@colbymchenry/codegraph-darwin-x64 1.0.0 → 1.1.0

package/lib/dist/bin/codegraph.js

@@ -65,6 +65,7 @@ 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 fatal_handler_1 = require("./fatal-handler");
 const wasm_runtime_flags_1 = require("../extraction/wasm-runtime-flags");
 const extraction_version_1 = require("../extraction/extraction-version");
 const telemetry_1 = require("../telemetry");
@@ -118,6 +119,12 @@ if (nodeMajor < node_version_check_1.MIN_NODE_MAJOR) {
 // 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);
+// Last-resort fatal handlers: log a bounded line and exit non-zero. A fault
+// that reaches here escaped every boundary, so the process is in an undefined
+// state — keeping it alive is what let the detached MCP daemon orphan and pin a
+// CPU core with no recovery (#799, #850). Installed before the command branch
+// so it also covers a synchronous throw during startup. See ./fatal-handler.
+(0, fatal_handler_1.installFatalHandlers)();
 // Check if running with no arguments - run installer
 if (process.argv.length === 2) {
     Promise.resolve().then(() => __importStar(require('../installer'))).then(({ runInstaller }) => runInstaller()).catch((err) => {
@@ -129,16 +136,21 @@ else {
     // Normal CLI flow
     main();
 }
-process.on('uncaughtException', (error) => {
-    console.error('[CodeGraph] Uncaught exception:', error);
-});
-process.on('unhandledRejection', (reason) => {
-    console.error('[CodeGraph] Unhandled rejection:', reason);
-});
 function main() {
     const program = new commander_1.Command();
     // Version from package.json
     const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+    // Make the version trivial to reach. commander's `.version()` (below) wires up
+    // `--version` and `-V`; intercept the spellings it can't — lowercase `-v` and
+    // single-dash `-version` — before any parsing. (commander's version short flag
+    // is the capital `-V`, and its parser rejects a multi-character single-dash
+    // flag.) The bare `codegraph version` subcommand is registered further down so
+    // the affordance also shows up in `codegraph --help`.
+    const firstArg = process.argv[2];
+    if (firstArg === '-v' || firstArg === '-version') {
+        console.log(packageJson.version);
+        return;
+    }
     // =============================================================================
     // ANSI Color Helpers (avoid chalk ESM issues)
     // =============================================================================
@@ -432,12 +444,24 @@ function main() {
         .command('init [path]')
         .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('-f, --force', 'Initialize even if the path looks like your home directory or a filesystem root')
         .option('-v, --verbose', 'Show detailed worker lifecycle and memory info')
         .action(async (pathArg, options) => {
         const projectPath = path.resolve(pathArg || process.cwd());
         const clack = await importESM('@clack/prompts');
         clack.intro('Initializing CodeGraph');
         try {
+            // Refuse to index your home directory / a filesystem root — it pulls in
+            // caches, other projects, and your whole tree (a multi-GB index + watcher
+            // churn, and on pre-1.0 macOS a machine-crashing fd blowup, #845).
+            const unsafe = (0, directory_1.unsafeIndexRootReason)(projectPath);
+            if (unsafe && !options.force) {
+                clack.log.error(`Refusing to initialize in ${projectPath} — it looks like ${unsafe}.`);
+                clack.log.info('Run this inside a specific project directory, or pass --force if you really mean to index everything under it.');
+                clack.outro('');
+                process.exitCode = 1;
+                return;
+            }
             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');
@@ -543,13 +567,20 @@ function main() {
      */
     program
         .command('index [path]')
-        .description('Index all files in the project')
-        .option('-f, --force', 'Force full re-index even if already indexed')
+        .description('Rebuild the full index from scratch (same result as a fresh init)')
+        .option('-f, --force', 'Index even if the path looks like your home directory or a filesystem root')
         .option('-q, --quiet', 'Suppress progress output')
         .option('-v, --verbose', 'Show detailed worker lifecycle and memory info')
         .action(async (pathArg, options) => {
         const projectPath = resolveProjectPath(pathArg);
         try {
+            // Don't (re)index your home directory / a filesystem root (#845). --force
+            // doubles as the override.
+            const unsafe = (0, directory_1.unsafeIndexRootReason)(projectPath);
+            if (unsafe && !options.force) {
+                error(`Refusing to index ${projectPath} — it looks like ${unsafe}. Pass --force to override.`);
+                process.exit(1);
+            }
             if (!(0, directory_1.isInitialized)(projectPath)) {
                 error(`CodeGraph not initialized in ${projectPath}`);
                 info('Run "codegraph init" first');
@@ -558,9 +589,9 @@ function main() {
             const { default: CodeGraph } = await loadCodeGraph();
             const cg = await CodeGraph.open(projectPath);
             if (options.quiet) {
-                // Quiet mode: no UI, just run
-                if (options.force)
-                    cg.clear();
+                // Quiet mode: no UI, just run. `index` is a full re-index, so clear the
+                // existing graph and rebuild from scratch (see the note below — #874).
+                cg.clear();
                 const result = await cg.indexAll();
                 if (!result.success)
                     process.exit(1);
@@ -569,10 +600,12 @@ function main() {
             }
             const clack = await importESM('@clack/prompts');
             clack.intro('Indexing project');
-            if (options.force) {
-                cg.clear();
-                clack.log.info('Cleared existing index');
-            }
+            // `index` is a FULL re-index: clear the existing graph and rebuild it from
+            // scratch so the result is identical to a fresh `init`. Without the clear,
+            // indexAll() skips every unchanged file by its content hash and reports
+            // "0 nodes, 0 edges" against the already-populated graph — which reads as
+            // "index wiped my index" (#874). For fast incremental updates use `sync`.
+            cg.clear();
             let result;
             if (options.verbose) {
                 result = await cg.indexAll({
@@ -800,7 +833,7 @@ function main() {
             if (reindexRecommended) {
                 const builtWith = buildInfo.version ? `v${buildInfo.version.replace(/^v/, '')}` : 'an earlier version';
                 warn(`Index was built by ${builtWith}; re-index to pick up this engine's improvements.`);
-                info('Run "codegraph index -f" (full rebuild) or "codegraph sync"');
+                info('Run "codegraph index" (full rebuild) or "codegraph sync"');
                 console.log();
             }
             cg.destroy();
@@ -913,6 +946,104 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * codegraph prompt-hook  (hidden)
+     *
+     * A Claude Code `UserPromptSubmit` hook entry point. Reads `{prompt, cwd}` JSON
+     * on stdin; for a structural/flow/impact prompt it runs `codegraph_explore` on
+     * the indexed project and prints the result to stdout, which Claude injects into
+     * the agent's context — so the agent's reflex grep/read has nothing left to find
+     * and reliably uses CodeGraph (the adoption problem). Installed by the installer
+     * into Claude's settings.json (opt-in, default-yes).
+     *
+     * LOAD-BEARING: this must NEVER break the user's prompt. Every failure path —
+     * kill-switch, non-structural prompt, no index, engine error — exits 0 with no
+     * output. The only effect is additive context when it can confidently provide it.
+     */
+    program
+        .command('prompt-hook', { hidden: true })
+        .description('Claude UserPromptSubmit hook: inject CodeGraph context for structural prompts (reads {prompt,cwd} JSON on stdin)')
+        .action(async () => {
+        try {
+            // Kill-switch: lets a user disable the nudge without uninstalling /
+            // editing settings.json (CI, low-power machines, personal preference).
+            if (process.env.CODEGRAPH_NO_PROMPT_HOOK === '1' || process.env.CODEGRAPH_PROMPT_HOOK === '0')
+                return;
+            if (process.stdin.isTTY)
+                return; // invoked by hand, no piped payload
+            const raw = await new Promise((resolve) => {
+                let data = '';
+                process.stdin.setEncoding('utf8');
+                process.stdin.on('data', (c) => { data += c; });
+                process.stdin.on('end', () => resolve(data));
+                process.stdin.on('error', () => resolve(data));
+            });
+            let input = {};
+            try {
+                input = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            const prompt = String(input.prompt || '');
+            // Gate: only structural / flow / impact / where-how prompts get context.
+            // A cheap regex keeps every other prompt ("fix this typo") a zero-cost
+            // no-op so we never add latency where there's no structural answer to give.
+            const STRUCTURAL = /\b(how|where|trace|flow|path|reach(?:es|ed)?|call(?:s|ed|er|ers|ee)?|depend|impact|affect|wired?|connect|implement|architect|structure|breaks?|what calls|why does)\b/i;
+            if (!prompt || !STRUCTURAL.test(prompt))
+                return;
+            // Decide what to inject, shaped by WHERE the index(es) are: the nearest
+            // indexed ancestor of cwd, or — when cwd is an un-indexed workspace root
+            // whose indexed project(s) live in sub-dirs (the monorepo case, #964) —
+            // the sub-project the prompt points at, plus a `projectPath` nudge for any
+            // others. Without the down-scan the hook injected nothing at a monorepo
+            // root (it only walked up), so the validated adoption lever never fired
+            // exactly where the agent most needs it.
+            const plan = (0, directory_1.planFrontload)(String(input.cwd || process.cwd()), prompt);
+            if (!plan.exploreRoot && plan.nudgeProjects.length === 0)
+                return; // nothing reachable — the agent's normal tools apply
+            // A "pass projectPath" line for indexed sub-projects we did NOT front-load.
+            // Follow-up codegraph_explore calls against a sub-project (cwd isn't its
+            // index root) need an explicit projectPath, so spell it out.
+            const nudge = (projects, lead) => `${lead}\n${projects.map((p) => `  - projectPath: "${p}"`).join('\n')}\n`;
+            if (plan.exploreRoot) {
+                const { default: CodeGraph } = await loadCodeGraph();
+                const cg = await CodeGraph.open(plan.exploreRoot);
+                try {
+                    const { ToolHandler } = await Promise.resolve().then(() => __importStar(require('../mcp/tools')));
+                    const handler = new ToolHandler(cg);
+                    const result = await handler.execute('codegraph_explore', { query: prompt });
+                    const text = result.content[0]?.text ?? '';
+                    if (!result.isError && text.trim()) {
+                        // Cap the injection so a large-repo explore can't flood the prompt.
+                        const MAX = 16000;
+                        const body = text.length > MAX ? `${text.slice(0, MAX)}\n…(truncated; call codegraph_explore for the rest)` : text;
+                        // For a front-loaded SUB-project, a follow-up explore needs its path.
+                        const more = plan.viaSubScan
+                            ? `call codegraph_explore with projectPath: "${plan.exploreRoot}" for more`
+                            : 'call codegraph_explore for more';
+                        const others = plan.nudgeProjects.length
+                            ? `\n${nudge(plan.nudgeProjects, 'Other indexed projects in this workspace — pass projectPath to query them:')}`
+                            : '';
+                        process.stdout.write(`<codegraph_context note="Structural context from CodeGraph for this prompt — treat returned source as already read; ${more}.">\n${body}${others}\n</codegraph_context>\n`);
+                    }
+                }
+                finally {
+                    cg.destroy();
+                }
+            }
+            else {
+                // Several indexed sub-projects, none a clear match — don't guess; tell
+                // the agent they exist and how to query one.
+                process.stdout.write(`<codegraph_context note="CodeGraph is available for this workspace's indexed sub-projects — query one by passing projectPath to codegraph_explore.">\n` +
+                    nudge(plan.nudgeProjects, "This workspace's CodeGraph indexes live in sub-projects. To use CodeGraph, call codegraph_explore with the projectPath of the relevant one:") +
+                    `</codegraph_context>\n`);
+            }
+        }
+        catch {
+            // Degradable by contract: never surface an error to the prompt pipeline.
+        }
+    });
     /**
      * codegraph node <name>
      *
@@ -1081,6 +1212,24 @@ function main() {
             process.exit(1);
         }
     });
+    /**
+     * Normalize a user-supplied file path to the project-relative, forward-slash
+     * form CodeGraph stores in the index. Accepts an absolute path, a `./`-prefixed
+     * path, or Windows back-slashes; an empty string when the input is blank. Used
+     * by `codegraph affected` so `./src/x.ts`, `/abs/repo/src/x.ts`, and
+     * `src/x.ts` all match the same indexed file. (#825)
+     */
+    function normalizeIndexPath(filePath, projectPath) {
+        let f = filePath.trim();
+        if (!f)
+            return '';
+        if (path.isAbsolute(f))
+            f = path.relative(projectPath, f);
+        // Collapse `.`/`..` segments, then force forward slashes and drop a leading
+        // `./` (path.normalize already strips it on POSIX; explicit for Windows).
+        f = path.normalize(f).replace(/\\/g, '/').replace(/^\.\//, '');
+        return f;
+    }
     /**
      * Convert glob pattern to regex
      */
@@ -1143,11 +1292,66 @@ function main() {
         };
         renderNode(root, '', true, 0);
     }
+    /**
+     * codegraph daemon — interactive manager for the background daemons. Arrow keys
+     * to pick one (the current project's daemon floats to the top, auto-selected),
+     * enter to stop it. Falls back to a plain list when output isn't a TTY.
+     */
+    program
+        .command('daemon')
+        .aliases(['daemons'])
+        .description('Manage running CodeGraph background daemons — pick one and press enter to stop it')
+        .action(async () => {
+        const { listDaemons, stopDaemonAt, stopAllDaemons } = await Promise.resolve().then(() => __importStar(require('../mcp/daemon-registry')));
+        const { runDaemonPicker } = await Promise.resolve().then(() => __importStar(require('../mcp/daemon-manager')));
+        const daemons = listDaemons();
+        if (daemons.length === 0) {
+            info('No CodeGraph daemons running.');
+            return;
+        }
+        // No TTY (piped / CI / non-interactive) — can't do arrow-key selection, so
+        // just print what's running instead of crashing on a prompt with no input.
+        if (!process.stdout.isTTY || !process.stdin.isTTY) {
+            for (const d of daemons) {
+                console.log(`pid ${d.pid}  v${d.version}  up ${formatDuration(Date.now() - d.startedAt)}  ${d.root}`);
+            }
+            return;
+        }
+        // The current project's daemon floats to the top and is pre-selected.
+        let cwdRoot = null;
+        const found = (0, directory_1.findNearestCodeGraphRoot)(process.cwd());
+        if (found) {
+            try {
+                cwdRoot = fs.realpathSync(found);
+            }
+            catch {
+                cwdRoot = found;
+            }
+        }
+        const clack = await importESM('@clack/prompts');
+        clack.intro('CodeGraph daemons');
+        await runDaemonPicker({
+            list: listDaemons,
+            stop: stopDaemonAt,
+            stopAll: stopAllDaemons,
+            cwdRoot,
+            now: () => Date.now(),
+            select: (opts) => clack.select(opts),
+            isCancel: (v) => clack.isCancel(v),
+            note: (m) => clack.log.success(m),
+            done: (m) => clack.outro(m),
+        });
+    });
     /**
      * codegraph serve
      */
     program
-        .command('serve')
+        // Hidden from `--help`: this is the stdio entry point an AI agent launches
+        // for itself (the installer wires `args: ['serve','--mcp']` into every
+        // agent's MCP config), not a command a human runs. It still works when
+        // invoked — hiding only removes it from the listing. See the interactive-TTY
+        // guard below, which explains this to anyone who runs it by hand.
+        .command('serve', { hidden: true })
         .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)')
@@ -1161,6 +1365,22 @@ function main() {
         }
         try {
             if (options.mcp) {
+                // `serve --mcp` is the stdio MCP server an AI agent launches for itself,
+                // not a command to run by hand. A human in a terminal would otherwise
+                // see it hang waiting for JSON-RPC on stdin, which reads as broken. If
+                // stdin is an interactive TTY, explain instead of hanging. The agent's
+                // pipe and the detached daemon both have a non-TTY stdin, so this only
+                // ever fires for a person who typed it.
+                if (process.stdin.isTTY && !process.env.CODEGRAPH_DAEMON_INTERNAL) {
+                    console.error(chalk.bold('\nCodeGraph MCP server\n'));
+                    console.error("This is the MCP server your AI agent (Claude Code, Cursor, Codex, opencode, …)");
+                    console.error("starts automatically — you don't run it yourself.");
+                    console.error(`\nIt's already wired up by ${chalk.cyan('codegraph install')}. To check on things:`);
+                    console.error(`  ${chalk.cyan('codegraph status')}   ${chalk.dim('— is this project indexed and healthy?')}`);
+                    console.error(`  ${chalk.cyan('codegraph daemon')}   ${chalk.dim('— list or stop background MCP servers')}`);
+                    console.error(chalk.dim('\n(Running it directly only does something when an MCP client drives it over stdin.)'));
+                    return;
+                }
                 // Start MCP server - it handles initialization lazily based on rootUri from client
                 const { MCPServer } = await Promise.resolve().then(() => __importStar(require('../mcp/index')));
                 const server = new MCPServer(projectPath);
@@ -1493,6 +1713,13 @@ function main() {
                 const stdinFiles = stdinData.split('\n').map(f => f.trim()).filter(Boolean);
                 changedFiles.push(...stdinFiles);
             }
+            // Normalize inputs to the project-relative, forward-slash form the index
+            // stores. Without this, `affected ./src/x.ts`, an absolute path (what a
+            // wrapping script often passes), or a Windows back-slash path silently
+            // matches nothing and reports 0 affected tests. (#825)
+            changedFiles = changedFiles
+                .map((f) => normalizeIndexPath(f, projectPath))
+                .filter(Boolean);
             if (changedFiles.length === 0) {
                 if (!options.quiet)
                     info('No files provided. Use file arguments or --stdin.');
@@ -1748,6 +1975,20 @@ function main() {
         });
         process.exit(code);
     });
+    /**
+     * codegraph version
+     *
+     * The bare-noun form of `--version`. commander already provides `--version`
+     * and `-V`, and the `-v` / `-version` spellings are intercepted before parse
+     * (see top of main). This subcommand makes `codegraph version` work and lists
+     * the version affordance in `codegraph --help`.
+     */
+    program
+        .command('version')
+        .description('Print the installed CodeGraph version (also: -v, --version)')
+        .action(() => {
+        console.log(packageJson.version);
+    });
     // Parse and run
     program.parse();
 } // end main()