@lovenyberg/ove 0.3.0 → 0.4.0

package/src/adapters/cli.ts

@@ -1,4 +1,4 @@
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { createInterface } from "node:readline";
 
 const DIM = "\x1b[2m";
@@ -12,6 +12,8 @@ export class CliAdapter implements ChatAdapter {
   private userId: string;
   private statusLines: string[] = [];
   private statusLinesShown = 0;
+  private started = false;
+  private startedAt?: string;
 
   constructor(userId: string = "cli:local") {
     this.userId = userId;
@@ -42,6 +44,9 @@ export class CliAdapter implements ChatAdapter {
       prompt: "\nove> ",
     });
 
+    this.started = true;
+    this.startedAt = new Date().toISOString();
+
     console.log("\n--- Ove ---");
     console.log("Ja. What do you want? Type 'help' if you need it.\n");
 
@@ -87,7 +92,17 @@ export class CliAdapter implements ChatAdapter {
     });
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "cli",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     this.rl?.close();
   }
 }

package/src/adapters/debounce.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "bun:test";
+import { debounce } from "./debounce";
+
+describe("debounce", () => {
+  it("delays execution", async () => {
+    let called = 0;
+    const fn = debounce(() => { called++; }, 50);
+    fn();
+    expect(called).toBe(0);
+    await Bun.sleep(80);
+    expect(called).toBe(1);
+  });
+
+  it("collapses rapid calls", async () => {
+    let lastArg: string | undefined;
+    const fn = debounce((v: string) => { lastArg = v; }, 50);
+    fn("a");
+    fn("b");
+    fn("c");
+    await Bun.sleep(80);
+    expect(lastArg).toBe("c");
+  });
+
+  it("flush fires immediately", () => {
+    let called = 0;
+    const fn = debounce(() => { called++; }, 5000);
+    fn();
+    expect(called).toBe(0);
+    fn.flush();
+    expect(called).toBe(1);
+  });
+
+  it("flush with no pending is a no-op", () => {
+    let called = 0;
+    const fn = debounce(() => { called++; }, 5000);
+    fn.flush();
+    expect(called).toBe(0);
+  });
+
+  it("cancel discards pending", async () => {
+    let called = 0;
+    const fn = debounce(() => { called++; }, 50);
+    fn();
+    fn.cancel();
+    await Bun.sleep(80);
+    expect(called).toBe(0);
+  });
+
+  it("flush uses latest args", () => {
+    let lastArg: string | undefined;
+    const fn = debounce((v: string) => { lastArg = v; }, 5000);
+    fn("first");
+    fn("second");
+    fn.flush();
+    expect(lastArg).toBe("second");
+  });
+});

package/src/adapters/debounce.ts

@@ -1,10 +1,42 @@
-export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+export type DebouncedFunction<T extends (...args: any[]) => any> = T & {
+  flush(): void;
+  cancel(): void;
+};
+
+export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): DebouncedFunction<T> {
   let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
+  let lastArgs: any[] | null = null;
+
+  const debounced = ((...args: any[]) => {
+    lastArgs = args;
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
       timer = null;
-      fn(...args);
+      const pending = lastArgs;
+      lastArgs = null;
+      if (pending) fn(...pending);
     }, ms);
-  }) as any as T;
+  }) as DebouncedFunction<T>;
+
+  debounced.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (lastArgs) {
+      const args = lastArgs;
+      lastArgs = null;
+      fn(...args);
+    }
+  };
+
+  debounced.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    lastArgs = null;
+  };
+
+  return debounced;
 }

package/src/adapters/discord.ts

@@ -1,5 +1,5 @@
 import { Client, GatewayIntentBits, type Message } from "discord.js";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
 import { debounce } from "./debounce";
 
@@ -7,6 +7,8 @@ export class DiscordAdapter implements ChatAdapter {
   private client: Client;
   private token: string;
   private onMessage?: (msg: IncomingMessage) => void;
+  private started = false;
+  private startedAt?: string;
 
   constructor(token: string) {
     if (!token) throw new Error("Discord bot token is required");
@@ -48,7 +50,8 @@ export class DiscordAdapter implements ChatAdapter {
           } else {
             statusMsg = await discordMsg.channel.send(statusText);
           }
-        } catch {
+        } catch (err) {
+          logger.warn("discord status update failed", { error: String(err) });
           statusMsg = await discordMsg.channel.send(statusText);
         }
       }, 3000);
@@ -68,10 +71,22 @@ export class DiscordAdapter implements ChatAdapter {
     });
 
     await this.client.login(this.token);
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("discord adapter started");
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "discord",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     this.client.destroy();
     logger.info("discord adapter stopped");
   }

package/src/adapters/github.ts

@@ -1,4 +1,4 @@
-import type { EventAdapter, IncomingEvent, EventSource } from "./types";
+import type { EventAdapter, IncomingEvent, EventSource, AdapterStatus } from "./types";
 import { logger } from "../logger";
 
 export function parseMention(body: string, botName: string): string | null {
@@ -21,6 +21,9 @@ export class GitHubAdapter implements EventAdapter {
   private onEvent?: (event: IncomingEvent) => void;
   private seenCommentIds = new Set<number>();
   private pollTimer?: ReturnType<typeof setInterval>;
+  private started = false;
+  private startedAt?: string;
+  private lastPollError?: string;
 
   constructor(repos: string[], botName: string, pollIntervalMs: number = 30_000) {
     if (!repos.length) throw new Error("GitHub adapter requires at least one repo");
@@ -38,10 +41,28 @@ export class GitHubAdapter implements EventAdapter {
     }
 
     this.pollTimer = setInterval(() => this.pollAll(), this.pollIntervalMs);
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("github adapter started", { repos: this.repos, pollMs: this.pollIntervalMs });
   }
 
+  getStatus(): AdapterStatus {
+    let status: AdapterStatus["status"] = "disconnected";
+    if (this.started && !this.lastPollError) status = "connected";
+    else if (this.started && this.lastPollError) status = "degraded";
+
+    return {
+      name: "github",
+      type: "event",
+      status,
+      error: this.lastPollError,
+      details: { repos: this.repos, pollIntervalMs: this.pollIntervalMs },
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     if (this.pollTimer) clearInterval(this.pollTimer);
     logger.info("github adapter stopped");
   }
@@ -72,13 +93,17 @@ export class GitHubAdapter implements EventAdapter {
   }
 
   private async pollAll(): Promise<void> {
+    let hadError = false;
     for (const repo of this.repos) {
       try {
         await this.pollRepo(repo);
       } catch (err) {
+        hadError = true;
+        this.lastPollError = String(err);
         logger.error("github poll error", { repo, error: String(err) });
       }
     }
+    if (!hadError) this.lastPollError = undefined;
   }
 
   private async pollRepo(repo: string): Promise<void> {

package/src/adapters/http.test.ts

@@ -1,4 +1,7 @@
+import { Database } from "bun:sqlite";
 import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { TraceStore } from "../trace";
+import { TaskQueue } from "../queue";
 import type { IncomingEvent } from "./types";
 
 let adapter: any;
@@ -10,7 +13,10 @@ describe("HttpApiAdapter", () => {
   beforeAll(async () => {
     const { HttpApiAdapter } = await import("./http");
     receivedEvents = [];
-    adapter = new HttpApiAdapter(TEST_PORT, API_KEY);
+    const db = new Database(":memory:");
+    const trace = new TraceStore(db);
+    const queue = new TaskQueue(db);
+    adapter = new HttpApiAdapter(TEST_PORT, API_KEY, trace, queue);
     await adapter.start((event: IncomingEvent) => {
       receivedEvents.push(event);
     });

package/src/adapters/http.ts

@@ -1,11 +1,14 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { EventAdapter, IncomingEvent } from "./types";
+import { readFileSync, existsSync } from "node:fs";
+import { join, extname } from "node:path";
+import type { EventAdapter, IncomingEvent, IncomingMessage, ChatAdapter, AdapterStatus } from "./types";
+import type { TraceStore } from "../trace";
+import type { TaskQueue } from "../queue";
+import type { SessionStore } from "../sessions";
 import { logger } from "../logger";
 
-interface PendingEvent {
+interface PendingChat {
   status: "pending" | "completed";
-  result?: string;
+  replies: string[];
   statusText?: string;
   sseControllers: ReadableStreamDefaultController[];
 }
@@ -13,19 +16,65 @@ interface PendingEvent {
 export class HttpApiAdapter implements EventAdapter {
   private port: number;
   private apiKey: string;
+  private trace: TraceStore;
+  private queue: TaskQueue | null;
+  private sessions: SessionStore | null;
   private server?: ReturnType<typeof Bun.serve>;
   private onEvent?: (event: IncomingEvent) => void;
-  private events = new Map<string, PendingEvent>();
+  private onMessage?: (msg: IncomingMessage) => void;
+  private chats = new Map<string, PendingChat>();
   private webUiHtml: string;
+  private traceUiHtml: string;
+  private statusUiHtml: string;
+  private publicDir: string;
+  private chatAdapters: ChatAdapter[] = [];
+  private eventAdapters: EventAdapter[] = [];
+  private startedAt?: string;
 
-  constructor(port: number, apiKey: string) {
+  constructor(port: number, apiKey: string, trace: TraceStore, queue?: TaskQueue, sessions?: SessionStore) {
     this.port = port;
     this.apiKey = apiKey;
+    this.trace = trace;
+    this.queue = queue || null;
+    this.sessions = sessions || null;
+    const publicDir = join(import.meta.dir, "../../public");
+    this.publicDir = publicDir;
     try {
-      this.webUiHtml = readFileSync(join(import.meta.dir, "../../public/index.html"), "utf-8");
+      this.webUiHtml = readFileSync(join(publicDir, "index.html"), "utf-8");
     } catch {
       this.webUiHtml = "<html><body><p>Web UI not found. Place public/index.html in project root.</p></body></html>";
     }
+    try {
+      this.traceUiHtml = readFileSync(join(publicDir, "trace.html"), "utf-8");
+    } catch {
+      this.traceUiHtml = "<html><body><p>Trace viewer not found. Place public/trace.html in project root.</p></body></html>";
+    }
+    try {
+      this.statusUiHtml = readFileSync(join(publicDir, "status.html"), "utf-8");
+    } catch {
+      this.statusUiHtml = "<html><body><p>Status page not found. Place public/status.html in project root.</p></body></html>";
+    }
+  }
+
+  /** Set the chat message handler so web UI messages go through the full chat pipeline */
+  setMessageHandler(handler: (msg: IncomingMessage) => void): void {
+    this.onMessage = handler;
+  }
+
+  /** Register all adapters so the status page can query them */
+  setAdapters(chat: ChatAdapter[], event: EventAdapter[]): void {
+    this.chatAdapters = chat;
+    this.eventAdapters = event;
+  }
+
+  getStatus(): AdapterStatus {
+    return {
+      name: "http",
+      type: "event",
+      status: this.server ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+      details: { port: this.port },
+    };
   }
 
   async start(onEvent: (event: IncomingEvent) => void): Promise<void> {
@@ -34,6 +83,7 @@ export class HttpApiAdapter implements EventAdapter {
 
     this.server = Bun.serve({
       port: this.port,
+      idleTimeout: 255, // SSE connections need to stay open for long-running tasks
       async fetch(req) {
         const url = new URL(req.url);
         const path = url.pathname;
@@ -45,6 +95,18 @@ export class HttpApiAdapter implements EventAdapter {
           });
         }
 
+        if (path === "/trace" || path === "/trace.html") {
+          return new Response(self.traceUiHtml, {
+            headers: { "Content-Type": "text/html" },
+          });
+        }
+
+        if (path === "/status" || path === "/status.html") {
+          return new Response(self.statusUiHtml, {
+            headers: { "Content-Type": "text/html" },
+          });
+        }
+
         // Auth check for API routes
         if (path.startsWith("/api/")) {
           const key = req.headers.get("X-API-Key") || url.searchParams.get("key");
@@ -53,49 +115,127 @@ export class HttpApiAdapter implements EventAdapter {
           }
         }
 
-        // POST /api/message — submit a task
+        // GET /api/status — adapter health + queue stats
+        if (path === "/api/status" && req.method === "GET") {
+          const adapterStatuses: AdapterStatus[] = [];
+          for (const a of self.chatAdapters) {
+            adapterStatuses.push(a.getStatus?.() ?? { name: a.constructor.name, type: "chat", status: "unknown" });
+          }
+          for (const a of self.eventAdapters) {
+            adapterStatuses.push(a.getStatus?.() ?? { name: a.constructor.name, type: "event", status: "unknown" });
+          }
+          const queueStats = self.queue?.stats() ?? { pending: 0, running: 0, completed: 0, failed: 0 };
+          return Response.json({
+            adapters: adapterStatuses,
+            queue: queueStats,
+            uptime: process.uptime(),
+            timestamp: new Date().toISOString(),
+          });
+        }
+
+        // GET /api/tasks — list recent tasks
+        if (path === "/api/tasks" && req.method === "GET") {
+          if (!self.queue) {
+            return Response.json({ error: "Task queue not available" }, { status: 503 });
+          }
+          const limit = Math.min(parseInt(url.searchParams.get("limit") || "20") || 20, 100);
+          const status = url.searchParams.get("status") || undefined;
+          const tasks = self.queue.listRecent(limit, status);
+          return Response.json(tasks.map((t) => ({
+            id: t.id,
+            userId: t.userId,
+            repo: t.repo,
+            prompt: t.prompt,
+            status: t.status,
+            result: t.result && t.result.length > 300 ? t.result.slice(0, 300) + "..." : t.result,
+            createdAt: t.createdAt,
+            completedAt: t.completedAt,
+          })));
+        }
+
+        // POST /api/message — submit a chat message (full chat pipeline)
         if (path === "/api/message" && req.method === "POST") {
           const body = await req.json() as { text: string; userId?: string };
-          const eventId = crypto.randomUUID();
-          const userId = body.userId || "http:anon";
+          const chatId = crypto.randomUUID();
+          const userId = body.userId || "http:web";
+
+          const chat: PendingChat = { status: "pending", replies: [], sseControllers: [] };
+          self.chats.set(chatId, chat);
 
-          self.events.set(eventId, { status: "pending", sseControllers: [] });
+          function notifySSE(data: object) {
+            const payload = JSON.stringify(data);
+            for (const ctrl of chat.sseControllers) {
+              try { ctrl.enqueue(`data: ${payload}\n\n`); } catch {}
+            }
+          }
 
-          const event: IncomingEvent = {
-            eventId,
-            userId,
-            platform: "http",
-            source: { type: "http", requestId: eventId },
-            text: body.text,
-          };
+          if (self.onMessage) {
+            // Route through full chat handler (commands, session, repo resolution, etc.)
+            let closeTimer: ReturnType<typeof setTimeout> | null = null;
+            const msg: IncomingMessage = {
+              userId,
+              platform: "http",
+              text: body.text,
+              reply: async (text: string) => {
+                chat.replies.push(text);
+                chat.status = "completed";
+                notifySSE({ status: "completed", result: chat.replies.join("\n\n") });
+                // Delay closing SSE to allow multiple split replies to arrive
+                if (closeTimer) clearTimeout(closeTimer);
+                closeTimer = setTimeout(() => {
+                  for (const ctrl of chat.sseControllers) {
+                    try { ctrl.close(); } catch {}
+                  }
+                  chat.sseControllers = [];
+                  setTimeout(() => self.chats.delete(chatId), 5 * 60 * 1000);
+                }, 500);
+              },
+              updateStatus: async (text: string) => {
+                chat.statusText = text;
+                notifySSE({ status: "pending", statusText: text });
+              },
+            };
+            self.onMessage(msg);
+          } else {
+            // Fallback to event handler
+            const event: IncomingEvent = {
+              eventId: chatId,
+              userId,
+              platform: "http",
+              source: { type: "http", requestId: chatId },
+              text: body.text,
+            };
+            self.onEvent?.(event);
+          }
 
-          self.onEvent?.(event);
-          return Response.json({ eventId }, { status: 202 });
+          return Response.json({ eventId: chatId }, { status: 202 });
         }
 
         // GET /api/message/:id/stream — SSE stream
         const streamMatch = path.match(/^\/api\/message\/([^/]+)\/stream$/);
         if (streamMatch && req.method === "GET") {
-          const eventId = streamMatch[1];
-          const pending = self.events.get(eventId);
-          if (!pending) {
+          const chatId = streamMatch[1];
+          const chat = self.chats.get(chatId);
+          if (!chat) {
             return Response.json({ error: "Not found" }, { status: 404 });
           }
 
+          let sseController: ReadableStreamDefaultController;
           const stream = new ReadableStream({
             start(controller) {
-              pending.sseControllers.push(controller);
+              sseController = controller;
+              chat.sseControllers.push(controller);
               // Send current state immediately
               const data = JSON.stringify({
-                status: pending.status,
-                result: pending.result,
-                statusText: pending.statusText,
+                status: chat.status,
+                result: chat.replies.length > 0 ? chat.replies.join("\n\n") : undefined,
+                statusText: chat.statusText,
               });
               controller.enqueue(`data: ${data}\n\n`);
             },
             cancel() {
-              const idx = pending.sseControllers.indexOf(controller);
-              if (idx >= 0) pending.sseControllers.splice(idx, 1);
+              const idx = chat.sseControllers.indexOf(sseController);
+              if (idx >= 0) chat.sseControllers.splice(idx, 1);
             },
           });
 
@@ -111,21 +251,53 @@ export class HttpApiAdapter implements EventAdapter {
         // GET /api/message/:id — poll status
         const getMatch = path.match(/^\/api\/message\/([^/]+)$/);
         if (getMatch && req.method === "GET") {
-          const eventId = getMatch[1];
-          const pending = self.events.get(eventId);
-          if (!pending) {
+          const chatId = getMatch[1];
+          const chat = self.chats.get(chatId);
+          if (!chat) {
             return Response.json({ error: "Not found" }, { status: 404 });
           }
           return Response.json({
-            status: pending.status,
-            result: pending.result,
+            status: chat.status,
+            result: chat.replies.length > 0 ? chat.replies.join("\n\n") : undefined,
           });
         }
 
+        // GET /api/trace/:taskId — trace events for a task
+        const traceMatch = path.match(/^\/api\/trace\/([^/]+)$/);
+        if (traceMatch && req.method === "GET") {
+          const taskId = traceMatch[1];
+          const events = self.trace.getByTask(taskId);
+          return Response.json(events);
+        }
+
+        // GET /api/history/:userId — chat history for a user
+        const historyMatch = path.match(/^\/api\/history\/([^/]+)$/);
+        if (historyMatch && req.method === "GET") {
+          if (!self.sessions) {
+            return Response.json({ error: "Sessions not available" }, { status: 503 });
+          }
+          const userId = decodeURIComponent(historyMatch[1]);
+          const limit = Math.min(parseInt(url.searchParams.get("limit") || "50") || 50, 200);
+          const history = self.sessions.getHistory(userId, limit);
+          return Response.json(history);
+        }
+
+        // Static files from public/
+        const MIME: Record<string, string> = { ".png": "image/png", ".ico": "image/x-icon", ".svg": "image/svg+xml", ".jpg": "image/jpeg", ".css": "text/css", ".js": "application/javascript" };
+        const ext = extname(path);
+        if (ext && MIME[ext]) {
+          const filePath = join(self.publicDir, path);
+          if (existsSync(filePath)) {
+            const data = readFileSync(filePath);
+            return new Response(data, { headers: { "Content-Type": MIME[ext], "Cache-Control": "public, max-age=3600" } });
+          }
+        }
+
         return Response.json({ error: "Not found" }, { status: 404 });
       },
     });
 
+    this.startedAt = new Date().toISOString();
     logger.info("http api adapter started", { port: this.port });
   }
 
@@ -135,15 +307,15 @@ export class HttpApiAdapter implements EventAdapter {
   }
 
   async respondToEvent(eventId: string, text: string): Promise<void> {
-    const pending = this.events.get(eventId);
-    if (!pending) return;
+    const chat = this.chats.get(eventId);
+    if (!chat) return;
 
-    pending.status = "completed";
-    pending.result = text;
+    chat.status = "completed";
+    chat.replies.push(text);
 
     // Notify SSE listeners
-    const data = JSON.stringify({ status: "completed", result: text });
-    for (const controller of pending.sseControllers) {
+    const data = JSON.stringify({ status: "completed", result: chat.replies.join("\n\n") });
+    for (const controller of chat.sseControllers) {
       try {
         controller.enqueue(`data: ${data}\n\n`);
         controller.close();
@@ -151,20 +323,20 @@ export class HttpApiAdapter implements EventAdapter {
         logger.debug("sse enqueue failed", { eventId, error: String(err) });
       }
     }
-    pending.sseControllers = [];
+    chat.sseControllers = [];
 
-    // Clean up event after 5 minutes
-    setTimeout(() => this.events.delete(eventId), 5 * 60 * 1000);
+    // Clean up after 5 minutes
+    setTimeout(() => this.chats.delete(eventId), 5 * 60 * 1000);
   }
 
   /** Called by index.ts to push status updates to SSE clients */
   updateEventStatus(eventId: string, statusText: string): void {
-    const pending = this.events.get(eventId);
-    if (!pending) return;
-    pending.statusText = statusText;
+    const chat = this.chats.get(eventId);
+    if (!chat) return;
+    chat.statusText = statusText;
 
     const data = JSON.stringify({ status: "pending", statusText });
-    for (const controller of pending.sseControllers) {
+    for (const controller of chat.sseControllers) {
       try {
         controller.enqueue(`data: ${data}\n\n`);
       } catch (err) {