prodboard 0.0.0 → 0.1.1

package/src/commands/schedules.ts

@@ -0,0 +1,276 @@
+import { Database } from "bun:sqlite";
+import { ensureDb } from "../db.ts";
+import { loadConfig } from "../config.ts";
+import { validateCron, getNextFire } from "../cron.ts";
+import {
+  createSchedule, getScheduleByPrefix, listSchedules,
+  updateSchedule, deleteSchedule, enableSchedule, disableSchedule,
+} from "../queries/schedules.ts";
+import { listRuns, getScheduleStats } from "../queries/runs.ts";
+import { renderTable, formatDate, jsonOutput } from "../format.ts";
+import { confirm } from "../confirm.ts";
+import { ExecutionManager } from "../scheduler.ts";
+import { createRun } from "../queries/runs.ts";
+
+function safeParseInt(val: string | boolean | undefined): number | undefined {
+  if (typeof val !== "string") return undefined;
+  const n = parseInt(val, 10);
+  return isNaN(n) ? undefined : n;
+}
+
+function parseArgs(args: string[]): { flags: Record<string, string | boolean>; positional: string[] } {
+  const flags: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (key === "no-worktree" || key === "no-context" || key === "persist-session" || key === "force" || key === "all" || key === "json" || key === "asc") {
+        flags[key] = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      if (key === "f" || key === "a") {
+        flags[key] = true;
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+export async function scheduleAdd(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags } = parseArgs(args);
+  const db = dbOverride ?? ensureDb();
+
+  const name = (flags.name ?? flags.n) as string;
+  const cron = (flags.cron ?? flags.c) as string;
+  const prompt = (flags.prompt ?? flags.p) as string;
+
+  if (!name || !cron || !prompt) {
+    console.error("Usage: prodboard schedule add --name <name> --cron <expr> --prompt <prompt>");
+    throw new Error("Invalid arguments");
+  }
+
+  const validation = validateCron(cron);
+  if (!validation.valid) {
+    console.error(`Invalid cron expression: ${validation.error}`);
+    throw new Error("Invalid arguments");
+  }
+
+  const schedule = createSchedule(db, {
+    name,
+    cron,
+    prompt,
+    workdir: (flags.workdir ?? flags.w) as string | undefined,
+    max_turns: flags["max-turns"] ? parseInt(flags["max-turns"] as string, 10) : undefined,
+    use_worktree: !flags["no-worktree"],
+    inject_context: !flags["no-context"],
+    persist_session: !!flags["persist-session"],
+  });
+
+  console.log(`Created schedule ${schedule.id}: ${schedule.name} [${schedule.cron}]`);
+}
+
+export async function scheduleLs(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags } = parseArgs(args);
+  const db = dbOverride ?? ensureDb();
+  const isJson = !!flags.json;
+  const all = !!(flags.all || flags.a);
+
+  const schedules = listSchedules(db, { includeDisabled: all });
+
+  if (isJson) {
+    console.log(jsonOutput(schedules));
+    return;
+  }
+
+  if (schedules.length === 0) {
+    console.log("No schedules.");
+    return;
+  }
+
+  const table = renderTable(
+    ["ID", "Name", "Cron", "Enabled", "Next Fire"],
+    schedules.map((s) => {
+      let nextFire = "";
+      try {
+        const next = getNextFire(s.cron, new Date());
+        nextFire = formatDate(next.toISOString());
+      } catch {}
+      return [s.id, s.name, s.cron, s.enabled ? "yes" : "no", nextFire];
+    }),
+    { maxWidths: [10, 30, 20, 8, 18] }
+  );
+  console.log(table);
+  console.log(`${schedules.length} schedule${schedules.length === 1 ? "" : "s"}`);
+}
+
+export async function scheduleEdit(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard schedule edit <id> [--name name] [--cron expr] [--prompt prompt]");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const schedule = getScheduleByPrefix(db, idOrPrefix);
+
+  const fields: any = {};
+  if (flags.name || flags.n) fields.name = flags.name ?? flags.n;
+  if (flags.cron || flags.c) {
+    const newCron = (flags.cron ?? flags.c) as string;
+    const validation = validateCron(newCron);
+    if (!validation.valid) {
+      console.error(`Invalid cron expression: ${validation.error}`);
+      throw new Error("Invalid arguments");
+    }
+    fields.cron = newCron;
+  }
+  if (flags.prompt || flags.p) fields.prompt = flags.prompt ?? flags.p;
+  if (flags["max-turns"]) fields.max_turns = parseInt(flags["max-turns"] as string, 10);
+
+  const updated = updateSchedule(db, schedule.id, fields);
+  console.log(`Updated schedule ${updated.id}: ${updated.name}`);
+}
+
+export async function scheduleEnable(args: string[], dbOverride?: Database): Promise<void> {
+  const { positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard schedule enable <id>");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const schedule = getScheduleByPrefix(db, idOrPrefix);
+  enableSchedule(db, schedule.id);
+  console.log(`Enabled schedule ${schedule.id}: ${schedule.name}`);
+}
+
+export async function scheduleDisable(args: string[], dbOverride?: Database): Promise<void> {
+  const { positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard schedule disable <id>");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const schedule = getScheduleByPrefix(db, idOrPrefix);
+  disableSchedule(db, schedule.id);
+  console.log(`Disabled schedule ${schedule.id}: ${schedule.name}`);
+}
+
+export async function scheduleRm(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard schedule rm <id> [--force/-f]");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const schedule = getScheduleByPrefix(db, idOrPrefix);
+
+  if (!flags.force && !flags.f) {
+    const ok = await confirm(`Delete schedule ${schedule.id}: ${schedule.name}?`);
+    if (!ok) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+
+  deleteSchedule(db, schedule.id);
+  console.log(`Deleted schedule ${schedule.id}`);
+}
+
+export async function scheduleLogs(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags } = parseArgs(args);
+  const db = dbOverride ?? ensureDb();
+  const isJson = !!flags.json;
+
+  const runs = listRuns(db, {
+    schedule_id: (flags.schedule ?? flags.s) as string | undefined,
+    status: flags.status as string | undefined,
+    limit: safeParseInt(flags.limit ?? flags.n),
+  });
+
+  if (isJson) {
+    console.log(jsonOutput(runs));
+    return;
+  }
+
+  if (runs.length === 0) {
+    console.log("No runs found.");
+    return;
+  }
+
+  const table = renderTable(
+    ["ID", "Schedule", "Status", "Started", "Exit", "Tokens"],
+    runs.map((r) => [
+      r.id,
+      r.schedule_name ?? r.schedule_id,
+      r.status,
+      formatDate(r.started_at),
+      r.exit_code !== null ? String(r.exit_code) : "-",
+      r.tokens_in ? `${r.tokens_in}/${r.tokens_out}` : "-",
+    ]),
+    { maxWidths: [10, 20, 10, 18, 5, 12] }
+  );
+  console.log(table);
+}
+
+export async function scheduleRun(args: string[], dbOverride?: Database): Promise<void> {
+  const { positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard schedule run <id>");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const config = loadConfig();
+  const schedule = getScheduleByPrefix(db, idOrPrefix);
+
+  console.log(`Running schedule ${schedule.id}: ${schedule.name}...`);
+
+  const run = createRun(db, {
+    schedule_id: schedule.id,
+    prompt_used: schedule.prompt,
+  });
+
+  const em = new ExecutionManager(db, config);
+  await em.executeRun(schedule, run);
+
+  const updatedRun = db.query("SELECT * FROM runs WHERE id = ?").get(run.id) as any;
+  console.log(`Run completed: ${updatedRun.status} (exit code: ${updatedRun.exit_code ?? "N/A"})`);
+}
+
+export async function scheduleStats(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags } = parseArgs(args);
+  const db = dbOverride ?? ensureDb();
+
+  const scheduleId = (flags.schedule ?? flags.s) as string | undefined;
+  const days = safeParseInt(flags.days ?? flags.d);
+
+  const stats = getScheduleStats(db, scheduleId, days);
+
+  console.log(`Total runs: ${stats.total}`);
+  console.log(`Success: ${stats.success} (${(stats.success_rate * 100).toFixed(1)}%)`);
+  console.log(`Failed: ${stats.failed}`);
+  console.log(`Avg tokens in: ${Math.round(stats.avg_tokens_in)}`);
+  console.log(`Avg tokens out: ${Math.round(stats.avg_tokens_out)}`);
+  console.log(`Total cost: $${stats.total_cost.toFixed(4)}`);
+}

package/src/config.ts

@@ -0,0 +1,155 @@
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+import type { Config } from "./types.ts";
+
+export const PRODBOARD_DIR = path.join(os.homedir(), ".prodboard");
+
+export function stripJsoncComments(text: string): string {
+  let result = "";
+  let i = 0;
+  let inString = false;
+  let stringChar = "";
+
+  while (i < text.length) {
+    // Handle string literals
+    if (inString) {
+      if (text[i] === "\\" && i + 1 < text.length) {
+        result += text[i] + text[i + 1];
+        i += 2;
+        continue;
+      }
+      if (text[i] === stringChar) {
+        inString = false;
+      }
+      result += text[i];
+      i++;
+      continue;
+    }
+
+    // Check for string start
+    if (text[i] === '"') {
+      inString = true;
+      stringChar = text[i];
+      result += text[i];
+      i++;
+      continue;
+    }
+
+    // Check for line comment
+    if (text[i] === "/" && i + 1 < text.length && text[i + 1] === "/") {
+      // Skip until end of line
+      while (i < text.length && text[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+
+    // Check for block comment
+    if (text[i] === "/" && i + 1 < text.length && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && i + 1 < text.length && text[i + 1] === "/")) {
+        i++;
+      }
+      if (i < text.length) {
+        i += 2; // skip */
+      }
+      continue;
+    }
+
+    result += text[i];
+    i++;
+  }
+
+  return result;
+}
+
+export function getDefaults(): Config {
+  return {
+    general: {
+      statuses: ["todo", "in-progress", "review", "done", "archived"],
+      defaultStatus: "todo",
+      idPrefix: "",
+    },
+    daemon: {
+      maxConcurrentRuns: 2,
+      maxTurns: 50,
+      hardMaxTurns: 200,
+      runTimeoutSeconds: 1800,
+      runRetentionDays: 30,
+      logLevel: "info",
+      logMaxSizeMb: 10,
+      logMaxFiles: 5,
+      defaultAllowedTools: [
+        "Read", "Edit", "Write", "Glob", "Grep", "Bash",
+        "mcp__prodboard__list_issues",
+        "mcp__prodboard__get_issue",
+        "mcp__prodboard__create_issue",
+        "mcp__prodboard__update_issue",
+        "mcp__prodboard__add_comment",
+        "mcp__prodboard__board_summary",
+        "mcp__prodboard__pick_next_issue",
+        "mcp__prodboard__complete_issue",
+      ],
+      nonGitDefaultAllowedTools: [
+        "Read", "Edit", "Write", "Glob", "Grep", "Bash",
+        "mcp__prodboard__list_issues",
+        "mcp__prodboard__get_issue",
+        "mcp__prodboard__create_issue",
+        "mcp__prodboard__update_issue",
+        "mcp__prodboard__add_comment",
+        "mcp__prodboard__board_summary",
+        "mcp__prodboard__pick_next_issue",
+        "mcp__prodboard__complete_issue",
+      ],
+      useWorktrees: "auto",
+    },
+  };
+}
+
+export function deepMerge(defaults: any, user: any): any {
+  const result = { ...defaults };
+  for (const key of Object.keys(user)) {
+    if (
+      user[key] !== null &&
+      typeof user[key] === "object" &&
+      !Array.isArray(user[key]) &&
+      defaults[key] !== undefined &&
+      typeof defaults[key] === "object" &&
+      !Array.isArray(defaults[key])
+    ) {
+      result[key] = deepMerge(defaults[key], user[key]);
+    } else {
+      result[key] = user[key];
+    }
+  }
+  return result;
+}
+
+export function loadConfig(configDir?: string): Config {
+  const dir = configDir ?? PRODBOARD_DIR;
+  const configPath = path.join(dir, "config.jsonc");
+  const defaults = getDefaults();
+
+  if (!fs.existsSync(configPath)) {
+    return defaults;
+  }
+
+  let text: string;
+  try {
+    text = fs.readFileSync(configPath, "utf-8");
+  } catch (err: any) {
+    throw new Error(`Failed to read config file: ${err.message}`);
+  }
+
+  const stripped = stripJsoncComments(text);
+
+  let parsed: any;
+  try {
+    parsed = JSON.parse(stripped);
+  } catch (err: any) {
+    throw new Error(`Invalid JSON in config file ${configPath}: ${err.message}`);
+  }
+
+  return deepMerge(defaults, parsed);
+}

package/src/confirm.ts

@@ -0,0 +1,14 @@
+export async function confirm(message: string): Promise<boolean> {
+  process.stdout.write(`${message} [y/N] `);
+  const response = await new Promise<string>((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (chunk: string) => {
+      process.stdin.pause();
+      data += chunk;
+      resolve(data.trim().toLowerCase());
+    });
+    process.stdin.resume();
+  });
+  return response === "y" || response === "yes";
+}

package/src/cron.ts

@@ -0,0 +1,121 @@
+export interface CronFields {
+  minute: Set<number>;
+  hour: Set<number>;
+  dayOfMonth: Set<number>;
+  month: Set<number>;
+  dayOfWeek: Set<number>;
+}
+
+export function parseCronField(field: string, min: number, max: number): Set<number> {
+  const result = new Set<number>();
+  const parts = field.split(",");
+
+  for (const part of parts) {
+    if (part === "*") {
+      for (let i = min; i <= max; i++) result.add(i);
+    } else if (part.includes("/")) {
+      const [range, stepStr] = part.split("/");
+      const step = parseInt(stepStr, 10);
+      if (isNaN(step) || step <= 0) throw new Error(`Invalid step value: ${stepStr}`);
+
+      let start = min;
+      let end = max;
+
+      if (range !== "*") {
+        if (range.includes("-")) {
+          const [s, e] = range.split("-").map(Number);
+          start = s;
+          end = e;
+        } else {
+          start = parseInt(range, 10);
+        }
+      }
+
+      if (isNaN(start) || isNaN(end)) throw new Error(`Invalid range: ${range}`);
+      if (start < min || end > max) throw new Error(`Range ${start}-${end} out of bounds (${min}-${max})`);
+
+      for (let i = start; i <= end; i += step) {
+        result.add(i);
+      }
+    } else if (part.includes("-")) {
+      const [startStr, endStr] = part.split("-");
+      const start = parseInt(startStr, 10);
+      const end = parseInt(endStr, 10);
+      if (isNaN(start) || isNaN(end)) throw new Error(`Invalid range: ${part}`);
+      if (start < min || end > max) throw new Error(`Range ${part} out of bounds (${min}-${max})`);
+
+      for (let i = start; i <= end; i++) {
+        result.add(i);
+      }
+    } else {
+      const val = parseInt(part, 10);
+      if (isNaN(val)) throw new Error(`Invalid value: ${part}`);
+      if (val < min || val > max) throw new Error(`Value ${val} out of range (${min}-${max})`);
+      result.add(val);
+    }
+  }
+
+  return result;
+}
+
+export function parseCronExpression(expr: string): CronFields {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`Cron expression must have 5 fields, got ${parts.length}: "${expr}"`);
+  }
+
+  return {
+    minute: parseCronField(parts[0], 0, 59),
+    hour: parseCronField(parts[1], 0, 23),
+    dayOfMonth: parseCronField(parts[2], 1, 31),
+    month: parseCronField(parts[3], 1, 12),
+    dayOfWeek: parseCronField(parts[4], 0, 6),
+  };
+}
+
+/** Cron expressions are evaluated in server-local time, matching standard crontab behavior. */
+export function shouldFire(expr: string, date: Date): boolean {
+  const fields = parseCronExpression(expr);
+  return (
+    fields.minute.has(date.getMinutes()) &&
+    fields.hour.has(date.getHours()) &&
+    fields.dayOfMonth.has(date.getDate()) &&
+    fields.month.has(date.getMonth() + 1) &&
+    fields.dayOfWeek.has(date.getDay())
+  );
+}
+
+export function validateCron(expr: string): { valid: boolean; error?: string } {
+  try {
+    parseCronExpression(expr);
+    return { valid: true };
+  } catch (err: any) {
+    return { valid: false, error: err.message };
+  }
+}
+
+export function getNextFire(expr: string, after: Date): Date {
+  const fields = parseCronExpression(expr);
+  const candidate = new Date(after);
+  candidate.setSeconds(0, 0);
+  candidate.setMinutes(candidate.getMinutes() + 1);
+
+  // Search up to 2 years ahead
+  const limit = new Date(after);
+  limit.setFullYear(limit.getFullYear() + 2);
+
+  while (candidate < limit) {
+    if (
+      fields.minute.has(candidate.getMinutes()) &&
+      fields.hour.has(candidate.getHours()) &&
+      fields.dayOfMonth.has(candidate.getDate()) &&
+      fields.month.has(candidate.getMonth() + 1) &&
+      fields.dayOfWeek.has(candidate.getDay())
+    ) {
+      return candidate;
+    }
+    candidate.setMinutes(candidate.getMinutes() + 1);
+  }
+
+  throw new Error(`No next fire time found within 2 years for: ${expr}`);
+}