@neurcode-ai/cli 0.9.8 → 0.9.10

package/dist/commands/plan.js

@@ -45,6 +45,7 @@ const ROILogger_1 = require("../utils/ROILogger");
 const toolbox_service_1 = require("../services/toolbox-service");
 const plan_cache_1 = require("../utils/plan-cache");
 const neurcode_context_1 = require("../utils/neurcode-context");
+const brain_context_1 = require("../utils/brain-context");
 const project_root_1 = require("../utils/project-root");
 // Import chalk with fallback for plain strings if not available
 let chalk;
@@ -217,6 +218,99 @@ async function ensureAssetMap(cwd) {
     }
     return map;
 }
+function detectIntentMode(intent) {
+    const normalized = (0, plan_cache_1.normalizeIntent)(intent);
+    if (!normalized)
+        return 'implementation';
+    const implementationSignals = [
+        /\b(add|create|implement|build|fix|refactor|update|change|write|generate|migrate|remove|delete|ship)\b/,
+    ];
+    for (const pattern of implementationSignals) {
+        if (pattern.test(normalized)) {
+            return 'implementation';
+        }
+    }
+    const analysisSignals = [
+        /\b(read|review|inspect|analyze|audit|check|find|search|locate|compare|list|tell me|where|whether|is there)\b/,
+        /\?$/,
+    ];
+    for (const pattern of analysisSignals) {
+        if (pattern.test(normalized)) {
+            return 'analysis';
+        }
+    }
+    return 'implementation';
+}
+function applyReadOnlyDirective(intentText) {
+    return [
+        intentText,
+        '',
+        'NEURCODE_EXECUTION_MODE: READ_ONLY_ANALYSIS',
+        '- The user asked for analysis only, not code implementation.',
+        '- Do not propose code writes or file creation.',
+        '- Prefer a compact investigation plan with target files and concrete checks.',
+        '- Treat suggested files as inspection targets.',
+    ].join('\n');
+}
+function renderCacheMissReason(reason, bestIntentSimilarity) {
+    const reasonText = {
+        no_scope_entries: 'no cached plans exist yet for this org/project scope',
+        repo_identity_changed: 'repo identity changed for this scope',
+        repo_snapshot_changed: 'repo snapshot changed (HEAD tree differs)',
+        policy_changed: 'policy fingerprint changed',
+        neurcode_version_changed: 'neurcode version changed',
+        prompt_changed: 'prompt/context changed',
+    };
+    if (reason === 'prompt_changed' && bestIntentSimilarity > 0) {
+        return `${reasonText[reason]} (closest intent similarity ${bestIntentSimilarity.toFixed(2)})`;
+    }
+    return reasonText[reason];
+}
+function emitCachedPlanHit(input) {
+    if (input.touchKey) {
+        try {
+            (0, plan_cache_1.readCachedPlan)(input.cwd, input.touchKey);
+        }
+        catch {
+            // Ignore cache touch failures.
+        }
+    }
+    const createdAtLabel = new Date(input.createdAt).toLocaleString();
+    if (input.mode === 'near' && typeof input.similarity === 'number') {
+        console.log(chalk.dim(`⚡ Using near-cached plan (similarity ${input.similarity.toFixed(2)}, created: ${createdAtLabel})\n`));
+    }
+    else {
+        console.log(chalk.dim(`⚡ Using cached plan (created: ${createdAtLabel})\n`));
+    }
+    displayPlan(input.response.plan);
+    console.log(chalk.dim(`\nGenerated at: ${new Date(input.response.timestamp).toLocaleString()} (cached)`));
+    if (input.response.planId && input.response.planId !== 'unknown') {
+        console.log(chalk.bold.cyan(`\n📌 Plan ID: ${input.response.planId} (Cached)`));
+        console.log(chalk.dim('   Run \'neurcode prompt\' to generate a Cursor/AI prompt.'));
+    }
+    try {
+        if (input.response.planId && input.response.planId !== 'unknown') {
+            (0, state_1.setActivePlanId)(input.response.planId);
+            (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
+        }
+        if (input.response.sessionId) {
+            (0, state_1.setSessionId)(input.response.sessionId);
+        }
+        (0, brain_context_1.recordBrainProgressEvent)(input.cwd, {
+            orgId: input.orgId,
+            projectId: input.projectId,
+        }, {
+            type: 'plan',
+            planId: input.response.planId || undefined,
+            note: input.mode === 'near'
+                ? `cache_hit=near;similarity=${typeof input.similarity === 'number' ? input.similarity.toFixed(2) : 'n/a'}`
+                : 'cache_hit=exact',
+        });
+    }
+    catch {
+        // ignore state write errors
+    }
+}
 async function planCommand(intent, options) {
     try {
         if (!intent || !intent.trim()) {
@@ -243,6 +337,17 @@ async function planCommand(intent, options) {
         const stateProjectId = (0, state_1.getProjectId)();
         const finalProjectIdEarly = options.projectId || stateProjectId || config.projectId;
         const shouldUseCache = options.cache !== false && process.env.NEURCODE_PLAN_NO_CACHE !== '1';
+        const normalizedIntent = (0, plan_cache_1.normalizeIntent)(intent);
+        const intentMode = detectIntentMode(intent);
+        const isReadOnlyAnalysis = intentMode === 'analysis';
+        const policyVersionHash = (0, plan_cache_1.computePolicyVersionHash)(cwd);
+        const neurcodeVersion = (0, plan_cache_1.getNeurcodeVersion)();
+        // Create a local, gitignored context file scaffold (similar to CLAUDE.md workflows),
+        // so teams/users have a predictable place to add project-specific guidance.
+        // This runs only on interactive terminals to avoid polluting CI checkouts.
+        if (process.stdout.isTTY && !process.env.CI) {
+            (0, neurcode_context_1.ensureDefaultLocalContextFile)(cwd);
+        }
         const staticContextEarly = (0, neurcode_context_1.loadStaticNeurcodeContext)(cwd, orgId && finalProjectIdEarly ? { orgId, projectId: finalProjectIdEarly } : undefined);
         const ticketRef = options.issue
             ? `github_issue:${options.issue}`
@@ -251,48 +356,66 @@ async function planCommand(intent, options) {
                 : options.ticket
                     ? `ticket:${options.ticket}`
                     : undefined;
+        const promptHashEarly = (0, plan_cache_1.computePromptHash)({
+            intent: normalizedIntent,
+            ticketRef,
+            contextHash: staticContextEarly.hash,
+        });
         const gitFingerprint = (0, plan_cache_1.getGitRepoFingerprint)(cwd);
         if (shouldUseCache && orgId && finalProjectIdEarly && gitFingerprint) {
             const key = (0, plan_cache_1.computePlanCacheKey)({
-                schemaVersion: 1,
-                apiUrl: (config.apiUrl || '').replace(/\/$/, ''),
+                schemaVersion: 2,
                 orgId,
                 projectId: finalProjectIdEarly,
-                intent: (0, plan_cache_1.normalizeIntent)(intent),
-                ticketRef,
-                contextHash: staticContextEarly.hash,
                 repo: gitFingerprint,
+                promptHash: promptHashEarly,
+                policyVersionHash,
+                neurcodeVersion,
             });
             const cached = (0, plan_cache_1.readCachedPlan)(cwd, key);
             if (cached) {
-                console.log(chalk.dim(`⚡ Using cached plan (created: ${new Date(cached.createdAt).toLocaleString()})\n`));
-                displayPlan(cached.response.plan);
-                console.log(chalk.dim(`\nGenerated at: ${new Date(cached.response.timestamp).toLocaleString()} (cached)`));
-                if (cached.response.planId && cached.response.planId !== 'unknown') {
-                    console.log(chalk.bold.cyan(`\n📌 Plan ID: ${cached.response.planId} (Cached)`));
-                    console.log(chalk.dim('   Run \'neurcode prompt\' to generate a Cursor/AI prompt.'));
-                }
-                // Maintain the same state side-effects as a fresh plan.
-                try {
-                    if (cached.response.planId && cached.response.planId !== 'unknown') {
-                        (0, state_1.setActivePlanId)(cached.response.planId);
-                        (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
-                    }
-                    if (cached.response.sessionId) {
-                        (0, state_1.setSessionId)(cached.response.sessionId);
-                    }
-                }
-                catch {
-                    // ignore state write errors
-                }
+                emitCachedPlanHit({
+                    cwd,
+                    response: cached.response,
+                    createdAt: cached.createdAt,
+                    mode: 'exact',
+                    orgId,
+                    projectId: finalProjectIdEarly,
+                });
                 return;
             }
-        }
-        // Create a local, gitignored context file scaffold (similar to CLAUDE.md workflows),
-        // so teams/users have a predictable place to add project-specific guidance.
-        // This runs only on interactive terminals to avoid polluting CI checkouts.
-        if (process.stdout.isTTY && !process.env.CI) {
-            (0, neurcode_context_1.ensureDefaultLocalContextFile)(cwd);
+            const near = (0, plan_cache_1.findNearCachedPlan)(cwd, {
+                orgId,
+                projectId: finalProjectIdEarly,
+                repo: gitFingerprint,
+                intent: normalizedIntent,
+                policyVersionHash,
+                neurcodeVersion,
+                ticketRef,
+                contextHash: staticContextEarly.hash,
+            });
+            if (near) {
+                emitCachedPlanHit({
+                    cwd,
+                    response: near.entry.response,
+                    createdAt: near.entry.createdAt,
+                    mode: 'near',
+                    similarity: near.intentSimilarity,
+                    orgId,
+                    projectId: finalProjectIdEarly,
+                    touchKey: near.entry.key,
+                });
+                return;
+            }
+            const miss = (0, plan_cache_1.diagnosePlanCacheMiss)(cwd, {
+                orgId,
+                projectId: finalProjectIdEarly,
+                repo: gitFingerprint,
+                intent: normalizedIntent,
+                policyVersionHash,
+                neurcodeVersion,
+            });
+            console.log(chalk.dim(`🧠 Cache miss: ${renderCacheMissReason(miss.reason, miss.bestIntentSimilarity)}`));
         }
         // Initialize Security Guard, Ticket Service, and Project Knowledge Service
         const { SecurityGuard } = await Promise.resolve().then(() => __importStar(require('../services/security/SecurityGuard')));
@@ -408,6 +531,10 @@ async function planCommand(intent, options) {
             await initCommand();
             return;
         }
+        const brainScope = {
+            orgId: orgId || null,
+            projectId: finalProjectIdForGuard || null,
+        };
         // Step B: Scan file tree (paths only, no content)
         console.log(chalk.dim(`📂 Scanning file tree in ${cwd}...`));
         const fileTree = scanFiles(cwd, cwd, 200);
@@ -420,43 +547,84 @@ async function planCommand(intent, options) {
         // - influence plan generation
         // - participate in the cache key (avoid stale cached plans after context edits)
         const staticContext = (0, neurcode_context_1.loadStaticNeurcodeContext)(cwd, orgId && finalProjectIdForGuard ? { orgId, projectId: finalProjectIdForGuard } : undefined);
+        // Incremental Brain refresh: keep context in sync with human progress even when watch is not running.
+        if (orgId && finalProjectIdForGuard) {
+            try {
+                const refresh = (0, brain_context_1.refreshBrainContextFromWorkspace)(cwd, brainScope, {
+                    workingTreeHash: gitFingerprint?.kind === 'git' ? gitFingerprint.workingTreeHash : undefined,
+                    maxFiles: 80,
+                    recordEvent: false,
+                });
+                if (refresh.refreshed && (refresh.indexed > 0 || refresh.removed > 0)) {
+                    console.log(chalk.dim(`🧠 Brain refresh: indexed ${refresh.indexed}, removed ${refresh.removed}, considered ${refresh.considered}`));
+                }
+            }
+            catch {
+                // Brain refresh should never block plan generation.
+            }
+        }
         // If we couldn't use the git-based fast path (non-git projects), try a filesystem-based cache hit
         // after we have the file tree fingerprint.
         if (shouldUseCache && orgId && finalProjectIdForGuard && !gitFingerprint) {
-            const fsFingerprint = (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree);
+            const fsFingerprint = (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree, cwd);
+            const promptHash = (0, plan_cache_1.computePromptHash)({
+                intent: normalizedIntent,
+                ticketRef,
+                contextHash: staticContext.hash,
+            });
             const key = (0, plan_cache_1.computePlanCacheKey)({
-                schemaVersion: 1,
-                apiUrl: (config.apiUrl || '').replace(/\/$/, ''),
+                schemaVersion: 2,
                 orgId,
                 projectId: finalProjectIdForGuard,
-                intent: (0, plan_cache_1.normalizeIntent)(intent),
-                ticketRef,
-                contextHash: staticContext.hash,
                 repo: fsFingerprint,
+                promptHash,
+                policyVersionHash,
+                neurcodeVersion,
             });
             const cached = (0, plan_cache_1.readCachedPlan)(cwd, key);
             if (cached) {
-                console.log(chalk.dim(`⚡ Using cached plan (created: ${new Date(cached.createdAt).toLocaleString()})\n`));
-                displayPlan(cached.response.plan);
-                console.log(chalk.dim(`\nGenerated at: ${new Date(cached.response.timestamp).toLocaleString()} (cached)`));
-                if (cached.response.planId && cached.response.planId !== 'unknown') {
-                    console.log(chalk.bold.cyan(`\n📌 Plan ID: ${cached.response.planId} (Cached)`));
-                    console.log(chalk.dim('   Run \'neurcode prompt\' to generate a Cursor/AI prompt.'));
-                }
-                try {
-                    if (cached.response.planId && cached.response.planId !== 'unknown') {
-                        (0, state_1.setActivePlanId)(cached.response.planId);
-                        (0, state_1.setLastPlanGeneratedAt)(new Date().toISOString());
-                    }
-                    if (cached.response.sessionId) {
-                        (0, state_1.setSessionId)(cached.response.sessionId);
-                    }
-                }
-                catch {
-                    // ignore
-                }
+                emitCachedPlanHit({
+                    cwd,
+                    response: cached.response,
+                    createdAt: cached.createdAt,
+                    mode: 'exact',
+                    orgId,
+                    projectId: finalProjectIdForGuard,
+                });
+                return;
+            }
+            const near = (0, plan_cache_1.findNearCachedPlan)(cwd, {
+                orgId,
+                projectId: finalProjectIdForGuard,
+                repo: fsFingerprint,
+                intent: normalizedIntent,
+                policyVersionHash,
+                neurcodeVersion,
+                ticketRef,
+                contextHash: staticContext.hash,
+            });
+            if (near) {
+                emitCachedPlanHit({
+                    cwd,
+                    response: near.entry.response,
+                    createdAt: near.entry.createdAt,
+                    mode: 'near',
+                    similarity: near.intentSimilarity,
+                    orgId,
+                    projectId: finalProjectIdForGuard,
+                    touchKey: near.entry.key,
+                });
                 return;
             }
+            const miss = (0, plan_cache_1.diagnosePlanCacheMiss)(cwd, {
+                orgId,
+                projectId: finalProjectIdForGuard,
+                repo: fsFingerprint,
+                intent: normalizedIntent,
+                policyVersionHash,
+                neurcodeVersion,
+            });
+            console.log(chalk.dim(`🧠 Cache miss: ${renderCacheMissReason(miss.reason, miss.bestIntentSimilarity)}`));
         }
         // Step 2: Build enhanced intent with static context + org/project memory (before any LLM call)
         let enhancedIntent = enrichedIntent;
@@ -469,6 +637,27 @@ async function planCommand(intent, options) {
                 enhancedIntent = `${enhancedIntent}\n\n${memoryTail}`;
             }
         }
+        if (isReadOnlyAnalysis) {
+            console.log(chalk.dim('🔎 Read-only analysis mode enabled (no-code intent detected)'));
+            enhancedIntent = applyReadOnlyDirective(enhancedIntent);
+        }
+        // Retrieval augmentation: include a repo-grounded live context pack (file summaries + recent progress events).
+        if (orgId && finalProjectIdForGuard) {
+            try {
+                const pack = (0, brain_context_1.buildBrainContextPack)(cwd, brainScope, normalizedIntent, {
+                    maxFiles: 8,
+                    maxEvents: 6,
+                    maxBytes: 10 * 1024,
+                });
+                if (pack.text) {
+                    enhancedIntent = `${enhancedIntent}\n\n${pack.text}`;
+                    console.log(chalk.dim(`🧠 Brain context: ${pack.selectedFiles} relevant file summary(s), ${pack.recentEvents} recent event(s) from ${pack.totalIndexedFiles} indexed file(s)`));
+                }
+            }
+            catch {
+                // Brain context pack should never block plan generation.
+            }
+        }
         // Step 3: Load or create asset map for context injection (toolbox summary)
         try {
             const map = await ensureAssetMap(cwd);
@@ -490,7 +679,14 @@ async function planCommand(intent, options) {
         }
         // Retrieval augmentation: include summaries from similar cached plans (org+project scoped)
         if (shouldUseCache && orgId && finalProjectIdForGuard) {
-            const similar = (0, plan_cache_1.findSimilarCachedPlans)(cwd, { orgId, projectId: finalProjectIdForGuard }, (0, plan_cache_1.normalizeIntent)(intent), 3);
+            const repoIdentityForSimilarity = gitFingerprint
+                ? gitFingerprint.repoIdentity
+                : (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree, cwd).repoIdentity;
+            const similar = (0, plan_cache_1.findSimilarCachedPlans)(cwd, {
+                orgId,
+                projectId: finalProjectIdForGuard,
+                repoIdentity: repoIdentityForSimilarity,
+            }, normalizedIntent, 3);
             if (similar.length > 0) {
                 const memoryLines = [];
                 memoryLines.push('PROJECT MEMORY (recent Neurcode plans in this repo; use only if relevant):');
@@ -557,7 +753,7 @@ async function planCommand(intent, options) {
         }
         // Check for active sessions before creating a new one
         const finalProjectId = options.projectId || projectId || config.projectId;
-        if (finalProjectId && process.stdout.isTTY && !process.env.CI) {
+        if (finalProjectId && process.stdout.isTTY && !process.env.CI && !isReadOnlyAnalysis) {
             try {
                 const sessions = await client.getSessions(finalProjectId, 10);
                 const activeSessions = sessions.filter(s => s.status === 'active');
@@ -652,41 +848,64 @@ async function planCommand(intent, options) {
             }
         }
         // Ensure we have at least some files
-        const filesToUse = validFiles.length > 0 ? validFiles : fileTree.slice(0, 10);
+        let filesToUse = validFiles.length > 0 ? validFiles : fileTree.slice(0, 10);
         if (validFiles.length < selectedFiles.length) {
             console.log(chalk.yellow(`⚠️  ${selectedFiles.length - validFiles.length} selected file(s) could not be read, using ${filesToUse.length} valid file(s)`));
         }
+        if (isReadOnlyAnalysis && filesToUse.length > 8) {
+            filesToUse = filesToUse.slice(0, 8);
+            console.log(chalk.dim(`🔎 Analysis mode: narrowed to ${filesToUse.length} top file(s)`));
+        }
         // Step E: Pass 2 - The Architect (generate plan with selected files)
         console.log(chalk.dim('🤖 Generating plan with selected files...\n'));
         const response = await client.generatePlan(enhancedIntent, filesToUse, finalProjectId, ticketMetadata, projectSummary);
+        if (orgId && finalProjectIdForGuard) {
+            try {
+                const refreshed = (0, brain_context_1.refreshBrainContextForFiles)(cwd, brainScope, filesToUse);
+                (0, brain_context_1.recordBrainProgressEvent)(cwd, brainScope, {
+                    type: 'plan',
+                    planId: response.planId || undefined,
+                    note: `selected=${filesToUse.length};indexed=${refreshed.indexed};removed=${refreshed.removed};complexity=${response.plan.estimatedComplexity || 'unknown'}`,
+                });
+            }
+            catch {
+                // Brain progression tracking should never block plan generation.
+            }
+        }
         // Persist in local cache for instant repeat plans.
         if (shouldUseCache && orgId && finalProjectIdForGuard) {
             // Recompute repo fingerprint right before writing to cache so Neurcode-managed
             // housekeeping (e.g. `.neurcode/config.json`, `.gitignore` updates) doesn't
             // cause immediate cache misses on the next identical run.
             const finalGitFingerprint = (0, plan_cache_1.getGitRepoFingerprint)(cwd);
-            const repo = finalGitFingerprint || (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree);
+            const repo = finalGitFingerprint || (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree, cwd);
+            const promptHash = (0, plan_cache_1.computePromptHash)({
+                intent: normalizedIntent,
+                ticketRef,
+                contextHash: staticContext.hash,
+            });
             const key = (0, plan_cache_1.computePlanCacheKey)({
-                schemaVersion: 1,
-                apiUrl: (config.apiUrl || '').replace(/\/$/, ''),
+                schemaVersion: 2,
                 orgId,
                 projectId: finalProjectIdForGuard,
-                intent: (0, plan_cache_1.normalizeIntent)(intent),
-                ticketRef,
-                contextHash: staticContext.hash,
                 repo,
+                promptHash,
+                policyVersionHash,
+                neurcodeVersion,
             });
             (0, plan_cache_1.writeCachedPlan)(cwd, {
                 key,
                 input: {
-                    schemaVersion: 1,
-                    apiUrl: (config.apiUrl || '').replace(/\/$/, ''),
+                    schemaVersion: 2,
                     orgId,
                     projectId: finalProjectIdForGuard,
-                    intent: (0, plan_cache_1.normalizeIntent)(intent),
+                    repo,
+                    promptHash,
+                    policyVersionHash,
+                    neurcodeVersion,
+                    intent: normalizedIntent,
                     ticketRef,
                     contextHash: staticContext.hash,
-                    repo,
                 },
                 response,
             });
@@ -698,7 +917,10 @@ async function planCommand(intent, options) {
         // Pre-Flight Snapshot: Capture current state of files that will be MODIFIED
         // This ensures we have a baseline to revert to if AI destroys files
         const modifyFiles = response.plan.files.filter(f => f.action === 'MODIFY');
-        if (modifyFiles.length > 0) {
+        if (isReadOnlyAnalysis) {
+            console.log(chalk.dim('\n🔎 Analysis mode: skipping pre-flight file snapshots'));
+        }
+        else if (modifyFiles.length > 0) {
             console.log(chalk.dim(`\n📸 Capturing pre-flight snapshots for ${modifyFiles.length} file(s)...`));
             let snapshotsSaved = 0;
             let snapshotsFailed = 0;
@@ -746,11 +968,16 @@ async function planCommand(intent, options) {
         // Step 3: Post-Generation Hallucination Check (DEEP SCAN)
         // Scan ALL plan content for phantom packages - not just summaries, but full proposed code
         let hasHallucinations = false;
+        let skippedHallucinationScan = false;
         const allHallucinations = [];
         // Check tier for hallucination scanning (PRO feature)
         const { getUserTier } = await Promise.resolve().then(() => __importStar(require('../utils/tier')));
         const tier = await getUserTier();
-        if (tier === 'FREE') {
+        if (isReadOnlyAnalysis) {
+            skippedHallucinationScan = true;
+            console.log(chalk.dim('🔎 Analysis mode: skipping hallucination package scan'));
+        }
+        else if (tier === 'FREE') {
             console.log(chalk.yellow('\n🛡️  Hallucination Shield is a PRO feature.'));
             console.log(chalk.dim('   Upgrade at: https://www.neurcode.com/dashboard/purchase-plan\n'));
         }
@@ -863,9 +1090,18 @@ async function planCommand(intent, options) {
             console.log('');
         }
         else {
-            console.log(chalk.green('✅ No hallucinations detected'));
+            if (skippedHallucinationScan) {
+                console.log(chalk.dim('🔎 Hallucination scan skipped (read-only analysis mode)'));
+            }
+            else {
+                console.log(chalk.green('✅ No hallucinations detected'));
+            }
         }
         // Display the plan (AFTER hallucination warnings)
+        if (isReadOnlyAnalysis) {
+            const writableTargets = response.plan.files.filter((file) => file.action !== 'BLOCK').length;
+            console.log(chalk.dim(`🔎 Read-only query guidance: treat listed files as inspection targets (${writableTargets} target(s)).`));
+        }
         displayPlan(response.plan);
         console.log(chalk.dim(`\nGenerated at: ${new Date(response.timestamp).toLocaleString()}`));
         // Display plan ID if available