@neurcode-ai/cli 0.18.0 → 0.19.0

package/dist/commands/brain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brain.d.ts","sourceRoot":"","sources":["../../src/commands/brain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgZpC,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgiDnD"}
+{"version":3,"file":"brain.d.ts","sourceRoot":"","sources":["../../src/commands/brain.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsfpC,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA46DnD"}

package/dist/commands/brain.js

@@ -45,6 +45,7 @@ exports.brainCommand = brainCommand;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const brain_1 = require("@neurcode-ai/brain");
 const brain_cache_1 = require("../utils/brain-cache");
 const local_repo_brain_1 = require("../utils/local-repo-brain");
 const repo_brain_impact_1 = require("../utils/repo-brain-impact");
@@ -57,6 +58,7 @@ const messages_1 = require("../utils/messages");
 const brain_context_1 = require("../utils/brain-context");
 const semantic_1 = require("../semantic");
 const ask_cache_1 = require("../utils/ask-cache");
+const proposed_change_analysis_1 = require("../utils/proposed-change-analysis");
 // Import chalk with fallback
 let chalk;
 try {
@@ -280,6 +282,86 @@ function splitChangedPathList(value) {
         .map((path) => path.trim())
         .filter(Boolean);
 }
+function parseRenameList(value) {
+    return splitChangedPathList(value)
+        .map((entry) => {
+        const delimiter = entry.includes('=>') ? '=>' : ':';
+        const [from, to] = entry.split(delimiter, 2).map((item) => item.trim());
+        return from && to ? { from, to } : null;
+    })
+        .filter((entry) => Boolean(entry));
+}
+function repositoryGraphError(error, json) {
+    const locked = error instanceof brain_1.RepositoryGraphLockedError;
+    const payload = {
+        ok: false,
+        code: locked ? 'repository_graph_locked' : 'repository_graph_failed',
+        message: error instanceof Error ? error.message : String(error),
+        exitCode: locked ? 3 : 1,
+    };
+    if (json) {
+        console.log(JSON.stringify(payload, null, 2));
+    }
+    else {
+        (0, messages_1.printError)('Repository Graph V2 operation failed', payload.message);
+    }
+    process.exitCode = payload.exitCode;
+}
+function printRepositoryGraphIndexResult(repoRoot, result, json) {
+    const payload = {
+        ok: true,
+        graphPath: (0, brain_1.repositoryGraphPath)(repoRoot),
+        schemaVersion: result.graph.schemaVersion,
+        graphId: result.graph.graphId,
+        generation: result.graph.generation,
+        freshness: result.graph.freshness,
+        coverage: result.graph.coverage,
+        stats: result.stats,
+        privacy: result.graph.privacy,
+    };
+    if (json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(chalk.bold('\n🧠 Repository Graph V2\n'));
+    console.log(chalk.dim(`Mode:              ${result.stats.mode}`));
+    console.log(chalk.dim(`Generation:        ${result.graph.generation}`));
+    console.log(chalk.dim(`Freshness:         ${result.graph.freshness.state}`));
+    console.log(chalk.dim(`Files indexed:     ${result.graph.coverage.filesIndexed}`));
+    console.log(chalk.dim(`Files parsed:      ${result.stats.filesParsed}`));
+    console.log(chalk.dim(`Files reused:      ${result.stats.filesReused}`));
+    console.log(chalk.dim(`Unsupported:       ${result.graph.coverage.unsupportedPercent}%`));
+    console.log(chalk.dim(`Nodes / edges:     ${result.graph.nodes.length} / ${result.graph.edges.length}`));
+    console.log(chalk.dim(`Graph size:        ${formatBytes(result.stats.graphBytes)}`));
+    console.log(chalk.dim(`Duration:          ${result.stats.durationMs}ms`));
+    console.log(chalk.dim(`Peak RSS:          ${result.stats.peakMemoryMb} MB`));
+    console.log(chalk.dim(`Artifact:          ${payload.graphPath}`));
+    console.log(chalk.dim('Privacy:           source-free local structural facts; raw source is not retained.'));
+}
+function normalizeAdvisoryTarget(repoRoot, input) {
+    const absolutePath = (0, path_1.isAbsolute)(input) ? (0, path_1.resolve)(input) : (0, path_1.resolve)(repoRoot, input);
+    const relativePath = (0, path_1.relative)(repoRoot, absolutePath).replace(/\\/g, '/');
+    if (!relativePath || relativePath === '..' || relativePath.startsWith('../')) {
+        throw new Error(`Path is outside repository root: ${input}`);
+    }
+    return { relativePath, absolutePath };
+}
+function advisoryCategory(value) {
+    const categories = [
+        'behavior_similarity',
+        'reuse_suggestion',
+        'duplicate_module',
+        'architecture_deviation',
+        'cross_service_consequence',
+        'reviewer_question',
+        'missing_test',
+        'ownership_review',
+    ];
+    if (!categories.includes(value)) {
+        throw new Error(`Unsupported advisory category: ${value}`);
+    }
+    return value;
+}
 function renderBrainExportMarkdown(input) {
     const lines = [];
     lines.push('# Neurcode Brain Export');
@@ -595,6 +677,375 @@ function brainCommand(program) {
         }
         (0, messages_1.printInfo)('Next', 'Run: neurcode brain inspect "<area or symbol>"');
     });
+    // -- Repository Graph V2 ---------------------------------------------------
+    brain
+        .command('repo-index')
+        .description('Create or incrementally refresh the persistent Repository Graph V2')
+        .option('--changed <paths>', 'Changed paths separated by commas, spaces, or newlines')
+        .option('--deleted <paths>', 'Deleted paths separated by commas, spaces, or newlines')
+        .option('--rename <pairs>', 'Rename pairs as old:new or old=>new, separated by commas')
+        .option('--max-files <n>', 'Maximum files to inspect', (value) => parseInt(value, 10))
+        .option('--max-total-bytes <n>', 'Maximum total bytes to inspect', (value) => parseInt(value, 10))
+        .option('--max-bytes-per-file <n>', 'Maximum bytes per file', (value) => parseInt(value, 10))
+        .option('--json', 'Output stable machine-readable JSON')
+        .action(async (options) => {
+        const scope = getBrainScope();
+        try {
+            const limits = {
+                ...(Number.isFinite(options.maxFiles) ? { maxFiles: options.maxFiles } : {}),
+                ...(Number.isFinite(options.maxTotalBytes) ? { maxTotalBytes: options.maxTotalBytes } : {}),
+                ...(Number.isFinite(options.maxBytesPerFile) ? { maxBytesPerFile: options.maxBytesPerFile } : {}),
+            };
+            const result = await (0, brain_1.indexRepositoryGraph)({
+                repoRoot: scope.cwd,
+                changedPaths: splitChangedPathList(options.changed),
+                deletedPaths: splitChangedPathList(options.deleted),
+                renamedPaths: parseRenameList(options.rename),
+                limits,
+            });
+            printRepositoryGraphIndexResult(scope.cwd, result, options.json);
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('repo-refresh')
+        .description('Refresh stale Repository Graph V2 files using content hashes')
+        .option('--changed <paths>', 'Optional changed paths separated by commas, spaces, or newlines')
+        .option('--deleted <paths>', 'Optional deleted paths separated by commas, spaces, or newlines')
+        .option('--rename <pairs>', 'Optional rename pairs as old:new or old=>new')
+        .option('--json', 'Output stable machine-readable JSON')
+        .action(async (options) => {
+        const scope = getBrainScope();
+        try {
+            const result = await (0, brain_1.indexRepositoryGraph)({
+                repoRoot: scope.cwd,
+                changedPaths: splitChangedPathList(options.changed),
+                deletedPaths: splitChangedPathList(options.deleted),
+                renamedPaths: parseRenameList(options.rename),
+            });
+            printRepositoryGraphIndexResult(scope.cwd, result, options.json);
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('repo-status')
+        .description('Show Repository Graph V2 freshness, coverage, and parser depth')
+        .option('--json', 'Output stable machine-readable JSON')
+        .action(async (options) => {
+        const scope = getBrainScope();
+        try {
+            const freshness = await (0, brain_1.repositoryGraphStatus)(scope.cwd);
+            const graph = (0, brain_1.readRepositoryGraph)(scope.cwd);
+            const payload = {
+                ok: freshness.state !== 'corrupt',
+                repoRoot: scope.cwd,
+                graphPath: (0, brain_1.repositoryGraphPath)(scope.cwd),
+                freshness,
+                graph: graph ? {
+                    schemaVersion: graph.schemaVersion,
+                    graphId: graph.graphId,
+                    generation: graph.generation,
+                    updatedAt: graph.updatedAt,
+                    coverage: graph.coverage,
+                    nodeCount: graph.nodes.length,
+                    edgeCount: graph.edges.length,
+                    privacy: graph.privacy,
+                } : null,
+            };
+            if (options.json) {
+                console.log(JSON.stringify(payload, null, 2));
+                return;
+            }
+            console.log(chalk.bold('\n🧠 Repository Graph V2 Status\n'));
+            console.log(chalk.dim(`State:             ${freshness.state}`));
+            console.log(chalk.dim(`Indexed at:        ${freshness.indexedAt ?? 'never'}`));
+            console.log(chalk.dim(`Stale files:       ${freshness.staleFileCount}`));
+            console.log(chalk.dim(`Unsupported files: ${freshness.unsupportedFileCount}`));
+            console.log(chalk.dim(`Reason codes:      ${freshness.reasonCodes.join(', ') || 'none'}`));
+            if (graph) {
+                console.log(chalk.dim(`Generation:        ${graph.generation}`));
+                console.log(chalk.dim(`Nodes / edges:     ${graph.nodes.length} / ${graph.edges.length}`));
+                console.log(chalk.dim(`Unsupported:       ${graph.coverage.unsupportedPercent}%`));
+                for (const language of graph.coverage.languages) {
+                    console.log(chalk.dim(`  ${language.language}: ${language.depth}; ${language.filesAnalyzed}/${language.filesSeen} analyzed`));
+                }
+            }
+            else {
+                console.log(chalk.dim('Run `neurcode brain repo-index` to create the graph.'));
+            }
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('repo-explain <query...>')
+        .description('Explain a source-free path, symbol, package, service, or surface in Repository Graph V2')
+        .option('--limit <n>', 'Maximum matching nodes (default: 25)', (value) => parseInt(value, 10))
+        .option('--json', 'Output stable machine-readable JSON')
+        .action((queryParts, options) => {
+        const scope = getBrainScope();
+        const graph = (0, brain_1.readRepositoryGraph)(scope.cwd);
+        if (!graph) {
+            repositoryGraphError(new Error('Repository Graph V2 is missing or corrupt. Run `neurcode brain repo-index`.'), options.json);
+            return;
+        }
+        const query = queryParts.join(' ').trim();
+        const matches = (0, brain_1.explainRepositoryGraph)(graph, query, options.limit);
+        const matchIds = new Set(matches.map((node) => node.id));
+        const edges = graph.edges.filter((edge) => matchIds.has(edge.fromId) || matchIds.has(edge.toId));
+        const payload = { ok: true, query, matches, edges, freshness: graph.freshness };
+        if (options.json) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        console.log(chalk.bold(`\n🧠 Repository Graph V2: ${query}\n`));
+        if (matches.length === 0) {
+            console.log(chalk.dim('No source-free graph facts matched.'));
+            return;
+        }
+        matches.forEach((node, index) => {
+            console.log(chalk.white(`  ${index + 1}. [${node.kind}] ${node.name ?? node.key}`));
+            if (node.path)
+                console.log(chalk.dim(`     path: ${node.path}`));
+            console.log(chalk.dim(`     parser: ${node.provenance.parserDepth}`));
+        });
+        console.log(chalk.dim(`Related edges: ${edges.length}`));
+    });
+    brain
+        .command('repo-query')
+        .description('Query deterministic Repository Graph V2 references, dependencies, imports, calls, tests, or boundaries')
+        .option('--path <path>', 'Seed path or path fragment')
+        .option('--symbol <name>', 'Seed symbol name or fragment')
+        .option('--relationship <type>', 'Edge type such as references, depends_on, imports, calls, tests, or crosses_boundary')
+        .option('--direction <direction>', 'in | out | both', 'both')
+        .option('--limit <n>', 'Maximum nodes and edges (default: 100)', (value) => parseInt(value, 10))
+        .option('--json', 'Output stable machine-readable JSON')
+        .action((options) => {
+        const scope = getBrainScope();
+        const graph = (0, brain_1.readRepositoryGraph)(scope.cwd);
+        if (!graph) {
+            repositoryGraphError(new Error('Repository Graph V2 is missing or corrupt. Run `neurcode brain repo-index`.'), options.json);
+            return;
+        }
+        const allowedRelationships = new Set([
+            'defines', 'references', 'imports', 'exports', 'calls', 'owns',
+            'belongs_to_package', 'belongs_to_service', 'tests', 'depends_on',
+            'structurally_resembles', 'crosses_boundary',
+        ]);
+        const relationship = options.relationship;
+        if (relationship && !allowedRelationships.has(relationship)) {
+            repositoryGraphError(new Error(`Unsupported relationship: ${relationship}`), options.json);
+            return;
+        }
+        const direction = options.direction === 'in' || options.direction === 'out' ? options.direction : 'both';
+        const result = (0, brain_1.queryRepositoryGraph)(graph, {
+            path: options.path,
+            symbol: options.symbol,
+            relationship,
+            direction,
+            limit: options.limit,
+        });
+        const payload = { ok: true, query: options, ...result, freshness: graph.freshness };
+        if (options.json) {
+            console.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        console.log(chalk.bold('\n🧠 Repository Graph V2 Query\n'));
+        console.log(chalk.dim(`Seeds: ${result.seeds.length} | Nodes: ${result.nodes.length} | Edges: ${result.edges.length}`));
+        result.edges.forEach((edge) => {
+            console.log(chalk.dim(`  ${edge.type}: ${edge.fromId} -> ${edge.toId}`));
+        });
+    });
+    brain
+        .command('repo-rebuild')
+        .description('Rebuild Repository Graph V2 from local repository state')
+        .option('--json', 'Output stable machine-readable JSON')
+        .action(async (options) => {
+        const scope = getBrainScope();
+        try {
+            const result = await (0, brain_1.indexRepositoryGraph)({ repoRoot: scope.cwd, forceRebuild: true });
+            printRepositoryGraphIndexResult(scope.cwd, result, options.json);
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('repo-recover')
+        .description('Recover Repository Graph V2 from its last atomic backup or rebuild when unavailable')
+        .option('--json', 'Output stable machine-readable JSON')
+        .action(async (options) => {
+        const scope = getBrainScope();
+        try {
+            const result = await (0, brain_1.recoverRepositoryGraph)(scope.cwd);
+            printRepositoryGraphIndexResult(scope.cwd, result, options.json);
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('advisory <path>')
+        .description('Run local-only advisory semantic intelligence for a proposed or current file')
+        .option('--content-file <path>', 'Local proposed content file; raw content is parsed locally and not retained')
+        .option('--path-only', 'Run without proposed content and expose coverage limitations')
+        .option('--include-suppressed', 'Include findings suppressed by local feedback')
+        .option('--no-index', 'Do not create or refresh Repository Graph V2')
+        .option('--json', 'Output stable source-free JSON')
+        .action(async (path, options) => {
+        const scope = getBrainScope();
+        try {
+            let graph = (0, brain_1.readRepositoryGraph)(scope.cwd);
+            const status = await (0, brain_1.repositoryGraphStatus)(scope.cwd);
+            if (options.index !== false && (!graph || status.state !== 'fresh')) {
+                graph = (await (0, brain_1.indexRepositoryGraph)({ repoRoot: scope.cwd })).graph;
+            }
+            else if (graph) {
+                graph = { ...graph, freshness: status };
+            }
+            if (!graph)
+                throw new Error('Repository Graph V2 is missing. Run `neurcode brain repo-index`.');
+            const target = normalizeAdvisoryTarget(scope.cwd, path);
+            let proposedSource = null;
+            let sourceKind = 'not_available';
+            if (!options.pathOnly) {
+                const contentPath = options.contentFile
+                    ? ((0, path_1.isAbsolute)(options.contentFile) ? options.contentFile : (0, path_1.resolve)(scope.cwd, options.contentFile))
+                    : target.absolutePath;
+                if ((0, fs_1.existsSync)(contentPath)) {
+                    proposedSource = (0, fs_1.readFileSync)(contentPath, 'utf8');
+                    sourceKind = options.contentFile ? 'write_content' : 'post_write_disk_read';
+                }
+            }
+            const analysis = (0, proposed_change_analysis_1.analyzeProposedChange)({
+                repoRoot: scope.cwd,
+                filePath: target.relativePath,
+                proposedSource,
+                sourceKind,
+                adapterId: 'neurcode-cli',
+                timing: sourceKind === 'post_write_disk_read' ? 'after_write' : 'before_write',
+                sessionId: null,
+                planRevision: null,
+            });
+            analysis.envelope.target.operation = (0, fs_1.existsSync)(target.absolutePath) ? 'update' : 'create';
+            const result = await (0, brain_1.runSemanticAdvisory)({
+                repoRoot: scope.cwd,
+                graph,
+                change: analysis.envelope,
+            });
+            const findings = options.includeSuppressed
+                ? result.findings
+                : result.findings.filter((finding) => !finding.suppressed);
+            const payload = {
+                ok: true,
+                truth: 'advisory',
+                blocking: false,
+                cacheHit: result.cacheHit,
+                cacheKey: result.cacheKey,
+                graph: {
+                    graphId: graph.graphId,
+                    generation: graph.generation,
+                    freshness: graph.freshness,
+                },
+                host: analysis.envelope.host,
+                findings,
+                suppressedCount: result.findings.filter((finding) => finding.suppressed).length,
+                privacy: analysis.envelope.privacy,
+            };
+            if (options.json) {
+                console.log(JSON.stringify(payload, null, 2));
+                return;
+            }
+            console.log(chalk.bold('\n🧠 Advisory Semantic Intelligence V2\n'));
+            console.log(chalk.dim('Truth: advisory · Blocking: never'));
+            console.log(chalk.dim(`Graph: ${graph.graphId} generation ${graph.generation} (${graph.freshness.state})`));
+            console.log(chalk.dim(`Cache: ${result.cacheHit ? 'hit' : 'miss'}`));
+            if (findings.length === 0) {
+                console.log(chalk.dim('No unsuppressed advisory findings.'));
+                return;
+            }
+            findings.forEach((finding, index) => {
+                console.log(chalk.white(`  ${index + 1}. ${finding.category} · ${(finding.confidence * 100).toFixed(0)}%`));
+                console.log(chalk.dim(`     ${finding.rationaleCategories.join(', ')}`));
+                console.log(chalk.dim(`     ${finding.related.map((item) => item.path || item.symbol || item.hash).filter(Boolean).join(', ')}`));
+                console.log(chalk.dim(`     limitations: ${finding.limitations.join(' ')}`));
+                console.log(chalk.dim(`     id: ${finding.findingId}`));
+            });
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('advisory-suppress <key>')
+        .description('Suppress a finding ID, category:<name>, path:<path>, or fingerprint:<hash> locally')
+        .option('--remove', 'Remove the suppression instead')
+        .option('--json', 'Output stable source-free JSON')
+        .action((key, options) => {
+        const scope = getBrainScope();
+        try {
+            const registry = new brain_1.SemanticAdvisoryRegistry(scope.cwd);
+            const status = options.remove ? registry.unsuppress(key) : registry.suppress(key);
+            if (options.json)
+                console.log(JSON.stringify({ ok: true, status }, null, 2));
+            else
+                console.log(chalk.green(`\n✅ Advisory suppression ${options.remove ? 'removed' : 'saved'}: ${key}\n`));
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('advisory-feedback <finding-id>')
+        .description('Record source-free advisory feedback: accepted, dismissed, duplicate, or useful')
+        .requiredOption('--category <category>', 'Advisory category')
+        .requiredOption('--outcome <outcome>', 'accepted | dismissed | duplicate | useful')
+        .option('--json', 'Output stable source-free JSON')
+        .action((findingId, options) => {
+        const scope = getBrainScope();
+        try {
+            const outcomes = ['accepted', 'dismissed', 'duplicate', 'useful'];
+            if (!outcomes.includes(options.outcome)) {
+                throw new Error(`Unsupported advisory feedback outcome: ${options.outcome}`);
+            }
+            const registry = new brain_1.SemanticAdvisoryRegistry(scope.cwd);
+            const status = registry.recordFeedback({
+                findingId,
+                category: advisoryCategory(options.category),
+                outcome: options.outcome,
+            });
+            if (options.json)
+                console.log(JSON.stringify({ ok: true, status }, null, 2));
+            else
+                console.log(chalk.green(`\n✅ Advisory feedback recorded: ${options.outcome}\n`));
+        }
+        catch (error) {
+            repositoryGraphError(error, options.json);
+        }
+    });
+    brain
+        .command('advisory-status')
+        .description('Show local advisory cache, suppressions, feedback, and privacy mode')
+        .option('--json', 'Output stable source-free JSON')
+        .action((options) => {
+        const scope = getBrainScope();
+        const status = new brain_1.SemanticAdvisoryRegistry(scope.cwd).status();
+        if (options.json) {
+            console.log(JSON.stringify({ ok: true, status }, null, 2));
+            return;
+        }
+        console.log(chalk.bold('\n🧠 Advisory Semantic Intelligence Status\n'));
+        console.log(chalk.dim(`Registry:      ${status.path}`));
+        console.log(chalk.dim(`Cache entries: ${status.cacheEntries}`));
+        console.log(chalk.dim(`Suppressions:  ${status.suppressions.length}`));
+        console.log(chalk.dim(`Feedback IDs:  ${Object.keys(status.feedback).length}`));
+        console.log(chalk.dim('Privacy:       local-only; no source, diff, prompt, or chat upload.'));
+    });
     // -- brain inspect ----------------------------------------------------------
     brain
         .command('inspect [query...]')