prodboard 0.0.0 → 0.1.0

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

package/src/db.ts

@@ -0,0 +1,157 @@
+import { Database } from "bun:sqlite";
+import * as path from "path";
+import * as fs from "fs";
+import { PRODBOARD_DIR } from "./config.ts";
+
+export function getDbPath(): string {
+  return path.join(PRODBOARD_DIR, "db.sqlite");
+}
+
+export function getDb(dbPath?: string): Database {
+  const p = dbPath ?? getDbPath();
+  if (p !== ":memory:") {
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  const db = new Database(p);
+  if (p !== ":memory:") {
+    db.exec("PRAGMA journal_mode=WAL");
+  }
+  db.exec("PRAGMA foreign_keys=ON");
+  return db;
+}
+
+export function ensureDb(): Database {
+  return getDb(getDbPath());
+}
+
+interface Migration {
+  version: number;
+  sql: string;
+}
+
+const MIGRATIONS: Migration[] = [
+  {
+    version: 1,
+    sql: `
+      CREATE TABLE IF NOT EXISTS issues (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'todo',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS comments (
+        id TEXT PRIMARY KEY,
+        issue_id TEXT NOT NULL,
+        body TEXT NOT NULL,
+        author TEXT NOT NULL DEFAULT 'user',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        FOREIGN KEY (issue_id) REFERENCES issues(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS schedules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        cron TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        workdir TEXT NOT NULL DEFAULT '.',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        max_turns INTEGER,
+        allowed_tools TEXT,
+        use_worktree INTEGER NOT NULL DEFAULT 1,
+        inject_context INTEGER NOT NULL DEFAULT 1,
+        persist_session INTEGER NOT NULL DEFAULT 0,
+        agents_json TEXT,
+        source TEXT NOT NULL DEFAULT 'cli',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        schedule_id TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running',
+        prompt_used TEXT NOT NULL,
+        pid INTEGER,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        finished_at TEXT,
+        exit_code INTEGER,
+        stdout_tail TEXT,
+        stderr_tail TEXT,
+        session_id TEXT,
+        worktree_path TEXT,
+        tokens_in INTEGER,
+        tokens_out INTEGER,
+        cost_usd REAL,
+        tools_used TEXT,
+        issues_touched TEXT,
+        FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_issues_status ON issues(status);
+      CREATE INDEX IF NOT EXISTS idx_issues_updated ON issues(updated_at);
+      CREATE INDEX IF NOT EXISTS idx_comments_issue ON comments(issue_id);
+      CREATE INDEX IF NOT EXISTS idx_runs_schedule ON runs(schedule_id);
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+      CREATE INDEX IF NOT EXISTS idx_runs_started ON runs(started_at);
+    `,
+  },
+];
+
+export { MIGRATIONS };
+
+function splitStatements(sql: string): string[] {
+  const results: string[] = [];
+  let current = "";
+  let depth = 0;
+
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === ";" && depth === 0) {
+      const trimmed = current.trim();
+      if (trimmed.length > 0) results.push(trimmed);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  const trimmed = current.trim();
+  if (trimmed.length > 0) results.push(trimmed);
+  return results;
+}
+
+function execStatements(db: Database, sql: string): void {
+  for (const stmt of splitStatements(sql)) {
+    db.exec(stmt);
+  }
+}
+
+export function runMigrations(db: Database): void {
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS _migrations (version INTEGER PRIMARY KEY, applied_at TEXT NOT NULL DEFAULT (datetime('now')))"
+  );
+
+  const appliedRows = db.query("SELECT version FROM _migrations ORDER BY version").all() as { version: number }[];
+  const applied = new Set(appliedRows.map((r) => r.version));
+
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.version)) continue;
+
+    db.exec("BEGIN TRANSACTION");
+    try {
+      execStatements(db, migration.sql);
+      db.exec(`INSERT INTO _migrations (version) VALUES (${migration.version})`);
+      db.exec("COMMIT");
+    } catch (err: any) {
+      try { db.exec("ROLLBACK"); } catch {}
+      throw new Error(`Migration v${migration.version} failed: ${err.message}`);
+    }
+  }
+}

package/src/format.ts

@@ -0,0 +1,99 @@
+const NO_COLOR = !!process.env.NO_COLOR;
+
+export function color(text: string, code: number): string {
+  if (NO_COLOR) return text;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+export function dim(text: string): string {
+  return color(text, 2);
+}
+export function bold(text: string): string {
+  return color(text, 1);
+}
+export function green(text: string): string {
+  return color(text, 32);
+}
+export function red(text: string): string {
+  return color(text, 31);
+}
+export function yellow(text: string): string {
+  return color(text, 33);
+}
+export function cyan(text: string): string {
+  return color(text, 36);
+}
+
+export function renderTable(
+  headers: string[],
+  rows: string[][],
+  options?: { maxWidths?: number[] }
+): string {
+  const maxWidths = options?.maxWidths;
+
+  // Calculate column widths
+  const colWidths = headers.map((h, i) => {
+    let max = h.length;
+    for (const row of rows) {
+      if (row[i] && row[i].length > max) max = row[i].length;
+    }
+    if (maxWidths && maxWidths[i] && max > maxWidths[i]) {
+      max = maxWidths[i];
+    }
+    return max;
+  });
+
+  function truncate(text: string, width: number): string {
+    if (text.length <= width) return text;
+    return text.slice(0, width - 1) + "…";
+  }
+
+  function pad(text: string, width: number): string {
+    const t = truncate(text, width);
+    return t + " ".repeat(Math.max(0, width - t.length));
+  }
+
+  const top =
+    "┌" + colWidths.map((w) => "─".repeat(w + 2)).join("┬") + "┐";
+  const mid =
+    "├" + colWidths.map((w) => "─".repeat(w + 2)).join("┼") + "┤";
+  const bot =
+    "└" + colWidths.map((w) => "─".repeat(w + 2)).join("┴") + "┘";
+
+  const headerRow =
+    "│" +
+    headers.map((h, i) => " " + pad(h, colWidths[i]) + " ").join("│") +
+    "│";
+
+  const dataRows = rows.map(
+    (row) =>
+      "│" +
+      row
+        .map((cell, i) => " " + pad(cell ?? "", colWidths[i]) + " ")
+        .join("│") +
+      "│"
+  );
+
+  const lines = [top, headerRow];
+  if (rows.length > 0) {
+    lines.push(mid);
+    lines.push(...dataRows);
+  }
+  lines.push(bot);
+  return lines.join("\n");
+}
+
+export function formatDate(iso: string): string {
+  if (!iso) return "";
+  const d = new Date(iso + (iso.includes("Z") || iso.includes("+") ? "" : "Z"));
+  const year = d.getUTCFullYear();
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  const hour = String(d.getUTCHours()).padStart(2, "0");
+  const min = String(d.getUTCMinutes()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hour}:${min}`;
+}
+
+export function jsonOutput(data: unknown): string {
+  return JSON.stringify(data);
+}

package/src/ids.ts

@@ -0,0 +1,5 @@
+import { randomBytes } from "crypto";
+
+export function generateId(): string {
+  return randomBytes(8).toString("hex");
+}