gitnexus 1.4.8 → 1.4.10

package/README.md

@@ -53,7 +53,11 @@ If you prefer to configure manually instead of using `gitnexus setup`:
 ### Claude Code (full support — MCP + skills + hooks)
 
 ```bash
+# macOS / Linux
 claude mcp add gitnexus -- npx -y gitnexus@latest mcp
+
+# Windows
+claude mcp add gitnexus -- cmd /c npx -y gitnexus@latest mcp
 ```
 
 ### Codex (full support — MCP + skills)
@@ -99,6 +103,8 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 1. **Structure** — Walks the file tree and maps folder/file relationships
 2. **Parsing** — Extracts functions, classes, methods, and interfaces using Tree-sitter ASTs
 3. **Resolution** — Resolves imports and function calls across files with language-aware logic
+   - **Field & Property Type Resolution** — Tracks field types across classes and interfaces for deep chain resolution (e.g., `user.address.city.getName()`)
+   - **Return-Type-Aware Variable Binding** — Infers variable types from function return types, enabling accurate call-result binding
 4. **Clustering** — Groups related symbols into functional communities
 5. **Processes** — Traces execution flows from entry points through call chains
 6. **Search** — Builds hybrid search indexes for fast retrieval
@@ -150,6 +156,7 @@ gitnexus analyze --embeddings     # Enable embedding generation (slower, better
 gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
+gitnexus index                   # Register an existing .gitnexus/ folder into the global registry
 gitnexus list                    # List all indexed repositories
 gitnexus status                  # Show index status for current repo
 gitnexus clean                   # Delete index for current repo

package/dist/cli/index-repo.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Index Command
+ *
+ * Registers an existing .gitnexus/ folder into the global registry so the
+ * MCP server can discover the repo without running a full `gitnexus analyze`.
+ *
+ * Useful when a pre-built .gitnexus/ directory is already present (e.g. after
+ * cloning a repo that ships its index, restoring from backup, or using a
+ * shared team index).
+ */
+export interface IndexOptions {
+    force?: boolean;
+    allowNonGit?: boolean;
+}
+export declare const indexCommand: (inputPathParts?: string[], options?: IndexOptions) => Promise<void>;

package/dist/cli/index-repo.js

@@ -0,0 +1,115 @@
+/**
+ * Index Command
+ *
+ * Registers an existing .gitnexus/ folder into the global registry so the
+ * MCP server can discover the repo without running a full `gitnexus analyze`.
+ *
+ * Useful when a pre-built .gitnexus/ directory is already present (e.g. after
+ * cloning a repo that ships its index, restoring from backup, or using a
+ * shared team index).
+ */
+import path from "path";
+import fs from "fs/promises";
+import { getStoragePaths, loadMeta, addToGitignore, registerRepo, } from "../storage/repo-manager.js";
+import { getGitRoot, isGitRepo } from "../storage/git.js";
+export const indexCommand = async (inputPathParts, options) => {
+    console.log("\n  GitNexus Index\n");
+    const inputPath = inputPathParts?.length
+        ? inputPathParts.join(" ")
+        : undefined;
+    if (inputPathParts && inputPathParts.length > 1) {
+        const resolvedCombinedPath = path.resolve(inputPath);
+        try {
+            await fs.access(resolvedCombinedPath);
+        }
+        catch {
+            console.log("  The `index` command accepts a single path only.");
+            console.log("  If your path contains spaces, wrap it in quotes.");
+            console.log(`  Received multiple path parts: ${inputPathParts.join(", ")}`);
+            console.log("");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    let repoPath;
+    if (inputPath) {
+        repoPath = path.resolve(inputPath);
+    }
+    else {
+        const gitRoot = getGitRoot(process.cwd());
+        if (!gitRoot) {
+            console.log("  Not inside a git repository, try to run git init\n");
+            process.exitCode = 1;
+            return;
+        }
+        repoPath = gitRoot;
+    }
+    if (!options?.allowNonGit && !isGitRepo(repoPath)) {
+        console.log(`  Not a git repository: ${repoPath}`);
+        console.log("  Initialize one with `git init` or choose a valid repo path.\n");
+        console.log("  Or use --allow-non-git to register an existing .gitnexus index anyway.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const { storagePath, lbugPath } = getStoragePaths(repoPath);
+    // ── Verify .gitnexus/ exists ──────────────────────────────────────
+    try {
+        await fs.access(storagePath);
+    }
+    catch {
+        console.log(`  No .gitnexus/ folder found at: ${storagePath}`);
+        console.log("  Run `gitnexus analyze` to build the index first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // ── Verify lbug database exists ───────────────────────────────────
+    try {
+        await fs.access(lbugPath);
+    }
+    catch {
+        console.log(`  .gitnexus/ folder exists but contains no LadybugDB index.`);
+        console.log("  Run `gitnexus analyze` to build the index.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // ── Load or reconstruct meta ──────────────────────────────────────
+    let meta = await loadMeta(storagePath);
+    if (!meta) {
+        if (!options?.force) {
+            console.log(`  .gitnexus/ exists but meta.json is missing.`);
+            console.log("  Use --force to register anyway (stats will be empty),");
+            console.log("  or run `gitnexus analyze` to rebuild properly.\n");
+            process.exitCode = 1;
+            return;
+        }
+        // --force: build a minimal meta so the repo can be registered
+        meta = {
+            repoPath,
+            lastCommit: "",
+            indexedAt: new Date().toISOString(),
+        };
+    }
+    // ── Register in global registry ───────────────────────────────────
+    await registerRepo(repoPath, meta);
+    await addToGitignore(repoPath);
+    const projectName = path.basename(repoPath);
+    const { stats } = meta;
+    console.log(`  Repository registered: ${projectName}`);
+    if (stats) {
+        const parts = [];
+        if (stats.nodes != null) {
+            parts.push(`${stats.nodes.toLocaleString()} nodes`);
+        }
+        if (stats.edges != null) {
+            parts.push(`${stats.edges.toLocaleString()} edges`);
+        }
+        if (stats.communities != null)
+            parts.push(`${stats.communities} clusters`);
+        if (stats.processes != null)
+            parts.push(`${stats.processes} flows`);
+        if (parts.length)
+            console.log(`  ${parts.join(" | ")}`);
+    }
+    console.log(`  ${repoPath}`);
+    console.log("");
+};

package/dist/cli/index.js

@@ -25,6 +25,12 @@ program
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .addHelpText('after', '\nEnvironment variables:\n  GITNEXUS_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .gitnexusignore)')
     .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
+program
+    .command('index [path...]')
+    .description('Register an existing .gitnexus/ folder into the global registry (no re-analysis needed)')
+    .option('-f, --force', 'Register even if meta.json is missing (stats will be empty)')
+    .option('--allow-non-git', 'Allow registering folders that are not Git repositories')
+    .action(createLazyAction(() => import('./index-repo.js'), 'indexCommand'));
 program
     .command('serve')
     .description('Start local HTTP server for web UI connection')
@@ -53,11 +59,14 @@ program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
     .option('-f, --force', 'Force full regeneration even if up to date')
-    .option('--model <model>', 'LLM model name (default: minimax/minimax-m2.5)')
-    .option('--base-url <url>', 'LLM API base URL (default: OpenAI)')
+    .option('--provider <provider>', 'LLM provider: openai or cursor (default: openai)')
+    .option('--model <model>', 'LLM model name (default depends on provider)')
+    .option('--base-url <url>', 'LLM API base URL (for openai provider)')
     .option('--api-key <key>', 'LLM API key (saved to ~/.gitnexus/config.json)')
     .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3')
     .option('--gist', 'Publish wiki as a public GitHub Gist after generation')
+    .option('-v, --verbose', 'Enable verbose output (show LLM commands and responses)')
+    .option('--review', 'Stop after grouping to review module structure before generating pages')
     .action(createLazyAction(() => import('./wiki.js'), 'wikiCommand'));
 program
     .command('augment <pattern>')

package/dist/cli/setup.js

@@ -97,18 +97,21 @@ async function setupCursor(result) {
 }
 async function setupClaudeCode(result) {
     const claudeDir = path.join(os.homedir(), '.claude');
-    const hasClaude = await dirExists(claudeDir);
-    if (!hasClaude) {
+    if (!(await dirExists(claudeDir))) {
         result.skipped.push('Claude Code (not installed)');
         return;
     }
-    // Claude Code uses a JSON settings file at ~/.claude.json or claude mcp add
-    console.log('');
-    console.log('  Claude Code detected. Run this command to add GitNexus MCP:');
-    console.log('');
-    console.log('    claude mcp add gitnexus -- npx -y gitnexus mcp');
-    console.log('');
-    result.configured.push('Claude Code (MCP manual step printed)');
+    // Claude Code stores MCP config in ~/.claude.json
+    const mcpPath = path.join(os.homedir(), '.claude.json');
+    try {
+        const existing = await readJsonFile(mcpPath);
+        const updated = mergeMcpConfig(existing);
+        await writeJsonFile(mcpPath, updated);
+        result.configured.push('Claude Code');
+    }
+    catch (err) {
+        result.errors.push(`Claude Code: ${err.message}`);
+    }
 }
 /**
  * Install GitNexus skills to ~/.claude/skills/ for Claude Code.

package/dist/cli/wiki.d.ts

@@ -4,6 +4,7 @@
  * Generates repository documentation from the knowledge graph.
  * Usage: gitnexus wiki [path] [options]
  */
+import { type LLMProvider } from '../core/wiki/llm-client.js';
 export interface WikiCommandOptions {
     force?: boolean;
     model?: string;
@@ -11,5 +12,8 @@ export interface WikiCommandOptions {
     apiKey?: string;
     concurrency?: string;
     gist?: boolean;
+    provider?: LLMProvider;
+    verbose?: boolean;
+    review?: boolean;
 }
 export declare const wikiCommand: (inputPath?: string, options?: WikiCommandOptions) => Promise<void>;

package/dist/cli/wiki.js

@@ -12,6 +12,7 @@ import { getGitRoot, isGitRepo } from '../storage/git.js';
 import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
 import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
+import { detectCursorCLI } from '../core/wiki/cursor-client.js';
 /**
  * Prompt the user for input via stdin.
  */
@@ -65,6 +66,10 @@ function prompt(question, hide = false) {
     });
 }
 export const wikiCommand = async (inputPath, options) => {
+    // Set verbose mode globally for cursor-client to pick up
+    if (options?.verbose) {
+        process.env.GITNEXUS_VERBOSE = '1';
+    }
     console.log('\n  GitNexus Wiki Generator\n');
     // ── Resolve repo path ───────────────────────────────────────────────
     let repoPath;
@@ -96,94 +101,130 @@ export const wikiCommand = async (inputPath, options) => {
     }
     // ── Resolve LLM config (with interactive fallback) ─────────────────
     // Save any CLI overrides immediately
-    if (options?.apiKey || options?.model || options?.baseUrl) {
+    if (options?.apiKey || options?.model || options?.baseUrl || options?.provider) {
         const existing = await loadCLIConfig();
         const updates = {};
         if (options.apiKey)
             updates.apiKey = options.apiKey;
-        if (options.model)
-            updates.model = options.model;
         if (options.baseUrl)
             updates.baseUrl = options.baseUrl;
+        if (options.provider)
+            updates.provider = options.provider;
+        // Save model to appropriate field based on provider
+        if (options.model) {
+            if (options.provider === 'cursor') {
+                updates.cursorModel = options.model;
+            }
+            else {
+                updates.model = options.model;
+            }
+        }
         await saveCLIConfig({ ...existing, ...updates });
         console.log('  Config saved to ~/.gitnexus/config.json\n');
     }
     const savedConfig = await loadCLIConfig();
-    const hasSavedConfig = !!(savedConfig.apiKey && savedConfig.baseUrl);
-    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl);
+    const hasSavedConfig = !!(savedConfig.provider === 'cursor' || (savedConfig.apiKey && savedConfig.baseUrl));
+    const hasCLIOverrides = !!(options?.apiKey || options?.model || options?.baseUrl || options?.provider);
     let llmConfig = await resolveLLMConfig({
         model: options?.model,
         baseUrl: options?.baseUrl,
         apiKey: options?.apiKey,
+        provider: options?.provider,
     });
     // Run interactive setup if no saved config and no CLI flags provided
     // (even if env vars exist — let user explicitly choose their provider)
     if (!hasSavedConfig && !hasCLIOverrides) {
         if (!process.stdin.isTTY) {
-            if (!llmConfig.apiKey) {
+            // Non-interactive mode — need either API key or Cursor CLI
+            if (!llmConfig.apiKey && llmConfig.provider !== 'cursor') {
                 console.log('  Error: No LLM API key found.');
                 console.log('  Set OPENAI_API_KEY or GITNEXUS_API_KEY environment variable,');
-                console.log('  or pass --api-key <key>.\n');
+                console.log('  or pass --api-key <key>, or use --provider cursor.\n');
                 process.exitCode = 1;
                 return;
             }
-            // Non-interactive with env var — just use it
+            // Non-interactive with env var or cursor — just use it
         }
         else {
             console.log('  No LLM configured. Let\'s set it up.\n');
-            console.log('  Supports OpenAI, OpenRouter, or any OpenAI-compatible API.\n');
+            console.log('  Supports OpenAI, OpenRouter, any OpenAI-compatible API, or Cursor CLI.\n');
+            // Check if Cursor CLI is available
+            const hasCursor = detectCursorCLI();
             // Provider selection
             console.log('  [1] OpenAI (api.openai.com)');
             console.log('  [2] OpenRouter (openrouter.ai)');
-            console.log('  [3] Custom endpoint\n');
-            const choice = await prompt('  Select provider (1/2/3): ');
+            console.log('  [3] Custom endpoint');
+            if (hasCursor) {
+                console.log('  [4] Cursor CLI (local, uses your Cursor subscription)');
+            }
+            console.log('');
+            const maxChoice = hasCursor ? '4' : '3';
+            const choice = await prompt(`  Select provider (1/${maxChoice}): `);
             let baseUrl;
             let defaultModel;
-            if (choice === '2') {
-                baseUrl = 'https://openrouter.ai/api/v1';
-                defaultModel = 'minimax/minimax-m2.5';
-            }
-            else if (choice === '3') {
-                baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
-                if (!baseUrl) {
-                    console.log('\n  No URL provided. Aborting.\n');
-                    process.exitCode = 1;
-                    return;
-                }
-                defaultModel = 'gpt-4o-mini';
+            let provider = 'openai';
+            let key = '';
+            if (choice === '4' && hasCursor) {
+                // Cursor CLI selected - model defaults to 'auto' (Cursor's default)
+                provider = 'cursor';
+                baseUrl = '';
+                const modelInput = await prompt('  Model (leave empty for auto): ');
+                const model = modelInput || '';
+                // Save config for Cursor
+                const cursorConfig = { provider: 'cursor' };
+                if (model)
+                    cursorConfig.cursorModel = model;
+                await saveCLIConfig(cursorConfig);
+                console.log('  Config saved to ~/.gitnexus/config.json\n');
+                llmConfig = { ...llmConfig, provider: 'cursor', model, apiKey: '', baseUrl: '' };
             }
             else {
-                baseUrl = 'https://api.openai.com/v1';
-                defaultModel = 'gpt-4o-mini';
-            }
-            // Model
-            const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
-            const model = modelInput || defaultModel;
-            // API key — pre-fill hint if env var exists
-            const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
-            let key;
-            if (envKey) {
-                const masked = envKey.slice(0, 6) + '...' + envKey.slice(-4);
-                const useEnv = await prompt(`  Use existing env key (${masked})? (Y/n): `);
-                if (!useEnv || useEnv.toLowerCase() === 'y' || useEnv.toLowerCase() === 'yes') {
-                    key = envKey;
+                // OpenAI-compatible provider
+                if (choice === '2') {
+                    baseUrl = 'https://openrouter.ai/api/v1';
+                    defaultModel = 'minimax/minimax-m2.5';
+                }
+                else if (choice === '3') {
+                    baseUrl = await prompt('  Base URL (e.g. http://localhost:11434/v1): ');
+                    if (!baseUrl) {
+                        console.log('\n  No URL provided. Aborting.\n');
+                        process.exitCode = 1;
+                        return;
+                    }
+                    defaultModel = 'gpt-4o-mini';
+                }
+                else {
+                    baseUrl = 'https://api.openai.com/v1';
+                    defaultModel = 'gpt-4o-mini';
+                }
+                // Model
+                const modelInput = await prompt(`  Model (default: ${defaultModel}): `);
+                const model = modelInput || defaultModel;
+                // API key — pre-fill hint if env var exists
+                const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
+                if (envKey) {
+                    const masked = envKey.slice(0, 6) + '...' + envKey.slice(-4);
+                    const useEnv = await prompt(`  Use existing env key (${masked})? (Y/n): `);
+                    if (!useEnv || useEnv.toLowerCase() === 'y' || useEnv.toLowerCase() === 'yes') {
+                        key = envKey;
+                    }
+                    else {
+                        key = await prompt('  API key: ', true);
+                    }
                 }
                 else {
                     key = await prompt('  API key: ', true);
                 }
+                if (!key) {
+                    console.log('\n  No key provided. Aborting.\n');
+                    process.exitCode = 1;
+                    return;
+                }
+                // Save
+                await saveCLIConfig({ apiKey: key, baseUrl, model, provider: 'openai' });
+                console.log('  Config saved to ~/.gitnexus/config.json\n');
+                llmConfig = { ...llmConfig, apiKey: key, baseUrl, model, provider: 'openai' };
             }
-            else {
-                key = await prompt('  API key: ', true);
-            }
-            if (!key) {
-                console.log('\n  No key provided. Aborting.\n');
-                process.exitCode = 1;
-                return;
-            }
-            // Save
-            await saveCLIConfig({ apiKey: key, baseUrl, model });
-            console.log('  Config saved to ~/.gitnexus/config.json\n');
-            llmConfig = { ...llmConfig, apiKey: key, baseUrl, model };
         }
     }
     // ── Setup progress bar with elapsed timer ──────────────────────────
@@ -213,9 +254,8 @@ export const wikiCommand = async (inputPath, options) => {
     // ── Run generator ───────────────────────────────────────────────────
     const wikiOptions = {
         force: options?.force,
-        model: options?.model,
-        baseUrl: options?.baseUrl,
         concurrency: options?.concurrency ? parseInt(options.concurrency, 10) : undefined,
+        reviewOnly: options?.review,
     };
     const generator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, wikiOptions, (phase, percent, detail) => {
         const label = detail || phase;
@@ -228,11 +268,92 @@ export const wikiCommand = async (inputPath, options) => {
     try {
         const result = await generator.run();
         clearInterval(elapsedTimer);
-        bar.update(100, { phase: 'Done' });
         bar.stop();
         const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
         const wikiDir = path.join(storagePath, 'wiki');
         const viewerPath = path.join(wikiDir, 'index.html');
+        const treeFile = path.join(wikiDir, 'module_tree.json');
+        // Review mode: show module tree and ask for confirmation
+        if (options?.review && result.moduleTree) {
+            console.log(`\n  Module structure ready for review (${elapsed}s)\n`);
+            console.log('  Modules to generate:\n');
+            const printTree = (nodes, indent = 0) => {
+                for (const node of nodes) {
+                    const prefix = '  '.repeat(indent + 2);
+                    const fileCount = node.files?.length || 0;
+                    const childCount = node.children?.length || 0;
+                    const suffix = fileCount > 0 ? ` (${fileCount} files)` : childCount > 0 ? ` (${childCount} children)` : '';
+                    console.log(`${prefix}- ${node.name}${suffix}`);
+                    if (node.children && node.children.length > 0) {
+                        printTree(node.children, indent + 1);
+                    }
+                }
+            };
+            printTree(result.moduleTree);
+            console.log(`\n  Tree saved to: ${treeFile}`);
+            console.log('  You can edit this file to remove/rename modules.\n');
+            // Ask for confirmation (auto-continue in non-interactive environments)
+            if (!process.stdin.isTTY) {
+                console.log('  Non-interactive mode — auto-continuing with generation.\n');
+            }
+            const answer = process.stdin.isTTY
+                ? await prompt('  Continue with generation? (Y/n/edit): ')
+                : 'y';
+            const choice = answer.trim().toLowerCase();
+            if (choice === 'n' || choice === 'no') {
+                console.log('\n  Generation cancelled. Run `gitnexus wiki` later to generate.\n');
+                return;
+            }
+            if (choice === 'edit' || choice === 'e') {
+                // Open editor for the user
+                const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+                console.log(`\n  Opening ${treeFile} in ${editor}...`);
+                console.log('  Save and close the editor when done.\n');
+                try {
+                    execSync(`${editor} "${treeFile}"`, { stdio: 'inherit' });
+                }
+                catch {
+                    console.log(`  Could not open editor. Please edit manually:\n  ${treeFile}\n`);
+                    console.log('  Then run `gitnexus wiki` to continue.\n');
+                    return;
+                }
+            }
+            // Continue with generation using the (possibly edited) tree
+            console.log('\n  Continuing with wiki generation...\n');
+            bar.start(100, 30, { phase: 'Generating pages...' });
+            // Re-run generator without reviewOnly flag
+            const continueOptions = {
+                ...wikiOptions,
+                reviewOnly: false,
+            };
+            const continueGenerator = new WikiGenerator(repoPath, storagePath, lbugPath, llmConfig, continueOptions, (phase, percent, detail) => {
+                const label = detail || phase;
+                if (label !== lastPhase) {
+                    lastPhase = label;
+                    phaseStart = Date.now();
+                }
+                bar.update(percent, { phase: label });
+            });
+            const continueResult = await continueGenerator.run();
+            bar.update(100, { phase: 'Done' });
+            bar.stop();
+            const totalElapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            console.log(`\n  Wiki generated successfully (${totalElapsed}s)\n`);
+            console.log(`  Mode: ${continueResult.mode}`);
+            console.log(`  Pages: ${continueResult.pagesGenerated}`);
+            console.log(`  Output: ${wikiDir}`);
+            console.log(`  Viewer: ${viewerPath}`);
+            if (continueResult.failedModules && continueResult.failedModules.length > 0) {
+                console.log(`\n  Failed modules (${continueResult.failedModules.length}):`);
+                for (const mod of continueResult.failedModules) {
+                    console.log(`    - ${mod}`);
+                }
+            }
+            console.log('');
+            await maybePublishGist(viewerPath, options?.gist);
+            return;
+        }
+        bar.update(100, { phase: 'Done' });
         if (result.mode === 'up-to-date' && !options?.force) {
             console.log('\n  Wiki is already up to date.');
             console.log(`  Viewer: ${viewerPath}\n`);
@@ -280,7 +401,7 @@ export const wikiCommand = async (inputPath, options) => {
         }
         else {
             console.log(`\n  Error: ${err.message}\n`);
-            if (process.env.DEBUG) {
+            if (process.env.GITNEXUS_VERBOSE) {
                 console.error(err);
             }
         }

package/dist/config/supported-languages.d.ts

@@ -9,14 +9,13 @@
  *    ----------------------------------|------------------------------------------|---------------------------
  *    tree-sitter-queries.ts            | Query string + LANGUAGE_QUERIES entry    | (required)
  *    export-detection.ts               | ExportChecker function + table entry     | (required)
- *    import-resolution.ts              | Resolver in importResolvers              | resolveStandard(...)
- *    import-resolution.ts              | namedBindingExtractors entry             | undefined
- *    call-routing.ts                   | callRouters entry                        | noRouting
+ *    import-resolvers/<lang>.ts        | Exported resolve<Lang>Import function    | resolveStandard(...)
+ *    call-routing.ts                   | CallRouter function (or noRouting)       | noRouting
  *    entry-point-scoring.ts            | ENTRY_POINT_PATTERNS entry               | []
  *    framework-detection.ts            | AST_FRAMEWORK_PATTERNS entry             | []
  *    type-extractors/<lang>.ts         | New file + index.ts import               | (required)
  *    resolvers/<lang>.ts               | Resolver file (if non-standard)          | (only if resolveStandard insufficient)
- *    named-binding-extraction.ts       | Extractor (if named imports)             | (only if language has named imports)
+ *    named-bindings/<lang>.ts          | Extractor (if named imports)             | (only if language has named imports)
  *
  * 4. Also check these files for language-specific if-checks (no compile-time guard):
  *    - mro-processor.ts (MRO strategy selection)
@@ -41,5 +40,8 @@ export declare enum SupportedLanguages {
     Rust = "rust",
     PHP = "php",
     Kotlin = "kotlin",
-    Swift = "swift"
+    Swift = "swift",
+    Dart = "dart",
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    Cobol = "cobol"
 }

package/dist/config/supported-languages.js

@@ -9,14 +9,13 @@
  *    ----------------------------------|------------------------------------------|---------------------------
  *    tree-sitter-queries.ts            | Query string + LANGUAGE_QUERIES entry    | (required)
  *    export-detection.ts               | ExportChecker function + table entry     | (required)
- *    import-resolution.ts              | Resolver in importResolvers              | resolveStandard(...)
- *    import-resolution.ts              | namedBindingExtractors entry             | undefined
- *    call-routing.ts                   | callRouters entry                        | noRouting
+ *    import-resolvers/<lang>.ts        | Exported resolve<Lang>Import function    | resolveStandard(...)
+ *    call-routing.ts                   | CallRouter function (or noRouting)       | noRouting
  *    entry-point-scoring.ts            | ENTRY_POINT_PATTERNS entry               | []
  *    framework-detection.ts            | AST_FRAMEWORK_PATTERNS entry             | []
  *    type-extractors/<lang>.ts         | New file + index.ts import               | (required)
  *    resolvers/<lang>.ts               | Resolver file (if non-standard)          | (only if resolveStandard insufficient)
- *    named-binding-extraction.ts       | Extractor (if named imports)             | (only if language has named imports)
+ *    named-bindings/<lang>.ts          | Extractor (if named imports)             | (only if language has named imports)
  *
  * 4. Also check these files for language-specific if-checks (no compile-time guard):
  *    - mro-processor.ts (MRO strategy selection)
@@ -43,4 +42,7 @@ export var SupportedLanguages;
     SupportedLanguages["PHP"] = "php";
     SupportedLanguages["Kotlin"] = "kotlin";
     SupportedLanguages["Swift"] = "swift";
+    SupportedLanguages["Dart"] = "dart";
+    /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+    SupportedLanguages["Cobol"] = "cobol";
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/core/graph/graph.js

@@ -27,7 +27,14 @@ export const createKnowledgeGraph = () => {
         return true;
     };
     /**
-     * Remove all nodes (and their relationships) belonging to a file
+     * Remove a single relationship by id.
+     * Returns true if the relationship existed and was removed, false otherwise.
+     */
+    const removeRelationship = (relationshipId) => {
+        return relationshipMap.delete(relationshipId);
+    };
+    /**
+     * Remove all nodes (and their relationships) belonging to a file.
      */
     const removeNodesByFile = (filePath) => {
         let removed = 0;
@@ -62,5 +69,6 @@ export const createKnowledgeGraph = () => {
         addRelationship,
         removeNode,
         removeNodesByFile,
+        removeRelationship,
     };
 };