prodboard 0.0.0 → 0.1.1

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

package/src/index.ts

@@ -0,0 +1,227 @@
+import { existsSync } from "fs";
+import { PRODBOARD_DIR } from "./config.ts";
+
+export class NotInitializedError extends Error {
+  constructor() {
+    super(`prodboard is not initialized. Run 'prodboard init' first.`);
+    this.name = "NotInitializedError";
+  }
+}
+
+export class DatabaseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DatabaseError";
+  }
+}
+
+function ensureInitialized(): void {
+  if (!existsSync(PRODBOARD_DIR)) {
+    throw new NotInitializedError();
+  }
+}
+
+export async function main(): Promise<void> {
+  const args = Bun.argv.slice(2);
+  const command = args[0];
+
+  if (command === "--version" || command === "version") {
+    const pkg = await import("../package.json");
+    console.log(pkg.version);
+    return;
+  }
+
+  if (command === "--help" || command === "help" || !command) {
+    printHelp();
+    return;
+  }
+
+  try {
+    switch (command) {
+      case "init": {
+        const { init } = await import("./commands/init.ts");
+        await init(args.slice(1));
+        break;
+      }
+      case "add": {
+        ensureInitialized();
+        const { add } = await import("./commands/issues.ts");
+        await add(args.slice(1));
+        break;
+      }
+      case "ls": {
+        ensureInitialized();
+        const { ls } = await import("./commands/issues.ts");
+        await ls(args.slice(1));
+        break;
+      }
+      case "show": {
+        ensureInitialized();
+        const { show } = await import("./commands/issues.ts");
+        await show(args.slice(1));
+        break;
+      }
+      case "edit": {
+        ensureInitialized();
+        const { edit } = await import("./commands/issues.ts");
+        await edit(args.slice(1));
+        break;
+      }
+      case "mv": {
+        ensureInitialized();
+        const { mv } = await import("./commands/issues.ts");
+        await mv(args.slice(1));
+        break;
+      }
+      case "rm": {
+        ensureInitialized();
+        const { rm } = await import("./commands/issues.ts");
+        await rm(args.slice(1));
+        break;
+      }
+      case "comment": {
+        ensureInitialized();
+        const { comment } = await import("./commands/comments.ts");
+        await comment(args.slice(1));
+        break;
+      }
+      case "comments": {
+        ensureInitialized();
+        const { comments } = await import("./commands/comments.ts");
+        await comments(args.slice(1));
+        break;
+      }
+      case "schedule": {
+        ensureInitialized();
+        const sub = args[1];
+        const subArgs = args.slice(2);
+        const schedMod = await import("./commands/schedules.ts");
+        switch (sub) {
+          case "add":
+            await schedMod.scheduleAdd(subArgs);
+            break;
+          case "ls":
+            await schedMod.scheduleLs(subArgs);
+            break;
+          case "edit":
+            await schedMod.scheduleEdit(subArgs);
+            break;
+          case "enable":
+            await schedMod.scheduleEnable(subArgs);
+            break;
+          case "disable":
+            await schedMod.scheduleDisable(subArgs);
+            break;
+          case "rm":
+            await schedMod.scheduleRm(subArgs);
+            break;
+          case "logs":
+            await schedMod.scheduleLogs(subArgs);
+            break;
+          case "run":
+            await schedMod.scheduleRun(subArgs);
+            break;
+          case "stats":
+            await schedMod.scheduleStats(subArgs);
+            break;
+          default:
+            console.error(`Unknown schedule subcommand: ${sub}`);
+            console.error("Available: add, ls, edit, enable, disable, rm, logs, run, stats");
+            process.exit(1);
+        }
+        break;
+      }
+      case "daemon": {
+        ensureInitialized();
+        const sub = args[1];
+        const daemonMod = await import("./commands/daemon.ts");
+        if (sub === "status") {
+          await daemonMod.daemonStatus(args.slice(2));
+        } else {
+          await daemonMod.daemonStart(args.slice(1));
+        }
+        break;
+      }
+      case "install": {
+        ensureInitialized();
+        const { install } = await import("./commands/install.ts");
+        await install(args.slice(1));
+        break;
+      }
+      case "uninstall": {
+        const { uninstall } = await import("./commands/install.ts");
+        await uninstall(args.slice(1));
+        break;
+      }
+      case "config": {
+        ensureInitialized();
+        const { loadConfig } = await import("./config.ts");
+        const config = loadConfig();
+        console.log(JSON.stringify(config, null, 2));
+        break;
+      }
+      case "mcp": {
+        ensureInitialized();
+        const { startMcpServer } = await import("./mcp.ts");
+        await startMcpServer();
+        break;
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+    }
+  } catch (err: any) {
+    if (err instanceof NotInitializedError) {
+      console.error(err.message);
+      process.exit(3);
+    }
+    if (err instanceof DatabaseError) {
+      console.error(`Database error: ${err.message}`);
+      process.exit(2);
+    }
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+function printHelp(): void {
+  console.log(`prodboard — CLI-first issue tracker for AI coding agents
+
+Usage: prodboard <command> [options]
+
+Commands:
+  init              Initialize prodboard (~/.prodboard/)
+  add <title>       Create a new issue
+  ls                List issues
+  show <id>         Show issue details
+  edit <id>         Edit an issue
+  mv <id> <status>  Change issue status
+  rm <id>           Delete an issue
+  comment <id>      Add a comment to an issue
+  comments <id>     List comments for an issue
+  schedule <sub>    Manage scheduled tasks
+  daemon            Start the scheduler daemon
+  install           Install systemd service
+  uninstall         Remove systemd service
+  config            Show configuration
+  mcp               Start MCP server (stdio)
+  version           Show version
+  help              Show this help
+
+Schedule subcommands:
+  schedule add      Create a schedule
+  schedule ls       List schedules
+  schedule edit     Edit a schedule
+  schedule enable   Enable a schedule
+  schedule disable  Disable a schedule
+  schedule rm       Delete a schedule
+  schedule logs     Show run history
+  schedule run      Run a schedule immediately
+  schedule stats    Show schedule statistics
+
+Options:
+  --json            Output in JSON format
+  --help            Show help for a command
+  --version         Show version`);
+}

package/src/invocation.ts

@@ -0,0 +1,102 @@
+import * as path from "path";
+import type { Config, Schedule, Run, EnvironmentInfo } from "./types.ts";
+import { PRODBOARD_DIR } from "./config.ts";
+import { getLastSessionId } from "./queries/runs.ts";
+import { Database } from "bun:sqlite";
+
+export function detectEnvironment(workdir: string, config: Config): EnvironmentInfo {
+  let hasGit = false;
+  try {
+    const result = Bun.spawnSync(["git", "rev-parse", "--git-dir"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    hasGit = result.exitCode === 0;
+  } catch {}
+
+  let hasClaude = false;
+  try {
+    const result = Bun.spawnSync(["claude", "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    hasClaude = result.exitCode === 0;
+  } catch {}
+
+  const worktreeSupported = hasGit && config.daemon.useWorktrees !== "never";
+
+  return { hasGit, hasClaude, worktreeSupported };
+}
+
+export function buildInvocation(
+  schedule: Schedule,
+  run: Run,
+  config: Config,
+  env: EnvironmentInfo,
+  resolvedPrompt: string,
+  db?: Database
+): string[] {
+  const args: string[] = ["claude"];
+
+  // Prompt
+  args.push("-p", resolvedPrompt);
+
+  // Permissions
+  args.push("--dangerously-skip-permissions");
+
+  // Output format
+  args.push("--output-format", "stream-json");
+
+  // MCP config
+  const mcpConfigPath = path.join(PRODBOARD_DIR, "mcp.json");
+  args.push("--mcp-config", mcpConfigPath);
+
+  // System prompt
+  const systemPromptFile = env.hasGit
+    ? path.join(PRODBOARD_DIR, "system-prompt.md")
+    : path.join(PRODBOARD_DIR, "system-prompt-nogit.md");
+  args.push("--append-system-prompt-file", systemPromptFile);
+
+  // Max turns: min of schedule override, config default, and hard max
+  const scheduleTurns = schedule.max_turns ?? config.daemon.maxTurns;
+  const maxTurns = Math.min(scheduleTurns, config.daemon.hardMaxTurns);
+  args.push("--max-turns", String(maxTurns));
+
+  // Allowed tools
+  let tools: string[];
+  if (schedule.allowed_tools) {
+    try {
+      tools = JSON.parse(schedule.allowed_tools);
+    } catch {
+      tools = env.hasGit ? config.daemon.defaultAllowedTools : config.daemon.nonGitDefaultAllowedTools;
+    }
+  } else if (!env.hasGit) {
+    tools = config.daemon.nonGitDefaultAllowedTools;
+  } else {
+    tools = config.daemon.defaultAllowedTools;
+  }
+  for (const tool of tools) {
+    args.push("--allowedTools", tool);
+  }
+
+  // Worktree
+  if (env.worktreeSupported && schedule.use_worktree !== 0) {
+    args.push("--worktree");
+  }
+
+  // Session resume
+  if (schedule.persist_session && db) {
+    const lastSessionId = getLastSessionId(db, schedule.id);
+    if (lastSessionId) {
+      args.push("--resume", lastSessionId);
+    }
+  }
+
+  // Agents JSON
+  if (schedule.agents_json) {
+    args.push("--agents", schedule.agents_json);
+  }
+
+  return args;
+}

package/src/logger.ts

@@ -0,0 +1,84 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+const LEVEL_ORDER: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+export class Logger {
+  private logDir: string;
+  private level: LogLevel;
+  private maxSizeBytes: number;
+  private maxFiles: number;
+  private logFile: string;
+
+  constructor(options: { logDir: string; level: LogLevel; maxSizeMb: number; maxFiles: number }) {
+    this.logDir = options.logDir;
+    this.level = options.level;
+    this.maxSizeBytes = options.maxSizeMb * 1024 * 1024;
+    this.maxFiles = options.maxFiles;
+    this.logFile = path.join(this.logDir, "daemon.log");
+
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+
+  debug(msg: string, data?: Record<string, unknown>): void {
+    this.log("debug", msg, data);
+  }
+
+  info(msg: string, data?: Record<string, unknown>): void {
+    this.log("info", msg, data);
+  }
+
+  warn(msg: string, data?: Record<string, unknown>): void {
+    this.log("warn", msg, data);
+  }
+
+  error(msg: string, data?: Record<string, unknown>): void {
+    this.log("error", msg, data);
+  }
+
+  private log(level: LogLevel, msg: string, data?: Record<string, unknown>): void {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.level]) return;
+
+    const timestamp = new Date().toISOString();
+    const dataStr = data ? " " + JSON.stringify(data) : "";
+    const line = `[${timestamp}] [${level.toUpperCase()}] ${msg}${dataStr}\n`;
+
+    this.rotate();
+    fs.appendFileSync(this.logFile, line);
+
+    // Also output to stderr
+    process.stderr.write(line);
+  }
+
+  private rotate(): void {
+    try {
+      if (!fs.existsSync(this.logFile)) return;
+      const stat = fs.statSync(this.logFile);
+      if (stat.size < this.maxSizeBytes) return;
+
+      // Shift existing rotated files
+      for (let i = this.maxFiles; i >= 1; i--) {
+        const src = path.join(this.logDir, `daemon.${i}.log`);
+        if (fs.existsSync(src)) {
+          if (i >= this.maxFiles) {
+            fs.unlinkSync(src);
+          } else {
+            fs.renameSync(src, path.join(this.logDir, `daemon.${i + 1}.log`));
+          }
+        }
+      }
+
+      // Move current to .1
+      fs.renameSync(this.logFile, path.join(this.logDir, "daemon.1.log"));
+    } catch {}
+  }
+}