muonroi-cli 1.4.0 → 1.4.1

package/src/scaffold/__tests__/init-new.spec.ts

@@ -1,450 +0,0 @@
-/**
- * Unit tests for initNewProject scaffolder.
- * All fs + exec operations are mocked — no real I/O or shell-out.
- */
-
-import { describe, expect, it, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mock node:child_process so the bbTemplate path can run without real dotnet.
-//   - `dotnet --version`   → simulate dotnet present / absent via SPAWN_MODE
-//   - `dotnet new list`    → empty (template not installed) so installBBTemplates fires
-//   - `dotnet new install` → ok (status 0)
-// All test exec() calls go through opts.fs.exec (a vi.fn), so spawnSync is
-// only invoked by detectDotnet / detectInstalledBBTemplates / installBBTemplates.
-// ---------------------------------------------------------------------------
-const spawnSyncCalls: Array<{ cmd: string; args: string[] }> = [];
-let SPAWN_MODE: "dotnet-present" | "dotnet-absent" = "dotnet-absent";
-
-vi.mock("node:child_process", async () => {
-  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
-  return {
-    ...actual,
-    spawnSync: (cmd: string, args: string[]) => {
-      spawnSyncCalls.push({ cmd, args });
-      if (cmd !== "dotnet") {
-        return { status: 1, stdout: "", stderr: "no such command", pid: 0, output: [], signal: null } as ReturnType<
-          typeof actual.spawnSync
-        >;
-      }
-      if (args[0] === "--version") {
-        return SPAWN_MODE === "dotnet-present"
-          ? ({ status: 0, stdout: "9.0.100\n", stderr: "", pid: 0, output: [], signal: null } as ReturnType<
-              typeof actual.spawnSync
-            >)
-          : ({ status: 1, stdout: "", stderr: "not found", pid: 0, output: [], signal: null } as ReturnType<
-              typeof actual.spawnSync
-            >);
-      }
-      if (args[0] === "new" && args[1] === "list") {
-        // Pretend nothing is installed so installBBTemplates fires.
-        return {
-          status: 0,
-          stdout: "Template Name      Short Name\n--------------\n",
-          stderr: "",
-          pid: 0,
-          output: [],
-          signal: null,
-        } as ReturnType<typeof actual.spawnSync>;
-      }
-      if (args[0] === "new" && args[1] === "install") {
-        return { status: 0, stdout: "installed", stderr: "", pid: 0, output: [], signal: null } as ReturnType<
-          typeof actual.spawnSync
-        >;
-      }
-      return { status: 1, stdout: "", stderr: "unhandled", pid: 0, output: [], signal: null } as ReturnType<
-        typeof actual.spawnSync
-      >;
-    },
-  };
-});
-
-import { initNewProject } from "../init-new.js";
-
-// ---------------------------------------------------------------------------
-// Mock fs factory — returns a fresh spy set per test.
-// ---------------------------------------------------------------------------
-
-function makeMockFs(opts?: { mkdirThrows?: string; existsReturns?: boolean }) {
-  const mkdir = vi.fn(async (_p: string) => {
-    if (opts?.mkdirThrows) {
-      const err = new Error(opts.mkdirThrows) as NodeJS.ErrnoException;
-      err.code = "EEXIST";
-      throw err;
-    }
-  });
-  const writeFile = vi.fn(async (_p: string, _content: string) => {});
-  const exec = vi.fn(async (_cmd: string, _cwd: string) => ({ stdout: "", stderr: "" }));
-  const exists = vi.fn((_p: string) => opts?.existsReturns ?? false);
-  return { mkdir, writeFile, exec, exists };
-}
-
-// ---------------------------------------------------------------------------
-// Test 1: scaffolds expected file tree (react)
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — react", () => {
-  it("creates expected directories and files for react stack (FE-only, no bbTemplate)", async () => {
-    const fs = makeMockFs();
-    const result = await initNewProject({
-      projectName: "test-app",
-      feStack: "react",
-      projectsRoot: "/tmp/projects",
-      fs,
-    });
-
-    // Directories created: project root, server, client, client/src
-    const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0] as string);
-    expect(mkdirPaths.some((p) => p.endsWith("test-app"))).toBe(true);
-    expect(mkdirPaths.some((p) => p.includes("server"))).toBe(true);
-    expect(mkdirPaths.some((p) => p.endsWith("client"))).toBe(true);
-    expect(mkdirPaths.some((p) => p.includes("client") && p.endsWith("src"))).toBe(true);
-
-    // Files written
-    expect(result.files).toContain("package.json");
-    expect(result.files).toContain("client/package.json");
-    expect(result.files).toContain("client/vite.config.ts");
-    expect(result.files).toContain("client/index.html");
-    expect(result.files).toContain("client/src/main.tsx");
-
-    // No bbTemplate → no BE scaffold commands run (clone fallback retired).
-    const execCmds = fs.exec.mock.calls.map((c) => c[0] as string);
-    expect(execCmds.every((cmd) => !cmd.startsWith("git clone"))).toBe(true);
-    expect(execCmds.every((cmd) => !cmd.startsWith("dotnet"))).toBe(true);
-
-    // main.tsx contains SemanticProvider
-    const writeFileCalls = fs.writeFile.mock.calls;
-    const mainTsxCall = writeFileCalls.find((c) => (c[0] as string).endsWith("main.tsx"));
-    expect(mainTsxCall).toBeDefined();
-    expect(mainTsxCall![1] as string).toContain("SemanticProvider");
-
-    // projectDir returned correctly
-    expect(result.projectDir).toContain("test-app");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: scaffolds expected file tree (angular)
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — angular", () => {
-  it("creates expected directories and files for angular stack", async () => {
-    const fs = makeMockFs();
-    const result = await initNewProject({
-      projectName: "ng-app",
-      feStack: "angular",
-      projectsRoot: "/tmp/projects",
-      fs,
-    });
-
-    // Directories: project root, server, client, client/src, client/src/app
-    const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0] as string);
-    expect(mkdirPaths.some((p) => p.includes("app"))).toBe(true);
-
-    // Files written
-    expect(result.files).toContain("package.json");
-    expect(result.files).toContain("client/package.json");
-    expect(result.files).toContain("client/tsconfig.json");
-    expect(result.files).toContain("client/src/main.ts");
-    expect(result.files).toContain("client/src/app/app.component.ts");
-
-    // No react files
-    expect(result.files).not.toContain("client/vite.config.ts");
-    expect(result.files).not.toContain("client/src/main.tsx");
-
-    // app.component.ts uses muonroiSemantic directive
-    const writeFileCalls = fs.writeFile.mock.calls;
-    const componentCall = writeFileCalls.find((c) => (c[0] as string).endsWith("app.component.ts"));
-    expect(componentCall).toBeDefined();
-    expect(componentCall![1] as string).toContain("muonroiSemantic");
-    expect(componentCall![1] as string).toContain("SemanticDirective");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: feStack=none skips client/**
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — none", () => {
-  it("skips client directory and files when feStack is none", async () => {
-    const fs = makeMockFs();
-    const result = await initNewProject({
-      projectName: "be-only",
-      feStack: "none",
-      projectsRoot: "/tmp/projects",
-      fs,
-    });
-
-    // No client/* files
-    const clientFiles = result.files.filter((f) => f.startsWith("client/"));
-    expect(clientFiles).toHaveLength(0);
-
-    // No client directories created
-    const mkdirPaths = fs.mkdir.mock.calls.map((c) => c[0] as string);
-    expect(mkdirPaths.every((p) => !p.includes("client"))).toBe(true);
-
-    // root package.json still written
-    expect(result.files).toContain("package.json");
-
-    // No BE commands either (no bbTemplate provided).
-    expect(fs.exec.mock.calls.length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: refuses if projectDir already exists
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — existence guard", () => {
-  it("rejects with descriptive error when target directory already exists", async () => {
-    const fs = makeMockFs({ existsReturns: true });
-    await expect(
-      initNewProject({
-        projectName: "existing-app",
-        feStack: "react",
-        projectsRoot: "/tmp/projects",
-        fs,
-      }),
-    ).rejects.toThrow(/already exists/i);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 5: validates projectName
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — name validation", () => {
-  it("rejects path traversal in projectName", async () => {
-    const fs = makeMockFs();
-    await expect(
-      initNewProject({
-        projectName: "../escape",
-        feStack: "react",
-        fs,
-      }),
-    ).rejects.toThrow(/path traversal/i);
-  });
-
-  it("rejects empty project name", async () => {
-    const fs = makeMockFs();
-    await expect(
-      initNewProject({
-        projectName: "",
-        feStack: "react",
-        fs,
-      }),
-    ).rejects.toThrow(/empty/i);
-  });
-
-  it("rejects name with backslash traversal", async () => {
-    const fs = makeMockFs();
-    await expect(
-      initNewProject({
-        projectName: "foo\\bar",
-        feStack: "react",
-        fs,
-      }),
-    ).rejects.toThrow(/path traversal/i);
-  });
-
-  it("rejects name with invalid characters (spaces)", async () => {
-    const fs = makeMockFs();
-    await expect(
-      initNewProject({
-        projectName: "my app",
-        feStack: "react",
-        fs,
-      }),
-    ).rejects.toThrow(/invalid/i);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 6 (Plan 23-01b): bbTemplate path auto-installs missing template and
-// invokes `dotnet add package` per EE package.
-// ---------------------------------------------------------------------------
-
-describe("initNewProject — bbTemplate + EE packages (Plan 23-01b)", () => {
-  it("auto-installs the chosen template when missing and runs `dotnet add package` per EE package", async () => {
-    SPAWN_MODE = "dotnet-present";
-    spawnSyncCalls.length = 0;
-
-    const fs = makeMockFs();
-    const result = await initNewProject({
-      projectName: "todo-api",
-      feStack: "none",
-      projectsRoot: "/tmp/projects",
-      bbTemplate: {
-        shortName: "mr-base-sln",
-        nugetId: "Muonroi.BaseTemplate",
-        version: "1.0.0-alpha.3",
-      },
-      eePackages: ["Muonroi.AspNetCore", "Muonroi.Tenancy"],
-      fs,
-    });
-
-    // installBBTemplates was invoked with the selective nugetId.
-    const installCall = spawnSyncCalls.find(
-      (c) => c.cmd === "dotnet" && c.args[0] === "new" && c.args[1] === "install",
-    );
-    expect(installCall).toBeDefined();
-    expect(installCall!.args[2]).toBe("Muonroi.BaseTemplate@1.0.0-alpha.3");
-
-    // Only the chosen template was installed — sibling templates left alone.
-    const installRefs = spawnSyncCalls
-      .filter((c) => c.args[0] === "new" && c.args[1] === "install")
-      .map((c) => c.args[2]);
-    expect(installRefs).toEqual(["Muonroi.BaseTemplate@1.0.0-alpha.3"]);
-
-    // The exec recorder should contain `dotnet new mr-base-sln` and restore.
-    // The add-package loop is gated on findPrimaryCsproj() locating a real
-    // .csproj on disk — in this mock environment the template scaffold output
-    // doesn't exist, so the loop correctly skips all packages (with a single
-    // stderr warning). Tested separately against real scaffold output below
-    // via the dedicated findPrimaryCsproj unit test.
-    const execCmds = fs.exec.mock.calls.map((c) => [c[0] as string, c[1] as string]);
-    expect(execCmds.some(([cmd]) => cmd.startsWith("dotnet new mr-base-sln "))).toBe(true);
-    expect(execCmds.some(([cmd]) => cmd.includes("restore --nologo"))).toBe(true);
-
-    const addPackageCalls = execCmds.filter(([cmd]) => / add .* package /.test(cmd));
-    expect(addPackageCalls.length).toBe(0);
-
-    // No legacy `git clone` ever runs.
-    expect(execCmds.every(([cmd]) => !cmd.startsWith("git clone"))).toBe(true);
-
-    // Result flagged with template usage.
-    expect(result.usedDotnetTemplate).toBe(true);
-  });
-
-  it("throws (no clone fallback) when dotnet is unavailable but bbTemplate is requested", async () => {
-    SPAWN_MODE = "dotnet-absent";
-    spawnSyncCalls.length = 0;
-
-    const fs = makeMockFs();
-    await expect(
-      initNewProject({
-        projectName: "todo-api3",
-        feStack: "none",
-        projectsRoot: "/tmp/projects",
-        bbTemplate: {
-          shortName: "mr-base-sln",
-          nugetId: "Muonroi.BaseTemplate",
-          version: "1.0.0-alpha.3",
-        },
-        fs,
-      }),
-    ).rejects.toThrow(/Scaffold failed/i);
-
-    // No git clone command ever runs (no fallback).
-    const execCmds = fs.exec.mock.calls.map((c) => c[0] as string);
-    expect(execCmds.every((cmd) => !cmd.startsWith("git clone"))).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// findPrimaryCsproj — verifies heuristic against synthetic BB-shaped trees.
-// These shapes are derived from MANUAL scaffold runs of mr-micro-sln@1.10.0
-// and mr-mod-sln@1.10.0 (verified 2026-05-19 in /tmp/muonroi-scaffold-test).
-// ---------------------------------------------------------------------------
-
-import path from "node:path";
-import { type FindCsprojFs, findPrimaryCsproj } from "../init-new.js";
-
-function makeFsTree(files: Record<string, string>): FindCsprojFs {
-  // files: { "C:/x/y/foo.csproj": "<Project Sdk=...></Project>", ... }
-  const dirs = new Set<string>();
-  for (const p of Object.keys(files)) {
-    let cur = p;
-    while (true) {
-      const parent = cur.replace(/[/\\][^/\\]+$/, "");
-      if (parent === cur || parent === "") break;
-      dirs.add(parent);
-      cur = parent;
-    }
-  }
-  return {
-    readdir: (p: string) => {
-      const entries: Array<{ name: string; isDir: boolean; isFile: boolean }> = [];
-      const seen = new Set<string>();
-      const _prefix = `${p.replace(/[/\\]$/, "")}/`;
-      for (const f of Object.keys(files)) {
-        const norm = f.replace(/\\/g, "/");
-        const np = `${p.replace(/\\/g, "/").replace(/\/$/, "")}/`;
-        if (!norm.startsWith(np)) continue;
-        const rest = norm.slice(np.length);
-        const seg = rest.split("/")[0];
-        if (!seg || seen.has(seg)) continue;
-        seen.add(seg);
-        const isFile = rest === seg;
-        entries.push({ name: seg, isDir: !isFile, isFile });
-      }
-      for (const d of dirs) {
-        const norm = d.replace(/\\/g, "/");
-        const np = `${p.replace(/\\/g, "/").replace(/\/$/, "")}/`;
-        if (!norm.startsWith(np)) continue;
-        const rest = norm.slice(np.length);
-        const seg = rest.split("/")[0];
-        if (!seg || seen.has(seg)) continue;
-        seen.add(seg);
-        entries.push({ name: seg, isDir: true, isFile: false });
-      }
-      if (entries.length === 0 && !dirs.has(p.replace(/\\/g, "/").replace(/\/$/, ""))) {
-        throw new Error("ENOENT");
-      }
-      return entries;
-    },
-    readFile: (p: string) => {
-      const norm = p.replace(/\\/g, "/");
-      for (const [k, v] of Object.entries(files)) {
-        if (k.replace(/\\/g, "/") === norm) return v;
-      }
-      throw new Error("ENOENT");
-    },
-  };
-}
-
-describe("findPrimaryCsproj — BB template heuristic", () => {
-  const webSdk = `<Project Sdk="Microsoft.NET.Sdk.Web"><PropertyGroup/></Project>`;
-  const libSdk = `<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup/></Project>`;
-
-  it("picks the Gateway Web SDK csproj for mr-micro-sln shape", () => {
-    const fs = makeFsTree({
-      "C:/app/src/Gateways/App.Gateway/App.Gateway.csproj": webSdk,
-      "C:/app/src/Services/App.Catalog/App.Catalog.csproj": webSdk,
-      "C:/app/src/Services/App.Core/App.Core.csproj": libSdk,
-      "C:/app/src/Services/App.Data/App.Data.csproj": libSdk,
-    });
-    expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(
-      path.join("C:/app", "src", "Gateways", "App.Gateway", "App.Gateway.csproj"),
-    );
-  });
-
-  it("picks the Host Web SDK csproj for mr-mod-sln shape", () => {
-    const fs = makeFsTree({
-      "C:/app/src/Host/App.Host/App.Host.csproj": webSdk,
-      "C:/app/src/Modules/Catalog/App.Modules.Catalog.csproj": libSdk,
-      "C:/app/src/Shared/App.Kernel/App.Kernel.csproj": libSdk,
-    });
-    expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "Host", "App.Host", "App.Host.csproj"));
-  });
-
-  it("excludes test projects when picking primary", () => {
-    const fs = makeFsTree({
-      "C:/app/App.Tests/App.Tests.csproj": webSdk, // would otherwise win on depth
-      "C:/app/src/App.Api/App.Api.csproj": webSdk,
-    });
-    expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "App.Api", "App.Api.csproj"));
-  });
-
-  it("returns null when no .csproj is found", () => {
-    const fs = makeFsTree({ "C:/app/README.md": "" });
-    expect(findPrimaryCsproj("C:/app", 6, fs)).toBeNull();
-  });
-
-  it("falls back to non-Web SDK csproj when no Web SDK exists", () => {
-    const fs = makeFsTree({
-      "C:/app/src/App.Lib/App.Lib.csproj": libSdk,
-    });
-    expect(findPrimaryCsproj("C:/app", 6, fs)).toBe(path.join("C:/app", "src", "App.Lib", "App.Lib.csproj"));
-  });
-});

package/src/scaffold/__tests__/install-bb-templates.spec.ts

@@ -1,86 +0,0 @@
-/**
- * Plan 23-fix — focused tests for installBBTemplates exit-code detection.
- *
- * Background: `dotnet new install` on some SDKs prints warnings about stale
- * template paths (Failed to scan D:\...) and exits non-zero EVEN WHEN the
- * install succeeded. The fix treats stdout containing "Success:" as success
- * regardless of exit status. Without this, the TUI claimed "template could
- * not be applied" + a misleading "requires SDK X.0+; you have Y.Y.YYY" line
- * — observed in production session 36798f9c33fd (machine had SDK 9.0.313,
- * template required 9.0).
- */
-import { describe, expect, it, vi } from "vitest";
-
-const stubResult = (over: Partial<{ status: number; stdout: string; stderr: string }>) => ({
-  status: 0,
-  stdout: "",
-  stderr: "",
-  pid: 0,
-  output: [],
-  signal: null,
-  ...over,
-});
-
-let MOCK_INSTALL_RESULT: ReturnType<typeof stubResult> = stubResult({});
-
-vi.mock("node:child_process", async () => {
-  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
-  return {
-    ...actual,
-    spawnSync: (cmd: string, args: string[]) => {
-      if (cmd === "dotnet" && args[0] === "new" && args[1] === "install") {
-        return MOCK_INSTALL_RESULT;
-      }
-      return stubResult({ status: 1, stderr: "unhandled" });
-    },
-  };
-});
-
-import { installBBTemplates } from "../init-new.js";
-
-describe("installBBTemplates — Plan 23-fix exit code detection", () => {
-  it("returns true when status === 0 (normal success)", () => {
-    MOCK_INSTALL_RESULT = stubResult({
-      status: 0,
-      stdout: "Success: Muonroi.BaseTemplate::1.0.0-alpha.3 installed the following templates:\n",
-    });
-    expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-  });
-
-  it("returns true when status !== 0 but stdout has 'Success:' (stale scan-warning case)", () => {
-    // This is the exact failure mode from session 36798f9c33fd — dotnet emits
-    // "Warning: Failed to scan D:\Personal\Project\..." for stale template
-    // references, returns status=1, but the install itself succeeded.
-    MOCK_INSTALL_RESULT = stubResult({
-      status: 1,
-      stdout:
-        "The following template packages will be installed:\n   Muonroi.BaseTemplate::1.0.0-alpha.3\n" +
-        "Warning: Failed to scan D:\\Personal\\Project\\Muonroi.BaseTemplate.\n" +
-        "Success: Muonroi.BaseTemplate::1.0.0-alpha.3 installed the following templates:\n",
-      stderr: "stale scan warnings",
-    });
-    expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-  });
-
-  it("returns true when stdout contains 'is already installed' (legacy idempotency)", () => {
-    MOCK_INSTALL_RESULT = stubResult({
-      status: 1,
-      stdout: "Muonroi.BaseTemplate::1.0.0-alpha.3 is already installed.\n",
-    });
-    expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-  });
-
-  it("returns true when status === 106 (legacy already-installed code)", () => {
-    MOCK_INSTALL_RESULT = stubResult({ status: 106, stdout: "" });
-    expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(true);
-  });
-
-  it("returns false on genuine failure (non-zero status, no Success marker)", () => {
-    MOCK_INSTALL_RESULT = stubResult({
-      status: 1,
-      stdout: "NU1101: Unable to find package Muonroi.BaseTemplate.\n",
-      stderr: "package not found",
-    });
-    expect(installBBTemplates(["Muonroi.BaseTemplate"])).toBe(false);
-  });
-});

package/src/scaffold/__tests__/point-to-existing.spec.ts

@@ -1,114 +0,0 @@
-/**
- * Unit tests for pointToExisting().
- *
- * All filesystem operations use real tmp dirs so we don't need to mock fs.
- * detectVerifyRecipe is always mocked so there are no orchestrator calls.
- */
-
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { pointToExisting } from "../point-to-existing.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-let tmpRoot: string;
-
-beforeEach(() => {
-  tmpRoot = mkdtempSync(path.join(tmpdir(), "point-to-existing-test-"));
-});
-
-afterEach(() => {
-  rmSync(tmpRoot, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// Test 1: existing dir + recipe found → ok
-// ---------------------------------------------------------------------------
-
-describe("pointToExisting — success", () => {
-  it("returns ok=true when dir exists and detectVerifyRecipe returns a recipe", async () => {
-    const mockRecipe = { kind: "bun-test" };
-    const detectVerifyRecipe = vi.fn(async (_cwd: string) => mockRecipe);
-
-    const result = await pointToExisting({
-      path: tmpRoot,
-      detectVerifyRecipe,
-    });
-
-    expect(result.ok).toBe(true);
-    expect(result.reason).toBe("ok");
-    expect(result.recipe).toEqual(mockRecipe);
-    expect(path.isAbsolute(result.absolutePath)).toBe(true);
-    // detectVerifyRecipe called with the resolved absolute path
-    expect(detectVerifyRecipe).toHaveBeenCalledOnce();
-    expect(detectVerifyRecipe.mock.calls[0]![0]).toBe(result.absolutePath);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 2: nonexistent path → not_a_dir
-// ---------------------------------------------------------------------------
-
-describe("pointToExisting — nonexistent path", () => {
-  it("returns not_a_dir when path does not exist", async () => {
-    const detectVerifyRecipe = vi.fn(async () => ({ kind: "bun-test" }));
-
-    const result = await pointToExisting({
-      path: path.join(tmpRoot, "nonexistent-dir-xyz"),
-      detectVerifyRecipe,
-    });
-
-    expect(result.ok).toBe(false);
-    expect(result.reason).toBe("not_a_dir");
-    // detectVerifyRecipe must NOT be called when path is invalid
-    expect(detectVerifyRecipe).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 3: path is a file, not a directory → not_a_dir
-// ---------------------------------------------------------------------------
-
-describe("pointToExisting — file instead of directory", () => {
-  it("returns not_a_dir when path points to a file", async () => {
-    const filePath = path.join(tmpRoot, "some-file.txt");
-    writeFileSync(filePath, "hello");
-    const detectVerifyRecipe = vi.fn(async () => ({ kind: "bun-test" }));
-
-    const result = await pointToExisting({
-      path: filePath,
-      detectVerifyRecipe,
-    });
-
-    expect(result.ok).toBe(false);
-    expect(result.reason).toBe("not_a_dir");
-    expect(detectVerifyRecipe).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Test 4: dir exists but detectVerifyRecipe returns null → no_recipe
-// ---------------------------------------------------------------------------
-
-describe("pointToExisting — no recipe", () => {
-  it("returns no_recipe when detectVerifyRecipe returns null", async () => {
-    const subdir = path.join(tmpRoot, "project-no-recipe");
-    mkdirSync(subdir);
-    const detectVerifyRecipe = vi.fn(async (_cwd: string) => null);
-
-    const result = await pointToExisting({
-      path: subdir,
-      detectVerifyRecipe,
-    });
-
-    expect(result.ok).toBe(false);
-    expect(result.reason).toBe("no_recipe");
-    expect(result.absolutePath).toBeTruthy();
-    // detectVerifyRecipe was called (path was valid)
-    expect(detectVerifyRecipe).toHaveBeenCalledOnce();
-  });
-});