@stupidloud/codegraph 0.8.1 → 0.9.9

package/dist/bin/codegraph.d.ts

@@ -7,6 +7,7 @@
  * Usage:
  *   codegraph                    Run interactive installer (when no args)
  *   codegraph install            Run interactive installer
+ *   codegraph uninstall          Remove CodeGraph from your agents
  *   codegraph init [path]        Initialize CodeGraph in a project
  *   codegraph uninit [path]      Remove CodeGraph from a project
  *   codegraph index [path]       Index all files in the project
@@ -15,6 +16,9 @@
  *   codegraph query <search>     Search for symbols
  *   codegraph files [options]    Show project file structure
  *   codegraph context <task>     Build context for a task
+ *   codegraph callers <symbol>   Find what calls a function/method
+ *   codegraph callees <symbol>   Find what a function/method calls
+ *   codegraph impact <symbol>    Analyze what code is affected by changing a symbol
  *   codegraph affected [files]   Find test files affected by changes
  */
 export {};

package/dist/bin/codegraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegraph.d.ts","sourceRoot":"","sources":["../../src/bin/codegraph.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG"}
+{"version":3,"file":"codegraph.d.ts","sourceRoot":"","sources":["../../src/bin/codegraph.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/bin/codegraph.js

@@ -8,6 +8,7 @@
  * Usage:
  *   codegraph                    Run interactive installer (when no args)
  *   codegraph install            Run interactive installer
+ *   codegraph uninstall          Remove CodeGraph from your agents
  *   codegraph init [path]        Initialize CodeGraph in a project
  *   codegraph uninit [path]      Remove CodeGraph from a project
  *   codegraph index [path]       Index all files in the project
@@ -16,6 +17,9 @@
  *   codegraph query <search>     Search for symbols
  *   codegraph files [options]    Show project file structure
  *   codegraph context <task>     Build context for a task
+ *   codegraph callers <symbol>   Find what calls a function/method
+ *   codegraph callees <symbol>   Find what a function/method calls
+ *   codegraph impact <symbol>    Analyze what code is affected by changing a symbol
  *   codegraph affected [files]   Find test files affected by changes
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -57,9 +61,11 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
 const directory_1 = require("../directory");
+const worktree_1 = require("../sync/worktree");
 const shimmer_progress_1 = require("../ui/shimmer-progress");
 const glyphs_1 = require("../ui/glyphs");
 const node_version_check_1 = require("./node-version-check");
+const wasm_runtime_flags_1 = require("../extraction/wasm-runtime-flags");
 // Lazy-load heavy modules (CodeGraph, runInstaller) to keep CLI startup fast.
 async function loadCodeGraph() {
     try {
@@ -94,6 +100,22 @@ if (nodeMajor >= 25) {
     }
     // Override active — banner shown for visibility, continuing.
 }
+// Enforce the supported Node floor. `engines` in package.json only *warns* on
+// install (unless engine-strict), so hard-block here to actually keep users off
+// unsupported versions. Mirrors the 25+ block above. See package.json `engines`.
+if (nodeMajor < node_version_check_1.MIN_NODE_MAJOR) {
+    process.stderr.write((0, node_version_check_1.buildNodeTooOldBanner)(nodeVersion) + '\n');
+    if (!process.env.CODEGRAPH_ALLOW_UNSAFE_NODE) {
+        process.exit(1);
+    }
+    // Override active — banner shown for visibility, continuing.
+}
+// Re-exec with V8's `--liftoff-only` if it isn't already set, so tree-sitter's
+// large WASM grammars never hit the turboshaft Zone OOM (`Fatal process out of
+// memory: Zone`) on Node >= 22. No-op under the bundled launcher, which already
+// passes the flag. Must run before any grammar (in the parse worker, which
+// inherits this process's flags) is compiled. See ../extraction/wasm-runtime-flags.
+(0, wasm_runtime_flags_1.relaunchWithWasmRuntimeFlagsIfNeeded)(__filename);
 // Check if running with no arguments - run installer
 if (process.argv.length === 2) {
     Promise.resolve().then(() => __importStar(require('../installer'))).then(({ runInstaller }) => runInstaller()).catch((err) => {
@@ -381,8 +403,8 @@ function main() {
      */
     program
         .command('init [path]')
-        .description('Initialize CodeGraph in a project directory')
-        .option('-i, --index', 'Run initial indexing after initialization')
+        .description('Initialize CodeGraph in a project directory and build the initial index')
+        .option('-i, --index', 'Deprecated: indexing now runs by default; flag accepted for backward compatibility')
         .option('-v, --verbose', 'Show detailed worker lifecycle and memory info')
         .action(async (pathArg, options) => {
         const projectPath = path.resolve(pathArg || process.cwd());
@@ -392,16 +414,6 @@ function main() {
             if ((0, directory_1.isInitialized)(projectPath)) {
                 clack.log.warn(`Already initialized in ${projectPath}`);
                 clack.log.info('Use "codegraph index" to re-index or "codegraph sync" to update');
-                // Re-run agent surface wiring so re-running `init` is the
-                // documented way to recover a project that's missing its
-                // Cursor rules file (or future per-agent project surfaces).
-                try {
-                    const { wireProjectSurfacesForGlobalAgents } = await Promise.resolve().then(() => __importStar(require('../installer')));
-                    for (const { target, file } of wireProjectSurfacesForGlobalAgents()) {
-                        clack.log.success(`${target.displayName}: ${file.action} ${file.path}`);
-                    }
-                }
-                catch { /* non-fatal */ }
                 try {
                     const { offerWatchFallback } = await Promise.resolve().then(() => __importStar(require('../installer')));
                     await offerWatchFallback(clack, projectPath);
@@ -418,41 +430,25 @@ function main() {
                 config: semanticConfig,
             });
             clack.log.success(`Initialized in ${projectPath}`);
-            // Bootstrap project-local surfaces for any agent that's
-            // configured globally (Cursor needs ./.cursor/rules/codegraph.mdc
-            // to actually prefer codegraph over native grep). Silent when
-            // there's nothing to write.
-            try {
-                const { wireProjectSurfacesForGlobalAgents } = await Promise.resolve().then(() => __importStar(require('../installer')));
-                for (const { target, file } of wireProjectSurfacesForGlobalAgents()) {
-                    clack.log.success(`${target.displayName}: ${file.action} ${file.path}`);
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                clack.log.warn(`Skipped wiring project-local agent surfaces: ${msg}`);
-            }
-            if (options.index) {
-                let result;
-                if (options.verbose) {
-                    result = await cg.indexAll({
-                        onProgress: createVerboseProgress(),
-                        verbose: true,
-                    });
-                }
-                else {
-                    process.stdout.write(`${colors.dim}${(0, glyphs_1.getGlyphs)().rail}${colors.reset}\n`);
-                    const progress = (0, shimmer_progress_1.createShimmerProgress)();
-                    result = await cg.indexAll({
-                        onProgress: progress.onProgress,
-                    });
-                    await progress.stop();
-                }
-                printIndexResult(clack, result, projectPath);
+            // Indexing runs by default now. The legacy -i/--index flag is still
+            // accepted (so existing muscle memory and scripts don't break) but is a
+            // no-op — initializing always builds the initial index.
+            let result;
+            if (options.verbose) {
+                result = await cg.indexAll({
+                    onProgress: createVerboseProgress(),
+                    verbose: true,
+                });
             }
             else {
-                clack.log.info('Run "codegraph index" to index the project');
+                process.stdout.write(`${colors.dim}${(0, glyphs_1.getGlyphs)().rail}${colors.reset}\n`);
+                const progress = (0, shimmer_progress_1.createShimmerProgress)();
+                result = await cg.indexAll({
+                    onProgress: progress.onProgress,
+                });
+                await progress.stop();
             }
+            printIndexResult(clack, result, projectPath);
             try {
                 const { offerWatchFallback } = await Promise.resolve().then(() => __importStar(require('../installer')));
                 await offerWatchFallback(clack, projectPath);
@@ -639,10 +635,21 @@ function main() {
         .option('-j, --json', 'Output as JSON')
         .action(async (pathArg, options) => {
         const projectPath = resolveProjectPath(pathArg);
+        // The directory the user actually ran from, before walking up to the index
+        // root. Used to detect when the resolved index lives in a different git
+        // working tree (e.g. a nested worktree borrowing the main checkout's index).
+        const startPath = path.resolve(pathArg || process.cwd());
+        const worktreeMismatch = (0, worktree_1.detectWorktreeIndexMismatch)(startPath, projectPath);
         try {
             if (!(0, directory_1.isInitialized)(projectPath)) {
                 if (options.json) {
-                    console.log(JSON.stringify({ initialized: false, projectPath }));
+                    console.log(JSON.stringify({
+                        initialized: false,
+                        version: packageJson.version,
+                        projectPath,
+                        indexPath: (0, directory_1.getCodeGraphDir)(projectPath),
+                        lastIndexed: null,
+                    }));
                     return;
                 }
                 console.log(chalk.bold('\nCodeGraph Status\n'));
@@ -656,16 +663,22 @@ function main() {
             const stats = cg.getStats();
             const changes = cg.getChangedFiles();
             const backend = cg.getBackend();
+            const journalMode = cg.getJournalMode();
             // JSON output mode
             if (options.json) {
+                const lastIndexedMs = cg.getLastIndexedAt();
                 console.log(JSON.stringify({
                     initialized: true,
+                    version: packageJson.version,
                     projectPath,
+                    indexPath: (0, directory_1.getCodeGraphDir)(projectPath),
+                    lastIndexed: lastIndexedMs != null ? new Date(lastIndexedMs).toISOString() : null,
                     fileCount: stats.fileCount,
                     nodeCount: stats.nodeCount,
                     edgeCount: stats.edgeCount,
                     dbSizeBytes: stats.dbSizeBytes,
                     backend,
+                    journalMode,
                     nodesByKind: stats.nodesByKind,
                     languages: Object.entries(stats.filesByLanguage).filter(([, count]) => count > 0).map(([lang]) => lang),
                     pendingChanges: {
@@ -673,6 +686,9 @@ function main() {
                         modified: changes.modified.length,
                         removed: changes.removed.length,
                     },
+                    worktreeMismatch: worktreeMismatch
+                        ? { worktreeRoot: worktreeMismatch.worktreeRoot, indexRoot: worktreeMismatch.indexRoot }
+                        : null,
                 }));
                 cg.destroy();
                 return;
@@ -680,6 +696,9 @@ function main() {
             console.log(chalk.bold('\nCodeGraph Status\n'));
             // Project info
             console.log(chalk.cyan('Project:'), projectPath);
+            if (worktreeMismatch) {
+                warn((0, worktree_1.worktreeMismatchWarning)(worktreeMismatch));
+            }
             console.log();
             // Index stats
             console.log(chalk.bold('Index Statistics:'));
@@ -687,14 +706,18 @@ function main() {
             console.log(`  Nodes:     ${formatNumber(stats.nodeCount)}`);
             console.log(`  Edges:     ${formatNumber(stats.edgeCount)}`);
             console.log(`  DB Size:   ${(stats.dbSizeBytes / 1024 / 1024).toFixed(2)} MB`);
-            // Surface the active SQLite backend so users can spot the silent
-            // WASM fallback (5-10x slower). better-sqlite3 is in
-            // `optionalDependencies`, so `npm install` succeeds without it
-            // when the native build fails.
-            const backendLabel = backend === 'native'
-                ? chalk.green('native')
-                : chalk.yellow(`wasm ${(0, glyphs_1.getGlyphs)().dash} slower fallback; run \`npm rebuild better-sqlite3\``);
+            // Surface the active SQLite backend (node:sqlite — Node's built-in real
+            // SQLite, full WAL + FTS5, no native build).
+            const backendLabel = chalk.green(`node:sqlite ${(0, glyphs_1.getGlyphs)().dash} built-in (full WAL)`);
             console.log(`  Backend:   ${backendLabel}`);
+            // Effective journal mode: 'wal' means concurrent reads never block on a
+            // writer; anything else means they can ("database is locked"). node:sqlite
+            // supports WAL everywhere, so a non-wal mode means the filesystem can't
+            // (network mounts, WSL2 /mnt). See issue #238.
+            const journalLabel = journalMode === 'wal'
+                ? chalk.green('wal')
+                : chalk.yellow(`${journalMode || 'unknown'} ${(0, glyphs_1.getGlyphs)().dash} WAL inactive; reads can block on writes`);
+            console.log(`  Journal:   ${journalLabel}`);
             console.log();
             // Node breakdown
             console.log(chalk.bold('Nodes by Kind:'));
@@ -760,10 +783,19 @@ function main() {
             const { default: CodeGraph } = await loadCodeGraph();
             const cg = await CodeGraph.open(projectPath);
             const limit = parseInt(options.limit || '10', 10);
-            const results = cg.searchNodes(search, {
+            const rawResults = cg.searchNodes(search, {
                 limit,
                 kinds: options.kind ? [options.kind] : undefined,
             });
+            // Mirror the MCP search down-rank so the CLI also surfaces the
+            // hand-written implementation before protobuf/gRPC scaffolding
+            // when both share a name. See extraction/generated-detection.ts.
+            const { isGeneratedFile } = await Promise.resolve().then(() => __importStar(require('../extraction/generated-detection')));
+            const results = [...rawResults].sort((a, b) => {
+                const aGen = isGeneratedFile(a.node.filePath) ? 1 : 0;
+                const bGen = isGeneratedFile(b.node.filePath) ? 1 : 0;
+                return aGen - bGen;
+            });
             if (options.json) {
                 console.log(JSON.stringify(results, null, 2));
             }
@@ -964,41 +996,6 @@ function main() {
         };
         renderNode(root, '', true, 0);
     }
-    /**
-     * codegraph context <task>
-     */
-    program
-        .command('context <task>')
-        .description('Build context for a task (outputs markdown)')
-        .option('-p, --path <path>', 'Project path')
-        .option('-n, --max-nodes <number>', 'Maximum nodes to include', '50')
-        .option('-c, --max-code <number>', 'Maximum code blocks', '10')
-        .option('--no-code', 'Exclude code blocks')
-        .option('-f, --format <format>', 'Output format (markdown, json)', 'markdown')
-        .action(async (task, options) => {
-        const projectPath = resolveProjectPath(options.path);
-        try {
-            if (!(0, directory_1.isInitialized)(projectPath)) {
-                error(`CodeGraph not initialized in ${projectPath}`);
-                process.exit(1);
-            }
-            const { default: CodeGraph } = await loadCodeGraph();
-            const cg = await CodeGraph.open(projectPath);
-            const context = await cg.buildContext(task, {
-                maxNodes: parseInt(options.maxNodes || '50', 10),
-                maxCodeBlocks: parseInt(options.maxCode || '10', 10),
-                includeCode: options.code !== false,
-                format: options.format,
-            });
-            // Output the context
-            console.log(context);
-            cg.destroy();
-        }
-        catch (err) {
-            error(`Failed to build context: ${err instanceof Error ? err.message : String(err)}`);
-            process.exit(1);
-        }
-    });
     /**
      * codegraph serve
      */
@@ -1040,8 +1037,8 @@ function main() {
 }
 `));
                 console.error('Available tools:');
+                console.error(chalk.cyan('  codegraph_explore') + '   - Primary: source of the relevant symbols for any question');
                 console.error(chalk.cyan('  codegraph_search') + '    - Search for code symbols');
-                console.error(chalk.cyan('  codegraph_context') + '   - Build context for a task');
                 console.error(chalk.cyan('  codegraph_callers') + '   - Find callers of a symbol');
                 console.error(chalk.cyan('  codegraph_callees') + '   - Find what a symbol calls');
                 console.error(chalk.cyan('  codegraph_impact') + '    - Analyze impact of changes');
@@ -1214,6 +1211,241 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * codegraph callers <symbol>
+     *
+     * CLI parity with the MCP graph tools (codegraph_callers/callees/impact) so the
+     * traversal queries work in scripts, CI, and git hooks without a running MCP
+     * server.
+     */
+    program
+        .command('callers <symbol>')
+        .description('Find all functions/methods that call a specific symbol')
+        .option('-p, --path <path>', 'Project path')
+        .option('-l, --limit <number>', 'Maximum results', '20')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (symbol, options) => {
+        const projectPath = resolveProjectPath(options.path);
+        try {
+            if (!(0, directory_1.isInitialized)(projectPath)) {
+                error(`CodeGraph not initialized in ${projectPath}`);
+                process.exit(1);
+            }
+            const { default: CodeGraph } = await loadCodeGraph();
+            const cg = await CodeGraph.open(projectPath);
+            const limit = parseInt(options.limit || '20', 10);
+            const matches = cg.searchNodes(symbol, { limit: 50 });
+            if (matches.length === 0) {
+                info(`Symbol "${symbol}" not found`);
+                cg.destroy();
+                return;
+            }
+            const seen = new Set();
+            const allCallers = [];
+            for (const match of matches) {
+                const exactMatch = match.node.name === symbol || match.node.name.endsWith(`.${symbol}`) || match.node.name.endsWith(`::${symbol}`);
+                if (!exactMatch && matches.length > 1)
+                    continue;
+                for (const c of cg.getCallers(match.node.id)) {
+                    if (!seen.has(c.node.id)) {
+                        seen.add(c.node.id);
+                        allCallers.push({ name: c.node.name, kind: c.node.kind, filePath: c.node.filePath, startLine: c.node.startLine });
+                    }
+                }
+            }
+            // Fallback: if exact filter removed everything, use the top match
+            if (allCallers.length === 0 && matches[0]) {
+                for (const c of cg.getCallers(matches[0].node.id)) {
+                    if (!seen.has(c.node.id)) {
+                        seen.add(c.node.id);
+                        allCallers.push({ name: c.node.name, kind: c.node.kind, filePath: c.node.filePath, startLine: c.node.startLine });
+                    }
+                }
+            }
+            const limited = allCallers.slice(0, limit);
+            if (options.json) {
+                console.log(JSON.stringify({ symbol, callers: limited }, null, 2));
+            }
+            else if (limited.length === 0) {
+                info(`No callers found for "${symbol}"`);
+            }
+            else {
+                console.log(chalk.bold(`\nCallers of "${symbol}" (${limited.length}):\n`));
+                for (const node of limited) {
+                    const loc = node.startLine ? `:${node.startLine}` : '';
+                    console.log(chalk.cyan(node.kind.padEnd(12)) +
+                        chalk.white(node.name));
+                    console.log(chalk.dim(`  ${node.filePath}${loc}`));
+                    console.log();
+                }
+            }
+            cg.destroy();
+        }
+        catch (err) {
+            error(`callers failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * codegraph callees <symbol>
+     */
+    program
+        .command('callees <symbol>')
+        .description('Find all functions/methods that a specific symbol calls')
+        .option('-p, --path <path>', 'Project path')
+        .option('-l, --limit <number>', 'Maximum results', '20')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (symbol, options) => {
+        const projectPath = resolveProjectPath(options.path);
+        try {
+            if (!(0, directory_1.isInitialized)(projectPath)) {
+                error(`CodeGraph not initialized in ${projectPath}`);
+                process.exit(1);
+            }
+            const { default: CodeGraph } = await loadCodeGraph();
+            const cg = await CodeGraph.open(projectPath);
+            const limit = parseInt(options.limit || '20', 10);
+            const matches = cg.searchNodes(symbol, { limit: 50 });
+            if (matches.length === 0) {
+                info(`Symbol "${symbol}" not found`);
+                cg.destroy();
+                return;
+            }
+            const seen = new Set();
+            const allCallees = [];
+            for (const match of matches) {
+                const exactMatch = match.node.name === symbol || match.node.name.endsWith(`.${symbol}`) || match.node.name.endsWith(`::${symbol}`);
+                if (!exactMatch && matches.length > 1)
+                    continue;
+                for (const c of cg.getCallees(match.node.id)) {
+                    if (!seen.has(c.node.id)) {
+                        seen.add(c.node.id);
+                        allCallees.push({ name: c.node.name, kind: c.node.kind, filePath: c.node.filePath, startLine: c.node.startLine });
+                    }
+                }
+            }
+            if (allCallees.length === 0 && matches[0]) {
+                for (const c of cg.getCallees(matches[0].node.id)) {
+                    if (!seen.has(c.node.id)) {
+                        seen.add(c.node.id);
+                        allCallees.push({ name: c.node.name, kind: c.node.kind, filePath: c.node.filePath, startLine: c.node.startLine });
+                    }
+                }
+            }
+            const limited = allCallees.slice(0, limit);
+            if (options.json) {
+                console.log(JSON.stringify({ symbol, callees: limited }, null, 2));
+            }
+            else if (limited.length === 0) {
+                info(`No callees found for "${symbol}"`);
+            }
+            else {
+                console.log(chalk.bold(`\nCallees of "${symbol}" (${limited.length}):\n`));
+                for (const node of limited) {
+                    const loc = node.startLine ? `:${node.startLine}` : '';
+                    console.log(chalk.cyan(node.kind.padEnd(12)) +
+                        chalk.white(node.name));
+                    console.log(chalk.dim(`  ${node.filePath}${loc}`));
+                    console.log();
+                }
+            }
+            cg.destroy();
+        }
+        catch (err) {
+            error(`callees failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
+    /**
+     * codegraph impact <symbol>
+     */
+    program
+        .command('impact <symbol>')
+        .description('Analyze what code is affected by changing a symbol')
+        .option('-p, --path <path>', 'Project path')
+        .option('-d, --depth <number>', 'Traversal depth', '2')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (symbol, options) => {
+        const projectPath = resolveProjectPath(options.path);
+        try {
+            if (!(0, directory_1.isInitialized)(projectPath)) {
+                error(`CodeGraph not initialized in ${projectPath}`);
+                process.exit(1);
+            }
+            const { default: CodeGraph } = await loadCodeGraph();
+            const cg = await CodeGraph.open(projectPath);
+            const depth = Math.min(Math.max(parseInt(options.depth || '2', 10), 1), 10);
+            const matches = cg.searchNodes(symbol, { limit: 50 });
+            if (matches.length === 0) {
+                info(`Symbol "${symbol}" not found`);
+                cg.destroy();
+                return;
+            }
+            // Merge impact subgraphs across all exact-matching symbols
+            const mergedNodes = new Map();
+            const seenEdges = new Set();
+            let edgeCount = 0;
+            for (const match of matches) {
+                const exactMatch = match.node.name === symbol || match.node.name.endsWith(`.${symbol}`) || match.node.name.endsWith(`::${symbol}`);
+                if (!exactMatch && matches.length > 1)
+                    continue;
+                const impact = cg.getImpactRadius(match.node.id, depth);
+                for (const [id, n] of impact.nodes) {
+                    mergedNodes.set(id, { name: n.name, kind: n.kind, filePath: n.filePath, startLine: n.startLine });
+                }
+                for (const e of impact.edges) {
+                    const key = `${e.source}->${e.target}:${e.kind}`;
+                    if (!seenEdges.has(key)) {
+                        seenEdges.add(key);
+                        edgeCount++;
+                    }
+                }
+            }
+            // Fallback to top match if exact filter removed everything
+            if (mergedNodes.size === 0 && matches[0]) {
+                const impact = cg.getImpactRadius(matches[0].node.id, depth);
+                for (const [id, n] of impact.nodes) {
+                    mergedNodes.set(id, { name: n.name, kind: n.kind, filePath: n.filePath, startLine: n.startLine });
+                }
+                edgeCount = impact.edges.length;
+            }
+            if (options.json) {
+                console.log(JSON.stringify({
+                    symbol,
+                    depth,
+                    nodeCount: mergedNodes.size,
+                    edgeCount,
+                    affected: Array.from(mergedNodes.values()),
+                }, null, 2));
+            }
+            else if (mergedNodes.size === 0) {
+                info(`No affected symbols found for "${symbol}"`);
+            }
+            else {
+                console.log(chalk.bold(`\nImpact of changing "${symbol}" — ${mergedNodes.size} affected symbols:\n`));
+                // Group by file
+                const byFile = new Map();
+                for (const node of mergedNodes.values()) {
+                    const list = byFile.get(node.filePath) || [];
+                    list.push({ name: node.name, kind: node.kind, startLine: node.startLine });
+                    byFile.set(node.filePath, list);
+                }
+                for (const [file, nodes] of byFile) {
+                    console.log(chalk.cyan(file));
+                    for (const node of nodes) {
+                        const loc = node.startLine ? `:${node.startLine}` : '';
+                        console.log(`  ${chalk.dim(node.kind.padEnd(12))}${node.name}${chalk.dim(loc)}`);
+                    }
+                    console.log();
+                }
+            }
+            cg.destroy();
+        }
+        catch (err) {
+            error(`impact failed: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
     /**
      * codegraph affected [files...]
      *
@@ -1349,7 +1581,7 @@ function main() {
      */
     program
         .command('install')
-        .description('Install codegraph MCP server into one or more agents (Claude Code, Cursor, Codex CLI, opencode)')
+        .description('Install codegraph MCP server into one or more agents (Claude Code, Cursor, Codex CLI, opencode, Hermes Agent)')
         .option('-t, --target <ids>', 'Target agent(s): comma-separated ids, or "auto"|"all"|"none". Default: prompt')
         .option('-l, --location <where>', 'Install location: "global" or "local". Default: prompt')
         .option('-y, --yes', 'Non-interactive: defaults to --location=global --target=auto, auto-allow on')
@@ -1398,6 +1630,38 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * codegraph uninstall
+     *
+     * Inverse of `install`. Removes the codegraph MCP server entry,
+     * instructions block, and permissions from every agent (or a
+     * `--target` subset). Prompts global-vs-local when not given. Does NOT
+     * delete the `.codegraph/` index — that's `codegraph uninit`.
+     */
+    program
+        .command('uninstall')
+        .description('Remove codegraph from your agents (Claude Code, Cursor, Codex CLI, opencode, Hermes Agent)')
+        .option('-t, --target <ids>', 'Target agent(s): comma-separated ids, or "all". Default: all')
+        .option('-l, --location <where>', 'Uninstall location: "global" or "local". Default: prompt')
+        .option('-y, --yes', 'Non-interactive: defaults to --location=global --target=all')
+        .action(async (opts) => {
+        const { runUninstaller } = await Promise.resolve().then(() => __importStar(require('../installer')));
+        if (opts.location && opts.location !== 'global' && opts.location !== 'local') {
+            error(`--location must be "global" or "local" (got "${opts.location}").`);
+            process.exit(1);
+        }
+        try {
+            await runUninstaller({
+                target: opts.target,
+                location: opts.location,
+                yes: opts.yes,
+            });
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
     // Parse and run
     program.parse();
 } // end main()