gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/doctor-environment-worktree.test.ts

@@ -0,0 +1,164 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+/**
+ * doctor-environment-worktree.test.ts — Worktree-aware dependency checks (#2303).
+ *
+ * Reproduction: doctor-environment `checkDependenciesInstalled` falsely reports
+ * `env_dependencies` error inside auto-worktrees because `node_modules` is
+ * absent by design (worktrees symlink to the project root's node_modules and
+ * the symlink may not yet exist at check time).
+ *
+ * Fix: when the basePath contains `.gsd/worktrees/`, resolve the project root
+ * and check its node_modules instead.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, symlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  runEnvironmentChecks,
+  environmentResultsToDoctorIssues,
+  checkEnvironmentHealth,
+} from "../doctor-environment.ts";
+/** Create a directory tree with files. */
+function createDir(files: Record<string, string> = {}): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-wt-env-"));
+  for (const [name, content] of Object.entries(files)) {
+    const filePath = join(dir, name);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+  }
+  return dir;
+}
+
+describe('doctor-environment-worktree', async () => {
+  const cleanups: string[] = [];
+
+  try {
+    // ── Reproduction: worktree path without node_modules ───────────────
+    test('worktree: missing node_modules should NOT error when project root has them', () => {
+      // Simulate project root with node_modules
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      // Simulate a worktree inside .gsd/worktrees/<name>/
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-abc");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+      // node_modules intentionally absent — this is the bug scenario
+
+      const results = runEnvironmentChecks(worktreeDir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+
+      // Before fix: this would return status "error" with "node_modules missing"
+      // After fix: should return "ok" because project root has node_modules
+      assert.ok(
+        depsCheck === undefined || depsCheck.status !== "error",
+        "worktree should not report env_dependencies error when project root has node_modules",
+      );
+    });
+
+    // ── Worktree with NO node_modules anywhere should still error ──────
+    test('worktree: missing node_modules everywhere should still error', () => {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      cleanups.push(projectRoot);
+      // No node_modules at project root either
+
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-xyz");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+
+      const results = runEnvironmentChecks(worktreeDir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check still runs in worktree");
+      assert.deepStrictEqual(depsCheck!.status, "error", "reports error when node_modules missing everywhere");
+    });
+
+    // ── Worktree env_dependencies not in doctor issues ──────────────────
+    test('worktree: checkEnvironmentHealth should not add env_dependencies for valid worktree', async () => {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      const worktreeDir = join(projectRoot, ".gsd", "worktrees", "slice-pr");
+      mkdirSync(worktreeDir, { recursive: true });
+      writeFileSync(
+        join(worktreeDir, "package.json"),
+        JSON.stringify({ name: "test-project" }),
+      );
+
+      const issues: any[] = [];
+      await checkEnvironmentHealth(worktreeDir, issues);
+      const depIssue = issues.find(i => i.code === "env_dependencies");
+      assert.deepStrictEqual(
+        depIssue,
+        undefined,
+        "no env_dependencies issue for worktree with project root node_modules",
+      );
+    });
+
+    // ── Non-worktree path still catches missing node_modules ───────────
+    test('non-worktree: missing node_modules still detected', () => {
+      const dir = createDir({
+        "package.json": JSON.stringify({ name: "test" }),
+      });
+      cleanups.push(dir);
+      const results = runEnvironmentChecks(dir);
+      const depsCheck = results.find(r => r.name === "dependencies");
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.deepStrictEqual(depsCheck!.status, "error", "missing node_modules is an error for non-worktree");
+    });
+
+    // ── GSD_WORKTREE env var detection ─────────────────────────────────
+    test('GSD_WORKTREE env: should resolve project root node_modules', () => {
+      const projectRoot = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      mkdirSync(join(projectRoot, "node_modules"), { recursive: true });
+      cleanups.push(projectRoot);
+
+      // Create a directory that doesn't have .gsd/worktrees in path but
+      // has GSD_WORKTREE env pointing to project root
+      const someDir = createDir({
+        "package.json": JSON.stringify({ name: "test-project" }),
+      });
+      cleanups.push(someDir);
+
+      const origEnv = process.env.GSD_WORKTREE;
+      try {
+        process.env.GSD_WORKTREE = projectRoot;
+        const results = runEnvironmentChecks(someDir);
+        const depsCheck = results.find(r => r.name === "dependencies");
+        assert.ok(
+          depsCheck === undefined || depsCheck.status !== "error",
+          "GSD_WORKTREE env allows fallback to project root node_modules",
+        );
+      } finally {
+        if (origEnv === undefined) {
+          delete process.env.GSD_WORKTREE;
+        } else {
+          process.env.GSD_WORKTREE = origEnv;
+        }
+      }
+    });
+
+  } finally {
+    for (const dir of cleanups) {
+      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/doctor-environment.test.ts

@@ -1,3 +1,5 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 /**
  * doctor-environment.test.ts — Tests for environment health checks (#1221).
  *
@@ -25,10 +27,6 @@ import {
   checkEnvironmentHealth,
   type EnvironmentCheckResult,
 } from "../doctor-environment.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
 function createProjectDir(files: Record<string, string> = {}): string {
   const dir = mkdtempSync(join(tmpdir(), "gsd-env-test-"));
   for (const [name, content] of Object.entries(files)) {
@@ -39,34 +37,31 @@ function createProjectDir(files: Record<string, string> = {}): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe('doctor-environment', async () => {
   const cleanups: string[] = [];
 
   try {
     // ── Node Version Check ─────────────────────────────────────────────
-    console.log("\n=== env: no package.json returns empty ===");
-    {
+    test('env: no package.json returns empty', () => {
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       // No package.json → no node checks
       const nodeCheck = results.find(r => r.name === "node_version");
-      assertEq(nodeCheck, undefined, "no node version check without package.json");
-    }
+      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without package.json");
+    });
 
-    console.log("\n=== env: package.json without engines returns no node check ===");
-    {
+    test('env: package.json without engines returns no node check', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const nodeCheck = results.find(r => r.name === "node_version");
-      assertEq(nodeCheck, undefined, "no node version check without engines field");
-    }
+      assert.deepStrictEqual(nodeCheck, undefined, "no node version check without engines field");
+    });
 
-    console.log("\n=== env: package.json with engines returns node check ===");
-    {
+    test('env: package.json with engines returns node check', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({
           name: "test",
@@ -77,27 +72,25 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const nodeCheck = results.find(r => r.name === "node_version");
-      assertTrue(nodeCheck !== undefined, "node version check runs with engines field");
+      assert.ok(nodeCheck !== undefined, "node version check runs with engines field");
       // Current node should be >= 18 in CI
-      assertEq(nodeCheck!.status, "ok", "node version meets requirement");
-    }
+      assert.deepStrictEqual(nodeCheck!.status, "ok", "node version meets requirement");
+    });
 
     // ── Dependencies Check ─────────────────────────────────────────────
-    console.log("\n=== env: missing node_modules detected ===");
-    {
+    test('env: missing node_modules detected', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assertTrue(depsCheck !== undefined, "dependencies check runs");
-      assertEq(depsCheck!.status, "error", "missing node_modules is an error");
-      assertTrue(depsCheck!.message.includes("node_modules missing"), "reports missing node_modules");
-    }
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.deepStrictEqual(depsCheck!.status, "error", "missing node_modules is an error");
+      assert.ok(depsCheck!.message.includes("node_modules missing"), "reports missing node_modules");
+    });
 
-    console.log("\n=== env: existing node_modules detected ===");
-    {
+    test('env: existing node_modules detected', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -105,25 +98,23 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const depsCheck = results.find(r => r.name === "dependencies");
-      assertTrue(depsCheck !== undefined, "dependencies check runs");
-      assertEq(depsCheck!.status, "ok", "existing node_modules is ok");
-    }
+      assert.ok(depsCheck !== undefined, "dependencies check runs");
+      assert.deepStrictEqual(depsCheck!.status, "ok", "existing node_modules is ok");
+    });
 
     // ── Env File Check ─────────────────────────────────────────────────
-    console.log("\n=== env: .env.example without .env detected ===");
-    {
+    test('env: .env.example without .env detected', () => {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\nAPI_KEY=xxx\n",
       });
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "warning", "missing .env is a warning");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(envCheck!.status, "warning", "missing .env is a warning");
+    });
 
-    console.log("\n=== env: .env.example with .env is ok ===");
-    {
+    test('env: .env.example with .env is ok', () => {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\n",
         ".env": "DB_URL=postgres://localhost/test\n",
@@ -131,12 +122,11 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "ok", "present .env is ok");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(envCheck!.status, "ok", "present .env is ok");
+    });
 
-    console.log("\n=== env: .env.example with .env.local is ok ===");
-    {
+    test('env: .env.example with .env.local is ok', () => {
       const dir = createProjectDir({
         ".env.example": "DB_URL=xxx\n",
         ".env.local": "DB_URL=postgres://localhost/test\n",
@@ -144,25 +134,23 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const envCheck = results.find(r => r.name === "env_file");
-      assertTrue(envCheck !== undefined, "env file check runs");
-      assertEq(envCheck!.status, "ok", ".env.local counts as present");
-    }
+      assert.ok(envCheck !== undefined, "env file check runs");
+      assert.deepStrictEqual(envCheck!.status, "ok", ".env.local counts as present");
+    });
 
     // ── Disk Space Check ───────────────────────────────────────────────
-    console.log("\n=== env: disk space check returns result ===");
     if (process.platform !== "win32") {
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const diskCheck = results.find(r => r.name === "disk_space");
-      assertTrue(diskCheck !== undefined, "disk space check runs on unix");
+      assert.ok(diskCheck !== undefined, "disk space check runs on unix");
       // Should be ok on dev machines with reasonable disk
-      assertTrue(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
+      assert.ok(diskCheck!.status === "ok" || diskCheck!.status === "warning", "disk check returns valid status");
     }
 
     // ── Project Tools Check ────────────────────────────────────────────
-    console.log("\n=== env: detects missing python when pyproject.toml exists ===");
-    {
+    test('env: detects missing python when pyproject.toml exists', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "pyproject.toml": "[build-system]\nrequires = ['setuptools']\n",
@@ -173,11 +161,10 @@ async function main(): Promise<void> {
       const pythonCheck = results.find(r => r.name === "python");
       // Python is likely installed on CI/dev machines, so just verify the check runs
       // without error — the result depends on the system
-      assertTrue(true, "python check runs without error");
-    }
+      assert.ok(true, "python check runs without error");
+    });
 
-    console.log("\n=== env: detects Cargo.toml ===");
-    {
+    test('env: detects Cargo.toml', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Cargo.toml": "[package]\nname = 'test'\n",
@@ -186,12 +173,11 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       // Just verify it runs without error
-      assertTrue(true, "cargo check runs without error");
-    }
+      assert.ok(true, "cargo check runs without error");
+    });
 
     // ── Docker Check ───────────────────────────────────────────────────
-    console.log("\n=== env: no docker check without Dockerfile ===");
-    {
+    test('env: no docker check without Dockerfile', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -199,11 +185,10 @@ async function main(): Promise<void> {
       cleanups.push(dir);
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
-      assertEq(dockerCheck, undefined, "no docker check without Dockerfile");
-    }
+      assert.deepStrictEqual(dockerCheck, undefined, "no docker check without Dockerfile");
+    });
 
-    console.log("\n=== env: docker check with Dockerfile ===");
-    {
+    test('env: docker check with Dockerfile', () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
         "Dockerfile": "FROM node:22\n",
@@ -213,12 +198,11 @@ async function main(): Promise<void> {
       const results = runEnvironmentChecks(dir);
       const dockerCheck = results.find(r => r.name === "docker");
       // Docker may or may not be installed on the test machine
-      assertTrue(dockerCheck !== undefined, "docker check runs when Dockerfile present");
-    }
+      assert.ok(dockerCheck !== undefined, "docker check runs when Dockerfile present");
+    });
 
     // ── Doctor Issue Conversion ────────────────────────────────────────
-    console.log("\n=== env: converts results to doctor issues ===");
-    {
+    test('env: converts results to doctor issues', () => {
       const results: EnvironmentCheckResult[] = [
         { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
         { name: "dependencies", status: "error", message: "node_modules missing" },
@@ -226,16 +210,15 @@ async function main(): Promise<void> {
       ];
 
       const issues = environmentResultsToDoctorIssues(results);
-      assertEq(issues.length, 2, "only non-ok results converted");
-      assertEq(issues[0]!.severity, "error", "error severity preserved");
-      assertEq(issues[0]!.code, "env_dependencies", "code prefixed with env_");
-      assertEq(issues[1]!.severity, "warning", "warning severity preserved");
-      assertTrue(issues[1]!.message.includes("Copy .env.example"), "detail included in message");
-    }
+      assert.deepStrictEqual(issues.length, 2, "only non-ok results converted");
+      assert.deepStrictEqual(issues[0]!.severity, "error", "error severity preserved");
+      assert.deepStrictEqual(issues[0]!.code, "env_dependencies", "code prefixed with env_");
+      assert.deepStrictEqual(issues[1]!.severity, "warning", "warning severity preserved");
+      assert.ok(issues[1]!.message.includes("Copy .env.example"), "detail included in message");
+    });
 
     // ── checkEnvironmentHealth integration ──────────────────────────────
-    console.log("\n=== env: checkEnvironmentHealth adds issues to array ===");
-    {
+    test('env: checkEnvironmentHealth adds issues to array', async () => {
       const dir = createProjectDir({
         "package.json": JSON.stringify({ name: "test" }),
       });
@@ -244,12 +227,11 @@ async function main(): Promise<void> {
       const issues: any[] = [];
       await checkEnvironmentHealth(dir, issues);
       // Should have at least the missing node_modules issue
-      assertTrue(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
-    }
+      assert.ok(issues.some(i => i.code === "env_dependencies"), "environment issues added to array");
+    });
 
     // ── Report Formatting ──────────────────────────────────────────────
-    console.log("\n=== env: formatEnvironmentReport ===");
-    {
+    test('env: formatEnvironmentReport', () => {
       const results: EnvironmentCheckResult[] = [
         { name: "node_version", status: "ok", message: "Node.js v22.0.0" },
         { name: "dependencies", status: "error", message: "node_modules missing", detail: "Run npm install" },
@@ -257,32 +239,29 @@ async function main(): Promise<void> {
       ];
 
       const report = formatEnvironmentReport(results);
-      assertTrue(report.includes("Environment Health:"), "has header");
-      assertTrue(report.includes("Node.js v22.0.0"), "includes ok result");
-      assertTrue(report.includes("node_modules missing"), "includes error result");
-      assertTrue(report.includes("Run npm install"), "includes detail for errors");
-    }
+      assert.ok(report.includes("Environment Health:"), "has header");
+      assert.ok(report.includes("Node.js v22.0.0"), "includes ok result");
+      assert.ok(report.includes("node_modules missing"), "includes error result");
+      assert.ok(report.includes("Run npm install"), "includes detail for errors");
+    });
 
-    console.log("\n=== env: formatEnvironmentReport empty ===");
-    {
+    test('env: formatEnvironmentReport empty', () => {
       const report = formatEnvironmentReport([]);
-      assertEq(report, "No environment checks applicable.", "empty report message");
-    }
+      assert.deepStrictEqual(report, "No environment checks applicable.", "empty report message");
+    });
 
     // ── Full environment checks include git remote ─────────────────────
-    console.log("\n=== env: runFullEnvironmentChecks includes git remote ===");
-    {
+    test('env: runFullEnvironmentChecks includes git remote', () => {
       // runFullEnvironmentChecks adds git remote check
       // We can't easily test this without a real git repo, but verify it doesn't throw
       const dir = createProjectDir();
       cleanups.push(dir);
       const results = runFullEnvironmentChecks(dir);
       // No git repo → no remote check, but should not throw
-      assertTrue(true, "runFullEnvironmentChecks does not throw on non-git dir");
-    }
+      assert.ok(true, "runFullEnvironmentChecks does not throw on non-git dir");
+    });
 
     // ── Port Detection from package.json ───────────────────────────────
-    console.log("\n=== env: port detection from scripts ===");
     if (process.platform !== "win32") {
       const dir = createProjectDir({
         "package.json": JSON.stringify({
@@ -299,7 +278,7 @@ async function main(): Promise<void> {
       // Port 3456 is unlikely to be in use, so no conflicts expected
       const portConflicts = results.filter(r => r.name === "port_conflict");
       // Just verify it ran without error
-      assertTrue(true, "port check with script-detected ports runs without error");
+      assert.ok(true, "port check with script-detected ports runs without error");
     }
 
   } finally {
@@ -307,8 +286,4 @@ async function main(): Promise<void> {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-
-  report();
-}
-
-main();
+});