grov 0.2.3 → 0.5.3

package/README.md

@@ -14,8 +14,9 @@
 
 <p align="center">
   <a href="https://grov.dev">Website</a> •
+  <a href="https://app.grov.dev">Dashboard</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#advanced-features">Advanced</a> •
+  <a href="#team-sync">Team Sync</a> •
   <a href="#contributing">Contributing</a>
 </p>
 
@@ -35,7 +36,7 @@ Every time you start a new Claude Code session:
 
 Grov captures what Claude learns and injects it back on the next session.
 
-![grov status](docs/grov-status.jpeg)
+![grov demo](demo-converted.gif)
 
 ### What Gets Captured
 
@@ -77,6 +78,8 @@ grov init         # Configure proxy URL (one-time)
 grov proxy        # Start the proxy (required)
 grov proxy-status # Show active sessions
 grov status       # Show captured tasks
+grov login        # Login to cloud dashboard
+grov sync         # Sync memories to team dashboard
 grov disable      # Disable grov
 ```
 
@@ -84,7 +87,24 @@ grov disable      # Disable grov
 
 - **Database:** `~/.grov/memory.db` (SQLite)
 - **Per-project:** Context is filtered by project path
-- **Local only:** Nothing leaves your machine
+- **Local by default:** Memories stay on your machine unless you enable team sync
+
+## Team Sync
+
+Share memories across your engineering team with the cloud dashboard.
+
+```bash
+grov login                    # Authenticate via GitHub
+grov sync --enable --team ID  # Enable sync for a team
+```
+
+Once enabled, memories automatically sync to [app.grov.dev](https://app.grov.dev) where your team can:
+- Browse all captured reasoning
+- Search across sessions
+- Invite team members
+- See who learned what
+
+Memories sync automatically when sessions complete - no manual intervention needed.
 
 ## Requirements
 
@@ -109,6 +129,24 @@ Grov monitors what Claude **does** (not what you ask) and corrects if it drifts
 grov drift-test "refactor the auth system" --goal "fix login bug"
 ```
 
+### Extended Cache (Experimental)
+
+Anthropic's prompt cache expires after 5 minutes of inactivity. If you pause to think between prompts, the cache expires and must be recreated (costs more, takes longer).
+
+```bash
+grov proxy --extended-cache
+```
+
+**What this does:** Sends minimal keep-alive requests (~$0.002 each) during idle periods to preserve your cache.
+
+**Important:** By using `--extended-cache`, you consent to Grov making API requests on your behalf to keep the cache active. These requests:
+- Use your Anthropic API key
+- Are sent automatically during idle periods (every ~4 minutes)
+- Cost approximately $0.002 per keep-alive
+- Are discarded (not added to your conversation)
+
+This feature is **disabled by default** and requires explicit opt-in.
+
 ### Environment Variables
 
 ```bash
@@ -169,9 +207,10 @@ YOU MAY SKIP EXPLORE AGENTS for files mentioned above.
 - [x] LLM-powered extraction
 - [x] Local proxy with real-time monitoring
 - [x] Anti-drift detection & correction
-- [ ] Team sync (cloud backend)
-- [ ] Web dashboard
+- [x] Team sync (cloud backend)
+- [x] Web dashboard
 - [ ] Semantic search
+- [ ] VS Code extension
 
 ## Contributing
 

package/dist/cli.js

@@ -77,9 +77,18 @@ program
 program
     .command('proxy')
     .description('Start the Grov proxy server (intercepts Claude API calls)')
-    .action(async () => {
+    .option('-d, --debug', 'Enable debug logging to grov-proxy.log')
+    .option('--extended-cache', 'Keep Anthropic cache alive during idle (sends requests on your behalf)')
+    .action(async (options) => {
+    if (options.extendedCache) {
+        process.env.GROV_EXTENDED_CACHE = 'true';
+        console.log('\n⚠️  Extended Cache Enabled');
+        console.log('   By using --extended-cache, you consent to Grov making');
+        console.log('   minimal keep-alive requests on your behalf to preserve');
+        console.log('   Anthropic\'s prompt cache during idle periods.\n');
+    }
     const { startServer } = await import('./proxy/server.js');
-    await startServer();
+    await startServer({ debug: options.debug ?? false });
 });
 // grov proxy-status - Show active proxy sessions
 program
@@ -89,4 +98,33 @@ program
     const { proxyStatus } = await import('./commands/proxy-status.js');
     await proxyStatus();
 }));
+// grov login - Authenticate with Grov cloud
+program
+    .command('login')
+    .description('Login to Grov cloud (opens browser for authentication)')
+    .action(safeAction(async () => {
+    const { login } = await import('./commands/login.js');
+    await login();
+}));
+// grov logout - Clear stored credentials
+program
+    .command('logout')
+    .description('Logout from Grov cloud')
+    .action(safeAction(async () => {
+    const { logout } = await import('./commands/logout.js');
+    await logout();
+}));
+// grov sync - Configure cloud sync
+program
+    .command('sync')
+    .description('Configure cloud sync to team dashboard')
+    .option('--enable', 'Enable cloud sync')
+    .option('--disable', 'Disable cloud sync')
+    .option('--team <id>', 'Set team ID for sync')
+    .option('--status', 'Show sync status')
+    .option('--push', 'Upload any unsynced local tasks to the team')
+    .action(safeAction(async (options) => {
+    const { sync } = await import('./commands/sync.js');
+    await sync(options);
+}));
 program.parse();

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function login(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,115 @@
+// Login command - Device authorization flow
+// Authenticates CLI with Grov cloud using OAuth-like device flow
+import open from 'open';
+import { writeCredentials, isAuthenticated, readCredentials } from '../lib/credentials.js';
+import { startDeviceFlow, pollDeviceFlow, sleep } from '../lib/api-client.js';
+/**
+ * Decode JWT payload to extract user info
+ */
+function decodeTokenPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        return {
+            sub: payload.sub,
+            email: payload.email,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function login() {
+    console.log('Logging in to Grov cloud...\n');
+    // Check if already authenticated
+    if (isAuthenticated()) {
+        const creds = readCredentials();
+        if (creds) {
+            console.log(`Already logged in as ${creds.email}`);
+            console.log('Run "grov logout" to log out first.\n');
+            return;
+        }
+    }
+    // Start device flow
+    console.log('Starting device authorization...');
+    const startResult = await startDeviceFlow();
+    if (startResult.error || !startResult.data) {
+        console.error(`\nError: ${startResult.error || 'Failed to start login flow'}`);
+        console.error('Please check your network connection and try again.');
+        process.exit(1);
+    }
+    const { device_code, user_code, verification_uri, expires_in, interval } = startResult.data;
+    // Display code to user
+    console.log('\n┌─────────────────────────────────────────┐');
+    console.log('│                                         │');
+    console.log(`│  Your code:  ${user_code}               │`);
+    console.log('│                                         │');
+    console.log('└─────────────────────────────────────────┘\n');
+    console.log('Opening browser to authorize...');
+    console.log(`If browser does not open, visit: ${verification_uri}?code=${user_code}\n`);
+    // Open browser
+    try {
+        await open(`${verification_uri}?code=${user_code}`);
+    }
+    catch {
+        console.log('Could not open browser automatically.');
+        console.log(`Please visit: ${verification_uri}?code=${user_code}\n`);
+    }
+    // Poll for authorization
+    console.log('Waiting for authorization...');
+    const maxAttempts = Math.floor(expires_in / interval);
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        await sleep(interval * 1000);
+        attempts++;
+        const pollResult = await pollDeviceFlow(device_code);
+        if (pollResult.error) {
+            process.stdout.write('.');
+            continue;
+        }
+        if (!pollResult.data) {
+            process.stdout.write('.');
+            continue;
+        }
+        const { status, access_token, refresh_token, expires_at } = pollResult.data;
+        if (status === 'authorized' && access_token && refresh_token && expires_at) {
+            console.log('\n');
+            // Decode token to get user info
+            const userInfo = decodeTokenPayload(access_token);
+            if (!userInfo) {
+                console.error('Error: Failed to decode user info from token');
+                process.exit(1);
+            }
+            // Save credentials
+            writeCredentials({
+                access_token,
+                refresh_token,
+                expires_at,
+                user_id: userInfo.sub,
+                email: userInfo.email,
+                sync_enabled: false,
+            });
+            console.log('╔═════════════════════════════════════════╗');
+            console.log('║                                         ║');
+            console.log('║   Successfully logged in!               ║');
+            console.log('║                                         ║');
+            console.log('╚═════════════════════════════════════════╝');
+            console.log(`\nLogged in as: ${userInfo.email}\n`);
+            console.log('Next steps:');
+            console.log('  1. Run "grov sync --status" to check sync settings');
+            console.log('  2. Run "grov sync --enable --team <team-id>" to enable sync');
+            console.log('  3. Run "grov status" to view local memories\n');
+            return;
+        }
+        if (status === 'expired') {
+            console.log('\n\nAuthorization expired. Please run "grov login" again.\n');
+            process.exit(1);
+        }
+        // Still pending
+        process.stdout.write('.');
+    }
+    console.log('\n\nAuthorization timed out. Please run "grov login" again.\n');
+    process.exit(1);
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logout(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,13 @@
+// Logout command - Clear stored credentials
+import { clearCredentials, readCredentials } from '../lib/credentials.js';
+export async function logout() {
+    const creds = readCredentials();
+    if (!creds) {
+        console.log('Not currently logged in.\n');
+        return;
+    }
+    console.log(`Logging out ${creds.email}...`);
+    clearCredentials();
+    console.log('Successfully logged out.\n');
+    console.log('Run "grov login" to log in again.\n');
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,8 @@
+export interface SyncOptions {
+    enable?: boolean;
+    disable?: boolean;
+    team?: string;
+    status?: boolean;
+    push?: boolean;
+}
+export declare function sync(options: SyncOptions): Promise<void>;

package/dist/commands/sync.js

@@ -0,0 +1,127 @@
+// Sync command - Configure cloud sync settings
+import { readCredentials, setTeamId, setSyncEnabled, getSyncStatus } from '../lib/credentials.js';
+import { fetchTeams, getApiUrl } from '../lib/api-client.js';
+import { syncTasks } from '../lib/cloud-sync.js';
+import { getUnsyncedTasks, markTaskSynced, setTaskSyncError } from '../lib/store.js';
+export async function sync(options) {
+    const creds = readCredentials();
+    if (!creds) {
+        console.log('Not logged in. Run "grov login" first.\n');
+        process.exit(1);
+    }
+    // Manual catch-up: push unsynced tasks for current project
+    if (options.push) {
+        const projectPath = process.cwd();
+        const unsynced = getUnsyncedTasks(projectPath);
+        const apiUrl = getApiUrl();
+        if (unsynced.length === 0) {
+            console.log('No unsynced tasks found for this project.\n');
+            return;
+        }
+        console.log(`Syncing ${unsynced.length} pending task(s) to the cloud via ${apiUrl}...\n`);
+        const result = await syncTasks(unsynced);
+        if (result.syncedIds.length > 0) {
+            for (const id of result.syncedIds) {
+                markTaskSynced(id);
+            }
+        }
+        if (result.failedIds.length > 0) {
+            const errorMessage = result.errors[0] || 'Sync failed';
+            for (const id of result.failedIds) {
+                setTaskSyncError(id, errorMessage);
+            }
+        }
+        console.log(`Synced: ${result.synced}, Failed: ${result.failed}`);
+        if (result.errors.length > 0) {
+            console.log('Errors:');
+            for (const err of result.errors) {
+                console.log(`- ${err}`);
+            }
+        }
+        console.log('');
+        return;
+    }
+    // Show status
+    if (options.status || (!options.enable && !options.disable && !options.team)) {
+        const syncStatus = getSyncStatus();
+        console.log('Cloud Sync Status\n');
+        console.log(`  Logged in as: ${creds.email}`);
+        console.log(`  Sync enabled: ${syncStatus?.enabled ? 'Yes' : 'No'}`);
+        console.log(`  Team ID:      ${syncStatus?.teamId || 'Not set'}`);
+        console.log(`  API URL:      ${getApiUrl()}`);
+        console.log('');
+        if (!syncStatus?.enabled) {
+            console.log('To enable sync:');
+            console.log('  grov sync --enable --team <team-id>\n');
+            console.log('To see available teams:');
+            console.log('  grov sync --enable\n');
+        }
+        return;
+    }
+    // Disable sync
+    if (options.disable) {
+        setSyncEnabled(false);
+        console.log('Cloud sync disabled.\n');
+        console.log('Local memories will no longer be uploaded to your team.\n');
+        return;
+    }
+    // Enable sync
+    if (options.enable) {
+        // Check if team is specified
+        if (options.team) {
+            setTeamId(options.team);
+            setSyncEnabled(true);
+            console.log(`Cloud sync enabled for team: ${options.team}\n`);
+            console.log('Your memories will now be uploaded to your team dashboard.\n');
+            return;
+        }
+        // No team specified - show available teams
+        const currentStatus = getSyncStatus();
+        if (currentStatus?.teamId) {
+            // Team already set, just enable
+            setSyncEnabled(true);
+            console.log(`Cloud sync enabled for team: ${currentStatus.teamId}\n`);
+            console.log('Your memories will now be uploaded to your team dashboard.\n');
+            return;
+        }
+        // Need to select a team
+        console.log('Fetching your teams...\n');
+        try {
+            const teams = await fetchTeams();
+            if (teams.length === 0) {
+                console.log('You are not a member of any teams.\n');
+                console.log('Create a team at https://app.grov.dev or ask your team admin for an invite.\n');
+                return;
+            }
+            console.log('Available teams:\n');
+            console.log('  ID                                     Name');
+            console.log('  ─────────────────────────────────────  ────────────────────');
+            for (const team of teams) {
+                console.log(`  ${team.id}  ${team.name}`);
+            }
+            console.log('');
+            console.log('Enable sync with:');
+            console.log(`  grov sync --enable --team <team-id>\n`);
+            // If only one team, offer to use it
+            if (teams.length === 1) {
+                console.log(`Or, to use "${teams[0].name}":`);
+                console.log(`  grov sync --enable --team ${teams[0].id}\n`);
+            }
+        }
+        catch (err) {
+            console.error(`Error fetching teams: ${err instanceof Error ? err.message : 'Unknown error'}`);
+            console.error('Please check your network connection and try again.\n');
+            process.exit(1);
+        }
+        return;
+    }
+    // Just setting team (without enable flag)
+    if (options.team) {
+        setTeamId(options.team);
+        console.log(`Team ID set to: ${options.team}\n`);
+        const syncStatus = getSyncStatus();
+        if (!syncStatus?.enabled) {
+            console.log('Note: Sync is not enabled. Run "grov sync --enable" to start syncing.\n');
+        }
+    }
+}

package/dist/lib/api-client.d.ts

@@ -0,0 +1,57 @@
+import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse } from '@grov/shared';
+export interface ApiResponse<T> {
+    data?: T;
+    error?: string;
+    status: number;
+}
+/**
+ * Make an authenticated API request
+ */
+export declare function apiRequest<T>(method: 'GET' | 'POST' | 'PATCH' | 'DELETE', path: string, body?: unknown, options?: {
+    requireAuth?: boolean;
+}): Promise<ApiResponse<T>>;
+/**
+ * Start device authorization flow
+ */
+export declare function startDeviceFlow(): Promise<ApiResponse<DeviceFlowStartResponse>>;
+/**
+ * Poll for device authorization
+ */
+export declare function pollDeviceFlow(deviceCode: string): Promise<ApiResponse<DeviceFlowPollResponse>>;
+/**
+ * List user's teams
+ */
+export declare function fetchTeams(): Promise<Team[]>;
+/**
+ * Get team by ID
+ */
+export declare function fetchTeam(teamId: string): Promise<Team>;
+/**
+ * Sync memories to team
+ */
+export declare function syncMemories(teamId: string, request: MemorySyncRequest): Promise<MemorySyncResponse>;
+/**
+ * Fetch team memories from cloud (Supabase via API)
+ * Cloud equivalent of getTasksForProject() from store.ts
+ * Supports hybrid search when context is provided
+ *
+ * @param teamId - Team UUID
+ * @param projectPath - Project path to filter by (exact match)
+ * @param options - Optional filters (files, status, limit, context, current_files)
+ * @returns Array of memories (empty array on error - fail silent)
+ */
+export declare function fetchTeamMemories(teamId: string, projectPath: string, options?: {
+    files?: string[];
+    status?: string;
+    limit?: number;
+    context?: string;
+    current_files?: string[];
+}): Promise<Memory[]>;
+/**
+ * Sleep helper for polling
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Get API URL (for display)
+ */
+export declare function getApiUrl(): string;

package/dist/lib/api-client.js

@@ -0,0 +1,174 @@
+// HTTP client for Grov API calls
+// Handles authentication, retries, and error handling
+import { request } from 'undici';
+import { getAccessToken } from './credentials.js';
+// API configuration
+const API_URL = process.env.GROV_API_URL || 'https://api.grov.dev';
+/**
+ * Make an authenticated API request
+ */
+export async function apiRequest(method, path, body, options) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    // Add auth header if required (default: true)
+    if (options?.requireAuth !== false) {
+        const token = await getAccessToken();
+        if (!token) {
+            return {
+                error: 'Not authenticated. Please run: grov login',
+                status: 401,
+            };
+        }
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    try {
+        const response = await request(`${API_URL}${path}`, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const responseBody = await response.body.text();
+        // Handle empty responses
+        if (!responseBody) {
+            return {
+                data: undefined,
+                status: response.statusCode,
+            };
+        }
+        const data = JSON.parse(responseBody);
+        if (response.statusCode >= 400) {
+            return {
+                error: data.error || data.message || 'Request failed',
+                status: response.statusCode,
+            };
+        }
+        return {
+            data: data,
+            status: response.statusCode,
+        };
+    }
+    catch (err) {
+        return {
+            error: err instanceof Error ? err.message : 'Network error',
+            status: 0,
+        };
+    }
+}
+// ============= Auth Endpoints (no auth required) =============
+/**
+ * Start device authorization flow
+ */
+export async function startDeviceFlow() {
+    return apiRequest('POST', '/auth/device', {}, {
+        requireAuth: false,
+    });
+}
+/**
+ * Poll for device authorization
+ */
+export async function pollDeviceFlow(deviceCode) {
+    return apiRequest('POST', '/auth/device/poll', { device_code: deviceCode }, { requireAuth: false });
+}
+// ============= Team Endpoints =============
+/**
+ * List user's teams
+ */
+export async function fetchTeams() {
+    const response = await apiRequest('GET', '/teams');
+    if (response.error || !response.data) {
+        throw new Error(response.error || 'Failed to fetch teams');
+    }
+    return response.data.teams;
+}
+/**
+ * Get team by ID
+ */
+export async function fetchTeam(teamId) {
+    const response = await apiRequest('GET', `/teams/${teamId}`);
+    if (response.error || !response.data) {
+        throw new Error(response.error || 'Failed to fetch team');
+    }
+    return response.data;
+}
+// ============= Memory Endpoints =============
+/**
+ * Sync memories to team
+ */
+export async function syncMemories(teamId, request) {
+    const response = await apiRequest('POST', `/teams/${teamId}/memories/sync`, request);
+    if (response.error || !response.data) {
+        throw new Error(response.error || 'Failed to sync memories');
+    }
+    return response.data;
+}
+// Security limits for API params
+const MAX_CONTEXT_LENGTH = 2000; // Max chars for semantic search context
+const MAX_FILES_COUNT = 20; // Max files for boost/filter
+/**
+ * Fetch team memories from cloud (Supabase via API)
+ * Cloud equivalent of getTasksForProject() from store.ts
+ * Supports hybrid search when context is provided
+ *
+ * @param teamId - Team UUID
+ * @param projectPath - Project path to filter by (exact match)
+ * @param options - Optional filters (files, status, limit, context, current_files)
+ * @returns Array of memories (empty array on error - fail silent)
+ */
+export async function fetchTeamMemories(teamId, projectPath, options) {
+    // Build query params
+    const params = new URLSearchParams();
+    params.set('project_path', projectPath);
+    if (options?.status) {
+        params.set('status', options.status);
+    }
+    if (options?.limit) {
+        params.set('limit', options.limit.toString());
+    }
+    if (options?.files && options.files.length > 0) {
+        // API expects multiple 'files' params for array
+        options.files.slice(0, MAX_FILES_COUNT).forEach(f => params.append('files', f));
+    }
+    // Hybrid search params (with security limits)
+    if (options?.context) {
+        params.set('context', options.context.substring(0, MAX_CONTEXT_LENGTH));
+    }
+    if (options?.current_files && options.current_files.length > 0) {
+        // Comma-separated for current_files (boost)
+        const files = options.current_files.slice(0, MAX_FILES_COUNT);
+        params.set('current_files', files.join(','));
+    }
+    const url = `/teams/${teamId}/memories?${params.toString()}`;
+    console.log(`[API] fetchTeamMemories: GET ${url}`);
+    try {
+        const response = await apiRequest('GET', url);
+        if (response.error) {
+            console.warn(`[API] fetchTeamMemories failed: ${response.error} (status: ${response.status})`);
+            return []; // Fail silent - don't block Claude Code
+        }
+        if (!response.data || !response.data.memories) {
+            console.log('[API] fetchTeamMemories: No memories returned');
+            return [];
+        }
+        console.log(`[API] fetchTeamMemories: Got ${response.data.memories.length} memories`);
+        return response.data.memories;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[API] fetchTeamMemories exception: ${errorMsg}`);
+        return []; // Fail silent - don't block Claude Code
+    }
+}
+// ============= Utility Functions =============
+/**
+ * Sleep helper for polling
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Get API URL (for display)
+ */
+export function getApiUrl() {
+    return API_URL;
+}

package/dist/lib/cloud-sync.d.ts

@@ -0,0 +1,33 @@
+import type { CreateMemoryInput } from '@grov/shared';
+import type { Task } from './store.js';
+/**
+ * Convert local Task to CreateMemoryInput for API
+ */
+export declare function taskToMemory(task: Task): CreateMemoryInput;
+/**
+ * Check if sync is enabled and configured
+ */
+export declare function isSyncEnabled(): boolean;
+/**
+ * Get the configured team ID for sync
+ */
+export declare function getSyncTeamId(): string | null;
+/**
+ * Sync a single task to the cloud
+ * Called when a task is completed
+ */
+export declare function syncTask(task: Task): Promise<boolean>;
+/**
+ * Sync multiple tasks with batching and retry
+ */
+export declare function syncTasks(tasks: Task[]): Promise<{
+    synced: number;
+    failed: number;
+    errors: string[];
+    syncedIds: string[];
+    failedIds: string[];
+}>;
+/**
+ * Get sync status summary
+ */
+export declare function getSyncStatusSummary(): string;