mapra 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,818 @@
+#!/usr/bin/env node
+/**
+ * mapra CLI
+ *
+ * Commands:
+ *   mapra setup [path]    Generate .mapra and wire CLAUDE.md (first-time setup)
+ *   mapra generate [path] Scan codebase and write .mapra file
+ *   mapra update [path]   Regenerate .mapra in place (alias for generate in cwd)
+ *   mapra init [path]     Wire .mapra into project's CLAUDE.md
+ *   mapra status [path]   Show current mapra setup state
+ *   mapra check [path]    Check if .mapra is current or stale (git hash comparison)
+ *   mapra validate-plan <plan.md> [--since YYYY-MM-DD] [--checkpoints]  Cross-reference plan against .mapra
+ *   mapra batch <config.json> [--resume]  Run batch experiment from config
+ *   mapra analyze <results.json> [--advise] [--judge-check]  Analyze experiment results
+ *   mapra query <type> <file> [--json]  Query structural data (blast_radius, risk_profile, test_map)
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { applyMapraSection, SUPERSESSION_MESSAGE } from "./templates.js";
+import { installAllHooks, uninstallAllHooks, getHooksDir, MAPRA_HOOK_START } from "./hooks.js";
+import { generateHookShim } from "./shim.js";
+const [, , command, ...args] = process.argv;
+if (command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+}
+if (!command) {
+    console.log("No command given — running setup (generate + init) in current directory.");
+    console.log("Use 'mapra --help' to see all commands.\n");
+    await runSetup(undefined);
+    process.exit(0);
+}
+switch (command) {
+    case "setup":
+        await runSetup(args[0]);
+        break;
+    case "generate": {
+        const silent = args.includes("--silent");
+        const targetArg = args.find((a) => !a.startsWith("--"));
+        await runGenerate(targetArg, false, silent);
+        break;
+    }
+    case "update":
+        try {
+            const silent = args.includes("--silent");
+            const targetArg = args.find((a) => !a.startsWith("--"));
+            await runGenerate(targetArg ?? process.cwd(), true, silent);
+        }
+        catch (err) {
+            console.error(`mapra update failed: ${err instanceof Error ? err.message : String(err)}`);
+            console.error("Continuing with stale .mapra. Complete your refactor and retry.");
+        }
+        break;
+    case "init":
+        await runInit(args[0]);
+        break;
+    case "status":
+        await runStatus(args[0]);
+        break;
+    case "check": {
+        const failIfStale = args.includes("--fail-if-stale");
+        const targetArg = args.find((a) => !a.startsWith("--"));
+        await runCheck(targetArg, failIfStale);
+        break;
+    }
+    case "validate-plan": {
+        const sinceIdx = args.indexOf("--since");
+        const since = sinceIdx >= 0 ? args[sinceIdx + 1] : undefined;
+        const checkpoints = args.includes("--checkpoints");
+        const planFile = args.find((a) => !a.startsWith("--") && a !== since);
+        await runValidatePlan(planFile, since, checkpoints);
+        break;
+    }
+    case "batch": {
+        const configFile = args.find((a) => !a.startsWith("--"));
+        const resume = args.includes("--resume");
+        const smart = args.includes("--smart");
+        await runBatchCommand(configFile, resume, smart);
+        break;
+    }
+    case "analyze": {
+        const files = args.filter((a) => !a.startsWith("--"));
+        const advise = args.includes("--advise");
+        const apply = args.includes("--apply");
+        const judgeCheck = args.includes("--judge-check");
+        await runAnalyzeCommand(files, { advise, apply, judgeCheck });
+        break;
+    }
+    case "install-hooks": {
+        const targetPath = resolveTarget(args[0]);
+        const { installed, skipped } = installAllHooks(targetPath);
+        if (skipped) {
+            console.warn(`\u26A0 ${skipped} \u2014 skipping hook installation`);
+        }
+        else {
+            for (const h of installed)
+                console.log(`\u2713 Installed ${h} hook`);
+        }
+        break;
+    }
+    case "uninstall-hooks": {
+        const targetPath = resolveTarget(args[0]);
+        uninstallAllHooks(targetPath);
+        console.log("Removed mapra git hooks");
+        break;
+    }
+    case "query": {
+        try {
+            const { runQueryCommand } = await import("../query/index.js");
+            await runQueryCommand(args);
+        }
+        catch (err) {
+            handleError("query", err);
+        }
+        break;
+    }
+    default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+}
+function printHelp() {
+    console.log(`
+mapra — stop exploring. start building.
+
+Quick start:
+  mapra                        Run setup in current directory (first-time setup)
+  mapra update                 Regenerate .mapra after codebase changes
+
+Commands:
+  setup [path]    Generate .mapra, wire CLAUDE.md, install auto-update hooks
+  generate [path] Scan codebase and write .mapra to project root
+  update [path]   Regenerate .mapra in place (alias for generate in cwd)
+  init [path]     Wire @.mapra reference into project's CLAUDE.md
+  status [path]   Show whether .mapra is present, wired, and fresh
+  check [path]    Check if .mapra is current or stale (compares git hash)
+                  --fail-if-stale: exit code 1 if stale (for CI)
+  install-hooks [path]    Install git hooks for auto-update
+  uninstall-hooks [path]  Remove mapra git hooks
+  validate-plan <plan.md> [--since YYYY-MM-DD] [--checkpoints]
+                  Cross-reference plan file paths against .mapra data
+  batch <config.json> [--resume] [--smart]
+                  Run batch experiment comparing encoding conditions
+                  --smart: score inline and stop early when verdicts are unanimous
+  analyze <results.json> [--advise] [--judge-check]
+                  Analyze experiment results: stats, diagnostics, recommendations
+  analyze <old.json> <new.json>
+                  Compare two experiment iterations
+  query <type> <file> [--json]
+                  Query structural data for a specific file
+                  Types: blast_radius, risk_profile, test_map
+
+Flags:
+  --silent        Suppress output (used by git hooks)
+
+  Default path: current working directory
+
+Auto-update:
+  After setup, .mapra regenerates automatically on commit, merge, and
+  branch switch via git hooks. Teammates get hooks via npm install
+  (prepare script). Run 'mapra status' to check hook state.
+
+Examples:
+  mapra setup                      # first-time setup in cwd
+  mapra setup /path/to/project     # first-time setup for a specific project
+  mapra update                     # refresh after code changes
+  mapra status                     # check current state
+  mapra batch experiments/configs/strand-v3-effectiveness.json
+`);
+}
+async function runSetup(targetArg) {
+    console.log("Setting up mapra...\n");
+    const targetPath = resolveTarget(targetArg ?? process.cwd());
+    // Step 1: Generate .mapra
+    await runGenerate(targetPath);
+    console.log();
+    // Step 2: Wire CLAUDE.md
+    await runInit(targetPath);
+    // Step 3: Write .mapra/hook.mjs
+    const mapraDir = path.join(targetPath, ".mapra");
+    fs.mkdirSync(mapraDir, { recursive: true });
+    const version = getVersion();
+    const shimContent = generateHookShim(version);
+    fs.writeFileSync(path.join(mapraDir, "hook.mjs"), shimContent.replace(/\r\n/g, "\n"));
+    console.log("Wrote .mapra/hook.mjs (auto-update shim)");
+    // Step 4: Write .mapra/.gitignore (ignore lockfile)
+    fs.writeFileSync(path.join(mapraDir, ".gitignore"), ".lock\n");
+    // Step 5: Install git hooks
+    const { installed, skipped } = installAllHooks(targetPath);
+    if (skipped) {
+        console.warn(`\u26A0 ${skipped} \u2014 skipping hook installation`);
+    }
+    else {
+        console.log(`Installed git hooks (${installed.join(", ")})`);
+    }
+    // Step 6: Add .gitattributes entry for linguist-generated
+    const gitattrsPath = path.join(targetPath, ".gitattributes");
+    const gitattrsEntry = ".mapra/hook.mjs linguist-generated=true";
+    if (fs.existsSync(gitattrsPath)) {
+        const existing = fs.readFileSync(gitattrsPath, "utf-8");
+        if (!existing.includes(gitattrsEntry)) {
+            const separator = existing.endsWith("\n") ? "" : "\n";
+            fs.writeFileSync(gitattrsPath, existing + separator + gitattrsEntry + "\n");
+        }
+    }
+    else {
+        fs.writeFileSync(gitattrsPath, gitattrsEntry + "\n");
+    }
+    // Step 7: Add prepare script and devDependency to package.json
+    const pkgJsonPath = path.join(targetPath, "package.json");
+    if (fs.existsSync(pkgJsonPath)) {
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+            let modified = false;
+            // Add prepare script
+            if (!pkgJson.scripts)
+                pkgJson.scripts = {};
+            if (!pkgJson.scripts.prepare || !pkgJson.scripts.prepare.includes("mapra")) {
+                if (pkgJson.scripts.prepare) {
+                    pkgJson.scripts.prepare += " && mapra install-hooks";
+                }
+                else {
+                    pkgJson.scripts.prepare = "mapra install-hooks";
+                }
+                modified = true;
+            }
+            // Add devDependency
+            if (!pkgJson.devDependencies)
+                pkgJson.devDependencies = {};
+            if (!pkgJson.devDependencies.mapra) {
+                pkgJson.devDependencies.mapra = `^${version}`;
+                modified = true;
+            }
+            if (modified) {
+                fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+                console.log("Updated package.json (added mapra devDependency + prepare script)");
+            }
+        }
+        catch {
+            console.warn("\u26A0 Could not update package.json \u2014 add mapra manually");
+        }
+    }
+    console.log("\nDone. Your codebase map will stay fresh automatically.");
+}
+function getVersion() {
+    try {
+        const pkgPath = new URL("../../package.json", import.meta.url);
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function runGenerate(targetArg, softFail = false, silent = false) {
+    const targetPath = resolveTarget(targetArg);
+    try {
+        const { scanCodebase } = await import("../scanner/index.js");
+        const { analyzeGraph } = await import("../analyzer/index.js");
+        const { encodeToStrandFormat } = await import("../encoder/strand-format-encode.js");
+        const { getGitHash } = await import("../analyzer/git-hash.js");
+        const outputPath = path.join(targetPath, ".mapra");
+        if (!silent)
+            console.log(`Scanning ${targetPath}`);
+        const graph = await Promise.resolve(scanCodebase(targetPath));
+        const riskCount = graph.nodes.filter((n) => n.type !== "test" &&
+            n.type !== "config" &&
+            graph.edges.filter((e) => e.to === n.id).length > 3).length;
+        if (!silent) {
+            console.log(`  ${graph.totalFiles} files  ${graph.totalLines.toLocaleString()} lines  ${graph.modules.length} modules  ${riskCount} high-import files`);
+        }
+        const analysis = analyzeGraph(graph, targetPath);
+        const gitHash = getGitHash(targetPath);
+        const encoded = encodeToStrandFormat(graph, analysis, { gitHash });
+        const tokens = Math.round(encoded.length / 4);
+        const tmpPath = outputPath + ".tmp";
+        fs.writeFileSync(tmpPath, encoded, "utf-8");
+        try {
+            fs.renameSync(tmpPath, outputPath);
+        }
+        catch {
+            // Windows: rename can fail if another process holds a read handle.
+            // Fall back to direct write.
+            fs.writeFileSync(outputPath, encoded, "utf-8");
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmpPath);
+            }
+            catch { /* .tmp already renamed or gone */ }
+        }
+        // Write query cache alongside .mapra — failure is non-fatal
+        try {
+            const { writeCache, ensureCacheInGitignore } = await import("../query/cache.js");
+            const { execSync } = await import("child_process");
+            let fullHash;
+            try {
+                fullHash = execSync("git rev-parse HEAD", {
+                    cwd: targetPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"],
+                }).trim() || undefined;
+            }
+            catch { /* not a git repo */ }
+            writeCache(targetPath, graph, analysis, fullHash);
+            ensureCacheInGitignore(targetPath);
+        }
+        catch (cacheErr) {
+            if (!silent) {
+                console.warn(`\u26A0 Failed to write .mapra-cache.json: ${cacheErr instanceof Error ? cacheErr.message : String(cacheErr)}`);
+            }
+        }
+        if (!silent) {
+            const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "");
+            console.log(`\nWrote .mapra  (${encoded.length.toLocaleString()} chars  ~${tokens} tokens)`);
+            console.log(SUPERSESSION_MESSAGE(timestamp));
+        }
+    }
+    catch (err) {
+        if (softFail)
+            throw err;
+        handleError("generate", err);
+    }
+}
+async function runInit(targetArg) {
+    const targetPath = resolveTarget(targetArg);
+    try {
+        const strandPath = path.join(targetPath, ".mapra");
+        const claudePath = path.join(targetPath, "CLAUDE.md");
+        // Guard: .mapra must exist and be non-empty
+        if (!fs.existsSync(strandPath)) {
+            console.error(`Error: .mapra not found at ${strandPath}`);
+            console.error(`Run 'mapra generate' or 'mapra setup' first.`);
+            process.exit(1);
+        }
+        const strandSize = fs.statSync(strandPath).size;
+        if (strandSize < 100) {
+            console.error(`Warning: .mapra appears malformed (${strandSize} bytes). Re-run 'mapra generate'.`);
+            process.exit(1);
+        }
+        const existingContent = fs.existsSync(claudePath)
+            ? fs.readFileSync(claudePath, "utf-8")
+            : null;
+        const { content, action } = applyMapraSection(existingContent);
+        if (action === "up-to-date") {
+            console.log(`Already up to date — CLAUDE.md has current mapra section`);
+            return;
+        }
+        fs.writeFileSync(claudePath, content, "utf-8");
+        const messages = {
+            created: `Created CLAUDE.md and wired @.mapra`,
+            upgraded: `Upgraded mapra section in CLAUDE.md`,
+            "legacy-upgraded": `Upgraded CLAUDE.md — added section markers for future updates`,
+            appended: `Wired — added @.mapra reference to ${claudePath}`,
+        };
+        console.log(messages[action]);
+    }
+    catch (err) {
+        handleError("init", err);
+    }
+}
+async function runStatus(targetArg) {
+    const targetPath = resolveTarget(targetArg);
+    const strandPath = path.join(targetPath, ".mapra");
+    const claudePath = path.join(targetPath, "CLAUDE.md");
+    const gitignorePath = path.join(targetPath, ".gitignore");
+    console.log(`Status for: ${targetPath}\n`);
+    // .mapra presence and staleness
+    if (!fs.existsSync(strandPath)) {
+        console.log(`  .mapra        ✗ not found (run 'mapra setup')`);
+    }
+    else {
+        const { parseStrandHeader } = await import("../encoder/parse-strand-header.js");
+        const { getGitHash } = await import("../analyzer/git-hash.js");
+        const strandContent = fs.readFileSync(strandPath, "utf-8");
+        const header = parseStrandHeader(strandContent);
+        const strandMtime = fs.statSync(strandPath).mtimeMs;
+        const sourceMtime = newestSourceFileMtime(targetPath);
+        const ageMs = Date.now() - strandMtime;
+        const ageDays = Math.floor(ageMs / 86_400_000);
+        const ageStr = ageDays === 0 ? "today" : `${ageDays} day${ageDays !== 1 ? "s" : ""} ago`;
+        // Use git hash comparison if available, fall back to mtime
+        const currentHash = getGitHash(targetPath);
+        let staleStr = "";
+        if (header?.gitHash && currentHash) {
+            if (header.gitHash !== currentHash) {
+                staleStr = ` \u26A0 stale (generated at git:${header.gitHash}, HEAD is ${currentHash})`;
+            }
+        }
+        else {
+            const stale = sourceMtime > strandMtime;
+            staleStr = stale ? " \u26A0 may be stale (run 'mapra update')" : "";
+        }
+        console.log(`  .mapra        \u2713 present (updated ${ageStr})${staleStr}`);
+    }
+    // CLAUDE.md wiring
+    if (!fs.existsSync(claudePath)) {
+        console.log(`  CLAUDE.md     ✗ not found (run 'mapra init')`);
+    }
+    else {
+        const content = fs.readFileSync(claudePath, "utf-8");
+        const wired = /^@\.mapra$/m.test(content);
+        console.log(`  CLAUDE.md     ${wired ? "✓ wired" : "✗ not wired (run 'mapra init')"}`);
+    }
+    // .gitignore check
+    if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+        if (/^\.?mapra$/m.test(gitignore) || /^\*\.mapra$/m.test(gitignore)) {
+            console.log(`  .gitignore    ⚠ .mapra appears to be ignored — collaborators won't have the map`);
+        }
+    }
+    // Hook installation check
+    const hooksDir = getHooksDir(targetPath);
+    if (hooksDir) {
+        const postCommit = path.join(hooksDir, "post-commit");
+        if (fs.existsSync(postCommit)) {
+            const content = fs.readFileSync(postCommit, "utf-8");
+            const hasStrnd = content.includes(MAPRA_HOOK_START);
+            console.log(`  git hooks     ${hasStrnd ? "\u2713 installed" : "\u2717 not installed (run 'mapra setup')"}`);
+        }
+        else {
+            console.log(`  git hooks     \u2717 not installed (run 'mapra setup')`);
+        }
+    }
+    else {
+        console.log(`  git hooks     \u2717 no .git directory`);
+    }
+    // .mapra/hook.mjs check
+    const shimPath = path.join(targetPath, ".mapra", "hook.mjs");
+    if (fs.existsSync(shimPath)) {
+        console.log(`  hook shim     \u2713 present`);
+    }
+    else {
+        console.log(`  hook shim     \u2717 not found (run 'mapra setup')`);
+    }
+    console.log();
+}
+async function runCheck(targetArg, failIfStale = false) {
+    const targetPath = resolveTarget(targetArg);
+    const strandPath = path.join(targetPath, ".mapra");
+    if (!fs.existsSync(strandPath)) {
+        console.error(".mapra not found. Run 'mapra setup' or 'mapra generate' first.");
+        process.exit(1);
+    }
+    const { parseStrandHeader } = await import("../encoder/parse-strand-header.js");
+    const { getGitHash } = await import("../analyzer/git-hash.js");
+    const { execSync } = await import("child_process");
+    const strandContent = fs.readFileSync(strandPath, "utf-8");
+    const header = parseStrandHeader(strandContent);
+    if (!header) {
+        console.error(".mapra header is malformed. Run 'mapra generate' to regenerate.");
+        process.exit(1);
+    }
+    const currentHash = getGitHash(targetPath);
+    // Case 1: No git available
+    if (!currentHash) {
+        console.log(`.mapra generated ${header.timestamp} (not a git repo — cannot compare)`);
+        process.exit(0);
+    }
+    // Case 2: Legacy .mapra without git hash
+    if (!header.gitHash) {
+        console.log(`.mapra generated ${header.timestamp} (no git hash in header — run 'mapra update' to add)`);
+        if (failIfStale) {
+            console.log("Cannot determine staleness without git hash in .mapra header.");
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Case 3: Current — hashes match
+    if (header.gitHash === currentHash) {
+        console.log(`.mapra is current (generated at commit ${header.gitHash}, HEAD is ${currentHash})`);
+        process.exit(0);
+    }
+    // Case 4: Stale — hashes differ
+    let commitsAhead = "unknown";
+    let changedFiles = "unknown";
+    try {
+        commitsAhead = execSync(`git rev-list --count ${header.gitHash}..HEAD`, {
+            cwd: targetPath,
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        // git rev-list may fail if the generation commit is not in history (e.g., rebase)
+    }
+    try {
+        const diffOutput = execSync(`git diff --name-only ${header.gitHash}..HEAD`, {
+            cwd: targetPath,
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        changedFiles = diffOutput ? String(diffOutput.split("\n").length) : "0";
+    }
+    catch {
+        // git diff may fail if the generation commit is not in history
+    }
+    console.log(`.mapra may be stale:`);
+    console.log(`  Generated: ${header.timestamp} (commit ${header.gitHash})`);
+    console.log(`  Current HEAD: ${currentHash} (${commitsAhead} commits ahead)`);
+    console.log(`  Changed files since generation: ${changedFiles}`);
+    console.log(`  Run 'mapra update' to refresh.`);
+    if (failIfStale) {
+        process.exit(1);
+    }
+    process.exit(0);
+}
+async function runValidatePlan(planArg, sinceDate, checkpoints = false) {
+    if (!planArg) {
+        console.error("Usage: mapra validate-plan <plan.md> [--since YYYY-MM-DD] [--checkpoints]");
+        process.exit(1);
+    }
+    const planPath = path.resolve(planArg);
+    if (!fs.existsSync(planPath)) {
+        console.error(`Error: plan file not found: ${planPath}`);
+        process.exit(1);
+    }
+    // Find project root (walk up to find .mapra)
+    let projectRoot = path.dirname(planPath);
+    while (projectRoot !== path.dirname(projectRoot)) {
+        if (fs.existsSync(path.join(projectRoot, ".mapra")))
+            break;
+        projectRoot = path.dirname(projectRoot);
+    }
+    const strandPath = path.join(projectRoot, ".mapra");
+    if (!fs.existsSync(strandPath)) {
+        console.error("Error: no .mapra file found. Run 'mapra generate' first.");
+        process.exit(1);
+    }
+    // Staleness check: warn if .mapra is older than newest source file
+    const strandMtime = fs.statSync(strandPath).mtimeMs;
+    const sourceMtime = newestSourceFileMtime(projectRoot);
+    if (sourceMtime > strandMtime) {
+        const ageDays = Math.floor((Date.now() - strandMtime) / 86_400_000);
+        console.warn(`Warning: .mapra is ${ageDays > 0 ? `${ageDays}d` : "<1d"} old and source files have changed since.`);
+        console.warn(`Run 'mapra generate' first for accurate churn and risk data.\n`);
+    }
+    const { extractFilePaths, detectMissingCheckpoints } = await import("./plan-parser.js");
+    const { scanCodebase } = await import("../scanner/index.js");
+    const { analyzeGraph } = await import("../analyzer/index.js");
+    const planContent = fs.readFileSync(planPath, "utf-8");
+    const planPaths = extractFilePaths(planContent);
+    console.log(`Plan references ${planPaths.length} files. Validating against current codebase...\n`);
+    if (planPaths.length === 0) {
+        console.log("No file paths found in plan. Nothing to validate.");
+        return;
+    }
+    // Scan and analyze
+    const graph = scanCodebase(projectRoot);
+    const analysis = analyzeGraph(graph, projectRoot);
+    // Build lookup maps
+    const riskMap = new Map(analysis.risk.map((r) => [r.nodeId, r]));
+    const nodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+    const testCounts = new Map();
+    for (const edge of graph.edges) {
+        if (edge.type === "tests") {
+            testCounts.set(edge.to, (testCounts.get(edge.to) ?? 0) + 1);
+        }
+    }
+    // Parse --since date
+    const since = sinceDate ? new Date(sinceDate) : undefined;
+    // Categorize plan files
+    const stale = [];
+    const highCascade = [];
+    const notFound = [];
+    for (const filePath of planPaths) {
+        const node = nodeMap.get(filePath);
+        const risk = riskMap.get(filePath);
+        const churn = analysis.churn.get(filePath);
+        if (!node) {
+            notFound.push(filePath);
+            continue;
+        }
+        // Stale: has churn data (modified recently)
+        if (churn && churn.commits30d > 0) {
+            if (!since || new Date(churn.lastCommitDate) >= since) {
+                stale.push({ path: filePath, churn, risk });
+            }
+        }
+        // High cascade: amplification >= 2.0
+        if (risk && risk.amplificationRatio >= 2.0) {
+            highCascade.push({
+                path: filePath,
+                risk,
+                node,
+                tests: testCounts.get(filePath) ?? 0,
+            });
+        }
+    }
+    // Report: STALE
+    if (stale.length > 0) {
+        console.log(`STALE (modified${since ? ` since ${since.toISOString().slice(0, 10)}` : " in last 30 days"}):`);
+        for (const s of stale) {
+            console.log(`  ${s.path}`);
+            if (s.churn) {
+                console.log(`    ${s.churn.commits30d} commits, +${s.churn.linesAdded30d} -${s.churn.linesRemoved30d} lines`);
+                console.log(`    Last: "${s.churn.lastCommitMsg}" (${s.churn.lastCommitDate.slice(0, 10)})`);
+            }
+            if (s.risk) {
+                const amp = s.risk.amplificationRatio >= 2.0 ? "[AMP] " : "";
+                console.log(`    RISK: ${amp}amp${s.risk.amplificationRatio.toFixed(1)} ×${s.risk.directImporters}→${s.risk.affectedCount} d${s.risk.maxDepth}`);
+            }
+        }
+        console.log();
+    }
+    // Report: HIGH CASCADE
+    if (highCascade.length > 0) {
+        console.log("HIGH CASCADE (amplification >= 2.0):");
+        for (const h of highCascade) {
+            console.log(`  ${h.path}`);
+            console.log(`    RISK: [AMP] amp${h.risk.amplificationRatio.toFixed(1)} ×${h.risk.directImporters}→${h.risk.affectedCount} d${h.risk.maxDepth}`);
+            if (h.node?.exports && h.node.exports.length > 0) {
+                const shown = h.node.exports.filter((e) => e !== "default").slice(0, 5);
+                if (shown.length > 0)
+                    console.log(`    exports: ${shown.join(", ")}`);
+            }
+            console.log(`    Tests: ${h.tests} file${h.tests !== 1 ? "s" : ""}`);
+        }
+        console.log();
+    }
+    // Report: MISSING CONVENTIONS
+    if (analysis.conventions.length > 0) {
+        const missing = [];
+        for (const conv of analysis.conventions) {
+            // Check if plan adds new files of this consumer type
+            const newFilesOfType = notFound.filter((p) => {
+                // Rough type detection from path
+                if (conv.consumerType === "api-route" &&
+                    /\/api\/.*route\.(ts|js)$/.test(p))
+                    return true;
+                if (conv.consumerType === "route" && /\/page\.(tsx|jsx)$/.test(p))
+                    return true;
+                return false;
+            });
+            if (newFilesOfType.length > 0) {
+                const label = conv.anchorExports.slice(0, 2).join(", ") ||
+                    conv.anchorFile
+                        .split("/")
+                        .pop()
+                        ?.replace(/\.\w+$/, "") ||
+                    "?";
+                missing.push(`Plan adds ${conv.consumerType} but may not import ${label} from ${conv.anchorFile} (${conv.adoption}/${conv.total} ${conv.consumerType}s use it)`);
+            }
+        }
+        if (missing.length > 0) {
+            console.log("MISSING CONVENTIONS:");
+            for (const m of missing) {
+                console.log(`  ${m}`);
+            }
+            console.log();
+        }
+    }
+    // Report: DEAD CODE REFERENCED
+    const deadCodeSet = new Set(analysis.deadCode);
+    const deadRefs = planPaths.filter((p) => deadCodeSet.has(p));
+    if (deadRefs.length > 0) {
+        console.log("DEAD CODE REFERENCED (plan modifies unreachable files):");
+        for (const d of deadRefs) {
+            console.log(`  ${d}`);
+        }
+        console.log();
+    }
+    // Report: NOT FOUND (new files the plan will create)
+    if (notFound.length > 0) {
+        console.log(`NEW FILES (${notFound.length} paths not in current codebase):`);
+        for (const p of notFound) {
+            console.log(`  ${p}`);
+        }
+        console.log();
+    }
+    // Summary
+    console.log(`SUMMARY: ${stale.length} stale, ${highCascade.length} high-cascade, ${deadRefs.length} dead-code, ${notFound.length} new files`);
+    // Checkpoint validation
+    if (checkpoints) {
+        const cpWarnings = detectMissingCheckpoints(planContent);
+        if (cpWarnings.length > 0) {
+            console.log("\nMISSING CHECKPOINTS:");
+            for (const w of cpWarnings) {
+                console.log(`  \u26A0 ${w}`);
+            }
+            console.log(`\n  Add [CHECKPOINT] steps after architectural changes: run \`mapra update\`,`);
+            console.log(`  then use the Read tool or \`cat .mapra\` to load fresh data into context.`);
+        }
+        else {
+            console.log("\nCHECKPOINTS: all architectural steps have checkpoints.");
+        }
+    }
+}
+async function runBatchCommand(configArg, resume, smart) {
+    if (!configArg) {
+        console.error("Usage: mapra batch <config.json> [--resume] [--smart]");
+        process.exit(1);
+    }
+    const configPath = path.resolve(configArg);
+    if (!fs.existsSync(configPath)) {
+        console.error(`Error: config file not found: ${configPath}`);
+        process.exit(1);
+    }
+    if (!process.env["ANTHROPIC_API_KEY"]) {
+        console.error("Error: ANTHROPIC_API_KEY environment variable is required");
+        console.error("  Set it: ANTHROPIC_API_KEY=sk-... mapra batch <config>");
+        process.exit(1);
+    }
+    try {
+        const { runBatch } = await import("../batch/runner.js");
+        await runBatch(configPath, { resume, smart });
+    }
+    catch (err) {
+        handleError("batch", err);
+    }
+}
+async function runAnalyzeCommand(files, options) {
+    if (files.length === 0) {
+        console.error("Usage: mapra analyze <results.json> [results2.json] [--advise] [--apply] [--judge-check]");
+        process.exit(1);
+    }
+    const { analyzeResults, formatReport, compareIterations, formatComparison } = await import("../batch/analyzer.js");
+    const resultsPath = path.resolve(files[0]);
+    if (!fs.existsSync(resultsPath)) {
+        console.error(`Error: results file not found: ${resultsPath}`);
+        process.exit(1);
+    }
+    const batch = JSON.parse(fs.readFileSync(resultsPath, "utf-8"));
+    if (files.length === 1) {
+        const report = analyzeResults(batch);
+        console.log(formatReport(report));
+        if (options.judgeCheck) {
+            if (!process.env["ANTHROPIC_API_KEY"]) {
+                console.error("Error: --judge-check requires ANTHROPIC_API_KEY");
+                process.exit(1);
+            }
+            const { runJudgeCheck, formatJudgeCheck } = await import("../batch/judge-check.js");
+            const check = await runJudgeCheck(batch);
+            console.log(formatJudgeCheck(check));
+        }
+        if (options.advise) {
+            if (!process.env["ANTHROPIC_API_KEY"]) {
+                console.error("Error: --advise requires ANTHROPIC_API_KEY");
+                process.exit(1);
+            }
+            const { generateAdvice, formatAdvice } = await import("../batch/advisor.js");
+            const advice = await generateAdvice(report, batch);
+            console.log(formatAdvice(advice));
+            if (options.apply) {
+                console.log("\n--apply: config generation not yet implemented");
+            }
+        }
+    }
+    else {
+        const afterPath = path.resolve(files[1]);
+        if (!fs.existsSync(afterPath)) {
+            console.error(`Error: results file not found: ${afterPath}`);
+            process.exit(1);
+        }
+        const after = JSON.parse(fs.readFileSync(afterPath, "utf-8"));
+        const comp = compareIterations(batch, after);
+        console.log(formatComparison(comp));
+    }
+}
+// ─── Helpers ────────────────────────────────────────────
+function resolveTarget(targetArg) {
+    const targetPath = path.resolve(targetArg ?? process.cwd());
+    if (!fs.existsSync(targetPath)) {
+        console.error(`Error: path does not exist: ${targetPath}`);
+        process.exit(1);
+    }
+    const stat = fs.statSync(targetPath);
+    if (!stat.isDirectory()) {
+        console.error(`Error: expected a directory, got a file: ${targetPath}`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(path.join(targetPath, "package.json"))) {
+        console.warn(`Warning: no package.json found at ${targetPath} — are you in the right directory?`);
+    }
+    return targetPath;
+}
+function handleError(command, err) {
+    if (err instanceof Error &&
+        err.code === "EACCES") {
+        console.error(`Error: permission denied`);
+        process.exit(1);
+    }
+    console.error(`Error: ${command} failed unexpectedly`);
+    if (err instanceof Error)
+        console.error(err.message);
+    console.error(`\nPlease report this at https://github.com/joellopezjl96/mapra/issues`);
+    process.exit(1);
+}
+function newestSourceFileMtime(targetPath) {
+    // Only check top-level src/ to avoid scanning everything
+    const srcPath = path.join(targetPath, "src");
+    if (!fs.existsSync(srcPath))
+        return 0;
+    let newest = 0;
+    function scan(dir) {
+        try {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name === "node_modules" || entry.name === ".git")
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    scan(full);
+                }
+                else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+                    const mtime = fs.statSync(full).mtimeMs;
+                    if (mtime > newest)
+                        newest = mtime;
+                }
+            }
+        }
+        catch {
+            // skip unreadable dirs
+        }
+    }
+    scan(srcPath);
+    return newest;
+}
+//# sourceMappingURL=index.js.map