@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/entrypoints/daemon.js

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

@@ -0,0 +1,147 @@
+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

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