gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

package/src/resources/extensions/gsd/tests/commands-workflow-custom.test.ts

@@ -0,0 +1,283 @@
+/**
+ * commands-workflow-custom.test.ts — Tests for `/gsd workflow` subcommands
+ * and catalog completions.
+ *
+ * Uses real temp directories with actual definition YAML files.
+ */
+
+import { describe, it, afterEach, before } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getGsdArgumentCompletions, TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+let savedCwd: string;
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wf-cmd-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  // Restore cwd if changed during tests
+  if (savedCwd && process.cwd() !== savedCwd) {
+    process.chdir(savedCwd);
+  }
+  for (const d of tmpDirs) {
+    try { rmSync(d, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* Windows EPERM */ }
+  }
+  tmpDirs.length = 0;
+});
+
+before(() => {
+  savedCwd = process.cwd();
+});
+
+function createMockCtx() {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => {},
+    },
+    shutdown: async () => {},
+    sessionManager: {
+      getSessionFile: () => null,
+    },
+  };
+}
+
+function createMockPi() {
+  return {
+    registerCommand() {},
+    registerTool() {},
+    registerShortcut() {},
+    on() {},
+    sendMessage() {},
+  };
+}
+
+/** Write a minimal valid workflow definition YAML to the expected location. */
+function writeDefinition(basePath: string, name: string, content: string): void {
+  const defsDir = join(basePath, ".gsd", "workflow-defs");
+  mkdirSync(defsDir, { recursive: true });
+  writeFileSync(join(defsDir, `${name}.yaml`), content, "utf-8");
+}
+
+const SIMPLE_DEF = `
+version: 1
+name: test-workflow
+description: A test workflow
+steps:
+  - id: step-1
+    name: First Step
+    prompt: Do step 1
+    requires: []
+    produces: []
+`;
+
+const INVALID_DEF = `
+version: 2
+name: bad-workflow
+steps: []
+`;
+
+// ─── Catalog Registration ────────────────────────────────────────────────
+
+describe("workflow catalog registration", () => {
+  it("workflow appears in TOP_LEVEL_SUBCOMMANDS", () => {
+    const entry = TOP_LEVEL_SUBCOMMANDS.find((c) => c.cmd === "workflow");
+    assert.ok(entry, "workflow should be in TOP_LEVEL_SUBCOMMANDS");
+    assert.ok(entry!.desc.includes("new"), "description should mention new");
+    assert.ok(entry!.desc.includes("run"), "description should mention run");
+  });
+
+  it("getGsdArgumentCompletions('workflow ') returns six subcommands", () => {
+    const completions = getGsdArgumentCompletions("workflow ");
+    const labels = completions.map((c: any) => c.label);
+    for (const sub of ["new", "run", "list", "validate", "pause", "resume"]) {
+      assert.ok(labels.includes(sub), `missing completion: ${sub}`);
+    }
+    assert.equal(labels.length, 6, "should have exactly 6 subcommands");
+  });
+
+  it("getGsdArgumentCompletions('workflow r') filters to run and resume", () => {
+    const completions = getGsdArgumentCompletions("workflow r");
+    const labels = completions.map((c: any) => c.label);
+    assert.ok(labels.includes("run"), "should include run");
+    assert.ok(labels.includes("resume"), "should include resume");
+    assert.ok(!labels.includes("list"), "should not include list");
+  });
+
+  it("getGsdArgumentCompletions('workflow run ') returns definition names", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "deploy-pipeline", SIMPLE_DEF);
+    writeDefinition(base, "test-suite", SIMPLE_DEF);
+
+    // Change cwd so the completion scanner can find `.gsd/workflow-defs/`
+    process.chdir(base);
+
+    const completions = getGsdArgumentCompletions("workflow run ");
+    const labels = completions.map((c: any) => c.label);
+    assert.ok(labels.includes("deploy-pipeline"), "should include deploy-pipeline");
+    assert.ok(labels.includes("test-suite"), "should include test-suite");
+  });
+
+  it("getGsdArgumentCompletions('workflow validate ') returns definition names", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "my-workflow", SIMPLE_DEF);
+
+    process.chdir(base);
+
+    const completions = getGsdArgumentCompletions("workflow validate ");
+    const labels = completions.map((c: any) => c.label);
+    assert.ok(labels.includes("my-workflow"), "should include my-workflow");
+  });
+
+  it("getGsdArgumentCompletions('workflow run d') filters by prefix", () => {
+    const base = makeTmpBase();
+    writeDefinition(base, "deploy-pipeline", SIMPLE_DEF);
+    writeDefinition(base, "test-suite", SIMPLE_DEF);
+
+    process.chdir(base);
+
+    const completions = getGsdArgumentCompletions("workflow run d");
+    const labels = completions.map((c: any) => c.label);
+    assert.ok(labels.includes("deploy-pipeline"), "should include deploy-pipeline");
+    assert.ok(!labels.includes("test-suite"), "should not include test-suite");
+  });
+});
+
+// ─── Command Handler Tests ───────────────────────────────────────────────
+
+describe("workflow command handler", () => {
+  // Dynamically import the handler so module-level side effects
+  // don't break when auto.ts pulls in heavy runtime deps.
+  // We test the pure routing logic by calling handleWorkflowCommand directly.
+
+  async function callHandler(trimmed: string) {
+    const { handleWorkflowCommand } = await import("../commands/handlers/workflow.ts");
+    const ctx = createMockCtx();
+    const pi = createMockPi();
+    const handled = await handleWorkflowCommand(trimmed, ctx as any, pi as any);
+    return { handled, notifications: ctx.notifications };
+  }
+
+  it("bare '/gsd workflow' shows usage", async () => {
+    const { handled, notifications } = await callHandler("workflow");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.message.includes("Usage: /gsd workflow")),
+      "should show usage",
+    );
+  });
+
+  it("'/gsd workflow new' shows skill invocation message", async () => {
+    const { handled, notifications } = await callHandler("workflow new");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.message.includes("create-workflow")),
+      "should mention create-workflow skill",
+    );
+  });
+
+  it("'/gsd workflow run' without name shows usage warning", async () => {
+    const { handled, notifications } = await callHandler("workflow run");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.message.includes("Usage")),
+      "should show usage warning",
+    );
+  });
+
+  it("'/gsd workflow run nonexistent' shows error for missing definition", async () => {
+    const { handled, notifications } = await callHandler("workflow run nonexistent-def-12345");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "error" && n.message.includes("not found")),
+      "should show definition-not-found error",
+    );
+  });
+
+  it("'/gsd workflow validate' without name shows usage warning", async () => {
+    const { handled, notifications } = await callHandler("workflow validate");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "warning" && n.message.includes("Usage")),
+      "should show usage warning",
+    );
+  });
+
+  it("'/gsd workflow validate nonexistent' shows definition not found", async () => {
+    const { handled, notifications } = await callHandler("workflow validate nonexistent-def-12345");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "error" && n.message.includes("not found")),
+      "should show not-found error",
+    );
+  });
+
+  it("'/gsd workflow pause' without custom engine shows warning", async () => {
+    const { handled, notifications } = await callHandler("workflow pause");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "warning"),
+      "should show warning when no custom workflow is running",
+    );
+  });
+
+  it("'/gsd workflow resume' without custom engine shows warning", async () => {
+    const { handled, notifications } = await callHandler("workflow resume");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.level === "warning"),
+      "should show warning when no custom workflow to resume",
+    );
+  });
+
+  it("'/gsd workflow unknown-sub' shows unknown subcommand", async () => {
+    const { handled, notifications } = await callHandler("workflow blurble");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.message.includes("Unknown workflow subcommand")),
+      "should show unknown subcommand message",
+    );
+  });
+
+  it("'/gsd workflow list' with no runs shows empty message", async () => {
+    const { handled, notifications } = await callHandler("workflow list");
+    assert.ok(handled, "should be handled");
+    assert.ok(
+      notifications.some((n) => n.message.includes("No workflow runs found")),
+      "should show no runs message",
+    );
+  });
+
+  it("non-workflow commands are not intercepted by custom workflow routing", async () => {
+    const { handleWorkflowCommand } = await import("../commands/handlers/workflow.ts");
+    const ctx = createMockCtx();
+    const pi = createMockPi();
+    // "queue" does not start with "workflow" so the custom routing should not handle it.
+    // The function may still handle it via its existing dev-workflow routing, but it
+    // should not be captured by the custom workflow `if` block.
+    // We verify this by checking that a clearly non-workflow command like "somethingelse"
+    // returns false (unhandled).
+    const handled = await handleWorkflowCommand("somethingelse", ctx as any, pi as any);
+    assert.equal(handled, false, "non-workflow commands should return false");
+  });
+});

package/src/resources/extensions/gsd/tests/context-injector.test.ts

@@ -0,0 +1,313 @@
+/**
+ * context-injector.test.ts — Tests for injectContext().
+ *
+ * Tests context injection from prior step artifacts: single-step,
+ * multi-step chain, missing artifact, no contextFrom, truncation,
+ * and unknown step ID in contextFrom.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { stringify } from "yaml";
+import { injectContext } from "../context-injector.ts";
+import type { WorkflowDefinition } from "../definition-loader.ts";
+
+/** Create a temp run directory with the given definition and optional files. */
+function makeTempRun(
+  def: WorkflowDefinition,
+  files?: Record<string, string>,
+): string {
+  const runDir = mkdtempSync(join(tmpdir(), "ci-test-"));
+  writeFileSync(join(runDir, "DEFINITION.yaml"), stringify(def), "utf-8");
+
+  if (files) {
+    for (const [relPath, content] of Object.entries(files)) {
+      const absPath = join(runDir, relPath);
+      const parentDir = join(absPath, "..");
+      mkdirSync(parentDir, { recursive: true });
+      writeFileSync(absPath, content, "utf-8");
+    }
+  }
+
+  return runDir;
+}
+
+/** Minimal valid workflow definition factory. */
+function makeDef(
+  steps: WorkflowDefinition["steps"],
+): WorkflowDefinition {
+  return {
+    version: 1,
+    name: "test-workflow",
+    steps,
+  };
+}
+
+// ─── single-step context ────────────────────────────────────────────────
+
+describe("single-step context injection", () => {
+  it("prepends step-1 artifact content to step-2 prompt", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research the topic",
+        requires: [],
+        produces: ["output.md"],
+      },
+      {
+        id: "step-2",
+        name: "Write",
+        prompt: "Write the report",
+        requires: ["step-1"],
+        produces: ["report.md"],
+        contextFrom: ["step-1"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def, {
+      "output.md": "Research findings: AI is growing fast.",
+    });
+
+    const result = injectContext(runDir, "step-2", "Write the report");
+    assert.ok(result.includes("Research findings: AI is growing fast."));
+    assert.ok(result.includes('Context from step "step-1"'));
+    assert.ok(result.includes("(file: output.md)"));
+    assert.ok(result.endsWith("Write the report"));
+  });
+});
+
+// ─── multi-step chain ───────────────────────────────────────────────────
+
+describe("multi-step context chain", () => {
+  it("prepends artifacts from both step-1 and step-2", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: ["research.md"],
+      },
+      {
+        id: "step-2",
+        name: "Outline",
+        prompt: "Outline",
+        requires: ["step-1"],
+        produces: ["outline.md"],
+      },
+      {
+        id: "step-3",
+        name: "Draft",
+        prompt: "Write the draft",
+        requires: ["step-1", "step-2"],
+        produces: ["draft.md"],
+        contextFrom: ["step-1", "step-2"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def, {
+      "research.md": "Research content here.",
+      "outline.md": "Outline content here.",
+    });
+
+    const result = injectContext(runDir, "step-3", "Write the draft");
+    assert.ok(result.includes("Research content here."));
+    assert.ok(result.includes("Outline content here."));
+    assert.ok(result.includes('Context from step "step-1"'));
+    assert.ok(result.includes('Context from step "step-2"'));
+    assert.ok(result.endsWith("Write the draft"));
+
+    // Verify order: step-1 context appears before step-2 context
+    const idx1 = result.indexOf('Context from step "step-1"');
+    const idx2 = result.indexOf('Context from step "step-2"');
+    assert.ok(idx1 < idx2, "step-1 context should appear before step-2 context");
+  });
+});
+
+// ─── missing artifact file ──────────────────────────────────────────────
+
+describe("missing artifact file", () => {
+  it("skips missing artifact and includes existing ones", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: ["found.md", "missing.md"],
+      },
+      {
+        id: "step-2",
+        name: "Write",
+        prompt: "Write the report",
+        requires: ["step-1"],
+        produces: ["report.md"],
+        contextFrom: ["step-1"],
+      },
+    ]);
+
+    // Only create found.md, not missing.md
+    const runDir = makeTempRun(def, {
+      "found.md": "Found content.",
+    });
+
+    const result = injectContext(runDir, "step-2", "Write the report");
+    assert.ok(result.includes("Found content."));
+    assert.ok(!result.includes("missing.md"));
+    assert.ok(result.endsWith("Write the report"));
+  });
+
+  it("returns prompt unchanged when all referenced artifacts are missing", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: ["missing.md"],
+      },
+      {
+        id: "step-2",
+        name: "Write",
+        prompt: "Write the report",
+        requires: ["step-1"],
+        produces: ["report.md"],
+        contextFrom: ["step-1"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def);
+
+    const result = injectContext(runDir, "step-2", "Write the report");
+    assert.equal(result, "Write the report");
+  });
+});
+
+// ─── no contextFrom ────────────────────────────────────────────────────
+
+describe("no contextFrom", () => {
+  it("returns prompt unchanged when step has no contextFrom", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: ["output.md"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def, {
+      "output.md": "Some content.",
+    });
+
+    const result = injectContext(runDir, "step-1", "Research");
+    assert.equal(result, "Research");
+  });
+
+  it("returns prompt unchanged when step ID not found in definition", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: [],
+      },
+    ]);
+
+    const runDir = makeTempRun(def);
+
+    const result = injectContext(runDir, "nonexistent", "Some prompt");
+    assert.equal(result, "Some prompt");
+  });
+});
+
+// ─── truncation ─────────────────────────────────────────────────────────
+
+describe("truncation guard", () => {
+  it("truncates artifacts exceeding 10,000 characters", () => {
+    const largeContent = "A".repeat(15_000);
+
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Generate",
+        prompt: "Generate",
+        requires: [],
+        produces: ["big.md"],
+      },
+      {
+        id: "step-2",
+        name: "Consume",
+        prompt: "Use the output",
+        requires: ["step-1"],
+        produces: [],
+        contextFrom: ["step-1"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def, {
+      "big.md": largeContent,
+    });
+
+    const result = injectContext(runDir, "step-2", "Use the output");
+    assert.ok(result.includes("...[truncated]"));
+    // The injected content should be 10,000 chars + truncation marker, not all 15,000
+    const contextPart = result.split("Use the output")[0];
+    assert.ok(contextPart.length < 15_000, "Context should be truncated below original size");
+    // Verify the truncated content is exactly 10,000 A's (no collision with header text)
+    const aCount = (contextPart.match(/A/g) || []).length;
+    assert.equal(aCount, 10_000, "Should contain exactly 10,000 chars of original content");
+  });
+});
+
+// ─── unknown step ID in contextFrom ─────────────────────────────────────
+
+describe("unknown step in contextFrom", () => {
+  it("skips unknown step IDs gracefully", () => {
+    const def = makeDef([
+      {
+        id: "step-1",
+        name: "Research",
+        prompt: "Research",
+        requires: [],
+        produces: ["output.md"],
+      },
+      {
+        id: "step-2",
+        name: "Write",
+        prompt: "Write the report",
+        requires: ["step-1"],
+        produces: [],
+        contextFrom: ["step-1", "nonexistent-step"],
+      },
+    ]);
+
+    const runDir = makeTempRun(def, {
+      "output.md": "Research content.",
+    });
+
+    const result = injectContext(runDir, "step-2", "Write the report");
+    // Should include step-1 content despite nonexistent-step being in contextFrom
+    assert.ok(result.includes("Research content."));
+    assert.ok(result.endsWith("Write the report"));
+  });
+});
+
+// ─── error handling ─────────────────────────────────────────────────────
+
+describe("error handling", () => {
+  it("throws when DEFINITION.yaml is missing", () => {
+    const runDir = mkdtempSync(join(tmpdir(), "ci-test-nodef-"));
+
+    assert.throws(
+      () => injectContext(runDir, "step-1", "Some prompt"),
+      /ENOENT/,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -51,17 +51,17 @@ console.log('\n=== context-store: query all active decisions ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-    revisable: 'yes', superseded_by: 'D003', // superseded!
+    revisable: 'yes', made_by: 'agent', superseded_by: 'D003', // superseded!
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use WAL mode', choice: 'WAL', rationale: 'concurrent reads',
-    revisable: 'no', superseded_by: null,
+    revisable: 'no', made_by: 'agent', superseded_by: null,
   });
   insertDecision({
     id: 'D003', when_context: 'M002/S01', scope: 'performance',
     decision: 'use better-sqlite3', choice: 'better-sqlite3', rationale: 'faster',
-    revisable: 'yes', superseded_by: null,
+    revisable: 'yes', made_by: 'agent', superseded_by: null,
   });
 
   const all = queryDecisions();
@@ -81,11 +81,13 @@ console.log('\n=== context-store: query decisions by milestone ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M002/S02', scope: 'architecture',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -107,11 +109,13 @@ console.log('\n=== context-store: query decisions by scope ===');
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'decision A', choice: 'A', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertDecision({
     id: 'D002', when_context: 'M001/S01', scope: 'performance',
     decision: 'decision B', choice: 'B', rationale: 'r', revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
 
@@ -248,12 +252,12 @@ console.log('\n=== context-store: formatDecisionsForPrompt ===');
     {
       seq: 1, id: 'D001', when_context: 'M001/S01', scope: 'architecture',
       decision: 'use SQLite', choice: 'node:sqlite', rationale: 'built-in',
-      revisable: 'yes', superseded_by: null,
+      revisable: 'yes', made_by: 'agent', superseded_by: null,
     },
     {
       seq: 2, id: 'D002', when_context: 'M001/S02', scope: 'performance',
       decision: 'use WAL', choice: 'WAL', rationale: 'concurrent',
-      revisable: 'no', superseded_by: null,
+      revisable: 'no', made_by: 'human', superseded_by: null,
     },
   ]);
 
@@ -323,6 +327,7 @@ console.log('\n=== context-store: sub-5ms query timing ===');
       choice: `choice ${i}`,
       rationale: `rationale ${i}`,
       revisable: i % 3 === 0 ? 'no' : 'yes',
+      made_by: 'agent',
       superseded_by: null,
     });
   }