@lovenyberg/ove 0.2.1 → 0.3.0

package/src/router.ts

@@ -13,7 +13,9 @@ export type MessageType =
   | "clear"
   | "schedule"
   | "list-schedules"
-  | "remove-schedule";
+  | "remove-schedule"
+  | "list-tasks"
+  | "cancel-task";
 
 export interface ParsedMessage {
   type: MessageType;
@@ -26,11 +28,26 @@ export function parseMessage(text: string): ParsedMessage {
   const trimmed = text.trim();
   const lower = trimmed.toLowerCase();
 
+  // Handle Telegram /commands — strip leading slash
+  if (lower === "/start") return { type: "help", args: {}, rawText: trimmed };
+  if (lower === "/help") return { type: "help", args: {}, rawText: trimmed };
+  if (lower === "/status") return { type: "status", args: {}, rawText: trimmed };
+  if (lower === "/history") return { type: "history", args: {}, rawText: trimmed };
+  if (lower === "/clear") return { type: "clear", args: {}, rawText: trimmed };
+
   if (lower === "status") return { type: "status", args: {}, rawText: trimmed };
   if (lower === "history" || lower === "my tasks") return { type: "history", args: {}, rawText: trimmed };
   if (lower === "help") return { type: "help", args: {}, rawText: trimmed };
   if (lower === "clear" || lower === "reset") return { type: "clear", args: {}, rawText: trimmed };
 
+  // Task management
+  if (lower === "tasks" || lower === "/tasks") return { type: "list-tasks", args: {}, rawText: trimmed };
+  const cancelMatch = trimmed.match(/^(?:\/)?cancel\s+(\S+)$/i);
+  if (cancelMatch) return { type: "cancel-task", args: { taskId: cancelMatch[1] }, rawText: trimmed };
+
+  // Natural language status inquiries — short messages asking about progress
+  if (isStatusInquiry(lower)) return { type: "status", args: {}, rawText: trimmed };
+
   const prMatch = trimmed.match(/review\s+pr\s+#?(\d+)\s+(?:on|in)\s+(\S+)/i);
   if (prMatch) {
     return { type: "review-pr", repo: prMatch[2], args: { prNumber: parseInt(prMatch[1]) }, rawText: trimmed };
@@ -70,7 +87,7 @@ export function parseMessage(text: string): ParsedMessage {
   }
 
   // Schedule creation — detect natural language scheduling intent
-  if (/\b(?:every\s+(?:day|week|month|monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekday|morning|evening)|each\s+(?:day|week|weekday)|daily|weekly|monthly)\b/i.test(lower) ||
+  if (/\b(?:every\s+(?:day|week|month|monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekday|morning|evening|hour|(?:\d+\s+)?(?:min(?:ute)?s?|hours?))|each\s+(?:day|week|weekday)|daily|weekly|monthly)\b/i.test(lower) ||
       /\b(?:at\s+\d{1,2}(?::\d{2})?)\b.*\b(?:every|each|daily|weekly)\b/i.test(lower)) {
     const repoHint = trimmed.match(/(?:in|on)\s+(\S+)\s*$/i);
     return { type: "schedule", repo: repoHint?.[1], args: {}, rawText: trimmed };
@@ -95,10 +112,36 @@ export function parseMessage(text: string): ParsedMessage {
     };
   }
 
-  const repoHint = trimmed.match(/(?:in|on)\s+(\S+)\s*$/i);
+  const repoHint = trimmed.match(/(?:in|on)\s+(\S+?)[?.!,]*\s*$/i);
   return { type: "free-form", repo: repoHint?.[1], args: {}, rawText: trimmed };
 }
 
+// Detect natural language status/progress inquiries.
+// Only matches short, question-like messages — not work requests that happen
+// to contain words like "progress" or "status" (e.g. "fix the status page").
+const STATUS_PATTERNS = [
+  /^(?:how.s it going|how.?s .* going)/,       // how's it going, how is the work going
+  /^(?:any )?update[s]?\??$/,                   // updates?, any updates?
+  /^(?:are you |you |is it )done/,              // are you done?, is it done
+  /^done\s*(?:yet)?\??$/,                       // done?, done yet?
+  /^(?:what.s the |what is the )?progress\??$/,  // progress?, what's the progress
+  /^how (?:far|much)/,                          // how far along, how much left
+  /^(?:how.s|what.s|how is) (?:the )?(?:progress|status|work)/,  // how's the progress/status/work
+  /^(?:is it |are you )(?:still )?(?:working|running|busy)/,     // is it still running
+  /^(?:how do(?:se|es)? (?:it )?(?:the )?work go|how (?:do(?:se|es)? )?(?:the )?work go)/, // how does the work go (typo-tolerant)
+  /^(?:eta|when (?:will|are) (?:you|it) (?:be )?done)/,          // eta, when will you be done
+];
+
+function isStatusInquiry(lower: string): boolean {
+  // Only consider short messages (< 60 chars) to avoid matching work requests
+  if (lower.length > 60) return false;
+  return STATUS_PATTERNS.some((p) => p.test(lower));
+}
+
+export function buildCronPrompt(prompt: string): string {
+  return `This is an autonomous scheduled task. Do not ask questions — make your own decisions and proceed with the work. If there are multiple options, pick the best one and go.\n\n${prompt}`;
+}
+
 export function buildContextualPrompt(
   parsed: ParsedMessage,
   history: { role: string; content: string }[],

package/src/runner.ts

@@ -2,6 +2,7 @@ export interface RunOptions {
   maxTurns: number;
   mcpConfigPath?: string;
   model?: string;
+  signal?: AbortSignal;
 }
 
 export interface RunResult {

package/src/runners/claude.ts

@@ -53,6 +53,10 @@ export class ClaudeRunner implements AgentRunner {
       env: { ...process.env, CI: "1" },
     });
 
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", () => proc.kill(), { once: true });
+    }
+
     let resultText: string | null = null;
     let lastTextBlock: string | null = null;
     const decoder = new TextDecoder();
@@ -84,7 +88,9 @@ export class ClaudeRunner implements AgentRunner {
                 }
               }
             }
-          } catch {}
+          } catch {
+            // Non-JSON line in stream output — skip
+          }
         }
       }
     } finally {

package/src/runners/codex.ts

@@ -79,6 +79,10 @@ export class CodexRunner implements AgentRunner {
       stderr: "pipe",
     });
 
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", () => proc.kill(), { once: true });
+    }
+
     let lastAgentMessage: string | null = null;
     let errorMessage: string | null = null;
     const decoder = new TextDecoder();
@@ -112,7 +116,9 @@ export class CodexRunner implements AgentRunner {
             if (event.type === "turn.failed") {
               errorMessage = event.error?.message || "Turn failed";
             }
-          } catch {}
+          } catch {
+            // Non-JSON line in stream output — skip
+          }
         }
       }
     } finally {

package/src/schedules.ts

@@ -1,5 +1,15 @@
 import { Database } from "bun:sqlite";
 
+interface ScheduleRow {
+  id: number;
+  user_id: string;
+  repo: string;
+  prompt: string;
+  schedule: string;
+  description: string | null;
+  created_at: string;
+}
+
 export interface Schedule {
   id: number;
   userId: string;
@@ -45,7 +55,7 @@ export class ScheduleStore {
   }
 
   listByUser(userId: string): Schedule[] {
-    return (this.db.query(`SELECT * FROM schedules WHERE user_id = ? ORDER BY id`).all(userId) as any[])
+    return (this.db.query(`SELECT * FROM schedules WHERE user_id = ? ORDER BY id`).all(userId) as ScheduleRow[])
       .map(this.rowToSchedule);
   }
 
@@ -55,11 +65,11 @@ export class ScheduleStore {
   }
 
   getAll(): Schedule[] {
-    return (this.db.query(`SELECT * FROM schedules ORDER BY id`).all() as any[])
+    return (this.db.query(`SELECT * FROM schedules ORDER BY id`).all() as ScheduleRow[])
       .map(this.rowToSchedule);
   }
 
-  private rowToSchedule(row: any): Schedule {
+  private rowToSchedule(row: ScheduleRow): Schedule {
     return {
       id: row.id,
       userId: row.user_id,

package/src/sessions.ts

@@ -6,6 +6,12 @@ export interface ChatMessage {
   timestamp: string;
 }
 
+interface ChatMessageRow {
+  role: string;
+  content: string;
+  created_at: string;
+}
+
 export class SessionStore {
   private db: Database;
 
@@ -38,12 +44,12 @@ export class SessionStore {
          ORDER BY id DESC
          LIMIT ?`
       )
-      .all(userId, limit) as any[];
+      .all(userId, limit) as ChatMessageRow[];
 
     return rows
       .reverse()
       .map((r) => ({
-        role: r.role,
+        role: r.role as "user" | "assistant",
         content: r.content,
         timestamp: r.created_at,
       }));

package/src/worker.ts

@@ -0,0 +1,173 @@
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { unlink } from "node:fs/promises";
+import { logger } from "./logger";
+import { splitAndReply } from "./handlers";
+import type { Config } from "./config";
+import type { TaskQueue, Task } from "./queue";
+import type { RepoManager } from "./repos";
+import type { SessionStore } from "./sessions";
+import type { IncomingMessage, EventAdapter, IncomingEvent } from "./adapters/types";
+import type { AgentRunner, RunOptions, StatusEvent } from "./runner";
+
+export interface WorkerDeps {
+  config: Config;
+  queue: TaskQueue;
+  repos: RepoManager;
+  sessions: SessionStore;
+  pendingReplies: Map<string, IncomingMessage>;
+  pendingEventReplies: Map<string, { adapter: EventAdapter; event: IncomingEvent }>;
+  runningProcesses: Map<string, { abort: AbortController; task: Task }>;
+  getRunnerForRepo: (repo: string) => AgentRunner;
+  getRunnerOptsForRepo: (repo: string, baseOpts: RunOptions) => RunOptions;
+  getRepoInfo: (repoName: string) => { url: string; defaultBranch: string } | null;
+}
+
+async function processTask(task: Task, deps: WorkerDeps) {
+  const isCreateProject = task.taskType === "create-project";
+  const repoInfo = isCreateProject ? null : deps.getRepoInfo(task.repo);
+
+  if (!isCreateProject && !repoInfo) {
+    deps.queue.fail(task.id, `Unknown repo: ${task.repo}`);
+    return;
+  }
+
+  const abortController = new AbortController();
+  deps.runningProcesses.set(task.id, { abort: abortController, task });
+
+  const originalMsg = deps.pendingReplies.get(task.id);
+  const statusLog: string[] = [];
+
+  try {
+    await originalMsg?.updateStatus(`Working on it...`);
+
+    let workDir: string;
+
+    if (isCreateProject) {
+      workDir = join(deps.config.reposDir, task.repo);
+      await Bun.write(join(workDir, ".gitkeep"), "");
+    } else {
+      await deps.repos.cloneIfNeeded(task.repo, repoInfo!.url);
+      await deps.repos.pull(task.repo, repoInfo!.defaultBranch);
+
+      workDir = await deps.repos.createWorktree(
+        task.repo,
+        task.id,
+        repoInfo!.defaultBranch
+      );
+    }
+
+    try {
+      let mcpConfigPath: string | undefined;
+      if (deps.config.mcpServers && Object.keys(deps.config.mcpServers).length > 0) {
+        mcpConfigPath = join(tmpdir(), `mcp-${task.id}.json`);
+        await Bun.write(mcpConfigPath, JSON.stringify({ mcpServers: deps.config.mcpServers }));
+      }
+
+      const taskRunner = deps.getRunnerForRepo(task.repo);
+      const runOpts = deps.getRunnerOptsForRepo(task.repo, {
+        maxTurns: deps.config.claude.maxTurns,
+        mcpConfigPath,
+        signal: abortController.signal,
+      });
+
+      const result = await taskRunner.run(
+        task.prompt,
+        workDir,
+        runOpts,
+        (event: StatusEvent) => {
+          if (event.kind === "tool") {
+            const last = statusLog[statusLog.length - 1];
+            const summary = `Using ${event.tool}...`;
+            if (last !== summary) statusLog.push(summary);
+          } else {
+            statusLog.push(event.text.slice(0, 200));
+          }
+          originalMsg?.updateStatus(statusLog.slice(-5).join("\n"));
+        }
+      );
+
+      if (mcpConfigPath) {
+        try {
+          await unlink(mcpConfigPath);
+        } catch (err) {
+          logger.debug("failed to clean up mcp config", { error: String(err) });
+        }
+      }
+
+      if (result.success) {
+        deps.queue.complete(task.id, result.output);
+        logger.info("task completed", { taskId: task.id, durationMs: result.durationMs });
+
+        const platform = originalMsg?.platform || "slack";
+        const parts = splitAndReply(result.output, platform);
+        for (const part of parts) {
+          await originalMsg?.reply(part);
+        }
+        deps.sessions.addMessage(task.userId, "assistant", result.output.slice(0, 500));
+
+        const eventReply = deps.pendingEventReplies.get(task.id);
+        if (eventReply) {
+          await eventReply.adapter.respondToEvent(eventReply.event.eventId, result.output);
+          deps.pendingEventReplies.delete(task.id);
+        }
+      } else {
+        deps.queue.fail(task.id, result.output);
+        logger.error("task failed", { taskId: task.id });
+        await originalMsg?.reply(`Task failed: ${result.output.slice(0, 500)}`);
+        deps.sessions.addMessage(task.userId, "assistant", `Task failed: ${result.output.slice(0, 200)}`);
+
+        const eventReply = deps.pendingEventReplies.get(task.id);
+        if (eventReply) {
+          await eventReply.adapter.respondToEvent(eventReply.event.eventId, `Task failed: ${result.output.slice(0, 500)}`);
+          deps.pendingEventReplies.delete(task.id);
+        }
+      }
+    } finally {
+      if (!isCreateProject) {
+        await deps.repos.removeWorktree(task.repo, task.id).catch(() => {});
+      }
+    }
+  } catch (err) {
+    deps.queue.fail(task.id, String(err));
+    logger.error("task processing error", { taskId: task.id, error: String(err) });
+    await originalMsg?.reply(`Task error: ${String(err).slice(0, 500)}`);
+  } finally {
+    deps.runningProcesses.delete(task.id);
+    deps.pendingReplies.delete(task.id);
+  }
+}
+
+export function createWorker(deps: WorkerDeps): { start: () => void; cancel: (id: string) => boolean } {
+  async function workerLoop() {
+    const maxConcurrent = 5;
+
+    while (true) {
+      if (deps.runningProcesses.size < maxConcurrent) {
+        try {
+          const task = deps.queue.dequeue();
+          if (task) {
+            processTask(task, deps).catch((err) =>
+              logger.error("worker task error", { taskId: task.id, error: String(err) })
+            );
+            continue;
+          }
+        } catch (err) {
+          logger.error("worker loop error", { error: String(err) });
+        }
+      }
+      await Bun.sleep(2000);
+    }
+  }
+
+  return {
+    start: () => { workerLoop(); },
+    cancel: (id: string) => {
+      const entry = deps.runningProcesses.get(id);
+      if (!entry) return false;
+      entry.abort.abort();
+      deps.queue.cancel(entry.task.id);
+      return true;
+    },
+  };
+}