ai-spec-dev 0.38.0 → 0.42.0

package/core/dsl-extractor.ts

@@ -11,6 +11,8 @@ import {
   buildDslExtractionPrompt,
   buildDslRetryPrompt,
 } from "../prompts/dsl.prompt";
+import { estimateTokens, getDefaultBudget } from "./token-budget";
+import { parseJsonFromAiOutput } from "./safe-json";
 
 // ─── DSL Sanitizer ───────────────────────────────────────────────────────────
 
@@ -50,8 +52,8 @@ function sanitizeDsl(raw: unknown): unknown {
 /** Maximum AI attempts (1 initial + up to this many retries). */
 const MAX_RETRIES = 2;
 
-/** Maximum spec length passed to AI to avoid token/context blow-up. */
-const MAX_SPEC_CHARS = 12_000;
+/** Default maximum spec length passed to AI. Overridden by token budget when provider is known. */
+const DEFAULT_MAX_SPEC_CHARS = 12_000;
 
 // ─── DSL file naming ──────────────────────────────────────────────────────────
 
@@ -63,45 +65,8 @@ export function dslFilePath(specFilePath: string): string {
 
 // ─── Parser ───────────────────────────────────────────────────────────────────
 
-/**
- * Parse JSON from raw AI output.
- * Handles two cases:
- *   1. Bare JSON object starting with `{`
- *   2. JSON wrapped in a ```json ... ``` fence (model sometimes ignores instructions)
- *
- * Does NOT use eval or Function() — only JSON.parse().
- */
-function parseJsonFromOutput(raw: string): unknown {
-  const trimmed = raw.trim();
-
-  // Case 1: bare JSON
-  if (trimmed.startsWith("{")) {
-    return JSON.parse(trimmed);
-  }
-
-  // Case 2: fenced JSON  — extract content between first ``` and last ```
-  const fenceStart = trimmed.indexOf("```");
-  if (fenceStart !== -1) {
-    const afterFence = trimmed.slice(fenceStart + 3);
-    // Skip optional language tag (e.g. "json\n")
-    const newlinePos = afterFence.indexOf("\n");
-    const jsonStart = newlinePos !== -1 ? newlinePos + 1 : 0;
-    const fenceEnd = afterFence.lastIndexOf("```");
-    if (fenceEnd > jsonStart) {
-      const jsonStr = afterFence.slice(jsonStart, fenceEnd).trim();
-      return JSON.parse(jsonStr);
-    }
-  }
-
-  // Case 3: try to find the first `{` and last `}` pair
-  const objStart = trimmed.indexOf("{");
-  const objEnd = trimmed.lastIndexOf("}");
-  if (objStart !== -1 && objEnd > objStart) {
-    return JSON.parse(trimmed.slice(objStart, objEnd + 1));
-  }
-
-  throw new SyntaxError("No JSON object found in AI output");
-}
+// Uses shared parseJsonFromAiOutput from safe-json.ts
+const parseJsonFromOutput = parseJsonFromAiOutput;
 
 // ─── DslExtractor ────────────────────────────────────────────────────────────
 
@@ -125,12 +90,20 @@ export class DslExtractor {
     specContent: string,
     opts: { auto?: boolean; isFrontend?: boolean } = {}
   ): Promise<SpecDSL | null> {
+    // Compute dynamic spec char limit based on provider's token budget.
+    // Reserve ~30% of budget for DSL extraction prompt + response; use 70% for spec content.
+    const providerBudget = getDefaultBudget(this.provider.providerName);
+    const maxSpecChars = Math.max(
+      DEFAULT_MAX_SPEC_CHARS,
+      Math.floor(providerBudget * 0.7 * 3) // ~3 chars per token, 70% of budget
+    );
+
     // Truncate very long specs to avoid token issues
     const specForAI =
-      specContent.length > MAX_SPEC_CHARS
+      specContent.length > maxSpecChars
         ? (() => {
-            console.log(chalk.yellow(`  ⚠ Spec is ${specContent.length} chars — truncating to ${MAX_SPEC_CHARS} for DSL extraction. Details at the end may be lost.`));
-            return specContent.slice(0, MAX_SPEC_CHARS) + "\n... (truncated for DSL extraction)";
+            console.log(chalk.yellow(`  ⚠ Spec is ${specContent.length} chars — truncating to ${maxSpecChars} for DSL extraction (${this.provider.providerName} budget: ${Math.round(providerBudget / 1000)}K tokens).`));
+            return specContent.slice(0, maxSpecChars) + "\n... (truncated for DSL extraction)";
           })()
         : specContent;
 
@@ -170,8 +143,8 @@ export class DslExtractor {
         console.log(chalk.red(`  ✘ Failed to parse JSON from AI output: ${(parseErr as Error).message}`));
         const preview = rawOutput.slice(0, 500).replace(/\n/g, "\\n");
         console.log(chalk.gray(`  AI output preview (first 500 chars): ${preview}`));
-        if (rawOutput.length > MAX_SPEC_CHARS) {
-          console.log(chalk.gray(`  Note: spec was truncated to ${MAX_SPEC_CHARS} chars — long specs may lose context`));
+        if (rawOutput.length > maxSpecChars) {
+          console.log(chalk.gray(`  Note: spec was truncated to ${maxSpecChars} chars — long specs may lose context`));
         }
         lastErrors = [{ path: "root", message: "Output is not valid JSON — see raw output above" }];
 

package/core/dsl-feedback.ts

@@ -21,7 +21,7 @@ import { SpecDSL } from "./dsl-types";
 
 export interface DslGap {
   /** Short machine key for RunLog serialisation */
-  code: "sparse_model" | "missing_errors" | "generic_endpoint_desc" | "no_models_no_endpoints";
+  code: "sparse_model" | "missing_errors" | "generic_endpoint_desc" | "no_models_no_endpoints" | "uncovered_requirement";
   /** Human-readable message shown to the user */
   message: string;
   /** Concrete suggestion injected into the refinement prompt */

package/core/dsl-validator.ts

@@ -119,6 +119,9 @@ export function validateDsl(raw: unknown): DslValidationResult {
     }
   }
 
+  // ── Cross-reference checks ──────────────────────────────────────────────
+  crossReferenceChecks(obj, errors);
+
   if (errors.length > 0) {
     return { valid: false, errors };
   }
@@ -428,6 +431,77 @@ function validateComponent(
   }
 }
 
+// ─── Cross-reference checks ──────────────────────────────────────────────────
+
+function crossReferenceChecks(
+  obj: Record<string, unknown>,
+  errors: DslValidationError[]
+): void {
+  const models = Array.isArray(obj["models"]) ? (obj["models"] as Record<string, unknown>[]) : [];
+  const endpoints = Array.isArray(obj["endpoints"]) ? (obj["endpoints"] as Record<string, unknown>[]) : [];
+  const components = Array.isArray(obj["components"]) ? (obj["components"] as Record<string, unknown>[]) : [];
+
+  // 1. Duplicate path+method detection
+  const seenRoutes = new Map<string, number>();
+  for (let i = 0; i < endpoints.length; i++) {
+    const ep = endpoints[i];
+    if (typeof ep?.["method"] === "string" && typeof ep?.["path"] === "string") {
+      const route = `${(ep["method"] as string).toUpperCase()} ${ep["path"]}`;
+      if (seenRoutes.has(route)) {
+        errors.push({
+          path: `endpoints[${i}]`,
+          message: `Duplicate route "${route}" — also defined at endpoints[${seenRoutes.get(route)}]`,
+        });
+      } else {
+        seenRoutes.set(route, i);
+      }
+    }
+  }
+
+  // 2. Model relations reference existing model names
+  const modelNames = new Set(
+    models.filter((m) => typeof m?.["name"] === "string").map((m) => m["name"] as string)
+  );
+  for (let i = 0; i < models.length; i++) {
+    const m = models[i];
+    if (!Array.isArray(m?.["relations"])) continue;
+    for (const rel of m["relations"] as string[]) {
+      if (typeof rel !== "string") continue;
+      // Extract referenced model name: "User hasMany Post" → "Post", "belongsTo Category" → "Category"
+      const refMatch = rel.match(/(?:hasMany|hasOne|belongsTo|manyToMany)\s+(\w+)/i);
+      if (refMatch) {
+        const refName = refMatch[1];
+        if (!modelNames.has(refName)) {
+          errors.push({
+            path: `models[${i}].relations`,
+            message: `Relation references model "${refName}" which is not defined in models[]`,
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Component apiCalls reference existing endpoint IDs
+  const endpointIds = new Set(
+    endpoints.filter((e) => typeof e?.["id"] === "string").map((e) => e["id"] as string)
+  );
+  if (endpointIds.size > 0) {
+    for (let i = 0; i < components.length; i++) {
+      const c = components[i];
+      if (!Array.isArray(c?.["apiCalls"])) continue;
+      for (const call of c["apiCalls"] as string[]) {
+        if (typeof call !== "string") continue;
+        if (!endpointIds.has(call)) {
+          errors.push({
+            path: `components[${i}].apiCalls`,
+            message: `References endpoint "${call}" which is not defined in endpoints[]`,
+          });
+        }
+      }
+    }
+  }
+}
+
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function requireNonEmptyString(

package/core/error-feedback.ts

@@ -7,10 +7,11 @@ import { getCodeGenSystemPrompt } from "../prompts/codegen.prompt";
 import { SpecDSL } from "./dsl-types";
 import { buildDslContextSection } from "./dsl-extractor";
 import { getActiveSnapshot } from "./run-snapshot";
+import { startSpinner } from "./cli-ui";
 
 // ─── Types ──────────────────────────────────────────────────────────────────────
 
-interface ErrorEntry {
+export interface ErrorEntry {
   source: "test" | "lint" | "build";
   message: string;
   file?: string;
@@ -60,7 +61,7 @@ function runCommand(cmd: string, cwd: string): { success: boolean; output: strin
  * Detect TypeScript type-check command for the given directory.
  * Returns null for non-TS projects or projects without tsconfig.
  */
-function detectBuildCommand(workingDir: string): string | null {
+export function detectBuildCommand(workingDir: string): string | null {
   // Only applies to Node.js / frontend TypeScript projects
   if (!fs.existsSync(path.join(workingDir, "tsconfig.json"))) return null;
 
@@ -80,7 +81,7 @@ function detectBuildCommand(workingDir: string): string | null {
   return "npx tsc --noEmit";
 }
 
-function detectTestCommand(workingDir: string): string | null {
+export function detectTestCommand(workingDir: string): string | null {
   // ── Go ──────────────────────────────────────────────────────────────────────
   if (fs.existsSync(path.join(workingDir, "go.mod"))) return "go test ./...";
 
@@ -129,7 +130,7 @@ function detectTestCommand(workingDir: string): string | null {
   return null;
 }
 
-function detectLintCommand(workingDir: string): string | null {
+export function detectLintCommand(workingDir: string): string | null {
   // ── Go ──────────────────────────────────────────────────────────────────────
   if (fs.existsSync(path.join(workingDir, "go.mod"))) {
     // golangci-lint is optional; fall back to go vet
@@ -183,7 +184,7 @@ function detectLintCommand(workingDir: string): string | null {
   return null;
 }
 
-function parseErrors(output: string, source: ErrorEntry["source"]): ErrorEntry[] {
+export function parseErrors(output: string, source: ErrorEntry["source"]): ErrorEntry[] {
   const errors: ErrorEntry[] = [];
   if (!output.trim()) return errors;
 
@@ -226,7 +227,7 @@ function parseErrors(output: string, source: ErrorEntry["source"]): ErrorEntry[]
  * Returns paths normalized to project-root-relative form (no extension).
  * Only considers relative imports (./foo, ../foo) — skips aliases and node_modules.
  */
-function parseRelativeImports(content: string, fromFileRel: string): string[] {
+export function parseRelativeImports(content: string, fromFileRel: string): string[] {
   const relDir = path.dirname(fromFileRel);
   const results: string[] = [];
 
@@ -253,7 +254,7 @@ function parseRelativeImports(content: string, fromFileRel: string): string[] {
  * Example: if A exports a type used by B and C, fix A first so cycle 1 can cascade correctly.
  * Uses Kahn's topological sort; cycles are appended at the end (unavoidable, fix last).
  */
-async function buildRepairOrder(
+export async function buildRepairOrder(
   errorsByFile: Map<string, ErrorEntry[]>,
   workingDir: string
 ): Promise<[string, ErrorEntry[]][]> {
@@ -369,22 +370,80 @@ ${fileContent}
 
 Output ONLY the complete fixed file content. No markdown fences, no explanations.`;
 
+    const fixSpinner = startSpinner(`Fixing ${chalk.bold(file)} (${fileErrors.length} error(s))...`);
     try {
       const raw = await provider.generate(prompt, getCodeGenSystemPrompt());
       const fixed = raw.replace(/^```\w*\n?/gm, "").replace(/\n?```$/gm, "").trim();
       await getActiveSnapshot()?.snapshotFile(fullPath);
       await fs.writeFile(fullPath, fixed, "utf-8");
       results.push({ fixed: true, file, explanation: `Fixed ${fileErrors.length} error(s)` });
-      console.log(chalk.green(`  ✔ Auto-fixed: ${file}`));
+      fixSpinner.succeed(`Auto-fixed: ${file}`);
     } catch (err) {
       results.push({ fixed: false, file, explanation: `AI fix failed: ${(err as Error).message}` });
-      console.log(chalk.yellow(`  ⚠ Could not auto-fix: ${file}`));
+      fixSpinner.fail(`Could not auto-fix: ${file}`);
     }
   }
 
   return results;
 }
 
+// ─── Test Existence Validation ──────────────────────────────────────────────────
+
+/** Patterns that indicate a file contains actual test cases (language-agnostic). */
+const TEST_PATTERNS = [
+  /\bdescribe\s*\(/,       // JS/TS (vitest, jest, mocha)
+  /\bit\s*\(/,             // JS/TS
+  /\btest\s*\(/,           // JS/TS
+  /\bfunc\s+Test\w*\s*\(/, // Go
+  /\bdef\s+test_/,         // Python
+  /@Test\b/,               // Java (JUnit)
+  /#\[test\]/,             // Rust
+];
+
+export interface TestValidationResult {
+  valid: boolean;
+  fileCount: number;
+  reason?: string;
+}
+
+/**
+ * Check that generated test files exist on disk and contain actual test cases.
+ * Prevents false-positive "tests pass" when no tests were generated.
+ */
+export function validateTestFilesExist(
+  workingDir: string,
+  generatedTestFiles: string[]
+): TestValidationResult {
+  if (generatedTestFiles.length === 0) {
+    return { valid: false, fileCount: 0, reason: "No test files were generated" };
+  }
+
+  let validCount = 0;
+  for (const relPath of generatedTestFiles) {
+    const absPath = path.join(workingDir, relPath);
+    if (!fs.existsSync(absPath)) continue;
+
+    try {
+      const content = fs.readFileSync(absPath, "utf-8");
+      if (TEST_PATTERNS.some((p) => p.test(content))) {
+        validCount++;
+      }
+    } catch {
+      // unreadable — skip
+    }
+  }
+
+  if (validCount === 0) {
+    return {
+      valid: false,
+      fileCount: generatedTestFiles.length,
+      reason: `${generatedTestFiles.length} test file(s) listed but none contain actual test cases`,
+    };
+  }
+
+  return { valid: true, fileCount: validCount };
+}
+
 // ─── Public API ─────────────────────────────────────────────────────────────────
 
 export interface ErrorFeedbackOptions {
@@ -396,6 +455,8 @@ export interface ErrorFeedbackOptions {
   skipLint?: boolean;
   /** Whether to skip TypeScript type-check (tsc --noEmit / vue-tsc --noEmit) */
   skipBuild?: boolean;
+  /** List of generated test files — used to validate tests actually exist */
+  generatedTestFiles?: string[];
 }
 
 /**
@@ -421,6 +482,19 @@ export async function runErrorFeedback(
     return true;
   }
 
+  // ── Pre-check: validate generated test files actually exist ──────────────
+  let testsValidated = true;
+  if (testCmd && opts.generatedTestFiles) {
+    const testValidation = validateTestFilesExist(workingDir, opts.generatedTestFiles);
+    if (!testValidation.valid) {
+      console.log(chalk.yellow(`  ⚠ Test validation: ${testValidation.reason}`));
+      console.log(chalk.yellow("    Test results will be treated as unvalidated (not as 'pass')."));
+      testsValidated = false;
+    } else {
+      console.log(chalk.gray(`  Test validation: ${testValidation.fileCount} valid test file(s) found.`));
+    }
+  }
+
   if (buildCmd) console.log(chalk.gray(`  Type-check: ${buildCmd}`));
 
   let prevErrorCount = Infinity; // circuit-breaker: tracks error count from previous cycle
@@ -489,16 +563,28 @@ export async function runErrorFeedback(
     }
 
     if (allErrors.length === 0) {
+      if (!testsValidated) {
+        console.log(chalk.yellow(`\n  ⚠ Build/lint passed but tests were not validated (no test files with actual test cases).`));
+        return true; // don't block pipeline, but the warning is logged
+      }
       console.log(chalk.green(`\n  ✔ All checks passed after ${cycle} cycle(s).`));
       return true;
     }
 
-    // Circuit breaker: if the fix cycle made no progress (error count did not
-    // decrease), stop immediately rather than spending another AI cycle.
-    if (allErrors.length >= prevErrorCount) {
+    // Circuit breaker: stop if error count didn't decrease or is increasing.
+    if (allErrors.length > prevErrorCount) {
+      console.log(
+        chalk.red(
+          `\n  ✘ Auto-fix caused regression (${prevErrorCount} → ${allErrors.length} errors). Stopping immediately.`
+        )
+      );
+      console.log(chalk.gray("    The fix attempt introduced new errors. Manual intervention needed."));
+      return false;
+    }
+    if (allErrors.length === prevErrorCount) {
       console.log(
         chalk.yellow(
-          `\n  ⚠ Auto-fix made no progress (${allErrors.length} error(s) before and after). Stopping early.`
+          `\n  ⚠ Auto-fix made no progress (${allErrors.length} error(s) remain). Stopping early.`
         )
       );
       console.log(chalk.gray("    Manual intervention needed."));

package/core/frontend-context-loader.ts

@@ -4,7 +4,10 @@ import { glob } from "glob";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
-export type FrontendFramework = "react" | "next" | "vue" | "react-native" | "unknown";
+export type FrontendFramework =
+  | "react" | "next" | "vue" | "react-native"
+  | "svelte" | "sveltekit" | "solid" | "qwik" | "remix" | "astro"
+  | "unknown";
 
 export interface FrontendContext {
   framework: FrontendFramework;
@@ -88,7 +91,7 @@ interface ImportStatement {
  *  - Returns structured objects so callers can inspect specifiers vs module path
  *    without re-running a second regex
  */
-function parseImportStatements(content: string): ImportStatement[] {
+export function parseImportStatements(content: string): ImportStatement[] {
   // 1. Strip block comments (/* ... */) to avoid matching imports inside comments
   const stripped = content.replace(/\/\*[\s\S]*?\*\//g, (m) => "\n".repeat(m.split("\n").length - 1));
 
@@ -137,7 +140,7 @@ const HTTP_MODULE_PATTERNS: RegExp[] = [
  *  - Module-path matching is done on the resolved path string, not the full line,
  *    so a long specifier list doesn't prevent a match
  */
-function findHttpClientImport(content: string): string | undefined {
+export function findHttpClientImport(content: string): string | undefined {
   for (const stmt of parseImportStatements(content)) {
     if (HTTP_MODULE_PATTERNS.some((p) => p.test(stmt.modulePath))) {
       return stmt.line;
@@ -190,6 +193,8 @@ const ROUTING_LIBS: Array<[string, string]> = [
   ["react-navigation", "react-navigation"],
   ["expo-router", "expo-router"],
   ["vue-router", "vue-router"],
+  ["@solidjs/router", "solid-router"],
+  ["@builder.io/qwik-city", "qwik-city"],
 ];
 
 // ─── Main function ─────────────────────────────────────────────────────────────
@@ -231,9 +236,21 @@ export async function loadFrontendContext(
     const depKeys = Object.keys(allDeps);
     const has = (name: string) => depKeys.includes(name);
 
-    // Framework
+    // Framework (order matters: more specific before generic)
     if (has("react-native") || has("expo")) {
       ctx.framework = "react-native";
+    } else if (has("@sveltejs/kit")) {
+      ctx.framework = "sveltekit";
+    } else if (has("svelte")) {
+      ctx.framework = "svelte";
+    } else if (has("@builder.io/qwik")) {
+      ctx.framework = "qwik";
+    } else if (has("@remix-run/react") || has("@remix-run/node")) {
+      ctx.framework = "remix";
+    } else if (has("astro")) {
+      ctx.framework = "astro";
+    } else if (has("solid-js")) {
+      ctx.framework = "solid";
     } else if (has("next")) {
       ctx.framework = "next";
     } else if (has("react")) {
@@ -266,9 +283,14 @@ export async function loadFrontendContext(
 
     // Routing
     if (ctx.framework === "next") {
-      // Detect app router vs pages router
       const hasAppDir = await fs.pathExists(path.join(projectRoot, "app"));
       ctx.routingPattern = hasAppDir ? "next-app-router" : "next-pages-router";
+    } else if (ctx.framework === "sveltekit") {
+      ctx.routingPattern = "sveltekit-file-router";
+    } else if (ctx.framework === "remix") {
+      ctx.routingPattern = "remix-file-router";
+    } else if (ctx.framework === "astro") {
+      ctx.routingPattern = "astro-file-router";
     } else {
       for (const [lib, label] of ROUTING_LIBS) {
         if (has(lib)) {

package/core/knowledge-memory.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import { AIProvider } from "./spec-generator";
 import { CONSTITUTION_FILE } from "./constitution-generator";
 import { parseConstitutionStats } from "../prompts/consolidate.prompt";
+import { ConstitutionConsolidator } from "./constitution-consolidator";
 
 // ─── Types ──────────────────────────────────────────────────────────────────────
 
@@ -223,3 +224,54 @@ export async function accumulateReviewKnowledge(
 
   await appendLessonsToConstitution(projectRoot, issues);
 }
+
+// ─── Auto-Consolidation ──────────────────────────────────────────────────────
+
+const DEFAULT_AUTO_CONSOLIDATE_THRESHOLD = 12;
+
+/**
+ * Check if §9 has grown past the threshold and auto-consolidate if so.
+ * Non-blocking, creates backups, uses the same ConstitutionConsolidator.
+ * Returns true if consolidation was performed.
+ */
+export async function maybeAutoConsolidate(
+  provider: AIProvider,
+  projectRoot: string,
+  opts: { threshold?: number } = {}
+): Promise<boolean> {
+  const threshold = opts.threshold ?? DEFAULT_AUTO_CONSOLIDATE_THRESHOLD;
+  const constitutionPath = path.join(projectRoot, CONSTITUTION_FILE);
+
+  let content: string;
+  try {
+    content = await fs.readFile(constitutionPath, "utf-8");
+  } catch {
+    return false;
+  }
+
+  const stats = parseConstitutionStats(content);
+  if (stats.lessonCount < threshold) return false;
+
+  console.log(
+    chalk.cyan(
+      `  §9 has ${stats.lessonCount} lessons (threshold: ${threshold}) — auto-consolidating...`
+    )
+  );
+
+  try {
+    const consolidator = new ConstitutionConsolidator(provider);
+    const result = await consolidator.consolidate(projectRoot, { minLessons: threshold });
+    if (result.written) {
+      console.log(
+        chalk.green(
+          `  ✔ Auto-consolidated: ${result.before.lessonCount} → ${result.after!.lessonCount} lessons. Backup: ${result.backupPath}`
+        )
+      );
+      return true;
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  ⚠ Auto-consolidation failed: ${(err as Error).message}`));
+  }
+
+  return false;
+}

package/core/mock/fixtures.ts

@@ -0,0 +1,89 @@
+import { SpecDSL, ApiEndpoint, FieldMap } from "../dsl-types";
+
+// ─── Fixture Generator ────────────────────────────────────────────────────────
+
+/**
+ * Convert a type-description string to a fixture value (JavaScript literal).
+ */
+function typeToFixture(fieldName: string, typeDesc: string): unknown {
+  const t = typeDesc.toLowerCase();
+
+  if (t.includes("boolean") || t === "bool") return true;
+  if (t.includes("int") || t.includes("number") || t.includes("float") || t.includes("decimal")) {
+    if (fieldName.toLowerCase().includes("id")) return 1;
+    if (fieldName.toLowerCase().includes("count") || fieldName.toLowerCase().includes("total")) return 42;
+    if (fieldName.toLowerCase().includes("price") || fieldName.toLowerCase().includes("amount")) return 9.99;
+    return 1;
+  }
+  if (t.includes("datetime") || t.includes("date") || t.includes("timestamp")) {
+    return "2024-01-15T10:30:00.000Z";
+  }
+  if (t.includes("[]") || t.includes("array") || t.includes("list")) return [];
+  if (t.includes("object") || t.includes("json") || t.includes("record")) return {};
+
+  // String heuristics by field name
+  const name = fieldName.toLowerCase();
+  if (name === "id" || name.endsWith("id")) return "abc123";
+  if (name.includes("email")) return "user@example.com";
+  if (name.includes("phone")) return "+1-555-0100";
+  if (name.includes("url") || name.includes("image") || name.includes("avatar")) return "https://example.com/sample.jpg";
+  if (name.includes("token") || name.includes("secret")) return "mock-token-xyz";
+  if (name.includes("name")) return "Example Name";
+  if (name.includes("title")) return "Example Title";
+  if (name.includes("description") || name.includes("content") || name.includes("body")) return "Example description text";
+  if (name.includes("status")) return "active";
+  if (name.includes("type") || name.includes("role")) return "default";
+  if (name.includes("code")) return "CODE001";
+
+  return `example_${fieldName}`;
+}
+
+function buildFixtureObject(fields: FieldMap): Record<string, unknown> {
+  const obj: Record<string, unknown> = {};
+  for (const [name, type] of Object.entries(fields)) {
+    obj[name] = typeToFixture(name, type);
+  }
+  return obj;
+}
+
+/**
+ * Build a fixture response object for an endpoint.
+ * For endpoints without explicit response schemas, generate minimal fixtures from model context.
+ */
+export function buildEndpointFixture(endpoint: ApiEndpoint, dsl: SpecDSL): unknown {
+  const method = endpoint.method;
+  const status = endpoint.successStatus;
+
+  // DELETE with 204 → no body
+  if (status === 204) return null;
+
+  // Try to derive fixture from model names mentioned in endpoint description
+  const descLower = endpoint.description.toLowerCase();
+  const matchedModel = dsl.models.find((m) =>
+    descLower.includes(m.name.toLowerCase())
+  );
+
+  if (matchedModel) {
+    const fields: FieldMap = {};
+    for (const f of matchedModel.fields) {
+      fields[f.name] = f.type;
+    }
+    const item = buildFixtureObject(fields);
+
+    // List endpoints return arrays
+    if (method === "GET" && (descLower.includes("list") || descLower.includes("all") || descLower.includes("paginate"))) {
+      return {
+        data: [item, { ...item, id: "def456" }],
+        total: 2,
+        page: 1,
+        pageSize: 10,
+      };
+    }
+    return { data: item };
+  }
+
+  // Fallback based on method
+  if (method === "POST") return { data: { id: "abc123", createdAt: "2024-01-15T10:30:00.000Z" } };
+  if (method === "GET") return { data: { id: "abc123" } };
+  return { success: true };
+}