grov 0.5.11 → 0.6.13

package/dist/cli/commands/init.js

@@ -0,0 +1,90 @@
+// grov init - Configure AI agent to use grov proxy/MCP
+import { getAgentByName } from '../../integrations/proxy/agents/index.js';
+import { setupMcpCursor, setupMcpAntigravity, setupMcpZed, setupCursorHooks } from './setup.js';
+import { installProjectRules } from '../../integrations/mcp/clients/cursor/rules-installer.js';
+const AGENT_INSTRUCTIONS = {
+    claude: {
+        envVar: 'ANTHROPIC_API_KEY',
+        command: 'claude',
+        keyUrl: 'https://console.anthropic.com/settings/keys',
+    },
+    codex: {
+        envVar: 'OPENAI_API_KEY',
+        command: 'codex',
+        keyUrl: 'https://platform.openai.com/api-keys',
+    },
+};
+export async function init(agentName = 'claude') {
+    // Cursor: MCP-based setup (different from proxy)
+    if (agentName === 'cursor') {
+        console.log('Configuring grov for Cursor...\n');
+        // 1. MCP registration (global)
+        await setupMcpCursor();
+        // 2. Stop hook registration (global)
+        await setupCursorHooks();
+        // 3. Project rules (per-project)
+        const projectDir = process.cwd();
+        const result = installProjectRules(projectDir);
+        if (result.grovRules) {
+            console.log('  + Created .grov/rules.mdc');
+        }
+        else {
+            console.log('  = .grov/rules.mdc already exists');
+        }
+        if (result.cursorPointer) {
+            console.log('  + Created .cursor/rules/90_grov.mdc');
+        }
+        else {
+            console.log('  = .cursor/rules/90_grov.mdc already exists');
+        }
+        console.log('\n--- Next Steps ---');
+        console.log('1. Restart Cursor');
+        console.log('2. Open this project in Cursor');
+        console.log('\nRun "grov doctor cursor" to verify setup.');
+        return;
+    }
+    // Antigravity: MCP-based setup
+    if (agentName === 'antigravity') {
+        console.log('Configuring grov for Antigravity...\n');
+        // MCP registration (global)
+        await setupMcpAntigravity();
+        console.log('\n--- Next Steps ---');
+        console.log('1. Restart Antigravity');
+        console.log('2. Open your project in Antigravity');
+        console.log('\nRun "grov doctor antigravity" to verify setup.');
+        return;
+    }
+    // Zed: MCP-based setup
+    if (agentName === 'zed') {
+        console.log('Configuring grov for Zed...\n');
+        // MCP registration (global)
+        await setupMcpZed();
+        console.log('\n--- Next Steps ---');
+        console.log('1. Restart Zed');
+        console.log('2. Open the Agent Panel in Zed');
+        console.log('\nRun "grov doctor zed" to verify setup.');
+        return;
+    }
+    // Claude/Codex: proxy-based setup
+    const agent = getAgentByName(agentName);
+    if (!agent) {
+        console.error(`Unknown agent: ${agentName}`);
+        console.error('Supported agents: claude, codex, cursor');
+        process.exit(1);
+    }
+    const instructions = AGENT_INSTRUCTIONS[agentName];
+    console.log(`Configuring grov for ${agentName}...\n`);
+    const settings = agent.getSettings();
+    const result = settings.setProxyEnabled(true);
+    if (result.action === 'added') {
+        console.log(`  + Proxy configured for ${agentName}`);
+    }
+    else if (result.action === 'unchanged') {
+        console.log(`  = Proxy already configured for ${agentName}`);
+    }
+    console.log(`\nConfig file: ${settings.getConfigPath()}`);
+    console.log('\n--- Next Steps (Claude/Codex) ---');
+    console.log('1. Terminal 1: grov proxy');
+    console.log(`2. Terminal 2: ${instructions.command}`);
+    console.log('\nRun "grov doctor" to verify your setup is complete.');
+}

package/dist/{commands → cli/commands}/login.js

@@ -2,8 +2,9 @@
 // Authenticates CLI with Grov cloud using OAuth-like device flow
 import open from 'open';
 import * as readline from 'readline';
-import { writeCredentials, isAuthenticated, readCredentials, setTeamId, setSyncEnabled } from '../lib/credentials.js';
-import { startDeviceFlow, pollDeviceFlow, sleep, fetchTeams } from '../lib/api-client.js';
+import { writeCredentials, isAuthenticated, readCredentials, setTeamId, setSyncEnabled } from '../../core/cloud/credentials.js';
+import { startDeviceFlow, pollDeviceFlow, sleep, fetchTeams } from '../../core/cloud/api-client.js';
+import { isAnyAgentConfigured } from '../agents/registry.js';
 /**
  * Prompt user for input
  */
@@ -38,6 +39,7 @@ function decodeTokenPayload(token) {
     }
 }
 export async function login() {
+    const autoMode = process.argv.includes('--auto');
     console.log('Logging in to Grov cloud...\n');
     // Check if already authenticated
     if (isAuthenticated()) {
@@ -119,8 +121,8 @@ export async function login() {
                     return;
                 }
                 let selectedTeam = teams[0];
-                // If multiple teams, let user choose
-                if (teams.length > 1) {
+                // If multiple teams, let user choose (skip in auto mode)
+                if (teams.length > 1 && !autoMode) {
                     console.log('\nYour teams:');
                     teams.forEach((team, i) => {
                         console.log(`  ${i + 1}. ${team.name} (${team.slug})`);
@@ -131,8 +133,8 @@ export async function login() {
                         selectedTeam = teams[index];
                     }
                 }
-                // Ask to enable sync (default yes)
-                const enableSync = await prompt(`Enable cloud sync to "${selectedTeam.name}"? [Y/n]: `);
+                // Ask to enable sync (default yes, skip in auto mode)
+                const enableSync = autoMode ? '' : await prompt(`Enable cloud sync to "${selectedTeam.name}"? [Y/n]: `);
                 if (enableSync !== 'n' && enableSync !== 'no') {
                     setTeamId(selectedTeam.id);
                     setSyncEnabled(true);
@@ -142,21 +144,20 @@ export async function login() {
                     console.log('║                                         ║');
                     console.log('╚═════════════════════════════════════════╝');
                     console.log(`\nSyncing to: ${selectedTeam.name}`);
-                    // Check API key and warn if not set
-                    if (!process.env.ANTHROPIC_API_KEY) {
-                        const shell = process.env.SHELL?.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
-                        console.log('\n⚠️  WARNING: ANTHROPIC_API_KEY not set - memories will NOT sync!');
-                        console.log('\n   Add PERMANENTLY to your shell (not just "export"):');
-                        console.log(`   echo 'export ANTHROPIC_API_KEY=sk-ant-...' >> ${shell}`);
-                        console.log(`   source ${shell}`);
-                        console.log('\n   Get your key at: https://console.anthropic.com/settings/keys');
-                    }
-                    console.log('\nRun "grov doctor" to verify your setup is complete.');
-                    console.log('View memories at: https://app.grov.dev/memories\n');
                 }
                 else {
                     console.log('\n✓ Logged in. Sync not enabled.');
-                    console.log('Run "grov sync --enable" later to start syncing.\n');
+                }
+                // Continue to agent setup if no agent configured
+                if (!isAnyAgentConfigured()) {
+                    console.log('\n───────────────────────────────────────────────────────────\n');
+                    console.log('Now let\'s configure your AI agent...\n');
+                    const { runAgentSetup } = await import('./setup.js');
+                    await runAgentSetup();
+                }
+                else {
+                    console.log('\nRun "grov doctor" to verify your setup is complete.');
+                    console.log('View memories at: https://app.grov.dev/memories\n');
                 }
             }
             catch (err) {

package/dist/{commands → cli/commands}/logout.js

@@ -1,5 +1,5 @@
 // Logout command - Clear stored credentials
-import { clearCredentials, readCredentials } from '../lib/credentials.js';
+import { clearCredentials, readCredentials } from '../../core/cloud/credentials.js';
 export async function logout() {
     const creds = readCredentials();
     if (!creds) {

package/dist/{commands → cli/commands}/proxy-status.js

@@ -1,5 +1,5 @@
 // grov proxy-status - Show active proxy sessions
-import { getActiveSessionsForStatus } from '../lib/store.js';
+import { getActiveSessionsForStatus } from '../../core/store/store.js';
 export async function proxyStatus() {
     const sessions = getActiveSessionsForStatus();
     if (sessions.length === 0) {

package/dist/cli/commands/setup.d.ts

@@ -0,0 +1,6 @@
+export declare function setupCursorHooks(): Promise<void>;
+export declare function setupMcpCursor(): Promise<void>;
+export declare function setupMcpAntigravity(): Promise<void>;
+export declare function setupMcpZed(): Promise<void>;
+export declare function runAgentSetup(): Promise<void>;
+export declare function setup(): Promise<void>;

package/dist/cli/commands/setup.js

@@ -0,0 +1,309 @@
+// Setup commands for grov integrations
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import * as readline from 'readline';
+import { getCliAgentsByType, isAnyAgentConfigured } from '../agents/registry.js';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const cyan = '\x1b[36m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+export async function setupCursorHooks() {
+    const hooksPath = join(homedir(), '.cursor', 'hooks.json');
+    const apiUrl = process.env.GROV_API_URL;
+    const command = apiUrl
+        ? `GROV_API_URL=${apiUrl} grov capture-hook`
+        : 'grov capture-hook';
+    const grovHook = { command };
+    let config = { version: 1, hooks: { stop: [] } };
+    if (existsSync(hooksPath)) {
+        try {
+            const content = readFileSync(hooksPath, 'utf-8');
+            config = JSON.parse(content);
+            if (!config.hooks)
+                config.hooks = {};
+            if (!config.hooks.stop)
+                config.hooks.stop = [];
+        }
+        catch {
+            config = { version: 1, hooks: { stop: [] } };
+        }
+    }
+    // Remove existing grov hook (if any) to replace with new one
+    const hadGrovHook = config.hooks.stop.some((h) => h.command?.includes('grov capture-hook'));
+    config.hooks.stop = config.hooks.stop.filter((h) => !h.command?.includes('grov capture-hook'));
+    // Add new grov hook
+    config.hooks.stop.push(grovHook);
+    try {
+        writeFileSync(hooksPath, JSON.stringify(config, null, 2));
+        if (hadGrovHook) {
+            console.log(`${green}✓${reset} Cursor stop hook updated.`);
+        }
+        else {
+            console.log(`${green}✓${reset} Cursor stop hook configured.`);
+        }
+        if (apiUrl) {
+            console.log(`${dim}  API URL: ${apiUrl}${reset}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`${yellow}⚠${reset} Could not write ${hooksPath}: ${msg}`);
+    }
+}
+export async function setupMcpCursor() {
+    const cursorDir = join(homedir(), '.cursor');
+    const mcpPath = join(cursorDir, 'mcp.json');
+    // Check if Cursor directory exists
+    if (!existsSync(cursorDir)) {
+        console.log(`${yellow}⚠${reset} Cursor not installed (~/.cursor not found)`);
+        console.log(`${dim}Install Cursor first, then run this command again.${reset}\n`);
+        return;
+    }
+    // Build grov entry - add env if GROV_API_URL is set
+    const apiUrl = process.env.GROV_API_URL;
+    const grovEntry = {
+        command: 'grov',
+        args: ['mcp'],
+    };
+    if (apiUrl) {
+        grovEntry.env = { GROV_API_URL: apiUrl };
+    }
+    let mcpConfig = { mcpServers: {} };
+    // Read existing config
+    if (existsSync(mcpPath)) {
+        try {
+            const content = readFileSync(mcpPath, 'utf-8');
+            mcpConfig = JSON.parse(content);
+            if (!mcpConfig.mcpServers) {
+                mcpConfig.mcpServers = {};
+            }
+        }
+        catch {
+            console.log(`${yellow}⚠${reset} Could not parse ${mcpPath}, creating new config.`);
+            mcpConfig = { mcpServers: {} };
+        }
+    }
+    const wasConfigured = !!mcpConfig.mcpServers?.grov;
+    // Always set/update grov entry
+    mcpConfig.mcpServers.grov = grovEntry;
+    // Write config
+    try {
+        writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2));
+        if (wasConfigured) {
+            console.log(`${green}✓${reset} Cursor MCP updated.`);
+        }
+        else {
+            console.log(`${green}✓${reset} Cursor MCP configured.`);
+        }
+        if (apiUrl) {
+            console.log(`${dim}  API URL: ${apiUrl}${reset}`);
+        }
+        console.log(`${dim}Restart Cursor to apply changes.${reset}\n`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`${yellow}⚠${reset} Could not write ${mcpPath}: ${msg}`);
+    }
+}
+export async function setupMcpAntigravity() {
+    const antigravityDir = join(homedir(), '.gemini', 'antigravity');
+    const mcpConfigPath = join(antigravityDir, 'mcp_config.json');
+    // Check if Antigravity directory exists
+    if (!existsSync(antigravityDir)) {
+        console.log(`${yellow}⚠${reset} Antigravity not installed (~/.gemini/antigravity not found)`);
+        console.log(`${dim}Install Antigravity first, then run this command again.${reset}\n`);
+        return;
+    }
+    // Extract project name from cwd (Antigravity runs MCP with cwd="/")
+    const projectPath = process.cwd().split('/').filter(Boolean).pop() || 'unknown';
+    const grovEntry = {
+        command: 'grov',
+        args: ['mcp'],
+        env: {
+            GROV_PROJECT_PATH: projectPath,
+        },
+    };
+    let config = { mcpServers: {} };
+    // Read existing config
+    if (existsSync(mcpConfigPath)) {
+        try {
+            const content = readFileSync(mcpConfigPath, 'utf-8');
+            config = JSON.parse(content);
+            if (!config.mcpServers) {
+                config.mcpServers = {};
+            }
+        }
+        catch {
+            console.log(`${yellow}⚠${reset} Could not parse ${mcpConfigPath}, creating new config.`);
+            config = { mcpServers: {} };
+        }
+    }
+    // Check if already configured
+    if (config.mcpServers?.grov) {
+        console.log(`${green}✓${reset} Antigravity MCP already configured for grov.`);
+        console.log(`${dim}Restart Antigravity to apply any changes.${reset}\n`);
+        return;
+    }
+    // Add grov entry
+    config.mcpServers.grov = grovEntry;
+    // Write config
+    try {
+        writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2));
+        console.log(`${green}✓${reset} Antigravity MCP configured.`);
+        console.log(`${dim}Restart Antigravity to activate grov.${reset}\n`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`${yellow}⚠${reset} Could not write ${mcpConfigPath}: ${msg}`);
+    }
+}
+export async function setupMcpZed() {
+    const zedConfigDir = join(homedir(), '.config', 'zed');
+    const settingsPath = join(zedConfigDir, 'settings.json');
+    // Check if Zed config directory exists
+    if (!existsSync(zedConfigDir)) {
+        console.log(`${yellow}⚠${reset} Zed not installed (~/.config/zed not found)`);
+        console.log(`${dim}Install Zed first, then run this command again.${reset}\n`);
+        return;
+    }
+    const grovEntry = {
+        command: 'grov',
+        args: ['mcp'],
+    };
+    let config = {};
+    // Read existing config (preserve all settings)
+    if (existsSync(settingsPath)) {
+        try {
+            // Zed settings.json may have comments, try to parse anyway
+            const content = readFileSync(settingsPath, 'utf-8');
+            // Remove single-line comments for parsing
+            const cleanContent = content.replace(/^\s*\/\/.*$/gm, '');
+            config = JSON.parse(cleanContent);
+        }
+        catch {
+            console.log(`${yellow}⚠${reset} Could not parse ${settingsPath}. Please add grov manually.`);
+            console.log(`\nAdd to your settings.json under "context_servers":`);
+            console.log(`  "grov": { "command": "grov", "args": ["mcp"] }\n`);
+            return;
+        }
+    }
+    // Ensure context_servers object exists
+    if (!config.context_servers) {
+        config.context_servers = {};
+    }
+    const contextServers = config.context_servers;
+    // Check if already configured
+    if (contextServers.grov) {
+        console.log(`${green}✓${reset} Zed context_servers already configured for grov.`);
+        console.log(`${dim}Restart Zed to apply any changes.${reset}\n`);
+        return;
+    }
+    // Add grov entry
+    contextServers.grov = grovEntry;
+    // Write config
+    try {
+        writeFileSync(settingsPath, JSON.stringify(config, null, 2));
+        console.log(`${green}✓${reset} Zed context_servers configured.`);
+        console.log(`${dim}Restart Zed to activate grov.${reset}\n`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`${yellow}⚠${reset} Could not write ${settingsPath}: ${msg}`);
+    }
+}
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runAgentSetup() {
+    const cliAgents = getCliAgentsByType('cli');
+    const ideAgents = getCliAgentsByType('ide');
+    const allAgents = [...cliAgents, ...ideAgents];
+    console.log('What AI tool do you use?\n');
+    console.log('CLI AGENTS (require proxy running)');
+    cliAgents.forEach((agent, i) => {
+        console.log(`  ${i + 1}. ${agent.name} - ${agent.description}`);
+    });
+    console.log('\nIDE AGENTS (native integration, no proxy)');
+    ideAgents.forEach((agent, i) => {
+        console.log(`  ${cliAgents.length + i + 1}. ${agent.name} - ${agent.description}`);
+    });
+    const choice = await prompt(`\nSelect agent [1-${allAgents.length}]: `);
+    const index = parseInt(choice, 10) - 1;
+    if (index < 0 || index >= allAgents.length || isNaN(index)) {
+        console.log('\nInvalid selection. Run "grov setup" to try again.\n');
+        return;
+    }
+    const selectedAgent = allAgents[index];
+    await configureAgent(selectedAgent);
+    showFinalInstructions(selectedAgent);
+}
+async function configureAgent(agent) {
+    console.log(`\nConfiguring ${agent.name}...\n`);
+    const { init } = await import('./init.js');
+    await init(agent.id);
+}
+function showFinalInstructions(agent) {
+    console.log('\n╔═════════════════════════════════════════════════════════╗');
+    console.log('║                                                         ║');
+    console.log('║   ✓ Setup complete!                                     ║');
+    console.log('║                                                         ║');
+    console.log('╚═════════════════════════════════════════════════════════╝\n');
+    if (agent.type === 'cli') {
+        console.log('┌─────────────────────────────────────────────────────┐');
+        console.log('│  HOW TO USE GROV                                    │');
+        console.log('│                                                     │');
+        console.log('│  1. Start proxy (keep running):                     │');
+        console.log('│     $ grov proxy                                    │');
+        console.log('│                                                     │');
+        console.log('│  2. In another terminal, use your agent:            │');
+        console.log(`│     $ ${agent.command}`.padEnd(54) + '│');
+        console.log('│                                                     │');
+        console.log('│  3. View your team\'s memories:                      │');
+        console.log('│     https://app.grov.dev                            │');
+        console.log('└─────────────────────────────────────────────────────┘');
+    }
+    else {
+        console.log('┌─────────────────────────────────────────────────────┐');
+        console.log('│  HOW TO USE GROV                                    │');
+        console.log('│                                                     │');
+        console.log(`│  1. Restart ${agent.name}`.padEnd(54) + '│');
+        console.log('│                                                     │');
+        console.log(`│  2. Use ${agent.name} normally`.padEnd(54) + '│');
+        console.log('│     Grov runs automatically in the background       │');
+        console.log('│                                                     │');
+        console.log('│  3. View your team\'s memories:                      │');
+        console.log('│     https://app.grov.dev                            │');
+        console.log('└─────────────────────────────────────────────────────┘');
+    }
+    console.log('\nTip: Run "grov doctor" anytime to check status\n');
+}
+export async function setup() {
+    const { isAuthenticated } = await import('../../core/cloud/credentials.js');
+    if (!isAuthenticated()) {
+        console.log('Let\'s get you set up with Grov.\n');
+        console.log('First, we\'ll connect to your team...\n');
+        const { login } = await import('./login.js');
+        await login();
+        return;
+    }
+    if (isAnyAgentConfigured()) {
+        console.log('An agent is already configured.\n');
+        const reconfigure = await prompt('Reconfigure? [y/N]: ');
+        if (reconfigure.toLowerCase() !== 'y' && reconfigure.toLowerCase() !== 'yes') {
+            console.log('\nRun "grov doctor" to check your setup.\n');
+            return;
+        }
+    }
+    await runAgentSetup();
+}

package/dist/{commands → cli/commands}/status.js

@@ -1,5 +1,5 @@
 // grov status - Show stored reasoning for current project
-import { getTasksForProject, getTaskCount, getDatabasePath } from '../lib/store.js';
+import { getTasksForProject, getTaskCount, getDatabasePath } from '../../core/store/store.js';
 export async function status(options) {
     const projectPath = process.cwd();
     console.log('Grov Status');

package/dist/{commands → cli/commands}/sync.d.ts

@@ -4,5 +4,6 @@ export interface SyncOptions {
     team?: string;
     status?: boolean;
     push?: boolean;
+    antigravity?: boolean;
 }
 export declare function sync(options: SyncOptions): Promise<void>;

package/dist/{commands → cli/commands}/sync.js

@@ -1,14 +1,21 @@
 // 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';
+import { readCredentials, setTeamId, setSyncEnabled, getSyncStatus } from '../../core/cloud/credentials.js';
+import { fetchTeams, getApiUrl } from '../../core/cloud/api-client.js';
+import { syncTasks } from '../../core/cloud/cloud-sync.js';
+import { getUnsyncedTasks, markTaskSynced, setTaskSyncError } from '../../core/store/store.js';
+import { scanOnce as scanAntigravity } from '../../integrations/mcp/capture/antigravity-scanner.js';
+import { antigravityExists } from '../../integrations/mcp/capture/antigravity-parser.js';
 export async function sync(options) {
     const creds = readCredentials();
     if (!creds) {
         console.log('Not logged in. Run "grov login" first.\n');
         process.exit(1);
     }
+    // Sync Antigravity sessions
+    if (options.antigravity) {
+        await syncAntigravitySessions();
+        return;
+    }
     // Manual catch-up: push unsynced tasks for current project
     if (options.push) {
         const projectPath = process.cwd();
@@ -125,3 +132,51 @@ export async function sync(options) {
         }
     }
 }
+// ─────────────────────────────────────────────────────────────
+// Antigravity Sync
+// ─────────────────────────────────────────────────────────────
+async function syncAntigravitySessions() {
+    // Check prerequisites
+    if (!antigravityExists()) {
+        console.log('Antigravity not installed.\n');
+        console.log('Antigravity IDE stores its data in ~/.gemini/antigravity/');
+        console.log('Install Antigravity or check if the directory exists.\n');
+        process.exit(1);
+    }
+    const syncStatus = getSyncStatus();
+    if (!syncStatus?.enabled || !syncStatus.teamId) {
+        console.log('Cloud sync not configured.\n');
+        console.log('Enable sync first:');
+        console.log('  grov sync --enable --team <team-id>\n');
+        process.exit(1);
+    }
+    console.log('Scanning Antigravity sessions...\n');
+    try {
+        const result = await scanAntigravity();
+        console.log('Antigravity Sync Results\n');
+        console.log(`  Sessions scanned: ${result.scanned}`);
+        console.log(`  New memories:     ${result.synced}`);
+        console.log(`  Updated:          ${result.updated}`);
+        console.log(`  Skipped:          ${result.skipped}`);
+        console.log(`  Failed:           ${result.failed}`);
+        console.log('');
+        if (result.errors.length > 0) {
+            console.log('Errors:');
+            for (const err of result.errors) {
+                console.log(`  - ${err}`);
+            }
+            console.log('');
+        }
+        if (result.scanned === 0) {
+            console.log('No sessions found in ~/.gemini/antigravity/brain/');
+            console.log('Sessions are created when you use Antigravity IDE.\n');
+        }
+        else if (result.synced === 0 && result.updated === 0 && result.failed === 0) {
+            console.log('All sessions are already synced.\n');
+        }
+    }
+    catch (err) {
+        console.error(`Sync failed: ${err instanceof Error ? err.message : 'Unknown error'}\n`);
+        process.exit(1);
+    }
+}

package/dist/{commands → cli/commands}/uninstall.js

@@ -3,8 +3,8 @@ import { rmSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import * as readline from 'readline';
-import { setProxyEnv } from '../lib/settings.js';
-import { clearCredentials } from '../lib/credentials.js';
+import { setProxyEnv } from '../../integrations/proxy/agents/claude/settings.js';
+import { clearCredentials } from '../../core/cloud/credentials.js';
 const GROV_DIR = join(homedir(), '.grov');
 function prompt(question) {
     const rl = readline.createInterface({