gsd-pi 2.35.0-dev.30eec3f → 2.35.0-dev.640d5c7

package/src/resources/extensions/gsd/tests/paths.test.ts

@@ -1,113 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { spawnSync } from "node:child_process";
-
-import { gsdRoot, _clearGsdRootCache } from "../paths.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-/** Create a tmp dir and resolve symlinks + 8.3 short names (macOS /var→/private/var, Windows RUNNER~1→runneradmin). */
-function tmp(): string {
-  const p = mkdtempSync(join(tmpdir(), "gsd-paths-test-"));
-  try { return realpathSync.native(p); } catch { return p; }
-}
-
-function cleanup(dir: string): void {
-  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-}
-
-function initGit(dir: string): void {
-  spawnSync("git", ["init"], { cwd: dir });
-  spawnSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
-}
-
-// ── tests ──────────────────────────────────────────────────────────────────
-
-{
-  // Case 1: .gsd exists at basePath — fast path
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const result = gsdRoot(root);
-    assertEq(result, join(root, ".gsd"), "fast path: returns basePath/.gsd");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 2: .gsd exists at git root, cwd is a subdirectory
-  const root = tmp();
-  try {
-    initGit(root);
-    mkdirSync(join(root, ".gsd"));
-    const sub = join(root, "src", "deep");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    assertEq(result, join(root, ".gsd"), "git-root probe: finds .gsd at git root from subdirectory");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 3: .gsd in an ancestor — walk-up finds it (git repo with no .gsd at root)
-  const root = tmp();
-  try {
-    // Init a git repo so git probe returns root — but put .gsd one level deeper
-    // to force the walk-up path: root/project/.gsd, cwd = root/project/src/deep
-    initGit(root);
-    const project = join(root, "project");
-    mkdirSync(join(project, ".gsd"), { recursive: true });
-    const deep = join(project, "src", "deep");
-    mkdirSync(deep, { recursive: true });
-    _clearGsdRootCache();
-    // git probe returns root (no .gsd there), so walk-up takes over and finds project/.gsd
-    const result = gsdRoot(deep);
-    assertEq(result, join(project, ".gsd"), "walk-up: finds .gsd in ancestor when git root has none");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 4: .gsd nowhere — fallback returns original basePath/.gsd
-  // Use an isolated git repo so we fully control the environment above basePath
-  const root = tmp();
-  try {
-    initGit(root);                          // git root = root, no .gsd anywhere
-    const sub = join(root, "src");
-    mkdirSync(sub, { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(sub);
-    // git probe finds root (no .gsd), walk-up finds nothing → fallback = sub/.gsd
-    assertEq(result, join(sub, ".gsd"), "fallback: returns basePath/.gsd when .gsd not found anywhere");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 5: cache — second call returns same value without re-probing
-  const root = tmp();
-  try {
-    mkdirSync(join(root, ".gsd"));
-    _clearGsdRootCache();
-    const first = gsdRoot(root);
-    const second = gsdRoot(root);
-    assertEq(first, second, "cache: same result returned on second call");
-    assertTrue(first === second, "cache: identity check (same string)");
-  } finally { cleanup(root); }
-}
-
-{
-  // Case 6: .gsd at basePath takes precedence over ancestor .gsd
-  const outer = tmp();
-  try {
-    initGit(outer);
-    mkdirSync(join(outer, ".gsd"));
-    const inner = join(outer, "nested");
-    mkdirSync(join(inner, ".gsd"), { recursive: true });
-    _clearGsdRootCache();
-    const result = gsdRoot(inner);
-    assertEq(result, join(inner, ".gsd"), "precedence: nearest .gsd wins over ancestor");
-  } finally { cleanup(outer); }
-}
-
-report();

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

@@ -1,165 +0,0 @@
-/**
- * Shared test utilities for GSD extension tests.
- *
- * Provides cross-platform helpers for creating temporary git repos,
- * safe cleanup, file creation, and shell-free git operations.
- *
- * Usage:
- *   import { git, makeTempRepo, cleanup, createFile } from "./test-utils.ts";
- */
-
-import { execFileSync } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-import { tmpdir } from "node:os";
-
-/**
- * Shell-free git helper — uses execFileSync to bypass shell entirely.
- * No quoting issues, no Windows cmd.exe incompatibilities.
- *
- * @param cwd - Working directory for git command
- * @param args - Git arguments (e.g., "add", "-A")
- * @returns trimmed stdout
- */
-export function git(cwd: string, ...args: string[]): string {
-  return execFileSync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    stdio: "pipe",
-  }).trim();
-}
-
-/**
- * Create a temporary git repository with an initial commit.
- * Configures user.email, user.name, and core.autocrlf=false for
- * consistent behavior across platforms.
- *
- * @param prefix - Optional prefix for the temp directory name
- * @returns absolute path to the temp repo
- */
-export function makeTempRepo(prefix: string = "gsd-test-"): string {
-  const dir = mkdtempSync(join(tmpdir(), prefix));
-  git(dir, "init");
-  git(dir, "config", "user.email", "test@test.com");
-  git(dir, "config", "user.name", "Test");
-  git(dir, "config", "core.autocrlf", "false");
-  writeFileSync(join(dir, "README.md"), "# init\n");
-  git(dir, "add", "-A");
-  git(dir, "commit", "-m", "init");
-  git(dir, "branch", "-M", "main");
-  return dir;
-}
-
-/**
- * Create a temporary directory (not a git repo).
- *
- * @param prefix - Optional prefix for the temp directory name
- * @returns absolute path to the temp directory
- */
-export function makeTempDir(prefix: string = "gsd-test-"): string {
-  return mkdtempSync(join(tmpdir(), prefix));
-}
-
-/**
- * Safely clean up a temporary directory.
- * Non-fatal — Windows may hold file descriptors briefly.
- */
-export function cleanup(dir: string): void {
-  try {
-    rmSync(dir, { recursive: true, force: true });
-  } catch {
-    // ignore — Windows may hold file descriptors briefly after test
-  }
-}
-
-/**
- * Create a file with intermediate directories.
- *
- * @param base - Base directory
- * @param relativePath - Relative path within base (e.g., "src/index.ts")
- * @param content - File content (defaults to empty string)
- * @returns absolute path to the created file
- */
-export function createFile(base: string, relativePath: string, content: string = ""): string {
-  const fullPath = join(base, relativePath);
-  mkdirSync(dirname(fullPath), { recursive: true });
-  writeFileSync(fullPath, content, "utf-8");
-  return fullPath;
-}
-
-/**
- * Safely read a file, returning null if it doesn't exist or is a directory.
- * Prevents EISDIR errors.
- */
-export function safeReadFile(filePath: string): string | null {
-  try {
-    if (!existsSync(filePath)) return null;
-    if (!statSync(filePath).isFile()) return null;
-    return readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Create a minimal GSD milestone structure in a temp directory.
- *
- * @param base - Base directory (should have .gsd/ or be a temp repo)
- * @param mid - Milestone ID (e.g., "M001")
- * @param options - What to create
- */
-export function writeMilestoneFixture(
-  base: string,
-  mid: string,
-  options: {
-    roadmap?: string;
-    context?: string;
-    summary?: string;
-    validation?: string;
-    slices?: Array<{
-      id: string;
-      plan?: string;
-      summary?: string;
-      uat?: string;
-    }>;
-  } = {},
-): void {
-  const milestoneDir = join(base, ".gsd", "milestones", mid);
-  mkdirSync(milestoneDir, { recursive: true });
-
-  if (options.roadmap) {
-    writeFileSync(join(milestoneDir, `${mid}-ROADMAP.md`), options.roadmap);
-  }
-  if (options.context) {
-    writeFileSync(join(milestoneDir, `${mid}-CONTEXT.md`), options.context);
-  }
-  if (options.summary) {
-    writeFileSync(join(milestoneDir, `${mid}-SUMMARY.md`), options.summary);
-  }
-  if (options.validation) {
-    writeFileSync(join(milestoneDir, `${mid}-VALIDATION.md`), options.validation);
-  }
-  if (options.slices) {
-    for (const slice of options.slices) {
-      const sliceDir = join(milestoneDir, "slices", slice.id);
-      mkdirSync(sliceDir, { recursive: true });
-      if (slice.plan) {
-        writeFileSync(join(sliceDir, `${slice.id}-PLAN.md`), slice.plan);
-      }
-      if (slice.summary) {
-        writeFileSync(join(sliceDir, `${slice.id}-SUMMARY.md`), slice.summary);
-      }
-      if (slice.uat) {
-        writeFileSync(join(sliceDir, `${slice.id}-UAT.md`), slice.uat);
-      }
-    }
-  }
-}