grov 0.5.11 → 0.6.13

package/dist/integrations/mcp/cache.js

@@ -0,0 +1,106 @@
+// MCP In-Memory Cache
+// Caches preview results for expand calls
+// Uses 8-char memory IDs for lookup (consistent with local proxy)
+// Keyed by project path with TTL
+// ─────────────────────────────────────────────────────────────
+// Configuration
+// ─────────────────────────────────────────────────────────────
+const TTL_MS = 10 * 60 * 1000; // 10 minutes
+// ─────────────────────────────────────────────────────────────
+// Cache Storage
+// ─────────────────────────────────────────────────────────────
+// Keyed by project path
+const previewCache = new Map();
+// ─────────────────────────────────────────────────────────────
+// Project Path
+// ─────────────────────────────────────────────────────────────
+/**
+ * Get current project path
+ * Used as cache key and for API filtering
+ *
+ * Cursor sets WORKSPACE_FOLDER_PATHS env var with the open workspace path.
+ * We extract just the folder name to match how proxy stores project_path.
+ */
+export function getProjectPath() {
+    // Check explicit project path (set by grov init antigravity)
+    if (process.env.GROV_PROJECT_PATH) {
+        return process.env.GROV_PROJECT_PATH;
+    }
+    const workspacePaths = process.env.WORKSPACE_FOLDER_PATHS;
+    if (workspacePaths) {
+        // Can be multiple paths separated by some delimiter, take first one
+        const firstPath = workspacePaths.split(':')[0] || workspacePaths;
+        // Extract just the folder name (e.g., "/home/marian/Grov" -> "Grov")
+        const folderName = firstPath.split('/').filter(Boolean).pop();
+        if (folderName) {
+            return folderName;
+        }
+    }
+    // Fallback to cwd folder name
+    const cwdParts = process.cwd().split('/').filter(Boolean);
+    return cwdParts.pop() || process.cwd();
+}
+// ─────────────────────────────────────────────────────────────
+// Cache Operations
+// ─────────────────────────────────────────────────────────────
+/**
+ * Store memories from preview call
+ * Indexes by 8-char ID prefix for fast lookup
+ */
+export function setPreviewCache(memories) {
+    const projectPath = getProjectPath();
+    const memoriesById = new Map();
+    const cachedIds = [];
+    for (const m of memories) {
+        const shortId = m.id.substring(0, 8);
+        memoriesById.set(shortId, m);
+        cachedIds.push(shortId);
+    }
+    previewCache.set(projectPath, {
+        memoriesById,
+        timestamp: Date.now(),
+        cachedIds,
+    });
+}
+/**
+ * Get cached entry (internal use)
+ * Returns null if cache expired or missing
+ */
+function getPreviewCache() {
+    const projectPath = getProjectPath();
+    const entry = previewCache.get(projectPath);
+    if (!entry)
+        return null;
+    // Check TTL
+    if (Date.now() - entry.timestamp > TTL_MS) {
+        previewCache.delete(projectPath);
+        return null;
+    }
+    return entry;
+}
+/**
+ * Get memory by 8-char ID
+ * Handles both 8-char and full UUID (extracts first 8 chars)
+ */
+export function getMemoryById(id) {
+    const cache = getPreviewCache();
+    if (!cache)
+        return null;
+    // Normalize to 8-char
+    const shortId = id.substring(0, 8);
+    return cache.memoriesById.get(shortId) || null;
+}
+/**
+ * Get list of cached IDs (for error messages)
+ */
+export function getCachedIds() {
+    const cache = getPreviewCache();
+    return cache?.cachedIds || [];
+}
+/**
+ * Clear preview cache (e.g., when project changes)
+ */
+export function clearPreviewCache() {
+    const projectPath = getProjectPath();
+    previewCache.delete(projectPath);
+}

package/dist/integrations/mcp/capture/antigravity-parser.d.ts

@@ -0,0 +1,26 @@
+export interface AntigravitySession {
+    sessionId: string;
+    projectPath: string;
+    linkedCommit: string | null;
+    title: string;
+    metadataSummary: string;
+    planContent: string;
+    taskContent: string;
+    filesTouched: string[];
+    completionStatus: 'complete' | 'partial';
+    updatedAt: string;
+}
+export declare function antigravityExists(): boolean;
+export declare function isAntigravityConfigured(): boolean;
+/**
+ * Get all session UUIDs from the brain folder
+ */
+export declare function getAllSessionIds(): string[];
+/**
+ * Parse a single session by UUID
+ */
+export declare function parseSession(sessionId: string): AntigravitySession | null;
+/**
+ * Get sessions sorted by updatedAt (most recent first)
+ */
+export declare function getSessionsSortedByDate(): AntigravitySession[];

package/dist/integrations/mcp/capture/antigravity-parser.js

@@ -0,0 +1,272 @@
+// Antigravity Session Parser
+// Reads plan files from ~/.gemini/antigravity/brain/
+// and file tracking from ~/.gemini/antigravity/code_tracker/
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const ANTIGRAVITY_DIR = join(homedir(), '.gemini', 'antigravity');
+const BRAIN_DIR = join(ANTIGRAVITY_DIR, 'brain');
+const CODE_TRACKER_DIR = join(ANTIGRAVITY_DIR, 'code_tracker', 'active');
+const MCP_CONFIG_PATH = join(ANTIGRAVITY_DIR, 'mcp_config.json');
+// ─────────────────────────────────────────────────────────────
+// Directory Checks
+// ─────────────────────────────────────────────────────────────
+export function antigravityExists() {
+    return existsSync(BRAIN_DIR);
+}
+export function isAntigravityConfigured() {
+    if (!existsSync(MCP_CONFIG_PATH))
+        return false;
+    try {
+        const config = JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf-8'));
+        return !!config.mcpServers?.grov;
+    }
+    catch {
+        return false;
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Session Discovery
+// ─────────────────────────────────────────────────────────────
+/**
+ * Get all session UUIDs from the brain folder
+ */
+export function getAllSessionIds() {
+    if (!existsSync(BRAIN_DIR))
+        return [];
+    try {
+        return readdirSync(BRAIN_DIR)
+            .filter(name => {
+            const path = join(BRAIN_DIR, name);
+            // Must be a directory and look like a UUID
+            return statSync(path).isDirectory() && isValidUuid(name);
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check if string looks like a UUID
+ */
+function isValidUuid(str) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+// ─────────────────────────────────────────────────────────────
+// File Reading Helpers
+// ─────────────────────────────────────────────────────────────
+function readTextFile(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonFile(path) {
+    const content = readTextFile(path);
+    if (!content)
+        return null;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function parseTaskMd(content) {
+    const lines = content.split('\n');
+    // Extract title from first heading
+    let title = '';
+    for (const line of lines) {
+        if (line.startsWith('# ')) {
+            title = line.substring(2).trim();
+            break;
+        }
+    }
+    // Count checkboxes for completion status
+    const checkedCount = (content.match(/- \[x\]/gi) || []).length;
+    const uncheckedCount = (content.match(/- \[ \]/g) || []).length;
+    const totalBoxes = checkedCount + uncheckedCount;
+    const completionStatus = totalBoxes === 0 || checkedCount === totalBoxes ? 'complete' : 'partial';
+    return {
+        title: title || 'Untitled Task',
+        completionStatus,
+        content,
+    };
+}
+// ─────────────────────────────────────────────────────────────
+// Implementation Plan Parsing
+// ─────────────────────────────────────────────────────────────
+/**
+ * Extract file paths from [MODIFY] markers in implementation plan
+ */
+function extractFilesFromPlan(content) {
+    const files = [];
+    // Match [MODIFY] [filename](file://...) patterns
+    const modifyRegex = /\[MODIFY\]\s*\[([^\]]+)\]/g;
+    let match;
+    while ((match = modifyRegex.exec(content)) !== null) {
+        files.push(match[1]);
+    }
+    // Also match file:// URLs and extract filenames
+    const fileUrlRegex = /file:\/\/[^\s\)]+\/([^\/\s\)]+\.[a-z]+)/gi;
+    while ((match = fileUrlRegex.exec(content)) !== null) {
+        const filename = match[1];
+        if (!files.includes(filename)) {
+            files.push(filename);
+        }
+    }
+    return files;
+}
+/**
+ * Parse code_tracker/active/ folder for project and files
+ * Folder format: {ProjectName}_{commitHash}/
+ * File format: {hash}_{filename}
+ */
+function parseCodeTracker() {
+    if (!existsSync(CODE_TRACKER_DIR))
+        return [];
+    const results = [];
+    try {
+        const projectFolders = readdirSync(CODE_TRACKER_DIR);
+        for (const folder of projectFolders) {
+            const folderPath = join(CODE_TRACKER_DIR, folder);
+            if (!statSync(folderPath).isDirectory())
+                continue;
+            // Parse folder name: ProjectName_commitHash
+            const lastUnderscore = folder.lastIndexOf('_');
+            if (lastUnderscore === -1)
+                continue;
+            const projectPath = folder.substring(0, lastUnderscore);
+            const linkedCommit = folder.substring(lastUnderscore + 1);
+            // Get files in folder
+            const files = readdirSync(folderPath);
+            const filesTouched = [];
+            for (const file of files) {
+                // File format: {hash}_{filename}
+                const underscoreIdx = file.indexOf('_');
+                if (underscoreIdx > 0) {
+                    const filename = file.substring(underscoreIdx + 1);
+                    filesTouched.push(filename);
+                }
+            }
+            results.push({
+                projectPath,
+                linkedCommit: linkedCommit || null,
+                filesTouched,
+            });
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return results;
+}
+/**
+ * Find the most recent code tracker entry (by modification time)
+ */
+function getMostRecentCodeTracker() {
+    if (!existsSync(CODE_TRACKER_DIR))
+        return null;
+    try {
+        const folders = readdirSync(CODE_TRACKER_DIR)
+            .map(name => ({
+            name,
+            path: join(CODE_TRACKER_DIR, name),
+        }))
+            .filter(f => statSync(f.path).isDirectory())
+            .map(f => ({
+            ...f,
+            mtime: statSync(f.path).mtime.getTime(),
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        if (folders.length === 0)
+            return null;
+        const mostRecent = folders[0];
+        const lastUnderscore = mostRecent.name.lastIndexOf('_');
+        if (lastUnderscore === -1)
+            return null;
+        const projectPath = mostRecent.name.substring(0, lastUnderscore);
+        const linkedCommit = mostRecent.name.substring(lastUnderscore + 1);
+        const files = readdirSync(mostRecent.path);
+        const filesTouched = [];
+        for (const file of files) {
+            const underscoreIdx = file.indexOf('_');
+            if (underscoreIdx > 0) {
+                filesTouched.push(file.substring(underscoreIdx + 1));
+            }
+        }
+        return { projectPath, linkedCommit, filesTouched };
+    }
+    catch {
+        return null;
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Session Parsing
+// ─────────────────────────────────────────────────────────────
+/**
+ * Parse a single session by UUID
+ */
+export function parseSession(sessionId) {
+    const sessionDir = join(BRAIN_DIR, sessionId);
+    if (!existsSync(sessionDir))
+        return null;
+    // Read task.md
+    const taskContent = readTextFile(join(sessionDir, 'task.md'));
+    if (!taskContent)
+        return null; // No task = skip
+    const taskParsed = parseTaskMd(taskContent);
+    // Read implementation_plan.md (optional)
+    const planContent = readTextFile(join(sessionDir, 'implementation_plan.md')) || '';
+    // Read metadata files
+    const taskMetadata = readJsonFile(join(sessionDir, 'task.md.metadata.json'));
+    const planMetadata = readJsonFile(join(sessionDir, 'implementation_plan.md.metadata.json'));
+    // Prefer plan metadata summary, fall back to task metadata
+    const metadataSummary = planMetadata?.summary || taskMetadata?.summary || taskParsed.title;
+    const updatedAt = planMetadata?.updatedAt || taskMetadata?.updatedAt || new Date().toISOString();
+    // Get files from plan content
+    const filesFromPlan = extractFilesFromPlan(planContent);
+    // Get files from code tracker (use most recent as approximation)
+    const codeTracker = getMostRecentCodeTracker();
+    // Merge files, prefer code tracker
+    const allFiles = new Set([
+        ...(codeTracker?.filesTouched || []),
+        ...filesFromPlan,
+    ]);
+    return {
+        sessionId,
+        projectPath: codeTracker?.projectPath || 'unknown',
+        linkedCommit: codeTracker?.linkedCommit || null,
+        title: taskParsed.title,
+        metadataSummary,
+        planContent,
+        taskContent: taskParsed.content,
+        filesTouched: Array.from(allFiles),
+        completionStatus: taskParsed.completionStatus,
+        updatedAt,
+    };
+}
+/**
+ * Get sessions sorted by updatedAt (most recent first)
+ */
+export function getSessionsSortedByDate() {
+    const sessionIds = getAllSessionIds();
+    const sessions = [];
+    for (const id of sessionIds) {
+        const session = parseSession(id);
+        if (session) {
+            sessions.push(session);
+        }
+    }
+    // Sort by updatedAt descending
+    sessions.sort((a, b) => {
+        const dateA = new Date(a.updatedAt).getTime();
+        const dateB = new Date(b.updatedAt).getTime();
+        return dateB - dateA;
+    });
+    return sessions;
+}

package/dist/integrations/mcp/capture/antigravity-scanner.d.ts

@@ -0,0 +1,24 @@
+export interface ScanResult {
+    scanned: number;
+    synced: number;
+    updated: number;
+    skipped: number;
+    failed: number;
+    errors: string[];
+}
+/**
+ * Perform a single scan of Antigravity sessions
+ */
+export declare function scanOnce(): Promise<ScanResult>;
+/**
+ * Start the periodic scanner
+ */
+export declare function startScanner(): void;
+/**
+ * Stop the periodic scanner
+ */
+export declare function stopScanner(): void;
+/**
+ * Check if scanner is running
+ */
+export declare function isScannerRunning(): boolean;

package/dist/integrations/mcp/capture/antigravity-scanner.js

@@ -0,0 +1,153 @@
+// Antigravity Periodic Scanner
+// Scans ~/.gemini/antigravity/brain/ for new/updated sessions
+// and syncs them to the Grov API
+import { antigravityExists, getAllSessionIds, parseSession, } from './antigravity-parser.js';
+import { isSynced, needsUpdate, markSynced, pruneOldEntries, } from './antigravity-sync-tracker.js';
+import { getAccessToken, getSyncStatus } from '../../../core/cloud/credentials.js';
+import { getApiUrl } from '../../../core/cloud/api-client.js';
+import { mcpLog } from '../logger.js';
+// ─────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────
+const SCAN_INTERVAL_MS = 3 * 60 * 1000; // 3 minutes
+let scannerInterval = null;
+async function syncSessionToApi(session, teamId, token) {
+    const apiUrl = getApiUrl();
+    const url = `${apiUrl}/teams/${teamId}/antigravity/extract`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(session),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            return { success: false, error: `HTTP ${response.status}: ${text}` };
+        }
+        const result = (await response.json());
+        return {
+            success: result.success,
+            action: result.action,
+            memoryId: result.memoryId,
+        };
+    }
+    catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : 'Unknown error' };
+    }
+}
+/**
+ * Perform a single scan of Antigravity sessions
+ */
+export async function scanOnce() {
+    const result = {
+        scanned: 0,
+        synced: 0,
+        updated: 0,
+        skipped: 0,
+        failed: 0,
+        errors: [],
+    };
+    // Check prerequisites
+    if (!antigravityExists()) {
+        mcpLog('[ANTIGRAVITY-SCANNER] Antigravity not installed, skipping scan');
+        return result;
+    }
+    const syncStatus = getSyncStatus();
+    if (!syncStatus?.enabled || !syncStatus.teamId) {
+        mcpLog('[ANTIGRAVITY-SCANNER] Sync not enabled or no team configured');
+        return result;
+    }
+    const token = await getAccessToken();
+    if (!token) {
+        mcpLog('[ANTIGRAVITY-SCANNER] No access token, skipping scan');
+        return result;
+    }
+    // Get all sessions
+    const sessionIds = getAllSessionIds();
+    mcpLog(`[ANTIGRAVITY-SCANNER] Found ${sessionIds.length} total sessions`);
+    for (const sessionId of sessionIds) {
+        result.scanned++;
+        // Parse session
+        const session = parseSession(sessionId);
+        if (!session) {
+            mcpLog(`[ANTIGRAVITY-SCANNER] Failed to parse session ${sessionId}`);
+            continue;
+        }
+        // Check if needs sync
+        const alreadySynced = isSynced(sessionId);
+        const hasUpdates = needsUpdate(sessionId, session.planContent);
+        if (alreadySynced && !hasUpdates) {
+            result.skipped++;
+            continue;
+        }
+        // Sync to API
+        mcpLog(`[ANTIGRAVITY-SCANNER] Syncing session ${sessionId.slice(0, 8)}... (${alreadySynced ? 'update' : 'new'})`);
+        const syncResult = await syncSessionToApi(session, syncStatus.teamId, token);
+        if (syncResult.success) {
+            markSynced(sessionId, session.planContent);
+            if (syncResult.action === 'insert') {
+                result.synced++;
+                mcpLog(`[ANTIGRAVITY-SCANNER] Inserted memory ${syncResult.memoryId?.slice(0, 8)}...`);
+            }
+            else if (syncResult.action === 'update') {
+                result.updated++;
+                mcpLog(`[ANTIGRAVITY-SCANNER] Updated memory ${syncResult.memoryId?.slice(0, 8)}...`);
+            }
+            else {
+                result.skipped++;
+                mcpLog(`[ANTIGRAVITY-SCANNER] Skipped (no extractable content)`);
+            }
+        }
+        else {
+            result.failed++;
+            result.errors.push(`Session ${sessionId.slice(0, 8)}: ${syncResult.error}`);
+            mcpLog(`[ANTIGRAVITY-SCANNER] Failed: ${syncResult.error}`);
+        }
+    }
+    // Prune old entries periodically
+    pruneOldEntries();
+    mcpLog(`[ANTIGRAVITY-SCANNER] Scan complete: scanned=${result.scanned}, synced=${result.synced}, updated=${result.updated}, skipped=${result.skipped}, failed=${result.failed}`);
+    return result;
+}
+// ─────────────────────────────────────────────────────────────
+// Scanner Control
+// ─────────────────────────────────────────────────────────────
+/**
+ * Start the periodic scanner
+ */
+export function startScanner() {
+    if (scannerInterval) {
+        mcpLog('[ANTIGRAVITY-SCANNER] Scanner already running');
+        return;
+    }
+    mcpLog('[ANTIGRAVITY-SCANNER] Starting periodic scanner (3 min interval)');
+    // Run immediately
+    scanOnce().catch(err => {
+        mcpLog(`[ANTIGRAVITY-SCANNER] Initial scan error: ${err}`);
+    });
+    // Then run periodically
+    scannerInterval = setInterval(() => {
+        scanOnce().catch(err => {
+            mcpLog(`[ANTIGRAVITY-SCANNER] Scan error: ${err}`);
+        });
+    }, SCAN_INTERVAL_MS);
+}
+/**
+ * Stop the periodic scanner
+ */
+export function stopScanner() {
+    if (scannerInterval) {
+        clearInterval(scannerInterval);
+        scannerInterval = null;
+        mcpLog('[ANTIGRAVITY-SCANNER] Scanner stopped');
+    }
+}
+/**
+ * Check if scanner is running
+ */
+export function isScannerRunning() {
+    return scannerInterval !== null;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Simple hash for detecting plan content changes
+ */
+export declare function hashContent(content: string): string;
+/**
+ * Check if a session has been synced
+ */
+export declare function isSynced(sessionId: string): boolean;
+/**
+ * Check if a session needs update (plan content changed)
+ */
+export declare function needsUpdate(sessionId: string, planContent: string): boolean;
+/**
+ * Mark a session as synced
+ */
+export declare function markSynced(sessionId: string, planContent?: string): void;
+/**
+ * Get all synced session IDs
+ */
+export declare function getSyncedSessionIds(): string[];
+/**
+ * Get sessions that haven't been synced yet
+ */
+export declare function getUnsynced(allSessionIds: string[]): string[];
+/**
+ * Remove old entries to keep file size manageable
+ * Keeps most recent 500 entries
+ */
+export declare function pruneOldEntries(keepCount?: number): void;