@lovenyberg/ove 0.2.1 → 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,17 +122,42 @@ 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;
   }
 
-  private rowToTask(row: any): Task {
+  listActive(limit: number = 20): Task[] {
+    const rows = this.db
+      .query(
+        `SELECT * FROM tasks WHERE status IN ('running', 'pending') ORDER BY created_at ASC LIMIT ?`
+      )
+      .all(limit) as TaskRow[];
+    return rows.map((r) => this.rowToTask(r));
+  }
+
+  cancel(id: string): boolean {
+    const result = this.db.run(
+      `UPDATE tasks SET status = 'failed', result = 'Cancelled', completed_at = ? WHERE id = ? AND status IN ('running', 'pending')`,
+      [new Date().toISOString(), id]
+    );
+    return result.changes > 0;
+  }
+
+  resetStale(): number {
+    const result = this.db.run(
+      `UPDATE tasks SET status = 'failed', result = 'Interrupted — process restarted', completed_at = ? WHERE status = 'running'`,
+      [new Date().toISOString()]
+    );
+    return result.changes;
+  }
+
+  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.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { RepoRegistry, parseGhRepoLine } from "./repo-registry";
+
+describe("RepoRegistry", () => {
+  let db: Database;
+  let registry: RepoRegistry;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    registry = new RepoRegistry(db);
+  });
+
+  it("creates repos table on construction", () => {
+    const tables = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='repos'").all();
+    expect(tables.length).toBe(1);
+  });
+
+  it("upserts and retrieves a repo", () => {
+    registry.upsert({
+      name: "my-app",
+      url: "git@github.com:user/my-app.git",
+      owner: "user",
+      defaultBranch: "main",
+      source: "github-sync",
+    });
+    const repo = registry.getByName("my-app");
+    expect(repo).not.toBeNull();
+    expect(repo!.url).toBe("git@github.com:user/my-app.git");
+    expect(repo!.source).toBe("github-sync");
+  });
+
+  it("upsert updates existing repo", () => {
+    registry.upsert({ name: "my-app", url: "old-url", source: "config" });
+    registry.upsert({ name: "my-app", url: "new-url", source: "github-sync" });
+    const repo = registry.getByName("my-app");
+    expect(repo!.url).toBe("new-url");
+  });
+
+  it("returns null for unknown repo", () => {
+    expect(registry.getByName("nope")).toBeNull();
+  });
+
+  it("lists all non-excluded repos", () => {
+    registry.upsert({ name: "a", url: "u1", source: "github-sync" });
+    registry.upsert({ name: "b", url: "u2", source: "github-sync" });
+    registry.upsert({ name: "c", url: "u3", source: "github-sync", excluded: true });
+    const all = registry.getAll();
+    expect(all.length).toBe(2);
+    expect(all.map(r => r.name).sort()).toEqual(["a", "b"]);
+  });
+
+  it("lists all repo names", () => {
+    registry.upsert({ name: "x", url: "u1", source: "config" });
+    registry.upsert({ name: "y", url: "u2", source: "github-sync" });
+    const names = registry.getAllNames();
+    expect(names.sort()).toEqual(["x", "y"]);
+  });
+
+  it("excludes a repo", () => {
+    registry.upsert({ name: "old", url: "u", source: "github-sync" });
+    registry.setExcluded("old", true);
+    expect(registry.getAll().length).toBe(0);
+    expect(registry.getByName("old")!.excluded).toBe(true);
+  });
+
+  it("migrates config repos", () => {
+    const configRepos = {
+      "my-app": { url: "git@github.com:user/my-app.git", defaultBranch: "main" },
+      "infra": { url: "git@github.com:user/infra.git", defaultBranch: "develop" },
+    };
+    registry.migrateFromConfig(configRepos);
+    expect(registry.getAll().length).toBe(2);
+    const infra = registry.getByName("infra");
+    expect(infra!.defaultBranch).toBe("develop");
+    expect(infra!.source).toBe("config");
+  });
+
+  it("migration does not overwrite github-sync repos", () => {
+    registry.upsert({ name: "my-app", url: "gh-url", source: "github-sync", defaultBranch: "main" });
+    registry.migrateFromConfig({
+      "my-app": { url: "config-url", defaultBranch: "main" },
+    });
+    expect(registry.getByName("my-app")!.url).toBe("gh-url");
+  });
+});
+
+describe("parseGhRepoLine", () => {
+  it("parses standard gh repo list output", () => {
+    const result = parseGhRepoLine("jacksoncage/ove\tMy app\tpublic\t2026-02-20T10:00:00Z");
+    expect(result).toEqual({ name: "ove", owner: "jacksoncage", fullName: "jacksoncage/ove" });
+  });
+
+  it("parses line with no description", () => {
+    const result = parseGhRepoLine("org/repo-name\t\tprivate\t2026-01-01T00:00:00Z");
+    expect(result).toEqual({ name: "repo-name", owner: "org", fullName: "org/repo-name" });
+  });
+
+  it("returns null for empty line", () => {
+    expect(parseGhRepoLine("")).toBeNull();
+  });
+
+  it("returns null for line without slash", () => {
+    expect(parseGhRepoLine("no-slash-here")).toBeNull();
+  });
+});
+
+describe("config + registry integration", () => {
+  it("config repos + registry merge correctly", () => {
+    const db = new Database(":memory:");
+    const registry = new RepoRegistry(db);
+
+    // Simulate GitHub sync adding repos
+    registry.upsert({ name: "api", url: "git@github.com:org/api.git", owner: "org", source: "github-sync" });
+    registry.upsert({ name: "web", url: "git@github.com:org/web.git", owner: "org", source: "github-sync" });
+
+    // Simulate config migration (manual repo)
+    registry.migrateFromConfig({
+      "legacy": { url: "git@github.com:me/legacy.git", defaultBranch: "develop" },
+    });
+
+    // All three repos exist
+    expect(registry.getAllNames().sort()).toEqual(["api", "legacy", "web"]);
+
+    // Excluding a repo hides it from getAll but not getByName
+    registry.setExcluded("legacy", true);
+    expect(registry.getAllNames().sort()).toEqual(["api", "web"]);
+    expect(registry.getByName("legacy")).not.toBeNull();
+  });
+});

package/src/repo-registry.ts

@@ -0,0 +1,201 @@
+import { Database } from "bun:sqlite";
+import { logger } from "./logger";
+
+export interface RepoRecord {
+  name: string;
+  url: string;
+  owner: string | null;
+  defaultBranch: string;
+  source: string;
+  excluded: boolean;
+  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;
+  owner?: string;
+  defaultBranch?: string;
+  source: string;
+  excluded?: boolean;
+}
+
+export class RepoRegistry {
+  private db: Database;
+
+  constructor(db: Database) {
+    this.db = db;
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS repos (
+        name TEXT PRIMARY KEY,
+        url TEXT NOT NULL,
+        owner TEXT,
+        default_branch TEXT DEFAULT 'main',
+        source TEXT NOT NULL,
+        excluded INTEGER DEFAULT 0,
+        last_synced_at TEXT
+      )
+    `);
+  }
+
+  upsert(input: RepoUpsertInput): void {
+    this.db.run(
+      `INSERT INTO repos (name, url, owner, default_branch, source, excluded, last_synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(name) DO UPDATE SET
+         url = excluded.url,
+         owner = excluded.owner,
+         default_branch = excluded.default_branch,
+         source = excluded.source,
+         excluded = excluded.excluded,
+         last_synced_at = excluded.last_synced_at`,
+      [
+        input.name,
+        input.url,
+        input.owner || null,
+        input.defaultBranch || "main",
+        input.source,
+        input.excluded ? 1 : 0,
+        new Date().toISOString(),
+      ]
+    );
+  }
+
+  getByName(name: string): RepoRecord | null {
+    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 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 { name: string }[];
+    return rows.map(r => r.name);
+  }
+
+  setExcluded(name: string, excluded: boolean): void {
+    this.db.run(`UPDATE repos SET excluded = ? WHERE name = ?`, [excluded ? 1 : 0, name]);
+  }
+
+  migrateFromConfig(configRepos: Record<string, { url: string; defaultBranch?: string }>): void {
+    for (const [name, repo] of Object.entries(configRepos)) {
+      const existing = this.getByName(name);
+      if (existing && existing.source === "github-sync") continue;
+
+      this.upsert({
+        name,
+        url: repo.url,
+        defaultBranch: repo.defaultBranch || "main",
+        source: "config",
+      });
+    }
+  }
+
+  private rowToRecord(row: RepoRow): RepoRecord {
+    return {
+      name: row.name,
+      url: row.url,
+      owner: row.owner,
+      defaultBranch: row.default_branch,
+      source: row.source,
+      excluded: row.excluded === 1,
+      lastSyncedAt: row.last_synced_at,
+    };
+  }
+}
+
+export interface GhRepoParsed {
+  name: string;
+  owner: string;
+  fullName: string;
+}
+
+export function parseGhRepoLine(line: string): GhRepoParsed | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  // gh repo list output: owner/name\tdescription\tvisibility\tupdated_at
+  const fullName = trimmed.split("\t")[0];
+  if (!fullName || !fullName.includes("/")) return null;
+  const [owner, ...rest] = fullName.split("/");
+  const name = rest.join("/"); // handle potential edge cases
+  return { name, owner, fullName };
+}
+
+interface GhRepoResponse {
+  name: string;
+  owner?: { login: string };
+  defaultBranchRef?: { name: string };
+  isArchived: boolean;
+}
+
+export async function syncGitHub(
+  registry: RepoRegistry,
+  orgs?: string[]
+): Promise<number> {
+  let count = 0;
+  const targets = orgs && orgs.length > 0 ? orgs : [undefined];
+
+  for (const org of targets) {
+    try {
+      const args = ["repo", "list", "--json", "name,owner,defaultBranchRef,isArchived", "--limit", "500"];
+      if (org) args.splice(2, 0, org);
+
+      const proc = Bun.spawn(["gh", ...args], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+
+      if (exitCode !== 0) {
+        const stderr = await new Response(proc.stderr).text();
+        logger.warn("gh repo list failed", { org, error: stderr.slice(0, 200) });
+        continue;
+      }
+
+      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;
+      }
+
+      for (const repo of repos) {
+        if (repo.isArchived) continue;
+        const owner = repo.owner?.login || org || "";
+        const name = repo.name;
+        const defaultBranch = repo.defaultBranchRef?.name || "main";
+
+        registry.upsert({
+          name,
+          url: `git@github.com:${owner}/${name}.git`,
+          owner,
+          defaultBranch,
+          source: "github-sync",
+        });
+        count++;
+      }
+    } catch (err) {
+      logger.warn("github sync error", { org, error: String(err) });
+    }
+  }
+
+  logger.info("github sync complete", { repos: count });
+  return count;
+}

package/src/repos.ts

@@ -1,6 +1,12 @@
 import { join, resolve } from "node:path";
 import { logger } from "./logger";
 
+const GIT_TIMEOUT = 60_000; // 60 seconds
+const GIT_ENV = {
+  ...process.env,
+  GIT_SSH_COMMAND: "ssh -o ConnectTimeout=10 -o BatchMode=yes",
+};
+
 export class RepoManager {
   constructor(private reposDir: string) {}
 
@@ -23,10 +29,14 @@ export class RepoManager {
     const proc = Bun.spawn(["git", "clone", url, path], {
       stdout: "pipe",
       stderr: "pipe",
+      env: GIT_ENV,
     });
-    const exitCode = await proc.exited;
+    const exitCode = await Promise.race([
+      proc.exited,
+      Bun.sleep(GIT_TIMEOUT).then(() => { proc.kill(); return -1; }),
+    ]);
     if (exitCode !== 0) {
-      const stderr = await new Response(proc.stderr).text();
+      const stderr = exitCode === -1 ? "git clone timed out" : await new Response(proc.stderr).text();
       throw new Error(`git clone failed: ${stderr}`);
     }
   }
@@ -38,11 +48,15 @@ export class RepoManager {
       cwd: path,
       stdout: "pipe",
       stderr: "pipe",
+      env: GIT_ENV,
     });
-    const exitCode = await proc.exited;
+    const exitCode = await Promise.race([
+      proc.exited,
+      Bun.sleep(GIT_TIMEOUT).then(() => { proc.kill(); return -1; }),
+    ]);
     if (exitCode !== 0) {
-      const stderr = await new Response(proc.stderr).text();
-      logger.warn("git pull failed", { repo: repoName, error: stderr });
+      const msg = exitCode === -1 ? "git pull timed out" : await new Response(proc.stderr).text();
+      logger.warn("git pull failed", { repo: repoName, error: msg });
     }
   }
 

package/src/router.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "bun:test";
-import { parseMessage, buildPrompt } from "./router";
+import { parseMessage, buildPrompt, buildCronPrompt } from "./router";
 
 describe("parseMessage", () => {
   it("parses PR review command", () => {
@@ -124,6 +124,29 @@ describe("parseMessage", () => {
     expect(result.args.scheduleId).toBe(1);
   });
 
+  it("parses 'every 30 min' as schedule", () => {
+    const result = parseMessage("simplify code and create a PR every 30 min on infra-salming-ai");
+    expect(result.type).toBe("schedule");
+    expect(result.repo).toBe("infra-salming-ai");
+  });
+
+  it("parses 'every 2 hours' as schedule", () => {
+    const result = parseMessage("run tests every 2 hours on my-app");
+    expect(result.type).toBe("schedule");
+    expect(result.repo).toBe("my-app");
+  });
+
+  it("parses 'every hour' as schedule", () => {
+    const result = parseMessage("check for updates every hour");
+    expect(result.type).toBe("schedule");
+  });
+
+  it("parses 'every 15 minutes' as schedule", () => {
+    const result = parseMessage("deploy every 15 minutes on staging");
+    expect(result.type).toBe("schedule");
+    expect(result.repo).toBe("staging");
+  });
+
   it("parses init repo with SSH URL", () => {
     const result = parseMessage("init repo my-app git@github.com:user/my-app.git");
     expect(result.type).toBe("init-repo");
@@ -149,6 +172,88 @@ describe("parseMessage", () => {
     expect(result.type).not.toBe("init-repo");
   });
 
+  it("parses Telegram /start as help", () => {
+    const result = parseMessage("/start");
+    expect(result.type).toBe("help");
+  });
+
+  it("parses Telegram /help as help", () => {
+    const result = parseMessage("/help");
+    expect(result.type).toBe("help");
+  });
+
+  it("parses Telegram /status as status", () => {
+    const result = parseMessage("/status");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses Telegram /history as history", () => {
+    const result = parseMessage("/history");
+    expect(result.type).toBe("history");
+  });
+
+  it("parses Telegram /clear as clear", () => {
+    const result = parseMessage("/clear");
+    expect(result.type).toBe("clear");
+  });
+
+  // Natural language status inquiries
+  it("parses 'how's it going?' as status", () => {
+    const result = parseMessage("how's it going?");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'any updates?' as status", () => {
+    const result = parseMessage("any updates?");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'are you done?' as status", () => {
+    const result = parseMessage("are you done?");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'how dose it the work go?' as status", () => {
+    const result = parseMessage("how dose it the work go?");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'how is the work going' as status", () => {
+    const result = parseMessage("how is the work going");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'what's the progress' as status", () => {
+    const result = parseMessage("what's the progress");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'done yet?' as status", () => {
+    const result = parseMessage("done yet?");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'how far along are you' as status", () => {
+    const result = parseMessage("how far along are you");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'is it done' as status", () => {
+    const result = parseMessage("is it done");
+    expect(result.type).toBe("status");
+  });
+
+  it("parses 'progress?' as status", () => {
+    const result = parseMessage("progress?");
+    expect(result.type).toBe("status");
+  });
+
+  it("does NOT parse work requests as status", () => {
+    expect(parseMessage("update the progress bar on my-app").type).toBe("free-form");
+    expect(parseMessage("fix the status page in my-app").type).toBe("free-form");
+    expect(parseMessage("add a progress indicator on my-app").type).toBe("free-form");
+  });
+
   it("falls back to free-form for unrecognized input", () => {
     const result = parseMessage("what does the auth middleware do in my-app");
     expect(result.type).toBe("free-form");
@@ -190,3 +295,22 @@ describe("buildPrompt", () => {
     expect(prompt).toBe("explain the auth flow");
   });
 });
+
+describe("buildCronPrompt", () => {
+  it("wraps prompt with autonomy instructions", () => {
+    const prompt = buildCronPrompt("simplify code and create a PR");
+    expect(prompt).toContain("simplify code and create a PR");
+    expect(prompt).toContain("autonomous");
+  });
+
+  it("instructs not to ask questions", () => {
+    const prompt = buildCronPrompt("run tests");
+    expect(prompt).toMatch(/do not ask|never ask|don't ask/i);
+  });
+
+  it("includes the original prompt verbatim", () => {
+    const original = "check for security vulnerabilities and fix them";
+    const prompt = buildCronPrompt(original);
+    expect(prompt).toContain(original);
+  });
+});