@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/server/routes/system.js

@@ -1,73 +0,0 @@
-/**
- * Layer 7: System status and configuration routes.
- *
- * GET /api/system/status  — Proxy state, uptime, PID, graph info
- * GET /api/system/config  — Repo config, IDE, installed skills
- */
-import { Hono } from "hono";
-export function createSystemRoutes(deps) {
-    const app = new Hono();
-    app.get("/status", async (c) => {
-        const start = performance.now();
-        const uptime = Math.round((Date.now() - deps.startedAt) / 1000);
-        const graphStats = await deps.getGraphStats();
-        return c.json({
-            data: {
-                status: "running",
-                pid: process.pid,
-                uptime_s: uptime,
-                mode: "local",
-                dashboard_port: deps.dashboardPort,
-                cwd: deps.cwd,
-                ide: deps.ide,
-                graph: graphStats,
-                session: {
-                    tool_calls: deps.stats.toolCallsLocal,
-                    tokens_saved: deps.stats.estimatedTokensSaved,
-                    violations_caught: deps.stats.violationsCaught,
-                    started_at: new Date(deps.stats.sessionStartedAt).toISOString(),
-                },
-            },
-            _meta: {
-                source: "local",
-                latency_ms: Math.round((performance.now() - start) * 100) / 100,
-            },
-        });
-    });
-    app.get("/config", async (c) => {
-        const start = performance.now();
-        const { existsSync, readFileSync } = await import("node:fs");
-        const { join } = await import("node:path");
-        let config = {};
-        const configPath = join(deps.cwd, ".unerr", "config.json");
-        if (existsSync(configPath)) {
-            try {
-                config = JSON.parse(readFileSync(configPath, "utf-8"));
-            }
-            catch {
-                config = { error: "unreadable" };
-            }
-        }
-        // Detect installed skills
-        let skills = [];
-        try {
-            const { listInstalledSkills } = await import("../../skills/resolver.js");
-            skills = listInstalledSkills(deps.ide, deps.cwd).map((s) => s.name);
-        }
-        catch {
-            // Skills module may not be available
-        }
-        return c.json({
-            data: {
-                repo_config: config,
-                ide: deps.ide,
-                skills_installed: skills,
-            },
-            _meta: {
-                source: "local",
-                latency_ms: Math.round((performance.now() - start) * 100) / 100,
-            },
-        });
-    });
-    return app;
-}

package/dist/server/routes/temporal.js

@@ -1,170 +0,0 @@
-/**
- * Layer 9: Temporal Intelligence API — facts, sessions, decay projections.
- *
- * Endpoints:
- *   GET  /api/facts              — list active facts (filterable by scope, type, confidence)
- *   GET  /api/facts/:id/history  — evidence chain for a specific fact
- *   GET  /api/facts/health       — fact store health summary
- *   GET  /api/sessions           — recent session summaries
- *   POST /api/facts/:id/reinforce — manual reinforcement ("still true")
- *   DELETE /api/facts/:id         — manual dismissal (prune)
- *
- * All handlers operate against the TemporalFactStore (facts.db).
- * The event bus receives fact lifecycle events for SSE broadcast.
- */
-import { Hono } from "hono";
-export function createTemporalRoutes(deps) {
-    const app = new Hono();
-    // ── GET /api/facts ─────────────────────────────────────────────────
-    app.get("/api/facts", async (c) => {
-        if (!deps.factStore) {
-            return c.json({ facts: [], message: "Fact store not available" });
-        }
-        const scope = c.req.query("scope") ?? "project";
-        const factType = c.req.query("type");
-        const minConfidence = Number.parseFloat(c.req.query("min_confidence") ?? "0.2");
-        const limit = Number.parseInt(c.req.query("limit") ?? "50", 10);
-        try {
-            let facts = scope === "*"
-                ? await deps.factStore.recallAll(minConfidence)
-                : await deps.factStore.recallByScope(scope, minConfidence);
-            if (factType && factType !== "all") {
-                facts = facts.filter((f) => f.fact_type === factType);
-            }
-            return c.json({
-                facts: facts.slice(0, limit).map((f) => ({
-                    fact_id: f.fact_id,
-                    fact_type: f.fact_type,
-                    scope: f.scope,
-                    subject: f.subject,
-                    content: f.content,
-                    base_confidence: f.base_confidence,
-                    effective_confidence: Math.round(f.effective_confidence * 1000) / 1000,
-                    reinforcement_count: f.reinforcement_count,
-                    created_at: f.created_at,
-                    last_reinforced_at: f.last_reinforced_at,
-                    source: f.source,
-                })),
-                total: facts.length,
-                filters: {
-                    scope,
-                    type: factType ?? "all",
-                    min_confidence: minConfidence,
-                },
-            });
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    // ── GET /api/facts/health ──────────────────────────────────────────
-    app.get("/api/facts/health", async (c) => {
-        if (!deps.factStore) {
-            return c.json({ error: "Fact store not available" }, 503);
-        }
-        try {
-            const health = await deps.factStore.getFactHealth();
-            return c.json(health);
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    // ── GET /api/facts/:id/history ─────────────────────────────────────
-    app.get("/api/facts/:id/history", async (c) => {
-        if (!deps.factStore) {
-            return c.json({ error: "Fact store not available" }, 503);
-        }
-        const factId = c.req.param("id");
-        try {
-            const facts = await deps.factStore.recallByScope("project", 0);
-            const fact = facts.find((f) => f.fact_id === factId);
-            if (!fact) {
-                return c.json({ error: "Fact not found" }, 404);
-            }
-            return c.json({
-                fact_id: fact.fact_id,
-                fact_type: fact.fact_type,
-                scope: fact.scope,
-                subject: fact.subject,
-                content: fact.content,
-                base_confidence: fact.base_confidence,
-                effective_confidence: fact.effective_confidence,
-                reinforcement_count: fact.reinforcement_count,
-                created_at: fact.created_at,
-                last_reinforced_at: fact.last_reinforced_at,
-                last_contradicted_at: fact.last_contradicted_at,
-                source: fact.source,
-            });
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    // ── GET /api/sessions ──────────────────────────────────────────────
-    app.get("/api/sessions", (c) => {
-        const limit = Number.parseInt(c.req.query("limit") ?? "10", 10);
-        try {
-            const sessions = deps.loadRecentSessions(limit);
-            return c.json({
-                sessions: sessions.map((s) => ({
-                    session_id: s.session_id,
-                    started_at: s.started_at,
-                    ended_at: s.ended_at,
-                    duration_ms: s.duration_ms,
-                    tool_calls: s.tool_calls,
-                    chains: s.chains,
-                    files_modified: s.files_modified.length,
-                    facts_recorded: s.facts_recorded,
-                    revert_count: s.revert_count,
-                    branch: s.branch,
-                })),
-                total: sessions.length,
-            });
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    // ── POST /api/facts/:id/reinforce ──────────────────────────────────
-    app.post("/api/facts/:id/reinforce", async (c) => {
-        if (!deps.factStore) {
-            return c.json({ error: "Fact store not available" }, 503);
-        }
-        const factId = c.req.param("id");
-        try {
-            await deps.factStore.reinforceFact(factId, {
-                session_id: "dashboard-manual",
-                action: "reinforced",
-                timestamp: Date.now(),
-            });
-            deps.emitEvent("fact:reinforced", {
-                fact_id: factId,
-                source: "dashboard",
-            });
-            return c.json({ success: true, fact_id: factId, action: "reinforced" });
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    // ── DELETE /api/facts/:id ──────────────────────────────────────────
-    app.delete("/api/facts/:id", async (c) => {
-        if (!deps.factStore) {
-            return c.json({ error: "Fact store not available" }, 503);
-        }
-        const factId = c.req.param("id");
-        try {
-            await deps.factStore.contradictFact(factId, "Manually dismissed from dashboard");
-            deps.emitEvent("fact:expired", {
-                fact_id: factId,
-                source: "dashboard_dismiss",
-            });
-            return c.json({ success: true, fact_id: factId, action: "dismissed" });
-        }
-        catch (err) {
-            return c.json({ error: err instanceof Error ? err.message : "Unknown error" }, 500);
-        }
-    });
-    return app;
-}

package/dist/server/routes/timeline.js

@@ -1,232 +0,0 @@
-/**
- * Timeline API — routes for the new Session Timeline experience (ST-1 → ST-5).
- *
- * All routes are conditional on the timeline subsystem being active. When the
- * subsystem is off (UNERR_TIMELINE_V2=0) the dashboard never mounts these
- * routes, so the existing /api/session and /api/intelligence surfaces stay
- * completely untouched.
- *
- * Read-only against shadow ledger and timeline.db. No writes back to facts.db
- * or graph.db.
- */
-import { Hono } from "hono";
-import { runIntentStitch } from "../../timeline/intent-detector.js";
-import { detectLoops } from "../../timeline/loop-miner.js";
-import { computeOpenThreads } from "../../timeline/open-threads.js";
-function parseLimit(raw, fallback, max) {
-    const n = Number.parseInt(raw ?? "", 10);
-    if (Number.isNaN(n) || n < 1)
-        return fallback;
-    return Math.min(n, max);
-}
-function parseInt0(raw, fallback, min = 0) {
-    const n = Number.parseInt(raw ?? "", 10);
-    if (Number.isNaN(n) || n < min)
-        return fallback;
-    return n;
-}
-function parseTs(raw) {
-    if (!raw)
-        return undefined;
-    const n = Number(raw);
-    if (Number.isFinite(n) && n > 0)
-        return n;
-    const parsed = Date.parse(raw);
-    return Number.isFinite(parsed) ? parsed : undefined;
-}
-export function createTimelineRoutes(deps) {
-    const app = new Hono();
-    app.get("/health", (c) => c.json({
-        data: {
-            ok: true,
-            db_path: deps.store.dbPath,
-            is_new: deps.store.isNew,
-        },
-    }));
-    app.get("/turns", async (c) => {
-        const sessionId = c.req.query("session_id");
-        const fromTs = parseTs(c.req.query("from"));
-        const toTs = parseTs(c.req.query("to"));
-        const query = c.req.query("q");
-        const limit = parseLimit(c.req.query("limit"), 50, 500);
-        const offset = parseInt0(c.req.query("offset"), 0);
-        const filter = {
-            sessionId: sessionId || undefined,
-            fromTs,
-            toTs,
-            query: query || undefined,
-        };
-        const [turns, total] = await Promise.all([
-            deps.store.listTurns({ ...filter, limit, offset }),
-            deps.store.countTurns(filter),
-        ]);
-        return c.json({
-            data: turns,
-            total,
-            returned: turns.length,
-            offset,
-            limit,
-        });
-    });
-    app.get("/sessions", async (c) => {
-        const fromTs = parseTs(c.req.query("from"));
-        const toTs = parseTs(c.req.query("to"));
-        const limit = parseLimit(c.req.query("limit"), 200, 1000);
-        const agentFilter = c.req.query("agent");
-        let sessions = await deps.store.listSessions({ fromTs, toTs, limit });
-        if (agentFilter && agentFilter.length > 0) {
-            sessions = sessions.filter((s) => s.agent_name === agentFilter);
-        }
-        return c.json({
-            data: sessions,
-            total: sessions.length,
-            returned: sessions.length,
-        });
-    });
-    app.get("/agents", async (c) => {
-        const agents = await deps.store.listAgents();
-        return c.json({
-            data: agents,
-            total: agents.length,
-            returned: agents.length,
-        });
-    });
-    app.get("/heatmap", async (c) => {
-        const days = Math.max(1, Math.min(parseInt0(c.req.query("days"), 30), 365));
-        const bucketMs = 24 * 60 * 60_000;
-        const toTs = Date.now();
-        const fromTs = toTs - (days - 1) * bucketMs;
-        const buckets = await deps.store.getActivityBuckets({
-            fromTs,
-            toTs,
-            bucketMs,
-        });
-        return c.json({
-            data: buckets,
-            total: buckets.length,
-            returned: buckets.length,
-            from_ts: fromTs,
-            to_ts: toTs,
-        });
-    });
-    app.get("/markers", async (c) => {
-        const sessionId = c.req.query("session_id");
-        const type = c.req.query("type");
-        const limit = parseLimit(c.req.query("limit"), 100, 500);
-        const markers = await deps.store.listMarkers({
-            sessionId: sessionId || undefined,
-            type: type || undefined,
-            limit,
-        });
-        return c.json({
-            data: markers,
-            total: markers.length,
-            returned: markers.length,
-        });
-    });
-    app.get("/loops", (c) => {
-        if (!deps.getRecentLedgerEntries) {
-            return c.json({ data: [], total: 0, returned: 0 });
-        }
-        const entries = deps.getRecentLedgerEntries(200);
-        const loops = detectLoops(entries);
-        return c.json({ data: loops, total: loops.length, returned: loops.length });
-    });
-    app.get("/open-threads", async (c) => {
-        const sessionId = c.req.query("session_id");
-        const markers = await deps.store.listMarkers({
-            sessionId: sessionId || undefined,
-            limit: 500,
-        });
-        const threads = computeOpenThreads(markers);
-        return c.json({
-            data: threads,
-            total: threads.length,
-            returned: threads.length,
-        });
-    });
-    app.get("/signals", async (c) => {
-        const type = c.req.query("type");
-        const minConfidence = c.req.query("min_confidence");
-        const limit = parseLimit(c.req.query("limit"), 50, 500);
-        const signals = await deps.store.listSignals({
-            type: type || undefined,
-            minConfidence: minConfidence !== undefined ? Number(minConfidence) : undefined,
-            limit,
-        });
-        return c.json({
-            data: signals,
-            total: signals.length,
-            returned: signals.length,
-        });
-    });
-    app.get("/signals/:id/history", async (c) => {
-        const id = c.req.param("id");
-        const limit = parseLimit(c.req.query("limit"), 10, 100);
-        const history = await deps.store.getReinforcementHistory(id, limit);
-        return c.json({
-            data: history,
-            total: history.length,
-            returned: history.length,
-        });
-    });
-    app.get("/intents", async (c) => {
-        const status = c.req.query("status");
-        const limit = parseLimit(c.req.query("limit"), 100, 500);
-        const intents = await deps.store.listIntents({
-            status: status || undefined,
-            limit,
-        });
-        return c.json({
-            data: intents,
-            total: intents.length,
-            returned: intents.length,
-        });
-    });
-    app.get("/intents/:id", async (c) => {
-        const intentId = c.req.param("id");
-        const all = await deps.store.listIntents({ limit: 500 });
-        const intent = all.find((i) => i.intent_id === intentId);
-        if (!intent)
-            return c.json({ error: "not_found" }, 404);
-        const sessions = await deps.store.listIntentSessions(intentId);
-        return c.json({ data: { intent, sessions } });
-    });
-    app.post("/intents/stitch", async (c) => {
-        const summary = await runIntentStitch(deps.store);
-        return c.json({ data: summary });
-    });
-    /**
-     * Resume strip: dominant intent + open blockers + hot files from the most
-     * recent turn(s), provided that turn closed within 7 days. Returns `null`
-     * when nothing useful is available — the UI hides the strip.
-     */
-    app.get("/resume", async (c) => {
-        const SEVEN_DAYS_MS = 7 * 24 * 60 * 60_000;
-        const now = Date.now();
-        const turns = await deps.store.listTurns({ limit: 10 });
-        const latestActive = turns.find((t) => now - t.ended_at < SEVEN_DAYS_MS);
-        if (!latestActive) {
-            return c.json({ data: null });
-        }
-        const markers = await deps.store.listMarkers({
-            sessionId: latestActive.session_id,
-            limit: 500,
-        });
-        const openThreads = computeOpenThreads(markers);
-        const intent = markers.find((m) => m.type === "mark_intent")?.text ??
-            latestActive.title ??
-            "";
-        return c.json({
-            data: {
-                session_id: latestActive.session_id,
-                last_turn_id: latestActive.turn_id,
-                last_active_at: latestActive.ended_at,
-                elapsed_ms: now - latestActive.ended_at,
-                intent,
-                open_threads: openThreads,
-            },
-        });
-    });
-    return app;
-}