@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/ui/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>unerr — intelligence</title>
-    <script type="module" crossorigin src="/assets/index-B-0HTtUR.js"></script>
+    <script type="module" crossorigin src="/assets/index-BsMTQdhX.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-S-ySWqyJ.js">
     <link rel="modulepreload" crossorigin href="/assets/vis-network-NIJHUFI3.js">
     <link rel="stylesheet" crossorigin href="/assets/index-7gl3mIuY.css">

package/dist/utils/counterfactual.js

@@ -0,0 +1,65 @@
+/**
+ * Counterfactual Framing Utility — wraps all savings displays in
+ * "without unerr" framing for value perception.
+ *
+ * VS.8: Every savings display must use counterfactual language:
+ *   "Without unerr, this session would have cost $X.XX more"
+ *   "Without unerr, the agent would have explored 15 files to find this"
+ */
+import { formatDollars } from "../proxy/model-pricing.js";
+/**
+ * Frame a token savings as a counterfactual statement.
+ */
+export function frameTokenSavings(tokensSaved, dollarsSaved) {
+    if (tokensSaved <= 0)
+        return "";
+    const tokensStr = tokensSaved >= 1000
+        ? `${(tokensSaved / 1000).toFixed(1)}K`
+        : String(tokensSaved);
+    return `Without unerr, ${tokensStr} additional tokens (${formatDollars(dollarsSaved)}) would have been consumed.`;
+}
+/**
+ * Frame a guard moment (prevented cost).
+ */
+export function frameGuardMoment(description, dollarsPrevented) {
+    return `[unerr] ⚠ Prevented: ${description}. Without unerr, est. cost: ${formatDollars(dollarsPrevented)}`;
+}
+/**
+ * Frame exploration savings.
+ */
+export function frameExplorationSaving(queryType, filesAvoided) {
+    return `Without unerr, the agent would have read ~${filesAvoided} files to get this information.`;
+}
+/**
+ * Frame session summary with counterfactual.
+ */
+export function frameSessionSummary(tokensSaved, dollarsSaved, guardsFirered) {
+    const parts = [];
+    if (tokensSaved > 0) {
+        const tokensStr = tokensSaved >= 1000
+            ? `${(tokensSaved / 1000).toFixed(1)}K`
+            : String(tokensSaved);
+        parts.push(`${tokensStr} tokens saved (${formatDollars(dollarsSaved)})`);
+    }
+    if (guardsFirered > 0) {
+        parts.push(`${guardsFirered} issue(s) prevented`);
+    }
+    if (parts.length === 0) {
+        return "Graph intelligence active — monitoring for savings opportunities.";
+    }
+    return `Without unerr: ${parts.join(", ")} would have been wasted.`;
+}
+/**
+ * Frame a weekly trend delta.
+ */
+export function frameWeeklyTrend(thisWeekSaved, lastWeekSaved, dollarsSaved) {
+    const trend = thisWeekSaved > lastWeekSaved
+        ? "↑"
+        : thisWeekSaved < lastWeekSaved
+            ? "↓"
+            : "→";
+    const tokensStr = thisWeekSaved >= 1000
+        ? `${(thisWeekSaved / 1000).toFixed(1)}K`
+        : String(thisWeekSaved);
+    return `This week: ${tokensStr} tokens saved (${formatDollars(dollarsSaved)}) ${trend}`;
+}

package/dist/utils/deep-link.js

@@ -0,0 +1,34 @@
+/**
+ * Deep-link URL generation for bridging CLI → web dashboard.
+ *
+ * §0.7 Constraint #8: "Every terminal display must include a deep link."
+ * Used by: startup display, status command, health check, session summary.
+ */
+const BASE_URL = "https://app.unerr.dev";
+/**
+ * Generate a context-aware deep link to the unerr web dashboard.
+ *
+ * @param repoId - Repository identifier (e.g. "repo_abc123"). If empty/undefined, returns generic landing.
+ * @param options - Query parameters for view targeting and analytics.
+ * @returns Full URL string with query parameters.
+ */
+export function buildDeepLink(repoId, options) {
+    if (!repoId) {
+        // Fallback: generic landing when repo context unavailable
+        const params = new URLSearchParams();
+        params.set("utm_source", options?.utm_source ?? "cli");
+        return `${BASE_URL}?${params.toString()}`;
+    }
+    const base = `${BASE_URL}/r/${repoId}`;
+    const params = new URLSearchParams();
+    if (options?.view)
+        params.set("view", options.view);
+    if (options?.branch)
+        params.set("branch", options.branch);
+    if (options?.entities?.length)
+        params.set("entities", options.entities.join(","));
+    if (options?.intents?.length)
+        params.set("intents", options.intents.join(","));
+    params.set("utm_source", options?.utm_source ?? "cli");
+    return `${base}?${params.toString()}`;
+}

package/dist/utils/detect.js

@@ -0,0 +1,193 @@
+/**
+ * Smart detection utilities for git host and IDE type.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { exec } from "./exec.js";
+import { getCurrentBranch, getRemoteUrl, isGitRepo as isGitRepoGit, } from "./git.js";
+/**
+ * Classify a git remote URL into a known host or "other".
+ */
+export function classifyHost(remote) {
+    const lower = remote.toLowerCase();
+    if (lower.includes("github.com"))
+        return "github";
+    if (lower.includes("gitlab.com") || lower.includes("gitlab."))
+        return "gitlab";
+    if (lower.includes("bitbucket.org") || lower.includes("bitbucket."))
+        return "bitbucket";
+    return "other";
+}
+/**
+ * Parse a remote URL into owner/repo format.
+ */
+function parseRemote(remote) {
+    // git@github.com:owner/repo.git
+    const sshMatch = remote.match(/git@[^:]+:(.+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1] ?? null;
+    // https://github.com/owner/repo.git
+    const httpMatch = remote.match(/(?:https?:\/\/)?(?:www\.)?[^/]+\/(.+?)(?:\.git)?$/);
+    if (httpMatch)
+        return httpMatch[1] ?? null;
+    return null;
+}
+/**
+ * Detect full git context from the current working directory.
+ */
+export async function detectGitContext(cwd) {
+    try {
+        const dir = cwd ?? process.cwd();
+        const remote = await getRemoteUrl(dir);
+        if (!remote)
+            return null;
+        const branch = (await getCurrentBranch(dir)) || "main";
+        const fullName = parseRemote(remote);
+        if (!fullName)
+            return null;
+        const parts = fullName.split("/");
+        if (parts.length < 2)
+            return null;
+        return {
+            remote,
+            branch,
+            owner: parts[0] ?? "",
+            repo: parts[1] ?? "",
+            fullName,
+            host: classifyHost(remote),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if the current directory is inside a git repository.
+ */
+export async function isGitRepo(cwd) {
+    return isGitRepoGit(cwd ?? process.cwd());
+}
+/**
+ * Auto-detect the IDE from project directory and environment.
+ *
+ * Checks in order:
+ *  1. CURSOR_TRACE_ID env → Cursor terminal
+ *  2. TERM_PROGRAM=vscode + cursor extensions path → Cursor
+ *  3. CLAUDE_CODE env or "claude" process ancestry → Claude Code
+ *  4. .cursor/ directory in project → Cursor
+ *  5. .windsurf/ directory in project → Windsurf
+ *  6. TERM_PROGRAM=vscode → VS Code
+ *  7. .vscode/ directory in project → VS Code
+ *  8. "unknown" → will be prompted
+ */
+export async function detectIde(cwd) {
+    // Cursor sets CURSOR_TRACE_ID in its integrated terminal
+    if (process.env.CURSOR_TRACE_ID)
+        return "cursor";
+    // Claude Code sets CLAUDE_CODE or similar markers
+    if (process.env.CLAUDE_CODE === "1" || process.env.CLAUDE_CODE === "true")
+        return "claude-code";
+    // Check TERM_PROGRAM for VS Code-based editors
+    const termProgram = process.env.TERM_PROGRAM ?? "";
+    if (termProgram === "vscode") {
+        // Could be Cursor (fork of VS Code) — check for Cursor-specific paths
+        const cursorExtensions = process.env.VSCODE_CWD ?? "";
+        if (cursorExtensions.toLowerCase().includes("cursor"))
+            return "cursor";
+    }
+    // Check for Claude Code in process ancestry
+    try {
+        const ppid = process.ppid;
+        if (ppid) {
+            const result = await exec("ps", ["-o", "comm=", "-p", String(ppid)]);
+            if (result.exitCode === 0 && result.stdout.includes("claude"))
+                return "claude-code";
+        }
+    }
+    catch {
+        // Ignore — process inspection may not be available
+    }
+    // Directory-based detection
+    if (existsSync(join(cwd, ".cursor")))
+        return "cursor";
+    if (existsSync(join(cwd, ".windsurf")))
+        return "windsurf";
+    if (termProgram === "vscode")
+        return "vscode";
+    if (existsSync(join(cwd, ".vscode")))
+        return "vscode";
+    // Zed: checks for .zed/ directory or ZED_TERM env
+    if (process.env.ZED_TERM === "true" || existsSync(join(cwd, ".zed")))
+        return "zed";
+    // Antigravity: checks for env vars or .antigravity/ directory
+    if (process.env.ANTIGRAVITY_PROJECT_DIR || process.env.ANTIGRAVITY_VERSION)
+        return "antigravity";
+    if (existsSync(join(cwd, ".antigravity")))
+        return "antigravity";
+    return "unknown";
+}
+/**
+ * Human-readable IDE name for display.
+ */
+export function ideDisplayName(ide) {
+    switch (ide) {
+        case "cursor":
+            return "Cursor";
+        case "claude-code":
+            return "Claude Code";
+        case "vscode":
+            return "VS Code";
+        case "windsurf":
+            return "Windsurf";
+        case "zed":
+            return "Zed";
+        case "cline":
+            return "Cline";
+        case "kiro":
+            return "Kiro";
+        case "gemini-cli":
+            return "Gemini CLI";
+        case "codex":
+            return "Codex";
+        case "aider":
+            return "Aider";
+        case "opencode":
+            return "OpenCode";
+        case "trae":
+            return "Trae";
+        case "augment":
+            return "Augment";
+        case "github-copilot-cli":
+            return "GitHub Copilot CLI";
+        case "continue":
+            return "Continue";
+        case "antigravity":
+            return "Google Antigravity";
+        case "other":
+            return "Other";
+        case "unknown":
+            return "your IDE";
+    }
+}
+/**
+ * All IDE choices for interactive prompt.
+ */
+export const IDE_CHOICES = [
+    { title: "Cursor", value: "cursor" },
+    { title: "Claude Code", value: "claude-code" },
+    { title: "VS Code / Copilot", value: "vscode" },
+    { title: "Windsurf", value: "windsurf" },
+    { title: "Zed", value: "zed" },
+    { title: "Cline", value: "cline" },
+    { title: "Kiro", value: "kiro" },
+    { title: "Gemini CLI", value: "gemini-cli" },
+    { title: "Codex (OpenAI)", value: "codex" },
+    { title: "Aider", value: "aider" },
+    { title: "OpenCode", value: "opencode" },
+    { title: "Trae", value: "trae" },
+    { title: "Augment", value: "augment" },
+    { title: "GitHub Copilot CLI", value: "github-copilot-cli" },
+    { title: "Continue", value: "continue" },
+    { title: "Google Antigravity", value: "antigravity" },
+    { title: "Other (manual MCP setup)", value: "other" },
+];

package/dist/utils/exec.js

@@ -0,0 +1,73 @@
+/**
+ * Shell Execution Utility — tinyexec-based async command runner.
+ *
+ * Replaces all raw child_process.execSync / exec usage in the codebase.
+ * Provides type-safe, async, argument-array-based execution (no shell injection).
+ *
+ * For git operations specifically, prefer the higher-level helpers in git.ts
+ * which wrap simple-git. This module is for arbitrary shell commands and
+ * low-level git plumbing where simple-git's API doesn't reach.
+ */
+import { x } from "tinyexec";
+/**
+ * Execute a command with args (no shell interpolation — safe by construction).
+ * Returns structured result. Throws only if throwOnError is true and exit code != 0.
+ */
+export async function exec(command, args = [], options = {}) {
+    const result = await x(command, args, {
+        nodeOptions: {
+            cwd: options.cwd,
+            timeout: options.timeout,
+        },
+        throwOnError: false,
+    });
+    const execResult = {
+        stdout: result.stdout.trim(),
+        stderr: result.stderr.trim(),
+        exitCode: result.exitCode ?? 0,
+    };
+    if (options.throwOnError && execResult.exitCode !== 0) {
+        const msg = execResult.stderr ||
+            execResult.stdout ||
+            `Command failed: ${command} ${args.join(" ")}`;
+        throw new Error(msg);
+    }
+    return execResult;
+}
+/**
+ * Execute a git command. Convenience wrapper that prefixes args with the git subcommand.
+ *
+ * Example: gitExec(["rev-parse", "--is-inside-work-tree"], { cwd })
+ */
+export async function gitExec(args, options = {}) {
+    return exec("git", args, options);
+}
+/**
+ * Quick git query — returns stdout as trimmed string.
+ * Returns null on non-zero exit code instead of throwing.
+ */
+export async function gitQuery(args, cwd) {
+    const result = await gitExec(args, { cwd });
+    return result.exitCode === 0 ? result.stdout : null;
+}
+/**
+ * Open a `http(s):` URL in the system default browser (no shell interpolation).
+ * Localhost-only dashboard links use this from `unerr dashboard`.
+ */
+export async function openUrlInDefaultBrowser(url) {
+    if (!/^https?:\/\//i.test(url)) {
+        throw new Error("openUrlInDefaultBrowser: only http(s) URLs are allowed");
+    }
+    const platform = process.platform;
+    if (platform === "darwin") {
+        await exec("open", [url], { throwOnError: true });
+        return;
+    }
+    if (platform === "win32") {
+        await exec("rundll32", ["url.dll,FileProtocolHandler", url], {
+            throwOnError: true,
+        });
+        return;
+    }
+    await exec("xdg-open", [url], { throwOnError: true });
+}

package/dist/utils/file-logger.js

@@ -0,0 +1,87 @@
+/**
+ * Layer 12 / DM-0: rotating stderr → file mirror.
+ *
+ * Tees every `process.stderr.write` call to a `.log` file on disk so the
+ * three Layer-12 processes (`unerrd`, `unerr`, `unerr --mcp`) still produce
+ * inspectable output when they leave the foreground (auto-spawn from DM-3,
+ * stdio-only IDE bridge, etc.).
+ *
+ * Rotation: when the current file passes `maxBytes`, rename `*.log` →
+ * `*.log.1` (shift the rest), keep the last `keep` files, drop the oldest.
+ *
+ * Independent of `startupLog`: that tool writes structured JSONL events
+ * (`unerr.jsonl`); this one mirrors the raw stderr byte stream (`*.log`).
+ */
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync, } from "node:fs";
+import { dirname } from "node:path";
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape codes are control characters by definition.
+const ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z~]|\x1b\][^\x07]*\x07/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+function rotate(filePath, keep) {
+    for (let i = keep; i >= 1; i--) {
+        const cur = i === 1 ? filePath : `${filePath}.${i - 1}`;
+        const next = `${filePath}.${i}`;
+        if (!existsSync(cur))
+            continue;
+        if (i === keep && existsSync(next)) {
+            try {
+                unlinkSync(next);
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        try {
+            renameSync(cur, next);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+/**
+ * Mirror `process.stderr.write` to `filePath` with ANSI codes stripped.
+ * Returns an uninstaller that restores the original `stderr.write`.
+ *
+ * Side effects: ensures `dirname(filePath)` exists, opens the file in append
+ * mode, never closes it (process lifetime). Terminal stderr is unchanged —
+ * the original colored bytes still reach the TTY.
+ */
+export function installFileLogger(opts) {
+    const { filePath, maxBytes = 5_000_000, keep = 5 } = opts;
+    mkdirSync(dirname(filePath), { recursive: true });
+    let bytesWritten = 0;
+    try {
+        bytesWritten = statSync(filePath).size;
+    }
+    catch {
+        /* file doesn't exist yet */
+    }
+    const original = process.stderr.write;
+    const bound = original.bind(process.stderr);
+    const wrapped = ((chunk, ...rest) => {
+        const result = bound(chunk, ...rest);
+        try {
+            const text = typeof chunk === "string"
+                ? chunk
+                : Buffer.from(chunk).toString("utf-8");
+            const clean = stripAnsi(text);
+            appendFileSync(filePath, clean);
+            bytesWritten += clean.length;
+            if (bytesWritten >= maxBytes) {
+                rotate(filePath, keep);
+                bytesWritten = 0;
+            }
+        }
+        catch {
+            /* file logging is best-effort — never block stderr */
+        }
+        return result;
+    });
+    process.stderr.write = wrapped;
+    return () => {
+        process.stderr.write = original;
+    };
+}

package/dist/utils/format-error.js

@@ -0,0 +1,29 @@
+/**
+ * Serialize an unknown caught value into a stable, human-readable string.
+ *
+ * Why: `String(obj)` returns `"[object Object]"` for plain objects (e.g.,
+ * cozo-node driver errors that aren't Error instances), which is useless in
+ * logs. `JSON.stringify(obj)` returns `"{}"` when an object's properties
+ * are non-enumerable. This helper handles all three shapes deterministically.
+ */
+export function formatUnknownError(err) {
+    if (err instanceof Error)
+        return err.stack ?? err.message;
+    if (typeof err === "object" && err !== null) {
+        const obj = err;
+        if (typeof obj.display === "string")
+            return obj.display;
+        if (typeof obj.message === "string")
+            return obj.message;
+        try {
+            const serialized = JSON.stringify(err, Object.getOwnPropertyNames(err));
+            if (serialized && serialized !== "{}")
+                return serialized;
+        }
+        catch {
+            // fall through
+        }
+        return Object.prototype.toString.call(err);
+    }
+    return String(err);
+}

package/dist/utils/git.js

@@ -0,0 +1,181 @@
+/**
+ * Centralized Git Utility — simple-git based.
+ *
+ * Provides a single factory for creating git instances and typed helpers
+ * for common operations used throughout the codebase.
+ *
+ * Design notes (temporal intelligence foundation):
+ *   - Git log queries return structured data for bi-temporal edge construction.
+ *   - Blame/history helpers enable "when did this fact become true?" queries.
+ *   - Instance caching avoids re-initialization overhead on hot paths.
+ */
+import { simpleGit } from "simple-git";
+const instanceCache = new Map();
+/**
+ * Get a simple-git instance for a working directory.
+ * Instances are cached per cwd to avoid repeated initialization.
+ */
+export function getGit(cwd) {
+    const cached = instanceCache.get(cwd);
+    if (cached)
+        return cached;
+    const opts = {
+        baseDir: cwd,
+        binary: "git",
+        maxConcurrentProcesses: 6,
+        trimmed: true,
+    };
+    const instance = simpleGit(opts);
+    instanceCache.set(cwd, instance);
+    return instance;
+}
+/**
+ * Clear the instance cache (for testing or after cwd changes).
+ */
+export function clearGitCache() {
+    instanceCache.clear();
+}
+/**
+ * Check if a directory is inside a git work tree.
+ */
+export async function isGitRepo(cwd) {
+    try {
+        const git = getGit(cwd);
+        await git.revparse(["--is-inside-work-tree"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current HEAD commit SHA.
+ */
+export async function getHeadSha(cwd) {
+    try {
+        const git = getGit(cwd);
+        return await git.revparse(["HEAD"]);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the current branch name.
+ */
+export async function getCurrentBranch(cwd) {
+    try {
+        const git = getGit(cwd);
+        return await git.revparse(["--abbrev-ref", "HEAD"]);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the remote origin URL.
+ */
+export async function getRemoteUrl(cwd) {
+    try {
+        const git = getGit(cwd);
+        const remotes = await git.getRemotes(true);
+        const origin = remotes.find((r) => r.name === "origin");
+        return origin?.refs.fetch ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get files changed between two refs.
+ */
+export async function getChangedFiles(cwd, fromRef, toRef) {
+    try {
+        const git = getGit(cwd);
+        const diff = await git.diff(["--name-only", `${fromRef}..${toRef}`]);
+        return diff
+            .split("\n")
+            .map((f) => f.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Restore a file to a specific ref's version.
+ */
+export async function checkoutFile(cwd, ref, filePath) {
+    const git = getGit(cwd);
+    await git.checkout([ref, "--", filePath]);
+}
+/**
+ * Get staged file names (for pre-commit hooks).
+ */
+export async function getStagedFiles(cwd) {
+    try {
+        const git = getGit(cwd);
+        const diff = await git.diff([
+            "--cached",
+            "--name-only",
+            "--diff-filter=ACMR",
+        ]);
+        return diff
+            .split("\n")
+            .map((f) => f.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get recent commit log entries.
+ */
+export async function getLog(cwd, maxCount = 5) {
+    try {
+        const git = getGit(cwd);
+        const log = await git.log({ maxCount });
+        return log.all.map((entry) => ({
+            hash: entry.hash,
+            date: entry.date,
+            message: entry.message,
+            author_name: entry.author_name,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List local branches.
+ */
+export async function listBranches(cwd) {
+    try {
+        const git = getGit(cwd);
+        const summary = await git.branchLocal();
+        return summary.all;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Write a git note under a custom ref namespace.
+ */
+export async function writeNote(cwd, ref, commitSha, content) {
+    const git = getGit(cwd);
+    await git.raw(["notes", "--ref", ref, "add", "-f", "-m", content, commitSha]);
+}
+/**
+ * Read a git note from a custom ref namespace. Returns null if no note exists.
+ */
+export async function readNote(cwd, ref, commitSha) {
+    try {
+        const git = getGit(cwd);
+        return await git.raw(["notes", "--ref", ref, "show", commitSha]);
+    }
+    catch {
+        return null;
+    }
+}