@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/utils/detect.js

@@ -1,193 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * 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

@@ -1,87 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,181 +0,0 @@
-/**
- * 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;
-    }
-}

package/dist/utils/log.js

@@ -1,57 +0,0 @@
-/**
- * File logger — writes structured logs to .unerr/logs/ in the repo root.
- *
- * Each setup run creates a timestamped log file. All API calls, responses,
- * and errors are recorded. On error, the CLI prints the log file path.
- *
- * Built on consola — routes all output to file, never to stdout.
- */
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-let logFilePath = null;
-function ensureLogDir(cwd) {
-    const logsDir = join(cwd, ".unerr", "logs");
-    mkdirSync(logsDir, { recursive: true });
-    return logsDir;
-}
-function timestamp() {
-    return new Date().toISOString();
-}
-function datestamp() {
-    return new Date().toISOString().slice(0, 10);
-}
-export function initLogFile(cwd) {
-    const logsDir = ensureLogDir(cwd);
-    logFilePath = join(logsDir, `setup-${datestamp()}.log`);
-    write("info", "=== unerr setup started ===");
-    write("info", `cwd: ${cwd}`);
-    write("info", `node: ${process.version}`);
-    write("info", `platform: ${process.platform} ${process.arch}`);
-    return logFilePath;
-}
-function write(level, message, data) {
-    if (!logFilePath)
-        return;
-    const line = data
-        ? `[${timestamp()}] [${level}] ${message} ${JSON.stringify(data)}`
-        : `[${timestamp()}] [${level}] ${message}`;
-    try {
-        appendFileSync(logFilePath, `${line}\n`);
-    }
-    catch {
-        /* best effort — never crash on logging failure */
-    }
-}
-export function logInfo(message, data) {
-    write("info", message, data);
-}
-export function logError(message, data) {
-    write("error", message, data);
-}
-export function logApi(method, url, status, body) {
-    const statusStr = status !== undefined ? ` → ${status}` : "";
-    write("api", `${method} ${url}${statusStr}`, body);
-}
-export function getLogFilePath() {
-    return logFilePath;
-}

package/dist/utils/logger.js

@@ -1,35 +0,0 @@
-/**
- * Centralized Logger — consola-based, stderr-only.
- *
- * CRITICAL INVARIANT: stdout is reserved for MCP JSON-RPC protocol.
- * Every log call routes to stderr. This is enforced at construction time
- * by setting both stdout and stderr streams to process.stderr.
- *
- * Design notes (temporal intelligence foundation):
- *   - Structured event emission supports future episodic memory capture.
- *   - Module-scoped child loggers enable per-subsystem log routing.
- *   - Log levels respect UNERR_LOG_LEVEL env var (0=silent, 3=info, 4=debug, 5=trace).
- */
-import { createConsola } from "consola";
-const resolveLevel = () => {
-    const env = process.env.UNERR_LOG_LEVEL;
-    if (env !== undefined) {
-        const parsed = Number(env);
-        return Number.isFinite(parsed) ? parsed : 3;
-    }
-    return process.env.NODE_ENV === "test" ? 0 : 3;
-};
-export const logger = createConsola({
-    stdout: process.stderr,
-    stderr: process.stderr,
-    level: resolveLevel(),
-    defaults: { tag: "unerr" },
-    formatOptions: {
-        date: false,
-        colors: process.env.NO_COLOR === undefined,
-        compact: true,
-    },
-});
-export function createModuleLogger(module) {
-    return logger.withTag(module);
-}

package/dist/utils/mcp-content-json.js

@@ -1,8 +0,0 @@
-/**
- * Layer 6 — Sprint FE-A (§43): MCP tool `content[].text` payloads use compact JSON only.
- * Pretty-printed JSON (`JSON.stringify(v, null, 2)`) inflates token count by ~15–25%
- * on structural whitespace (`LAYER_6_FORMAT_ENCODING.md`).
- */
-export function stringifyMcpToolJson(value) {
-    return JSON.stringify(value);
-}