@ashlr/stack-core 0.1.1

package/src/__tests__/pipeline-recovery.test.ts

@@ -0,0 +1,106 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { emptyConfig, readConfig, writeConfig } from "../config.ts";
+import { addService } from "../pipeline.ts";
+import type { Provider } from "../providers/_base.ts";
+import { providers } from "../providers/index.ts";
+import { type Harness, setupFakePhantom } from "./_harness.ts";
+
+/**
+ * Partial-failure regression: if `materialize()` throws after `provision()`
+ * succeeded, we MUST still write a breadcrumb entry to .stack.toml so
+ * `stack doctor --fix` / `stack remove` can find and clean up the dangling
+ * upstream resource. Without this guard, the user ends up with a live
+ * provider-side resource and no local record of it at all.
+ */
+describe("addService partial-failure breadcrumb", () => {
+  let h: Harness;
+  let cwd: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    h = setupFakePhantom();
+    cwd = mkdtempSync(join(tmpdir(), "stack-partial-"));
+    originalCwd = process.cwd();
+    process.chdir(cwd);
+    await writeConfig(emptyConfig("test-template"), cwd);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    h.cleanup();
+  });
+
+  test("writes a partial entry when materialize throws post-provision", async () => {
+    const failingProvider: Provider = {
+      name: "partialsvc",
+      displayName: "Partial Service",
+      category: "database",
+      authKind: "api_key",
+      async login() {
+        return { token: "stub-token", identity: { id: "user-1" } };
+      },
+      async provision() {
+        return { id: "partial-resource-42", displayName: "the one", region: "us-east-1" };
+      },
+      async materialize() {
+        throw new Error("simulated materialize failure (e.g. keys endpoint 500)");
+      },
+    };
+
+    providers.partialsvc = async () => failingProvider;
+
+    await expect(
+      addService({ providerName: "partialsvc", cwd, interactive: false }),
+    ).rejects.toThrow(/simulated materialize failure/);
+
+    // Breadcrumb must be present so cleanup tooling can find the dangling resource.
+    const config = await readConfig(cwd);
+    expect(config.services.partialsvc).toBeDefined();
+    expect(config.services.partialsvc.resource_id).toBe("partial-resource-42");
+    expect(config.services.partialsvc.provider).toBe("partialsvc");
+    expect(config.services.partialsvc.region).toBe("us-east-1");
+    // We don't know what was materialized, so secrets must be empty.
+    expect(config.services.partialsvc.secrets).toEqual([]);
+    // Marker lets `stack doctor` distinguish partial rows from healthy ones.
+    expect(config.services.partialsvc.created_by).toBe("stack add (partial)");
+
+    delete providers.partialsvc;
+  });
+
+  test("non-persist runs do NOT leave a breadcrumb (dry-run / preview)", async () => {
+    const failingProvider: Provider = {
+      name: "drypartialsvc",
+      displayName: "Dry Partial Service",
+      category: "database",
+      authKind: "api_key",
+      async login() {
+        return { token: "stub-token" };
+      },
+      async provision() {
+        return { id: "dry-resource-1", displayName: "dry" };
+      },
+      async materialize() {
+        throw new Error("boom");
+      },
+    };
+
+    providers.drypartialsvc = async () => failingProvider;
+
+    await expect(
+      addService({
+        providerName: "drypartialsvc",
+        cwd,
+        interactive: false,
+        persist: false,
+      }),
+    ).rejects.toThrow(/boom/);
+
+    const config = await readConfig(cwd);
+    expect(config.services.drypartialsvc).toBeUndefined();
+
+    delete providers.drypartialsvc;
+  });
+});

package/src/__tests__/pipeline.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getProvider, listProviderNames } from "../providers/index.ts";
+
+/**
+ * Pipeline sanity checks — load every registered provider so a broken import
+ * in any provider shows up immediately, even without Phantom or real API keys.
+ */
+describe("provider registry", () => {
+  test("lists a curated catalog", () => {
+    const names = listProviderNames();
+    expect(names.length).toBeGreaterThanOrEqual(15);
+    // Spot-check the core four that define the product thesis.
+    expect(names).toContain("supabase");
+    expect(names).toContain("openai");
+    expect(names).toContain("vercel");
+    expect(names).toContain("github");
+  });
+
+  test("every provider loads and exposes the Provider contract", async () => {
+    for (const name of listProviderNames()) {
+      const p = await getProvider(name);
+      expect(p.name).toBe(name);
+      expect(typeof p.displayName).toBe("string");
+      expect(typeof p.login).toBe("function");
+      expect(typeof p.provision).toBe("function");
+      expect(typeof p.materialize).toBe("function");
+    }
+  });
+
+  test("getProvider rejects unknown names", async () => {
+    await expect(getProvider("not-a-real-provider")).rejects.toThrow(/PROVIDER_NOT_FOUND|No provider/);
+  });
+});
+
+describe("templates", () => {
+  test("templates directory resolves inside the monorepo", async () => {
+    const { resolveTemplatesDir, loadTemplate } = await import("../templates.ts");
+    const dir = resolveTemplatesDir();
+    expect(dir).toBeDefined();
+    const template = await loadTemplate("nextjs-supabase-posthog");
+    expect(template).toBeDefined();
+    expect(template?.services.supabase?.provider).toBe("supabase");
+  });
+
+  test("loadTemplate returns undefined for unknown names", async () => {
+    const { loadTemplate } = await import("../templates.ts");
+    const result = await loadTemplate("not-real");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("mcp-writer", () => {
+  test("mergeMcpEntry creates .mcp.json with the entry", async () => {
+    const { mergeMcpEntry } = await import("../mcp-writer.ts");
+    const cwd = mkdtempSync(join(tmpdir(), "stack-mcp-"));
+    await mergeMcpEntry(
+      {
+        name: "supabase",
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "@supabase/mcp-server-supabase"],
+      },
+      cwd,
+    );
+    const raw = await Bun.file(join(cwd, ".mcp.json")).text();
+    const parsed = JSON.parse(raw) as { mcpServers: Record<string, { command: string }> };
+    expect(parsed.mcpServers.supabase.command).toBe("npx");
+  });
+
+  test("mergeMcpEntry preserves unrelated keys in an existing file", async () => {
+    const { mergeMcpEntry } = await import("../mcp-writer.ts");
+    const cwd = mkdtempSync(join(tmpdir(), "stack-mcp-"));
+    writeFileSync(
+      join(cwd, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: { other: { command: "echo" } },
+        customKey: "keep-me",
+      }),
+    );
+    await mergeMcpEntry({ name: "new-one", type: "stdio", command: "npx" }, cwd);
+    const parsed = JSON.parse(await Bun.file(join(cwd, ".mcp.json")).text()) as {
+      mcpServers: Record<string, unknown>;
+      customKey: string;
+    };
+    expect(parsed.mcpServers.other).toBeDefined();
+    expect(parsed.mcpServers["new-one"]).toBeDefined();
+    expect(parsed.customKey).toBe("keep-me");
+  });
+});

package/src/__tests__/recipe.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  listRecipes,
+  readRecipe,
+  recipeFromRetrieval,
+  slugifyQuery,
+  writeRecipe,
+  type Recipe,
+} from "../ai/recipe.ts";
+
+function scratchDir(): { dir: string; cleanup: () => void } {
+  const dir = mkdtempSync(join(tmpdir(), "stack-recipe-"));
+  return {
+    dir,
+    cleanup: () => rmSync(dir, { recursive: true, force: true }),
+  };
+}
+
+describe("ai/recipe", () => {
+  it("round-trips a Recipe through write → read with fields preserved", async () => {
+    const { dir, cleanup } = scratchDir();
+    try {
+      const original: Recipe = {
+        id: "b2b-saas-auth-ai",
+        query: "B2B SaaS with auth + AI",
+        createdAt: "2026-04-18T00:00:00.000Z",
+        providers: [
+          { name: "supabase", rationale: "auth, database" },
+          { name: "anthropic", rationale: "ai" },
+        ],
+        guidance: "Top pick per category: Auth→supabase, AI→anthropic.",
+        projectContext: { hasAuth: true, language: "typescript" },
+      };
+      const path = await writeRecipe(original, dir);
+      expect(path).toContain(".stack/recipes/b2b-saas-auth-ai.toml");
+
+      const round = await readRecipe("b2b-saas-auth-ai", dir);
+      expect(round).toEqual(original);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("rejects reading a recipe referencing an unknown provider", async () => {
+    const { dir, cleanup } = scratchDir();
+    try {
+      // Write a valid recipe first, then corrupt it to contain an unknown provider.
+      await writeRecipe(
+        {
+          id: "bad",
+          query: "bad",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          providers: [{ name: "supabase" }],
+        },
+        dir,
+      );
+      const fs = await import("node:fs/promises");
+      await fs.writeFile(
+        join(dir, ".stack/recipes/bad.toml"),
+        `id = "bad"
+query = "bad"
+createdAt = "2026-01-01T00:00:00.000Z"
+
+[[providers]]
+name = "totally-made-up-provider"
+`,
+        "utf-8",
+      );
+      await expect(readRecipe("bad", dir)).rejects.toThrow(/UNKNOWN_PROVIDER_IN_RECIPE|unknown provider/i);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("rejects writing a recipe with an unknown provider", async () => {
+    const { dir, cleanup } = scratchDir();
+    try {
+      await expect(
+        writeRecipe(
+          {
+            id: "x",
+            query: "x",
+            createdAt: "2026-01-01T00:00:00.000Z",
+            providers: [{ name: "nope-not-real" }],
+          },
+          dir,
+        ),
+      ).rejects.toThrow(/unknown provider/i);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("listRecipes returns newest first and skips corrupt files", async () => {
+    const { dir, cleanup } = scratchDir();
+    try {
+      await writeRecipe(
+        {
+          id: "older",
+          query: "older",
+          createdAt: "2026-01-01T00:00:00.000Z",
+          providers: [{ name: "neon" }],
+        },
+        dir,
+      );
+      await writeRecipe(
+        {
+          id: "newer",
+          query: "newer",
+          createdAt: "2026-06-01T00:00:00.000Z",
+          providers: [{ name: "supabase" }],
+        },
+        dir,
+      );
+      const list = await listRecipes(dir);
+      expect(list.map((r) => r.id)).toEqual(["newer", "older"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("listRecipes returns [] when no recipes dir exists", async () => {
+    const { dir, cleanup } = scratchDir();
+    try {
+      const list = await listRecipes(dir);
+      expect(list).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  it("recipeFromRetrieval derives id, rationale, and createdAt", () => {
+    const recipe = recipeFromRetrieval(
+      "B2B SaaS with auth + AI + payments",
+      [
+        {
+          provider: { name: "supabase" } as never,
+          score: 9.9,
+          matched: ["auth", "database"],
+        },
+        {
+          provider: { name: "stripe" } as never,
+          score: 8.1,
+          matched: ["payments"],
+        },
+      ],
+      "pick supabase + stripe",
+    );
+    expect(recipe.id).toBe("b2b-saas-with-auth-ai-payments");
+    expect(recipe.providers[0]).toEqual({ name: "supabase", rationale: "auth, database" });
+    expect(recipe.providers[1]).toEqual({ name: "stripe", rationale: "payments" });
+    expect(recipe.guidance).toBe("pick supabase + stripe");
+    expect(new Date(recipe.createdAt).getTime()).toBeGreaterThan(0);
+  });
+
+  it("slugifyQuery handles empty / punctuation-only input", () => {
+    expect(slugifyQuery("")).toBe("recipe");
+    expect(slugifyQuery("!!!")).toBe("recipe");
+    expect(slugifyQuery("  B2B  SaaS  ")).toBe("b2b-saas");
+  });
+});

package/src/__tests__/recommend-apply-e2e.test.ts

@@ -0,0 +1,222 @@
+/**
+ * End-to-end integration test for the `stack recommend → stack apply` flow.
+ *
+ * Exercises the real pipeline via core exports (not by spawning the CLI):
+ *
+ *   retrieve(query)
+ *     → recipeFromRetrieval(...)
+ *     → writeRecipe(..., cwd)                  // creates .stack/recipes/<id>.toml
+ *     → readRecipe(id, cwd)                    // round-trips through TOML
+ *     → wirePhantomForRecipe(recipe, { cwd })  // fills the fake Phantom vault
+ *
+ * Calling the real provider CLIs (`stack add <provider>`) is out of scope:
+ * those make live HTTPS/OAuth calls. This test stops at the phantom-wire
+ * boundary, which is exactly what `stack apply --no-wire` would skip.
+ *
+ * The `setupFakePhantom` harness stubs out the Phantom CLI via a PATH-prefix
+ * shell script, so `wirePhantomForRecipe` can shell out for real without
+ * hitting the user's actual vault. We assert on its call log.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { retrieve } from "../ai/catalog-index.ts";
+import { wirePhantomForRecipe } from "../ai/phantom-wire.ts";
+import {
+  type Recipe,
+  listRecipes,
+  readRecipe,
+  recipeFromRetrieval,
+  writeRecipe,
+} from "../ai/recipe.ts";
+import { type Harness, setupFakePhantom } from "./_harness.ts";
+
+describe("recommend → apply e2e", () => {
+  let harness: Harness;
+  // A project-scratch cwd, separate from the phantom harness's own dir, so
+  // `.stack/recipes/*.toml` lands in an isolated location we can assert on.
+  let projectDir: string;
+
+  beforeEach(() => {
+    harness = setupFakePhantom();
+    projectDir = mkdtempSync(join(tmpdir(), "stack-e2e-project-"));
+  });
+
+  afterEach(() => {
+    harness.cleanup();
+    try {
+      rmSync(projectDir, { recursive: true, force: true });
+    } catch {
+      /* best-effort */
+    }
+  });
+
+  it("happy path: retrieve → recipeFromRetrieval → writeRecipe → readRecipe → wirePhantomForRecipe", async () => {
+    // 1) Simulate `stack recommend "postgres database"` — catalog retrieval.
+    const hits = retrieve("postgres database", { k: 3 });
+    expect(hits.length).toBeGreaterThan(0);
+
+    // Build a recipe deterministically from small, pure-API-key providers so
+    // the apply path never touches a real OAuth flow.
+    const recipe: Recipe = {
+      id: "postgres-database-e2e",
+      query: "postgres database",
+      createdAt: new Date().toISOString(),
+      providers: [
+        { name: "neon", rationale: "database, postgres" },
+        { name: "openai", rationale: "ai" },
+        { name: "anthropic", rationale: "ai" },
+      ],
+      guidance: "Neon for DB, OpenAI + Anthropic for AI.",
+    };
+
+    // 2) Simulate `--save` — freeze the recipe to TOML under the project cwd.
+    const path = await writeRecipe(recipe, projectDir);
+    expect(path).toContain(".stack/recipes/postgres-database-e2e.toml");
+    expect(existsSync(path)).toBe(true);
+
+    // 3) Simulate `stack apply <id>` reading the TOML back.
+    const loaded = await readRecipe("postgres-database-e2e", projectDir);
+    expect(loaded.id).toBe(recipe.id);
+    expect(loaded.providers.map((p) => p.name)).toEqual(["neon", "openai", "anthropic"]);
+
+    // 4) Wire envelopes via the fake Phantom CLI.
+    const result = await wirePhantomForRecipe(loaded, { cwd: projectDir });
+
+    // Every provider's declared catalog secrets must be envelope-added.
+    // (neon / openai / anthropic are all api_key providers with known secrets.)
+    expect(result.envelopes).toEqual(
+      expect.arrayContaining([
+        "neon:NEON_API_KEY",
+        "openai:OPENAI_API_KEY",
+        "anthropic:ANTHROPIC_API_KEY",
+      ]),
+    );
+    expect(result.skipped).toEqual([]);
+
+    // No webhook stubs for these providers — none are in the webhook-capable set.
+    expect(result.webhooks).toEqual([]);
+
+    // 5) Inspect the fake Phantom call log — every secret should have been
+    // shelled out as `phantom add <KEY> <placeholder>`.
+    const adds = harness.callsTo("add");
+    const addedKeys = adds.flatMap((c) => c.args);
+    expect(addedKeys).toContain("NEON_API_KEY");
+    expect(addedKeys).toContain("OPENAI_API_KEY");
+    expect(addedKeys).toContain("ANTHROPIC_API_KEY");
+
+    // The placeholder is intentional — `stack add <provider>` would replace it
+    // with the real secret. Stopping here is the "noWire: false but no OAuth"
+    // boundary: the vault now holds placeholders, not real credentials.
+    const vault = JSON.parse(readFileSync(harness.vaultPath, "utf-8")) as Record<string, string>;
+    expect(Object.keys(vault)).toEqual(
+      expect.arrayContaining(["NEON_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"]),
+    );
+  });
+
+  it("noWire: true performs zero phantom envelope calls and writes no webhook stubs", async () => {
+    // Use stripe so we can also prove the webhook stub is skipped — stripe is
+    // in WEBHOOK_PROVIDERS, so it would otherwise drop a stub file.
+    const recipe: Recipe = {
+      id: "payments-nowire",
+      query: "payments",
+      createdAt: "2026-04-18T00:00:00.000Z",
+      providers: [{ name: "stripe", rationale: "payments" }],
+    };
+    await writeRecipe(recipe, projectDir);
+    const loaded = await readRecipe("payments-nowire", projectDir);
+
+    const result = await wirePhantomForRecipe(loaded, {
+      cwd: projectDir,
+      noWire: true,
+    });
+    expect(result).toEqual({ envelopes: [], webhooks: [], skipped: [] });
+
+    // Zero phantom calls for recipe secrets.
+    expect(harness.callsTo("add")).toEqual([]);
+
+    // And no webhook stub file dropped.
+    expect(existsSync(join(projectDir, ".stack/webhooks/stripe.ts"))).toBe(false);
+  });
+
+  it("writeRecipe rejects a recipe referencing an unknown provider", async () => {
+    const recipe: Recipe = {
+      id: "bad",
+      query: "unknown",
+      createdAt: "2026-04-18T00:00:00.000Z",
+      providers: [{ name: "not-a-real-provider" }],
+    };
+    await expect(writeRecipe(recipe, projectDir)).rejects.toThrow(/unknown provider/i);
+
+    // The thrown error should be a `StackError` with the typed code.
+    let caughtCode: string | undefined;
+    try {
+      await writeRecipe(recipe, projectDir);
+    } catch (err) {
+      caughtCode = (err as { code?: string }).code;
+    }
+    expect(caughtCode).toBe("UNKNOWN_PROVIDER_IN_RECIPE");
+  });
+
+  it("recipe round-trip preserves rationale fields on providers", async () => {
+    const recipe: Recipe = {
+      id: "rationale-roundtrip",
+      query: "mixed",
+      createdAt: "2026-04-18T00:00:00.000Z",
+      providers: [
+        { name: "openai", rationale: "primary llm" },
+        { name: "anthropic", rationale: "fallback + tool use" },
+        { name: "stripe", rationale: "billing" },
+      ],
+      guidance: "ai + payments",
+    };
+    await writeRecipe(recipe, projectDir);
+    const loaded = await readRecipe("rationale-roundtrip", projectDir);
+
+    expect(loaded.providers).toEqual([
+      { name: "openai", rationale: "primary llm" },
+      { name: "anthropic", rationale: "fallback + tool use" },
+      { name: "stripe", rationale: "billing" },
+    ]);
+    expect(loaded.guidance).toBe("ai + payments");
+  });
+
+  it("listRecipes returns freshly-written recipe by id", async () => {
+    const base: Omit<Recipe, "id" | "query"> = {
+      createdAt: "2026-04-18T12:00:00.000Z",
+      providers: [{ name: "openai" }],
+    };
+    await writeRecipe({ ...base, id: "list-me-a", query: "a" }, projectDir);
+    await writeRecipe({ ...base, id: "list-me-b", query: "b" }, projectDir);
+
+    // recipeFromRetrieval → writeRecipe is the shape `stack recommend --save`
+    // uses; prove it lands in the same listing surface `stack apply` reads.
+    const fromRetrieval = recipeFromRetrieval(
+      "openai inference",
+      [
+        {
+          provider: { name: "openai" } as never,
+          score: 9,
+          matched: ["ai"],
+        },
+      ],
+      "ai only",
+    );
+    await writeRecipe(fromRetrieval, projectDir);
+
+    const listed = await listRecipes(projectDir);
+    const ids = listed.map((r) => r.id);
+    expect(ids).toContain("list-me-a");
+    expect(ids).toContain("list-me-b");
+    expect(ids).toContain(fromRetrieval.id);
+
+    // Spot-check the `recipeFromRetrieval`-derived entry survived the
+    // round-trip with its rationale intact.
+    const fromList = listed.find((r) => r.id === fromRetrieval.id);
+    if (!fromList) throw new Error(`listRecipes missing ${fromRetrieval.id}`);
+    expect(fromList.providers).toEqual([{ name: "openai", rationale: "ai" }]);
+    expect(fromList.guidance).toBe("ai only");
+  });
+});

package/src/__tests__/registry.test.ts

@@ -0,0 +1,78 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { emptyConfig, writeConfig } from "../config.ts";
+import {
+  findProjectByName,
+  listProjects,
+  registerProject,
+  registryPath,
+  unregisterProject,
+} from "../registry.ts";
+
+describe("cross-project registry", () => {
+  let previousDir: string | undefined;
+
+  beforeEach(() => {
+    previousDir = process.env.STACK_REGISTRY_DIR;
+    process.env.STACK_REGISTRY_DIR = mkdtempSync(join(tmpdir(), "stack-registry-"));
+  });
+
+  afterEach(() => {
+    if (previousDir === undefined) delete process.env.STACK_REGISTRY_DIR;
+    else process.env.STACK_REGISTRY_DIR = previousDir;
+  });
+
+  test("registryPath honors STACK_REGISTRY_DIR override", () => {
+    expect(registryPath().startsWith(process.env.STACK_REGISTRY_DIR!)).toBe(true);
+  });
+
+  test("writeConfig auto-registers the cwd", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "stack-auto-reg-"));
+    await writeConfig(emptyConfig("auto"), cwd);
+    const projects = await listProjects();
+    expect(projects.length).toBe(1);
+    expect(projects[0].path).toBe(cwd);
+    expect(projects[0].template).toBe("auto");
+  });
+
+  test("registerProject noops on directories without .stack.toml", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "stack-bare-"));
+    const entry = await registerProject(cwd);
+    expect(entry).toBeUndefined();
+    const projects = await listProjects();
+    expect(projects.length).toBe(0);
+  });
+
+  test("findProjectByName finds exact and case-insensitive matches", async () => {
+    const cwd1 = mkdtempSync(join(tmpdir(), "stack-alpha-"));
+    const cwd2 = mkdtempSync(join(tmpdir(), "stack-beta-"));
+    await writeConfig(emptyConfig(), cwd1);
+    await writeConfig(emptyConfig(), cwd2);
+    const all = await listProjects();
+    const firstName = all[0].name;
+    const found = await findProjectByName(firstName);
+    expect(found?.path).toBe(all[0].path);
+    const foundCaseInsensitive = await findProjectByName(firstName.toUpperCase());
+    expect(foundCaseInsensitive?.path).toBe(all[0].path);
+  });
+
+  test("unregisterProject removes without deleting files", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "stack-unreg-"));
+    await writeConfig(emptyConfig(), cwd);
+    expect((await listProjects()).length).toBe(1);
+    await unregisterProject(cwd);
+    expect((await listProjects()).length).toBe(0);
+  });
+
+  test("listProjects prunes entries whose .stack.toml was deleted", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "stack-prune-"));
+    await writeConfig(emptyConfig(), cwd);
+    // Simulate the file vanishing out from under us.
+    const { rmSync } = await import("node:fs");
+    rmSync(join(cwd, ".stack.toml"));
+    const projects = await listProjects();
+    expect(projects.length).toBe(0);
+  });
+});