@thoughtflow/core 0.1.2

package/dist/libs/code-analysis-pipeline.class.js

@@ -0,0 +1,946 @@
+"use strict";
+/**
+ * CodeAnalysisPipeline — Chains code analysis stages.
+ *
+ * Stages:
+ *   1. structural-decode  → StructuralSnapshot[] (deterministic, no LLM)
+ *   2. incremental-analyze → FileAnalysisRecord[] + ranges (LLM-based)
+ *   3. knowledge-graph-build → unified graph (from both stages)
+ *   4. graph-render → Mermaid diagram
+ *
+ * Each stage persists output to `{storeBaseDir}/{stageId}/`.
+ * Pipeline is resumable — skips stages with valid cached output.
+ */
+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.CodeAnalysisPipeline = exports.CodePipelineStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const decoder_registry_class_1 = require("./decoder-registry.class");
+const incremental_analyzer_class_1 = require("./incremental-analyzer.class");
+// ── Structural synthesis helper ─────────────────────────────────────────────
+/**
+ * Convert a StructuralSnapshot into RangeAnalysisResult[] without an LLM call.
+ * Each top-level symbol becomes one range; imports become dependencies.
+ * Used by the structural fast-path in runIncrementalAnalyze().
+ */
+function synthesizeRangesFromSnapshot(snapshot, targetRange) {
+    const totalLines = snapshot.totalLines;
+    // External packages start with a letter/@ but have no "./" prefix — skip them.
+    const deps = snapshot.imports
+        .filter((imp) => imp.source.startsWith(".") || imp.source.startsWith("/"))
+        .map((imp) => ({
+        targetFile: imp.source,
+        reason: "import",
+        symbol: imp.names?.[0] ?? undefined,
+    }));
+    // Determine the range we're responsible for (chunk or whole file).
+    const rangeStart = targetRange?.startLine ?? 1;
+    const rangeEnd = targetRange?.endLine ?? totalLines;
+    // Collect symbols that overlap this range.
+    const symbols = snapshot.symbols.filter((sym) => {
+        if (!targetRange)
+            return true;
+        return sym.startLine <= targetRange.endLine && sym.endLine >= targetRange.startLine;
+    });
+    if (symbols.length === 0) {
+        // No structural symbols: produce a single catch-all range for the chunk.
+        return [
+            {
+                range: { startLine: rangeStart, endLine: rangeEnd },
+                purpose: snapshot.resourceKind ?? "module",
+                symbols: [],
+                description: "",
+                dependencies: deps,
+                confidence: 0.5,
+            },
+        ];
+    }
+    // Produce ONE range that covers the entire chunk with all symbols aggregated.
+    // This ensures analyzedLines == totalLines (≥80% coverage → "complete" status).
+    const allSymbolNames = symbols.flatMap((sym) => [sym.name, ...(sym.members ?? []).map((m) => m.name)]);
+    return [
+        {
+            range: { startLine: rangeStart, endLine: rangeEnd },
+            purpose: symbols[0]?.kind ?? snapshot.resourceKind ?? "module",
+            symbols: allSymbolNames,
+            description: "",
+            dependencies: deps,
+            confidence: 0.85,
+        },
+    ];
+}
+// ── Pipeline Store ──────────────────────────────────────────────────────────
+class CodePipelineStore {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        fs.mkdirSync(baseDir, { recursive: true });
+    }
+    stageDir(stageId) {
+        const dir = path.join(this.baseDir, stageId);
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    saveStageResult(stageId, data) {
+        const filePath = path.join(this.stageDir(stageId), "result.json");
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    loadStageResult(stageId) {
+        const filePath = path.join(this.stageDir(stageId), "result.json");
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    hasStageResult(stageId) {
+        return fs.existsSync(path.join(this.stageDir(stageId), "result.json"));
+    }
+    saveFile(stageId, fileName, content) {
+        fs.writeFileSync(path.join(this.stageDir(stageId), fileName), content);
+    }
+    getBaseDir() {
+        return this.baseDir;
+    }
+}
+exports.CodePipelineStore = CodePipelineStore;
+// ── Pipeline Runner ─────────────────────────────────────────────────────────
+class CodeAnalysisPipeline {
+    config;
+    store;
+    runId;
+    registry;
+    constructor(config, registry) {
+        this.config = config;
+        this.store = new CodePipelineStore(config.storeBaseDir);
+        this.registry = registry;
+    }
+    getStore() {
+        return this.store;
+    }
+    /** Create a new run record in the registry and return it. */
+    createRun() {
+        if (!this.registry) {
+            throw new Error("No PipelineRunRegistry configured. Pass one to the constructor.");
+        }
+        const run = this.registry.create({
+            projectName: this.config.projectName,
+            projectRoot: this.config.projectRoot,
+            storeBaseDir: this.config.storeBaseDir,
+            model: this.config.model,
+        });
+        this.runId = run.uuid;
+        return run;
+    }
+    /** Returns the UUID of the current run, or undefined if none started. */
+    getCurrentRunId() {
+        return this.runId;
+    }
+    // ── Registry Helpers (all guarded — only called when registry+runId set) ─
+    phaseStart(stageId) {
+        if (!this.registry || !this.runId)
+            return;
+        this.registry.updatePhase(this.runId, stageId, {
+            status: "running",
+            startedAt: new Date().toISOString(),
+            progress: 0,
+        });
+        this.emitPhaseProgress(stageId, "running", 0, "Started");
+    }
+    phaseProgress(stageId, progress, message, details) {
+        if (!this.registry || !this.runId)
+            return;
+        this.registry.updatePhase(this.runId, stageId, { progress });
+        this.emitPhaseProgress(stageId, "running", progress, message, details);
+    }
+    phaseComplete(stageId, details) {
+        if (!this.registry || !this.runId)
+            return;
+        this.registry.updatePhase(this.runId, stageId, {
+            status: "complete",
+            completedAt: new Date().toISOString(),
+            progress: 1,
+            details,
+        });
+        this.emitPhaseProgress(stageId, "complete", 1, "Complete", details);
+    }
+    phaseFail(stageId, error) {
+        if (!this.registry || !this.runId)
+            return;
+        this.registry.updatePhase(this.runId, stageId, {
+            status: "failed",
+            completedAt: new Date().toISOString(),
+            error,
+        });
+        this.emitPhaseProgress(stageId, "failed", 0, error);
+    }
+    emitPhaseProgress(stage, status, progress, message, details) {
+        this.config.onPhaseProgress?.({
+            runId: this.runId,
+            stage,
+            status,
+            progress,
+            message,
+            details,
+        });
+    }
+    // ── Stage 1: Structural Decode ──────────────────────────────────────
+    async runStructuralDecode(options) {
+        const stageId = "structural-decode";
+        this.config.onProgress?.(stageId, "Starting structural decode...");
+        this.phaseStart(stageId);
+        if (!options?.force) {
+            const cached = this.store.loadStageResult(stageId);
+            if (cached) {
+                this.config.onProgress?.(stageId, `Cache hit: ${cached.stats.decoded} files`);
+                this.phaseComplete(stageId, { cached: true, decoded: cached.stats.decoded });
+                return cached;
+            }
+        }
+        try {
+            const registry = new decoder_registry_class_1.DecoderRegistry({
+                projectRoot: this.config.projectRoot,
+            });
+            const files = this.discoverFiles();
+            const snapshots = [];
+            const languages = {};
+            let skipped = 0;
+            for (const file of files) {
+                if (this.config.signal?.aborted)
+                    break;
+                const absPath = path.join(this.config.projectRoot, file);
+                let content;
+                try {
+                    content = fs.readFileSync(absPath, "utf-8");
+                }
+                catch {
+                    skipped++;
+                    continue;
+                }
+                const snapshot = registry.decode(file, content);
+                if (snapshot) {
+                    snapshots.push(snapshot);
+                    languages[snapshot.language] = (languages[snapshot.language] ?? 0) + 1;
+                }
+                else {
+                    skipped++;
+                }
+                if (snapshots.length % 50 === 0) {
+                    this.config.onProgress?.(stageId, `Decoded ${snapshots.length}/${files.length} files`);
+                    this.phaseProgress(stageId, snapshots.length / Math.max(files.length, 1), `Decoded ${snapshots.length}/${files.length}`);
+                }
+            }
+            registry.dispose();
+            const result = {
+                snapshots,
+                stats: { totalFiles: files.length, decoded: snapshots.length, skipped, languages },
+            };
+            this.store.saveStageResult(stageId, result);
+            this.config.onProgress?.(stageId, `Done: ${snapshots.length} decoded, ${skipped} skipped`);
+            this.phaseComplete(stageId, { decoded: snapshots.length, skipped, languages });
+            return result;
+        }
+        catch (err) {
+            this.phaseFail(stageId, err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    }
+    // ── Stage 2: Incremental Analyze ──────────────────────────────────────
+    async runIncrementalAnalyze(callbacks, structuralResult, options) {
+        const stageId = "incremental-analyze";
+        this.config.onProgress?.(stageId, "Starting incremental analysis...");
+        this.phaseStart(stageId);
+        if (!options?.force) {
+            const cached = this.store.loadStageResult(stageId);
+            if (cached) {
+                this.config.onProgress?.(stageId, `Cache hit: ${cached.records.length} records`);
+                this.phaseComplete(stageId, { cached: true, files: cached.records.length });
+                return cached;
+            }
+        }
+        try {
+            // When force is requested, clean the analyzer's internal store
+            // so that stale "complete" file records don't cause enqueueDiscoveredFiles
+            // to skip all files.
+            if (options?.force) {
+                const analyzerDir = this.store.stageDir(stageId);
+                const filesDir = path.join(analyzerDir, "files");
+                if (fs.existsSync(filesDir)) {
+                    fs.rmSync(filesDir, { recursive: true });
+                }
+                for (const f of ["session.json", "queue.json"]) {
+                    const p = path.join(analyzerDir, f);
+                    if (fs.existsSync(p))
+                        fs.unlinkSync(p);
+                }
+            }
+            const structural = structuralResult
+                ?? this.store.loadStageResult("structural-decode");
+            const analyzer = new incremental_analyzer_class_1.IncrementalAnalyzer({
+                projectRoot: this.config.projectRoot,
+                storeDir: this.store.stageDir(stageId),
+                projectName: this.config.projectName,
+                model: this.config.model,
+                numCtx: this.config.numCtx,
+                maxFiles: this.config.maxFiles,
+                enableDecoder: false,
+            });
+            // Pre-populate structural snapshots into file records
+            // Note: This runs after analyzer.collect() discovers files, so we hook into
+            // the analyzer's store after initial scan but before LLM processing
+            const structuralByFile = new Map();
+            if (structural) {
+                for (const snapshot of structural.snapshots) {
+                    structuralByFile.set(snapshot.filePath, snapshot);
+                }
+            }
+            // Wrap the callbacks to inject structural context (and optionally skip LLM)
+            const wrappedCallbacks = {
+                ...callbacks,
+                analyzeRange: async (filePath, content, range, context) => {
+                    const snap = structuralByFile.get(filePath);
+                    // ── Structural fast-path: skip LLM when decoder found symbols ────────
+                    if (this.config.structuralFastPath && snap && snap.symbols.length > 0) {
+                        return synthesizeRangesFromSnapshot(snap, range ?? null);
+                    }
+                    // ─────────────────────────────────────────────────────────────────────
+                    // Inject structural summary if available from Stage 1
+                    if (snap && !context.structuralSummary) {
+                        const symbols = snap.symbols.map((s) => {
+                            let line = `  ${s.kind} ${s.name}`;
+                            if (s.extends)
+                                line += ` extends ${s.extends}`;
+                            if (s.implements?.length)
+                                line += ` implements ${s.implements.join(", ")}`;
+                            if (s.parameters?.length)
+                                line += `(${s.parameters.map((p) => `${p.name}: ${p.type ?? "?"}`).join(", ")})`;
+                            if (s.returnType)
+                                line += `: ${s.returnType}`;
+                            return line;
+                        }).join("\n");
+                        const imports = snap.imports.map((i) => `  ${(i.names ?? []).join(", ")} from "${i.source}"`).join("\n");
+                        context = {
+                            ...context,
+                            structuralSummary: `Language: ${snap.language}\nImports:\n${imports}\nSymbols:\n${symbols}`,
+                        };
+                    }
+                    return callbacks.analyzeRange(filePath, content, range, context);
+                },
+            };
+            const stats = await analyzer.collect(wrappedCallbacks);
+            const records = analyzer.getCollectedRecords();
+            const result = { records, stats };
+            this.store.saveStageResult(stageId, result);
+            this.config.onProgress?.(stageId, `Done: ${records.length} files, ${stats.totalRanges} ranges`);
+            this.phaseComplete(stageId, {
+                files: records.length,
+                ranges: stats.totalRanges,
+                deps: stats.totalDependencies,
+                llmCalls: stats.llmCalls,
+            });
+            return result;
+        }
+        catch (err) {
+            this.phaseFail(stageId, err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    }
+    // ── Stage 3: Knowledge Graph Build ────────────────────────────────────
+    async runKnowledgeGraphBuild(analyzeResult, options) {
+        const stageId = "knowledge-graph-build";
+        this.config.onProgress?.(stageId, "Building knowledge graph...");
+        this.phaseStart(stageId);
+        if (!options?.force) {
+            const cached = this.store.loadStageResult(stageId);
+            if (cached) {
+                this.config.onProgress?.(stageId, `Cache hit: ${cached.nodes.length} nodes, ${cached.edges.length} edges`);
+                this.phaseComplete(stageId, { cached: true, nodes: cached.nodes.length, edges: cached.edges.length });
+                return cached;
+            }
+        }
+        try {
+            const analysis = analyzeResult
+                ?? this.store.loadStageResult("incremental-analyze");
+            const structural = this.store.loadStageResult("structural-decode");
+            const nodes = [];
+            const edges = [];
+            const nodeIdMap = new Map();
+            /** Resource node ids — for dead-resource detection. */
+            const resourceNodeIds = new Set();
+            let nextId = 1;
+            const makeId = () => `n${nextId++}`;
+            // Build nodes from structural snapshots
+            if (structural) {
+                for (const snapshot of structural.snapshots) {
+                    const layer = snapshot.resourceKind ?? "code";
+                    for (const sym of snapshot.symbols) {
+                        // Skip property-level symbols as top-level nodes — keep as members only
+                        if (layer === "code" &&
+                            (sym.kind === "property" || sym.kind === "method") &&
+                            !sym.exported) {
+                            continue;
+                        }
+                        const id = makeId();
+                        const key = `${sym.name}@${snapshot.filePath}`;
+                        nodeIdMap.set(key, id);
+                        // Also register by bare name for cross-layer resolution
+                        if (!nodeIdMap.has(sym.name)) {
+                            nodeIdMap.set(sym.name, id);
+                        }
+                        nodes.push({
+                            id,
+                            type: sym.kind,
+                            name: sym.name,
+                            file: snapshot.filePath,
+                            line: sym.startLine,
+                            lineEnd: sym.endLine,
+                            layer,
+                        });
+                        if (layer !== "code")
+                            resourceNodeIds.add(id);
+                        if (sym.extends) {
+                            edges.push({ from: id, to: `unresolved:${sym.extends}`, type: "extends" });
+                        }
+                        if (sym.implements) {
+                            for (const iface of sym.implements) {
+                                edges.push({ from: id, to: `unresolved:${iface}`, type: "implements" });
+                            }
+                        }
+                        // Members as child nodes
+                        if (sym.members) {
+                            for (const member of sym.members) {
+                                const memberId = makeId();
+                                const memberKey = `${member.name}@${snapshot.filePath}`;
+                                nodeIdMap.set(memberKey, memberId);
+                                nodes.push({
+                                    id: memberId,
+                                    type: member.kind,
+                                    name: `${sym.name}.${member.name}`,
+                                    file: snapshot.filePath,
+                                    line: member.startLine,
+                                    lineEnd: member.endLine,
+                                    layer,
+                                });
+                                edges.push({ from: id, to: memberId, type: "contains" });
+                                if (layer !== "code")
+                                    resourceNodeIds.add(memberId);
+                            }
+                        }
+                    }
+                    // Import edges
+                    for (const imp of snapshot.imports) {
+                        if (!imp.names)
+                            continue;
+                        for (const name of imp.names) {
+                            const fromNodes = nodes.filter((n) => n.file === snapshot.filePath);
+                            if (fromNodes.length > 0) {
+                                edges.push({
+                                    from: fromNodes[0].id,
+                                    to: `unresolved:${name}`,
+                                    type: "depends_on",
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // Cross-layer edges: detect code-to-resource references via naming conventions
+            if (structural) {
+                this.buildCrossLayerEdges(structural.snapshots, nodes, edges, nodeIdMap);
+            }
+            // Enrich from LLM analysis (business concepts, runtime deps)
+            if (analysis) {
+                for (const record of analysis.records) {
+                    for (const range of record.ranges) {
+                        for (const symbol of range.symbols) {
+                            const key = `${symbol}@${record.filePath}`;
+                            if (!nodeIdMap.has(key)) {
+                                const id = makeId();
+                                nodeIdMap.set(key, id);
+                                nodes.push({
+                                    id,
+                                    type: range.purpose,
+                                    name: symbol,
+                                    file: record.filePath,
+                                    line: range.startLine,
+                                    lineEnd: range.endLine,
+                                });
+                            }
+                        }
+                        for (const dep of range.dependencies) {
+                            const sourceKey = range.symbols[0] ? `${range.symbols[0]}@${record.filePath}` : null;
+                            const sourceId = sourceKey ? nodeIdMap.get(sourceKey) : null;
+                            if (!sourceId)
+                                continue;
+                            const targetKey = dep.symbol ? `${dep.symbol}@${dep.targetFile}` : null;
+                            const targetId = targetKey ? nodeIdMap.get(targetKey) : null;
+                            edges.push({
+                                from: sourceId,
+                                to: targetId ?? `unresolved:${dep.symbol ?? dep.targetFile}`,
+                                type: "depends_on",
+                            });
+                        }
+                    }
+                }
+            }
+            // Resolve unresolved edge targets
+            for (const edge of edges) {
+                if (edge.to.startsWith("unresolved:")) {
+                    const name = edge.to.replace("unresolved:", "");
+                    const match = nodes.find((n) => n.name === name || n.name.endsWith(`.${name}`));
+                    if (match)
+                        edge.to = match.id;
+                }
+            }
+            // Filter edges that still have unresolved targets
+            const validNodeIds = new Set(nodes.map((n) => n.id));
+            const validEdges = edges.filter((e) => validNodeIds.has(e.from) && validNodeIds.has(e.to));
+            // Detect unreferenced resources (tables, endpoints, models with no incoming edges from code)
+            const referencedIds = new Set();
+            for (const edge of validEdges) {
+                if (edge.type !== "contains") {
+                    referencedIds.add(edge.to);
+                }
+            }
+            const unreferencedResources = [];
+            for (const nodeId of resourceNodeIds) {
+                if (!referencedIds.has(nodeId)) {
+                    const node = nodes.find((n) => n.id === nodeId);
+                    if (node && !node.name.includes(".")) {
+                        // Only report top-level resource symbols, not members
+                        unreferencedResources.push({
+                            name: node.name,
+                            kind: node.type,
+                            file: node.file ?? "unknown",
+                            line: node.line,
+                        });
+                    }
+                }
+            }
+            // Detect missing infra: code services/entry points with no corresponding infra definition
+            const missingInfra = this.detectMissingInfra(nodes, edges);
+            // Detect unreferenced code: code-layer top-level symbols with no incoming usage edges
+            const unreferencedCode = this.detectUnreferencedCode(nodes, validEdges);
+            const result = {
+                nodes,
+                edges: validEdges,
+                unreferencedResources: unreferencedResources.length > 0 ? unreferencedResources : undefined,
+                unreferencedCode: unreferencedCode.length > 0 ? unreferencedCode : undefined,
+                missingInfra: missingInfra.length > 0 ? missingInfra : undefined,
+            };
+            this.store.saveStageResult(stageId, result);
+            const unreferencedMsg = unreferencedResources.length > 0
+                ? `, ${unreferencedResources.length} unreferenced resources`
+                : "";
+            const unreferencedCodeMsg = unreferencedCode.length > 0
+                ? `, ${unreferencedCode.length} unreferenced code`
+                : "";
+            const missingInfraMsg = missingInfra.length > 0
+                ? `, ${missingInfra.length} missing infra`
+                : "";
+            this.config.onProgress?.(stageId, `Done: ${nodes.length} nodes, ${validEdges.length} edges${unreferencedMsg}${unreferencedCodeMsg}${missingInfraMsg}`);
+            this.phaseComplete(stageId, {
+                nodes: nodes.length,
+                edges: validEdges.length,
+                unreferencedResources: unreferencedResources.length,
+                unreferencedCode: unreferencedCode.length,
+                missingInfra: missingInfra.length,
+            });
+            return result;
+        }
+        catch (err) {
+            this.phaseFail(stageId, err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    }
+    // ── Cross-Layer Edge Detection ────────────────────────────────────────
+    /**
+     * Detects references from code to non-code resources by matching names.
+     * E.g. a class `Order` or decorator `@Entity("orders")` → SQL table `orders`.
+     * Uses case-insensitive, plural-aware matching.
+     */
+    buildCrossLayerEdges(snapshots, nodes, edges, nodeIdMap) {
+        // Collect resource symbols (tables, models, endpoints, services, etc.)
+        const resourceNames = new Map(); // lowercase name → nodeId
+        for (const node of nodes) {
+            if (node.layer && node.layer !== "code" && !node.name.includes(".")) {
+                resourceNames.set(node.name.toLowerCase(), node.id);
+                // Also register plural/singular variants
+                const lower = node.name.toLowerCase();
+                if (lower.endsWith("s")) {
+                    resourceNames.set(lower.slice(0, -1), node.id);
+                }
+                else {
+                    resourceNames.set(lower + "s", node.id);
+                }
+            }
+        }
+        if (resourceNames.size === 0)
+            return;
+        // Scan code snapshots for references to resource names
+        for (const snapshot of snapshots) {
+            if (snapshot.resourceKind && snapshot.resourceKind !== "code")
+                continue;
+            for (const sym of snapshot.symbols) {
+                const codeKey = `${sym.name}@${snapshot.filePath}`;
+                const codeNodeId = nodeIdMap.get(codeKey);
+                if (!codeNodeId)
+                    continue;
+                // Check if class/entity name matches a resource name
+                const lowerName = sym.name.toLowerCase();
+                const matchId = resourceNames.get(lowerName);
+                if (matchId && matchId !== codeNodeId) {
+                    edges.push({ from: codeNodeId, to: matchId, type: "maps_to" });
+                }
+                // Check decorators like @Entity("tableName") or @Table("name")
+                if (sym.decorators) {
+                    for (const decorator of sym.decorators) {
+                        const argMatch = decorator.match(/\(\s*["'](\w+)["']/);
+                        if (argMatch) {
+                            const argMatchId = resourceNames.get(argMatch[1].toLowerCase());
+                            if (argMatchId) {
+                                edges.push({ from: codeNodeId, to: argMatchId, type: "maps_to" });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // ── Missing Infrastructure Detection ──────────────────────────────────
+    /**
+     * Detects code services/processes that aren't mapped in infra manifests.
+     * E.g. a `WorkerService` class or `worker.ts` entry point with no
+     * docker-compose service or k8s Deployment.
+     *
+     * Heuristic: looks for code-layer nodes that resemble entry points
+     * (controllers, services with "worker"/"job"/"cron", main files)
+     * and checks if any infra-layer service references them.
+     */
+    detectMissingInfra(nodes, edges) {
+        const infraNodes = nodes.filter((n) => n.layer === "infra");
+        if (infraNodes.length === 0)
+            return []; // no infra manifests → can't detect
+        // Collect infra service names (lowercase)
+        const infraServiceNames = new Set();
+        for (const n of infraNodes) {
+            if (n.type === "service" || n.type === "container") {
+                infraServiceNames.add(n.name.toLowerCase());
+            }
+        }
+        // Collect infra env vars that reference known paths/services
+        const infraEnvValues = new Set();
+        for (const n of infraNodes) {
+            if (n.type === "env_var") {
+                infraEnvValues.add(n.name.toLowerCase());
+            }
+        }
+        const missing = [];
+        // Patterns that suggest an entry point / deployable process
+        const entryPointPatterns = [
+            /worker/i, /job/i, /cron/i, /scheduler/i, /consumer/i,
+            /processor/i, /listener/i, /handler$/i, /server/i,
+        ];
+        const codeNodes = nodes.filter((n) => n.layer === "code" || !n.layer);
+        for (const codeNode of codeNodes) {
+            // Only check classes/modules that look like independent processes
+            if (!["class", "module", "function"].includes(codeNode.type))
+                continue;
+            const isEntryPoint = entryPointPatterns.some((p) => p.test(codeNode.name));
+            if (!isEntryPoint)
+                continue;
+            // Check if any infra service name matches or contains this name
+            const lowerName = codeNode.name.toLowerCase()
+                .replace(/service$|class$|handler$|processor$/i, "")
+                .replace(/[^a-z0-9]/g, "");
+            const hasInfra = [...infraServiceNames].some((svc) => {
+                const svcClean = svc.replace(/[^a-z0-9]/g, "");
+                return svcClean.includes(lowerName) || lowerName.includes(svcClean);
+            });
+            if (!hasInfra && lowerName.length > 2) {
+                missing.push({
+                    name: codeNode.name,
+                    kind: codeNode.type,
+                    file: codeNode.file ?? "unknown",
+                    hint: `No matching service/deployment found in infra manifests for "${codeNode.name}"`,
+                });
+            }
+        }
+        return missing;
+    }
+    // ── Unreferenced Code Detection ────────────────────────────────────────
+    /**
+     * Detects code-layer symbols (class, interface, enum, type, function/module)
+     * that have no incoming usage edges from other code nodes.
+     *
+     * A symbol is considered "unreferenced" when nothing in the codebase has a
+     * depends_on / uses / extends / implements / calls edge pointing TO it.
+     * Note: entry-point types (Controller, Router, Resolver, App, Main, Server)
+     * are expected to have zero callers and are excluded from the report.
+     */
+    detectUnreferencedCode(nodes, edges) {
+        // Top-level code kinds worth tracking (skip fine-grained method/property/import)
+        const TOP_LEVEL_KINDS = new Set([
+            "class", "interface", "enum", "type", "function",
+            "class_declaration", "interface_declaration", "enum_declaration",
+            "module", "constant",
+        ]);
+        // Entry-point patterns: frameworks call these, so no code caller is expected
+        const ENTRY_POINT_PATTERNS = [
+            /controller$/i, /router$/i, /resolver$/i, /middleware$/i,
+            /app$/i, /main$/i, /server$/i, /bootstrap/i, /index$/i,
+            /module$/i, /plugin$/i, /guard$/i, /interceptor$/i,
+        ];
+        // Collect all code-layer top-level node IDs that could be dead code candidates
+        const candidates = nodes.filter((n) => (n.layer === "code" || !n.layer) &&
+            TOP_LEVEL_KINDS.has(n.type) &&
+            !ENTRY_POINT_PATTERNS.some((p) => p.test(n.name)));
+        if (candidates.length === 0)
+            return [];
+        const candidateIds = new Set(candidates.map((n) => n.id));
+        // Build set of node IDs that are referenced by a non-contains edge
+        const usageEdgeTypes = new Set(["depends_on", "uses", "extends", "implements", "calls", "maps_to"]);
+        const referencedIds = new Set();
+        for (const edge of edges) {
+            if (usageEdgeTypes.has(edge.type) && candidateIds.has(edge.to)) {
+                referencedIds.add(edge.to);
+            }
+        }
+        return candidates
+            .filter((n) => !referencedIds.has(n.id))
+            .map((n) => ({
+            name: n.name,
+            kind: n.type,
+            file: n.file ?? "unknown",
+            line: n.line,
+        }));
+    }
+    // ── Stage 4: Mermaid Render ───────────────────────────────────────────
+    async runGraphRender(graphResult, options) {
+        const stageId = "graph-render";
+        this.config.onProgress?.(stageId, "Rendering graph...");
+        this.phaseStart(stageId);
+        if (!options?.force) {
+            const cached = this.store.loadStageResult(stageId);
+            if (cached) {
+                this.phaseComplete(stageId, { cached: true });
+                return cached;
+            }
+        }
+        try {
+            const graph = graphResult
+                ?? this.store.loadStageResult("knowledge-graph-build");
+            if (!graph)
+                throw new Error("No knowledge graph. Run knowledge-graph-build first.");
+            const maxNodes = options?.maxNodes ?? 200;
+            const nodes = graph.nodes.slice(0, maxNodes);
+            const nodeIds = new Set(nodes.map((n) => n.id));
+            const edges = graph.edges.filter((e) => nodeIds.has(e.from) && nodeIds.has(e.to));
+            const mermaid = this.buildMermaid(nodes, edges);
+            const outputPath = path.join(this.store.stageDir(stageId), "graph.mmd");
+            fs.writeFileSync(outputPath, mermaid);
+            const result = { mermaidCode: mermaid, outputPath };
+            this.store.saveStageResult(stageId, result);
+            this.config.onProgress?.(stageId, `Done: ${nodes.length} nodes → ${outputPath}`);
+            this.phaseComplete(stageId, { nodes: nodes.length, lines: mermaid.split("\n").length, outputPath });
+            return result;
+        }
+        catch (err) {
+            this.phaseFail(stageId, err instanceof Error ? err.message : String(err));
+            throw err;
+        }
+    }
+    // ── Run All ───────────────────────────────────────────────────────────
+    async runAll(llmCallbacks, options) {
+        const structural = await this.runStructuralDecode(options);
+        const analysis = await this.runIncrementalAnalyze(llmCallbacks, structural, options);
+        const graph = await this.runKnowledgeGraphBuild(analysis, options);
+        const render = await this.runGraphRender(graph, options);
+        return { structural, analysis, graph, render };
+    }
+    // ── File Discovery ────────────────────────────────────────────────────
+    discoverFiles() {
+        const skipDirs = 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 codeExts = new Set([
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".py", ".pyw", ".rb", ".rake", ".go",
+            ".java", ".kt", ".kts", ".scala", ".cs",
+            ".rs", ".cpp", ".cc", ".c", ".h", ".hpp",
+            ".swift", ".ex", ".exs", ".php",
+        ]);
+        const resourceExts = new Set([
+            ".sql", ".prisma", ".graphql", ".gql", ".proto",
+            ".yaml", ".yml",
+        ]);
+        const files = [];
+        const limit = this.config.maxFiles ?? 0;
+        const walk = (dir, depth) => {
+            if (depth > 8 || (limit > 0 && files.length >= limit))
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (limit > 0 && files.length >= limit)
+                    break;
+                if (entry.name.startsWith(".") && entry.isDirectory())
+                    continue;
+                if (skipDirs.has(entry.name.toLowerCase()))
+                    continue;
+                const abs = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(abs, depth + 1);
+                    continue;
+                }
+                const ext = path.extname(entry.name).toLowerCase();
+                const isCode = codeExts.has(ext);
+                const isResource = resourceExts.has(ext);
+                const isDockerfile = /^Dockerfile/i.test(entry.name) || /\.dockerfile$/i.test(entry.name);
+                if (!isCode && !isResource && !isDockerfile)
+                    continue;
+                try {
+                    if (fs.statSync(abs).size > 500_000)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                files.push(path.relative(this.config.projectRoot, abs));
+            }
+        };
+        walk(this.config.projectRoot, 0);
+        return files;
+    }
+    // ── Mermaid Builder ───────────────────────────────────────────────────
+    buildMermaid(nodes, edges) {
+        const lines = ["graph LR"];
+        // Group by architecture layer, then by directory within each layer
+        const layerGroups = new Map();
+        for (const node of nodes) {
+            const layer = node.layer ?? "code";
+            const dir = node.file ? path.dirname(node.file) : "__root__";
+            if (!layerGroups.has(layer))
+                layerGroups.set(layer, new Map());
+            const dirMap = layerGroups.get(layer);
+            if (!dirMap.has(dir))
+                dirMap.set(dir, []);
+            dirMap.get(dir).push(node);
+        }
+        const layerLabels = {
+            code: "Application Code",
+            schema: "Database / Schema",
+            infra: "Infrastructure",
+            "api-spec": "API Specifications",
+            config: "Configuration",
+            migration: "Migrations",
+            "test-fixture": "Test Fixtures",
+        };
+        for (const [layer, dirMap] of layerGroups) {
+            const safeLayer = layer.replace(/[^a-zA-Z0-9]/g, "_");
+            const label = layerLabels[layer] ?? layer;
+            lines.push(`  subgraph ${safeLayer}["${label}"]`);
+            lines.push(`    direction TB`);
+            for (const [dir, group] of dirMap) {
+                if (dirMap.size > 1) {
+                    const safeDir = `${safeLayer}_${dir.replace(/[^a-zA-Z0-9]/g, "_")}`;
+                    lines.push(`    subgraph ${safeDir}["${dir}"]`);
+                }
+                for (const node of group) {
+                    const shape = this.mermaidShape(node.type);
+                    const label = node.name.replace(/"/g, "'");
+                    lines.push(`      ${node.id}${shape[0]}"${label}"${shape[1]}`);
+                }
+                if (dirMap.size > 1) {
+                    lines.push(`    end`);
+                }
+            }
+            lines.push("  end");
+        }
+        for (const edge of edges) {
+            const style = this.mermaidEdgeStyle(edge.type);
+            lines.push(`  ${edge.from} ${style} ${edge.to}`);
+        }
+        return lines.join("\n");
+    }
+    mermaidShape(type) {
+        switch (type) {
+            case "class":
+            case "struct": return ["[", "]"];
+            case "interface":
+            case "trait":
+            case "protocol": return ["([", "])"];
+            case "function":
+            case "method": return [">", "]"];
+            case "enum": return ["{{", "}}"];
+            case "module":
+            case "namespace": return ["[[", "]]"];
+            // Resource shapes
+            case "table":
+            case "model": return ["[(", ")]"];
+            case "column":
+            case "field": return ["(", ")"];
+            case "index": return ["{", "}"];
+            case "endpoint":
+            case "route": return ["(((", ")))"];
+            case "message": return ["[/", "/]"];
+            case "service":
+            case "container": return ["[[", "]]"];
+            case "volume":
+            case "env_var": return ["{{", "}}"];
+            case "migration": return ["[\\", "\\]"];
+            default: return ["(", ")"];
+        }
+    }
+    mermaidEdgeStyle(type) {
+        switch (type) {
+            case "extends": return "-->|extends|";
+            case "implements": return "-.->|implements|";
+            case "depends_on": return "-->|uses|";
+            case "calls": return "-->|calls|";
+            case "contains": return "-->|contains|";
+            case "maps_to": return "==>|maps to|";
+            default: return "-->";
+        }
+    }
+}
+exports.CodeAnalysisPipeline = CodeAnalysisPipeline;
+//# sourceMappingURL=code-analysis-pipeline.class.js.map