@codragraph/cli 2.1.4 → 2.1.6

package/dist/cli/index.js

@@ -8,6 +8,26 @@ import { registerGroupCommands } from './group.js';
 const _require = createRequire(import.meta.url);
 const pkg = _require('../../package.json');
 const program = new Command();
+const exitOneShot = (code) => {
+    const reallyExit = process
+        .reallyExit;
+    if (typeof reallyExit === 'function') {
+        reallyExit(code);
+    }
+    process.exit(code);
+};
+const createOneShotLazyAction = (loader, exportName) => {
+    const action = createLazyAction(loader, exportName);
+    return async (...args) => {
+        await action(...args);
+        const code = typeof process.exitCode === 'number'
+            ? process.exitCode
+            : process.exitCode
+                ? Number(process.exitCode) || 1
+                : 0;
+        exitOneShot(code);
+    };
+};
 program.name('codragraph').description('CodraGraph local CLI and MCP server').version(pkg.version);
 program
     .command('setup')
@@ -17,7 +37,9 @@ program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
-    .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
+    .option('--profile <mode>', 'Adaptive runtime profile: auto, lean, balanced, power', 'auto')
+    .option('--embedding-mode <mode>', 'Embedding policy: auto, off, on', 'auto')
+    .option('--embeddings', 'Enable embedding generation for semantic search (same as --embedding-mode on)')
     .option('--skills', 'Generate repo-specific skill files from detected communities')
     .option('--skill-targets <list>', 'CSV of editor targets for --skills (claude, cursor, opencode, codex). Default: claude.')
     .option('--skip-agents-md', 'Skip updating the codragraph section in AGENTS.md and CLAUDE.md')
@@ -30,7 +52,7 @@ program
     .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
     .option('--max-file-size <kb>', 'Skip files larger than this (KB). Default: 512. Hard cap: 32768 (tree-sitter limit).')
     .option('--no-setup', 'Skip the first-run editor setup (auto-runs once when ~/.codragraph/registry.json is missing)')
-    .option('--compress <encoding>', 'Compress per-row content (RFC 0001 Phase 2). One of: none (default), brotli, zstd. zstd requires Node ≥ 22.15.', 'none')
+    .option('--compress <encoding>', 'Compress per-row content. One of: auto (default), none, brotli, zstd. zstd requires Node >= 22.15.', 'auto')
     .addHelpText('after', '\nEnvironment variables:\n' +
     '  CODRAGRAPH_NO_GITIGNORE=1   Skip .gitignore parsing (still reads .codragraphignore)\n' +
     '  CODRAGRAPH_MAX_FILE_SIZE=N  Override large-file skip threshold (KB). Default 512, max 32768.\n' +
@@ -114,65 +136,69 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
-    .action(createLazyAction(() => import('./tool.js'), 'queryCommand'));
+    .action(createOneShotLazyAction(() => import('./tool.js'), 'queryCommand'));
 program
     .command('context [name]')
     .description('360-degree view of a code symbol: callers, callees, processes')
     .option('-r, --repo <name>', 'Target repository')
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
+    .option('-k, --kind <kind>', 'Symbol kind to disambiguate common names')
     .option('--content', 'Include full symbol source code')
-    .action(createLazyAction(() => import('./tool.js'), 'contextCommand'));
+    .action(createOneShotLazyAction(() => import('./tool.js'), 'contextCommand'));
 program
-    .command('impact <target>')
+    .command('impact [target]')
     .description('Blast radius analysis: what breaks if you change a symbol')
     .option('-d, --direction <dir>', 'upstream (dependants) or downstream (dependencies)', 'upstream')
     .option('-r, --repo <name>', 'Target repository')
+    .option('-u, --uid <uid>', 'Direct target symbol UID (zero-ambiguity lookup)')
+    .option('-f, --file <path>', 'File path to disambiguate common names')
+    .option('-k, --kind <kind>', 'Symbol kind to disambiguate common names')
     .option('--depth <n>', 'Max relationship depth (default: 3)')
     .option('--include-tests', 'Include test files in results')
-    .action(createLazyAction(() => import('./tool.js'), 'impactCommand'));
+    .action(createOneShotLazyAction(() => import('./tool.js'), 'impactCommand'));
 program
     .command('cypher <query>')
     .description('Execute raw Cypher query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => 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'));
+    .action(createOneShotLazyAction(() => import('./tool.js'), 'clusterImpactCommand'));
 program
     .command('detect-changes')
     .alias('detect_changes')
@@ -180,7 +206,7 @@ program
     .option('-s, --scope <scope>', 'What to analyze: unstaged, staged, all, or compare', 'unstaged')
     .option('-b, --base-ref <ref>', 'Branch/commit for compare scope (e.g. main)')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'detectChangesCommand'));
+    .action(createOneShotLazyAction(() => import('./tool.js'), 'detectChangesCommand'));
 // ─── Eval Server (persistent daemon for SWE-bench) ─────────────────
 program
     .command('eval-server')

package/dist/cli/status.d.ts

@@ -13,7 +13,7 @@ export interface IndexStorageSummary {
 }
 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?: {
+export declare const formatIndexStatusLines: (summary: IndexStorageSummary | null, meta: Pick<RepoMeta, "stats" | "compress" | "adaptiveProfile">, options?: {
     largeIndexWarningBytes?: number;
 }) => string[];
 export declare const statusCommand: () => Promise<void>;

package/dist/cli/status.js

@@ -94,6 +94,14 @@ export const formatIndexStatusLines = (summary, meta, options = {}) => {
     const embeddings = meta.stats?.embeddings;
     lines.push(`Embeddings: ${typeof embeddings === 'number' ? embeddings.toLocaleString('en-US') : 'unknown'}`);
     lines.push(`Compression: ${meta.compress ?? 'none'}`);
+    if (meta.adaptiveProfile?.resolved) {
+        const profile = meta.adaptiveProfile;
+        const workerText = typeof profile.workerPoolSize === 'number' ? `, workers ${profile.workerPoolSize}` : '';
+        const embeddingText = profile.embeddingDecision
+            ? `, embeddings ${profile.embeddingDecision}`
+            : '';
+        lines.push(`Adaptive profile: ${profile.resolved}${workerText}${embeddingText}`);
+    }
     return lines;
 };
 export const statusCommand = async () => {

package/dist/cli/tool.d.ts

@@ -21,15 +21,23 @@ export declare function queryCommand(queryText: string, options?: {
     limit?: string;
     content?: boolean;
 }): Promise<void>;
-export declare function contextCommand(name: string, options?: {
+export declare function contextCommand(name: string | undefined | {
+    opts?: () => Record<string, unknown>;
+}, options?: {
     repo?: string;
     file?: string;
     uid?: string;
+    kind?: string;
     content?: boolean;
 }): Promise<void>;
-export declare function impactCommand(target: string, options?: {
+export declare function impactCommand(target: string | undefined | {
+    opts?: () => Record<string, unknown>;
+}, options?: {
     direction?: string;
     repo?: string;
+    uid?: string;
+    file?: string;
+    kind?: string;
     depth?: string;
     includeTests?: boolean;
 }): Promise<void>;

package/dist/cli/tool.js

@@ -17,6 +17,7 @@
 import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 import { emitTokenStats } from './compress-stats.js';
+import { findRepo } from '../storage/repo-manager.js';
 let _backend = null;
 async function getBackend() {
     if (_backend)
@@ -29,6 +30,27 @@ async function getBackend() {
     }
     return _backend;
 }
+async function callToolOnce(toolName, params) {
+    const backend = await getBackend();
+    return backend.callTool(toolName, params);
+}
+async function resolveCliRepoParam(repoParam) {
+    if (repoParam)
+        return repoParam;
+    const currentRepo = await findRepo(process.cwd());
+    if (currentRepo)
+        return currentRepo.repoPath;
+    output(`Error: Current repository is not indexed: ${process.cwd()}\n` +
+        'Run: npx @codragraph/cli analyze');
+    process.exitCode = 1;
+    return null;
+}
+function unwrapCommanderOptions(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const maybeCommand = value;
+    return typeof maybeCommand.opts === 'function' ? maybeCommand.opts() : value;
+}
 /**
  * Write tool output to stdout using low-level fd write.
  *
@@ -59,47 +81,67 @@ export async function queryCommand(queryText, options) {
         console.error('Usage: codragraph query <search_query>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('query', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('query', {
         query: queryText,
         task_context: options?.context,
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
-        repo: options?.repo,
+        repo,
     });
     output(result);
     emitTokenStats(result);
 }
 export async function contextCommand(name, options) {
-    if (!name?.trim() && !options?.uid) {
+    let symbolName = typeof name === 'string' ? name : undefined;
+    if (typeof name !== 'string' && name && !options) {
+        options = unwrapCommanderOptions(name);
+        symbolName = undefined;
+    }
+    if (!symbolName?.trim() && !options?.uid) {
         console.error('Usage: codragraph context <symbol_name> [--uid <uid>] [--file <path>]');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('context', {
-        name: name || undefined,
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('context', {
+        name: symbolName || undefined,
         uid: options?.uid,
         file_path: options?.file,
+        kind: options?.kind,
         include_content: options?.content ?? false,
-        repo: options?.repo,
+        repo,
     });
     output(result);
     emitTokenStats(result);
 }
 export async function impactCommand(target, options) {
-    if (!target?.trim()) {
-        console.error('Usage: codragraph impact <symbol_name> [--direction upstream|downstream]');
+    let targetName = typeof target === 'string' ? target : undefined;
+    if (typeof target !== 'string' && target && !options) {
+        options = unwrapCommanderOptions(target);
+        targetName = undefined;
+    }
+    if (!targetName?.trim() && !options?.uid) {
+        console.error('Usage: codragraph impact <symbol_name> [--uid <uid>] [--direction upstream|downstream]');
         process.exit(1);
     }
     try {
-        const backend = await getBackend();
-        const result = await backend.callTool('impact', {
-            target,
+        const repo = await resolveCliRepoParam(options?.repo);
+        if (!repo)
+            return;
+        const result = await callToolOnce('impact', {
+            target: targetName || undefined,
+            target_uid: options?.uid,
+            file_path: options?.file,
+            kind: options?.kind,
             direction: options?.direction || 'upstream',
             maxDepth: options?.depth ? parseInt(options.depth, 10) : undefined,
             includeTests: options?.includeTests ?? false,
-            repo: options?.repo,
+            repo,
         });
         output(result);
         emitTokenStats(result);
@@ -109,7 +151,7 @@ export async function impactCommand(target, options) {
         // The backend's impact() already returns structured errors for graph query failures
         output({
             error: (err instanceof Error ? err.message : String(err)) || 'Impact analysis failed unexpectedly',
-            target: { name: target },
+            target: { name: targetName || options?.uid },
             direction: options?.direction || 'upstream',
             suggestion: 'Try reducing --depth or using codragraph context <symbol> as a fallback',
         });
@@ -121,26 +163,32 @@ export async function cypherCommand(query, options) {
         console.error('Usage: codragraph cypher <cypher_query>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cypher', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cypher', {
         query,
-        repo: options?.repo,
+        repo,
     });
     output(result);
 }
 export async function featureClustersCommand(options) {
-    const backend = await getBackend();
-    const result = await backend.callTool('feature_clusters', {
-        repo: options?.repo,
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('feature_clusters', {
+        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', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_query', {
         query,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -150,10 +198,12 @@ export async function featureContextCommand(name, options) {
         console.error('Usage: codragraph feature-context <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('feature_context', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('feature_context', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -164,10 +214,12 @@ export async function clusterContextCommand(name, options) {
         console.error('Usage: codragraph cluster-context <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cluster_context', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_context', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -178,10 +230,12 @@ export async function contextPackCommand(name, options) {
         console.error('Usage: codragraph context-pack <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('context_pack', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('context_pack', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -192,11 +246,13 @@ export async function clusterImpactCommand(name, options) {
         console.error('Usage: codragraph cluster-impact <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cluster_impact', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_impact', {
         name,
         direction: options?.direction,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -236,11 +292,16 @@ function formatDetectChangesResult(result) {
     return lines.join('\n').trim();
 }
 export async function detectChangesCommand(options) {
-    const backend = await getBackend();
-    const result = await backend.callTool('detect_changes', {
+    options = unwrapCommanderOptions(options);
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('detect_changes', {
         scope: options?.scope || 'unstaged',
         base_ref: options?.baseRef,
-        repo: options?.repo,
+        repo,
     });
     output(formatDetectChangesResult(result));
+    if (result?.error)
+        process.exitCode = 1;
 }

package/dist/config/ignore-service.js

@@ -4,6 +4,7 @@ import nodePath from 'path';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
+    '.codragraph',
     '.svn',
     '.hg',
     '.bzr',

package/dist/core/adaptive-profile.d.ts

@@ -0,0 +1,52 @@
+import type { ContentEncoding } from '@codragraph/graphstore';
+import type { RepoMeta } from '../storage/repo-manager.js';
+export type AnalyzeProfileOption = 'auto' | 'lean' | 'balanced' | 'power';
+export type ResolvedAnalyzeProfile = Exclude<AnalyzeProfileOption, 'auto'>;
+export type EmbeddingMode = 'auto' | 'off' | 'on';
+export type CompressionOption = ContentEncoding | 'auto';
+export interface MachineSnapshot {
+    platform: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    logicalCpus: number;
+    availableParallelism: number;
+    totalMemoryBytes: number;
+    freeMemoryBytes: number;
+    heapLimitBytes: number;
+    nodeVersion: string;
+    httpEmbeddingsConfigured: boolean;
+}
+export interface AdaptiveAnalyzePlan {
+    requestedProfile: AnalyzeProfileOption;
+    profile: ResolvedAnalyzeProfile;
+    machine: MachineSnapshot;
+    compress: ContentEncoding;
+    embeddingMode: EmbeddingMode;
+    embeddingNodeLimit: number;
+    workerPoolSize: number;
+    workerSubBatchSize: number;
+    reasons: string[];
+}
+export interface EmbeddingDecision {
+    enabled: boolean;
+    reason: string;
+    limit: number;
+}
+export declare const parseAnalyzeProfile: (value?: string) => AnalyzeProfileOption;
+export declare const parseEmbeddingMode: (value?: string) => EmbeddingMode;
+export declare const parseCompressionOption: (value?: string) => CompressionOption;
+export declare const detectMachineSnapshot: () => MachineSnapshot;
+export declare const resolveAnalyzeProfile: (requested: AnalyzeProfileOption, machine: MachineSnapshot) => ResolvedAnalyzeProfile;
+export declare const resolveEmbeddingMode: (embeddingsFlag: boolean | undefined, requestedMode: string | undefined) => EmbeddingMode;
+export declare const resolveCompression: (requested: CompressionOption, profile: ResolvedAnalyzeProfile, existingMeta?: Pick<RepoMeta, "compress"> | null) => ContentEncoding;
+export declare const embeddingLimitForProfile: (profile: ResolvedAnalyzeProfile, httpEmbeddingsConfigured: boolean) => number;
+export declare const workerPlanForProfile: (profile: ResolvedAnalyzeProfile, machine: Pick<MachineSnapshot, "availableParallelism">) => Pick<AdaptiveAnalyzePlan, "workerPoolSize" | "workerSubBatchSize">;
+export declare const resolveAdaptiveAnalyzePlan: (input: {
+    profile?: string;
+    embeddingMode?: string;
+    embeddings?: boolean;
+    compress?: string;
+    existingMeta?: Pick<RepoMeta, "compress"> | null;
+    machine?: MachineSnapshot;
+}) => AdaptiveAnalyzePlan;
+export declare const decideEmbeddingRun: (plan: Pick<AdaptiveAnalyzePlan, "embeddingMode" | "embeddingNodeLimit" | "profile" | "machine">, stats?: Pick<NonNullable<RepoMeta["stats"]>, "nodes" | "embeddings">) => EmbeddingDecision;
+export declare const formatAdaptiveAnalyzePlan: (plan: AdaptiveAnalyzePlan) => string;