gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.703eabc

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

@@ -217,6 +217,20 @@ describe("workflow command handler", () => {
     );
   });
 
+  it("preserves quoted workflow run overrides (#4130)", async () => {
+    const { parseWorkflowRunArgs } = await import("../commands/handlers/workflow.ts");
+    assert.deepStrictEqual(
+      parseWorkflowRunArgs('demo-workflow target="multi word target" region=\'us east\''),
+      {
+        defName: "demo-workflow",
+        overrides: {
+          target: "multi word target",
+          region: "us east",
+        },
+      },
+    );
+  });
+
   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");

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(

package/src/resources/extensions/gsd/tests/extension-bootstrap-isolation.test.ts

@@ -0,0 +1,154 @@
+// Structural contracts for GSD extension bootstrap isolation.
+//
+// The /gsd command must survive failures in the full extension bootstrap
+// (register-extension.ts). This guards against the regression where a
+// Windows-specific import failure in register-shortcuts.ts silently
+// prevented /gsd from being registered at all (#4168, #4172).
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const indexSrc = readFileSync(join(__dirname, "../index.ts"), "utf-8");
+const registerExtSrc = readFileSync(
+  join(__dirname, "../bootstrap/register-extension.ts"),
+  "utf-8",
+);
+
+// ─── index.ts: core /gsd command must be registered before full bootstrap ─────
+
+describe("index.ts bootstrap isolation", () => {
+  test("imports registerGSDCommand from commands/index.js separately", () => {
+    assert.ok(
+      indexSrc.includes('./commands/index.js"') || indexSrc.includes("./commands/index.js'"),
+      "index.ts must import registerGSDCommand from ./commands/index.js",
+    );
+  });
+
+  test("calls registerGSDCommand before importing register-extension.js", () => {
+    const gsdCommandCallPos = indexSrc.indexOf("registerGSDCommand(pi)");
+    const bootstrapImportPos = indexSrc.indexOf(
+      './bootstrap/register-extension.js"',
+    );
+
+    assert.ok(gsdCommandCallPos >= 0, "must call registerGSDCommand(pi)");
+    assert.ok(bootstrapImportPos >= 0, "must import register-extension.js");
+    assert.ok(
+      gsdCommandCallPos < bootstrapImportPos,
+      "registerGSDCommand(pi) must be called BEFORE importing register-extension.js",
+    );
+  });
+
+  test("wraps register-extension.js import in try-catch", () => {
+    // The dynamic import of register-extension.js must be inside a try block
+    const tryPos = indexSrc.indexOf("try {");
+    const bootstrapImportPos = indexSrc.indexOf(
+      './bootstrap/register-extension.js"',
+    );
+    const catchPos = indexSrc.indexOf("catch (err)");
+
+    assert.ok(tryPos >= 0, "must have try block");
+    assert.ok(catchPos >= 0, "must have catch block");
+    assert.ok(
+      tryPos < bootstrapImportPos && bootstrapImportPos < catchPos,
+      "register-extension.js import must be wrapped in try-catch",
+    );
+  });
+
+  test("logs warning on bootstrap failure via workflow-logger", () => {
+    assert.ok(
+      indexSrc.includes("logWarning"),
+      "must use logWarning when bootstrap fails",
+    );
+    assert.ok(
+      indexSrc.includes("Extension setup partially failed"),
+      "warning message must indicate partial failure with /gsd still available",
+    );
+  });
+});
+
+// ─── register-extension.ts: no double-registration + defensive wrapping ───────
+
+describe("register-extension.ts defensive registration", () => {
+  test("does NOT import or call registerGSDCommand (avoids double-registration)", () => {
+    // registerGSDCommand is now called by index.ts, not register-extension.ts
+    assert.ok(
+      !registerExtSrc.includes("import { registerGSDCommand }"),
+      "register-extension.ts must NOT import registerGSDCommand",
+    );
+
+    // Check the function body of registerGsdExtension doesn't call it
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+    assert.ok(
+      !funcBody.includes("registerGSDCommand(pi)"),
+      "registerGsdExtension must NOT call registerGSDCommand(pi)",
+    );
+  });
+
+  test("still registers worktree, exit, and kill commands", () => {
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+
+    assert.ok(
+      funcBody.includes("registerWorktreeCommand(pi)"),
+      "must register worktree command",
+    );
+    assert.ok(
+      funcBody.includes("registerExitCommand(pi)"),
+      "must register exit command",
+    );
+    assert.ok(
+      funcBody.includes('"kill"'),
+      "must register kill command",
+    );
+  });
+
+  test("wraps non-critical registrations in individual try-catch blocks", () => {
+    const funcBodyStart = registerExtSrc.indexOf(
+      "export function registerGsdExtension",
+    );
+    const funcBody = registerExtSrc.slice(funcBodyStart);
+
+    // Each non-critical registration should be wrapped with error handling
+    const registrationNames = [
+      "dynamic-tools",
+      "db-tools",
+      "journal-tools",
+      "query-tools",
+      "shortcuts",
+      "hooks",
+    ];
+
+    for (const name of registrationNames) {
+      assert.ok(
+        funcBody.includes(`"${name}"`),
+        `non-critical registration "${name}" must be present`,
+      );
+    }
+
+    // Must have try-catch inside the registration loop
+    assert.ok(
+      funcBody.includes("try {") && funcBody.includes("catch (err)"),
+      "must have try-catch for non-critical registrations",
+    );
+  });
+
+  test("logs warning when a non-critical registration fails", () => {
+    assert.ok(
+      registerExtSrc.includes("Failed to register"),
+      "must log descriptive warning for individual registration failures",
+    );
+    assert.ok(
+      registerExtSrc.includes("logWarning"),
+      "must use logWarning from workflow-logger",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/finalize-timeout-guard.test.ts

@@ -26,6 +26,14 @@ import { MAX_FINALIZE_TIMEOUTS } from "../auto/types.ts";
 
 const { assertTrue, assertEq, report } = createTestContext();
 
+function getRunFinalizeBody(phasesSource: string): string {
+  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
+  assertTrue(fnIdx > 0, "runFinalize function should exist in phases.ts");
+
+  const nextExportIdx = phasesSource.indexOf("\nexport ", fnIdx + 1);
+  return phasesSource.slice(fnIdx, nextExportIdx > fnIdx ? nextExportIdx : undefined);
+}
+
 // ═══ Test: withTimeout resolves when inner promise resolves promptly ══════════
 
 {
@@ -145,11 +153,7 @@ const { assertTrue, assertEq, report } = createTestContext();
     "utf-8",
   );
 
-  // Find the runFinalize function body
-  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
-  assertTrue(fnIdx > 0, "runFinalize function should exist in phases.ts");
-
-  const fnBody = phasesSource.slice(fnIdx, fnIdx + 8000);
+  const fnBody = getRunFinalizeBody(phasesSource);
 
   // postUnitPreVerification must be wrapped in withTimeout
   const preTimeoutIdx = fnBody.indexOf("withTimeout(");
@@ -207,8 +211,7 @@ const { assertTrue, assertEq, report } = createTestContext();
     "utf-8",
   );
 
-  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
-  const fnBody = phasesSource.slice(fnIdx, fnIdx + 8000);
+  const fnBody = getRunFinalizeBody(phasesSource);
 
   // Both timeout handlers should increment consecutiveFinalizeTimeouts
   const incrementCount = (fnBody.match(/consecutiveFinalizeTimeouts\+\+/g) || []).length;

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

@@ -0,0 +1,337 @@
+/**
+ * graph-context.test.ts — Unit tests for inlineGraphSubgraph().
+ *
+ * Covers:
+ *   Group 1: Null-return paths (empty term, zero nodes, missing graph.json)
+ *   Group 2: Correct output formatting (nodes, edges, stale annotation)
+ *   Group 3: Node formatting (description, confidence, no-description)
+ *
+ * Testing strategy:
+ *   @gsd-build/mcp-server is dynamically imported inside inlineGraphSubgraph().
+ *   Because node:test (v22) does not support mock.module() without the
+ *   --experimental-test-module-mocks flag (not enabled in test:unit), we
+ *   exercise the real graphQuery/graphStatus functions by controlling the
+ *   on-disk graph.json that those functions read. This is a clean, deterministic
+ *   approach that avoids all module-level mocking.
+ *
+ *   Fixture layout per test:
+ *     <tmpDir>/.gsd/graphs/graph.json
+ *
+ *   builtAt controls staleness: old timestamp → stale, recent → fresh.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { inlineGraphSubgraph } from "../graph-context.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+interface TestNode {
+  id: string;
+  label: string;
+  type: string;
+  confidence: string;
+  description?: string;
+  sourceFile?: string;
+}
+
+interface TestEdge {
+  from: string;
+  to: string;
+  type: string;
+  confidence: string;
+}
+
+interface GraphFixture {
+  nodes: TestNode[];
+  edges: TestEdge[];
+  /** ISO timestamp for graph.builtAt. Controls staleness. Default: recent (not stale). */
+  builtAt?: string;
+}
+
+/** Returns an ISO timestamp that is stale (> 24h ago). */
+function staleTimestamp(hoursAgo = 26): string {
+  return new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
+}
+
+/** Returns an ISO timestamp that is fresh (< 24h ago). */
+function freshTimestamp(): string {
+  return new Date(Date.now() - 30 * 60 * 1000).toISOString(); // 30 minutes ago
+}
+
+/**
+ * Creates a temp project directory with a .gsd/graphs/graph.json file.
+ * Returns the projectDir path. Caller is responsible for cleanup.
+ */
+function makeProjectDir(fixture: GraphFixture): string {
+  const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-test-"));
+  const gsdDir = join(projectDir, ".gsd");
+  const graphsDir = join(gsdDir, "graphs");
+  mkdirSync(graphsDir, { recursive: true });
+
+  const graph = {
+    nodes: fixture.nodes,
+    edges: fixture.edges,
+    builtAt: fixture.builtAt ?? freshTimestamp(),
+  };
+
+  writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+  return projectDir;
+}
+
+/** Removes a temp directory, suppressing errors on Windows. */
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/** Minimal node factory. */
+function makeNode(overrides: Partial<TestNode> & { id: string; label: string }): TestNode {
+  return {
+    type: "CLASS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+/** Minimal edge factory. */
+function makeEdge(overrides: Partial<TestEdge> & { from: string; to: string }): TestEdge {
+  return {
+    type: "CALLS",
+    confidence: "INFERRED",
+    ...overrides,
+  };
+}
+
+// ─── Group 1: Null returns ────────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — null returns", () => {
+  it("returns null immediately for empty string term", async () => {
+    // No graph.json needed — exits before any file I/O
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null for whitespace-only term", async () => {
+    const result = await inlineGraphSubgraph("/tmp/nonexistent", "   ", { budget: 3000 });
+    assert.strictEqual(result, null);
+  });
+
+  it("returns null when graphQuery returns zero nodes (no matching term in graph)", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+    });
+    try {
+      // "zzznomatch999" is intentionally absent from the fixture
+      const result = await inlineGraphSubgraph(projectDir, "zzznomatch999", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns null (no throw) when graph.json is missing", async () => {
+    // A project dir with no .gsd directory at all — graphQuery returns zero nodes
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-nofile-"));
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "auth", { budget: 3000 });
+      assert.strictEqual(result, null);
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 2: Correct output formatting ──────────────────────────────────────
+
+describe("inlineGraphSubgraph — correct output", () => {
+  it("returns block with section header and node labels when term matches", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "UserService" }),
+        makeNode({ id: "n2", label: "UserRepository" }),
+      ],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "User", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("### Knowledge Graph Context"), "should include section header");
+      assert.ok(result!.includes("UserService"), "should include first node label");
+      assert.ok(result!.includes("UserRepository"), "should include second node label");
+      assert.ok(result!.includes("Nodes (2)"), "should show node count");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include Relations section when edges array is empty", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthController" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("Relations"), "should not include Relations section for zero edges");
+      assert.ok(!result!.includes("⚠"), "should not include stale warning for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes Relations section when edges are present", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [
+        makeNode({ id: "n1", label: "AuthService" }),
+        makeNode({ id: "n2", label: "UserRepo" }),
+      ],
+      edges: [makeEdge({ from: "n1", to: "n2", type: "CALLS" })],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("Relations (1)"), "should show edge count");
+      assert.ok(result!.includes("→[CALLS]→"), "should include edge type in arrow notation");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes stale annotation when graph was built more than 24h ago", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: staleTimestamp(26), // 26 hours ago → stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("⚠ Graph last built"), "should include stale annotation");
+      assert.ok(result!.includes("h ago"), "should include hours-ago text");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("does not include stale annotation for a fresh graph", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService" })],
+      edges: [],
+      builtAt: freshTimestamp(), // 30 minutes ago → not stale
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(!result!.includes("⚠"), "should not include stale annotation for fresh graph");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("returns valid block even when graph.json has corrupted builtAt (graphStatus throws internally)", async () => {
+    // Write a graph.json with an invalid builtAt — graphStatus will catch and return {exists: false}
+    // inlineGraphSubgraph should still return the node block without stale annotation
+    const projectDir = mkdtempSync(join(tmpdir(), "graph-ctx-corrupt-"));
+    const gsdDir = join(projectDir, ".gsd");
+    const graphsDir = join(gsdDir, "graphs");
+    mkdirSync(graphsDir, { recursive: true });
+
+    const graph = {
+      nodes: [{ id: "n1", label: "AuthController", type: "CLASS", confidence: "INFERRED" }],
+      edges: [],
+      builtAt: "NOT-A-DATE", // invalid ISO — will cause Date.now() - NaN to produce NaN
+    };
+    writeFileSync(join(graphsDir, "graph.json"), JSON.stringify(graph), "utf-8");
+
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      // graphQuery reads the file and finds the node; graphStatus may return {exists: true, stale: false/true}
+      // Either way, function must not throw and must return a string with node content
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("AuthController"), "should include node label");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("passes the budget option to graphQuery (enforces node count limit)", async () => {
+    // Each node uses ~20 tokens. With budget=20, only ~1 node should be returned.
+    // Build a graph with many nodes all matching the same term.
+    const nodes: TestNode[] = Array.from({ length: 10 }, (_, i) =>
+      makeNode({ id: `n${i}`, label: `AuthModule${i}` })
+    );
+    const projectDir = makeProjectDir({ nodes, edges: [] });
+    try {
+      const resultSmall = await inlineGraphSubgraph(projectDir, "Auth", { budget: 20 });
+      const resultLarge = await inlineGraphSubgraph(projectDir, "Auth", { budget: 10000 });
+
+      // Both should return something (at least 1 node matches)
+      assert.ok(resultSmall !== null, "small-budget result should not be null");
+      assert.ok(resultLarge !== null, "large-budget result should not be null");
+
+      // With a very small budget (20 tokens ≈ 1 node), fewer nodes should appear
+      const smallNodeCount = (resultSmall!.match(/- \*\*/g) || []).length;
+      const largeNodeCount = (resultLarge!.match(/- \*\*/g) || []).length;
+      assert.ok(
+        smallNodeCount <= largeNodeCount,
+        `small-budget should return <= nodes than large-budget (got ${smallNodeCount} vs ${largeNodeCount})`,
+      );
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});
+
+// ─── Group 3: Node formatting ─────────────────────────────────────────────────
+
+describe("inlineGraphSubgraph — node formatting", () => {
+  it("includes description after em-dash when node has description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "JwtValidator", description: "JWT validation" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Jwt", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("— JWT validation"), "should include description after em-dash");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("omits em-dash suffix when node has no description", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "TokenStore" })], // no description
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Token", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      const lines = result!.split("\n");
+      const nodeLine = lines.find((l) => l.includes("TokenStore"));
+      assert.ok(nodeLine !== undefined, "node line should be present");
+      assert.ok(!nodeLine.includes("—"), "node line should not include em-dash when no description");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+
+  it("includes confidence tier in the node output line", async () => {
+    const projectDir = makeProjectDir({
+      nodes: [makeNode({ id: "n1", label: "AuthService", confidence: "EXTRACTED" })],
+      edges: [],
+    });
+    try {
+      const result = await inlineGraphSubgraph(projectDir, "Auth", { budget: 3000 });
+      assert.ok(result !== null, "result should not be null");
+      assert.ok(result!.includes("EXTRACTED"), "should include the confidence tier in node line");
+    } finally {
+      cleanup(projectDir);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -80,7 +80,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 14, 'schema version should be 14');
+    assert.deepStrictEqual(version?.['version'], 15, 'schema version should be 15');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -198,7 +198,7 @@ test("session_start bootstraps the health widget alongside notifications", async
     },
   } as any;
 
-  registerHooks(pi);
+  registerHooks(pi, []);
   const sessionStart = handlers.get("session_start");
   assert.ok(sessionStart, "session_start handler is registered");