prodboard 0.0.0 → 0.1.0

package/src/index.ts

@@ -0,0 +1,214 @@
+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 "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
+  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 {}
+  }
+}