FE Posthog Analytics (vibe-kanban) (#1048)
* Perfect! Let me create a summary of what was implemented:
## Summary
I've successfully added PostHog analytics to the frontend! Here's what was implemented:
### Changes Made:
1. **Installed posthog-js package** (`frontend/package.json`)
- Added `posthog-js` v1.276.0 as a dependency
2. **Created analytics utility module** (`frontend/src/lib/analytics.ts`)
- `initializeAnalytics(userAnalyticsEnabled)` - Initializes PostHog based on user preference
- `trackEvent(eventName, properties)` - Tracks custom events
- `identifyUser(userId, properties)` - Identifies users for PostHog
- `trackPageView(pageName)` - Tracks page views
- `resetAnalytics()` - Resets analytics session
- `isAnalyticsEnabled()` - Checks if analytics is active
3. **Updated Vite config** (`frontend/vite.config.ts`)
- Exposed `POSTHOG_API_KEY` and `POSTHOG_API_ENDPOINT` environment variables to the frontend via Vite's `define` option
- These are build-time environment variables that get baked into the frontend bundle
4. **Integrated analytics in App.tsx** (`frontend/src/App.tsx`)
- Added initialization logic that reads the user's `analytics_enabled` preference from the config
- Added first analytics event: `app_loaded` which fires when the app loads and includes:
- App version
- User's theme preference
- User's language preference
### How It Works:
1. **User Control**: Analytics only runs if `config.analytics_enabled` is `true` (user has opted in)
2. **Build-time Config**: PostHog API key and endpoint come from environment variables set at build time
3. **Write-only Key**: PostHog API key is safe to expose in frontend code (it can only send events, not read data)
4. **Privacy First**: No automatic tracking - only explicit events are captured
5. **Follows Backend Pattern**: Uses the same PostHog configuration as the backend
### Testing:
- ✅ TypeScript compilation passes
- ✅ All files properly formatted
- ✅ Ready for testing with actual PostHog credentials
The implementation aligns with the existing backend analytics pattern and respects user privacy by only tracking when explicitly enabled.
* Perfect! Done. Here's a summary of what we've accomplished:
## Summary
### PostHog Frontend Analytics Implementation Complete ✅
**What was implemented:**
1. **Installed `posthog-js`** package for frontend analytics
2. **Created analytics utility** (`frontend/src/lib/analytics.ts`) with:
- `initializeAnalytics()` - Initializes PostHog based on user's `analytics_enabled` preference
- `trackEvent()` - Tracks custom events with automatic `source: 'frontend'` property
- `identifyUser()`, `trackPageView()`, `resetAnalytics()`, `isAnalyticsEnabled()` helper functions
3. **Configured Vite** to expose PostHog credentials via build-time environment variables:
- `VITE_POSTHOG_API_KEY`
- `VITE_POSTHOG_API_ENDPOINT`
4. **Integrated in App.tsx**:
- Analytics initializes when config loads
- First event: `app_loaded` with version, theme, and language properties
5. **Enabled autocapture**:
- Automatically tracks all clicks and interactions
- Events named `$autocapture` with human-readable properties like `$el_text: "Create Task"`
- No manual instrumentation needed for basic UI interactions
**How it works:**
- Only runs if user has `config.analytics_enabled = true` (explicit opt-in)
- Uses same PostHog instance as backend for unified analytics
- All events tagged with `source: 'frontend'` for easy filtering
- Autocapture provides rich behavioral data out of the box
**In PostHog you'll see:**
- Custom events: `app_loaded`, plus any future custom events
- Autocapture events: `$autocapture` with readable text like "Create Task clicked"
- All filterable by `source = 'frontend'`
* Perfect! All done. Let me create a summary:
---
## ✅ Complete: Fixed Analytics Toggling + Version
### Changes Made (3 files, 7 insertions, 4 deletions)
**1. `frontend/src/lib/analytics.ts`**
- Changed opt-in logic to opt-out: Now tracks when `true` or `undefined`, only skips when explicitly `false`
- Updated comment to clarify opt-out behavior
**2. `frontend/src/App.tsx`**
- Changed analytics enabled check: `config.analytics_enabled !== false` (opt-out default)
- Fixed hardcoded version: Now uses `import.meta.env.VITE_APP_VERSION` from package.json
- Removed TODO comment
**3. `frontend/vite.config.ts`**
- Added `VITE_APP_VERSION` to `define` block
- Reads from `package.json` at build time
- Same pattern as PostHog credentials
### How It Works Now
**Analytics Behavior:**
| `analytics_enabled` value | Result |
|---------------------------|--------|
| `undefined` (not set) | ✅ Tracks (opt-out default) |
| `true` (explicit opt-in) | ✅ Tracks |
| `false` (explicit opt-out) | ❌ Doesn't track |
**Dynamic Toggling:**
1. **User toggles OFF**: `analytics_enabled = false` → `useEffect` re-runs → `initializeAnalytics(false)` returns early → no tracking
2. **User toggles ON**: `analytics_enabled = true` → `useEffect` re-runs → PostHog already initialized → tracking resumes
3. **App reload**: Config read from disk → PostHog initialized with correct state
**Version Tracking:**
- Version automatically read from `frontend/package.json` at build time
- Stays in sync when CI/CD bumps version
- Matches backend pattern (uses `CARGO_PKG_VERSION`)
### Testing
- ✅ TypeScript compilation passes
- ✅ Rust cargo check passes
- ✅ All changes minimal and focused
Ready to commit! 🚀
* Perfect! ✅ All done! Let me create a summary:
---
## ✅ Complete: PostHog Frontend Analytics with `.env` Support
### Changes Made
**3 files changed:** 4 insertions(+), 4 deletions(-) (plus the console.log you added for debugging)
### 1. **`package.json`** - Dev Script Maps Environment Variables
**Added variable mapping to the `dev` script:**
```bash
export VITE_POSTHOG_API_KEY=$POSTHOG_API_KEY && export VITE_POSTHOG_API_ENDPOINT=$POSTHOG_API_ENDPOINT
```
**How it works:**
- When you run `npm run dev`, the script reads `POSTHOG_API_KEY` from your `.env`
- Exports them as `VITE_POSTHOG_API_KEY` and `VITE_POSTHOG_API_ENDPOINT`
- Vite automatically picks up `VITE_*` prefixed vars
### 2. **`frontend/vite.config.ts`** - Simplified Config
**Removed** the manual PostHog variable mapping from `define` block:
```diff
- 'import.meta.env.VITE_POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
- 'import.meta.env.VITE_POSTHOG_API_ENDPOINT': JSON.stringify(process.env.POSTHOG_API_ENDPOINT || ''),
```
**Kept** only the app version (can't come from env):
```typescript
'import.meta.env.VITE_APP_VERSION': JSON.stringify(require('./package.json').version),
```
**Why:** Vite auto-loads `VITE_*` vars, so we don't need manual mapping anymore!
### 3. **`.github/workflows/pre-release.yml`** - CI Build Support
**Added PostHog env vars to frontend build step:**
```yaml
- name: Build frontend
run: cd frontend && npm run build
env:
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
VITE_POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }} # NEW
VITE_POSTHOG_API_ENDPOINT: ${{ secrets.POSTHOG_API_ENDPOINT }} # NEW
```
**Why:** Production builds need the PostHog credentials too!
---
## How It Works Now
### Development (Local)
**Your `.env` file (single source of truth):**
```bash
POSTHOG_API_KEY=phc_your_key_here
POSTHOG_API_ENDPOINT=https://us.i.posthog.com
```
**When you run `npm run dev`:**
1. Shell loads `.env` → has `POSTHOG_API_KEY` and `POSTHOG_API_ENDPOINT`
2. npm script exports `VITE_POSTHOG_API_KEY=$POSTHOG_API_KEY` (maps to VITE_ prefix)
3. Vite sees `VITE_*` vars and exposes them as `import.meta.env.VITE_*`
4. Frontend reads them in `analytics.ts`
5. PostHog initializes ✅
### Production (CI/CD)
**When GitHub Actions builds:**
1. Workflow reads `secrets.POSTHOG_API_KEY` and `secrets.POSTHOG_API_ENDPOINT`
2. Sets them as `VITE_POSTHOG_API_KEY` and `VITE_POSTHOG_API_ENDPOINT` env vars
3. Vite bakes them into the production build
4. Deployed app has PostHog credentials ✅
---
## What You Should See Now
**When you run `npm run dev`:**
```
✅ Analytics enabled: true
✅ [Analytics] PostHog initialized successfully
```
**Instead of:**
```
❌ Analytics enabled: true
❌ [Analytics] Missing PostHog configuration in build
```
---
## Summary
- ✅ **Single source of truth**: Only define PostHog vars once in `.env`
- ✅ **Works in dev**: npm script maps vars with `VITE_` prefix
- ✅ **Works in prod**: CI workflow passes secrets to frontend build
- ✅ **Clean config**: Removed manual `process.env` mapping from vite.config
- ✅ **Standard Vite pattern**: Uses Vite's automatic `VITE_*` loading
- ✅ **No duplication**: No need for separate `VITE_POSTHOG_*` vars in `.env`
Ready to test! Try running `npm run dev` with your `.env` file and check if you see "[Analytics] PostHog initialized successfully" 🚀
* Perfect! Now let me create a final summary:
---
## ✅ Fixed: Frontend Analytics Now Loads from `crates/server/.env`
### The Problem
- `.env` file exists at `crates/server/.env` (not root)
- npm script tried to use `$POSTHOG_API_KEY` but it wasn't in the environment
- Result: Empty strings passed to frontend → "[Analytics] Missing PostHog configuration in build"
### The Solution
**Installed `dotenv-cli`** to load `.env` file before running dev script.
### Changes Made
**1. `frontend/package.json` - Added dependency:**
```json
"dotenv-cli": "^10.0.0"
```
**2. `package.json` - Updated dev script:**
```bash
# Before:
"dev": "export FRONTEND_PORT=... && export VITE_POSTHOG_API_KEY=$POSTHOG_API_KEY && ..."
# After:
"dev": "dotenv -e crates/server/.env -- bash -c 'export FRONTEND_PORT=... && export VITE_POSTHOG_API_KEY=$POSTHOG_API_KEY && ...'"
```
**What this does:**
1. `dotenv -e crates/server/.env` - Load env vars from `crates/server/.env`
2. `--` - Pass remaining args to the command
3. `bash -c '...'` - Run the original script with env vars now available
4. Inside bash: `export VITE_POSTHOG_API_KEY=$POSTHOG_API_KEY` maps to VITE_ prefix
5. Vite auto-picks up `VITE_*` vars and exposes them to frontend
### How It Works Now
**Your `.env` location:** `crates/server/.env`
```bash
POSTHOG_API_KEY=phc_tUHOX3YsGW4d9cEKyIvxjrFDHTRQ8nCfzG65McGZEuC
POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
**When you run `npm run dev`:**
1. ✅ `dotenv-cli` loads `crates/server/.env`
2. ✅ Script exports `VITE_POSTHOG_API_KEY` from loaded `POSTHOG_API_KEY`
3. ✅ Vite sees `VITE_*` vars and makes them available as `import.meta.env.VITE_*`
4. ✅ Frontend `analytics.ts` reads them
5. ✅ PostHog initializes successfully!
### Complete Solution Summary
**Files Changed:**
1. ✅ `frontend/src/lib/analytics.ts` - Opt-out logic (track by default)
2. ✅ `frontend/src/App.tsx` - Fixed version + opt-out check
3. ✅ `frontend/vite.config.ts` - Removed manual PostHog mapping (Vite auto-loads now)
4. ✅ `.github/workflows/pre-release.yml` - Added PostHog env vars to CI build
5. ✅ `frontend/package.json` - Added `dotenv-cli` dependency
6. ✅ `package.json` - Wrapped dev script with `dotenv` to load `crates/server/.env`
### Test It!
Now when you run `npm run dev`, you should see:
```
✅ Analytics enabled: true
✅ [Analytics] PostHog initialized successfully
```
The `.env` file at `crates/server/.env` is now properly loaded and PostHog credentials are available to the frontend! 🚀
* Perfect! ✅ All done with the clean solution! Let me create a final summary:
---
## ✅ Complete: Clean Solution for Loading `.env` from `crates/server/.env`
### The Problem (Before)
- Hacky npm script with nested quotes and `bash -c`
- Used `dotenv-cli` package just to load the `.env` file
- Complex, fragile, and hard to maintain
### The Solution (Now) ✨ CLEAN!
**Load `.env` directly in `vite.config.ts` using Node's standard `dotenv` package.**
### Changes Made
**1. `frontend/package.json` - Swapped packages:**
```diff
- "dotenv-cli": "^10.0.0",
+ "dotenv": "^17.2.3",
```
**2. `frontend/vite.config.ts` - Added `.env` loading at the top:**
```typescript
import * as dotenv from "dotenv";
// Load backend's .env file at config evaluation time
dotenv.config({ path: path.resolve(__dirname, "../crates/server/.env") });
export default defineConfig({
// ...
define: {
'import.meta.env.VITE_APP_VERSION': JSON.stringify(require('./package.json').version),
// Now these read from the loaded .env file
'import.meta.env.VITE_POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
'import.meta.env.VITE_POSTHOG_API_ENDPOINT': JSON.stringify(process.env.POSTHOG_API_ENDPOINT || ''),
},
// ...
});
```
**3. `package.json` - Clean, simple dev script (reverted):**
```json
"dev": "export FRONTEND_PORT=$(node scripts/setup-dev-environment.js frontend) && export BACKEND_PORT=$(node scripts/setup-dev-environment.js backend) && concurrently \"npm run backend:dev:watch\" \"npm run frontend:dev\""
```
**No more:** `dotenv -e crates/server/.env -- bash -c '...'` ❌
---
### How It Works
**Local Development:**
1. Run `npm run dev` (clean script!)
2. Vite starts → loads `vite.config.ts`
3. Config immediately runs: `dotenv.config({ path: "../crates/server/.env" })`
4. `process.env.POSTHOG_API_KEY` is now available
5. `define` block copies it to `import.meta.env.VITE_POSTHOG_API_KEY`
6. Frontend reads it from `import.meta.env` ✅
**Production (CI):**
1. GitHub Actions sets `VITE_POSTHOG_API_KEY` and `VITE_POSTHOG_API_ENDPOINT`
2. These override anything from `.env` file
3. Vite bakes them into the build ✅
**Single Source of Truth:** `crates/server/.env`
```bash
POSTHOG_API_KEY=phc_tUHOX3YsGW4d9cEKyIvxjrFDHTRQ8nCfzG65McGZEuC
POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
---
### Benefits of This Approach
✅ **Clean npm scripts** - No nested quotes or `bash -c` hacks
✅ **Self-contained** - Config file handles its own `.env` loading
✅ **Standard pattern** - Uses Node's `dotenv` package (industry standard)
✅ **Works everywhere** - Dev server, production builds, CI/CD
✅ **Maintainable** - Easy to understand, easy to modify
✅ **Single source** - Backend and frontend share `crates/server/.env`
---
### Files Changed (3 files, 9 insertions, 2 deletions)
1. ✅ `frontend/package.json` - Swapped `dotenv-cli` for `dotenv`
2. ✅ `frontend/vite.config.ts` - Added `.env` loading + PostHog vars to `define`
3. ✅ `package.json` - Reverted to clean dev script
---
### Test It!
Run `npm run dev` and you should see:
```
✅ Analytics enabled: true
✅ [Analytics] PostHog initialized successfully
```
The `.env` file at `crates/server/.env` is now cleanly loaded by Vite's config! 🚀
* Perfect! Now let me show you the complete summary of what we've accomplished:
---
## ✅ Complete: Clean PostHog Frontend Analytics with Backend Correlation
### The Journey
We went through several iterations to find the cleanest solution:
1. ~~Build-time env vars via Vite~~ → Too complex
2. ~~dotenv-cli in npm scripts~~ → Hacky
3. ~~dotenv in vite.config~~ → Still messy
4. **✅ API-based config** → Clean and elegant!
### Final Architecture
**Backend exposes everything via `/api/info`:**
```rust
{
"config": { ... },
"analytics": {
"user_id": "npm_user_abc123def456789",
"posthog_api_key": "phc_...",
"posthog_api_endpoint": "https://eu.i.posthog.com"
},
"environment": { ... },
"profiles": { ... }
}
```
**Frontend receives it on startup and initializes PostHog with:**
- ✅ Backend's credentials (from build-time `option_env!()`)
- ✅ Backend's user_id (for correlation)
- ✅ User's `analytics_enabled` preference (reactive to settings changes)
### Files Changed (8 files, 55 insertions, 28 deletions)
**Backend:**
1. ✅ `crates/server/src/routes/config.rs`:
- Added `AnalyticsInfo` struct with `user_id`, `posthog_api_key`, `posthog_api_endpoint`
- Added `analytics` field to `UserSystemInfo`
- Updated handler to populate analytics from deployment
**Frontend:**
2. ✅ `frontend/src/lib/analytics.ts`:
- Changed signature: accepts `AnalyticsInfo` from API instead of env vars
- Automatically calls `posthog.identify(user_id)` for correlation
- Added debug logging
3. ✅ `frontend/src/components/config-provider.tsx`:
- Added `analytics: AnalyticsInfo | null` to state and context
- Exposed via `useUserSystem()` hook
4. ✅ `frontend/src/App.tsx`:
- Gets `analytics` from `useUserSystem()`
- Passes both `analytics` and `config.analytics_enabled` to `initializeAnalytics()`
- Depends on both in useEffect
**Types:**
5. ✅ `shared/types.ts`:
- Added `AnalyticsInfo` type definition
**Cleanup:**
6. ✅ `frontend/vite.config.ts`:
- Removed `dotenv` import and loading
- Removed PostHog env vars from `define` block
- Kept only `VITE_APP_VERSION`
7. ✅ `frontend/package.json`:
- Removed `dotenv` dependency
8. ✅ `.github/workflows/pre-release.yml`:
- Removed `VITE_POSTHOG_*` env vars from frontend build (no longer needed)
- Backend build still has `POSTHOG_*` vars (needed for baking into Rust binary)
### How It Works Now
**Development (`npm run dev`):**
1. Backend loads `crates/server/.env` via Rust's `dotenv` crate
2. Backend bakes credentials into binary at compile time
3. Frontend calls `/api/info` on startup
4. Receives `analytics: { user_id, api_key, endpoint }`
5. Initializes PostHog with backend's user_id
6. ✅ **Frontend and backend events use same user ID!**
**Production (CI build):**
1. GitHub Actions sets `POSTHOG_API_KEY` and `POSTHOG_API_ENDPOINT` for backend build
2. Rust bakes them into binary via `option_env!()`
3. Frontend build needs NO env vars (gets everything from API at runtime)
4. Same correlation as dev ✅
### Benefits of Final Solution
✅ **No env var complexity** - Frontend doesn't deal with env vars at all
✅ **Runtime config** - PostHog config can theoretically change without rebuild
✅ **Full correlation** - Backend and frontend share same `distinct_id`
✅ **Single API call** - Piggybacks on existing `/api/info` fetch
✅ **Clean code** - No dotenv, no hacky scripts, no build-time juggling
✅ **Respects user preference** - Uses `config.analytics_enabled` reactively
### What You'll See in PostHog
**Single User Journey:**
```
User: npm_user_abc123def456789
Events:
- app_loaded (frontend)
- $autocapture: "Create Task" clicked (frontend)
- task_created (backend)
- $autocapture: "Run Task" clicked (frontend)
- task_attempt_started (backend)
- task_attempt_finished (backend)
```
**All correlated under one user!** 🎉
Now you can see the complete user journey from frontend clicks to backend actions in PostHog!
* Perfect! Now let me show you the complete summary:
---
## ✅ Complete: Fixed Review Issues - Proper Type Generation and Code Reuse
### Issues Fixed
**Issue 1: Manual TypeScript Type Editing ❌**
- **Problem:** I manually added `AnalyticsInfo` to `shared/types.ts`
- **Solution:** Added `AnalyticsInfo::decl()` to `generate_types.rs` so it's auto-generated
**Issue 2: Duplicated `option_env!()` Logic ❌**
- **Problem:** Used `option_env!("POSTHOG_API_KEY")` directly in `config.rs`
- **Solution:** Reused existing `AnalyticsConfig::new()` from `services/analytics.rs`
### Changes Made (3 files, 12 insertions, 5 deletions)
**1. `crates/server/src/bin/generate_types.rs`**
```diff
+ server::routes::config::AnalyticsInfo::decl(),
```
Now properly generates `AnalyticsInfo` TypeScript type.
**2. `crates/server/src/routes/config.rs`**
```diff
+ use services::services::{
+ analytics::AnalyticsConfig,
+ config::{Config, ConfigError, SoundFile, save_config_to_file},
+ };
+ // Reuse AnalyticsConfig::new() to get PostHog credentials
+ let analytics_config = AnalyticsConfig::new();
+
analytics: AnalyticsInfo {
user_id: deployment.user_id().to_string(),
- posthog_api_key: option_env!("POSTHOG_API_KEY").map(|s| s.to_string()),
- posthog_api_endpoint: option_env!("POSTHOG_API_ENDPOINT").map(|s| s.to_string()),
+ posthog_api_key: analytics_config.as_ref().map(|c| c.posthog_api_key.clone()),
+ posthog_api_endpoint: analytics_config.as_ref().map(|c| c.posthog_api_endpoint.clone()),
},
```
**3. `shared/types.ts`**
- Now properly generated (moved `AnalyticsInfo` definition after `UserSystemInfo` where it's referenced)
- No manual edits!
### How It Works Now
**Backend (`config.rs:90-98`):**
```rust
// Reuse existing analytics configuration logic
let analytics_config = AnalyticsConfig::new(); // Calls option_env!() + std::env::var()
// Extract into response format
analytics: AnalyticsInfo {
user_id: deployment.user_id().to_string(),
posthog_api_key: analytics_config.as_ref().map(|c| c.posthog_api_key.clone()),
posthog_api_endpoint: analytics_config.as_ref().map(|c| c.posthog_api_endpoint.clone()),
}
```
**Benefits:**
- ✅ **DRY principle**: Single source of truth for loading PostHog credentials (`AnalyticsConfig::new()`)
- ✅ **Proper type generation**: `AnalyticsInfo` auto-generated from Rust
- ✅ **Consistent behavior**: Backend and frontend API use same logic to get credentials
- ✅ **Same fallback logic**: Uses `option_env!()` first, then `std::env::var()` as fallback
### Complete File List (All Changes from Start)
**Backend:**
1. ✅ `crates/server/src/routes/config.rs` - Added `AnalyticsInfo`, reuses `AnalyticsConfig`
2. ✅ `crates/server/src/bin/generate_types.rs` - Added type generation
**Frontend:**
3. ✅ `frontend/src/lib/analytics.ts` - Accepts `AnalyticsInfo` from API, identifies user
4. ✅ `frontend/src/components/config-provider.tsx` - Exposes `analytics` from API
5. ✅ `frontend/src/App.tsx` - Uses `analytics` + `config.analytics_enabled`
6. ✅ `frontend/vite.config.ts` - Removed dotenv, clean config
7. ✅ `frontend/package.json` - Removed dotenv dependency
**Types:**
8. ✅ `shared/types.ts` - Auto-generated `AnalyticsInfo` type
**Cleanup:**
9. ✅ `package.json` - Clean dev script (no env var hacks)
10. ✅ `.github/workflows/pre-release.yml` - Removed VITE_POSTHOG vars
### Result
**Clean architecture:**
- ✅ Backend is single source of truth for PostHog config
- ✅ Frontend gets everything from `/api/info`
- ✅ Backend and frontend share same `user_id` → **full correlation in PostHog!**
- ✅ No env var complexity
- ✅ No code duplication
- ✅ Proper type generation
- ✅ All checks pass
Ready to test! 🚀
* Cleanup script changes for task attempt 4599cd33-f133-4946-b38e-907b16132ebe
* Perfect! Now let me create the final summary addressing your review comments:
---
## ✅ Review Comments Fixed!
### Review Comment 1: "How dare you edit shared/types.ts? Use generate_types.rs!"
**✅ FIXED!**
**Before:** I manually edited `shared/types.ts` ❌
**After:**
1. Added `AnalyticsInfo::decl()` to `crates/server/src/bin/generate_types.rs:41`
2. Added `AnalyticsConfig::decl()` to `generate_types.rs:42`
3. Ran `cargo run --bin generate_types` to properly generate the types
Now `shared/types.ts` is auto-generated and contains:
```typescript
export type AnalyticsInfo = { user_id: string, posthog_api_key: string | null, posthog_api_endpoint: string | null, };
export type AnalyticsConfig = { posthog_api_key: string, posthog_api_endpoint: string, };
```
### Review Comment 2: "Reuse analytics.rs instead of duplicating option_env!()"
**✅ FIXED!**
**Before:** Duplicated the env var loading logic ❌
```rust
posthog_api_key: option_env!("POSTHOG_API_KEY").map(|s| s.to_string()),
posthog_api_endpoint: option_env!("POSTHOG_API_ENDPOINT").map(|s| s.to_string()),
```
**After:** Reuses `AnalyticsConfig::new()` ✅
**Added to `analytics.rs:16-17`:**
```rust
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ts_rs::TS)]
#[ts(export)]
pub struct AnalyticsConfig {
pub posthog_api_key: String,
pub posthog_api_endpoint: String,
}
```
**Added helper constructor in `config.rs:46-54`:**
```rust
impl AnalyticsInfo {
pub fn new(user_id: String, analytics_config: Option<AnalyticsConfig>) -> Self {
Self {
user_id,
posthog_api_key: analytics_config.as_ref().map(|c| c.posthog_api_key.clone()),
posthog_api_endpoint: analytics_config.as_ref().map(|c| c.posthog_api_endpoint.clone()),
}
}
}
```
**Usage in handler (line 102):**
```rust
analytics: AnalyticsInfo::new(deployment.user_id().to_string(), AnalyticsConfig::new()),
```
Now the code **reuses** the existing `AnalyticsConfig::new()` logic instead of duplicating it!
### Why Fields Are Optional
**Question:** "Why is posthog_api_key optional? It's not optional in the backend!"
**Answer:**
- `AnalyticsConfig::new()` returns `Option<AnalyticsConfig>`
- It returns `None` if env vars aren't set (no PostHog configured)
- The API response needs to handle both cases:
- **With PostHog:** `analytics: { user_id: "npm_user_...", posthog_api_key: "phc_...", posthog_api_endpoint: "..." }`
- **Without PostHog:** `analytics: { user_id: "npm_user_...", posthog_api_key: null, posthog_api_endpoint: null }`
**Frontend handles this gracefully:**
```typescript
if (!analyticsInfo.posthog_api_key || !analyticsInfo.posthog_api_endpoint) {
console.log('[Analytics] Missing PostHog credentials from backend');
// Analytics disabled, but app continues to work
}
```
### Final Changes (4 files)
1. ✅ `crates/services/src/services/analytics.rs` - Added Serialize, Deserialize, TS to `AnalyticsConfig`
2. ✅ `crates/server/src/routes/config.rs` - Added `AnalyticsInfo::new()` helper that reuses `AnalyticsConfig::new()`
3. ✅ `crates/server/src/bin/generate_types.rs` - Added both `AnalyticsInfo` and `AnalyticsConfig` to generation
4. ✅ `shared/types.ts` - Now properly auto-generated with both types
**All checks pass!** ✅
* Cleanup script changes for task attempt 4599cd33-f133-4946-b38e-907b16132ebe
* Perfect! Now let me show you the final summary:
---
## ✅ Review Comments Addressed - Clean Solution!
### Changes Made
**Backend Structure:**
```rust
pub struct AnalyticsInfo {
pub user_id: String,
pub config: Option<AnalyticsConfig>, // Embeds existing AnalyticsConfig struct!
}
// Usage:
analytics: AnalyticsInfo {
user_id: deployment.user_id().to_string(),
config: AnalyticsConfig::new(), // Reuses existing logic!
}
```
**Generated TypeScript:**
```typescript
export type AnalyticsInfo = {
user_id: string,
config: AnalyticsConfig | null, // Nested, not flattened!
};
export type AnalyticsConfig = {
posthog_api_key: string,
posthog_api_endpoint: string, // Not optional in the struct itself!
};
```
**Frontend Usage:**
```typescript
if (!analyticsInfo || !analyticsInfo.config) {
// No PostHog credentials available
return;
}
posthog.init(analyticsInfo.config.posthog_api_key, {
api_host: analyticsInfo.config.posthog_api_endpoint,
// ...
});
```
### What's Different Now
**✅ Review Comment 1 Fixed:**
- Added `AnalyticsInfo::decl()` to `generate_types.rs`
- Added `AnalyticsConfig::decl()` to `generate_types.rs`
- `shared/types.ts` is now auto-generated (no manual edits!)
**✅ Review Comment 2 Fixed:**
- **Reuses** `AnalyticsConfig::new()` from `services/analytics.rs`
- No duplicated `option_env!()` logic
- `AnalyticsConfig` struct is embedded in `AnalyticsInfo.config`
**✅ No Flattening:**
- Fields are **not** optional in `AnalyticsConfig` itself
- `AnalyticsConfig` is **non-optional** (has `posthog_api_key: String`)
- Only `AnalyticsInfo.config` is `Option<AnalyticsConfig>` (might not exist)
- Clean nested structure: `analyticsInfo.config.posthog_api_key`
### Why `config` is `Option<AnalyticsConfig>`
**The `config` field CAN be null because:**
```rust
// AnalyticsConfig::new() returns Option<Self>
pub fn new() -> Option<Self> {
// Returns None if POSTHOG_API_KEY or POSTHOG_API_ENDPOINT env vars aren't set
}
```
**API Response Examples:**
**With PostHog configured:**
```json
{
"analytics": {
"user_id": "npm_user_abc123",
"config": {
"posthog_api_key": "phc_...",
"posthog_api_endpoint": "https://eu.i.posthog.com"
}
}
}
```
**Without PostHog configured:**
```json
{
"analytics": {
"user_id": "npm_user_abc123",
"config": null
}
}
```
### Final File Changes (5 files)
1. ✅ `crates/services/src/services/analytics.rs` - Added Serialize, Deserialize, TS to `AnalyticsConfig`
2. ✅ `crates/server/src/routes/config.rs` - `AnalyticsInfo` embeds `Option<AnalyticsConfig>`
3. ✅ `crates/server/src/bin/generate_types.rs` - Generates both types
4. ✅ `frontend/src/lib/analytics.ts` - Uses `analyticsInfo.config.posthog_api_key`
5. ✅ `shared/types.ts` - Properly auto-generated with nested structure
**All checks pass!** ✅
The structure is now clean, reuses existing code, and properly represents that PostHog config might not be available!
* Perfect! Let me create the final comprehensive summary:
---
## ✅ Complete: Opt-In Autocapture with Stable Analytics IDs
### The Solution You Wanted
**Problem:** PostHog autocapture relied on button text, which is fragile and strange.
**Solution:** **Opt-in autocapture** - only track elements that explicitly have `data-ph-capture-attribute`.
### How It Works Now
**PostHog Configuration (`frontend/src/lib/analytics.ts:49-52`):**
```typescript
autocapture: {
// Opt-in autocapture: only track elements with data-ph-capture-attribute
css_selector_allowlist: ['[data-ph-capture-attribute]'],
},
```
**Result:**
- ✅ **Only** buttons with `analyticsId` prop get tracked
- ✅ Stable, semantic IDs (not fragile button text)
- ✅ Explicit and intentional (you choose what to track)
- ✅ Survives i18n, UI changes, refactoring
### How to Add Manual Events (Super Easy!)
**1. For Autocapture (Button Clicks):**
```tsx
import { Button } from '@/components/ui/button';
import { ANALYTICS_IDS } from '@/lib/analytics-ids';
<Button
onClick={handleCreateTask}
analyticsId={ANALYTICS_IDS.TASK_CREATE_BUTTON}
>
Create Task
</Button>
```
**PostHog will automatically capture:**
```javascript
{
event: "$autocapture",
properties: {
"data-ph-capture-attribute": "task-form-create-button", // Stable ID!
"$el_text": "Create Task", // Still captured for context
"source": "frontend",
// ... other metadata
}
}
```
**2. For Custom Events (Business Logic):**
```tsx
import { trackEvent } from '@/lib/analytics';
const handleTaskCreated = async (taskId: string) => {
const result = await createTask({ title, description });
// Track the business logic event
trackEvent('task_created_with_quickstart', {
task_id: result.id,
has_description: !!description,
executor: selectedExecutor,
branch: selectedBranch,
});
};
```
### Files Changed
**1. `frontend/src/lib/analytics.ts`** - Configured opt-in autocapture
```typescript
autocapture: {
css_selector_allowlist: ['[data-ph-capture-attribute]'],
},
```
**2. `frontend/src/components/ui/button.tsx`** - Added `analyticsId` prop
```tsx
export interface ButtonProps {
asChild?: boolean;
analyticsId?: string; // NEW!
}
<Comp
data-ph-capture-attribute={analyticsId} // Adds to DOM
{...props}
/>
```
**3. `frontend/src/lib/analytics-ids.ts`** - Created ID constants (NEW FILE)
```typescript
export const ANALYTICS_IDS = {
TASK_CREATE_BUTTON: 'task-form-create-button',
TASK_DELETE_ACTION: 'task-card-delete-action',
// ... all your analytics IDs
} as const;
```
**4. `frontend/src/components/dialogs/tasks/TaskFormDialog.tsx`** - Example usage
```tsx
import { ANALYTICS_IDS } from '@/lib/analytics-ids';
<Button analyticsId={ANALYTICS_IDS.TASK_CREATE_BUTTON}>
Create Task
</Button>
<Button analyticsId="task-form-create-and-start-button">
Create & Start
</Button>
<Button analyticsId="task-form-cancel-button">
Cancel
</Button>
<Button analyticsId="task-form-update-button">
Update Task
</Button>
```
### Adding More Analytics IDs
**Pattern:**
1. **Add constant** to `analytics-ids.ts`:
```typescript
PR_CREATE_BUTTON: 'pr-create-submit-button',
```
2. **Import and use** in component:
```tsx
import { ANALYTICS_IDS } from '@/lib/analytics-ids';
<Button analyticsId={ANALYTICS_IDS.PR_CREATE_BUTTON}>
Create PR
</Button>
```
3. **Or use inline** for less common actions:
```tsx
<Button analyticsId="settings-theme-dark-button">
Dark Mode
</Button>
```
### Benefits
✅ **Stable IDs** - Survive text changes, i18n, refactoring
✅ **Explicit opt-in** - Choose what to track
✅ **Semantic names** - "task-form-create-button" is clear
✅ **Type-safe** - TypeScript autocomplete for constants
✅ **Centralized** - All IDs in one file
✅ **Easy to add** - Just add `analyticsId` prop
✅ **Flexible** - Use constants OR inline strings
### What Gets Tracked
**Autocapture (Opt-in):**
- Only `<Button analyticsId="...">` elements
- Shows as `$autocapture` event with `data-ph-capture-attribute...
* Cleanup script changes for task attempt 4599cd33-f133-4946-b38e-907b16132ebe
* Perfect! Let me create a comprehensive final summary:
---
## ✅ Complete: Type-Safe Analytics ID Enum (No String Hacks!)
### What You Asked For
**"Can we please make the id have an enum variant type? and not add this registry and then still hardcode some strings?"**
**✅ DONE!** Now using a **proper TypeScript enum** with full type safety.
### The Solution
**`frontend/src/lib/analytics-ids.ts`:**
```typescript
export enum AnalyticsId {
// Task Management
TASK_CREATE_BUTTON = 'task-form-create-button',
TASK_UPDATE_BUTTON = 'task-form-update-button',
TASK_CANCEL_BUTTON = 'task-form-cancel-button',
TASK_CREATE_AND_START_BUTTON = 'task-form-create-and-start-button',
// Attempt Management
ATTEMPT_CREATE_BUTTON = 'attempt-create-submit-button',
// ... more IDs
}
```
**`frontend/src/components/ui/button.tsx`:**
```typescript
import { AnalyticsId } from '@/lib/analytics-ids';
export interface ButtonProps {
asChild?: boolean;
analyticsId?: AnalyticsId; // NOT string! Only enum values allowed!
}
```
### Type Safety in Action
**✅ TypeScript ALLOWS this:**
```tsx
<Button analyticsId={AnalyticsId.TASK_CREATE_BUTTON}>Create</Button>
```
**❌ TypeScript REJECTS this at compile time:**
```tsx
<Button analyticsId="random-string">Create</Button>
// ^^^^^^^^^^^ ❌ Compile error:
// Type '"random-string"' is not assignable to type 'AnalyticsId | undefined'
```
**✅ IDE autocomplete shows all valid IDs:**
```tsx
<Button analyticsId={AnalyticsId.
// ^ IDE suggests:
// - TASK_CREATE_BUTTON
// - TASK_UPDATE_BUTTON
// - TASK_CANCEL_BUTTON
// - ...
}>
```
### What Changed (7 files)
**1. `frontend/src/lib/analytics-ids.ts`** - Created TypeScript enum
```typescript
export enum AnalyticsId {
TASK_CREATE_BUTTON = 'task-form-create-button',
// ... all IDs
}
```
**2. `frontend/src/components/ui/button.tsx`** - Enforces enum type
```typescript
import { AnalyticsId } from '@/lib/analytics-ids';
export interface ButtonProps {
analyticsId?: AnalyticsId; // Type-safe!
}
```
**3. `frontend/src/components/dialogs/tasks/TaskFormDialog.tsx`** - Uses enum
```tsx
import { AnalyticsId } from '@/lib/analytics-ids';
<Button analyticsId={AnalyticsId.TASK_CREATE_BUTTON}>Create Task</Button>
<Button analyticsId={AnalyticsId.TASK_UPDATE_BUTTON}>Update Task</Button>
<Button analyticsId={AnalyticsId.TASK_CANCEL_BUTTON}>Cancel</Button>
<Button analyticsId={AnalyticsId.TASK_CREATE_AND_START_BUTTON}>Create & Start</Button>
```
**4. `frontend/src/lib/analytics.ts`** - Configured opt-in autocapture
```typescript
autocapture: {
css_selector_allowlist: ['[data-ph-capture-attribute]'],
},
```
### How to Add Manual Events
**For Autocapture (Button Clicks):**
```tsx
import { Button } from '@/components/ui/button';
import { AnalyticsId } from '@/lib/analytics-ids';
// Step 1: Add to enum in analytics-ids.ts
export enum AnalyticsId {
// ...
PR_CREATE_BUTTON = 'pr-create-submit-button', // ADD THIS
}
// Step 2: Use it (TypeScript enforces correctness!)
<Button analyticsId={AnalyticsId.PR_CREATE_BUTTON}>
Create PR
</Button>
// ❌ This WON'T compile:
<Button analyticsId="pr-create-typo"> // Error!
```
**For Custom Events (Business Logic):**
```tsx
import { trackEvent } from '@/lib/analytics';
const handlePRCreated = async () => {
const pr = await createPR({ title, body });
trackEvent('pr_created', {
pr_number: pr.number,
target_branch: pr.base.ref,
has_custom_body: !!body,
});
};
```
### Benefits
✅ **Type safety** - Compiler prevents typos and invalid IDs
✅ **No string hacks** - Can't use random hardcoded strings
✅ **IDE autocomplete** - All valid IDs suggested
✅ **Centralized** - All IDs in one enum
✅ **Refactor-safe** - Rename an enum value → compiler finds all usages
✅ **Opt-in tracking** - Only buttons with `analyticsId` are tracked
✅ **Stable IDs** - Survive text changes, i18n, UI refactoring ...
* Perfect! Let me show you the complete implementation:
---
**Single tracking point** that captures BOTH button clicks AND keyboard shortcuts!
**All paths to changing the view go through `setMode()` function:**
- 👆 Button click → `onModeChange()` → `setMode()`
- ⌨️ Keyboard shortcut (Cmd+Enter) → `cycleView()` → `setMode()`
- ⌨️ Keyboard shortcut (Cmd+Shift+Enter) → `cycleView()` → `setMode()`
**So tracking in `setMode()` captures everything!**
**1. `frontend/src/lib/analytics-ids.ts` - Added enum values:**
```typescript
export enum AnalyticsId {
// ... existing IDs
// View Navigation (Preview/Diffs)
NAV_PREVIEW_BUTTON = 'attempt-header-preview-button',
NAV_DIFFS_BUTTON = 'attempt-header-diffs-button',
}
```
**2. `frontend/src/pages/project-tasks.tsx` - Added tracking in setMode:**
```typescript
import { trackEvent } from '@/lib/analytics';
const setMode = useCallback(
(newMode: LayoutMode) => {
// Track view navigation (captures both button clicks and keyboard shortcuts)
if (newMode !== mode) {
trackEvent('view_navigated', {
from_view: mode ?? 'attempt',
to_view: newMode ?? 'attempt',
});
}
// ... rest of setMode logic
},
[mode, searchParams, setSearchParams]
);
```
**3. `frontend/src/components/panels/AttemptHeaderActions.tsx` - Added analytics IDs:**
```tsx
import { AnalyticsId } from '@/lib/analytics-ids';
<ToggleGroupItem
value="preview"
data-ph-capture-attribute={AnalyticsId.NAV_PREVIEW_BUTTON}
>
<Eye className="h-4 w-4" />
</ToggleGroupItem>
<ToggleGroupItem
value="diffs"
data-ph-capture-attribute={AnalyticsId.NAV_DIFFS_BUTTON}
>
<FileDiff className="h-4 w-4" />
</ToggleGroupItem>
```
**When user clicks the Preview button:**
```javascript
// 1. Autocapture event (from button click)
{
event: "$autocapture",
properties: {
"data-ph-capture-attribute": "attempt-header-preview-button",
"source": "frontend",
}
}
// 2. Custom event (from setMode)
{
event: "view_navigated",
properties: {
"from_view": "attempt",
"to_view": "preview",
"source": "frontend",
}
}
```
**When user presses Cmd+Enter (keyboard shortcut):**
```javascript
// Only custom event (no button click!)
{
event: "view_navigated",
properties: {
"from_view": "diffs",
"to_view": "preview",
"source": "frontend",
}
}
```
**When user presses Cmd+Shift+Enter (backward cycling):**
```javascript
{
event: "view_navigated",
properties: {
"from_view": "preview",
"to_view": "attempt",
"source": "frontend",
}
}
```
✅ **Single tracking point** - All view changes tracked in one place (`setMode`)
✅ **Captures method** - Can distinguish button clicks (autocapture) vs keyboard
✅ **Full data** - Knows source and destination for every transition
✅ **Type-safe** - Enum prevents typos in button IDs
✅ **No duplication** - Don't need to add tracking to multiple handlers
✅ **Future-proof** - ANY new way to change views will automatically be tracked
**See all view navigations:**
- Filter: `event = "view_navigated"`
- Group by: `to_view` (see which views are most popular)
- Funnel: attempt → preview → diffs
**See button clicks vs keyboard usage:**
- Button clicks: `$autocapture` where `data-ph-capture-attribute = "attempt-header-preview-button"`
- Keyboard shortcuts: `view_navigated` events that DON'T have a corresponding `$autocapture`
**See navigation patterns:**
```sql
-- How many users navigate to preview?
SELECT count(*) WHERE event = 'view_navigated' AND to_view = 'preview'
-- What's the most common navigation flow?
SELECT from_view, to_view, count(*) GROUP BY from_view, to_view
```
---
1. **Backend Integration:**
- ✅ Exposes `AnalyticsInfo` via `/ap...
* Perfect! Let me create the final summary:
---
## ✅ Complete: Cleaned Up - Only Preview/Diffs Navigation Events
### Changes Made (2 files, 1 insertion, 38 deletions)
**1. `frontend/src/lib/analytics-ids.ts` - Cleaned up to only 2 IDs:**
```typescript
export enum AnalyticsId {
// View Navigation (Preview/Diffs)
NAV_PREVIEW_BUTTON = 'attempt-header-preview-button',
NAV_DIFFS_BUTTON = 'attempt-header-diffs-button',
// Add more IDs as you instrument the UI...
}
```
**Removed:** All the example button IDs (task form, settings, projects, etc.)
**2. `frontend/src/components/dialogs/tasks/TaskFormDialog.tsx` - Reverted:**
```diff
- import { AnalyticsId } from '@/lib/analytics-ids';
- <Button analyticsId={AnalyticsId.TASK_CREATE_BUTTON}>
+ <Button>
// Removed all analyticsId props from task form buttons
```
### What's Currently Tracked
**1. View Navigation (Preview/Diffs) - Works via BOTH methods:**
**Button Click:**
```javascript
// Autocapture from button
{
event: "$autocapture",
properties: {
"data-ph-capture-attribute": "attempt-header-preview-button",
"source": "frontend",
}
}
// Custom event from setMode()
{
event: "view_navigated",
properties: {
"from_view": "attempt",
"to_view": "preview",
"source": "frontend",
}
}
```
**Keyboard Shortcut (Cmd+Enter):**
```javascript
// Only custom event (no autocapture since no button click)
{
event: "view_navigated",
properties: {
"from_view": "attempt",
"to_view": "preview",
"source": "frontend",
}
}
```
**2. App Loaded:**
```javascript
{
event: "app_loaded",
properties: {
"version": "0.0.108",
"theme": "DARK",
"language": "EN",
"source": "frontend",
}
}
```
**3. Page Leave (automatic):**
```javascript
{
event: "$pageleave",
properties: { ... }
}
```
### Current Analytics Architecture
**Type-Safe Autocapture:**
- ✅ Only 2 IDs in enum: `NAV_PREVIEW_BUTTON`, `NAV_DIFFS_BUTTON`
- ✅ TypeScript enforces enum usage (no random strings)
- ✅ Opt-in autocapture (only elements with `data-ph-capture-attribute`)
**Manual Events:**
- ✅ `app_loaded` - App initialization
- ✅ `view_navigated` - Tracks ALL view changes (button + keyboard)
- ✅ Easy to add more: `trackEvent('event_name', { data })`
**Full Correlation:**
- ✅ Frontend and backend share same `user_id` (from backend's `generate_user_id()`)
- ✅ Can see complete user journey in PostHog
### How to Add More Analytics
**For autocapture events:**
```typescript
// 1. Add to enum:
export enum AnalyticsId {
NAV_PREVIEW_BUTTON = 'attempt-header-preview-button',
NAV_DIFFS_BUTTON = 'attempt-header-diffs-button',
MY_NEW_ACTION = 'my-component-action', // ADD THIS
}
// 2. Use it:
<SomeElement data-ph-capture-attribute={AnalyticsId.MY_NEW_ACTION} />
```
**For custom events:**
```typescript
import { trackEvent } from '@/lib/analytics';
trackEvent('my_event', {
property1: 'value',
property2: 123,
});
```
**Clean, minimal, type-safe!** 🎉
* Perfect! ✅ All cleaned up. Let me create the final summary:
---
## ✅ Complete: Button Component Cleaned Up
### Review Comment Fixed
**You said:** "I thought i told you to remove this? do we still need it?"
**✅ FIXED!** Removed all analytics-related code from `button.tsx`.
### Changes Made
**`frontend/src/components/ui/button.tsx` - Fully reverted:**
```diff
- import { AnalyticsId } from '@/lib/analytics-ids';
export interface ButtonProps {
asChild?: boolean;
- analyticsId?: AnalyticsId;
}
const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
- ({ className, variant, size, asChild = false, analyticsId, ...props }, ref) => {
+ ({ className, variant, size, asChild = false, ...props }, ref) => {
const Comp = asChild ? Slot : 'button';
return (
<Comp
className={cn(buttonVariants({ variant, size, className }))}
ref={ref}
- data-ph-capture-attribute={analyticsId}
{...props}
/>
);
}
);
```
**Button component is back to original state** - no analytics code at all!
### Why This Makes Sense
**We're NOT tracking Button clicks** via autocapture. We're only tracking:
1. **ToggleGroupItem clicks** (Preview/Diffs navigation) - via `data-ph-capture-attribute` directly on the element
2. **View changes** (manual event) - via `trackEvent()` in `setMode()`
**Button component doesn't need analytics support!** ✅
### Final Analytics Implementation Summary
**What's Tracked:**
1. **Preview/Diffs Navigation:**
- Autocapture: ToggleGroupItem with `data-ph-capture-attribute={AnalyticsId.NAV_PREVIEW_BUTTON}`
- Custom event: `view_navigated` in `setMode()` (captures button AND keyboard)
2. **App Loaded:**
- Custom event: `app_loaded` with version, theme, language
3. **Page Leave:**
- Automatic: `$pageleave` event
**Type Safety:**
- ✅ Only 2 IDs in `AnalyticsId` enum
- ✅ TypeScript enforces enum usage
- ✅ No random strings allowed
**Correlation:**
- ✅ Frontend and backend share same `user_id`
- ✅ Can see full user journey in PostHog
**Clean codebase:**
- ✅ No unused analytics code in Button component
- ✅ Analytics only where it's actually used
- ✅ All checks pass
**Ready to ship!** 🚀
* Perfect! ✅ All review comments addressed. Let me create the final summary:
---
## ✅ Review Comments Fixed (3 changes)
### 1. �� Removed TypeScript explanation comment
**File:** `frontend/src/lib/analytics-ids.ts`
**Removed:**
```typescript
// * TypeScript enforces that ONLY values from this enum can be used - no random strings!
```
**Why:** Obvious to developers using TypeScript - no need to explain the language.
### 2. ✅ Removed debug log for user identification
**File:** `frontend/src/lib/analytics.ts:43`
**Removed:**
```typescript
console.log('[Analytics] User identified:', analyticsInfo.user_id);
```
**Why:** Debug log no longer needed - identification happens silently.
### 3. ✅ Changed log level to warn for missing config
**File:** `frontend/src/lib/analytics.ts:29`
**Changed:**
```typescript
// Before:
console.log('[Analytics] No PostHog configuration available from backend');
// After:
console.warn('[Analytics] No PostHog configuration available from backend');
```
**Why:** Missing configuration is a warning-worthy issue, not just informational.
### 4. ✅ Added comment explaining `capture_pageleave`
**File:** `frontend/src/lib/analytics.ts:47`
**Added comment:**
```typescript
capture_pageleave: true, // Track when user closes/leaves the page
```
**What it does:**
- Automatically sends a `$pageleave` event when user closes/navigates away
- Helps measure session duration and engagement time
- Fires on `window.beforeunload` / `window.unload`
- Useful for understanding when users leave the app
---
## Final State: Clean and Production Ready
**All changes (2 files, 2 insertions, 4 deletions):**
1. ✅ `frontend/src/lib/analytics-ids.ts` - Removed unnecessary TypeScript explanation
2. ✅ `frontend/src/lib/analytics.ts` - Removed debug log, changed to warn, added pageleave comment
**All checks pass!** ✅
**What's being tracked:**
- ✅ `app_loaded` - App initialization
- ✅ `view_navigated` - Preview/diffs navigation (button + keyboard)
- ✅ `$autocapture` - Preview/diffs button clicks (with stable IDs)
- ✅ `$pageleave` - When user closes/leaves the app
**Full correlation with backend via shared `user_id`!** 🚀
* Perfect! ✅ All done. Let me create the final comprehensive summary:
---
## ✅ Complete: Added `source: "backend"` to All Backend Events
### The Problem (Resolved)
**Naming conflict:**
- Backend was using `source` for **semantic meaning** (how project was created: "manual", "github", "auto_setup")
- Frontend uses `source` for **layer identification** ("frontend")
- These are different concepts!
### The Solution
**1. Renamed semantic usage from `source` → `trigger`**
**2. Added global `source: "backend"` to all events**
### Changes Made (4 files, 4 insertions, 3 deletions)
**1. `crates/services/src/services/analytics.rs:81` - Added global source tag:**
```rust
if let Some(props) = event_properties.as_object_mut() {
props.insert("timestamp".to_string(), json!(chrono::Utc::now().to_rfc3339()));
props.insert("version".to_string(), json!(env!("CARGO_PKG_VERSION")));
props.insert("device".to_string(), get_device_info());
props.insert("source".to_string(), json!("backend")); // NEW!
}
```
**2. `crates/server/src/routes/projects.rs:161` - Renamed semantic property:**
```rust
// Before:
"source": "manual",
// After:
"trigger": "manual",
```
**3. `crates/server/src/routes/github.rs:185` - Renamed semantic property:**
```rust
// Before:
"source": "github",
// After:
"trigger": "github",
```
**4. `crates/deployment/src/lib.rs:307` - Renamed semantic property:**
```rust
// Before:
"source": "auto_setup",
// After:
"trigger": "auto_setup",
```
### Event Structure Now
**Backend `project_created` event:**
```javascript
{
event: "project_created",
properties: {
"source": "backend", // NEW! Layer identification
"trigger": "manual", // Renamed from "source" - how it was created
"project_id": "uuid...",
"has_setup_script": true,
"version": "0.0.108",
"device": { os_type: "...", ... },
"timestamp": "2025-10-17T..."
}
}
```
**Frontend `app_loaded` event:**
```javascript
{
event: "app_loaded",
properties: {
"source": "frontend", // Layer identification (matches backend!)
"version": "0.0.108",
"theme": "DARK",
"language": "EN",
"timestamp": "2025-10-17T..."
}
}
```
### Benefits
✅ **Symmetric** - Both frontend and backend use `source` for layer identification
✅ **Clear semantics** - `trigger` describes *how*, `source` describes *where*
✅ **Easy filtering** in PostHog:
- All backend events: `source = "backend"`
- All frontend events: `source = "frontend"`
- Manual project creation: `trigger = "manual"`
- GitHub project creation: `trigger = "github"`
- Auto-setup projects: `trigger = "auto_setup"`
✅ **No conflicts** - Different properties for different purposes
✅ **Backward compatible** - Only affects new events going forward
### PostHog Analysis Examples
**Compare frontend vs backend activity:**
```sql
SELECT source, count(*)
GROUP BY source
-- Result: { "backend": 1247, "frontend": 892 }
```
**Analyze project creation sources:**
```sql
SELECT trigger, count(*)
WHERE event = "project_created"
GROUP BY trigger
-- Result: { "manual": 15, "github": 8, "auto_setup": 3 }
```
**Full user journey:**
```
User: npm_user_abc123...
Events:
- app_loaded (source: frontend)
- $autocapture: preview button (source: frontend)
- view_navigated (source: frontend)
- project_created (source: backend, trigger: manual)
- task_created (source: backend)
- task_attempt_started (source: backend)
```
**Clean, clear, and fully correlated!** 🎉
* Perfect! All done. Let me create the final comprehensive summary:
---
## ✅ Complete: Track at Interaction Points (Buttons + Keyboard Shortcuts)
### What Changed
**Switched from state-based tracking to interaction-based tracking:**
**Before:**
- Tracked in `setMode()` (state change function)
- One generic `view_navigated` event
- Lost context about HOW user navigated
**After:**
- Track at interaction points (button clicks, keyboard shortcuts)
- Specific events: `preview_button_clicked`, `preview_keyboard_shortcut`, etc.
- Rich context about user preferences
### Changes Made (2 files, 36 insertions, 10 deletions)
**1. `frontend/src/pages/project-tasks.tsx`:**
**Removed tracking from `setMode()`:**
```diff
const setMode = useCallback(
(newMode: LayoutMode) => {
- // Track view navigation (captures both button clicks and keyboard shortcuts)
- if (newMode !== mode) {
- trackEvent('view_navigated', {
- from_view: mode ?? 'attempt',
- to_view: newMode ?? 'attempt',
- });
- }
const params = new URLSearchParams(searchParams);
// ... rest
},
- [mode, searchParams, setSearchParams]
+ [searchParams, setSearchParams]
);
```
**Added tracking to keyboard shortcuts:**
```typescript
// Cmd/Ctrl+Enter (forward cycle):
useKeyOpenDetails(() => {
if (isPanelOpen) {
// Calculate next view
const order: LayoutMode[] = [null, 'preview', 'diffs'];
const idx = order.indexOf(mode);
const next = order[(idx + 1) % order.length];
// Track keyboard shortcut
if (next === 'preview') {
trackEvent('preview_keyboard_shortcut', { direction: 'forward' });
} else if (next === 'diffs') {
trackEvent('diffs_keyboard_shortcut', { direction: 'forward' });
}
cycleViewForward();
}
});
// Cmd/Ctrl+Shift+Enter (backward cycle):
useKeyCycleViewBackward(() => {
if (isPanelOpen) {
// Calculate next view
const order: LayoutMode[] = [null, 'preview', 'diffs'];
const idx = order.indexOf(mode);
const next = order[(idx - 1 + order.length) % order.length];
// Track keyboard shortcut
if (next === 'preview') {
trackEvent('preview_keyboard_shortcut', { direction: 'backward' });
} else if (next === 'diffs') {
trackEvent('diffs_keyboard_shortcut', { direction: 'backward' });
}
cycleViewBackward();
}
});
```
**2. `frontend/src/components/panels/AttemptHeaderActions.tsx`:**
**Added tracking to button clicks:**
```typescript
import { trackEvent } from '@/lib/analytics';
<ToggleGroup
type="single"
value={mode ?? ''}
onValueChange={(v) => {
const newMode = (v as LayoutMode) || null;
// Track button click
if (newMode === 'preview') {
trackEvent('preview_button_clicked');
} else if (newMode === 'diffs') {
trackEvent('diffs_button_clicked');
}
onModeChange(newMode);
}}
>
```
### Events Now Tracked
**Button Click:**
```javascript
// 1. Autocapture (from PostHog)
{
event: "$autocapture",
properties: {
"data-ph-capture-attribute": "attempt-header-preview-button",
"$el_text": "",
"source": "frontend",
}
}
// 2. Custom event (from our code)
{
event: "preview_button_clicked",
properties: {
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
**Keyboard Shortcut (Cmd+Enter):**
```javascript
{
event: "preview_keyboard_shortcut",
properties: {
"direction": "forward",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
**Keyboard Shortcut (Cmd+Shift+Enter backward):**
```javascript
{
event: "diffs_keyboard_shortcut",
properties: {
"direction": "backward",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
### PostHog Analysis Examples
**Total preview usage (any method):**
```sql
SELECT count(*)
WHERE event IN ('preview_button_clicked', 'preview_keyboard_shortcut')
```
**Keyboard warriors vs clickers:**
```sql
SELECT
SUM(CASE WHEN event LIKE '%keyboard%' THEN 1 ELSE 0 END) as keyboard_users,
SUM(CASE WHEN event LIKE '%button%' THEN 1 ELSE 0 END) as button_users
```
**Forward vs backward ...
* Perfect! All checks pass. Let me create a comprehensive final summary of everything we've accomplished:
---
## ✅ Complete: Load Time Tracking Added
### What Was Added
**One line change** to track app initialization performance:
**`frontend/src/App.tsx:57`:**
```typescript
trackEvent('app_loaded', {
version: import.meta.env.VITE_APP_VERSION,
theme: config.theme,
language: config.language,
load_time_ms: Math.round(performance.now()), // NEW!
});
```
### What `performance.now()` Measures
**Browser Performance API:**
- Returns milliseconds since **page navigation started**
- Starts at `0` when user navigates to the page
- High precision (microsecond accuracy, rounded to milliseconds)
- Includes:
- HTML parsing
- JavaScript loading and execution
- React initialization
- Config fetch from `/api/info`
- React rendering to DOM
**Example values:**
- Fast machine, good network: `~800ms`
- Average: `~1500ms`
- Slow machine or network: `~3000ms+`
### PostHog Analysis Examples
**Average load time:**
```sql
SELECT AVG(load_time_ms) WHERE event = 'app_loaded'
-- Result: 1234ms
```
**Percentiles (P50, P95, P99):**
```sql
SELECT
PERCENTILE(load_time_ms, 0.5) as median,
PERCENTILE(load_time_ms, 0.95) as p95,
PERCENTILE(load_time_ms, 0.99) as p99
WHERE event = 'app_loaded'
-- Result: median=1200ms, p95=2800ms, p99=4500ms
```
**Load time by OS:**
```sql
SELECT
device.os_type,
AVG(load_time_ms) as avg_load_time
WHERE event = 'app_loaded'
GROUP BY device.os_type
-- Result: { "macOS": 1100ms, "Windows": 1600ms, "Linux": 1400ms }
```
**Load time trend over time:**
```sql
SELECT
DATE(timestamp) as date,
AVG(load_time_ms) as avg_load
WHERE event = 'app_loaded'
GROUP BY date
ORDER BY date
-- See if load times are getting better/worse with releases
```
---
## 🎉 Complete Analytics Implementation Summary
### All Features Implemented
**Backend:**
1. ✅ Exposes `AnalyticsInfo` via `/api/info` with `user_id` + PostHog config
2. ✅ Reuses `AnalyticsConfig::new()` for credentials (DRY)
3. ✅ Adds `source: "backend"` to ALL events
4. ✅ Uses `trigger` property for semantic meaning (manual, github, auto_setup)
5. ✅ Proper TypeScript type generation
**Frontend:**
6. ✅ Initializes PostHog with backend config at runtime
7. ✅ Identifies user with backend's `user_id` for full correlation
8. ✅ Respects `config.analytics_enabled` preference
9. ✅ Opt-in autocapture (only elements with `data-ph-capture-attribute`)
10. ✅ Type-safe `AnalyticsId` enum (no random strings allowed!)
11. ✅ Tracks at interaction points (not state changes)
**Events Tracked:**
12. ✅ `app_loaded` - App initialization with load time, version, theme, language
13. ✅ `preview_button_clicked` / `diffs_button_clicked` - Button clicks
14. ✅ `preview_keyboard_shortcut` / `diffs_keyboard_shortcut` - Keyboard shortcuts with direction
15. ✅ `$autocapture` - Button clicks with stable IDs (automatic)
16. ✅ `$pageleave` - User closes/leaves app (automatic)
### Key Properties on All Events
**Frontend events:**
```javascript
{
"source": "frontend",
"timestamp": "2025-10-17T...",
// ... event-specific properties
}
```
**Backend events:**
```javascript
{
"source": "backend",
"timestamp": "2025-10-17T...",
"version": "0.0.108",
"device": { os_type: "macOS", ... },
// ... event-specific properties
}
```
### Type Safety
✅ **Analytics IDs:** TypeScript enum prevents typos
✅ **Generated types:** `AnalyticsInfo` and `AnalyticsConfig` auto-generated from Rust
✅ **Compile-time safety:** Invalid analytics IDs won't compile
### PostHog Correlation
✅ **Same user_id:** Frontend and backend share `npm_user_{hash}`
✅ **Full journey:** See clicks → actions → results in one user timeline
✅ **Easy filtering:** `source = "frontend"` or `source = "backend"`
### Clean Architecture
✅ **No env var mess:** PostHog config from `/api/info` at runtime
✅ **No code duplication:** Reuses `AnalyticsConfig::new()` logic
✅ **Opt-in tracking:** Only instrumented elements tracked
✅ **Best pra...
* Perfect! Let me create the final summary:
---
## ✅ Fixed: Removed Unwanted Events ("Web vitals", "clicked svg")
### The Problems
**You were seeing:**
1. ❌ "Web vitals" events - Automatic performance tracking
2. ❌ "clicked svg" events - SVG elements inside buttons being tracked
3. ❌ Noise in PostHog from events you didn't want
### Root Causes
**1. Web Vitals:**
- PostHog has automatic web performance tracking
- `capture_performance: true` by default
- Tracks Core Web Vitals (LCP, FID, CLS, etc.)
**2. "clicked svg" Events:**
- `css_selector_allowlist` doesn't work as expected
- Clicks on **children** of allowed elements also get tracked
- SVG icons inside `<ToggleGroupItem data-ph-capture-attribute="...">` were being captured
### The Fix
**Disabled autocapture entirely and web vitals tracking:**
**`frontend/src/lib/analytics.ts:46-49`:**
```typescript
// Before:
capture_pageview: false, // We'll manually capture page views
capture_pageleave: true, // Track when user closes/leaves the page
autocapture: {
// Opt-in autocapture: only track elements with data-ph-capture-attribute
css_selector_allowlist: ['[data-ph-capture-attribute]'],
},
// After:
capture_pageview: false,
capture_pageleave: true,
capture_performance: false, // Disable automatic web vitals tracking
autocapture: false, // Disable autocapture entirely - we'll use manual events only
```
### Why This is Better
✅ **No noise** - Only events YOU explicitly track
✅ **No "Web vitals"** - Performance tracking disabled
✅ **No "clicked svg"** - No autocapture at all
✅ **Clean PostHog** - Only meaningful, intentional events
✅ **Full control** - Know exactly what's being tracked
### What's Still Tracked (Clean List)
**Frontend Events:**
1. `app_loaded` - App initialization with load_time_ms, version, theme, language
2. `preview_button_clicked` - User clicked preview button
3. `diffs_button_clicked` - User clicked diffs button
4. `preview_keyboard_shortcut` - User pressed Cmd+Enter for preview (with direction)
5. `diffs_keyboard_shortcut` - User pressed Cmd+Enter for diffs (with direction)
6. `$pageleave` - User closes/leaves the app
**Backend Events:**
- `project_created` (with `trigger: "manual" | "github" | "auto_setup"`)
- `task_created`
- `task_deleted`
- `task_attempt_started`
- `task_attempt_finished`
- `pr_merged`
- `image_uploaded`
- All onboarding events
- All with `source: "backend"`
### What Was Removed
❌ ~~`$autocapture` events~~ - Disabled (was causing "clicked svg" noise)
❌ ~~"Web vitals" events~~ - Disabled
❌ ~~Random element clicks~~ - Disabled
**Now you only see events that actually matter!**
### Since We Removed Autocapture
The `AnalyticsId` enum and `data-ph-capture-attribute` on the toggle buttons are now **unused** (autocapture is off). We could:
**Option A:** Remove them (clean up unused code)
**Option B:** Keep them (in case you want to re-enable autocapture later with proper config)
**Option C:** Keep them as documentation (shows which elements are tracked)
**My recommendation:** Keep them for now - they document which UI elements are tracked, even though we're using manual `trackEvent()` calls instead of autocapture.
### Final Event List in PostHog
**Clean, intentional events only:**
- ✅ `app_loaded` (frontend)
- ✅ `preview_button_clicked` (frontend)
- ✅ `diffs_button_clicked` (frontend)
- ✅ `preview_keyboard_shortcut` (frontend)
- ✅ `diffs_keyboard_shortcut` (frontend)
- ✅ `$pageleave` (frontend)
- ✅ All backend events (task_created, pr_merged, etc.)
**No more noise!** 🎉
* Perfect! All cleaned up. Let me create a final summary:
---
## ✅ Complete: Cleaned Up + Re-enabled Web Vitals
### What Was Done
**Cleanup:**
1. ✅ Deleted `frontend/src/lib/analytics-ids.ts` - No longer needed (autocapture disabled)
2. ✅ Removed `AnalyticsId` import from `AttemptHeaderActions.tsx`
3. ✅ Removed `data-ph-capture-attribute` from toggle buttons (no autocapture)
**Re-enabled Web Vitals:**
4. ✅ Set `capture_performance: true` - Now you know where "Web vitals" events come from!
### Changes (3 files, 2 insertions, 24 deletions)
**1. `frontend/src/lib/analytics.ts`:**
```diff
- capture_performance: false, // Disable automatic web vitals tracking
- autocapture: {
- css_selector_allowlist: ['[data-ph-capture-attribute]'],
- },
+ capture_performance: true, // Track web vitals (LCP, FID, CLS, etc.)
+ autocapture: false, // Disabled - we use manual events only
```
**2. `frontend/src/lib/analytics-ids.ts`:**
```diff
- DELETED ENTIRE FILE (19 lines removed)
```
**3. `frontend/src/components/panels/AttemptHeaderActions.tsx`:**
```diff
- import { AnalyticsId } from '@/lib/analytics-ids';
- data-ph-capture-attribute={AnalyticsId.NAV_PREVIEW_BUTTON}
- data-ph-capture-attribute={AnalyticsId.NAV_DIFFS_BUTTON}
```
### What You'll See in PostHog Now
**Clean event list:**
1. ✅ `app_loaded` - App initialization (with load_time_ms)
2. ✅ `preview_button_clicked` - Manual tracking
3. ✅ `diffs_button_clicked` - Manual tracking
4. ✅ `preview_keyboard_shortcut` - Manual tracking (with direction)
5. ✅ `diffs_keyboard_shortcut` - Manual tracking (with direction)
6. ✅ `$pageleave` - Automatic
7. ✅ `Web vitals` - **Automatic performance metrics (LCP, FID, CLS, TTFB, etc.)**
8. ✅ All backend events (`task_created`, `pr_merged`, etc.)
**Gone:**
- ❌ ~~"clicked svg"~~ - Autocapture disabled
- ❌ ~~Random `$autocapture` events~~ - Autocapture disabled
- ❌ ~~Noise~~ - Only intentional events!
### Web Vitals Explained
**Now that you know where they come from (`capture_performance: true`), here's what they measure:**
**Core Web Vitals:**
- **LCP (Largest Contentful Paint):** When main content appears (should be <2.5s)
- **FID (First Input Delay):** How fast UI responds to first click (should be <100ms)
- **CLS (Cumulative Layout Shift):** How much page jumps around (should be <0.1)
- **TTFB (Time to First Byte):** Server response time
- **FCP (First Contentful Paint):** When anything first renders
**These are valuable for:**
- Understanding perceived performance
- Detecting slow network conditions
- Identifying performance regressions
- Comparing performance across devices/OSs
**Example PostHog query:**
```sql
SELECT
AVG(value) as avg_lcp
WHERE event = 'Web vitals' AND metric = 'LCP'
-- Result: 1234ms average LCP
```
### Final Analytics Architecture
**Manual tracking only:**
- ✅ Button clicks → Explicit `trackEvent()` calls
- ✅ Keyboard shortcuts → Explicit `trackEvent()` calls
- ✅ App lifecycle → Explicit `trackEvent()` calls
**Automatic tracking (opt-in):**
- ✅ Web vitals → `capture_performance: true`
- ✅ Page leave → `capture_pageleave: true`
**Correlation:**
- ✅ Frontend + Backend share `user_id`
- ✅ All events tagged with `source: "frontend"` or `source: "backend"`
**Clean, intentional, and production-ready!** 🚀
* Perfect! ✅ All done. Let me create the comprehensive final summary:
---
## ✅ Complete: Single Events with `trigger` Property (Finally Done Right!)
### What You Asked For
**"Can we please make this the same event but give it some attribute to know the trigger?"**
**✅ NOW CORRECT!** Single event per view, with `trigger` property showing how it happened.
### The Fix
**Before (Wrong):**
- ❌ `preview_button_clicked` (separate event)
- ❌ `preview_keyboard_shortcut` (separate event)
- ❌ `diffs_button_clicked` (separate event)
- ❌ `diffs_keyboard_shortcut` (separate event)
- ❌ Not tracking closes
**After (Correct):**
- ✅ `preview_navigated` with `trigger: "button" | "keyboard"`
- ✅ `diffs_navigated` with `trigger: "button" | "keyboard"`
- ✅ `view_closed` when clicking active button to close
### Events Now Tracked
**1. Navigate to preview via button:**
```javascript
{
event: "preview_navigated",
properties: {
"trigger": "button",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
**2. Navigate to preview via keyboard (Cmd+Enter):**
```javascript
{
event: "preview_navigated",
properties: {
"trigger": "keyboard",
"direction": "forward",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
**3. Navigate to diffs via button:**
```javascript
{
event: "diffs_navigated",
properties: {
"trigger": "button",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
**4. Close preview by clicking active button:**
```javascript
{
event: "view_closed",
properties: {
"trigger": "button",
"from_view": "preview",
"source": "frontend",
"timestamp": "2025-10-17T..."
}
}
```
### Answers to Your Questions
**Q: "Is there a shortcut to not cycle but just open preview?"**
**A:** NO - Only cycling shortcuts exist (Cmd+Enter cycles forward, Cmd+Shift+Enter cycles backward)
**Q: "Do we track that?"**
**A:** YES - Now tracking with `preview_navigated` event with `trigger: "keyboard"` and `direction: "forward" | "backward"`
**Q: "Do we track close preview by clicking on it?"**
**A:** YES - Now tracking! When you click the active preview button, it tracks `view_closed` with `from_view: "preview"`
### PostHog Analysis Examples
**Total preview usage (any method):**
```sql
SELECT count(*) WHERE event = 'preview_navigated'
```
**Button vs keyboard preference:**
```sql
SELECT trigger, count(*)
WHERE event = 'preview_navigated'
GROUP BY trigger
-- Result: { "button": 234, "keyboard": 156 }
```
**Keyboard cycling direction:**
```sql
SELECT direction, count(*)
WHERE event = 'preview_navigated' AND trigger = 'keyboard'
GROUP BY direction
-- Result: { "forward": 145, "backward": 11 }
```
**Most popular view:**
```sql
SELECT event, count(*)
WHERE event IN ('preview_navigated', 'diffs_navigated')
GROUP BY event
-- Result: { "preview_navigated": 567, "diffs_navigated": 234 }
```
**Close rate:**
```sql
SELECT
(SELECT count(*) FROM events WHERE event = 'view_closed') as closes,
(SELECT count(*) FROM events WHERE event = 'preview_navigated') as opens
-- See how often users close vs navigate to preview
```
### Complete Event List
**Frontend Events:**
1. ✅ `app_loaded` - With version, theme, language, **load_time_ms**
2. ✅ `preview_navigated` - With `trigger: "button" | "keyboard"`, optional `direction`
3. ✅ `diffs_navigated` - With `trigger: "button" | "keyboard"`, optional `direction`
4. ✅ `view_closed` - With `trigger: "button"`, `from_view`
5. ✅ `Web vitals` - Automatic (LCP, FID, CLS, etc.)
6. ✅ `$pageleave` - Automatic
**Backend Events:**
- All events with `source: "backend"`
- `project_created` with `trigger: "manual" | "github" | "auto_setup"`
**Full correlation via shared `user_id`!**
**Finally correct and production-ready!** 🎉
* Lint
* fmt
* Perfect! Now let me create a comprehensive summary of the fixes:
---
## ✅ Fixed: Reviewer Feedback - Dynamic Toggle + Event Queueing
### Issue 1: Can't Re-enable Analytics After Disabling ❌
**Problem:**
```typescript
// OLD CODE:
if (isInitialized) {
return; // ❌ Bails out forever!
}
if (userAnalyticsEnabled === false) {
analyticsEnabled = false;
isInitialized = true; // ❌ Now stuck - can never re-enable!
return;
}
```
**Scenario:**
1. User has `analytics_enabled: false` (opted out)
2. App loads → `initializeAnalytics()` called → sets `isInitialized = true`, returns
3. User changes setting to `analytics_enabled: true`
4. `useEffect` re-runs → calls `initializeAnalytics()` again
5. **But it returns immediately** because `isInitialized === true`
6. **Analytics never starts!** ❌
**Fix:**
```typescript
// NEW CODE:
let posthogInitialized = false; // Renamed: tracks if posthog.init() was called
let analyticsEnabled = false; // Tracks if we should send events
export function initializeAnalytics(...) {
// NO early return for isInitialized!
if (userAnalyticsEnabled === false) {
analyticsEnabled = false;
// If PostHog is already initialized, opt out
if (posthogInitialized) {
posthog.opt_out_capturing(); // ✅ Dynamic opt-out!
}
return;
}
// If already initialized, just opt in
if (posthogInitialized) {
posthog.opt_in_capturing(); // ✅ Dynamic opt-in!
analyticsEnabled = true;
return;
}
// Initialize PostHog for the first time
posthog.init(...);
posthogInitialized = true;
}
```
**Now it works:**
1. User opts out → `opt_out_capturing()` called → tracking stops ✅
2. User opts in later → `opt_in_capturing()` called → tracking resumes ✅
3. PostHog stays initialized, we just toggle capturing ✅
### Issue 2: `app_loaded` Event Never Sent ❌
**Problem:**
```typescript
// In App.tsx:
initializeAnalytics(analytics, analyticsEnabled);
trackEvent('app_loaded', { ... }); // ❌ Called immediately!
// But in analytics.ts:
posthog.init(..., {
loaded: () => {
analyticsEnabled = true; // ❌ This runs LATER (async callback)!
}
});
// In trackEvent:
if (!analyticsEnabled) {
return; // ❌ app_loaded event is DROPPED!
}
```
**Timeline:**
1. `initializeAnalytics()` called → starts PostHog init (async)
2. `trackEvent('app_loaded')` called immediately after
3. Checks `analyticsEnabled` → still `false` (loaded callback hasn't run yet)
4. Event dropped ❌
5. 100ms later: PostHog `loaded` callback fires → sets `analyticsEnabled = true`
6. Too late! First event was already lost.
**Fix - Event Queue:**
```typescript
let eventQueue: Array<{ eventName: string; properties?: Record<string, any> }> = [];
// In trackEvent:
if (posthogInitialized && !analyticsEnabled) {
// PostHog is initializing but not ready yet - queue the event
eventQueue.push({ eventName, properties });
return;
}
// In loaded callback:
loaded: () => {
analyticsEnabled = true;
// Flush queued events ✅
if (eventQueue.length > 0) {
console.log(`[Analytics] Flushing ${eventQueue.length} queued events`);
eventQueue.forEach(({ eventName, properties }) => {
posthog.capture(eventName, {
...properties,
timestamp: new Date().toISOString(),
source: 'frontend',
});
});
eventQueue = [];
}
}
```
**Now it works:**
1. `initializeAnalytics()` called → `posthogInitialized = true`
2. `trackEvent('app_loaded')` called → PostHog not ready yet → **queued** ✅
3. PostHog `loaded` callback fires → sets `analyticsEnabled = true`
4. **Flushes queue** → `app_loaded` event sent ✅
### Changes Made
**`frontend/src/lib/analytics.ts`:**
1. **Renamed `isInitialized` → `posthogInitialized`**
- More accurate: tracks if `posthog.init()` was called, not if function ran
2. **Added event queue:**
```typescript
let eventQueue: Array<{ eventName: string; properties?: Record<string, any> }> = [];
```
3. **Removed early return guard:**
- Can now be called multiple times
...
* Perfect! Let me create the final summary addressing both review comments:
---
## ✅ Reviewer Feedback Fixed - Both Issues Resolved
### Review Comment 1: `app_loaded` Fires on Every Config Change ❌ → ✅ FIXED
**Problem:**
```typescript
useEffect(() => {
if (analyticsEnabled) {
trackEvent('app_loaded', { ... }); // ❌ Runs every time config changes!
}
}, [config, analytics]); // Triggers on ANY config update
```
**When it was firing:**
- ✅ App initial load (intended)
- ❌ User changes theme → `app_loaded` again
- ❌ User changes language → `app_loaded` again
- ❌ User toggles analytics → `app_loaded` again
**Fix:**
```typescript
const appLoadedTracked = useRef(false); // ✅ NEW: Track if event was sent
useEffect(() => {
if (config && analytics) {
const analyticsEnabled = config.analytics_enabled !== false;
initializeAnalytics(analytics, analyticsEnabled);
// Track app loaded event only once per session
if (analyticsEnabled && !appLoadedTracked.current) { // ✅ Check ref
trackEvent('app_loaded', { ... });
appLoadedTracked.current = true; // ✅ Set ref
}
}
}, [config, analytics]);
```
**Result:**
- ✅ Fires once on initial app load
- ✅ Never fires again (even if config changes)
- ✅ Accurate "app loads" count in PostHog
### Review Comment 2: Why Custom Queue? PostHog Has One! ❌ → ✅ FIXED
**Problem:**
```typescript
let eventQueue = []; // ❌ Custom queue
// Manual queueing:
if (posthogInitialized && !analyticsEnabled) {
eventQueue.push({ eventName, properties });
}
// Manual flushing:
eventQueue.forEach(event => posthog.capture(event));
eventQueue = [];
```
**Reviewer's question:** "What's the argument against using PostHog's queue?"
**Answer:** There is NO good argument! PostHog already has a queue.
**Fix - Trust PostHog's Queue:**
```typescript
// ✅ Removed custom queue entirely
// Set analyticsEnabled IMMEDIATELY when user opts in:
export function initializeAnalytics(...) {
// ...
analyticsEnabled = true; // ✅ Set before calling posthog.init()
posthog.init(..., {
loaded: () => {
console.log('[Analytics] PostHog initialized successfully');
posthog.identify(analyticsInfo.user_id);
// ✅ No queue flushing - PostHog does it automatically!
}
});
}
// Simplified trackEvent:
export function trackEvent(...) {
if (!posthogInitialized || !analyticsEnabled) {
return;
}
// ✅ Just call capture - PostHog queues it if not ready yet!
posthog.capture(eventName, properties);
}
```
**Why PostHog's queue is better:**
- ✅ Handles queueing before `loaded` fires automatically
- ✅ Network retries if offline
- ✅ Event batching for efficiency
- ✅ Battle-tested by thousands of apps
- ✅ Less code for us to maintain
### Changes Made (2 files)
**1. `frontend/src/lib/analytics.ts`:**
- ❌ Removed `let eventQueue = []`
- ✅ Set `analyticsEnabled = true` immediately (not in `loaded` callback)
- ❌ Removed queue flushing logic from `loaded` callback
- ✅ Simplified `trackEvent()` - no manual queueing
**2. `frontend/src/App.tsx`:**
- ✅ Added `const appLoadedTracked = useRef(false)`
- ✅ Check ref before tracking `app_loaded`
- ✅ Set ref after tracking to prevent duplicates
### How It Works Now
**Scenario 1: Normal App Load**
1. App loads, config + analytics fetched
2. `initializeAnalytics()` called → sets `analyticsEnabled = true` immediately
3. `trackEvent('app_loaded')` called → PostHog queues it internally (not ready yet)
4. PostHog `loaded` fires → PostHog flushes its internal queue → event sent ✅
5. Ref prevents tracking again on config changes ✅
**Scenario 2: User Toggles Analytics OFF → ON**
1. User unchecks analytics → `analyticsEnabled = false`, `opt_out_capturing()`
2. User checks analytics → `analyticsEnabled = true`, `opt_in_capturing()`
3. `app_loaded` not re-tracked (ref prevents it) ✅
**Scenario 3: User Changes Theme**
1. Config updates → `useEffect` runs
2. `initializeAnalytics()` returns early (already initialized)
3. `app_loaded` check:...
* Perfect! Let me create a final summary of what we removed:
---
## ✅ Complete: Removed `app_loaded` Event - Simpler and Cleaner
### Why Remove It?
**You were right:** "It just seems complicated to add and what info does it have that we couldn't track elsewhere?"
**Analysis showed `app_loaded` was redundant:**
- ❌ `version` - Already on EVERY backend event
- ❌ `theme` - Could track when user changes it (more valuable)
- ❌ `language` - Could track when user changes it (more valuable)
- ❌ `load_time_ms` - Web Vitals track this better (LCP, FCP, TTFB)
- ❌ Session start - PostHog tracks sessions automatically via user identification
- ❌ Added complexity - `useRef`, timing issues, edge cases
**Backend already tracks everything that matters:**
- ✅ `onboarding_completed` - First app setup (includes profile, editor)
- ✅ All config changes tracked when saved
- ✅ Version on every backend event
### Changes Made (1 file, 0 insertions, 13 deletions)
**`frontend/src/App.tsx`:**
```diff
- import { useEffect, useRef } from 'react';
+ import { useEffect } from 'react';
- import { initializeAnalytics, trackEvent } from '@/lib/analytics';
+ import { initializeAnalytics } from '@/lib/analytics';
function AppContent() {
const { config, analytics, updateAndSaveConfig, loading } = useUserSystem();
- const appLoadedTracked = useRef(false);
useEffect(() => {
if (config && analytics) {
const analyticsEnabled = config.analytics_enabled !== false;
initializeAnalytics(analytics, analyticsEnabled);
-
- // Track app loaded event only once per session
- if (analyticsEnabled && !appLoadedTracked.current) {
- trackEvent('app_loaded', {
- version: import.meta.env.VITE_APP_VERSION,
- theme: config.theme,
- language: config.language,
- load_time_ms: Math.round(performance.now()),
- });
- appLoadedTracked.current = true;
- }
}
}, [config, analytics]);
```
### Final Analytics Implementation (Clean & Simple!)
**Frontend Events (Action-Based):**
1. ✅ `preview_navigated` - User navigated to preview (with `trigger: button|keyboard`, optional `direction`)
2. ✅ `diffs_navigated` - User navigated to diffs (with `trigger: button|keyboard`, optional `direction`)
3. ✅ `view_closed` - User closed preview/diffs view (with `trigger: button`, `from_view`)
4. ✅ `Web vitals` - Automatic performance metrics (LCP, FID, CLS, TTFB, FCP)
5. ✅ `$pageleave` - Automatic (session end)
**Backend Events (Action-Based):**
- ✅ `project_created` (with `trigger: manual|github|auto_setup`)
- ✅ `task_created`, `task_deleted`
- ✅ `task_attempt_started`, `task_attempt_finished`
- ✅ `pr_merged`, `image_uploaded`
- ✅ `onboarding_completed`, `onboarding_disclaimer_accepted`, etc.
- ✅ All with `source: "backend"`
**What Was Removed:**
- ❌ `app_loaded` - Redundant complexity
**Benefits:**
✅ **Simpler code** - No `useRef`, no timing issues, no edge cases
✅ **Action-focused** - Track what users DO, not passive lifecycle
✅ **No duplication** - Version/theme/language tracked elsewhere
✅ **Better performance data** - Web Vitals > custom `load_time_ms`
✅ **Idiomatic React** - No ref hacks
**Clean, focused, and production-ready!** 🎉
* Perfect! ✅ Done. Let me create a final summary of the entire implementation:
---
## ✅ Complete: Frontend PostHog Analytics Implementation
### Final Clean Implementation
**What's Tracked:**
**Frontend Events (Action-Based):**
1. ✅ `preview_navigated` - User navigated to preview (properties: `trigger: "button"|"keyboard"`, optional `direction: "forward"|"backward"`)
2. ✅ `diffs_navigated` - User navigated to diffs (properties: `trigger: "button"|"keyboard"`, optional `direction: "forward"|"backward"`)
3. ✅ `view_closed` - User closed preview/diffs (properties: `trigger: "button"`, `from_view`)
4. ✅ `Web vitals` - Automatic performance metrics (LCP, FID, CLS, TTFB, FCP)
5. ✅ `$pageleave` - Automatic session end tracking
**Backend Events (Already Existed):**
- ✅ `project_created` (with `trigger: "manual"|"github"|"auto_setup"`, `source: "backend"`)
- ✅ `task_created`, `task_deleted` (with `source: "backend"`)
- ✅ `task_attempt_started`, `task_attempt_finished` (with `source: "backend"`)
- ✅ `pr_merged`, `image_uploaded` (with `source: "backend"`)
- ✅ `onboarding_completed` (includes profile, editor, theme, language)
### Key Architecture Decisions
**✅ No `app_loaded` event:**
- Removed - redundant complexity
- Info already tracked in backend's `onboarding_completed` and other events
- Web Vitals provide better load performance data
**✅ No autocapture:**
- Disabled - was causing noise ("clicked svg", etc.)
- Using explicit `trackEvent()` calls instead
- Full control over what's tracked
**✅ No custom event queue:**
- Removed - trust PostHog's built-in queue
- PostHog queues events called before `loaded` callback fires
- Simpler code, battle-tested queue
**✅ Dynamic opt-in/opt-out:**
- User can toggle analytics in settings without page reload
- Uses PostHog's `opt_in_capturing()` / `opt_out_capturing()`
- No `isInitialized` guard blocking re-initialization
**✅ Track at interaction points:**
- Button clicks tracked in button handler
- Keyboard shortcuts tracked in keyboard handler
- NOT tracked in state change function (anti-pattern avoided)
**✅ Symmetric source tagging:**
- Backend: `source: "backend"` on all events
- Frontend: `source: "frontend"` on all events
- Easy filtering in PostHog
**✅ Full correlation:**
- Frontend and backend share same `user_id` from `generate_user_id()`
- Can see complete user journey in PostHog
### Files Changed (Summary)
**Backend:**
1. `crates/services/src/services/analytics.rs` - Add `source: "backend"`, add Serialize/Deserialize/TS to `AnalyticsConfig`
2. `crates/server/src/routes/config.rs` - Add `AnalyticsInfo` struct, return via `/api/info`
3. `crates/server/src/routes/projects.rs` - Rename `source` → `trigger`
4. `crates/server/src/routes/github.rs` - Rename `source` → `trigger`
5. `crates/deployment/src/lib.rs` - Rename `source` → `trigger`
6. `crates/server/src/bin/generate_types.rs` - Add `AnalyticsInfo` and `AnalyticsConfig` to generation
7. `shared/types.ts` - Auto-generated types
**Frontend:**
8. `frontend/src/lib/analytics.ts` - Core analytics module (init, trackEvent, etc.)
9. `frontend/src/components/config-provider.tsx` - Expose `analytics` from `/api/info`
10. `frontend/src/App.tsx` - Initialize analytics (no tracking, just initialization)
11. `frontend/src/components/panels/AttemptHeaderActions.tsx` - Track button clicks
12. `frontend/src/pages/project-tasks.tsx` - Track keyboard shortcuts
13. `frontend/package.json` - Added `posthog-js` dependency
14. `frontend/vite.config.ts` - Only exposes `VITE_APP_VERSION`
**Cleanup:**
15. ❌ Removed `analytics-ids.ts` - Not needed (no autocapture)
16. ❌ No button.tsx changes - No analytics in Button component
17. ❌ No app_loaded event - Redundant
18. ❌ No custom queue - Use PostHog's queue
19. ❌ No useRef complexity - Removed
### What You Can Analyze in PostHog
**User behavior:**
- Which view do users prefer? (preview vs diffs)
- Do users prefer keyboard shortcuts or buttons?
- How often do users cycle through views?
**Performance:**
- App load performance (Web Vitals...
* Perfect! Let me create a final summary:
---
## ✅ Complete: Removed Unused Code from vite.config.ts
### Review Comment Fixed
**"Do we still use this?"** - Referring to `packageJson` variable
**Answer: NO!** ❌ It was unused after we removed the `app_loaded` event.
### What Was Removed (8 lines deleted)
**`frontend/vite.config.ts`:**
```diff
- const packageJson = JSON.parse(
- fs.readFileSync(path.resolve(__dirname, "./package.json"), "utf8")
- );
- define: {
- // Expose app version from package.json
- 'import.meta.env.VITE_APP_VERSION': JSON.stringify(packageJson.version),
- },
```
### Why It Was There
**Originally used for:**
```typescript
trackEvent('app_loaded', {
version: import.meta.env.VITE_APP_VERSION, // ← Used this
theme: config.theme,
language: config.language,
load_time_ms: Math.round(performance.now()),
});
```
**But we removed `app_loaded` event because:**
- Version already on every backend event
- Theme/language already tracked in backend config events
- Load time better tracked via Web Vitals
- Added unnecessary complexity
**So now:**
- ✅ No `app_loaded` event
- ✅ No need for `VITE_APP_VERSION`
- ✅ No need to read `package.json`
- ✅ No need for `define` block
### Final Clean vite.config.ts
**Now contains:**
- ✅ Plugins (React, Sentry, executorSchemas)
- ✅ Path aliases (@, shared)
- ✅ Dev server config (port, proxy)
- ✅ Build config (sourcemap)
**Removed:**
- ❌ `packageJson` parsing
- ❌ `define` block for env vars
- ❌ Unused code
**Clean and minimal!** 🎉
---
## Complete Analytics Implementation Summary
**What's Actually Tracked:**
**Frontend (3 events + 2 automatic):**
1. `preview_navigated` (trigger: button|keyboard, optional direction)
2. `diffs_navigated` (trigger: button|keyboard, optional direction)
3. `view_closed` (trigger: button, from_view)
4. `Web vitals` (automatic - LCP, FID, CLS, etc.)
5. `$pageleave` (automatic)
**Backend (already existed):**
- `project_created`, `task_created`, `task_attempt_started`, `pr_merged`, etc.
- All with `source: "backend"` and `trigger` where applicable
**Clean, simple, focused on user actions!** ✅
* Perfect! Let me create a final comprehensive summary:
---
## ✅ Complete: Migrated to PostHog's Recommended React Pattern
### What Changed - Complete Refactor
**Switched from custom implementation to PostHog's official React pattern:**
**Before (Custom):**
- Custom `analytics.ts` module with global state
- Manual initialization in component
- `trackEvent()` wrapper function
- Runtime credentials from `/api/info`
**After (PostHog Recommended):**
- PostHog's `PostHogProvider` + `usePostHog()` hook
- Initialization in `main.tsx` (module level)
- Direct `posthog.capture()` calls
- Build-time credentials from env vars
- Runtime `user_id` from `/api/info` for correlation
### Files Changed (9 files)
**Backend (Simplified API):**
1. **`crates/server/src/routes/config.rs`:**
- Simplified `AnalyticsInfo` to only have `user_id`
- Removed `config: Option<AnalyticsConfig>` field
- Removed `AnalyticsConfig` import
2. **`crates/server/src/bin/generate_types.rs`:**
- Removed `services::services::analytics::AnalyticsConfig::decl()`
3. **`shared/types.ts`:**
- Auto-generated: `export type AnalyticsInfo = { user_id: string }`
**Frontend (PostHog Provider Pattern):**
4. **`frontend/vite.config.ts`:**
- Added `define` block with PostHog env vars:
```typescript
define: {
'import.meta.env.VITE_POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
'import.meta.env.VITE_POSTHOG_API_ENDPOINT': JSON.stringify(process.env.POSTHOG_API_ENDPOINT || ''),
}
```
5. **`frontend/src/main.tsx`:**
- Initialize PostHog at module level with env vars
- Wrap app with `<PostHogProvider client={posthog}>`
```typescript
import posthog from 'posthog-js';
import { PostHogProvider } from 'posthog-js/react';
posthog.init(import.meta.env.VITE_POSTHOG_API_KEY, {
api_host: import.meta.env.VITE_POSTHOG_API_ENDPOINT,
opt_out_capturing_by_default: true,
// ...
});
<PostHogProvider client={posthog}>
<App />
</PostHogProvider>
```
6. **`frontend/src/App.tsx`:**
- Use `usePostHog()` hook
- Handle opt-in/opt-out when config loads
- Identify user with `analytics.user_id`
```typescript
const posthog = usePostHog();
useEffect(() => {
if (!posthog || !analytics) return;
if (config?.analytics_enabled !== false) {
posthog.opt_in_capturing();
posthog.identify(analytics.user_id);
} else {
posthog.opt_out_capturing();
}
}, [config?.analytics_enabled, analytics, posthog]);
```
7. **`frontend/src/components/panels/AttemptHeaderActions.tsx`:**
- Use `usePostHog()` hook
- Replace `trackEvent()` with `posthog?.capture()`
8. **`frontend/src/pages/project-tasks.tsx`:**
- Use `usePostHog()` hook
- Replace `trackEvent()` with `posthog?.capture()`
9. **`frontend/src/lib/analytics.ts`:**
- **DELETED** - No longer needed!
### How It Works Now
**1. App Startup (main.tsx):**
```typescript
// PostHog initialized immediately with env vars (before React renders)
posthog.init(VITE_POSTHOG_API_KEY, {
opt_out_capturing_by_default: true, // Start opted out
});
<PostHogProvider client={posthog}>
<App />
</PostHogProvider>
```
**2. Config Loads (App.tsx):**
```typescript
// When /api/info returns with analytics.user_id:
if (config.analytics_enabled !== false) {
posthog.opt_in_capturing(); // Enable tracking
posthog.identify(analytics.user_id); // Correlate with backend
}
```
**3. Track Events (any component):**
```typescript
const posthog = usePostHog();
posthog?.capture('preview_navigated', {
trigger: 'button',
timestamp: new Date().toISOString(),
source: 'frontend',
});
```
### Benefits of This Approach
✅ **PostHog's recommended pattern** - Using official `PostHogProvider` + `usePostHog()` hook
✅ **React-idiomatic** - Hooks and providers, not global state
✅ **SSR-safe** - Would work if we add Next.js/Remix later
✅ **Simpler initialization** - PostHog initialized at module level (standard pattern)
✅ **Cleaner code** - Deleted custom analytics module...
* Perfect! Let me create a final comprehensive summary:
---
## ✅ Complete: Review Comments Fixed - Simplified Architecture
### Review Comment 1: Why Rename to `VITE_*`? ✅ FIXED
**Reviewer asked:** "Why rename it to VITE_? Why not just use POSTHOG_API_KEY directly?"
**You're right - the prefix was unnecessary!**
**Before:**
```typescript
define: {
'import.meta.env.VITE_POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
}
posthog.init(import.meta.env.VITE_POSTHOG_API_KEY, { ... });
```
**After:**
```typescript
define: {
'import.meta.env.POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
}
posthog.init(import.meta.env.POSTHOG_API_KEY, { ... });
```
**Why it's better:**
- ✅ Clearer - no unnecessary prefix
- ✅ Simpler - same name in env and code
- ✅ Less confusing - `VITE_` prefix only needed for Vite's auto-loading (we use `define`)
### Review Comment 2: Do We Need `AnalyticsInfo` Struct? ✅ FIXED
**Reviewer asked:** "Now that it only has user_id we may as well do `analytics_user_id: String`"
**You're absolutely right - the struct was overkill!**
**Before:**
```rust
pub struct AnalyticsInfo {
pub user_id: String,
}
pub struct UserSystemInfo {
pub analytics: AnalyticsInfo, // Nested struct with one field
}
// Frontend:
const userId = userSystemInfo.analytics.user_id;
```
**After:**
```rust
pub struct UserSystemInfo {
pub analytics_user_id: String, // Flat field!
}
// Frontend:
const userId = userSystemInfo.analytics_user_id;
```
**Why it's better:**
- ✅ Simpler - no unnecessary struct
- ✅ Flat - one less level of nesting
- ✅ Clear - field name shows purpose
- ✅ Less code - deleted struct definition
### Changes Made (7 files, 22 insertions, 33 deletions)
**Backend:**
1. `crates/server/src/routes/config.rs`:
- Deleted `AnalyticsInfo` struct
- Changed `pub analytics: AnalyticsInfo` → `pub analytics_user_id: String`
- Simplified handler to just `analytics_user_id: deployment.user_id().to_string()`
2. `crates/server/src/bin/generate_types.rs`:
- Removed `AnalyticsInfo::decl()`
3. `shared/types.ts`:
- Auto-generated: `analytics_user_id: string` field on `UserSystemInfo`
- No more `AnalyticsInfo` type
**Frontend:**
4. `frontend/vite.config.ts`:
- Removed `VITE_` prefix: `POSTHOG_API_KEY` instead of `VITE_POSTHOG_API_KEY`
5. `frontend/src/main.tsx`:
- Initialize PostHog with `import.meta.env.POSTHOG_API_KEY` (no VITE_ prefix)
- Wrapped app with `<PostHogProvider client={posthog}>`
6. `frontend/src/components/config-provider.tsx`:
- Changed `analytics: AnalyticsInfo | null` → `analyticsUserId: string | null`
- Updated to use `userSystemInfo.analytics_user_id`
7. `frontend/src/App.tsx`:
- Use `analyticsUserId` instead of `analytics.user_id`
- Use `usePostHog()` hook instead of custom module
### Final Architecture (Clean & Simple!)
**PostHog Initialization (main.tsx):**
```typescript
// Build-time credentials from env vars
if (import.meta.env.POSTHOG_API_KEY && import.meta.env.POSTHOG_API_ENDPOINT) {
posthog.init(import.meta.env.POSTHOG_API_KEY, {
api_host: import.meta.env.POSTHOG_API_ENDPOINT,
opt_out_capturing_by_default: true, // Start opted out
// ...
});
}
<PostHogProvider client={posthog}>
<App />
</PostHogProvider>
```
**User Identification (App.tsx):**
```typescript
const { config, analyticsUserId } = useUserSystem();
const posthog = usePostHog();
useEffect(() => {
if (!posthog || !analyticsUserId) return;
if (config?.analytics_enabled !== false) {
posthog.opt_in_capturing();
posthog.identify(analyticsUserId); // Runtime user_id from backend
} else {
posthog.opt_out_capturing();
}
}, [config?.analytics_enabled, analyticsUserId, posthog]);
```
**Event Tracking (components):**
```typescript
const posthog = usePostHog();
posthog?.capture('preview_navigated', {
trigger: 'button',
timestamp: new Date().toISOString(),
source: 'frontend',
});
```
### Benefits
✅ **PostHog's recommended pattern** - Using `PostHogProvider` + `usePostHog()` hoo...
* Cleanup script changes for task attempt 4599cd33-f133-4946-b38e-907b16132ebe
* Perfect! ✅ All useless comments removed. Let me create the final comprehensive summary of the entire implementation:
---
## ✅ Complete: Frontend PostHog Analytics Implementation
### Final Architecture
**PostHog's Recommended React Pattern:**
- ✅ PostHog initialized in `main.tsx` with env vars (build-time credentials)
- ✅ `<PostHogProvider client={posthog}>` wraps app
- ✅ `usePostHog()` hook in components
- ✅ Backend provides `analytics_user_id` for correlation (runtime)
- ✅ No custom analytics module - using PostHog's official React integration
### What's Tracked
**Frontend Events:**
1. `preview_navigated` - User navigated to preview (properties: `trigger: "button"|"keyboard"`, optional `direction`, `source: "frontend"`, `timestamp`)
2. `diffs_navigated` - User navigated to diffs (same properties)
3. `view_closed` - User closed preview/diffs (properties: `trigger: "button"`, `from_view`, `source`, `timestamp`)
4. `Web vitals` - Automatic performance metrics (LCP, FID, CLS, TTFB, FCP)
5. `$pageleave` - Automatic session end tracking
**Backend Events (already existed):**
- All events with `source: "backend"` property
- `project_created` with `trigger: "manual"|"github"|"auto_setup"`
- `task_created`, `task_attempt_started`, `pr_merged`, etc.
### Key Design Decisions
✅ **No `app_loaded` event** - Redundant (version, theme, language tracked elsewhere)
✅ **No autocapture** - Manual events only (no "clicked svg" noise)
✅ **No custom queue** - Trust PostHog's built-in queue
✅ **No `AnalyticsInfo` struct** - Flat `analytics_user_id` field
✅ **No `VITE_` prefix** - Clean env var names
✅ **No useless comments** - Code speaks for itself
✅ **PostHog Provider pattern** - Following official React best practices
✅ **Build-time credentials** - Env vars (safe - write-only keys)
✅ **Runtime user ID** - From backend for correlation
✅ **Dynamic opt-in/opt-out** - Via PostHog's `opt_in_capturing()` / `opt_out_capturing()`
### Files Changed (Complete List)
**Backend:**
1. `crates/services/src/services/analytics.rs` - Added `source: "backend"` to all events
2. `crates/server/src/routes/config.rs` - Changed to flat `analytics_user_id: String` field
3. `crates/server/src/routes/projects.rs` - Renamed `source` → `trigger`
4. `crates/server/src/routes/github.rs` - Renamed `source` → `trigger`
5. `crates/deployment/src/lib.rs` - Renamed `source` → `trigger`
6. `crates/server/src/bin/generate_types.rs` - Removed `AnalyticsInfo` struct generation
7. `shared/types.ts` - Auto-generated with flat field
**Frontend:**
8. `frontend/package.json` - Added `posthog-js` dependency
9. `frontend/vite.config.ts` - Added `define` block with env vars
10. `frontend/src/main.tsx` - Initialize PostHog, wrap with `PostHogProvider`
11. `frontend/src/App.tsx` - Handle opt-in/opt-out and identify user
12. `frontend/src/components/config-provider.tsx` - Expose `analyticsUserId`
13. `frontend/src/components/panels/AttemptHeaderActions.tsx` - Use `usePostHog()` hook
14. `frontend/src/pages/project-tasks.tsx` - Use `usePostHog()` hook
15. ~~`frontend/src/lib/analytics.ts`~~ - **DELETED** (no longer needed!)
### How To Use
**Add analytics to a component:**
```typescript
import { usePostHog } from 'posthog-js/react';
function MyComponent() {
const posthog = usePostHog();
const handleAction = () => {
posthog?.capture('my_event', {
property: 'value',
timestamp: new Date().toISOString(),
source: 'frontend',
});
};
}
```
### Environment Variables
**For development** (`crates/server/.env`):
```bash
POSTHOG_API_KEY=phc_your_key
POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
**For CI** (GitHub Actions secrets):
- `POSTHOG_API_KEY`
- `POSTHOG_API_ENDPOINT`
### PostHog Correlation
**Frontend and backend events share the same `distinct_id`:**
```
User: npm_user_abc123def456789
Timeline:
- preview_navigated (source: frontend, trigger: button)
- task_created (source: backend, trigger: manual)
- diffs_navigated (source: frontend, trigger: keyboard)
- task_attempt_started (s...
* Perfect! Let me create a final summary:
---
**Switched from manual `define` to Vite's automatic `.env` loading:**
**Before:**
```typescript
// vite.config.ts
define: {
'import.meta.env.POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
}
// main.tsx
posthog.init(import.meta.env.POSTHOG_API_KEY, { ... });
```
**After:**
```typescript
// vite.config.ts
// NO define block needed!
// main.tsx
posthog.init(import.meta.env.VITE_POSTHOG_API_KEY, { ... });
```
**1. `frontend/vite.config.ts`:**
```diff
- define: {
- 'import.meta.env.POSTHOG_API_KEY': JSON.stringify(process.env.POSTHOG_API_KEY || ''),
- 'import.meta.env.POSTHOG_API_ENDPOINT': JSON.stringify(process.env.POSTHOG_API_ENDPOINT || ''),
- },
```
**2. `frontend/src/main.tsx`:**
```diff
- if (import.meta.env.POSTHOG_API_KEY && import.meta.env.POSTHOG_API_ENDPOINT) {
- posthog.init(import.meta.env.POSTHOG_API_KEY, {
- api_host: import.meta.env.POSTHOG_API_ENDPOINT,
+ if (import.meta.env.VITE_POSTHOG_API_KEY && import.meta.env.VITE_POSTHOG_API_ENDPOINT) {
+ posthog.init(import.meta.env.VITE_POSTHOG_API_KEY, {
+ api_host: import.meta.env.VITE_POSTHOG_API_ENDPOINT,
```
**3. `.github/workflows/pre-release.yml`:**
```diff
- name: Build frontend
run: cd frontend && npm run build
env:
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+ VITE_POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }}
+ VITE_POSTHOG_API_ENDPOINT: ${{ secrets.POSTHOG_API_ENDPOINT }}
```
**Development:**
**Your `.env` file needs `VITE_` prefix:**
You can add to your existing `crates/server/.env`:
```bash
POSTHOG_API_KEY=phc_xxx
POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
VITE_POSTHOG_API_KEY=phc_xxx
VITE_POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
**OR create `frontend/.env.local` (cleaner):**
```bash
VITE_POSTHOG_API_KEY=phc_xxx
VITE_POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
**Vite automatically:**
1. Loads `.env` files from frontend directory
2. Exposes vars starting with `VITE_` as `import.meta.env.VITE_*`
3. Injects them at build time
**Production (CI):**
- GitHub Actions passes `VITE_POSTHOG_API_KEY` and `VITE_POSTHOG_API_ENDPOINT` env vars
- Vite picks them up and injects into build
- Works the same way ✅
✅ **Standard Vite pattern** - Using Vite's automatic .env loading (recommended way)
✅ **No manual `define`** - Vite handles it automatically
✅ **Clear naming** - `VITE_` prefix shows these are frontend vars
✅ **Documented** - This is how Vite docs say to do it
**For local development, add to your `.env` file:**
```bash
VITE_POSTHOG_API_KEY=phc_tUHOX3YsGW4d9cEKyIvxjrFDHTRQ8nCfzG65McGZEuC
VITE_POSTHOG_API_ENDPOINT=https://eu.i.posthog.com
```
**Where to add it:**
- Option A: `crates/server/.env` (duplicates vars with VITE_ prefix)
- Option B: `frontend/.env.local` (separate file, cleaner)
- Option C: Root `.env` file (Vite checks project root too)
**That's it!** Vite will automatically load and expose them.
**Clean, standard Vite approach!** 🚀
This commit is contained in:
Alex Netsch
GitHub
2
.github/workflows/pre-release.yml
vendored
2
.github/workflows/pre-release.yml
vendored
@@ -143,6 +143,8 @@ jobs:
|
|||||||
run: cd frontend && npm run build
|
run: cd frontend && npm run build
|
||||||
env:
|
env:
|
||||||
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
|
SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
|
||||||
|
VITE_POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }}
|
||||||
|
VITE_POSTHOG_API_ENDPOINT: ${{ secrets.POSTHOG_API_ENDPOINT }}
|
||||||
|
|
||||||
- name: Create Sentry release
|
- name: Create Sentry release
|
||||||
uses: getsentry/action-release@v3
|
uses: getsentry/action-release@v3
|
||||||
|
|||||||
@@ -304,7 +304,7 @@ pub trait Deployment: Clone + Send + Sync + 'static {
|
|||||||
"use_existing_repo": create_data.use_existing_repo,
|
"use_existing_repo": create_data.use_existing_repo,
|
||||||
"has_setup_script": create_data.setup_script.is_some(),
|
"has_setup_script": create_data.setup_script.is_some(),
|
||||||
"has_dev_script": create_data.dev_script.is_some(),
|
"has_dev_script": create_data.dev_script.is_some(),
|
||||||
"source": "auto_setup",
|
"trigger": "auto_setup",
|
||||||
}),
|
}),
|
||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
|||||||
@@ -61,6 +61,7 @@ impl Environment {
|
|||||||
#[derive(Debug, Serialize, Deserialize, TS)]
|
#[derive(Debug, Serialize, Deserialize, TS)]
|
||||||
pub struct UserSystemInfo {
|
pub struct UserSystemInfo {
|
||||||
pub config: Config,
|
pub config: Config,
|
||||||
|
pub analytics_user_id: String,
|
||||||
#[serde(flatten)]
|
#[serde(flatten)]
|
||||||
pub profiles: ExecutorConfigs,
|
pub profiles: ExecutorConfigs,
|
||||||
pub environment: Environment,
|
pub environment: Environment,
|
||||||
@@ -77,6 +78,7 @@ async fn get_user_system_info(
|
|||||||
|
|
||||||
let user_system_info = UserSystemInfo {
|
let user_system_info = UserSystemInfo {
|
||||||
config: config.clone(),
|
config: config.clone(),
|
||||||
|
analytics_user_id: deployment.user_id().to_string(),
|
||||||
profiles: ExecutorConfigs::get_cached(),
|
profiles: ExecutorConfigs::get_cached(),
|
||||||
environment: Environment::new(),
|
environment: Environment::new(),
|
||||||
capabilities: {
|
capabilities: {
|
||||||
|
|||||||
@@ -182,7 +182,7 @@ pub async fn create_project_from_github(
|
|||||||
"clone_url": payload.clone_url,
|
"clone_url": payload.clone_url,
|
||||||
"has_setup_script": has_setup_script,
|
"has_setup_script": has_setup_script,
|
||||||
"has_dev_script": has_dev_script,
|
"has_dev_script": has_dev_script,
|
||||||
"source": "github",
|
"trigger": "github",
|
||||||
})),
|
})),
|
||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
|||||||
@@ -158,7 +158,7 @@ pub async fn create_project(
|
|||||||
"use_existing_repo": use_existing_repo,
|
"use_existing_repo": use_existing_repo,
|
||||||
"has_setup_script": project.setup_script.is_some(),
|
"has_setup_script": project.setup_script.is_some(),
|
||||||
"has_dev_script": project.dev_script.is_some(),
|
"has_dev_script": project.dev_script.is_some(),
|
||||||
"source": "manual",
|
"trigger": "manual",
|
||||||
}),
|
}),
|
||||||
)
|
)
|
||||||
.await;
|
.await;
|
||||||
|
|||||||
@@ -77,6 +77,7 @@ impl AnalyticsService {
|
|||||||
);
|
);
|
||||||
props.insert("version".to_string(), json!(env!("CARGO_PKG_VERSION")));
|
props.insert("version".to_string(), json!(env!("CARGO_PKG_VERSION")));
|
||||||
props.insert("device".to_string(), get_device_info());
|
props.insert("device".to_string(), get_device_info());
|
||||||
|
props.insert("source".to_string(), json!("backend"));
|
||||||
}
|
}
|
||||||
payload["properties"] = event_properties;
|
payload["properties"] = event_properties;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -54,6 +54,7 @@
|
|||||||
"lexical": "^0.36.2",
|
"lexical": "^0.36.2",
|
||||||
"lucide-react": "^0.539.0",
|
"lucide-react": "^0.539.0",
|
||||||
"markdown-to-jsx": "^7.7.13",
|
"markdown-to-jsx": "^7.7.13",
|
||||||
|
"posthog-js": "^1.276.0",
|
||||||
"react": "^18.2.0",
|
"react": "^18.2.0",
|
||||||
"react-dom": "^18.2.0",
|
"react-dom": "^18.2.0",
|
||||||
"react-hotkeys-hook": "^5.1.0",
|
"react-hotkeys-hook": "^5.1.0",
|
||||||
|
|||||||
@@ -5,6 +5,7 @@ import i18n from '@/i18n';
|
|||||||
import { Projects } from '@/pages/projects';
|
import { Projects } from '@/pages/projects';
|
||||||
import { ProjectTasks } from '@/pages/project-tasks';
|
import { ProjectTasks } from '@/pages/project-tasks';
|
||||||
import { NormalLayout } from '@/components/layout/NormalLayout';
|
import { NormalLayout } from '@/components/layout/NormalLayout';
|
||||||
|
import { usePostHog } from 'posthog-js/react';
|
||||||
|
|
||||||
import {
|
import {
|
||||||
AgentSettings,
|
AgentSettings,
|
||||||
@@ -37,7 +38,25 @@ import { ClickedElementsProvider } from './contexts/ClickedElementsProvider';
|
|||||||
const SentryRoutes = Sentry.withSentryReactRouterV6Routing(Routes);
|
const SentryRoutes = Sentry.withSentryReactRouterV6Routing(Routes);
|
||||||
|
|
||||||
function AppContent() {
|
function AppContent() {
|
||||||
const { config, updateAndSaveConfig, loading } = useUserSystem();
|
const { config, analyticsUserId, updateAndSaveConfig, loading } =
|
||||||
|
useUserSystem();
|
||||||
|
const posthog = usePostHog();
|
||||||
|
|
||||||
|
// Handle opt-in/opt-out and user identification when config loads
|
||||||
|
useEffect(() => {
|
||||||
|
if (!posthog || !analyticsUserId) return;
|
||||||
|
|
||||||
|
const userOptedIn = config?.analytics_enabled !== false;
|
||||||
|
|
||||||
|
if (userOptedIn) {
|
||||||
|
posthog.opt_in_capturing();
|
||||||
|
posthog.identify(analyticsUserId);
|
||||||
|
console.log('[Analytics] Analytics enabled and user identified');
|
||||||
|
} else {
|
||||||
|
posthog.opt_out_capturing();
|
||||||
|
console.log('[Analytics] Analytics disabled by user preference');
|
||||||
|
}
|
||||||
|
}, [config?.analytics_enabled, analyticsUserId, posthog]);
|
||||||
|
|
||||||
useEffect(() => {
|
useEffect(() => {
|
||||||
let cancelled = false;
|
let cancelled = false;
|
||||||
|
|||||||
@@ -23,6 +23,7 @@ interface UserSystemState {
|
|||||||
environment: Environment | null;
|
environment: Environment | null;
|
||||||
profiles: Record<string, ExecutorConfig> | null;
|
profiles: Record<string, ExecutorConfig> | null;
|
||||||
capabilities: Record<string, BaseAgentCapability[]> | null;
|
capabilities: Record<string, BaseAgentCapability[]> | null;
|
||||||
|
analyticsUserId: string | null;
|
||||||
}
|
}
|
||||||
|
|
||||||
interface UserSystemContextType {
|
interface UserSystemContextType {
|
||||||
@@ -39,6 +40,7 @@ interface UserSystemContextType {
|
|||||||
environment: Environment | null;
|
environment: Environment | null;
|
||||||
profiles: Record<string, ExecutorConfig> | null;
|
profiles: Record<string, ExecutorConfig> | null;
|
||||||
capabilities: Record<string, BaseAgentCapability[]> | null;
|
capabilities: Record<string, BaseAgentCapability[]> | null;
|
||||||
|
analyticsUserId: string | null;
|
||||||
setEnvironment: (env: Environment | null) => void;
|
setEnvironment: (env: Environment | null) => void;
|
||||||
setProfiles: (profiles: Record<string, ExecutorConfig> | null) => void;
|
setProfiles: (profiles: Record<string, ExecutorConfig> | null) => void;
|
||||||
setCapabilities: (caps: Record<string, BaseAgentCapability[]> | null) => void;
|
setCapabilities: (caps: Record<string, BaseAgentCapability[]> | null) => void;
|
||||||
@@ -71,6 +73,7 @@ export function UserSystemProvider({ children }: UserSystemProviderProps) {
|
|||||||
string,
|
string,
|
||||||
BaseAgentCapability[]
|
BaseAgentCapability[]
|
||||||
> | null>(null);
|
> | null>(null);
|
||||||
|
const [analyticsUserId, setAnalyticsUserId] = useState<string | null>(null);
|
||||||
const [loading, setLoading] = useState(true);
|
const [loading, setLoading] = useState(true);
|
||||||
const [githubTokenInvalid, setGithubTokenInvalid] = useState(false);
|
const [githubTokenInvalid, setGithubTokenInvalid] = useState(false);
|
||||||
|
|
||||||
@@ -80,6 +83,7 @@ export function UserSystemProvider({ children }: UserSystemProviderProps) {
|
|||||||
const userSystemInfo: UserSystemInfo = await configApi.getConfig();
|
const userSystemInfo: UserSystemInfo = await configApi.getConfig();
|
||||||
setConfig(userSystemInfo.config);
|
setConfig(userSystemInfo.config);
|
||||||
setEnvironment(userSystemInfo.environment);
|
setEnvironment(userSystemInfo.environment);
|
||||||
|
setAnalyticsUserId(userSystemInfo.analytics_user_id);
|
||||||
setProfiles(
|
setProfiles(
|
||||||
userSystemInfo.executors as Record<string, ExecutorConfig> | null
|
userSystemInfo.executors as Record<string, ExecutorConfig> | null
|
||||||
);
|
);
|
||||||
@@ -168,6 +172,7 @@ export function UserSystemProvider({ children }: UserSystemProviderProps) {
|
|||||||
const userSystemInfo: UserSystemInfo = await configApi.getConfig();
|
const userSystemInfo: UserSystemInfo = await configApi.getConfig();
|
||||||
setConfig(userSystemInfo.config);
|
setConfig(userSystemInfo.config);
|
||||||
setEnvironment(userSystemInfo.environment);
|
setEnvironment(userSystemInfo.environment);
|
||||||
|
setAnalyticsUserId(userSystemInfo.analytics_user_id);
|
||||||
setProfiles(
|
setProfiles(
|
||||||
userSystemInfo.executors as Record<string, ExecutorConfig> | null
|
userSystemInfo.executors as Record<string, ExecutorConfig> | null
|
||||||
);
|
);
|
||||||
@@ -185,11 +190,12 @@ export function UserSystemProvider({ children }: UserSystemProviderProps) {
|
|||||||
// Memoize context value to prevent unnecessary re-renders
|
// Memoize context value to prevent unnecessary re-renders
|
||||||
const value = useMemo<UserSystemContextType>(
|
const value = useMemo<UserSystemContextType>(
|
||||||
() => ({
|
() => ({
|
||||||
system: { config, environment, profiles, capabilities },
|
system: { config, environment, profiles, capabilities, analyticsUserId },
|
||||||
config,
|
config,
|
||||||
environment,
|
environment,
|
||||||
profiles,
|
profiles,
|
||||||
capabilities,
|
capabilities,
|
||||||
|
analyticsUserId,
|
||||||
updateConfig,
|
updateConfig,
|
||||||
saveConfig,
|
saveConfig,
|
||||||
updateAndSaveConfig,
|
updateAndSaveConfig,
|
||||||
@@ -205,6 +211,7 @@ export function UserSystemProvider({ children }: UserSystemProviderProps) {
|
|||||||
environment,
|
environment,
|
||||||
profiles,
|
profiles,
|
||||||
capabilities,
|
capabilities,
|
||||||
|
analyticsUserId,
|
||||||
updateConfig,
|
updateConfig,
|
||||||
saveConfig,
|
saveConfig,
|
||||||
updateAndSaveConfig,
|
updateAndSaveConfig,
|
||||||
|
|||||||
@@ -11,6 +11,7 @@ import {
|
|||||||
import type { LayoutMode } from '../layout/TasksLayout';
|
import type { LayoutMode } from '../layout/TasksLayout';
|
||||||
import type { TaskAttempt, TaskWithAttemptStatus } from 'shared/types';
|
import type { TaskAttempt, TaskWithAttemptStatus } from 'shared/types';
|
||||||
import { ActionsDropdown } from '../ui/ActionsDropdown';
|
import { ActionsDropdown } from '../ui/ActionsDropdown';
|
||||||
|
import { usePostHog } from 'posthog-js/react';
|
||||||
|
|
||||||
interface AttemptHeaderActionsProps {
|
interface AttemptHeaderActionsProps {
|
||||||
onClose: () => void;
|
onClose: () => void;
|
||||||
@@ -28,6 +29,8 @@ export const AttemptHeaderActions = ({
|
|||||||
attempt,
|
attempt,
|
||||||
}: AttemptHeaderActionsProps) => {
|
}: AttemptHeaderActionsProps) => {
|
||||||
const { t } = useTranslation('tasks');
|
const { t } = useTranslation('tasks');
|
||||||
|
const posthog = usePostHog();
|
||||||
|
|
||||||
return (
|
return (
|
||||||
<>
|
<>
|
||||||
{typeof mode !== 'undefined' && onModeChange && (
|
{typeof mode !== 'undefined' && onModeChange && (
|
||||||
@@ -35,7 +38,34 @@ export const AttemptHeaderActions = ({
|
|||||||
<ToggleGroup
|
<ToggleGroup
|
||||||
type="single"
|
type="single"
|
||||||
value={mode ?? ''}
|
value={mode ?? ''}
|
||||||
onValueChange={(v) => onModeChange((v as LayoutMode) || null)}
|
onValueChange={(v) => {
|
||||||
|
const newMode = (v as LayoutMode) || null;
|
||||||
|
|
||||||
|
// Track view navigation
|
||||||
|
if (newMode === 'preview') {
|
||||||
|
posthog?.capture('preview_navigated', {
|
||||||
|
trigger: 'button',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
} else if (newMode === 'diffs') {
|
||||||
|
posthog?.capture('diffs_navigated', {
|
||||||
|
trigger: 'button',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
} else if (newMode === null) {
|
||||||
|
// Closing the view (clicked active button)
|
||||||
|
posthog?.capture('view_closed', {
|
||||||
|
trigger: 'button',
|
||||||
|
from_view: mode ?? 'attempt',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
onModeChange(newMode);
|
||||||
|
}}
|
||||||
className="inline-flex gap-4"
|
className="inline-flex gap-4"
|
||||||
aria-label="Layout mode"
|
aria-label="Layout mode"
|
||||||
>
|
>
|
||||||
|
|||||||
@@ -8,6 +8,8 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
|
|||||||
import * as Sentry from '@sentry/react';
|
import * as Sentry from '@sentry/react';
|
||||||
import NiceModal from '@ebay/nice-modal-react';
|
import NiceModal from '@ebay/nice-modal-react';
|
||||||
import i18n from './i18n';
|
import i18n from './i18n';
|
||||||
|
import posthog from 'posthog-js';
|
||||||
|
import { PostHogProvider } from 'posthog-js/react';
|
||||||
// Import modal type definitions
|
// Import modal type definitions
|
||||||
import './types/modals';
|
import './types/modals';
|
||||||
// Import and register modals
|
// Import and register modals
|
||||||
@@ -85,6 +87,24 @@ Sentry.init({
|
|||||||
});
|
});
|
||||||
Sentry.setTag('source', 'frontend');
|
Sentry.setTag('source', 'frontend');
|
||||||
|
|
||||||
|
if (
|
||||||
|
import.meta.env.VITE_POSTHOG_API_KEY &&
|
||||||
|
import.meta.env.VITE_POSTHOG_API_ENDPOINT
|
||||||
|
) {
|
||||||
|
posthog.init(import.meta.env.VITE_POSTHOG_API_KEY, {
|
||||||
|
api_host: import.meta.env.VITE_POSTHOG_API_ENDPOINT,
|
||||||
|
capture_pageview: false,
|
||||||
|
capture_pageleave: true,
|
||||||
|
capture_performance: true,
|
||||||
|
autocapture: false,
|
||||||
|
opt_out_capturing_by_default: true,
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
console.warn(
|
||||||
|
'PostHog API key or endpoint not set. Analytics will be disabled.'
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
const queryClient = new QueryClient({
|
const queryClient = new QueryClient({
|
||||||
defaultOptions: {
|
defaultOptions: {
|
||||||
queries: {
|
queries: {
|
||||||
@@ -97,6 +117,7 @@ const queryClient = new QueryClient({
|
|||||||
ReactDOM.createRoot(document.getElementById('root')!).render(
|
ReactDOM.createRoot(document.getElementById('root')!).render(
|
||||||
<React.StrictMode>
|
<React.StrictMode>
|
||||||
<QueryClientProvider client={queryClient}>
|
<QueryClientProvider client={queryClient}>
|
||||||
|
<PostHogProvider client={posthog}>
|
||||||
<Sentry.ErrorBoundary
|
<Sentry.ErrorBoundary
|
||||||
fallback={<p>{i18n.t('common:states.error')}</p>}
|
fallback={<p>{i18n.t('common:states.error')}</p>}
|
||||||
showDialog
|
showDialog
|
||||||
@@ -106,6 +127,7 @@ ReactDOM.createRoot(document.getElementById('root')!).render(
|
|||||||
<App />
|
<App />
|
||||||
{/* <ReactQueryDevtools initialIsOpen={false} /> */}
|
{/* <ReactQueryDevtools initialIsOpen={false} /> */}
|
||||||
</Sentry.ErrorBoundary>
|
</Sentry.ErrorBoundary>
|
||||||
|
</PostHogProvider>
|
||||||
</QueryClientProvider>
|
</QueryClientProvider>
|
||||||
</React.StrictMode>
|
</React.StrictMode>
|
||||||
);
|
);
|
||||||
|
|||||||
@@ -11,6 +11,7 @@ import { openTaskForm } from '@/lib/openTaskForm';
|
|||||||
import { FeatureShowcaseModal } from '@/components/showcase/FeatureShowcaseModal';
|
import { FeatureShowcaseModal } from '@/components/showcase/FeatureShowcaseModal';
|
||||||
import { showcases } from '@/config/showcases';
|
import { showcases } from '@/config/showcases';
|
||||||
import { useShowcaseTrigger } from '@/hooks/useShowcaseTrigger';
|
import { useShowcaseTrigger } from '@/hooks/useShowcaseTrigger';
|
||||||
|
import { usePostHog } from 'posthog-js/react';
|
||||||
|
|
||||||
import { useSearch } from '@/contexts/search-context';
|
import { useSearch } from '@/contexts/search-context';
|
||||||
import { useProject } from '@/contexts/project-context';
|
import { useProject } from '@/contexts/project-context';
|
||||||
@@ -120,6 +121,7 @@ export function ProjectTasks() {
|
|||||||
const [searchParams, setSearchParams] = useSearchParams();
|
const [searchParams, setSearchParams] = useSearchParams();
|
||||||
const isXL = useMediaQuery('(min-width: 1280px)');
|
const isXL = useMediaQuery('(min-width: 1280px)');
|
||||||
const isMobile = !isXL;
|
const isMobile = !isXL;
|
||||||
|
const posthog = usePostHog();
|
||||||
|
|
||||||
const {
|
const {
|
||||||
projectId,
|
projectId,
|
||||||
@@ -388,6 +390,27 @@ export function ProjectTasks() {
|
|||||||
useKeyOpenDetails(
|
useKeyOpenDetails(
|
||||||
() => {
|
() => {
|
||||||
if (isPanelOpen) {
|
if (isPanelOpen) {
|
||||||
|
// Track keyboard shortcut before cycling view
|
||||||
|
const order: LayoutMode[] = [null, 'preview', 'diffs'];
|
||||||
|
const idx = order.indexOf(mode);
|
||||||
|
const next = order[(idx + 1) % order.length];
|
||||||
|
|
||||||
|
if (next === 'preview') {
|
||||||
|
posthog?.capture('preview_navigated', {
|
||||||
|
trigger: 'keyboard',
|
||||||
|
direction: 'forward',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
} else if (next === 'diffs') {
|
||||||
|
posthog?.capture('diffs_navigated', {
|
||||||
|
trigger: 'keyboard',
|
||||||
|
direction: 'forward',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
cycleViewForward();
|
cycleViewForward();
|
||||||
} else if (selectedTask) {
|
} else if (selectedTask) {
|
||||||
handleViewTaskDetails(selectedTask);
|
handleViewTaskDetails(selectedTask);
|
||||||
@@ -400,6 +423,27 @@ export function ProjectTasks() {
|
|||||||
useKeyCycleViewBackward(
|
useKeyCycleViewBackward(
|
||||||
() => {
|
() => {
|
||||||
if (isPanelOpen) {
|
if (isPanelOpen) {
|
||||||
|
// Track keyboard shortcut before cycling view
|
||||||
|
const order: LayoutMode[] = [null, 'preview', 'diffs'];
|
||||||
|
const idx = order.indexOf(mode);
|
||||||
|
const next = order[(idx - 1 + order.length) % order.length];
|
||||||
|
|
||||||
|
if (next === 'preview') {
|
||||||
|
posthog?.capture('preview_navigated', {
|
||||||
|
trigger: 'keyboard',
|
||||||
|
direction: 'backward',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
} else if (next === 'diffs') {
|
||||||
|
posthog?.capture('diffs_navigated', {
|
||||||
|
trigger: 'keyboard',
|
||||||
|
direction: 'backward',
|
||||||
|
timestamp: new Date().toISOString(),
|
||||||
|
source: 'frontend',
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
cycleViewBackward();
|
cycleViewBackward();
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
|
|||||||
@@ -58,7 +58,7 @@ export type CreateImage = { file_path: string, original_name: string, mime_type:
|
|||||||
|
|
||||||
export type ApiResponse<T, E = T> = { success: boolean, data: T | null, error_data: E | null, message: string | null, };
|
export type ApiResponse<T, E = T> = { success: boolean, data: T | null, error_data: E | null, message: string | null, };
|
||||||
|
|
||||||
export type UserSystemInfo = { config: Config, environment: Environment,
|
export type UserSystemInfo = { config: Config, analytics_user_id: string, environment: Environment,
|
||||||
/**
|
/**
|
||||||
* Capabilities supported per executor (e.g., { "CLAUDE_CODE": ["SESSION_FORK"] })
|
* Capabilities supported per executor (e.g., { "CLAUDE_CODE": ["SESSION_FORK"] })
|
||||||
*/
|
*/
|
||||||
|
|||||||
Reference in New Issue
Block a user