@neurcode-ai/cli 0.9.9 → 0.9.11

package/dist/commands/ask.d.ts

@@ -0,0 +1,10 @@
+interface AskOptions {
+    projectId?: string;
+    json?: boolean;
+    cache?: boolean;
+    maxCitations?: number;
+    fromPlan?: boolean;
+}
+export declare function askCommand(question: string, options?: AskOptions): Promise<void>;
+export {};
+//# sourceMappingURL=ask.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../src/commands/ask.ts"],"names":[],"mappings":"AA+CA,UAAU,UAAU;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAkVD,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAoV1F"}

package/dist/commands/ask.js

@@ -0,0 +1,631 @@
+"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 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',
+]);
+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 terms = [...new Set([...quoted, ...keywords].map(normalizeTerm).filter(Boolean))];
+    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 scoreConfidence(citationCount, matchedFiles) {
+    if (citationCount === 0)
+        return 'low';
+    if (citationCount >= 8 && matchedFiles >= 3)
+        return 'high';
+    return 'medium';
+}
+function buildAnswer(mode, question, terms, citations, stats, termCounts, perFileCounts) {
+    const confidence = scoreConfidence(citations.length, stats.matchedFiles);
+    const normalizedQuestion = (0, plan_cache_1.normalizeIntent)(question);
+    const findings = [];
+    let answer = '';
+    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,
+        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:'));
+    console.log(chalk.green(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.'));
+    }
+    console.log(chalk.dim(`\nConfidence: ${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: 2,
+                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 = [];
+        const perFileCounts = new Map();
+        const termCounts = new Map();
+        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);
+                    perFileCounts.set(filePath, (perFileCounts.get(filePath) || 0) + 1);
+                    termCounts.set(matcher.label, (termCounts.get(matcher.label) || 0) + 1);
+                    break;
+                }
+            }
+        }
+        citations.sort((a, b) => b.weight - a.weight);
+        const selectedForOutput = [];
+        if (mode === 'comparison' && terms.length >= 2) {
+            for (const term of terms.slice(0, 2)) {
+                const firstForTerm = citations.find((citation) => citation.term === term);
+                if (firstForTerm) {
+                    selectedForOutput.push(firstForTerm);
+                }
+            }
+        }
+        for (const citation of citations) {
+            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: perFileCounts.size,
+            matchedLines: citations.length,
+            brainCandidates: brainResults.entries.length,
+        };
+        const answer = buildAnswer(mode, question, terms, finalCitations, stats, termCounts, perFileCounts);
+        emitAskResult(answer, {
+            json: options.json,
+            maxCitations,
+            fromPlan: options.fromPlan,
+        });
+        if (orgId && projectId) {
+            (0, brain_context_1.recordBrainProgressEvent)(cwd, scope, {
+                type: 'ask',
+                note: `mode=${mode};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: 2,
+                orgId,
+                projectId,
+                repo: repoFingerprint,
+                questionHash,
+                policyVersionHash,
+                neurcodeVersion,
+            });
+            (0, ask_cache_1.writeCachedAsk)(cwd, {
+                key,
+                input: {
+                    schemaVersion: 2,
+                    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