ndomo 0.1.0

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

@@ -0,0 +1,289 @@
+/**
+ * Tests for plan_files join table (v7 migration).
+ *
+ * Validates:
+ * - Insert and query plan_files
+ * - CASCADE delete when plan is deleted
+ * - Composite primary key (plan_id, file_path)
+ *
+ * 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 { createPlan, deletePlan } 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",
+    approach: null,
+    complexity: 3,
+    createdBy: "test",
+    updatedBy: "test",
+    sourceSessionId: null,
+    sourceMessageId: null,
+    category: null,
+    metadata: {},
+    archivedAt: null,
+    ...overrides,
+  });
+}
+
+describe("plan_files", () => {
+  test("insert and query plan files", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/index.ts",
+      "input",
+    );
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "README.md",
+      "reference",
+    );
+
+    const rows = db
+      .query("SELECT * FROM plan_files WHERE plan_id = ? ORDER BY file_path")
+      .all(plan.id) as Array<{ plan_id: string; file_path: string; role: string }>;
+
+    expect(rows).toHaveLength(2);
+    expect(rows[0]?.file_path).toBe("README.md");
+    expect(rows[0]?.role).toBe("reference");
+    expect(rows[1]?.file_path).toBe("src/index.ts");
+    expect(rows[1]?.role).toBe("input");
+  });
+
+  test("multi-role inserts allowed (same file_path, different roles)", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/index.ts",
+      "input",
+    );
+
+    // v10: same file_path with different role is ALLOWED (multi-role PK)
+    expect(() => {
+      db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+        plan.id,
+        "src/index.ts",
+        "output",
+      );
+    }).not.toThrow();
+
+    // Both rows exist
+    const rows = db
+      .query("SELECT * FROM plan_files WHERE plan_id = ? AND file_path = ?")
+      .all(plan.id, "src/index.ts") as Array<{ role: string }>;
+    expect(rows).toHaveLength(2);
+    expect(rows.map((r) => r.role).sort()).toEqual(["input", "output"]);
+  });
+
+  test("CASCADE delete removes plan_files when plan is deleted", () => {
+    const plan = makePlan({ status: "approved" });
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/index.ts",
+      "input",
+    );
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "README.md",
+      "reference",
+    );
+
+    // Verify files exist
+    const before = db
+      .query("SELECT COUNT(*) as count FROM plan_files WHERE plan_id = ?")
+      .get(plan.id) as { count: number };
+    expect(before.count).toBe(2);
+
+    // Delete plan — CASCADE should remove plan_files
+    deletePlan(db, plan.id, { confirm: true });
+
+    // Verify files are gone
+    const after = db
+      .query("SELECT COUNT(*) as count FROM plan_files WHERE plan_id = ?")
+      .get(plan.id) as { count: number };
+    expect(after.count).toBe(0);
+  });
+
+  test("default role is 'input'", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path) VALUES (?, ?)").run(
+      plan.id,
+      "src/utils.ts",
+    );
+
+    const row = db
+      .query("SELECT role FROM plan_files WHERE plan_id = ? AND file_path = ?")
+      .get(plan.id, "src/utils.ts") as { role: string };
+
+    expect(row.role).toBe("input");
+  });
+
+  test("multi-role: same file_path with 3 roles all exist", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "input",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "modified",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "reviewed",
+    );
+
+    const rows = db
+      .query("SELECT * FROM plan_files WHERE plan_id = ? AND file_path = ?")
+      .all(plan.id, "src/main.ts") as Array<{ role: string }>;
+    expect(rows).toHaveLength(3);
+    expect(rows.map((r) => r.role).sort()).toEqual(["input", "modified", "reviewed"]);
+  });
+
+  test("created_at column auto-populated on insert", () => {
+    const plan = makePlan();
+    // strftime('%s','now')*1000 has second-precision (ends in 000ms)
+    // so floor before to second boundary for comparison
+    const beforeSec = Math.floor(Date.now() / 1000) * 1000;
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/test.ts",
+      "input",
+    );
+
+    const afterSec = Math.ceil(Date.now() / 1000) * 1000;
+
+    const row = db
+      .query("SELECT created_at FROM plan_files WHERE plan_id = ? AND file_path = ?")
+      .get(plan.id, "src/test.ts") as { created_at: number };
+
+    expect(row.created_at).toBeGreaterThanOrEqual(beforeSec);
+    expect(row.created_at).toBeLessThanOrEqual(afterSec);
+  });
+
+  test("query by role filter returns only matching rows", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/a.ts",
+      "input",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/a.ts",
+      "modified",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/b.ts",
+      "modified",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/c.ts",
+      "reviewed",
+    );
+
+    const modified = db
+      .query("SELECT * FROM plan_files WHERE plan_id = ? AND role = ?")
+      .all(plan.id, "modified") as Array<{ file_path: string }>;
+    expect(modified).toHaveLength(2);
+    expect(modified.map((r) => r.file_path).sort()).toEqual(["src/a.ts", "src/b.ts"]);
+  });
+
+  test("duplicate (plan_id, file_path, role) triple still throws", () => {
+    const plan = makePlan();
+
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "input",
+    );
+
+    // Same triple insert should throw (PK violation)
+    expect(() => {
+      db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+        plan.id,
+        "src/main.ts",
+        "input",
+      );
+    }).toThrow();
+  });
+
+  test("CASCADE delete removes all role rows for plan files", () => {
+    const plan = makePlan({ status: "approved" });
+
+    // Insert same file with 3 roles
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "input",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "modified",
+    );
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "src/main.ts",
+      "reviewed",
+    );
+    // Insert different file
+    db.query("INSERT INTO plan_files (plan_id, file_path, role) VALUES (?, ?, ?)").run(
+      plan.id,
+      "README.md",
+      "reference",
+    );
+
+    // Verify 4 rows exist
+    const before = db
+      .query("SELECT COUNT(*) as count FROM plan_files WHERE plan_id = ?")
+      .get(plan.id) as { count: number };
+    expect(before.count).toBe(4);
+
+    // Delete plan — CASCADE should remove all plan_files
+    deletePlan(db, plan.id, { confirm: true });
+
+    // Verify all gone
+    const after = db
+      .query("SELECT COUNT(*) as count FROM plan_files WHERE plan_id = ?")
+      .get(plan.id) as { count: number };
+    expect(after.count).toBe(0);
+  });
+});

package/src/db/plan-update-status.ts

@@ -0,0 +1,287 @@
+/**
+ * ndomo DB — plan_update_status tool executor (T3.1).
+ *
+ * Pure function extracted from the MCP tool wrapper in src/plugin.ts
+ * to enable unit testing without spinning up the full MCP harness.
+ *
+ * Adds: readiness checks (blockers/warnings), atomic transaction,
+ * dryRun, force with plan_audit capture.
+ */
+
+import type { Database } from "bun:sqlite";
+import type { ArchiveResult } from "./plan-archive.ts";
+import { archivePlan } from "./plan-archive.ts";
+import { getPlan, updatePlanStatus } from "./plans.ts";
+import type { Plan, PlanStatus } from "./types.ts";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface PlanUpdateStatusArgs {
+  id: string;
+  status: PlanStatus;
+  dryRun?: boolean;
+  force?: boolean;
+  forceReason?: string;
+}
+
+export interface PlanUpdateStatusContext {
+  agent?: string;
+  sessionID?: string;
+  messageID?: string;
+  directory?: string;
+  worktree?: string;
+}
+
+export interface PlanUpdateStatusResult {
+  plan: Plan | null;
+  statusChanged: boolean;
+  blocked: boolean;
+  forced: boolean;
+  dryRun: boolean;
+  blockers: string[];
+  warnings: string[];
+  archived: ArchiveResult | null;
+  archiveError: string | null;
+  auditId: number | null;
+}
+
+// ─── Constants ──────────────────────────────────────────────────────────────
+
+const TERMINAL_STATUSES = new Set<PlanStatus>(["completed", "failed", "abandoned"]);
+
+const VALID_TRANSITIONS: Record<PlanStatus, PlanStatus[]> = {
+  draft: ["approved", "abandoned"],
+  approved: ["executing", "abandoned"],
+  executing: ["completed", "failed", "abandoned"],
+  completed: [],
+  failed: [],
+  abandoned: [],
+};
+
+// ─── Executor ───────────────────────────────────────────────────────────────
+
+/**
+ * Execute plan_update_status with readiness checks, dryRun, force, and
+ * atomic transaction wrapping updatePlanStatus + archivePlan.
+ *
+ * @param db - Database instance
+ * @param args - Tool args (id, status, dryRun?, force?, forceReason?)
+ * @param ctx - Tool context (agent, sessionID, directory, worktree)
+ * @param archiveDir - Resolved archive directory for markdown output
+ */
+export function planUpdateStatusExecutor(
+  db: Database,
+  args: PlanUpdateStatusArgs,
+  ctx: PlanUpdateStatusContext,
+  archiveDir: string,
+): PlanUpdateStatusResult {
+  // ── 1. Load current plan ────────────────────────────────────────────────
+  const currentPlan = getPlan(db, args.id);
+  if (!currentPlan) {
+    throw new Error(`ndomo: plan not found: ${args.id}`);
+  }
+  const currentStatus = currentPlan.status;
+
+  // ── 2. Compute readiness check ─────────────────────────────────────────
+  const blockers: string[] = [];
+  const warnings: string[] = [];
+
+  // tasks_pending
+  const pendingCount = (
+    db
+      .query(
+        "SELECT COUNT(*) as cnt FROM plan_tasks WHERE plan_id = ? AND status = 'pending' AND archived_at IS NULL",
+      )
+      .get(args.id) as { cnt: number }
+  ).cnt;
+  if (pendingCount > 0) blockers.push("tasks_pending");
+
+  // tasks_running
+  const runningCount = (
+    db
+      .query(
+        "SELECT COUNT(*) as cnt FROM plan_tasks WHERE plan_id = ? AND status = 'running' AND archived_at IS NULL",
+      )
+      .get(args.id) as { cnt: number }
+  ).cnt;
+  if (runningCount > 0) blockers.push("tasks_running");
+
+  // sessions_open
+  const openSessionsCount = (
+    db
+      .query(
+        "SELECT COUNT(*) as cnt FROM sessions WHERE plan_id = ? AND ended_at IS NULL AND archived_at IS NULL",
+      )
+      .get(args.id) as { cnt: number }
+  ).cnt;
+  if (openSessionsCount > 0) blockers.push("sessions_open");
+
+  // status_invalid — always a blocker (force cannot bypass)
+  const allowed = VALID_TRANSITIONS[currentStatus] ?? [];
+  if (args.status !== currentStatus && !allowed.includes(args.status)) {
+    blockers.push("status_invalid");
+  }
+
+  // orphan_plan — warning only
+  const totalTasks = (
+    db
+      .query(
+        "SELECT COUNT(*) as cnt FROM plan_tasks WHERE plan_id = ? AND archived_at IS NULL",
+      )
+      .get(args.id) as { cnt: number }
+  ).cnt;
+  if (totalTasks === 0) warnings.push("orphan_plan");
+
+  // executing→failed: downgrade blockers to warnings (except status_invalid)
+  const isExecutingToFailed = currentStatus === "executing" && args.status === "failed";
+  const hardBlockers = isExecutingToFailed
+    ? blockers.filter((b) => b === "status_invalid")
+    : blockers;
+  if (isExecutingToFailed) {
+    // Move non-status_invalid blockers to warnings
+    for (const b of blockers) {
+      if (b !== "status_invalid" && !warnings.includes(b)) {
+        warnings.push(b);
+      }
+    }
+  }
+
+  // status_invalid is always a hard blocker — force cannot bypass it
+  if (hardBlockers.includes("status_invalid")) {
+    return {
+      plan: currentPlan,
+      statusChanged: false,
+      blocked: true,
+      forced: false,
+      dryRun: false,
+      blockers: hardBlockers,
+      warnings,
+      archived: null,
+      archiveError: null,
+      auditId: null,
+    };
+  }
+
+  // ── 3. dryRun — return check results, no mutation ──────────────────────
+  if (args.dryRun) {
+    return {
+      plan: currentPlan,
+      statusChanged: false,
+      blocked: hardBlockers.length > 0,
+      forced: false,
+      dryRun: true,
+      blockers: hardBlockers,
+      warnings,
+      archived: null,
+      archiveError: null,
+      auditId: null,
+    };
+  }
+
+  // ── 4. Blockers without force ──────────────────────────────────────────
+  if (hardBlockers.length > 0 && !args.force) {
+    return {
+      plan: currentPlan,
+      statusChanged: false,
+      blocked: true,
+      forced: false,
+      dryRun: false,
+      blockers: hardBlockers,
+      warnings,
+      archived: null,
+      archiveError: null,
+      auditId: null,
+    };
+  }
+
+  // ── 5. force=true validation ───────────────────────────────────────────
+  if (args.force && (!args.forceReason || args.forceReason.trim() === "")) {
+    throw new Error("ndomo: force=true requires non-empty forceReason");
+  }
+
+  // ── 6. Atomic transaction: readiness check → audit → update → archive ─
+  const opts: {
+    sessionId?: string;
+    updatedBy: string;
+    executedByAgent?: string;
+    executedBySession?: string;
+  } = {
+    updatedBy: ctx.agent ?? "unknown",
+  };
+  if (ctx.sessionID) opts.sessionId = ctx.sessionID;
+  if (args.status === "executing") {
+    opts.executedByAgent = ctx.agent ?? "unknown";
+    if (ctx.sessionID) opts.executedBySession = ctx.sessionID;
+  }
+
+  const txn = db.transaction(() => {
+    // Re-check status inside transaction (another writer could have changed it)
+    const freshPlan = getPlan(db, args.id);
+    if (!freshPlan) {
+      throw new Error(`ndomo: plan not found during transaction: ${args.id}`);
+    }
+
+    // Re-validate status transition inside transaction
+    const freshAllowed = VALID_TRANSITIONS[freshPlan.status] ?? [];
+    if (args.status !== freshPlan.status && !freshAllowed.includes(args.status)) {
+      throw new Error(
+        `ndomo: invalid status transition '${freshPlan.status}' → '${args.status}'`,
+      );
+    }
+
+    // Force audit insert
+    let auditRowId: number | null = null;
+    if (args.force) {
+      const snapshot = JSON.stringify({
+        reason: args.forceReason,
+        forcedBy: ctx.agent ?? "unknown",
+        blockers: hardBlockers,
+        warnings,
+        previousStatus: currentStatus,
+      });
+      const result = db
+        .query(
+          "INSERT INTO plan_audit (plan_id, captured_at, snapshot, trigger) VALUES (?, ?, ?, 'force_close')",
+        )
+        .run(args.id, Date.now(), snapshot);
+      auditRowId = Number(result.lastInsertRowid);
+    }
+
+    // Update status (idempotent same-status is a no-op warning)
+    const updated = updatePlanStatus(db, args.id, args.status, opts);
+
+    // Auto-archive on terminal status
+    let archiveResult: ArchiveResult | null = null;
+    let archiveError: string | null = null;
+
+    if (updated && TERMINAL_STATUSES.has(args.status)) {
+      try {
+        archiveResult = archivePlan(db, updated.id, { memDir: archiveDir });
+      } catch (err) {
+        archiveError = err instanceof Error ? err.message : String(err);
+        console.warn(
+          `[ndomo] auto-archive failed for plan ${updated.id}: ${archiveError}`,
+        );
+        // Re-throw so the outer transaction rolls back (atomicity)
+        throw err;
+      }
+    }
+
+    return { updated, archiveResult, archiveError, auditRowId };
+  });
+
+  const { updated, archiveResult, archiveError, auditRowId } = txn();
+
+  return {
+    plan: updated,
+    statusChanged: updated?.status === args.status,
+    blocked: false,
+    forced: !!args.force,
+    dryRun: false,
+    blockers: hardBlockers,
+    warnings,
+    archived: archiveResult,
+    archiveError,
+    auditId: auditRowId,
+  };
+}