claude-setup 1.0.0 → 1.1.1

package/dist/collect.js

@@ -1,12 +1,13 @@
-import { readFileSync, existsSync, statSync } from "fs";
+import { readFileSync, existsSync, statSync, readdirSync } from "fs";
 import { glob } from "glob";
 import { join, extname, basename, dirname } from "path";
-// Universal blocklist — always exclude these patterns
+import { loadConfig } from "./config.js";
+// --- Blocklists ---
 const BLOCKED_DIRS = new Set([
     "node_modules", "vendor", ".venv", "venv", "env", "__pypackages__",
     "dist", "build", "out", ".next", ".nuxt", ".svelte-kit", "__pycache__",
     "target", ".git", ".cache", "coverage", ".nyc_output", ".pytest_cache",
-    ".tox", "htmlcov", ".ruff_cache", "logs",
+    ".tox", "htmlcov", ".ruff_cache", "logs", ".egg-info",
 ]);
 const BLOCKED_EXTENSIONS = new Set([
     ".lock", ".pyc", ".pyo", ".class", ".o", ".a", ".so", ".dylib", ".dll",
@@ -21,195 +22,453 @@ const BLOCKED_EXTENSIONS = new Set([
 ]);
 const BLOCKED_FILES = new Set([
     "go.sum", "poetry.lock", "Pipfile.lock", "composer.lock",
-    ".DS_Store", "Thumbs.db",
+    ".DS_Store", "Thumbs.db", "package-lock.json",
 ]);
-// Config files to read at root (or one level deep)
-const CONFIG_FILES = [
-    { pattern: "package.json" },
-    { pattern: "package-lock.json", truncate: truncatePackageLock },
-    { pattern: "pyproject.toml" },
-    { pattern: "setup.py", truncate: (c) => firstLines(c, 60) },
-    { pattern: "requirements.txt" },
-    { pattern: "Pipfile" },
-    { pattern: "go.mod" },
-    { pattern: "Cargo.toml" },
-    { pattern: "pom.xml", truncate: (c) => firstLines(c, 80) },
-    { pattern: "build.gradle", truncate: (c) => firstLines(c, 80) },
-    { pattern: "build.gradle.kts", truncate: (c) => firstLines(c, 80) },
-    { pattern: "composer.json" },
-    { pattern: "Gemfile" },
-    { pattern: "turbo.json" },
-    { pattern: "nx.json" },
-    { pattern: "pnpm-workspace.yaml" },
-    { pattern: "lerna.json" },
-    { pattern: ".env.example" },
-    { pattern: ".env.sample" },
-    { pattern: ".env.template" },
-    { pattern: "docker-compose.yml", truncate: (c) => c.length > 8000 ? firstLines(c, 100) + "\n[... truncated]" : c },
-    { pattern: "docker-compose.yaml", truncate: (c) => c.length > 8000 ? firstLines(c, 100) + "\n[... truncated]" : c },
-    { pattern: "Dockerfile", truncate: (c) => firstLines(c, 50) },
-];
 const SOURCE_EXTENSIONS = new Set([
     ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
     ".py", ".go", ".rs", ".java", ".kt", ".scala",
     ".rb", ".php", ".cs", ".swift", ".c", ".cpp", ".h",
     ".vue", ".svelte", ".astro",
 ]);
-const ENTRY_BASENAMES = new Set([
-    "index", "main", "app", "server", "cmd", "cli", "mod", "run",
-]);
+const ENTRY_BASENAMES = new Set(["index", "main", "app", "server", "cmd", "cli", "mod", "run"]);
 const ENTRY_DIRS = [".", "src", "app", "cmd", "bin"];
-const PRIMARY_SOURCE_DIRS = [
-    "src", "app", "lib", "core", "pkg", "internal", "api", "cmd",
+const PRIMARY_SOURCE_DIRS = ["src", "app", "lib", "core", "pkg", "internal", "api", "cmd"];
+// Config files the CLI knows how to find — but NOT what they mean
+const KNOWN_CONFIG_FILES = [
+    "package.json", "pyproject.toml", "setup.py", "requirements.txt", "Pipfile",
+    "go.mod", "Cargo.toml", "pom.xml", "build.gradle", "build.gradle.kts",
+    "composer.json", "Gemfile", "turbo.json", "nx.json", "pnpm-workspace.yaml",
+    "lerna.json", ".env.example", ".env.sample", ".env.template",
+    "docker-compose.yml", "docker-compose.yaml", "Dockerfile",
+    "tsconfig.json", "Makefile",
 ];
-const MAX_SOURCE_FILES = 10;
-const MAX_FILE_BYTES = 80_000;
-export async function collectProjectFiles(cwd = process.cwd()) {
+// --- Main collection function ---
+export async function collectProjectFiles(cwd = process.cwd(), mode = "normal") {
+    const config = loadConfig(cwd);
+    const allBlocked = new Set([...BLOCKED_DIRS, ...config.extraBlockedDirs]);
     const configs = {};
     const source = [];
     const skipped = [];
-    // Collect config files
-    for (const cfg of CONFIG_FILES) {
-        const filePath = join(cwd, cfg.pattern);
-        if (existsSync(filePath)) {
-            try {
-                let content = readFileSync(filePath, "utf8");
-                if (cfg.truncate)
-                    content = cfg.truncate(content);
-                configs[cfg.pattern] = content;
-            }
-            catch {
-                skipped.push({ path: cfg.pattern, reason: "could not read" });
-            }
+    if (config.digestMode) {
+        const digest = await buildProjectDigest(cwd, config, allBlocked);
+        configs["__digest__"] = formatDigest(digest);
+        for (const [k, v] of Object.entries(digest.configs)) {
+            configs[k] = v;
         }
     }
-    // Check for .env (note existence but never read)
+    else {
+        await collectRawConfigs(cwd, configs, skipped);
+    }
     if (existsSync(join(cwd, ".env")) && !configs[".env"]) {
         configs[".env"] = "[.env exists — not read for security]";
     }
-    // Root-level *.config.{js,ts,mjs} files
-    for (const ext of ["js", "ts", "mjs"]) {
+    if (mode === "configOnly")
+        return { configs, source, skipped };
+    // Source sampling
+    const maxFiles = mode === "deep" ? config.maxSourceFiles : Math.min(config.maxSourceFiles, 10);
+    const allSourceFiles = await findSourceFiles(cwd, config.maxDepth, allBlocked);
+    const entries = selectEntryPoints(allSourceFiles, 3);
+    const breadthSample = selectBreadthSample(cwd, allSourceFiles, entries, maxFiles - entries.length, config.sourceDirs);
+    const selected = [...entries, ...breadthSample];
+    for (const filePath of selected) {
+        const fullPath = join(cwd, filePath);
         try {
-            const matches = await glob(`*.config.${ext}`, { cwd, nodir: true });
-            for (const m of matches) {
-                const filePath = join(cwd, m);
-                try {
-                    const content = readFileSync(filePath, "utf8");
-                    configs[m] = firstLines(content, 100);
-                }
-                catch {
-                    skipped.push({ path: m, reason: "could not read" });
-                }
+            const stat = statSync(fullPath);
+            if (stat.size > config.maxFileSizeKB * 1024) {
+                skipped.push({ path: filePath, reason: `${(stat.size / 1024).toFixed(0)}KB` });
+                continue;
+            }
+            const raw = readFileSync(fullPath, "utf8");
+            if (config.digestMode) {
+                const isEntry = entries.includes(filePath);
+                source.push({
+                    path: filePath,
+                    content: isEntry ? compactContent(raw) : extractSignatures(raw),
+                });
             }
+            else {
+                source.push({ path: filePath, content: truncateSource(raw) });
+            }
+        }
+        catch {
+            skipped.push({ path: filePath, reason: "could not read" });
         }
-        catch { /* glob error — skip */ }
     }
-    // Root-level *.csproj files
+    return { configs, source, skipped };
+}
+// --- Digest builder ---
+// ZERO domain knowledge. Extracts raw data only. Claude Code interprets.
+async function buildProjectDigest(cwd, config, blockedDirs) {
+    const digest = {
+        configFilesFound: [],
+        deps: [],
+        scripts: [],
+        tree: "",
+        envVars: [],
+        configs: {},
+    };
+    // Which config files exist? Just the names — Claude Code infers the stack.
+    for (const name of KNOWN_CONFIG_FILES) {
+        if (existsSync(join(cwd, name))) {
+            digest.configFilesFound.push(name);
+        }
+    }
+    // Also check for *.config.{js,ts,mjs} and *.csproj
     try {
+        for (const ext of ["js", "ts", "mjs"]) {
+            const matches = await glob(`*.config.${ext}`, { cwd, nodir: true });
+            digest.configFilesFound.push(...matches);
+        }
         const csprojMatches = await glob("*.csproj", { cwd, nodir: true });
-        for (const m of csprojMatches) {
-            try {
-                configs[m] = readFileSync(join(cwd, m), "utf8");
+        digest.configFilesFound.push(...csprojMatches);
+    }
+    catch { /* skip */ }
+    // Extract dep names from whatever package manifest exists
+    // No interpretation — just the names as strings
+    digest.deps = extractDeps(cwd, digest.configFilesFound);
+    digest.scripts = extractScripts(cwd, digest.configFilesFound);
+    // Env var names from .env.example / .env.sample / .env.template
+    for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
+        const envPath = join(cwd, envFile);
+        if (existsSync(envPath)) {
+            const lines = readFileSync(envPath, "utf8").split("\n");
+            for (const line of lines) {
+                const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+                if (match)
+                    digest.envVars.push(match[1]);
             }
-            catch {
-                skipped.push({ path: m, reason: "could not read" });
+            break;
+        }
+    }
+    // Directory tree
+    digest.tree = buildTree(cwd, blockedDirs, 3);
+    // Full content only for infra files that are usually small and high-signal
+    for (const dcFile of ["docker-compose.yml", "docker-compose.yaml"]) {
+        const dcPath = join(cwd, dcFile);
+        if (existsSync(dcPath)) {
+            const content = readFileSync(dcPath, "utf8");
+            if (content.length < 2000) {
+                digest.configs[dcFile] = content;
+            }
+            else {
+                // Just service block headers — no interpretation of what they are
+                const services = [...content.matchAll(/^\s{2}(\w[\w-]*):\s*$/gm)].map(m => m[1]);
+                digest.configs[dcFile] = `services: ${services.join(", ")}\n[${content.split("\n").length} lines total]`;
             }
         }
     }
-    catch { /* skip */ }
-    // Collect source files — max 10, cost-aware
-    const allSourceFiles = await findSourceFiles(cwd);
-    // Step 1: entry points
-    const entries = [];
-    for (const dir of ENTRY_DIRS) {
-        for (const file of allSourceFiles) {
-            const base = basename(file, extname(file));
-            const fileDir = dirname(file);
-            if (ENTRY_BASENAMES.has(base) && (fileDir === dir || fileDir === ".")) {
-                if (!entries.includes(file))
-                    entries.push(file);
-                if (entries.length >= 3)
-                    break;
+    const dockerfilePath = join(cwd, "Dockerfile");
+    if (existsSync(dockerfilePath)) {
+        const lines = readFileSync(dockerfilePath, "utf8").split("\n");
+        const fromLines = lines.filter(l => /^FROM\s/i.test(l.trim()));
+        if (fromLines.length)
+            digest.configs["Dockerfile"] = fromLines.join("\n");
+    }
+    // Small monorepo configs — full content
+    for (const f of ["turbo.json", "nx.json", "pnpm-workspace.yaml", "lerna.json"]) {
+        const p = join(cwd, f);
+        if (existsSync(p)) {
+            const content = readFileSync(p, "utf8");
+            if (content.length < 500)
+                digest.configs[f] = content;
+        }
+    }
+    digest.deps = [...new Set(digest.deps)].filter(Boolean);
+    return digest;
+}
+// --- Raw data extractors — no domain knowledge ---
+/** Extract dependency names from any package manifest. Just names, no meaning. */
+function extractDeps(cwd, configFiles) {
+    const deps = [];
+    // package.json — extract keys from dependencies/devDependencies
+    if (configFiles.includes("package.json")) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+            deps.push(...Object.keys(pkg.dependencies ?? {}));
+            deps.push(...Object.keys(pkg.devDependencies ?? {}));
+        }
+        catch { /* skip */ }
+    }
+    // requirements.txt — each non-comment line is a dep
+    if (configFiles.includes("requirements.txt")) {
+        try {
+            const lines = readFileSync(join(cwd, "requirements.txt"), "utf8").split("\n");
+            for (const l of lines) {
+                const dep = l.trim().split(/[>=<!\[;\s]/)[0].trim();
+                if (dep && !dep.startsWith("#") && !dep.startsWith("-"))
+                    deps.push(dep);
             }
         }
-        if (entries.length >= 3)
-            break;
+        catch { /* skip */ }
     }
-    // Step 2: breadth sample from primary source directory
-    let primaryDir = "";
-    let maxCount = 0;
-    for (const dir of PRIMARY_SOURCE_DIRS) {
-        const count = allSourceFiles.filter(f => f.startsWith(dir + "/")).length;
-        if (count > maxCount) {
-            maxCount = count;
-            primaryDir = dir;
+    // pyproject.toml — extract from dependencies sections
+    if (configFiles.includes("pyproject.toml")) {
+        try {
+            const content = readFileSync(join(cwd, "pyproject.toml"), "utf8");
+            deps.push(...extractTomlDeps(content));
         }
+        catch { /* skip */ }
     }
-    const breadthFiles = [];
-    if (primaryDir) {
-        const dirFiles = allSourceFiles
-            .filter(f => f.startsWith(primaryDir + "/"))
-            .filter(f => !entries.includes(f));
-        // Sort smallest first — highest signal-to-size ratio
-        const withSize = dirFiles.map(f => {
-            try {
-                return { path: f, size: statSync(join(cwd, f)).size };
+    // go.mod — require block
+    if (configFiles.includes("go.mod")) {
+        try {
+            const content = readFileSync(join(cwd, "go.mod"), "utf8");
+            const requires = content.match(/require\s*\(([\s\S]*?)\)/)?.[1] ?? "";
+            for (const line of requires.split("\n")) {
+                const dep = line.trim().split(/\s/)[0];
+                if (dep)
+                    deps.push(dep);
             }
-            catch {
-                return { path: f, size: Infinity };
+        }
+        catch { /* skip */ }
+    }
+    // Cargo.toml — [dependencies] section
+    if (configFiles.includes("Cargo.toml")) {
+        try {
+            const content = readFileSync(join(cwd, "Cargo.toml"), "utf8");
+            const depsSection = content.match(/\[dependencies\]([\s\S]*?)(\[|$)/)?.[1] ?? "";
+            for (const line of depsSection.split("\n")) {
+                const dep = line.split("=")[0].trim();
+                if (dep && !dep.startsWith("#"))
+                    deps.push(dep);
             }
-        }).sort((a, b) => a.size - b.size);
-        for (const { path: p } of withSize) {
-            if (breadthFiles.length >= 5)
-                break;
-            breadthFiles.push(p);
         }
+        catch { /* skip */ }
     }
-    // Step 3: fill remaining from other top-level dirs
-    const selected = [...entries, ...breadthFiles];
-    const remaining = allSourceFiles.filter(f => !selected.includes(f));
-    for (const f of remaining) {
-        if (selected.length >= MAX_SOURCE_FILES)
-            break;
-        selected.push(f);
+    // Gemfile — gem lines
+    if (configFiles.includes("Gemfile")) {
+        try {
+            const lines = readFileSync(join(cwd, "Gemfile"), "utf8").split("\n");
+            for (const l of lines) {
+                const match = l.match(/^\s*gem\s+['"]([^'"]+)/);
+                if (match)
+                    deps.push(match[1]);
+            }
+        }
+        catch { /* skip */ }
     }
-    // Step 4: read and truncate
-    for (const filePath of selected) {
-        const fullPath = join(cwd, filePath);
+    // composer.json
+    if (configFiles.includes("composer.json")) {
         try {
-            const stat = statSync(fullPath);
-            if (stat.size > MAX_FILE_BYTES) {
-                skipped.push({ path: filePath, reason: `too large (${(stat.size / 1024).toFixed(0)}KB)` });
+            const pkg = JSON.parse(readFileSync(join(cwd, "composer.json"), "utf8"));
+            deps.push(...Object.keys(pkg.require ?? {}));
+            deps.push(...Object.keys(pkg["require-dev"] ?? {}));
+        }
+        catch { /* skip */ }
+    }
+    return deps;
+}
+/** Extract script/task names */
+function extractScripts(cwd, configFiles) {
+    const scripts = [];
+    if (configFiles.includes("package.json")) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+            scripts.push(...Object.keys(pkg.scripts ?? {}));
+        }
+        catch { /* skip */ }
+    }
+    if (configFiles.includes("Makefile")) {
+        try {
+            const content = readFileSync(join(cwd, "Makefile"), "utf8");
+            for (const m of content.matchAll(/^([a-zA-Z_][\w-]*):/gm)) {
+                scripts.push(m[1]);
+            }
+        }
+        catch { /* skip */ }
+    }
+    return scripts;
+}
+function extractTomlDeps(content) {
+    const deps = [];
+    const sections = content.match(/\[(?:project\.dependencies|tool\.poetry\.dependencies)\]([\s\S]*?)(?:\[|$)/g) ?? [];
+    for (const section of sections) {
+        for (const line of section.split("\n")) {
+            const match = line.match(/^(\w[\w-]*)/);
+            if (match && !line.startsWith("["))
+                deps.push(match[1]);
+        }
+    }
+    const listMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/g);
+    for (const block of listMatch ?? []) {
+        for (const m of block.matchAll(/"([^">=<\[]+)/g)) {
+            deps.push(m[1].trim());
+        }
+    }
+    return deps;
+}
+// --- Digest formatter ---
+function formatDigest(d) {
+    const lines = [];
+    if (d.configFilesFound.length)
+        lines.push(`Config files: ${d.configFilesFound.join(", ")}`);
+    if (d.deps.length)
+        lines.push(`Deps: ${d.deps.join(", ")}`);
+    if (d.scripts.length)
+        lines.push(`Scripts: ${d.scripts.join(", ")}`);
+    if (d.envVars.length)
+        lines.push(`Env vars: ${d.envVars.join(", ")}`);
+    if (d.tree) {
+        lines.push("");
+        lines.push("Structure:");
+        lines.push(d.tree);
+    }
+    return lines.join("\n");
+}
+// --- Directory tree ---
+function buildTree(cwd, blocked, maxDepth, prefix = "", depth = 0) {
+    if (depth > maxDepth)
+        return "";
+    const lines = [];
+    try {
+        const entries = readdirSync(cwd, { withFileTypes: true })
+            .filter(e => !blocked.has(e.name) && !e.name.startsWith("."))
+            .sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        const dirs = entries.filter(e => e.isDirectory());
+        const files = entries.filter(e => e.isFile() && SOURCE_EXTENSIONS.has(extname(e.name)));
+        for (const dir of dirs) {
+            const subPath = join(cwd, dir.name);
+            const fileCount = countSourceFiles(subPath, blocked);
+            if (fileCount === 0)
                 continue;
+            lines.push(`${prefix}${dir.name}/ (${fileCount} files)`);
+            const subtree = buildTree(subPath, blocked, maxDepth, prefix + "  ", depth + 1);
+            if (subtree)
+                lines.push(subtree);
+        }
+        if (depth === 0 && files.length > 0) {
+            for (const f of files.slice(0, 5)) {
+                lines.push(`${prefix}${f.name}`);
             }
-            const raw = readFileSync(fullPath, "utf8");
-            source.push({ path: filePath, content: truncateSource(raw, filePath) });
+            if (files.length > 5)
+                lines.push(`${prefix}... +${files.length - 5} more`);
         }
-        catch {
-            skipped.push({ path: filePath, reason: "could not read" });
+    }
+    catch { /* skip */ }
+    return lines.join("\n");
+}
+function countSourceFiles(dir, blocked) {
+    let count = 0;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const e of entries) {
+            if (blocked.has(e.name) || e.name.startsWith("."))
+                continue;
+            if (e.isFile() && SOURCE_EXTENSIONS.has(extname(e.name)))
+                count++;
+            else if (e.isDirectory())
+                count += countSourceFiles(join(dir, e.name), blocked);
         }
     }
-    return { configs, source, skipped };
+    catch { /* skip */ }
+    return count;
+}
+// --- Source file processing ---
+function extractSignatures(content) {
+    const lines = content.split("\n");
+    const sigs = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*"))
+            continue;
+        // Imports
+        if (/^import\s/.test(trimmed) || /^from\s/.test(trimmed) || /^require\(/.test(trimmed) ||
+            /^const\s+\w+\s*=\s*require/.test(trimmed) || /^use\s/.test(trimmed)) {
+            sigs.push(trimmed);
+            continue;
+        }
+        // Exports
+        if (/^export\s/.test(trimmed) || /^module\.exports/.test(trimmed)) {
+            sigs.push(trimmed.length > 120 ? trimmed.slice(0, 120) + "..." : trimmed);
+            continue;
+        }
+        // Declarations
+        if (/^(export\s+)?(async\s+)?function\s/.test(trimmed) ||
+            /^(export\s+)?(abstract\s+)?class\s/.test(trimmed) ||
+            /^(export\s+)?interface\s/.test(trimmed) ||
+            /^(export\s+)?type\s/.test(trimmed) ||
+            /^(export\s+)?enum\s/.test(trimmed) ||
+            /^def\s/.test(trimmed) || /^class\s/.test(trimmed) ||
+            /^func\s/.test(trimmed) || /^fn\s/.test(trimmed) ||
+            /^pub\s/.test(trimmed) ||
+            /^(public|private|protected)\s/.test(trimmed)) {
+            sigs.push(trimmed.length > 120 ? trimmed.slice(0, 120) + "..." : trimmed);
+        }
+        if (trimmed.startsWith("@") && !trimmed.startsWith("@import")) {
+            sigs.push(trimmed);
+        }
+    }
+    if (sigs.length === 0)
+        return `[${lines.length} lines, no extractable signatures]`;
+    return sigs.join("\n");
+}
+function compactContent(content) {
+    const lines = content.split("\n");
+    const kept = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("//") && !trimmed.startsWith("///"))
+            continue;
+        if (trimmed === "*" || trimmed === "/**" || trimmed === "*/")
+            continue;
+        if (trimmed.startsWith("* ") && !trimmed.startsWith("* @"))
+            continue;
+        if (trimmed.startsWith("#") && !trimmed.startsWith("#!") && !trimmed.startsWith("#include"))
+            continue;
+        kept.push(line);
+    }
+    if (kept.length > 80) {
+        return kept.slice(0, 60).join("\n") + `\n[... ${kept.length - 60} more lines]`;
+    }
+    return kept.join("\n");
+}
+function truncateSource(content) {
+    const lines = content.split("\n");
+    if (lines.length <= 100)
+        return content;
+    if (lines.length <= 300) {
+        return lines.slice(0, 80).join("\n") + `\n[... ${lines.length - 80} more lines]`;
+    }
+    return lines.slice(0, 50).join("\n") + `\n[... truncated — ${lines.length} lines total]`;
 }
-async function findSourceFiles(cwd) {
+// --- Legacy raw config collection ---
+async function collectRawConfigs(cwd, configs, skipped) {
+    for (const name of KNOWN_CONFIG_FILES) {
+        const p = join(cwd, name);
+        if (existsSync(p)) {
+            try {
+                const content = readFileSync(p, "utf8");
+                configs[name] = content.length > 4000 ? content.slice(0, 4000) + "\n[... truncated]" : content;
+            }
+            catch {
+                skipped.push({ path: name, reason: "could not read" });
+            }
+        }
+    }
+}
+// --- Source file discovery ---
+async function findSourceFiles(cwd, maxDepth, blocked) {
     try {
         const files = await glob("**/*", {
-            cwd,
-            nodir: true,
-            ignore: [...BLOCKED_DIRS].map(d => `${d}/**`),
-            maxDepth: 5,
+            cwd, nodir: true,
+            ignore: [...blocked].map(d => `${d}/**`),
+            maxDepth,
         });
         return files
             .filter(f => {
-            const ext = extname(f);
-            const base = basename(f);
-            if (BLOCKED_FILES.has(base))
+            if (BLOCKED_FILES.has(basename(f)))
                 return false;
-            if (BLOCKED_EXTENSIONS.has(ext))
+            if (BLOCKED_EXTENSIONS.has(extname(f)))
                 return false;
-            if (SOURCE_EXTENSIONS.has(ext))
-                return true;
-            return false;
+            return SOURCE_EXTENSIONS.has(extname(f));
         })
             .map(f => f.replace(/\\/g, "/"));
     }
@@ -217,50 +476,60 @@ async function findSourceFiles(cwd) {
         return [];
     }
 }
-function truncateSource(content, path) {
-    const lines = content.split("\n");
-    const total = lines.length;
-    if (total <= 150)
-        return content;
-    if (total <= 400) {
-        return lines.slice(0, 100).join("\n") + `\n[... ${total - 100} more lines truncated]`;
+function selectEntryPoints(files, max) {
+    const entries = [];
+    for (const dir of ENTRY_DIRS) {
+        for (const file of files) {
+            if (entries.length >= max)
+                return entries;
+            const base = basename(file, extname(file));
+            const fileDir = dirname(file);
+            if (ENTRY_BASENAMES.has(base) && (fileDir === dir || fileDir === ".")) {
+                if (!entries.includes(file))
+                    entries.push(file);
+            }
+        }
     }
-    return lines.slice(0, 60).join("\n") + `\n[... truncated — ${total} lines total]`;
+    return entries;
 }
-function firstLines(content, n) {
-    const lines = content.split("\n");
-    if (lines.length <= n)
-        return content;
-    return lines.slice(0, n).join("\n") + `\n[... ${lines.length - n} more lines]`;
-}
-function truncatePackageLock(content) {
-    try {
-        const pkg = JSON.parse(content);
-        return JSON.stringify({
-            name: pkg.name,
-            version: pkg.version,
-            lockfileVersion: pkg.lockfileVersion,
-        }, null, 2);
+function selectBreadthSample(cwd, files, exclude, max, forceDirs) {
+    const selected = [];
+    const dirsToSample = forceDirs.length > 0 ? forceDirs : PRIMARY_SOURCE_DIRS;
+    for (const dir of dirsToSample) {
+        const dirFiles = files
+            .filter(f => f.startsWith(dir + "/"))
+            .filter(f => !exclude.includes(f) && !selected.includes(f));
+        const sorted = dirFiles.sort((a, b) => {
+            try {
+                return statSync(join(cwd, a)).size - statSync(join(cwd, b)).size;
+            }
+            catch {
+                return 0;
+            }
+        });
+        for (const f of sorted) {
+            if (selected.length >= max)
+                return selected;
+            selected.push(f);
+        }
     }
-    catch {
-        return "[package-lock.json: could not parse]";
+    for (const f of files) {
+        if (selected.length >= max)
+            break;
+        if (!exclude.includes(f) && !selected.includes(f))
+            selected.push(f);
     }
+    return selected;
 }
+// --- Empty project detection ---
 export function isEmptyProject(collected) {
     const hasSource = collected.source.length > 0;
-    const hasOnlyBarePackageJson = Object.keys(collected.configs).length === 1 &&
-        "package.json" in collected.configs &&
-        isBarePkgJson(collected.configs["package.json"]);
-    const hasAnyConfig = Object.keys(collected.configs).length > 0;
+    const digestContent = collected.configs["__digest__"] ?? "";
+    const hasDeps = digestContent.includes("Deps:");
+    const rawConfigs = Object.keys(collected.configs).filter(k => k !== "__digest__" && k !== ".env");
+    const hasAnyConfig = rawConfigs.length > 0 || hasDeps;
+    // A bare package.json has no deps
+    const hasOnlyBarePackageJson = !hasDeps && digestContent.includes("package.json") &&
+        !digestContent.includes(","); // only one config file
     return !hasSource && (!hasAnyConfig || hasOnlyBarePackageJson);
 }
-function isBarePkgJson(content) {
-    try {
-        const pkg = JSON.parse(content);
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
-        return Object.keys(deps).length === 0;
-    }
-    catch {
-        return false;
-    }
-}