ai-spec-dev 0.38.0 → 0.41.0

package/tests/test-generator.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import { TestGenerator } from "../core/test-generator";
+import { SpecDSL } from "../core/dsl-types";
+
+function makeDsl(): SpecDSL {
+  return {
+    feature: { title: "Orders", description: "Order management" },
+    models: [
+      {
+        name: "Order",
+        fields: [
+          { name: "id", type: "Int", required: true, unique: true },
+          { name: "total", type: "Float", required: true, unique: false },
+        ],
+      },
+    ],
+    endpoints: [
+      {
+        id: "createOrder",
+        method: "POST",
+        path: "/api/orders",
+        auth: true,
+        description: "Create order",
+        request: { body: { total: "number" }, params: {}, query: {} },
+        successStatus: 201,
+        successDescription: "Created",
+        errors: [{ status: 400, code: "INVALID", description: "Bad input" }],
+      },
+    ],
+    behaviors: [
+      { description: "Order total must be positive", constraints: ["total > 0"] },
+    ],
+  } as SpecDSL;
+}
+
+describe("TestGenerator", () => {
+  let tmpDir: string;
+  const mockProvider = {
+    generate: vi.fn(),
+    providerName: "test",
+    modelName: "test-model",
+  };
+  const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `tg-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+    mockProvider.generate.mockReset();
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("generate() writes test files returned by AI", async () => {
+    // No package.json → backend mode
+    mockProvider.generate.mockResolvedValueOnce(
+      JSON.stringify([
+        { file: "tests/order.test.ts", content: 'describe("Order", () => {});\n' },
+      ])
+    );
+
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generate(makeDsl(), tmpDir);
+    expect(files).toEqual(["tests/order.test.ts"]);
+    expect(await fs.readFile(path.join(tmpDir, "tests/order.test.ts"), "utf-8")).toContain("Order");
+  });
+
+  it("generate() returns empty array when AI returns invalid JSON", async () => {
+    mockProvider.generate.mockResolvedValueOnce("not json");
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generate(makeDsl(), tmpDir);
+    expect(files).toEqual([]);
+  });
+
+  it("generate() returns empty array when AI call fails", async () => {
+    mockProvider.generate.mockRejectedValueOnce(new Error("timeout"));
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generate(makeDsl(), tmpDir);
+    expect(files).toEqual([]);
+  });
+
+  it("generate() detects frontend mode from package.json", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { react: "18.0.0" },
+      devDependencies: { vitest: "2.0.0" },
+    });
+    mockProvider.generate.mockResolvedValueOnce("[]");
+
+    const gen = new TestGenerator(mockProvider);
+    await gen.generate(makeDsl(), tmpDir);
+    // Should have called with frontend system prompt (we just verify it doesn't crash)
+    expect(mockProvider.generate).toHaveBeenCalledOnce();
+  });
+
+  it("generate() uses existing test directory when found", async () => {
+    await fs.ensureDir(path.join(tmpDir, "__tests__"));
+    mockProvider.generate.mockResolvedValueOnce(
+      JSON.stringify([{ file: "__tests__/order.test.ts", content: "test" }])
+    );
+
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generate(makeDsl(), tmpDir);
+    expect(files).toEqual(["__tests__/order.test.ts"]);
+  });
+
+  it("generate() handles fenced JSON response", async () => {
+    mockProvider.generate.mockResolvedValueOnce(
+      '```json\n[{"file":"tests/a.test.ts","content":"test code"}]\n```'
+    );
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generate(makeDsl(), tmpDir);
+    expect(files).toEqual(["tests/a.test.ts"]);
+  });
+
+  it("generateTdd() writes TDD test files", async () => {
+    mockProvider.generate.mockResolvedValueOnce(
+      JSON.stringify([
+        { file: "tests/order.tdd.test.ts", content: 'it("should create order", () => { expect(true).toBe(false); });\n' },
+      ])
+    );
+
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generateTdd(makeDsl(), tmpDir);
+    expect(files).toEqual(["tests/order.tdd.test.ts"]);
+    const content = await fs.readFile(path.join(tmpDir, "tests/order.tdd.test.ts"), "utf-8");
+    expect(content).toContain("should create order");
+  });
+
+  it("generateTdd() returns empty on AI failure", async () => {
+    mockProvider.generate.mockRejectedValueOnce(new Error("fail"));
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generateTdd(makeDsl(), tmpDir);
+    expect(files).toEqual([]);
+  });
+
+  it("generateTdd() returns empty on invalid JSON", async () => {
+    mockProvider.generate.mockResolvedValueOnce("not json");
+    const gen = new TestGenerator(mockProvider);
+    const files = await gen.generateTdd(makeDsl(), tmpDir);
+    expect(files).toEqual([]);
+  });
+});

package/tests/token-budget.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  estimateTokens,
+  assembleSections,
+  getDefaultBudget,
+  BudgetSection,
+} from "../core/token-budget";
+
+// Suppress console.log from assembleSections warnings
+vi.spyOn(console, "log").mockImplementation(() => {});
+
+// ─── estimateTokens ─────────────────────────────────────────────────────────
+
+describe("estimateTokens", () => {
+  it("returns 0 for empty string", () => {
+    expect(estimateTokens("")).toBe(0);
+  });
+
+  it("estimates English text (~4 chars per token)", () => {
+    const text = "Hello world, this is a test string";
+    const tokens = estimateTokens(text);
+    // 34 chars / 4 ≈ 9 tokens
+    expect(tokens).toBeGreaterThanOrEqual(8);
+    expect(tokens).toBeLessThanOrEqual(12);
+  });
+
+  it("estimates CJK text (~1 char per token)", () => {
+    const text = "你好世界这是测试";
+    const tokens = estimateTokens(text);
+    // 8 CJK chars ≈ 8 tokens
+    expect(tokens).toBe(8);
+  });
+
+  it("handles mixed CJK + English", () => {
+    const text = "Hello 你好";
+    const tokens = estimateTokens(text);
+    // "Hello " = 6 non-CJK / 4 = 1.5, "你好" = 2 CJK → ~4 total
+    expect(tokens).toBeGreaterThanOrEqual(3);
+    expect(tokens).toBeLessThanOrEqual(5);
+  });
+
+  it("handles code content", () => {
+    const code = 'export function foo(bar: string): number {\n  return bar.length;\n}';
+    const tokens = estimateTokens(code);
+    expect(tokens).toBeGreaterThan(10);
+  });
+});
+
+// ─── assembleSections ───────────────────────────────────────────────────────
+
+describe("assembleSections", () => {
+  it("includes all sections when within budget", () => {
+    const sections: BudgetSection[] = [
+      { name: "spec", content: "Feature spec content", priority: 2 },
+      { name: "dsl", content: "DSL context", priority: 2 },
+    ];
+    const result = assembleSections(sections, 10000);
+    expect(result.trimmedSections).toHaveLength(0);
+    expect(result.assembledPrompt).toContain("Feature spec content");
+    expect(result.assembledPrompt).toContain("DSL context");
+  });
+
+  it("sorts by priority (higher priority included first)", () => {
+    const sections: BudgetSection[] = [
+      { name: "low", content: "L".repeat(100), priority: 5 },
+      { name: "high", content: "H".repeat(100), priority: 1 },
+    ];
+    const result = assembleSections(sections, 10000);
+    const hIdx = result.assembledPrompt.indexOf("H");
+    const lIdx = result.assembledPrompt.indexOf("L");
+    expect(hIdx).toBeLessThan(lIdx);
+  });
+
+  it("trims lower-priority sections when budget exceeded", () => {
+    const sections: BudgetSection[] = [
+      { name: "critical", content: "A".repeat(400), priority: 1 },
+      { name: "nice-to-have", content: "B".repeat(4000), priority: 5 },
+    ];
+    // Budget of ~200 tokens ≈ 800 chars English
+    const result = assembleSections(sections, 200);
+    expect(result.trimmedSections).toContain("nice-to-have");
+    expect(result.assembledPrompt).toContain("A".repeat(400));
+  });
+
+  it("drops sections entirely when no room at all", () => {
+    const sections: BudgetSection[] = [
+      { name: "critical", content: "A".repeat(4000), priority: 1 },
+      { name: "dropped", content: "B".repeat(4000), priority: 5 },
+    ];
+    // Very tight budget
+    const result = assembleSections(sections, 1000);
+    expect(result.trimmedSections.length).toBeGreaterThan(0);
+  });
+
+  it("skips empty sections", () => {
+    const sections: BudgetSection[] = [
+      { name: "empty", content: "", priority: 1 },
+      { name: "content", content: "Real content", priority: 2 },
+    ];
+    const result = assembleSections(sections, 10000);
+    expect(result.assembledPrompt).toBe("Real content");
+    expect(result.trimmedSections).toHaveLength(0);
+  });
+
+  it("returns empty prompt when all sections are empty", () => {
+    const result = assembleSections([], 10000);
+    expect(result.assembledPrompt).toBe("");
+    expect(result.totalTokens).toBe(0);
+  });
+});
+
+// ─── getDefaultBudget ───────────────────────────────────────────────────────
+
+describe("getDefaultBudget", () => {
+  it("returns known provider budgets", () => {
+    expect(getDefaultBudget("gemini")).toBe(900_000);
+    expect(getDefaultBudget("claude")).toBe(180_000);
+    expect(getDefaultBudget("openai")).toBe(120_000);
+  });
+
+  it("returns default for unknown providers", () => {
+    expect(getDefaultBudget("unknown-provider")).toBe(100_000);
+  });
+});

package/tests/vcr-hash.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from "vitest";
+import { createHash } from "crypto";
+import { VcrReplayProvider, VcrRecording, VcrRecordingProvider } from "../core/vcr";
+
+function makeRecording(entries: Array<{ prompt: string; system?: string; response: string }>): VcrRecording {
+  return {
+    runId: "test-run",
+    recordedAt: "2026-04-02T00:00:00Z",
+    entryCount: entries.length,
+    providers: ["test/model"],
+    entries: entries.map((e, i) => ({
+      index: i,
+      promptPreview: e.prompt.slice(0, 200),
+      callHash: createHash("sha256")
+        .update(e.prompt + "\x00" + (e.system ?? ""))
+        .digest("hex")
+        .slice(0, 8),
+      response: e.response,
+      providerName: "test",
+      modelName: "model",
+      ts: new Date().toISOString(),
+      durationMs: 0,
+    })),
+  };
+}
+
+describe("VcrReplayProvider prompt hash validation", () => {
+  it("reports no mismatches when prompts match", async () => {
+    const recording = makeRecording([
+      { prompt: "hello", system: "sys", response: "world" },
+    ]);
+    const replay = new VcrReplayProvider(recording);
+    const result = await replay.generate("hello", "sys");
+    expect(result).toBe("world");
+    expect(replay.hasMismatches).toBe(false);
+    expect(replay.mismatches).toHaveLength(0);
+  });
+
+  it("detects mismatch when prompt changes", async () => {
+    const recording = makeRecording([
+      { prompt: "hello", response: "world" },
+    ]);
+    const replay = new VcrReplayProvider(recording);
+    await replay.generate("different prompt");
+    expect(replay.hasMismatches).toBe(true);
+    expect(replay.mismatches).toHaveLength(1);
+    expect(replay.mismatches[0].index).toBe(0);
+  });
+
+  it("detects mismatch when system instruction changes", async () => {
+    const recording = makeRecording([
+      { prompt: "hello", system: "original-system", response: "world" },
+    ]);
+    const replay = new VcrReplayProvider(recording);
+    await replay.generate("hello", "modified-system");
+    expect(replay.hasMismatches).toBe(true);
+  });
+
+  it("tracks multiple mismatches across calls", async () => {
+    const recording = makeRecording([
+      { prompt: "a", response: "1" },
+      { prompt: "b", response: "2" },
+      { prompt: "c", response: "3" },
+    ]);
+    const replay = new VcrReplayProvider(recording);
+    await replay.generate("a");       // match
+    await replay.generate("changed"); // mismatch
+    await replay.generate("c");       // match
+    expect(replay.mismatches).toHaveLength(1);
+    expect(replay.mismatches[0].index).toBe(1);
+  });
+
+  it("still returns response even on mismatch", async () => {
+    const recording = makeRecording([
+      { prompt: "original", response: "recorded-response" },
+    ]);
+    const replay = new VcrReplayProvider(recording);
+    const result = await replay.generate("different");
+    expect(result).toBe("recorded-response");
+  });
+
+  it("throws when recording is exhausted", async () => {
+    const recording = makeRecording([{ prompt: "a", response: "1" }]);
+    const replay = new VcrReplayProvider(recording);
+    await replay.generate("a");
+    await expect(replay.generate("b")).rejects.toThrow(/exhausted/);
+  });
+});
+
+describe("VcrRecordingProvider", () => {
+  it("records calls with correct hash", async () => {
+    const inner = {
+      providerName: "test",
+      modelName: "model",
+      generate: async () => "response",
+    };
+    const recorder = new VcrRecordingProvider(inner);
+    await recorder.generate("prompt", "system");
+    expect(recorder.callCount).toBe(1);
+  });
+});

package/tests/workspace-loader.test.ts

@@ -0,0 +1,277 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import {
+  detectRepoType,
+  WorkspaceLoader,
+  WORKSPACE_CONFIG_FILE,
+} from "../core/workspace-loader";
+
+// ─── detectRepoType ──────────────────────────────────────────────────────────
+
+describe("detectRepoType", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `wl-detect-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("detects Go project", async () => {
+    await fs.writeFile(path.join(tmpDir, "go.mod"), "module example.com/app");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "go", role: "backend" });
+  });
+
+  it("detects Rust project", async () => {
+    await fs.writeFile(path.join(tmpDir, "Cargo.toml"), "[package]");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "rust", role: "backend" });
+  });
+
+  it("detects Java (pom.xml)", async () => {
+    await fs.writeFile(path.join(tmpDir, "pom.xml"), "<project/>");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "java", role: "backend" });
+  });
+
+  it("detects Java (build.gradle)", async () => {
+    await fs.writeFile(path.join(tmpDir, "build.gradle"), "plugins {}");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "java", role: "backend" });
+  });
+
+  it("detects Python (requirements.txt)", async () => {
+    await fs.writeFile(path.join(tmpDir, "requirements.txt"), "flask");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "python", role: "backend" });
+  });
+
+  it("detects Python (pyproject.toml)", async () => {
+    await fs.writeFile(path.join(tmpDir, "pyproject.toml"), "[tool.poetry]");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "python", role: "backend" });
+  });
+
+  it("detects PHP", async () => {
+    await fs.writeFile(path.join(tmpDir, "composer.json"), "{}");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "php", role: "backend" });
+  });
+
+  it("detects React Native", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { "react-native": "0.74.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "react-native", role: "mobile" });
+  });
+
+  it("detects Next.js", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { next: "14.0.0", react: "18.0.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "next", role: "frontend" });
+  });
+
+  it("detects React", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { react: "18.0.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "react", role: "frontend" });
+  });
+
+  it("detects Vue", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { vue: "3.4.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "vue", role: "frontend" });
+  });
+
+  it("detects Koa", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { koa: "2.0.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "node-koa", role: "backend" });
+  });
+
+  it("detects Express", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { express: "4.18.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "node-express", role: "backend" });
+  });
+
+  it("detects NestJS as node-express", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { "@nestjs/core": "10.0.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "node-express", role: "backend" });
+  });
+
+  it("detects Prisma-only as node-express backend", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { "@prisma/client": "5.0.0" },
+    });
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "node-express", role: "backend" });
+  });
+
+  it("returns unknown/shared for empty package.json", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {});
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "unknown", role: "shared" });
+  });
+
+  it("returns unknown/shared when no manifest exists", async () => {
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "unknown", role: "shared" });
+  });
+
+  it("returns unknown/shared for corrupt package.json", async () => {
+    await fs.writeFile(path.join(tmpDir, "package.json"), "not json");
+    const result = await detectRepoType(tmpDir);
+    expect(result).toEqual({ type: "unknown", role: "shared" });
+  });
+});
+
+// ─── WorkspaceLoader ─────────────────────────────────────────────────────────
+
+describe("WorkspaceLoader", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `wl-load-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("load() returns null when no config file exists", async () => {
+    const loader = new WorkspaceLoader(tmpDir);
+    expect(await loader.load()).toBeNull();
+  });
+
+  it("load() throws on invalid JSON", async () => {
+    await fs.writeFile(path.join(tmpDir, WORKSPACE_CONFIG_FILE), "not json");
+    const loader = new WorkspaceLoader(tmpDir);
+    await expect(loader.load()).rejects.toThrow("Failed to parse");
+  });
+
+  it("load() throws on missing required fields", async () => {
+    await fs.writeJson(path.join(tmpDir, WORKSPACE_CONFIG_FILE), { foo: "bar" });
+    const loader = new WorkspaceLoader(tmpDir);
+    await expect(loader.load()).rejects.toThrow("missing required fields");
+  });
+
+  it("load() throws on empty repos array", async () => {
+    await fs.writeJson(path.join(tmpDir, WORKSPACE_CONFIG_FILE), {
+      name: "test-ws",
+      repos: [],
+    });
+    const loader = new WorkspaceLoader(tmpDir);
+    await expect(loader.load()).rejects.toThrow("non-empty array");
+  });
+
+  it("load() returns config with resolved repos", async () => {
+    const repoDir = path.join(tmpDir, "my-api");
+    await fs.ensureDir(repoDir);
+    await fs.writeJson(path.join(tmpDir, WORKSPACE_CONFIG_FILE), {
+      name: "test-ws",
+      repos: [{ name: "my-api", path: "my-api", type: "node-express", role: "backend" }],
+    });
+    const loader = new WorkspaceLoader(tmpDir);
+    const config = await loader.load();
+    expect(config).not.toBeNull();
+    expect(config!.name).toBe("test-ws");
+    expect(config!.repos).toHaveLength(1);
+  });
+
+  it("load() loads constitution when present", async () => {
+    const repoDir = path.join(tmpDir, "my-api");
+    await fs.ensureDir(repoDir);
+    await fs.writeFile(path.join(repoDir, ".ai-spec-constitution.md"), "my rules");
+    await fs.writeJson(path.join(tmpDir, WORKSPACE_CONFIG_FILE), {
+      name: "ws",
+      repos: [{ name: "my-api", path: "my-api", type: "node-express", role: "backend" }],
+    });
+    const loader = new WorkspaceLoader(tmpDir);
+    const config = await loader.load();
+    expect(config!.repos[0].constitution).toBe("my rules");
+  });
+
+  it("resolveAbsPath returns absolute path", () => {
+    const loader = new WorkspaceLoader(tmpDir);
+    const abs = loader.resolveAbsPath({ name: "api", path: "api", type: "node-express", role: "backend" });
+    expect(path.isAbsolute(abs)).toBe(true);
+    expect(abs).toBe(path.join(tmpDir, "api"));
+  });
+
+  it("save() writes config without runtime constitution", async () => {
+    const loader = new WorkspaceLoader(tmpDir);
+    await loader.save({
+      name: "ws",
+      repos: [{ name: "api", path: "api", type: "node-express", role: "backend", constitution: "should be stripped" }],
+    });
+    const saved = await fs.readJson(path.join(tmpDir, WORKSPACE_CONFIG_FILE));
+    expect(saved.repos[0].constitution).toBeUndefined();
+    expect(saved.name).toBe("ws");
+  });
+
+  it("autoDetect() discovers repos with package.json", async () => {
+    const repoDir = path.join(tmpDir, "my-app");
+    await fs.ensureDir(repoDir);
+    await fs.writeJson(path.join(repoDir, "package.json"), {
+      dependencies: { express: "4.0.0" },
+    });
+    const loader = new WorkspaceLoader(tmpDir);
+    const repos = await loader.autoDetect();
+    expect(repos).toHaveLength(1);
+    expect(repos[0].name).toBe("my-app");
+    expect(repos[0].type).toBe("node-express");
+  });
+
+  it("autoDetect() skips dotfiles and node_modules", async () => {
+    await fs.ensureDir(path.join(tmpDir, ".hidden"));
+    await fs.writeJson(path.join(tmpDir, ".hidden", "package.json"), {});
+    await fs.ensureDir(path.join(tmpDir, "node_modules", "pkg"));
+    await fs.writeJson(path.join(tmpDir, "node_modules", "pkg", "package.json"), {});
+    const loader = new WorkspaceLoader(tmpDir);
+    const repos = await loader.autoDetect();
+    expect(repos).toHaveLength(0);
+  });
+
+  it("autoDetect() filters by names when provided", async () => {
+    for (const name of ["alpha", "beta", "gamma"]) {
+      await fs.ensureDir(path.join(tmpDir, name));
+      await fs.writeJson(path.join(tmpDir, name, "package.json"), {});
+    }
+    const loader = new WorkspaceLoader(tmpDir);
+    const repos = await loader.autoDetect(["alpha", "gamma"]);
+    expect(repos.map((r) => r.name).sort()).toEqual(["alpha", "gamma"]);
+  });
+
+  it("getProcessingOrder sorts backend → shared → frontend → mobile", () => {
+    const repos = [
+      { name: "web", path: "web", type: "react" as const, role: "frontend" as const },
+      { name: "api", path: "api", type: "node-express" as const, role: "backend" as const },
+      { name: "app", path: "app", type: "react-native" as const, role: "mobile" as const },
+      { name: "lib", path: "lib", type: "unknown" as const, role: "shared" as const },
+    ];
+    const sorted = WorkspaceLoader.getProcessingOrder(repos);
+    expect(sorted.map((r) => r.role)).toEqual(["backend", "shared", "frontend", "mobile"]);
+  });
+});