@contractspec/bundle.workspace 1.44.0

package/dist/services/build.d.ts

@@ -0,0 +1,59 @@
+import { FsAdapter } from "../ports/fs.js";
+import { LoggerAdapter } from "../ports/logger.js";
+import { SpecScanResult, WorkspaceConfig } from "@contractspec/module.workspace";
+
+//#region src/services/build.d.ts
+
+/**
+ * Build target types.
+ */
+type BuildTarget = 'handler' | 'component' | 'test';
+/**
+ * Options for building from a spec.
+ */
+interface BuildSpecOptions {
+  /**
+   * Which artifacts to generate.
+   */
+  targets?: BuildTarget[];
+  /**
+   * Override output directory.
+   */
+  outputDir?: string;
+  /**
+   * Whether to overwrite existing files.
+   */
+  overwrite?: boolean;
+  /**
+   * Skip writing files (dry run).
+   */
+  dryRun?: boolean;
+}
+/**
+ * Result of a single build target.
+ */
+interface BuildTargetResult {
+  target: BuildTarget;
+  outputPath: string;
+  success: boolean;
+  skipped?: boolean;
+  error?: string;
+}
+/**
+ * Result of building from a spec.
+ */
+interface BuildSpecResult {
+  specPath: string;
+  specInfo: SpecScanResult;
+  results: BuildTargetResult[];
+}
+/**
+ * Build implementation files from a spec.
+ */
+declare function buildSpec(specPath: string, adapters: {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}, config: WorkspaceConfig, options?: BuildSpecOptions): Promise<BuildSpecResult>;
+//#endregion
+export { BuildSpecOptions, BuildSpecResult, BuildTarget, BuildTargetResult, buildSpec };
+//# sourceMappingURL=build.d.ts.map

package/dist/services/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","names":[],"sources":["../../src/services/build.ts"],"sourcesContent":[],"mappings":";;;;;;AAwEA;;;AAGU,KArDE,WAAA,GAqDF,SAAA,GAAA,WAAA,GAAA,MAAA;;;;AAEA,UAlDO,gBAAA,CAkDP;;;;YA9CE;;;;;;;;;;;;;;;;;UAqBK,iBAAA;UACP;;;;;;;;;UAUO,eAAA;;YAEL;WACD;;;;;iBAMW,SAAA;MAEJ;UAAmB;WAC3B,2BACC,mBACR,QAAQ"}

package/dist/services/build.js

@@ -0,0 +1,140 @@
+import { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate, inferSpecTypeFromFilePath, scanSpecSource } from "@contractspec/module.workspace";
+
+//#region src/services/build.ts
+/**
+* Build/scaffold service for generating implementation files from specs.
+*
+* Uses templates from @contractspec/module.workspace to generate
+* handler, component, and test skeletons without requiring AI.
+*/
+/**
+* Build implementation files from a spec.
+*/
+async function buildSpec(specPath, adapters, config, options = {}) {
+	const { fs, logger } = adapters;
+	const { targets = detectDefaultTargets(specPath), outputDir = config.outputDir, overwrite = false, dryRun = false } = options;
+	const specCode = await fs.readFile(specPath);
+	const specInfo = scanSpecSource(specCode, specPath);
+	const specType = inferSpecTypeFromFilePath(specPath);
+	logger.info(`Building from spec: ${specPath}`, { specType });
+	const results = [];
+	for (const target of targets) try {
+		const result = await buildTarget(target, specPath, specCode, specInfo, specType, {
+			fs,
+			logger
+		}, outputDir, overwrite, dryRun);
+		results.push(result);
+	} catch (error) {
+		results.push({
+			target,
+			outputPath: "",
+			success: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		specPath,
+		specInfo,
+		results
+	};
+}
+/**
+* Build a single target from a spec.
+*/
+async function buildTarget(target, specPath, _specCode, specInfo, specType, adapters, outputDir, overwrite, dryRun) {
+	const { fs, logger } = adapters;
+	let code;
+	let outputPath;
+	switch (target) {
+		case "handler": {
+			if (specType !== "operation") return {
+				target,
+				outputPath: "",
+				success: false,
+				skipped: true,
+				error: `Handler generation only supported for operation specs (got ${specType})`
+			};
+			const kind = specInfo.kind === "command" || specInfo.kind === "query" ? specInfo.kind : "command";
+			code = generateHandlerTemplate(specInfo.key ?? "unknown", kind);
+			outputPath = resolveOutputPath(specPath, outputDir, "handlers", specInfo.key ?? "unknown", ".handler.ts", adapters.fs);
+			break;
+		}
+		case "component":
+			if (specType !== "presentation") return {
+				target,
+				outputPath: "",
+				success: false,
+				skipped: true,
+				error: `Component generation only supported for presentation specs (got ${specType})`
+			};
+			code = generateComponentTemplate(specInfo.key ?? "unknown", specInfo.description ?? "");
+			outputPath = resolveOutputPath(specPath, outputDir, "components", specInfo.key ?? "unknown", ".tsx", adapters.fs);
+			break;
+		case "test": {
+			const testType = specType === "operation" ? "handler" : "component";
+			code = generateTestTemplate(specInfo.key ?? "unknown", testType);
+			outputPath = resolveOutputPath(specPath, outputDir, "__tests__", specInfo.key ?? "unknown", ".test.ts", adapters.fs);
+			break;
+		}
+		default: return {
+			target,
+			outputPath: "",
+			success: false,
+			error: `Unknown target: ${target}`
+		};
+	}
+	if (await fs.exists(outputPath) && !overwrite) return {
+		target,
+		outputPath,
+		success: false,
+		skipped: true,
+		error: "File already exists (use overwrite option)"
+	};
+	if (dryRun) {
+		logger.info(`[dry-run] Would write: ${outputPath}`);
+		return {
+			target,
+			outputPath,
+			success: true
+		};
+	}
+	const dirPath = fs.dirname(outputPath);
+	await fs.mkdir(dirPath);
+	await fs.writeFile(outputPath, code);
+	logger.info(`Generated: ${outputPath}`);
+	return {
+		target,
+		outputPath,
+		success: true
+	};
+}
+/**
+* Detect default targets based on spec type.
+*/
+function detectDefaultTargets(specPath) {
+	switch (inferSpecTypeFromFilePath(specPath)) {
+		case "operation": return ["handler"];
+		case "presentation": return ["component"];
+		default: return [];
+	}
+}
+/**
+* Resolve output path for generated file.
+*/
+function resolveOutputPath(specPath, outputDir, subdir, specName, extension, fs) {
+	const sanitizedName = toKebabCase(specName.split(".").pop() ?? "unknown");
+	let baseDir;
+	if (outputDir.startsWith(".")) baseDir = fs.resolve(fs.dirname(specPath), "..", outputDir, subdir);
+	else baseDir = fs.resolve(outputDir, subdir);
+	return fs.join(baseDir, `${sanitizedName}${extension}`);
+}
+/**
+* Convert string to kebab-case.
+*/
+function toKebabCase(str) {
+	return str.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+//#endregion
+export { buildSpec };
+//# sourceMappingURL=build.js.map

package/dist/services/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","names":["results: BuildTargetResult[]","code: string","outputPath: string","baseDir: string"],"sources":["../../src/services/build.ts"],"sourcesContent":["/**\n * Build/scaffold service for generating implementation files from specs.\n *\n * Uses templates from @contractspec/module.workspace to generate\n * handler, component, and test skeletons without requiring AI.\n */\n\nimport {\n  generateComponentTemplate,\n  generateHandlerTemplate,\n  generateTestTemplate,\n  inferSpecTypeFromFilePath,\n  scanSpecSource,\n  type SpecScanResult,\n  type WorkspaceConfig,\n} from '@contractspec/module.workspace';\nimport type { FsAdapter } from '../ports/fs';\nimport type { LoggerAdapter } from '../ports/logger';\n\n/**\n * Build target types.\n */\nexport type BuildTarget = 'handler' | 'component' | 'test';\n\n/**\n * Options for building from a spec.\n */\nexport interface BuildSpecOptions {\n  /**\n   * Which artifacts to generate.\n   */\n  targets?: BuildTarget[];\n\n  /**\n   * Override output directory.\n   */\n  outputDir?: string;\n\n  /**\n   * Whether to overwrite existing files.\n   */\n  overwrite?: boolean;\n\n  /**\n   * Skip writing files (dry run).\n   */\n  dryRun?: boolean;\n}\n\n/**\n * Result of a single build target.\n */\nexport interface BuildTargetResult {\n  target: BuildTarget;\n  outputPath: string;\n  success: boolean;\n  skipped?: boolean;\n  error?: string;\n}\n\n/**\n * Result of building from a spec.\n */\nexport interface BuildSpecResult {\n  specPath: string;\n  specInfo: SpecScanResult;\n  results: BuildTargetResult[];\n}\n\n/**\n * Build implementation files from a spec.\n */\nexport async function buildSpec(\n  specPath: string,\n  adapters: { fs: FsAdapter; logger: LoggerAdapter },\n  config: WorkspaceConfig,\n  options: BuildSpecOptions = {}\n): Promise<BuildSpecResult> {\n  const { fs, logger } = adapters;\n  const {\n    targets = detectDefaultTargets(specPath),\n    outputDir = config.outputDir,\n    overwrite = false,\n    dryRun = false,\n  } = options;\n\n  // Read and scan spec\n  const specCode = await fs.readFile(specPath);\n  const specInfo = scanSpecSource(specCode, specPath);\n  const specType = inferSpecTypeFromFilePath(specPath);\n\n  logger.info(`Building from spec: ${specPath}`, { specType });\n\n  const results: BuildTargetResult[] = [];\n\n  for (const target of targets) {\n    try {\n      const result = await buildTarget(\n        target,\n        specPath,\n        specCode,\n        specInfo,\n        specType,\n        { fs, logger },\n        outputDir,\n        overwrite,\n        dryRun\n      );\n      results.push(result);\n    } catch (error) {\n      results.push({\n        target,\n        outputPath: '',\n        success: false,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  return {\n    specPath,\n    specInfo,\n    results,\n  };\n}\n\n/**\n * Build a single target from a spec.\n */\nasync function buildTarget(\n  target: BuildTarget,\n  specPath: string,\n  _specCode: string,\n  specInfo: SpecScanResult,\n  specType: string,\n  adapters: { fs: FsAdapter; logger: LoggerAdapter },\n  outputDir: string,\n  overwrite: boolean,\n  dryRun: boolean\n): Promise<BuildTargetResult> {\n  const { fs, logger } = adapters;\n\n  let code: string;\n  let outputPath: string;\n\n  switch (target) {\n    case 'handler': {\n      if (specType !== 'operation') {\n        return {\n          target,\n          outputPath: '',\n          success: false,\n          skipped: true,\n          error: `Handler generation only supported for operation specs (got ${specType})`,\n        };\n      }\n\n      const kind =\n        specInfo.kind === 'command' || specInfo.kind === 'query'\n          ? specInfo.kind\n          : 'command';\n\n      code = generateHandlerTemplate(specInfo.key ?? 'unknown', kind);\n      outputPath = resolveOutputPath(\n        specPath,\n        outputDir,\n        'handlers',\n        specInfo.key ?? 'unknown',\n        '.handler.ts',\n        adapters.fs\n      );\n      break;\n    }\n\n    case 'component': {\n      if (specType !== 'presentation') {\n        return {\n          target,\n          outputPath: '',\n          success: false,\n          skipped: true,\n          error: `Component generation only supported for presentation specs (got ${specType})`,\n        };\n      }\n\n      code = generateComponentTemplate(\n        specInfo.key ?? 'unknown',\n        specInfo.description ?? ''\n      );\n      outputPath = resolveOutputPath(\n        specPath,\n        outputDir,\n        'components',\n        specInfo.key ?? 'unknown',\n        '.tsx',\n        adapters.fs\n      );\n      break;\n    }\n\n    case 'test': {\n      const testType = specType === 'operation' ? 'handler' : 'component';\n      code = generateTestTemplate(specInfo.key ?? 'unknown', testType);\n      outputPath = resolveOutputPath(\n        specPath,\n        outputDir,\n        '__tests__',\n        specInfo.key ?? 'unknown',\n        '.test.ts',\n        adapters.fs\n      );\n      break;\n    }\n\n    default:\n      return {\n        target,\n        outputPath: '',\n        success: false,\n        error: `Unknown target: ${target}`,\n      };\n  }\n\n  // Check if file exists\n  const exists = await fs.exists(outputPath);\n  if (exists && !overwrite) {\n    return {\n      target,\n      outputPath,\n      success: false,\n      skipped: true,\n      error: 'File already exists (use overwrite option)',\n    };\n  }\n\n  if (dryRun) {\n    logger.info(`[dry-run] Would write: ${outputPath}`);\n    return {\n      target,\n      outputPath,\n      success: true,\n    };\n  }\n\n  // Ensure directory exists\n  const dirPath = fs.dirname(outputPath);\n  await fs.mkdir(dirPath);\n\n  // Write file\n  await fs.writeFile(outputPath, code);\n  logger.info(`Generated: ${outputPath}`);\n\n  return {\n    target,\n    outputPath,\n    success: true,\n  };\n}\n\n/**\n * Detect default targets based on spec type.\n */\nfunction detectDefaultTargets(specPath: string): BuildTarget[] {\n  const specType = inferSpecTypeFromFilePath(specPath);\n\n  switch (specType) {\n    case 'operation':\n      return ['handler'];\n    case 'presentation':\n      return ['component'];\n    default:\n      return [];\n  }\n}\n\n/**\n * Resolve output path for generated file.\n */\nfunction resolveOutputPath(\n  specPath: string,\n  outputDir: string,\n  subdir: string,\n  specName: string,\n  extension: string,\n  fs: FsAdapter\n): string {\n  const sanitizedName = toKebabCase(specName.split('.').pop() ?? 'unknown');\n\n  let baseDir: string;\n  if (outputDir.startsWith('.')) {\n    // Relative to spec file location\n    baseDir = fs.resolve(fs.dirname(specPath), '..', outputDir, subdir);\n  } else {\n    // Absolute or relative to cwd\n    baseDir = fs.resolve(outputDir, subdir);\n  }\n\n  return fs.join(baseDir, `${sanitizedName}${extension}`);\n}\n\n/**\n * Convert string to kebab-case.\n */\nfunction toKebabCase(str: string): string {\n  return str\n    .replace(/\\./g, '-')\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .toLowerCase();\n}\n"],"mappings":"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"}

package/dist/services/ci-check/ci-check-service.d.ts

@@ -0,0 +1,16 @@
+import { FsAdapter } from "../../ports/fs.js";
+import { LoggerAdapter } from "../../ports/logger.js";
+import { CICheckOptions, CICheckResult } from "./types.js";
+
+//#region src/services/ci-check/ci-check-service.d.ts
+
+/**
+ * Run all CI checks and return structured results.
+ */
+declare function runCIChecks(adapters: {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}, options?: CICheckOptions): Promise<CICheckResult>;
+//#endregion
+export { runCIChecks };
+//# sourceMappingURL=ci-check-service.d.ts.map

package/dist/services/ci-check/ci-check-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-check-service.d.ts","names":[],"sources":["../../../src/services/ci-check/ci-check-service.ts"],"sourcesContent":[],"mappings":";;;;;;;;;iBA+BsB,WAAA;MACJ;UAAmB;aAC1B,iBACR,QAAQ"}

package/dist/services/ci-check/ci-check-service.js

@@ -0,0 +1,392 @@
+import { validateImplementationFiles } from "../validate-implementation.js";
+import { analyzeDeps } from "../deps.js";
+import { loadWorkspaceConfig } from "../config.js";
+import { analyzeIntegrity } from "../integrity.js";
+import { runDoctor } from "../doctor/doctor-service.js";
+import { resolveAllImplementations } from "../implementation/resolver.js";
+import { isFeatureFile, validateSpecStructure } from "@contractspec/module.workspace";
+
+//#region src/services/ci-check/ci-check-service.ts
+/**
+* CI Check service.
+*
+* Orchestrates all validation checks for CI/CD pipelines.
+* Returns structured results suitable for multiple output formats.
+*/
+/**
+* Run all CI checks and return structured results.
+*/
+async function runCIChecks(adapters, options = {}) {
+	const startTime = Date.now();
+	const { fs, logger } = adapters;
+	const issues = [];
+	const categorySummaries = [];
+	const checksToRun = getChecksToRun(options);
+	logger.info("Starting CI checks...", { checks: checksToRun });
+	const specFiles = (await fs.glob({ pattern: options.pattern })).filter((f) => !isFeatureFile(f) && !f.includes(".test.") && !f.includes(".spec."));
+	if (checksToRun.includes("structure")) {
+		const categoryStart = Date.now();
+		const structureIssues = await runStructureChecks(adapters, specFiles);
+		issues.push(...structureIssues);
+		categorySummaries.push(createCategorySummary("structure", structureIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("integrity")) {
+		const categoryStart = Date.now();
+		const integrityIssues = await runIntegrityChecks(adapters, options);
+		issues.push(...integrityIssues);
+		categorySummaries.push(createCategorySummary("integrity", integrityIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("deps")) {
+		const categoryStart = Date.now();
+		const depsIssues = await runDepsChecks(adapters, options);
+		issues.push(...depsIssues);
+		categorySummaries.push(createCategorySummary("deps", depsIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("doctor")) {
+		const categoryStart = Date.now();
+		const doctorIssues = await runDoctorChecks(adapters, options);
+		issues.push(...doctorIssues);
+		categorySummaries.push(createCategorySummary("doctor", doctorIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("handlers") || options.checkHandlers) {
+		const categoryStart = Date.now();
+		const handlerIssues = await runHandlerChecks(adapters, specFiles);
+		issues.push(...handlerIssues);
+		categorySummaries.push(createCategorySummary("handlers", handlerIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("tests") || options.checkTests) {
+		const categoryStart = Date.now();
+		const testIssues = await runTestChecks(adapters, specFiles);
+		issues.push(...testIssues);
+		categorySummaries.push(createCategorySummary("tests", testIssues, Date.now() - categoryStart));
+	}
+	if (checksToRun.includes("implementation")) {
+		const categoryStart = Date.now();
+		const implIssues = await runImplementationChecks(adapters, specFiles, options);
+		issues.push(...implIssues);
+		categorySummaries.push(createCategorySummary("implementation", implIssues, Date.now() - categoryStart));
+	}
+	const totalErrors = issues.filter((i) => i.severity === "error").length;
+	const totalWarnings = issues.filter((i) => i.severity === "warning").length;
+	const totalNotes = issues.filter((i) => i.severity === "note").length;
+	const success = options.failOnWarnings ? totalErrors === 0 && totalWarnings === 0 : totalErrors === 0;
+	const gitInfo = await getGitInfo(fs);
+	const result = {
+		success,
+		totalErrors,
+		totalWarnings,
+		totalNotes,
+		issues,
+		categories: categorySummaries,
+		durationMs: Date.now() - startTime,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...gitInfo
+	};
+	logger.info("CI checks complete", {
+		success,
+		errors: totalErrors,
+		warnings: totalWarnings,
+		durationMs: result.durationMs
+	});
+	return result;
+}
+/**
+* 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.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;
+}
+/**
+* Run spec structure validation checks.
+*/
+async function runStructureChecks(adapters, specFiles) {
+	const { fs } = adapters;
+	const issues = [];
+	for (const file of specFiles) {
+		const result = validateSpecStructure(await fs.readFile(file), file);
+		for (const error of result.errors) issues.push({
+			ruleId: "spec-structure-error",
+			severity: "error",
+			message: error,
+			category: "structure",
+			file
+		});
+		for (const warning of result.warnings) issues.push({
+			ruleId: "spec-structure-warning",
+			severity: "warning",
+			message: warning,
+			category: "structure",
+			file
+		});
+	}
+	return issues;
+}
+/**
+* Run integrity analysis checks.
+*/
+async function runIntegrityChecks(adapters, options) {
+	const issues = [];
+	const result = await analyzeIntegrity(adapters, {
+		pattern: options.pattern,
+		all: true
+	});
+	for (const issue of result.issues) issues.push({
+		ruleId: `integrity-${issue.type}`,
+		severity: issue.severity === "error" ? "error" : "warning",
+		message: issue.message,
+		category: "integrity",
+		file: issue.file,
+		context: {
+			specKey: issue.specKey,
+			specType: issue.specType,
+			featureKey: issue.featureKey,
+			ref: issue.ref
+		}
+	});
+	return issues;
+}
+/**
+* Run dependency analysis checks.
+*/
+async function runDepsChecks(adapters, options) {
+	const issues = [];
+	const result = await analyzeDeps(adapters, { pattern: options.pattern });
+	for (const cycle of result.cycles) issues.push({
+		ruleId: "deps-circular",
+		severity: "error",
+		message: `Circular dependency detected: ${cycle.join(" → ")}`,
+		category: "deps",
+		context: { cycle }
+	});
+	for (const item of result.missing) for (const missing of item.missing) issues.push({
+		ruleId: "deps-missing",
+		severity: "error",
+		message: `Missing dependency: ${item.contract} requires ${missing}`,
+		category: "deps",
+		context: {
+			contract: item.contract,
+			missing
+		}
+	});
+	return issues;
+}
+/**
+* Run doctor checks (skipping AI in CI).
+*/
+async function runDoctorChecks(adapters, options) {
+	const issues = [];
+	const result = await runDoctor(adapters, {
+		workspaceRoot: options.workspaceRoot ?? process.cwd(),
+		skipAi: true,
+		categories: [
+			"cli",
+			"config",
+			"deps",
+			"workspace"
+		]
+	});
+	for (const check of result.checks) if (check.status === "fail") issues.push({
+		ruleId: `doctor-${check.category}-${check.name.toLowerCase().replace(/\s+/g, "-")}`,
+		severity: "error",
+		message: `${check.name}: ${check.message}`,
+		category: "doctor",
+		context: { details: check.details }
+	});
+	else if (check.status === "warn") issues.push({
+		ruleId: `doctor-${check.category}-${check.name.toLowerCase().replace(/\s+/g, "-")}`,
+		severity: "warning",
+		message: `${check.name}: ${check.message}`,
+		category: "doctor",
+		context: { details: check.details }
+	});
+	return issues;
+}
+/**
+* Run handler implementation checks.
+*/
+async function runHandlerChecks(adapters, specFiles) {
+	const { fs } = adapters;
+	const issues = [];
+	const config = await loadWorkspaceConfig(fs);
+	for (const specFile of specFiles) {
+		if (!specFile.includes(".operation.")) continue;
+		const result = await validateImplementationFiles(specFile, { fs }, config, {
+			checkHandlers: true,
+			outputDir: config.outputDir
+		});
+		for (const error of result.errors) issues.push({
+			ruleId: "handler-missing",
+			severity: "warning",
+			message: error,
+			category: "handlers",
+			file: specFile
+		});
+		for (const warning of result.warnings) issues.push({
+			ruleId: "handler-warning",
+			severity: "warning",
+			message: warning,
+			category: "handlers",
+			file: specFile
+		});
+	}
+	return issues;
+}
+/**
+* Run test coverage checks.
+*/
+async function runTestChecks(adapters, specFiles) {
+	const { fs } = adapters;
+	const issues = [];
+	const config = await loadWorkspaceConfig(fs);
+	for (const specFile of specFiles) {
+		if (!specFile.includes(".operation.")) continue;
+		const result = await validateImplementationFiles(specFile, { fs }, config, {
+			checkTests: true,
+			outputDir: config.outputDir
+		});
+		for (const error of result.errors) issues.push({
+			ruleId: "test-missing",
+			severity: "warning",
+			message: error,
+			category: "tests",
+			file: specFile
+		});
+		for (const warning of result.warnings) issues.push({
+			ruleId: "test-warning",
+			severity: "warning",
+			message: warning,
+			category: "tests",
+			file: specFile
+		});
+	}
+	return issues;
+}
+/**
+* Run implementation verification checks.
+*/
+async function runImplementationChecks(adapters, specFiles, options) {
+	const { fs } = adapters;
+	const issues = [];
+	const config = await loadWorkspaceConfig(fs);
+	const implOptions = options.implementation ?? {};
+	const results = await resolveAllImplementations(specFiles.filter((f) => f.includes(".operation.")), { fs }, config, { computeHashes: implOptions.useCache ?? true });
+	for (const result of results) {
+		if (implOptions.requireImplemented && result.status === "missing") issues.push({
+			ruleId: "impl-missing",
+			severity: "error",
+			message: `Spec ${result.specKey} has no implementation`,
+			category: "implementation",
+			file: result.specPath,
+			context: {
+				specKey: result.specKey,
+				specVersion: result.specVersion,
+				status: result.status
+			}
+		});
+		else if (result.status === "missing") issues.push({
+			ruleId: "impl-missing",
+			severity: "warning",
+			message: `Spec ${result.specKey} has no implementation`,
+			category: "implementation",
+			file: result.specPath,
+			context: {
+				specKey: result.specKey,
+				specVersion: result.specVersion,
+				status: result.status
+			}
+		});
+		if (!implOptions.allowPartial && result.status === "partial") {
+			const missingImpls = result.implementations.filter((i) => !i.exists && i.type !== "test").map((i) => i.path);
+			issues.push({
+				ruleId: "impl-partial",
+				severity: "warning",
+				message: `Spec ${result.specKey} has partial implementation: missing ${missingImpls.join(", ")}`,
+				category: "implementation",
+				file: result.specPath,
+				context: {
+					specKey: result.specKey,
+					specVersion: result.specVersion,
+					status: result.status,
+					missingFiles: missingImpls
+				}
+			});
+		}
+		const missingTests = result.implementations.filter((i) => !i.exists && i.type === "test");
+		if (missingTests.length > 0) issues.push({
+			ruleId: "impl-missing-tests",
+			severity: "note",
+			message: `Spec ${result.specKey} missing test files: ${missingTests.map((t) => t.path).join(", ")}`,
+			category: "implementation",
+			file: result.specPath,
+			context: {
+				specKey: result.specKey,
+				missingTests: missingTests.map((t) => t.path)
+			}
+		});
+	}
+	return issues;
+}
+/**
+* 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",
+		implementation: "Implementation Verification"
+	};
+	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 {};
+	}
+}
+
+//#endregion
+export { runCIChecks };
+//# sourceMappingURL=ci-check-service.js.map