@lovenyberg/ove 0.7.0 → 0.9.0

package/src/queue.test.ts

@@ -110,4 +110,178 @@ describe("TaskQueue", () => {
     const task = queue.dequeue();
     expect(task!.taskType).toBe("discuss");
   });
+
+  it("default priority is 0", () => {
+    const id = queue.enqueue({
+      userId: "slack:U123",
+      repo: "my-app",
+      prompt: "normal task",
+    });
+    const task = queue.get(id);
+    expect(task!.priority).toBe(0);
+  });
+
+  it("stores and retrieves priority", () => {
+    const id = queue.enqueue({
+      userId: "slack:U123",
+      repo: "my-app",
+      prompt: "urgent task",
+      priority: 2,
+    });
+    const task = queue.get(id);
+    expect(task!.priority).toBe(2);
+  });
+
+  it("preserves priority through dequeue", () => {
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "my-app",
+      prompt: "high priority task",
+      priority: 1,
+    });
+    const task = queue.dequeue();
+    expect(task!.priority).toBe(1);
+  });
+
+  it("dequeues higher priority tasks before lower priority", () => {
+    // Enqueue low priority first, then high priority
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "repo-a",
+      prompt: "normal task",
+      priority: 0,
+    });
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "repo-b",
+      prompt: "urgent task",
+      priority: 2,
+    });
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "repo-c",
+      prompt: "high task",
+      priority: 1,
+    });
+
+    // Should dequeue urgent (2) first, then high (1), then normal (0)
+    const first = queue.dequeue();
+    expect(first!.prompt).toBe("urgent task");
+    expect(first!.priority).toBe(2);
+
+    const second = queue.dequeue();
+    expect(second!.prompt).toBe("high task");
+    expect(second!.priority).toBe(1);
+
+    const third = queue.dequeue();
+    expect(third!.prompt).toBe("normal task");
+    expect(third!.priority).toBe(0);
+  });
+
+  it("dequeues by FIFO within same priority", () => {
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "repo-a",
+      prompt: "first normal",
+      priority: 0,
+    });
+    queue.enqueue({
+      userId: "slack:U123",
+      repo: "repo-b",
+      prompt: "second normal",
+      priority: 0,
+    });
+
+    const first = queue.dequeue();
+    expect(first!.prompt).toBe("first normal");
+
+    const second = queue.dequeue();
+    expect(second!.prompt).toBe("second normal");
+  });
+
+  describe("metrics()", () => {
+    it("returns zeroes on empty queue", () => {
+      const m = queue.metrics();
+      expect(m.counts).toEqual({ pending: 0, running: 0, completed: 0, failed: 0 });
+      expect(m.avgDurationByRepo).toEqual([]);
+      expect(m.throughput.lastHour).toBe(0);
+      expect(m.throughput.last24h).toBe(0);
+      expect(m.errorRate).toBe(0);
+      expect(m.repoBreakdown).toEqual([]);
+    });
+
+    it("returns correct counts by status", () => {
+      queue.enqueue({ userId: "u1", repo: "a", prompt: "p1" });
+      const id2 = queue.enqueue({ userId: "u1", repo: "b", prompt: "p2" });
+      queue.dequeue(); // dequeues repo "a" -> running
+      // repo "b" is still pending since "a" is running but different repo, so dequeue "b"
+      const task2 = queue.dequeue();
+      if (task2) queue.complete(task2.id, "done");
+
+      const m = queue.metrics();
+      expect(m.counts.running).toBe(1);
+      expect(m.counts.completed).toBe(1);
+    });
+
+    it("computes average duration by repo", () => {
+      const id1 = queue.enqueue({ userId: "u1", repo: "app-a", prompt: "p1" });
+      queue.dequeue();
+      queue.complete(id1, "ok");
+
+      const id2 = queue.enqueue({ userId: "u1", repo: "app-a", prompt: "p2" });
+      queue.dequeue();
+      queue.complete(id2, "ok");
+
+      const m = queue.metrics();
+      expect(m.avgDurationByRepo.length).toBe(1);
+      expect(m.avgDurationByRepo[0].repo).toBe("app-a");
+      expect(m.avgDurationByRepo[0].count).toBe(2);
+      expect(m.avgDurationByRepo[0].avgMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it("computes throughput for recent tasks", () => {
+      const id = queue.enqueue({ userId: "u1", repo: "x", prompt: "p" });
+      queue.dequeue();
+      queue.complete(id, "done");
+
+      const m = queue.metrics();
+      expect(m.throughput.lastHour).toBe(1);
+      expect(m.throughput.last24h).toBe(1);
+    });
+
+    it("computes error rate", () => {
+      const id1 = queue.enqueue({ userId: "u1", repo: "a", prompt: "p1" });
+      queue.dequeue();
+      queue.complete(id1, "ok");
+
+      const id2 = queue.enqueue({ userId: "u1", repo: "a", prompt: "p2" });
+      queue.dequeue();
+      queue.fail(id2, "broken");
+
+      const m = queue.metrics();
+      // 1 failed out of 2 finished = 0.5
+      expect(m.errorRate).toBe(0.5);
+    });
+
+    it("returns per-repo breakdown", () => {
+      queue.enqueue({ userId: "u1", repo: "alpha", prompt: "p1" });
+      queue.enqueue({ userId: "u1", repo: "beta", prompt: "p2" });
+      queue.enqueue({ userId: "u2", repo: "alpha", prompt: "p3" });
+
+      const m = queue.metrics();
+      expect(m.repoBreakdown.length).toBe(2);
+      const alpha = m.repoBreakdown.find((r) => r.repo === "alpha");
+      expect(alpha).toBeDefined();
+      expect(alpha!.pending).toBe(2);
+      const beta = m.repoBreakdown.find((r) => r.repo === "beta");
+      expect(beta).toBeDefined();
+      expect(beta!.pending).toBe(1);
+    });
+
+    it("error rate is zero when no finished tasks", () => {
+      queue.enqueue({ userId: "u1", repo: "x", prompt: "p" });
+      const m = queue.metrics();
+      expect(m.errorRate).toBe(0);
+    });
+  });
 });

package/src/queue.ts

@@ -5,6 +5,7 @@ export interface TaskInput {
   repo: string;
   prompt: string;
   taskType?: string;
+  priority?: number;
 }
 
 export interface Task {
@@ -15,6 +16,7 @@ export interface Task {
   status: "pending" | "running" | "completed" | "failed";
   result: string | null;
   taskType: string | null;
+  priority: number;
   createdAt: string;
   completedAt: string | null;
 }
@@ -27,6 +29,7 @@ interface TaskRow {
   status: string;
   result: string | null;
   task_type: string | null;
+  priority: number;
   created_at: string;
   completed_at: string | null;
 }
@@ -45,6 +48,7 @@ export class TaskQueue {
         status TEXT NOT NULL DEFAULT 'pending',
         result TEXT,
         task_type TEXT,
+        priority INTEGER NOT NULL DEFAULT 0,
         created_at TEXT NOT NULL,
         completed_at TEXT
       )
@@ -54,14 +58,18 @@ export class TaskQueue {
     if (!columns.some(c => c.name === "task_type")) {
       this.db.run("ALTER TABLE tasks ADD COLUMN task_type TEXT");
     }
+    // Migration: add priority column if missing (backward compat)
+    if (!columns.some(c => c.name === "priority")) {
+      this.db.run("ALTER TABLE tasks ADD COLUMN priority INTEGER NOT NULL DEFAULT 0");
+    }
   }
 
   enqueue(input: TaskInput): string {
     const id = crypto.randomUUID();
     this.db.run(
-      `INSERT INTO tasks (id, user_id, repo, prompt, status, task_type, created_at)
-       VALUES (?, ?, ?, ?, 'pending', ?, ?)`,
-      [id, input.userId, input.repo, input.prompt, input.taskType || null, new Date().toISOString()]
+      `INSERT INTO tasks (id, user_id, repo, prompt, status, task_type, priority, created_at)
+       VALUES (?, ?, ?, ?, 'pending', ?, ?, ?)`,
+      [id, input.userId, input.repo, input.prompt, input.taskType || null, input.priority ?? 0, new Date().toISOString()]
     );
     return id;
   }
@@ -72,7 +80,7 @@ export class TaskQueue {
         `SELECT * FROM tasks
          WHERE status = 'pending'
          AND repo NOT IN (SELECT repo FROM tasks WHERE status = 'running')
-         ORDER BY created_at ASC
+         ORDER BY priority DESC, created_at ASC
          LIMIT 1`
       )
       .get() as TaskRow;
@@ -106,7 +114,7 @@ export class TaskQueue {
   listByUser(userId: string, limit: number = 10): Task[] {
     const rows = this.db
       .query(
-        `SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at DESC LIMIT ?`
+        `SELECT * FROM tasks WHERE user_id = ? ORDER BY priority DESC, created_at DESC LIMIT ?`
       )
       .all(userId, limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
@@ -126,10 +134,79 @@ export class TaskQueue {
     return row;
   }
 
+  metrics(): {
+    counts: { pending: number; running: number; completed: number; failed: number };
+    avgDurationByRepo: { repo: string; avgMs: number; count: number }[];
+    throughput: { lastHour: number; last24h: number };
+    errorRate: number;
+    repoBreakdown: { repo: string; pending: number; running: number; completed: number; failed: number }[];
+  } {
+    const counts = this.stats();
+
+    // Average task duration by repo (only completed/failed tasks with both timestamps)
+    const avgDurationByRepo = this.db
+      .query(
+        `SELECT repo,
+          AVG((julianday(completed_at) - julianday(created_at)) * 86400000) as avg_ms,
+          COUNT(*) as count
+        FROM tasks
+        WHERE completed_at IS NOT NULL AND created_at IS NOT NULL
+          AND status IN ('completed', 'failed')
+        GROUP BY repo
+        ORDER BY count DESC`
+      )
+      .all() as { repo: string; avg_ms: number; count: number }[];
+
+    // Task throughput — completed in last hour and last 24h
+    const now = new Date().toISOString();
+    const throughputRow = this.db
+      .query(
+        `SELECT
+          COUNT(*) FILTER (WHERE completed_at >= datetime(?, '-1 hour')) as last_hour,
+          COUNT(*) FILTER (WHERE completed_at >= datetime(?, '-24 hours')) as last_24h
+        FROM tasks
+        WHERE status IN ('completed', 'failed') AND completed_at IS NOT NULL`
+      )
+      .get(now, now) as { last_hour: number; last_24h: number };
+
+    // Error rate: failed / total finished
+    const total = counts.completed + counts.failed;
+    const errorRate = total > 0 ? counts.failed / total : 0;
+
+    // Per-repo breakdown
+    const repoBreakdown = this.db
+      .query(
+        `SELECT repo,
+          COUNT(*) FILTER (WHERE status = 'pending') as pending,
+          COUNT(*) FILTER (WHERE status = 'running') as running,
+          COUNT(*) FILTER (WHERE status = 'completed') as completed,
+          COUNT(*) FILTER (WHERE status = 'failed') as failed
+        FROM tasks
+        GROUP BY repo
+        ORDER BY (COUNT(*) FILTER (WHERE status = 'running') + COUNT(*) FILTER (WHERE status = 'pending')) DESC, repo ASC`
+      )
+      .all() as { repo: string; pending: number; running: number; completed: number; failed: number }[];
+
+    return {
+      counts,
+      avgDurationByRepo: avgDurationByRepo.map((r) => ({
+        repo: r.repo,
+        avgMs: Math.round(r.avg_ms),
+        count: r.count,
+      })),
+      throughput: {
+        lastHour: throughputRow.last_hour,
+        last24h: throughputRow.last_24h,
+      },
+      errorRate: Math.round(errorRate * 10000) / 10000, // 4 decimal places
+      repoBreakdown,
+    };
+  }
+
   listActive(limit: number = 20): Task[] {
     const rows = this.db
       .query(
-        `SELECT * FROM tasks WHERE status IN ('running', 'pending') ORDER BY created_at ASC LIMIT ?`
+        `SELECT * FROM tasks WHERE status IN ('running', 'pending') ORDER BY priority DESC, created_at ASC LIMIT ?`
       )
       .all(limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
@@ -159,7 +236,7 @@ export class TaskQueue {
       sql += ` WHERE status = ?`;
       params.push(status);
     }
-    sql += ` ORDER BY created_at DESC LIMIT ?`;
+    sql += ` ORDER BY priority DESC, created_at DESC LIMIT ?`;
     params.push(limit);
     const rows = this.db.query(sql).all(...params) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
@@ -182,6 +259,7 @@ export class TaskQueue {
       status: row.status as "pending" | "running" | "completed" | "failed",
       result: row.result,
       taskType: row.task_type || null,
+      priority: row.priority ?? 0,
       createdAt: row.created_at,
       completedAt: row.completed_at,
     };

package/src/router.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "bun:test";
-import { parseMessage, buildPrompt, buildCronPrompt } from "./router";
+import { parseMessage, buildPrompt, buildCronPrompt, parsePriority } from "./router";
 
 describe("parseMessage", () => {
   it("parses PR review command", () => {
@@ -260,6 +260,73 @@ describe("parseMessage", () => {
   });
 });
 
+describe("set-mode parsing", () => {
+  it("parses 'mode assistant'", () => {
+    const result = parseMessage("mode assistant");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'mode strict'", () => {
+    const result = parseMessage("mode strict");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("strict");
+  });
+
+  it("parses '/mode assistant'", () => {
+    const result = parseMessage("/mode assistant");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'assistant mode'", () => {
+    const result = parseMessage("assistant mode");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'yolo mode'", () => {
+    const result = parseMessage("yolo mode");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'be more helpful'", () => {
+    const result = parseMessage("be more helpful");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'help me with anything'", () => {
+    const result = parseMessage("help me with anything");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("assistant");
+  });
+
+  it("parses 'strict mode'", () => {
+    const result = parseMessage("strict mode");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("strict");
+  });
+
+  it("parses 'code mode'", () => {
+    const result = parseMessage("code mode");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("strict");
+  });
+
+  it("parses 'back to normal'", () => {
+    const result = parseMessage("back to normal");
+    expect(result.type).toBe("set-mode");
+    expect(result.args.mode).toBe("strict");
+  });
+
+  it("does NOT match 'help me fix a bug on my-app' as set-mode", () => {
+    const result = parseMessage("help me fix a bug on my-app");
+    expect(result.type).not.toBe("set-mode");
+  });
+});
+
 describe("buildPrompt", () => {
   it("builds review-pr prompt", () => {
     const prompt = buildPrompt({ type: "review-pr", repo: "my-app", args: { prNumber: 42 }, rawText: "" });
@@ -314,3 +381,86 @@ describe("buildCronPrompt", () => {
     expect(prompt).toContain(original);
   });
 });
+
+describe("parsePriority", () => {
+  it("returns 0 for normal text", () => {
+    const result = parsePriority("fix the login bug");
+    expect(result.priority).toBe(0);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses 'urgent:' prefix as priority 2", () => {
+    const result = parsePriority("urgent: fix the login bug");
+    expect(result.priority).toBe(2);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses '!important' marker as priority 1", () => {
+    const result = parsePriority("fix the login bug !important");
+    expect(result.priority).toBe(1);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses 'p1' as priority 1 (high)", () => {
+    const result = parsePriority("fix the login bug p1");
+    expect(result.priority).toBe(1);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses 'p0' as priority 2 (urgent)", () => {
+    const result = parsePriority("p0 fix the login bug");
+    expect(result.priority).toBe(2);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses 'p2' as priority 0 (normal)", () => {
+    const result = parsePriority("fix the login bug p2");
+    expect(result.priority).toBe(0);
+  });
+
+  it("parses '--priority high' as priority 1", () => {
+    const result = parsePriority("fix the login bug --priority high");
+    expect(result.priority).toBe(1);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses '--priority urgent' as priority 2", () => {
+    const result = parsePriority("fix the login bug --priority urgent");
+    expect(result.priority).toBe(2);
+    expect(result.text).toBe("fix the login bug");
+  });
+
+  it("parses '--priority normal' as priority 0", () => {
+    const result = parsePriority("fix the login bug --priority normal");
+    expect(result.priority).toBe(0);
+    expect(result.text).toBe("fix the login bug");
+  });
+});
+
+describe("parseMessage priority integration", () => {
+  it("default priority is 0", () => {
+    const result = parseMessage("fix issue #15 on infra");
+    expect(result.priority).toBe(0);
+  });
+
+  it("detects urgent: prefix and sets priority 2", () => {
+    const result = parseMessage("urgent: fix the login bug on my-app");
+    expect(result.priority).toBe(2);
+    expect(result.type).toBe("free-form");
+  });
+
+  it("detects !important and sets priority 1", () => {
+    const result = parseMessage("fix issue #15 on infra !important");
+    expect(result.priority).toBe(1);
+  });
+
+  it("detects p1 and sets priority 1", () => {
+    const result = parseMessage("review PR #42 on my-app p1");
+    expect(result.priority).toBe(1);
+  });
+
+  it("detects --priority urgent and sets priority 2", () => {
+    const result = parseMessage("fix the login bug on my-app --priority urgent");
+    expect(result.priority).toBe(2);
+  });
+});