@thoughtflow/core 0.1.2

package/dist/libs/incremental-analyzer.class.js

@@ -0,0 +1,798 @@
+"use strict";
+/**
+ * IncrementalAnalyzer — Range-aware incremental codebase analysis
+ *
+ * Two-phase architecture:
+ *   Phase 1 (collect): Walk files, analyze in line-ranges via LLM,
+ *     discover dependencies → queue them for analysis. All results
+ *     persisted immediately to JSON via AnalysisStore.
+ *   Phase 2 (prepare): Build KnowledgeGraph nodes/edges purely from
+ *     collected FileAnalysisRecords. No LLM needed.
+ *
+ * Key features:
+ *   - Content-hash based change detection (skip unchanged files on re-run)
+ *   - Dependency-driven queue: analyzing file A discovers import of B → B queued
+ *   - Range granularity: only re-analyze changed or unresolved ranges
+ *   - Crash-safe: every LLM result written to disk before next call
+ *   - Resume: --resume skips files/ranges with existing valid records
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalAnalyzer = exports.AnalysisStore = void 0;
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const decoder_registry_class_1 = require("./decoder-registry.class");
+// ─── AnalysisStore — JSON-file persistence ──────────────────────────────────
+/**
+ * Persists analysis state to a directory of JSON files.
+ *
+ * Layout:
+ *   {storeDir}/
+ *     session.json                  — AnalysisSessionMeta
+ *     queue.json                    — AnalysisQueueItem[]
+ *     files/
+ *       {sanitized-path}.json       — FileAnalysisRecord per file
+ */
+class AnalysisStore {
+    storeDir;
+    filesDir;
+    constructor(storeDir) {
+        this.storeDir = storeDir;
+        this.filesDir = path.join(storeDir, "files");
+        fs.mkdirSync(this.filesDir, { recursive: true });
+    }
+    // ── Helpers ──
+    sanitize(name) {
+        return name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 250);
+    }
+    write(filePath, data) {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    readJson(filePath) {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    // ── Session ──
+    saveSession(meta) {
+        this.write(path.join(this.storeDir, "session.json"), meta);
+    }
+    loadSession() {
+        return this.readJson(path.join(this.storeDir, "session.json"));
+    }
+    // ── File Records ──
+    saveFileRecord(record) {
+        this.write(path.join(this.filesDir, `${this.sanitize(record.filePath)}.json`), record);
+    }
+    loadFileRecord(filePath) {
+        return this.readJson(path.join(this.filesDir, `${this.sanitize(filePath)}.json`));
+    }
+    listFileRecords() {
+        if (!fs.existsSync(this.filesDir))
+            return [];
+        return fs.readdirSync(this.filesDir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => this.readJson(path.join(this.filesDir, f)))
+            .filter((r) => r !== null);
+    }
+    // ── Queue ──
+    saveQueue(items) {
+        this.write(path.join(this.storeDir, "queue.json"), items);
+    }
+    loadQueue() {
+        return this.readJson(path.join(this.storeDir, "queue.json")) ?? [];
+    }
+    /** Full path to the store directory. */
+    getStoreDir() {
+        return this.storeDir;
+    }
+}
+exports.AnalysisStore = AnalysisStore;
+const DEFAULT_SKIP_DIRS = new Set([
+    "node_modules", ".git", "vendor", "dist", "build", ".next", ".nuxt",
+    "__pycache__", "coverage", "target", ".cache", ".venv", "venv",
+    ".idea", ".vscode", "tmp", "log", "logs", ".yarn", ".pnpm-store",
+]);
+const DEFAULT_CODE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".php", ".py", ".pyw", ".rb", ".rake", ".go",
+    ".java", ".kt", ".kts", ".scala", ".cs", ".fs",
+    ".rs", ".cpp", ".cc", ".c", ".h", ".hpp",
+    ".swift", ".ex", ".exs", ".elm", ".clj",
+    ".lua", ".r", ".jl", ".sh",
+]);
+class IncrementalAnalyzer {
+    config;
+    store;
+    skipDirs;
+    codeExtensions;
+    decoderRegistry;
+    queue = [];
+    session;
+    constructor(config) {
+        this.config = {
+            ...config,
+            maxFiles: config.maxFiles ?? 0,
+            maxQueueDepth: config.maxQueueDepth ?? 500,
+            maxFileSize: config.maxFileSize ?? 500_000,
+        };
+        this.store = new AnalysisStore(config.storeDir);
+        this.skipDirs = new Set([
+            ...DEFAULT_SKIP_DIRS,
+            ...(config.skipDirs ?? []),
+        ]);
+        this.codeExtensions = config.includeExtensions
+            ? new Set(config.includeExtensions.map((e) => e.startsWith(".") ? e : `.${e}`))
+            : DEFAULT_CODE_EXTENSIONS;
+        // Initialize decoder registry if enabled
+        if (config.enableDecoder !== false) {
+            this.decoderRegistry = new decoder_registry_class_1.DecoderRegistry({
+                projectRoot: config.projectRoot,
+                tsconfigPath: config.tsconfigPath,
+            });
+        }
+        else {
+            this.decoderRegistry = null;
+        }
+        // Load or create session
+        const existing = this.store.loadSession();
+        if (existing && existing.projectRoot === config.projectRoot) {
+            this.session = existing;
+            this.queue = this.store.loadQueue();
+        }
+        else {
+            this.session = {
+                sessionId: (0, crypto_1.randomUUID)(),
+                projectRoot: config.projectRoot,
+                projectName: config.projectName ?? path.basename(config.projectRoot),
+                model: config.model ?? "unknown",
+                numCtx: config.numCtx ?? 0,
+                startedAt: new Date().toISOString(),
+                phase: "collect",
+                stats: this.emptyStats(),
+            };
+        }
+    }
+    // ── Phase 1: Collect ──────────────────────────────────────────────────
+    /**
+     * Run the collection phase: discover files, analyze ranges, follow deps.
+     * Resumable — checks existing records before calling LLM.
+     */
+    async collect(callbacks) {
+        this.session.phase = "collect";
+        const startMs = Date.now();
+        // Step 1: Scan filesystem → enqueue new/changed files
+        const discovered = this.discoverFiles();
+        this.enqueueDiscoveredFiles(discovered);
+        // Step 2: Process queue until empty or limit reached
+        await this.processQueue(callbacks);
+        // Step 3: Resolve pending dependencies → enqueue new targets
+        this.resolveAndEnqueueDependencies();
+        // Step 4: Second pass — process newly enqueued dependency targets
+        await this.processQueue(callbacks);
+        // Update session
+        this.session.stats = this.computeStats();
+        this.session.stats.totalDurationMs += Date.now() - startMs;
+        this.store.saveSession(this.session);
+        return this.session.stats;
+    }
+    /**
+     * Get collected analysis records for Phase 2.
+     */
+    getCollectedRecords() {
+        return this.store.listFileRecords();
+    }
+    /**
+     * Get analysis record for a specific file.
+     */
+    getFileRecord(filePath) {
+        return this.store.loadFileRecord(filePath);
+    }
+    /**
+     * Get session metadata.
+     */
+    getSession() {
+        return { ...this.session };
+    }
+    /**
+     * Get the queue (for debugging/monitoring).
+     */
+    getQueue() {
+        return [...this.queue];
+    }
+    /**
+     * Get the store instance.
+     */
+    getStore() {
+        return this.store;
+    }
+    // ── File Discovery ────────────────────────────────────────────────────
+    discoverFiles() {
+        const files = [];
+        const limit = this.config.maxFiles || Infinity;
+        const walk = (dir, depth) => {
+            if (depth > 8 || files.length >= limit)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (files.length >= limit)
+                    break;
+                if (entry.name.startsWith(".") && entry.isDirectory())
+                    continue;
+                if (this.skipDirs.has(entry.name.toLowerCase()))
+                    continue;
+                const abs = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(abs, depth + 1);
+                }
+                else {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (!this.codeExtensions.has(ext))
+                        continue;
+                    try {
+                        const stat = fs.statSync(abs);
+                        if (stat.size > this.config.maxFileSize)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    files.push(path.relative(this.config.projectRoot, abs));
+                }
+            }
+        };
+        walk(this.config.projectRoot, 0);
+        return files;
+    }
+    enqueueDiscoveredFiles(files) {
+        for (const filePath of files) {
+            const existing = this.store.loadFileRecord(filePath);
+            if (existing) {
+                // Check if file changed
+                const currentHash = this.hashFile(filePath);
+                if (currentHash === existing.contentHash && existing.status === "complete") {
+                    continue; // Skip unchanged completed files
+                }
+                if (currentHash !== existing.contentHash) {
+                    // File changed — mark stale, re-queue
+                    existing.status = "stale";
+                    this.store.saveFileRecord(existing);
+                    this.addToQueue(filePath, null, "re_analysis", "high");
+                    continue;
+                }
+                // Partial — re-queue to continue
+                if (existing.status === "partial") {
+                    this.addToQueue(filePath, null, "re_analysis", "normal");
+                    continue;
+                }
+            }
+            else {
+                // New file
+                this.addToQueue(filePath, null, "initial_scan", "normal");
+            }
+        }
+        this.store.saveQueue(this.queue);
+    }
+    // ── Queue Management ──────────────────────────────────────────────────
+    addToQueue(filePath, targetRange, reason, priority, triggeredBy) {
+        // Skip duplicates
+        const isDuplicate = this.queue.some((item) => item.filePath === filePath &&
+            item.status === "queued" &&
+            this.rangesEqual(item.targetRange, targetRange));
+        if (isDuplicate)
+            return;
+        if (this.queue.length >= this.config.maxQueueDepth)
+            return;
+        this.queue.push({
+            id: (0, crypto_1.randomUUID)(),
+            filePath,
+            targetRange,
+            reason,
+            priority,
+            triggeredBy,
+            status: "queued",
+            createdAt: new Date().toISOString(),
+            retryCount: 0,
+        });
+    }
+    nextQueueItem() {
+        const priorityOrder = ["critical", "high", "normal", "low"];
+        for (const p of priorityOrder) {
+            const item = this.queue.find((i) => i.status === "queued" && i.priority === p);
+            if (item)
+                return item;
+        }
+        return null;
+    }
+    rangesEqual(a, b) {
+        if (a === null && b === null)
+            return true;
+        if (a === null || b === null)
+            return false;
+        return a.startLine === b.startLine && a.endLine === b.endLine;
+    }
+    // ── Queue Processing ──────────────────────────────────────────────────
+    async processQueue(callbacks) {
+        let item;
+        while ((item = this.nextQueueItem()) !== null) {
+            if (callbacks.signal?.aborted)
+                break;
+            item.status = "in_progress";
+            item.startedAt = new Date().toISOString();
+            try {
+                await this.analyzeFile(item, callbacks);
+                item.status = "completed";
+                item.completedAt = new Date().toISOString();
+                this.session.stats.llmCalls++;
+            }
+            catch (err) {
+                item.status = "failed";
+                item.error = err instanceof Error ? err.message : String(err);
+                item.completedAt = new Date().toISOString();
+            }
+            this.store.saveQueue(this.queue);
+            callbacks.onProgress?.(`${item.status}: ${item.filePath}${item.targetRange ? ` L${item.targetRange.startLine}-${item.targetRange.endLine}` : ""}`, this.computeStats());
+        }
+    }
+    async analyzeFile(item, callbacks) {
+        const absPath = path.join(this.config.projectRoot, item.filePath);
+        if (!fs.existsSync(absPath))
+            return;
+        const content = fs.readFileSync(absPath, "utf-8");
+        const lines = content.split("\n");
+        const contentHash = (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+        const stat = fs.statSync(absPath);
+        // Load existing record or create new
+        let record = this.store.loadFileRecord(item.filePath) ?? this.newRecord(item.filePath, contentHash, stat, lines.length);
+        // If content changed, reset ranges
+        if (record.contentHash !== contentHash) {
+            record.contentHash = contentHash;
+            record.mtime = stat.mtimeMs;
+            record.sizeBytes = stat.size;
+            record.totalLines = lines.length;
+            record.ranges = [];
+            record.analyzedLines = 0;
+            record.status = "pending";
+        }
+        // Determine what to analyze
+        const targetRange = item.targetRange;
+        // Check if this range is already analyzed
+        if (targetRange && this.isRangeCovered(record, targetRange)) {
+            this.session.stats.cacheHits++;
+            record.status = this.computeFileStatus(record);
+            this.store.saveFileRecord(record);
+            return;
+        }
+        // Run structural decoder (if available) — deterministic, no LLM needed
+        let structuralSummary;
+        if (this.decoderRegistry && !record.structuralSnapshot) {
+            const snapshot = this.decoderRegistry.decode(item.filePath, content);
+            if (snapshot) {
+                record.structuralSnapshot = snapshot;
+                structuralSummary = this.formatStructuralSummary(snapshot);
+            }
+        }
+        else if (record.structuralSnapshot) {
+            structuralSummary = this.formatStructuralSummary(record.structuralSnapshot);
+        }
+        // ── Structural fast-path: skip LLM when decoder found symbols ────────────
+        if (this.config.structuralFastPath &&
+            record.structuralSnapshot &&
+            record.structuralSnapshot.symbols.length > 0) {
+            const fastResults = this.synthesizeFromStructural(record.structuralSnapshot, targetRange ?? null);
+            for (const result of fastResults) {
+                const analyzedRange = {
+                    startLine: result.range.startLine,
+                    endLine: result.range.endLine,
+                    purpose: result.purpose,
+                    symbols: result.symbols,
+                    description: result.description,
+                    dependencies: result.dependencies.map((d) => ({ ...d, resolved: false })),
+                    analyzedAt: new Date().toISOString(),
+                    confidence: result.confidence,
+                };
+                record.ranges = this.mergeRange(record.ranges, analyzedRange);
+            }
+            record.analyzedLines = this.countAnalyzedLines(record.ranges, record.totalLines);
+            record.status = this.computeFileStatus(record, fastResults.length === 0);
+            record.lastAnalyzedAt = new Date().toISOString();
+            this.store.saveFileRecord(record);
+            callbacks.onProgress?.(`completed (structural): ${item.filePath}`, this.computeStats());
+            return;
+        }
+        // ─────────────────────────────────────────────────────────────────────────
+        // Build context for the LLM
+        const context = {
+            knownConcepts: this.getKnownConcepts(),
+            analyzedRangesInFile: record.ranges,
+            knownImporters: this.getKnownImporters(item.filePath),
+            language: path.extname(item.filePath).replace(".", "") || "txt",
+            structuralSummary,
+        };
+        // Extract content for the target range
+        const rangeContent = targetRange
+            ? lines.slice(targetRange.startLine - 1, targetRange.endLine).join("\n")
+            : content;
+        // Call LLM
+        const results = await callbacks.analyzeRange(item.filePath, rangeContent, targetRange, context);
+        // Merge results into record
+        for (const result of results) {
+            const analyzedRange = {
+                startLine: result.range.startLine,
+                endLine: result.range.endLine,
+                purpose: result.purpose,
+                symbols: result.symbols,
+                description: result.description,
+                dependencies: result.dependencies.map((d) => ({
+                    ...d,
+                    resolved: false,
+                })),
+                analyzedAt: new Date().toISOString(),
+                confidence: result.confidence,
+            };
+            // Replace overlapping ranges or add new
+            record.ranges = this.mergeRange(record.ranges, analyzedRange);
+        }
+        // Recalculate coverage
+        record.analyzedLines = this.countAnalyzedLines(record.ranges, record.totalLines);
+        record.status = this.computeFileStatus(record, results.length === 0);
+        record.lastAnalyzedAt = new Date().toISOString();
+        // Persist immediately
+        this.store.saveFileRecord(record);
+        // Enqueue discovered dependencies
+        for (const result of results) {
+            for (const dep of result.dependencies) {
+                if (!dep.targetFile)
+                    continue;
+                // Only enqueue if target exists
+                const targetAbs = path.join(this.config.projectRoot, dep.targetFile);
+                if (fs.existsSync(targetAbs)) {
+                    this.addToQueue(dep.targetFile, dep.targetRange ?? null, "dependency", "normal", { filePath: item.filePath, range: result.range, symbol: dep.symbol });
+                }
+            }
+        }
+    }
+    // ── Dependency Resolution ─────────────────────────────────────────────
+    resolveAndEnqueueDependencies() {
+        const records = this.store.listFileRecords();
+        for (const record of records) {
+            for (const range of record.ranges) {
+                for (const dep of range.dependencies) {
+                    if (dep.resolved)
+                        continue;
+                    const targetRecord = this.store.loadFileRecord(dep.targetFile);
+                    if (!targetRecord) {
+                        // Target not analyzed yet → queue it
+                        this.addToQueue(dep.targetFile, dep.targetRange ?? null, "dependency", "normal", {
+                            filePath: record.filePath,
+                            range: { startLine: range.startLine, endLine: range.endLine },
+                            symbol: dep.symbol,
+                        });
+                        continue;
+                    }
+                    // Check if the specific range is covered
+                    if (dep.targetRange) {
+                        if (this.isRangeCovered(targetRecord, dep.targetRange)) {
+                            dep.resolved = true;
+                        }
+                        else {
+                            this.addToQueue(dep.targetFile, dep.targetRange, "dependency", "normal", {
+                                filePath: record.filePath,
+                                range: { startLine: range.startLine, endLine: range.endLine },
+                                symbol: dep.symbol,
+                            });
+                        }
+                    }
+                    else if (targetRecord.status === "complete") {
+                        dep.resolved = true;
+                    }
+                }
+            }
+            // Persist updated dependency resolution status
+            this.store.saveFileRecord(record);
+        }
+        this.store.saveQueue(this.queue);
+    }
+    // ── Range Utilities ───────────────────────────────────────────────────
+    isRangeCovered(record, range) {
+        return record.ranges.some((r) => r.startLine <= range.startLine && r.endLine >= range.endLine);
+    }
+    /**
+     * Merge a new range into existing ranges, replacing any it fully overlaps.
+     * Adjacent/overlapping ranges are merged into one.
+     */
+    mergeRange(existing, newRange) {
+        const nonOverlapping = existing.filter((r) => r.endLine < newRange.startLine - 1 || r.startLine > newRange.endLine + 1);
+        // Ranges that overlap or are adjacent → absorb their deps/symbols
+        const overlapping = existing.filter((r) => !(r.endLine < newRange.startLine - 1 || r.startLine > newRange.endLine + 1));
+        if (overlapping.length > 0) {
+            const allRanges = [newRange, ...overlapping];
+            newRange = {
+                ...newRange,
+                startLine: Math.min(...allRanges.map((r) => r.startLine)),
+                endLine: Math.max(...allRanges.map((r) => r.endLine)),
+                symbols: [...new Set([...newRange.symbols, ...overlapping.flatMap((r) => r.symbols)])],
+                dependencies: this.mergeDependencies(newRange.dependencies, overlapping.flatMap((r) => r.dependencies)),
+            };
+        }
+        return [...nonOverlapping, newRange].sort((a, b) => a.startLine - b.startLine);
+    }
+    mergeDependencies(a, b) {
+        const seen = new Set();
+        const result = [];
+        for (const dep of [...a, ...b]) {
+            const key = `${dep.targetFile}:${dep.symbol ?? ""}:${dep.reason}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            result.push(dep);
+        }
+        return result;
+    }
+    countAnalyzedLines(ranges, totalLines) {
+        if (ranges.length === 0)
+            return 0;
+        // Union of ranges
+        const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine);
+        let covered = 0;
+        let currentEnd = 0;
+        for (const r of sorted) {
+            const start = Math.max(r.startLine, currentEnd + 1);
+            if (start <= r.endLine) {
+                covered += r.endLine - start + 1;
+                currentEnd = Math.max(currentEnd, r.endLine);
+            }
+        }
+        return Math.min(covered, totalLines);
+    }
+    computeFileStatus(record, llmReturnedEmpty = false) {
+        if (record.ranges.length === 0) {
+            // LLM analyzed the file but extracted no meaningful ranges
+            // (e.g. config files, data dumps, language packs). Mark as complete
+            // so the counter advances and the completion gate doesn't block.
+            return llmReturnedEmpty ? "complete" : "pending";
+        }
+        const coverage = record.analyzedLines / Math.max(record.totalLines, 1);
+        // Consider >80% coverage as complete (imports, blank lines, etc. may not be worth ranges)
+        if (coverage >= 0.8)
+            return "complete";
+        return "partial";
+    }
+    // ── Structural Summary ────────────────────────────────────────────────
+    /**
+     * Format a StructuralSnapshot as a compact text summary for LLM context.
+     * This replaces the need for LLM to parse imports/class structure/signatures.
+     */
+    formatStructuralSummary(snapshot) {
+        const parts = [];
+        parts.push(`Language: ${snapshot.language}`);
+        if (snapshot.imports.length > 0) {
+            const importList = snapshot.imports
+                .map((i) => {
+                const names = i.names?.join(", ") ?? "*";
+                return `  ${names} from "${i.source}"${i.isTypeOnly ? " (type)" : ""}`;
+            })
+                .join("\n");
+            parts.push(`Imports:\n${importList}`);
+        }
+        if (snapshot.symbols.length > 0) {
+            const symbolList = snapshot.symbols.map((s) => this.formatSymbolBrief(s, 0)).join("\n");
+            parts.push(`Symbols:\n${symbolList}`);
+        }
+        if (snapshot.exports.length > 0) {
+            const exportList = snapshot.exports
+                .map((e) => `  ${e.name ?? "*"} (${e.kind})${e.source ? ` from "${e.source}"` : ""}`)
+                .join("\n");
+            parts.push(`Exports:\n${exportList}`);
+        }
+        return parts.join("\n\n");
+    }
+    formatSymbolBrief(sym, depth) {
+        const indent = "  ".repeat(depth + 1);
+        let line = `${indent}${sym.kind} ${sym.name}`;
+        if (sym.extends)
+            line += ` extends ${sym.extends}`;
+        if (sym.implements?.length)
+            line += ` implements ${sym.implements.join(", ")}`;
+        if (sym.parameters) {
+            const params = sym.parameters.map((p) => `${p.name}${p.type ? `: ${p.type}` : ""}`).join(", ");
+            line += `(${params})`;
+        }
+        if (sym.returnType)
+            line += `: ${sym.returnType}`;
+        if (sym.typeAnnotation)
+            line += `: ${sym.typeAnnotation}`;
+        if (sym.isAbstract)
+            line += " [abstract]";
+        if (sym.isAsync)
+            line += " [async]";
+        if (sym.decorators?.length)
+            line += ` @${sym.decorators.join(", @")}`;
+        line += ` L${sym.startLine}-${sym.endLine}`;
+        if (sym.exported)
+            line += " [exported]";
+        if (sym.members?.length) {
+            const memberLines = sym.members.map((m) => this.formatSymbolBrief(m, depth + 1));
+            line += "\n" + memberLines.join("\n");
+        }
+        return line;
+    }
+    // ── Context Helpers ───────────────────────────────────────────────────
+    getKnownConcepts() {
+        // Collect all symbols across analyzed files
+        const records = this.store.listFileRecords();
+        const concepts = [];
+        for (const record of records) {
+            for (const range of record.ranges) {
+                if (range.purpose === "business_concept" || range.purpose === "domain_entity") {
+                    concepts.push(...range.symbols);
+                }
+            }
+        }
+        return [...new Set(concepts)].slice(0, 50);
+    }
+    getKnownImporters(filePath) {
+        const records = this.store.listFileRecords();
+        const importers = [];
+        for (const record of records) {
+            for (const range of record.ranges) {
+                for (const dep of range.dependencies) {
+                    if (dep.targetFile === filePath && dep.symbol) {
+                        importers.push(dep.symbol);
+                    }
+                }
+            }
+        }
+        return [...new Set(importers)].slice(0, 20);
+    }
+    // ── Record Helpers ────────────────────────────────────────────────────
+    newRecord(filePath, contentHash, stat, totalLines) {
+        return {
+            filePath,
+            contentHash,
+            mtime: stat.mtimeMs,
+            sizeBytes: stat.size,
+            ranges: [],
+            status: "pending",
+            lastAnalyzedAt: new Date().toISOString(),
+            totalLines,
+            analyzedLines: 0,
+        };
+    }
+    hashFile(filePath) {
+        const abs = path.join(this.config.projectRoot, filePath);
+        const content = fs.readFileSync(abs, "utf-8");
+        return (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+    }
+    emptyStats() {
+        return {
+            totalFiles: 0,
+            analyzedFiles: 0,
+            pendingFiles: 0,
+            staleFiles: 0,
+            totalRanges: 0,
+            totalDependencies: 0,
+            unresolvedDependencies: 0,
+            llmCalls: 0,
+            cacheHits: 0,
+            totalDurationMs: 0,
+        };
+    }
+    computeStats() {
+        const records = this.store.listFileRecords();
+        const stats = { ...this.session.stats };
+        stats.totalFiles = records.length;
+        stats.analyzedFiles = records.filter((r) => r.status === "complete").length;
+        stats.pendingFiles = records.filter((r) => r.status === "pending").length;
+        stats.staleFiles = records.filter((r) => r.status === "stale").length;
+        stats.totalRanges = records.reduce((sum, r) => sum + r.ranges.length, 0);
+        let totalDeps = 0;
+        let unresolved = 0;
+        for (const r of records) {
+            for (const range of r.ranges) {
+                totalDeps += range.dependencies.length;
+                unresolved += range.dependencies.filter((d) => !d.resolved).length;
+            }
+        }
+        stats.totalDependencies = totalDeps;
+        stats.unresolvedDependencies = unresolved;
+        return stats;
+    }
+    // ── Structural Fast-Path ─────────────────────────────────────────────
+    /**
+     * Convert a StructuralSnapshot into RangeAnalysisResult[] without calling LLM.
+     * Each top-level symbol becomes one range. Imports become dependencies.
+     * Descriptions are left empty — no semantic content, pure structure.
+     *
+     * Used when `structuralFastPath` is enabled and the decoder provided symbols.
+     */
+    synthesizeFromStructural(snapshot, targetRange) {
+        const results = [];
+        const totalLines = snapshot.totalLines;
+        // Build dependencies from imports
+        const deps = snapshot.imports
+            .filter((imp) => !imp.source.startsWith("node:") && !imp.source.match(/^[a-zA-Z@][^./]/))
+            .map((imp) => ({
+            targetFile: imp.source.replace(/^\.\//, "").replace(/^\.\.\//, "../"),
+            reason: "import",
+            symbol: imp.names?.[0] ?? undefined,
+        }));
+        const symbols = snapshot.symbols.filter((sym) => {
+            if (!targetRange)
+                return true;
+            return sym.startLine <= targetRange.endLine && sym.endLine >= targetRange.startLine;
+        });
+        if (symbols.length === 0) {
+            // No symbols in range — emit a single generic range for the whole target
+            const rangeStart = targetRange?.startLine ?? 1;
+            const rangeEnd = targetRange?.endLine ?? totalLines;
+            results.push({
+                range: { startLine: rangeStart, endLine: rangeEnd },
+                purpose: snapshot.resourceKind ?? "module",
+                symbols: [],
+                description: "",
+                dependencies: rangeStart === 1 ? deps : [],
+                confidence: 0.5,
+            });
+            return results;
+        }
+        for (const sym of symbols) {
+            const memberNames = (sym.members ?? []).map((m) => m.name);
+            const allSymbols = [sym.name, ...memberNames];
+            results.push({
+                range: {
+                    startLine: Math.max(1, sym.startLine),
+                    endLine: Math.min(totalLines, sym.endLine),
+                },
+                purpose: sym.kind,
+                symbols: allSymbols,
+                description: "",
+                // attach imports as deps only to the first/top symbol in the file
+                dependencies: sym.startLine === symbols[0].startLine ? deps : [],
+                confidence: 0.85,
+            });
+        }
+        return results;
+    }
+}
+exports.IncrementalAnalyzer = IncrementalAnalyzer;
+//# sourceMappingURL=incremental-analyzer.class.js.map