@stupidloud/codegraph 0.7.20 → 0.9.5

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) {
@@ -60,6 +64,7 @@ const directory_1 = require("../directory");
 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 +99,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) => {
@@ -402,6 +423,11 @@ function main() {
                     }
                 }
                 catch { /* non-fatal */ }
+                try {
+                    const { offerWatchFallback } = await Promise.resolve().then(() => __importStar(require('../installer')));
+                    await offerWatchFallback(clack, projectPath);
+                }
+                catch { /* non-fatal */ }
                 clack.outro('');
                 return;
             }
@@ -448,6 +474,11 @@ function main() {
             else {
                 clack.log.info('Run "codegraph index" to index the project');
             }
+            try {
+                const { offerWatchFallback } = await Promise.resolve().then(() => __importStar(require('../installer')));
+                await offerWatchFallback(clack, projectPath);
+            }
+            catch { /* non-fatal */ }
             clack.outro('Done');
             cg.destroy();
         }
@@ -486,6 +517,15 @@ function main() {
             const { default: CodeGraph } = await loadCodeGraph();
             const cg = CodeGraph.openSync(projectPath);
             cg.uninitialize();
+            // Clean up any git sync hooks we installed (no-op if none / not a repo).
+            try {
+                const { removeGitSyncHook } = await Promise.resolve().then(() => __importStar(require('../sync/git-hooks')));
+                const removed = removeGitSyncHook(projectPath);
+                if (removed.installed.length > 0) {
+                    info(`Removed git ${removed.installed.join(', ')} sync hook${removed.installed.length > 1 ? 's' : ''}`);
+                }
+            }
+            catch { /* non-fatal */ }
             success(`Removed CodeGraph from ${projectPath}`);
         }
         catch (err) {
@@ -637,6 +677,7 @@ function main() {
             const stats = cg.getStats();
             const changes = cg.getChangedFiles();
             const backend = cg.getBackend();
+            const journalMode = cg.getJournalMode();
             // JSON output mode
             if (options.json) {
                 console.log(JSON.stringify({
@@ -647,6 +688,7 @@ function main() {
                     edgeCount: stats.edgeCount,
                     dbSizeBytes: stats.dbSizeBytes,
                     backend,
+                    journalMode,
                     nodesByKind: stats.nodesByKind,
                     languages: Object.entries(stats.filesByLanguage).filter(([, count]) => count > 0).map(([lang]) => lang),
                     pendingChanges: {
@@ -668,14 +710,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:'));
@@ -988,8 +1034,14 @@ function main() {
         .description('Start CodeGraph as an MCP server for AI assistants')
         .option('-p, --path <path>', 'Project path (optional for MCP mode, uses rootUri from client)')
         .option('--mcp', 'Run as MCP server (stdio transport)')
+        .option('--no-watch', 'Disable the file watcher (no auto-sync; useful on slow filesystems like WSL2 /mnt drives)')
         .action(async (options) => {
         const projectPath = options.path ? resolveProjectPath(options.path) : undefined;
+        // Commander sets watch=false when --no-watch is passed. Route it through
+        // the same env-var chokepoint the watcher and MCP server already honor.
+        if (options.watch === false) {
+            process.env.CODEGRAPH_NO_WATCH = '1';
+        }
         try {
             if (options.mcp) {
                 // Start MCP server - it handles initialization lazily based on rootUri from client
@@ -1189,6 +1241,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...]
      *
@@ -1324,7 +1611,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')
@@ -1373,6 +1660,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()