grov 0.5.11 → 0.6.13

package/dist/integrations/mcp/capture/hook-handler.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Cursor Stop Hook Handler
+// Called by Cursor after each LLM response
+// Reads from SQLite, handles mode logic, POSTs to API
+import { getLatestComposerId, getComposerData, getLatestPromptId, getConversationPair, getCurrentWorkspace, dbExists, } from './sqlite-reader.js';
+import { isSynced, markSynced, getPlanState, addToPlanState, clearPlanState, isPlanTimedOut, } from './sync-tracker.js';
+import { getAccessToken, getSyncStatus } from '../../../core/cloud/credentials.js';
+import { request } from 'undici';
+import { mcpLog } from '../logger.js';
+const API_URL = process.env.GROV_API_URL || 'https://api.grov.dev';
+const PLAN_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+function modeNumToString(num) {
+    if (num === 1)
+        return 'ask';
+    if (num === 5)
+        return 'plan';
+    return 'agent';
+}
+async function postToApi(teamId, token, payload) {
+    try {
+        const res = await request(`${API_URL}/teams/${teamId}/cursor/extract`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        return res.statusCode === 200;
+    }
+    catch {
+        return false;
+    }
+}
+function buildPayload(pair, projectPath) {
+    return {
+        composerId: pair.assistant.composerId,
+        usageUuid: pair.assistant.usageUuid,
+        mode: modeNumToString(pair.assistant.unifiedMode),
+        projectPath,
+        original_query: pair.user.text,
+        text: pair.assistant.text,
+        thinking: pair.assistant.thinking,
+        toolCalls: pair.assistant.toolCalls,
+    };
+}
+// Syncs accumulated plan messages if the plan session has been idle too long.
+async function handlePlanTimeout(teamId, token) {
+    const planState = getPlanState();
+    if (!planState || !isPlanTimedOut(PLAN_TIMEOUT_MS))
+        return;
+    const composer = getComposerData(planState.composerId);
+    if (!composer) {
+        clearPlanState();
+        return;
+    }
+    for (const usageUuid of planState.usageUuids) {
+        if (isSynced(planState.composerId, usageUuid))
+            continue;
+        const pair = getConversationPair(planState.composerId, usageUuid);
+        if (!pair)
+            continue;
+        const payload = buildPayload(pair, composer.projectPath);
+        const success = await postToApi(teamId, token, payload);
+        if (success) {
+            markSynced(planState.composerId, usageUuid);
+        }
+    }
+    clearPlanState();
+}
+async function handleCurrentPrompt(teamId, token, composerId, usageUuid, projectPath) {
+    if (isSynced(composerId, usageUuid))
+        return;
+    const pair = getConversationPair(composerId, usageUuid);
+    if (!pair)
+        return;
+    const mode = pair.assistant.unifiedMode;
+    // Warn if text is empty (helps debug text=0 issue)
+    if (pair.assistant.text.length === 0) {
+        mcpLog(`[hook] WARNING: Assistant text is EMPTY for ${usageUuid.substring(0, 8)}...`);
+    }
+    // Ask mode (1): skip
+    if (mode === 1) {
+        markSynced(composerId, usageUuid);
+        return;
+    }
+    // Plan mode (5): accumulate
+    if (mode === 5) {
+        addToPlanState(composerId, usageUuid);
+        return;
+    }
+    // Agent mode (2): check if we have accumulated plan to send first
+    const planState = getPlanState();
+    if (planState && planState.composerId === composerId) {
+        for (const planUuid of planState.usageUuids) {
+            if (isSynced(composerId, planUuid))
+                continue;
+            const planPair = getConversationPair(composerId, planUuid);
+            if (!planPair)
+                continue;
+            const planPayload = buildPayload(planPair, projectPath);
+            const success = await postToApi(teamId, token, planPayload);
+            if (success)
+                markSynced(composerId, planUuid);
+        }
+        clearPlanState();
+    }
+    // Send current agent message
+    const payload = buildPayload(pair, projectPath);
+    const success = await postToApi(teamId, token, payload);
+    if (success) {
+        markSynced(composerId, usageUuid);
+    }
+    else {
+        mcpLog(`[hook] Failed to sync ${usageUuid.substring(0, 8)}...`);
+    }
+}
+// Helper to sleep
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function main() {
+    mcpLog(`[hook] started`);
+    // Wait 3 seconds to let Cursor finish writing to SQLite
+    await sleep(3000);
+    // Check prerequisites
+    if (!dbExists())
+        process.exit(0);
+    const syncStatus = getSyncStatus();
+    if (!syncStatus?.enabled || !syncStatus.teamId)
+        process.exit(0);
+    const token = await getAccessToken();
+    if (!token)
+        process.exit(0);
+    const teamId = syncStatus.teamId;
+    // Handle any timed-out plan from a DIFFERENT conversation
+    await handlePlanTimeout(teamId, token);
+    // Get latest composer (skips empty ones)
+    const composerId = getLatestComposerId();
+    if (!composerId)
+        process.exit(0);
+    const composer = getComposerData(composerId);
+    if (!composer)
+        process.exit(0);
+    // Get latest prompt (usageUuid) with content
+    const usageUuid = getLatestPromptId(composerId);
+    if (!usageUuid)
+        process.exit(0);
+    // Get project path from current workspace (MRU list)
+    const projectPath = getCurrentWorkspace() || composer.projectPath;
+    await handleCurrentPrompt(teamId, token, composerId, usageUuid, projectPath);
+    mcpLog(`[hook] finished`);
+}
+main().catch((err) => {
+    mcpLog(`[main] Fatal error: ${err instanceof Error ? err.message : 'unknown'}`);
+    process.exit(1);
+});

package/dist/integrations/mcp/capture/sqlite-reader.d.ts

@@ -0,0 +1,35 @@
+export interface ToolCall {
+    name: string;
+    params: Record<string, unknown>;
+}
+export interface ComposerData {
+    composerId: string;
+    projectPath: string;
+    createdAt: number;
+}
+export interface AggregatedAssistant {
+    composerId: string;
+    usageUuid: string;
+    unifiedMode: 1 | 2 | 5;
+    text: string;
+    thinking: string;
+    toolCalls: ToolCall[];
+    bubbleCount: number;
+}
+export interface ConversationPair {
+    user: {
+        text: string;
+        timestamp: number;
+    };
+    assistant: AggregatedAssistant;
+}
+export declare function getLatestComposerId(): string | null;
+export declare function getComposerData(composerId: string): ComposerData | null;
+export declare function getLatestPromptId(composerId: string): string | null;
+export declare function getConversationPair(composerId: string, usageUuid: string): ConversationPair | null;
+export declare function dbExists(): boolean;
+/**
+ * Get current workspace from Cursor's recently opened list.
+ * Index 0 = most recently accessed = current workspace.
+ */
+export declare function getCurrentWorkspace(): string | null;

package/dist/integrations/mcp/capture/sqlite-reader.js

@@ -0,0 +1,388 @@
+// Read messages from Cursor SQLite
+// Location varies by OS:
+//   Linux:   ~/.config/Cursor/User/globalStorage/state.vscdb
+//   macOS:   ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+//   Windows: %APPDATA%/Cursor/User/globalStorage/state.vscdb
+import Database from 'better-sqlite3';
+import { homedir, platform } from 'os';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { mcpLog } from '../logger.js';
+function getCursorDbPath() {
+    const home = homedir();
+    switch (platform()) {
+        case 'darwin':
+            return join(home, 'Library/Application Support/Cursor/User/globalStorage/state.vscdb');
+        case 'win32':
+            return join(process.env.APPDATA || join(home, 'AppData/Roaming'), 'Cursor/User/globalStorage/state.vscdb');
+        default:
+            return join(home, '.config/Cursor/User/globalStorage/state.vscdb');
+    }
+}
+const CURSOR_DB_PATH = getCursorDbPath();
+const TABLE = 'cursorDiskKV';
+function getDb() {
+    if (!existsSync(CURSOR_DB_PATH))
+        return null;
+    try {
+        return new Database(CURSOR_DB_PATH, { readonly: true });
+    }
+    catch {
+        return null;
+    }
+}
+function getValue(db, key) {
+    const row = db.prepare(`SELECT value FROM ${TABLE} WHERE key = ?`).get(key);
+    if (!row)
+        return null;
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return null;
+    }
+}
+export function getLatestComposerId() {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        // Get all composer keys with their createdAt
+        const rows = db.prepare(`SELECT key FROM ${TABLE} WHERE key LIKE 'composerData:%'`).all();
+        mcpLog(`[getLatestComposerId] Found ${rows.length} composers, checking for bubbles...`);
+        // Build list of composers with their timestamps
+        const composers = [];
+        for (const row of rows) {
+            const composerId = row.key.replace('composerData:', '');
+            const data = getValue(db, row.key);
+            if (data?.createdAt) {
+                composers.push({ id: composerId, createdAt: data.createdAt });
+            }
+        }
+        // Sort by createdAt descending (newest first)
+        composers.sort((a, b) => b.createdAt - a.createdAt);
+        // Find first composer that has at least one bubble
+        for (const composer of composers) {
+            const bubbleCount = db.prepare(`SELECT COUNT(*) as count FROM ${TABLE} WHERE key LIKE ?`).get(`bubbleId:${composer.id}:%`);
+            if (bubbleCount.count > 0) {
+                mcpLog(`[getLatestComposerId] Selected ${composer.id.substring(0, 8)}... (${bubbleCount.count} bubbles)`);
+                return composer.id;
+            }
+            else {
+                mcpLog(`[getLatestComposerId] Skipping ${composer.id.substring(0, 8)}... (0 bubbles)`);
+            }
+        }
+        mcpLog(`[getLatestComposerId] No composer with bubbles found`);
+        return null;
+    }
+    finally {
+        db.close();
+    }
+}
+export function getComposerData(composerId) {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        const data = getValue(db, `composerData:${composerId}`);
+        if (!data)
+            return null;
+        let projectPath = '';
+        // Primary: Extract from messageRequestContext.ideEditorsState
+        // Find a user bubble (type=1) to get its bubbleId
+        const userBubble = db.prepare(`
+      SELECT json_extract(value, '$.bubbleId') as bubbleId
+      FROM ${TABLE}
+      WHERE key LIKE ? AND json_extract(value, '$.type') = 1
+      LIMIT 1
+    `).get(`bubbleId:${composerId}:%`);
+        if (userBubble?.bubbleId) {
+            const msgCtx = getValue(db, `messageRequestContext:${composerId}:${userBubble.bubbleId}`);
+            if (msgCtx?.ideEditorsState && typeof msgCtx.ideEditorsState === 'string') {
+                try {
+                    const ide = JSON.parse(msgCtx.ideEditorsState);
+                    const file = ide.visibleFiles?.[0];
+                    if (file?.relativePath && file?.absolutePath && file.absolutePath.endsWith(file.relativePath)) {
+                        projectPath = file.absolutePath.slice(0, -(file.relativePath.length + 1));
+                        mcpLog(`[getComposerData] Project from ideEditorsState: ${projectPath}`);
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+        }
+        // Fallback: Extract from toolFormerData file paths
+        if (!projectPath) {
+            const toolBubbles = db.prepare(`
+        SELECT json_extract(value, '$.toolFormerData') as toolData
+        FROM ${TABLE}
+        WHERE key LIKE ? AND json_extract(value, '$.toolFormerData') IS NOT NULL
+        LIMIT 5
+      `).all(`bubbleId:${composerId}:%`);
+            for (const row of toolBubbles) {
+                if (projectPath)
+                    break;
+                try {
+                    const toolData = JSON.parse(row.toolData);
+                    if (toolData.params) {
+                        const params = JSON.parse(toolData.params);
+                        // Look for file paths in common param names
+                        const filePath = params.targetFile || params.relativeWorkspacePath || params.file_path || params.path;
+                        if (typeof filePath === 'string' && filePath.startsWith('/')) {
+                            // Extract project root from absolute path (assume src/, lib/, etc. are inside project)
+                            const match = filePath.match(/^(\/[^/]+(?:\/[^/]+)*?)\/(?:src|lib|test|tests|app|packages|node_modules)\//);
+                            if (match) {
+                                projectPath = match[1];
+                                mcpLog(`[getComposerData] Project from toolFormerData: ${projectPath}`);
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+        }
+        return {
+            composerId,
+            projectPath,
+            createdAt: typeof data.createdAt === 'number' ? data.createdAt : 0,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function getLatestPromptId(composerId) {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        // Get all bubbles for this composer with their usageUuid and content info
+        const rows = db.prepare(`
+      SELECT
+        key,
+        json_extract(value, '$.usageUuid') as usageUuid,
+        json_extract(value, '$.requestId') as requestId,
+        json_extract(value, '$.type') as type,
+        json_extract(value, '$.text') as text,
+        json_extract(value, '$.thinking.text') as thinking,
+        json_extract(value, '$.createdAt') as createdAt
+      FROM ${TABLE}
+      WHERE key LIKE ?
+      ORDER BY json_extract(value, '$.createdAt') DESC
+    `).all(`bubbleId:${composerId}:%`);
+        mcpLog(`[getLatestPromptId] Composer ${composerId.substring(0, 8)}: found ${rows.length} bubbles total`);
+        if (rows.length === 0)
+            return null;
+        // First: collect all usageUuids that have a user bubble (type=1)
+        // These are the only valid ones we can use
+        const uuidsWithUserBubble = new Set();
+        for (const row of rows) {
+            if (row.type === 1 && row.requestId) {
+                uuidsWithUserBubble.add(row.requestId);
+            }
+        }
+        mcpLog(`[getLatestPromptId] usageUuids with user bubble: ${uuidsWithUserBubble.size}`);
+        // Group by usageUuid, track latest timestamp and whether it has content
+        const promptMap = new Map();
+        for (const row of rows) {
+            // usageUuid is on assistant messages, requestId is on user messages (same value)
+            const uuid = row.usageUuid || row.requestId;
+            if (!uuid)
+                continue;
+            // Skip usageUuids that don't have a user bubble (continuations)
+            if (!uuidsWithUserBubble.has(uuid))
+                continue;
+            const hasContent = Boolean((row.text && row.text.length > 0) || (row.thinking && row.thinking.length > 0));
+            const timestamp = row.createdAt ? parseInt(row.createdAt, 10) : 0;
+            const existing = promptMap.get(uuid);
+            if (!existing) {
+                promptMap.set(uuid, { maxTimestamp: timestamp, hasContent });
+            }
+            else {
+                if (timestamp > existing.maxTimestamp) {
+                    existing.maxTimestamp = timestamp;
+                }
+                if (hasContent) {
+                    existing.hasContent = true;
+                }
+            }
+        }
+        mcpLog(`[getLatestPromptId] Distinct usageUuids (with user bubble): ${promptMap.size}`);
+        // Find the latest usageUuid that has content
+        let latestUuid = null;
+        let latestTime = 0;
+        for (const [uuid, info] of promptMap) {
+            if (info.hasContent && info.maxTimestamp > latestTime) {
+                latestTime = info.maxTimestamp;
+                latestUuid = uuid;
+            }
+        }
+        if (latestUuid) {
+            mcpLog(`[getLatestPromptId] Latest with content: ${latestUuid.substring(0, 8)}... (timestamp: ${latestTime})`);
+        }
+        else {
+            mcpLog(`[getLatestPromptId] No valid prompt found with content`);
+        }
+        return latestUuid;
+    }
+    finally {
+        db.close();
+    }
+}
+export function getConversationPair(composerId, usageUuid) {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        // Get all bubbles for this usageUuid
+        const rows = db.prepare(`
+      SELECT
+        json_extract(value, '$.type') as type,
+        json_extract(value, '$.usageUuid') as usageUuid,
+        json_extract(value, '$.requestId') as requestId,
+        json_extract(value, '$.text') as text,
+        json_extract(value, '$.thinking.text') as thinking,
+        json_extract(value, '$.unifiedMode') as unifiedMode,
+        json_extract(value, '$.createdAt') as createdAt,
+        json_extract(value, '$.toolFormerData') as toolFormerData
+      FROM ${TABLE}
+      WHERE key LIKE ?
+      ORDER BY json_extract(value, '$.createdAt') ASC
+    `).all(`bubbleId:${composerId}:%`);
+        // Find START: user bubble (type=1) with requestId = usageUuid
+        mcpLog(`[getConversationPair] Total rows: ${rows.length}, looking for usageUuid=${usageUuid.substring(0, 8)}...`);
+        const startIdx = rows.findIndex(r => r.type === 1 && r.requestId === usageUuid);
+        if (startIdx === -1) {
+            mcpLog(`[getConversationPair] No user bubble found for usageUuid`);
+            return null;
+        }
+        const userBubble = rows[startIdx];
+        mcpLog(`[getConversationPair] Found user bubble at index ${startIdx}`);
+        // Collect ALL type=2 bubbles until next type=1 or end of array
+        // This includes continuation bubbles with NULL usageUuid
+        const assistantBubbles = [];
+        for (let i = startIdx + 1; i < rows.length; i++) {
+            if (rows[i].type === 1) {
+                mcpLog(`[getConversationPair] Stopping at next user bubble (index ${i})`);
+                break;
+            }
+            if (rows[i].type === 2) {
+                assistantBubbles.push(rows[i]);
+            }
+        }
+        mcpLog(`[getConversationPair] Found ${assistantBubbles.length} assistant bubbles (including continuations)`);
+        // Debug: log each bubble's fields
+        for (let i = 0; i < assistantBubbles.length; i++) {
+            const b = assistantBubbles[i];
+            mcpLog(`[getConversationPair] Bubble ${i}: text=${b.text?.length || 0}, thinking=${b.thinking?.length || 0}, hasTool=${b.toolFormerData ? 'yes' : 'no'}`);
+        }
+        // Aggregate thinking from all bubbles
+        const thinkingParts = [];
+        let withThinking = 0;
+        let withText = 0;
+        for (const bubble of assistantBubbles) {
+            if (bubble.thinking && bubble.thinking.length > 0) {
+                thinkingParts.push(bubble.thinking);
+                withThinking++;
+            }
+        }
+        // Get text from the last bubble that has text
+        let finalText = '';
+        for (let i = assistantBubbles.length - 1; i >= 0; i--) {
+            if (assistantBubbles[i].text && assistantBubbles[i].text.length > 0) {
+                finalText = assistantBubbles[i].text;
+                withText++;
+                break;
+            }
+        }
+        // Aggregate tool calls from all bubbles (toolFormerData is a JSON object with name/params)
+        const allToolCalls = [];
+        for (const bubble of assistantBubbles) {
+            if (bubble.toolFormerData) {
+                try {
+                    const toolData = JSON.parse(bubble.toolFormerData);
+                    if (toolData.name) {
+                        let params = {};
+                        if (toolData.params) {
+                            try {
+                                params = JSON.parse(toolData.params);
+                            }
+                            catch {
+                                // params might not be valid JSON
+                            }
+                        }
+                        allToolCalls.push({
+                            name: toolData.name,
+                            params,
+                        });
+                        mcpLog(`[getConversationPair] Tool: ${toolData.name}, params keys: ${Object.keys(params).join(',')}`);
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+        }
+        // Get unifiedMode from first assistant bubble
+        const unifiedMode = assistantBubbles[0]?.unifiedMode;
+        const mode = unifiedMode === 1 ? 1 : unifiedMode === 5 ? 5 : 2;
+        const aggregatedThinking = thinkingParts.join('\n\n');
+        mcpLog(`[getConversationPair] User: "${userBubble.text?.substring(0, 50)}..." (${userBubble.text?.length || 0} chars)`);
+        mcpLog(`[getConversationPair] Assistant bubbles: ${assistantBubbles.length} total, ${withThinking} with thinking, ${withText > 0 ? 1 : 0} with text`);
+        mcpLog(`[getConversationPair] Aggregated: thinking=${aggregatedThinking.length} chars, text=${finalText.length} chars, toolCalls=${allToolCalls.length}`);
+        return {
+            user: {
+                text: userBubble.text || '',
+                timestamp: userBubble.createdAt ? parseInt(userBubble.createdAt, 10) : 0,
+            },
+            assistant: {
+                composerId,
+                usageUuid,
+                unifiedMode: mode,
+                text: finalText,
+                thinking: aggregatedThinking,
+                toolCalls: allToolCalls,
+                bubbleCount: assistantBubbles.length,
+            },
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function dbExists() {
+    return existsSync(CURSOR_DB_PATH);
+}
+/**
+ * Get current workspace from Cursor's recently opened list.
+ * Index 0 = most recently accessed = current workspace.
+ */
+export function getCurrentWorkspace() {
+    const db = getDb();
+    if (!db)
+        return null;
+    try {
+        const row = db.prepare(`SELECT value FROM ItemTable WHERE key = ?`).get('history.recentlyOpenedPathsList');
+        if (!row)
+            return null;
+        const data = JSON.parse(row.value);
+        const folderUri = data.entries?.[0]?.folderUri;
+        if (!folderUri)
+            return null;
+        // Remove file:// prefix
+        const projectPath = folderUri.replace('file://', '');
+        mcpLog(`[getCurrentWorkspace] Current workspace: ${projectPath}`);
+        return projectPath;
+    }
+    catch (err) {
+        mcpLog(`[getCurrentWorkspace] Error: ${err}`);
+        return null;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/integrations/mcp/capture/sync-tracker.d.ts

@@ -0,0 +1,16 @@
+type SyncedId = string;
+interface PlanState {
+    composerId: string;
+    usageUuids: string[];
+    lastActivity: number;
+}
+export declare function getSyncedIds(): Set<SyncedId>;
+export declare function isSynced(composerId: string, usageUuid: string): boolean;
+export declare function markSynced(composerId: string, usageUuid: string): void;
+export declare function getPlanState(): PlanState | null;
+export declare function setPlanState(composerId: string, usageUuids: string[]): void;
+export declare function addToPlanState(composerId: string, usageUuid: string): void;
+export declare function clearPlanState(): void;
+export declare function isPlanTimedOut(timeoutMs?: number): boolean;
+export declare function pruneSyncedOlderThan(days?: number): void;
+export {};