@lovenyberg/ove 0.2.2 → 0.4.0

package/src/adapters/slack.ts

@@ -1,22 +1,14 @@
 // src/adapters/slack.ts
 import { App } from "@slack/bolt";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 export class SlackAdapter implements ChatAdapter {
   private app: App;
   private onMessage?: (msg: IncomingMessage) => void;
+  private started = false;
+  private startedAt?: string;
 
   constructor() {
     this.app = new App({
@@ -42,7 +34,8 @@ export class SlackAdapter implements ChatAdapter {
             ts: statusMsgTs,
             text: statusText,
           });
-        } catch {
+        } catch (err) {
+          logger.warn("slack status update failed", { error: String(err) });
           const result = await say(statusText);
           if (result && "ts" in result) statusMsgTs = result.ts;
         }
@@ -96,10 +89,22 @@ export class SlackAdapter implements ChatAdapter {
     });
 
     await this.app.start();
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("slack adapter started");
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "slack",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     await this.app.stop();
     logger.info("slack adapter stopped");
   }

package/src/adapters/telegram.ts

@@ -1,17 +1,7 @@
 import { Bot } from "grammy";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 /** Convert simple markdown (*bold*, `code`, ```blocks```) to Telegram HTML */
 function mdToHtml(text: string): string {
@@ -34,6 +24,8 @@ function mdToHtml(text: string): string {
 export class TelegramAdapter implements ChatAdapter {
   private bot: Bot;
   private onMessage?: (msg: IncomingMessage) => void;
+  private started = false;
+  private startedAt?: string;
 
   constructor(token: string) {
     if (!token) throw new Error("Telegram bot token is required");
@@ -61,8 +53,8 @@ export class TelegramAdapter implements ChatAdapter {
             const sent = await ctx.reply(html, { parse_mode: "HTML" });
             statusMsgId = sent.message_id;
           }
-        } catch {
-          // Edit may fail if content unchanged or message too old — ignore
+        } catch (err) {
+          logger.warn("telegram status update failed", { error: String(err) });
         }
       }, 3000);
 
@@ -71,14 +63,12 @@ export class TelegramAdapter implements ChatAdapter {
         platform: "telegram",
         text,
         reply: async (replyText: string) => {
-          // Replace the status message with the first reply, then send new messages for the rest
+          // Delete status message and send a new one so the user gets a notification
           if (statusMsgId) {
             try {
-              await ctx.api.editMessageText(chatId, statusMsgId, mdToHtml(replyText), { parse_mode: "HTML" });
-              statusMsgId = undefined;
-              return;
-            } catch {
-              // Edit failed (message too old, etc.) — fall through to send new
+              await ctx.api.deleteMessage(chatId, statusMsgId);
+            } catch (err) {
+              logger.debug("telegram status delete failed", { error: String(err) });
             }
             statusMsgId = undefined;
           }
@@ -92,10 +82,22 @@ export class TelegramAdapter implements ChatAdapter {
     });
 
     this.bot.start();
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("telegram adapter started");
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "telegram",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     this.bot.stop();
     logger.info("telegram adapter stopped");
   }

package/src/adapters/types.ts

@@ -6,10 +6,20 @@ export interface IncomingMessage {
   updateStatus: (text: string) => Promise<void>;
 }
 
+export interface AdapterStatus {
+  name: string;
+  type: "chat" | "event";
+  status: "connected" | "disconnected" | "degraded" | "unknown";
+  error?: string;
+  details?: Record<string, unknown>;
+  startedAt?: string;
+}
+
 export interface ChatAdapter {
   start(onMessage: (msg: IncomingMessage) => void): Promise<void>;
   stop(): Promise<void>;
   sendToUser?(userId: string, text: string): Promise<void>;
+  getStatus?(): AdapterStatus;
 }
 
 export type EventSource =
@@ -29,4 +39,5 @@ export interface EventAdapter {
   start(onEvent: (event: IncomingEvent) => void): Promise<void>;
   stop(): Promise<void>;
   respondToEvent(eventId: string, text: string): Promise<void>;
+  getStatus?(): AdapterStatus;
 }

package/src/adapters/whatsapp.ts

@@ -4,7 +4,7 @@ import makeWASocket, {
   DisconnectReason,
   type WASocket,
 } from "baileys";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
 
 export class WhatsAppAdapter implements ChatAdapter {
@@ -12,12 +12,18 @@ export class WhatsAppAdapter implements ChatAdapter {
   private onMessage?: (msg: IncomingMessage) => void;
   private authDir: string;
   private phoneNumber?: string;
+  private allowedChats: Set<string>;
   private reconnectAttempt = 0;
   private sentByBot = new Set<string>();
+  private connectionState: "open" | "close" | "connecting" = "connecting";
+  private lastError?: string;
+  private startedAt?: string;
+  private pairingCode?: string;
 
-  constructor(opts: { authDir?: string; phoneNumber?: string } = {}) {
+  constructor(opts: { authDir?: string; phoneNumber?: string; allowedChats?: string[] } = {}) {
     this.authDir = opts.authDir ?? "./auth/whatsapp";
     this.phoneNumber = opts.phoneNumber;
+    this.allowedChats = new Set(opts.allowedChats ?? []);
   }
 
   async start(onMessage: (msg: IncomingMessage) => void): Promise<void> {
@@ -33,13 +39,17 @@ export class WhatsAppAdapter implements ChatAdapter {
 
     let pairingRequested = false;
 
+    this.startedAt = this.startedAt || new Date().toISOString();
+
     this.sock.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
+      if (connection) this.connectionState = connection as "open" | "close" | "connecting";
       // Request pairing code when server is ready (sends qr event)
       if (qr && this.phoneNumber && !pairingRequested) {
         pairingRequested = true;
         try {
           const phone = this.phoneNumber.replace(/[^0-9]/g, "");
           const code = await this.sock!.requestPairingCode(phone);
+          this.pairingCode = code;
           logger.info(`whatsapp pairing code: ${code}`, { phone });
           console.log(`\n  WhatsApp pairing code: ${code}`);
           console.log(`  Enter this code on your phone: WhatsApp → Linked Devices → Link a Device\n`);
@@ -50,16 +60,20 @@ export class WhatsAppAdapter implements ChatAdapter {
 
       if (connection === "close") {
         const statusCode = (lastDisconnect?.error as any)?.output?.statusCode;
+        this.lastError = `disconnected (status ${statusCode})`;
         if (statusCode !== DisconnectReason.loggedOut) {
           this.reconnectAttempt++;
           const delay = Math.min(2000 * this.reconnectAttempt, 30_000);
           logger.warn("whatsapp disconnected, reconnecting...", { statusCode, delay });
           setTimeout(() => this.start(onMessage), delay);
         } else {
+          this.lastError = "logged out";
           logger.error("whatsapp logged out");
         }
       } else if (connection === "open") {
         this.reconnectAttempt = 0;
+        this.lastError = undefined;
+        this.pairingCode = undefined;
         logger.info("whatsapp adapter connected");
       }
     });
@@ -78,6 +92,14 @@ export class WhatsAppAdapter implements ChatAdapter {
         // Skip messages from others (not our phone) — we only process our own commands
         if (!waMsg.key.fromMe) continue;
 
+        // Only process messages in whitelisted chats (if configured)
+        if (this.allowedChats.size > 0) {
+          const jid = waMsg.key.remoteJid;
+          if (!jid) continue;
+          const chatId = jid.split("@")[0];
+          if (!this.allowedChats.has(jid) && !this.allowedChats.has(chatId)) continue;
+        }
+
         const text =
           waMsg.message.conversation ||
           waMsg.message.extendedTextMessage?.text;
@@ -141,6 +163,22 @@ export class WhatsAppAdapter implements ChatAdapter {
     });
   }
 
+  getStatus(): AdapterStatus {
+    let status: AdapterStatus["status"] = "unknown";
+    if (this.connectionState === "open") status = "connected";
+    else if (this.connectionState === "close") status = "disconnected";
+    else if (this.connectionState === "connecting") status = this.reconnectAttempt > 0 ? "degraded" : "unknown";
+
+    return {
+      name: "whatsapp",
+      type: "chat",
+      status,
+      error: this.lastError,
+      details: { reconnectAttempt: this.reconnectAttempt, pairingCode: this.pairingCode },
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
     this.sock?.end(undefined);
     this.sock = null;

package/src/config.ts

@@ -64,6 +64,7 @@ export function loadConfig(): Config {
       github: raw.github,
     };
   } catch {
+    // Config file doesn't exist yet or is invalid — use defaults
     return {
       repos: {},
       users: {},
@@ -94,7 +95,9 @@ export function saveConfig(config: Config): void {
   let existing: Record<string, any> = {};
   try {
     existing = JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {}
+  } catch {
+    // File doesn't exist yet or is invalid — start with empty object
+  }
   const merged = { ...existing, repos: config.repos, users: config.users, claude: config.claude, reposDir: config.reposDir };
   if (config.mcpServers) merged.mcpServers = config.mcpServers;
   if (config.cron) merged.cron = config.cron;

package/src/flows.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
 import { parseMessage, buildPrompt, buildContextualPrompt, type ParsedMessage } from "./router";
 import { TaskQueue } from "./queue";
+import { SessionStore } from "./sessions";
 
 describe("Conversational flow routing", () => {
   describe("discuss flows", () => {
@@ -238,6 +239,26 @@ describe("buildContextualPrompt", () => {
   });
 });
 
+describe("Conversation-aware repo resolution", () => {
+  it("derives lastRepo from recent task history", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check the roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "Here's the roadmap...");
+
+    const recent = queue.listByUser("telegram:U1", 1);
+    expect(recent.length).toBe(1);
+    expect(recent[0].repo).toBe("iris");
+  });
+});
+
 describe("Queue round-trip with taskType", () => {
   let queue: TaskQueue;
 
@@ -310,3 +331,108 @@ describe("Queue round-trip with taskType", () => {
     expect(task!.taskType).toBeNull();
   });
 });
+
+describe("Full follow-up conversation flow", () => {
+  it("follow-up message without repo uses last task's repo", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+    const sessions = new SessionStore(db);
+
+    // Simulate conversation: user talked about iris
+    sessions.addMessage("telegram:U1", "user", "check the roadmap on iris");
+    sessions.addMessage("telegram:U1", "assistant", "Here's the iris roadmap...");
+    sessions.addMessage("telegram:U1", "user", "what about tomorrow's plan");
+
+    // Simulate a completed task on iris
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check the roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "Here's the roadmap...");
+
+    // Now a follow-up: "what about tomorrow" — no repo mentioned
+    const parsed = parseMessage("what about tomorrow's plan");
+    expect(parsed.type).toBe("free-form");
+    expect(parsed.repo).toBeUndefined(); // Router can't find repo in text
+
+    // But the last task was on iris
+    const recentTasks = queue.listByUser("telegram:U1", 5);
+    const lastRepo = recentTasks.find(t => t.status === "completed" || t.status === "failed")?.repo;
+    expect(lastRepo).toBe("iris");
+
+    // And the conversation history mentions iris
+    const history = sessions.getHistory("telegram:U1", 6);
+    expect(history.some(m => m.content.includes("iris"))).toBe(true);
+  });
+
+  it("explicit repo in message overrides last task repo", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    // Last task was on iris
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "done");
+
+    // But new message explicitly says "on docs"
+    const parsed = parseMessage("check the tests on docs");
+    expect(parsed.repo).toBe("docs"); // Regex hint takes priority
+  });
+
+  it("lastRepo only considers completed/failed tasks, not pending", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    // Completed task on iris
+    const task1 = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check roadmap",
+    });
+    queue.dequeue();
+    queue.complete(task1, "done");
+
+    // Pending task on docs (enqueued but not completed)
+    queue.enqueue({
+      userId: "telegram:U1",
+      repo: "docs",
+      prompt: "pending work",
+    });
+
+    // lastRepo should be iris (completed), not docs (pending)
+    const recentTasks = queue.listByUser("telegram:U1", 5);
+    const lastRepo = recentTasks.find(t => t.status === "completed" || t.status === "failed")?.repo;
+    expect(lastRepo).toBe("iris");
+  });
+
+  it("LLM resolver prompt includes conversation history", () => {
+    const db = new Database(":memory:");
+    const sessions = new SessionStore(db);
+
+    sessions.addMessage("telegram:U1", "user", "check the roadmap on iris");
+    sessions.addMessage("telegram:U1", "assistant", "Here's the iris roadmap...");
+    sessions.addMessage("telegram:U1", "user", "what about tomorrow");
+
+    const history = sessions.getHistory("telegram:U1", 6);
+    const historyContext = history.length > 1
+      ? "Recent conversation:\n" + history.slice(0, -1).map(m => `${m.role}: ${m.content}`).join("\n") + "\n\n"
+      : "";
+    const resolvePrompt = `You are a repo-name resolver. ${historyContext}The user's latest message:\n"what about tomorrow"\n\nAvailable repos: iris, docs, my-app\n\nRespond with ONLY the repo name that best matches their request. Consider the conversation context if the current message doesn't mention a specific repo. Nothing else — just the exact repo name from the list. If you cannot determine which repo, respond with "UNKNOWN".`;
+
+    expect(resolvePrompt).toContain("Recent conversation:");
+    expect(resolvePrompt).toContain("check the roadmap on iris");
+    expect(resolvePrompt).toContain("Here's the iris roadmap");
+    expect(resolvePrompt).toContain("what about tomorrow");
+    expect(resolvePrompt).toContain("iris, docs, my-app");
+    expect(resolvePrompt).toContain("Consider the conversation context");
+  });
+});