gsd-pi 2.16.0 → 2.18.0

package/src/resources/extensions/gsd/tests/memory-leak-guards.test.ts

@@ -0,0 +1,87 @@
+/**
+ * memory-leak-guards.test.ts — Tests for #611 memory leak fixes.
+ *
+ * Verifies that module-level state accumulators are properly bounded
+ * and cleared to prevent OOM during long-running auto-mode sessions.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { saveActivityLog, clearActivityLogState } from "../activity-log.ts";
+import { clearPathCache } from "../paths.ts";
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+
+function createCtx(entries: unknown[]) {
+  return { sessionManager: { getEntries: () => entries } } as unknown as ExtensionContext;
+}
+
+// ─── activity-log: clearActivityLogState ─────────────────────────────────────
+
+test("clearActivityLogState resets dedup state so identical saves write again", () => {
+  clearActivityLogState();
+  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-test-"));
+  try {
+    const entries = [{ role: "assistant", content: "test entry" }];
+    const ctx = createCtx(entries);
+
+    // First save
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+
+    const actDir = join(baseDir, ".gsd", "activity");
+    assert.equal(readdirSync(actDir).length, 1, "first save creates one file");
+
+    // Same content, same unit — deduped
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+    assert.equal(readdirSync(actDir).length, 1, "dedup prevents duplicate write");
+
+    // Clear state
+    clearActivityLogState();
+
+    // Same content again — after clear, writes again (fresh state)
+    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
+    assert.equal(readdirSync(actDir).length, 2, "after clear, dedup state is reset");
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ─── activity-log: streaming JSONL write ────────────────────────────────────
+
+test("saveActivityLog writes valid JSONL via streaming", () => {
+  clearActivityLogState();
+  const baseDir = mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-"));
+  try {
+    const entries = [
+      { type: "message", message: { role: "user", content: "hello" } },
+      { type: "message", message: { role: "assistant", content: "world" } },
+      { type: "message", message: { role: "user", content: "test" } },
+    ];
+    const ctx = createCtx(entries);
+
+    saveActivityLog(ctx, baseDir, "execute-task", "M002/S01/T01");
+
+    const actDir = join(baseDir, ".gsd", "activity");
+    const files = readdirSync(actDir);
+    assert.equal(files.length, 1, "one file written");
+
+    const content = readFileSync(join(actDir, files[0]), "utf-8");
+    const lines = content.trim().split("\n");
+    assert.equal(lines.length, 3, "three JSONL lines");
+
+    for (const line of lines) {
+      assert.doesNotThrow(() => JSON.parse(line), `line is valid JSON`);
+    }
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+});
+
+// ─── paths.ts: directory cache bounds ───────────────────────────────────────
+
+test("clearPathCache does not throw", () => {
+  assert.doesNotThrow(() => clearPathCache(), "clearPathCache should not throw");
+});

package/src/resources/extensions/gsd/tests/preferences-git.test.ts

@@ -68,6 +68,34 @@ async function main(): Promise<void> {
     assertTrue(warnings[0].includes("merge_to_main"), "warning mentions merge_to_main");
   }
 
+  console.log("\n=== git.commit_docs ===");
+
+  // Valid boolean values accepted
+  {
+    const { preferences, errors } = validatePreferences({ git: { commit_docs: false } });
+    assertEq(errors.length, 0, "commit_docs: false — no errors");
+    assertEq(preferences.git?.commit_docs, false, "commit_docs: false — value preserved");
+  }
+  {
+    const { preferences, errors } = validatePreferences({ git: { commit_docs: true } });
+    assertEq(errors.length, 0, "commit_docs: true — no errors");
+    assertEq(preferences.git?.commit_docs, true, "commit_docs: true — value preserved");
+  }
+
+  // Invalid type produces error
+  {
+    const { errors } = validatePreferences({ git: { commit_docs: "no" as any } });
+    assertTrue(errors.length > 0, "commit_docs: string — produces error");
+    assertTrue(errors[0].includes("commit_docs"), "commit_docs: string — error mentions commit_docs");
+  }
+
+  // Undefined passes through without issue
+  {
+    const { preferences, errors } = validatePreferences({ git: { auto_push: true } });
+    assertEq(errors.length, 0, "commit_docs: undefined — no errors");
+    assertEq(preferences.git?.commit_docs, undefined, "commit_docs: undefined — not set");
+  }
+
   report();
 }
 

package/src/resources/extensions/gsd/tests/preferences-wizard-fields.test.ts

@@ -0,0 +1,168 @@
+/**
+ * preferences-wizard-fields.test.ts — Validates that all wizard-configurable
+ * preference fields are properly validated and round-trip through the schema.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+import { validatePreferences } from "../preferences.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+  console.log("\n=== budget fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_ceiling: 25.50,
+      budget_enforcement: "warn",
+      context_pause_threshold: 80,
+    });
+    assertEq(errors.length, 0, "valid budget fields produce no errors");
+    assertEq(preferences.budget_ceiling, 25.50, "budget_ceiling passes through");
+    assertEq(preferences.budget_enforcement, "warn", "budget_enforcement passes through");
+    assertEq(preferences.context_pause_threshold, 80, "context_pause_threshold passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_enforcement: "pause",
+    });
+    assertEq(errors.length, 0, "budget_enforcement 'pause' is valid");
+    assertEq(preferences.budget_enforcement, "pause", "pause passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({
+      budget_enforcement: "halt",
+    });
+    assertEq(errors.length, 0, "budget_enforcement 'halt' is valid");
+    assertEq(preferences.budget_enforcement, "halt", "halt passes through");
+  }
+
+  {
+    const { errors } = validatePreferences({
+      budget_enforcement: "invalid",
+    } as unknown as GSDPreferences);
+    assertTrue(errors.some(e => e.includes("budget_enforcement")), "invalid budget_enforcement rejected");
+  }
+
+  console.log("\n=== notification fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      notifications: {
+        enabled: true,
+        on_complete: false,
+        on_error: true,
+        on_budget: true,
+        on_milestone: false,
+        on_attention: true,
+      },
+    });
+    assertEq(errors.length, 0, "valid notifications produce no errors");
+    assertEq(preferences.notifications?.enabled, true, "notifications.enabled passes through");
+    assertEq(preferences.notifications?.on_complete, false, "notifications.on_complete passes through");
+    assertEq(preferences.notifications?.on_milestone, false, "notifications.on_milestone passes through");
+  }
+
+  {
+    const { errors } = validatePreferences({
+      notifications: "invalid",
+    } as unknown as GSDPreferences);
+    assertTrue(errors.some(e => e.includes("notifications")), "invalid notifications rejected");
+  }
+
+  console.log("\n=== git fields validate correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({
+      git: {
+        auto_push: true,
+        push_branches: false,
+        remote: "upstream",
+        snapshots: true,
+        pre_merge_check: "auto",
+        commit_type: "feat",
+        main_branch: "develop",
+        merge_strategy: "squash",
+        isolation: "branch",
+      },
+    });
+    assertEq(errors.length, 0, "valid git fields produce no errors");
+    assertEq(preferences.git?.auto_push, true, "git.auto_push passes through");
+    assertEq(preferences.git?.push_branches, false, "git.push_branches passes through");
+    assertEq(preferences.git?.remote, "upstream", "git.remote passes through");
+    assertEq(preferences.git?.snapshots, true, "git.snapshots passes through");
+    assertEq(preferences.git?.pre_merge_check, "auto", "git.pre_merge_check passes through");
+    assertEq(preferences.git?.commit_type, "feat", "git.commit_type passes through");
+    assertEq(preferences.git?.main_branch, "develop", "git.main_branch passes through");
+    assertEq(preferences.git?.merge_strategy, "squash", "git.merge_strategy passes through");
+    assertEq(preferences.git?.isolation, "branch", "git.isolation passes through");
+  }
+
+  console.log("\n=== uat_dispatch validates correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({ uat_dispatch: true });
+    assertEq(errors.length, 0, "valid uat_dispatch produces no errors");
+    assertEq(preferences.uat_dispatch, true, "uat_dispatch true passes through");
+  }
+
+  {
+    const { preferences, errors } = validatePreferences({ uat_dispatch: false });
+    assertEq(errors.length, 0, "valid uat_dispatch false produces no errors");
+    assertEq(preferences.uat_dispatch, false, "uat_dispatch false passes through");
+  }
+
+  console.log("\n=== unique_milestone_ids validates correctly ===");
+
+  {
+    const { preferences, errors } = validatePreferences({ unique_milestone_ids: true });
+    assertEq(errors.length, 0, "valid unique_milestone_ids produces no errors");
+    assertEq(preferences.unique_milestone_ids, true, "unique_milestone_ids passes through");
+  }
+
+  console.log("\n=== all wizard fields together produce no errors ===");
+
+  {
+    const fullPrefs: GSDPreferences = {
+      version: 1,
+      models: { research: "claude-opus-4-6", planning: "claude-sonnet-4-6" },
+      auto_supervisor: { soft_timeout_minutes: 15, idle_timeout_minutes: 5, hard_timeout_minutes: 25 },
+      git: {
+        main_branch: "main",
+        auto_push: true,
+        push_branches: false,
+        remote: "origin",
+        snapshots: true,
+        pre_merge_check: "auto",
+        commit_type: "feat",
+        merge_strategy: "squash",
+        isolation: "worktree",
+      },
+      skill_discovery: "suggest",
+      unique_milestone_ids: false,
+      budget_ceiling: 50,
+      budget_enforcement: "pause",
+      context_pause_threshold: 75,
+      notifications: {
+        enabled: true,
+        on_complete: true,
+        on_error: true,
+        on_budget: true,
+        on_milestone: true,
+        on_attention: true,
+      },
+      uat_dispatch: false,
+    };
+    const { errors, warnings } = validatePreferences(fullPrefs);
+    const unknownWarnings = warnings.filter(w => w.includes("unknown"));
+    assertEq(errors.length, 0, "full wizard prefs produce no errors");
+    assertEq(unknownWarnings.length, 0, "full wizard prefs produce no unknown-key warnings");
+  }
+
+  report();
+}
+
+main();

package/src/resources/extensions/gsd/tests/queue-order.test.ts

@@ -0,0 +1,204 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  loadQueueOrder,
+  saveQueueOrder,
+  sortByQueueOrder,
+  pruneQueueOrder,
+  validateQueueOrder,
+} from '../queue-order.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-queue-order-'));
+  mkdirSync(join(base, '.gsd'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// sortByQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== sortByQueueOrder ===');
+
+// Null order → default milestoneIdSort
+{
+  const result = sortByQueueOrder(['M003', 'M001', 'M002'], null);
+  assertEq(result, ['M001', 'M002', 'M003'], 'null order falls back to numeric sort');
+}
+
+// Custom order → exact sequence
+{
+  const result = sortByQueueOrder(['M001', 'M002', 'M003'], ['M003', 'M001', 'M002']);
+  assertEq(result, ['M003', 'M001', 'M002'], 'custom order produces exact sequence');
+}
+
+// Custom order with new IDs → appended at end in numeric order
+{
+  const result = sortByQueueOrder(['M001', 'M002', 'M003', 'M004'], ['M003', 'M001']);
+  assertEq(result, ['M003', 'M001', 'M002', 'M004'], 'new IDs appended in numeric order');
+}
+
+// Custom order with deleted IDs → silently skipped
+{
+  const result = sortByQueueOrder(['M001', 'M003'], ['M003', 'M002', 'M001']);
+  assertEq(result, ['M003', 'M001'], 'deleted IDs in order are skipped');
+}
+
+// Empty custom order → all IDs in numeric order
+{
+  const result = sortByQueueOrder(['M002', 'M001'], []);
+  assertEq(result, ['M001', 'M002'], 'empty custom order falls back to numeric sort');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// loadQueueOrder / saveQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== loadQueueOrder / saveQueueOrder ===');
+
+// Load returns null when file doesn't exist
+{
+  const base = createFixtureBase();
+  assertEq(loadQueueOrder(base), null, 'returns null when file missing');
+  cleanup(base);
+}
+
+// Save then load round-trip
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M003', 'M001', 'M002']);
+  const loaded = loadQueueOrder(base);
+  assertEq(loaded, ['M003', 'M001', 'M002'], 'round-trip preserves order');
+
+  // Verify file contains updatedAt
+  const raw = JSON.parse(readFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'utf-8'));
+  assertTrue(typeof raw.updatedAt === 'string' && raw.updatedAt.length > 0, 'file contains updatedAt');
+
+  cleanup(base);
+}
+
+// Load returns null on corrupt JSON
+{
+  const base = createFixtureBase();
+  writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), 'not json');
+  assertEq(loadQueueOrder(base), null, 'returns null on corrupt JSON');
+  cleanup(base);
+}
+
+// Load returns null when order field is not an array
+{
+  const base = createFixtureBase();
+  writeFileSync(join(base, '.gsd', 'QUEUE-ORDER.json'), '{"order": "invalid"}');
+  assertEq(loadQueueOrder(base), null, 'returns null when order is not array');
+  cleanup(base);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// pruneQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== pruneQueueOrder ===');
+
+// Prune removes invalid IDs
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M001', 'M002', 'M003']);
+  pruneQueueOrder(base, ['M001', 'M003']);
+  assertEq(loadQueueOrder(base), ['M001', 'M003'], 'prune removes invalid IDs');
+  cleanup(base);
+}
+
+// Prune no-ops when file doesn't exist
+{
+  const base = createFixtureBase();
+  pruneQueueOrder(base, ['M001']); // should not throw
+  assertTrue(!existsSync(join(base, '.gsd', 'QUEUE-ORDER.json')), 'prune does not create file');
+  cleanup(base);
+}
+
+// Prune no-ops when all IDs are valid
+{
+  const base = createFixtureBase();
+  saveQueueOrder(base, ['M001', 'M002']);
+  pruneQueueOrder(base, ['M001', 'M002', 'M003']);
+  assertEq(loadQueueOrder(base), ['M001', 'M002'], 'prune is no-op when all valid');
+  cleanup(base);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateQueueOrder
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateQueueOrder ===');
+
+// Valid order with no dependencies
+{
+  const depsMap = new Map<string, string[]>();
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(result.valid, 'valid when no dependencies');
+  assertEq(result.violations.length, 0, 'no violations');
+  assertEq(result.redundant.length, 0, 'no redundancies');
+}
+
+// Dependency violation: M002 before M001, but M002 depends on M001
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M002', 'M001'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid when dep violated');
+  assertEq(result.violations.length, 1, 'one violation');
+  assertEq(result.violations[0].type, 'would_block', 'violation type is would_block');
+  assertEq(result.violations[0].milestone, 'M002', 'violation milestone is M002');
+  assertEq(result.violations[0].dependsOn, 'M001', 'violation dep is M001');
+}
+
+// Redundant dependency: M002 depends on M001, M001 comes first in order
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(result.valid, 'valid when dep satisfied by position');
+  assertEq(result.redundant.length, 1, 'one redundancy');
+  assertEq(result.redundant[0].milestone, 'M002', 'redundant milestone is M002');
+}
+
+// Completed dep is always satisfied
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M001']]]);
+  const result = validateQueueOrder(['M002'], depsMap, new Set(['M001']));
+  assertTrue(result.valid, 'valid when dep is already completed');
+  assertEq(result.violations.length, 0, 'no violations for completed dep');
+}
+
+// Missing dependency
+{
+  const depsMap = new Map<string, string[]>([['M002', ['M099']]]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid when dep does not exist');
+  assertEq(result.violations[0].type, 'missing_dep', 'violation type is missing_dep');
+}
+
+// Circular dependency
+{
+  const depsMap = new Map<string, string[]>([
+    ['M001', ['M002']],
+    ['M002', ['M001']],
+  ]);
+  const result = validateQueueOrder(['M001', 'M002'], depsMap, new Set());
+  assertTrue(!result.valid, 'invalid on circular dependency');
+  const circularViolation = result.violations.find(v => v.type === 'circular');
+  assertTrue(!!circularViolation, 'circular violation detected');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+
+report();