feinai 0.5.0

package/src/dashboard.ts

@@ -0,0 +1,3 @@
+// Bun embeds this file as a string at compile time — works in both dev and compiled binary
+import dashboardHtml from './dashboard.html' with { type: 'text' };
+export { dashboardHtml };

package/src/db.ts

@@ -0,0 +1,221 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { openSqlite, type DbAdapter } from "./sqlite-adapter";
+
+const DB_DIR = ".tasca";
+const DB_FILE = "tasca.db";
+
+export type DbInstance = DbAdapter;
+
+/**
+ * Schema split into individual statements so we can use db.run() per statement
+ * (avoiding the deprecated db.exec(sql, ...bindings) overload).
+ */
+const SCHEMA_STATEMENTS: string[] = [
+  `CREATE TABLE IF NOT EXISTS specs (
+    id           TEXT PRIMARY KEY,
+    numero       INTEGER,
+    title        TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'lista',
+    content      TEXT,
+    pr           TEXT,
+    merged_date  TEXT,
+    created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
+  )`,
+
+  `CREATE TABLE IF NOT EXISTS plans (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    spec_id     TEXT NOT NULL REFERENCES specs(id) ON DELETE CASCADE ON UPDATE CASCADE,
+    content     TEXT NOT NULL,
+    version     INTEGER NOT NULL DEFAULT 1,
+    created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(spec_id, version)
+  )`,
+
+  `CREATE TABLE IF NOT EXISTS tasks (
+    id            TEXT PRIMARY KEY,
+    spec_id       TEXT REFERENCES specs(id) ON DELETE SET NULL ON UPDATE CASCADE,
+    subject       TEXT NOT NULL,
+    description   TEXT,
+    status        TEXT NOT NULL DEFAULT 'pending',
+    owner         TEXT,
+    blocked_by    TEXT NOT NULL DEFAULT '[]',
+    packages      TEXT NOT NULL DEFAULT '[]',
+    quality_gates TEXT NOT NULL DEFAULT '[]',
+    result        TEXT,
+    error         TEXT,
+    taken_at      TEXT,
+    completed_at  TEXT,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+  )`,
+
+  `CREATE TABLE IF NOT EXISTS events (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    entity_type  TEXT NOT NULL,
+    entity_id    TEXT NOT NULL,
+    event_type   TEXT NOT NULL,
+    actor        TEXT,
+    payload      TEXT,
+    created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+  )`,
+
+  `CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)`,
+  `CREATE INDEX IF NOT EXISTS idx_tasks_spec_id ON tasks(spec_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner)`,
+  `CREATE INDEX IF NOT EXISTS idx_plans_spec_id ON plans(spec_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity_type, entity_id)`,
+
+  // Trigger: propagate spec id renames to the polymorphic events audit log.
+  // (events.entity_id has no FK — it covers tasks, specs, and plans — so
+  //  ON UPDATE CASCADE is not possible; a trigger is the only option.)
+  `CREATE TRIGGER IF NOT EXISTS trg_specs_rename_events
+   AFTER UPDATE OF id ON specs
+   WHEN OLD.id != NEW.id
+   BEGIN
+     UPDATE events SET entity_id = NEW.id
+     WHERE entity_type = 'spec' AND entity_id = OLD.id;
+   END`,
+];
+
+// Migration: recreate tables that need new FK constraints (ON UPDATE CASCADE).
+// SQLite does not support ALTER COLUMN — the only way is recreate + copy.
+// Each migration is idempotent: guarded by a user_version pragma bump.
+const MIGRATIONS: Array<{ version: number; stmts: string[] }> = [
+  {
+    version: 1,
+    stmts: [
+      `ALTER TABLE plans RENAME TO _plans_old`,
+      `CREATE TABLE plans (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        spec_id     TEXT NOT NULL REFERENCES specs(id) ON DELETE CASCADE ON UPDATE CASCADE,
+        content     TEXT NOT NULL,
+        version     INTEGER NOT NULL DEFAULT 1,
+        created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(spec_id, version)
+      )`,
+      `INSERT INTO plans SELECT * FROM _plans_old`,
+      `DROP TABLE _plans_old`,
+      `ALTER TABLE tasks RENAME TO _tasks_old`,
+      `CREATE TABLE tasks (
+        id            TEXT PRIMARY KEY,
+        spec_id       TEXT REFERENCES specs(id) ON DELETE SET NULL ON UPDATE CASCADE,
+        subject       TEXT NOT NULL,
+        description   TEXT,
+        status        TEXT NOT NULL DEFAULT 'pending',
+        owner         TEXT,
+        blocked_by    TEXT NOT NULL DEFAULT '[]',
+        packages      TEXT NOT NULL DEFAULT '[]',
+        quality_gates TEXT NOT NULL DEFAULT '[]',
+        result        TEXT,
+        error         TEXT,
+        taken_at      TEXT,
+        completed_at  TEXT,
+        created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+      )`,
+      `INSERT INTO tasks SELECT * FROM _tasks_old`,
+      `DROP TABLE _tasks_old`,
+    ],
+  },
+  {
+    version: 2,
+    stmts: [
+      `ALTER TABLE tasks ADD COLUMN worktree TEXT`,
+    ],
+  },
+];
+
+function applyMigrations(db: DbInstance): void {
+  const { user_version: current } = db.prepare("PRAGMA user_version").get() as { user_version: number };
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= current) continue;
+    db.run("PRAGMA foreign_keys = OFF");
+    for (const stmt of migration.stmts) db.run(stmt);
+    db.run(`PRAGMA user_version = ${migration.version}`);
+    db.run("PRAGMA foreign_keys = ON");
+  }
+}
+
+function applySchema(db: DbInstance): void {
+  for (const stmt of SCHEMA_STATEMENTS) {
+    db.run(stmt);
+  }
+  applyMigrations(db);
+}
+
+/**
+ * Find .tasca/tasca.db by walking up from cwd, like git does with .git.
+ * Returns null if no DB exists in the tree above the starting directory.
+ */
+export function findDbPath(startDir: string = process.cwd()): string | null {
+  let current = resolve(startDir);
+  while (true) {
+    const candidate = join(current, DB_DIR, DB_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+/**
+ * Initialize a new tasca DB in the given directory (default: cwd).
+ * Returns the absolute path of the created DB file.
+ */
+export function initDb(dir: string = process.cwd()): string {
+  const tascaDir = join(dir, DB_DIR);
+  const dbPath = join(tascaDir, DB_FILE);
+
+  if (!existsSync(tascaDir)) {
+    mkdirSync(tascaDir, { recursive: true });
+  }
+
+  const db = openSqlite(dbPath, { create: true });
+  db.run("PRAGMA foreign_keys = ON;");
+  applySchema(db);
+  db.close();
+
+  return dbPath;
+}
+
+/**
+ * Open the DB found by auto-discovery, or throw if none exists.
+ */
+export function openDb(): DbInstance {
+  const path = findDbPath();
+  if (!path) {
+    throw new Error(
+      `No tasca DB found. Run 'tasca init' to create one in the current directory.`,
+    );
+  }
+  const db = openSqlite(path);
+  db.run("PRAGMA foreign_keys = ON;");
+  // Apply any new statements that didn't exist when DB was created (safe due to IF NOT EXISTS).
+  applySchema(db);
+  return db;
+}
+
+/**
+ * Record an event in the events log (append-only audit trail).
+ */
+export function recordEvent(
+  db: DbInstance,
+  entityType: "task" | "spec" | "plan",
+  entityId: string,
+  eventType: string,
+  payload: object | null = null,
+  actor: string | null = null,
+): void {
+  db.prepare(
+    `INSERT INTO events (entity_type, entity_id, event_type, actor, payload)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(
+    entityType,
+    entityId,
+    eventType,
+    actor,
+    payload ? JSON.stringify(payload) : null,
+  );
+}

package/src/format.ts

@@ -0,0 +1,166 @@
+import type { Task } from "./tasks";
+import type { Spec, Plan } from "./specs";
+
+export type OutputFormat = "json" | "plain" | "color";
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+} as const;
+
+function c(format: OutputFormat, color: keyof typeof COLORS, text: string): string {
+  return format === "color" ? `${COLORS[color]}${text}${COLORS.reset}` : text;
+}
+
+const STATUS_COLOR: Record<string, keyof typeof COLORS> = {
+  pending: "yellow",
+  in_progress: "blue",
+  completed: "green",
+  failed: "red",
+  deleted: "gray",
+  lista: "yellow",
+  en_progreso: "blue",
+  hecha: "green",
+  archivada: "gray",
+};
+
+export function formatTask(task: Task, format: OutputFormat): string {
+  if (format === "json") return JSON.stringify(task, null, 2);
+
+  const color = STATUS_COLOR[task.status] ?? "reset";
+  const lines: string[] = [];
+  lines.push(`${c(format, "bold", task.id)} ${c(format, color, `[${task.status}]`)}`);
+  lines.push(`  ${task.subject}`);
+  if (task.spec_id) lines.push(`  ${c(format, "dim", "spec:")} ${task.spec_id}`);
+  if (task.owner) lines.push(`  ${c(format, "dim", "owner:")} ${task.owner}`);
+  if (task.worktree) lines.push(`  ${c(format, "dim", "worktree:")} ${task.worktree}`);
+  if (task.blocked_by.length)
+    lines.push(`  ${c(format, "dim", "blocked by:")} ${task.blocked_by.join(", ")}`);
+  if (task.packages.length)
+    lines.push(`  ${c(format, "dim", "packages:")} ${task.packages.join(", ")}`);
+  if (task.quality_gates.length) {
+    lines.push(`  ${c(format, "dim", "quality gates:")}`);
+    for (const gate of task.quality_gates) lines.push(`    - ${gate}`);
+  }
+  if (task.description) {
+    lines.push(`  ${c(format, "dim", "description:")}`);
+    for (const line of task.description.split("\n")) lines.push(`    ${line}`);
+  }
+  if (task.result) lines.push(`  ${c(format, "green", "result:")} ${task.result}`);
+  if (task.error) lines.push(`  ${c(format, "red", "error:")} ${task.error}`);
+  return lines.join("\n");
+}
+
+export function formatTaskList(tasks: Task[], format: OutputFormat): string {
+  if (format === "json") return JSON.stringify(tasks, null, 2);
+  if (tasks.length === 0) return c(format, "dim", "(no tasks)");
+
+  return tasks
+    .map((t) => {
+      const color = STATUS_COLOR[t.status] ?? "reset";
+      const spec = t.spec_id ? c(format, "dim", `[${t.spec_id}]`) : "";
+      const owner = t.owner ? c(format, "dim", ` @${t.owner}`) : "";
+      return `${c(format, "bold", t.id)} ${c(format, color, `[${t.status}]`)} ${spec}${owner}  ${t.subject}`;
+    })
+    .join("\n");
+}
+
+export function formatSpec(
+  spec: Spec,
+  format: OutputFormat,
+  opts: { includeContent?: boolean; plan?: Plan } = {},
+): string {
+  if (format === "json") {
+    const obj = opts.plan ? { ...spec, plan: opts.plan } : spec;
+    return JSON.stringify(obj, null, 2);
+  }
+
+  const color = STATUS_COLOR[spec.status] ?? "reset";
+  const lines: string[] = [];
+  lines.push(`${c(format, "bold", spec.id)} ${c(format, color, `[${spec.status}]`)}`);
+  lines.push(`  ${spec.title}`);
+  if (spec.pr) lines.push(`  ${c(format, "dim", "pr:")} ${spec.pr}`);
+  if (spec.merged_date)
+    lines.push(`  ${c(format, "dim", "merged:")} ${spec.merged_date}`);
+  if (spec.content) {
+    const bytes = spec.content.length;
+    lines.push(`  ${c(format, "dim", `content (${bytes} bytes):`)}`);
+    if (opts.includeContent) {
+      for (const line of spec.content.split("\n")) lines.push(`    ${line}`);
+    } else {
+      lines.push(`    ${c(format, "dim", "(use --full to view; tasca spec content " + spec.id + " to export)")}`);
+    }
+  }
+  if (opts.plan) {
+    lines.push(`  ${c(format, "dim", `plan (v${opts.plan.version}, ${opts.plan.content.length} bytes):`)}`);
+    if (opts.includeContent) {
+      for (const line of opts.plan.content.split("\n")) lines.push(`    ${line}`);
+    } else {
+      lines.push(`    ${c(format, "dim", "(use --full to view; tasca plan show " + spec.id + " to export)")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export function formatSpecList(specs: Spec[], format: OutputFormat): string {
+  if (format === "json") return JSON.stringify(specs, null, 2);
+  if (specs.length === 0) return c(format, "dim", "(no specs)");
+
+  return specs
+    .map((s) => {
+      const color = STATUS_COLOR[s.status] ?? "reset";
+      return `${c(format, "bold", s.id)} ${c(format, color, `[${s.status}]`)}  ${s.title}`;
+    })
+    .join("\n");
+}
+
+export function formatPlan(plan: Plan, format: OutputFormat, opts: { includeContent?: boolean } = {}): string {
+  if (format === "json") return JSON.stringify(plan, null, 2);
+  const lines: string[] = [];
+  lines.push(
+    `${c(format, "bold", `Plan #${plan.id}`)} ${c(format, "dim", `v${plan.version}`)}  spec: ${plan.spec_id}`,
+  );
+  lines.push(`  ${c(format, "dim", `created:`)} ${plan.created_at}`);
+  lines.push(`  ${c(format, "dim", `content (${plan.content.length} bytes):`)}`);
+  if (opts.includeContent) {
+    for (const line of plan.content.split("\n")) lines.push(`    ${line}`);
+  }
+  return lines.join("\n");
+}
+
+export function formatPlanList(plans: Plan[], format: OutputFormat): string {
+  if (format === "json") return JSON.stringify(plans, null, 2);
+  if (plans.length === 0) return c(format, "dim", "(no plans)");
+  return plans
+    .map(
+      (p) =>
+        `${c(format, "bold", `v${p.version}`)} ${c(format, "dim", `#${p.id}`)}  ${p.created_at}  ${p.content.length}B`,
+    )
+    .join("\n");
+}
+
+export function formatStatus(
+  stats: { pending: number; in_progress: number; completed: number; specs: number; plans: number; serverRunning?: boolean; serverPort?: number },
+  format: OutputFormat,
+): string {
+  if (format === "json") return JSON.stringify(stats, null, 2);
+  const serverLine = stats.serverRunning
+    ? c(format, "green", `server:      running → http://127.0.0.1:${stats.serverPort}`)
+    : c(format, "dim",   `server:      stopped  (tasca server -d to start)`);
+  return [
+    `${c(format, "yellow", `pending:     ${stats.pending}`)}`,
+    `${c(format, "blue",   `in_progress: ${stats.in_progress}`)}`,
+    `${c(format, "green",  `completed:   ${stats.completed}`)}`,
+    `${c(format, "dim",    `specs:       ${stats.specs}`)}`,
+    `${c(format, "dim",    `plans:       ${stats.plans}`)}`,
+    serverLine,
+  ].join("\n");
+}

package/src/opengit.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# opengit - Safe git wrapper for OpenCode worktree-only workflow
+#
+# This script enforces a whitelist of git commands and blocks operations
+# that could interfere with parallel worktree-based work by other agents.
+#
+# CRITICAL: OpenCode must use `opengit` instead of `git` for all operations.
+# Other agents work in worktrees simultaneously — no branch changes allowed.
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# ─────────────────────────────────────────────────────────────────────────
+# Allowed commands (whitelist-only)
+# ─────────────────────────────────────────────────────────────────────────
+
+# Worktree operations (primary workflow)
+ALLOW_WORKTREE=1
+
+# Read-only operations (status checks)
+ALLOW_STATUS=1
+ALLOW_DIFF=1
+ALLOW_LOG=1
+ALLOW_SHOW=1
+
+# Worktree lifecycle operations (add files, commit, push)
+ALLOW_ADD=1
+ALLOW_COMMIT=1
+ALLOW_PUSH=1
+
+# ─────────────────────────────────────────────────────────────────────────
+# Prohibited commands (explicit deny list)
+# ─────────────────────────────────────────────────────────────────────────
+
+PROHIBITED=(
+  "branch"         # No creating/deleting branches — use worktrees only
+  "checkout"       # No switching branches — stays in worktree
+  "switch"         # No switching branches — stays in worktree
+  "merge"          # No merging — prevents conflicts during parallel work
+  "rebase"         # No rebasing — prevents conflicts during parallel work
+  "reset"          # No destructive resets — preserves work
+  "tag"            # No tags — infrastructure operation, not workflow
+  "stash"          # No stashing — preserves all work in worktree
+  "cherry-pick"    # No cherry-picking — use proper merge instead
+  "fetch"          # No fetch — could introduce divergence
+  "pull"           # No pull — pull = fetch + merge, both problematic
+  "remote"         # No remote management — infrastructure operation
+  "clone"          # No clone — infrastructure operation
+  "rm"             # No rm — use standard shell tools
+  "mv"             # No mv — use standard shell tools
+  "clean"          # No clean — destructive, use explicit commands
+)
+
+# ─────────────────────────────────────────────────────────────────────────
+# Helper functions
+# ─────────────────────────────────────────────────────────────────────────
+
+die() {
+  echo -e "${RED}Error: $*${NC}" >&2
+  exit 1
+}
+
+warn() {
+  echo -e "${YELLOW}Warning: $*${NC}" >&2
+}
+
+# ─────────────────────────────────────────────────────────────────────────
+# Main logic
+# ─────────────────────────────────────────────────────────────────────────
+
+if [ $# -eq 0 ]; then
+  die "opengit requires a command (e.g., 'opengit worktree add', 'opengit commit -m ...')"
+fi
+
+cmd="$1"
+
+# Check if command is prohibited
+for prohibited_cmd in "${PROHIBITED[@]}"; do
+  if [ "$cmd" = "$prohibited_cmd" ]; then
+    die "'$cmd' is not allowed in worktree-only workflow (other agents work in parallel worktrees)"
+  fi
+done
+
+# Dispatch to allowed commands
+case "$cmd" in
+  worktree)
+    # All worktree subcommands allowed: add, remove, list, lock, unlock
+    exec /usr/bin/git "$@"
+    ;;
+  status|diff|log|show)
+    # Read-only status commands
+    exec /usr/bin/git "$@"
+    ;;
+  add)
+    # Stage files for commit (required in worktree lifecycle)
+    exec /usr/bin/git "$@"
+    ;;
+  commit)
+    # Create commits (required in worktree lifecycle)
+    exec /usr/bin/git "$@"
+    ;;
+  push)
+    # Push commits to remote (required in worktree lifecycle)
+    exec /usr/bin/git "$@"
+    ;;
+  complete)
+    # Sync main branch after a worktree push. Run from repo root.
+    exec /usr/bin/git pull --ff-only
+    ;;
+  *)
+    die "unknown or disallowed git command '$cmd' (not in whitelist)"
+    ;;
+esac