@unerr-ai/unerr 0.1.0 → 0.1.2

package/dist/server/routes/system.js

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

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

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