@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/commands/branches.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { gitQuery } from "../utils/exec.js";
+export async function listLocalBranches(cwd) {
+    const raw = await gitQuery([
+        "branch",
+        "-a",
+        "--format=%(HEAD)|%(refname:short)|%(upstream:track)|%(committerdate:relative)",
+    ], cwd);
+    if (!raw)
+        return [];
+    const driftCounts = loadBranchDriftCounts(cwd);
+    const branches = [];
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split("|");
+        const isCurrent = parts[0] === "*";
+        const name = parts[1] ?? "";
+        const tracking = parts[2] ?? "";
+        const lastCommit = parts[3] ?? "";
+        if (!name)
+            continue;
+        branches.push({
+            name,
+            isCurrent,
+            lastCommit,
+            tracking,
+            driftEntityCount: driftCounts.get(name) ?? 0,
+        });
+    }
+    return branches;
+}
+function loadBranchDriftCounts(cwd) {
+    const counts = new Map();
+    const branchDir = path.join(cwd, ".unerr", "state", "branch-overlays");
+    if (!fs.existsSync(branchDir))
+        return counts;
+    try {
+        const entries = fs.readdirSync(branchDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const overlayPath = path.join(branchDir, entry.name, "overlay_snapshot.json");
+            if (!fs.existsSync(overlayPath))
+                continue;
+            try {
+                const raw = fs.readFileSync(overlayPath, "utf-8");
+                const snapshot = JSON.parse(raw);
+                if (snapshot.branch && snapshot.entities) {
+                    counts.set(snapshot.branch, snapshot.entities.length);
+                }
+            }
+            catch {
+                // Skip corrupt snapshots
+            }
+        }
+    }
+    catch {
+        // Non-blocking
+    }
+    return counts;
+}
+export function registerBranchesCommand(program) {
+    program
+        .command("branches")
+        .description("Show branches for this repository")
+        .action(async () => {
+        try {
+            const cwd = process.cwd();
+            const branches = await listLocalBranches(cwd);
+            if (branches.length === 0) {
+                process.stderr.write("[unerr] No branches found.\n");
+                return;
+            }
+            let withDrift = 0;
+            process.stderr.write("\n");
+            for (const branch of branches) {
+                const marker = branch.isCurrent ? "* " : "  ";
+                const trackingSuffix = branch.tracking ? ` ${branch.tracking}` : "";
+                let driftSuffix = "";
+                if (branch.driftEntityCount > 0) {
+                    driftSuffix = ` (${branch.driftEntityCount} drift entities)`;
+                    withDrift++;
+                }
+                process.stderr.write(`${marker}${branch.name.padEnd(30)} ${branch.lastCommit}${trackingSuffix}${driftSuffix}\n`);
+            }
+            process.stderr.write(`\n  ${branches.length} branches · ${withDrift} with drift overlays\n\n`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${message}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/check-commit.js

@@ -0,0 +1,225 @@
+/**
+ * unerr check-commit — Pre-commit convention validation.
+ *
+ * Called by the pre-commit git hook to check staged changes
+ * against project conventions. Non-blocking by default.
+ *
+ * Sprint 4 (Task 4.2): Full convention checking implementation.
+ *
+ * Flow:
+ *   1. Load CozoDB graph from local snapshot
+ *   2. Get staged files from git
+ *   3. Evaluate rules against each staged file
+ *   4. Display violations with formatted output
+ *   5. Exit 1 if blocking mode and violations found
+ *
+ * Exit codes:
+ *   0 — All checks pass (or no checks available)
+ *   1 — Violations found (only when blocking mode is enabled)
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { gunzipSync } from "node:zlib";
+import pc from "picocolors";
+import { getStagedFiles } from "../utils/git.js";
+import { logInfo } from "../utils/log.js";
+import { detail, fail, info, section, success, warn } from "../utils/ui.js";
+/** File extensions we can evaluate rules against. */
+const SUPPORTED_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+]);
+export function registerCheckCommitCommand(program) {
+    program
+        .command("check-commit")
+        .description("Check staged changes against project conventions (pre-commit hook)")
+        .option("--blocking", "Exit with code 1 on violations (default: non-blocking)")
+        .option("--verbose", "Show detailed output including passing files")
+        .action(async (opts) => {
+        const cwd = process.cwd();
+        // ── Blocking mode detection ──────────────────────────────────
+        let blockingMode = opts.blocking ?? false;
+        const settingsPath = join(cwd, ".unerr", "settings.json");
+        if (!blockingMode && existsSync(settingsPath)) {
+            try {
+                const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+                blockingMode = settings.hooks?.precommit?.blocking ?? false;
+            }
+            catch {
+                /* ignore malformed settings */
+            }
+        }
+        logInfo("check-commit invoked", { blocking: blockingMode });
+        // ── Config gating ────────────────────────────────────────────
+        const configPath = join(cwd, ".unerr", "config.json");
+        if (!existsSync(configPath)) {
+            logInfo("check-commit: no .unerr/config.json, skipping");
+            return;
+        }
+        let repoId;
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            if (!config.repoId) {
+                logInfo("check-commit: no repoId in config, skipping");
+                return;
+            }
+            repoId = config.repoId;
+        }
+        catch {
+            logInfo("check-commit: invalid config.json, skipping");
+            return;
+        }
+        // ── Get staged files ─────────────────────────────────────────
+        const stagedFiles = await getStagedFiles(cwd);
+        if (stagedFiles.length === 0) {
+            logInfo("check-commit: no staged files");
+            return;
+        }
+        // Filter to supported file types
+        const checkableFiles = stagedFiles.filter((f) => SUPPORTED_EXTENSIONS.has(extname(f)));
+        if (checkableFiles.length === 0) {
+            if (opts.verbose) {
+                section("unerr pre-commit check");
+                detail(`${stagedFiles.length} staged file${stagedFiles.length !== 1 ? "s" : ""} — none with supported extensions`);
+            }
+            return;
+        }
+        // ── Load graph ───────────────────────────────────────────────
+        const snapshotsDir = join(cwd, ".unerr", "snapshots");
+        const manifestsDir = join(cwd, ".unerr", "manifests");
+        const localGraph = await loadGraphForCheckCommit(repoId, snapshotsDir, manifestsDir);
+        if (!localGraph) {
+            if (opts.verbose) {
+                section("unerr pre-commit check");
+                detail("No local graph available — skipping convention checks");
+            }
+            logInfo("check-commit: no graph available, skipping");
+            return;
+        }
+        // Check if any rules exist
+        if (!(await localGraph.hasRules())) {
+            if (opts.verbose) {
+                section("unerr pre-commit check");
+                detail("No rules defined — skipping convention checks");
+            }
+            logInfo("check-commit: no rules in graph, skipping");
+            return;
+        }
+        // ── Evaluate rules per file ──────────────────────────────────
+        const { evaluateRules } = await import("../intelligence/rule-evaluator.js");
+        const allFileViolations = [];
+        let totalRulesEvaluated = 0;
+        let filesChecked = 0;
+        for (const filePath of checkableFiles) {
+            const absPath = join(cwd, filePath);
+            if (!existsSync(absPath))
+                continue;
+            let content;
+            try {
+                content = readFileSync(absPath, "utf-8");
+            }
+            catch {
+                continue; // Skip unreadable files
+            }
+            const rules = await localGraph.getRules(filePath);
+            if (rules.length === 0)
+                continue;
+            filesChecked++;
+            totalRulesEvaluated += rules.length;
+            try {
+                const result = await evaluateRules(rules, filePath, content, localGraph);
+                if (result.violations.length > 0) {
+                    allFileViolations.push({
+                        filePath,
+                        violations: result.violations,
+                    });
+                }
+            }
+            catch (err) {
+                logInfo(`check-commit: rule evaluation failed for ${filePath}`, err);
+            }
+        }
+        const totalViolations = allFileViolations.reduce((sum, fv) => sum + fv.violations.length, 0);
+        // ── Display results ──────────────────────────────────────────
+        section("unerr pre-commit check");
+        if (totalViolations === 0) {
+            success(`${filesChecked} file${filesChecked !== 1 ? "s" : ""} checked, ${totalRulesEvaluated} rules evaluated — all clear`);
+            process.exitCode = 0;
+            return;
+        }
+        // Display violations grouped by file
+        for (const fv of allFileViolations) {
+            fail(`${fv.filePath}`);
+            for (const v of fv.violations) {
+                const location = v.line ? `:${v.line}` : "";
+                const severityColor = v.severity === "error"
+                    ? pc.red
+                    : v.severity === "warning"
+                        ? pc.yellow
+                        : pc.dim;
+                info(`${severityColor(`[${v.severity}]`)} ${v.message}${location ? pc.dim(` (line ${v.line})`) : ""}`);
+                if (v.matchedCode && opts.verbose) {
+                    detail(`  → ${v.matchedCode.slice(0, 80)}`);
+                }
+            }
+        }
+        // Summary line
+        const errorCount = allFileViolations.reduce((sum, fv) => sum + fv.violations.filter((v) => v.severity === "error").length, 0);
+        const warningCount = totalViolations - errorCount;
+        const errorSuffix = errorCount > 0
+            ? ` (${errorCount} error${errorCount !== 1 ? "s" : ""})`
+            : "";
+        const warnSuffix = warningCount > 0
+            ? ` (${warningCount} warning${warningCount !== 1 ? "s" : ""})`
+            : "";
+        warn(`${totalViolations} violation${totalViolations !== 1 ? "s" : ""} found${errorSuffix}${warnSuffix}`);
+        if (blockingMode) {
+            fail("Commit blocked — fix violations or use --no-verify to bypass");
+            process.exitCode = 1;
+        }
+        else {
+            detail("Non-blocking mode — commit will proceed");
+            detail("Enable blocking: set hooks.precommit.blocking=true in .unerr/settings.json");
+            process.exitCode = 0;
+        }
+    });
+}
+// ── Graph Loading ────────────────────────────────────────────────────
+/**
+ * Load CozoDB graph for standalone check-commit (proxy may not be running).
+ * Returns null if no snapshot available.
+ */
+async function loadGraphForCheckCommit(repoId, snapshotsDir, manifestsDir) {
+    // Check manifest exists
+    const manifestPath = join(manifestsDir, `${repoId}.json`);
+    if (!existsSync(manifestPath))
+        return null;
+    // Find snapshot file
+    let snapshotPath = join(snapshotsDir, `${repoId}.msgpack.gz`);
+    if (!existsSync(snapshotPath)) {
+        snapshotPath = join(snapshotsDir, `${repoId}.msgpack`);
+    }
+    if (!existsSync(snapshotPath))
+        return null;
+    try {
+        // Dynamic imports to keep cold start fast when no check needed
+        const { default: CozoDbConstructor } = await import("cozo-node");
+        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
+        const { unpack } = await import("msgpackr");
+        const db = new CozoDbConstructor();
+        const localGraph = await CozoGraphStore.create(db);
+        const raw = readFileSync(snapshotPath);
+        const buffer = snapshotPath.endsWith(".gz") ? gunzipSync(raw) : raw;
+        const envelope = unpack(buffer);
+        await localGraph.loadSnapshot(envelope);
+        return localGraph;
+    }
+    catch (err) {
+        logInfo("check-commit: failed to load graph", err);
+        return null;
+    }
+}

package/dist/commands/compress-output.js

@@ -0,0 +1,64 @@
+/**
+ * `unerr compress-output` — stdin→stdout compression for CLI hooks.
+ *
+ * S6.4: Reads text from stdin, compresses with the output compressor,
+ * writes compressed output to stdout. When graph is available, passes
+ * entity risk map for graph-aware prioritization.
+ *
+ * Usage (in hooks): echo "$OUTPUT" | unerr compress-output
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { compressOutput, } from "../proxy/output-compressor.js";
+/**
+ * Load entity risk map from the local graph state if available.
+ * Returns empty map if graph is not initialized.
+ */
+function loadEntityRiskMap(cwd) {
+    const riskMap = new Map();
+    try {
+        const unerrDir = join(cwd, ".unerr");
+        const configPath = join(unerrDir, "config.json");
+        if (!existsSync(configPath))
+            return riskMap;
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!config.repoId)
+            return riskMap;
+        const riskCachePath = join(unerrDir, "state", "entity_risk_cache.json");
+        if (!existsSync(riskCachePath))
+            return riskMap;
+        const data = JSON.parse(readFileSync(riskCachePath, "utf-8"));
+        for (const [key, info] of Object.entries(data)) {
+            riskMap.set(key, info);
+        }
+    }
+    catch {
+        // Risk map loading is best-effort — compression works without it
+    }
+    return riskMap;
+}
+export function registerCompressOutputCommand(program) {
+    program
+        .command("compress-output")
+        .description("Compress text from stdin using graph-aware compression (for hooks)")
+        .option("--budget <tokens>", "Token budget", "2000")
+        .option("--no-graph", "Skip loading graph risk map")
+        .action(async (opts) => {
+        const budget = Number.parseInt(opts.budget, 10) || 2000;
+        let input = "";
+        for await (const chunk of process.stdin) {
+            input += chunk;
+        }
+        if (input.length === 0) {
+            process.exit(0);
+            return;
+        }
+        // S6.4: Load entity risk map from graph when available
+        const entityRiskMap = opts.graph !== false ? loadEntityRiskMap(process.cwd()) : undefined;
+        const result = compressOutput(input, {
+            tokenBudget: budget,
+            entityRiskMap: entityRiskMap && entityRiskMap.size > 0 ? entityRiskMap : undefined,
+        });
+        process.stdout.write(result.output);
+    });
+}

package/dist/commands/config-verify.js

@@ -0,0 +1,243 @@
+/**
+ * unerr config verify — P5.6-ADV-04: Self-healing MCP configuration.
+ * Checks and repairs MCP config for supported IDEs (VS Code, Cursor, etc.)
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const IDE_CONFIG_PATHS = {
+    vscode: path.join(os.homedir(), ".vscode", "settings.json"),
+    cursor: path.join(os.homedir(), ".cursor", "mcp.json"),
+    windsurf: path.join(os.homedir(), ".windsurf", "mcp.json"),
+    "claude-code": path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
+};
+function loadConfig() {
+    const configPath = path.join(process.cwd(), ".unerr", "config.json");
+    if (!fs.existsSync(configPath))
+        return null;
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+}
+export function checkIdeConfig(ideName, configPath) {
+    const issues = [];
+    if (!fs.existsSync(configPath)) {
+        return {
+            found: false,
+            configured: false,
+            issues: [`${ideName} config not found at ${configPath}`],
+            needsMigration: false,
+        };
+    }
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        if (!config.mcpServers) {
+            issues.push(`${ideName}: No mcpServers section found`);
+            return { found: true, configured: false, issues, needsMigration: false };
+        }
+        const unerrServer = config.mcpServers.unerr;
+        if (!unerrServer) {
+            issues.push(`${ideName}: No unerr MCP server configured`);
+            return { found: true, configured: false, issues, needsMigration: false };
+        }
+        // Check if still pointing to remote URL (needs migration to local proxy)
+        if (unerrServer.url && !unerrServer.command) {
+            issues.push(`${ideName}: unerr MCP config points to remote URL — should use local proxy`);
+            return { found: true, configured: true, issues, needsMigration: true };
+        }
+        // Check if using local proxy correctly (direct binary or npx)
+        if (unerrServer.command === "unerr" &&
+            unerrServer.args?.includes("--mcp")) {
+            return { found: true, configured: true, issues, needsMigration: false };
+        }
+        // Legacy: npx @unerr/unerr format (needs migration to direct binary)
+        if (unerrServer.command === "npx" &&
+            (unerrServer.args?.includes("@unerr/unerr") ||
+                unerrServer.args?.includes("@unerr/unerr-mcp"))) {
+            issues.push(`${ideName}: using npx with unpublished package — should use direct 'unerr' binary`);
+            return { found: true, configured: true, issues, needsMigration: true };
+        }
+        issues.push(`${ideName}: unerr MCP config has unexpected format`);
+        return { found: true, configured: true, issues, needsMigration: true };
+    }
+    catch {
+        issues.push(`${ideName}: Failed to parse config at ${configPath}`);
+        return { found: true, configured: false, issues, needsMigration: false };
+    }
+}
+export function repairIdeConfig(ideName, configPath, mode = "proxy") {
+    try {
+        const dir = path.dirname(configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        let config = {};
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf-8");
+            config = JSON.parse(raw);
+        }
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        if (mode === "standalone") {
+            // Sprint 5.4: Standalone read-only MCP server
+            const graphPath = resolveGraphPath();
+            config.mcpServers.unerr = {
+                command: "unerr",
+                args: ["--mcp"],
+                env: graphPath ? { UNERR_GRAPH_PATH: graphPath } : {},
+            };
+        }
+        else {
+            // Local proxy — direct binary
+            config.mcpServers.unerr = {
+                command: "unerr",
+                args: ["--mcp"],
+            };
+        }
+        fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sprint 5.4: Resolve the graph snapshot path.
+ * Looks in the repo's .unerr/snapshots/ directory.
+ */
+function resolveGraphPath() {
+    const snapshotsDir = path.join(process.cwd(), ".unerr", "snapshots");
+    if (!fs.existsSync(snapshotsDir))
+        return null;
+    const files = fs
+        .readdirSync(snapshotsDir)
+        .filter((f) => f.endsWith(".msgpack.gz") || f.endsWith(".msgpack"))
+        .map((f) => ({
+        name: f,
+        path: path.join(snapshotsDir, f),
+        mtime: fs.statSync(path.join(snapshotsDir, f)).mtimeMs,
+    }))
+        .sort((a, b) => b.mtime - a.mtime);
+    return files[0]?.path ?? null;
+}
+export function registerConfigVerifyCommand(program) {
+    const configCmd = program
+        .command("config")
+        .description("Manage unerr configuration");
+    configCmd
+        .command("verify")
+        .description("Check and optionally repair MCP configuration for IDEs")
+        .option("--silent", "Only output errors")
+        .option("--repair", "Automatically repair misconfigured IDEs")
+        .option("--ide <ide>", "Check specific IDE (vscode, cursor, windsurf, claude-code)")
+        .option("--mode <mode>", "Server mode: proxy (full) or standalone (read-only)", "proxy")
+        .action(async (opts) => {
+        const idesToCheck = opts.ide
+            ? { [opts.ide]: IDE_CONFIG_PATHS[opts.ide] ?? "" }
+            : IDE_CONFIG_PATHS;
+        let allGood = true;
+        for (const [ideName, configPath] of Object.entries(idesToCheck)) {
+            if (!configPath) {
+                if (!opts.silent)
+                    console.log(`  Unknown IDE: ${ideName}`);
+                continue;
+            }
+            const result = checkIdeConfig(ideName, configPath);
+            if (result.configured && result.issues.length === 0) {
+                if (!opts.silent)
+                    console.log(`  ✓ ${ideName}: configured correctly`);
+            }
+            else {
+                allGood = false;
+                for (const issue of result.issues) {
+                    console.log(`  ✗ ${issue}`);
+                }
+                if (opts.repair) {
+                    const serverMode = (opts.mode === "standalone" ? "standalone" : "proxy");
+                    const repaired = repairIdeConfig(ideName, configPath, serverMode);
+                    if (repaired) {
+                        console.log(`  ✓ ${ideName}: repaired`);
+                    }
+                    else {
+                        console.log(`  ✗ ${ideName}: repair failed`);
+                    }
+                }
+            }
+        }
+        if (!allGood && !opts.repair) {
+            console.log("\n  Run with --repair to fix issues automatically.");
+        }
+        if (allGood && !opts.silent) {
+            console.log("\n  All IDE configurations look good!");
+        }
+    });
+    // Show MCP config for manual copy-paste
+    configCmd
+        .command("show")
+        .description("Show MCP config snippet for an agent (for manual setup)")
+        .argument("[agent]", "Agent name (e.g. cursor, claude-code, kiro) or 'all'")
+        .action(async (agent) => {
+        const { generateConfigSnippet, getConfigInfo } = await import("../config/mcp-config-writer.js");
+        const { AGENT_REGISTRY } = await import("../config/agent-registry.js");
+        const { ideDisplayName } = await import("../utils/detect.js");
+        if (!agent || agent === "all") {
+            console.log("\n  Supported agents and their MCP config paths:\n");
+            for (const a of AGENT_REGISTRY) {
+                console.log(`    ${a.name.padEnd(22)} ${a.projectConfigPath}`);
+            }
+            console.log("\n  Usage: unerr install <agent>\n  Example: unerr install kiro\n");
+            return;
+        }
+        const agentDef = AGENT_REGISTRY.find((a) => a.id === agent || a.name.toLowerCase() === agent.toLowerCase());
+        if (!agentDef) {
+            console.error(`  Unknown agent: ${agent}\n  Available: ${AGENT_REGISTRY.map((a) => a.id).join(", ")}`);
+            process.exit(1);
+        }
+        const info = getConfigInfo(agentDef.id);
+        const snippet = generateConfigSnippet(agentDef.id);
+        console.log(`\n  ${agentDef.name} — ${agentDef.description}`);
+        console.log(`  Config path: ${info?.path}\n`);
+        console.log("  Add this to your config:\n");
+        console.log(snippet
+            .split("\n")
+            .map((l) => `    ${l}`)
+            .join("\n"));
+        console.log("");
+    });
+    // Git hooks sub-command
+    configCmd
+        .command("install-hooks")
+        .description("Install git hooks for automatic MCP config verification")
+        .action(async () => {
+        const gitDir = path.join(process.cwd(), ".git");
+        if (!fs.existsSync(gitDir)) {
+            console.error("Not a git repository");
+            process.exit(1);
+        }
+        const hooksDir = path.join(gitDir, "hooks");
+        if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true });
+        }
+        const hookScript = `#!/bin/sh
+# unerr auto-verify MCP config
+if command -v unerr &> /dev/null; then
+  unerr config verify --silent 2>/dev/null || true
+fi
+`;
+        for (const hookName of ["post-checkout", "post-merge"]) {
+            const hookPath = path.join(hooksDir, hookName);
+            if (fs.existsSync(hookPath)) {
+                const existing = fs.readFileSync(hookPath, "utf-8");
+                if (existing.includes("unerr config verify")) {
+                    console.log(`  ✓ ${hookName}: already installed`);
+                    continue;
+                }
+                fs.appendFileSync(hookPath, `\n${hookScript}`);
+            }
+            else {
+                fs.writeFileSync(hookPath, hookScript);
+                fs.chmodSync(hookPath, "755");
+            }
+            console.log(`  ✓ ${hookName}: installed`);
+        }
+    });
+}