prodboard 0.0.0 → 0.1.1

package/src/commands/daemon.ts

@@ -0,0 +1,112 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ensureDb } from "../db.ts";
+import { loadConfig, PRODBOARD_DIR } from "../config.ts";
+import { listSchedules } from "../queries/schedules.ts";
+import { getNextFire } from "../cron.ts";
+import { formatDate } from "../format.ts";
+import { Daemon } from "../scheduler.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.startsWith("--")) {
+      const key = arg.slice(2);
+      if (key === "dry-run" || key === "foreground") {
+        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") {
+        flags.foreground = true;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+export async function daemonStart(args: string[]): Promise<void> {
+  const { flags } = parseArgs(args);
+  const db = ensureDb();
+  const config = loadConfig();
+
+  if (flags["dry-run"]) {
+    const schedules = listSchedules(db);
+    if (schedules.length === 0) {
+      console.log("No active schedules.");
+      return;
+    }
+
+    console.log("Active schedules (dry run):\n");
+    for (const s of schedules) {
+      let nextFire = "N/A";
+      try {
+        const next = getNextFire(s.cron, new Date());
+        nextFire = formatDate(next.toISOString());
+      } catch {}
+      console.log(`  ${s.id}  ${s.name}`);
+      console.log(`    Cron: ${s.cron}`);
+      console.log(`    Next: ${nextFire}`);
+      console.log();
+    }
+    return;
+  }
+
+  const daemon = new Daemon(db, config);
+  await daemon.start();
+
+  // Keep process alive
+  await new Promise(() => {});
+}
+
+export async function daemonStatus(args: string[]): Promise<void> {
+  const pidFile = path.join(PRODBOARD_DIR, "daemon.pid");
+
+  if (!fs.existsSync(pidFile)) {
+    console.log("Daemon is not running (no PID file).");
+    return;
+  }
+
+  const pidStr = fs.readFileSync(pidFile, "utf-8").trim();
+  const pid = parseInt(pidStr, 10);
+
+  let running = false;
+  try {
+    process.kill(pid, 0);
+    running = true;
+  } catch {}
+
+  if (running) {
+    console.log(`Daemon is running (PID ${pid}).`);
+
+    // Show next scheduled runs
+    try {
+      const db = ensureDb();
+      const schedules = listSchedules(db);
+      if (schedules.length > 0) {
+        console.log("\nUpcoming runs:");
+        for (const s of schedules) {
+          try {
+            const next = getNextFire(s.cron, new Date());
+            console.log(`  ${s.name}: ${formatDate(next.toISOString())}`);
+          } catch {}
+        }
+      }
+    } catch {}
+  } else {
+    console.log(`Daemon is not running (stale PID file: ${pid}).`);
+    // Clean up stale PID file
+    try { fs.unlinkSync(pidFile); } catch {}
+  }
+}

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/install.ts

@@ -0,0 +1,127 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const SERVICE_NAME = "prodboard";
+const SERVICE_DIR = path.join(os.homedir(), ".config", "systemd", "user");
+const SERVICE_PATH = path.join(SERVICE_DIR, `${SERVICE_NAME}.service`);
+
+function parseArgs(args: string[]): { flags: Record<string, boolean> } {
+  const flags: Record<string, boolean> = {};
+  for (const arg of args) {
+    if (arg === "--force" || arg === "-f") {
+      flags.force = true;
+    }
+  }
+  return { flags };
+}
+
+async function systemctlAvailable(): Promise<boolean> {
+  try {
+    const proc = Bun.spawn(["systemctl", "--version"], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    const code = await proc.exited;
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function runSystemctl(...args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  const proc = Bun.spawn(["systemctl", "--user", ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return { exitCode, stdout, stderr };
+}
+
+export function generateServiceFile(bunPath: string, prodboardPath: string, home: string): string {
+  return `[Unit]
+Description=prodboard scheduler daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${bunPath} run ${prodboardPath} daemon
+Restart=on-failure
+RestartSec=10
+Environment="HOME=${home}"
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+export async function install(args: string[]): Promise<void> {
+  const { flags } = parseArgs(args);
+
+  if (!(await systemctlAvailable())) {
+    console.error("systemd is not available on this system.");
+    console.error("The install command requires systemd (Linux).");
+    process.exit(1);
+  }
+
+  const alreadyInstalled = fs.existsSync(SERVICE_PATH);
+
+  if (alreadyInstalled && !flags.force) {
+    console.log("prodboard is already installed as a systemd service.");
+    const { stdout } = await runSystemctl("status", SERVICE_NAME);
+    console.log(stdout);
+    return;
+  }
+
+  const bunPath = Bun.which("bun") ?? process.execPath;
+  const prodboardPath = Bun.which("prodboard") ?? `${bunPath} x prodboard`;
+  const home = os.homedir();
+
+  const serviceContent = generateServiceFile(bunPath, prodboardPath, home);
+
+  fs.mkdirSync(SERVICE_DIR, { recursive: true });
+  fs.writeFileSync(SERVICE_PATH, serviceContent);
+  console.log(`Service file written to ${SERVICE_PATH}`);
+
+  const reload = await runSystemctl("daemon-reload");
+  if (reload.exitCode !== 0) {
+    console.error("Failed to reload systemd:", reload.stderr);
+    process.exit(1);
+  }
+
+  const enable = await runSystemctl("enable", SERVICE_NAME);
+  if (enable.exitCode !== 0) {
+    console.error("Failed to enable service:", enable.stderr);
+    process.exit(1);
+  }
+
+  const start = await runSystemctl("start", SERVICE_NAME);
+  if (start.exitCode !== 0) {
+    console.error("Failed to start service:", start.stderr);
+    process.exit(1);
+  }
+
+  console.log("prodboard service installed, enabled, and started.");
+  const { stdout } = await runSystemctl("status", SERVICE_NAME);
+  console.log(stdout);
+}
+
+export async function uninstall(_args: string[]): Promise<void> {
+  if (!fs.existsSync(SERVICE_PATH)) {
+    console.log("prodboard is not installed as a systemd service.");
+    return;
+  }
+
+  await runSystemctl("stop", SERVICE_NAME);
+  await runSystemctl("disable", SERVICE_NAME);
+
+  fs.unlinkSync(SERVICE_PATH);
+  console.log(`Removed ${SERVICE_PATH}`);
+
+  await runSystemctl("daemon-reload");
+  console.log("prodboard service uninstalled.");
+}

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