ai-spec-dev 0.35.0 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-spec-dev",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "AI-driven Development Orchestrator SDK & CLI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/code-generator.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  extractBehavioralContract,
+  printTaskProgress,
+} from "../core/code-generator";
+import type { SpecTask } from "../core/task-generator";
+
+// ─── extractBehavioralContract ───────────────────────────────────────────────
+
+describe("extractBehavioralContract", () => {
+  it("captures export interface with full body", () => {
+    const content = `import { Foo } from "./foo";
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+const x = 1;`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export interface User {");
+    expect(result).toContain("id: string;");
+    expect(result).toContain("email: string;");
+    expect(result).toContain("}");
+    // Should NOT contain non-export lines
+    expect(result).not.toContain("const x = 1");
+  });
+
+  it("captures export enum with full body", () => {
+    const content = `export enum Status {
+  ACTIVE = "active",
+  INACTIVE = "inactive",
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export enum Status {");
+    expect(result).toContain("ACTIVE");
+    expect(result).toContain("INACTIVE");
+  });
+
+  it("captures export type alias", () => {
+    const content = `export type UserId = string;`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export type UserId = string;");
+  });
+
+  it("captures export function signature (single line)", () => {
+    const content = `export function createUser(name: string): User {
+  return { name };
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export function createUser");
+  });
+
+  it("captures export const declaration", () => {
+    const content = `export const API_BASE = "/api/v1";`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export const API_BASE");
+  });
+
+  it("captures throw statements as error contracts", () => {
+    const content = `function validate(input: string) {
+  if (!input) throw new Error("INPUT_REQUIRED");
+  if (input.length > 100) throw new ValidationError("TOO_LONG");
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("Error contracts");
+    expect(result).toContain("INPUT_REQUIRED");
+    expect(result).toContain("TOO_LONG");
+  });
+
+  it("limits throw captures to 20", () => {
+    const throwLines = Array.from(
+      { length: 25 },
+      (_, i) => `  throw new Error("ERR_${i}");`
+    );
+    const content = `function foo() {\n${throwLines.join("\n")}\n}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("ERR_19");
+    expect(result).not.toContain("ERR_20");
+  });
+
+  it("captures export class with full body", () => {
+    const content = `export class UserService {
+  async findById(id: string): Promise<User> {
+    return db.user.findUnique({ where: { id } });
+  }
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export class UserService {");
+    expect(result).toContain("findById");
+  });
+
+  it("captures defineStore full block", () => {
+    const content = `export const useTaskStore = defineStore("tasks", () => {
+  const tasks = ref([]);
+  function fetchTasks() {}
+  return { tasks, fetchTasks };
+});`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("defineStore");
+    expect(result).toContain("fetchTasks");
+  });
+
+  it("captures return { } block as public API", () => {
+    const content = `export function useAuth() {
+  const user = ref(null);
+  function login() {}
+return {
+  user,
+  login,
+};
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("public API");
+    expect(result).toContain("login");
+  });
+
+  it("captures export default function with body", () => {
+    const content = `export default function HomePage() {
+  return <div>Home</div>;
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export default function HomePage");
+  });
+
+  it("captures export default async function", () => {
+    const content = `export default async function handler(req, res) {
+  res.json({ ok: true });
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export default async function handler");
+  });
+
+  it("falls back to first 3000 chars when no exports found", () => {
+    const content = "a".repeat(5000);
+    const result = extractBehavioralContract(content);
+    expect(result.length).toBe(3000);
+  });
+
+  it("returns empty exports + throws correctly combined", () => {
+    const content = `export interface Foo {
+  bar: string;
+}
+
+function internal() {
+  throw new Error("FAIL");
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export interface Foo");
+    expect(result).toContain("Error contracts");
+    expect(result).toContain("FAIL");
+  });
+
+  it("handles nested braces in interface correctly", () => {
+    const content = `export interface Config {
+  db: {
+    host: string;
+    port: number;
+  };
+  cache: {
+    ttl: number;
+  };
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("host: string;");
+    expect(result).toContain("ttl: number;");
+    // The closing brace of the outer interface should be present
+    const lines = result.split("\n");
+    const lastNonEmpty = lines.filter((l) => l.trim()).pop();
+    expect(lastNonEmpty?.trim()).toBe("}");
+  });
+
+  it("handles abstract class export", () => {
+    const content = `export abstract class BaseService {
+  abstract findAll(): Promise<any[]>;
+}`;
+    const result = extractBehavioralContract(content);
+    expect(result).toContain("export abstract class BaseService");
+    expect(result).toContain("findAll");
+  });
+});
+
+// ─── printTaskProgress ───────────────────────────────────────────────────────
+
+describe("printTaskProgress", () => {
+  const baseTask: SpecTask = {
+    id: "T-001",
+    title: "Create User model",
+    layer: "data",
+    description: "Define Prisma model for User",
+    filesToTouch: ["prisma/schema.prisma"],
+    acceptanceCriteria: ["User model exists"],
+    verificationSteps: [],
+    dependencies: [],
+    status: "pending",
+  };
+
+  it("prints progress bar in run mode without throwing", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    expect(() => printTaskProgress(2, 5, baseTask, "run")).not.toThrow();
+    const output = spy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(output).toContain("T-001");
+    expect(output).toContain("Create User model");
+    spy.mockRestore();
+  });
+
+  it("prints progress bar in skip mode", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    printTaskProgress(3, 5, { ...baseTask, status: "done" }, "skip");
+    const output = spy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(output).toContain("already done");
+    spy.mockRestore();
+  });
+
+  it("calculates correct percentage", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    printTaskProgress(1, 4, baseTask, "run");
+    const output = spy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(output).toContain("25%");
+    spy.mockRestore();
+  });
+
+  it("handles 0 total without crashing", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    expect(() => printTaskProgress(0, 0, baseTask, "run")).not.toThrow();
+    spy.mockRestore();
+  });
+
+  it("shows 100% when all completed", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    printTaskProgress(5, 5, baseTask, "run");
+    const output = spy.mock.calls.map((c) => c.join(" ")).join("\n");
+    expect(output).toContain("100%");
+    spy.mockRestore();
+  });
+
+  it("uses layer icon for known layers", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    printTaskProgress(0, 1, { ...baseTask, layer: "api" }, "run");
+    // api layer has an icon, just verify no crash
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
+
+  it("handles unknown layer gracefully", () => {
+    const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+    expect(() =>
+      printTaskProgress(0, 1, { ...baseTask, layer: "unknown" as any }, "run")
+    ).not.toThrow();
+    spy.mockRestore();
+  });
+});

package/tests/context-loader.test.ts

@@ -0,0 +1,207 @@
+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 {
+  ContextLoader,
+  isFrontendDeps,
+  FRONTEND_FRAMEWORKS,
+} from "../core/context-loader";
+
+// ─── isFrontendDeps ──────────────────────────────────────────────────────────
+
+describe("isFrontendDeps", () => {
+  it("returns true for react", () => {
+    expect(isFrontendDeps(["react", "express"])).toBe(true);
+  });
+
+  it("returns true for vue", () => {
+    expect(isFrontendDeps(["vue", "axios"])).toBe(true);
+  });
+
+  it("returns true for next", () => {
+    expect(isFrontendDeps(["next", "typescript"])).toBe(true);
+  });
+
+  it("returns true for nuxt", () => {
+    expect(isFrontendDeps(["nuxt"])).toBe(true);
+  });
+
+  it("returns true for svelte", () => {
+    expect(isFrontendDeps(["svelte"])).toBe(true);
+  });
+
+  it("returns false for backend-only deps", () => {
+    expect(isFrontendDeps(["express", "prisma", "mongoose"])).toBe(false);
+  });
+
+  it("returns false for empty deps", () => {
+    expect(isFrontendDeps([])).toBe(false);
+  });
+
+  it("FRONTEND_FRAMEWORKS has at least 5 entries", () => {
+    expect(FRONTEND_FRAMEWORKS.length).toBeGreaterThanOrEqual(5);
+  });
+});
+
+// ─── ContextLoader ───────────────────────────────────────────────────────────
+
+describe("ContextLoader", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `context-test-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("loads context from a Node.js project with package.json", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { express: "^4.0.0", prisma: "^5.0.0" },
+      devDependencies: { typescript: "^5.0.0" },
+    });
+    await fs.ensureDir(path.join(tmpDir, "src"));
+    await fs.writeFile(path.join(tmpDir, "src", "index.ts"), "console.log('hello')");
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+
+    expect(ctx.dependencies).toContain("express");
+    expect(ctx.dependencies).toContain("prisma");
+    expect(ctx.dependencies).toContain("typescript");
+    expect(ctx.techStack).toContain("Express");
+    expect(ctx.techStack).toContain("Prisma");
+    expect(ctx.techStack).toContain("TypeScript");
+  });
+
+  it("detects React in techStack", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { react: "^18.0.0", "react-dom": "^18.0.0" },
+    });
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.techStack).toContain("React");
+  });
+
+  it("detects Vue in techStack", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), {
+      dependencies: { vue: "^3.0.0" },
+    });
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.techStack).toContain("Vue");
+  });
+
+  it("loads Prisma schema when present", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), { dependencies: {} });
+    await fs.ensureDir(path.join(tmpDir, "prisma"));
+    await fs.writeFile(
+      path.join(tmpDir, "prisma", "schema.prisma"),
+      "model User { id Int @id }"
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.schema).toContain("model User");
+  });
+
+  it("returns empty context for empty directory", async () => {
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.techStack).toEqual([]);
+    expect(ctx.dependencies).toEqual([]);
+    expect(ctx.apiStructure).toEqual([]);
+  });
+
+  it("loads constitution when .ai-spec-constitution.md exists", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), { dependencies: {} });
+    await fs.writeFile(
+      path.join(tmpDir, ".ai-spec-constitution.md"),
+      "## 1. Architecture\nUse layered architecture"
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.constitution).toContain("Architecture");
+  });
+
+  it("scans API structure from src/routes", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), { dependencies: {} });
+    await fs.ensureDir(path.join(tmpDir, "src", "routes"));
+    await fs.writeFile(
+      path.join(tmpDir, "src", "routes", "user.ts"),
+      "export default router;"
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.apiStructure.some((f) => f.includes("user.ts"))).toBe(true);
+  });
+
+  it("loads shared config files (i18n, constants)", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), { dependencies: {} });
+    await fs.ensureDir(path.join(tmpDir, "src", "constants"));
+    await fs.writeFile(
+      path.join(tmpDir, "src", "constants", "index.ts"),
+      "export const API_BASE = '/api';"
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.sharedConfigFiles?.some((f) => f.category === "constants")).toBe(true);
+  });
+
+  it("loads error patterns when error handler files exist", async () => {
+    await fs.writeJson(path.join(tmpDir, "package.json"), { dependencies: {} });
+    await fs.ensureDir(path.join(tmpDir, "src"));
+    await fs.writeFile(
+      path.join(tmpDir, "src", "errorHandler.ts"),
+      "export function handleError(err) { console.error(err); }"
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.errorPatterns).toContain("handleError");
+  });
+
+  it("loads PHP project context from composer.json", async () => {
+    await fs.writeJson(path.join(tmpDir, "composer.json"), {
+      require: {
+        php: "^8.1",
+        "laravel/framework": "^10.0",
+      },
+      "require-dev": {
+        phpunit: "^10.0",
+      },
+    });
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.techStack).toContain("PHP");
+    expect(ctx.techStack).toContain("Laravel");
+    expect(ctx.dependencies).toContain("laravel/framework");
+  });
+
+  it("loads Java project context from pom.xml", async () => {
+    await fs.writeFile(
+      path.join(tmpDir, "pom.xml"),
+      `<project>
+        <artifactId>my-app</artifactId>
+        <dependencies>
+          <dependency><artifactId>spring-boot-starter-web</artifactId></dependency>
+          <dependency><artifactId>mybatis-spring-boot-starter</artifactId></dependency>
+        </dependencies>
+      </project>`
+    );
+
+    const loader = new ContextLoader(tmpDir);
+    const ctx = await loader.loadProjectContext();
+    expect(ctx.techStack).toContain("Java");
+    expect(ctx.techStack).toContain("Spring Boot");
+  });
+});

package/tests/dsl-validator.test.ts

@@ -264,6 +264,111 @@ describe("validateDsl — model validation", () => {
   });
 });
 
+// ─── Endpoint ID uniqueness ──────────────────────────────────────────────────
+
+describe("validateDsl — endpoint ID uniqueness", () => {
+  it("accepts endpoints with unique IDs", () => {
+    const ep1 = { ...VALID_DSL.endpoints[0], id: "EP-001" };
+    const ep2 = { ...VALID_DSL.endpoints[0], id: "EP-002", path: "/api/auth/logout" };
+    const result = validateDsl({ ...VALID_DSL, endpoints: [ep1, ep2] });
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects duplicate endpoint IDs", () => {
+    const ep1 = { ...VALID_DSL.endpoints[0], id: "EP-001" };
+    const ep2 = { ...VALID_DSL.endpoints[0], id: "EP-001", path: "/api/auth/logout" };
+    const result = validateDsl({ ...VALID_DSL, endpoints: [ep1, ep2] });
+    expect(result.valid).toBe(false);
+    if (!result.valid) {
+      expect(result.errors.some((e) => e.message.includes("Duplicate endpoint id"))).toBe(true);
+    }
+  });
+
+  it("reports the correct path for the duplicate", () => {
+    const ep1 = { ...VALID_DSL.endpoints[0], id: "EP-001" };
+    const ep2 = { ...VALID_DSL.endpoints[0], id: "EP-001", path: "/api/other" };
+    const result = validateDsl({ ...VALID_DSL, endpoints: [ep1, ep2] });
+    if (!result.valid) {
+      const dupError = result.errors.find((e) => e.message.includes("Duplicate"));
+      expect(dupError?.path).toBe("endpoints[1].id");
+    }
+  });
+
+  it("detects multiple groups of duplicates", () => {
+    const eps = [
+      { ...VALID_DSL.endpoints[0], id: "EP-001" },
+      { ...VALID_DSL.endpoints[0], id: "EP-002", path: "/api/b" },
+      { ...VALID_DSL.endpoints[0], id: "EP-001", path: "/api/c" },
+      { ...VALID_DSL.endpoints[0], id: "EP-002", path: "/api/d" },
+    ];
+    const result = validateDsl({ ...VALID_DSL, endpoints: eps });
+    expect(result.valid).toBe(false);
+    if (!result.valid) {
+      const dupErrors = result.errors.filter((e) => e.message.includes("Duplicate endpoint id"));
+      expect(dupErrors.length).toBe(2);
+    }
+  });
+});
+
+// ─── Model field name uniqueness ─────────────────────────────────────────────
+
+describe("validateDsl — model field name uniqueness", () => {
+  it("accepts models with unique field names", () => {
+    const result = validateDsl(VALID_DSL);
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects duplicate field names within a model", () => {
+    const model = {
+      name: "User",
+      fields: [
+        { name: "id", type: "String", required: true },
+        { name: "email", type: "String", required: true },
+        { name: "id", type: "Int", required: true },
+      ],
+    };
+    const result = validateDsl({ ...VALID_DSL, models: [model] });
+    expect(result.valid).toBe(false);
+    if (!result.valid) {
+      expect(result.errors.some((e) => e.message.includes("Duplicate field name"))).toBe(true);
+    }
+  });
+
+  it("reports the correct path for the duplicate field", () => {
+    const model = {
+      name: "User",
+      fields: [
+        { name: "name", type: "String", required: true },
+        { name: "name", type: "String", required: false },
+      ],
+    };
+    const result = validateDsl({ ...VALID_DSL, models: [model] });
+    if (!result.valid) {
+      const dupError = result.errors.find((e) => e.message.includes("Duplicate field name"));
+      expect(dupError?.path).toBe("models[0].fields[1].name");
+    }
+  });
+
+  it("allows same field name in different models", () => {
+    const model1 = {
+      name: "User",
+      fields: [
+        { name: "id", type: "String", required: true },
+        { name: "name", type: "String", required: true },
+      ],
+    };
+    const model2 = {
+      name: "Post",
+      fields: [
+        { name: "id", type: "String", required: true },
+        { name: "name", type: "String", required: true },
+      ],
+    };
+    const result = validateDsl({ ...VALID_DSL, models: [model1, model2] });
+    expect(result.valid).toBe(true);
+  });
+});
+
 // ─── Error collection (all errors in one pass) ───────────────────────────────
 
 describe("validateDsl — error accumulation", () => {