prodboard 0.0.0 → 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as path from "path";
+import { PRODBOARD_DIR } from "../config.ts";
+import { getDb, runMigrations } from "../db.ts";
+
+function resolveTemplatePath(name: string): string {
+  return path.resolve(import.meta.dir, "../../templates", name);
+}
+
+function resolveSchemaPath(): string {
+  return path.resolve(import.meta.dir, "../../config.schema.json");
+}
+
+export async function init(args: string[], dirOverride?: string): Promise<void> {
+  const prodboardDir = dirOverride ?? PRODBOARD_DIR;
+  const logsDir = path.join(prodboardDir, "logs");
+  const claudeMdFlag = args.includes("--claude-md");
+
+  // Create directories
+  if (!fs.existsSync(prodboardDir)) {
+    fs.mkdirSync(prodboardDir, { recursive: true });
+    console.log(`Created ${prodboardDir}/`);
+  }
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+    console.log(`Created ${logsDir}/`);
+  }
+
+  // Initialize database
+  const dbPath = path.join(prodboardDir, "db.sqlite");
+  const db = getDb(dbPath);
+  runMigrations(db);
+  db.close();
+  try { fs.chmodSync(dbPath, 0o600); } catch {}
+  try { fs.chmodSync(logsDir, 0o700); } catch {}
+  console.log("Database initialized.");
+
+  // Config file — only write if not exists (user may have edited)
+  const configDest = path.join(prodboardDir, "config.jsonc");
+  if (!fs.existsSync(configDest)) {
+    const configSrc = resolveTemplatePath("config.jsonc");
+    fs.copyFileSync(configSrc, configDest);
+    console.log("Created config.jsonc");
+  } else {
+    console.log("config.jsonc already exists, skipping.");
+  }
+
+  // Schema — always overwrite (package-managed)
+  const schemaDest = path.join(prodboardDir, "config.schema.json");
+  const schemaSrc = resolveSchemaPath();
+  fs.copyFileSync(schemaSrc, schemaDest);
+  console.log("Updated config.schema.json");
+
+  // MCP config — always overwrite
+  const mcpDest = path.join(prodboardDir, "mcp.json");
+  const mcpSrc = resolveTemplatePath("mcp.json");
+  fs.copyFileSync(mcpSrc, mcpDest);
+  console.log("Updated mcp.json");
+
+  // System prompts — always overwrite
+  const spDest = path.join(prodboardDir, "system-prompt.md");
+  const spSrc = resolveTemplatePath("system-prompt.md");
+  fs.copyFileSync(spSrc, spDest);
+
+  const spNogitDest = path.join(prodboardDir, "system-prompt-nogit.md");
+  const spNogitSrc = resolveTemplatePath("system-prompt-nogit.md");
+  fs.copyFileSync(spNogitSrc, spNogitDest);
+  console.log("Updated system prompts.");
+
+  // CLAUDE.md — only if --claude-md flag and not exists
+  if (claudeMdFlag) {
+    const claudeMdDest = path.join(process.cwd(), "CLAUDE.md");
+    if (!fs.existsSync(claudeMdDest)) {
+      const claudeMdSrc = resolveTemplatePath("CLAUDE.md");
+      fs.copyFileSync(claudeMdSrc, claudeMdDest);
+      console.log("Created CLAUDE.md in current directory.");
+    } else {
+      console.log("CLAUDE.md already exists, skipping.");
+    }
+  }
+
+  console.log("\nprodboard initialized successfully!");
+}

package/src/commands/issues.ts

@@ -0,0 +1,268 @@
+import { Database } from "bun:sqlite";
+import { ensureDb } from "../db.ts";
+import { loadConfig } from "../config.ts";
+import {
+  createIssue, getIssueByPrefix, listIssues, updateIssue,
+  deleteIssue, validateStatus
+} from "../queries/issues.ts";
+import { listComments } from "../queries/comments.ts";
+import { renderTable, formatDate, jsonOutput, bold, dim, cyan } from "../format.ts";
+import { confirm } from "../confirm.ts";
+
+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 === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      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 (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+function getFlag(flags: Record<string, string | boolean>, ...keys: string[]): string | undefined {
+  for (const k of keys) {
+    const val = flags[k];
+    if (val !== undefined && val !== true) return val as string;
+  }
+  return undefined;
+}
+
+function hasFlag(flags: Record<string, string | boolean>, ...keys: string[]): boolean {
+  return keys.some((k) => flags[k] !== undefined);
+}
+
+// Collect repeatable flags like --status todo --status done
+function parseArgsMulti(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 === "--") {
+      positional.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (!flags[key]) flags[key] = [];
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[key].push(args[++i]);
+      } else {
+        flags[key].push(true);
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      if (!flags[key]) flags[key] = [];
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[key].push(args[++i]);
+      } else {
+        flags[key].push(true);
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+export async function add(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const title = positional.join(" ");
+  if (!title) {
+    console.error("Usage: prodboard add <title> [-d description] [-s status]");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const config = loadConfig();
+
+  const status = getFlag(flags, "status", "s");
+  if (status) validateStatus(status, config);
+
+  const issue = createIssue(db, {
+    title,
+    description: getFlag(flags, "description", "d"),
+    status,
+  });
+
+  console.log(`Created issue ${issue.id}: ${issue.title} [${issue.status}]`);
+}
+
+export async function ls(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags } = parseArgsMulti(args);
+  const db = dbOverride ?? ensureDb();
+
+  const statusFilters = [
+    ...(flags.status?.filter((v): v is string => typeof v === "string") ?? []),
+    ...(flags.s?.filter((v): v is string => typeof v === "string") ?? []),
+  ];
+
+  const search = (flags.search?.[0] ?? flags.q?.[0]) as string | undefined;
+  const all = flags.all !== undefined || flags.a !== undefined;
+  const sortFlag = flags.sort?.[0] as string | undefined;
+  const asc = flags.asc !== undefined;
+  const limitStr = (flags.limit?.[0] ?? flags.n?.[0]) as string | undefined;
+  const isJson = flags.json !== undefined;
+
+  const { issues, total } = listIssues(db, {
+    status: statusFilters.length > 0 ? statusFilters : undefined,
+    search: typeof search === "string" ? search : undefined,
+    includeArchived: all,
+    sort: typeof sortFlag === "string" ? sortFlag : undefined,
+    order: asc ? "ASC" : undefined,
+    limit: limitStr ? parseInt(limitStr, 10) : undefined,
+  });
+
+  if (isJson) {
+    console.log(jsonOutput(issues));
+    return;
+  }
+
+  if (issues.length === 0) {
+    console.log("No issues found.");
+    return;
+  }
+
+  const table = renderTable(
+    ["ID", "Title", "Status", "Updated"],
+    issues.map((i) => [i.id, i.title, i.status, formatDate(i.updated_at)]),
+    { maxWidths: [10, 40, 15, 18] }
+  );
+  console.log(table);
+  console.log(`${total} issue${total === 1 ? "" : "s"}`);
+}
+
+export async function show(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard show <id>");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const isJson = hasFlag(flags, "json");
+
+  const issue = getIssueByPrefix(db, idOrPrefix);
+  const comments = listComments(db, issue.id);
+
+  if (isJson) {
+    console.log(jsonOutput({ ...issue, comments }));
+    return;
+  }
+
+  console.log(`Issue ${issue.id}`);
+  console.log(`Title: ${issue.title}`);
+  console.log(`Status: ${issue.status}`);
+  console.log(`Created: ${formatDate(issue.created_at)}`);
+  console.log(`Updated: ${formatDate(issue.updated_at)}`);
+
+  if (issue.description) {
+    console.log(`\nDescription:\n${issue.description}`);
+  }
+
+  if (comments.length > 0) {
+    console.log(`\nComments (${comments.length}):`);
+    for (const c of comments) {
+      console.log(`  [${c.author}] ${formatDate(c.created_at)}`);
+      console.log(`  ${c.body}`);
+      console.log();
+    }
+  }
+}
+
+export async function edit(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard edit <id> [--title/-t title] [--description/-d desc] [--status/-s status]");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const config = loadConfig();
+  const issue = getIssueByPrefix(db, idOrPrefix);
+
+  const fields: { title?: string; description?: string; status?: string } = {};
+  const title = getFlag(flags, "title", "t");
+  const description = getFlag(flags, "description", "d");
+  const status = getFlag(flags, "status", "s");
+
+  if (title) fields.title = title;
+  if (description) fields.description = description;
+  if (status) {
+    validateStatus(status, config);
+    fields.status = status;
+  }
+
+  if (Object.keys(fields).length === 0) {
+    console.error("No fields to update. Use --title, --description, or --status.");
+    throw new Error("Invalid arguments");
+  }
+
+  const updated = updateIssue(db, issue.id, fields);
+  console.log(`Updated issue ${updated.id}: ${updated.title} [${updated.status}]`);
+}
+
+export async function mv(args: string[], dbOverride?: Database): Promise<void> {
+  const { positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  const newStatus = positional[1];
+
+  if (!idOrPrefix || !newStatus) {
+    console.error("Usage: prodboard mv <id> <status>");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const config = loadConfig();
+  validateStatus(newStatus, config);
+
+  const issue = getIssueByPrefix(db, idOrPrefix);
+  const updated = updateIssue(db, issue.id, { status: newStatus });
+  console.log(`Moved issue ${updated.id} to ${updated.status}`);
+}
+
+export async function rm(args: string[], dbOverride?: Database): Promise<void> {
+  const { flags, positional } = parseArgs(args);
+  const idOrPrefix = positional[0];
+  if (!idOrPrefix) {
+    console.error("Usage: prodboard rm <id> [--force/-f]");
+    throw new Error("Invalid arguments");
+  }
+
+  const db = dbOverride ?? ensureDb();
+  const issue = getIssueByPrefix(db, idOrPrefix);
+
+  if (!hasFlag(flags, "force", "f")) {
+    const ok = await confirm(`Delete issue ${issue.id}: ${issue.title}?`);
+    if (!ok) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+
+  deleteIssue(db, issue.id);
+  console.log(`Deleted issue ${issue.id}`);
+}

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)}`);
+}