prodboard 0.0.0 → 0.1.1

package/src/queries/issues.ts

@@ -0,0 +1,155 @@
+import { Database } from "bun:sqlite";
+import type { Issue, Config } from "../types.ts";
+import { generateId } from "../ids.ts";
+
+export function createIssue(
+  db: Database,
+  opts: { title: string; description?: string; status?: string }
+): Issue {
+  const id = generateId();
+  const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+  const status = opts.status ?? "todo";
+  const description = opts.description ?? "";
+
+  db.query(
+    "INSERT INTO issues (id, title, description, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(id, opts.title, description, status, now, now);
+
+  return { id, title: opts.title, description, status, created_at: now, updated_at: now };
+}
+
+export function getIssue(db: Database, id: string): Issue | null {
+  return db.query("SELECT * FROM issues WHERE id = ?").get(id) as Issue | null;
+}
+
+export function getIssueByPrefix(db: Database, prefix: string): Issue {
+  // Try exact match first
+  const exact = getIssue(db, prefix);
+  if (exact) return exact;
+
+  const escaped = prefix.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+  const matches = db
+    .query("SELECT * FROM issues WHERE id LIKE ? || '%' ESCAPE '\\'")
+    .all(escaped) as Issue[];
+
+  if (matches.length === 0) {
+    throw new Error(`Issue not found: ${prefix}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Ambiguous prefix '${prefix}': matches ${matches.map((m) => m.id).join(", ")}`
+    );
+  }
+  return matches[0];
+}
+
+export function resolveIssueId(db: Database, idOrPrefix: string): string {
+  return getIssueByPrefix(db, idOrPrefix).id;
+}
+
+export function listIssues(
+  db: Database,
+  opts?: {
+    status?: string[];
+    search?: string;
+    sort?: string;
+    order?: string;
+    includeArchived?: boolean;
+    limit?: number;
+  }
+): { issues: Issue[]; total: number } {
+  const conditions: string[] = [];
+  const params: any[] = [];
+
+  if (!opts?.includeArchived) {
+    conditions.push("status != 'archived'");
+  }
+
+  if (opts?.status && opts.status.length > 0) {
+    const placeholders = opts.status.map(() => "?").join(", ");
+    conditions.push(`status IN (${placeholders})`);
+    params.push(...opts.status);
+  }
+
+  if (opts?.search) {
+    conditions.push("(title LIKE '%' || ? || '%' OR description LIKE '%' || ? || '%')");
+    params.push(opts.search, opts.search);
+  }
+
+  const where = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+
+  const VALID_SORT = new Set(["updated_at", "created_at", "title", "status"]);
+  const VALID_ORDER = new Set(["ASC", "DESC"]);
+  const sort = VALID_SORT.has(opts?.sort ?? "") ? opts!.sort! : "updated_at";
+  const order = VALID_ORDER.has((opts?.order ?? "").toUpperCase()) ? (opts!.order!).toUpperCase() : "DESC";
+  const limit = opts?.limit ?? 50;
+
+  const countResult = db.query(`SELECT COUNT(*) as count FROM issues ${where}`).get(...params) as { count: number };
+
+  const issues = db
+    .query(`SELECT * FROM issues ${where} ORDER BY ${sort} ${order} LIMIT ?`)
+    .all(...params, limit) as Issue[];
+
+  return { issues, total: countResult.count };
+}
+
+export function updateIssue(
+  db: Database,
+  id: string,
+  fields: { title?: string; description?: string; status?: string }
+): Issue {
+  const issue = getIssue(db, id);
+  if (!issue) throw new Error(`Issue not found: ${id}`);
+
+  const hasFields = fields.title !== undefined || fields.description !== undefined || fields.status !== undefined;
+  if (!hasFields) return issue;
+
+  const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+  const sets: string[] = ["updated_at = ?"];
+  const params: any[] = [now];
+
+  if (fields.title !== undefined) {
+    sets.push("title = ?");
+    params.push(fields.title);
+  }
+  if (fields.description !== undefined) {
+    sets.push("description = ?");
+    params.push(fields.description);
+  }
+  if (fields.status !== undefined) {
+    sets.push("status = ?");
+    params.push(fields.status);
+  }
+
+  params.push(id);
+  db.query(`UPDATE issues SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+
+  return getIssue(db, id)!;
+}
+
+export function deleteIssue(db: Database, id: string): void {
+  const result = db.query("DELETE FROM issues WHERE id = ?").run(id);
+  if (result.changes === 0) {
+    throw new Error(`Issue not found: ${id}`);
+  }
+}
+
+export function getIssueCounts(db: Database): Record<string, number> {
+  const rows = db
+    .query("SELECT status, COUNT(*) as count FROM issues GROUP BY status")
+    .all() as { status: string; count: number }[];
+
+  const counts: Record<string, number> = {};
+  for (const row of rows) {
+    counts[row.status] = row.count;
+  }
+  return counts;
+}
+
+export function validateStatus(status: string, config: Config): void {
+  if (!config.general.statuses.includes(status)) {
+    throw new Error(
+      `Invalid status '${status}'. Valid statuses: ${config.general.statuses.join(", ")}`
+    );
+  }
+}

package/src/queries/runs.ts

@@ -0,0 +1,159 @@
+import { Database } from "bun:sqlite";
+import type { Run } from "../types.ts";
+import { generateId } from "../ids.ts";
+
+export function createRun(
+  db: Database,
+  opts: { schedule_id: string; prompt_used: string; pid?: number }
+): Run {
+  const id = generateId();
+  const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+
+  db.query(`
+    INSERT INTO runs (id, schedule_id, status, prompt_used, pid, started_at)
+    VALUES (?, ?, 'running', ?, ?, ?)
+  `).run(id, opts.schedule_id, opts.prompt_used, opts.pid ?? null, now);
+
+  return db.query("SELECT * FROM runs WHERE id = ?").get(id) as Run;
+}
+
+export function updateRun(
+  db: Database,
+  id: string,
+  fields: Partial<Omit<Run, "id" | "schedule_id" | "started_at">>
+): void {
+  const sets: string[] = [];
+  const params: any[] = [];
+
+  const fieldMap: Record<string, string> = {
+    status: "status", finished_at: "finished_at", exit_code: "exit_code",
+    stdout_tail: "stdout_tail", stderr_tail: "stderr_tail",
+    session_id: "session_id", worktree_path: "worktree_path",
+    tokens_in: "tokens_in", tokens_out: "tokens_out", cost_usd: "cost_usd",
+    tools_used: "tools_used", issues_touched: "issues_touched",
+    prompt_used: "prompt_used", pid: "pid",
+  };
+
+  for (const [key, col] of Object.entries(fieldMap)) {
+    if ((fields as any)[key] !== undefined) {
+      sets.push(`${col} = ?`);
+      params.push((fields as any)[key]);
+    }
+  }
+
+  if (sets.length === 0) return;
+
+  params.push(id);
+  db.query(`UPDATE runs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+
+export function listRuns(
+  db: Database,
+  opts?: { schedule_id?: string; status?: string; limit?: number }
+): Run[] {
+  const conditions: string[] = [];
+  const params: any[] = [];
+
+  if (opts?.schedule_id) {
+    conditions.push("r.schedule_id = ?");
+    params.push(opts.schedule_id);
+  }
+  if (opts?.status) {
+    conditions.push("r.status = ?");
+    params.push(opts.status);
+  }
+
+  const where = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+  const limit = opts?.limit ?? 50;
+
+  return db.query(`
+    SELECT r.*, s.name as schedule_name
+    FROM runs r
+    LEFT JOIN schedules s ON r.schedule_id = s.id
+    ${where}
+    ORDER BY r.started_at DESC
+    LIMIT ?
+  `).all(...params, limit) as Run[];
+}
+
+export function getRunningRuns(db: Database): Run[] {
+  return db.query("SELECT * FROM runs WHERE status = 'running'").all() as Run[];
+}
+
+export function getLastRun(db: Database, scheduleId: string): Run | null {
+  return db.query(
+    "SELECT * FROM runs WHERE schedule_id = ? ORDER BY started_at DESC LIMIT 1"
+  ).get(scheduleId) as Run | null;
+}
+
+export function getLastSessionId(db: Database, scheduleId: string): string | null {
+  const run = db.query(
+    "SELECT session_id FROM runs WHERE schedule_id = ? AND session_id IS NOT NULL ORDER BY started_at DESC LIMIT 1"
+  ).get(scheduleId) as { session_id: string } | null;
+  return run?.session_id ?? null;
+}
+
+export function getScheduleStats(
+  db: Database,
+  scheduleId?: string,
+  days?: number
+): {
+  total: number;
+  success: number;
+  failed: number;
+  success_rate: number;
+  avg_tokens_in: number;
+  avg_tokens_out: number;
+  total_cost: number;
+} {
+  const conditions: string[] = [];
+  const params: any[] = [];
+
+  if (scheduleId) {
+    conditions.push("schedule_id = ?");
+    params.push(scheduleId);
+  }
+  if (days) {
+    conditions.push("started_at >= datetime('now', ? || ' days')");
+    params.push(-days);
+  }
+
+  const where = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+
+  const stats = db.query(`
+    SELECT
+      COUNT(*) as total,
+      SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed,
+      AVG(tokens_in) as avg_tokens_in,
+      AVG(tokens_out) as avg_tokens_out,
+      SUM(COALESCE(cost_usd, 0)) as total_cost
+    FROM runs ${where}
+  `).get(...params) as any;
+
+  return {
+    total: stats.total ?? 0,
+    success: stats.success ?? 0,
+    failed: stats.failed ?? 0,
+    success_rate: stats.total > 0 ? (stats.success ?? 0) / stats.total : 0,
+    avg_tokens_in: stats.avg_tokens_in ?? 0,
+    avg_tokens_out: stats.avg_tokens_out ?? 0,
+    total_cost: stats.total_cost ?? 0,
+  };
+}
+
+export function pruneOldRuns(db: Database, retentionDays: number): number {
+  const result = db.query(
+    "DELETE FROM runs WHERE started_at < datetime('now', ? || ' days')"
+  ).run(-retentionDays);
+  return result.changes;
+}
+
+export function getSessionRunCount(db: Database, scheduleId: string): number {
+  const lastSessionId = getLastSessionId(db, scheduleId);
+  if (!lastSessionId) return 0;
+  const result = db.query(
+    "SELECT COUNT(*) as count FROM runs WHERE schedule_id = ? AND session_id = ?"
+  ).get(scheduleId, lastSessionId) as { count: number };
+  return result.count;
+}

package/src/queries/schedules.ts

@@ -0,0 +1,115 @@
+import { Database } from "bun:sqlite";
+import type { Schedule } from "../types.ts";
+import { generateId } from "../ids.ts";
+
+export function createSchedule(
+  db: Database,
+  opts: {
+    name: string;
+    cron: string;
+    prompt: string;
+    workdir?: string;
+    max_turns?: number;
+    allowed_tools?: string;
+    use_worktree?: boolean;
+    inject_context?: boolean;
+    persist_session?: boolean;
+    agents_json?: string;
+    source?: string;
+  }
+): Schedule {
+  const id = generateId();
+  const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+
+  db.query(`
+    INSERT INTO schedules (id, name, cron, prompt, workdir, max_turns, allowed_tools,
+      use_worktree, inject_context, persist_session, agents_json, source, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id, opts.name, opts.cron, opts.prompt,
+    opts.workdir ?? ".",
+    opts.max_turns ?? null,
+    opts.allowed_tools ?? null,
+    opts.use_worktree !== false ? 1 : 0,
+    opts.inject_context !== false ? 1 : 0,
+    opts.persist_session ? 1 : 0,
+    opts.agents_json ?? null,
+    opts.source ?? "cli",
+    now, now
+  );
+
+  return getSchedule(db, id)!;
+}
+
+export function getSchedule(db: Database, id: string): Schedule | null {
+  return db.query("SELECT * FROM schedules WHERE id = ?").get(id) as Schedule | null;
+}
+
+export function getScheduleByPrefix(db: Database, prefix: string): Schedule {
+  const exact = getSchedule(db, prefix);
+  if (exact) return exact;
+
+  const escaped = prefix.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+  const matches = db
+    .query("SELECT * FROM schedules WHERE id LIKE ? || '%' ESCAPE '\\'")
+    .all(escaped) as Schedule[];
+
+  if (matches.length === 0) throw new Error(`Schedule not found: ${prefix}`);
+  if (matches.length > 1) throw new Error(`Ambiguous prefix '${prefix}': matches ${matches.map((m) => m.id).join(", ")}`);
+  return matches[0];
+}
+
+export function listSchedules(
+  db: Database,
+  opts?: { includeDisabled?: boolean }
+): Schedule[] {
+  if (opts?.includeDisabled) {
+    return db.query("SELECT * FROM schedules ORDER BY created_at DESC").all() as Schedule[];
+  }
+  return db.query("SELECT * FROM schedules WHERE enabled = 1 ORDER BY created_at DESC").all() as Schedule[];
+}
+
+export function updateSchedule(
+  db: Database,
+  id: string,
+  fields: Partial<Omit<Schedule, "id" | "created_at">>
+): Schedule {
+  const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+  const sets: string[] = ["updated_at = ?"];
+  const params: any[] = [now];
+
+  const fieldMap: Record<string, string> = {
+    name: "name", cron: "cron", prompt: "prompt", workdir: "workdir",
+    enabled: "enabled", max_turns: "max_turns", allowed_tools: "allowed_tools",
+    use_worktree: "use_worktree", inject_context: "inject_context",
+    persist_session: "persist_session", agents_json: "agents_json",
+  };
+
+  let hasRealFields = false;
+  for (const [key, col] of Object.entries(fieldMap)) {
+    if ((fields as any)[key] !== undefined) {
+      sets.push(`${col} = ?`);
+      params.push((fields as any)[key]);
+      hasRealFields = true;
+    }
+  }
+
+  if (!hasRealFields) return getSchedule(db, id)!;
+
+  params.push(id);
+  db.query(`UPDATE schedules SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  return getSchedule(db, id)!;
+}
+
+export function deleteSchedule(db: Database, id: string): void {
+  const result = db.query("DELETE FROM schedules WHERE id = ?").run(id);
+  if (result.changes === 0) throw new Error(`Schedule not found: ${id}`);
+}
+
+export function enableSchedule(db: Database, id: string): void {
+  db.query("UPDATE schedules SET enabled = 1, updated_at = datetime('now') WHERE id = ?").run(id);
+}
+
+export function disableSchedule(db: Database, id: string): void {
+  db.query("UPDATE schedules SET enabled = 0, updated_at = datetime('now') WHERE id = ?").run(id);
+}