ai-spec-dev 0.1.0 → 0.17.0

package/core/test-generator.ts

@@ -0,0 +1,273 @@
+import chalk from "chalk";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { AIProvider } from "./spec-generator";
+import { SpecDSL } from "./dsl-types";
+import { testGenSystemPrompt, testGenFrontendSystemPrompt, tddTestGenSystemPrompt } from "../prompts/testgen.prompt";
+import { loadFrontendContext, FrontendContext } from "./frontend-context-loader";
+import { FRONTEND_FRAMEWORKS } from "./context-loader";
+
+// ─── Prompt builders ──────────────────────────────────────────────────────────
+
+function buildBackendTestGenPrompt(dsl: SpecDSL, testDir: string): string {
+  const lines: string[] = [
+    `Generate test skeleton files for the "${dsl.feature.title}" feature.`,
+    `Test files should be placed under: ${testDir}\n`,
+  ];
+
+  if (dsl.models.length > 0) {
+    lines.push("=== Data Models ===");
+    for (const m of dsl.models) {
+      lines.push(`${m.name}:`);
+      for (const f of m.fields) {
+        const flags = [f.required ? "required" : "", f.unique ? "unique" : ""].filter(Boolean).join(", ");
+        lines.push(`  ${f.name}: ${f.type}${flags ? ` (${flags})` : ""}`);
+      }
+    }
+    lines.push("");
+  }
+
+  if (dsl.endpoints.length > 0) {
+    lines.push("=== API Endpoints ===");
+    for (const ep of dsl.endpoints) {
+      lines.push(`${ep.id}: ${ep.method} ${ep.path}  [auth: ${ep.auth}]  → ${ep.successStatus}`);
+      lines.push(`  ${ep.description}`);
+      if (ep.request?.body) {
+        const fields = Object.entries(ep.request.body).map(([k, v]) => `${k}: ${v}`).join(", ");
+        lines.push(`  body: { ${fields} }`);
+      }
+      if (ep.errors && ep.errors.length > 0) {
+        lines.push(`  errors: ${ep.errors.map((e) => `${e.status} ${e.code}`).join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+
+  if (dsl.behaviors.length > 0) {
+    lines.push("=== Business Behaviors (include edge-case tests for these) ===");
+    for (const b of dsl.behaviors) {
+      lines.push(`- ${b.description}`);
+      if (b.constraints) lines.push(`  rules: ${b.constraints.join("; ")}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(
+    "Generate one test file per logical module (e.g. one for API routes, one for service/model tests).",
+    'Output a JSON array of {"file": "path", "content": "full test file source"}.'
+  );
+
+  return lines.join("\n");
+}
+
+function buildFrontendTestGenPrompt(dsl: SpecDSL, testDir: string, ctx: FrontendContext): string {
+  const lines: string[] = [
+    `Generate test skeleton files for the "${dsl.feature.title}" frontend feature.`,
+    `Test framework   : ${ctx.testFramework}`,
+    `Test files should be placed under: ${testDir}\n`,
+  ];
+
+  // Component specs (primary for frontend)
+  if (dsl.components && dsl.components.length > 0) {
+    lines.push("=== Component Specs ===");
+    for (const cmp of dsl.components) {
+      lines.push(`${cmp.id}: ${cmp.name} — ${cmp.description}`);
+      if (cmp.props.length > 0) {
+        lines.push(`  props: ${cmp.props.map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`).join(", ")}`);
+      }
+      if (cmp.events.length > 0) {
+        lines.push(`  events: ${cmp.events.map((e) => `${e.name}(${e.payload ?? ""})`).join(", ")}`);
+      }
+      if (Object.keys(cmp.state).length > 0) {
+        lines.push(`  state: ${Object.entries(cmp.state).map(([k, v]) => `${k}: ${v}`).join(", ")}`);
+      }
+      if (cmp.apiCalls.length > 0) {
+        lines.push(`  api calls: ${cmp.apiCalls.join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Endpoints (for API hook tests)
+  if (dsl.endpoints.length > 0) {
+    lines.push("=== API Endpoints (write hook/service tests for these) ===");
+    for (const ep of dsl.endpoints) {
+      lines.push(`${ep.id}: ${ep.method} ${ep.path}  [auth: ${ep.auth}]  → ${ep.successStatus}`);
+      if (ep.errors && ep.errors.length > 0) {
+        lines.push(`  errors: ${ep.errors.map((e) => `${e.status} ${e.code}`).join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+
+  // Existing hooks (to import from)
+  if (ctx.hookFiles.length > 0) {
+    lines.push("=== Existing custom hooks (import from these, don't create duplicates) ===");
+    ctx.hookFiles.forEach((f) => lines.push(`  - ${f}`));
+    lines.push("");
+  }
+
+  // Existing API wrappers
+  if (ctx.apiWrapperContent.length > 0) {
+    lines.push("=== Existing API wrappers (reference these call patterns) ===");
+    ctx.apiWrapperContent.forEach((c) => {
+      lines.push("```");
+      lines.push(c.slice(0, 400));
+      lines.push("```");
+    });
+    lines.push("");
+  }
+
+  lines.push(
+    "Generate test files: one per component (RTL) and one for API hooks/services.",
+    'Output a JSON array of {"file": "path", "content": "full source"}.'
+  );
+
+  return lines.join("\n");
+}
+
+// ─── Parser ───────────────────────────────────────────────────────────────────
+
+interface TestFileResult {
+  file: string;
+  content: string;
+}
+
+function parseTestFiles(raw: string): TestFileResult[] {
+  const fenced = raw.match(/```(?:json)?\n(\[[\s\S]*?\])\n```/);
+  const jsonStr = fenced ? fenced[1] : (raw.match(/\[[\s\S]*\]/)?.[0] ?? "");
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (Array.isArray(parsed)) return parsed as TestFileResult[];
+  } catch {
+    // fall through
+  }
+  return [];
+}
+
+// ─── Frontend detection ───────────────────────────────────────────────────────
+
+async function isFrontendProject(workingDir: string): Promise<boolean> {
+  const pkgPath = path.join(workingDir, "package.json");
+  if (!(await fs.pathExists(pkgPath))) return false;
+  try {
+    const pkg = await fs.readJson(pkgPath);
+    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    const keys = Object.keys(deps);
+    return keys.some((k) => (FRONTEND_FRAMEWORKS as readonly string[]).includes(k));
+  } catch {
+    return false;
+  }
+}
+
+// ─── TestGenerator ────────────────────────────────────────────────────────────
+
+export class TestGenerator {
+  constructor(private provider: AIProvider) {}
+
+  /**
+   * Generate test skeleton files from a validated DSL.
+   * Automatically detects frontend vs backend and uses the appropriate template.
+   * Returns the list of test file paths written.
+   */
+  async generate(dsl: SpecDSL, workingDir: string): Promise<string[]> {
+    console.log(chalk.blue("\n─── Test Generation ─────────────────────────────"));
+
+    const testDir = await this.detectTestDir(workingDir);
+    const frontend = await isFrontendProject(workingDir);
+
+    let prompt: string;
+    let systemPrompt: string;
+
+    if (frontend) {
+      const ctx = await loadFrontendContext(workingDir);
+      console.log(chalk.gray(`  Mode: frontend (${ctx.framework} / ${ctx.testFramework})`));
+      console.log(chalk.gray(`  Test directory: ${testDir}`));
+      prompt = buildFrontendTestGenPrompt(dsl, testDir, ctx);
+      systemPrompt = testGenFrontendSystemPrompt;
+    } else {
+      console.log(chalk.gray(`  Mode: backend`));
+      console.log(chalk.gray(`  Test directory: ${testDir}`));
+      prompt = buildBackendTestGenPrompt(dsl, testDir);
+      systemPrompt = testGenSystemPrompt;
+    }
+
+    let rawOutput: string;
+    try {
+      rawOutput = await this.provider.generate(prompt, systemPrompt);
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Test generation AI call failed: ${(err as Error).message}`));
+      return [];
+    }
+
+    const testFiles = parseTestFiles(rawOutput);
+    if (testFiles.length === 0) {
+      console.log(chalk.yellow("  ⚠ Could not parse test files from AI output. Skipping."));
+      return [];
+    }
+
+    const writtenFiles: string[] = [];
+    for (const tf of testFiles) {
+      const fullPath = path.join(workingDir, tf.file);
+      await fs.ensureDir(path.dirname(fullPath));
+      await fs.writeFile(fullPath, tf.content, "utf-8");
+      console.log(chalk.green(`  + ${tf.file}`));
+      writtenFiles.push(tf.file);
+    }
+
+    console.log(chalk.green(`  ✔ ${writtenFiles.length} test file(s) generated.`));
+    return writtenFiles;
+  }
+
+  /**
+   * TDD mode: generate test files with real assertions BEFORE the implementation exists.
+   * These tests will initially fail — the error feedback loop drives implementation to pass them.
+   * Only supports backend projects (uses supertest + DSL endpoints/models).
+   */
+  async generateTdd(dsl: SpecDSL, workingDir: string): Promise<string[]> {
+    console.log(chalk.blue("\n─── TDD Test Generation (pre-implementation) ────"));
+
+    const testDir = await this.detectTestDir(workingDir);
+    console.log(chalk.gray(`  Mode: TDD (real assertions — tests will fail until implementation is complete)`));
+    console.log(chalk.gray(`  Test directory: ${testDir}`));
+
+    const prompt = buildBackendTestGenPrompt(dsl, testDir);
+
+    let rawOutput: string;
+    try {
+      rawOutput = await this.provider.generate(prompt, tddTestGenSystemPrompt);
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ TDD test generation failed: ${(err as Error).message}`));
+      return [];
+    }
+
+    const testFiles = parseTestFiles(rawOutput);
+    if (testFiles.length === 0) {
+      console.log(chalk.yellow("  ⚠ Could not parse TDD test files from AI output. Skipping."));
+      return [];
+    }
+
+    const writtenFiles: string[] = [];
+    for (const tf of testFiles) {
+      const fullPath = path.join(workingDir, tf.file);
+      await fs.ensureDir(path.dirname(fullPath));
+      await fs.writeFile(fullPath, tf.content, "utf-8");
+      console.log(chalk.green(`  + ${tf.file}`));
+      writtenFiles.push(tf.file);
+    }
+
+    console.log(
+      chalk.green(`  ✔ ${writtenFiles.length} TDD test file(s) written.`) +
+      chalk.gray(" (expected to fail — implementation will make them pass)")
+    );
+    return writtenFiles;
+  }
+
+  private async detectTestDir(workingDir: string): Promise<string> {
+    const candidates = ["tests", "test", "__tests__", "src/__tests__", "spec"];
+    for (const c of candidates) {
+      if (await fs.pathExists(path.join(workingDir, c))) return c;
+    }
+    return "tests";
+  }
+}

package/core/workspace-loader.ts

@@ -0,0 +1,256 @@
+import * as fs from "fs-extra";
+import * as path from "path";
+import { glob } from "glob";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export type RepoType =
+  | "node-express"
+  | "node-koa"
+  | "react"
+  | "next"
+  | "vue"
+  | "react-native"
+  | "go"
+  | "python"
+  | "java"
+  | "rust"
+  | "php"
+  | "unknown";
+
+export type RepoRole = "backend" | "frontend" | "mobile" | "shared";
+
+export interface RepoConfig {
+  name: string;
+  /** Relative path from workspace root (the directory containing .ai-spec-workspace.json) */
+  path: string;
+  type: RepoType;
+  role: RepoRole;
+  /** Contents of .ai-spec-constitution.md, loaded at runtime */
+  constitution?: string;
+}
+
+export interface WorkspaceConfig {
+  name: string;
+  repos: RepoConfig[];
+}
+
+export const WORKSPACE_CONFIG_FILE = ".ai-spec-workspace.json";
+
+// ─── Type Detection ───────────────────────────────────────────────────────────
+
+/**
+ * Detect the repo type and role from its package.json dependencies.
+ */
+export async function detectRepoType(
+  repoAbsPath: string
+): Promise<{ type: RepoType; role: RepoRole }> {
+  // ── Non-Node language detection (check before package.json) ──────────────
+  if (await fs.pathExists(path.join(repoAbsPath, "go.mod"))) {
+    return { type: "go", role: "backend" };
+  }
+  if (await fs.pathExists(path.join(repoAbsPath, "composer.json"))) {
+    return { type: "php", role: "backend" };
+  }
+  if (await fs.pathExists(path.join(repoAbsPath, "Cargo.toml"))) {
+    return { type: "rust", role: "backend" };
+  }
+  if (
+    (await fs.pathExists(path.join(repoAbsPath, "pom.xml"))) ||
+    (await fs.pathExists(path.join(repoAbsPath, "build.gradle"))) ||
+    (await fs.pathExists(path.join(repoAbsPath, "build.gradle.kts")))
+  ) {
+    return { type: "java", role: "backend" };
+  }
+  if (
+    (await fs.pathExists(path.join(repoAbsPath, "requirements.txt"))) ||
+    (await fs.pathExists(path.join(repoAbsPath, "pyproject.toml"))) ||
+    (await fs.pathExists(path.join(repoAbsPath, "setup.py")))
+  ) {
+    return { type: "python", role: "backend" };
+  }
+
+  // ── Node.js detection via package.json ────────────────────────────────────
+  const pkgPath = path.join(repoAbsPath, "package.json");
+  if (!(await fs.pathExists(pkgPath))) {
+    return { type: "unknown", role: "shared" };
+  }
+
+  let pkg: Record<string, unknown> = {};
+  try {
+    pkg = await fs.readJson(pkgPath);
+  } catch {
+    return { type: "unknown", role: "shared" };
+  }
+
+  const deps = {
+    ...((pkg.dependencies as Record<string, string>) ?? {}),
+    ...((pkg.devDependencies as Record<string, string>) ?? {}),
+  };
+  const depKeys = Object.keys(deps);
+
+  const has = (...names: string[]) => names.some((n) => depKeys.includes(n));
+
+  if (has("react-native", "expo")) {
+    return { type: "react-native", role: "mobile" };
+  }
+  if (has("next")) {
+    return { type: "next", role: "frontend" };
+  }
+  if (has("react")) {
+    return { type: "react", role: "frontend" };
+  }
+  if (has("vue", "@vue/cli-service")) {
+    return { type: "vue", role: "frontend" };
+  }
+  if (has("koa", "@koa/router")) {
+    return { type: "node-koa", role: "backend" };
+  }
+  if (
+    has("express", "@nestjs/core", "fastify", "hapi") ||
+    has("prisma", "@prisma/client", "mongoose", "typeorm", "sequelize")
+  ) {
+    return { type: "node-express", role: "backend" };
+  }
+
+  return { type: "unknown", role: "shared" };
+}
+
+// ─── WorkspaceLoader ─────────────────────────────────────────────────────────
+
+export class WorkspaceLoader {
+  constructor(private workspaceRoot: string) {}
+
+  /**
+   * Load and validate .ai-spec-workspace.json from the workspace root.
+   * Returns null if the file does not exist (graceful degradation).
+   */
+  async load(): Promise<WorkspaceConfig | null> {
+    const configPath = path.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
+    if (!(await fs.pathExists(configPath))) {
+      return null;
+    }
+
+    let raw: unknown;
+    try {
+      raw = await fs.readJson(configPath);
+    } catch (err) {
+      throw new Error(
+        `Failed to parse ${WORKSPACE_CONFIG_FILE}: ${(err as Error).message}`
+      );
+    }
+
+    if (
+      typeof raw !== "object" ||
+      raw === null ||
+      !("name" in raw) ||
+      !("repos" in raw)
+    ) {
+      throw new Error(
+        `${WORKSPACE_CONFIG_FILE} is missing required fields: name, repos`
+      );
+    }
+
+    const config = raw as WorkspaceConfig;
+
+    if (!Array.isArray(config.repos) || config.repos.length === 0) {
+      throw new Error(`${WORKSPACE_CONFIG_FILE}: repos must be a non-empty array`);
+    }
+
+    // Load constitutions at runtime
+    const resolvedRepos = await this.resolveRepoPaths(config);
+    return { ...config, repos: resolvedRepos };
+  }
+
+  /**
+   * Scan sibling directories for repos by looking for package.json.
+   * Auto-detects type and role from dependencies.
+   */
+  async autoDetect(names?: string[]): Promise<RepoConfig[]> {
+    const entries = await fs.readdir(this.workspaceRoot);
+    const repos: RepoConfig[] = [];
+
+    for (const entry of entries) {
+      const absPath = path.join(this.workspaceRoot, entry);
+      const stat = await fs.stat(absPath).catch(() => null);
+      if (!stat || !stat.isDirectory()) continue;
+      if (entry.startsWith(".") || entry === "node_modules") continue;
+      if (names && !names.includes(entry)) continue;
+
+      // Accept any recognizable project (package.json, go.mod, Cargo.toml, pom.xml, etc.)
+      const hasManifest =
+        (await fs.pathExists(path.join(absPath, "package.json"))) ||
+        (await fs.pathExists(path.join(absPath, "go.mod"))) ||
+        (await fs.pathExists(path.join(absPath, "Cargo.toml"))) ||
+        (await fs.pathExists(path.join(absPath, "pom.xml"))) ||
+        (await fs.pathExists(path.join(absPath, "build.gradle"))) ||
+        (await fs.pathExists(path.join(absPath, "requirements.txt"))) ||
+        (await fs.pathExists(path.join(absPath, "pyproject.toml"))) ||
+        (await fs.pathExists(path.join(absPath, "composer.json")));
+      if (!hasManifest) continue;
+
+      const { type, role } = await detectRepoType(absPath);
+      repos.push({ name: entry, path: entry, type, role });
+    }
+
+    return repos;
+  }
+
+  /**
+   * Resolve relative paths to absolute and load constitutions.
+   */
+  async resolveRepoPaths(config: WorkspaceConfig): Promise<RepoConfig[]> {
+    const resolved: RepoConfig[] = [];
+
+    for (const repo of config.repos) {
+      const absPath = path.resolve(this.workspaceRoot, repo.path);
+      let constitution: string | undefined;
+
+      const constitutionFile = path.join(absPath, ".ai-spec-constitution.md");
+      if (await fs.pathExists(constitutionFile)) {
+        constitution = await fs.readFile(constitutionFile, "utf-8");
+      }
+
+      resolved.push({ ...repo, constitution });
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Save a workspace config to disk.
+   */
+  async save(config: WorkspaceConfig): Promise<string> {
+    const configPath = path.join(this.workspaceRoot, WORKSPACE_CONFIG_FILE);
+    // Strip runtime-loaded constitutions before saving
+    const toSave: WorkspaceConfig = {
+      name: config.name,
+      repos: config.repos.map(({ constitution: _c, ...rest }) => rest),
+    };
+    await fs.writeJson(configPath, toSave, { spaces: 2 });
+    return configPath;
+  }
+
+  /**
+   * Resolve the absolute path of a repo given its config.
+   */
+  resolveAbsPath(repo: RepoConfig): string {
+    return path.resolve(this.workspaceRoot, repo.path);
+  }
+
+  /**
+   * Find which repos are backend (contract providers) and which depend on them.
+   */
+  static getProcessingOrder(repos: RepoConfig[]): RepoConfig[] {
+    // Backends first, then frontends/mobile, then shared
+    const roleOrder: Record<RepoRole, number> = {
+      backend: 0,
+      shared: 1,
+      frontend: 2,
+      mobile: 3,
+    };
+    return [...repos].sort(
+      (a, b) => roleOrder[a.role] - roleOrder[b.role]
+    );
+  }
+}