memor-code-cli 0.2.0

package/dist/graph/buildLLMPayload.js

@@ -0,0 +1,715 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransportScaffold = isTransportScaffold;
+exports.isDocPage = isDocPage;
+exports.classifyArchetype = classifyArchetype;
+exports.buildLLMPayloadWithMeta = buildLLMPayloadWithMeta;
+exports.buildLLMPayload = buildLLMPayload;
+exports.estimateTokens = estimateTokens;
+exports.promoteFamilies = promoteFamilies;
+exports.buildAmbiguousPayload = buildAmbiguousPayload;
+const MAX_CLUSTERS = 50;
+const MAX_EDGES = 20;
+const MAX_EXPORTS_PER_CLUSTER = 8;
+const MAX_PACKAGE_GUARANTEE = 10; // Layer 3: cap on L1 package coverage additions
+const TOKEN_BUDGET = 2500; // Layer 2: cluster-array budget (~4500 total with meta/edges overhead)
+// ── Filtering ─────────────────────────────────────────────────────────────
+const NOISE_TOP_DIRS = new Set([
+    "examples", "example", "demo", "demos", "playground", "playgrounds",
+    "bench", "benchmark", "benchmarks", "fixtures", "scripts", "tools",
+    "hack", "spike", "sandbox", "test", "tests", "spec", "specs",
+    "__tests__", "__mocks__", "e2e", "cypress", "playwright",
+    "archived", "archive", "old", "deprecated", "legacy", "unused",
+]);
+// ── Transport scaffold detection ──────────────────────────────────────────
+// Parameterised route handlers ([id].ts, [teamId].ts) are filesystem artifacts —
+// they are not systems. They get filtered and their routes summarised as families.
+const DOC_DIRS = new Set(["docs", "documentation", "doc", "website", "www", "storybook-static"]);
+function isTransportScaffold(n) {
+    if (n.kind !== "cluster" && n.kind !== "package")
+        return false;
+    // [param] in path = parameterised route directory — a filesystem artifact, never a system.
+    // Universal across Next.js / SvelteKit / Remix / Astro / Nuxt.
+    // We drop the inDegree requirement: barrel imports (inDegree=1) don't make it a real system.
+    if (n.id.includes("[") && n.id.includes("]") && n.routes.length > 0 && n.models.length === 0)
+        return true;
+    return false;
+}
+function isDocPage(n) {
+    if (n.kind !== "cluster" && n.kind !== "package")
+        return false;
+    const parts = n.id.split("/");
+    // docs/pages/... or website/pages/... — framework routing inside a doc site
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (DOC_DIRS.has(parts[i]) && (parts[i + 1] === "pages" || parts[i + 1] === "src"))
+            return true;
+    }
+    return false;
+}
+function isNoiseNode(n) {
+    // L1-declared infra/app/queue/etc. nodes are never noise — explicitly declared
+    if (n.kind !== "cluster" && n.kind !== "package")
+        return false;
+    // Transport scaffolding must be checked before the route guard below
+    if (isTransportScaffold(n))
+        return true;
+    // Documentation site pages masquerading as routes
+    if (isDocPage(n))
+        return true;
+    // Clusters that own routes or models are NEVER noise — orientation anchors
+    if (n.routes.length > 0 || n.models.length > 0)
+        return false;
+    // Test-only clusters with no incoming edges
+    if (n.hasTests && n.inDegree === 0)
+        return true;
+    // Empty clusters
+    if (n.fileCount === 0)
+        return true;
+    // Zero-connection clusters — barrel stubs or dead code
+    if (n.inDegree === 0 && n.outDegree === 0)
+        return true;
+    // Example/demo/archived directories (case-insensitive)
+    const topDir = n.id.split("/")[0].toLowerCase();
+    if (NOISE_TOP_DIRS.has(topDir))
+        return true;
+    // Micro-clusters: single file, low connectivity, not shared
+    if (n.fileCount === 1 && n.inDegree <= 1 && n.outDegree <= 2 && !n.isShared)
+        return true;
+    return false;
+}
+// ── Layer 1: Sibling Collapse ──────────────────────────────────────────────
+// Merge structurally identical sibling clusters pre-selection to prevent slot flooding.
+// Only collapses when structure matches AND no semantic boundary signals differ.
+// Example: /packages/email + /packages/pdf + /packages/sms collapse into /packages
+// when they look identical. But /billing + /bookings do NOT collapse (different routes).
+function getParentPath(id) {
+    const parts = id.split("/");
+    return parts.length > 1 ? parts.slice(0, -1).join("/") : "__root__";
+}
+function routeRoot(routes) {
+    if (routes.length === 0)
+        return null;
+    return routes[0].replace(/^\//, "").split("/")[0] || null;
+}
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const v of a)
+        if (!b.has(v))
+            return false;
+    return true;
+}
+// Returns true if siblings are structurally similar enough to consider collapsing.
+function structuralGate(siblings) {
+    if (siblings.length < 3)
+        return false;
+    const fileCounts = siblings.map((n) => n.fileCount);
+    const maxFC = Math.max(...fileCounts);
+    const minFC = Math.min(...fileCounts);
+    if (maxFC > minFC * 2 + 1)
+        return false; // file counts vary too much
+    const routeCounts = siblings.map((n) => n.routes.length);
+    if (Math.max(...routeCounts) - Math.min(...routeCounts) > 1)
+        return false;
+    const shape = (n) => `${n.hasTests}-${n.hasTypes}-${n.hasConfig}`;
+    if (new Set(siblings.map(shape)).size > 1)
+        return false; // different signal shapes
+    return true;
+}
+// Returns true if collapse should be VETOED — siblings cross semantic boundaries.
+function semanticVeto(siblings) {
+    // 1. Different env var usage — different runtime configs = different systems
+    const firstEnv = new Set(siblings[0].envConsumes);
+    for (let i = 1; i < siblings.length; i++) {
+        if (!setsEqual(firstEnv, new Set(siblings[i].envConsumes)))
+            return true;
+    }
+    // 2. Different ORM usage — different DB access patterns
+    const firstOrm = new Set(siblings[0].ormUses);
+    for (let i = 1; i < siblings.length; i++) {
+        if (!setsEqual(firstOrm, new Set(siblings[i].ormUses)))
+            return true;
+    }
+    // 3. Non-empty model sets that differ — different domain boundaries
+    if (siblings.some((n) => n.models.length > 0)) {
+        const firstModels = new Set(siblings[0].models);
+        for (let i = 1; i < siblings.length; i++) {
+            if (!setsEqual(firstModels, new Set(siblings[i].models)))
+                return true;
+        }
+    }
+    // 4. Mixed entry-point status — entry points are structurally distinct
+    if (new Set(siblings.map((n) => n.isEntryPoint)).size > 1)
+        return true;
+    // 5. Different route roots (when any sibling is route-bearing — orientation anchor)
+    const withRoutes = siblings.filter((n) => n.routes.length > 0);
+    if (withRoutes.length > 0) {
+        const roots = new Set(withRoutes.map((n) => routeRoot(n.routes)));
+        if (roots.size > 1)
+            return true;
+    }
+    return false;
+}
+function collapseGroup(siblings, parentId) {
+    return {
+        id: parentId,
+        name: parentId.split("/").pop() ?? parentId,
+        kind: "cluster",
+        packageId: siblings[0]?.packageId,
+        fileCount: siblings.reduce((s, n) => s + n.fileCount, 0),
+        topExports: [...new Set(siblings.flatMap((n) => n.topExports))].slice(0, 20),
+        centrality: Math.max(...siblings.map((n) => n.centrality)),
+        inDegree: Math.max(...siblings.map((n) => n.inDegree)),
+        outDegree: Math.max(...siblings.map((n) => n.outDegree)),
+        isEntryPoint: siblings[0]?.isEntryPoint ?? false,
+        isShared: siblings.some((n) => n.isShared),
+        routes: [...new Set(siblings.flatMap((n) => n.routes))],
+        models: [...new Set(siblings.flatMap((n) => n.models))],
+        hasTests: siblings.some((n) => n.hasTests),
+        hasTypes: siblings.some((n) => n.hasTypes),
+        hasConfig: siblings.some((n) => n.hasConfig),
+        envConsumes: [...new Set(siblings.flatMap((n) => n.envConsumes))],
+        ormUses: [...new Set(siblings.flatMap((n) => n.ormUses))],
+    };
+}
+function applySiblingCollapse(nodes) {
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const byParent = new Map();
+    for (const n of nodes) {
+        const parent = getParentPath(n.id);
+        if (parent === "__root__")
+            continue;
+        if (nodeIds.has(parent))
+            continue; // parent is a first-class node, never collapse into it
+        if (!byParent.has(parent))
+            byParent.set(parent, []);
+        byParent.get(parent).push(n);
+    }
+    const collapseMap = new Map(); // child id → merged parent id
+    const collapsedChildIds = new Set();
+    const syntheticNodes = [];
+    for (const [parentId, siblings] of byParent) {
+        if (!structuralGate(siblings))
+            continue;
+        if (semanticVeto(siblings))
+            continue;
+        syntheticNodes.push(collapseGroup(siblings, parentId));
+        for (const s of siblings) {
+            collapseMap.set(s.id, parentId);
+            collapsedChildIds.add(s.id);
+        }
+    }
+    const surviving = nodes.filter((n) => !collapsedChildIds.has(n.id));
+    surviving.push(...syntheticNodes);
+    return { nodes: surviving, collapseMap };
+}
+function classifyArchetype(n) {
+    const name = n.name.toLowerCase();
+    const id = n.id.toLowerCase();
+    // ── Data layer ─────────────────────────────────────────────────────────────
+    // Prisma cluster (by name or ORM signal + models)
+    if (id.includes("prisma") && (n.ormUses.length > 0 || n.models.length > 0))
+        return "data-layer";
+    // Any ORM with significant models
+    if (n.ormUses.length > 0 && n.models.length > 2)
+        return "data-layer";
+    // TypeORM / Mongoose / Sequelize / Drizzle / Knex — DB-access layer regardless of models
+    if (n.ormUses.some((o) => /typeorm|mongoose|sequelize|drizzle|knex/i.test(o)))
+        return "data-layer";
+    // Non-ORM DB clients: Supabase, Firebase, Neon, PlanetScale, Turso, libSQL.
+    // Guard: the cluster name or id must also suggest it IS the data layer, not just
+    // a consumer of it. A generic "lib" that initialises supabase is not a data layer.
+    const DB_LAYER_NAME = /database|^db$|^data$|supabase|firebase|neon|planetscale|mongo|postgres|repository|repositories|repo|store|storage/i;
+    if (n.ormUses.some((o) => /supabase|firebase|firestore|neon|planetscale|turso|libsql/i.test(o)) &&
+        (DB_LAYER_NAME.test(n.name) || DB_LAYER_NAME.test(n.id)))
+        return "data-layer";
+    // Env-pattern fallback: DATABASE_URL etc. signal a data layer only when the cluster
+    // has a database-related name AND at least one model — prevents API routes that merely
+    // read SUPABASE_URL from being mis-classified.
+    const DB_ENV = /^(DATABASE_URL|MONGO_URI|MONGODB_URI|SUPABASE_URL|FIREBASE_URL|NEON_URL|TURSO_URL|PLANETSCALE_URL)$/i;
+    if (n.envConsumes.some((e) => DB_ENV.test(e)) &&
+        (DB_LAYER_NAME.test(n.name) || n.models.length >= 1) &&
+        n.inDegree >= 1)
+        return "data-layer";
+    // ── DB migrations / seeds ──────────────────────────────────────────────────
+    if ((/migrations?$|seeders?$|seeds?$/.test(name) || id.includes("/migration")) &&
+        n.routes.length === 0)
+        return "db-migration";
+    // ── Cache client ───────────────────────────────────────────────────────────
+    if (n.envConsumes.some((e) => /redis/i.test(e)) || n.ormUses.some((o) => /redis/i.test(o)))
+        return "cache-client";
+    // ── Auth / session ─────────────────────────────────────────────────────────
+    if (/auth|jwt|passport|session/.test(name) &&
+        n.envConsumes.some((e) => /jwt|secret|auth|token|password/i.test(e)))
+        return "auth-service";
+    // ── Queue / worker ─────────────────────────────────────────────────────────
+    if (/queue|worker|bull|job|cron/.test(name) && n.envConsumes.length > 0)
+        return "queue-worker";
+    // ── Email / notification service ───────────────────────────────────────────
+    if (/mailer?|mailing|smtp|sendgrid|notification|notif$|messaging$/.test(name) &&
+        n.routes.length === 0 && n.models.length < 2 &&
+        n.envConsumes.length > 0)
+        return "email-service";
+    // ── Middleware / cross-cutting concerns ────────────────────────────────────
+    if (/^middleware$|interceptors?$|guards?$|pipes?$|exception.?filters?$|decorators?$/.test(name) &&
+        n.routes.length === 0 && n.models.length === 0 &&
+        n.fileCount < 30)
+        return "middleware";
+    // ── Pure type definitions ──────────────────────────────────────────────────
+    // If hasTypes is set and there are zero runtime signals, this cluster is
+    // unambiguously a type-definitions package regardless of name.
+    if (n.hasTypes && n.routes.length === 0 && n.models.length === 0 &&
+        n.ormUses.length === 0 && n.envConsumes.length === 0 && !n.hasTests &&
+        n.fileCount < 25)
+        return "type-defs";
+    // Name-driven fallback for larger type packages (DTOs, interfaces, schemas)
+    if (n.routes.length === 0 && n.models.length === 0 &&
+        n.ormUses.length === 0 && n.envConsumes.length === 0 &&
+        /^types?$|^interfaces?$|^dtos?$|^schemas?$|^typings?$|^declarations?$|^contracts?$|^enums?$/.test(name))
+        return "type-defs";
+    // Path-driven: cluster is a sub-directory of a dto/types/interfaces/schemas folder.
+    // Covers "jira" in server/api/v1/dto/jira — name alone won't match but parent path does.
+    const DTO_PATH_SEGMENTS = new Set(["dto", "dtos", "types", "type", "interfaces", "schemas", "typings", "contracts"]);
+    const pathSegs = n.id.split("/");
+    if (pathSegs.some((seg) => DTO_PATH_SEGMENTS.has(seg.toLowerCase())) &&
+        n.routes.length === 0 && n.models.length === 0 &&
+        n.ormUses.length === 0 && n.envConsumes.length === 0)
+        return "type-defs";
+    // ── Config-only package ────────────────────────────────────────────────────
+    // Small clusters with config signal and no runtime signals are unambiguous.
+    if (n.hasConfig && n.routes.length === 0 && n.models.length === 0 &&
+        n.ormUses.length === 0 && n.envConsumes.length === 0 && n.fileCount < 8)
+        return "config";
+    // Name-driven config (larger config packages like eslint, prettier, tsconfig)
+    if (n.routes.length === 0 && n.models.length === 0 && n.fileCount < 15 &&
+        /config|tsconfig|eslint|prettier|constants?$|settings?$|^env$|environment/.test(name))
+        return "config";
+    // ── Shared utility library ─────────────────────────────────────────────────
+    // Universal utility name catch-all — these folder names are unambiguous
+    const UTIL_NAMES = new Set([
+        "utils", "util", "helpers", "helper", "common", "lib", "tools", "toolkit",
+        "shared", "core-utils", "utilities",
+    ]);
+    if (UTIL_NAMES.has(name) &&
+        n.routes.length === 0 && n.models.length === 0 &&
+        n.ormUses.length === 0 && n.envConsumes.length === 0)
+        return "shared-lib";
+    // React hooks folder — unambiguously support layer
+    if ((name === "hooks" || n.name.startsWith("use") || name.endsWith("-hooks")) &&
+        n.routes.length === 0 && n.models.length === 0 && n.isShared)
+        return "shared-lib";
+    // Heavily imported with no business signals
+    if (n.isShared && n.inDegree >= 3 && n.routes.length === 0 && n.models.length === 0)
+        return "shared-lib";
+    // ── App entry ──────────────────────────────────────────────────────────────
+    if (n.isEntryPoint && n.fileCount <= 5 && n.outDegree >= 4 && n.routes.length === 0)
+        return "app-entry";
+    // ── Public web page ────────────────────────────────────────────────────────
+    // Next.js app-router page clusters: public-facing routes (not /api/, not /admin/).
+    // These are orientation anchors the LLM routinely overlooks because they have
+    // minimal signal (1 file, 1 route, no models/ORM) — classify deterministically.
+    if (n.routes.length > 0 &&
+        n.routes.every((r) => !r.startsWith("/api/") && !r.startsWith("/admin")) &&
+        n.models.length === 0 && n.ormUses.length === 0 &&
+        !n.id.includes("[") // not a transport scaffold
+    )
+        return "web-page";
+    return null;
+}
+// ── Layer 2: Token Budget ─────────────────────────────────────────────────
+// Drop lowest-signal clusters when payload exceeds budget.
+// Runtime-edge clusters are always preserved (they carry dynamic architecture facts).
+function enforceTokenBudget(clusters, runtimeEdgeClusterIds) {
+    const budget = TOKEN_BUDGET * 4; // chars (~4 chars per token)
+    if (JSON.stringify(clusters).length <= budget)
+        return clusters;
+    const scored = clusters.map((c) => ({
+        c,
+        score: c.routes.length * 5 +
+            c.models.length * 3 +
+            (c.uses_orm?.length ?? 0) * 4 +
+            (c.env_consumes?.length ?? 0) * 2 +
+            c.files * 0.5 +
+            c.centrality * 10 +
+            (c.is_entry ? 3 : 0) +
+            (runtimeEdgeClusterIds.has(c.id) ? 1000 : 0), // never drop runtime-edge clusters
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const kept = [];
+    let chars = 0;
+    for (const { c } of scored) {
+        const len = JSON.stringify(c).length;
+        // Always keep the first item; skip others that would bust the budget
+        if (chars + len > budget && kept.length > 0)
+            continue;
+        kept.push(c);
+        chars += len;
+    }
+    return kept;
+}
+function buildLLMPayloadWithMeta(graph) {
+    // Split nodes: structural clusters vs declared infra nodes
+    const clusterNodes = graph.nodes.filter((n) => n.kind === "cluster" || n.kind === "package");
+    const infraNodes = graph.nodes.filter((n) => n.kind !== "cluster" && n.kind !== "package");
+    // ── Transport scaffold extraction ────────────────────────────────────────
+    // Collect route families from transport clusters before they're discarded,
+    // so the LLM still gets route orientation context in a compact form.
+    const transportNodes = clusterNodes.filter((n) => isTransportScaffold(n) || isDocPage(n));
+    const routeFamilyMap = new Map();
+    for (const n of transportNodes) {
+        for (const route of n.routes) {
+            const seg = route.replace(/^\//, "").split("/")[0];
+            const family = seg ? `/${seg}` : "/";
+            routeFamilyMap.set(family, (routeFamilyMap.get(family) ?? 0) + 1);
+        }
+    }
+    const routeFamilies = [...routeFamilyMap.entries()]
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([family, count]) => ({ family: family + "/*", count }));
+    // Filter noisy cluster nodes
+    const filtered = clusterNodes.filter((n) => !isNoiseNode(n));
+    // ── Layer 1: Sibling Collapse ────────────────────────────────────────────
+    const { nodes: collapsed, collapseMap } = applySiblingCollapse(filtered);
+    const resolve = (id) => collapseMap.get(id) ?? id;
+    // ── Orientation-driven selection ─────────────────────────────────────────
+    const ROUTE_SLOTS = Math.floor(MAX_CLUSTERS * 0.45);
+    const MODEL_SLOTS = Math.floor(MAX_CLUSTERS * 0.10);
+    const INFRA_SLOTS = MAX_CLUSTERS - ROUTE_SLOTS - MODEL_SLOTS;
+    const withRoutes = collapsed
+        .filter((n) => n.routes.length > 0)
+        .sort((a, b) => (b.routes.length + b.fileCount) - (a.routes.length + a.fileCount))
+        .slice(0, ROUTE_SLOTS);
+    const orientationIds = new Set(withRoutes.map((n) => n.id));
+    const withModels = collapsed
+        .filter((n) => n.models.length > 0 && !orientationIds.has(n.id))
+        .sort((a, b) => b.models.length - a.models.length)
+        .slice(0, MODEL_SLOTS);
+    withModels.forEach((n) => orientationIds.add(n.id));
+    const orientationNodes = [...withRoutes, ...withModels];
+    // Sort rest by centrality so collapsed synthetic nodes rank fairly
+    const rest = collapsed
+        .filter((n) => !orientationIds.has(n.id))
+        .sort((a, b) => b.centrality - a.centrality);
+    const CENTRALITY_SLOTS = Math.floor(INFRA_SLOTS * 0.5);
+    const FILECOUNT_SLOTS = Math.floor(INFRA_SLOTS * 0.35);
+    const ENTRY_SLOTS = INFRA_SLOTS - CENTRALITY_SLOTS - FILECOUNT_SLOTS;
+    const byCentrality = rest.slice(0, CENTRALITY_SLOTS);
+    const centralityIds = new Set(byCentrality.map((n) => n.id));
+    const afterCentrality = rest.filter((n) => !centralityIds.has(n.id));
+    const byFileCount = afterCentrality
+        .sort((a, b) => b.fileCount - a.fileCount)
+        .slice(0, FILECOUNT_SLOTS);
+    const fileCountIds = new Set(byFileCount.map((n) => n.id));
+    const byEntry = afterCentrality
+        .filter((n) => !fileCountIds.has(n.id) && n.isEntryPoint && n.outDegree >= 2)
+        .sort((a, b) => b.outDegree - a.outDegree)
+        .slice(0, ENTRY_SLOTS);
+    const selected = [...orientationNodes, ...byCentrality, ...byFileCount, ...byEntry];
+    // ── Layer 3: L1 package coverage guarantee (capped) ──────────────────────
+    const coveredPackageIds = new Set(selected.map((n) => n.packageId).filter((id) => !!id));
+    const allPackageIds = new Set(collapsed.map((n) => n.packageId).filter((id) => !!id));
+    const selectedIds = new Set(selected.map((n) => n.id));
+    let packageGuaranteeCount = 0;
+    for (const pkgId of allPackageIds) {
+        if (packageGuaranteeCount >= MAX_PACKAGE_GUARANTEE)
+            break;
+        if (coveredPackageIds.has(pkgId))
+            continue;
+        const best = collapsed
+            .filter((n) => n.packageId === pkgId && !selectedIds.has(n.id))
+            .sort((a, b) => (b.routes.length * 5 + b.models.length * 3 + b.fileCount + b.centrality * 10) -
+            (a.routes.length * 5 + a.models.length * 3 + a.fileCount + a.centrality * 10))[0];
+        if (best) {
+            selected.push(best);
+            selectedIds.add(best.id);
+            coveredPackageIds.add(pkgId);
+            packageGuaranteeCount++;
+        }
+    }
+    // Always include declared infra nodes (they are architecture facts, not noise)
+    // Cap at 10 to avoid flooding the payload on large compose files
+    const selectedInfra = infraNodes
+        .filter((n) => graph.edges.some((e) => (e.to === n.id || e.from === n.id) &&
+        (selectedIds.has(resolve(e.from)) || selectedIds.has(resolve(e.to)))))
+        .slice(0, 10);
+    selectedInfra.forEach((n) => selectedIds.add(n.id));
+    const allSelected = [...selected, ...selectedInfra];
+    const includedIds = new Set(allSelected.map((n) => n.id));
+    // ── Import edges (with collapse remapping) ────────────────────────────────
+    const importEdges = graph.edges
+        .filter((e) => e.kind === "import")
+        .map((e) => ({ ...e, from: resolve(e.from), to: resolve(e.to) }))
+        .filter((e) => e.from !== e.to && includedIds.has(e.from) && includedIds.has(e.to))
+        .sort((a, b) => b.weight - a.weight)
+        .slice(0, MAX_EDGES);
+    // Pre-build adjacency for compact cluster representation
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const id of includedIds) {
+        outgoing.set(id, []);
+        incoming.set(id, []);
+    }
+    for (const e of importEdges) {
+        outgoing.get(e.from)?.push(e.to);
+        incoming.get(e.to)?.push(e.from);
+    }
+    // ── Runtime edges ─────────────────────────────────────────────────────────
+    const runtimeEdges = graph.edges
+        .filter((e) => e.kind === "runtime" && (includedIds.has(e.from) || includedIds.has(e.to)));
+    const runtimeEdgeClusterIds = new Set(runtimeEdges.flatMap((e) => [e.from, e.to]));
+    // ── Build compact clusters ────────────────────────────────────────────────
+    const compactClusters = allSelected.map((n) => {
+        const signals = {};
+        if (n.hasTests)
+            signals.tests = true;
+        if (n.hasTypes)
+            signals.types = true;
+        if (n.hasConfig)
+            signals.config = true;
+        // Runtime calls from this node to other nodes (HTTP, tRPC, proxy)
+        const runtimeCalls = [...new Set(runtimeEdges
+                .filter((e) => e.from === n.id &&
+                (e.type === "HTTP_CALL" || e.type === "TRPC_CALL" || e.type === "PROXY_ROUTE"))
+                .map((e) => e.to))];
+        const compact = {
+            id: n.id,
+            name: n.name,
+            files: n.fileCount,
+            exports: n.topExports.slice(0, MAX_EXPORTS_PER_CLUSTER),
+            imports_from: outgoing.get(n.id) ?? [],
+            imported_by: incoming.get(n.id) ?? [],
+            is_entry: n.isEntryPoint,
+            is_shared: n.isShared,
+            centrality: n.centrality,
+            routes: n.routes.slice(0, 6),
+            models: n.models.slice(0, 10),
+            signals,
+        };
+        if (n.kind !== "cluster" && n.kind !== "package")
+            compact.kind = n.kind;
+        const archetype = classifyArchetype(n);
+        if (archetype)
+            compact.archetype = archetype;
+        if (n.envConsumes.length > 0)
+            compact.env_consumes = n.envConsumes;
+        if (n.ormUses.length > 0)
+            compact.uses_orm = n.ormUses;
+        if (runtimeCalls.length > 0)
+            compact.runtime_calls = runtimeCalls;
+        return compact;
+    });
+    // ── Layer 2: Token Budget ─────────────────────────────────────────────────
+    const budgetedClusters = enforceTokenBudget(compactClusters, runtimeEdgeClusterIds);
+    const budgetedIds = new Set(budgetedClusters.map((c) => c.id));
+    const topEdges = importEdges
+        .filter((e) => budgetedIds.has(e.from) && budgetedIds.has(e.to))
+        .map((e) => ({
+        from: e.from,
+        to: e.to,
+        weight: e.weight,
+        symbols: e.symbols.slice(0, 3),
+    }));
+    const meta = {
+        repo_name: graph.meta.repoName,
+        total_files: graph.meta.totalFiles,
+        total_clusters: graph.meta.totalClusters,
+        frameworks: graph.meta.frameworks,
+        packages: graph.meta.packages,
+    };
+    if (graph.meta.readmeSummary)
+        meta.repo_purpose = graph.meta.readmeSummary;
+    if (graph.meta.repoStructure)
+        meta.repo_structure = graph.meta.repoStructure;
+    if (graph.meta.repoType)
+        meta.repo_type = graph.meta.repoType;
+    if (graph.meta.techStack?.length)
+        meta.tech_stack = graph.meta.techStack;
+    if (graph.meta.dataModels.length > 0)
+        meta.data_models = graph.meta.dataModels;
+    if (routeFamilies.length > 0)
+        meta.route_families = routeFamilies;
+    const payload = { meta, clusters: budgetedClusters, top_edges: topEdges };
+    // Include runtime edges that involve budgeted clusters
+    const compactRuntime = runtimeEdges
+        .filter((e) => budgetedIds.has(e.from) || budgetedIds.has(e.to))
+        .map((e) => ({
+        from: e.from,
+        to: e.to,
+        type: e.type ?? "runtime",
+        evidence: e.evidence ?? "",
+    }));
+    if (compactRuntime.length > 0)
+        payload.runtime_edges = compactRuntime;
+    const payloadStr = JSON.stringify(payload);
+    const tokens = estimateTokens(payloadStr);
+    // ── Compute metrics ───────────────────────────────────────────────────────
+    const routesTotal = clusterNodes.reduce((s, n) => s + n.routes.length, 0);
+    const routesRetained = budgetedClusters.reduce((s, c) => s + c.routes.length, 0);
+    const modelsTotal = clusterNodes.reduce((s, n) => s + n.models.length, 0);
+    const modelsRetained = budgetedClusters.reduce((s, c) => s + c.models.length, 0);
+    const ormClustersTotal = clusterNodes.filter((n) => n.ormUses.length > 0).length;
+    const ormClustersRetained = budgetedClusters.filter((c) => (c.uses_orm?.length ?? 0) > 0).length;
+    const hasSignal = (c) => c.routes.length > 0 || c.models.length > 0 ||
+        (c.uses_orm?.length ?? 0) > 0 || (c.env_consumes?.length ?? 0) > 0;
+    const semanticDensity = budgetedClusters.length === 0 ? 0
+        : budgetedClusters.filter(hasSignal).length / budgetedClusters.length;
+    const archetypeHits = budgetedClusters.filter((c) => c.archetype !== undefined).length;
+    const buildMeta = {
+        rawClusters: clusterNodes.length,
+        afterNoiseFilter: filtered.length,
+        afterSiblingCollapse: collapsed.length,
+        siblingsCollapsed: collapseMap.size,
+        transportFolded: transportNodes.length,
+        prebudgetClusters: compactClusters.length,
+        payloadClusters: budgetedClusters.length,
+        budgetDropped: compactClusters.length - budgetedClusters.length,
+        packageGuaranteeAdded: packageGuaranteeCount,
+        tokens,
+        routesTotal,
+        routesRetained,
+        modelsTotal,
+        modelsRetained,
+        ormClustersTotal,
+        ormClustersRetained,
+        semanticDensity,
+        signalRetentionRoutes: routesTotal === 0 ? 1 : routesRetained / routesTotal,
+        signalRetentionModels: modelsTotal === 0 ? 1 : modelsRetained / modelsTotal,
+        archetypeHits,
+        archetypeRate: budgetedClusters.length === 0 ? 0 : archetypeHits / budgetedClusters.length,
+    };
+    return { payload: payloadStr, meta: buildMeta };
+}
+function buildLLMPayload(graph) {
+    return buildLLMPayloadWithMeta(graph).payload;
+}
+function estimateTokens(payload) {
+    return Math.ceil(payload.length / 4);
+}
+// ── Family Promotion ─────────────────────────────────────────────────────────
+// When ≥ FAMILY_THRESHOLD siblings share a parent directory, replace them with
+// one merged cluster at the parent level. The LLM names the parent once instead
+// of naming each child separately. Repo-agnostic: works for any framework.
+const FAMILY_THRESHOLD = 3;
+function parentDir(id) {
+    const i = id.lastIndexOf("/");
+    return i > 0 ? id.slice(0, i) : "";
+}
+function promoteFamilies(clusters) {
+    const existingIds = new Set(clusters.map((c) => c.id));
+    const byParent = new Map();
+    for (const c of clusters) {
+        const p = parentDir(c.id);
+        if (!p)
+            continue;
+        if (!byParent.has(p))
+            byParent.set(p, []);
+        byParent.get(p).push(c);
+    }
+    const toRemove = new Set();
+    const toAdd = [];
+    const parentToChildren = new Map();
+    for (const [parent, children] of byParent) {
+        if (children.length < FAMILY_THRESHOLD)
+            continue;
+        const parentCluster = clusters.find((c) => c.id === parent);
+        if (parentCluster) {
+            // Parent already a cluster — absorb children's signals into it, remove children.
+            // Routes, models, exports, envs, orms are unioned in; parent keeps its own signals.
+            const allRoutes = [...new Set([...parentCluster.routes, ...children.flatMap((c) => c.routes)])];
+            const allModels = [...new Set([...parentCluster.models, ...children.flatMap((c) => c.models)])];
+            const allExports = [...new Set([...parentCluster.exports, ...children.flatMap((c) => c.exports)])].slice(0, 10);
+            const allEnvs = [...new Set([...(parentCluster.env_consumes ?? []), ...children.flatMap((c) => c.env_consumes ?? [])])];
+            const allOrms = [...new Set([...(parentCluster.uses_orm ?? []), ...children.flatMap((c) => c.uses_orm ?? [])])];
+            const allCalls = [...new Set([...(parentCluster.runtime_calls ?? []), ...children.flatMap((c) => c.runtime_calls ?? [])])];
+            parentCluster.routes = allRoutes;
+            parentCluster.models = allModels;
+            parentCluster.exports = allExports;
+            parentCluster.files += children.reduce((s, c) => s + c.files, 0);
+            parentCluster.centrality = Math.max(parentCluster.centrality, ...children.map((c) => c.centrality));
+            if (allEnvs.length)
+                parentCluster.env_consumes = allEnvs;
+            if (allOrms.length)
+                parentCluster.uses_orm = allOrms;
+            if (allCalls.length)
+                parentCluster.runtime_calls = allCalls;
+            for (const c of children)
+                toRemove.add(c.id);
+            parentToChildren.set(parent, children.map((c) => c.id));
+            continue;
+        }
+        const merged = {
+            id: parent,
+            name: parent.split("/").pop() ?? parent,
+            files: children.reduce((s, c) => s + c.files, 0),
+            exports: [...new Set(children.flatMap((c) => c.exports))].slice(0, 10),
+            imports_from: [...new Set(children.flatMap((c) => c.imports_from))],
+            imported_by: [...new Set(children.flatMap((c) => c.imported_by))],
+            is_entry: children.some((c) => c.is_entry),
+            is_shared: children.some((c) => c.is_shared),
+            centrality: Math.max(...children.map((c) => c.centrality)),
+            routes: [...new Set(children.flatMap((c) => c.routes))],
+            models: [...new Set(children.flatMap((c) => c.models))],
+            signals: {
+                tests: children.some((c) => c.signals.tests) ? true : undefined,
+                types: children.some((c) => c.signals.types) ? true : undefined,
+                config: children.some((c) => c.signals.config) ? true : undefined,
+            },
+        };
+        const envs = [...new Set(children.flatMap((c) => c.env_consumes ?? []))];
+        const orms = [...new Set(children.flatMap((c) => c.uses_orm ?? []))];
+        const calls = [...new Set(children.flatMap((c) => c.runtime_calls ?? []))];
+        if (envs.length)
+            merged.env_consumes = envs;
+        if (orms.length)
+            merged.uses_orm = orms;
+        if (calls.length)
+            merged.runtime_calls = calls;
+        for (const c of children)
+            toRemove.add(c.id);
+        toAdd.push(merged);
+        parentToChildren.set(parent, children.map((c) => c.id));
+    }
+    return {
+        clusters: [...clusters.filter((c) => !toRemove.has(c.id)), ...toAdd],
+        parentToChildren,
+    };
+}
+/**
+ * Split the full payload into deterministic (classified) and ambiguous clusters.
+ * Returns the ambiguous-only payload string for LLM + the deterministic clusters
+ * for pre-naming without an API call. Core of Phase 3.
+ * Also runs family promotion so sibling-heavy directories appear as one cluster.
+ */
+function buildAmbiguousPayload(graph) {
+    const { payload } = buildLLMPayloadWithMeta(graph);
+    const parsed = JSON.parse(payload);
+    const routeFamilies = parsed.meta.route_families ?? [];
+    const deterministicClusters = parsed.clusters.filter((c) => c.archetype !== undefined);
+    // Infra/synthetic nodes (kind set = not a real cluster) are architecture facts captured
+    // in uses_infra — they must NOT become named systems on the AM.
+    let ambiguousClusters = parsed.clusters.filter((c) => c.archetype === undefined && !c.kind);
+    // Family promotion: merge siblings → parent before sending to LLM
+    const { clusters: promoted, parentToChildren } = promoteFamilies(ambiguousClusters);
+    ambiguousClusters = promoted;
+    if (ambiguousClusters.length === 0) {
+        return { ambiguousPayloadStr: "", deterministicClusters, routeFamilies, parentToChildren };
+    }
+    const ambiguousIds = new Set(ambiguousClusters.map((c) => c.id));
+    const ambiguousPayload = {
+        meta: parsed.meta,
+        clusters: ambiguousClusters,
+        top_edges: (parsed.top_edges ?? []).filter((e) => ambiguousIds.has(e.from) && ambiguousIds.has(e.to)),
+        ...(parsed.runtime_edges
+            ? { runtime_edges: parsed.runtime_edges.filter((e) => ambiguousIds.has(e.from) || ambiguousIds.has(e.to)) }
+            : {}),
+    };
+    return {
+        ambiguousPayloadStr: JSON.stringify(ambiguousPayload),
+        deterministicClusters,
+        routeFamilies,
+        parentToChildren,
+    };
+}
+//# sourceMappingURL=buildLLMPayload.js.map