@contractspec/bundle.workspace 1.46.1 → 1.47.0

package/dist/services/ci-check/utils.mjs

@@ -0,0 +1,76 @@
+//#region src/services/ci-check/utils.ts
+/**
+* Create a category summary from issues.
+*/
+function createCategorySummary(category, issues, durationMs) {
+	const categoryLabels = {
+		structure: "Spec Structure Validation",
+		integrity: "Contract Integrity Analysis",
+		deps: "Dependency Analysis",
+		doctor: "Installation Health",
+		handlers: "Handler Implementation",
+		tests: "Test Coverage",
+		"test-refs": "Test Reference Validation",
+		coverage: "Coverage Verification",
+		implementation: "Implementation Verification",
+		layers: "Contract Layers Validation",
+		drift: "Drift Detection"
+	};
+	const errors = issues.filter((i) => i.severity === "error").length;
+	const warnings = issues.filter((i) => i.severity === "warning").length;
+	const notes = issues.filter((i) => i.severity === "note").length;
+	return {
+		category,
+		label: categoryLabels[category],
+		errors,
+		warnings,
+		notes,
+		passed: errors === 0,
+		durationMs
+	};
+}
+/**
+* Get git information if available.
+*/
+async function getGitInfo(fs) {
+	try {
+		const gitHeadPath = ".git/HEAD";
+		if (!await fs.exists(gitHeadPath)) return {};
+		const headContent = await fs.readFile(gitHeadPath);
+		const refMatch = headContent.match(/^ref: (.+)$/m);
+		if (refMatch) {
+			const branch = refMatch[1]?.replace("refs/heads/", "");
+			const refPath = `.git/${refMatch[1]}`;
+			if (await fs.exists(refPath)) return {
+				commitSha: (await fs.readFile(refPath)).trim(),
+				branch
+			};
+			return { branch };
+		}
+		return { commitSha: headContent.trim() };
+	} catch {
+		return {};
+	}
+}
+/**
+* Determine which checks to run based on options.
+*/
+function getChecksToRun(options) {
+	const allCategories = [
+		"structure",
+		"integrity",
+		"deps",
+		"doctor"
+	];
+	if (options.checkHandlers) allCategories.push("handlers");
+	if (options.checkTests) allCategories.push("tests");
+	if (options.implementation) allCategories.push("implementation");
+	if (options.checkDrift) allCategories.push("drift");
+	if (options.checks && options.checks.length > 0) return options.checks;
+	if (options.skip && options.skip.length > 0) return allCategories.filter((c) => !options.skip?.includes(c));
+	return allCategories;
+}
+
+//#endregion
+export { createCategorySummary, getChecksToRun, getGitInfo };
+//# sourceMappingURL=utils.mjs.map

package/dist/services/ci-check/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../src/services/ci-check/utils.ts"],"sourcesContent":["/**\n * CI check utilities.\n */\n\nimport type { FsAdapter } from '../../ports/fs';\nimport type { CICheckCategory, CICheckCategorySummary, CIIssue } from './types';\n\n/**\n * Create a category summary from issues.\n */\nexport function createCategorySummary(\n  category: CICheckCategory,\n  issues: CIIssue[],\n  durationMs: number\n): CICheckCategorySummary {\n  const categoryLabels: Record<CICheckCategory, string> = {\n    structure: 'Spec Structure Validation',\n    integrity: 'Contract Integrity Analysis',\n    deps: 'Dependency Analysis',\n    doctor: 'Installation Health',\n    handlers: 'Handler Implementation',\n    tests: 'Test Coverage',\n    'test-refs': 'Test Reference Validation',\n    coverage: 'Coverage Verification',\n    implementation: 'Implementation Verification',\n    layers: 'Contract Layers Validation',\n    drift: 'Drift Detection',\n  };\n\n  const errors = issues.filter((i) => i.severity === 'error').length;\n  const warnings = issues.filter((i) => i.severity === 'warning').length;\n  const notes = issues.filter((i) => i.severity === 'note').length;\n\n  return {\n    category,\n    label: categoryLabels[category],\n    errors,\n    warnings,\n    notes,\n    passed: errors === 0,\n    durationMs,\n  };\n}\n\n/**\n * Get git information if available.\n */\nexport async function getGitInfo(\n  fs: FsAdapter\n): Promise<{ commitSha?: string; branch?: string }> {\n  try {\n    // Try to read from .git/HEAD and refs\n    const gitHeadPath = '.git/HEAD';\n    if (!(await fs.exists(gitHeadPath))) {\n      return {};\n    }\n\n    const headContent = await fs.readFile(gitHeadPath);\n    const refMatch = headContent.match(/^ref: (.+)$/m);\n\n    if (refMatch) {\n      const branch = refMatch[1]?.replace('refs/heads/', '');\n      const refPath = `.git/${refMatch[1]}`;\n\n      if (await fs.exists(refPath)) {\n        const commitSha = (await fs.readFile(refPath)).trim();\n        return { commitSha, branch };\n      }\n\n      return { branch };\n    }\n\n    // Detached HEAD - content is the SHA\n    const commitSha = headContent.trim();\n    return { commitSha };\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Determine which checks to run based on options.\n */\nexport function getChecksToRun(options: {\n  checkHandlers?: boolean;\n  checkTests?: boolean;\n  implementation?: unknown;\n  checkDrift?: boolean;\n  checks?: CICheckCategory[];\n  skip?: CICheckCategory[];\n}): CICheckCategory[] {\n  const allCategories: CICheckCategory[] = [\n    'structure',\n    'integrity',\n    'deps',\n    'doctor',\n  ];\n\n  // Add optional checks if explicitly requested\n  if (options.checkHandlers) {\n    allCategories.push('handlers');\n  }\n  if (options.checkTests) {\n    allCategories.push('tests');\n  }\n  if (options.implementation) {\n    allCategories.push('implementation');\n  }\n  if (options.checkDrift) {\n    allCategories.push('drift');\n  }\n\n  // If specific checks are requested, use those\n  if (options.checks && options.checks.length > 0) {\n    return options.checks;\n  }\n\n  // Otherwise, use all minus skipped\n  if (options.skip && options.skip.length > 0) {\n    return allCategories.filter((c) => !options.skip?.includes(c));\n  }\n\n  return allCategories;\n}\n"],"mappings":";;;;AAUA,SAAgB,sBACd,UACA,QACA,YACwB;CACxB,MAAM,iBAAkD;EACtD,WAAW;EACX,WAAW;EACX,MAAM;EACN,QAAQ;EACR,UAAU;EACV,OAAO;EACP,aAAa;EACb,UAAU;EACV,gBAAgB;EAChB,QAAQ;EACR,OAAO;EACR;CAED,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE,aAAa,QAAQ,CAAC;CAC5D,MAAM,WAAW,OAAO,QAAQ,MAAM,EAAE,aAAa,UAAU,CAAC;CAChE,MAAM,QAAQ,OAAO,QAAQ,MAAM,EAAE,aAAa,OAAO,CAAC;AAE1D,QAAO;EACL;EACA,OAAO,eAAe;EACtB;EACA;EACA;EACA,QAAQ,WAAW;EACnB;EACD;;;;;AAMH,eAAsB,WACpB,IACkD;AAClD,KAAI;EAEF,MAAM,cAAc;AACpB,MAAI,CAAE,MAAM,GAAG,OAAO,YAAY,CAChC,QAAO,EAAE;EAGX,MAAM,cAAc,MAAM,GAAG,SAAS,YAAY;EAClD,MAAM,WAAW,YAAY,MAAM,eAAe;AAElD,MAAI,UAAU;GACZ,MAAM,SAAS,SAAS,IAAI,QAAQ,eAAe,GAAG;GACtD,MAAM,UAAU,QAAQ,SAAS;AAEjC,OAAI,MAAM,GAAG,OAAO,QAAQ,CAE1B,QAAO;IAAE,YADU,MAAM,GAAG,SAAS,QAAQ,EAAE,MAAM;IACjC;IAAQ;AAG9B,UAAO,EAAE,QAAQ;;AAKnB,SAAO,EAAE,WADS,YAAY,MAAM,EAChB;SACd;AACN,SAAO,EAAE;;;;;;AAOb,SAAgB,eAAe,SAOT;CACpB,MAAM,gBAAmC;EACvC;EACA;EACA;EACA;EACD;AAGD,KAAI,QAAQ,cACV,eAAc,KAAK,WAAW;AAEhC,KAAI,QAAQ,WACV,eAAc,KAAK,QAAQ;AAE7B,KAAI,QAAQ,eACV,eAAc,KAAK,iBAAiB;AAEtC,KAAI,QAAQ,WACV,eAAc,KAAK,QAAQ;AAI7B,KAAI,QAAQ,UAAU,QAAQ,OAAO,SAAS,EAC5C,QAAO,QAAQ;AAIjB,KAAI,QAAQ,QAAQ,QAAQ,KAAK,SAAS,EACxC,QAAO,cAAc,QAAQ,MAAM,CAAC,QAAQ,MAAM,SAAS,EAAE,CAAC;AAGhE,QAAO"}

package/dist/services/clean.d.mts

@@ -0,0 +1,41 @@
+import { FsAdapter } from "../ports/fs.mjs";
+import { LoggerAdapter } from "../ports/logger.mjs";
+
+//#region src/services/clean.d.ts
+
+interface CleanOptions {
+  /**
+   * When true, only remove known build artifact directories and known generated
+   * suffixes (safe-by-default).
+   */
+  generatedOnly?: boolean;
+  /**
+   * Skip deletions; just report.
+   */
+  dryRun?: boolean;
+  /**
+   * Only delete files older than this many days.
+   */
+  olderThanDays?: number;
+  /**
+   * Output directory used for generated artifacts (handlers/components/forms).
+   */
+  outputDir?: string;
+}
+interface CleanResult {
+  removed: {
+    path: string;
+    size: number;
+  }[];
+  skipped: {
+    path: string;
+    reason: string;
+  }[];
+}
+declare function cleanArtifacts(adapters: {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}, options?: CleanOptions): Promise<CleanResult>;
+//#endregion
+export { CleanOptions, CleanResult, cleanArtifacts };
+//# sourceMappingURL=clean.d.mts.map

package/dist/services/clean.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.mts","names":[],"sources":["../../src/services/clean.ts"],"sourcesContent":[],"mappings":";;;;;AAmCkB,UA1BD,YAAA,CA0BC;EAAmB;;;;EAE3B,aAAA,CAAA,EAAA,OAAA;;;;;;;;;;;;;;UARO,WAAA;;;;;;;;;;iBAKK,cAAA;MACJ;UAAmB;aAC1B,eACR,QAAQ"}

package/dist/services/clean.mjs

@@ -0,0 +1,72 @@
+//#region src/services/clean.ts
+async function cleanArtifacts(adapters, options = {}) {
+	const { fs, logger } = adapters;
+	const outputDir = (options.outputDir ?? "./src").replace(/\\/g, "/");
+	const basePatterns = [
+		"generated/**",
+		"dist/**",
+		".turbo/**"
+	];
+	const outputDirPatterns = [
+		`${outputDir}/handlers/**/*.handler.ts`,
+		`${outputDir}/handlers/**/*.handler.test.ts`,
+		`${outputDir}/components/**/*.tsx`,
+		`${outputDir}/components/**/*.test.tsx`,
+		`${outputDir}/forms/**/*.form.tsx`,
+		`${outputDir}/forms/**/*.form.test.tsx`,
+		`${outputDir}/**/*.runner.ts`,
+		`${outputDir}/**/*.renderer.tsx`
+	];
+	const patterns = options.generatedOnly ? [...basePatterns, ...outputDirPatterns] : [
+		...basePatterns,
+		"**/*.generated.ts",
+		"**/*.generated.js",
+		"**/*.generated.d.ts",
+		...outputDirPatterns
+	];
+	const candidates = await fs.glob({
+		patterns,
+		ignore: ["node_modules/**"]
+	});
+	const removed = [];
+	const skipped = [];
+	for (const p of candidates) try {
+		const st = await fs.stat(p);
+		const ageDays = (Date.now() - st.mtime.getTime()) / (1e3 * 60 * 60 * 24);
+		if (typeof options.olderThanDays === "number" && ageDays < options.olderThanDays) {
+			skipped.push({
+				path: p,
+				reason: `younger_than_${options.olderThanDays}_days`
+			});
+			continue;
+		}
+		if (options.dryRun) logger.info("[dry-run] clean would remove", {
+			path: p,
+			size: st.size
+		});
+		else {
+			await fs.remove(p);
+			logger.info("clean.removed", {
+				path: p,
+				size: st.size
+			});
+		}
+		removed.push({
+			path: p,
+			size: st.size
+		});
+	} catch (error) {
+		skipped.push({
+			path: p,
+			reason: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		removed,
+		skipped
+	};
+}
+
+//#endregion
+export { cleanArtifacts };
+//# sourceMappingURL=clean.mjs.map

package/dist/services/clean.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.mjs","names":[],"sources":["../../src/services/clean.ts"],"sourcesContent":["/**\n * Clean service.\n *\n * Safe-by-default cleanup of generated artifacts.\n */\n\nimport type { FsAdapter } from '../ports/fs';\nimport type { LoggerAdapter } from '../ports/logger';\n\nexport interface CleanOptions {\n  /**\n   * When true, only remove known build artifact directories and known generated\n   * suffixes (safe-by-default).\n   */\n  generatedOnly?: boolean;\n  /**\n   * Skip deletions; just report.\n   */\n  dryRun?: boolean;\n  /**\n   * Only delete files older than this many days.\n   */\n  olderThanDays?: number;\n  /**\n   * Output directory used for generated artifacts (handlers/components/forms).\n   */\n  outputDir?: string;\n}\n\nexport interface CleanResult {\n  removed: { path: string; size: number }[];\n  skipped: { path: string; reason: string }[];\n}\n\nexport async function cleanArtifacts(\n  adapters: { fs: FsAdapter; logger: LoggerAdapter },\n  options: CleanOptions = {}\n): Promise<CleanResult> {\n  const { fs, logger } = adapters;\n  const outputDir = (options.outputDir ?? './src').replace(/\\\\/g, '/');\n\n  const basePatterns = ['generated/**', 'dist/**', '.turbo/**'];\n\n  const outputDirPatterns = [\n    `${outputDir}/handlers/**/*.handler.ts`,\n    `${outputDir}/handlers/**/*.handler.test.ts`,\n    `${outputDir}/components/**/*.tsx`,\n    `${outputDir}/components/**/*.test.tsx`,\n    `${outputDir}/forms/**/*.form.tsx`,\n    `${outputDir}/forms/**/*.form.test.tsx`,\n    `${outputDir}/**/*.runner.ts`,\n    `${outputDir}/**/*.renderer.tsx`,\n  ];\n\n  const patterns = options.generatedOnly\n    ? [...basePatterns, ...outputDirPatterns]\n    : [\n        ...basePatterns,\n        '**/*.generated.ts',\n        '**/*.generated.js',\n        '**/*.generated.d.ts',\n        ...outputDirPatterns,\n      ];\n\n  const candidates = await fs.glob({\n    patterns,\n    ignore: ['node_modules/**'],\n  });\n\n  const removed: { path: string; size: number }[] = [];\n  const skipped: { path: string; reason: string }[] = [];\n\n  for (const p of candidates) {\n    try {\n      const st = await fs.stat(p);\n      const ageDays = (Date.now() - st.mtime.getTime()) / (1000 * 60 * 60 * 24);\n      if (\n        typeof options.olderThanDays === 'number' &&\n        ageDays < options.olderThanDays\n      ) {\n        skipped.push({\n          path: p,\n          reason: `younger_than_${options.olderThanDays}_days`,\n        });\n        continue;\n      }\n\n      if (options.dryRun) {\n        logger.info('[dry-run] clean would remove', { path: p, size: st.size });\n      } else {\n        await fs.remove(p);\n        logger.info('clean.removed', { path: p, size: st.size });\n      }\n      removed.push({ path: p, size: st.size });\n    } catch (error) {\n      skipped.push({\n        path: p,\n        reason: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  return { removed, skipped };\n}\n"],"mappings":";AAkCA,eAAsB,eACpB,UACA,UAAwB,EAAE,EACJ;CACtB,MAAM,EAAE,IAAI,WAAW;CACvB,MAAM,aAAa,QAAQ,aAAa,SAAS,QAAQ,OAAO,IAAI;CAEpE,MAAM,eAAe;EAAC;EAAgB;EAAW;EAAY;CAE7D,MAAM,oBAAoB;EACxB,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACb,GAAG,UAAU;EACd;CAED,MAAM,WAAW,QAAQ,gBACrB,CAAC,GAAG,cAAc,GAAG,kBAAkB,GACvC;EACE,GAAG;EACH;EACA;EACA;EACA,GAAG;EACJ;CAEL,MAAM,aAAa,MAAM,GAAG,KAAK;EAC/B;EACA,QAAQ,CAAC,kBAAkB;EAC5B,CAAC;CAEF,MAAM,UAA4C,EAAE;CACpD,MAAM,UAA8C,EAAE;AAEtD,MAAK,MAAM,KAAK,WACd,KAAI;EACF,MAAM,KAAK,MAAM,GAAG,KAAK,EAAE;EAC3B,MAAM,WAAW,KAAK,KAAK,GAAG,GAAG,MAAM,SAAS,KAAK,MAAO,KAAK,KAAK;AACtE,MACE,OAAO,QAAQ,kBAAkB,YACjC,UAAU,QAAQ,eAClB;AACA,WAAQ,KAAK;IACX,MAAM;IACN,QAAQ,gBAAgB,QAAQ,cAAc;IAC/C,CAAC;AACF;;AAGF,MAAI,QAAQ,OACV,QAAO,KAAK,gCAAgC;GAAE,MAAM;GAAG,MAAM,GAAG;GAAM,CAAC;OAClE;AACL,SAAM,GAAG,OAAO,EAAE;AAClB,UAAO,KAAK,iBAAiB;IAAE,MAAM;IAAG,MAAM,GAAG;IAAM,CAAC;;AAE1D,UAAQ,KAAK;GAAE,MAAM;GAAG,MAAM,GAAG;GAAM,CAAC;UACjC,OAAO;AACd,UAAQ,KAAK;GACX,MAAM;GACN,QAAQ,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC/D,CAAC;;AAIN,QAAO;EAAE;EAAS;EAAS"}

package/dist/services/config.d.mts

@@ -0,0 +1,16 @@
+import { FsAdapter } from "../ports/fs.mjs";
+import { WorkspaceConfig } from "@contractspec/module.workspace";
+
+//#region src/services/config.d.ts
+
+/**
+ * Load workspace configuration from .contractsrc.json.
+ */
+declare function loadWorkspaceConfig(fs: FsAdapter, cwd?: string): Promise<WorkspaceConfig>;
+/**
+ * Get API key for the configured provider.
+ */
+declare function getApiKey(provider: WorkspaceConfig['aiProvider']): string | undefined;
+//#endregion
+export { getApiKey, loadWorkspaceConfig };
+//# sourceMappingURL=config.d.mts.map

package/dist/services/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../src/services/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAoCU,iBAHY,mBAAA,CAGZ,EAAA,EAFJ,SAEI,EAAA,GAAA,CAAA,EAAA,MAAA,CAAA,EAAP,OAAO,CAAC,eAAD,CAAA;AAoBV;;;iBAAgB,SAAA,WACJ"}

package/dist/services/config.mjs

@@ -0,0 +1,63 @@
+import { DEFAULT_WORKSPACE_CONFIG } from "@contractspec/module.workspace";
+import * as z$1 from "zod";
+
+//#region src/services/config.ts
+/**
+* Workspace configuration service.
+*/
+const ConfigSchema = z$1.object({
+	aiProvider: z$1.enum([
+		"claude",
+		"openai",
+		"ollama",
+		"custom"
+	]).default("claude"),
+	aiModel: z$1.string().optional(),
+	agentMode: z$1.enum([
+		"simple",
+		"cursor",
+		"claude-code",
+		"openai-codex"
+	]).default("simple"),
+	customEndpoint: z$1.url().nullable().optional(),
+	customApiKey: z$1.string().nullable().optional(),
+	outputDir: z$1.string().default("./src"),
+	conventions: z$1.object({
+		operations: z$1.string().default("interactions/commands|queries"),
+		events: z$1.string().default("events"),
+		presentations: z$1.string().default("presentations"),
+		forms: z$1.string().default("forms")
+	}),
+	defaultOwners: z$1.array(z$1.string()).default([]),
+	defaultTags: z$1.array(z$1.string()).default([])
+});
+/**
+* Load workspace configuration from .contractsrc.json.
+*/
+async function loadWorkspaceConfig(fs, cwd) {
+	const configPath = fs.join(cwd ?? ".", ".contractsrc.json");
+	if (!await fs.exists(configPath)) return DEFAULT_WORKSPACE_CONFIG;
+	try {
+		const content = await fs.readFile(configPath);
+		const parsed = JSON.parse(content);
+		return ConfigSchema.parse(parsed);
+	} catch {
+		return DEFAULT_WORKSPACE_CONFIG;
+	}
+}
+/**
+* Get API key for the configured provider.
+*/
+function getApiKey(provider) {
+	switch (provider) {
+		case "claude": return process.env["ANTHROPIC_API_KEY"];
+		case "openai": return process.env["OPENAI_API_KEY"];
+		case "custom": return process.env["CONTRACTSPEC_LLM_API_KEY"];
+		case "ollama": return;
+		default: return;
+	}
+}
+
+//#endregion
+export { getApiKey, loadWorkspaceConfig };
+//# sourceMappingURL=config.mjs.map

package/dist/services/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":["z"],"sources":["../../src/services/config.ts"],"sourcesContent":["/**\n * Workspace configuration service.\n */\n\nimport * as z from 'zod';\nimport type { WorkspaceConfig } from '@contractspec/module.workspace';\nimport { DEFAULT_WORKSPACE_CONFIG } from '@contractspec/module.workspace';\nimport type { FsAdapter } from '../ports/fs';\n\nconst ConfigSchema = z.object({\n  aiProvider: z\n    .enum(['claude', 'openai', 'ollama', 'custom'])\n    .default('claude'),\n  aiModel: z.string().optional(),\n  agentMode: z\n    .enum(['simple', 'cursor', 'claude-code', 'openai-codex'])\n    .default('simple'),\n  customEndpoint: z.url().nullable().optional(),\n  customApiKey: z.string().nullable().optional(),\n  outputDir: z.string().default('./src'),\n  conventions: z.object({\n    operations: z.string().default('interactions/commands|queries'),\n    events: z.string().default('events'),\n    presentations: z.string().default('presentations'),\n    forms: z.string().default('forms'),\n  }),\n  defaultOwners: z.array(z.string()).default([]),\n  defaultTags: z.array(z.string()).default([]),\n});\n\n/**\n * Load workspace configuration from .contractsrc.json.\n */\nexport async function loadWorkspaceConfig(\n  fs: FsAdapter,\n  cwd?: string\n): Promise<WorkspaceConfig> {\n  const configPath = fs.join(cwd ?? '.', '.contractsrc.json');\n\n  const exists = await fs.exists(configPath);\n  if (!exists) {\n    return DEFAULT_WORKSPACE_CONFIG;\n  }\n\n  try {\n    const content = await fs.readFile(configPath);\n    const parsed = JSON.parse(content);\n    return ConfigSchema.parse(parsed) as WorkspaceConfig;\n  } catch {\n    return DEFAULT_WORKSPACE_CONFIG;\n  }\n}\n\n/**\n * Get API key for the configured provider.\n */\nexport function getApiKey(\n  provider: WorkspaceConfig['aiProvider']\n): string | undefined {\n  switch (provider) {\n    case 'claude':\n      return process.env['ANTHROPIC_API_KEY'];\n    case 'openai':\n      return process.env['OPENAI_API_KEY'];\n    case 'custom':\n      return process.env['CONTRACTSPEC_LLM_API_KEY'];\n    case 'ollama':\n      return undefined; // Ollama doesn't need API key for local\n    default:\n      return undefined;\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAM,eAAeA,IAAE,OAAO;CAC5B,YAAYA,IACT,KAAK;EAAC;EAAU;EAAU;EAAU;EAAS,CAAC,CAC9C,QAAQ,SAAS;CACpB,SAASA,IAAE,QAAQ,CAAC,UAAU;CAC9B,WAAWA,IACR,KAAK;EAAC;EAAU;EAAU;EAAe;EAAe,CAAC,CACzD,QAAQ,SAAS;CACpB,gBAAgBA,IAAE,KAAK,CAAC,UAAU,CAAC,UAAU;CAC7C,cAAcA,IAAE,QAAQ,CAAC,UAAU,CAAC,UAAU;CAC9C,WAAWA,IAAE,QAAQ,CAAC,QAAQ,QAAQ;CACtC,aAAaA,IAAE,OAAO;EACpB,YAAYA,IAAE,QAAQ,CAAC,QAAQ,gCAAgC;EAC/D,QAAQA,IAAE,QAAQ,CAAC,QAAQ,SAAS;EACpC,eAAeA,IAAE,QAAQ,CAAC,QAAQ,gBAAgB;EAClD,OAAOA,IAAE,QAAQ,CAAC,QAAQ,QAAQ;EACnC,CAAC;CACF,eAAeA,IAAE,MAAMA,IAAE,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;CAC9C,aAAaA,IAAE,MAAMA,IAAE,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC;CAC7C,CAAC;;;;AAKF,eAAsB,oBACpB,IACA,KAC0B;CAC1B,MAAM,aAAa,GAAG,KAAK,OAAO,KAAK,oBAAoB;AAG3D,KAAI,CADW,MAAM,GAAG,OAAO,WAAW,CAExC,QAAO;AAGT,KAAI;EACF,MAAM,UAAU,MAAM,GAAG,SAAS,WAAW;EAC7C,MAAM,SAAS,KAAK,MAAM,QAAQ;AAClC,SAAO,aAAa,MAAM,OAAO;SAC3B;AACN,SAAO;;;;;;AAOX,SAAgB,UACd,UACoB;AACpB,SAAQ,UAAR;EACE,KAAK,SACH,QAAO,QAAQ,IAAI;EACrB,KAAK,SACH,QAAO,QAAQ,IAAI;EACrB,KAAK,SACH,QAAO,QAAQ,IAAI;EACrB,KAAK,SACH;EACF,QACE"}

package/dist/services/coverage/parsers/index.mjs

@@ -0,0 +1,34 @@
+import { parseIstanbulCoverage } from "./istanbul-parser.mjs";
+
+//#region src/services/coverage/parsers/index.ts
+/**
+* Create a parser for the specified format.
+*
+* @param format - The coverage report format
+* @returns A parser for the format
+*/
+function createParser(format) {
+	switch (format) {
+		case "istanbul": return { parse: parseIstanbulCoverage };
+		case "lcov": throw new Error("LCOV format not yet supported");
+		case "cobertura": throw new Error("Cobertura format not yet supported");
+		default: throw new Error(`Unknown coverage format: ${format}`);
+	}
+}
+/**
+* Detect the coverage format from a file path or content.
+*
+* @param path - The file path
+* @param content - Optional file content
+* @returns The detected format
+*/
+function detectFormat(path, content) {
+	if (path.endsWith(".json") || path.includes("coverage-final.json")) return "istanbul";
+	if (path.endsWith(".lcov") || path.includes("lcov.info")) return "lcov";
+	if (path.endsWith(".xml") && content?.includes("cobertura")) return "cobertura";
+	return "istanbul";
+}
+
+//#endregion
+export { createParser, detectFormat };
+//# sourceMappingURL=index.mjs.map

package/dist/services/coverage/parsers/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/coverage/parsers/index.ts"],"sourcesContent":["/**\n * Coverage report parsers.\n *\n * Parses coverage reports from various test runners into a unified format.\n */\n\nimport type { CoverageReport } from '../types';\nimport { parseIstanbulCoverage } from './istanbul-parser';\n\n/**\n * Supported coverage report formats.\n */\nexport type CoverageFormat = 'istanbul' | 'lcov' | 'cobertura';\n\n/**\n * Parser interface for coverage reports.\n */\nexport interface CoverageParser {\n  /**\n   * Parse a coverage report file or directory.\n   *\n   * @param content - The file content or directory path\n   * @returns Parsed coverage report\n   */\n  parse(content: string): CoverageReport;\n}\n\n/**\n * Create a parser for the specified format.\n *\n * @param format - The coverage report format\n * @returns A parser for the format\n */\nexport function createParser(format: CoverageFormat): CoverageParser {\n  switch (format) {\n    case 'istanbul':\n      return { parse: parseIstanbulCoverage };\n    case 'lcov':\n      // LCOV support can be added later\n      throw new Error('LCOV format not yet supported');\n    case 'cobertura':\n      // Cobertura support can be added later\n      throw new Error('Cobertura format not yet supported');\n    default:\n      throw new Error(`Unknown coverage format: ${format}`);\n  }\n}\n\n/**\n * Detect the coverage format from a file path or content.\n *\n * @param path - The file path\n * @param content - Optional file content\n * @returns The detected format\n */\nexport function detectFormat(path: string, content?: string): CoverageFormat {\n  // Check file extension first\n  if (path.endsWith('.json') || path.includes('coverage-final.json')) {\n    return 'istanbul';\n  }\n  if (path.endsWith('.lcov') || path.includes('lcov.info')) {\n    return 'lcov';\n  }\n  if (path.endsWith('.xml') && content?.includes('cobertura')) {\n    return 'cobertura';\n  }\n\n  // Default to Istanbul JSON\n  return 'istanbul';\n}\n\nexport { parseIstanbulCoverage } from './istanbul-parser';\n"],"mappings":";;;;;;;;;AAiCA,SAAgB,aAAa,QAAwC;AACnE,SAAQ,QAAR;EACE,KAAK,WACH,QAAO,EAAE,OAAO,uBAAuB;EACzC,KAAK,OAEH,OAAM,IAAI,MAAM,gCAAgC;EAClD,KAAK,YAEH,OAAM,IAAI,MAAM,qCAAqC;EACvD,QACE,OAAM,IAAI,MAAM,4BAA4B,SAAS;;;;;;;;;;AAW3D,SAAgB,aAAa,MAAc,SAAkC;AAE3E,KAAI,KAAK,SAAS,QAAQ,IAAI,KAAK,SAAS,sBAAsB,CAChE,QAAO;AAET,KAAI,KAAK,SAAS,QAAQ,IAAI,KAAK,SAAS,YAAY,CACtD,QAAO;AAET,KAAI,KAAK,SAAS,OAAO,IAAI,SAAS,SAAS,YAAY,CACzD,QAAO;AAIT,QAAO"}

package/dist/services/coverage/parsers/istanbul-parser.mjs

@@ -0,0 +1,108 @@
+//#region src/services/coverage/parsers/istanbul-parser.ts
+function calculatePct(covered, total) {
+	if (total === 0) return 100;
+	return Math.round(covered / total * 100 * 100) / 100;
+}
+/**
+* Parse Istanbul JSON coverage report.
+*
+* @param content - The JSON content as a string
+* @returns Parsed coverage report
+*/
+function parseIstanbulCoverage(content) {
+	const data = JSON.parse(content);
+	const files = /* @__PURE__ */ new Map();
+	let totalStatements = 0;
+	let coveredStatements = 0;
+	let totalBranches = 0;
+	let coveredBranches = 0;
+	let totalFunctions = 0;
+	let coveredFunctions = 0;
+	let totalLines = 0;
+	let coveredLines = 0;
+	for (const [filePath, fileCoverage] of Object.entries(data)) {
+		const parsed = parseFileCoverage(filePath, fileCoverage);
+		files.set(filePath, parsed);
+		totalStatements += parsed.statements.total;
+		coveredStatements += parsed.statements.covered;
+		totalBranches += parsed.branches.total;
+		coveredBranches += parsed.branches.covered;
+		totalFunctions += parsed.functions.total;
+		coveredFunctions += parsed.functions.covered;
+		totalLines += parsed.lines.total;
+		coveredLines += parsed.lines.covered;
+	}
+	return {
+		files,
+		total: {
+			statements: {
+				covered: coveredStatements,
+				total: totalStatements,
+				pct: calculatePct(coveredStatements, totalStatements)
+			},
+			branches: {
+				covered: coveredBranches,
+				total: totalBranches,
+				pct: calculatePct(coveredBranches, totalBranches)
+			},
+			functions: {
+				covered: coveredFunctions,
+				total: totalFunctions,
+				pct: calculatePct(coveredFunctions, totalFunctions)
+			},
+			lines: {
+				covered: coveredLines,
+				total: totalLines,
+				pct: calculatePct(coveredLines, totalLines)
+			}
+		}
+	};
+}
+/**
+* Parse coverage data for a single file.
+*/
+function parseFileCoverage(path, coverage) {
+	const statementTotal = Object.keys(coverage.statementMap).length;
+	const statementCovered = Object.values(coverage.s).filter((c) => c > 0).length;
+	const functionTotal = Object.keys(coverage.fnMap).length;
+	const functionCovered = Object.values(coverage.f).filter((c) => c > 0).length;
+	let branchTotal = 0;
+	let branchCovered = 0;
+	for (const branch of Object.values(coverage.b)) {
+		branchTotal += branch.length;
+		branchCovered += branch.filter((c) => c > 0).length;
+	}
+	const lineSet = /* @__PURE__ */ new Set();
+	const coveredLineSet = /* @__PURE__ */ new Set();
+	for (const [id, location] of Object.entries(coverage.statementMap)) for (let line = location.start.line; line <= location.end.line; line++) {
+		lineSet.add(line);
+		if ((coverage.s[id] ?? 0) > 0) coveredLineSet.add(line);
+	}
+	return {
+		path,
+		statements: {
+			covered: statementCovered,
+			total: statementTotal,
+			pct: calculatePct(statementCovered, statementTotal)
+		},
+		branches: {
+			covered: branchCovered,
+			total: branchTotal,
+			pct: calculatePct(branchCovered, branchTotal)
+		},
+		functions: {
+			covered: functionCovered,
+			total: functionTotal,
+			pct: calculatePct(functionCovered, functionTotal)
+		},
+		lines: {
+			covered: coveredLineSet.size,
+			total: lineSet.size,
+			pct: calculatePct(coveredLineSet.size, lineSet.size)
+		}
+	};
+}
+
+//#endregion
+export { parseIstanbulCoverage };
+//# sourceMappingURL=istanbul-parser.mjs.map

package/dist/services/coverage/parsers/istanbul-parser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"istanbul-parser.mjs","names":[],"sources":["../../../../src/services/coverage/parsers/istanbul-parser.ts"],"sourcesContent":["/**\n * Istanbul JSON coverage report parser.\n *\n * Parses the standard Istanbul JSON format used by:\n * - Vitest (with coverage.reporter = ['json'])\n * - Bun (with --coverage)\n * - Jest (with collectCoverage and json reporter)\n * - NYC (directly)\n */\n\nimport type { CoverageReport, FileCoverage, CoverageData } from '../types';\n\nfunction calculatePct(covered: number, total: number): number {\n  if (total === 0) return 100;\n  return Math.round((covered / total) * 100 * 100) / 100;\n}\n\n/**\n * Istanbul JSON coverage format.\n */\ntype IstanbulCoverage = Record<string, IstanbulFileCoverage>;\n\ninterface IstanbulFileCoverage {\n  path: string;\n  statementMap: Record<string, IstanbulLocation>;\n  fnMap: Record<string, IstanbulFunction>;\n  branchMap: Record<string, IstanbulBranch>;\n  s: Record<string, number>; // statement execution counts\n  f: Record<string, number>; // function execution counts\n  b: Record<string, number[]>; // branch execution counts\n}\n\ninterface IstanbulLocation {\n  start: { line: number; column: number };\n  end: { line: number; column: number };\n}\n\ninterface IstanbulFunction {\n  name: string;\n  decl: IstanbulLocation;\n  loc: IstanbulLocation;\n  line: number;\n}\n\ninterface IstanbulBranch {\n  type: string;\n  loc: IstanbulLocation;\n  locations: IstanbulLocation[];\n  line: number;\n}\n\n/**\n * Parse Istanbul JSON coverage report.\n *\n * @param content - The JSON content as a string\n * @returns Parsed coverage report\n */\nexport function parseIstanbulCoverage(content: string): CoverageReport {\n  const data: IstanbulCoverage = JSON.parse(content);\n  const files = new Map<string, FileCoverage>();\n\n  // Aggregate totals\n  let totalStatements = 0;\n  let coveredStatements = 0;\n  let totalBranches = 0;\n  let coveredBranches = 0;\n  let totalFunctions = 0;\n  let coveredFunctions = 0;\n  let totalLines = 0;\n  let coveredLines = 0;\n\n  for (const [filePath, fileCoverage] of Object.entries(data)) {\n    const parsed = parseFileCoverage(filePath, fileCoverage);\n    files.set(filePath, parsed);\n\n    // Accumulate totals\n    totalStatements += parsed.statements.total;\n    coveredStatements += parsed.statements.covered;\n    totalBranches += parsed.branches.total;\n    coveredBranches += parsed.branches.covered;\n    totalFunctions += parsed.functions.total;\n    coveredFunctions += parsed.functions.covered;\n    totalLines += parsed.lines.total;\n    coveredLines += parsed.lines.covered;\n  }\n\n  const total: CoverageData = {\n    statements: {\n      covered: coveredStatements,\n      total: totalStatements,\n      pct: calculatePct(coveredStatements, totalStatements),\n    },\n    branches: {\n      covered: coveredBranches,\n      total: totalBranches,\n      pct: calculatePct(coveredBranches, totalBranches),\n    },\n    functions: {\n      covered: coveredFunctions,\n      total: totalFunctions,\n      pct: calculatePct(coveredFunctions, totalFunctions),\n    },\n    lines: {\n      covered: coveredLines,\n      total: totalLines,\n      pct: calculatePct(coveredLines, totalLines),\n    },\n  };\n\n  return { files, total };\n}\n\n/**\n * Parse coverage data for a single file.\n */\nfunction parseFileCoverage(\n  path: string,\n  coverage: IstanbulFileCoverage\n): FileCoverage {\n  // Count statements\n  const statementTotal = Object.keys(coverage.statementMap).length;\n  const statementCovered = Object.values(coverage.s).filter(\n    (c) => c > 0\n  ).length;\n\n  // Count functions\n  const functionTotal = Object.keys(coverage.fnMap).length;\n  const functionCovered = Object.values(coverage.f).filter((c) => c > 0).length;\n\n  // Count branches (each branch can have multiple paths)\n  let branchTotal = 0;\n  let branchCovered = 0;\n  for (const branch of Object.values(coverage.b)) {\n    branchTotal += branch.length;\n    branchCovered += branch.filter((c) => c > 0).length;\n  }\n\n  // Calculate line coverage from statement map\n  const lineSet = new Set<number>();\n  const coveredLineSet = new Set<number>();\n\n  for (const [id, location] of Object.entries(coverage.statementMap)) {\n    for (let line = location.start.line; line <= location.end.line; line++) {\n      lineSet.add(line);\n      if ((coverage.s[id] ?? 0) > 0) {\n        coveredLineSet.add(line);\n      }\n    }\n  }\n\n  return {\n    path,\n    statements: {\n      covered: statementCovered,\n      total: statementTotal,\n      pct: calculatePct(statementCovered, statementTotal),\n    },\n    branches: {\n      covered: branchCovered,\n      total: branchTotal,\n      pct: calculatePct(branchCovered, branchTotal),\n    },\n    functions: {\n      covered: functionCovered,\n      total: functionTotal,\n      pct: calculatePct(functionCovered, functionTotal),\n    },\n    lines: {\n      covered: coveredLineSet.size,\n      total: lineSet.size,\n      pct: calculatePct(coveredLineSet.size, lineSet.size),\n    },\n  };\n}\n"],"mappings":";AAYA,SAAS,aAAa,SAAiB,OAAuB;AAC5D,KAAI,UAAU,EAAG,QAAO;AACxB,QAAO,KAAK,MAAO,UAAU,QAAS,MAAM,IAAI,GAAG;;;;;;;;AA2CrD,SAAgB,sBAAsB,SAAiC;CACrE,MAAM,OAAyB,KAAK,MAAM,QAAQ;CAClD,MAAM,wBAAQ,IAAI,KAA2B;CAG7C,IAAI,kBAAkB;CACtB,IAAI,oBAAoB;CACxB,IAAI,gBAAgB;CACpB,IAAI,kBAAkB;CACtB,IAAI,iBAAiB;CACrB,IAAI,mBAAmB;CACvB,IAAI,aAAa;CACjB,IAAI,eAAe;AAEnB,MAAK,MAAM,CAAC,UAAU,iBAAiB,OAAO,QAAQ,KAAK,EAAE;EAC3D,MAAM,SAAS,kBAAkB,UAAU,aAAa;AACxD,QAAM,IAAI,UAAU,OAAO;AAG3B,qBAAmB,OAAO,WAAW;AACrC,uBAAqB,OAAO,WAAW;AACvC,mBAAiB,OAAO,SAAS;AACjC,qBAAmB,OAAO,SAAS;AACnC,oBAAkB,OAAO,UAAU;AACnC,sBAAoB,OAAO,UAAU;AACrC,gBAAc,OAAO,MAAM;AAC3B,kBAAgB,OAAO,MAAM;;AA0B/B,QAAO;EAAE;EAAO,OAvBY;GAC1B,YAAY;IACV,SAAS;IACT,OAAO;IACP,KAAK,aAAa,mBAAmB,gBAAgB;IACtD;GACD,UAAU;IACR,SAAS;IACT,OAAO;IACP,KAAK,aAAa,iBAAiB,cAAc;IAClD;GACD,WAAW;IACT,SAAS;IACT,OAAO;IACP,KAAK,aAAa,kBAAkB,eAAe;IACpD;GACD,OAAO;IACL,SAAS;IACT,OAAO;IACP,KAAK,aAAa,cAAc,WAAW;IAC5C;GACF;EAEsB;;;;;AAMzB,SAAS,kBACP,MACA,UACc;CAEd,MAAM,iBAAiB,OAAO,KAAK,SAAS,aAAa,CAAC;CAC1D,MAAM,mBAAmB,OAAO,OAAO,SAAS,EAAE,CAAC,QAChD,MAAM,IAAI,EACZ,CAAC;CAGF,MAAM,gBAAgB,OAAO,KAAK,SAAS,MAAM,CAAC;CAClD,MAAM,kBAAkB,OAAO,OAAO,SAAS,EAAE,CAAC,QAAQ,MAAM,IAAI,EAAE,CAAC;CAGvE,IAAI,cAAc;CAClB,IAAI,gBAAgB;AACpB,MAAK,MAAM,UAAU,OAAO,OAAO,SAAS,EAAE,EAAE;AAC9C,iBAAe,OAAO;AACtB,mBAAiB,OAAO,QAAQ,MAAM,IAAI,EAAE,CAAC;;CAI/C,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,iCAAiB,IAAI,KAAa;AAExC,MAAK,MAAM,CAAC,IAAI,aAAa,OAAO,QAAQ,SAAS,aAAa,CAChE,MAAK,IAAI,OAAO,SAAS,MAAM,MAAM,QAAQ,SAAS,IAAI,MAAM,QAAQ;AACtE,UAAQ,IAAI,KAAK;AACjB,OAAK,SAAS,EAAE,OAAO,KAAK,EAC1B,gBAAe,IAAI,KAAK;;AAK9B,QAAO;EACL;EACA,YAAY;GACV,SAAS;GACT,OAAO;GACP,KAAK,aAAa,kBAAkB,eAAe;GACpD;EACD,UAAU;GACR,SAAS;GACT,OAAO;GACP,KAAK,aAAa,eAAe,YAAY;GAC9C;EACD,WAAW;GACT,SAAS;GACT,OAAO;GACP,KAAK,aAAa,iBAAiB,cAAc;GAClD;EACD,OAAO;GACL,SAAS,eAAe;GACxB,OAAO,QAAQ;GACf,KAAK,aAAa,eAAe,MAAM,QAAQ,KAAK;GACrD;EACF"}

package/dist/services/coverage/validator.mjs

@@ -0,0 +1,55 @@
+//#region src/services/coverage/validator.ts
+/**
+* Validate coverage data against requirements.
+*
+* @param specKey - The spec key being validated
+* @param specVersion - The spec version
+* @param requirement - The coverage requirements from TestSpec
+* @param actual - The actual coverage data
+* @returns Validation result with pass/fail and details
+*/
+function validateCoverage(specKey, specVersion, requirement, actual) {
+	const failures = [];
+	if (requirement.statements !== void 0 && actual.statements.pct < requirement.statements) failures.push({
+		metric: "statements",
+		required: requirement.statements,
+		actual: actual.statements.pct,
+		message: `Statement coverage ${actual.statements.pct}% is below required ${requirement.statements}%`
+	});
+	if (requirement.branches !== void 0 && actual.branches.pct < requirement.branches) failures.push({
+		metric: "branches",
+		required: requirement.branches,
+		actual: actual.branches.pct,
+		message: `Branch coverage ${actual.branches.pct}% is below required ${requirement.branches}%`
+	});
+	if (requirement.functions !== void 0 && actual.functions.pct < requirement.functions) failures.push({
+		metric: "functions",
+		required: requirement.functions,
+		actual: actual.functions.pct,
+		message: `Function coverage ${actual.functions.pct}% is below required ${requirement.functions}%`
+	});
+	if (requirement.lines !== void 0 && actual.lines.pct < requirement.lines) failures.push({
+		metric: "lines",
+		required: requirement.lines,
+		actual: actual.lines.pct,
+		message: `Line coverage ${actual.lines.pct}% is below required ${requirement.lines}%`
+	});
+	if (requirement.mutations !== void 0) failures.push({
+		metric: "mutations",
+		required: requirement.mutations,
+		actual: 0,
+		message: `Mutation coverage required (${requirement.mutations}%) but mutation testing is not yet supported`
+	});
+	return {
+		specKey,
+		specVersion,
+		requirement,
+		actual,
+		passed: failures.length === 0,
+		failures
+	};
+}
+
+//#endregion
+export { validateCoverage };
+//# sourceMappingURL=validator.mjs.map

package/dist/services/coverage/validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.mjs","names":[],"sources":["../../../src/services/coverage/validator.ts"],"sourcesContent":["/**\n * Coverage validator.\n *\n * Validates actual coverage data against TestSpec.coverage requirements.\n */\n\nimport type { CoverageRequirement } from '@contractspec/lib.contracts';\nimport type {\n  CoverageData,\n  CoverageValidationResult,\n  CoverageFailure,\n  CoverageValidationSummary,\n} from './types';\n\n/**\n * Validate coverage data against requirements.\n *\n * @param specKey - The spec key being validated\n * @param specVersion - The spec version\n * @param requirement - The coverage requirements from TestSpec\n * @param actual - The actual coverage data\n * @returns Validation result with pass/fail and details\n */\nexport function validateCoverage(\n  specKey: string,\n  specVersion: string,\n  requirement: CoverageRequirement,\n  actual: CoverageData\n): CoverageValidationResult {\n  const failures: CoverageFailure[] = [];\n\n  // Check statements requirement\n  if (\n    requirement.statements !== undefined &&\n    actual.statements.pct < requirement.statements\n  ) {\n    failures.push({\n      metric: 'statements',\n      required: requirement.statements,\n      actual: actual.statements.pct,\n      message: `Statement coverage ${actual.statements.pct}% is below required ${requirement.statements}%`,\n    });\n  }\n\n  // Check branches requirement\n  if (\n    requirement.branches !== undefined &&\n    actual.branches.pct < requirement.branches\n  ) {\n    failures.push({\n      metric: 'branches',\n      required: requirement.branches,\n      actual: actual.branches.pct,\n      message: `Branch coverage ${actual.branches.pct}% is below required ${requirement.branches}%`,\n    });\n  }\n\n  // Check functions requirement\n  if (\n    requirement.functions !== undefined &&\n    actual.functions.pct < requirement.functions\n  ) {\n    failures.push({\n      metric: 'functions',\n      required: requirement.functions,\n      actual: actual.functions.pct,\n      message: `Function coverage ${actual.functions.pct}% is below required ${requirement.functions}%`,\n    });\n  }\n\n  // Check lines requirement\n  if (requirement.lines !== undefined && actual.lines.pct < requirement.lines) {\n    failures.push({\n      metric: 'lines',\n      required: requirement.lines,\n      actual: actual.lines.pct,\n      message: `Line coverage ${actual.lines.pct}% is below required ${requirement.lines}%`,\n    });\n  }\n\n  // Note: Mutation coverage would require integration with a mutation testing tool\n  // like Stryker. For now, we skip this check.\n  if (requirement.mutations !== undefined) {\n    // Mutation testing not yet supported\n    failures.push({\n      metric: 'mutations',\n      required: requirement.mutations,\n      actual: 0,\n      message: `Mutation coverage required (${requirement.mutations}%) but mutation testing is not yet supported`,\n    });\n  }\n\n  return {\n    specKey,\n    specVersion,\n    requirement,\n    actual,\n    passed: failures.length === 0,\n    failures,\n  };\n}\n\n/**\n * Validate coverage for multiple specs and create a summary.\n *\n * @param validations - Array of specs with requirements and coverage\n * @returns Summary of all validations\n */\nexport function validateAllCoverage(\n  validations: {\n    specKey: string;\n    specVersion: string;\n    requirement: CoverageRequirement;\n    actual: CoverageData;\n  }[]\n): CoverageValidationSummary {\n  const results: CoverageValidationResult[] = [];\n\n  for (const v of validations) {\n    results.push(\n      validateCoverage(v.specKey, v.specVersion, v.requirement, v.actual)\n    );\n  }\n\n  const passedSpecs = results.filter((r) => r.passed).length;\n  const failedSpecs = results.filter((r) => !r.passed).length;\n\n  return {\n    totalSpecs: results.length,\n    passedSpecs,\n    failedSpecs,\n    results,\n    allPassed: failedSpecs === 0,\n  };\n}\n\n/**\n * Format coverage validation result as a human-readable string.\n */\nexport function formatCoverageResult(result: CoverageValidationResult): string {\n  const lines: string[] = [];\n\n  lines.push(\n    `${result.specKey}.v${result.specVersion}: ${result.passed ? 'PASS' : 'FAIL'}`\n  );\n\n  if (!result.passed) {\n    for (const failure of result.failures) {\n      lines.push(`  - ${failure.message}`);\n    }\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Format coverage validation summary as a human-readable string.\n */\nexport function formatCoverageSummary(\n  summary: CoverageValidationSummary\n): string {\n  const lines: string[] = [];\n\n  lines.push('Coverage Validation Summary');\n  lines.push('===========================');\n  lines.push(`Total specs: ${summary.totalSpecs}`);\n  lines.push(`Passed: ${summary.passedSpecs}`);\n  lines.push(`Failed: ${summary.failedSpecs}`);\n  lines.push('');\n\n  for (const result of summary.results) {\n    lines.push(formatCoverageResult(result));\n  }\n\n  return lines.join('\\n');\n}\n"],"mappings":";;;;;;;;;;AAuBA,SAAgB,iBACd,SACA,aACA,aACA,QAC0B;CAC1B,MAAM,WAA8B,EAAE;AAGtC,KACE,YAAY,eAAe,UAC3B,OAAO,WAAW,MAAM,YAAY,WAEpC,UAAS,KAAK;EACZ,QAAQ;EACR,UAAU,YAAY;EACtB,QAAQ,OAAO,WAAW;EAC1B,SAAS,sBAAsB,OAAO,WAAW,IAAI,sBAAsB,YAAY,WAAW;EACnG,CAAC;AAIJ,KACE,YAAY,aAAa,UACzB,OAAO,SAAS,MAAM,YAAY,SAElC,UAAS,KAAK;EACZ,QAAQ;EACR,UAAU,YAAY;EACtB,QAAQ,OAAO,SAAS;EACxB,SAAS,mBAAmB,OAAO,SAAS,IAAI,sBAAsB,YAAY,SAAS;EAC5F,CAAC;AAIJ,KACE,YAAY,cAAc,UAC1B,OAAO,UAAU,MAAM,YAAY,UAEnC,UAAS,KAAK;EACZ,QAAQ;EACR,UAAU,YAAY;EACtB,QAAQ,OAAO,UAAU;EACzB,SAAS,qBAAqB,OAAO,UAAU,IAAI,sBAAsB,YAAY,UAAU;EAChG,CAAC;AAIJ,KAAI,YAAY,UAAU,UAAa,OAAO,MAAM,MAAM,YAAY,MACpE,UAAS,KAAK;EACZ,QAAQ;EACR,UAAU,YAAY;EACtB,QAAQ,OAAO,MAAM;EACrB,SAAS,iBAAiB,OAAO,MAAM,IAAI,sBAAsB,YAAY,MAAM;EACpF,CAAC;AAKJ,KAAI,YAAY,cAAc,OAE5B,UAAS,KAAK;EACZ,QAAQ;EACR,UAAU,YAAY;EACtB,QAAQ;EACR,SAAS,+BAA+B,YAAY,UAAU;EAC/D,CAAC;AAGJ,QAAO;EACL;EACA;EACA;EACA;EACA,QAAQ,SAAS,WAAW;EAC5B;EACD"}

package/dist/services/create/ai-generator.d.mts

@@ -0,0 +1,84 @@
+import { PresentationKind, WorkspaceConfig } from "@contractspec/module.workspace";
+import { OpKind } from "@contractspec/lib.contracts";
+
+//#region src/services/create/ai-generator.d.ts
+
+/**
+ * AI Generator Service
+ */
+declare class AIGenerator {
+  private config;
+  constructor(config: WorkspaceConfig);
+  private getModel;
+  /**
+   * Generate operation spec from natural language description
+   */
+  generateOperationSpec(description: string, kind: OpKind): Promise<{
+    name: string;
+    version: number;
+    description: string;
+    goal: string;
+    context: string;
+    stability: "experimental" | "beta" | "stable" | "deprecated";
+    owners: string[];
+    tags: string[];
+    auth: "anonymous" | "user" | "admin";
+    inputShape: string;
+    outputShape: string;
+    flags: string[];
+    possibleEvents: string[];
+    analytics: string[];
+  }>;
+  /**
+   * Generate event spec from description
+   */
+  generateEventSpec(description: string): Promise<{
+    name: string;
+    version: number;
+    description: string;
+    stability: "experimental" | "beta" | "stable" | "deprecated";
+    owners: string[];
+    tags: string[];
+    payloadShape: string;
+    piiFields: string[];
+  }>;
+  /**
+   * Generate presentation spec from description
+   */
+  generatePresentationSpec(description: string, kind: PresentationKind): Promise<{
+    name: string;
+    version: number;
+    description: string;
+    stability: "experimental" | "beta" | "stable" | "deprecated";
+    owners: string[];
+    tags: string[];
+    componentKey?: string | undefined;
+    propsShape?: string | undefined;
+    content?: string | undefined;
+    mimeType?: string | undefined;
+    dataShape?: string | undefined;
+  }>;
+  /**
+   * Generate handler implementation from spec
+   */
+  generateHandler(specCode: string): Promise<string>;
+  /**
+   * Generate React component from presentation spec
+   */
+  generateComponent(specCode: string): Promise<string>;
+  /**
+   * Generate form component from form spec
+   */
+  generateForm(specCode: string): Promise<string>;
+  /**
+   * Generate tests for implementation
+   */
+  generateTests(specCode: string, implementationCode: string, testType: 'handler' | 'component'): Promise<string>;
+  /**
+   * Stream code generation for better UX
+   */
+  streamCodeGeneration(prompt: string, onChunk: (text: string) => void): Promise<string>;
+}
+//#endregion
+export { AIGenerator };
+//# sourceMappingURL=ai-generator.d.mts.map

package/dist/services/create/ai-generator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-generator.d.mts","names":[],"sources":["../../../src/services/create/ai-generator.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAsI4E,cApG/D,WAAA,CAoG+D;EAkCjC,QAAA,MAAA;EAeE,WAAA,CAAA,MAAA,EApJf,eAoJe;EAeL,QAAA,QAAA;EAmBnC;;;mDA/JoD,SAAM;;;;;;;;;;;;;;;;;;;0CA6ClB;;;;;;;;;;;;;sDA+Be,mBAAgB;;;;;;;;;;;;;;;;qCAkCjC;;;;uCAeE;;;;kCAeL;;;;kGAmBnC;;;;yEAkBA"}