@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/entrypoints/daemon.js

@@ -1,380 +0,0 @@
-/**
- * unerrd — the centralized daemon supervisor.
- *
- * Listens on ~/.unerr/unerrd.sock for JSON protocol messages.
- * Manages per-repo child processes via ProcessManager.
- *
- * Entry points:
- *   `unerr daemon start`             — foreground (for debugging)
- *   `unerr daemon start --background` — detached (auto-spawned by bridge)
- *
- * Lifecycle:
- *   1. Acquire PID lock (~/.unerr/unerrd.pid)
- *   2. Start UDS server (~/.unerr/unerrd.sock)
- *   3. Load registry, start idle sweep
- *   4. Serve JSON protocol requests
- *   5. On SIGTERM/SIGINT: stop all children → exit
- */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
-import { createConnection, createServer } from "node:net";
-import { join } from "node:path";
-import { ProcessManager } from "../daemon/process-manager.js";
-import { addRepo, globalDir, readRegistry, removeRepo, } from "../daemon/registry.js";
-import { installFileLogger } from "../utils/file-logger.js";
-// ── Paths ───────────────────────────────────────────────────────
-function pidPath() {
-    return join(globalDir(), "unerrd.pid");
-}
-function sockPath() {
-    return join(globalDir(), "unerrd.sock");
-}
-// ── PID Lock ────────────────────────────────────────────────────
-function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function acquirePidLock() {
-    const p = pidPath();
-    try {
-        const raw = readFileSync(p, "utf-8").trim();
-        const existingPid = Number.parseInt(raw, 10);
-        if (Number.isFinite(existingPid) && isProcessAlive(existingPid)) {
-            return false;
-        }
-        // Stale PID file — previous process died
-    }
-    catch {
-        // No PID file
-    }
-    const dir = globalDir();
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    writeFileSync(p, `${process.pid}\n`);
-    return true;
-}
-function releasePidLock() {
-    try {
-        unlinkSync(pidPath());
-    }
-    catch {
-        /* best effort */
-    }
-}
-// ── Orphaned socket cleanup ─────────────────────────────────────
-/**
- * Check if the UDS socket file exists but the process that created it is dead.
- * If so, remove the stale socket so we can bind fresh.
- */
-function cleanStaleSocket() {
-    const sock = sockPath();
-    if (!existsSync(sock))
-        return;
-    // Try connecting — if it fails, the socket is stale
-    try {
-        const probe = createConnection(sock);
-        probe.on("connect", () => {
-            probe.destroy();
-            // Socket is live — another daemon is running
-        });
-        probe.on("error", () => {
-            // Socket is stale — remove it
-            try {
-                unlinkSync(sock);
-            }
-            catch {
-                /* race — ok */
-            }
-        });
-        // Give probe 500ms to connect or fail
-        setTimeout(() => {
-            if (!probe.destroyed)
-                probe.destroy();
-        }, 500).unref();
-    }
-    catch {
-        try {
-            unlinkSync(sock);
-        }
-        catch {
-            /* race — ok */
-        }
-    }
-}
-// ── UDS Protocol Server ─────────────────────────────────────────
-function createUdsServer(pm) {
-    const server = createServer((socket) => {
-        let buffer = "";
-        socket.on("data", (chunk) => {
-            buffer += chunk.toString();
-            // Process all complete newline-delimited messages
-            while (true) {
-                const newlineIdx = buffer.indexOf("\n");
-                if (newlineIdx === -1)
-                    break;
-                const line = buffer.slice(0, newlineIdx).trim();
-                buffer = buffer.slice(newlineIdx + 1);
-                if (!line)
-                    continue;
-                handleRequest(pm, line)
-                    .then((response) => {
-                    if (response && !socket.destroyed) {
-                        socket.write(`${JSON.stringify(response)}\n`);
-                    }
-                })
-                    .catch((err) => {
-                    if (!socket.destroyed) {
-                        socket.write(`${JSON.stringify({ ok: false, error: String(err) })}\n`);
-                    }
-                });
-            }
-        });
-        socket.on("error", () => {
-            // Client disconnected — non-fatal
-        });
-    });
-    return server;
-}
-async function handleRequest(pm, raw) {
-    let req;
-    try {
-        req = JSON.parse(raw);
-    }
-    catch {
-        return { ok: false, error: "Invalid JSON" };
-    }
-    switch (req.cmd) {
-        case "ensure": {
-            try {
-                const sock = await pm.ensure(req.repo);
-                return { ok: true, sock };
-            }
-            catch (err) {
-                return { ok: false, error: err.message };
-            }
-        }
-        case "connect":
-            pm.connect(req.repo);
-            return { ok: true };
-        case "disconnect":
-            pm.disconnect(req.repo);
-            return { ok: true };
-        case "activity":
-            pm.recordActivity(req.repo);
-            return null; // fire-and-forget
-        case "status":
-            return { ok: true, repos: pm.getStatus() };
-        case "add": {
-            const result = addRepo(req.repo, req.settings ?? {});
-            if (result.ok)
-                return { ok: true };
-            return {
-                ok: false,
-                error: result.error,
-                parentConflict: result.parentConflict,
-            };
-        }
-        case "remove": {
-            await pm.stop(req.repo);
-            const removed = removeRepo(req.repo);
-            if (removed)
-                return { ok: true };
-            return { ok: false, error: "Not registered" };
-        }
-        case "stop":
-            await pm.stop(req.repo);
-            return { ok: true };
-        case "shutdown":
-            // Handled by the caller — triggers graceful shutdown
-            return { ok: true };
-        case "dashboard-state":
-            return { ok: true, repos: pm.getStatus() };
-        case "repo-detail": {
-            const managed = pm.getManaged(req.repo);
-            if (!managed)
-                return { ok: false, error: "Not managed" };
-            return {
-                ok: true,
-                repos: [
-                    {
-                        path: managed.path,
-                        label: managed.label,
-                        status: managed.status,
-                        pid: managed.pid,
-                        memory: managed.memory,
-                        idle: managed.lastActivity
-                            ? Math.round((Date.now() - managed.lastActivity) / 1000)
-                            : null,
-                        connections: managed.connections,
-                        lastActivity: managed.lastActivity
-                            ? new Date(managed.lastActivity).toISOString()
-                            : null,
-                        entityCount: managed.entities,
-                        edgeCount: managed.edges,
-                        needsInput: managed.needsInput,
-                    },
-                ],
-            };
-        }
-        default:
-            return {
-                ok: false,
-                error: `Unknown command: ${req.cmd}`,
-            };
-    }
-}
-// ── Main ────────────────────────────────────────────────────────
-const log = {
-    info: (msg) => process.stderr.write(`[unerrd] ${msg}\n`),
-    warn: (msg) => process.stderr.write(`[unerrd] WARN: ${msg}\n`),
-    error: (msg) => process.stderr.write(`[unerrd] ERROR: ${msg}\n`),
-};
-export async function startDaemon(opts) {
-    // Install file logger as first action
-    const logsDir = join(globalDir(), "logs");
-    if (!existsSync(logsDir))
-        mkdirSync(logsDir, { recursive: true });
-    installFileLogger({
-        filePath: join(logsDir, "unerrd.log"),
-        maxBytes: 10_000_000,
-        keep: 5,
-    });
-    // Acquire PID lock
-    if (!acquirePidLock()) {
-        log.info("unerrd is already running. Exiting.");
-        process.exit(0);
-    }
-    // Clean stale socket from previous hard kill
-    cleanStaleSocket();
-    // Wait briefly for stale socket cleanup
-    await new Promise((r) => setTimeout(r, 100));
-    // Remove stale socket synchronously if it's still there
-    const sock = sockPath();
-    if (existsSync(sock)) {
-        try {
-            unlinkSync(sock);
-        }
-        catch {
-            /* race — will fail on bind instead */
-        }
-    }
-    const pm = new ProcessManager();
-    pm.setEventHandler((event, repo, detail) => {
-        log.info(`[${repo.label}] ${event}${detail ? `: ${detail}` : ""}`);
-    });
-    const server = createUdsServer(pm);
-    // Track shutdown request from protocol
-    let shutdownRequested = false;
-    const origHandler = handleRequest;
-    // Wrap to detect shutdown command
-    const originalCreateUdsServer = server;
-    // Graceful shutdown procedure
-    let apiHandle = null;
-    const shutdown = async (reason) => {
-        if (shutdownRequested)
-            return;
-        shutdownRequested = true;
-        log.info(`Shutting down: ${reason}`);
-        pm.stopIdleSweep();
-        apiHandle?.close();
-        server.close();
-        try {
-            unlinkSync(sock);
-        }
-        catch {
-            /* already gone */
-        }
-        await pm.shutdownAll();
-        releasePidLock();
-        log.info("Shutdown complete.");
-        process.exit(0);
-    };
-    // Signal handling
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    // Intercept "shutdown" command in UDS handler
-    server.on("connection", (socket) => {
-        socket.on("data", (chunk) => {
-            const str = chunk.toString();
-            if (str.includes('"shutdown"')) {
-                // The handleRequest already sent { ok: true } — now shut down
-                setTimeout(() => shutdown("shutdown command"), 100);
-            }
-        });
-    });
-    // Bind and listen
-    await new Promise((resolve, reject) => {
-        server.on("error", (err) => {
-            log.error(`UDS server error: ${err.message}`);
-            releasePidLock();
-            reject(err);
-        });
-        server.listen(sock, () => {
-            resolve();
-        });
-    });
-    const reg = readRegistry();
-    pm.startIdleSweep();
-    // Start the dashboard HTTP API (non-critical — daemon works without it)
-    try {
-        const { startDaemonApi } = await import("../daemon/api.js");
-        apiHandle = startDaemonApi(pm);
-        if (apiHandle) {
-            log.info(`Dashboard: http://localhost:${apiHandle.port}`);
-        }
-    }
-    catch (err) {
-        log.warn(`Dashboard API failed to start: ${err.message}`);
-    }
-    // Schedule warm-start of MRU repos (non-critical)
-    let cancelWarmStart = null;
-    try {
-        const { scheduleWarmStart } = await import("../daemon/warm-start.js");
-        cancelWarmStart = scheduleWarmStart(pm, (event) => {
-            apiHandle?.pushWarmStartEvent(event);
-            if (event.status === "started") {
-                log.info(`warm-start: ${event.label} ready (${event.ms}ms)`);
-            }
-            else if (event.status === "skipped") {
-                log.info(`warm-start: ${event.label} skipped — ${event.reason}`);
-            }
-            else if (event.status === "failed") {
-                log.warn(`warm-start: ${event.label} failed — ${event.reason}`);
-            }
-            else if (event.status === "aborted") {
-                log.warn(`warm-start: ${event.label} aborted — ${event.reason}`);
-            }
-        });
-    }
-    catch (err) {
-        log.warn(`Warm-start scheduler failed: ${err.message}`);
-    }
-    // Start periodic version checking (non-critical)
-    let cancelVersionCheck = null;
-    try {
-        const { startPeriodicCheck } = await import("../daemon/version-checker.js");
-        cancelVersionCheck = startPeriodicCheck();
-    }
-    catch (err) {
-        log.warn(`Version checker failed: ${err.message}`);
-    }
-    // Add warm-start + version-check cancellation to shutdown
-    const origShutdown = shutdown;
-    const wrappedShutdown = async (reason) => {
-        cancelWarmStart?.();
-        cancelVersionCheck?.();
-        await origShutdown(reason);
-    };
-    process.removeAllListeners("SIGTERM");
-    process.removeAllListeners("SIGINT");
-    process.on("SIGTERM", () => wrappedShutdown("SIGTERM"));
-    process.on("SIGINT", () => wrappedShutdown("SIGINT"));
-    log.info(`Started (PID ${process.pid}), ${reg.repos.length} repos registered. Socket: ${sock}`);
-    if (!opts.background) {
-        log.info("Running in foreground. Press Ctrl+C to stop.");
-    }
-}

package/dist/entrypoints/repl.js

@@ -1,147 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/**
- * REPL Entry Point — launches the interactive AI assistant.
- *
- * Wires together:
- * - Ink terminal UI (App component)
- * - QueryEngine (streaming + tool loop) via ChatProvider
- * - Coding tools (file read/write/edit, bash, grep, glob)
- * - Intelligence tools (graph queries, if local graph available)
- * - Context assembly (system prompt with project + graph intelligence)
- *
- * Supports two modes:
- * - Default: Anthropic SDK via AnthropicChatProvider
- * - Local (--local or mode=local): BYO-LLM via LocalChatProvider
- */
-import { render } from "ink";
-import { App } from "../components/App.js";
-import { loadSettings } from "../config/settings.js";
-import { assembleContext } from "../core/context-assembly.js";
-import { codingTools } from "../tools/coding/index.js";
-import { ToolRegistry } from "../tools/registry.js";
-export async function launchRepl(opts = {}) {
-    const cwd = process.cwd();
-    const settings = loadSettings(cwd);
-    let chatProvider;
-    let apiKey;
-    let model;
-    if (settings.localLlm) {
-        // BYO-LLM via LocalChatProvider
-        if (!settings.localLlm) {
-            console.error("BYO-LLM not configured.\n" +
-                "Add localLlm configuration to ~/.unerr/settings.json:\n" +
-                '  { "localLlm": { "provider": "ollama", "chatModel": "llama3" } }');
-            process.exit(1);
-        }
-        const { LocalChatProvider } = await import("../core/local-chat-provider.js");
-        chatProvider = new LocalChatProvider(settings.localLlm);
-        model = opts.model ?? settings.localLlm.chatModel;
-        // Seal the firewall in local mode chat
-        const { addAllowedHost, seal } = await import("../proxy/network-firewall.js");
-        const allowedUrls = [];
-        if (settings.localLlm.baseUrl) {
-            allowedUrls.push(settings.localLlm.baseUrl);
-        }
-        if (settings.localLlm.provider === "anthropic-direct") {
-            addAllowedHost("api.anthropic.com");
-        }
-        seal(allowedUrls);
-    }
-    else {
-        // Anthropic SDK (BYO API key)
-        apiKey = settings.anthropicApiKey ?? process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            console.error("No Anthropic API key found.\n" +
-                "Set ANTHROPIC_API_KEY environment variable or add it to ~/.unerr/settings.json");
-            process.exit(1);
-        }
-        model = opts.model ?? settings.model;
-    }
-    // Register tools
-    const registry = new ToolRegistry();
-    // 1. Register coding tools (always available)
-    for (const tool of codingTools) {
-        registry.register(tool, "coding");
-    }
-    // 2. Register intelligence tools (if graph available)
-    let graphLoaded = false;
-    if (opts.loadGraph !== false) {
-        try {
-            graphLoaded = await loadIntelligenceTools(registry, cwd);
-        }
-        catch {
-            // Graph not available — continue without intelligence tools
-        }
-    }
-    // Assemble system prompt
-    const { systemPrompt } = await assembleContext({
-        cwd,
-        additionalInstructions: buildInstructions(graphLoaded, true),
-    });
-    const allTools = registry.all();
-    const welcomeMsg = buildWelcomeMessage(graphLoaded, allTools.length, !!settings.localLlm, chatProvider?.providerName, model);
-    // Launch Ink UI
-    const { waitUntilExit } = render(_jsx(App, { apiKey: apiKey, chatProvider: chatProvider, model: model, systemPrompt: systemPrompt, tools: allTools, cwd: cwd, welcomeMessage: welcomeMsg }));
-    await waitUntilExit();
-}
-/**
- * Attempt to load intelligence tools from the local graph.
- * Returns true if successful.
- */
-async function loadIntelligenceTools(registry, cwd) {
-    try {
-        // Open persistent CozoDB (SQLite-backed at .unerr/graph.db)
-        const { openPersistentDb, hasPersistedGraph } = await import("../intelligence/persistent-db.js");
-        if (!hasPersistedGraph(cwd))
-            return false;
-        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
-        const { QueryRouter } = await import("../intelligence/query-router.js");
-        const { createIntelligenceTools } = await import("../tools/intelligence/index.js");
-        const { db } = await openPersistentDb(cwd);
-        const graph = await CozoGraphStore.create(db);
-        // Create router — all tools are local
-        const router = new QueryRouter(graph);
-        // Register intelligence tools
-        const intelligenceTools = createIntelligenceTools(router);
-        for (const tool of intelligenceTools) {
-            registry.register(tool, "intelligence");
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function buildInstructions(graphLoaded, isLocal) {
-    const lines = [
-        "You are unerr, an AI coding assistant with deep code intelligence.",
-        "You help developers understand, navigate, and modify their codebase.",
-        "",
-        "Available capabilities:",
-        "- Read, write, and edit files",
-        "- Execute bash commands",
-        "- Search files by name (glob) or content (grep)",
-    ];
-    if (graphLoaded) {
-        lines.push("- Query the code intelligence graph for function/class details, callers/callees, imports", "- Search code entities semantically", "- Check coding rules and conventions", "- Get business context for code entities", "- Understand blast radius via caller/callee analysis", "", "IMPORTANT: Use the intelligence tools (get_function, get_callers, search_code, etc.) to understand", "the codebase architecture BEFORE making changes. These tools provide pre-computed analysis", "that is faster and more accurate than reading files manually.");
-    }
-    if (isLocal) {
-        lines.push("", "MODE: Local-only (fully offline). All processing happens on this machine.", "No data is sent to external servers.");
-    }
-    lines.push("", "Commands: /exit, /clear, /cost");
-    return lines.join("\n");
-}
-function buildWelcomeMessage(graphLoaded, toolCount, isLocal, providerName, model) {
-    const parts = [`${toolCount} tools available.`];
-    if (graphLoaded) {
-        parts.push("Code intelligence graph loaded.");
-    }
-    else {
-        parts.push("No graph loaded — run 'unerr pull' to enable intelligence tools.");
-    }
-    if (isLocal && providerName) {
-        parts.push(`Local mode: ${providerName} (${model}).`);
-    }
-    parts.push("Type /exit to quit, /clear to reset, /cost for usage.");
-    return parts.join(" ");
-}

package/dist/hooks/adapters/claude-code.js

@@ -1,90 +0,0 @@
-/**
- * Claude Code hook adapter.
- *
- * Protocol:
- *   stdin:  { tool_input: {...}, hook_event_name: "PreToolUse" | "PostToolUse" }
- *   stdout (PreToolUse):
- *     - passthrough: {}
- *     - nudge:   { hookSpecificOutput: { hookEventName, permissionDecision: "allow", systemMessage } }
- *     - rewrite: { hookSpecificOutput: { hookEventName, permissionDecision: "allow", updatedInput } }
- *   stdout (PostToolUse):
- *     - passthrough: {}
- *     - enrich:  { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext } }
- *   stdout (UserPromptSubmit):
- *     - passthrough: {}
- *     - enrich:  { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext } }
- */
-export const claudeCodeAdapter = {
-    name: "claude-code",
-    detect(payload) {
-        // Claude Code sends hook_event_name as a string field
-        // Also serves as the default fallback — detect returns true broadly
-        return (typeof payload.hook_event_name === "string" ||
-            typeof payload.tool_input === "object" ||
-            // Fallback: if no other adapter matched, Claude Code is default
-            true);
-    },
-    normalize(payload) {
-        const toolInput = (payload.tool_input ?? payload.input ?? {});
-        const toolName = (payload.tool_name ?? payload.toolName);
-        const eventName = payload.hook_event_name;
-        let event;
-        if (eventName === "PreToolUse")
-            event = "PreToolUse";
-        else if (eventName === "PostToolUse")
-            event = "PostToolUse";
-        else if (eventName === "UserPromptSubmit")
-            event = "UserPromptSubmit";
-        return { raw: payload, toolInput, toolName, event };
-    },
-    formatPreToolUse(result) {
-        if (result.type === "passthrough")
-            return "{}";
-        if (result.type === "nudge" && result.message) {
-            return JSON.stringify({
-                hookSpecificOutput: {
-                    hookEventName: "PreToolUse",
-                    permissionDecision: "allow",
-                    systemMessage: result.message,
-                },
-            });
-        }
-        if (result.type === "rewrite" && result.updatedInput) {
-            return JSON.stringify({
-                hookSpecificOutput: {
-                    hookEventName: "PreToolUse",
-                    permissionDecision: "allow",
-                    updatedInput: result.updatedInput,
-                },
-            });
-        }
-        return "{}";
-    },
-    formatPostToolUse(result) {
-        if (result.type === "passthrough")
-            return "{}";
-        if ((result.type === "enrich" || result.type === "nudge") &&
-            result.message) {
-            return JSON.stringify({
-                hookSpecificOutput: {
-                    hookEventName: "PostToolUse",
-                    additionalContext: result.message,
-                },
-            });
-        }
-        return "{}";
-    },
-    formatPromptSubmit(result) {
-        if (result.type === "passthrough")
-            return "{}";
-        if (result.message) {
-            return JSON.stringify({
-                hookSpecificOutput: {
-                    hookEventName: "UserPromptSubmit",
-                    additionalContext: result.message,
-                },
-            });
-        }
-        return "{}";
-    },
-};