ai-spec-dev 0.35.0 → 0.37.0

package/tests/spec-generator.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  createProvider,
+  SpecGenerator,
+  PROVIDER_CATALOG,
+  SUPPORTED_PROVIDERS,
+  DEFAULT_MODELS,
+  ENV_KEY_MAP,
+  GeminiProvider,
+  ClaudeProvider,
+  OpenAICompatibleProvider,
+  MiMoProvider,
+} from "../core/spec-generator";
+import type { AIProvider } from "../core/spec-generator";
+
+// ─── Provider Catalog ────────────────────────────────────────────────────────
+
+describe("PROVIDER_CATALOG", () => {
+  it("has at least 8 providers", () => {
+    expect(Object.keys(PROVIDER_CATALOG).length).toBeGreaterThanOrEqual(8);
+  });
+
+  it("every provider has required fields", () => {
+    for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
+      expect(meta.displayName, `${key} missing displayName`).toBeTruthy();
+      expect(meta.description, `${key} missing description`).toBeTruthy();
+      expect(meta.models.length, `${key} has no models`).toBeGreaterThan(0);
+      expect(meta.envKey, `${key} missing envKey`).toBeTruthy();
+    }
+  });
+
+  it("each provider has a unique envKey", () => {
+    const envKeys = Object.values(PROVIDER_CATALOG).map((m) => m.envKey);
+    expect(new Set(envKeys).size).toBe(envKeys.length);
+  });
+});
+
+// ─── Derived Maps ────────────────────────────────────────────────────────────
+
+describe("Derived maps", () => {
+  it("SUPPORTED_PROVIDERS matches PROVIDER_CATALOG keys", () => {
+    expect(SUPPORTED_PROVIDERS.sort()).toEqual(Object.keys(PROVIDER_CATALOG).sort());
+  });
+
+  it("DEFAULT_MODELS picks first model for each provider", () => {
+    for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
+      expect(DEFAULT_MODELS[key]).toBe(meta.models[0]);
+    }
+  });
+
+  it("ENV_KEY_MAP maps provider to envKey", () => {
+    for (const [key, meta] of Object.entries(PROVIDER_CATALOG)) {
+      expect(ENV_KEY_MAP[key]).toBe(meta.envKey);
+    }
+  });
+});
+
+// ─── createProvider ──────────────────────────────────────────────────────────
+
+describe("createProvider", () => {
+  it("creates GeminiProvider for 'gemini'", () => {
+    const provider = createProvider("gemini", "fake-key");
+    expect(provider).toBeInstanceOf(GeminiProvider);
+    expect(provider.providerName).toBe("gemini");
+    expect(provider.modelName).toBe(PROVIDER_CATALOG.gemini.models[0]);
+  });
+
+  it("creates ClaudeProvider for 'claude'", () => {
+    const provider = createProvider("claude", "fake-key");
+    expect(provider).toBeInstanceOf(ClaudeProvider);
+    expect(provider.providerName).toBe("claude");
+  });
+
+  it("creates MiMoProvider for 'mimo'", () => {
+    const provider = createProvider("mimo", "fake-key");
+    expect(provider).toBeInstanceOf(MiMoProvider);
+    expect(provider.providerName).toBe("mimo");
+  });
+
+  it("creates OpenAICompatibleProvider for 'openai'", () => {
+    const provider = createProvider("openai", "fake-key");
+    expect(provider).toBeInstanceOf(OpenAICompatibleProvider);
+    expect(provider.providerName).toBe("openai");
+  });
+
+  it("creates OpenAICompatibleProvider for 'deepseek'", () => {
+    const provider = createProvider("deepseek", "fake-key");
+    expect(provider).toBeInstanceOf(OpenAICompatibleProvider);
+    expect(provider.providerName).toBe("deepseek");
+  });
+
+  it("creates OpenAICompatibleProvider for 'qwen'", () => {
+    const provider = createProvider("qwen", "fake-key");
+    expect(provider).toBeInstanceOf(OpenAICompatibleProvider);
+    expect(provider.providerName).toBe("qwen");
+  });
+
+  it("uses custom model name when provided", () => {
+    const provider = createProvider("gemini", "fake-key", "gemini-2.0-flash");
+    expect(provider.modelName).toBe("gemini-2.0-flash");
+  });
+
+  it("throws for unknown provider", () => {
+    expect(() => createProvider("nonexistent", "key")).toThrow(/Unknown provider/);
+  });
+
+  it("throws with suggestion listing valid providers", () => {
+    expect(() => createProvider("bad", "key")).toThrow(/Valid options/);
+  });
+});
+
+// ─── SpecGenerator ───────────────────────────────────────────────────────────
+
+describe("SpecGenerator", () => {
+  function makeProvider(response: string): AIProvider {
+    return {
+      generate: vi.fn().mockResolvedValue(response),
+      providerName: "test",
+      modelName: "test-model",
+    };
+  }
+
+  it("passes idea to provider", async () => {
+    const provider = makeProvider("generated spec");
+    const gen = new SpecGenerator(provider);
+    const result = await gen.generateSpec("Build a todo app");
+    expect(result).toBe("generated spec");
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).toContain("Build a todo app");
+  });
+
+  it("includes architecture decision when provided", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    await gen.generateSpec("idea", undefined, "Use microservices");
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).toContain("Architecture Decision");
+    expect(prompt).toContain("Use microservices");
+  });
+
+  it("includes project context when provided", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    await gen.generateSpec("idea", {
+      techStack: ["Express", "TypeScript"],
+      dependencies: ["express", "prisma"],
+      apiStructure: ["src/routes/user.ts"],
+      schema: "model User { id Int }",
+      constitution: "## 1. Architecture\nUse layered architecture",
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).toContain("Express");
+    expect(prompt).toContain("prisma");
+    expect(prompt).toContain("src/routes/user.ts");
+    expect(prompt).toContain("model User");
+    expect(prompt).toContain("Project Constitution");
+  });
+
+  it("puts constitution before project context", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    await gen.generateSpec("idea", {
+      techStack: ["Express"],
+      dependencies: [],
+      apiStructure: [],
+      constitution: "CONSTITUTION_CONTENT",
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    const constitutionIdx = prompt.indexOf("CONSTITUTION_CONTENT");
+    const contextIdx = prompt.indexOf("Project Context");
+    expect(constitutionIdx).toBeLessThan(contextIdx);
+  });
+
+  it("omits constitution section when not provided", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    await gen.generateSpec("idea", {
+      techStack: [],
+      dependencies: [],
+      apiStructure: [],
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).not.toContain("Project Constitution");
+  });
+
+  it("truncates schema to 3000 chars", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    const longSchema = "x".repeat(5000);
+    await gen.generateSpec("idea", {
+      techStack: [],
+      dependencies: [],
+      apiStructure: [],
+      schema: longSchema,
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    // schema.slice(0, 3000) means at most 3000 chars of schema in prompt
+    expect(prompt).not.toContain("x".repeat(3001));
+  });
+
+  it("limits dependencies to 25 entries", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    const deps = Array.from({ length: 30 }, (_, i) => `dep-${i}`);
+    await gen.generateSpec("idea", {
+      techStack: [],
+      dependencies: deps,
+      apiStructure: [],
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).toContain("dep-24");
+    expect(prompt).not.toContain("dep-25");
+  });
+
+  it("limits API structure to 10 entries", async () => {
+    const provider = makeProvider("spec");
+    const gen = new SpecGenerator(provider);
+    const apis = Array.from({ length: 15 }, (_, i) => `src/routes/route-${i}.ts`);
+    await gen.generateSpec("idea", {
+      techStack: [],
+      dependencies: [],
+      apiStructure: apis,
+    } as any);
+    const [prompt] = (provider.generate as ReturnType<typeof vi.fn>).mock.calls[0];
+    expect(prompt).toContain("route-9");
+    expect(prompt).not.toContain("route-10");
+  });
+});

package/tests/spec-versioning.test.ts

@@ -0,0 +1,205 @@
+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 {
+  slugify,
+  computeDiff,
+  findLatestVersion,
+  nextVersionPath,
+} from "../core/spec-versioning";
+
+// ─── slugify ─────────────────────────────────────────────────────────────────
+
+describe("slugify", () => {
+  it("converts simple English to lowercase slug", () => {
+    expect(slugify("User Login")).toBe("user-login");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Add OAuth2.0 Support!")).toBe("add-oauth2-0-support");
+  });
+
+  it("trims leading and trailing hyphens", () => {
+    expect(slugify("---hello---")).toBe("hello");
+  });
+
+  it("handles CJK characters by stripping them", () => {
+    const result = slugify("用户登录 with OAuth");
+    expect(result).toContain("with");
+    expect(result).toContain("oauth");
+    expect(result).not.toMatch(/[\u4e00-\u9fa5]/);
+  });
+
+  it("limits length to 48 characters", () => {
+    const long = "a".repeat(100);
+    expect(slugify(long).length).toBeLessThanOrEqual(48);
+  });
+
+  it("returns 'feature' for empty input", () => {
+    expect(slugify("")).toBe("feature");
+  });
+
+  it("returns 'feature' for CJK-only input", () => {
+    // CJK gets stripped, leaving empty → fallback
+    expect(slugify("用户管理")).toBe("feature");
+  });
+
+  it("collapses multiple consecutive hyphens", () => {
+    expect(slugify("hello   world")).toBe("hello-world");
+  });
+});
+
+// ─── computeDiff ─────────────────────────────────────────────────────────────
+
+describe("computeDiff", () => {
+  it("returns no changes for identical texts", () => {
+    const diff = computeDiff("hello\nworld", "hello\nworld");
+    expect(diff.added).toBe(0);
+    expect(diff.removed).toBe(0);
+    expect(diff.unchanged).toBe(2);
+  });
+
+  it("detects added lines", () => {
+    const diff = computeDiff("line1", "line1\nline2");
+    expect(diff.added).toBe(1);
+    expect(diff.removed).toBe(0);
+  });
+
+  it("detects removed lines", () => {
+    const diff = computeDiff("line1\nline2", "line1");
+    expect(diff.removed).toBe(1);
+    expect(diff.added).toBe(0);
+  });
+
+  it("detects modified lines as remove + add", () => {
+    const diff = computeDiff("hello", "world");
+    expect(diff.removed).toBe(1);
+    expect(diff.added).toBe(1);
+  });
+
+  it("handles empty old text", () => {
+    const diff = computeDiff("", "new content");
+    expect(diff.added).toBeGreaterThan(0);
+  });
+
+  it("handles empty new text", () => {
+    const diff = computeDiff("old content", "");
+    expect(diff.removed).toBeGreaterThan(0);
+  });
+
+  it("handles both empty", () => {
+    const diff = computeDiff("", "");
+    expect(diff.added).toBe(0);
+    expect(diff.removed).toBe(0);
+  });
+
+  it("falls back to simple diff for large files (>800 lines)", () => {
+    const oldText = Array.from({ length: 900 }, (_, i) => `line ${i}`).join("\n");
+    const newText = Array.from({ length: 900 }, (_, i) => `modified ${i}`).join("\n");
+    const diff = computeDiff(oldText, newText);
+    // Simple diff marks all old as removed and all new as added
+    expect(diff.removed).toBe(900);
+    expect(diff.added).toBe(900);
+    expect(diff.unchanged).toBe(0);
+  });
+
+  it("produces correct line types", () => {
+    const diff = computeDiff("keep\nremove", "keep\nadd");
+    const types = diff.lines.map((l) => l.type);
+    expect(types).toContain("unchanged");
+    expect(types).toContain("added");
+    expect(types).toContain("removed");
+  });
+});
+
+// ─── findLatestVersion / nextVersionPath ─────────────────────────────────────
+
+describe("findLatestVersion", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `version-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("returns null for non-existent directory", async () => {
+    const result = await findLatestVersion("/nonexistent/path", "feature");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when no matching files exist", async () => {
+    await fs.writeFile(path.join(tmpDir, "unrelated.md"), "hello");
+    const result = await findLatestVersion(tmpDir, "user-login");
+    expect(result).toBeNull();
+  });
+
+  it("finds v1 when only v1 exists", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v1.md"), "spec v1 content");
+    const result = await findLatestVersion(tmpDir, "auth");
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe(1);
+    expect(result!.content).toBe("spec v1 content");
+  });
+
+  it("finds latest version among multiple", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v1.md"), "v1");
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v2.md"), "v2");
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v3.md"), "v3");
+    const result = await findLatestVersion(tmpDir, "auth");
+    expect(result!.version).toBe(3);
+    expect(result!.content).toBe("v3");
+  });
+
+  it("does not confuse different slugs", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v5.md"), "auth v5");
+    await fs.writeFile(path.join(tmpDir, "feature-user-v2.md"), "user v2");
+    const result = await findLatestVersion(tmpDir, "user");
+    expect(result!.version).toBe(2);
+    expect(result!.content).toBe("user v2");
+  });
+
+  it("handles regex special characters in slug", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-2.0-v1.md"), "spec");
+    const result = await findLatestVersion(tmpDir, "auth-2.0");
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe(1);
+  });
+});
+
+describe("nextVersionPath", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `nextver-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("returns v1 when no versions exist", async () => {
+    const result = await nextVersionPath(tmpDir, "auth");
+    expect(result.version).toBe(1);
+    expect(result.filePath).toContain("feature-auth-v1.md");
+  });
+
+  it("returns v2 when v1 exists", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v1.md"), "v1");
+    const result = await nextVersionPath(tmpDir, "auth");
+    expect(result.version).toBe(2);
+    expect(result.filePath).toContain("feature-auth-v2.md");
+  });
+
+  it("returns v4 when v3 is latest", async () => {
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v1.md"), "v1");
+    await fs.writeFile(path.join(tmpDir, "feature-auth-v3.md"), "v3");
+    const result = await nextVersionPath(tmpDir, "auth");
+    expect(result.version).toBe(4);
+  });
+});