gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -1,13 +1,13 @@
 // tool-naming — Verifies canonical + alias tool registration for GSD DB tools.
 //
-// Each of the 4 DB tools must register under its canonical gsd_concept_action name
-// AND under the old gsd_action_concept name as a backward-compatible alias.
+// Each DB tool must register under its canonical gsd_concept_action name
+// AND under a backward-compatible alias name.
 // The alias must share the exact same execute function reference as the canonical tool.
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
 
@@ -26,6 +26,14 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_requirement_update", alias: "gsd_update_requirement" },
   { canonical: "gsd_summary_save", alias: "gsd_save_summary" },
   { canonical: "gsd_milestone_generate_id", alias: "gsd_generate_milestone_id" },
+  { canonical: "gsd_task_complete", alias: "gsd_complete_task" },
+  { canonical: "gsd_slice_complete", alias: "gsd_complete_slice" },
+  { canonical: "gsd_plan_milestone", alias: "gsd_milestone_plan" },
+  { canonical: "gsd_plan_slice", alias: "gsd_slice_plan" },
+  { canonical: "gsd_plan_task", alias: "gsd_task_plan" },
+  { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
+  { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
+  { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -35,7 +43,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assertEq(pi.tools.length, 8, 'Should register exactly 8 tools (4 canonical + 4 aliases)');
+assert.deepStrictEqual(pi.tools.length, 24, 'Should register exactly 24 tools (12 canonical + 12 aliases)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 
@@ -45,8 +53,8 @@ for (const { canonical, alias } of RENAME_MAP) {
   const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
-  assertTrue(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
-  assertTrue(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
+  assert.ok(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
+  assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
 }
 
 // ─── Execute function identity ───────────────────────────────────────────────
@@ -58,7 +66,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (canonicalTool && aliasTool) {
-    assertTrue(
+    assert.ok(
       canonicalTool.execute === aliasTool.execute,
       `"${canonical}" and "${alias}" should share the same execute function reference`,
     );
@@ -73,7 +81,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (aliasTool) {
-    assertTrue(
+    assert.ok(
       aliasTool.description.includes(`alias for ${canonical}`),
       `Alias "${alias}" description should include "alias for ${canonical}"`,
     );
@@ -89,7 +97,7 @@ for (const { canonical } of RENAME_MAP) {
 
   if (canonicalTool) {
     const guidelinesText = canonicalTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(canonical),
       `Canonical tool "${canonical}" promptGuidelines should reference its own name`,
     );
@@ -105,7 +113,7 @@ for (const { canonical, alias } of RENAME_MAP) {
 
   if (aliasTool) {
     const guidelinesText = aliasTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(`Alias for ${canonical}`),
       `Alias "${alias}" promptGuidelines should say "Alias for ${canonical}"`,
     );
@@ -113,5 +121,3 @@ for (const { canonical, alias } of RENAME_MAP) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();

package/src/resources/extensions/gsd/tests/undo.test.ts

@@ -8,8 +8,21 @@ import {
   extractCommitShas,
   findCommitsForUnit,
   handleUndo,
+  handleUndoTask,
+  handleResetSlice,
   uncheckTaskInPlan,
-} from "../undo.js";
+} from "../undo.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  getTask,
+  getSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { existsSync } from "node:fs";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), `${prefix}-`));
@@ -140,3 +153,310 @@ test("extractCommitShas ignores malformed commit tokens", () => {
 
   assert.deepEqual(extractCommitShas(content), ["1234567"]);
 });
+
+// ─── handleUndoTask tests ────────────────────────────────────────────────────
+
+function makeCtx(): { notifications: Array<{ message: string; level: string }>; ctx: any } {
+  const notifications: Array<{ message: string; level: string }> = [];
+  const ctx = {
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+    },
+  };
+  return { notifications, ctx };
+}
+
+function setupTaskFixture(base: string): void {
+  // Create milestone/slice/task directory structure
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  // Write plan file with checked task
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:30m`",
+      "- [ ] **T02: Second task** `est:30m`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write task summary file
+  writeFileSync(
+    join(tasksDir, "T01-SUMMARY.md"),
+    "# T01 Summary\nDone.",
+    "utf-8",
+  );
+
+  // Set up DB
+  openDatabase(":memory:");
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "active", risk: "low", depends: [] });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
+  insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Second task", status: "pending" });
+  invalidateAllCaches();
+}
+
+test("handleUndoTask without args shows usage", async () => {
+  const { notifications, ctx } = makeCtx();
+  const base = makeTempDir("gsd-undo-task-usage");
+  try {
+    await handleUndoTask("", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /Usage:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask without --force shows confirmation", async () => {
+  const base = makeTempDir("gsd-undo-task-confirm");
+  try {
+    setupTaskFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T01", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /--force to confirm/);
+    // Verify state was NOT modified
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask with --force resets task and re-renders plan", async () => {
+  const base = makeTempDir("gsd-undo-task-force");
+  try {
+    setupTaskFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T01 --force", ctx, {} as any, base);
+
+    // DB status reset
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+
+    // Summary file deleted
+    const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
+    assert.equal(existsSync(summaryPath), false);
+
+    // Plan checkbox unchecked
+    const planContent = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      "utf-8",
+    );
+    assert.match(planContent, /\[ \] \*\*T01:/);
+
+    // Success notification
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Reset task M001\/S01\/T01/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask with non-existent task returns error", async () => {
+  const base = makeTempDir("gsd-undo-task-notfound");
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Test", status: "active", risk: "low", depends: [] });
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("M001/S01/T99 --force", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "error");
+    assert.match(notifications[0]?.message ?? "", /not found/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleUndoTask accepts partial ID (T01) and resolves from state", async () => {
+  const base = makeTempDir("gsd-undo-task-partial");
+  try {
+    setupTaskFixture(base);
+
+    // Create STATE.md so deriveState can resolve the active milestone/slice
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "STATE.md"),
+      [
+        "# GSD State",
+        "",
+        "- Phase: executing",
+        "- Active Milestone: M001",
+        "- Active Slice: S01",
+        "- Active Task: T01",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndoTask("T01 --force", ctx, {} as any, base);
+
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+    assert.equal(notifications[0]?.level, "success");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── handleResetSlice tests ──────────────────────────────────────────────────
+
+function setupSliceFixture(base: string): void {
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  const sliceDir = join(mDir, "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+
+  // Write roadmap file
+  writeFileSync(
+    join(mDir, "M001-ROADMAP.md"),
+    [
+      "# Roadmap",
+      "",
+      "## Slices",
+      "",
+      "- [x] **S01: Test Slice** `risk:low` `depends:[]`",
+      "- [ ] **S02: Next Slice** `risk:low` `depends:[S01]`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write plan file
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [x] **T01: First task** `est:30m`",
+      "- [x] **T02: Second task** `est:30m`",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Write task summaries
+  writeFileSync(join(tasksDir, "T01-SUMMARY.md"), "# T01 Summary\nDone.", "utf-8");
+  writeFileSync(join(tasksDir, "T02-SUMMARY.md"), "# T02 Summary\nDone.", "utf-8");
+
+  // Write slice summary and UAT
+  writeFileSync(join(sliceDir, "S01-SUMMARY.md"), "# Slice Summary\nDone.", "utf-8");
+  writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\nPassed.", "utf-8");
+
+  // Set up DB
+  openDatabase(":memory:");
+  insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Test Slice", status: "complete", risk: "low", depends: [] });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", risk: "low", depends: ["S01"] });
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "First task", status: "complete" });
+  insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", title: "Second task", status: "complete" });
+  invalidateAllCaches();
+}
+
+test("handleResetSlice without args shows usage", async () => {
+  const { notifications, ctx } = makeCtx();
+  const base = makeTempDir("gsd-reset-slice-usage");
+  try {
+    await handleResetSlice("", ctx, {} as any, base);
+    assert.equal(notifications.length, 1);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /Usage:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice without --force shows confirmation", async () => {
+  const base = makeTempDir("gsd-reset-slice-confirm");
+  try {
+    setupSliceFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S01", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "warning");
+    assert.match(notifications[0]?.message ?? "", /--force to confirm/);
+    // State not modified
+    const slice = getSlice("M001", "S01");
+    assert.equal(slice?.status, "complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice with --force resets slice and all tasks", async () => {
+  const base = makeTempDir("gsd-reset-slice-force");
+  try {
+    setupSliceFixture(base);
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S01 --force", ctx, {} as any, base);
+
+    // DB status reset
+    const slice = getSlice("M001", "S01");
+    assert.equal(slice?.status, "active");
+    const t1 = getTask("M001", "S01", "T01");
+    assert.equal(t1?.status, "pending");
+    const t2 = getTask("M001", "S01", "T02");
+    assert.equal(t2?.status, "pending");
+
+    // Task summaries deleted
+    const tasksDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+    assert.equal(existsSync(join(tasksDir, "T01-SUMMARY.md")), false);
+    assert.equal(existsSync(join(tasksDir, "T02-SUMMARY.md")), false);
+
+    // Slice summary and UAT deleted
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    assert.equal(existsSync(join(sliceDir, "S01-SUMMARY.md")), false);
+    assert.equal(existsSync(join(sliceDir, "S01-UAT.md")), false);
+
+    // Plan checkboxes unchecked
+    const planContent = readFileSync(join(sliceDir, "S01-PLAN.md"), "utf-8");
+    assert.match(planContent, /\[ \] \*\*T01:/);
+    assert.match(planContent, /\[ \] \*\*T02:/);
+
+    // Roadmap checkbox unchecked
+    const roadmapContent = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "utf-8",
+    );
+    assert.match(roadmapContent, /\[ \] \*\*S01:/);
+
+    // Success notification
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Reset slice M001\/S01/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("handleResetSlice with non-existent slice returns error", async () => {
+  const base = makeTempDir("gsd-reset-slice-notfound");
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const { notifications, ctx } = makeCtx();
+    await handleResetSlice("M001/S99 --force", ctx, {} as any, base);
+    assert.equal(notifications[0]?.level, "error");
+    assert.match(notifications[0]?.message ?? "", /not found/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});