memor-code-cli 0.2.0

package/dist/amGeneration/buildFlowGraph.d.ts

@@ -0,0 +1,39 @@
+/**
+ * buildFlowGraph — 4-layer deterministic flow discovery pipeline.
+ *
+ * L1: Multi-framework entry point discovery (Next.js, NestJS, Express)
+ * L2: Cross-file call chain tracing — follows imports 4 hops deep
+ * L3: Step enrichment — maps files to AM systems, detects DB/external calls
+ * L4: Flow clustering — group by domain, deduplicate, rank by richness
+ *
+ * Zero LLM calls. Output feeds generateFlows for narration only.
+ */
+export type FlowStep = {
+    fn: string;
+    file: string;
+    systemId: string | null;
+    externalCalls: string[];
+    dbAccess: string[];
+    returnType: string;
+    isExternal: boolean;
+};
+export type FlowCandidate = {
+    id: string;
+    nameSeed: string;
+    method: string;
+    routePath: string;
+    entryFile: string;
+    steps: FlowStep[];
+    framework: "nextjs" | "nestjs" | "express" | "generic";
+};
+type EntryPoint = {
+    method: string;
+    routePath: string;
+    handlerFn: string;
+    absFile: string;
+    framework: FlowCandidate["framework"];
+};
+export declare function discoverEntryPoints(repoRoot: string): EntryPoint[];
+export declare function buildFlowGraph(repoRoot: string, am: any, onProgress?: (step: string) => void): Promise<FlowCandidate[]>;
+export {};
+//# sourceMappingURL=buildFlowGraph.d.ts.map

package/dist/amGeneration/buildFlowGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFlowGraph.d.ts","sourceRoot":"","sources":["../../src/amGeneration/buildFlowGraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAWH,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;CACxD,CAAC;AAIF,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;CACvC,CAAC;AAsTF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,EAAE,CAclE;AA2ND,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,GAAG,EACP,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAClC,OAAO,CAAC,aAAa,EAAE,CAAC,CA2C1B"}

package/dist/amGeneration/buildFlowGraph.js

@@ -0,0 +1,643 @@
+"use strict";
+/**
+ * buildFlowGraph — 4-layer deterministic flow discovery pipeline.
+ *
+ * L1: Multi-framework entry point discovery (Next.js, NestJS, Express)
+ * L2: Cross-file call chain tracing — follows imports 4 hops deep
+ * L3: Step enrichment — maps files to AM systems, detects DB/external calls
+ * L4: Flow clustering — group by domain, deduplicate, rank by richness
+ *
+ * Zero LLM calls. Output feeds generateFlows for narration only.
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverEntryPoints = discoverEntryPoints;
+exports.buildFlowGraph = buildFlowGraph;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const babelParser = __importStar(require("@babel/parser"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const buildDetailedFileXRay_1 = require("../analysis/buildDetailedFileXRay");
+// ── Shared helpers ────────────────────────────────────────────────────────────
+const HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+function walkDir(dir, pattern) {
+    const out = [];
+    if (!fs.existsSync(dir))
+        return out;
+    function walk(cur) {
+        let entries;
+        try {
+            entries = fs.readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith(".") || e.name === "node_modules" || e.name === "dist")
+                continue;
+            const full = path.join(cur, e.name);
+            if (e.isDirectory())
+                walk(full);
+            else if (pattern.test(e.name))
+                out.push(full);
+        }
+    }
+    walk(dir);
+    return out;
+}
+function resolveImport(source, fromAbs) {
+    // Skip npm packages
+    if (!source.startsWith(".") && !source.startsWith("/"))
+        return null;
+    const fromDir = path.dirname(fromAbs);
+    for (const suffix of ["", ".ts", ".tsx", "/index.ts", "/index.tsx", ".js", "/index.js"]) {
+        const abs = path.resolve(fromDir, source + suffix);
+        if (fs.existsSync(abs))
+            return abs;
+    }
+    return null;
+}
+function parseBabel(src) {
+    try {
+        return babelParser.parse(src, {
+            sourceType: "module",
+            plugins: ["typescript", "jsx", "decorators-legacy", "classProperties", "optionalChaining"],
+            errorRecovery: true,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function getDecoratorName(d) {
+    const e = d?.expression;
+    if (e?.type === "Identifier")
+        return e.name;
+    if (e?.type === "CallExpression") {
+        const c = e.callee;
+        if (c?.type === "Identifier")
+            return c.name;
+        if (c?.type === "MemberExpression")
+            return c.property?.name ?? "";
+    }
+    return "";
+}
+function getDecoratorArg(d) {
+    const args = d?.expression?.arguments;
+    if (!args?.length)
+        return "";
+    const a = args[0];
+    if (a?.type === "StringLiteral")
+        return a.value;
+    return "";
+}
+// ── L1: Entry point discovery ─────────────────────────────────────────────────
+function discoverNextJS(repoRoot) {
+    const entries = [];
+    const files = [
+        ...walkDir(repoRoot, /^route\.(ts|tsx|js|jsx)$/),
+        ...walkDir(path.join(repoRoot, "pages", "api"), /\.(ts|tsx|js|jsx)$/),
+    ].filter(f => !f.includes("node_modules"));
+    for (const absFile of files) {
+        let xray;
+        try {
+            xray = (0, buildDetailedFileXRay_1.buildDetailedFileXRay)(absFile, repoRoot);
+        }
+        catch {
+            continue;
+        }
+        const handlers = xray.functions.filter(f => HTTP_METHODS.has(f.name));
+        if (!handlers.length)
+            continue;
+        const rel = path.relative(repoRoot, absFile).replace(/\\/g, "/");
+        const routePath = ("/" + rel
+            .replace(/\.(ts|tsx|js|jsx)$/, "")
+            .replace(/\/route$/, "")
+            .replace(/^(app|pages)\//, "")
+            .replace(/\/\([^)]+\)/g, "")
+            .replace(/\/+/g, "/")).replace(/\/$/, "") || "/";
+        for (const h of handlers) {
+            entries.push({ method: h.name, routePath, handlerFn: h.name, absFile, framework: "nextjs" });
+        }
+    }
+    return entries;
+}
+function discoverNestJS(repoRoot) {
+    const entries = [];
+    const tsFiles = walkDir(repoRoot, /\.(ts|tsx)$/).filter(f => !f.includes("node_modules") && !f.includes(".spec.") && !f.includes(".test."));
+    for (const absFile of tsFiles) {
+        let src;
+        try {
+            src = fs.readFileSync(absFile, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!src.includes("@Controller"))
+            continue;
+        const ast = parseBabel(src);
+        if (!ast)
+            continue;
+        try {
+            (0, traverse_1.default)(ast, {
+                ClassDeclaration(np) {
+                    const cls = np.node;
+                    const ctrlDec = (cls.decorators ?? []).find((d) => getDecoratorName(d) === "Controller");
+                    if (!ctrlDec)
+                        return;
+                    const base = ("/" + getDecoratorArg(ctrlDec).replace(/^\//, "")).replace(/\/$/, "") || "/";
+                    for (const member of cls.body?.body ?? []) {
+                        const methodName = member.key?.name;
+                        if (!methodName)
+                            continue;
+                        for (const dec of member.decorators ?? []) {
+                            const verb = getDecoratorName(dec).toUpperCase();
+                            if (!HTTP_METHODS.has(verb))
+                                continue;
+                            const sub = getDecoratorArg(dec).replace(/^\//, "");
+                            const routePath = (base + (sub ? "/" + sub : "")).replace(/\/+/g, "/") || "/";
+                            entries.push({ method: verb, routePath, handlerFn: methodName, absFile, framework: "nestjs" });
+                        }
+                    }
+                },
+            });
+        }
+        catch { /* best-effort */ }
+    }
+    return entries;
+}
+// Build cross-file mount map: absFilePath → mount prefix
+// Scans all files for app.use('/prefix', require('./routes/X')) and import-based patterns
+function buildMountMap(repoRoot, files) {
+    const mountMap = new Map();
+    for (const absFile of files) {
+        let src;
+        try {
+            src = fs.readFileSync(absFile, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!src.includes(".use("))
+            continue;
+        const ast = parseBabel(src);
+        if (!ast)
+            continue;
+        // Collect varName → resolved abs path from imports and requires
+        const importedVars = new Map();
+        try {
+            (0, traverse_1.default)(ast, {
+                ImportDeclaration(np) {
+                    const resolved = resolveImport(np.node.source?.value ?? "", absFile);
+                    if (!resolved)
+                        return;
+                    for (const spec of np.node.specifiers ?? []) {
+                        if (spec.local?.name)
+                            importedVars.set(spec.local.name, resolved);
+                    }
+                },
+                VariableDeclarator(np) {
+                    const init = np.node.init;
+                    const name = np.node.id?.name;
+                    if (!name)
+                        return;
+                    // const X = require('./path') or require('./path').default or .router
+                    let srcStr = null;
+                    if (init?.type === "CallExpression" && init.callee?.name === "require") {
+                        srcStr = init.arguments?.[0]?.value;
+                    }
+                    else if (init?.type === "MemberExpression" && init.object?.type === "CallExpression"
+                        && init.object.callee?.name === "require") {
+                        srcStr = init.object.arguments?.[0]?.value;
+                    }
+                    if (srcStr) {
+                        const resolved = resolveImport(srcStr, absFile);
+                        if (resolved)
+                            importedVars.set(name, resolved);
+                    }
+                },
+            });
+        }
+        catch { }
+        // Find app.use('/prefix', importedVar) calls
+        try {
+            (0, traverse_1.default)(ast, {
+                CallExpression(np) {
+                    const callee = np.node.callee;
+                    if (callee?.type !== "MemberExpression")
+                        return;
+                    if (callee.property?.name !== "use")
+                        return;
+                    const args = np.node.arguments ?? [];
+                    if (args.length < 2 || args[0]?.type !== "StringLiteral")
+                        return;
+                    const prefix = args[0].value;
+                    const routerArg = args[1];
+                    // Identifier: app.use('/prefix', routerVar)
+                    if (routerArg?.type === "Identifier") {
+                        const resolved = importedVars.get(routerArg.name);
+                        if (resolved && !mountMap.has(resolved))
+                            mountMap.set(resolved, prefix);
+                    }
+                    // Inline require: app.use('/prefix', require('./X'))
+                    if (routerArg?.type === "CallExpression" && routerArg.callee?.name === "require") {
+                        const srcStr = routerArg.arguments?.[0]?.value;
+                        if (srcStr) {
+                            const resolved = resolveImport(srcStr, absFile);
+                            if (resolved && !mountMap.has(resolved))
+                                mountMap.set(resolved, prefix);
+                        }
+                    }
+                },
+            });
+        }
+        catch { }
+    }
+    return mountMap;
+}
+function discoverExpress(repoRoot) {
+    const entries = [];
+    const files = walkDir(repoRoot, /\.(ts|tsx|js|jsx)$/).filter(f => !f.includes("node_modules"));
+    // Build cross-file mount map first (one pass over all files)
+    const mountMap = buildMountMap(repoRoot, files);
+    for (const absFile of files) {
+        let src;
+        try {
+            src = fs.readFileSync(absFile, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!/\.(get|post|put|patch|delete)\s*\(/.test(src))
+            continue;
+        const ast = parseBabel(src);
+        if (!ast)
+            continue;
+        // Pass 1: discover all router variable names in this file (dynamic — not hardcoded)
+        const routerVars = new Set(["router", "app", "Router", "api"]);
+        try {
+            (0, traverse_1.default)(ast, {
+                VariableDeclarator(np) {
+                    const init = np.node.init;
+                    const name = np.node.id?.name;
+                    if (!name || !init)
+                        return;
+                    const isRouter = (init.type === "CallExpression" && (init.callee?.name === "Router" ||
+                        (init.callee?.type === "MemberExpression" &&
+                            (init.callee.property?.name === "Router" ||
+                                (init.callee.object?.name === "express" && init.callee.property?.name === "Router") ||
+                                init.callee.object?.name === "express"))));
+                    if (isRouter)
+                        routerVars.add(name);
+                },
+            });
+        }
+        catch { }
+        // Pass 2: within-file mount map — app.use('/prefix', subRouter) in same file
+        // Maps subRouter variable name → prefix applied to it
+        const withinFileMount = new Map();
+        try {
+            (0, traverse_1.default)(ast, {
+                CallExpression(np) {
+                    const callee = np.node.callee;
+                    if (callee?.type !== "MemberExpression")
+                        return;
+                    if (callee.property?.name !== "use")
+                        return;
+                    if (!routerVars.has(callee.object?.name ?? ""))
+                        return;
+                    const args = np.node.arguments ?? [];
+                    if (args.length < 2 || args[0]?.type !== "StringLiteral")
+                        return;
+                    const prefix = args[0].value;
+                    const subArg = args[1];
+                    if (subArg?.type === "Identifier")
+                        withinFileMount.set(subArg.name, prefix);
+                },
+            });
+        }
+        catch { }
+        // Cross-file mount prefix for this file
+        const crossFilePrefix = mountMap.get(absFile) ?? "";
+        // Pass 3: collect route definitions
+        try {
+            (0, traverse_1.default)(ast, {
+                CallExpression(np) {
+                    const callee = np.node.callee;
+                    if (callee?.type !== "MemberExpression")
+                        return;
+                    const verb = callee.property?.name?.toUpperCase();
+                    if (!verb || !HTTP_METHODS.has(verb))
+                        return;
+                    const obj = callee.object?.name ?? "";
+                    if (!routerVars.has(obj))
+                        return;
+                    const args = np.node.arguments ?? [];
+                    if (args.length < 2 || args[0]?.type !== "StringLiteral")
+                        return;
+                    const localPath = args[0].value;
+                    // Compose full path: crossFile mount + within-file mount for this var + local path
+                    const withinPrefix = withinFileMount.get(obj) ?? "";
+                    const rawFull = (crossFilePrefix + withinPrefix + "/" + localPath).replace(/\/+/g, "/");
+                    const routePath = rawFull || "/";
+                    const handlerArg = args[1];
+                    const handlerFn = handlerArg?.type === "Identifier"
+                        ? handlerArg.name
+                        : `${verb.toLowerCase()}${localPath.replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "")}`;
+                    entries.push({ method: verb, routePath, handlerFn, absFile, framework: "express" });
+                },
+            });
+        }
+        catch { /* best-effort */ }
+    }
+    return entries;
+}
+function discoverEntryPoints(repoRoot) {
+    const all = [
+        ...discoverNextJS(repoRoot),
+        ...discoverNestJS(repoRoot),
+        ...discoverExpress(repoRoot),
+    ];
+    // Deduplicate by method + routePath
+    const seen = new Set();
+    return all.filter(e => {
+        const k = `${e.method}:${e.routePath}`;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+// ── L2: Cross-file call chain tracing ────────────────────────────────────────
+const MAX_DEPTH = 4;
+const MAX_FAN_OUT = 5;
+const MAX_STEPS = 16;
+function traceChain(fn, absFile, repoRoot, depth, visited, xrayCache) {
+    const key = `${absFile}::${fn}`;
+    if (visited.has(key) || depth < 0 || visited.size > 30)
+        return [];
+    visited.add(key);
+    let xray = xrayCache.get(absFile);
+    if (!xray) {
+        try {
+            xray = (0, buildDetailedFileXRay_1.buildDetailedFileXRay)(absFile, repoRoot);
+        }
+        catch {
+            return [];
+        }
+        xrayCache.set(absFile, xray);
+    }
+    const fnDef = xray.functions.find(f => f.name === fn);
+    if (!fnDef)
+        return [];
+    const step = {
+        fn: fnDef.name,
+        absFile,
+        calls: fnDef.calls,
+        externalCalls: fnDef.externalCalls ?? [],
+        returnType: fnDef.returnType,
+    };
+    const steps = [step];
+    if (depth === 0)
+        return steps;
+    for (const callee of fnDef.calls.slice(0, MAX_FAN_OUT)) {
+        if (steps.length >= MAX_STEPS)
+            break;
+        // Callee defined in this file?
+        if (xray.functions.some(f => f.name === callee)) {
+            steps.push(...traceChain(callee, absFile, repoRoot, depth - 1, visited, xrayCache));
+            continue;
+        }
+        // Follow import to another file
+        for (const imp of xray.imports) {
+            if (!imp.names.includes(callee))
+                continue;
+            const target = resolveImport(imp.source, absFile);
+            if (target) {
+                steps.push(...traceChain(callee, target, repoRoot, depth - 1, visited, xrayCache));
+            }
+            break;
+        }
+    }
+    return steps;
+}
+// ── L3: Step enrichment ───────────────────────────────────────────────────────
+const DB_PATTERN = /^(prisma|sequelize|typeorm|mongoose|knex|db|pool|client|repository|repo|dataSource)\./i;
+const ORM_METHODS = new Set([
+    "find", "findOne", "findAll", "findMany", "findFirst", "findUnique", "findById",
+    "create", "save", "insert", "insertOne", "insertMany",
+    "update", "updateOne", "updateMany", "updateById",
+    "delete", "deleteOne", "deleteMany", "remove", "destroy",
+    "upsert", "count", "aggregate", "query", "execute", "raw",
+]);
+function classifyExternalCall(call) {
+    if (DB_PATTERN.test(call))
+        return "db";
+    const method = call.split(".").pop() ?? "";
+    if (ORM_METHODS.has(method))
+        return "db";
+    return "external";
+}
+// External service name patterns — presence in externalCalls signals a step IS external
+const EXTERNAL_SERVICE_PATTERNS = [
+    /supabase/i, /prisma/i, /mongo/i, /redis/i, /stripe/i, /sendgrid/i, /twilio/i,
+    /s3\b/i, /cloudinary/i, /firebase/i, /dynamodb/i, /elasticsearch/i, /algolia/i,
+    /youtube/i, /openai/i, /anthropic/i, /github\.com/i, /axios\.(get|post|put)/i,
+];
+function stepIsExternal(dbAccess, externalCalls) {
+    if (dbAccess.length > 0)
+        return true;
+    return externalCalls.some(c => EXTERNAL_SERVICE_PATTERNS.some(p => p.test(c)));
+}
+function mapFileToSystem(relFile, routePath, am) {
+    if (!am?.systems)
+        return null;
+    // Strategy 1a: exact key_file match (highest precision)
+    for (const sys of am.systems) {
+        for (const kf of (sys.key_files ?? [])) {
+            if (relFile === kf)
+                return sys.id;
+        }
+    }
+    // Strategy 1b: same directory as a key_file — only for deep paths (depth ≥ 2)
+    // Prevents shallow dirs like "app/" matching everything
+    for (const sys of am.systems) {
+        for (const kf of (sys.key_files ?? [])) {
+            const kfDir = kf.replace(/\/[^/]+$/, "");
+            const depth = kfDir.split("/").filter(Boolean).length;
+            if (depth >= 2 && relFile.startsWith(kfDir + "/"))
+                return sys.id;
+        }
+    }
+    // Strategy 2: owns_routes match — most precise for API route handlers
+    if (routePath) {
+        const normalise = (r) => r.replace(/^[A-Z]+\s+/, "").replace(/\[[^\]]+\]/g, ":p").replace(/:[^/]+/g, ":p");
+        const needle = normalise(routePath);
+        for (const sys of am.systems) {
+            for (const r of (sys.owns_routes ?? [])) {
+                if (normalise(r) === needle)
+                    return sys.id;
+                const base = normalise(r).replace(/\/:p$/, "");
+                if (base.length > 4 && needle.startsWith(base))
+                    return sys.id;
+            }
+        }
+    }
+    // Strategy 3: path-segment overlap with system id tokens (fuzzy fallback)
+    const skip = new Set(["app", "api", "src", "pages", "route", "index", "lib", "utils", "helpers"]);
+    const fileSegs = relFile
+        .replace(/\.(ts|tsx|js|jsx)$/, "")
+        .split("/")
+        .filter(s => s && !skip.has(s) && !s.startsWith("[") && !s.startsWith("("));
+    let bestSys = null;
+    let bestScore = 0;
+    for (const sys of am.systems) {
+        const sysTokens = sys.id.split("-").filter((t) => t.length > 2);
+        let score = 0;
+        for (const t of sysTokens) {
+            if (fileSegs.some(s => s.toLowerCase().includes(t) || t.includes(s.toLowerCase())))
+                score++;
+        }
+        if (score > 0 && score >= sysTokens.length - 1 && score > bestScore) {
+            bestScore = score;
+            bestSys = sys.id;
+        }
+    }
+    return bestSys;
+}
+function enrichStep(raw, repoRoot, am, routePath) {
+    const relFile = path.relative(repoRoot, raw.absFile).replace(/\\/g, "/");
+    const dbAccess = [];
+    const externalCalls = [];
+    for (const call of raw.externalCalls) {
+        if (classifyExternalCall(call) === "db")
+            dbAccess.push(call);
+        else
+            externalCalls.push(call);
+    }
+    return {
+        fn: raw.fn,
+        file: relFile,
+        systemId: mapFileToSystem(relFile, routePath, am),
+        dbAccess,
+        externalCalls,
+        returnType: raw.returnType,
+        isExternal: stepIsExternal(dbAccess, externalCalls),
+    };
+}
+// ── L4: Flow clustering ───────────────────────────────────────────────────────
+function routeToId(method, route) {
+    return (method.toLowerCase() + "-" + route.replace(/[/:*?]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, ""))
+        .slice(0, 60);
+}
+function flowRichness(f) {
+    const dbHits = f.steps.reduce((n, s) => n + s.dbAccess.length, 0);
+    const extHits = f.steps.reduce((n, s) => n + s.externalCalls.length, 0);
+    const withSystem = f.steps.filter(s => s.systemId).length;
+    return f.steps.length * 2 + dbHits * 3 + extHits * 2 + withSystem;
+}
+// Extract domain prefix from route (/api/auth/login → "auth")
+function routeDomain(routePath) {
+    const parts = routePath.split("/").filter(Boolean);
+    if (parts[0] === "api" && parts[1])
+        return parts[1];
+    return parts[0] ?? "root";
+}
+function clusterFlows(candidates) {
+    if (candidates.length === 0)
+        return [];
+    // Sort richest first
+    const ranked = [...candidates].sort((a, b) => flowRichness(b) - flowRichness(a));
+    // Keep at most 2 flows per (domain × method) to avoid repetition
+    const domainMethodCount = new Map();
+    const MAX_PER_BUCKET = 2;
+    const MAX_TOTAL = 16;
+    const kept = [];
+    for (const f of ranked) {
+        if (kept.length >= MAX_TOTAL)
+            break;
+        const key = `${routeDomain(f.routePath)}:${f.method}`;
+        const count = domainMethodCount.get(key) ?? 0;
+        if (count >= MAX_PER_BUCKET)
+            continue;
+        domainMethodCount.set(key, count + 1);
+        kept.push(f);
+    }
+    // Sort final output by route path for determinism
+    return kept.sort((a, b) => a.routePath.localeCompare(b.routePath));
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+async function buildFlowGraph(repoRoot, am, onProgress) {
+    const log = (s) => onProgress?.(s);
+    const xrayCache = new Map();
+    // L1
+    log("L1 Discovering entry points…");
+    const entries = discoverEntryPoints(repoRoot);
+    log(`L1 Found ${entries.length} entry points (Next.js / NestJS / Express)`);
+    if (entries.length === 0)
+        return [];
+    // L2
+    log("L2 Tracing call chains…");
+    const rawFlows = [];
+    for (const entry of entries) {
+        const visited = new Set();
+        const steps = traceChain(entry.handlerFn, entry.absFile, repoRoot, MAX_DEPTH, visited, xrayCache);
+        rawFlows.push({ entry, steps });
+    }
+    log(`L2 Traced ${rawFlows.length} call chains (${xrayCache.size} files parsed)`);
+    // L3
+    log("L3 Enriching steps with system IDs and DB access…");
+    const enrichedFlows = rawFlows.map(({ entry, steps }) => ({
+        id: routeToId(entry.method, entry.routePath),
+        nameSeed: `${entry.method} ${entry.routePath}`,
+        method: entry.method,
+        routePath: entry.routePath,
+        entryFile: path.relative(repoRoot, entry.absFile).replace(/\\/g, "/"),
+        steps: steps.map(s => enrichStep(s, repoRoot, am, entry.routePath)),
+        framework: entry.framework,
+    }));
+    const withDb = enrichedFlows.filter(f => f.steps.some(s => s.dbAccess.length > 0)).length;
+    const withSystem = enrichedFlows.filter(f => f.steps.some(s => s.systemId)).length;
+    log(`L3 ${withDb} flows reach DB · ${withSystem} flows map to AM systems`);
+    // L4
+    log("L4 Clustering and ranking flows…");
+    const final = clusterFlows(enrichedFlows);
+    log(`L4 Selected ${final.length} flows from ${enrichedFlows.length} candidates`);
+    return final;
+}
+//# sourceMappingURL=buildFlowGraph.js.map