@lovenyberg/ove 0.2.2 → 0.3.0

package/src/queue.ts

@@ -19,6 +19,18 @@ export interface Task {
   completedAt: string | null;
 }
 
+interface TaskRow {
+  id: string;
+  user_id: string;
+  repo: string;
+  prompt: string;
+  status: string;
+  result: string | null;
+  task_type: string | null;
+  created_at: string;
+  completed_at: string | null;
+}
+
 export class TaskQueue {
   private db: Database;
 
@@ -38,10 +50,9 @@ export class TaskQueue {
       )
     `);
     // Migration: add task_type column if missing (backward compat)
-    try {
-      this.db.run(`ALTER TABLE tasks ADD COLUMN task_type TEXT`);
-    } catch {
-      // Column already exists
+    const columns = this.db.query("PRAGMA table_info(tasks)").all() as { name: string }[];
+    if (!columns.some(c => c.name === "task_type")) {
+      this.db.run("ALTER TABLE tasks ADD COLUMN task_type TEXT");
     }
   }
 
@@ -64,7 +75,7 @@ export class TaskQueue {
          ORDER BY created_at ASC
          LIMIT 1`
       )
-      .get() as any;
+      .get() as TaskRow;
 
     if (!row) return null;
 
@@ -88,7 +99,7 @@ export class TaskQueue {
   }
 
   get(id: string): Task | null {
-    const row = this.db.query(`SELECT * FROM tasks WHERE id = ?`).get(id) as any;
+    const row = this.db.query(`SELECT * FROM tasks WHERE id = ?`).get(id) as TaskRow;
     return row ? this.rowToTask(row) : null;
   }
 
@@ -97,7 +108,7 @@ export class TaskQueue {
       .query(
         `SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at DESC LIMIT ?`
       )
-      .all(userId, limit) as any[];
+      .all(userId, limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
   }
 
@@ -111,7 +122,7 @@ export class TaskQueue {
           COUNT(*) FILTER (WHERE status = 'failed') as failed
         FROM tasks`
       )
-      .get() as any;
+      .get() as { pending: number; running: number; completed: number; failed: number };
     return row;
   }
 
@@ -120,7 +131,7 @@ export class TaskQueue {
       .query(
         `SELECT * FROM tasks WHERE status IN ('running', 'pending') ORDER BY created_at ASC LIMIT ?`
       )
-      .all(limit) as any[];
+      .all(limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
   }
 
@@ -140,13 +151,13 @@ export class TaskQueue {
     return result.changes;
   }
 
-  private rowToTask(row: any): Task {
+  private rowToTask(row: TaskRow): Task {
     return {
       id: row.id,
       userId: row.user_id,
       repo: row.repo,
       prompt: row.prompt,
-      status: row.status,
+      status: row.status as "pending" | "running" | "completed" | "failed",
       result: row.result,
       taskType: row.task_type || null,
       createdAt: row.created_at,

package/src/repo-registry.ts

@@ -11,6 +11,16 @@ export interface RepoRecord {
   lastSyncedAt: string | null;
 }
 
+interface RepoRow {
+  name: string;
+  url: string;
+  owner: string | null;
+  default_branch: string;
+  source: string;
+  excluded: number;
+  last_synced_at: string | null;
+}
+
 export interface RepoUpsertInput {
   name: string;
   url: string;
@@ -62,17 +72,17 @@ export class RepoRegistry {
   }
 
   getByName(name: string): RepoRecord | null {
-    const row = this.db.query(`SELECT * FROM repos WHERE name = ?`).get(name) as any;
+    const row = this.db.query(`SELECT * FROM repos WHERE name = ?`).get(name) as RepoRow;
     return row ? this.rowToRecord(row) : null;
   }
 
   getAll(): RepoRecord[] {
-    const rows = this.db.query(`SELECT * FROM repos WHERE excluded = 0 ORDER BY name`).all() as any[];
+    const rows = this.db.query(`SELECT * FROM repos WHERE excluded = 0 ORDER BY name`).all() as RepoRow[];
     return rows.map(r => this.rowToRecord(r));
   }
 
   getAllNames(): string[] {
-    const rows = this.db.query(`SELECT name FROM repos WHERE excluded = 0 ORDER BY name`).all() as any[];
+    const rows = this.db.query(`SELECT name FROM repos WHERE excluded = 0 ORDER BY name`).all() as { name: string }[];
     return rows.map(r => r.name);
   }
 
@@ -94,7 +104,7 @@ export class RepoRegistry {
     }
   }
 
-  private rowToRecord(row: any): RepoRecord {
+  private rowToRecord(row: RepoRow): RepoRecord {
     return {
       name: row.name,
       url: row.url,
@@ -124,6 +134,13 @@ export function parseGhRepoLine(line: string): GhRepoParsed | null {
   return { name, owner, fullName };
 }
 
+interface GhRepoResponse {
+  name: string;
+  owner?: { login: string };
+  defaultBranchRef?: { name: string };
+  isArchived: boolean;
+}
+
 export async function syncGitHub(
   registry: RepoRegistry,
   orgs?: string[]
@@ -150,10 +167,11 @@ export async function syncGitHub(
         continue;
       }
 
-      let repos: any[];
+      let repos: GhRepoResponse[];
       try {
         repos = JSON.parse(output);
       } catch {
+        // JSON parsing failed — log and skip this org
         logger.warn("gh repo list returned invalid JSON", { org });
         continue;
       }

package/src/runners/claude.ts

@@ -88,7 +88,9 @@ export class ClaudeRunner implements AgentRunner {
                 }
               }
             }
-          } catch {}
+          } catch {
+            // Non-JSON line in stream output — skip
+          }
         }
       }
     } finally {

package/src/runners/codex.ts

@@ -116,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;
+    },
+  };
+}