@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/core/query-engine.js

@@ -1,174 +0,0 @@
-/**
- * Query Engine — the LLM tool-call loop.
- *
- * Orchestrates: system prompt assembly → LLM streaming → tool execution → loop.
- * Decoupled from UI — emits events that any consumer (REPL, SDK, headless) can subscribe to.
- *
- * Supports both Anthropic SDK and BYO-LLM (local) via the ChatProvider interface.
- */
-import { AiSdkChatProvider, AnthropicChatProvider, toChatToolDefs, } from "./local-chat-provider.js";
-// ── Cost Table (per million tokens) ───────────────────────────
-const COST_TABLE = {
-    "claude-sonnet-4-20250514": { input: 3, output: 15 },
-    "claude-opus-4-20250514": { input: 15, output: 75 },
-    "claude-haiku-4-20250506": { input: 0.8, output: 4 },
-};
-function estimateCost(model, inputTokens, outputTokens) {
-    const rates = COST_TABLE[model] ?? { input: 3, output: 15 };
-    return (inputTokens * rates.input + outputTokens * rates.output) / 1_000_000;
-}
-// ── Conversion Helpers ────────────────────────────────────────
-/**
- * Convert our conversation messages to ChatMessage format.
- * Handles tool_use/tool_result pairs.
- */
-function toChatMessages(messages) {
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "user") {
-            result.push({ role: "user", content: msg.content });
-        }
-        else {
-            if (msg.toolCalls && msg.toolCalls.length > 0) {
-                // Assistant message with tool calls
-                const toolCallsFormatted = msg.toolCalls.map((tc) => ({
-                    id: `toolu_${Date.now()}_${tc.name}`,
-                    type: "function",
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.args),
-                    },
-                }));
-                result.push({
-                    role: "assistant",
-                    content: msg.content || "",
-                    tool_calls: toolCallsFormatted,
-                });
-                // Add tool result messages
-                for (let i = 0; i < msg.toolCalls.length; i++) {
-                    const tc = msg.toolCalls[i];
-                    if (!tc)
-                        continue;
-                    result.push({
-                        role: "tool",
-                        content: typeof tc.result.content === "string"
-                            ? tc.result.content
-                            : JSON.stringify(tc.result.content),
-                        tool_call_id: toolCallsFormatted[i]?.id,
-                    });
-                }
-            }
-            else {
-                result.push({ role: "assistant", content: msg.content });
-            }
-        }
-    }
-    return result;
-}
-// ── Engine ────────────────────────────────────────────────────
-/**
- * Resolve the ChatProvider from options.
- * Priority: chatProvider > languageModel > apiKey (Anthropic fallback).
- */
-function resolveProvider(options) {
-    if (options.chatProvider) {
-        return options.chatProvider;
-    }
-    if (options.languageModel) {
-        return new AiSdkChatProvider(options.languageModel, options.providerName ?? "ai-sdk", options.model);
-    }
-    if (!options.apiKey) {
-        throw new Error("QueryEngine requires one of: chatProvider, languageModel, or apiKey");
-    }
-    return new AnthropicChatProvider(options.apiKey, options.model);
-}
-/**
- * Execute a single query turn: send messages to the LLM, handle tool calls, return result.
- *
- * The loop:
- * 1. Send conversation + system prompt + tool defs to LLM (streaming)
- * 2. Accumulate text tokens, emit onToken events
- * 3. When the LLM requests tool calls, execute each tool
- * 4. Feed tool results back as a new turn, loop to step 1
- * 5. When the LLM produces no more tool calls, return the full result
- */
-export async function executeQuery(messages, options, events) {
-    const provider = resolveProvider(options);
-    const chatToolDefs = toChatToolDefs(options.tools);
-    const toolMap = new Map(options.tools.map((t) => [t.name, t]));
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    const allToolCalls = [];
-    const workingMessages = toChatMessages(messages);
-    let finalResponse = "";
-    // Tool-call loop — keep going until the LLM produces no tool calls
-    while (true) {
-        const response = await provider.streamChat(workingMessages, chatToolDefs, options.systemPrompt, options.maxTokens ?? 8192, (chunk) => {
-            if (chunk.type === "text_delta" && chunk.text) {
-                events?.onToken?.(chunk.text);
-            }
-        });
-        totalInputTokens += response.inputTokens;
-        totalOutputTokens += response.outputTokens;
-        // If no tool calls, we're done
-        if (response.toolCalls.length === 0) {
-            finalResponse = response.text;
-            break;
-        }
-        // Execute tool calls
-        const toolCallMessages = [];
-        // Add assistant message with tool calls
-        workingMessages.push({
-            role: "assistant",
-            content: response.text || "",
-            tool_calls: response.toolCalls.map((tc) => ({
-                id: tc.id,
-                type: "function",
-                function: {
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.args),
-                },
-            })),
-        });
-        for (const toolCall of response.toolCalls) {
-            const tool = toolMap.get(toolCall.name);
-            events?.onToolCall?.(toolCall.name, toolCall.args);
-            let result;
-            if (!tool) {
-                result = { content: `Unknown tool: ${toolCall.name}`, isError: true };
-            }
-            else {
-                try {
-                    result = await tool.execute(toolCall.args, options.toolContext);
-                }
-                catch (err) {
-                    result = {
-                        content: `Tool error: ${err instanceof Error ? err.message : String(err)}`,
-                        isError: true,
-                    };
-                }
-            }
-            events?.onToolResult?.(toolCall.name, result);
-            allToolCalls.push({ name: toolCall.name, args: toolCall.args, result });
-            const contentStr = typeof result.content === "string"
-                ? result.content
-                : JSON.stringify(result.content);
-            workingMessages.push({
-                role: "tool",
-                content: contentStr,
-                tool_call_id: toolCall.id,
-            });
-        }
-    }
-    const queryResult = {
-        response: finalResponse,
-        toolCalls: allToolCalls,
-        usage: {
-            inputTokens: totalInputTokens,
-            outputTokens: totalOutputTokens,
-            estimatedCost: estimateCost(provider.modelId, totalInputTokens, totalOutputTokens),
-        },
-    };
-    events?.onDone?.(queryResult);
-    return queryResult;
-}

package/dist/daemon/api.js

@@ -1,312 +0,0 @@
-/**
- * unerrd HTTP API — served on port 9847 by the daemon supervisor.
- *
- * Route layout:
- *   /api/daemon          — supervisor metadata (uptime, version, pid)
- *   /api/repos           — all registered repos with status
- *   /api/repos/aggregate — aggregated metrics across all running repos
- *   /api/repo/:label/*   — proxy to the per-repo HTTP API (token-flow, reasoning, etc.)
- *
- * Static assets (the React SPA) are served from the same dist/ui/ directory
- * used by per-repo dashboards. The SPA detects whether it's served by unerrd
- * (via /api/daemon) and shows the global overview vs per-repo view.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { request as httpRequest } from "node:http";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { listRepos } from "./registry.js";
-const DAEMON_PORT = 9847;
-export function startDaemonApi(pm) {
-    const app = new Hono();
-    const startedAt = Date.now();
-    app.use("*", cors({ origin: "*" }));
-    // ── /api/daemon — supervisor metadata ───────────────────────
-    app.get("/api/daemon", (c) => {
-        return c.json({
-            pid: process.pid,
-            uptime: Math.round((Date.now() - startedAt) / 1000),
-            startedAt: new Date(startedAt).toISOString(),
-            version: "0.1.0",
-            port: DAEMON_PORT,
-        });
-    });
-    // ── /api/repos — all repos with live status ─────────────────
-    app.get("/api/repos", (c) => {
-        const repos = pm.getStatus();
-        return c.json({ repos });
-    });
-    // ── /api/repos/aggregate — cross-repo metrics ───────────────
-    app.get("/api/repos/aggregate", async (c) => {
-        const repos = pm.getStatus();
-        const running = repos.filter((r) => r.status === "running");
-        let totalEntities = 0;
-        let totalEdges = 0;
-        let totalMemory = 0;
-        let totalConnections = 0;
-        let totalNeedsInput = 0;
-        // Aggregate token-flow and reasoning data from running repos
-        const tokenFlowAgg = { saved: 0, total: 0, violations: 0 };
-        const reasoningAgg = { sessions: 0, avgQuality: 0, totalQualities: 0 };
-        for (const repo of repos) {
-            totalEntities += repo.entityCount ?? 0;
-            totalEdges += repo.edgeCount ?? 0;
-            totalMemory += repo.memory ?? 0;
-            totalConnections += repo.connections;
-            totalNeedsInput += repo.needsInput.length;
-        }
-        // Fetch per-repo stats from running processes' HTTP APIs
-        const perRepoStats = await Promise.allSettled(running.map(async (repo) => {
-            if (!repo.pid)
-                return null;
-            const managed = pm.getManaged(repo.path);
-            if (!managed?.sock)
-                return null;
-            // Try to read server.json from the repo's .unerr/state/ to get its HTTP port
-            const serverJsonPath = join(repo.path, ".unerr", "state", "server.json");
-            if (!existsSync(serverJsonPath))
-                return null;
-            try {
-                const serverInfo = JSON.parse(readFileSync(serverJsonPath, "utf-8"));
-                const [sessionStats, tokenFlow] = await Promise.allSettled([
-                    fetchRepoApi(serverInfo.port, "/api/session/stats"),
-                    fetchRepoApi(serverInfo.port, "/api/token-flow/summary"),
-                ]);
-                return {
-                    label: repo.label,
-                    port: serverInfo.port,
-                    sessionStats: sessionStats.status === "fulfilled" ? sessionStats.value : null,
-                    tokenFlow: tokenFlow.status === "fulfilled" ? tokenFlow.value : null,
-                };
-            }
-            catch {
-                return null;
-            }
-        }));
-        for (const result of perRepoStats) {
-            if (result.status !== "fulfilled" || !result.value)
-                continue;
-            const stats = result.value;
-            if (stats.sessionStats) {
-                const s = stats.sessionStats;
-                tokenFlowAgg.saved += s.data?.estimatedTokensSaved ?? 0;
-                tokenFlowAgg.total += s.data?.toolCallsLocal ?? 0;
-                tokenFlowAgg.violations += s.data?.violationsCaught ?? 0;
-            }
-        }
-        return c.json({
-            summary: {
-                totalRepos: repos.length,
-                runningRepos: running.length,
-                stoppedRepos: repos.length - running.length,
-                totalEntities,
-                totalEdges,
-                totalMemoryMb: totalMemory,
-                totalConnections,
-                totalNeedsInput,
-            },
-            tokenFlow: tokenFlowAgg,
-            reasoning: reasoningAgg,
-        });
-    });
-    // ── /api/daemon/warm-start — warm-start status ───────────────
-    const warmStartEvents = [];
-    let warmStartLastRun = null;
-    app.get("/api/daemon/warm-start", async (c) => {
-        let config = {
-            warmStartBudget: 3,
-            warmStartIdleDays: 14,
-            warmStartDelayMs: 30_000,
-        };
-        try {
-            const mod = await import("./warm-start.js");
-            config = mod.loadWarmStartConfig();
-        }
-        catch {
-            // Module not available
-        }
-        return c.json({
-            lastRun: warmStartLastRun,
-            events: warmStartEvents,
-            config,
-        });
-    });
-    // Public method for daemon.ts to push warm-start events
-    const pushWarmStartEvent = (event) => {
-        warmStartEvents.push(event);
-        warmStartLastRun = new Date().toISOString();
-    };
-    // ── /api/daemon/version — update notification ────────────────
-    app.get("/api/daemon/version", async (c) => {
-        try {
-            const { getCachedUpdateInfo } = await import("./version-checker.js");
-            return c.json(getCachedUpdateInfo());
-        }
-        catch {
-            return c.json({
-                available: false,
-                current: "0.0.1",
-                latest: "0.0.1",
-                behindMinor: 0,
-                dismissed: false,
-            });
-        }
-    });
-    app.post("/api/daemon/version/dismiss", async (c) => {
-        try {
-            const body = await c.req.json();
-            if (body.version) {
-                const { dismissVersion } = await import("./version-checker.js");
-                dismissVersion(body.version);
-            }
-            return c.json({ ok: true });
-        }
-        catch {
-            return c.json({ ok: false }, 400);
-        }
-    });
-    // ── /api/repo/:label/* — proxy to per-repo HTTP ─────────────
-    app.all("/api/repo/:label/*", async (c) => {
-        const label = c.req.param("label");
-        const repos = listRepos();
-        const repo = repos.find((r) => r.label === label);
-        if (!repo) {
-            return c.json({ error: `Unknown repo: ${label}` }, 404);
-        }
-        const managed = pm.getManaged(repo.path);
-        if (!managed || managed.status !== "running") {
-            return c.json({
-                error: `Repo ${label} is not running`,
-                status: managed?.status ?? "stopped",
-            }, 503);
-        }
-        // Read the repo's server.json for its HTTP port
-        const serverJsonPath = join(repo.path, ".unerr", "state", "server.json");
-        if (!existsSync(serverJsonPath)) {
-            return c.json({ error: `Repo ${label} has no dashboard server` }, 503);
-        }
-        let repoPort;
-        try {
-            const info = JSON.parse(readFileSync(serverJsonPath, "utf-8"));
-            repoPort = info.port;
-        }
-        catch {
-            return c.json({ error: `Cannot read server.json for ${label}` }, 500);
-        }
-        // Strip /api/repo/:label prefix and prepend /api so that
-        // /api/repo/label/stats → /api/stats on the per-repo server.
-        const remaining = c.req.path.replace(`/api/repo/${label}`, "");
-        const targetPath = `/api${remaining || "/"}`;
-        try {
-            const proxyResponse = await proxyToRepoHttp(repoPort, targetPath, c.req.method);
-            return c.json(proxyResponse);
-        }
-        catch (err) {
-            return c.json({ error: `Proxy error: ${err.message}` }, 502);
-        }
-    });
-    // ── Static SPA serving ──────────────────────────────────────
-    const distDir = join(dirname(fileURLToPath(import.meta.url)), "ui");
-    const spaIndex = join(distDir, "index.html");
-    if (existsSync(spaIndex)) {
-        const spaHtml = readFileSync(spaIndex, "utf-8");
-        app.use("*", serveStatic({ root: distDir }));
-        app.get("*", (c) => {
-            if (c.req.path.startsWith("/api/"))
-                return c.notFound();
-            return c.html(spaHtml);
-        });
-    }
-    else {
-        app.get("/", (c) => {
-            return c.json({
-                message: "unerrd dashboard API is running. UI not built yet.",
-                hint: "Run 'pnpm run build' to build the dashboard SPA.",
-                api: {
-                    daemon: "/api/daemon",
-                    repos: "/api/repos",
-                    aggregate: "/api/repos/aggregate",
-                    proxy: "/api/repo/<label>/api/...",
-                },
-            });
-        });
-    }
-    // ── Start server ────────────────────────────────────────────
-    let server;
-    try {
-        server = serve({
-            fetch: app.fetch,
-            port: DAEMON_PORT,
-            hostname: "127.0.0.1",
-        });
-    }
-    catch {
-        process.stderr.write(`[unerrd] Port ${DAEMON_PORT} occupied, skipping dashboard.\n`);
-        return null;
-    }
-    return {
-        port: DAEMON_PORT,
-        close: () => {
-            try {
-                server.close();
-            }
-            catch {
-                /* already closed */
-            }
-        },
-        pushWarmStartEvent,
-    };
-}
-// ── Helpers ───────────────────────────────────────────────────────
-function fetchRepoApi(port, path) {
-    return new Promise((resolve, reject) => {
-        const req = httpRequest({ hostname: "127.0.0.1", port, path, method: "GET", timeout: 3000 }, (res) => {
-            let body = "";
-            res.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            res.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    resolve(body);
-                }
-            });
-        });
-        req.on("error", reject);
-        req.on("timeout", () => {
-            req.destroy();
-            reject(new Error("timeout"));
-        });
-        req.end();
-    });
-}
-function proxyToRepoHttp(port, path, method) {
-    return new Promise((resolve, reject) => {
-        const req = httpRequest({ hostname: "127.0.0.1", port, path, method, timeout: 10_000 }, (res) => {
-            let body = "";
-            res.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            res.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    resolve(body);
-                }
-            });
-        });
-        req.on("error", reject);
-        req.on("timeout", () => {
-            req.destroy();
-            reject(new Error("Proxy timeout"));
-        });
-        req.end();
-    });
-}

package/dist/daemon/autostart.js

@@ -1,119 +0,0 @@
-/**
- * Unified auto-start installer — dispatches to the correct platform module.
- *
- * Gated by:
- *   - ~/.unerr/.autostart-installed sentinel (never re-runs)
- *   - isCI() check (never installs in CI/containers)
- *
- * Called automatically on first `unerr install <agent>` or `unerr daemon add`.
- */
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { isCI } from "./detect-ci.js";
-const SENTINEL_PATH = join(homedir(), ".unerr", ".autostart-installed");
-export function isAutostartInstalled() {
-    return existsSync(SENTINEL_PATH);
-}
-/**
- * Install platform auto-start if not already done.
- * Returns null if skipped (already installed, CI, or unsupported platform).
- */
-export async function autoInstallIfNeeded() {
-    if (isAutostartInstalled())
-        return null;
-    if (isCI())
-        return null;
-    const result = await installForCurrentPlatform();
-    if (result.installed) {
-        const dir = join(homedir(), ".unerr");
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(SENTINEL_PATH, new Date().toISOString(), "utf-8");
-    }
-    return result;
-}
-export async function installForCurrentPlatform() {
-    const plat = process.platform;
-    if (plat === "darwin") {
-        const { installLaunchd } = await import("./platform-macos.js");
-        return installLaunchd();
-    }
-    if (plat === "linux") {
-        const { installSystemd } = await import("./platform-linux.js");
-        return installSystemd();
-    }
-    if (plat === "win32") {
-        const { installWindows } = await import("./platform-windows.js");
-        return installWindows();
-    }
-    return {
-        installed: false,
-        path: "",
-        error: `Unsupported platform: ${plat}. Auto-start is available on macOS, Linux, and Windows.`,
-    };
-}
-export async function uninstallForCurrentPlatform() {
-    const plat = process.platform;
-    if (plat === "darwin") {
-        const { uninstallLaunchd } = await import("./platform-macos.js");
-        return uninstallLaunchd();
-    }
-    if (plat === "linux") {
-        const { uninstallSystemd } = await import("./platform-linux.js");
-        return uninstallSystemd();
-    }
-    if (plat === "win32") {
-        const { uninstallWindows } = await import("./platform-windows.js");
-        return uninstallWindows();
-    }
-    return {
-        installed: false,
-        path: "",
-        error: `Unsupported platform: ${plat}`,
-    };
-}
-export async function getAutostartStatus() {
-    const plat = process.platform;
-    const sentinelExists = isAutostartInstalled();
-    if (plat === "darwin") {
-        const { getLaunchdStatus } = await import("./platform-macos.js");
-        return {
-            platform: "macOS (launchd)",
-            installed: sentinelExists,
-            sentinelExists,
-            details: getLaunchdStatus(),
-        };
-    }
-    if (plat === "linux") {
-        const { getSystemdStatus } = await import("./platform-linux.js");
-        return {
-            platform: "Linux (systemd)",
-            installed: sentinelExists,
-            sentinelExists,
-            details: getSystemdStatus(),
-        };
-    }
-    if (plat === "win32") {
-        const { isWindowsInstalled } = await import("./platform-windows.js");
-        return {
-            platform: "Windows (schtasks/startup)",
-            installed: sentinelExists,
-            sentinelExists,
-            details: { registered: isWindowsInstalled() },
-        };
-    }
-    return { platform: plat, installed: false, sentinelExists, details: {} };
-}
-/**
- * Remove the sentinel to allow re-installation.
- * Used by `unerr daemon autostart off`.
- */
-export function removeSentinel() {
-    try {
-        if (existsSync(SENTINEL_PATH))
-            unlinkSync(SENTINEL_PATH);
-    }
-    catch {
-        // Best-effort
-    }
-}

package/dist/daemon/bootstrap.js

@@ -1,39 +0,0 @@
-/**
- * unerrd readiness polling — waits for the daemon socket to become reachable.
- *
- * Used by `daemon initialize` and `daemon start` after they spawn the process
- * themselves. This module does NOT spawn anything — it only polls.
- *
- * Timeout: 5s polling at 100ms intervals. On timeout → throw.
- */
-import { daemonSockPath, probeDaemon } from "./client.js";
-const POLL_INTERVAL_MS = 100;
-const WAIT_TIMEOUT_MS = 5_000;
-/**
- * Wait for `unerrd` to become reachable on its UDS socket.
- * Returns immediately if already running.
- *
- * @returns The daemon socket path once it's confirmed reachable.
- * @throws If the daemon is not reachable within WAIT_TIMEOUT_MS.
- */
-export async function waitForDaemonReady() {
-    const sock = daemonSockPath();
-    // Fast path: daemon already running
-    if (await probeDaemon(sock)) {
-        return sock;
-    }
-    // Poll until the socket is reachable or timeout
-    const deadline = Date.now() + WAIT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
-        await sleep(POLL_INTERVAL_MS);
-        if (await probeDaemon(sock)) {
-            return sock;
-        }
-    }
-    throw new Error(`unerrd did not become reachable within ${WAIT_TIMEOUT_MS / 1000}s. Check logs: ~/.unerr/logs/unerrd.log`);
-}
-/** @deprecated Use waitForDaemonReady instead. Alias kept for test compatibility. */
-export const ensureDaemonRunning = waitForDaemonReady;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}