@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/commands/install.js

@@ -1,505 +0,0 @@
-/**
- * `unerr install <agent>` — Install unerr for a specific AI coding agent.
- *
- * Following the Graphify pattern: explicit per-agent installation.
- * Each install writes the MCP config + installs intelligence skills.
- *
- * Examples:
- *   unerr install claude-code   → .mcp.json + .claude/skills/
- *   unerr install cursor        → .cursor/mcp.json + .cursor/rules/
- *   unerr install vscode        → .vscode/mcp.json + .github/copilot/
- *
- * All output to stderr (stdout is MCP-sacred).
- */
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-import { AGENT_REGISTRY, getAgent, normalizeAgentName, } from "../config/agent-registry.js";
-import { addDisallowedTools, mergePreToolUseBashHook, } from "../config/claude-settings-hooks.js";
-import { installClaudeHook } from "../config/hook-installer.js";
-import { generateCustomInstructions, writeInstructionFile, } from "../config/instruction-writer.js";
-import { isConfigured, writeMcpConfig } from "../config/mcp-config-writer.js";
-import { BUNDLED_SKILLS } from "../skills/local-pack.js";
-import { resolveAndInstallSkills } from "../skills/resolver.js";
-export function registerInstallCommand(program) {
-    program
-        .command("install [agent]")
-        .description("Install unerr for a specific AI coding agent")
-        .option("--force", "Overwrite existing configuration")
-        .option("--no-force-tools", "Keep built-in Read/Grep/Glob enabled (Claude Code only, default: denied)")
-        .option("--show-skills", "Print skill content for manual installation")
-        .option("--show-instructions [agent]", "Print setup instructions for any AI coding agent")
-        .action(async (agent, opts) => {
-        const cwd = process.cwd();
-        // --show-instructions: print agent-specific or generic setup guide
-        if (opts?.showInstructions !== undefined) {
-            const targetAgent = typeof opts.showInstructions === "string"
-                ? opts.showInstructions
-                : (agent ?? "other");
-            showSetupInstructions(normalizeAgentName(targetAgent));
-            return;
-        }
-        // --show-skills: print skill content for manual copy
-        if (opts?.showSkills) {
-            await showSkillContent();
-            return;
-        }
-        // No agent specified — show available agents
-        if (!agent) {
-            showAvailableAgents(cwd);
-            return;
-        }
-        // Normalize agent name (allow "claude" as alias for "claude-code")
-        const normalizedAgent = normalizeAgentName(agent);
-        const agentDef = getAgent(normalizedAgent);
-        if (!agentDef) {
-            process.stderr.write(`\x1b[31m✗\x1b[0m Unknown agent: "${agent}"\n\n`);
-            showAvailableAgents(cwd);
-            return;
-        }
-        const result = await runInstall(cwd, normalizedAgent, {
-            forceTools: opts?.forceTools,
-        });
-        // Display results
-        process.stderr.write("\n");
-        process.stderr.write(`  \x1b[38;2;139;92;246m◆\x1b[0m \x1b[1munerr → ${agentDef.name}\x1b[0m\n`);
-        process.stderr.write("\n");
-        // MCP config
-        if (result.mcpConfig.action === "created") {
-            process.stderr.write(`  \x1b[38;2;52;211;153m✓\x1b[0m MCP config created → ${result.mcpConfig.path}\n`);
-        }
-        else if (result.mcpConfig.action === "updated") {
-            process.stderr.write(`  \x1b[38;2;52;211;153m✓\x1b[0m MCP config updated → ${result.mcpConfig.path}\n`);
-        }
-        else {
-            process.stderr.write(`  \x1b[38;2;161;161;170m·\x1b[0m MCP config already present → ${result.mcpConfig.path}\n`);
-        }
-        // Skills
-        if (result.skillsInstalled > 0) {
-            process.stderr.write(`  \x1b[38;2;52;211;153m✓\x1b[0m ${result.skillsInstalled} intelligence skills installed\n`);
-        }
-        // Hook
-        if (result.hookInstalled) {
-            process.stderr.write("  \x1b[38;2;52;211;153m✓\x1b[0m PreToolUse hook installed (graph-first navigation)\n");
-        }
-        // Gitignore
-        if (result.gitignoreUpdated) {
-            process.stderr.write("  \x1b[38;2;52;211;153m✓\x1b[0m .unerr added to .gitignore\n");
-        }
-        // Instructions
-        if (result.instructionsInjected) {
-            process.stderr.write(`  \x1b[38;2;52;211;153m✓\x1b[0m Tool preferences → ${result.instructionPath}\n`);
-        }
-        // S8: Disallowed tools (default-on for Claude Code)
-        if (result.toolsDenied > 0) {
-            process.stderr.write("  \x1b[38;2;52;211;153m✓\x1b[0m Built-in Read/Grep/Glob denied (use --no-force-tools to keep)\n");
-        }
-        process.stderr.write("\n");
-        process.stderr.write("  \x1b[38;2;161;161;170mRun \x1b[0munerr\x1b[38;2;161;161;170m to start the intelligence engine.\x1b[0m\n");
-        process.stderr.write("\n");
-    });
-}
-/**
- * Core install logic — writes MCP config + skills for a single agent.
- */
-export async function runInstall(cwd, ide, opts) {
-    const agentDef = getAgent(ide);
-    const agentName = agentDef?.name ?? ide;
-    // 1. Write MCP config (project-level)
-    const mcpConfig = writeMcpConfig(cwd, ide);
-    // 2. Install skills into agent-specific directory
-    let skillsInstalled = 0;
-    try {
-        const result = await resolveAndInstallSkills({ ide, cwd });
-        skillsInstalled = result.installed.length;
-    }
-    catch {
-        // Non-blocking
-    }
-    // 3. Install hooks if supported: agent-specific hook registration
-    let hookInstalled = false;
-    if (agentDef?.hookSupport) {
-        try {
-            if (ide === "claude-code") {
-                // Claude Code: PostToolUse shell hook + PreToolUse/PostToolUse/UserPromptSubmit settings hooks
-                const hookResult = installClaudeHook(cwd);
-                const preTool = mergePreToolUseBashHook(cwd);
-                hookInstalled =
-                    hookResult.action === "installed" ||
-                        preTool.action === "merged" ||
-                        preTool.action === "already_present";
-            }
-            else if (ide === "cursor") {
-                // Cursor: hook config in .cursor/hooks.json (when supported)
-                hookInstalled = installCursorHooks(cwd);
-            }
-            else if (ide === "cline") {
-                // Cline: hook scripts in .clinerules/hooks/ (when supported)
-                hookInstalled = installClineHooks(cwd);
-            }
-        }
-        catch {
-            // Non-blocking
-        }
-    }
-    // 4. Ensure .unerr is in .gitignore
-    const gitignoreUpdated = ensureGitignore(cwd);
-    // 5. Inject tool preferences into agent instruction file
-    let instructionsInjected = false;
-    let instructionPath = "";
-    try {
-        const instrResult = writeInstructionFile(cwd, ide);
-        instructionsInjected =
-            instrResult.action === "created" || instrResult.action === "updated";
-        instructionPath = instrResult.path;
-    }
-    catch {
-        // Non-blocking
-    }
-    // 6. S8: Deny built-in tools (Claude Code only, default-on)
-    // --no-force-tools opts out; otherwise always deny Read/Grep/Glob
-    let toolsDenied = 0;
-    const shouldDenyTools = opts?.forceTools !== false && ide === "claude-code";
-    if (shouldDenyTools) {
-        try {
-            const deny = addDisallowedTools(cwd);
-            toolsDenied = deny.added;
-        }
-        catch {
-            // Non-blocking
-        }
-    }
-    // 7. Register repo with daemon supervisor and start the per-repo process (only if unerrd is running)
-    let repoRegistered = false;
-    try {
-        const { daemonSockPath, probeDaemon, ensureRepo } = await import("../daemon/client.js");
-        const { addRepo, findRepo } = await import("../daemon/registry.js");
-        const sock = daemonSockPath();
-        const daemonRunning = await probeDaemon(sock);
-        if (daemonRunning) {
-            if (!findRepo(cwd)) {
-                addRepo(cwd, {});
-                repoRegistered = true;
-                process.stderr.write("\x1b[38;2;52;211;153m✓\x1b[0m Registered repo with unerrd.\n");
-            }
-            // Ask the daemon to start the per-repo process
-            try {
-                await ensureRepo(sock, cwd);
-                process.stderr.write("\x1b[38;2;52;211;153m✓\x1b[0m unerr process started via daemon.\n");
-            }
-            catch {
-                process.stderr.write("\x1b[38;2;251;191;36m⚠\x1b[0m Repo registered but process did not start. It will start on next IDE connection.\n");
-            }
-        }
-        else {
-            process.stderr.write("\x1b[38;2;34;211;238m▸\x1b[0m Daemon not running. To use daemon mode: \x1b[1munerr daemon initialize\x1b[0m\n" +
-                "  For standalone mode: run \x1b[1munerr\x1b[0m in this directory.\n");
-        }
-    }
-    catch {
-        // Non-blocking — user can register later
-    }
-    return {
-        agent: agentName,
-        mcpConfig,
-        skillsInstalled,
-        hookInstalled,
-        gitignoreUpdated,
-        instructionsInjected,
-        instructionPath,
-        toolsDenied,
-        repoRegistered,
-    };
-}
-/**
- * Display available agents with install status.
- */
-function showAvailableAgents(cwd) {
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;139;92;246m◆\x1b[0m \x1b[1munerr install <agent>\x1b[0m\n");
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mInstall unerr intelligence for a specific AI coding agent.\x1b[0m\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mWrites MCP config + installs skills (project-level, never global).\x1b[0m\n");
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mAgent              Command                          Status\x1b[0m\n");
-    process.stderr.write("  \x1b[2m─────────────────────────────────────────────────────────────────\x1b[0m\n");
-    for (const agent of AGENT_REGISTRY) {
-        const installed = isConfigured(cwd, agent.id);
-        const status = installed
-            ? "\x1b[38;2;52;211;153m✓ installed\x1b[0m"
-            : "\x1b[38;2;161;161;170m·\x1b[0m";
-        const name = agent.name.padEnd(18);
-        const cmd = `unerr install ${agent.id}`.padEnd(32);
-        process.stderr.write(`  ${name} ${cmd} ${status}\n`);
-    }
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mExample:\x1b[0m unerr install claude-code\n");
-    process.stderr.write("\n");
-}
-/**
- * Print bundled skill content for manual installation into custom agents.
- */
-async function showSkillContent() {
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;139;92;246m◆\x1b[0m \x1b[1munerr intelligence skills\x1b[0m\n");
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mCopy these into your agent's rules/prompts directory.\x1b[0m\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mThey teach the agent to use unerr's graph tools before reading files.\x1b[0m\n");
-    for (const skill of BUNDLED_SKILLS) {
-        process.stderr.write("\n");
-        process.stderr.write(`  \x1b[2m── ${skill.name} ──────────────────────────────────────────\x1b[0m\n`);
-        process.stderr.write(`  \x1b[38;2;161;161;170m${skill.description}\x1b[0m\n\n`);
-        // Print content with indentation
-        for (const line of skill.content.split("\n")) {
-            process.stderr.write(`  ${line}\n`);
-        }
-    }
-    process.stderr.write("\n");
-    process.stderr.write("  \x1b[38;2;161;161;170mMCP config to add alongside skills:\x1b[0m\n\n");
-    process.stderr.write(`  ${JSON.stringify({ mcpServers: { unerr: { command: "unerr", args: ["--mcp"] } } }, null, 2)
-        .split("\n")
-        .join("\n  ")}\n`);
-    process.stderr.write("\n");
-}
-/**
- * Print detailed setup instructions for a specific agent or generic guide.
- */
-function showSetupInstructions(agentName) {
-    const agentDef = getAgent(agentName);
-    const w = (s) => process.stderr.write(s);
-    w("\n");
-    if (agentDef) {
-        // Known agent — show agent-specific instructions
-        w(`  \x1b[38;2;139;92;246m◆\x1b[0m \x1b[1mSetup instructions for ${agentDef.name}\x1b[0m\n\n`);
-        // Step 1: MCP config
-        w("  \x1b[1m1. MCP Configuration\x1b[0m\n");
-        w(`     Add to ${agentDef.projectConfigPath}:\n\n`);
-        if (agentDef.configFormat === "settings-json") {
-            w(`     ${JSON.stringify({ mcpServers: { unerr: { command: "unerr", args: ["--mcp"] } } }, null, 2)
-                .split("\n")
-                .join("\n     ")}\n\n`);
-        }
-        else if (agentDef.configFormat === "continue-config") {
-            w(`     ${JSON.stringify({
-                mcpServers: [{ name: "unerr", command: "unerr", args: ["--mcp"] }],
-            }, null, 2)
-                .split("\n")
-                .join("\n     ")}\n\n`);
-        }
-        else {
-            w(`     ${JSON.stringify({ mcpServers: { unerr: { command: "unerr", args: ["--mcp"] } } }, null, 2)
-                .split("\n")
-                .join("\n     ")}\n\n`);
-        }
-        // Step 2: Instruction file
-        if (agentDef.instructionFilePath) {
-            w("  \x1b[1m2. Tool Preferences\x1b[0m\n");
-            w(`     ${generateCustomInstructions(agentDef.id).split("\n").join("\n     ")}\n\n`);
-        }
-        // Step 3: Auto install
-        w(`  \x1b[1m${agentDef.instructionFilePath ? "3" : "2"}. Or run automatically:\x1b[0m\n`);
-        w(`     unerr install ${agentDef.id}\n\n`);
-        // Step 4: Restart
-        w(`  \x1b[38;2;161;161;170mRestart ${agentDef.name} to pick up changes.\x1b[0m\n`);
-    }
-    else {
-        // Unknown/other agent — generic guide
-        w("  \x1b[38;2;139;92;246m◆\x1b[0m \x1b[1mManual setup for any AI coding agent\x1b[0m\n\n");
-        w("  unerr works with any agent that supports MCP (Model Context Protocol).\n\n");
-        w("  \x1b[1mStep 1: MCP Server Configuration\x1b[0m\n");
-        w("  \x1b[2m─────────────────────────────────\x1b[0m\n");
-        w("  Add unerr as an MCP server in your agent's config file.\n");
-        w("  The exact format depends on your agent:\n\n");
-        w("  Standard JSON format (most agents):\n");
-        w(`  ${JSON.stringify({ mcpServers: { unerr: { command: "unerr", args: ["--mcp"] } } }, null, 2)
-            .split("\n")
-            .join("\n  ")}\n\n`);
-        w("  \x1b[1mStep 2: Agent Instructions (Critical for Adoption)\x1b[0m\n");
-        w("  \x1b[2m───────────────────────────────────────────────────\x1b[0m\n");
-        w("  Add these instructions to your agent's instruction file\n");
-        w("  (CLAUDE.md, AGENTS.md, .cursorrules, GEMINI.md, etc.):\n\n");
-        w(`  ${generateCustomInstructions().split("\n").join("\n  ")}\n\n`);
-        w("  \x1b[1mStep 3: Verify\x1b[0m\n");
-        w("  \x1b[2m──────────────\x1b[0m\n");
-        w("  After restarting your agent, verify unerr tools are available.\n");
-        w("  You should see tools like: get_callers, search_code, file_read,\n");
-        w("  file_outline, get_imports, get_callees.\n\n");
-        w("  \x1b[1mStep 4: Start unerr\x1b[0m\n");
-        w("  \x1b[2m────────────────────\x1b[0m\n");
-        w("  Run \x1b[1munerr\x1b[0m in your project root to start the intelligence engine.\n");
-        w("  The MCP server will be available at \x1b[1munerr --mcp\x1b[0m.\n");
-    }
-    w("\n");
-}
-// ── Cursor Hook Scripts ──────────────────────────────────────────────
-// These are written to .cursor/hooks/ by installCursorHooks().
-// Each reads JSON from stdin and dispatches to the appropriate unerr hook subcommand.
-const CURSOR_PRE_TOOL_SCRIPT = `#!/bin/bash
-# unerr preToolUse hook for Cursor
-# Installed by: unerr install cursor | Removed by: unerr uninstall cursor
-input=$(cat)
-tool_name=$(echo "$input" | jq -r '.tool_name // empty')
-case "$tool_name" in
-  Read)  echo "$input" | unerr hook pre-read ;;
-  Grep)  echo "$input" | unerr hook pre-grep ;;
-  Glob)  echo "$input" | unerr hook pre-glob ;;
-  Write) echo "$input" | unerr hook pre-write ;;
-  Edit)  echo "$input" | unerr hook pre-edit ;;
-  *)     echo '{"permission":"allow"}' ;;
-esac
-`;
-const CURSOR_POST_TOOL_SCRIPT = `#!/bin/bash
-# unerr postToolUse hook for Cursor
-# Installed by: unerr install cursor | Removed by: unerr uninstall cursor
-input=$(cat)
-tool_name=$(echo "$input" | jq -r '.tool_name // empty')
-case "$tool_name" in
-  Read)  echo "$input" | unerr hook post-read ;;
-  Grep)  echo "$input" | unerr hook post-grep ;;
-  Glob)  echo "$input" | unerr hook post-glob ;;
-  Write) echo "$input" | unerr hook post-write ;;
-  Edit)  echo "$input" | unerr hook post-edit ;;
-  *)     echo '{}' ;;
-esac
-`;
-const CURSOR_PROMPT_SCRIPT = `#!/bin/bash
-# unerr beforeSubmitPrompt hook for Cursor
-# Installed by: unerr install cursor | Removed by: unerr uninstall cursor
-cat | unerr hook prompt-submit
-`;
-const CURSOR_PRE_SHELL_SCRIPT = `#!/bin/bash
-# unerr beforeShellExecution hook for Cursor
-# Installed by: unerr install cursor | Removed by: unerr uninstall cursor
-# For v1, just allow — shell compression routes through PreToolUse/Bash/exec pipeline
-cat > /dev/null
-echo '{"permission":"allow"}'
-`;
-/**
- * Install Cursor hook configuration in `.cursor/hooks.json`.
- * Registers unerr as a hook provider for PreToolUse events.
- * Idempotent — skips if already present.
- */
-function installCursorHooks(cwd) {
-    const hooksJsonPath = join(cwd, ".cursor", "hooks.json");
-    const hooksDir = join(cwd, ".cursor", "hooks");
-    // Define our hook entries per Cursor's official format
-    const unerrHooks = {
-        preToolUse: [
-            {
-                command: ".cursor/hooks/unerr-pre-tool.sh",
-                matcher: "Read|Grep|Glob|Write|Edit",
-            },
-        ],
-        postToolUse: [
-            {
-                command: ".cursor/hooks/unerr-post-tool.sh",
-                matcher: "Read|Grep|Glob|Write|Edit",
-            },
-        ],
-        beforeSubmitPrompt: [{ command: ".cursor/hooks/unerr-prompt.sh" }],
-        beforeShellExecution: [{ command: ".cursor/hooks/unerr-pre-shell.sh" }],
-    };
-    try {
-        // Ensure directories exist
-        if (!existsSync(hooksDir)) {
-            mkdirSync(hooksDir, { recursive: true });
-        }
-        // Read or create hooks.json with correct Cursor format
-        let config = {
-            version: 1,
-            hooks: {},
-        };
-        if (existsSync(hooksJsonPath)) {
-            try {
-                const existing = JSON.parse(readFileSync(hooksJsonPath, "utf-8"));
-                if (existing.version && existing.hooks) {
-                    config = existing;
-                }
-            }
-            catch {
-                // Corrupt file — overwrite with fresh config
-            }
-        }
-        // Merge our hooks into each event, avoiding duplicates by command path
-        for (const [event, entries] of Object.entries(unerrHooks)) {
-            const existing = Array.isArray(config.hooks[event])
-                ? config.hooks[event]
-                : [];
-            for (const entry of entries) {
-                const alreadyPresent = existing.some((h) => h.command === entry.command);
-                if (!alreadyPresent) {
-                    existing.push(entry);
-                }
-            }
-            config.hooks[event] = existing;
-        }
-        writeFileSync(hooksJsonPath, `${JSON.stringify(config, null, 2)}\n`);
-        // Write hook scripts
-        writeCursorHookScript(hooksDir, "unerr-pre-tool.sh", CURSOR_PRE_TOOL_SCRIPT);
-        writeCursorHookScript(hooksDir, "unerr-post-tool.sh", CURSOR_POST_TOOL_SCRIPT);
-        writeCursorHookScript(hooksDir, "unerr-prompt.sh", CURSOR_PROMPT_SCRIPT);
-        writeCursorHookScript(hooksDir, "unerr-pre-shell.sh", CURSOR_PRE_SHELL_SCRIPT);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Write a hook script file and make it executable. */
-function writeCursorHookScript(dir, filename, content) {
-    const scriptPath = join(dir, filename);
-    writeFileSync(scriptPath, content, "utf-8");
-    chmodSync(scriptPath, 0o755);
-}
-/**
- * Install Cline hook scripts in `.clinerules/hooks/`.
- * Creates a pre-tool hook script that routes through unerr.
- * Idempotent — skips if already present.
- */
-function installClineHooks(cwd) {
-    const hooksDir = join(cwd, ".clinerules", "hooks");
-    const hookPath = join(hooksDir, "unerr-pre-tool.sh");
-    if (existsSync(hookPath))
-        return true;
-    try {
-        if (!existsSync(hooksDir)) {
-            const { mkdirSync } = require("node:fs");
-            mkdirSync(hooksDir, { recursive: true });
-        }
-        const hookContent = `#!/bin/bash
-# unerr hook — graph-first tool navigation for Cline
-# Installed by: unerr install cline
-# Removed by: unerr uninstall cline
-cat /dev/stdin | unerr hook pre-read
-`;
-        writeFileSync(hookPath, hookContent, "utf-8");
-        chmodSync(hookPath, 0o755);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Ensure .unerr is listed in .gitignore so artifacts don't get committed.
- * Only modifies .gitignore if it exists and doesn't already contain .unerr.
- */
-function ensureGitignore(cwd) {
-    const gitignorePath = join(cwd, ".gitignore");
-    if (!existsSync(gitignorePath))
-        return false;
-    try {
-        const content = readFileSync(gitignorePath, "utf-8");
-        const lines = content.split("\n");
-        // Check if .unerr is already ignored (exact line match)
-        if (lines.some((l) => l.trim() === ".unerr" || l.trim() === ".unerr/")) {
-            return false;
-        }
-        // Append .unerr entry
-        const newline = content.endsWith("\n") ? "" : "\n";
-        writeFileSync(gitignorePath, `${content}${newline}\n# unerr local artifacts\n.unerr\n`);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

package/dist/commands/learn.js

@@ -1,116 +0,0 @@
-/**
- * unerr learn — Run correction detector on shadow ledger entries.
- *
- * Scans the shadow ledger for error→fix correction pairs and displays
- * detected patterns. With --write, persists patterns to CozoDB for
- * injection into future MCP responses.
- *
- * Leapfrog Sprint B, Task B.4
- *
- * Usage:
- *   unerr learn                    — Detect and display patterns (last 7 days)
- *   unerr learn --write            — Detect and persist to CozoDB
- *   unerr learn --days 30          — Scan last 30 days
- *   unerr learn --json             — Output as JSON
- *   unerr learn --min-conf 0.8     — Only show high-confidence patterns
- */
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { gunzipSync } from "node:zlib";
-import pc from "picocolors";
-import { detectCorrections } from "../tracking/correction-detector.js";
-import { detail, fail, info, section, success, warn } from "../utils/ui.js";
-export function registerLearnCommand(program) {
-    program
-        .command("learn")
-        .description("Detect correction patterns from shadow ledger — learn what mistakes agents keep making")
-        .option("--days <n>", "Scan last N days of ledger", "7")
-        .option("--write", "Persist detected patterns to CozoDB for agent guidance")
-        .option("--json", "Output as JSON")
-        .option("--min-conf <f>", "Minimum confidence threshold (0.0-1.0)", "0.6")
-        .action(async (opts) => {
-        const days = Math.max(1, Number.parseInt(opts.days, 10) || 7);
-        const minConf = Math.max(0, Math.min(1, Number.parseFloat(opts.minConf) || 0.6));
-        const cwd = process.cwd();
-        const unerrDir = join(cwd, ".unerr");
-        const ledgerPath = join(unerrDir, "ledger", "shadow.jsonl");
-        if (!existsSync(ledgerPath)) {
-            fail("No shadow ledger found at .unerr/ledger/shadow.jsonl");
-            info("The shadow ledger is created when the unerr proxy runs. Start the proxy first.");
-            process.exit(1);
-        }
-        section("Correction Detection");
-        info(`Scanning last ${days} days of shadow ledger...`);
-        const patterns = detectCorrections(ledgerPath, {
-            since_days: days,
-            min_confidence: minConf,
-        });
-        if (patterns.length === 0) {
-            info(`No correction patterns found in last ${days} days (threshold: ${minConf})`);
-            process.exit(0);
-        }
-        if (opts.json) {
-            process.stdout.write(`${JSON.stringify(patterns, null, 2)}\n`);
-        }
-        else {
-            success(`Detected ${patterns.length} correction pattern${patterns.length !== 1 ? "s" : ""}:`);
-            process.stderr.write("\n");
-            for (let i = 0; i < patterns.length; i++) {
-                const p = patterns[i];
-                const name = p.entity_key.split("/").pop()?.split(":").pop() ?? p.entity_key;
-                process.stderr.write(`  ${pc.bold(`${i + 1}.`)} ${pc.cyan(name)} ${pc.dim(`(${p.error_type})`)} — confidence: ${pc.yellow(String(p.confidence))}, seen ${pc.bold(String(p.occurrences))}x\n`);
-                process.stderr.write(`     ${pc.dim(p.correction_summary)}\n`);
-                process.stderr.write(`     ${pc.dim(`Last seen: ${p.last_seen.slice(0, 16).replace("T", " ")}`)}\n`);
-                process.stderr.write("\n");
-            }
-        }
-        if (opts.write) {
-            await persistPatterns(patterns, unerrDir);
-        }
-        else if (!opts.json) {
-            detail("Run with --write to persist these patterns for agent guidance.");
-        }
-    });
-}
-async function persistPatterns(patterns, _unerrDir) {
-    try {
-        const cwd = process.cwd();
-        // Find snapshot to initialize CozoDB
-        const configPath = join(cwd, ".unerr", "config.json");
-        if (!existsSync(configPath)) {
-            warn("No repo config found — cannot persist to CozoDB. Run 'unerr' to configure.");
-            return;
-        }
-        const { readFileSync } = await import("node:fs");
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        if (!config.repoId || !config.orgId) {
-            warn("Repo not configured — cannot persist to CozoDB.");
-            return;
-        }
-        const snapshotPath = join(cwd, ".unerr", "snapshots", "graph.msgpack.gz");
-        if (!existsSync(snapshotPath)) {
-            warn("No graph snapshot found — cannot persist to CozoDB.");
-            return;
-        }
-        // Dynamic imports for heavy modules
-        const cozoModule = await import("cozo-node");
-        const CozoDbClass = cozoModule.default
-            ? cozoModule.default.CozoDb
-            : cozoModule.CozoDb;
-        const db = new CozoDbClass();
-        const { initSchema } = await import("../intelligence/cozo-schema.js");
-        initSchema(db);
-        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
-        const store = await CozoGraphStore.create(db);
-        const { unpack } = await import("msgpackr");
-        const raw = readFileSync(snapshotPath);
-        const buffer = gunzipSync(raw);
-        const envelope = unpack(buffer);
-        await store.loadSnapshot(envelope);
-        store.persistCorrections(patterns);
-        success(`Persisted ${patterns.length} correction pattern${patterns.length !== 1 ? "s" : ""} to CozoDB`);
-    }
-    catch (err) {
-        warn(`Failed to persist corrections: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}