@codragraph/cli 2.1.0 → 2.1.4

package/dist/cli/analyze.js

@@ -12,12 +12,17 @@ import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import * as fsSync from 'node:fs';
+import { createRequire } from 'module';
 import { closeCgdb } from '../core/cgdb/cgdb-adapter.js';
 import { getStoragePaths, getGlobalRegistryPath, RegistryNameCollisionError, } from '../storage/repo-manager.js';
 import { getGitRoot, hasGitDir } from '../storage/git.js';
 import { runFullAnalysis } from '../core/run-analyze.js';
 import { getMaxFileSizeBannerMessage } from '../core/ingestion/utils/max-file-size.js';
 import fs from 'fs/promises';
+import { formatBytes, LARGE_INDEX_WARNING_BYTES, summarizeIndexStorage } from './status.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const CLI_PACKAGE_SPEC = `@codragraph/cli@${pkg.version}`;
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
 /** Increase default stack size (KB) to prevent stack overflow on deep class hierarchies. */
@@ -105,25 +110,6 @@ export const analyzeCommand = async (inputPath, options) => {
             }
         });
     }
-    // ── First-run auto-setup ───────────────────────────────────────────
-    // Makes `npx @codragraph/cli analyze` a true one-command entry. We detect
-    // first-run by the absence of the global registry — analyze writes to it on
-    // every successful index, so it's a reliable "this user has never run us
-    // before" signal. Opt out with `--no-setup` for CI / headless contexts;
-    // commander maps `--no-setup` to `options.setup === false`.
-    if (options?.setup !== false) {
-        let registryExists = true;
-        try {
-            await fs.access(getGlobalRegistryPath());
-        }
-        catch {
-            registryExists = false;
-        }
-        if (!registryExists) {
-            const { runSetup } = await import('./setup.js');
-            await runSetup({ skipNextSteps: true, compactHeader: true });
-        }
-    }
     console.log('\n  CodraGraph Analyzer\n');
     let repoPath;
     if (inputPath) {
@@ -153,6 +139,23 @@ export const analyzeCommand = async (inputPath, options) => {
     if (!repoHasGit) {
         console.log('  Warning: no .git directory found \u2014 commit-tracking and incremental updates disabled.\n');
     }
+    // ── First-run auto-setup ───────────────────────────────────────────
+    // Makes `npx @codragraph/cli analyze` a true one-command entry. Validate
+    // the target repo first so invalid invocations fail fast without mutating
+    // editor/global config.
+    if (options?.setup !== false) {
+        let registryExists = true;
+        try {
+            await fs.access(getGlobalRegistryPath());
+        }
+        catch {
+            registryExists = false;
+        }
+        if (!registryExists) {
+            const { runSetup } = await import('./setup.js');
+            await runSetup({ skipNextSteps: true, compactHeader: true });
+        }
+    }
     // KuzuDB migration cleanup is handled by runFullAnalysis internally.
     // Note: --skills is handled after runFullAnalysis using the returned pipelineResult.
     if (process.env.CODRAGRAPH_NO_GITIGNORE) {
@@ -253,7 +256,7 @@ export const analyzeCommand = async (inputPath, options) => {
             console.warn = origWarn;
             console.error = origError;
             bar.stop();
-            console.log('  Already up to date\n');
+            console.log(`  ${result.reuseReason ?? 'Already up to date'}\n`);
             // Safe to return without process.exit(0) — the early-return path in
             // runFullAnalysis never opens LadybugDB, so no native handles prevent exit.
             return;
@@ -299,7 +302,8 @@ export const analyzeCommand = async (inputPath, options) => {
                         nodes: s.nodes ?? 0,
                         edges: s.edges ?? 0,
                         communities: s.communities,
-                        clusters: aggregatedClusterCount,
+                        clusters: result.pipelineResult?.featureClusterResult?.stats.totalClusters ??
+                            aggregatedClusterCount,
                         processes: s.processes,
                     }, skillResult.skills, { skipAgentsMd: options?.skipAgentsMd, noStats: options?.noStats });
                 }
@@ -321,6 +325,20 @@ export const analyzeCommand = async (inputPath, options) => {
         console.log(`\n  Repository indexed successfully (${totalTime}s)\n`);
         console.log(`  ${(s.nodes ?? 0).toLocaleString()} nodes | ${(s.edges ?? 0).toLocaleString()} edges | ${s.communities ?? 0} clusters | ${s.processes ?? 0} flows`);
         console.log(`  ${repoPath}`);
+        try {
+            const { storagePath } = getStoragePaths(repoPath);
+            const storageSummary = await summarizeIndexStorage(storagePath);
+            if (storageSummary) {
+                console.log(`  .codragraph size: ${formatBytes(storageSummary.bytes)}`);
+                if (storageSummary.bytes >= LARGE_INDEX_WARNING_BYTES) {
+                    console.log(`  Storage warning: index is >= ${formatBytes(LARGE_INDEX_WARNING_BYTES)}. ` +
+                        `Use --compress brotli (or zstd on Node >=22.15) and reserve --embeddings for repos that need vector search.`);
+                }
+            }
+        }
+        catch {
+            /* size summary is best-effort */
+        }
         // Surface @codragraph/compress's value prop with concrete numbers: how
         // many tokens of distilled context did we generate. Best-effort — never
         // fail the analyze for a stat read.
@@ -388,12 +406,13 @@ export const analyzeCommand = async (inputPath, options) => {
             // 'node.target'" crash happens inside npm *before* codragraph code runs,
             // so it can't be caught here.  This branch handles dependency-resolution
             // errors that surface at runtime (e.g. dynamic require failures).
-            console.error('  This looks like an npm dependency resolution issue.');
+            console.error('  This looks like a package-manager dependency resolution issue.');
             console.error('  Suggestions:');
             console.error('    1. Clear the npm cache:    npm cache clean --force');
             console.error('    2. Update npm:             npm install -g npm@latest');
-            console.error('    3. Reinstall codragraph:     npm install -g @codragraph/cli@latest');
-            console.error('    4. Or try npx directly:    npx @codragraph/cli@latest analyze');
+            console.error(`    3. Reinstall codragraph:     npm install -g ${CLI_PACKAGE_SPEC}`);
+            console.error(`    4. Or try npx directly:    npx ${CLI_PACKAGE_SPEC} analyze`);
+            console.error(`    5. Bun alternative:        bunx ${CLI_PACKAGE_SPEC} analyze`);
             console.error('');
         }
         else if (msg.includes('MODULE_NOT_FOUND') ||
@@ -401,8 +420,9 @@ export const analyzeCommand = async (inputPath, options) => {
             msg.includes('ERR_MODULE_NOT_FOUND')) {
             console.error('  A required module could not be loaded. The installation may be corrupt.');
             console.error('  Suggestions:');
-            console.error('    1. Reinstall:   npm install -g @codragraph/cli@latest');
-            console.error('    2. Clear cache: npm cache clean --force && npx @codragraph/cli@latest analyze');
+            console.error(`    1. Reinstall:   npm install -g ${CLI_PACKAGE_SPEC}`);
+            console.error(`    2. Clear cache: npm cache clean --force && npx ${CLI_PACKAGE_SPEC} analyze`);
+            console.error(`    3. Bun cache:   bun pm cache rm && bunx ${CLI_PACKAGE_SPEC} analyze`);
             console.error('');
         }
         process.exitCode = 1;

package/dist/cli/index.js

@@ -55,9 +55,10 @@ program
     .action(createLazyAction(() => import('./index-repo.js'), 'indexCommand'));
 program
     .command('serve')
-    .description('Start local HTTP server for web UI connection')
+    .description('Start local HTTP API and web dashboard')
     .option('-p, --port <port>', 'Port number', '4747')
     .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
+    .option('--web <mode>', 'Dashboard mode: local serves the bundled app, hosted prints hosted UI connection info, off serves API only', 'local')
     .action(createLazyAction(() => import('./serve.js'), 'serveCommand'));
 program
     .command('mcp')
@@ -135,6 +136,43 @@ program
     .description('Execute raw Cypher query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
     .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
+program
+    .command('feature-clusters')
+    .description('List human-facing feature clusters for targeted context building')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max feature clusters to return (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'featureClustersCommand'));
+program
+    .command('cluster-query [query]')
+    .description('Alias for feature-clusters: list product/domain clusters')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max feature clusters to return (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'clusterQueryCommand'));
+program
+    .command('feature-context <name>')
+    .description('Show members, line ranges, and dependencies for a feature cluster')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max members to return (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'featureContextCommand'));
+program
+    .command('cluster-context <name>')
+    .description('Alias for feature-context: show a feature cluster context pack')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max members to return (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'clusterContextCommand'));
+program
+    .command('context-pack <name>')
+    .description('Generate the compact agent context pack for a feature cluster')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max members to return (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'contextPackCommand'));
+program
+    .command('cluster-impact <name>')
+    .description('Feature-level blast radius analysis for a cluster')
+    .option('-d, --direction <dir>', 'upstream, downstream, or both', 'upstream')
+    .option('-r, --repo <name>', 'Target repository')
+    .option('-l, --limit <n>', 'Max context-pack members to include (default: 100)')
+    .action(createLazyAction(() => import('./tool.js'), 'clusterImpactCommand'));
 program
     .command('detect-changes')
     .alias('detect_changes')

package/dist/cli/serve.d.ts

@@ -1,4 +1,5 @@
 export declare const serveCommand: (options?: {
     port?: string;
     host?: string;
+    web?: string;
 }) => Promise<void>;

package/dist/cli/serve.js

@@ -1,4 +1,5 @@
 import { createServer } from '../server/api.js';
+import { normalizeWebDashboardMode } from '../server/web-dashboard.js';
 // Catch anything that would cause a silent exit
 process.on('uncaughtException', (err) => {
     console.error('\n[codragraph serve] Uncaught exception:', err.message);
@@ -19,7 +20,8 @@ export const serveCommand = async (options) => {
     // hosted frontend at codragraph.vercel.app connects to localhost.
     const host = options?.host ?? 'localhost';
     try {
-        await createServer(port, host);
+        const web = normalizeWebDashboardMode(options?.web);
+        await createServer(port, host, { web });
     }
     catch (err) {
         console.error(`\nFailed to start CodraGraph server:\n`);

package/dist/cli/setup.js

@@ -11,15 +11,19 @@ import os from 'os';
 import { execFile, execFileSync } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
 import { glob } from 'glob';
 import { parseTree, modify, applyEdits } from 'jsonc-parser';
 import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+const CLI_PACKAGE_SPEC = `@codragraph/cli@${pkg.version}`;
 /**
  * Resolve the absolute path to the `codragraph` binary if it's installed
- * globally (or via npm -g / yarn global). Returns null when not found.
+ * globally (or via npm -g / bun -g / yarn global). Returns null when not found.
  *
  * Note: the npm package is `@codragraph/cli`, but the executable it installs
  * is `codragraph` (see package.json `bin`). PATH lookup must use the bin name.
@@ -45,7 +49,7 @@ function resolveCodragraphBin() {
             .filter(Boolean);
         if (process.platform === 'win32') {
             // Prefer a Windows-executable shim. If none is on PATH, return null so
-            // the caller falls through to the `cmd /c npx -y @codragraph/cli` path.
+            // the caller falls through to the package-runner fallback.
             const exe = lines.find((l) => /\.(cmd|exe|bat)$/i.test(l));
             return exe ?? null;
         }
@@ -59,39 +63,61 @@ function resolveCodragraphBin() {
  * The MCP server entry for all editors.
  *
  * Prefers the globally-installed `codragraph` binary (starts in ~1 s) over
- * `npx -y @codragraph/cli@latest` (cold-cache install of native deps can take
+ * `npx` / `bunx` package execution (cold-cache install of native deps can take
  * >60 s, exceeding Claude Code's 30 s MCP connection timeout).
  *
- * Falls back to npx when the binary isn't on PATH — e.g. first-time
- * users who ran `npx @codragraph/cli analyze` but haven't done `npm i -g`.
+ * Falls back to the package runner that invoked setup when the binary isn't on
+ * PATH — e.g. first-time `npx @codragraph/cli` or `bunx @codragraph/cli` users.
  *
  * Windows note: even when the bin is on PATH, we launch via `cmd /c codragraph
  * mcp` rather than writing the resolved path. Reason: `where codragraph`
  * returns the extensionless Unix shim before `codragraph.cmd`, and Node's
  * spawn/execFile cannot launch the extensionless shim on Windows. Letting
  * cmd resolve via PATHEXT is the only reliable path that works for npm-,
- * pnpm-, and yarn-installed shims alike.
+ * bun-, pnpm-, and yarn-installed shims alike.
  */
-function getMcpEntry() {
-    const bin = resolveCodragraphBin();
-    if (bin) {
+function isRunningUnderBun() {
+    const userAgent = (process.env.npm_config_user_agent ?? '').toLowerCase();
+    const rawExecPath = process.env.npm_execpath ?? '';
+    const execPath = process.platform === 'win32'
+        ? path.win32.basename(rawExecPath).toLowerCase()
+        : path.basename(rawExecPath).toLowerCase();
+    return userAgent.startsWith('bun/') || execPath === 'bun' || execPath === 'bun.exe';
+}
+function getPackageRunnerMcpEntry() {
+    if (isRunningUnderBun()) {
         if (process.platform === 'win32') {
-            return { command: 'cmd', args: ['/c', 'codragraph', 'mcp'] };
+            return {
+                command: 'cmd',
+                args: ['/c', 'bunx', CLI_PACKAGE_SPEC, 'mcp'],
+            };
         }
-        return { command: bin, args: ['mcp'] };
+        return {
+            command: 'bunx',
+            args: [CLI_PACKAGE_SPEC, 'mcp'],
+        };
     }
-    // Fallback: npx (works without a global install, but slow cold-start)
     if (process.platform === 'win32') {
         return {
             command: 'cmd',
-            args: ['/c', 'npx', '-y', '@codragraph/cli@latest', 'mcp'],
+            args: ['/c', 'npx', '-y', CLI_PACKAGE_SPEC, 'mcp'],
         };
     }
     return {
         command: 'npx',
-        args: ['-y', '@codragraph/cli@latest', 'mcp'],
+        args: ['-y', CLI_PACKAGE_SPEC, 'mcp'],
     };
 }
+function getMcpEntry() {
+    const bin = resolveCodragraphBin();
+    if (bin) {
+        if (process.platform === 'win32') {
+            return { command: 'cmd', args: ['/c', 'codragraph', 'mcp'] };
+        }
+        return { command: bin, args: ['mcp'] };
+    }
+    return getPackageRunnerMcpEntry();
+}
 /**
  * OpenCode uses a different MCP format: { type: "local", command: [...] }
  * where command is a flat array (command + args combined).
@@ -104,13 +130,8 @@ function getOpenCodeMcpEntry() {
         }
         return { type: 'local', command: [bin, 'mcp'] };
     }
-    if (process.platform === 'win32') {
-        return {
-            type: 'local',
-            command: ['cmd', '/c', 'npx', '-y', '@codragraph/cli@latest', 'mcp'],
-        };
-    }
-    return { type: 'local', command: ['npx', '-y', '@codragraph/cli@latest', 'mcp'] };
+    const entry = getPackageRunnerMcpEntry();
+    return { type: 'local', command: [entry.command, ...entry.args] };
 }
 /**
  * Merge codragraph entry into an existing MCP config JSON object.

package/dist/cli/status.d.ts

@@ -3,4 +3,17 @@
  *
  * Shows the indexing status of the current repository.
  */
+import { type RepoMeta } from '../storage/repo-manager.js';
+export declare const LARGE_INDEX_WARNING_BYTES: number;
+export interface IndexStorageSummary {
+    path: string;
+    bytes: number;
+    fileCount: number;
+    unreadableEntries: number;
+}
+export declare const formatBytes: (bytes: number) => string;
+export declare const summarizeIndexStorage: (storagePath: string) => Promise<IndexStorageSummary | null>;
+export declare const formatIndexStatusLines: (summary: IndexStorageSummary | null, meta: Pick<RepoMeta, "stats" | "compress">, options?: {
+    largeIndexWarningBytes?: number;
+}) => string[];
 export declare const statusCommand: () => Promise<void>;

package/dist/cli/status.js

@@ -3,8 +3,99 @@
  *
  * Shows the indexing status of the current repository.
  */
+import fs from 'fs/promises';
+import path from 'path';
 import { findRepo, getStoragePaths, hasKuzuIndex } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
+export const LARGE_INDEX_WARNING_BYTES = 500 * 1024 * 1024;
+const STORAGE_SCAN_BATCH_SIZE = 64;
+export const formatBytes = (bytes) => {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    if (unitIndex === 0)
+        return `${Math.round(value)} ${units[unitIndex]}`;
+    return `${value.toFixed(1)} ${units[unitIndex]}`;
+};
+export const summarizeIndexStorage = async (storagePath) => {
+    let rootStat;
+    try {
+        rootStat = await fs.lstat(storagePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        return { path: storagePath, bytes: 0, fileCount: 0, unreadableEntries: 1 };
+    }
+    if (!rootStat.isDirectory()) {
+        return { path: storagePath, bytes: rootStat.size, fileCount: 1, unreadableEntries: 0 };
+    }
+    const stack = [storagePath];
+    let bytes = 0;
+    let fileCount = 0;
+    let unreadableEntries = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            unreadableEntries += 1;
+            continue;
+        }
+        for (let i = 0; i < entries.length; i += STORAGE_SCAN_BATCH_SIZE) {
+            const batch = entries.slice(i, i + STORAGE_SCAN_BATCH_SIZE);
+            const stats = await Promise.all(batch.map(async (entry) => {
+                const entryPath = path.join(current, entry.name);
+                try {
+                    return { entryPath, stat: await fs.lstat(entryPath) };
+                }
+                catch {
+                    return { entryPath, stat: null };
+                }
+            }));
+            for (const { entryPath, stat } of stats) {
+                if (!stat) {
+                    unreadableEntries += 1;
+                    continue;
+                }
+                if (stat.isDirectory()) {
+                    stack.push(entryPath);
+                    continue;
+                }
+                bytes += stat.size;
+                fileCount += 1;
+            }
+        }
+    }
+    return { path: storagePath, bytes, fileCount, unreadableEntries };
+};
+export const formatIndexStatusLines = (summary, meta, options = {}) => {
+    const lines = [];
+    const threshold = options.largeIndexWarningBytes ?? LARGE_INDEX_WARNING_BYTES;
+    if (summary) {
+        const fileLabel = summary.fileCount === 1 ? 'file' : 'files';
+        lines.push(`Index size: ${formatBytes(summary.bytes)} (${summary.fileCount.toLocaleString('en-US')} ${fileLabel} under .codragraph)`);
+        if (summary.unreadableEntries > 0) {
+            const entryLabel = summary.unreadableEntries === 1 ? 'entry' : 'entries';
+            lines.push(`Index size note: ${summary.unreadableEntries.toLocaleString('en-US')} ${entryLabel} could not be read.`);
+        }
+        if (summary.bytes >= threshold) {
+            lines.push(`Storage warning: .codragraph is ${formatBytes(summary.bytes)} (>= ${formatBytes(threshold)}). Consider codragraph analyze --compress brotli (or zstd on Node >=22.15) and only use --embeddings when vectors are needed.`);
+        }
+    }
+    const embeddings = meta.stats?.embeddings;
+    lines.push(`Embeddings: ${typeof embeddings === 'number' ? embeddings.toLocaleString('en-US') : 'unknown'}`);
+    lines.push(`Compression: ${meta.compress ?? 'none'}`);
+    return lines;
+};
 export const statusCommand = async () => {
     const cwd = process.cwd();
     if (!isGitRepo(cwd)) {
@@ -16,6 +107,7 @@ export const statusCommand = async () => {
         // Check if there's a stale KuzuDB index that needs migration
         const repoRoot = getGitRoot(cwd) ?? cwd;
         const { storagePath } = getStoragePaths(repoRoot);
+        const storageSummary = await summarizeIndexStorage(storagePath);
         if (await hasKuzuIndex(storagePath)) {
             console.log('Repository has a stale KuzuDB index from a previous version.');
             console.log('Run: codragraph analyze   (rebuilds the index with LadybugDB)');
@@ -24,13 +116,20 @@ export const statusCommand = async () => {
             console.log('Repository not indexed.');
             console.log('Run: codragraph analyze');
         }
+        if (storageSummary) {
+            for (const line of formatIndexStatusLines(storageSummary, {}))
+                console.log(line);
+        }
         return;
     }
     const currentCommit = getCurrentCommit(repo.repoPath);
     const isUpToDate = currentCommit === repo.meta.lastCommit;
+    const storageSummary = await summarizeIndexStorage(repo.storagePath);
     console.log(`Repository: ${repo.repoPath}`);
     console.log(`Indexed: ${new Date(repo.meta.indexedAt).toLocaleString()}`);
     console.log(`Indexed commit: ${repo.meta.lastCommit?.slice(0, 7)}`);
     console.log(`Current commit: ${currentCommit?.slice(0, 7)}`);
+    for (const line of formatIndexStatusLines(storageSummary, repo.meta))
+        console.log(line);
     console.log(`Status: ${isUpToDate ? '✅ up-to-date' : '⚠️ stale (re-run codragraph analyze)'}`);
 };

package/dist/cli/tool.d.ts

@@ -36,6 +36,31 @@ export declare function impactCommand(target: string, options?: {
 export declare function cypherCommand(query: string, options?: {
     repo?: string;
 }): Promise<void>;
+export declare function featureClustersCommand(options?: {
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function clusterQueryCommand(query?: string, options?: {
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function featureContextCommand(name: string, options?: {
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function clusterContextCommand(name: string, options?: {
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function contextPackCommand(name: string, options?: {
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function clusterImpactCommand(name: string, options?: {
+    direction?: string;
+    repo?: string;
+    limit?: string;
+}): Promise<void>;
 export declare function detectChangesCommand(options?: {
     scope?: string;
     baseRef?: string;

package/dist/cli/tool.js

@@ -128,6 +128,80 @@ export async function cypherCommand(query, options) {
     });
     output(result);
 }
+export async function featureClustersCommand(options) {
+    const backend = await getBackend();
+    const result = await backend.callTool('feature_clusters', {
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+}
+export async function clusterQueryCommand(query, options) {
+    const backend = await getBackend();
+    const result = await backend.callTool('cluster_query', {
+        query,
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+}
+export async function featureContextCommand(name, options) {
+    if (!name?.trim()) {
+        console.error('Usage: codragraph feature-context <name>');
+        process.exit(1);
+    }
+    const backend = await getBackend();
+    const result = await backend.callTool('feature_context', {
+        name,
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+    emitTokenStats(result);
+}
+export async function clusterContextCommand(name, options) {
+    if (!name?.trim()) {
+        console.error('Usage: codragraph cluster-context <name>');
+        process.exit(1);
+    }
+    const backend = await getBackend();
+    const result = await backend.callTool('cluster_context', {
+        name,
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+    emitTokenStats(result);
+}
+export async function contextPackCommand(name, options) {
+    if (!name?.trim()) {
+        console.error('Usage: codragraph context-pack <name>');
+        process.exit(1);
+    }
+    const backend = await getBackend();
+    const result = await backend.callTool('context_pack', {
+        name,
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+    emitTokenStats(result);
+}
+export async function clusterImpactCommand(name, options) {
+    if (!name?.trim()) {
+        console.error('Usage: codragraph cluster-impact <name>');
+        process.exit(1);
+    }
+    const backend = await getBackend();
+    const result = await backend.callTool('cluster_impact', {
+        name,
+        direction: options?.direction,
+        repo: options?.repo,
+        limit: options?.limit ? parseInt(options.limit, 10) : undefined,
+    });
+    output(result);
+    emitTokenStats(result);
+}
 function formatDetectChangesResult(result) {
     if (result?.error)
         return `Error: ${result.error}`;

package/dist/config/ignore-service.js

@@ -212,6 +212,8 @@ const IGNORED_EXTENSIONS = new Set([
 // Files to ignore by exact name
 const IGNORED_FILES = new Set([
     'package-lock.json',
+    'bun.lock',
+    'bun.lockb',
     'yarn.lock',
     'pnpm-lock.yaml',
     'composer.lock',

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

@@ -1,12 +1,12 @@
 /**
- * Re-export SupportedLanguages from codragraph-shared (single source of truth).
+ * Re-export SupportedLanguages from @codragraph/shared (single source of truth).
  *
  * HOW TO ADD A NEW LANGUAGE:
  *
- * 1. Add the enum member in codragraph-shared/src/languages.ts
+ * 1. Add the enum member in packages/shared/src/languages.ts
  * 2. Run `tsc --noEmit` — compiler errors guide you to every dispatch table
  * 3. Use the checklist in each ingestion file for what to add
- * 4. Add tree-sitter-<lang> to codragraph/package.json dependencies
+ * 4. Add tree-sitter-<lang> to packages/core/package.json dependencies
  * 5. Add file extension mapping in utils.ts getLanguageFromFilename()
  * 6. Run full test suite
  */

package/dist/config/supported-languages.js

@@ -1,12 +1,12 @@
 /**
- * Re-export SupportedLanguages from codragraph-shared (single source of truth).
+ * Re-export SupportedLanguages from @codragraph/shared (single source of truth).
  *
  * HOW TO ADD A NEW LANGUAGE:
  *
- * 1. Add the enum member in codragraph-shared/src/languages.ts
+ * 1. Add the enum member in packages/shared/src/languages.ts
  * 2. Run `tsc --noEmit` — compiler errors guide you to every dispatch table
  * 3. Use the checklist in each ingestion file for what to add
- * 4. Add tree-sitter-<lang> to codragraph/package.json dependencies
+ * 4. Add tree-sitter-<lang> to packages/core/package.json dependencies
  * 5. Add file extension mapping in utils.ts getLanguageFromFilename()
  * 6. Run full test suite
  */