@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/entrypoints/cli.js

@@ -1,1043 +0,0 @@
-#!/usr/bin/env node
-/**
- * unerr — Local-first code intelligence CLI.
- *
- * Boot State Machine:
- *   unerr                  — THE command. First-run: wizard → index → serve. Subsequent: resume → serve.
- *   unerr chat             — Interactive AI assistant (Ink REPL)
- *   unerr status           — Quick diagnostic dump
- *   unerr debug            — Full diagnostic for support
- *
- * All other commands are hidden but remain callable for power users and scripts.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { Command } from "commander";
-import { registerBranchesCommand } from "../commands/branches.js";
-import { registerCheckCommitCommand } from "../commands/check-commit.js";
-import { registerCompressOutputCommand } from "../commands/compress-output.js";
-import { registerConfigVerifyCommand } from "../commands/config-verify.js";
-import { registerDaemonCommand } from "../commands/daemon.js";
-import { registerDashboardCommand } from "../commands/dashboard.js";
-import { registerDebugCommand } from "../commands/debug.js";
-import { registerEnrichCommand } from "../commands/enrich.js";
-import { registerExecCommand } from "../commands/exec.js";
-import { registerDiscoverCommand, registerGainCommand, } from "../commands/gain.js";
-import { registerHookCommand } from "../commands/hook.js";
-import { registerIndexCommand } from "../commands/index.js";
-import { registerInitCommand } from "../commands/init.js";
-import { registerInstallCommand } from "../commands/install.js";
-import { registerLearnCommand } from "../commands/learn.js";
-import { registerManifestCommand } from "../commands/manifest.js";
-import { registerRewindCommand } from "../commands/rewind.js";
-import { registerSkillsCommand } from "../commands/skills.js";
-import { registerStatsCommand } from "../commands/stats.js";
-import { registerStatusCommand } from "../commands/status.js";
-import { registerTimelineCommand } from "../commands/timeline.js";
-import { registerUninstallCommand } from "../commands/uninstall.js";
-import { installFileLogger } from "../utils/file-logger.js";
-import { initFileLog } from "../utils/startup-log.js";
-// ── Helpers ─────────────────────────────────────────────────
-/**
- * Start the unified proxy.
- */
-async function startProxy(repoId) {
-    const { startProxy: boot } = await import("../proxy/proxy.js");
-    const httpPort = Number.parseInt(process.env.UNERR_HTTP_PORT ?? "0", 10);
-    await boot({ repoId, httpPort: httpPort || undefined });
-}
-/**
- * Auto-verify and repair IDE MCP configs before proxy start.
- * Silently fixes stale MCP configs → local proxy format.
- */
-async function autoVerifyIdeConfigs() {
-    try {
-        const { checkIdeConfig, repairIdeConfig } = await import("../commands/config-verify.js");
-        const os = await import("node:os");
-        const path = await import("node:path");
-        const ideConfigs = {
-            cursor: path.join(os.homedir(), ".cursor", "mcp.json"),
-            vscode: path.join(os.homedir(), ".vscode", "settings.json"),
-            windsurf: path.join(os.homedir(), ".windsurf", "mcp.json"),
-        };
-        for (const [ideName, configPath] of Object.entries(ideConfigs)) {
-            const result = checkIdeConfig(ideName, configPath);
-            if (result.found && result.needsMigration) {
-                const repaired = repairIdeConfig(ideName, configPath);
-                if (repaired) {
-                    process.stderr.write(`[unerr] Auto-repaired ${ideName} MCP config (remote URL → local proxy)\n`);
-                }
-            }
-        }
-    }
-    catch {
-        // Non-blocking — config verification should never prevent proxy startup
-    }
-}
-/**
- * Check if we're inside a git repository.
- */
-async function isInsideGitRepo() {
-    const { isGitRepo } = await import("../utils/git.js");
-    return isGitRepo(process.cwd());
-}
-// ── Project Root Detection (Scored Multi-Signal Analysis) ─────
-/**
- * TIER 1: Definitive project markers — files whose presence at root
- * guarantees this is a project directory. Grouped by ecosystem.
- */
-const DEFINITIVE_MARKERS = [
-    // JavaScript / TypeScript
-    "package.json",
-    "tsconfig.json",
-    "jsconfig.json",
-    "deno.json",
-    "deno.jsonc",
-    "bun.lockb",
-    "bunfig.toml",
-    // Python
-    "pyproject.toml",
-    "setup.py",
-    "setup.cfg",
-    "Pipfile",
-    "hatch.toml",
-    // Rust
-    "Cargo.toml",
-    // Go
-    "go.mod",
-    // Java / Kotlin / Gradle
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    "settings.gradle",
-    "settings.gradle.kts",
-    // C# / .NET
-    "Directory.Build.props",
-    "global.json",
-    "nuget.config",
-    // Ruby
-    "Gemfile",
-    "Rakefile",
-    // PHP
-    "composer.json",
-    // Swift / Obj-C / Apple
-    "Package.swift",
-    "Podfile",
-    // C / C++
-    "CMakeLists.txt",
-    "Makefile",
-    "configure.ac",
-    "meson.build",
-    "conanfile.txt",
-    "conanfile.py",
-    "vcpkg.json",
-    // Dart / Flutter
-    "pubspec.yaml",
-    // Elixir
-    "mix.exs",
-    // Scala
-    "build.sbt",
-    "build.sc",
-    // Haskell
-    "stack.yaml",
-    "cabal.project",
-    // Clojure
-    "project.clj",
-    "deps.edn",
-    "shadow-cljs.edn",
-    // Zig
-    "build.zig",
-    "build.zig.zon",
-    // Julia
-    "Project.toml",
-    // Terraform / IaC
-    "main.tf",
-    "terraform.tf",
-    "pulumi.yaml",
-    "serverless.yml",
-    "cdk.json",
-    "sam.yaml",
-    // Containers
-    "Dockerfile",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    // Monorepo
-    "lerna.json",
-    "nx.json",
-    "turbo.json",
-    "pnpm-workspace.yaml",
-    "rush.json",
-    "pants.toml",
-    // Bazel
-    "BUILD.bazel",
-    "WORKSPACE",
-    "WORKSPACE.bazel",
-    // General build / task
-    "Justfile",
-    "Taskfile.yml",
-    // Nix
-    "flake.nix",
-    "shell.nix",
-    "default.nix",
-    // Android
-    "AndroidManifest.xml",
-];
-/**
- * TIER 2: Strong signals — VCS, IDE, CI/CD, lock files, editor configs.
- * Not definitive alone (a stray .gitignore doesn't make a project) but
- * contribute significant score.
- */
-const STRONG_SIGNAL_FILES = [
-    // Lock files (imply a package manager was run here)
-    "package-lock.json",
-    "yarn.lock",
-    "pnpm-lock.yaml",
-    "Pipfile.lock",
-    "poetry.lock",
-    "Gemfile.lock",
-    "composer.lock",
-    "Cargo.lock",
-    "flake.lock",
-    "pubspec.lock",
-    "mix.lock",
-    "go.sum",
-    "uv.lock",
-    "pdm.lock",
-    // CI/CD (a CI config strongly implies project root)
-    ".gitlab-ci.yml",
-    "Jenkinsfile",
-    ".travis.yml",
-    "azure-pipelines.yml",
-    "bitbucket-pipelines.yml",
-    // Editor / LSP configs (placed at project root)
-    ".editorconfig",
-    ".prettierrc",
-    ".prettierrc.json",
-    ".eslintrc",
-    ".eslintrc.json",
-    ".eslintrc.js",
-    "biome.json",
-    "biome.jsonc",
-    "pyrightconfig.json",
-    "rust-toolchain.toml",
-    ".clang-format",
-    ".clangd",
-    "compile_commands.json",
-    ".luarc.json",
-    "stylua.toml",
-    ".rubocop.yml",
-    ".php-cs-fixer.php",
-    // Environment
-    ".env",
-    ".envrc",
-    // Git-specific (at root level these are strong signals)
-    ".gitignore",
-    ".gitattributes",
-];
-/** TIER 2: Directories that are strong signals when present at root. */
-const STRONG_SIGNAL_DIRS = [
-    ".git",
-    ".svn",
-    ".hg",
-    ".fossil",
-    ".bzr",
-    "_darcs", // VCS
-    ".github",
-    ".circleci",
-    ".buildkite", // CI/CD
-    ".idea",
-    ".vscode",
-    ".vs",
-    ".fleet",
-    ".zed", // IDE
-];
-/** Glob patterns for file-extension markers (e.g., *.sln, *.csproj). */
-const EXTENSION_MARKERS = [
-    ".sln",
-    ".csproj",
-    ".fsproj",
-    ".vbproj", // .NET
-    ".xcodeproj",
-    ".xcworkspace", // Xcode (dirs)
-    ".cabal", // Haskell
-    ".nimble", // Nim
-    ".gemspec", // Ruby
-    ".rockspec", // Lua
-];
-/**
- * TIER 3: Code file extensions — comprehensive across all mainstream
- * and emerging languages. Used to scan root + source dirs.
- */
-const CODE_EXTENSIONS = new Set([
-    // Web / JS ecosystem
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".vue",
-    ".svelte",
-    ".astro",
-    // Systems
-    ".rs",
-    ".go",
-    ".c",
-    ".h",
-    ".cpp",
-    ".cc",
-    ".cxx",
-    ".hpp",
-    ".hxx",
-    ".zig",
-    // JVM
-    ".java",
-    ".kt",
-    ".kts",
-    ".scala",
-    ".sc",
-    ".clj",
-    ".cljs",
-    ".cljc",
-    // .NET
-    ".cs",
-    ".fs",
-    ".fsx",
-    ".vb",
-    // Scripting
-    ".py",
-    ".pyi",
-    ".rb",
-    ".php",
-    ".lua",
-    ".pl",
-    ".pm",
-    ".raku",
-    // Apple / Mobile
-    ".swift",
-    ".m",
-    ".mm",
-    ".dart",
-    // Functional
-    ".hs",
-    ".lhs",
-    ".ml",
-    ".mli",
-    ".re",
-    ".rei",
-    ".elm",
-    ".ex",
-    ".exs",
-    ".purs",
-    ".idr",
-    ".agda",
-    ".lean",
-    // Data / Science
-    ".r",
-    ".R",
-    ".jl",
-    // Infrastructure
-    ".tf",
-    ".hcl",
-    // Emerging / Niche
-    ".nim",
-    ".cr",
-    ".d",
-    ".v",
-    ".sol",
-    ".move",
-    ".cairo",
-    ".nr",
-    // Shell / Config as code
-    ".sh",
-    ".bash",
-    ".zsh",
-    ".fish",
-    ".ps1",
-]);
-/**
- * TIER 4: Anti-signals — files/dirs that indicate this is a home dir,
- * system path, or otherwise NOT a project root. Each match subtracts score.
- */
-const ANTI_SIGNAL_FILES = [
-    ".bashrc",
-    ".zshrc",
-    ".bash_profile",
-    ".profile",
-    ".zprofile",
-    ".zshenv",
-    ".bash_history",
-    ".zsh_history",
-];
-const ANTI_SIGNAL_DIRS = [
-    ".config",
-    ".local",
-    ".cache",
-    ".ssh",
-    ".gnupg",
-    ".npm",
-    ".cargo",
-    "Desktop",
-    "Downloads",
-    "Documents",
-    "Pictures",
-    "Music",
-    "Movies",
-    "Library",
-    "Applications",
-];
-const ANTI_SIGNAL_PATHS = [
-    "/",
-    "/usr",
-    "/tmp",
-    "/var",
-    "/etc",
-    "/opt",
-    "/home",
-    "/Users",
-    "/root",
-];
-/**
- * TIER 5: Well-known source directories — if these exist at root AND
- * contain code files, that's a strong project signal.
- */
-const SOURCE_DIRS = new Set([
-    "src",
-    "lib",
-    "app",
-    "apps",
-    "cmd",
-    "pkg",
-    "packages",
-    "internal",
-    "modules",
-    "components",
-    "pages",
-    "routes",
-    "api",
-    "server",
-    "client",
-    "web",
-    "core",
-    "common",
-    "shared",
-    "utils",
-    "helpers",
-    "services",
-    "models",
-    "views",
-    "controllers",
-    "handlers",
-    "middleware",
-    "plugins",
-    "test",
-    "tests",
-    "spec",
-    "__tests__",
-    "e2e",
-    "integration",
-    "scripts",
-    "tools",
-    "bin",
-    "examples",
-    "samples",
-    "proto",
-    "schemas",
-    "migrations",
-    "seeds",
-]);
-/**
- * Scored project-root detection. Accumulates evidence across 5 tiers
- * and subtracts anti-signals. A score >= THRESHOLD means "this is a project".
- *
- * Scoring weights:
- *   Definitive marker file:       +10  (instant pass)
- *   VCS directory (.git, .hg):    +8
- *   Strong signal file/dir:       +4
- *   Extension marker (*.sln):     +10
- *   Code files in root:           +5
- *   Code files in source dir:     +6
- *   Anti-signal file:             -3
- *   Anti-signal directory:        -2
- *   Anti-signal path:             -15  (instant fail for /, /usr, etc.)
- *
- * Threshold: 5 (a single definitive marker or VCS dir passes)
- */
-const DETECTION_THRESHOLD = 5;
-async function detectProjectRoot(cwd) {
-    const { readdirSync } = await import("node:fs");
-    let score = 0;
-    const signals = [];
-    let hasGit = false;
-    // ── TIER 4 first: Anti-signal paths (early reject) ──────────
-    const normalizedCwd = cwd.replace(/\\/g, "/");
-    for (const ap of ANTI_SIGNAL_PATHS) {
-        if (normalizedCwd === ap || normalizedCwd === `${ap}/`) {
-            return {
-                isProject: false,
-                hasGit: false,
-                reason: `System/root path: ${cwd}`,
-                score: -15,
-                signals: [`anti-path: ${ap}`],
-            };
-        }
-    }
-    // Read root directory entries once
-    let rootEntries = [];
-    try {
-        rootEntries = readdirSync(cwd, { withFileTypes: true }).map((e) => ({
-            name: e.name,
-            isFile: e.isFile(),
-            isDir: e.isDirectory(),
-        }));
-    }
-    catch {
-        return {
-            isProject: false,
-            hasGit: false,
-            reason: "Cannot read directory",
-            score: -1,
-            signals: ["unreadable"],
-        };
-    }
-    const rootFileNames = new Set(rootEntries.filter((e) => e.isFile).map((e) => e.name));
-    const rootDirNames = new Set(rootEntries.filter((e) => e.isDir).map((e) => e.name));
-    // ── TIER 4: Anti-signal files & dirs at root ────────────────
-    for (const af of ANTI_SIGNAL_FILES) {
-        if (rootFileNames.has(af)) {
-            score -= 3;
-            signals.push(`anti-file: ${af}`);
-        }
-    }
-    for (const ad of ANTI_SIGNAL_DIRS) {
-        if (rootDirNames.has(ad)) {
-            score -= 2;
-            signals.push(`anti-dir: ${ad}/`);
-        }
-    }
-    // ── TIER 1: Definitive marker files ─────────────────────────
-    for (const marker of DEFINITIVE_MARKERS) {
-        if (rootFileNames.has(marker)) {
-            score += 10;
-            signals.push(`marker: ${marker}`);
-            break; // one is enough
-        }
-    }
-    // ── TIER 1: Extension-based markers (*.sln, *.csproj, etc.) ─
-    if (score < DETECTION_THRESHOLD) {
-        for (const entry of rootEntries) {
-            if (!entry.isFile && !entry.isDir)
-                continue;
-            const name = entry.name.toLowerCase();
-            for (const ext of EXTENSION_MARKERS) {
-                if (name.endsWith(ext)) {
-                    score += 10;
-                    signals.push(`ext-marker: ${entry.name}`);
-                    break;
-                }
-            }
-            if (score >= DETECTION_THRESHOLD)
-                break;
-        }
-    }
-    // ── TIER 2: VCS directories ─────────────────────────────────
-    for (const vcs of STRONG_SIGNAL_DIRS.slice(0, 6)) {
-        if (rootDirNames.has(vcs)) {
-            if (vcs === ".git")
-                hasGit = true;
-            score += 8;
-            signals.push(`vcs: ${vcs}/`);
-            break;
-        }
-    }
-    // ── TIER 2: Strong signal files ─────────────────────────────
-    for (const sf of STRONG_SIGNAL_FILES) {
-        if (rootFileNames.has(sf)) {
-            score += 4;
-            signals.push(`strong: ${sf}`);
-            if (score >= DETECTION_THRESHOLD)
-                break;
-        }
-    }
-    // ── TIER 2: Strong signal dirs (IDE, CI) ────────────────────
-    for (const sd of STRONG_SIGNAL_DIRS.slice(6)) {
-        if (rootDirNames.has(sd)) {
-            score += 4;
-            signals.push(`strong: ${sd}/`);
-            if (score >= DETECTION_THRESHOLD)
-                break;
-        }
-    }
-    // ── TIER 2: Git repo check (may be in a parent .git) ───────
-    if (!hasGit) {
-        try {
-            hasGit = await isInsideGitRepo();
-            if (hasGit) {
-                score += 6;
-                signals.push("git: inside work tree");
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    // Already passing? Skip expensive file scan.
-    if (score >= DETECTION_THRESHOLD) {
-        const topSignal = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "unknown";
-        return { isProject: true, hasGit, reason: topSignal, score, signals };
-    }
-    // ── TIER 3 + 5: Code files in root, then source dirs ───────
-    function dirHasCodeFile(dir) {
-        try {
-            const entries = readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isFile())
-                    continue;
-                const dot = entry.name.lastIndexOf(".");
-                if (dot >= 0 &&
-                    CODE_EXTENSIONS.has(entry.name.slice(dot).toLowerCase())) {
-                    return entry.name;
-                }
-            }
-        }
-        catch {
-            // skip
-        }
-        return null;
-    }
-    // Code files directly in cwd
-    const rootCodeFile = dirHasCodeFile(cwd);
-    if (rootCodeFile) {
-        score += 5;
-        signals.push(`code-root: ${rootCodeFile}`);
-    }
-    if (score >= DETECTION_THRESHOLD) {
-        const topSignal = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "unknown";
-        return { isProject: true, hasGit, reason: topSignal, score, signals };
-    }
-    // Code files inside well-known source dirs (+ one level deeper)
-    for (const dirEntry of rootEntries) {
-        if (!dirEntry.isDir || dirEntry.name.startsWith("."))
-            continue;
-        if (!SOURCE_DIRS.has(dirEntry.name.toLowerCase()))
-            continue;
-        const sourceDir = join(cwd, dirEntry.name);
-        const srcCodeFile = dirHasCodeFile(sourceDir);
-        if (srcCodeFile) {
-            score += 6;
-            signals.push(`code-src: ${dirEntry.name}/${srcCodeFile}`);
-            break;
-        }
-        // One level deeper (src/components/, lib/utils/)
-        try {
-            const subEntries = readdirSync(sourceDir, { withFileTypes: true });
-            let found = false;
-            for (const sub of subEntries) {
-                if (!sub.isDirectory() || sub.name.startsWith("."))
-                    continue;
-                const deepCode = dirHasCodeFile(join(sourceDir, sub.name));
-                if (deepCode) {
-                    score += 6;
-                    signals.push(`code-src: ${dirEntry.name}/${sub.name}/${deepCode}`);
-                    found = true;
-                    break;
-                }
-            }
-            if (found)
-                break;
-        }
-        catch {
-            // skip
-        }
-    }
-    const isProject = score >= DETECTION_THRESHOLD;
-    const topSignal = signals.find((s) => !s.startsWith("anti-")) ?? signals[0] ?? "No signals";
-    return {
-        isProject,
-        hasGit,
-        reason: isProject ? topSignal : "No code files or project markers found",
-        score,
-        signals,
-    };
-}
-/**
- * Read .unerr/config.json if it exists.
- */
-function readLocalConfig(cwd) {
-    const configPath = join(cwd, ".unerr", "config.json");
-    if (!existsSync(configPath))
-        return null;
-    try {
-        return JSON.parse(readFileSync(configPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-// ── Boot State Machine ─────────────────────────────────────
-/**
- * Resume path: config exists, skip all interactive prompts.
- */
-async function resumeBoot(config) {
-    initFileLog(process.cwd());
-    // Verify this is still a valid project directory (config may be stale)
-    const detection = await detectProjectRoot(process.cwd());
-    if (!detection.isProject) {
-        const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
-        process.stderr.write(`\x1b[38;2;248;113;113m\u2717\x1b[0m No code project detected in this directory.\n  Found .unerr/config.json but the directory doesn't look like a project root.\n  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})\n${antiSignals.length > 0
-            ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}\n`
-            : ""}\n  unerr checks for: project files (package.json, Cargo.toml, go.mod, ...),\n  VCS directories (.git, .hg), IDE configs, CI/CD files, lock files,\n  and source code across 50+ languages.\n\n  \u25b8 Run \x1b[1munerr\x1b[0m from a project root directory.\n`);
-        process.exit(1);
-    }
-    const { initSessionLogger, createSessionModuleLogger } = await import("../utils/session-logger.js");
-    initSessionLogger();
-    const log = createSessionModuleLogger("boot");
-    log.info({ msg: "Resume boot", mode: "local", repoId: config.repoId });
-    // Show update notice (non-blocking, from cache only)
-    try {
-        const { getCachedUpdateInfo } = await import("../daemon/version-checker.js");
-        const info = getCachedUpdateInfo();
-        if (info.available && !info.dismissed) {
-            process.stderr.write(`\x1b[38;2;34;211;238m▸\x1b[0m Update available: ${info.current} → ${info.latest} — run \x1b[38;2;139;92;246munerr daemon update\x1b[0m\n`);
-        }
-    }
-    catch {
-        // Non-blocking
-    }
-    process.stderr.write("[unerr] Starting proxy...\n");
-    await autoVerifyIdeConfigs();
-    await startProxy(config.repoId);
-}
-/**
- * First-run path: no config exists. Auto-detect environment, prompt if needed.
- */
-async function firstRunBoot() {
-    initFileLog(process.cwd());
-    const { initSessionLogger, createSessionModuleLogger } = await import("../utils/session-logger.js");
-    initSessionLogger();
-    const log = createSessionModuleLogger("boot");
-    // Must be in a project directory
-    const detection = await detectProjectRoot(process.cwd());
-    if (!detection.isProject) {
-        const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
-        process.stderr.write(`\x1b[38;2;248;113;113m\u2717\x1b[0m No code project detected in this directory.\n  unerr needs a folder containing source code to index.\n  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})\n${antiSignals.length > 0
-            ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}\n`
-            : ""}\n  Checked for: project files (package.json, Cargo.toml, go.mod, pyproject.toml, ...),\n  VCS directories (.git, .hg, .svn), IDE configs (.vscode, .idea),\n  CI/CD files (.github, Jenkinsfile), lock files, and source code\n  across 50+ languages in root + standard source directories.\n\n  \u25b8 Run \x1b[1munerr\x1b[0m from a project root directory.\n`);
-        process.exit(1);
-    }
-    if (!detection.hasGit) {
-        process.stderr.write(`\x1b[38;2;251;191;36m\u26a0\x1b[0m Project detected (${detection.reason}) but no git repository found.\n  unerr works best with git. Consider running \x1b[1mgit init\x1b[0m first.\n  Continuing anyway...\n\n`);
-    }
-    log.info({
-        msg: "First-run boot, entering local setup",
-        detection: detection.reason,
-        score: detection.score,
-        hasGit: detection.hasGit,
-    });
-    const { runSetup } = await import("../commands/setup-wizard.js");
-    const result = await runSetup();
-    if (result.action === "setup") {
-        await autoVerifyIdeConfigs();
-        await startProxy(result.repoId);
-        return;
-    }
-    process.exit(0);
-}
-/**
- * Daemon-child mode: spawned and managed by unerrd.
- *
- * Differences from standalone `unerr`:
- *   - No interactive prompts (process.stdin.isTTY is false)
- *   - IPC channel to parent: sends { type: "ready", sock }, { type: "activity" }
- *   - SIGTERM triggers snapshot + clean exit (no delay)
- *   - Orphan detection: checks ppid every 60s, self-exits if parent died
- *   - Activity reports: stats sent every 60s while running
- */
-async function daemonChildBoot(cwd) {
-    installFileLogger({
-        filePath: join(cwd, ".unerr", "logs", `child-${process.pid}.log`),
-        maxBytes: 5_000_000,
-        keep: 5,
-    });
-    initFileLog(cwd);
-    const config = readLocalConfig(cwd);
-    if (!config) {
-        process.stderr.write("[unerr:child] No .unerr/config.json — run `unerr` interactively first.\n");
-        process.exit(1);
-    }
-    const originalPpid = process.ppid;
-    // Orphan detection: if parent (unerrd) dies, self-exit
-    const orphanTimer = setInterval(() => {
-        if (process.ppid !== originalPpid) {
-            process.stderr.write("[unerr:child] Parent died — orphan exit.\n");
-            clearInterval(orphanTimer);
-            clearInterval(statsTimer);
-            shutdownProxy("orphan");
-        }
-    }, 60_000);
-    orphanTimer.unref();
-    // SIGTERM from parent: graceful shutdown
-    process.on("SIGTERM", () => {
-        clearInterval(orphanTimer);
-        clearInterval(statsTimer);
-        shutdownProxy("sigterm");
-    });
-    // Start the proxy (bypass local wrapper to get shutdown handle + stats)
-    const { startProxy: bootProxy } = await import("../proxy/proxy.js");
-    const proxyResult = await bootProxy({
-        repoId: config.repoId,
-        daemonChild: true,
-    });
-    // Notify parent: ready
-    const stateDir = join(cwd, ".unerr", "state");
-    const sockPath = join(stateDir, "proxy.sock");
-    if (process.send) {
-        process.send({ type: "ready", sock: sockPath });
-    }
-    // Inject update notification into MCP _meta if behind >2 minor versions
-    try {
-        const { getCachedUpdateInfo } = await import("../daemon/version-checker.js");
-        const { setUpdateNotification } = await import("../proxy/response-envelope.js");
-        const info = getCachedUpdateInfo();
-        if (info.available && !info.dismissed && info.behindMinor > 2) {
-            setUpdateNotification(info.latest, info.current);
-        }
-    }
-    catch {
-        // Non-critical
-    }
-    function collectStats() {
-        const mem = process.memoryUsage();
-        return {
-            entities: proxyResult.stats.toolCallsLocal,
-            edges: 0,
-            memory: Math.round(mem.rss / 1024 / 1024),
-        };
-    }
-    // Periodic stats report to parent
-    const statsTimer = setInterval(() => {
-        if (!process.send)
-            return;
-        process.send({ type: "stats", ...collectStats() });
-    }, 60_000);
-    statsTimer.unref();
-    // IPC messages from parent
-    process.on("message", (msg) => {
-        if (msg.type === "shutdown") {
-            clearInterval(orphanTimer);
-            clearInterval(statsTimer);
-            shutdownProxy("parent-shutdown");
-        }
-        if (msg.type === "get-stats") {
-            if (!process.send)
-                return;
-            process.send({ type: "stats", ...collectStats() });
-        }
-    });
-    async function shutdownProxy(reason) {
-        process.stderr.write(`[unerr:child] Shutting down: ${reason}\n`);
-        try {
-            await proxyResult.shutdown();
-        }
-        catch (err) {
-            process.stderr.write(`[unerr:child] Shutdown error: ${err.message}\n`);
-        }
-        process.exit(0);
-    }
-}
-/**
- * MCP mode: headless boot for IDE integration.
- *
- * Socket discovery order:
- *   1. Per-repo proxy sock (`<cwd>/.unerr/state/proxy.sock`) — direct bridge
- *   2. unerrd daemon sock (`~/.unerr/unerrd.sock`) — bridge if repo is registered
- *
- * The bridge NEVER spawns unerrd or registers repos. It only connects to
- * what's already running. If nothing is available, it exits with an error.
- */
-async function mcpBoot(cwd) {
-    installFileLogger({
-        filePath: join(cwd, ".unerr", "logs", `mcp-${process.pid}.log`),
-        maxBytes: 5_000_000,
-        keep: 5,
-    });
-    initFileLog(cwd);
-    const detection = await detectProjectRoot(cwd);
-    if (!detection.isProject) {
-        const antiSignals = detection.signals.filter((s) => s.startsWith("anti-"));
-        process.stderr.write(`\x1b[38;2;248;113;113m\u2717\x1b[0m No code project detected in this directory.\n  unerr needs a folder containing source code to index.\n  Detection score: ${detection.score} (need ${DETECTION_THRESHOLD})\n${antiSignals.length > 0
-            ? `  Negative signals: ${antiSignals.map((s) => s.replace("anti-", "")).join(", ")}\n`
-            : ""}\n  \u25b8 Run \x1b[1munerr --mcp\x1b[0m from a project root directory.\n`);
-        process.exit(1);
-    }
-    const { startUdsBridge } = await import("../proxy/bridge.js");
-    // ── Step 1: Try per-repo proxy sock (standalone `unerr` running) ──
-    const repoSock = join(cwd, ".unerr", "state", "proxy.sock");
-    if (existsSync(repoSock)) {
-        const { PidLock } = await import("../proxy/pid-lock.js");
-        const pidLock = new PidLock(join(cwd, ".unerr", "state"));
-        const probeResult = await pidLock.probe();
-        if (probeResult.alive) {
-            process.stderr.write(`[unerr:mcp] Bridging to running proxy (PID ${probeResult.pid})\n`);
-            return bridgeAndExit(startUdsBridge, repoSock);
-        }
-    }
-    // ── Step 2: Try unerrd (must already be running, repo must be registered) ──
-    const { daemonSockPath, probeDaemon, ensureRepo, connectRepo, disconnectRepo, sendActivity, } = await import("../daemon/client.js");
-    const { findRepo } = await import("../daemon/registry.js");
-    const daemonSock = daemonSockPath();
-    const daemonRunning = await probeDaemon(daemonSock);
-    if (!daemonRunning) {
-        process.stderr.write("\x1b[38;2;248;113;113m\u2717\x1b[0m No unerr process found for this project.\n\n" +
-            "  To use standalone mode:\n" +
-            "    unerr              # start per-repo process in this directory\n\n" +
-            "  To use daemon mode:\n" +
-            "    unerr daemon initialize    # one-time setup\n" +
-            "    unerr install <agent>      # register this repo\n");
-        process.exit(1);
-    }
-    // Daemon is running — check if this repo is registered
-    const repoEntry = findRepo(cwd);
-    if (!repoEntry) {
-        process.stderr.write("\x1b[38;2;248;113;113m\u2717\x1b[0m Repo not registered with unerrd.\n\n" +
-            "  Run: unerr install <agent>   # registers this repo with the daemon\n" +
-            "  Or:  unerr daemon add .      # register without installing agent config\n");
-        process.exit(1);
-    }
-    // Daemon running + repo registered → ensure the per-repo process is up
-    let repoSockViaEnsure;
-    try {
-        repoSockViaEnsure = await ensureRepo(daemonSock, cwd);
-    }
-    catch (err) {
-        process.stderr.write(`\x1b[38;2;248;113;113m\u2717\x1b[0m Failed to ensure repo process: ${err.message}\n`);
-        process.exit(1);
-    }
-    // Register this bridge connection
-    try {
-        await connectRepo(daemonSock, cwd);
-    }
-    catch {
-        // Non-fatal — idle sweep may stop the repo eventually
-    }
-    process.stderr.write(`[unerr:mcp] Bridging to repo process via unerrd (sock: ${repoSockViaEnsure})\n`);
-    // Throttled activity reporting (1/min)
-    const ACTIVITY_THROTTLE_MS = 60_000;
-    let lastActivitySent = 0;
-    const activityInterval = setInterval(() => {
-        const now = Date.now();
-        if (now - lastActivitySent >= ACTIVITY_THROTTLE_MS) {
-            sendActivity(daemonSock, cwd);
-            lastActivitySent = now;
-        }
-    }, ACTIVITY_THROTTLE_MS);
-    activityInterval.unref();
-    // Bridge to the per-repo process
-    const bridgeResult = await startUdsBridge(repoSockViaEnsure);
-    // Cleanup: disconnect from daemon, stop activity reporting
-    clearInterval(activityInterval);
-    try {
-        await disconnectRepo(daemonSock, cwd);
-    }
-    catch {
-        // Best-effort — daemon may already be gone
-    }
-    if (bridgeResult.reason === "daemon_dead") {
-        process.stderr.write("\x1b[38;2;248;113;113m\u2717\x1b[0m unerr proxy disconnected mid-session.\n  The repo process may have been idle-stopped or crashed.\n");
-        process.exit(1);
-    }
-}
-/** Bridge to a UDS sock and handle disconnect/error. */
-async function bridgeAndExit(startBridge, sockPath) {
-    const result = await startBridge(sockPath);
-    if (result.reason === "daemon_dead") {
-        process.stderr.write("\x1b[38;2;248;113;113m\u2717\x1b[0m unerr proxy disconnected mid-session.\n");
-        process.exit(1);
-    }
-}
-// ── Commander Setup ─────────────────────────────────────────
-const program = new Command();
-program
-    .name("unerr")
-    .description("Code intelligence for AI agents")
-    .version("0.1.0")
-    .option("--ide <type>", "IDE type: cursor, vscode, claude-code, windsurf")
-    .option("--mcp", "Start in MCP server mode (stdio, no interactive prompts)")
-    .option("--daemon-child", "Run as a daemon-managed child process (internal, set by unerrd)")
-    .showHelpAfterError("(use --help for available commands)")
-    .action(async (opts) => {
-    const cwd = process.cwd();
-    // --daemon-child: managed child mode (spawned by unerrd)
-    if (opts.daemonChild) {
-        await daemonChildBoot(cwd);
-        return;
-    }
-    // --mcp: headless MCP server mode for IDE integration
-    if (opts.mcp) {
-        await mcpBoot(cwd);
-        return;
-    }
-    const config = readLocalConfig(cwd);
-    if (config) {
-        await resumeBoot(config);
-    }
-    else {
-        await firstRunBoot();
-    }
-});
-// ── Visible Commands (shown in --help) ──────────────────────
-program
-    .command("chat")
-    .description("Interactive AI assistant (coming soon)")
-    .option("--model <model>", "Claude model to use")
-    .option("--no-graph", "Skip loading the code intelligence graph")
-    .action(async () => {
-    process.stderr.write("\n  unerr chat is temporarily disabled.\n  Use unerr as an MCP proxy with your preferred AI agent instead.\n\n");
-    process.exit(0);
-});
-registerStatusCommand(program);
-registerStatsCommand(program);
-registerInstallCommand(program);
-registerDashboardCommand(program);
-registerDebugCommand(program);
-registerGainCommand(program);
-registerDiscoverCommand(program);
-registerDaemonCommand(program);
-// ── Hidden Commands (callable but not shown in --help) ──────
-const hiddenCommands = [
-    registerBranchesCommand,
-    registerCheckCommitCommand,
-    registerCompressOutputCommand,
-    registerConfigVerifyCommand,
-    registerEnrichCommand,
-    registerExecCommand,
-    registerHookCommand,
-    registerIndexCommand,
-    registerInitCommand,
-    registerLearnCommand,
-    registerManifestCommand,
-    registerRewindCommand,
-    registerSkillsCommand,
-    registerTimelineCommand,
-    registerUninstallCommand,
-];
-for (const register of hiddenCommands) {
-    register(program);
-}
-// Hide all commands except chat, status, debug from --help output
-const visibleCommands = new Set([
-    "status",
-    "stats",
-    "install",
-    "dashboard",
-    "debug",
-    "init",
-    "daemon",
-]);
-for (const cmd of program.commands) {
-    if (!visibleCommands.has(cmd.name())) {
-        // Commander internal property — commands with _hidden=true are omitted from help
-        cmd._hidden = true;
-    }
-}
-program.parse();