feinai 0.5.0

package/src/specs.ts

@@ -0,0 +1,289 @@
+import type { DbInstance } from "./db";
+import { recordEvent } from "./db";
+
+export type SpecStatus = "lista" | "en_progreso" | "hecha" | "archivada";
+
+export interface Spec {
+  id: string;
+  numero: number | null;
+  title: string;
+  status: SpecStatus;
+  content: string | null;
+  pr: string | null;
+  merged_date: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface Plan {
+  id: number;
+  spec_id: string;
+  content: string;
+  version: number;
+  created_at: string;
+}
+
+export interface AddSpecInput {
+  id: string;
+  title: string;
+  numero?: number;
+  content?: string;
+}
+
+export function listSpecs(db: DbInstance, status?: SpecStatus): Spec[] {
+  const sql = status
+    ? "SELECT * FROM specs WHERE status = ? ORDER BY numero ASC"
+    : "SELECT * FROM specs ORDER BY numero ASC";
+  const args = status ? [status] : [];
+  return db.prepare(sql).all(...args) as Spec[];
+}
+
+export function getSpec(db: DbInstance, id: string): Spec | null {
+  return db.prepare("SELECT * FROM specs WHERE id = ?").get(id) as Spec | null;
+}
+
+export function addSpec(db: DbInstance, input: AddSpecInput, actor: string | null = null): Spec {
+  // Auto-extract numero from id if not provided (e.g., SPEC-121 → 121)
+  let numero = input.numero;
+  if (numero === undefined) {
+    const match = input.id.match(/(\d+)$/);
+    numero = match ? Number(match[1]) : null as unknown as number;
+  }
+
+  db.prepare(
+    `INSERT INTO specs (id, numero, title, content)
+     VALUES (?, ?, ?, ?)`,
+  ).run(input.id, numero ?? null, input.title, input.content ?? null);
+
+  recordEvent(db, "spec", input.id, "created", { title: input.title }, actor);
+
+  return getSpec(db, input.id) as Spec;
+}
+
+export function startSpec(db: DbInstance, id: string, actor: string | null = null): Spec {
+  const upd = db
+    .prepare(
+      `UPDATE specs SET status = 'en_progreso', updated_at = datetime('now')
+       WHERE id = ? AND status = 'lista'`,
+    )
+    .run(id);
+
+  if (upd.changes === 0) {
+    const existing = getSpec(db, id);
+    if (!existing) throw new Error(`Spec ${id} not found`);
+    throw new Error(`Spec ${id} cannot be started (status: ${existing.status})`);
+  }
+
+  recordEvent(db, "spec", id, "started", null, actor);
+  return getSpec(db, id) as Spec;
+}
+
+export function doneSpec(
+  db: DbInstance,
+  id: string,
+  opts: { pr?: string; merged_date?: string } = {},
+  actor: string | null = null,
+): Spec {
+  const upd = db
+    .prepare(
+      `UPDATE specs SET status = 'hecha',
+        pr = COALESCE(?, pr),
+        merged_date = COALESCE(?, merged_date),
+        updated_at = datetime('now')
+       WHERE id = ?`,
+    )
+    .run(opts.pr ?? null, opts.merged_date ?? null, id);
+
+  if (upd.changes === 0) {
+    throw new Error(`Spec ${id} not found`);
+  }
+
+  recordEvent(db, "spec", id, "completed", opts, actor);
+  return getSpec(db, id) as Spec;
+}
+
+/**
+ * Update the spec's markdown content. Useful when brainstorming refines a spec.
+ */
+export function setSpecContent(
+  db: DbInstance,
+  id: string,
+  content: string,
+  actor: string | null = null,
+): Spec {
+  const upd = db
+    .prepare(
+      `UPDATE specs SET content = ?, updated_at = datetime('now') WHERE id = ?`,
+    )
+    .run(content, id);
+
+  if (upd.changes === 0) throw new Error(`Spec ${id} not found`);
+  recordEvent(db, "spec", id, "content_updated", { bytes: content.length }, actor);
+  return getSpec(db, id) as Spec;
+}
+
+export interface EditSpecInput {
+  title?: string;
+}
+
+export function editSpec(
+  db: DbInstance,
+  id: string,
+  input: EditSpecInput,
+  actor: string | null = null,
+): Spec {
+  if (input.title === undefined) {
+    throw new Error('editSpec: provide at least one field to edit');
+  }
+
+  const spec = getSpec(db, id);
+  if (!spec) throw new Error(`Spec ${id} not found`);
+
+  const sets: string[] = ["updated_at = datetime('now')"];
+  const args: (string | null)[] = [];
+  const changed: Record<string, unknown> = {};
+
+  if (input.title !== undefined) {
+    sets.push('title = ?');
+    args.push(input.title);
+    changed.title = input.title;
+  }
+
+  args.push(id);
+  db.prepare(`UPDATE specs SET ${sets.join(', ')} WHERE id = ?`).run(...args);
+  recordEvent(db, 'spec', id, 'edited', changed, actor);
+
+  return getSpec(db, id) as Spec;
+}
+
+/**
+ * Add a new plan revision for a spec. Each new plan gets the next version number.
+ */
+export function addPlan(
+  db: DbInstance,
+  specId: string,
+  content: string,
+  actor: string | null = null,
+): Plan {
+  const spec = getSpec(db, specId);
+  if (!spec) throw new Error(`Spec ${specId} not found`);
+
+  const row = db
+    .prepare(
+      `SELECT COALESCE(MAX(version), 0) AS max_version FROM plans WHERE spec_id = ?`,
+    )
+    .get(specId) as { max_version: number };
+
+  const nextVersion = row.max_version + 1;
+
+  const insert = db
+    .prepare(
+      `INSERT INTO plans (spec_id, content, version) VALUES (?, ?, ?)
+       RETURNING *`,
+    )
+    .get(specId, content, nextVersion) as Plan;
+
+  recordEvent(
+    db,
+    "plan",
+    String(insert.id),
+    "created",
+    { spec_id: specId, version: nextVersion, bytes: content.length },
+    actor,
+  );
+
+  return insert;
+}
+
+/**
+ * Get the latest plan for a spec, or null if no plan exists.
+ */
+export function getLatestPlan(db: DbInstance, specId: string): Plan | null {
+  return db
+    .prepare(
+      `SELECT * FROM plans WHERE spec_id = ? ORDER BY version DESC LIMIT 1`,
+    )
+    .get(specId) as Plan | null;
+}
+
+/**
+ * Get all plans for a spec (history), ordered oldest → newest.
+ */
+export function listPlans(db: DbInstance, specId: string): Plan[] {
+  return db
+    .prepare(`SELECT * FROM plans WHERE spec_id = ? ORDER BY version ASC`)
+    .all(specId) as Plan[];
+}
+
+/**
+ * Archive a spec and unassign its tasks so they disappear from active task lists.
+ */
+export function archiveSpec(
+  db: DbInstance,
+  id: string,
+  actor: string | null = null,
+): Spec {
+  const spec = getSpec(db, id);
+  if (!spec) throw new Error(`Spec ${id} not found`);
+
+  const upd = db
+    .prepare(
+      `UPDATE specs SET status = 'archivada', updated_at = datetime('now') WHERE id = ?`,
+    )
+    .run(id);
+
+  if (upd.changes === 0) throw new Error(`Spec ${id} could not be archived`);
+
+  // Unassign owner and set status to pending for all related tasks so they leave active lists
+  db.prepare(
+    `UPDATE tasks SET status = 'pending', owner = NULL, taken_at = NULL, updated_at = datetime('now') WHERE spec_id = ?`,
+  ).run(id);
+
+  recordEvent(db, "spec", id, "archived", { title: spec.title }, actor);
+  return getSpec(db, id) as Spec;
+}
+
+/**
+ * Unarchive a spec — restore it to active work.
+ */
+export function unarchiveSpec(
+  db: DbInstance,
+  id: string,
+  actor: string | null = null,
+): Spec {
+  const spec = getSpec(db, id);
+  if (!spec) throw new Error(`Spec ${id} not found`);
+
+  const upd = db
+    .prepare(
+      `UPDATE specs SET status = 'lista', updated_at = datetime('now') WHERE id = ? AND status = 'archivada'`,
+    )
+    .run(id);
+
+  if (upd.changes === 0) throw new Error(`Spec ${id} is not archived`);
+
+  recordEvent(db, "spec", id, "unarchived", { title: spec.title }, actor);
+  return getSpec(db, id) as Spec;
+}
+
+/**
+ * Delete a spec and all related data (plans, tasks) in cascade.
+ */
+export function deleteSpec(
+  db: DbInstance,
+  id: string,
+  actor: string | null = null,
+): { deleted: boolean } {
+  const spec = getSpec(db, id);
+  if (!spec) throw new Error(`Spec ${id} not found`);
+
+  // Delete related tasks first (foreign key, though SQLite may not enforce without PRAGMA)
+  db.prepare(`DELETE FROM tasks WHERE spec_id = ?`).run(id);
+  // Delete plans
+  db.prepare(`DELETE FROM plans WHERE spec_id = ?`).run(id);
+  // Delete spec
+  db.prepare(`DELETE FROM specs WHERE id = ?`).run(id);
+
+  recordEvent(db, "spec", id, "deleted", { title: spec.title }, actor);
+  return { deleted: true };
+}

package/src/sqlite-adapter.ts

@@ -0,0 +1,130 @@
+/**
+ * SQLite backend detection and thin adapter.
+ *
+ * Tries backends in order (least to most external deps):
+ *   1. bun:sqlite      — built-in when running under Bun
+ *   2. node:sqlite     — built-in since Node 22.5 (experimental)
+ *   3. better-sqlite3  — npm optional dependency
+ *
+ * All three share the same synchronous .prepare().run/.get/.all API,
+ * so the adapter surface is minimal.
+ */
+
+export interface Statement {
+  run(...args: unknown[]): { changes: number; lastInsertRowid: number | bigint };
+  get(...args: unknown[]): unknown;
+  all(...args: unknown[]): unknown[];
+}
+
+export interface DbAdapter {
+  prepare(sql: string): Statement;
+  run(sql: string, ...args: unknown[]): void;
+  close(): void;
+}
+
+type DbConstructor = (path: string, options?: { create?: boolean }) => DbAdapter;
+
+// ---- backend loaders -------------------------------------------------------
+
+function loadBun(): DbConstructor | null {
+  try {
+    // Only attempt if we're actually running under Bun
+    if (typeof (globalThis as unknown as { Bun?: unknown }).Bun === "undefined") return null;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Database } = require("bun:sqlite") as { Database: new (path: string, opts?: { create?: boolean }) => DbAdapter };
+    return (path, opts) => new Database(path, opts);
+  } catch {
+    return null;
+  }
+}
+
+function loadNodeSqlite(): DbConstructor | null {
+  try {
+    // node:sqlite is available in Node 22.5+ (experimental)
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { DatabaseSync } = require("node:sqlite") as {
+      DatabaseSync: new (path: string, opts?: { open?: boolean }) => {
+        prepare(sql: string): {
+          run(...args: unknown[]): { changes: number; lastInsertRowid: number | bigint };
+          get(...args: unknown[]): unknown;
+          all(...args: unknown[]): unknown[];
+        };
+        exec(sql: string): void;
+        close(): void;
+      };
+    };
+    return (path, opts) => {
+      const raw = new DatabaseSync(path, { open: opts?.create !== false });
+      return {
+        prepare: (sql) => raw.prepare(sql),
+        run: (sql, ...args) => {
+          if (args.length === 0) {
+            raw.exec(sql);
+          } else {
+            raw.prepare(sql).run(...args);
+          }
+        },
+        close: () => raw.close(),
+      };
+    };
+  } catch {
+    return null;
+  }
+}
+
+function loadBetterSqlite3(): DbConstructor | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const BetterSqlite3 = require("better-sqlite3") as new (path: string, opts?: { readonly?: boolean }) => {
+      prepare(sql: string): Statement;
+      exec(sql: string): void;
+      close(): void;
+    };
+    return (path) => {
+      const raw = new BetterSqlite3(path);
+      return {
+        prepare: (sql) => raw.prepare(sql),
+        run: (sql, ...args) => {
+          if (args.length === 0) {
+            raw.exec(sql);
+          } else {
+            raw.prepare(sql).run(...args);
+          }
+        },
+        close: () => raw.close(),
+      };
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ---- public API ------------------------------------------------------------
+
+let _constructor: DbConstructor | null | undefined = undefined;
+
+export function getSqliteConstructor(): DbConstructor {
+  if (_constructor !== undefined) return _constructor!;
+
+  _constructor =
+    loadBun() ??
+    loadNodeSqlite() ??
+    loadBetterSqlite3() ??
+    null;
+
+  if (!_constructor) {
+    console.error(`
+Error: No SQLite backend found. tasca requires one of:
+  • Bun 1.0+       (current runtime)
+  • Node.js 22.5+  (built-in node:sqlite)
+  • better-sqlite3 (npm install -g better-sqlite3)
+`);
+    process.exit(1);
+  }
+
+  return _constructor;
+}
+
+export function openSqlite(path: string, opts?: { create?: boolean }): DbAdapter {
+  return getSqliteConstructor()(path, opts);
+}