memor-code-cli 0.2.0

package/dist/amGeneration/selectStrategicFiles.js

@@ -0,0 +1,672 @@
+"use strict";
+/**
+ * selectStrategicFiles — picks files the LLM should read + builds a file tree.
+ *
+ * Three-phase selection:
+ *  Phase 0 — Workspace-aware: For monorepos (pnpm/yarn/npm workspaces), pick 1
+ *             representative file per workspace package. Ensures every package is
+ *             represented, not just the first N files found.
+ *  Phase 1 — Targeted reads: API route handlers, lib/service files, schema files,
+ *             external clients. Per-pattern caps prevent any one category from
+ *             consuming all slots.
+ *  Phase 2 — Graph-signal reads: entry points, route owners, high inDegree.
+ *             Fill remaining slots up to MAX_FILES.
+ *
+ * Also exports buildFileTree() — a compact directory listing used in the prompt
+ * so the LLM sees every path even if it can't read every file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileTree = buildFileTree;
+exports.readWorkspaceManifests = readWorkspaceManifests;
+exports.selectStrategicFiles = selectStrategicFiles;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const MAX_FILES = 30;
+const MAX_FILE_SIZE_BYTES = 8000;
+// For monorepos: max packages to represent before targeted/graph phases fill the rest
+const MAX_WORKSPACE_PACKAGE_SLOTS = 30;
+// ── File tree builder ─────────────────────────────────────────────────────────
+const TREE_IGNORE = new Set([
+    "node_modules", ".next", ".git", "dist", "build", "out",
+    ".cache", "coverage", "__pycache__", ".turbo", ".vercel",
+]);
+const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".prisma"]);
+async function walkDir(dir, repoRoot, depth) {
+    if (depth > 6)
+        return [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const lines = [];
+    const indent = "  ".repeat(depth);
+    const sorted = entries.sort((a, b) => {
+        // dirs first, then files
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (const e of sorted) {
+        if (e.name.startsWith(".") && e.name !== ".env.example")
+            continue;
+        if (TREE_IGNORE.has(e.name))
+            continue;
+        if (e.isDirectory()) {
+            lines.push(`${indent}${e.name}/`);
+            const sub = await walkDir(path_1.default.join(dir, e.name), repoRoot, depth + 1);
+            lines.push(...sub);
+        }
+        else if (e.isFile()) {
+            const ext = path_1.default.extname(e.name);
+            if (SOURCE_EXTS.has(ext) || e.name === "package.json" || e.name === "schema.prisma") {
+                lines.push(`${indent}${e.name}`);
+            }
+        }
+    }
+    return lines;
+}
+async function buildFileTree(repoRoot, workspaceDirs) {
+    // For large monorepos: show workspace packages as flat list + top-level files only.
+    // Descending into every package at depth-6 produces tens of thousands of lines; the
+    // 300-line cap then truncates to ~2% of the structure — useless. Better to show all
+    // package names clearly and let workspace manifests provide the detail.
+    if (workspaceDirs && workspaceDirs.size >= 10) {
+        const rootEntries = await promises_1.default.readdir(repoRoot, { withFileTypes: true }).catch(() => []);
+        const lines = [];
+        // Top-level source files
+        for (const e of rootEntries) {
+            if (e.isFile()) {
+                const ext = path_1.default.extname(e.name);
+                if (SOURCE_EXTS.has(ext) || e.name === "package.json")
+                    lines.push(e.name);
+            }
+        }
+        // Workspace directories — show one level deep (subdirs only, not every file)
+        const workspaceDirsSorted = [...workspaceDirs].sort();
+        for (const absDir of workspaceDirsSorted) {
+            const rel = path_1.default.relative(repoRoot, absDir);
+            lines.push(`${rel}/`);
+            // Show src/ or top-level source structure — one level only
+            const subEntries = await promises_1.default.readdir(absDir, { withFileTypes: true }).catch(() => []);
+            for (const e of subEntries) {
+                if (e.name.startsWith(".") || TREE_IGNORE.has(e.name))
+                    continue;
+                if (e.isDirectory()) {
+                    lines.push(`  ${e.name}/`);
+                }
+                else if (e.isFile()) {
+                    const ext = path_1.default.extname(e.name);
+                    if (SOURCE_EXTS.has(ext) || e.name === "package.json")
+                        lines.push(`  ${e.name}`);
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+    const lines = await walkDir(repoRoot, repoRoot, 0);
+    // Cap at 400 lines to avoid bloating the prompt
+    if (lines.length > 400) {
+        return lines.slice(0, 400).join("\n") + `\n... (${lines.length - 400} more files)`;
+    }
+    return lines.join("\n");
+}
+/**
+ * Parse glob patterns from pnpm-workspace.yaml, package.json#workspaces, or
+ * lerna.json#packages. Expands `dir/*` patterns into real subdirectories.
+ * Returns directories that actually contain a package.json.
+ */
+async function detectWorkspacePackages(repoRoot) {
+    const packages = [];
+    const seen = new Set();
+    async function tryAddDir(dir) {
+        const abs = path_1.default.isAbsolute(dir) ? dir : path_1.default.join(repoRoot, dir);
+        if (seen.has(abs))
+            return;
+        seen.add(abs);
+        try {
+            const raw = await promises_1.default.readFile(path_1.default.join(abs, "package.json"), "utf8");
+            const pkg = JSON.parse(raw);
+            packages.push({ dir: abs, name: pkg.name ?? path_1.default.basename(abs) });
+        }
+        catch { }
+    }
+    async function expandGlob(pattern) {
+        // Only handle the common `dir/*` pattern — deeper globs are rare in practice
+        if (pattern.endsWith("/*")) {
+            const parent = path_1.default.join(repoRoot, pattern.slice(0, -2));
+            try {
+                const entries = await promises_1.default.readdir(parent, { withFileTypes: true });
+                for (const e of entries) {
+                    if (e.isDirectory() && !e.name.startsWith(".") && !TREE_IGNORE.has(e.name)) {
+                        await tryAddDir(path_1.default.join(parent, e.name));
+                    }
+                }
+            }
+            catch { }
+        }
+        else {
+            await tryAddDir(path_1.default.join(repoRoot, pattern));
+        }
+    }
+    // pnpm-workspace.yaml
+    try {
+        const raw = await promises_1.default.readFile(path_1.default.join(repoRoot, "pnpm-workspace.yaml"), "utf8");
+        // Extract lines like `  - 'packages/*'` or `  - packages/*`
+        const lines = raw.split("\n");
+        let inPackages = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === "packages:") {
+                inPackages = true;
+                continue;
+            }
+            if (inPackages) {
+                if (trimmed.startsWith("-")) {
+                    const glob = trimmed.slice(1).trim().replace(/^['"]|['"]$/g, "");
+                    await expandGlob(glob);
+                }
+                else if (trimmed && !trimmed.startsWith("#")) {
+                    inPackages = false; // new top-level key
+                }
+            }
+        }
+    }
+    catch { }
+    // root package.json#workspaces (yarn / npm workspaces)
+    if (packages.length === 0) {
+        try {
+            const root = JSON.parse(await promises_1.default.readFile(path_1.default.join(repoRoot, "package.json"), "utf8"));
+            const globs = Array.isArray(root.workspaces)
+                ? root.workspaces
+                : (root.workspaces?.packages ?? []);
+            for (const glob of globs)
+                await expandGlob(glob);
+        }
+        catch { }
+    }
+    // lerna.json
+    if (packages.length === 0) {
+        try {
+            const lerna = JSON.parse(await promises_1.default.readFile(path_1.default.join(repoRoot, "lerna.json"), "utf8"));
+            const globs = lerna.packages ?? ["packages/*"];
+            for (const glob of globs)
+                await expandGlob(glob);
+        }
+        catch { }
+    }
+    return packages;
+}
+/**
+ * Read package.json manifests for ALL workspace packages.
+ * Returns lightweight summaries used to build the WORKSPACE PACKAGES prompt section.
+ * This is the reliable alternative to heuristic source-file selection — package.json
+ * always exists and contains names, descriptions, and inter-package dependencies.
+ */
+async function readWorkspaceManifests(repoRoot) {
+    const packages = await detectWorkspacePackages(repoRoot);
+    if (packages.length < 3)
+        return []; // not a monorepo
+    // Build a set of all workspace package names for internal dep detection
+    const workspaceNames = new Set(packages.map((p) => p.name));
+    const manifests = [];
+    await Promise.all(packages.map(async ({ dir, name }) => {
+        try {
+            const raw = await promises_1.default.readFile(path_1.default.join(dir, "package.json"), "utf8");
+            const pkg = JSON.parse(raw);
+            const allDeps = {
+                ...(pkg.dependencies ?? {}),
+                ...(pkg.peerDependencies ?? {}),
+            };
+            const internalDeps = Object.keys(allDeps)
+                .filter((d) => workspaceNames.has(d))
+                .sort();
+            const externalDeps = Object.keys(allDeps)
+                .filter((d) => !workspaceNames.has(d) && !d.startsWith("@types/"))
+                .slice(0, 5)
+                .sort();
+            // Simplified exports: just the subpath keys (e.g. ".", "./client", "./server")
+            const exportsField = pkg.exports;
+            let exports = [];
+            if (typeof exportsField === "string") {
+                exports = ["."];
+            }
+            else if (typeof exportsField === "object" && exportsField !== null) {
+                exports = Object.keys(exportsField).slice(0, 8);
+            }
+            else if (pkg.main || pkg.module) {
+                exports = ["."];
+            }
+            manifests.push({
+                relDir: path_1.default.relative(repoRoot, dir),
+                name: pkg.name ?? name,
+                description: pkg.description,
+                internalDeps,
+                externalDeps,
+                exports,
+                isPrivate: !!pkg.private,
+            });
+        }
+        catch { /* skip unreadable */ }
+    }));
+    // Sort: fewest deps first (foundation packages first), then alphabetically
+    manifests.sort((a, b) => a.internalDeps.length - b.internalDeps.length ||
+        a.name.localeCompare(b.name));
+    return manifests;
+}
+/**
+ * For a workspace package directory, find the single most representative source
+ * file: prefers the main/module entry from package.json, then index.ts/js, then
+ * any top-level source file.
+ */
+async function findPackageEntryFile(pkgDir) {
+    // Try package.json#main / #module / #exports
+    try {
+        const raw = await promises_1.default.readFile(path_1.default.join(pkgDir, "package.json"), "utf8");
+        const pkg = JSON.parse(raw);
+        const candidates = [pkg.main, pkg.module, pkg.source, pkg.exports]
+            .flat()
+            .filter(Boolean)
+            .map((s) => (typeof s === "string" ? s : null))
+            .filter(Boolean);
+        for (const c of candidates) {
+            // Resolve src variant (package.json often points to compiled dist, but src is better)
+            const srcVariant = c.replace(/^(dist|lib|build)\//, "src/").replace(/\.(js|cjs|mjs)$/, ".ts");
+            for (const candidate of [srcVariant, c]) {
+                const abs = path_1.default.resolve(pkgDir, candidate);
+                try {
+                    await promises_1.default.access(abs);
+                    return abs;
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    // Fallback: standard entry file names in pkg root, src/, or lib/
+    const ENTRY_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx",
+        "main.ts", "main.tsx", "main.js", "app.ts", "app.tsx", "app.js"];
+    const searchDirs = [pkgDir, path_1.default.join(pkgDir, "src"), path_1.default.join(pkgDir, "lib")];
+    for (const dir of searchDirs) {
+        for (const name of ENTRY_NAMES) {
+            const abs = path_1.default.join(dir, name);
+            try {
+                await promises_1.default.access(abs);
+                return abs;
+            }
+            catch { }
+        }
+    }
+    const isSourceFile = (name) => /\.(ts|tsx|js|jsx)$/.test(name) &&
+        !name.endsWith(".test.ts") && !name.endsWith(".spec.ts") &&
+        !name.endsWith(".test.js") && !name.endsWith(".spec.js") &&
+        !name.endsWith(".stories.tsx") && !name.endsWith(".d.ts");
+    // Score filenames: prefer "main module" signals over utility files.
+    // Lower = more representative.
+    const fileScore = (name) => {
+        const stem = name.replace(/\.(ts|tsx|js|jsx)$/, "").toLowerCase();
+        if (/^(index|main|app|server|client|core|plugin|registry|manager|symbols|config|types|constants)$/i.test(stem))
+            return 0;
+        if (/hostconfig|symbols|registry|plugin|manager|internals|public/i.test(stem))
+            return 1;
+        if (/^react/i.test(stem))
+            return 2;
+        return 3;
+    };
+    const bestFile = (files, dir) => {
+        const src = files.filter((e) => e.isFile() && isSourceFile(e.name));
+        if (!src.length)
+            return null;
+        src.sort((a, b) => fileScore(a.name) - fileScore(b.name) || a.name.localeCompare(b.name));
+        return path_1.default.join(dir, src[0].name);
+    };
+    // Files directly in src/
+    const srcDir = path_1.default.join(pkgDir, "src");
+    try {
+        const entries = await promises_1.default.readdir(srcDir, { withFileTypes: true });
+        const f = bestFile(entries, srcDir);
+        if (f)
+            return f;
+    }
+    catch { }
+    // Files at package root — covers packages like shared/ that put .js at root
+    try {
+        const entries = await promises_1.default.readdir(pkgDir, { withFileTypes: true });
+        const f = bestFile(entries, pkgDir);
+        if (f)
+            return f;
+    }
+    catch { }
+    // One level deeper into src/ subdirs — covers packages like react-dom-bindings
+    // where src/ has only subdirs (client/, events/, server/)
+    const SUBDIR_PRIORITY = ["client", "server", "shared", "lib", "core"];
+    try {
+        const srcEntries = await promises_1.default.readdir(srcDir, { withFileTypes: true });
+        const subdirs = srcEntries
+            .filter((e) => e.isDirectory() && !TREE_IGNORE.has(e.name))
+            .sort((a, b) => {
+            const ai = SUBDIR_PRIORITY.indexOf(a.name);
+            const bi = SUBDIR_PRIORITY.indexOf(b.name);
+            return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+        });
+        for (const subdir of subdirs) {
+            const subPath = path_1.default.join(srcDir, subdir.name);
+            const subEntries = await promises_1.default.readdir(subPath, { withFileTypes: true });
+            const f = bestFile(subEntries, subPath);
+            if (f)
+                return f;
+        }
+    }
+    catch { }
+    return null;
+}
+// ── Targeted file reader ──────────────────────────────────────────────────────
+// Paths that look like API routes but are actually type/DTO/schema definitions — skip them.
+const TARGETED_EXCLUDE = /\/(dto|types?|interfaces?|schemas?|models?|constants?|enums?)\//i;
+const TARGETED_PATTERNS = [
+    // External service clients (Jira, Stripe, AWS, third-party HTTP clients) — read all, usually few
+    { glob: /\/(external|clients?|integrations?|providers?)\/.+\.(ts|js)$/i, reason: "external client", priority: 1 },
+    // Next.js / Express API route handlers — cap at 8 to avoid every snowflake route consuming slots
+    { glob: /\/(api|routes?|controllers?)\/.+\.(ts|js)$/, reason: "API route handler", priority: 2, cap: 8 },
+    // Command/operation handlers (handler classes, use-cases, commands) — cap at 6
+    { glob: /\/(handlers?|use.?cases?|commands?|actions?)\/.+\.(ts|js)$/i, reason: "handler", priority: 2, cap: 6 },
+    // Service / library functions — cap at 6
+    { glob: /\/(lib|services?|helpers?|utils?)\/[^/]+\.(ts|js)$/, reason: "service layer", priority: 3, cap: 6 },
+    // React data hooks (use*.js/ts files — custom hooks for data fetching) — cap at 4
+    { glob: /\/use[A-Z][^/]+\.(ts|tsx|js|jsx)$/, reason: "data hook", priority: 3, cap: 4 },
+    // Page / component files — ensures user-facing systems get at least one .tsx in key_files
+    // so the LLM and import scanner can trace UI library consumption (e.g. @calcom/ui, @mui/material)
+    // Matches Next.js pages/, App Router app/, generic components/, Vue views/, RN screens/
+    { glob: /\/(pages?|components?|views?|screens?)\/.+\.tsx$/, reason: "page/component", priority: 3, cap: 5 },
+    // DB clients and config
+    { glob: /(supabase|prisma|drizzle|mongoose|knex|sequelize|database|db)\.(ts|js)$/i, reason: "data client", priority: 4 },
+    // Prisma schema
+    { glob: /schema\.prisma$/, reason: "ORM schema", priority: 4 },
+    // Auth / middleware
+    { glob: /(auth|middleware|guard|session)\.(ts|js)$/, reason: "auth/middleware", priority: 5 },
+    // Transformers / mappers
+    { glob: /\/(transformers?|mappers?|serializers?|adapters?)\/.+\.(ts|js)$/i, reason: "transformer", priority: 5, cap: 3 },
+];
+async function findTargetedFiles(repoRoot) {
+    const results = [];
+    const seen = new Set();
+    // Track per-pattern counts for cap enforcement
+    const patternCounts = new Map();
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith("."))
+                continue;
+            if (TREE_IGNORE.has(e.name))
+                continue;
+            const full = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                await walk(full);
+            }
+            else if (e.isFile()) {
+                const rel = path_1.default.relative(repoRoot, full);
+                if (seen.has(rel))
+                    continue;
+                const ext = path_1.default.extname(e.name);
+                if (!SOURCE_EXTS.has(ext) && e.name !== "schema.prisma")
+                    continue;
+                // Skip pure type/DTO files — they don't define systems, they waste slots
+                if (TARGETED_EXCLUDE.test(rel))
+                    continue;
+                for (let pi = 0; pi < TARGETED_PATTERNS.length; pi++) {
+                    const pat = TARGETED_PATTERNS[pi];
+                    if (pat.glob.test(rel)) {
+                        const count = patternCounts.get(pi) ?? 0;
+                        if (pat.cap !== undefined && count >= pat.cap)
+                            break;
+                        patternCounts.set(pi, count + 1);
+                        seen.add(rel);
+                        results.push({ filePath: full, relPath: rel, reason: pat.reason, priority: pat.priority });
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    await walk(repoRoot);
+    return results.sort((a, b) => a.priority - b.priority || a.relPath.localeCompare(b.relPath));
+}
+// ── Graph-signal file finder (unchanged from original) ────────────────────────
+async function findRepresentativeFile(clusterId, repoRoot) {
+    const clusterPath = path_1.default.join(repoRoot, clusterId);
+    const candidates = [
+        "index.ts", "index.tsx", "index.js", "index.jsx",
+        "router.ts", "router.js", "main.ts", "main.js",
+        "server.ts", "server.js", "app.ts", "app.js", "app.tsx",
+    ];
+    const searchDirs = [clusterPath, path_1.default.join(clusterPath, "src"), path_1.default.join(clusterPath, "lib")];
+    for (const dir of searchDirs) {
+        for (const candidate of candidates) {
+            const full = path_1.default.join(dir, candidate);
+            try {
+                await promises_1.default.access(full);
+                return full;
+            }
+            catch { }
+        }
+    }
+    for (const dir of searchDirs) {
+        try {
+            const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+            const srcFile = entries.find((e) => e.isFile()
+                && (e.name.endsWith(".ts") || e.name.endsWith(".tsx") || e.name.endsWith(".js") || e.name.endsWith(".jsx"))
+                && !e.name.endsWith(".test.ts") && !e.name.endsWith(".spec.ts")
+                && !e.name.endsWith(".test.js") && !e.name.endsWith(".spec.js")
+                && !e.name.endsWith(".stories.tsx") && !e.name.endsWith(".stories.jsx"));
+            if (srcFile)
+                return path_1.default.join(dir, srcFile.name);
+        }
+        catch { }
+    }
+    for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+        const full = path_1.default.join(repoRoot, clusterId + ext);
+        try {
+            await promises_1.default.access(full);
+            return full;
+        }
+        catch { }
+    }
+    return null;
+}
+async function readTruncated(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, "utf8");
+        if (Buffer.byteLength(content) <= MAX_FILE_SIZE_BYTES)
+            return content;
+        return content.slice(0, MAX_FILE_SIZE_BYTES) + "\n\n// ... (truncated)";
+    }
+    catch {
+        return "";
+    }
+}
+// ── Must-include: data-client and external service files ─────────────────────
+// These reveal the data-client swimlane layer. They bypass MAX_FILES so the LLM
+// always sees DB connections and external service clients regardless of repo size.
+const MUST_INCLUDE_PATTERNS = [
+    { glob: /(supabase|prisma|drizzle|mongoose|knex|sequelize|typeorm)\.(ts|js)$/i, reason: "DB client" },
+    { glob: /(snowflake|redshift|bigquery|databricks)\.(ts|js)$/i, reason: "data warehouse client" },
+    { glob: /(redis|elasticache|memcache)\.(ts|js)$/i, reason: "cache client" },
+    { glob: /(stripe|braintree|paypal|square)\.(ts|js)$/i, reason: "payment client" },
+    { glob: /(jira|github|gitlab|slack|twilio|sendgrid|mailgun|postmark)\.(ts|js)$/i, reason: "external service client" },
+    { glob: /(aws|gcp|azure).*(client|sdk|secret|credentials?)\.(ts|js)$/i, reason: "cloud client" },
+    { glob: /(connection.?manager|db.?pool|database.?pool|pg.?pool|connection.?pool)\.(ts|js)$/i, reason: "connection pool" },
+    { glob: /\/(secrets?|credentials?|vault)\.(ts|js)$/i, reason: "secrets client" },
+];
+const MUST_INCLUDE_BONUS = 3; // files we'll add beyond MAX_FILES
+async function findMustIncludeFiles(repoRoot) {
+    const results = [];
+    const walk = async (dir) => {
+        let entries;
+        try {
+            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith(".") || TREE_IGNORE.has(e.name))
+                continue;
+            const full = path_1.default.join(dir, e.name);
+            if (e.isDirectory()) {
+                await walk(full);
+            }
+            else if (e.isFile()) {
+                const rel = path_1.default.relative(repoRoot, full);
+                for (const pat of MUST_INCLUDE_PATTERNS) {
+                    if (pat.glob.test(rel)) {
+                        results.push({ filePath: full, relPath: rel, reason: pat.reason });
+                        break;
+                    }
+                }
+            }
+        }
+    };
+    await walk(repoRoot);
+    return results;
+}
+// ── Main export ───────────────────────────────────────────────────────────────
+async function selectStrategicFiles(enriched, repoRoot) {
+    const results = [];
+    const seenPaths = new Set();
+    // ── Phase 0: Workspace-aware package representation (monorepos) ──────────
+    const workspacePackages = await detectWorkspacePackages(repoRoot);
+    const isMonorepo = workspacePackages.length >= 3;
+    if (isMonorepo) {
+        // Score each package: packages with "api", "auth", "store", "router" in name
+        // get priority; the rest are sorted by name for stability.
+        // Prefer packages whose names signal runtime importance over test/devtools/tooling.
+        // Among equals, shorter names float up first (react < react-dom < react-devtools-extensions).
+        const LOW_VALUE = /\b(test|tests|spec|mock|devtools|storybook|eslint|jest|fixture|bench|example|demo|playground|docs|internal)\b/i;
+        const sorted = [...workspacePackages].sort((a, b) => {
+            const aLow = LOW_VALUE.test(a.name) ? 1 : 0;
+            const bLow = LOW_VALUE.test(b.name) ? 1 : 0;
+            if (aLow !== bLow)
+                return aLow - bLow;
+            // shorter names are more fundamental (react < react-reconciler < react-devtools-shared)
+            return a.name.length - b.name.length || a.name.localeCompare(b.name);
+        });
+        const pkgSlots = Math.min(sorted.length, MAX_WORKSPACE_PACKAGE_SLOTS);
+        await Promise.all(sorted.slice(0, pkgSlots).map(async ({ dir, name }) => {
+            const filePath = await findPackageEntryFile(dir);
+            if (!filePath)
+                return;
+            const relPath = path_1.default.relative(repoRoot, filePath);
+            if (seenPaths.has(relPath))
+                return;
+            const content = await readTruncated(filePath);
+            if (!content)
+                return;
+            seenPaths.add(relPath);
+            results.push({ path: filePath, relPath, reason: `workspace package: ${name}`, content });
+        }));
+    }
+    // ── Phase 1: Targeted reads (API routes, lib, data clients) ──────────────
+    const targeted = await findTargetedFiles(repoRoot);
+    for (const { filePath, relPath, reason } of targeted) {
+        if (results.length >= MAX_FILES)
+            break;
+        if (seenPaths.has(relPath))
+            continue;
+        const content = await readTruncated(filePath);
+        if (!content)
+            continue;
+        seenPaths.add(relPath);
+        results.push({ path: filePath, relPath, reason, content });
+    }
+    // ── Phase 2: Graph-signal reads (fill remaining slots) ────────────────────
+    const remaining = MAX_FILES - results.length;
+    if (remaining <= 0)
+        return results;
+    const nodes = enriched.nodes.filter((n) => n.kind === "cluster" || n.kind === "package");
+    const TEST_SEGS = new Set(["__tests__", "__test__", "__mocks__", "__mock__", "test", "tests", "spec", "specs", "fixtures", "mocks"]);
+    const isTestNode = (n) => n.id.split("/").some((seg) => TEST_SEGS.has(seg.toLowerCase()));
+    const ENTRY_NAMES = new Set(["index", "main", "app", "server", "cli", "entry", "bootstrap", "start"]);
+    const isRealEntryPoint = (n) => n.isEntryPoint && !isTestNode(n) &&
+        ENTRY_NAMES.has(n.name.toLowerCase().replace(/\.(ts|tsx|js|jsx)$/, ""));
+    const graphSelected = new Map();
+    let entryCount = 0;
+    for (const n of nodes) {
+        if (entryCount >= 3)
+            break;
+        if (isRealEntryPoint(n)) {
+            graphSelected.set(n.id, { node: n, reason: "entry point", priority: 1 });
+            entryCount++;
+        }
+    }
+    let routeCount = 0;
+    for (const n of nodes) {
+        if (routeCount >= 3)
+            break;
+        if (n.routes.length > 0 && !graphSelected.has(n.id)) {
+            graphSelected.set(n.id, { node: n, reason: `owns routes: ${n.routes.slice(0, 3).join(", ")}`, priority: 2 });
+            routeCount++;
+        }
+    }
+    let ormCount = 0;
+    for (const n of nodes) {
+        if (ormCount >= 2)
+            break;
+        if (n.ormUses.length > 0 && !graphSelected.has(n.id)) {
+            graphSelected.set(n.id, { node: n, reason: `uses ORM: ${n.ormUses.slice(0, 2).join(", ")}`, priority: 3 });
+            ormCount++;
+        }
+    }
+    const byInDegree = [...nodes]
+        .filter((n) => !graphSelected.has(n.id) && !isTestNode(n))
+        .sort((a, b) => b.inDegree - a.inDegree)
+        .slice(0, 4);
+    for (const n of byInDegree) {
+        graphSelected.set(n.id, { node: n, reason: `high inDegree (${n.inDegree})`, priority: 4 });
+    }
+    const sorted = [...graphSelected.values()]
+        .sort((a, b) => a.priority - b.priority)
+        .slice(0, remaining);
+    await Promise.all(sorted.map(async ({ node, reason }) => {
+        const filePath = await findRepresentativeFile(node.id, repoRoot);
+        if (!filePath)
+            return;
+        const relPath = path_1.default.relative(repoRoot, filePath);
+        if (seenPaths.has(relPath))
+            return;
+        const content = await readTruncated(filePath);
+        if (!content)
+            return;
+        seenPaths.add(relPath);
+        results.push({ path: filePath, relPath, reason, content });
+    }));
+    // ── Phase 3: Must-include infra (data-client + external service files) ────
+    // These bypass MAX_FILES — up to MUST_INCLUDE_BONUS extra slots.
+    const mustInclude = await findMustIncludeFiles(repoRoot);
+    const bonusCap = MAX_FILES + MUST_INCLUDE_BONUS;
+    for (const { filePath, relPath, reason } of mustInclude) {
+        if (results.length >= bonusCap)
+            break;
+        if (seenPaths.has(relPath))
+            continue;
+        const content = await readTruncated(filePath);
+        if (!content)
+            continue;
+        seenPaths.add(relPath);
+        results.push({ path: filePath, relPath, reason, content });
+    }
+    return results;
+}
+//# sourceMappingURL=selectStrategicFiles.js.map