memor-code-cli 0.2.0

package/dist/builders/analyzeRepo.js

@@ -0,0 +1,873 @@
+"use strict";
+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.analyzeRepo = analyzeRepo;
+const path = __importStar(require("path"));
+const scanRepo_1 = require("../scanner/scanRepo");
+const buildCodebaseGraph_1 = require("../graph/buildCodebaseGraph");
+const SystemSynthesis_1 = require("../SystemSynthesis");
+const detectRepoSignals_1 = require("../RepoTypeDetection/detectRepoSignals");
+const detectSystemCandidates_1 = require("../detectors/detectSystemCandidates");
+const classifySystemType_1 = require("../detectors/classifySystemType");
+const applyRunnableConfidenceGate_1 = require("../detectors/applyRunnableConfidenceGate");
+const detectEntryPoints_1 = require("../detectors/detectEntryPoints");
+const detectBlocks_1 = require("../detectors/detectBlocks");
+const detectAppArchetype_1 = require("../RepoTypeDetection/detectAppArchetype");
+const detectPackageArchetype_1 = require("../RepoTypeDetection/detectPackageArchetype");
+const detectRepoMode_1 = require("../RepoTypeDetection/detectRepoMode");
+const applyRepoModeConsistency_1 = require("../RepoTypeDetection/applyRepoModeConsistency");
+const detectRepoCenterSystems_1 = require("../RepoTypeDetection/detectRepoCenterSystems");
+const inferSupportRole_1 = require("../RepoTypeDetection/inferSupportRole");
+const detectSubsystems_1 = require("../detectors/detectSubsystems");
+const deriveRecommendedStartPath_1 = require("./deriveRecommendedStartPath");
+const deriveRuntimeRole_1 = require("./deriveRuntimeRole");
+const systemRanking_1 = require("./systemRanking");
+const buildSystemConnections_1 = require("./buildSystemConnections");
+const text_1 = require("../utils/text");
+const path_1 = require("../utils/path");
+const file_1 = require("../utils/file");
+const IntentionalStructure_1 = require("../IntentionalStructure");
+const RuntimeInference_1 = require("../RuntimeInference");
+const SystemSynthesis_2 = require("../SystemSynthesis");
+const detectAppInternalUnits_1 = require("../detectors/detectAppInternalUnits");
+const detectRoutes_1 = require("../scanner/detectRoutes");
+const detectDBOps_1 = require("../scanner/detectDBOps");
+const detectRepoPurpose_1 = require("../scanner/detectRepoPurpose");
+const loader_1 = require("../heuristics/loader");
+const detectRunCommands_1 = require("./detectRunCommands");
+// ── Per-system tech detection ─────────────────────────────────────────
+// Framework labels are now sourced from src/heuristics/known-packages.json.
+// To add a new framework or fix a label, edit that file — not this one.
+function detectTechFromPkg(pkg, rootPath, flat) {
+    const tech = [];
+    const seen = new Set();
+    // Language detection from file extensions within this system
+    const norm = path.normalize(rootPath);
+    const sysFiles = flat.filter((e) => !e.isDirectory && path.normalize(e.fullPath).startsWith(norm + path.sep));
+    let tsCount = 0, jsCount = 0, pyCount = 0, goCount = 0, rsCount = 0;
+    for (const f of sysFiles.slice(0, 200)) {
+        const ext = f.extension;
+        if (ext === "ts" || ext === "tsx")
+            tsCount++;
+        else if (ext === "js" || ext === "jsx")
+            jsCount++;
+        else if (ext === "py")
+            pyCount++;
+        else if (ext === "go")
+            goCount++;
+        else if (ext === "rs")
+            rsCount++;
+    }
+    if (tsCount > jsCount && tsCount > 0) {
+        tech.push("TypeScript");
+        seen.add("TypeScript");
+    }
+    else if (jsCount > 0) {
+        tech.push("JavaScript");
+        seen.add("JavaScript");
+    }
+    if (pyCount > 3) {
+        tech.push("Python");
+        seen.add("Python");
+    }
+    if (goCount > 3) {
+        tech.push("Go");
+        seen.add("Go");
+    }
+    if (rsCount > 3) {
+        tech.push("Rust");
+        seen.add("Rust");
+    }
+    if (!pkg)
+        return tech;
+    const runtimeDeps = Object.keys(pkg.dependencies || {});
+    const devDeps = Object.keys(pkg.devDependencies || {});
+    const peerDeps = Object.keys(pkg.peerDependencies || {});
+    // resolveFrameworkLabels reads known-packages.json — covers 100+ JS/TS frameworks.
+    // Deduplicates by framework name, respects depKind rules (runtime vs dev).
+    const frameworkLabels = (0, loader_1.resolveFrameworkLabels)(runtimeDeps, devDeps, peerDeps);
+    for (const label of frameworkLabels) {
+        if (!seen.has(label)) {
+            tech.push(label);
+            seen.add(label);
+        }
+    }
+    return tech.slice(0, 6);
+}
+function countFilesAndDirs(flat) {
+    let files = 0;
+    let dirs = 0;
+    for (const e of flat) {
+        if (e.isDirectory)
+            dirs += 1;
+        else
+            files += 1;
+    }
+    return { files, dirs };
+}
+function rankingContext(c) {
+    const rr = c.relativeRoot === "." ? "" : c.relativeRoot;
+    const parts = rr.split("/").filter(Boolean);
+    return {
+        candidateName: c.name,
+        underApps: parts[0] === "apps",
+        underPackages: parts[0] === "packages",
+    };
+}
+/**
+ * Full pipeline: scan → classify → entry points → runnable gate → blocks → tier/score/start → runtime role → flows → tier-group sort → summary.
+ */
+async function analyzeRepo(repoPath) {
+    const rootPath = (0, path_1.normalizeRepoRoot)(repoPath);
+    const repoName = path.basename(rootPath);
+    const scan = await (0, scanRepo_1.scanRepo)(rootPath);
+    const flat = (0, scanRepo_1.flattenScanTree)(scan.root);
+    const { files: totalFiles, dirs: totalDirectories } = countFilesAndDirs(flat);
+    const signals = await (0, detectRepoSignals_1.detectRepoSignals)(rootPath);
+    const candidates = await (0, detectSystemCandidates_1.detectSystemCandidates)(rootPath, scan.root, signals);
+    const systems = [];
+    for (let i = 0; i < candidates.length; i++) {
+        const c = candidates[i];
+        const sysId = `sys-${(0, text_1.slugify)(c.name)}-${i}`;
+        const rctx = rankingContext(c);
+        // Non-package systems (compiler/, scripts/, examples/, etc.)
+        if (c.isNonPackage) {
+            systems.push({
+                id: sysId,
+                name: c.name,
+                type: "support-system",
+                systemTier: "support",
+                runtimeRole: "consumable",
+                importanceScore: 0.3,
+                rootPath: c.relativeRoot,
+                confidence: 0.7,
+                description: c.reason,
+                entryPoints: [],
+                blocks: [],
+                flows: [],
+                tags: [],
+            });
+            continue;
+        }
+        const classifyCtx = {
+            candidateFolderName: c.name,
+            relativeRoot: c.relativeRoot,
+        };
+        let classification = await (0, classifySystemType_1.classifySystemType)(c.rootPath, rootPath, flat, classifyCtx);
+        const relRoot = c.relativeRoot;
+        const rootPathOut = relRoot === "." ? "." : relRoot;
+        let entryPoints = await (0, detectEntryPoints_1.detectEntryPoints)(c.rootPath, relRoot, flat, classification.type);
+        const gated = (0, applyRunnableConfidenceGate_1.applyRunnableConfidenceGate)(classification, c.rootPath, flat, classifyCtx, entryPoints);
+        if (gated.type !== classification.type) {
+            entryPoints = await (0, detectEntryPoints_1.detectEntryPoints)(c.rootPath, relRoot, flat, gated.type);
+        }
+        classification = gated;
+        const blocks = (0, detectBlocks_1.detectBlocks)(c.rootPath, relRoot, flat, sysId);
+        const baseDescription = `${classification.description} Candidate: ${c.reason}`;
+        // Read package.json description + deps for enrichment
+        const pkgJsonRaw = await (0, file_1.readTextSafe)(path.join(c.rootPath, "package.json"));
+        const pkgJson = pkgJsonRaw ? (0, text_1.parseJsonLoose)(pkgJsonRaw) : null;
+        const pkgDesc = pkgJson && typeof pkgJson.description === "string" && pkgJson.description.length > 5
+            ? pkgJson.description
+            : undefined;
+        const detectedTech = detectTechFromPkg(pkgJson, c.rootPath, flat);
+        // Tags are derived from the system's own detectedTech, not from repo-root signals.
+        // signals.frameworks are repo-wide (e.g., React detected somewhere in the monorepo)
+        // and would stamp the same tags on every system — Prisma packages getting React tags, etc.
+        const tagsOut = [...new Set(detectedTech)].slice(0, 8);
+        const draft = {
+            id: sysId,
+            name: c.name,
+            type: classification.type,
+            systemTier: "secondary",
+            runtimeRole: "consumable",
+            importanceScore: 0,
+            packageDescription: pkgDesc,
+            detectedTech: detectedTech.length > 0 ? detectedTech : undefined,
+            rootPath: rootPathOut,
+            confidence: classification.confidence,
+            description: baseDescription,
+            entryPoints,
+            blocks,
+            flows: [],
+            tags: tagsOut,
+        };
+        draft.systemTier = (0, systemRanking_1.assignSystemTier)(draft, rctx);
+        draft.importanceScore = (0, systemRanking_1.computeImportanceScore)(draft, rctx);
+        const startResult = (0, deriveRecommendedStartPath_1.deriveRecommendedStartPath)(draft);
+        draft.recommendedStartPath = startResult.path;
+        draft.startPathReason = startResult.reason;
+        draft.startPathConfidence = startResult.confidence;
+        draft.runtimeRole = (0, deriveRuntimeRole_1.deriveRuntimeRole)(draft, rctx);
+        draft.appArchetype = (0, detectAppArchetype_1.detectAppArchetype)(draft, { candidateName: c.name, relativeRoot: relRoot }, flat, c.rootPath);
+        draft.subsystems = (0, detectSubsystems_1.detectSubsystems)(draft, c.rootPath, relRoot, flat);
+        draft.packageArchetype = (0, detectPackageArchetype_1.detectPackageArchetype)(draft, rctx);
+        systems.push(draft);
+    }
+    // Read README excerpt for each system (used to enrich descriptions)
+    for (const s of systems) {
+        if (s.type === "support-system")
+            continue;
+        const sysAbs = s.rootPath === "." ? rootPath : path.resolve(rootPath, s.rootPath);
+        const readmeNames = ["README.md", "readme.md", "Readme.md", "README.MD"];
+        for (const name of readmeNames) {
+            const raw = await (0, file_1.readTextSafe)(path.join(sysAbs, name), 4000);
+            if (!raw)
+                continue;
+            const excerpt = extractReadmeExcerpt(raw);
+            if (excerpt) {
+                s.readmeExcerpt = excerpt;
+            }
+            break;
+        }
+    }
+    // Deduplicate: if two systems share the same name, keep the one with higher confidence
+    // (this can happen when a package appears in multiple locations, e.g. nested examples/)
+    const seenNames = new Map();
+    for (const s of systems) {
+        const key = s.name.toLowerCase();
+        const prev = seenNames.get(key);
+        if (!prev) {
+            seenNames.set(key, s);
+        }
+        else {
+            // Keep the one with higher confidence, or more blocks, or shorter rootPath (closer to root)
+            const prevDepth = prev.rootPath.split("/").length;
+            const curDepth = s.rootPath.split("/").length;
+            const betterConfidence = s.confidence > prev.confidence;
+            const moreBlocks = s.blocks.length > prev.blocks.length && s.confidence >= prev.confidence - 0.1;
+            const shallower = curDepth < prevDepth;
+            if (betterConfidence || moreBlocks || shallower) {
+                seenNames.set(key, s);
+            }
+        }
+    }
+    const dedupedSystems = [...seenNames.values()];
+    const sortedSystems = (0, systemRanking_1.sortSystemsGroupedByTier)(dedupedSystems);
+    const detectedRepoStyle = signals.isMonorepoLayout ? "monorepo"
+        : sortedSystems.length > 3 ? "multi-system"
+            : sortedSystems.length > 0 ? "single-app"
+                : "unknown";
+    const summary = {
+        totalFiles,
+        totalDirectories,
+        detectedFrameworks: signals.frameworks,
+        detectedRepoStyle,
+        totalSystems: sortedSystems.length,
+    };
+    const { mode: repoMode } = (0, detectRepoMode_1.detectRepoMode)(signals, repoName); // structure/type/techStack flow to RepoAnalysis via signals
+    // Phase 1: normalise types that contradict repo mode
+    (0, applyRepoModeConsistency_1.applyRepoModeConsistency)(sortedSystems, repoMode);
+    // Phase 2: promote core systems and assign role hints
+    promoteForRepoMode(sortedSystems, repoMode, repoName);
+    (0, detectRepoCenterSystems_1.detectRepoCenterSystems)(sortedSystems, repoMode, repoName);
+    // Ensure at least one primary: if nothing was promoted (e.g., single infra/docs repo),
+    // promote the highest-scoring non-support system so the repo is never all-secondary.
+    const primaryCount = sortedSystems.filter((s) => s.systemTier === "primary").length;
+    if (primaryCount === 0) {
+        const candidate = sortedSystems.find((s) => s.type !== "support-system");
+        if (candidate) {
+            candidate.systemTier = "primary";
+            candidate.importanceScore = Math.max(candidate.importanceScore, 0.7);
+        }
+    }
+    // Phase 3: infer support roles for non-center systems
+    for (const s of sortedSystems) {
+        s.inferredSupportRole = (0, inferSupportRole_1.inferSupportRole)(s, repoMode);
+    }
+    // Phase 4: re-detect archetypes for systems whose role was updated
+    for (const s of sortedSystems) {
+        if (s.systemRoleHint || s.isRepoCenter || s.inferredSupportRole) {
+            s.packageArchetype = (0, detectPackageArchetype_1.detectPackageArchetype)(s, { candidateName: s.name });
+        }
+    }
+    // Phase 5: build system-level connections
+    await (0, buildSystemConnections_1.buildSystemConnections)(sortedSystems, rootPath, flat, repoMode);
+    // Phase 5b: connection-aware hub promotion
+    promoteConnectionHub(sortedSystems, repoName);
+    // Phase 6: route + DB detection for API-surface and runnable systems
+    // Only run on systems that could plausibly have routes or DB calls.
+    // These are best-effort and never block analysis on failure.
+    for (const s of sortedSystems) {
+        if (s.type === "support-system")
+            continue;
+        const sysAbs = s.rootPath === "." ? rootPath : path.resolve(rootPath, s.rootPath);
+        const looksLikeRoute = s.type === "api-service" || s.type === "web-app" || s.type === "worker";
+        if (looksLikeRoute) {
+            try {
+                s.detectedRoutes = await (0, detectRoutes_1.detectRoutes)(sysAbs);
+            }
+            catch { /* best-effort */ }
+        }
+        try {
+            s.detectedDBOps = await (0, detectDBOps_1.detectDBOperations)(sysAbs);
+        }
+        catch { /* best-effort */ }
+    }
+    // Phase 7: for product-web-app repos, decompose internal architecture
+    if (repoMode === "product-web-app" && sortedSystems.length <= 3) {
+        const mainSystem = sortedSystems.find((s) => s.type !== "support-system") ?? sortedSystems[0];
+        if (mainSystem) {
+            const appUnits = (0, detectAppInternalUnits_1.detectAppInternalUnits)(mainSystem, rootPath, flat);
+            if (appUnits.length >= 2) {
+                sortedSystems.push(...appUnits);
+            }
+        }
+    }
+    const finalSystems = (0, systemRanking_1.sortSystemsGroupedByTier)(sortedSystems);
+    const repoCenter = (0, detectRepoMode_1.deriveRepoCenter)(repoMode);
+    const repoNarrative = (0, detectRepoMode_1.buildRepoNarrative)({ repoName, systems: finalSystems, summary }, repoMode);
+    // Phase 8: deterministic repo purpose detection
+    // Runs at repo root — uses file density, config files, package.json signals only.
+    let inferredRepoPurpose;
+    try {
+        const purpose = await (0, detectRepoPurpose_1.detectRepoPurpose)(rootPath);
+        if (purpose.kind !== "unknown")
+            inferredRepoPurpose = purpose;
+    }
+    catch { /* best-effort */ }
+    // Phase 9: run command extraction — zero LLM, pure file reading
+    let runCommands;
+    try {
+        const cmds = await (0, detectRunCommands_1.detectRunCommands)(rootPath);
+        if (cmds.length > 0)
+            runCommands = cmds;
+    }
+    catch { /* best-effort */ }
+    // ── Layer 1: Intentional Structure ────────────────────────────────────
+    // Run before the graph phase so Layer 1 package boundaries inform cluster building.
+    const intentional = await (0, IntentionalStructure_1.detectIntentionalStructure)(rootPath);
+    // Phase 10: always build the import graph (no API key needed) for blast radius data.
+    // LLM system naming only runs when an API key is available.
+    // Without an API key, systems fall back to the filesystem-scan path (finalSystems).
+    let graphSystems = [];
+    let graphResult;
+    let synthesisResultOut;
+    try {
+        const r = await runGraphPhase(rootPath, signals.frameworks, signals, intentional);
+        // Always use graph systems — even without LLM, cluster-based detection (real import
+        // edges, centrality ranking) is more accurate than filesystem-scan package detection
+        // for understanding code architecture.
+        graphSystems = r.systems;
+        graphResult = r.graph;
+        synthesisResultOut = r.synthesisResult;
+    }
+    catch {
+        // best-effort, never block analysis
+    }
+    const allSystems = graphSystems.length > 0
+        ? (0, systemRanking_1.sortSystemsGroupedByTier)([...graphSystems])
+        : finalSystems;
+    // Wire Layer 1 edges into system connections
+    await applyIntentionalStructure(allSystems, intentional, rootPath);
+    const analysis = {
+        repoName,
+        rootPath,
+        repoMode,
+        repoCenter,
+        repoNarrative,
+        systems: allSystems,
+        ignoredPaths: scan.ignoredPaths,
+        summary: { ...summary, totalSystems: allSystems.length },
+        inferredRepoPurpose,
+        runCommands,
+    };
+    return {
+        analysis,
+        deprioritizedPaths: scan.deprioritizedPaths,
+        scanMeta: scan.meta,
+        flat,
+        graph: graphResult,
+        synthesisResult: synthesisResultOut,
+    };
+}
+// ── Layer 1: Intentional Structure wiring ────────────────────────────────
+async function applyIntentionalStructure(systems, intentional, repoRoot) {
+    if (intentional.systems.length === 0 && intentional.edges.length === 0)
+        return;
+    // Map Layer 1 system name → AM system, matched by abs path overlap or name
+    const nameToSystem = new Map();
+    for (const iSys of intentional.systems) {
+        if (!iSys.path)
+            continue;
+        // Path match: find the AM system whose rootPath is the closest ancestor
+        let best = null;
+        let bestDepth = -1;
+        for (const sys of systems) {
+            const sysAbs = sys.rootPath === "." ? repoRoot : path.resolve(repoRoot, sys.rootPath);
+            if (iSys.path.startsWith(sysAbs)) {
+                const depth = sysAbs.split(path.sep).length;
+                if (depth > bestDepth) {
+                    best = sys;
+                    bestDepth = depth;
+                }
+            }
+        }
+        if (best) {
+            nameToSystem.set(iSys.name, best);
+            continue;
+        }
+        // Name match fallback
+        const byName = systems.find((s) => s.name.toLowerCase() === iSys.name.toLowerCase());
+        if (byName)
+            nameToSystem.set(iSys.name, byName);
+    }
+    // Wire edges from Layer 1
+    for (const edge of intentional.edges) {
+        const fromSys = nameToSystem.get(edge.from);
+        const toSys = nameToSystem.get(edge.to);
+        // Resolve or create the target system
+        let toId;
+        let toName;
+        if (toSys) {
+            toId = toSys.id;
+            toName = toSys.name;
+        }
+        else {
+            // Create a synthetic infra system for unmatched targets (postgres, redis, etc.)
+            const syntheticId = `intentional-${edge.to}`;
+            const existing = systems.find((s) => s.id === syntheticId);
+            if (existing) {
+                toId = existing.id;
+                toName = existing.name;
+            }
+            else {
+                const iSysDef = intentional.systems.find((s) => s.name === edge.to);
+                const inferredName = capitalize(edge.to);
+                const infraSys = {
+                    id: syntheticId,
+                    name: inferredName,
+                    systemTier: "support",
+                    type: "infra",
+                    runtimeRole: "support",
+                    importanceScore: 0.1,
+                    confidence: 1.0,
+                    description: iSysDef
+                        ? `${inferredName} — declared in ${iSysDef.source}`
+                        : `${inferredName} — declared in intentional structure`,
+                    rootPath: edge.to,
+                    connections: { outgoing: [], incoming: [] },
+                    blocks: [],
+                    entryPoints: [],
+                    flows: [],
+                    tags: ["intentional"],
+                };
+                systems.push(infraSys);
+                nameToSystem.set(edge.to, infraSys);
+                toId = infraSys.id;
+                toName = infraSys.name;
+            }
+        }
+        if (!fromSys)
+            continue;
+        if (!fromSys.connections)
+            fromSys.connections = { outgoing: [], incoming: [] };
+        const alreadyOut = fromSys.connections.outgoing.some((c) => c.targetSystemId === toId);
+        if (!alreadyOut) {
+            fromSys.connections.outgoing.push({
+                targetSystemId: toId,
+                targetSystemName: toName,
+                relation: "uses",
+                confidence: 1.0,
+                reason: edge.evidence,
+            });
+        }
+        const targetSys = toSys ?? systems.find((s) => s.id === toId);
+        if (targetSys) {
+            if (!targetSys.connections)
+                targetSys.connections = { outgoing: [], incoming: [] };
+            const alreadyIn = targetSys.connections.incoming.some((c) => c.targetSystemId === fromSys.id);
+            if (!alreadyIn) {
+                targetSys.connections.incoming.push({
+                    targetSystemId: fromSys.id,
+                    targetSystemName: fromSys.name,
+                    relation: "used-by",
+                    confidence: 1.0,
+                    reason: edge.evidence,
+                });
+            }
+        }
+    }
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+// ── Graph-based system detection (Phase 10) ───────────────────────────────
+const LLM_TYPE_MAP = {
+    "web-app": "web-app",
+    "api-service": "api-service",
+    "ui-library": "ui-library",
+    "docs-site": "docs-site",
+    "shared-library": "shared-package",
+    "shared-package": "shared-package",
+    "data-layer": "shared-package",
+    "infra": "infra",
+    "worker": "worker",
+    "cli": "worker",
+    "config": "support-system",
+    "core-engine": "unknown",
+};
+function synthesisToMemorSystems(result, graph) {
+    // Build id lookup so ConnectionRef.target (name) can resolve to id
+    const nameToId = new Map();
+    for (const s of result.systems)
+        nameToId.set(s.name, s.id);
+    return result.systems.map((s) => {
+        const sysType = LLM_TYPE_MAP[s.type] ?? "unknown";
+        const outgoing = s.connects_to.map((ref) => ({
+            targetSystemId: nameToId.get(ref.target) ?? `synth-ref-${ref.target}`,
+            targetSystemName: ref.target,
+            relation: "uses",
+            confidence: ref.confidence,
+            reason: ref.source,
+        }));
+        const incoming = s.called_by.map((ref) => ({
+            targetSystemId: nameToId.get(ref.target) ?? `synth-ref-${ref.target}`,
+            targetSystemName: ref.target,
+            relation: "used-by",
+            confidence: ref.confidence,
+            reason: ref.source,
+        }));
+        let files = graph.clusterFiles[s.cluster_id] ?? [];
+        // If the cluster has no direct files (e.g. app/api/admin/blocks whose files live
+        // in app/api/admin/blocks/create/, .../delete/, etc.), gather from child clusters.
+        if (files.length === 0) {
+            const prefix = s.cluster_id + "/";
+            for (const [cid, cfiles] of Object.entries(graph.clusterFiles)) {
+                if (cid.startsWith(prefix))
+                    files = files.concat(cfiles);
+            }
+        }
+        // Detect duplicate basenames — use parent/filename when ambiguous
+        const basenames = files.map((fp) => fp.split("/").pop() ?? fp);
+        const baseCount = new Map();
+        for (const b of basenames)
+            baseCount.set(b, (baseCount.get(b) ?? 0) + 1);
+        const blocks = files.map((filePath, i) => {
+            const base = basenames[i];
+            const parts = filePath.split("/");
+            const name = (baseCount.get(base) ?? 0) > 1 && parts.length >= 2
+                ? `${parts[parts.length - 2]}/${base}`
+                : base;
+            return {
+                id: `${s.id}-file-${i}`,
+                name,
+                type: "source-tree",
+                path: filePath,
+            };
+        });
+        const mem = {
+            id: s.id,
+            name: s.name,
+            type: sysType,
+            systemTier: s.tier,
+            runtimeRole: s.tier === "support" ? "support" : "consumable",
+            importanceScore: s.tier === "primary" ? 0.9 : s.tier === "secondary" ? 0.6 : 0.3,
+            rootPath: s.cluster_id,
+            confidence: 0.8,
+            description: s.description,
+            connections: { outgoing, incoming },
+            entryPoints: [],
+            blocks,
+            flows: [],
+            tags: [],
+        };
+        // owns_routes are path strings from L4; detectedRoutes is populated separately by detectRoutes()
+        if (s.package_id)
+            mem.packageDescription = s.package_id;
+        // Wire Phase 3 archetype label so Layer 5 UI can show it without re-classifying
+        if (s.archetype)
+            mem.graphArchetype = s.archetype;
+        return mem;
+    });
+}
+/**
+ * Run graph-based internal system detection for any repo.
+ * Builds an import/export graph across all source files, compresses it to
+ * ~3k tokens, and asks the LLM to name domain systems from real exported symbols.
+ * Falls back to raw cluster names if LLM is unavailable.
+ */
+async function runGraphPhase(rootPath, frameworks, signals, intentional) {
+    const layer1Paths = (intentional?.systems ?? [])
+        .filter((s) => s.path !== null)
+        .map((s) => s.path);
+    const graph = await (0, buildCodebaseGraph_1.buildCodebaseGraph)(rootPath, frameworks, layer1Paths);
+    if (graph.clusters.length === 0)
+        return { systems: [], graph, synthesisResult: undefined };
+    const meaningfulClusters = graph.clusters.filter((c) => !c.signals.hasTests && c.fileCount >= 1);
+    if (meaningfulClusters.length <= 1)
+        return { systems: [], graph, synthesisResult: undefined };
+    // Read root README and derive repo type — needed before merging layers
+    const repoName = rootPath.split("/").pop() ?? "repo";
+    const readmeNames = ["README.md", "readme.md", "Readme.md", "README.MD"];
+    let readmeSummary;
+    for (const name of readmeNames) {
+        const raw = await (0, file_1.readTextSafe)(path.join(rootPath, name), 4000);
+        if (raw) {
+            readmeSummary = extractReadmeExcerpt(raw) ?? undefined;
+            break;
+        }
+    }
+    let repoStructure;
+    let repoType;
+    let techStack;
+    if (signals) {
+        const { detectRepoMode } = await Promise.resolve().then(() => __importStar(require("../RepoTypeDetection/detectRepoMode")));
+        const result = detectRepoMode(signals, repoName);
+        repoStructure = result.structure;
+        repoType = result.type;
+        techStack = result.techStack;
+    }
+    // Layer 3: Runtime Inference
+    let runtimeInference = { edges: [], sources: [] };
+    if (intentional) {
+        try {
+            runtimeInference = await (0, RuntimeInference_1.detectRuntimeInference)(rootPath, graph, intentional);
+        }
+        catch { /* best-effort */ }
+    }
+    // Merge L1 + L2 + L3 into a single EnrichedGraph
+    const enriched = (0, SystemSynthesis_2.mergeLayerOutputs)(intentional ?? { systems: [], edges: [], envWiring: [], sources: [] }, graph, runtimeInference, { repoName, readmeSummary, repoStructure, repoType, techStack });
+    // Layer 4: Synthesize — handles cache / LLM / deterministic fallback + stampDeterministic
+    const synthesisResult = await (0, SystemSynthesis_1.synthesize)(enriched);
+    const systems = synthesisToMemorSystems(synthesisResult, graph);
+    return { systems, graph, synthesisResult };
+}
+/**
+ * Extract a 1–2 sentence description from a README file.
+ * Skips headings, badges, install instructions, and code blocks.
+ */
+function extractReadmeExcerpt(raw) {
+    const lines = raw.split("\n");
+    let inCodeBlock = false;
+    const candidates = [];
+    let h1Title = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        // Capture first H1 as fallback domain label
+        if (!h1Title && /^#\s+\S/.test(trimmed)) {
+            h1Title = trimmed.replace(/^#+\s*/, "").trim();
+        }
+        // Skip headings, badges, empty lines, HTML tags, install/usage sections
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("#"))
+            continue;
+        if (trimmed.startsWith("![") || trimmed.startsWith("[!["))
+            continue;
+        if (trimmed.startsWith("<"))
+            continue;
+        if (trimmed.startsWith("|"))
+            continue; // tables
+        if (/^(npm install|yarn add|pnpm add|npx |bun add)/i.test(trimmed))
+            continue;
+        if (/^(install|usage|getting started|quick start|table of contents|license)/i.test(trimmed))
+            continue;
+        // Require at least 30 chars and a letter, skip lines that look like code
+        if (trimmed.length < 30)
+            continue;
+        if (/^[`$>]/.test(trimmed))
+            continue;
+        if (/^\s*(import|require|const |let |var |export )/i.test(trimmed))
+            continue;
+        candidates.push(trimmed);
+        if (candidates.length >= 3)
+            break;
+    }
+    // Fall back to the H1 title if no prose was found
+    if (candidates.length === 0)
+        return h1Title;
+    // Take first 1-2 candidates, join, and truncate to 200 chars
+    let result = candidates.slice(0, 2).join(" ").trim();
+    // Clean up markdown links [text](url) → text
+    result = result.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Clean up bold/italic
+    result = result.replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1");
+    // Truncate
+    if (result.length > 220) {
+        result = result.slice(0, 217) + "...";
+    }
+    return result.length >= 30 ? result : null;
+}
+/**
+ * After connections are built, promote the system with the most incoming
+ * connections to primary/center if it clearly dominates the graph.
+ * Uses a composite score: incoming weight + outgoing weight + extends-target bonus.
+ */
+function promoteConnectionHub(systems, repoName) {
+    if (systems.length < 3)
+        return;
+    const hasCenter = systems.some((s) => s.isRepoCenter);
+    if (hasCenter)
+        return;
+    function hubScore(s) {
+        const inc = s.connections?.incoming ?? [];
+        const out = s.connections?.outgoing ?? [];
+        let score = inc.length * 2 + out.length;
+        // Systems that others extend are more architecturally central
+        const extendsCount = inc.filter((c) => c.relation === "used-by" &&
+            systems.find((x) => x.id === c.targetSystemId)?.connections?.outgoing
+                ?.some((o) => o.targetSystemId === s.id && o.relation === "extends")).length;
+        score += extendsCount * 3;
+        return score;
+    }
+    const scored = systems.map((s) => ({ sys: s, score: hubScore(s) }));
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    const second = scored[1];
+    if (best.score >= 8 && best.score > second.score * 1.3) {
+        best.sys.isRepoCenter = true;
+        best.sys.systemTier = "primary";
+        best.sys.importanceScore = Math.max(best.sys.importanceScore, 0.9);
+        if (!best.sys.systemRoleHint || best.sys.systemRoleHint === "unknown") {
+            const rnFlat = repoName.toLowerCase().replace(/[^a-z0-9]/g, "");
+            const nFlat = best.sys.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+            if (nFlat === rnFlat || nFlat.includes(rnFlat) || rnFlat.includes(nFlat)) {
+                best.sys.systemRoleHint = "framework-core-package";
+            }
+        }
+    }
+}
+/**
+ * After repo-level mode detection, selectively promote the most important
+ * packages to primary tier for framework-core and library-tooling repos.
+ * Also enriches descriptions for promoted packages. Mutates in place.
+ */
+function promoteForRepoMode(systems, repoMode, repoName) {
+    const rnLower = repoName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const FRAMEWORK_CORE_NAMES = /^(core|common|runtime|scheduler|compiler|reconciler|server|dom)$/i;
+    if (repoMode === "framework-core") {
+        let promoted = false;
+        for (const s of systems) {
+            if (s.type === "support-system")
+                continue;
+            const n = s.name.toLowerCase();
+            const nFlat = n.replace(/[^a-z0-9]/g, "");
+            if (FRAMEWORK_CORE_NAMES.test(n) ||
+                nFlat === rnLower ||
+                nFlat === `${rnLower}dom` ||
+                nFlat === `${rnLower}server` ||
+                nFlat === `${rnLower}reconciler`) {
+                s.systemTier = "primary";
+                s.importanceScore = Math.max(s.importanceScore, 0.86);
+                promoted = true;
+            }
+        }
+        // Single-package framework: promote the one real package
+        if (!promoted) {
+            const realPkgs = systems.filter((s) => s.type !== "support-system");
+            if (realPkgs.length === 1) {
+                realPkgs[0].systemTier = "primary";
+                realPkgs[0].importanceScore = Math.max(realPkgs[0].importanceScore, 0.9);
+                realPkgs[0].isRepoCenter = true;
+            }
+        }
+    }
+    if (repoMode === "library-tooling") {
+        let best = null;
+        for (const s of systems) {
+            const nFlat = s.name.toLowerCase().replace(/[^a-z0-9]/g, "");
+            if (nFlat === rnLower || nFlat.includes(rnLower) || rnLower.includes(nFlat)) {
+                if (!best || s.blocks.length > best.blocks.length)
+                    best = s;
+            }
+        }
+        if (!best && systems.length) {
+            best = systems.reduce((a, b) => b.blocks.length > a.blocks.length ? b : a);
+        }
+        if (best) {
+            best.systemTier = "primary";
+            best.importanceScore = Math.max(best.importanceScore, 0.9);
+            best.description = `This is the primary library package in this repository. It is consumed by applications and other packages rather than run directly.`;
+        }
+    }
+    if (repoMode === "product-web-app") {
+        // For single-app web repos, promote the main app as the center
+        const mainApp = systems.find((s) => s.type === "web-app");
+        if (mainApp) {
+            mainApp.systemTier = "primary";
+            mainApp.importanceScore = Math.max(mainApp.importanceScore, 0.9);
+            mainApp.isRepoCenter = true;
+        }
+    }
+    if (repoMode === "product-domain-machine") {
+        // Systems under packages/ can't get primary tier from assignSystemTier, but in a
+        // product-domain-machine monorepo they absolutely should be primary if they're runnable apps.
+        const primaries = systems.filter((s) => s.systemTier === "primary");
+        if (primaries.length === 0) {
+            const RUNNABLE_TYPES = new Set(["web-app", "api-service", "worker", "docs-site"]);
+            let promoted = false;
+            for (const s of systems) {
+                if (s.type === "support-system")
+                    continue;
+                if (RUNNABLE_TYPES.has(s.type)) {
+                    s.systemTier = "primary";
+                    s.importanceScore = Math.max(s.importanceScore, 0.88);
+                    promoted = true;
+                }
+            }
+            // If nothing runnable found, promote highest-importance systems
+            if (!promoted) {
+                const top = [...systems]
+                    .filter((s) => s.type !== "support-system")
+                    .sort((a, b) => b.importanceScore - a.importanceScore)
+                    .slice(0, 2);
+                for (const s of top) {
+                    s.systemTier = "primary";
+                    s.importanceScore = Math.max(s.importanceScore, 0.85);
+                }
+            }
+        }
+    }
+    if (repoMode === "workflow-platform") {
+        for (const s of systems) {
+            const n = s.name.toLowerCase();
+            if (/-(core|server|scheduler|executor)$/.test(n) ||
+                n === "core" ||
+                n === rnLower) {
+                s.systemTier = "primary";
+                s.importanceScore = Math.max(s.importanceScore, 0.88);
+                s.description = `Core platform module \`${s.name}\` — a foundational component of this workflow or orchestration system.`;
+            }
+        }
+    }
+}
+//# sourceMappingURL=analyzeRepo.js.map