ndomo 0.1.0

package/src/db/migrations-v8.test.ts

@@ -0,0 +1,301 @@
+/**
+ * Tests for v6+v8 migrations — write-once audit fields.
+ *
+ * Validates:
+ * - original_plan_data is set on plan creation and NOT overwritten on status updates
+ * - created_by_agent is set on plan creation
+ * - executed_by_agent/session can be set but are not overwritten if already set
+ *
+ * Uses in-memory SQLite via bun:sqlite. Each test gets a fresh DB
+ * with the full schema applied by runMigrations.
+ */
+
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+import { runMigrations } from "./migrations.ts";
+import { approvePlan, createPlan, getPlan, getPlanProgress, updatePlanStatus } from "./plans.ts";
+import { createTasksBatch, getTask, updateTaskStatus } from "./tasks.ts";
+import type { Plan } from "./types.ts";
+
+let db: Database;
+
+beforeEach(() => {
+  db = new Database(":memory:");
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+});
+
+function makePlan(overrides: Partial<Parameters<typeof createPlan>[1]> = {}): Plan {
+  return createPlan(db, {
+    id: crypto.randomUUID(),
+    slug: "test-plan",
+    title: "Test",
+    status: "draft",
+    priority: 2,
+    approvedAt: null,
+    completedAt: null,
+    sessionId: null,
+    overview: "test",
+    approach: null,
+    complexity: 3,
+    createdBy: "test",
+    updatedBy: "test",
+    sourceSessionId: null,
+    sourceMessageId: null,
+    category: null,
+    metadata: {},
+    archivedAt: null,
+    ...overrides,
+  });
+}
+
+describe("v6: original_plan_data (write-once)", () => {
+  test("plan has original_plan_data after creation", () => {
+    const plan = makePlan();
+    const fetched = getPlan(db, plan.id);
+
+    expect(fetched).not.toBeNull();
+    const opd = fetched?.originalPlanData;
+    expect(opd).not.toBeNull();
+
+    const data = JSON.parse(opd as string);
+    expect(data.id).toBe(plan.id);
+    expect(data.slug).toBe("test-plan");
+    expect(data.title).toBe("Test");
+    expect(data.overview).toBe("test");
+    expect(data.createdBy).toBe("test");
+  });
+
+  test("original_plan_data is NOT overwritten on status update", () => {
+    const plan = makePlan();
+    const beforeRaw = getPlan(db, plan.id);
+    expect(beforeRaw).not.toBeNull();
+    const before = beforeRaw as Plan;
+    const originalData = before.originalPlanData;
+
+    // Update status — should NOT touch original_plan_data
+    updatePlanStatus(db, plan.id, "approved", { updatedBy: "admin" });
+
+    const afterRaw = getPlan(db, plan.id);
+    expect(afterRaw).not.toBeNull();
+    const after = afterRaw as Plan;
+    expect(after.originalPlanData).toBe(originalData);
+  });
+
+  test("original_plan_data is NOT overwritten on approve", () => {
+    const plan = makePlan();
+    const beforeRaw = getPlan(db, plan.id);
+    expect(beforeRaw).not.toBeNull();
+    const before = beforeRaw as Plan;
+    const originalData = before.originalPlanData;
+
+    approvePlan(db, plan.id, { updatedBy: "admin" });
+
+    const afterRaw = getPlan(db, plan.id);
+    expect(afterRaw).not.toBeNull();
+    const after = afterRaw as Plan;
+    expect(after.originalPlanData).toBe(originalData);
+  });
+
+  test("task has original_plan_data after creation", () => {
+    const plan = makePlan();
+    const tasks = createTasksBatch(db, plan.id, [
+      {
+        orderIndex: 0,
+        description: "test task",
+        agent: "js-smith",
+        files: ["src/index.ts"],
+        complexity: 2,
+        dependencies: [],
+        createdBy: "foreman",
+        updatedBy: "foreman",
+        sourceSessionId: null,
+        sourceMessageId: null,
+        reviewedBy: null,
+        tokensUsed: null,
+        durationMs: null,
+        artifacts: [],
+        metadata: {},
+      },
+    ]);
+
+    const taskOpd = tasks[0]?.originalPlanData;
+    expect(taskOpd).not.toBeNull();
+    const data = JSON.parse(taskOpd as string);
+    expect(data.description).toBe("test task");
+    expect(data.agent).toBe("js-smith");
+    expect(data.files).toEqual(["src/index.ts"]);
+  });
+
+  test("task original_plan_data is NOT overwritten on status update", () => {
+    const plan = makePlan();
+    const tasks = createTasksBatch(db, plan.id, [
+      {
+        orderIndex: 0,
+        description: "test task",
+        agent: "js-smith",
+        files: [],
+        complexity: 1,
+        dependencies: [],
+        createdBy: "test",
+        updatedBy: "test",
+        sourceSessionId: null,
+        sourceMessageId: null,
+        reviewedBy: null,
+        tokensUsed: null,
+        durationMs: null,
+        artifacts: [],
+        metadata: {},
+      },
+    ]);
+
+    const originalData = tasks[0]?.originalPlanData;
+
+    // Update task status — should NOT touch original_plan_data
+    const t0id = tasks[0]?.id as string;
+    updateTaskStatus(db, t0id, "running");
+
+    const updated = getTask(db, t0id);
+
+    expect(updated?.originalPlanData).toBe(originalData);
+  });
+});
+
+describe("v8: created_by_agent (write-once)", () => {
+  test("plan has created_by_agent after creation", () => {
+    const plan = makePlan({ createdByAgent: "foreman" });
+    const fetched = getPlan(db, plan.id);
+
+    expect(fetched).not.toBeNull();
+    expect(fetched?.createdByAgent).toBe("foreman");
+  });
+
+  test("created_by_agent defaults to null when not provided", () => {
+    const plan = makePlan(); // no createdByAgent
+    const fetched = getPlan(db, plan.id);
+
+    expect(fetched?.createdByAgent).toBeNull();
+  });
+});
+
+describe("v8: executed_by_agent/session", () => {
+  test("executed_by_agent and executed_by_session are null on creation", () => {
+    const plan = makePlan();
+    const fetched = getPlan(db, plan.id);
+
+    expect(fetched?.executedByAgent).toBeNull();
+    expect(fetched?.executedBySession).toBeNull();
+  });
+
+  test("can be set via direct SQL update", () => {
+    const plan = makePlan();
+
+    db.query("UPDATE plans SET executed_by_agent = ?, executed_by_session = ? WHERE id = ?").run(
+      "craftsman",
+      "ses_123",
+      plan.id,
+    );
+
+    const fetched = getPlan(db, plan.id);
+    expect(fetched?.executedByAgent).toBe("craftsman");
+    expect(fetched?.executedBySession).toBe("ses_123");
+  });
+
+  test("updatePlanStatus sets executed_by_agent on first executing transition", () => {
+    const plan = makePlan();
+    // createPlan returns the spread input which may have undefined for optional fields
+    // The DB stores null, but the TS object preserves the input shape
+    expect(plan.executedByAgent ?? null).toBeNull();
+
+    updatePlanStatus(db, plan.id, "executing", {
+      executedByAgent: "craftsman",
+      executedBySession: "ses_exec_1",
+    });
+
+    const fetched = getPlan(db, plan.id);
+    expect(fetched?.executedByAgent).toBe("craftsman");
+    expect(fetched?.executedBySession).toBe("ses_exec_1");
+  });
+
+  test("updatePlanStatus does NOT overwrite executed_by_agent on second executing", () => {
+    const plan = makePlan();
+
+    // First executing
+    updatePlanStatus(db, plan.id, "executing", {
+      executedByAgent: "craftsman",
+      executedBySession: "ses_first",
+    });
+
+    // Second executing with different agent — should NOT overwrite
+    updatePlanStatus(db, plan.id, "executing", {
+      executedByAgent: "go-smith",
+      executedBySession: "ses_second",
+    });
+
+    const fetched = getPlan(db, plan.id);
+    expect(fetched?.executedByAgent).toBe("craftsman");
+    expect(fetched?.executedBySession).toBe("ses_first");
+  });
+});
+
+// ─── Critical 2: v9 migration — plan_progress excludes archived ─────────────
+
+describe("v9: plan_progress view fix", () => {
+  test("DB with schema_version=5 → runMigrations → schema_version=15", () => {
+    // Fresh DB already runs all migrations up to v15
+    const row = db.query("SELECT MAX(version) as version FROM schema_version").get() as {
+      version: number;
+    };
+    expect(row.version).toBe(15);
+  });
+
+  test("plan_progress excludes archived plans", () => {
+    const active = createPlan(db, {
+      id: crypto.randomUUID(),
+      slug: "active",
+      title: "Active",
+      status: "draft",
+      priority: 2,
+      approvedAt: null,
+      completedAt: null,
+      sessionId: null,
+      overview: "test",
+      approach: null,
+      complexity: 3,
+      createdBy: "test",
+      updatedBy: "test",
+      sourceSessionId: null,
+      sourceMessageId: null,
+      category: null,
+      metadata: {},
+      archivedAt: null,
+    });
+    const archived = createPlan(db, {
+      id: crypto.randomUUID(),
+      slug: "archived",
+      title: "Archived",
+      status: "draft",
+      priority: 2,
+      approvedAt: null,
+      completedAt: null,
+      sessionId: null,
+      overview: "test",
+      approach: null,
+      complexity: 3,
+      createdBy: "test",
+      updatedBy: "test",
+      sourceSessionId: null,
+      sourceMessageId: null,
+      category: null,
+      metadata: {},
+      archivedAt: null,
+    });
+
+    // Archive second plan
+    db.query("UPDATE plans SET archived_at = ? WHERE id = ?").run(Date.now(), archived.id);
+
+    const progress = getPlanProgress(db);
+    expect(progress).toHaveLength(1);
+    expect(progress[0]?.planId).toBe(active.id);
+  });
+});

package/src/db/migrations.ts

@@ -0,0 +1,147 @@
+/**
+ * ndomo DB — Migration runner.
+ *
+ * Reads MIGRATIONS from schema.ts, compares against schema_version,
+ * and applies pending migrations in a transaction.
+ */
+
+import type { Database } from "bun:sqlite";
+import { MIGRATIONS } from "./schema.ts";
+
+/**
+ * Add a column to a table if it doesn't already exist.
+ * Uses PRAGMA table_info to check — the only reliable idempotent pattern
+ * for SQLite 3.45 which lacks ALTER TABLE ADD COLUMN IF NOT EXISTS.
+ */
+function addColumnIfMissing(db: Database, table: string, column: string, type: string): void {
+  const cols = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  if (!cols.some((c) => c.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+  }
+}
+
+/**
+ * v15: backfill — rename finding keys inside analyses.findings_json.
+ *
+ * - description     → observation
+ * - recommendation  → proposedAction
+ *
+ * Idempotent: rows already renamed are skipped (presence of `observation`
+ * key signals the rename has already happened for that finding). Returns
+ * the number of findings renamed.
+ *
+ * Pure data migration — no DDL. Safe to call repeatedly.
+ */
+export function backfillAnalysisFindings(db: Database): number {
+  const rows = db
+    .query("SELECT id, findings_json FROM analyses")
+    .all() as Array<{ id: string; findings_json: string }>;
+
+  let renamed = 0;
+  const txn = db.transaction(() => {
+    for (const row of rows) {
+      let findings: unknown;
+      try {
+        findings = JSON.parse(row.findings_json);
+      } catch {
+        // Skip malformed JSON — leave row untouched
+        continue;
+      }
+      if (!Array.isArray(findings) || findings.length === 0) continue;
+
+      let mutated = false;
+      const next = findings.map((f: unknown) => {
+        if (f === null || typeof f !== "object") return f;
+        const obj = f as Record<string, unknown>;
+        // Skip if already renamed
+        if ("observation" in obj) return f;
+
+        const renamed_finding: Record<string, unknown> = { ...obj };
+        if ("description" in renamed_finding) {
+          renamed_finding.observation = renamed_finding.description;
+          delete renamed_finding.description;
+          mutated = true;
+        }
+        if ("recommendation" in renamed_finding) {
+          renamed_finding.proposedAction = renamed_finding.recommendation;
+          delete renamed_finding.recommendation;
+          mutated = true;
+        }
+        return renamed_finding;
+      });
+
+      if (mutated) {
+        renamed += next.length;
+        db.query("UPDATE analyses SET findings_json = ? WHERE id = ?").run(
+          JSON.stringify(next),
+          row.id,
+        );
+      }
+    }
+  });
+  txn();
+  return renamed;
+}
+
+export function runMigrations(db: Database): void {
+  // Ensure schema_version table exists first
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL, description TEXT);",
+  );
+
+  // Get current version
+  const row = db
+    .query<{ version: number }, []>("SELECT MAX(version) as version FROM schema_version")
+    .get();
+  const current = row?.version ?? 0;
+
+  // Apply pending migrations
+  for (const m of MIGRATIONS) {
+    if (m.version > current) {
+      const txn = db.transaction(() => {
+        // v5: add archived_at columns BEFORE running SQL that creates indexes
+        // on those columns. SQLite 3.45 lacks ADD COLUMN IF NOT EXISTS, so we
+        // check PRAGMA table_info first (addColumnIfMissing helper).
+        if (m.version === 5) {
+          addColumnIfMissing(db, "plans", "archived_at", "INTEGER");
+          addColumnIfMissing(db, "plan_tasks", "archived_at", "INTEGER");
+          addColumnIfMissing(db, "sessions", "archived_at", "INTEGER");
+        }
+
+        // v6: write-once audit trail — original_plan_data on plans + plan_tasks
+        if (m.version === 6) {
+          addColumnIfMissing(db, "plans", "original_plan_data", "TEXT");
+          addColumnIfMissing(db, "plan_tasks", "original_plan_data", "TEXT");
+        }
+
+        // v8: agent execution tracking on plans
+        if (m.version === 8) {
+          addColumnIfMissing(db, "plans", "created_by_agent", "TEXT");
+          addColumnIfMissing(db, "plans", "executed_by_agent", "TEXT");
+          addColumnIfMissing(db, "plans", "executed_by_session", "TEXT");
+        }
+
+        // v15: backfill finding keys (description→observation, recommendation→proposedAction)
+        // Data-only migration — runs in same transaction so a failure rolls back the
+        // schema_version insert (which would otherwise leave an inconsistent state).
+        if (m.version === 15) {
+          backfillAnalysisFindings(db);
+        }
+
+        // Execute SQL only if it contains actual statements (not just comments)
+        const hasStatements = m.sql.split("\n").some((line) => {
+          const trimmed = line.trim();
+          return trimmed.length > 0 && !trimmed.startsWith("--");
+        });
+        if (hasStatements) {
+          db.exec(m.sql);
+        }
+
+        db.query(
+          "INSERT INTO schema_version (version, applied_at, description) VALUES (?, ?, ?)",
+        ).run(m.version, Date.now(), m.description);
+      });
+      txn();
+    }
+  }
+}

package/src/db/plan-archive.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Tests for plan-archive serialization — verifies original_plan_data inclusion.
+ *
+ * Uses in-memory SQLite via bun:sqlite. Each test gets a fresh DB
+ * with the full schema applied by runMigrations.
+ */
+
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+import { runMigrations } from "./migrations.ts";
+import { serializePlanToMarkdown } from "./plan-archive.ts";
+import { createPlan } from "./plans.ts";
+import type { Plan } from "./types.ts";
+
+let db: Database;
+
+beforeEach(() => {
+  db = new Database(":memory:");
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+});
+
+function makePlan(overrides: Partial<Parameters<typeof createPlan>[1]> = {}): Plan {
+  return createPlan(db, {
+    id: crypto.randomUUID(),
+    slug: "test-plan",
+    title: "Test",
+    status: "draft",
+    priority: 2,
+    approvedAt: null,
+    completedAt: null,
+    sessionId: null,
+    overview: "test overview",
+    approach: null,
+    complexity: 3,
+    createdBy: "test",
+    updatedBy: "test",
+    sourceSessionId: null,
+    sourceMessageId: null,
+    category: null,
+    metadata: {},
+    archivedAt: null,
+    ...overrides,
+  });
+}
+
+describe("serializePlanToMarkdown", () => {
+  test("includes original_plan_data section when present", () => {
+    const plan = makePlan();
+    // originalPlanData is set by createPlan
+    const opd = plan.originalPlanData;
+    expect(opd).not.toBeNull();
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    expect(md).toContain("## Original Plan Data (write-once)");
+    expect(md).toContain("```json");
+    expect(md).toContain(opd as string);
+  });
+
+  test("omits original_plan_data section when null", () => {
+    // Construct a raw Plan object without going through createPlan
+    // (createPlan always sets originalPlanData)
+    const plan: Plan = {
+      id: crypto.randomUUID(),
+      slug: "no-opd",
+      title: "No OPD",
+      status: "draft",
+      priority: 2,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      approvedAt: null,
+      completedAt: null,
+      sessionId: null,
+      overview: "test",
+      approach: null,
+      complexity: 3,
+      createdBy: "test",
+      updatedBy: "test",
+      sourceSessionId: null,
+      sourceMessageId: null,
+      category: null,
+      metadata: {},
+      archivedAt: null,
+      originalPlanData: null,
+    };
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    expect(md).not.toContain("## Original Plan Data (write-once)");
+  });
+
+  test("includes agent trail section when createdByAgent is set", () => {
+    const plan = makePlan({ createdByAgent: "foreman" });
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    expect(md).toContain("## Agent Trail");
+    expect(md).toContain("**Created by agent:** foreman");
+  });
+
+  test("includes executed_by_agent when set", () => {
+    const plan = makePlan({
+      createdByAgent: "foreman",
+      executedByAgent: "craftsman",
+      executedBySession: "ses_123",
+    });
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    expect(md).toContain("**Executed by agent:** craftsman");
+    expect(md).toContain("**Executed by session:** ses_123");
+  });
+
+  test("JSON with triple backticks does not break markdown", () => {
+    // Construct plan with originalPlanData containing triple backticks
+    const plan: Plan = {
+      id: crypto.randomUUID(),
+      slug: "backtick-test",
+      title: "Backtick Test",
+      status: "draft",
+      priority: 2,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      approvedAt: null,
+      completedAt: null,
+      sessionId: null,
+      overview: "test",
+      approach: null,
+      complexity: 3,
+      createdBy: "test",
+      updatedBy: "test",
+      sourceSessionId: null,
+      sourceMessageId: null,
+      category: null,
+      metadata: {},
+      archivedAt: null,
+      originalPlanData: '{"code":"```js\\nconsole.log(1)\\n```"}',
+    };
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    // Should contain the sanitized version
+    expect(md).toContain("## Original Plan Data (write-once)");
+    // The triple backticks should be escaped so inner code blocks don't break markdown
+    expect(md).not.toContain("```js\nconsole.log(1)\n```");
+    // Verify the escaped version is present instead
+    expect(md).toContain("\\`\\`\\`js");
+  });
+
+  test("JSON without triple backticks is unmodified", () => {
+    const plan: Plan = {
+      id: crypto.randomUUID(),
+      slug: "normal-test",
+      title: "Normal Test",
+      status: "draft",
+      priority: 2,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      approvedAt: null,
+      completedAt: null,
+      sessionId: null,
+      overview: "test",
+      approach: null,
+      complexity: 3,
+      createdBy: "test",
+      updatedBy: "test",
+      sourceSessionId: null,
+      sourceMessageId: null,
+      category: null,
+      metadata: {},
+      archivedAt: null,
+      originalPlanData: '{"slug":"test","title":"Test"}',
+    };
+
+    const md = serializePlanToMarkdown(plan, [], [], Date.now());
+
+    expect(md).toContain('{"slug":"test","title":"Test"}');
+  });
+});