@neurcode-ai/cli 0.9.10 → 0.9.12

package/dist/commands/ask.js

@@ -0,0 +1,778 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askCommand = askCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("../config");
+const project_root_1 = require("../utils/project-root");
+const state_1 = require("../utils/state");
+const neurcode_context_1 = require("../utils/neurcode-context");
+const plan_cache_1 = require("../utils/plan-cache");
+const brain_context_1 = require("../utils/brain-context");
+const ask_cache_1 = require("../utils/ask-cache");
+let chalk;
+try {
+    chalk = require('chalk');
+}
+catch {
+    chalk = {
+        green: (str) => str,
+        yellow: (str) => str,
+        red: (str) => str,
+        bold: (str) => str,
+        dim: (str) => str,
+        cyan: (str) => str,
+        white: (str) => str,
+    };
+}
+const MAX_SCAN_FILES = 320;
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_RAW_CITATIONS = 120;
+const PRIMARY_SOURCE_EXTENSIONS = new Set([
+    'ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs',
+    'py', 'go', 'rs', 'java', 'kt', 'swift', 'rb', 'php', 'cs',
+    'json', 'yaml', 'yml', 'toml', 'md', 'sql', 'graphql', 'gql',
+    'sh', 'bash', 'zsh', 'ps1', 'env', 'html', 'css', 'scss', 'less', 'prisma',
+]);
+const STOP_WORDS = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'what', 'where', 'when', 'which', 'into',
+    'from', 'your', 'about', 'there', 'their', 'them', 'have', 'does', 'is', 'are', 'was',
+    'were', 'any', 'all', 'read', 'tell', 'me', 'its', 'it', 'instead', 'than', 'then',
+    'workflow', 'codebase', 'repo', 'repository', 'used', 'use', 'mentioned', 'mention', 'whether',
+]);
+const LOW_SIGNAL_TERMS = new Set([
+    'used', 'use', 'using', 'mentioned', 'mention', 'where', 'tell', 'read', 'check', 'find', 'search',
+    'workflow', 'repo', 'repository', 'codebase', 'anywhere',
+]);
+function scanFiles(dir, maxFiles = MAX_SCAN_FILES) {
+    const files = [];
+    const ignoreDirs = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.turbo', '.cache', 'coverage']);
+    const ignoreExts = new Set(['map', 'log', 'lock', 'png', 'jpg', 'jpeg', 'gif', 'ico', 'svg', 'woff', 'woff2', 'ttf', 'eot', 'pdf']);
+    const walk = (current) => {
+        if (files.length >= maxFiles)
+            return;
+        let entries = [];
+        try {
+            entries = (0, fs_1.readdirSync)(current);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= maxFiles)
+                break;
+            if (entry.startsWith('.') && !entry.startsWith('.env')) {
+                if (ignoreDirs.has(entry))
+                    continue;
+            }
+            const fullPath = (0, path_1.join)(current, entry);
+            let st;
+            try {
+                st = (0, fs_1.statSync)(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                if (ignoreDirs.has(entry))
+                    continue;
+                walk(fullPath);
+                continue;
+            }
+            if (!st.isFile())
+                continue;
+            if (st.size > MAX_FILE_BYTES)
+                continue;
+            const ext = entry.includes('.') ? entry.split('.').pop()?.toLowerCase() || '' : '';
+            if (ext && ignoreExts.has(ext))
+                continue;
+            const rel = fullPath.slice(dir.length + 1).replace(/\\/g, '/');
+            files.push(rel);
+        }
+    };
+    walk(dir);
+    return files.slice(0, maxFiles);
+}
+function tokenizeQuestion(question) {
+    return (0, plan_cache_1.normalizeIntent)(question)
+        .split(/\s+/)
+        .filter((token) => token.length >= 3 && !STOP_WORDS.has(token));
+}
+function escapeRegExp(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function normalizeTerm(raw) {
+    return raw
+        .toLowerCase()
+        .replace(/['"`]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function extractQuotedTerms(question) {
+    const seen = new Set();
+    const terms = [];
+    const re = /["'`](.{2,80}?)["'`]/g;
+    for (const match of question.matchAll(re)) {
+        const term = normalizeTerm(match[1] || '');
+        if (!term || seen.has(term))
+            continue;
+        seen.add(term);
+        terms.push(term);
+    }
+    return terms;
+}
+function extractIdentityTerms(question) {
+    const normalized = (0, plan_cache_1.normalizeIntent)(question);
+    const matches = normalized.match(/(?:organization[\s_-]*id|org[\s_-]*id|orgid|organizationid|user[\s_-]*id|userid|userid)/g);
+    if (!matches)
+        return [];
+    const seen = new Set();
+    const ordered = [];
+    for (const raw of matches) {
+        const term = normalizeTerm(raw);
+        if (seen.has(term))
+            continue;
+        seen.add(term);
+        ordered.push(term);
+    }
+    return ordered;
+}
+function extractComparisonTerms(question) {
+    const quoted = extractQuotedTerms(question);
+    if (quoted.length >= 2)
+        return quoted.slice(0, 2);
+    const normalized = (0, plan_cache_1.normalizeIntent)(question);
+    const hasComparisonJoiner = normalized.includes('instead of') ||
+        normalized.includes(' versus ') ||
+        normalized.includes(' vs ') ||
+        normalized.includes(' compared to ');
+    if (!hasComparisonJoiner)
+        return [];
+    const identities = extractIdentityTerms(question);
+    if (identities.length >= 2)
+        return identities.slice(0, 2);
+    return [];
+}
+function buildTermMatchers(term, weight) {
+    const normalized = normalizeTerm(term);
+    if (!normalized)
+        return [];
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    const out = [];
+    const push = (label, regexSource) => {
+        out.push({
+            label,
+            regex: new RegExp(regexSource, 'i'),
+            weight,
+        });
+    };
+    if (tokens.length === 1) {
+        const token = escapeRegExp(tokens[0]);
+        push(normalized, `\\b${token}\\b`);
+        return out;
+    }
+    const tokenChain = tokens.map((t) => escapeRegExp(t)).join('[\\s_-]*');
+    push(normalized, `\\b${tokenChain}\\b`);
+    push(normalized, `\\b${escapeRegExp(tokens.join(''))}\\b`);
+    push(normalized, `\\b${escapeRegExp(tokens.join('_'))}\\b`);
+    push(normalized, `\\b${escapeRegExp(tokens.join('-'))}\\b`);
+    return out;
+}
+function buildMatchers(question) {
+    const comparisonTerms = extractComparisonTerms(question);
+    if (comparisonTerms.length >= 2) {
+        const matchers = [
+            ...buildTermMatchers(comparisonTerms[0], 1.0),
+            ...buildTermMatchers(comparisonTerms[1], 0.9),
+        ];
+        return {
+            mode: 'comparison',
+            terms: comparisonTerms.slice(0, 2),
+            matchers,
+        };
+    }
+    const quoted = extractQuotedTerms(question);
+    const keywords = tokenizeQuestion(question).slice(0, 8);
+    const quotedSet = new Set(quoted.map((term) => normalizeTerm(term)));
+    const terms = [...new Set([...quoted, ...keywords].map(normalizeTerm).filter(Boolean))]
+        .filter((term) => quotedSet.has(term) || !LOW_SIGNAL_TERMS.has(term));
+    const matchers = terms.flatMap((term) => buildTermMatchers(term, quoted.includes(term) ? 0.9 : 0.55));
+    return {
+        mode: 'search',
+        terms,
+        matchers,
+    };
+}
+function derivePathHints(question) {
+    const normalized = (0, plan_cache_1.normalizeIntent)(question);
+    const hints = [];
+    if (/\bcli|command|terminal\b/.test(normalized)) {
+        hints.push('packages/cli/src/commands/');
+        hints.push('packages/cli/src/');
+        hints.push('packages/cli/');
+    }
+    if (/\bapi|backend|server|route|middleware\b/.test(normalized)) {
+        hints.push('services/api/');
+    }
+    if (/\bdashboard|landing|docs|frontend|ui|pricing\b/.test(normalized)) {
+        hints.push('web/dashboard/');
+    }
+    if (/(github action|\bci\b)/.test(normalized)) {
+        hints.push('packages/action/');
+        hints.push('actions/');
+    }
+    return [...new Set(hints)];
+}
+function normalizeSnippet(line) {
+    return line
+        .replace(/\t/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 220);
+}
+function isPrimarySourcePath(filePath) {
+    const normalized = filePath.trim().replace(/\\/g, '/').toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized.startsWith('.neurcode/') ||
+        normalized.startsWith('.git/') ||
+        normalized.startsWith('node_modules/') ||
+        normalized.startsWith('dist/') ||
+        normalized.startsWith('build/') ||
+        normalized.startsWith('coverage/')) {
+        return false;
+    }
+    if (normalized.includes('/dist/') || normalized.includes('/build/') || normalized.includes('/coverage/')) {
+        return false;
+    }
+    const ext = normalized.includes('.') ? normalized.split('.').pop() || '' : '';
+    if (!ext) {
+        // Allow extensionless source-like files (e.g. Dockerfile, Makefile).
+        return true;
+    }
+    return PRIMARY_SOURCE_EXTENSIONS.has(ext);
+}
+function isBroadQuestion(normalizedQuestion) {
+    return (/\banywhere\b/.test(normalizedQuestion) ||
+        /\bacross\b/.test(normalizedQuestion) ||
+        /\bworkflow\b/.test(normalizedQuestion) ||
+        /\bentire\b/.test(normalizedQuestion) ||
+        /\bwhole\b/.test(normalizedQuestion) ||
+        /\ball\b/.test(normalizedQuestion) ||
+        /\bin repo\b/.test(normalizedQuestion));
+}
+function calibrateConfidence(truth) {
+    if (truth.status === 'insufficient')
+        return 'low';
+    if (truth.score >= 0.78)
+        return 'high';
+    if (truth.score >= 0.52)
+        return 'medium';
+    return 'low';
+}
+function evaluateTruthAssessment(mode, normalizedQuestion, terms, sourceCitations, sourcePerFileCounts, sourceTermCounts) {
+    const broadQuestion = isBroadQuestion(normalizedQuestion);
+    const minCitationsRequired = mode === 'comparison' ? 2 : 2;
+    let minFilesRequired = mode === 'comparison' ? 2 : 1;
+    if (broadQuestion) {
+        minFilesRequired = Math.max(minFilesRequired, 2);
+    }
+    const reasons = [];
+    const sourceCitationCount = sourceCitations.length;
+    const sourceFileCount = sourcePerFileCounts.size;
+    if (sourceCitationCount === 0) {
+        reasons.push('No direct source-file evidence was found for the query terms.');
+    }
+    if (sourceCitationCount < minCitationsRequired) {
+        reasons.push(`Only ${sourceCitationCount} source citation(s) found (minimum ${minCitationsRequired} required).`);
+    }
+    if (sourceFileCount < minFilesRequired) {
+        reasons.push(`Evidence spans ${sourceFileCount} file(s) (minimum ${minFilesRequired} required for this question).`);
+    }
+    if (mode === 'comparison' && terms.length >= 2) {
+        const missingTerms = terms.filter((term) => (sourceTermCounts.get(term) || 0) === 0);
+        if (missingTerms.length > 0) {
+            reasons.push(`Missing direct source evidence for term(s): ${missingTerms.join(', ')}.`);
+        }
+    }
+    if (mode === 'search') {
+        const highSignalTerms = terms.filter((term) => !LOW_SIGNAL_TERMS.has(term));
+        if (highSignalTerms.length > 0) {
+            const matchedHighSignalTerms = highSignalTerms.filter((term) => (sourceTermCounts.get(term) || 0) > 0);
+            if (matchedHighSignalTerms.length === 0) {
+                reasons.push('No high-signal query terms were grounded in source citations.');
+            }
+        }
+    }
+    let dominantShare = 0;
+    if (sourceCitationCount > 0) {
+        const highest = Math.max(...sourcePerFileCounts.values());
+        dominantShare = highest / sourceCitationCount;
+    }
+    if (broadQuestion && dominantShare > 0.85 && sourceFileCount < 3) {
+        reasons.push('Evidence is highly concentrated in one file; broader coverage is required for this query.');
+    }
+    const citationScore = Math.min(1, sourceCitationCount / Math.max(minCitationsRequired, 4));
+    const fileScore = Math.min(1, sourceFileCount / Math.max(minFilesRequired, 3));
+    let termCoverageScore = 0;
+    if (mode === 'comparison' && terms.length >= 2) {
+        termCoverageScore = terms.filter((term) => (sourceTermCounts.get(term) || 0) > 0).length / terms.length;
+    }
+    else if (mode === 'search') {
+        const highSignalTerms = terms.filter((term) => !LOW_SIGNAL_TERMS.has(term));
+        if (highSignalTerms.length === 0) {
+            termCoverageScore = sourceCitationCount > 0 ? 1 : 0;
+        }
+        else {
+            termCoverageScore = highSignalTerms.filter((term) => (sourceTermCounts.get(term) || 0) > 0).length / highSignalTerms.length;
+        }
+    }
+    const concentrationPenalty = dominantShare > 0.9 ? 0.08 : dominantShare > 0.75 ? 0.04 : 0;
+    let score = citationScore * 0.45 + fileScore * 0.35 + termCoverageScore * 0.2 - concentrationPenalty;
+    if (!Number.isFinite(score))
+        score = 0;
+    score = Math.max(0, Math.min(score, 1));
+    if (score < 0.42 && reasons.length === 0) {
+        reasons.push('Evidence quality score is below the confidence threshold.');
+    }
+    return {
+        status: reasons.length > 0 ? 'insufficient' : 'grounded',
+        score,
+        reasons,
+        sourceCitations: sourceCitationCount,
+        sourceFiles: sourceFileCount,
+        minCitationsRequired,
+        minFilesRequired,
+    };
+}
+function buildAnswer(mode, question, terms, citations, stats, termCounts, perFileCounts, truth) {
+    const confidence = calibrateConfidence(truth);
+    const normalizedQuestion = (0, plan_cache_1.normalizeIntent)(question);
+    const findings = [];
+    let answer = '';
+    if (truth.status === 'insufficient') {
+        answer = 'Insufficient grounded evidence to answer confidently from current source coverage.';
+        findings.push(...truth.reasons);
+        findings.push('Refine the query with specific file paths, modules, or identifiers for stronger grounding.');
+    }
+    else if (mode === 'comparison' && terms.length >= 2) {
+        const left = terms[0];
+        const right = terms[1];
+        const leftCount = termCounts.get(left) || 0;
+        const rightCount = termCounts.get(right) || 0;
+        if (leftCount > 0 && rightCount > 0) {
+            answer = `Found both "${left}" (${leftCount}) and "${right}" (${rightCount}) references in the scanned scope.`;
+        }
+        else if (leftCount > 0) {
+            answer = `Found "${left}" references (${leftCount}) and no direct "${right}" references in the scanned scope.`;
+        }
+        else if (rightCount > 0) {
+            answer = `No direct "${left}" references found; "${right}" appears ${rightCount} time(s) in the scanned scope.`;
+        }
+        else {
+            answer = `No direct references to "${left}" or "${right}" were found in the scanned scope.`;
+        }
+        findings.push(`Compared terms: "${left}" vs "${right}"`);
+        findings.push(`Matches by term: ${left}=${leftCount}, ${right}=${rightCount}`);
+    }
+    else {
+        if (citations.length > 0) {
+            answer = `Found ${citations.length} relevant evidence line(s) across ${stats.matchedFiles} file(s) for your question.`;
+        }
+        else {
+            answer = 'No direct evidence lines were found for this question in the scanned files.';
+        }
+    }
+    const topFiles = [...perFileCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3)
+        .map(([file, count]) => `${file} (${count})`);
+    if (topFiles.length > 0) {
+        findings.push(`Most relevant files: ${topFiles.join(', ')}`);
+    }
+    findings.push(`Scanned ${stats.scannedFiles} file(s); matched ${stats.matchedFiles} file(s).`);
+    return {
+        question,
+        questionNormalized: normalizedQuestion,
+        mode,
+        answer,
+        findings,
+        confidence,
+        truth: {
+            status: truth.status,
+            score: Number(truth.score.toFixed(2)),
+            reasons: truth.reasons,
+            sourceCitations: truth.sourceCitations,
+            sourceFiles: truth.sourceFiles,
+            minCitationsRequired: truth.minCitationsRequired,
+            minFilesRequired: truth.minFilesRequired,
+        },
+        citations,
+        generatedAt: new Date().toISOString(),
+        stats,
+    };
+}
+function emitAskResult(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify({
+            ...result,
+            citations: result.citations.slice(0, options.maxCitations),
+            cache: options.cacheLabel || 'miss',
+        }, null, 2));
+        return;
+    }
+    if (options.cacheLabel) {
+        console.log(chalk.dim(`⚡ ${options.cacheLabel}\n`));
+    }
+    if (!options.fromPlan) {
+        console.log(chalk.bold.cyan('🧠 Neurcode Ask\n'));
+    }
+    console.log(chalk.bold.white('Question:'));
+    console.log(chalk.dim(result.question));
+    console.log('');
+    console.log(chalk.bold.white('Answer:'));
+    if (result.truth.status === 'grounded') {
+        console.log(chalk.green(result.answer));
+    }
+    else {
+        console.log(chalk.yellow(result.answer));
+    }
+    if (result.findings.length > 0) {
+        console.log(chalk.bold.white('\nFindings:'));
+        for (const finding of result.findings) {
+            console.log(chalk.cyan(`  • ${finding}`));
+        }
+    }
+    const citations = result.citations.slice(0, options.maxCitations);
+    if (citations.length > 0) {
+        console.log(chalk.bold.white('\nEvidence:'));
+        citations.forEach((citation, idx) => {
+            const prefix = citation.term ? `${citation.term} ` : '';
+            console.log(chalk.dim(`  ${idx + 1}. ${citation.path}:${citation.line} ${prefix}${citation.snippet}`));
+        });
+    }
+    else {
+        console.log(chalk.yellow('\nEvidence: no direct matching lines found.'));
+    }
+    const truthLabel = result.truth.status === 'grounded' ? chalk.green('GROUNDED') : chalk.yellow('INSUFFICIENT');
+    console.log(chalk.dim(`\nTruth Mode: ${truthLabel} (score=${result.truth.score.toFixed(2)}, source_citations=${result.truth.sourceCitations}, source_files=${result.truth.sourceFiles})`));
+    console.log(chalk.dim(`Confidence: ${result.confidence.toUpperCase()} | scanned=${result.stats.scannedFiles} matched=${result.stats.matchedFiles}`));
+}
+async function askCommand(question, options = {}) {
+    try {
+        if (!question || !question.trim()) {
+            console.error(chalk.red('❌ Error: Question cannot be empty.'));
+            console.log(chalk.dim('Usage: neurcode ask "<question>"'));
+            process.exit(1);
+        }
+        const cwd = (0, project_root_1.resolveNeurcodeProjectRoot)(process.cwd());
+        const config = (0, config_1.loadConfig)();
+        const orgId = (0, state_1.getOrgId)();
+        const stateProjectId = (0, state_1.getProjectId)();
+        const projectId = options.projectId || stateProjectId || config.projectId || null;
+        const scope = { orgId: orgId || null, projectId: projectId || null };
+        const maxCitations = Math.max(3, Math.min(options.maxCitations || 12, 30));
+        const shouldUseCache = options.cache !== false && process.env.NEURCODE_ASK_NO_CACHE !== '1';
+        const normalizedQuestion = (0, plan_cache_1.normalizeIntent)(question);
+        if (process.stdout.isTTY && !process.env.CI) {
+            (0, neurcode_context_1.ensureDefaultLocalContextFile)(cwd);
+        }
+        const fileTree = scanFiles(cwd, MAX_SCAN_FILES);
+        if (fileTree.length === 0) {
+            console.error(chalk.red('❌ No files found in the current project.'));
+            process.exit(1);
+        }
+        const staticContext = (0, neurcode_context_1.loadStaticNeurcodeContext)(cwd, orgId && projectId ? { orgId, projectId } : undefined);
+        const policyVersionHash = (0, plan_cache_1.computePolicyVersionHash)(cwd);
+        const neurcodeVersion = (0, plan_cache_1.getNeurcodeVersion)();
+        const gitFingerprint = (0, plan_cache_1.getGitRepoFingerprint)(cwd);
+        const repoFingerprint = gitFingerprint || (0, plan_cache_1.getFilesystemFingerprintFromTree)(fileTree, cwd);
+        if (orgId && projectId) {
+            try {
+                (0, brain_context_1.refreshBrainContextFromWorkspace)(cwd, scope, {
+                    workingTreeHash: gitFingerprint?.kind === 'git' ? gitFingerprint.workingTreeHash : undefined,
+                    maxFiles: 90,
+                    recordEvent: false,
+                });
+            }
+            catch {
+                // non-blocking
+            }
+        }
+        if (shouldUseCache && orgId && projectId) {
+            const questionHash = (0, ask_cache_1.computeAskQuestionHash)({
+                question: normalizedQuestion,
+                contextHash: staticContext.hash,
+            });
+            const exactKey = (0, ask_cache_1.computeAskCacheKey)({
+                schemaVersion: 3,
+                orgId,
+                projectId,
+                repo: repoFingerprint,
+                questionHash,
+                policyVersionHash,
+                neurcodeVersion,
+            });
+            const exact = (0, ask_cache_1.readCachedAsk)(cwd, exactKey);
+            if (exact) {
+                const exactOutput = {
+                    ...exact.output,
+                    question,
+                    questionNormalized: normalizedQuestion,
+                };
+                emitAskResult(exactOutput, {
+                    json: options.json,
+                    maxCitations,
+                    cacheLabel: `Using cached answer (created: ${new Date(exact.createdAt).toLocaleString()})`,
+                    fromPlan: options.fromPlan,
+                });
+                (0, brain_context_1.recordBrainProgressEvent)(cwd, scope, {
+                    type: 'ask',
+                    note: 'cache_hit=exact',
+                });
+                return;
+            }
+            const near = (0, ask_cache_1.findNearCachedAsk)(cwd, {
+                orgId,
+                projectId,
+                repo: repoFingerprint,
+                question: normalizedQuestion,
+                policyVersionHash,
+                neurcodeVersion,
+                contextHash: staticContext.hash,
+                changedPaths: (0, ask_cache_1.getChangedWorkingTreePaths)(cwd),
+                minSimilarity: 0.68,
+            });
+            if (near) {
+                const nearOutput = {
+                    ...near.entry.output,
+                    question,
+                    questionNormalized: normalizedQuestion,
+                };
+                const reasonText = near.reason === 'safe_repo_drift_similar_question'
+                    ? 'Using near-cached answer (safe repo drift)'
+                    : 'Using near-cached answer';
+                emitAskResult(nearOutput, {
+                    json: options.json,
+                    maxCitations,
+                    cacheLabel: `${reasonText}, similarity ${near.similarity.toFixed(2)}, created: ${new Date(near.entry.createdAt).toLocaleString()}`,
+                    fromPlan: options.fromPlan,
+                });
+                (0, brain_context_1.recordBrainProgressEvent)(cwd, scope, {
+                    type: 'ask',
+                    note: `cache_hit=near;similarity=${near.similarity.toFixed(2)};reason=${near.reason}`,
+                });
+                return;
+            }
+        }
+        if (!options.json) {
+            console.log(chalk.dim(`🧠 Asking repo context in ${cwd}...`));
+        }
+        const brainResults = orgId && projectId
+            ? (0, brain_context_1.searchBrainContextEntries)(cwd, scope, normalizedQuestion, { limit: 48 })
+            : { entries: [], totalIndexedFiles: 0 };
+        if (!options.json && brainResults.entries.length > 0) {
+            const top = brainResults.entries.filter((entry) => entry.score > 0).length;
+            console.log(chalk.dim(`🧠 Brain retrieval: ${top} relevant file summaries from ${brainResults.totalIndexedFiles} indexed files`));
+        }
+        const { mode, terms, matchers } = buildMatchers(question);
+        const pathHints = derivePathHints(question);
+        const mentionsAskCommand = /\bask\b/.test(normalizedQuestion);
+        if (matchers.length === 0) {
+            console.error(chalk.red('❌ Could not derive useful search terms from the question.'));
+            process.exit(1);
+        }
+        const candidateSet = new Set();
+        const pathPriority = new Map();
+        for (const entry of brainResults.entries) {
+            candidateSet.add(entry.path);
+            pathPriority.set(entry.path, (pathPriority.get(entry.path) || 0) + entry.score);
+        }
+        const tokenHints = tokenizeQuestion(question);
+        if (candidateSet.size < 80) {
+            for (const filePath of fileTree) {
+                const normalizedPath = filePath.toLowerCase();
+                let score = pathPriority.get(filePath) || 0;
+                for (const token of tokenHints) {
+                    if (normalizedPath.includes(token))
+                        score += 0.2;
+                }
+                if (!mentionsAskCommand && (filePath.endsWith('/commands/ask.ts') || filePath.endsWith('/utils/ask-cache.ts'))) {
+                    score -= 0.45;
+                }
+                if (pathHints.some((hint) => normalizedPath.startsWith(hint))) {
+                    score += 0.45;
+                }
+                else if (pathHints.length > 0) {
+                    score -= 0.08;
+                }
+                if (score > 0) {
+                    candidateSet.add(filePath);
+                    pathPriority.set(filePath, score);
+                }
+            }
+        }
+        if (candidateSet.size < 20) {
+            for (const filePath of fileTree.slice(0, 160)) {
+                candidateSet.add(filePath);
+            }
+        }
+        const selfReferenceFiles = new Set([
+            'packages/cli/src/commands/ask.ts',
+            'packages/cli/src/utils/ask-cache.ts',
+        ]);
+        const prioritized = [...candidateSet]
+            .filter((filePath) => (0, fs_1.existsSync)((0, path_1.join)(cwd, filePath)))
+            .filter((filePath) => mentionsAskCommand || !selfReferenceFiles.has(filePath))
+            .sort((a, b) => (pathPriority.get(b) || 0) - (pathPriority.get(a) || 0));
+        const hinted = pathHints.length > 0
+            ? prioritized.filter((filePath) => pathHints.some((hint) => filePath.startsWith(hint)))
+            : [];
+        const nonHinted = pathHints.length > 0
+            ? prioritized.filter((filePath) => !pathHints.some((hint) => filePath.startsWith(hint)))
+            : prioritized;
+        const candidates = [...hinted, ...nonHinted].slice(0, MAX_SCAN_FILES);
+        const citations = [];
+        let scannedFiles = 0;
+        for (const filePath of candidates) {
+            if (citations.length >= MAX_RAW_CITATIONS)
+                break;
+            const fullPath = (0, path_1.join)(cwd, filePath);
+            let content = '';
+            try {
+                const st = (0, fs_1.statSync)(fullPath);
+                if (st.size > MAX_FILE_BYTES)
+                    continue;
+                content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            scannedFiles++;
+            const lines = content.split(/\r?\n/);
+            for (let idx = 0; idx < lines.length; idx++) {
+                if (citations.length >= MAX_RAW_CITATIONS)
+                    break;
+                const line = lines[idx];
+                if (!line || line.trim().length === 0)
+                    continue;
+                for (const matcher of matchers) {
+                    if (!matcher.regex.test(line))
+                        continue;
+                    const snippet = normalizeSnippet(line);
+                    if (!snippet)
+                        continue;
+                    const evidence = {
+                        path: filePath,
+                        line: idx + 1,
+                        snippet,
+                        term: matcher.label,
+                        weight: matcher.weight +
+                            (pathPriority.get(filePath) || 0) +
+                            (pathHints.some((hint) => filePath.startsWith(hint)) ? 0.25 : 0),
+                    };
+                    const dedupeKey = `${evidence.path}:${evidence.line}:${evidence.term || ''}`;
+                    if (citations.some((item) => `${item.path}:${item.line}:${item.term || ''}` === dedupeKey)) {
+                        continue;
+                    }
+                    citations.push(evidence);
+                    break;
+                }
+            }
+        }
+        citations.sort((a, b) => b.weight - a.weight);
+        const sourceEvidence = citations.filter((citation) => isPrimarySourcePath(citation.path));
+        const sourcePerFileCounts = new Map();
+        const sourceTermCounts = new Map();
+        for (const citation of sourceEvidence) {
+            sourcePerFileCounts.set(citation.path, (sourcePerFileCounts.get(citation.path) || 0) + 1);
+            if (citation.term) {
+                sourceTermCounts.set(citation.term, (sourceTermCounts.get(citation.term) || 0) + 1);
+            }
+        }
+        const selectedForOutput = [];
+        if (mode === 'comparison' && terms.length >= 2) {
+            for (const term of terms.slice(0, 2)) {
+                const firstForTerm = sourceEvidence.find((citation) => citation.term === term);
+                if (firstForTerm) {
+                    selectedForOutput.push(firstForTerm);
+                }
+            }
+        }
+        for (const citation of sourceEvidence) {
+            if (selectedForOutput.length >= maxCitations)
+                break;
+            if (selectedForOutput.some((existing) => existing.path === citation.path && existing.line === citation.line && existing.term === citation.term)) {
+                continue;
+            }
+            selectedForOutput.push(citation);
+        }
+        const finalCitations = selectedForOutput.map(({ path, line, snippet, term }) => ({
+            path,
+            line,
+            snippet,
+            term,
+        }));
+        const stats = {
+            scannedFiles,
+            matchedFiles: sourcePerFileCounts.size,
+            matchedLines: sourceEvidence.length,
+            brainCandidates: brainResults.entries.length,
+        };
+        const truth = evaluateTruthAssessment(mode, normalizedQuestion, terms, sourceEvidence, sourcePerFileCounts, sourceTermCounts);
+        const answer = buildAnswer(mode, question, terms, finalCitations, stats, sourceTermCounts, sourcePerFileCounts, truth);
+        emitAskResult(answer, {
+            json: options.json,
+            maxCitations,
+            fromPlan: options.fromPlan,
+        });
+        if (orgId && projectId) {
+            (0, brain_context_1.recordBrainProgressEvent)(cwd, scope, {
+                type: 'ask',
+                note: `mode=${mode};truth=${truth.status};score=${truth.score.toFixed(2)};matched_files=${stats.matchedFiles};matched_lines=${stats.matchedLines}`,
+            });
+        }
+        if (shouldUseCache && orgId && projectId) {
+            const questionHash = (0, ask_cache_1.computeAskQuestionHash)({
+                question: normalizedQuestion,
+                contextHash: staticContext.hash,
+            });
+            const key = (0, ask_cache_1.computeAskCacheKey)({
+                schemaVersion: 3,
+                orgId,
+                projectId,
+                repo: repoFingerprint,
+                questionHash,
+                policyVersionHash,
+                neurcodeVersion,
+            });
+            (0, ask_cache_1.writeCachedAsk)(cwd, {
+                key,
+                input: {
+                    schemaVersion: 3,
+                    orgId,
+                    projectId,
+                    repo: repoFingerprint,
+                    questionHash,
+                    policyVersionHash,
+                    neurcodeVersion,
+                    question: normalizedQuestion,
+                    contextHash: staticContext.hash,
+                },
+                output: answer,
+                evidencePaths: finalCitations.map((citation) => citation.path),
+            });
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('\n❌ Error answering question:'));
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        else {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=ask.js.map