@stupidloud/codegraph 0.7.15 → 0.8.1

package/README.md

@@ -2,17 +2,21 @@
 
 # CodeGraph
 
-### Supercharge Claude Code with Semantic Code Intelligence
+### Supercharge Claude Code, Cursor, Codex, and OpenCode with Semantic Code Intelligence
 
-**94% fewer tool calls · 77% faster exploration · 100% local**
+**~35% cheaper · ~70% fewer tool calls · 100% local**
 
 [![npm version](https://img.shields.io/npm/v/@stupidloud/codegraph.svg)](https://www.npmjs.com/package/@stupidloud/codegraph)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-20--24-green.svg)](https://nodejs.org/)
 
 [![Windows](https://img.shields.io/badge/Windows-supported-blue.svg)](#)
 [![macOS](https://img.shields.io/badge/macOS-supported-blue.svg)](#)
 [![Linux](https://img.shields.io/badge/Linux-supported-blue.svg)](#)
+[![Claude Code](https://img.shields.io/badge/Claude_Code-supported-blueviolet.svg)](#)
+[![Cursor](https://img.shields.io/badge/Cursor-supported-blueviolet.svg)](#)
+[![Codex CLI](https://img.shields.io/badge/Codex_CLI-supported-blueviolet.svg)](#)
+[![opencode](https://img.shields.io/badge/opencode-supported-blueviolet.svg)](#)
 
 [English](./README.md) · [简体中文](./README.zh-CN.md)
 
@@ -24,7 +28,7 @@
 npx @stupidloud/codegraph
 ```
 
-<sub>Interactive installer configures Claude Code automatically</sub>
+<sub>Interactive installer auto-configures your agent(s) — Claude Code, Cursor, Codex CLI, opencode</sub>
 
 #### Initialize Projects
 
@@ -47,61 +51,50 @@ When Claude Code explores a codebase, it spawns **Explore agents** that scan fil
 
 ### Benchmark Results
 
-Tested across 6 real-world codebases comparing Claude Code's Explore agent **with** and **without** CodeGraph:
+Tested across **7 real-world open-source codebases** spanning 7 languages, comparing an agent (Claude Code, headless) answering one architecture question **with** and **without** CodeGraph. Each cell is the savings at the **median of 4 runs per arm**.
 
-> **Average: 92% fewer tool calls · 71% faster**
+> **Average: 35% cheaper · 59% fewer tokens · 49% faster · 70% fewer tool calls**
 
-| Codebase | With CG | Without CG | Improvement |
-|----------|---------|------------|-------------|
-| **VS Code** · TypeScript | 3 calls, 17s | 52 calls, 1m 37s | **94% fewer · 82% faster** |
-| **Excalidraw** · TypeScript | 3 calls, 29s | 47 calls, 1m 45s | **94% fewer · 72% faster** |
-| **Claude Code** · Python + Rust | 3 calls, 39s | 40 calls, 1m 8s | **93% fewer · 43% faster** |
-| **Claude Code** · Java | 1 call, 19s | 26 calls, 1m 22s | **96% fewer · 77% faster** |
-| **Alamofire** · Swift | 3 calls, 22s | 32 calls, 1m 39s | **91% fewer · 78% faster** |
-| **Swift Compiler** · Swift/C++ | 6 calls, 35s | 37 calls, 2m 8s | **84% fewer · 73% faster** |
+| Codebase | Language | Cost | Tokens | Time | Tool calls |
+|----------|----------|------|--------|------|------------|
+| **VS Code** | TypeScript · ~10k files | 35% cheaper | 73% fewer | 41% faster | 72% fewer |
+| **Excalidraw** | TypeScript · ~600 | 47% cheaper | 73% fewer | 60% faster | 86% fewer |
+| **Django** | Python · ~2.7k | 34% cheaper | 64% fewer | 59% faster | 81% fewer |
+| **Tokio** | Rust · ~700 | 52% cheaper | 81% fewer | 63% faster | 89% fewer |
+| **OkHttp** | Java · ~640 | 17% cheaper | 41% fewer | 36% faster | 64% fewer |
+| **Gin** | Go · ~150 | 22% cheaper | 23% fewer | 34% faster | 19% fewer |
+| **Alamofire** | Swift · ~100 | 38% cheaper | 59% fewer | 51% faster | 77% fewer |
+
+The gains scale with codebase size: on large repos the agent answers from the index in a handful of calls with **zero file reads**, while the no-CodeGraph agent fans out across grep/find/Read (and the sub-agents it spawns). On a small repo like Gin (~150 files) native search is already cheap, so the margin narrows.
 
 <details>
 <summary><strong>Full benchmark details</strong></summary>
 
-All tests used Claude Opus 4.6 (1M context) with Claude Code v2.1.91. Each test spawned a single Explore agent with the same question.
+**Methodology.** Each arm is `claude -p` (Claude Opus 4.7, Claude Code v2.1.145) run headlessly against the repo with `--strict-mcp-config`: **WITH** = CodeGraph's MCP server enabled, **WITHOUT** = an empty MCP config. Built-in Read/Grep/Bash stay available to both. Same question per repo, **4 runs per arm, median reported**. Cost = the run's `total_cost_usd`; Tokens = total tokens processed (input incl. cached + output); Time = wall-clock; Tool calls = every tool invocation, including those inside any sub-agents the model spawns. Repos cloned at `--depth 1` and indexed by the same CodeGraph build that served them.
 
-**Queries used:**
+**Queries:**
 | Codebase | Query |
 |----------|-------|
 | VS Code | "How does the extension host communicate with the main process?" |
-| Excalidraw | "How does collaborative editing and real-time sync work?" |
-| Claude Code (Python+Rust) | "How does tool execution work end to end?" |
-| Claude Code (Java) | "How does tool execution work end to end?" |
-| Alamofire | "Trace how a request flows from Session.request() through to the URLSession layer" |
-| Swift Compiler | "How does the Swift compiler handle error diagnostics?" |
-
-**With CodeGraph — the agent uses `codegraph_explore` and stops:**
-| Codebase | Files Indexed | Nodes | Tool Uses | Tokens | Time | File Reads |
-|----------|--------------|-------|-----------|--------|------|------------|
-| VS Code (TypeScript) | 4,002 | 59,377 | 3 | 56.6k | 17s | 0 |
-| Excalidraw (TypeScript) | 626 | 9,859 | 3 | 57.1k | 29s | 0 |
-| Claude Code (Python+Rust) | 115 | 3,080 | 3 | 67.1k | 39s | 0 |
-| Claude Code (Java) | — | — | 1 | 40.8k | 19s | 0 |
-| Alamofire (Swift) | 102 | 2,624 | 3 | 57.3k | 22s | 0 |
-| Swift Compiler (Swift/C++) | 25,874 | 272,898 | 6 | 77.4k | 35s | 0 |
-
-**Without CodeGraph — the agent uses grep, find, ls, and Read extensively:**
-| Codebase | Tool Uses | Tokens | Time | File Reads |
-|----------|-----------|--------|------|------------|
-| VS Code (TypeScript) | 52 | 89.4k | 1m 37s | ~15 |
-| Excalidraw (TypeScript) | 47 | 77.9k | 1m 45s | ~20 |
-| Claude Code (Python+Rust) | 40 | 69.3k | 1m 8s | ~15 |
-| Claude Code (Java) | 26 | 73.3k | 1m 22s | ~15 |
-| Alamofire (Swift) | 32 | 52.4k | 1m 39s | ~10 |
-| Swift Compiler (Swift/C++) | 37 | 99.1k | 2m 8s | ~20 |
-
-**Key observations:**
-- With CodeGraph, the agent **never fell back to reading files** — it trusted the codegraph_explore results completely
-- Without CodeGraph, agents spent most of their time on discovery (find, ls, grep) before they could even start reading relevant code
-- The Java codebase needed only **1 codegraph_explore call** to answer the entire question
-- Cross-language queries (Python+Rust) worked seamlessly — CodeGraph's graph traversal found connections across language boundaries
-- The Swift benchmark (Alamofire) traced a **9-step call chain** from `Session.request()` to `URLSession.dataTask()` — CodeGraph's graph traversal at depth 3 captured the full chain in one explore call
-- The **Swift Compiler** benchmark is the largest codebase tested (**25,874 files, 272,898 nodes**) — CodeGraph indexed it in under 4 minutes and the agent answered a complex cross-cutting question with **6 explore calls and zero file reads** in 35 seconds
+| Excalidraw | "How does Excalidraw render and update canvas elements?" |
+| Django | "How does Django's ORM build and execute a query from a QuerySet?" |
+| Tokio | "How does tokio schedule and run async tasks on its runtime?" |
+| OkHttp | "How does OkHttp process a request through its interceptor chain?" |
+| Gin | "How does gin route requests through its middleware chain?" |
+| Alamofire | "How does Alamofire build, send, and validate a request?" |
+
+**Raw medians — WITH → WITHOUT:**
+| Codebase | Cost | Tokens | Time | Tool calls |
+|----------|------|--------|------|------------|
+| VS Code | $0.42 → $0.64 | 393k → 1.4M | 1m 0s → 1m 43s | 7 → 23 |
+| Excalidraw | $0.54 → $1.02 | 851k → 3.2M | 1m 17s → 3m 14s | 12 → 83 |
+| Django | $0.41 → $0.62 | 499k → 1.4M | 1m 0s → 2m 25s | 9 → 48 |
+| Tokio | $0.50 → $1.04 | 657k → 3.4M | 1m 5s → 2m 56s | 9 → 75 |
+| OkHttp | $0.36 → $0.44 | 352k → 596k | 45s → 1m 11s | 5 → 14 |
+| Gin | $0.36 → $0.46 | 431k → 562k | 47s → 1m 11s | 7 → 8 |
+| Alamofire | $0.61 → $0.99 | 1.1M → 2.6M | 1m 19s → 2m 41s | 15 → 64 |
+
+**Why CodeGraph wins:** with the index available, the agent answers directly — `codegraph_context` to map the area, then one `codegraph_explore` for the relevant source — and stops, usually with zero file reads. Without it, the agent (and the Explore sub-agents it spawns) spends most of its budget on discovery (find/ls/grep) before reading the right code. CodeGraph only helps when queried *directly*, so its instructions steer agents to answer directly rather than delegate exploration to file-reading sub-agents — otherwise a sub-agent reads files regardless and CodeGraph becomes overhead.
 
 </details>
 
@@ -131,6 +124,7 @@ CodeGraph detects web-framework routing files and emits `route` nodes linked by
 | **Flask** | `@app.route('/path', methods=[...])`, blueprint routes |
 | **FastAPI** | `@app.get(...)`, `@router.post(...)`, all standard methods |
 | **Express** | `app.get(...)`, `router.post(...)` with middleware chains |
+| **NestJS** | `@Controller` + `@Get/@Post/...`, GraphQL `@Resolver` + `@Query/@Mutation`, `@MessagePattern`/`@EventPattern`, `@SubscribeMessage` |
 | **Laravel** | `Route::get()`, `Route::resource()`, `Controller@action`, tuple syntax |
 | **Rails** | `get '/x', to: 'users#index'`, hash-rocket `=>` syntax |
 | **Spring** | `@GetMapping`, `@PostMapping`, `@RequestMapping` on methods |
@@ -151,15 +145,33 @@ npx @stupidloud/codegraph
 ```
 
 The installer will:
-- Prompt to install `codegraph` globally (needed for the MCP server)
-- Configure the MCP server in `~/.claude.json`
-- Set up auto-allow permissions for CodeGraph tools
-- Add global instructions to `~/.claude/CLAUDE.md`
-- Optionally initialize your current project
+- Ask which agent(s) to configure — auto-detects installed ones from: **Claude Code**, **Cursor**, **Codex CLI**, **opencode**
+- Prompt to install `codegraph` on your PATH (so agents can launch the MCP server)
+- Ask whether configs apply to all your projects or just this one
+- Write each chosen agent's MCP server config + an instructions file (e.g. `CLAUDE.md`, `.cursor/rules/codegraph.mdc`, `~/.codex/AGENTS.md`)
+- Set up auto-allow permissions when Claude Code is one of the targets
+- Initialize your current project (local installs only)
+
+**Non-interactive (scripting / CI):**
+
+```bash
+codegraph install --yes                              # auto-detect agents, install global
+codegraph install --target=cursor,claude --yes       # explicit target list
+codegraph install --target=auto --location=local     # detected agents, project-local
+codegraph install --print-config codex               # print snippet, no file writes
+```
 
-### 2. Restart Claude Code
+| Flag | Values | Default |
+|---|---|---|
+| `--target` | `auto`, `all`, `none`, or csv (`claude,cursor,...`) | prompt |
+| `--location` | `global`, `local` | prompt |
+| `--yes` | (boolean) | prompt every step |
+| `--no-permissions` | (boolean) skip Claude auto-allow list | permissions on |
+| `--print-config <id>` | dump snippet for one agent and exit | — |
 
-Restart Claude Code for the MCP server to load.
+### 2. Restart Your Agent
+
+Restart your agent (Claude Code / Cursor / Codex CLI / opencode) for the MCP server to load.
 
 ### 3. Initialize Projects
 
@@ -168,7 +180,9 @@ cd your-project
 codegraph init -i
 ```
 
-That's it! Claude Code will use CodeGraph tools automatically when a `.codegraph/` directory exists.
+Builds the per-project knowledge graph index. Also wires up any project-local agent surfaces (e.g. Cursor's `.cursor/rules/codegraph.mdc`) so a single global `codegraph install` works in every project you open — no need to re-run the installer per project.
+
+That's it — your agent will use CodeGraph tools automatically when a `.codegraph/` directory exists.
 
 <details>
 <summary><strong>Manual Setup (Alternative)</strong></summary>
@@ -469,6 +483,16 @@ The `.codegraph/config.json` file controls indexing:
 
 **Missing symbols** — The MCP server auto-syncs on save (wait a couple seconds). Run `codegraph sync` manually if needed. Check that the file's language is supported and isn't excluded by config patterns.
 
+## Star History
+
+<a href="https://www.star-history.com/?repos=colbymchenry%2Fcodegraph&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=colbymchenry/codegraph&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=colbymchenry/codegraph&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=colbymchenry/codegraph&type=date&legend=top-left" />
+ </picture>
+</a>
+
 ## License
 
 MIT
@@ -477,7 +501,7 @@ MIT
 
 <div align="center">
 
-**Made for the Claude Code community**
+**Made for AI coding agents — Claude Code, Cursor, Codex CLI, and opencode**
 
 [Report Bug](https://github.com/colbymchenry/codegraph/issues) · [Request Feature](https://github.com/colbymchenry/codegraph/issues)
 

package/dist/bin/codegraph.js

@@ -58,6 +58,7 @@ const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
 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");
 // Lazy-load heavy modules (CodeGraph, runInstaller) to keep CLI startup fast.
 async function loadCodeGraph() {
@@ -66,7 +67,7 @@ async function loadCodeGraph() {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        console.error('\x1b[31m✗\x1b[0m Failed to load CodeGraph modules.');
+        console.error(`\x1b[31m${(0, glyphs_1.getGlyphs)().err}\x1b[0m Failed to load CodeGraph modules.`);
         console.error(`\n  Node: ${process.version}  Platform: ${process.platform} ${process.arch}`);
         console.error(`\n  Error: ${msg}`);
         console.error('\n  Try reinstalling with: npm install -g @stupidloud/codegraph\n');
@@ -204,12 +205,14 @@ function main() {
     function createVerboseProgress() {
         let lastPhase = '';
         let lastPct = -1;
+        let lastDetail = '';
         const startTime = Date.now();
         return (progress) => {
             const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
             if (progress.phase !== lastPhase) {
                 lastPhase = progress.phase;
                 lastPct = -1;
+                lastDetail = '';
                 console.log(`[${elapsed}s] Phase: ${progress.phase}`);
             }
             if (progress.total > 0) {
@@ -217,7 +220,13 @@ function main() {
                 // Log every 5% to keep output manageable
                 if (pct >= lastPct + 5 || progress.current === progress.total) {
                     lastPct = pct;
-                    console.log(`[${elapsed}s]   ${progress.current}/${progress.total} (${pct}%)${progress.currentFile ? ` — ${progress.currentFile}` : ''}`);
+                    console.log(`[${elapsed}s]   ${progress.current}/${progress.total} (${pct}%)${progress.currentFile ? ` ${(0, glyphs_1.getGlyphs)().dash} ${progress.currentFile}` : ''}`);
+                }
+            }
+            else if (progress.currentFile) {
+                if (progress.currentFile !== lastDetail) {
+                    lastDetail = progress.currentFile;
+                    console.log(`[${elapsed}s]   ${progress.currentFile}`);
                 }
             }
             else if (progress.current > 0) {
@@ -232,25 +241,25 @@ function main() {
      * Print success message
      */
     function success(message) {
-        console.log(chalk.green('✓') + ' ' + message);
+        console.log(chalk.green((0, glyphs_1.getGlyphs)().ok) + ' ' + message);
     }
     /**
      * Print error message
      */
     function error(message) {
-        console.error(chalk.red('✗') + ' ' + message);
+        console.error(chalk.red((0, glyphs_1.getGlyphs)().err) + ' ' + message);
     }
     /**
      * Print info message
      */
     function info(message) {
-        console.log(chalk.blue('ℹ') + ' ' + message);
+        console.log(chalk.blue((0, glyphs_1.getGlyphs)().info) + ' ' + message);
     }
     /**
      * Print warning message
      */
     function warn(message) {
-        console.log(chalk.yellow('⚠') + ' ' + message);
+        console.log(chalk.yellow((0, glyphs_1.getGlyphs)().warn) + ' ' + message);
     }
     /**
      * Print indexing results using clack log methods
@@ -270,7 +279,7 @@ function main() {
         // continuing to the misleading "No files found" branch or throwing.
         if (!result.success && !hasErrors && result.filesIndexed === 0) {
             const generic = result.errors.find((e) => e.severity === 'error');
-            clack.log.error(generic?.message ?? 'Indexing failed — no further details available');
+            clack.log.error(generic?.message ?? `Indexing failed ${(0, glyphs_1.getGlyphs)().dash} no further details available`);
             return;
         }
         if (result.filesIndexed > 0) {
@@ -283,7 +292,7 @@ function main() {
             clack.log.info(`${formatNumber(result.nodesCreated)} nodes, ${formatNumber(result.edgesCreated)} edges in ${formatDuration(result.durationMs)}`);
         }
         else if (hasErrors) {
-            clack.log.error(`Indexing failed — all ${formatNumber(result.filesErrored)} files had errors`);
+            clack.log.error(`Indexing failed ${(0, glyphs_1.getGlyphs)().dash} all ${formatNumber(result.filesErrored)} files had errors`);
         }
         else {
             clack.log.warn('No files found to index');
@@ -313,7 +322,7 @@ function main() {
                 clack.log.info('See .codegraph/errors.log for details');
             }
             if (result.filesIndexed > 0) {
-                clack.log.info('The index is fully usable — only the failed files are missing.');
+                clack.log.info(`The index is fully usable ${(0, glyphs_1.getGlyphs)().dash} only the failed files are missing.`);
             }
         }
         else if (projectPath) {
@@ -350,7 +359,7 @@ function main() {
             }
         }
         const lines = [
-            `CodeGraph Error Log — ${new Date().toISOString()}`,
+            `CodeGraph Error Log - ${new Date().toISOString()}`,
             `${errorsByFile.size} files with errors`,
             '',
         ];
@@ -383,6 +392,21 @@ 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);
+                }
+                catch { /* non-fatal */ }
                 clack.outro('');
                 return;
             }
@@ -394,6 +418,20 @@ 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) {
@@ -403,7 +441,7 @@ function main() {
                     });
                 }
                 else {
-                    process.stdout.write(`${colors.dim}│${colors.reset}\n`);
+                    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,
@@ -415,6 +453,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();
         }
@@ -442,7 +485,7 @@ function main() {
                 const readline = await Promise.resolve().then(() => __importStar(require('readline')));
                 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
                 const answer = await new Promise((resolve) => {
-                    rl.question(chalk.yellow('⚠ This will permanently delete all CodeGraph data. Continue? (y/N) '), resolve);
+                    rl.question(chalk.yellow(`${(0, glyphs_1.getGlyphs)().warn} This will permanently delete all CodeGraph data. Continue? (y/N) `), resolve);
                 });
                 rl.close();
                 if (answer.toLowerCase() !== 'y') {
@@ -453,6 +496,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) {
@@ -503,7 +555,7 @@ function main() {
                 });
             }
             else {
-                process.stdout.write(`${colors.dim}│${colors.reset}\n`);
+                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,
@@ -547,7 +599,7 @@ function main() {
             }
             const clack = await importESM('@clack/prompts');
             clack.intro('Syncing CodeGraph');
-            process.stdout.write(`${colors.dim}│${colors.reset}\n`);
+            process.stdout.write(`${colors.dim}${(0, glyphs_1.getGlyphs)().rail}${colors.reset}\n`);
             const progress = (0, shimmer_progress_1.createShimmerProgress)();
             const result = await cg.sync({
                 onProgress: progress.onProgress,
@@ -566,7 +618,7 @@ function main() {
                     details.push(`Modified: ${result.filesModified}`);
                 if (result.filesRemoved > 0)
                     details.push(`Removed: ${result.filesRemoved}`);
-                clack.log.info(`${details.join(', ')} — ${formatNumber(result.nodesUpdated)} nodes in ${formatDuration(result.durationMs)}`);
+                clack.log.info(`${details.join(', ')} ${(0, glyphs_1.getGlyphs)().dash} ${formatNumber(result.nodesUpdated)} nodes in ${formatDuration(result.durationMs)}`);
             }
             clack.outro('Done');
             cg.destroy();
@@ -641,7 +693,7 @@ function main() {
             // when the native build fails.
             const backendLabel = backend === 'native'
                 ? chalk.green('native')
-                : chalk.yellow('wasm — slower fallback; run `npm rebuild better-sqlite3`');
+                : chalk.yellow(`wasm ${(0, glyphs_1.getGlyphs)().dash} slower fallback; run \`npm rebuild better-sqlite3\``);
             console.log(`  Backend:   ${backendLabel}`);
             console.log();
             // Node breakdown
@@ -886,8 +938,9 @@ function main() {
         const renderNode = (node, prefix, isLast, depth) => {
             if (maxDepth !== undefined && depth > maxDepth)
                 return;
-            const connector = isLast ? '└── ' : '├── ';
-            const childPrefix = isLast ? '    ' : '│   ';
+            const glyphs = (0, glyphs_1.getGlyphs)();
+            const connector = isLast ? glyphs.treeLast : glyphs.treeBranch;
+            const childPrefix = isLast ? '    ' : glyphs.treePipe;
             if (node.name) {
                 let line = prefix + connector + node.name;
                 if (node.file && includeMetadata) {
@@ -954,8 +1007,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
@@ -968,7 +1027,7 @@ function main() {
                 // Default: show info about MCP mode.
                 // Use stderr so stdout stays clean for any piped/stdio usage.
                 console.error(chalk.bold('\nCodeGraph MCP Server\n'));
-                console.error(chalk.blue('ℹ') + ' Use --mcp flag to start the MCP server');
+                console.error(chalk.blue((0, glyphs_1.getGlyphs)().info) + ' Use --mcp flag to start the MCP server');
                 console.error('\nTo use with Claude Code, add to your MCP configuration:');
                 console.error(chalk.dim(`
 {
@@ -1144,7 +1203,7 @@ function main() {
             }
             const lockPath = path.join((0, directory_1.getCodeGraphDir)(projectPath), 'codegraph.lock');
             if (!fs.existsSync(lockPath)) {
-                info('No lock file found — nothing to do');
+                info(`No lock file found ${(0, glyphs_1.getGlyphs)().dash} nothing to do`);
                 return;
             }
             fs.unlinkSync(lockPath);
@@ -1290,10 +1349,54 @@ function main() {
      */
     program
         .command('install')
-        .description('Run interactive installer for Claude Code integration')
-        .action(async () => {
-        const { runInstaller } = await Promise.resolve().then(() => __importStar(require('../installer')));
-        await runInstaller();
+        .description('Install codegraph MCP server into one or more agents (Claude Code, Cursor, Codex CLI, opencode)')
+        .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')
+        .option('--no-permissions', 'Skip writing the auto-allow permissions list (Claude Code only)')
+        .option('--print-config <id>', 'Print MCP config snippet for the named agent and exit (no file writes)')
+        .action(async (opts) => {
+        if (opts.printConfig) {
+            const { getTarget, listTargetIds } = await Promise.resolve().then(() => __importStar(require('../installer/targets/registry')));
+            const target = getTarget(opts.printConfig);
+            if (!target) {
+                const known = listTargetIds().join(', ');
+                error(`Unknown target "${opts.printConfig}". Known: ${known}.`);
+                process.exit(1);
+            }
+            const loc = (opts.location === 'local' ? 'local' : 'global');
+            process.stdout.write(target.printConfig(loc));
+            return;
+        }
+        const { runInstallerWithOptions } = 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 {
+            // Commander's `--no-permissions` makes `opts.permissions === false`;
+            // omitting the flag leaves it `true` (the positive-form default).
+            // We MUST treat the default-true as "user did not override — let
+            // the orchestrator prompt" and only forward an explicit `false`
+            // (or `true` when --yes implies it). Otherwise the auto-allow
+            // prompt is silently skipped on every interactive run.
+            const explicitNoPermissions = opts.permissions === false;
+            const autoAllow = explicitNoPermissions
+                ? false
+                : opts.yes
+                    ? true
+                    : undefined;
+            await runInstallerWithOptions({
+                target: opts.target,
+                location: opts.location,
+                autoAllow,
+                yes: opts.yes,
+            });
+        }
+        catch (err) {
+            error(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
     });
     // Parse and run
     program.parse();