grov 0.5.11 → 0.6.13

package/dist/cli/index.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { closeDatabase } from '../core/store/store.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+// SECURITY: Global error handlers to catch unhandled rejections from dynamic imports
+process.on('unhandledRejection', (reason) => {
+    console.error('Error:', reason instanceof Error ? reason.message : 'Unknown error');
+    closeDatabase();
+    process.exit(1);
+});
+process.on('uncaughtException', (error) => {
+    console.error('Error:', error.message);
+    closeDatabase();
+    process.exit(1);
+});
+const program = new Command();
+/**
+ * Wrap async action with error handling and cleanup.
+ * Ensures database connections are closed and errors are handled gracefully.
+ */
+function safeAction(fn) {
+    return async (options) => {
+        try {
+            await fn(options);
+        }
+        catch (error) {
+            console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+        finally {
+            closeDatabase();
+        }
+    };
+}
+program
+    .name('grov')
+    .description('Collective AI memory for engineering teams')
+    .version(pkg.version);
+program
+    .command('init [agent]')
+    .description('Configure AI agent (claude, codex, cursor, antigravity, or zed)')
+    .action(safeAction(async (agent) => {
+    const { init } = await import('./commands/init.js');
+    if (agent === 'cursor') {
+        await init('cursor');
+    }
+    else if (agent === 'antigravity') {
+        await init('antigravity');
+    }
+    else if (agent === 'zed') {
+        await init('zed');
+    }
+    else {
+        const agentName = (agent === 'codex' ? 'codex' : 'claude');
+        await init(agentName);
+    }
+}));
+program
+    .command('disable [agent]')
+    .description('Disable grov for AI agent (claude, codex, cursor, antigravity, or zed)')
+    .action(safeAction(async (agent) => {
+    const { disable } = await import('./commands/disable.js');
+    if (agent === 'cursor') {
+        await disable('cursor');
+    }
+    else if (agent === 'antigravity') {
+        await disable('antigravity');
+    }
+    else if (agent === 'zed') {
+        await disable('zed');
+    }
+    else {
+        const agentName = (agent === 'codex' ? 'codex' : 'claude');
+        await disable(agentName);
+    }
+}));
+// grov status - Show stored reasoning for current project
+program
+    .command('status')
+    .description('Show stored reasoning for current project')
+    .option('--all', 'Show all tasks, not just completed')
+    .action(safeAction(async (options) => {
+    const { status } = await import('./commands/status.js');
+    await status(options);
+}));
+// grov drift-test - Test drift detection on a prompt (internal/debug)
+program
+    .command('drift-test', { hidden: true })
+    .description('Test drift detection on a prompt (debug command)')
+    .argument('<prompt>', 'The prompt to test for drift')
+    .option('--session <id>', 'Session ID to use for context')
+    .option('--goal <text>', 'Original goal (if no session provided)')
+    .option('-v, --verbose', 'Show verbose output')
+    .action(async (prompt, options) => {
+    const { driftTest } = await import('./commands/drift-test.js');
+    await driftTest(prompt, options);
+});
+// grov proxy - Start the proxy server
+program
+    .command('proxy')
+    .description('Start the Grov proxy server (intercepts Claude API calls)')
+    .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('../integrations/proxy/server.js');
+    await startServer({ debug: options.debug ?? false });
+});
+// grov proxy-status - Show active proxy sessions
+program
+    .command('proxy-status')
+    .description('Show active proxy sessions')
+    .action(safeAction(async () => {
+    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 uninstall - Full cleanup
+program
+    .command('uninstall')
+    .description('Remove all grov data and configuration')
+    .action(safeAction(async () => {
+    const { uninstall } = await import('./commands/uninstall.js');
+    await uninstall();
+}));
+// 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')
+    .option('--antigravity', 'Sync Antigravity sessions to cloud')
+    .action(safeAction(async (options) => {
+    const { sync } = await import('./commands/sync.js');
+    await sync(options);
+}));
+// grov doctor - Diagnose setup issues
+program
+    .command('doctor [agent]')
+    .description('Check grov setup and diagnose issues (optional: claude, codex)')
+    .action(safeAction(async (agent) => {
+    const { doctor } = await import('./commands/doctor.js');
+    const agentName = agent === 'claude' || agent === 'codex' ? agent : undefined;
+    await doctor(agentName);
+}));
+// grov agents - List supported agents
+program
+    .command('agents')
+    .description('List supported AI agents and setup instructions')
+    .action(safeAction(async () => {
+    const { agents } = await import('./commands/agents.js');
+    agents();
+}));
+// grov setup - Interactive setup wizard
+program
+    .command('setup')
+    .description('Interactive setup wizard for new users')
+    .action(safeAction(async () => {
+    const { setup } = await import('./commands/setup.js');
+    await setup();
+}));
+// grov mcp - Start MCP server (called by Cursor, not user)
+program
+    .command('mcp', { hidden: true })
+    .description('Start MCP server for Cursor integration')
+    .action(async () => {
+    const { startMcpServer } = await import('../integrations/mcp/index.js');
+    await startMcpServer();
+});
+// grov capture-hook - Called by Cursor stop hook (internal)
+program
+    .command('capture-hook', { hidden: true })
+    .description('Internal: Called by Cursor stop hook to capture conversations')
+    .action(async () => {
+    await import('../integrations/mcp/capture/hook-handler.js');
+});
+// Smart no-args behavior: show "get started" or status
+async function showSmartDefault() {
+    const { isAuthenticated, getSyncStatus } = await import('../core/cloud/credentials.js');
+    const { isAnyAgentConfigured, getFirstConfiguredAgent } = await import('./agents/registry.js');
+    const loggedIn = isAuthenticated();
+    const agentConfigured = isAnyAgentConfigured();
+    if (!loggedIn && !agentConfigured) {
+        // First run - show get started
+        console.log('\ngrov - Collective AI memory for engineering teams\n');
+        console.log('┌─────────────────────────────────────────────────────────────┐');
+        console.log('│  GET STARTED                                                │');
+        console.log('│                                                             │');
+        console.log('│  Run: grov setup                                            │');
+        console.log('│                                                             │');
+        console.log('│  This will:                                                 │');
+        console.log('│  • Connect to your team dashboard                           │');
+        console.log('│  • Configure your AI agent (Claude, Codex, Cursor, etc.)    │');
+        console.log('│  • Show you exactly how to use grov                         │');
+        console.log('└─────────────────────────────────────────────────────────────┘');
+        console.log('\nOr see all commands: grov --help\n');
+        return;
+    }
+    // Setup done - show status dashboard
+    console.log('\ngrov - Collective AI memory for engineering teams\n');
+    console.log('STATUS');
+    const agent = getFirstConfiguredAgent();
+    if (agent) {
+        console.log(`\x1b[32m●\x1b[0m ${agent.name}    Configured`);
+    }
+    else {
+        console.log('\x1b[90m○\x1b[0m Agent       Not configured');
+    }
+    const syncStatus = getSyncStatus();
+    if (syncStatus?.enabled && syncStatus.teamId) {
+        console.log(`\x1b[32m●\x1b[0m Team Sync   Enabled`);
+    }
+    else if (loggedIn) {
+        console.log('\x1b[33m○\x1b[0m Team Sync   Disabled');
+    }
+    else {
+        console.log('\x1b[90m○\x1b[0m Team Sync   Not logged in');
+    }
+    if (agent?.type === 'cli') {
+        console.log('\nTO USE:');
+        console.log('  Terminal 1: grov proxy');
+        console.log(`  Terminal 2: ${agent.command}`);
+    }
+    else if (agent?.type === 'ide') {
+        console.log('\nTO USE:');
+        console.log(`  Restart ${agent.name} and use normally`);
+    }
+    console.log('\nCOMMANDS');
+    console.log('  grov proxy     Start the proxy (for CLI agents)');
+    console.log('  grov status    View captured memories');
+    console.log('  grov doctor    Check setup health');
+    console.log('\nAll commands: grov --help\n');
+}
+// Check if no args - show smart default
+if (process.argv.length === 2) {
+    showSmartDefault().catch(err => {
+        console.error('Error:', err instanceof Error ? err.message : 'Unknown error');
+        process.exit(1);
+    });
+}
+else {
+    program.parse();
+}

package/dist/{lib → core/cloud}/cloud-sync.d.ts

@@ -1,6 +1,6 @@
 import type { CreateMemoryInput, Memory } from '@grov/shared';
-import type { Task } from './store.js';
-import type { ExtractedReasoningAndDecisions, ShouldUpdateResult } from './llm-extractor.js';
+import type { Task } from '../store/store.js';
+import type { ExtractedReasoningAndDecisions, ShouldUpdateResult, RequestHeaders } from '../extraction/llm-extractor.js';
 /**
  * Evolution step in memory history
  */
@@ -70,7 +70,7 @@ export declare function getSyncTeamId(): string | null;
  * @param extractedData - Optional pre-extracted reasoning and decisions
  * @param taskType - Optional task type for shouldUpdateMemory context
  */
-export declare function syncTask(task: Task, extractedData?: ExtractedReasoningAndDecisions, taskType?: 'information' | 'planning' | 'implementation'): Promise<boolean>;
+export declare function syncTask(task: Task, extractedData: ExtractedReasoningAndDecisions | undefined, taskType: 'information' | 'planning' | 'implementation' | undefined, headers: RequestHeaders): Promise<boolean>;
 /**
  * Sync multiple tasks with batching and retry
  */

package/dist/{lib → core/cloud}/cloud-sync.js

@@ -2,7 +2,7 @@
 // Handles batching, retries, and conversion from Task to Memory format
 import { getSyncStatus, getAccessToken } from './credentials.js';
 import { syncMemories, sleep, getApiUrl, fetchMatch } from './api-client.js';
-import { shouldUpdateMemory, isShouldUpdateAvailable } from './llm-extractor.js';
+import { shouldUpdateMemory } from '../extraction/llm-extractor.js';
 // Sync configuration
 const SYNC_CONFIG = {
     batchSize: 10, // Number of memories per batch
@@ -154,7 +154,7 @@ export function getSyncTeamId() {
  * @param extractedData - Optional pre-extracted reasoning and decisions
  * @param taskType - Optional task type for shouldUpdateMemory context
  */
-export async function syncTask(task, extractedData, taskType) {
+export async function syncTask(task, extractedData, taskType, headers) {
     if (!isSyncEnabled()) {
         return false;
     }
@@ -190,16 +190,16 @@ export async function syncTask(task, extractedData, taskType) {
         if (!matchResult.match) {
             const memory = taskToMemory(task);
             const result = await syncMemories(teamId, { memories: [memory] });
-            console.log(`[SYNC] ${taskId} -> INSERT ${result.synced === 1 ? 'OK' : 'FAILED'}`);
+            console.log(`[SYNC TO CLOUD] ${taskId} -> INSERT (${taskType || 'unknown'})`);
             return result.synced === 1;
         }
         const matchedId = matchResult.match.id.substring(0, 8);
         const score = matchResult.combined_score?.toFixed(3) || '-';
-        // If shouldUpdateMemory is not available or no extracted data, INSERT anyway
-        if (!isShouldUpdateAvailable() || !effectiveExtractedData) {
+        // If no extracted data, INSERT anyway
+        if (!effectiveExtractedData) {
             const memory = taskToMemory(task);
             const result = await syncMemories(teamId, { memories: [memory] });
-            console.log(`[SYNC] ${taskId} -> INSERT (no haiku) ${result.synced === 1 ? 'OK' : 'FAILED'}`);
+            console.log(`[SYNC TO CLOUD] ${taskId} -> INSERT (${taskType || 'unknown'})`);
             return result.synced === 1;
         }
         // Build session context for shouldUpdateMemory
@@ -216,22 +216,22 @@ export async function syncTask(task, extractedData, taskType) {
             reasoning_trace: matchResult.match.reasoning_trace || [],
             evolution_steps: (matchResult.match.evolution_steps || []),
             files_touched: matchResult.match.files_touched || [],
-        }, effectiveExtractedData, sessionContext);
+        }, effectiveExtractedData, sessionContext, headers);
         // If should NOT update, skip sync entirely
         if (!updateResult.should_update) {
-            console.log(`[SYNC] ${taskId} -> SKIP (matched ${matchedId}, score=${score})`);
+            console.log(`[SYNC TO CLOUD] ${taskId} -> SKIP (unchanged) [matched: ${matchedId}]`);
             return true;
         }
         // Prepare payload for UPDATE
         const payload = prepareSyncPayload(matchResult.match, effectiveExtractedData, updateResult, task);
         // Sync with memory_id for UPDATE path
         const result = await syncMemories(teamId, { memories: [payload] });
-        console.log(`[SYNC] ${taskId} -> UPDATE ${matchedId} (score=${score}) ${result.synced === 1 ? 'OK' : 'FAILED'}`);
+        console.log(`[SYNC TO CLOUD] ${taskId} -> UPDATE (${taskType || 'unknown'}) [matched: ${matchedId}]`);
         return result.synced === 1;
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : 'Unknown error';
-        console.error(`[SYNC] Error: ${msg}`);
+        console.error(`[SYNC TO CLOUD] ERROR: ${msg}`);
         return false;
     }
 }

package/dist/{lib → core/extraction}/correction-builder-proxy.d.ts

@@ -1,4 +1,4 @@
-import type { SessionState, CorrectionLevel } from './store.js';
+import type { SessionState, CorrectionLevel } from '../store/store.js';
 import type { DriftCheckResult } from './drift-checker-proxy.js';
 export interface CorrectionMessage {
     level: CorrectionLevel;

package/dist/{lib → core/extraction}/correction-builder-proxy.js

@@ -34,14 +34,10 @@ ${result.diagnostic}
  */
 function buildCorrect(result, sessionState) {
     const goal = sessionState.original_goal || 'the original task';
-    const scope = sessionState.expected_scope.length > 0
-        ? sessionState.expected_scope.join(', ')
-        : 'the relevant files';
     let message = `<grov_correction>
 DRIFT DETECTED - Please refocus on the original goal.
 
 Original goal: ${goal}
-Expected scope: ${scope}
 
 Issue: ${result.diagnostic}
 `;

package/dist/{lib → core/extraction}/drift-checker-proxy.d.ts

@@ -1,4 +1,5 @@
-import type { SessionState, StepRecord, DriftType, CorrectionLevel } from './store.js';
+import type { SessionState, StepRecord, DriftType, CorrectionLevel } from '../store/store.js';
+import type { RequestHeaders } from './llm-extractor.js';
 export interface DriftCheckInput {
     sessionState: SessionState;
     recentSteps: StepRecord[];
@@ -12,20 +13,23 @@ export interface DriftCheckResult {
     recoverySteps?: string[];
 }
 /**
- * Check if drift checking is available
+ * Main drift check - uses LLM with auth
  */
-export declare function isDriftCheckAvailable(): boolean;
-/**
- * Main drift check - uses LLM if available, fallback to basic
- */
-export declare function checkDrift(input: DriftCheckInput): Promise<DriftCheckResult>;
+export declare function checkDrift(input: DriftCheckInput, headers: RequestHeaders): Promise<DriftCheckResult>;
 /**
  * Basic drift check without LLM (fallback)
+ * Returns safe default - no penalties without LLM analysis
  */
-export declare function checkDriftBasic(input: DriftCheckInput): DriftCheckResult;
+export declare function checkDriftBasic(_input: DriftCheckInput): DriftCheckResult;
 /**
  * Convert score to correction level
  * Reference: plan_proxy_local.md Section 4.3
+ *
+ * Thresholds (lenient):
+ * - 5-10: OK, no correction needed
+ * - 4: nudge (mild reminder)
+ * - 3: correct (full correction)
+ * - 1-2: intervene (strong intervention)
  */
 export declare function scoreToCorrectionLevel(score: number): CorrectionLevel | null;
 /**
@@ -60,4 +64,4 @@ export interface ForcedRecoveryResult {
 export declare function generateForcedRecovery(sessionState: SessionState, recentActions: Array<{
     actionType: string;
     files: string[];
-}>, lastDriftResult: DriftCheckResult): Promise<ForcedRecoveryResult>;
+}>, lastDriftResult: DriftCheckResult, headers: RequestHeaders): Promise<ForcedRecoveryResult>;