gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/auto-session-scope.test.ts

@@ -0,0 +1,331 @@
+// GSD-2 + Tests for MilestoneScope threading through AutoSession state (C2)
+//
+// Strategy: construct AutoSession directly + call createWorkspace/scopeMilestone
+// to mirror the rebuildScope() helper in auto.ts — avoids importing the full
+// auto.ts module (too many .js resolved imports).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { AutoSession } from "../auto/session.ts";
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+import type { MilestoneScope } from "../workspace.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-scope-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+function makeWorktreeDir(projectDir: string, milestoneId: string): string {
+  const wt = join(projectDir, ".gsd", "worktrees", milestoneId);
+  mkdirSync(wt, { recursive: true });
+  return wt;
+}
+
+/**
+ * Mirror the rebuildScope() helper from auto.ts — computes s.scope from the
+ * same inputs so tests can verify the behaviour without importing auto.ts.
+ */
+function applyRebuildScope(
+  s: AutoSession,
+  rawPath: string,
+  milestoneId: string | null,
+): void {
+  if (!milestoneId) {
+    s.scope = null;
+    return;
+  }
+  try {
+    const workspace = createWorkspace(rawPath);
+    s.scope = scopeMilestone(workspace, milestoneId);
+  } catch {
+    s.scope = null;
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("AutoSession.scope — project mode (basePath equals originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope is null when milestoneId is null", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = null;
+
+    applyRebuildScope(s, projectDir, null);
+
+    assert.equal(s.scope, null);
+  });
+
+  test("scope mode is 'project' when basePath equals originalBasePath", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+
+  test("scope projectRoot matches realpath of projectDir", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope worktreeRoot is null in project mode", () => {
+    const mid = "M001";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("scope path methods resolve under the .gsd directory", () => {
+    const mid = "M002";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    const gsd = join(projectDir, ".gsd");
+    assert.equal(s.scope.contextFile(), join(gsd, "milestones", mid, `${mid}-CONTEXT.md`));
+    assert.equal(s.scope.roadmapFile(), join(gsd, "milestones", mid, `${mid}-ROADMAP.md`));
+    assert.equal(s.scope.stateFile(), join(gsd, "STATE.md"));
+  });
+});
+
+describe("AutoSession.scope — worktree mode (basePath differs from originalBasePath)", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M001");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope mode is 'worktree' when basePath is the worktree path", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.mode, "worktree");
+  });
+
+  test("scope worktreeRoot matches realpath of worktreeDir", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope projectRoot resolves to project root (not worktree)", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+  });
+
+  test("scope milestoneId matches the milestone being tracked", () => {
+    const mid = "M001";
+    s.basePath = worktreeDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, worktreeDir, mid);
+
+    assert.ok(s.scope, "scope should be set");
+    assert.equal(s.scope.milestoneId, mid);
+  });
+});
+
+describe("AutoSession.scope — milestoneId change rebuilds scope", () => {
+  let s: AutoSession;
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("scope reflects the new milestoneId after rebuild", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+
+    assert.ok(s.scope, "initial scope should be set");
+    assert.equal(s.scope.milestoneId, "M001");
+
+    // Simulate milestone transition mid-session
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+
+    assert.ok(s.scope, "scope should be set after transition");
+    assert.equal(s.scope.milestoneId, "M002");
+  });
+
+  test("scope contextFile changes when milestoneId changes", () => {
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+
+    s.currentMilestoneId = "M001";
+    applyRebuildScope(s, projectDir, "M001");
+    const ctxM001 = s.scope?.contextFile();
+
+    s.currentMilestoneId = "M002";
+    applyRebuildScope(s, projectDir, "M002");
+    const ctxM002 = s.scope?.contextFile();
+
+    assert.ok(ctxM001, "M001 contextFile should be set");
+    assert.ok(ctxM002, "M002 contextFile should be set");
+    assert.notEqual(ctxM001, ctxM002, "contextFile must differ between milestone IDs");
+    assert.ok(ctxM001.includes("M001"), "M001 path should contain M001");
+    assert.ok(ctxM002.includes("M002"), "M002 path should contain M002");
+  });
+});
+
+describe("AutoSession.scope — resume from persisted state", () => {
+  let s: AutoSession;
+  let projectDir: string;
+  let worktreeDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    worktreeDir = makeWorktreeDir(projectDir, "M003");
+    s = new AutoSession();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("resume without worktree: scope mode is project, projectRoot is base", () => {
+    // Mirror the paused-session resume path:
+    //   s.currentMilestoneId = meta.milestoneId
+    //   s.originalBasePath   = meta.originalBasePath || base
+    //   rawPath              = originalBasePath (no worktreePath present)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, s.originalBasePath, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "project");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, null);
+  });
+
+  test("resume with valid worktree path: scope mode is worktree", () => {
+    // Mirror the paused-session resume path where worktreePath exists on disk:
+    //   rawPath = worktreePath (existsSync true)
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = worktreeDir;
+
+    assert.ok(existsSync(worktreeDir), "worktreeDir must exist for this test");
+
+    applyRebuildScope(s, worktreeDir, s.currentMilestoneId);
+
+    assert.ok(s.scope, "scope should be reconstructed");
+    assert.equal(s.scope.milestoneId, mid);
+    assert.equal(s.scope.workspace.mode, "worktree");
+    assert.equal(s.scope.workspace.projectRoot, realpathSync(projectDir));
+    assert.equal(s.scope.workspace.worktreeRoot, realpathSync(worktreeDir));
+  });
+
+  test("scope is consistent with direct createWorkspace + scopeMilestone for same inputs", () => {
+    const mid = "M003";
+    s.currentMilestoneId = mid;
+    s.originalBasePath = projectDir;
+    s.basePath = projectDir;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set");
+
+    // Build expected scope via lower-level API to verify equivalence
+    const ws = createWorkspace(projectDir);
+    const expected = scopeMilestone(ws, mid);
+
+    assert.equal(s.scope.milestoneId, expected.milestoneId);
+    assert.equal(s.scope.contextFile(), expected.contextFile());
+    assert.equal(s.scope.roadmapFile(), expected.roadmapFile());
+    assert.equal(s.scope.stateFile(), expected.stateFile());
+    assert.equal(s.scope.dbPath(), expected.dbPath());
+    assert.equal(s.scope.milestoneDir(), expected.milestoneDir());
+    assert.equal(s.scope.metaJson(), expected.metaJson());
+  });
+
+  test("reset() clears scope", () => {
+    const mid = "M003";
+    s.basePath = projectDir;
+    s.originalBasePath = projectDir;
+    s.currentMilestoneId = mid;
+
+    applyRebuildScope(s, projectDir, mid);
+    assert.ok(s.scope, "scope should be set before reset");
+
+    s.reset();
+    assert.equal(s.scope, null, "scope must be null after reset()");
+  });
+});

package/src/resources/extensions/gsd/tests/auto-workers.test.ts

@@ -0,0 +1,105 @@
+// gsd-2 + Auto-mode worker registry tests (Phase B coordination)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import { _getAdapter } from "../gsd-db.ts";
+import {
+  registerAutoWorker,
+  heartbeatAutoWorker,
+  markWorkerCrashed,
+  markWorkerStopping,
+  getActiveAutoWorkers,
+  getAutoWorker,
+} from "../db/auto-workers.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-auto-workers-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("registerAutoWorker creates a row with active status and heartbeat", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  assert.match(id, /^auto-/, "worker_id has expected prefix");
+
+  const row = getAutoWorker(id);
+  assert.ok(row, "row exists");
+  assert.equal(row!.status, "active");
+  assert.equal(row!.project_root_realpath, base);
+  assert.equal(row!.pid, process.pid);
+});
+
+test("heartbeatAutoWorker updates last_heartbeat_at", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  const initial = getAutoWorker(id)!;
+  await new Promise(r => setTimeout(r, 10));
+  heartbeatAutoWorker(id);
+  const after = getAutoWorker(id)!;
+  const initialTs = Date.parse(initial.last_heartbeat_at);
+  const afterTs = Date.parse(after.last_heartbeat_at);
+  assert.ok(Number.isFinite(initialTs), "initial heartbeat parses");
+  assert.ok(Number.isFinite(afterTs), "updated heartbeat parses");
+  assert.ok(afterTs > initialTs, "heartbeat advanced");
+});
+
+test("markWorkerStopping flips status to stopping", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  markWorkerStopping(id);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "stopping");
+});
+
+test("markWorkerCrashed flips status to crashed", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  markWorkerCrashed(id);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "crashed");
+});
+
+test("getActiveAutoWorkers filters by status and TTL", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const a = registerAutoWorker({ projectRootRealpath: base });
+  const b = registerAutoWorker({ projectRootRealpath: base });
+
+  const active = getActiveAutoWorkers();
+  assert.equal(active.length, 2);
+  assert.ok(active.find(w => w.worker_id === a));
+  assert.ok(active.find(w => w.worker_id === b));
+
+  _getAdapter()!.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": a });
+
+  const after = getActiveAutoWorkers();
+  assert.equal(after.length, 1);
+  assert.equal(after[0].worker_id, b);
+});

package/src/resources/extensions/gsd/tests/auto-worktree-registry.test.ts

@@ -0,0 +1,176 @@
+// GSD-2 + Unit tests for the workspace registry that replaced the originalBase singleton
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import {
+  getAutoWorktreeOriginalBase,
+  getActiveAutoWorktreeContext,
+  _resetAutoWorktreeOriginalBaseForTests,
+  createAutoWorktree,
+  enterAutoWorktree,
+  teardownAutoWorktree,
+} from "../auto-worktree.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+// Safe: all inputs below are hardcoded test strings, not user input.
+function git(subArgs: string[], cwd: string): void {
+  execFileSync("git", subArgs, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function createTempRepo(t: { after: (fn: () => void) => void }): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "awreg-test-")));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("auto-worktree workspace registry", () => {
+  const savedCwd = process.cwd();
+
+  beforeEach(() => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(savedCwd);
+  });
+
+  test("getAutoWorktreeOriginalBase() is null at baseline", () => {
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+  });
+
+  test("getActiveAutoWorktreeContext() is null at baseline", () => {
+    assert.strictEqual(getActiveAutoWorktreeContext(), null);
+  });
+
+  test("_resetAutoWorktreeOriginalBaseForTests() clears the registry — idempotent", () => {
+    _resetAutoWorktreeOriginalBaseForTests();
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+    _resetAutoWorktreeOriginalBaseForTests();
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null);
+  });
+
+  test("behavioral equivalence: createAutoWorktree populates registry; teardown clears it", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M001");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M001 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    // Before entering: registry must be empty
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "originalBase is null before entering worktree");
+
+    createAutoWorktree(tempDir, "M001");
+
+    // After enter: getAutoWorktreeOriginalBase must equal tempDir
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      tempDir,
+      "getAutoWorktreeOriginalBase() returns projectRoot after createAutoWorktree",
+    );
+
+    // getActiveAutoWorktreeContext must return the correct shape
+    const ctx = getActiveAutoWorktreeContext();
+    assert.ok(ctx !== null, "context is non-null inside worktree");
+    assert.strictEqual(ctx.originalBase, tempDir, "context.originalBase matches tempDir");
+    assert.strictEqual(ctx.worktreeName, "M001", "context.worktreeName is M001");
+    assert.strictEqual(ctx.branch, "milestone/M001", "context.branch is milestone/M001");
+
+    // Teardown: registry must be cleared
+    teardownAutoWorktree(tempDir, "M001");
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "getAutoWorktreeOriginalBase() is null after teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null,
+      "getActiveAutoWorktreeContext() is null after teardown");
+
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("behavioral equivalence: enterAutoWorktree also populates registry", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M002");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M002 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M002");
+
+    // Simulate leaving the worktree (crash/pause)
+    _resetAutoWorktreeOriginalBaseForTests();
+    process.chdir(tempDir);
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null,
+      "registry is empty after manual reset");
+
+    // Re-enter via enterAutoWorktree
+    enterAutoWorktree(tempDir, "M002");
+
+    assert.strictEqual(
+      getAutoWorktreeOriginalBase(),
+      tempDir,
+      "getAutoWorktreeOriginalBase() returns projectRoot after enterAutoWorktree",
+    );
+    const ctx = getActiveAutoWorktreeContext();
+    assert.ok(ctx !== null, "context is non-null after re-entry");
+    assert.strictEqual(ctx.originalBase, tempDir);
+    assert.strictEqual(ctx.worktreeName, "M002");
+    assert.strictEqual(ctx.branch, "milestone/M002");
+
+    teardownAutoWorktree(tempDir, "M002");
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("single-occupancy: entering a new workspace replaces the previous one", (t) => {
+    const dir1 = createTempRepo(t);
+    const dir2 = createTempRepo(t);
+
+    // Set up milestone in dir1
+    const ms1Dir = join(dir1, ".gsd", "milestones", "M010");
+    mkdirSync(ms1Dir, { recursive: true });
+    writeFileSync(join(ms1Dir, "CONTEXT.md"), "# M010\n");
+    git(["add", "."], dir1);
+    git(["commit", "-m", "add milestone"], dir1);
+
+    // Set up milestone in dir2
+    const ms2Dir = join(dir2, ".gsd", "milestones", "M020");
+    mkdirSync(ms2Dir, { recursive: true });
+    writeFileSync(join(ms2Dir, "CONTEXT.md"), "# M020\n");
+    git(["add", "."], dir2);
+    git(["commit", "-m", "add milestone"], dir2);
+
+    // Enter dir1/M010
+    createAutoWorktree(dir1, "M010");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), dir1,
+      "registry holds dir1 after entering M010");
+
+    // Tear down dir1 cleanly
+    teardownAutoWorktree(dir1, "M010");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry cleared after M010 teardown");
+
+    // Enter dir2/M020 — registry should now hold dir2 only
+    createAutoWorktree(dir2, "M020");
+    assert.strictEqual(getAutoWorktreeOriginalBase(), dir2,
+      "registry holds dir2 after entering M020 (single-occupancy preserved)");
+    assert.notStrictEqual(getAutoWorktreeOriginalBase(), dir1,
+      "dir1 is no longer in the registry");
+
+    teardownAutoWorktree(dir2, "M020");
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+});