grov 0.5.11 → 0.6.13

package/dist/integrations/mcp/capture/antigravity-sync-tracker.js

@@ -0,0 +1,115 @@
+// Track which Antigravity sessions have been synced to cloud
+// File: ~/.grov/antigravity_synced.json
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const GROV_DIR = join(homedir(), '.grov');
+const SYNCED_FILE = join(GROV_DIR, 'antigravity_synced.json');
+// ─────────────────────────────────────────────────────────────
+// File Operations
+// ─────────────────────────────────────────────────────────────
+function ensureDir() {
+    if (!existsSync(GROV_DIR)) {
+        mkdirSync(GROV_DIR, { recursive: true });
+    }
+}
+function readState() {
+    if (!existsSync(SYNCED_FILE)) {
+        return { entries: [] };
+    }
+    try {
+        const content = readFileSync(SYNCED_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return { entries: [] };
+    }
+}
+function writeState(state) {
+    ensureDir();
+    writeFileSync(SYNCED_FILE, JSON.stringify(state, null, 2));
+}
+// ─────────────────────────────────────────────────────────────
+// Hash Helper
+// ─────────────────────────────────────────────────────────────
+/**
+ * Simple hash for detecting plan content changes
+ */
+export function hashContent(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(16);
+}
+// ─────────────────────────────────────────────────────────────
+// Sync Tracking
+// ─────────────────────────────────────────────────────────────
+/**
+ * Check if a session has been synced
+ */
+export function isSynced(sessionId) {
+    const state = readState();
+    return state.entries.some(e => e.sessionId === sessionId);
+}
+/**
+ * Check if a session needs update (plan content changed)
+ */
+export function needsUpdate(sessionId, planContent) {
+    const state = readState();
+    const entry = state.entries.find(e => e.sessionId === sessionId);
+    if (!entry)
+        return true; // Not synced yet
+    const currentHash = hashContent(planContent);
+    return entry.planHash !== currentHash;
+}
+/**
+ * Mark a session as synced
+ */
+export function markSynced(sessionId, planContent) {
+    const state = readState();
+    const existingIdx = state.entries.findIndex(e => e.sessionId === sessionId);
+    const entry = {
+        sessionId,
+        syncedAt: new Date().toISOString(),
+        planHash: planContent ? hashContent(planContent) : undefined,
+    };
+    if (existingIdx >= 0) {
+        state.entries[existingIdx] = entry;
+    }
+    else {
+        state.entries.push(entry);
+    }
+    writeState(state);
+}
+/**
+ * Get all synced session IDs
+ */
+export function getSyncedSessionIds() {
+    const state = readState();
+    return state.entries.map(e => e.sessionId);
+}
+/**
+ * Get sessions that haven't been synced yet
+ */
+export function getUnsynced(allSessionIds) {
+    const synced = new Set(getSyncedSessionIds());
+    return allSessionIds.filter(id => !synced.has(id));
+}
+/**
+ * Remove old entries to keep file size manageable
+ * Keeps most recent 500 entries
+ */
+export function pruneOldEntries(keepCount = 500) {
+    const state = readState();
+    if (state.entries.length <= keepCount)
+        return;
+    // Sort by syncedAt descending and keep most recent
+    state.entries.sort((a, b) => {
+        return new Date(b.syncedAt).getTime() - new Date(a.syncedAt).getTime();
+    });
+    state.entries = state.entries.slice(0, keepCount);
+    writeState(state);
+}

package/dist/integrations/mcp/capture/cli-extractor.d.ts

@@ -0,0 +1,18 @@
+export interface Turn {
+    usageUuid: string;
+    agentId: string;
+    userPrompt: string;
+    assistantTexts: string[];
+    reasoningBlocks: string[];
+    toolCalls: Array<{
+        toolName: string;
+        args: Record<string, unknown>;
+    }>;
+    projectPath: string;
+    model: string;
+    isComplete: boolean;
+}
+/**
+ * Main polling function - captures all completed turns from all CLI databases
+ */
+export declare function pollAndCaptureAll(): Promise<void>;

package/dist/integrations/mcp/capture/cli-extractor.js

@@ -0,0 +1,258 @@
+// CLI Extractor - Parse SQLite blobs, identify turns, extract conversation data
+// Cursor CLI stores conversations in protobuf-like blobs with embedded JSON
+import Database from 'better-sqlite3';
+import { findAllCLIDatabases, getConnectTime } from './cli-watcher.js';
+import { isAlreadyCaptured, markAsCaptured, cleanupOldChats } from './cli-synced.js';
+import { transformToApiFormat, postToApi } from './cli-transform.js';
+/**
+ * Main polling function - captures all completed turns from all CLI databases
+ */
+export async function pollAndCaptureAll() {
+    const databases = findAllCLIDatabases();
+    if (databases.length === 0)
+        return;
+    const startTime = getConnectTime();
+    for (const { dbPath, agentId, mtime } of databases) {
+        // Skip DBs not modified since MCP connect
+        if (mtime < startTime)
+            continue;
+        try {
+            await captureFromDatabase(dbPath, agentId);
+        }
+        catch {
+            // Ignore individual database errors
+        }
+    }
+    cleanupOldChats();
+}
+/**
+ * Capture turns from a single CLI database
+ */
+async function captureFromDatabase(dbPath, agentId) {
+    const db = new Database(dbPath, { readonly: true });
+    try {
+        const meta = getMetaData(db);
+        if (!meta)
+            return;
+        const orderedBlobIds = parseRootBlob(db, meta.latestRootBlobId);
+        if (orderedBlobIds.length === 0)
+            return;
+        const turns = identifyAllTurns(db, orderedBlobIds, meta);
+        const completedTurns = turns.filter(turn => turn.isComplete);
+        const newTurns = completedTurns.filter(turn => !isAlreadyCaptured(meta.agentId, turn.usageUuid));
+        if (newTurns.length === 0)
+            return;
+        for (const turn of newTurns) {
+            try {
+                const success = await postToApi(transformToApiFormat(turn, meta));
+                if (success) {
+                    markAsCaptured(meta.agentId, turn.usageUuid);
+                }
+            }
+            catch {
+                // Ignore individual capture errors
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Get meta data from CLI database
+ */
+function getMetaData(db) {
+    try {
+        const row = db.prepare("SELECT value FROM meta WHERE key='0'").get();
+        if (!row)
+            return null;
+        const json = Buffer.from(row.value, 'hex').toString('utf8');
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse root blob to get ordered list of child blob IDs
+ * Root blob contains protobuf-encoded list with 0a20 markers followed by 32-byte hashes
+ */
+function parseRootBlob(db, rootId) {
+    try {
+        const row = db.prepare("SELECT data FROM blobs WHERE id=?").get(rootId);
+        if (!row)
+            return [];
+        const data = row.data;
+        const ids = [];
+        for (let i = 0; i < data.length - 33; i++) {
+            if (data[i] === 0x0a && data[i + 1] === 0x20) {
+                const hash = data.slice(i + 2, i + 34).toString('hex');
+                ids.push(hash);
+                i += 33;
+            }
+        }
+        return ids;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Parse a single blob to extract message data
+ * CLI blobs are JSON with structure: {"role":"...", "content": string | ContentBlock[]}
+ */
+function parseBlob(db, blobId) {
+    try {
+        const row = db.prepare("SELECT data FROM blobs WHERE id=?").get(blobId);
+        if (!row)
+            return null;
+        const dataStr = row.data.toString('utf8');
+        // Skip non-JSON blobs (protobuf/binary)
+        if (!dataStr.startsWith('{'))
+            return null;
+        let json;
+        try {
+            json = JSON.parse(dataStr);
+        }
+        catch {
+            return null; // Not valid JSON
+        }
+        // Must have role (user, assistant, system - skip 'tool')
+        if (!json.role || json.role === 'tool')
+            return null;
+        if (json.role !== 'user' && json.role !== 'assistant' && json.role !== 'system')
+            return null;
+        const content = [];
+        // Handle content field - can be string or array
+        if (typeof json.content === 'string') {
+            // System/context messages have content as string
+            content.push({ type: 'text', text: json.content });
+        }
+        else if (Array.isArray(json.content)) {
+            // User queries and assistant responses have content as array
+            for (const block of json.content) {
+                if (block.type === 'text' && block.text) {
+                    content.push({ type: 'text', text: block.text });
+                }
+                else if (block.type === 'reasoning' && block.text) {
+                    content.push({ type: 'reasoning', text: block.text });
+                }
+                else if (block.type === 'tool-call' && block.toolName) {
+                    content.push({
+                        type: 'tool-call',
+                        toolName: block.toolName,
+                        args: block.args || {}
+                    });
+                }
+            }
+        }
+        // Extract requestId from providerOptions
+        const requestId = json.providerOptions?.cursor?.requestId;
+        return {
+            role: json.role,
+            content,
+            requestId
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Identify all turns from ordered blob IDs
+ * A turn starts with a user message and includes all following assistant messages
+ */
+function identifyAllTurns(db, orderedBlobIds, meta) {
+    const turns = [];
+    let currentTurn = null;
+    for (const blobId of orderedBlobIds) {
+        const message = parseBlob(db, blobId);
+        if (!message)
+            continue;
+        if (message.role === 'user' && hasTextContent(message)) {
+            // New turn starts
+            if (currentTurn && currentTurn.usageUuid) {
+                // Finalize previous turn
+                currentTurn.isComplete = isTurnComplete(currentTurn);
+                turns.push(currentTurn);
+            }
+            // Start new turn
+            currentTurn = {
+                usageUuid: message.requestId || blobId,
+                agentId: meta.agentId,
+                userPrompt: extractTextContent(message),
+                assistantTexts: [],
+                reasoningBlocks: [],
+                toolCalls: [],
+                projectPath: extractProjectPath(message) || '',
+                model: meta.lastUsedModel || 'unknown',
+                isComplete: false
+            };
+        }
+        else if (currentTurn && message.role === 'assistant') {
+            // Add to current turn
+            for (const block of message.content) {
+                if (block.type === 'text' && block.text) {
+                    currentTurn.assistantTexts.push(block.text);
+                }
+                else if (block.type === 'reasoning' && block.text) {
+                    currentTurn.reasoningBlocks.push(block.text);
+                }
+                else if (block.type === 'tool-call' && block.toolName) {
+                    currentTurn.toolCalls.push({
+                        toolName: block.toolName,
+                        args: block.args || {}
+                    });
+                }
+            }
+        }
+    }
+    // Don't forget last turn
+    if (currentTurn && currentTurn.usageUuid) {
+        currentTurn.isComplete = isTurnComplete(currentTurn);
+        turns.push(currentTurn);
+    }
+    return turns;
+}
+/**
+ * Check if message has text content
+ */
+function hasTextContent(message) {
+    return message.content.some(c => c.type === 'text' && c.text && c.text.length > 0);
+}
+/**
+ * Extract text content from message
+ */
+function extractTextContent(message) {
+    return message.content
+        .filter(c => c.type === 'text' && c.text)
+        .map(c => c.text)
+        .join('\n');
+}
+/**
+ * Extract project path from user context message
+ * Looks for "Workspace Path: /path/to/project" pattern
+ */
+function extractProjectPath(message) {
+    const fullText = message.content
+        .filter(c => c.type === 'text' && c.text)
+        .map(c => c.text)
+        .join('\n');
+    const match = fullText.match(/Workspace Path:\s*([^\n]+)/);
+    return match?.[1]?.trim() || null;
+}
+/**
+ * Check if turn is complete
+ * Complete = has text response AND no pending tool calls in final state
+ *
+ * Key insight: By LLM API design, if assistant has text AND wants to call tools,
+ * both MUST be in the SAME message. So text without tool-call = turn complete.
+ */
+function isTurnComplete(turn) {
+    // Must have assistant text response
+    if (!turn.assistantTexts || turn.assistantTexts.length === 0) {
+        return false;
+    }
+    // If has text, turn is complete (tool calls would be in same message)
+    return true;
+}

package/dist/integrations/mcp/capture/cli-synced.d.ts

@@ -0,0 +1,4 @@
+export declare function isAlreadyCaptured(agentId: string, usageUuid: string): boolean;
+export declare function markAsCaptured(agentId: string, usageUuid: string): void;
+export declare function cleanupOldChats(): void;
+export declare function getCapturedForAgent(agentId: string): string[];

package/dist/integrations/mcp/capture/cli-synced.js

@@ -0,0 +1,62 @@
+// CLI Sync Tracker - Deduplication + 6h cleanup
+// File: ~/.grov/cli_synced.json
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const GROV_DIR = join(homedir(), '.grov');
+const SYNCED_FILE = join(GROV_DIR, 'cli_synced.json');
+const SIX_HOURS = 6 * 60 * 60 * 1000;
+function ensureDir() {
+    if (!existsSync(GROV_DIR)) {
+        mkdirSync(GROV_DIR, { recursive: true });
+    }
+}
+function readSyncedFile() {
+    if (!existsSync(SYNCED_FILE)) {
+        return { chats: {} };
+    }
+    try {
+        return JSON.parse(readFileSync(SYNCED_FILE, 'utf-8'));
+    }
+    catch {
+        return { chats: {} };
+    }
+}
+function writeSyncedFile(data) {
+    ensureDir();
+    writeFileSync(SYNCED_FILE, JSON.stringify(data, null, 2));
+}
+export function isAlreadyCaptured(agentId, usageUuid) {
+    const synced = readSyncedFile();
+    return synced.chats[agentId]?.captured.includes(usageUuid) || false;
+}
+export function markAsCaptured(agentId, usageUuid) {
+    const synced = readSyncedFile();
+    if (!synced.chats[agentId]) {
+        synced.chats[agentId] = { captured: [], lastActivity: '' };
+    }
+    if (!synced.chats[agentId].captured.includes(usageUuid)) {
+        synced.chats[agentId].captured.push(usageUuid);
+    }
+    synced.chats[agentId].lastActivity = new Date().toISOString();
+    writeSyncedFile(synced);
+}
+export function cleanupOldChats() {
+    const synced = readSyncedFile();
+    const cutoff = Date.now() - SIX_HOURS;
+    let changed = false;
+    for (const [agentId, data] of Object.entries(synced.chats)) {
+        if (new Date(data.lastActivity).getTime() < cutoff) {
+            delete synced.chats[agentId];
+            changed = true;
+        }
+    }
+    if (changed) {
+        writeSyncedFile(synced);
+    }
+}
+// Get all captured usageUuids for an agent (for debugging)
+export function getCapturedForAgent(agentId) {
+    const synced = readSyncedFile();
+    return synced.chats[agentId]?.captured || [];
+}

package/dist/integrations/mcp/capture/cli-transform.d.ts

@@ -0,0 +1,30 @@
+import type { Turn } from './cli-extractor.js';
+interface ExtractPayload {
+    composerId: string;
+    usageUuid: string;
+    mode: 'ask' | 'plan' | 'agent';
+    projectPath: string;
+    original_query: string;
+    text: string;
+    thinking: string;
+    toolCalls: Array<{
+        name: string;
+        params: Record<string, unknown>;
+    }>;
+}
+interface MetaData {
+    agentId: string;
+    lastUsedModel: string;
+    mode?: string;
+}
+export declare function transformToApiFormat(turn: Turn, meta: MetaData): ExtractPayload;
+/**
+ * Post extracted turn to API
+ * Returns true on success, false on failure
+ */
+export declare function postToApi(payload: ExtractPayload): Promise<boolean>;
+/**
+ * Check if CLI capture is enabled (sync enabled + team ID set)
+ */
+export declare function isCLICaptureEnabled(): boolean;
+export {};

package/dist/integrations/mcp/capture/cli-transform.js

@@ -0,0 +1,62 @@
+// CLI Transform - Convert CLI Turn data to API format and POST to extraction endpoint
+// Reuses same /cursor/extract endpoint as IDE capture
+import { request } from 'undici';
+import { getAccessToken, getSyncStatus } from '../../../core/cloud/credentials.js';
+const API_URL = process.env.GROV_API_URL || 'https://api.grov.dev';
+/**
+ * Transform CLI Turn to API ExtractPayload format
+ * CLI always uses 'agent' mode (no ask/plan distinction in CLI)
+ */
+function stripUserQueryTags(text) {
+    return text.replace(/<\/?user_query>/g, '').trim();
+}
+export function transformToApiFormat(turn, meta) {
+    return {
+        composerId: meta.agentId,
+        usageUuid: turn.usageUuid,
+        mode: 'agent', // CLI always agent mode
+        projectPath: turn.projectPath || 'unknown',
+        original_query: stripUserQueryTags(turn.userPrompt),
+        text: turn.assistantTexts.join('\n'),
+        thinking: turn.reasoningBlocks.join('\n\n'),
+        toolCalls: turn.toolCalls.map(tc => ({
+            name: tc.toolName,
+            params: tc.args
+        }))
+    };
+}
+/**
+ * Post extracted turn to API
+ * Returns true on success, false on failure
+ */
+export async function postToApi(payload) {
+    const syncStatus = getSyncStatus();
+    if (!syncStatus?.enabled || !syncStatus.teamId)
+        return false;
+    const token = await getAccessToken();
+    if (!token)
+        return false;
+    const teamId = syncStatus.teamId;
+    const url = `${API_URL}/teams/${teamId}/cursor/extract`;
+    try {
+        const res = await request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        return res.statusCode === 200;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if CLI capture is enabled (sync enabled + team ID set)
+ */
+export function isCLICaptureEnabled() {
+    const syncStatus = getSyncStatus();
+    return syncStatus?.enabled === true && !!syncStatus.teamId;
+}

package/dist/integrations/mcp/capture/cli-watcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Start CLI capture polling
+ * Returns cleanup function to stop polling
+ */
+export declare function startCLICapture(pollAndCapture: () => Promise<void>): () => void;
+export declare function getConnectTime(): number;
+/**
+ * Find all CLI databases (not just most recent)
+ * Returns array of { dbPath, agentId, mtime }
+ */
+export declare function findAllCLIDatabases(): Array<{
+    dbPath: string;
+    workspaceHash: string;
+    agentId: string;
+    mtime: number;
+}>;
+/**
+ * Find most recently modified CLI database
+ */
+export declare function findMostRecentCLIDatabase(): {
+    dbPath: string;
+    agentId: string;
+} | null;
+/**
+ * Check if CLI chats directory exists
+ */
+export declare function cliChatsExist(): boolean;
+/**
+ * Get the CLI chats path (for debugging/logging)
+ */
+export declare function getCLIChatsPath(): string;

package/dist/integrations/mcp/capture/cli-watcher.js

@@ -0,0 +1,106 @@
+// CLI Watcher - Polling orchestration for Cursor CLI capture
+// Polls every 3 minutes while MCP connection is active
+import { homedir } from 'os';
+import { join } from 'path';
+import { readdirSync, existsSync, statSync } from 'fs';
+const CLI_CHATS_PATH = join(homedir(), '.cursor', 'chats');
+const POLL_INTERVAL = 3 * 60 * 1000; // 3 minutes
+let pollingInterval = null;
+let pollFunction = null;
+let connectTime = 0;
+/**
+ * Start CLI capture polling
+ * Returns cleanup function to stop polling
+ */
+export function startCLICapture(pollAndCapture) {
+    pollFunction = pollAndCapture;
+    connectTime = Date.now();
+    // Initial poll (delayed slightly to let MCP fully connect)
+    setTimeout(() => {
+        pollAndCapture().catch(() => { });
+    }, 5000);
+    // Start interval
+    pollingInterval = setInterval(() => {
+        pollAndCapture().catch(() => { });
+    }, POLL_INTERVAL);
+    // Return cleanup function
+    return () => {
+        if (pollFunction) {
+            pollFunction().catch(() => { });
+        }
+        if (pollingInterval) {
+            clearInterval(pollingInterval);
+            pollingInterval = null;
+        }
+        pollFunction = null;
+    };
+}
+export function getConnectTime() {
+    return connectTime;
+}
+/**
+ * Find all CLI databases (not just most recent)
+ * Returns array of { dbPath, agentId, mtime }
+ */
+export function findAllCLIDatabases() {
+    if (!existsSync(CLI_CHATS_PATH)) {
+        return [];
+    }
+    const databases = [];
+    try {
+        for (const workspaceHash of readdirSync(CLI_CHATS_PATH)) {
+            const wsPath = join(CLI_CHATS_PATH, workspaceHash);
+            // Skip if not a directory
+            try {
+                if (!statSync(wsPath).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            for (const agentId of readdirSync(wsPath)) {
+                const dbPath = join(wsPath, agentId, 'store.db');
+                if (existsSync(dbPath)) {
+                    try {
+                        const stat = statSync(dbPath);
+                        databases.push({
+                            dbPath,
+                            workspaceHash,
+                            agentId,
+                            mtime: stat.mtimeMs
+                        });
+                    }
+                    catch {
+                        // Skip inaccessible files
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore scan errors
+    }
+    // Sort by most recent first
+    return databases.sort((a, b) => b.mtime - a.mtime);
+}
+/**
+ * Find most recently modified CLI database
+ */
+export function findMostRecentCLIDatabase() {
+    const all = findAllCLIDatabases();
+    if (all.length === 0)
+        return null;
+    return { dbPath: all[0].dbPath, agentId: all[0].agentId };
+}
+/**
+ * Check if CLI chats directory exists
+ */
+export function cliChatsExist() {
+    return existsSync(CLI_CHATS_PATH);
+}
+/**
+ * Get the CLI chats path (for debugging/logging)
+ */
+export function getCLIChatsPath() {
+    return CLI_CHATS_PATH;
+}

package/dist/integrations/mcp/capture/hook-handler.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};