@contractspec/bundle.workspace 1.44.0

package/dist/services/impact/impact-detection-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-detection-service.js","names":["baseSnapshot: ContractSnapshot","specs: { path: string; content: string }[]","diffs: ReturnType<typeof computeIoDiff>"],"sources":["../../../src/services/impact/impact-detection-service.ts"],"sourcesContent":["/**\n * Impact detection service.\n *\n * Orchestrates contract snapshot generation, diff computation,\n * and impact classification for CI/CD pipelines.\n */\n\n// Note: Using internal imports from the bundle which re-exports from module\nimport {\n  classifyImpact,\n  computeIoDiff,\n  generateSnapshot,\n  type ContractSnapshot,\n  type SpecSnapshot,\n} from '../../index';\nimport type { FsAdapter } from '../../ports/fs';\nimport type { GitAdapter } from '../../ports/git';\nimport type { LoggerAdapter } from '../../ports/logger';\nimport type { ImpactDetectionOptions, ImpactDetectionResult } from './types';\n\n/**\n * Detect the impact of contract changes between baseline and current state.\n *\n * @param adapters - Required adapters (fs, git, logger)\n * @param options - Detection options\n * @returns Impact detection result\n */\nexport async function detectImpact(\n  adapters: { fs: FsAdapter; git: GitAdapter; logger: LoggerAdapter },\n  options: ImpactDetectionOptions = {}\n): Promise<ImpactDetectionResult> {\n  const { fs, git, logger } = adapters;\n  const workspaceRoot = options.workspaceRoot ?? process.cwd();\n\n  logger.info('Starting impact detection...', { baseline: options.baseline });\n\n  // Discover spec files\n  const files = await fs.glob({\n    pattern: options.pattern ?? '**/*.{operation,event}.ts',\n    cwd: workspaceRoot,\n  });\n\n  const specFiles = files.filter(\n    (f) =>\n      !f.includes('.test.') &&\n      !f.includes('.spec.') &&\n      !f.includes('node_modules')\n  );\n\n  logger.debug(`Found ${specFiles.length} spec files`);\n\n  // Load current (head) specs\n  const headSpecs = await loadSpecs(fs, specFiles, workspaceRoot);\n  const headSnapshot = generateSnapshot(headSpecs);\n\n  // Load baseline specs if specified\n  let baseSnapshot: ContractSnapshot;\n  if (options.baseline) {\n    const baseSpecs = await loadBaselineSpecs(\n      fs,\n      git,\n      specFiles,\n      options.baseline,\n      workspaceRoot\n    );\n    baseSnapshot = generateSnapshot(baseSpecs);\n  } else {\n    // No baseline means all specs are \"new\"\n    baseSnapshot = { version: 1, generatedAt: '', specs: [], hash: '' };\n  }\n\n  // Compute diffs between snapshots\n  const diffs = computeSnapshotDiffs(baseSnapshot.specs, headSnapshot.specs);\n\n  // Classify the impact\n  const impactResult = classifyImpact(\n    baseSnapshot.specs,\n    headSnapshot.specs,\n    diffs\n  );\n\n  logger.info('Impact detection complete', {\n    status: impactResult.status,\n    breaking: impactResult.summary.breaking,\n    nonBreaking: impactResult.summary.nonBreaking,\n  });\n\n  return {\n    ...impactResult,\n    workspaceRoot,\n    specsAnalyzed: specFiles.length,\n    baseRef: options.baseline,\n  };\n}\n\n/**\n * Load specs from current filesystem.\n */\nasync function loadSpecs(\n  fs: FsAdapter,\n  files: string[],\n  _workspaceRoot: string\n): Promise<{ path: string; content: string }[]> {\n  const specs: { path: string; content: string }[] = [];\n\n  for (const file of files) {\n    const content = await fs.readFile(file);\n    specs.push({ path: file, content });\n  }\n\n  return specs;\n}\n\n/**\n * Load specs from git baseline.\n */\nasync function loadBaselineSpecs(\n  _fs: FsAdapter,\n  git: GitAdapter,\n  files: string[],\n  baseline: string,\n  _workspaceRoot: string\n): Promise<{ path: string; content: string }[]> {\n  const specs: { path: string; content: string }[] = [];\n\n  for (const file of files) {\n    try {\n      const content = await git.showFile(baseline, file);\n      specs.push({ path: file, content });\n    } catch {\n      // File doesn't exist in baseline - skip (it's new)\n    }\n  }\n\n  return specs;\n}\n\n/**\n * Compute diffs between two sets of spec snapshots.\n */\nfunction computeSnapshotDiffs(\n  baseSpecs: SpecSnapshot[],\n  headSpecs: SpecSnapshot[]\n): ReturnType<typeof computeIoDiff> {\n  const diffs: ReturnType<typeof computeIoDiff> = [];\n\n  const baseMap = new Map(baseSpecs.map((s) => [`${s.key}@${s.version}`, s]));\n  const headMap = new Map(headSpecs.map((s) => [`${s.key}@${s.version}`, s]));\n\n  // Compare specs that exist in both\n  for (const [key, headSpec] of headMap) {\n    const baseSpec = baseMap.get(key);\n    if (\n      baseSpec &&\n      headSpec.type === 'operation' &&\n      baseSpec.type === 'operation'\n    ) {\n      const ioDiffs = computeIoDiff(baseSpec.io, headSpec.io);\n      diffs.push(...ioDiffs);\n    }\n  }\n\n  return diffs;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2BA,eAAsB,aACpB,UACA,UAAkC,EAAE,EACJ;CAChC,MAAM,EAAE,IAAI,KAAK,WAAW;CAC5B,MAAM,gBAAgB,QAAQ,iBAAiB,QAAQ,KAAK;AAE5D,QAAO,KAAK,gCAAgC,EAAE,UAAU,QAAQ,UAAU,CAAC;CAQ3E,MAAM,aALQ,MAAM,GAAG,KAAK;EAC1B,SAAS,QAAQ,WAAW;EAC5B,KAAK;EACN,CAAC,EAEsB,QACrB,MACC,CAAC,EAAE,SAAS,SAAS,IACrB,CAAC,EAAE,SAAS,SAAS,IACrB,CAAC,EAAE,SAAS,eAAe,CAC9B;AAED,QAAO,MAAM,SAAS,UAAU,OAAO,aAAa;CAIpD,MAAM,iDADY,MAAM,UAAU,IAAI,WAAW,cAAc,CACf;CAGhD,IAAIA;AACJ,KAAI,QAAQ,SAQV,kDAPkB,MAAM,kBACtB,IACA,KACA,WACA,QAAQ,UACR,cACD,CACyC;KAG1C,gBAAe;EAAE,SAAS;EAAG,aAAa;EAAI,OAAO,EAAE;EAAE,MAAM;EAAI;CAIrE,MAAM,QAAQ,qBAAqB,aAAa,OAAO,aAAa,MAAM;CAG1E,MAAM,+CACJ,aAAa,OACb,aAAa,OACb,MACD;AAED,QAAO,KAAK,6BAA6B;EACvC,QAAQ,aAAa;EACrB,UAAU,aAAa,QAAQ;EAC/B,aAAa,aAAa,QAAQ;EACnC,CAAC;AAEF,QAAO;EACL,GAAG;EACH;EACA,eAAe,UAAU;EACzB,SAAS,QAAQ;EAClB;;;;;AAMH,eAAe,UACb,IACA,OACA,gBAC8C;CAC9C,MAAMC,QAA6C,EAAE;AAErD,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,UAAU,MAAM,GAAG,SAAS,KAAK;AACvC,QAAM,KAAK;GAAE,MAAM;GAAM;GAAS,CAAC;;AAGrC,QAAO;;;;;AAMT,eAAe,kBACb,KACA,KACA,OACA,UACA,gBAC8C;CAC9C,MAAMA,QAA6C,EAAE;AAErD,MAAK,MAAM,QAAQ,MACjB,KAAI;EACF,MAAM,UAAU,MAAM,IAAI,SAAS,UAAU,KAAK;AAClD,QAAM,KAAK;GAAE,MAAM;GAAM;GAAS,CAAC;SAC7B;AAKV,QAAO;;;;;AAMT,SAAS,qBACP,WACA,WACkC;CAClC,MAAMC,QAA0C,EAAE;CAElD,MAAM,UAAU,IAAI,IAAI,UAAU,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;CAC3E,MAAM,UAAU,IAAI,IAAI,UAAU,KAAK,MAAM,CAAC,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;AAG3E,MAAK,MAAM,CAAC,KAAK,aAAa,SAAS;EACrC,MAAM,WAAW,QAAQ,IAAI,IAAI;AACjC,MACE,YACA,SAAS,SAAS,eAClB,SAAS,SAAS,aAClB;GACA,MAAM,yCAAwB,SAAS,IAAI,SAAS,GAAG;AACvD,SAAM,KAAK,GAAG,QAAQ;;;AAI1B,QAAO"}

package/dist/services/impact/index.d.ts

@@ -0,0 +1,11 @@
+import { CheckRunAnnotation, CheckRunPayload, ImpactDetectionOptions, ImpactDetectionResult, ImpactResult, PrCommentOptions } from "./types.js";
+import { detectImpact } from "./impact-detection-service.js";
+import { formatCheckRun, formatJson, formatMinimalComment, formatPrComment } from "./formatters.js";
+
+//#region src/services/impact/index.d.ts
+declare namespace index_d_exports {
+  export { CheckRunAnnotation, CheckRunPayload, ImpactDetectionOptions, ImpactDetectionResult, ImpactResult, PrCommentOptions, detectImpact, formatCheckRun, formatJson, formatMinimalComment, formatPrComment };
+}
+//#endregion
+export { index_d_exports };
+//# sourceMappingURL=index.d.ts.map

package/dist/services/impact/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/services/impact/index.ts"],"sourcesContent":[],"mappings":""}

package/dist/services/impact/index.js

@@ -0,0 +1,16 @@
+import { __exportAll } from "../../_virtual/rolldown_runtime.js";
+import { detectImpact } from "./impact-detection-service.js";
+import { formatCheckRun, formatJson, formatMinimalComment, formatPrComment } from "./formatters.js";
+
+//#region src/services/impact/index.ts
+var impact_exports = /* @__PURE__ */ __exportAll({
+	detectImpact: () => detectImpact,
+	formatCheckRun: () => formatCheckRun,
+	formatJson: () => formatJson,
+	formatMinimalComment: () => formatMinimalComment,
+	formatPrComment: () => formatPrComment
+});
+
+//#endregion
+export { impact_exports };
+//# sourceMappingURL=index.js.map

package/dist/services/impact/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/services/impact/index.ts"],"sourcesContent":["/**\n * Impact detection service module.\n */\n\nexport * from './types';\nexport { detectImpact } from './impact-detection-service';\nexport {\n  formatPrComment,\n  formatMinimalComment,\n  formatCheckRun,\n  formatJson,\n} from './formatters';\n"],"mappings":""}

package/dist/services/impact/types.d.ts

@@ -0,0 +1,58 @@
+import { ImpactResult } from "@contractspec/module.workspace";
+
+//#region src/services/impact/types.d.ts
+
+/** Options for impact detection */
+interface ImpactDetectionOptions {
+  /** Git ref to compare against (branch, tag, commit) */
+  baseline?: string;
+  /** Glob pattern for spec discovery */
+  pattern?: string;
+  /** Workspace root directory */
+  workspaceRoot?: string;
+}
+/** Impact detection result with additional context */
+interface ImpactDetectionResult extends ImpactResult {
+  /** Working directory */
+  workspaceRoot: string;
+  /** Number of specs analyzed */
+  specsAnalyzed: number;
+}
+/** PR comment options */
+interface PrCommentOptions {
+  /** Template style */
+  template: 'minimal' | 'detailed';
+  /** Include links to files */
+  includeLinks?: boolean;
+  /** Repository URL for links */
+  repositoryUrl?: string;
+  /** Commit SHA for links */
+  commitSha?: string;
+}
+/** GitHub check run payload */
+interface CheckRunPayload {
+  /** Check run name */
+  name: string;
+  /** Head SHA */
+  headSha: string;
+  /** Conclusion */
+  conclusion: 'success' | 'failure' | 'neutral';
+  /** Output title */
+  title: string;
+  /** Output summary */
+  summary: string;
+  /** Annotations */
+  annotations?: CheckRunAnnotation[];
+}
+/** Check run annotation */
+interface CheckRunAnnotation {
+  path: string;
+  startLine: number;
+  endLine: number;
+  annotationLevel: 'notice' | 'warning' | 'failure';
+  message: string;
+  title?: string;
+}
+//#endregion
+export { CheckRunAnnotation, CheckRunPayload, ImpactDetectionOptions, ImpactDetectionResult, type ImpactResult, PrCommentOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/services/impact/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/services/impact/types.ts"],"sourcesContent":[],"mappings":";;;;AA4BA;AAYiB,UA9BA,sBAAA,CA0CD;EAIC;;;;;;;;UApCA,qBAAA,SAA8B;;;;;;;UAQ9B,gBAAA;;;;;;;;;;;UAYA,eAAA;;;;;;;;;;;;gBAYD;;;UAIC,kBAAA"}

package/dist/services/implementation/discovery.d.ts

@@ -0,0 +1,30 @@
+import { FsAdapter } from "../../ports/fs.js";
+import { DiscoveryOptions, SpecReferenceMatch } from "./types.js";
+import { ImplementationType } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/discovery.d.ts
+
+/**
+ * Infer implementation type from file path.
+ */
+declare function inferImplementationType(filePath: string): ImplementationType;
+/**
+ * Extract spec references from source code.
+ */
+declare function extractSpecReferences(code: string, filePath: string): SpecReferenceMatch[];
+/**
+ * Discover implementations that reference a specific spec.
+ */
+declare function discoverImplementationsForSpec(specKey: string, adapters: {
+  fs: FsAdapter;
+}, options?: DiscoveryOptions): Promise<SpecReferenceMatch[]>;
+/**
+ * Discover all spec references in the workspace.
+ * Returns a map of spec key to implementation references.
+ */
+declare function discoverAllImplementations(adapters: {
+  fs: FsAdapter;
+}, options?: DiscoveryOptions): Promise<Map<string, SpecReferenceMatch[]>>;
+//#endregion
+export { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType };
+//# sourceMappingURL=discovery.d.ts.map

package/dist/services/implementation/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","names":[],"sources":["../../../src/services/implementation/discovery.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAsLU,iBAnIM,uBAAA,CAmIN,QAAA,EAAA,MAAA,CAAA,EAnIiD,kBAmIjD;AAkCV;;;AAGuB,iBAhJP,qBAAA,CAgJO,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EA7IpB,kBA6IoB,EAAA;;;;iBAzCD,8BAAA;MAEJ;aACP,mBACR,QAAQ;;;;;iBAkCW,0BAAA;MACJ;aACP,mBACR,QAAQ,YAAY"}

package/dist/services/implementation/discovery.js

@@ -0,0 +1,144 @@
+//#region src/services/implementation/discovery.ts
+/**
+* Patterns for detecting spec references in source code.
+*/
+const SPEC_REFERENCE_PATTERNS = {
+	namedImport: /import\s*\{[^}]*\b(\w+(?:Spec|Contract|Command|Query))\b[^}]*\}\s*from/g,
+	defaultImport: /import\s+(\w+(?:Spec|Contract|Command|Query))\s+from/g,
+	contractHandler: /ContractHandler\s*<\s*typeof\s+(\w+)\s*>/g,
+	typeofSpec: /typeof\s+(\w+(?:Spec|Contract|Command|Query))\b/g,
+	specAssignment: /(?:spec|contract)\s*[:=]\s*(\w+(?:Spec|Contract|Command|Query))\b/gi
+};
+/**
+* File patterns that indicate implementation types.
+*/
+const IMPLEMENTATION_TYPE_PATTERNS = {
+	".handler.ts": "handler",
+	".handler.tsx": "handler",
+	".service.ts": "service",
+	".service.tsx": "service",
+	".test.ts": "test",
+	".test.tsx": "test",
+	".spec.ts": "test",
+	".spec.tsx": "test",
+	".component.tsx": "component",
+	".tsx": "component",
+	".form.tsx": "form",
+	".hook.ts": "hook",
+	".hook.tsx": "hook"
+};
+/**
+* Infer implementation type from file path.
+*/
+function inferImplementationType(filePath) {
+	const lowerPath = filePath.toLowerCase();
+	for (const [pattern, type] of Object.entries(IMPLEMENTATION_TYPE_PATTERNS)) if (lowerPath.endsWith(pattern)) return type;
+	if (lowerPath.includes("/handlers/")) return "handler";
+	if (lowerPath.includes("/services/")) return "service";
+	if (lowerPath.includes("/components/")) return "component";
+	if (lowerPath.includes("/forms/")) return "form";
+	if (lowerPath.includes("/hooks/")) return "hook";
+	if (lowerPath.includes("/__tests__/")) return "test";
+	return "other";
+}
+/**
+* Extract spec references from source code.
+*/
+function extractSpecReferences(code, filePath) {
+	const matches = [];
+	const seenSpecs = /* @__PURE__ */ new Set();
+	const addMatch = (specKey, referenceType, lineNumber) => {
+		const key = `${specKey}:${referenceType}`;
+		if (seenSpecs.has(key)) return;
+		seenSpecs.add(key);
+		matches.push({
+			filePath,
+			specKey,
+			referenceType,
+			lineNumber,
+			inferredType: inferImplementationType(filePath)
+		});
+	};
+	const getLineNumber = (position) => {
+		return code.substring(0, position).split("\n").length;
+	};
+	let match;
+	const handlerPattern = new RegExp(SPEC_REFERENCE_PATTERNS.contractHandler);
+	while ((match = handlerPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "handler", getLineNumber(match.index));
+	const typeofPattern = new RegExp(SPEC_REFERENCE_PATTERNS.typeofSpec);
+	while ((match = typeofPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "typeof", getLineNumber(match.index));
+	const namedPattern = new RegExp(SPEC_REFERENCE_PATTERNS.namedImport);
+	while ((match = namedPattern.exec(code)) !== null) {
+		const specNames = match[0].match(/\b(\w+(?:Spec|Contract|Command|Query))\b/g);
+		if (specNames) for (const name of specNames) addMatch(name, "import", getLineNumber(match.index));
+	}
+	const defaultPattern = new RegExp(SPEC_REFERENCE_PATTERNS.defaultImport);
+	while ((match = defaultPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "import", getLineNumber(match.index));
+	const assignPattern = new RegExp(SPEC_REFERENCE_PATTERNS.specAssignment);
+	while ((match = assignPattern.exec(code)) !== null) if (match[1]) addMatch(match[1], "unknown", getLineNumber(match.index));
+	return matches;
+}
+/**
+* Default glob patterns for implementation files.
+*/
+const DEFAULT_INCLUDE_PATTERNS = ["**/*.ts", "**/*.tsx"];
+const DEFAULT_EXCLUDE_PATTERNS = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.git/**",
+	"**/*.d.ts",
+	"**/*.operation.ts",
+	"**/*.spec.ts",
+	"**/*.feature.ts",
+	"**/*.event.ts",
+	"**/*.presentation.ts"
+];
+/**
+* Discover implementations that reference a specific spec.
+*/
+async function discoverImplementationsForSpec(specKey, adapters, options = {}) {
+	const { fs } = adapters;
+	const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;
+	const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;
+	const allMatches = [];
+	for (const pattern of includePatterns) {
+		const files = await fs.glob({
+			pattern,
+			ignore: excludePatterns
+		});
+		for (const filePath of files) try {
+			const matchingRefs = extractSpecReferences(await fs.readFile(filePath), filePath).filter((ref) => ref.specKey === specKey);
+			allMatches.push(...matchingRefs);
+		} catch {}
+	}
+	return allMatches;
+}
+/**
+* Discover all spec references in the workspace.
+* Returns a map of spec key to implementation references.
+*/
+async function discoverAllImplementations(adapters, options = {}) {
+	const { fs } = adapters;
+	const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;
+	const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;
+	const specToImplementations = /* @__PURE__ */ new Map();
+	for (const pattern of includePatterns) {
+		const files = await fs.glob({
+			pattern,
+			ignore: excludePatterns
+		});
+		for (const filePath of files) try {
+			const references = extractSpecReferences(await fs.readFile(filePath), filePath);
+			for (const ref of references) {
+				const existing = specToImplementations.get(ref.specKey) ?? [];
+				existing.push(ref);
+				specToImplementations.set(ref.specKey, existing);
+			}
+		} catch {}
+	}
+	return specToImplementations;
+}
+
+//#endregion
+export { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType };
+//# sourceMappingURL=discovery.js.map

package/dist/services/implementation/discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.js","names":["IMPLEMENTATION_TYPE_PATTERNS: Record<string, ImplementationType>","matches: SpecReferenceMatch[]","match: RegExpExecArray | null","allMatches: SpecReferenceMatch[]"],"sources":["../../../src/services/implementation/discovery.ts"],"sourcesContent":["/**\n * Implementation auto-discovery service.\n *\n * Scans workspace files to find implementations that reference specs.\n * Uses regex-based pattern matching for performance (avoids full AST parsing).\n */\n\nimport type { FsAdapter } from '../../ports/fs';\nimport type { ImplementationType } from '@contractspec/lib.contracts';\nimport type { DiscoveryOptions, SpecReferenceMatch } from './types';\n\n/**\n * Patterns for detecting spec references in source code.\n */\nconst SPEC_REFERENCE_PATTERNS = {\n  // import { SpecName } from './path'\n  namedImport:\n    /import\\s*\\{[^}]*\\b(\\w+(?:Spec|Contract|Command|Query))\\b[^}]*\\}\\s*from/g,\n  // import SpecName from './path'\n  defaultImport: /import\\s+(\\w+(?:Spec|Contract|Command|Query))\\s+from/g,\n  // ContractHandler<typeof SpecName>\n  contractHandler: /ContractHandler\\s*<\\s*typeof\\s+(\\w+)\\s*>/g,\n  // typeof SpecName (generic usage)\n  typeofSpec: /typeof\\s+(\\w+(?:Spec|Contract|Command|Query))\\b/g,\n  // spec: SpecKey or spec = SpecKey\n  specAssignment:\n    /(?:spec|contract)\\s*[:=]\\s*(\\w+(?:Spec|Contract|Command|Query))\\b/gi,\n};\n\n/**\n * File patterns that indicate implementation types.\n */\nconst IMPLEMENTATION_TYPE_PATTERNS: Record<string, ImplementationType> = {\n  '.handler.ts': 'handler',\n  '.handler.tsx': 'handler',\n  '.service.ts': 'service',\n  '.service.tsx': 'service',\n  '.test.ts': 'test',\n  '.test.tsx': 'test',\n  '.spec.ts': 'test',\n  '.spec.tsx': 'test',\n  '.component.tsx': 'component',\n  '.tsx': 'component', // Default for TSX files\n  '.form.tsx': 'form',\n  '.hook.ts': 'hook',\n  '.hook.tsx': 'hook',\n};\n\n/**\n * Infer implementation type from file path.\n */\nexport function inferImplementationType(filePath: string): ImplementationType {\n  const lowerPath = filePath.toLowerCase();\n\n  // Check specific patterns first (order matters)\n  for (const [pattern, type] of Object.entries(IMPLEMENTATION_TYPE_PATTERNS)) {\n    if (lowerPath.endsWith(pattern)) {\n      return type;\n    }\n  }\n\n  // Check directory patterns\n  if (lowerPath.includes('/handlers/')) return 'handler';\n  if (lowerPath.includes('/services/')) return 'service';\n  if (lowerPath.includes('/components/')) return 'component';\n  if (lowerPath.includes('/forms/')) return 'form';\n  if (lowerPath.includes('/hooks/')) return 'hook';\n  if (lowerPath.includes('/__tests__/')) return 'test';\n\n  return 'other';\n}\n\n/**\n * Extract spec references from source code.\n */\nexport function extractSpecReferences(\n  code: string,\n  filePath: string\n): SpecReferenceMatch[] {\n  const matches: SpecReferenceMatch[] = [];\n  const seenSpecs = new Set<string>();\n\n  // Helper to add unique matches\n  const addMatch = (\n    specKey: string,\n    referenceType: SpecReferenceMatch['referenceType'],\n    lineNumber?: number\n  ) => {\n    const key = `${specKey}:${referenceType}`;\n    if (seenSpecs.has(key)) return;\n    seenSpecs.add(key);\n\n    matches.push({\n      filePath,\n      specKey,\n      referenceType,\n      lineNumber,\n      inferredType: inferImplementationType(filePath),\n    });\n  };\n\n  // Find line number for a match position\n  const getLineNumber = (position: number): number => {\n    const lines = code.substring(0, position).split('\\n');\n    return lines.length;\n  };\n\n  // Check ContractHandler pattern (most specific)\n  let match: RegExpExecArray | null;\n  const handlerPattern = new RegExp(SPEC_REFERENCE_PATTERNS.contractHandler);\n  while ((match = handlerPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'handler', getLineNumber(match.index));\n    }\n  }\n\n  // Check typeof pattern\n  const typeofPattern = new RegExp(SPEC_REFERENCE_PATTERNS.typeofSpec);\n  while ((match = typeofPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'typeof', getLineNumber(match.index));\n    }\n  }\n\n  // Check named imports\n  const namedPattern = new RegExp(SPEC_REFERENCE_PATTERNS.namedImport);\n  while ((match = namedPattern.exec(code)) !== null) {\n    // Extract all spec names from the import statement\n    const importBlock = match[0];\n    const specNames = importBlock.match(\n      /\\b(\\w+(?:Spec|Contract|Command|Query))\\b/g\n    );\n    if (specNames) {\n      for (const name of specNames) {\n        addMatch(name, 'import', getLineNumber(match.index));\n      }\n    }\n  }\n\n  // Check default imports\n  const defaultPattern = new RegExp(SPEC_REFERENCE_PATTERNS.defaultImport);\n  while ((match = defaultPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'import', getLineNumber(match.index));\n    }\n  }\n\n  // Check spec assignments\n  const assignPattern = new RegExp(SPEC_REFERENCE_PATTERNS.specAssignment);\n  while ((match = assignPattern.exec(code)) !== null) {\n    if (match[1]) {\n      addMatch(match[1], 'unknown', getLineNumber(match.index));\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Default glob patterns for implementation files.\n */\nconst DEFAULT_INCLUDE_PATTERNS = ['**/*.ts', '**/*.tsx'];\n\nconst DEFAULT_EXCLUDE_PATTERNS = [\n  '**/node_modules/**',\n  '**/dist/**',\n  '**/.git/**',\n  '**/*.d.ts',\n  '**/*.operation.ts', // Skip spec files themselves\n  '**/*.spec.ts', // Skip test spec files\n  '**/*.feature.ts', // Skip feature files\n  '**/*.event.ts', // Skip event spec files\n  '**/*.presentation.ts', // Skip presentation files\n];\n\n/**\n * Discover implementations that reference a specific spec.\n */\nexport async function discoverImplementationsForSpec(\n  specKey: string,\n  adapters: { fs: FsAdapter },\n  options: DiscoveryOptions = {}\n): Promise<SpecReferenceMatch[]> {\n  const { fs } = adapters;\n  const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;\n  const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;\n\n  const allMatches: SpecReferenceMatch[] = [];\n\n  // Scan each include pattern\n  for (const pattern of includePatterns) {\n    const files = await fs.glob({ pattern, ignore: excludePatterns });\n\n    for (const filePath of files) {\n      try {\n        const content = await fs.readFile(filePath);\n        const references = extractSpecReferences(content, filePath);\n\n        // Filter to only references for the target spec\n        const matchingRefs = references.filter(\n          (ref) => ref.specKey === specKey\n        );\n        allMatches.push(...matchingRefs);\n      } catch {\n        // Skip files that can't be read\n      }\n    }\n  }\n\n  return allMatches;\n}\n\n/**\n * Discover all spec references in the workspace.\n * Returns a map of spec key to implementation references.\n */\nexport async function discoverAllImplementations(\n  adapters: { fs: FsAdapter },\n  options: DiscoveryOptions = {}\n): Promise<Map<string, SpecReferenceMatch[]>> {\n  const { fs } = adapters;\n  const includePatterns = options.includePatterns ?? DEFAULT_INCLUDE_PATTERNS;\n  const excludePatterns = options.excludePatterns ?? DEFAULT_EXCLUDE_PATTERNS;\n\n  const specToImplementations = new Map<string, SpecReferenceMatch[]>();\n\n  // Scan each include pattern\n  for (const pattern of includePatterns) {\n    const files = await fs.glob({ pattern, ignore: excludePatterns });\n\n    for (const filePath of files) {\n      try {\n        const content = await fs.readFile(filePath);\n        const references = extractSpecReferences(content, filePath);\n\n        // Group by spec key\n        for (const ref of references) {\n          const existing = specToImplementations.get(ref.specKey) ?? [];\n          existing.push(ref);\n          specToImplementations.set(ref.specKey, existing);\n        }\n      } catch {\n        // Skip files that can't be read\n      }\n    }\n  }\n\n  return specToImplementations;\n}\n"],"mappings":"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"}

package/dist/services/implementation/index.d.ts

@@ -0,0 +1,3 @@
+import { DiscoveryOptions, ImplementationSource, ImplementationStatus, ResolvedImplementation, SpecImplementationResult, SpecReferenceMatch } from "./types.js";
+import { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType } from "./discovery.js";
+import { ResolverOptions, getImplementationSummary, resolveAllImplementations, resolveImplementations } from "./resolver.js";

package/dist/services/implementation/index.js

@@ -0,0 +1,2 @@
+import { discoverAllImplementations, discoverImplementationsForSpec, extractSpecReferences, inferImplementationType } from "./discovery.js";
+import { getImplementationSummary, resolveAllImplementations, resolveImplementations } from "./resolver.js";

package/dist/services/implementation/resolver.d.ts

@@ -0,0 +1,44 @@
+import { FsAdapter } from "../../ports/fs.js";
+import { DiscoveryOptions, SpecImplementationResult } from "./types.js";
+import { WorkspaceConfig } from "@contractspec/module.workspace";
+
+//#region src/services/implementation/resolver.d.ts
+
+/**
+ * Options for resolving implementations.
+ */
+interface ResolverOptions extends DiscoveryOptions {
+  /** Include explicit implementations from spec */
+  includeExplicit?: boolean;
+  /** Include auto-discovered implementations */
+  includeDiscovered?: boolean;
+  /** Include convention-based implementations */
+  includeConvention?: boolean;
+  /** Output directory for convention-based paths */
+  outputDir?: string;
+}
+/**
+ * Resolve all implementations for a spec file.
+ */
+declare function resolveImplementations(specFile: string, adapters: {
+  fs: FsAdapter;
+}, config: WorkspaceConfig, options?: ResolverOptions): Promise<SpecImplementationResult>;
+/**
+ * Resolve implementations for multiple spec files.
+ */
+declare function resolveAllImplementations(specFiles: string[], adapters: {
+  fs: FsAdapter;
+}, config: WorkspaceConfig, options?: ResolverOptions): Promise<SpecImplementationResult[]>;
+/**
+ * Get implementation summary statistics.
+ */
+declare function getImplementationSummary(results: SpecImplementationResult[]): {
+  total: number;
+  implemented: number;
+  partial: number;
+  missing: number;
+  coverage: number;
+};
+//#endregion
+export { ResolverOptions, getImplementationSummary, resolveAllImplementations, resolveImplementations };
+//# sourceMappingURL=resolver.d.ts.map

package/dist/services/implementation/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","names":[],"sources":["../../../src/services/implementation/resolver.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiVA;AAEkB,UAvTD,eAAA,SAAwB,gBAuTvB,CAAA;EACR;EACC,eAAA,CAAA,EAAA,OAAA;EACA;EAAR,iBAAA,CAAA,EAAA,OAAA;EAAO;EA2BM,iBAAA,CAAA,EAAA,OAAwB;;;;;;;iBAzNlB,sBAAA;MAEJ;WACR,2BACC,kBACR,QAAQ;;;;iBAoLW,yBAAA;MAEJ;WACR,2BACC,kBACR,QAAQ;;;;iBA2BK,wBAAA,UAAkC"}

package/dist/services/implementation/resolver.js

@@ -0,0 +1,224 @@
+import { discoverImplementationsForSpec } from "./discovery.js";
+import { scanSpecSource } from "@contractspec/module.workspace";
+import { createHash } from "crypto";
+
+//#region src/services/implementation/resolver.ts
+/**
+* Implementation resolver service.
+*
+* Resolves all implementations for a spec by merging:
+* 1. Explicit mappings from spec.implementations
+* 2. Auto-discovered references from workspace scanning
+* 3. Convention-based paths (naming conventions)
+*/
+const DEFAULT_OPTIONS = {
+	includeExplicit: true,
+	includeDiscovered: true,
+	includeConvention: true,
+	computeHashes: true
+};
+/**
+* Convert string to kebab-case.
+*/
+function toKebabCase(value) {
+	return value.replace(/\./g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Compute SHA256 hash of content.
+*/
+function computeHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Get convention-based implementation paths for a spec.
+*/
+function getConventionPaths(specType, specKey, outputDir) {
+	const kebab = toKebabCase(specKey);
+	const paths = [];
+	if (specType === "operation") {
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.ts`,
+			type: "handler"
+		});
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.test.ts`,
+			type: "test"
+		});
+	}
+	if (specType === "presentation") {
+		paths.push({
+			path: `${outputDir}/components/${kebab}.tsx`,
+			type: "component"
+		});
+		paths.push({
+			path: `${outputDir}/components/${kebab}.test.tsx`,
+			type: "test"
+		});
+	}
+	if (specType === "form") {
+		paths.push({
+			path: `${outputDir}/forms/${kebab}.form.tsx`,
+			type: "form"
+		});
+		paths.push({
+			path: `${outputDir}/forms/${kebab}.form.test.tsx`,
+			type: "test"
+		});
+	}
+	if (specType === "event") {
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.ts`,
+			type: "handler"
+		});
+		paths.push({
+			path: `${outputDir}/handlers/${kebab}.handler.test.ts`,
+			type: "test"
+		});
+	}
+	return paths;
+}
+/**
+* Determine overall implementation status.
+*/
+function determineStatus(implementations) {
+	if (implementations.length === 0) return "missing";
+	const existingImpls = implementations.filter((i) => i.exists);
+	implementations.filter((i) => i.type !== "test");
+	if (existingImpls.filter((i) => i.type !== "test").length === 0) return "missing";
+	if (implementations.every((i) => i.exists)) return "implemented";
+	return "partial";
+}
+/**
+* Resolve all implementations for a spec file.
+*/
+async function resolveImplementations(specFile, adapters, config, options = {}) {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	const { fs } = adapters;
+	if (!await fs.exists(specFile)) throw new Error(`Spec file not found: ${specFile}`);
+	const specContent = await fs.readFile(specFile);
+	const specHash = opts.computeHashes ? computeHash(specContent) : void 0;
+	const scan = scanSpecSource(specContent, specFile);
+	const specKey = scan.key ?? fs.basename(specFile).replace(/\.[jt]s$/, "");
+	const specVersion = scan.version ?? 1;
+	const specType = scan.specType ?? "operation";
+	const implementations = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const addImpl = async (path, type, source, description) => {
+		if (seenPaths.has(path)) return;
+		seenPaths.add(path);
+		const exists = await fs.exists(path);
+		let contentHash;
+		if (exists && opts.computeHashes) try {
+			contentHash = computeHash(await fs.readFile(path));
+		} catch {}
+		implementations.push({
+			path,
+			type,
+			source,
+			exists,
+			contentHash,
+			description
+		});
+	};
+	if (opts.includeExplicit) {
+		const explicitImpls = parseExplicitImplementations(specContent);
+		for (const impl of explicitImpls) await addImpl(impl.path, impl.type, "explicit", impl.description);
+	}
+	if (opts.includeDiscovered) {
+		const discovered = await discoverImplementationsForSpec(specKey, adapters, opts);
+		const specKeyVariants = getSpecKeyVariants(specKey);
+		for (const variant of specKeyVariants) {
+			const variantDiscovered = await discoverImplementationsForSpec(variant, adapters, opts);
+			discovered.push(...variantDiscovered);
+		}
+		for (const ref of discovered) {
+			if (ref.filePath === specFile) continue;
+			await addImpl(ref.filePath, ref.inferredType, "discovered");
+		}
+	}
+	if (opts.includeConvention) {
+		const conventionPaths = getConventionPaths(specType, specKey, opts.outputDir ?? config.outputDir ?? "./src");
+		for (const { path, type } of conventionPaths) await addImpl(path, type, "convention");
+	}
+	return {
+		specKey,
+		specVersion,
+		specPath: specFile,
+		specType,
+		implementations,
+		status: determineStatus(implementations),
+		specHash
+	};
+}
+/**
+* Parse explicit implementations from spec source code.
+* Looks for: implementations: [{ path: '...', type: '...' }]
+*/
+function parseExplicitImplementations(code) {
+	const implementations = [];
+	const implMatch = code.match(/implementations\s*:\s*\[([\s\S]*?)\]/);
+	if (!implMatch) return implementations;
+	const implBlock = implMatch[1];
+	if (!implBlock) return implementations;
+	const objRegex = /\{\s*path\s*:\s*['"`]([^'"`]+)['"`]\s*,\s*type\s*:\s*['"`]([^'"`]+)['"`](?:\s*,\s*description\s*:\s*['"`]([^'"`]+)['"`])?\s*\}/g;
+	let match;
+	while ((match = objRegex.exec(implBlock)) !== null) if (match[1] && match[2]) implementations.push({
+		path: match[1],
+		type: match[2],
+		description: match[3]
+	});
+	return implementations;
+}
+/**
+* Get common variants of a spec key for discovery.
+*/
+function getSpecKeyVariants(specKey) {
+	const variants = [];
+	const base = specKey.replace(/Spec$/, "").replace(/Contract$/, "").replace(/Command$/, "").replace(/Query$/, "");
+	if (base !== specKey) {
+		variants.push(base);
+		variants.push(`${base}Spec`);
+		variants.push(`${base}Contract`);
+	}
+	const parts = specKey.split(".");
+	if (parts.length > 1) {
+		const pascalName = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+		variants.push(pascalName);
+	}
+	return variants;
+}
+/**
+* Resolve implementations for multiple spec files.
+*/
+async function resolveAllImplementations(specFiles, adapters, config, options = {}) {
+	const results = [];
+	for (const specFile of specFiles) try {
+		const result = await resolveImplementations(specFile, adapters, config, options);
+		results.push(result);
+	} catch (error) {
+		console.error(`Failed to resolve implementations for ${specFile}:`, error);
+	}
+	return results;
+}
+/**
+* Get implementation summary statistics.
+*/
+function getImplementationSummary(results) {
+	const implemented = results.filter((r) => r.status === "implemented").length;
+	const partial = results.filter((r) => r.status === "partial").length;
+	const missing = results.filter((r) => r.status === "missing").length;
+	return {
+		total: results.length,
+		implemented,
+		partial,
+		missing,
+		coverage: results.length > 0 ? Math.round(implemented / results.length * 100) : 100
+	};
+}
+
+//#endregion
+export { getImplementationSummary, resolveAllImplementations, resolveImplementations };
+//# sourceMappingURL=resolver.js.map

package/dist/services/implementation/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","names":["DEFAULT_OPTIONS: ResolverOptions","paths: { path: string; type: ImplementationType }[]","implementations: ResolvedImplementation[]","contentHash: string | undefined","implementations: ImplementationRef[]","match: RegExpExecArray | null","variants: string[]","results: SpecImplementationResult[]"],"sources":["../../../src/services/implementation/resolver.ts"],"sourcesContent":["/**\n * Implementation resolver service.\n *\n * Resolves all implementations for a spec by merging:\n * 1. Explicit mappings from spec.implementations\n * 2. Auto-discovered references from workspace scanning\n * 3. Convention-based paths (naming conventions)\n */\n\nimport { createHash } from 'crypto';\nimport type { WorkspaceConfig } from '@contractspec/module.workspace';\nimport { scanSpecSource } from '@contractspec/module.workspace';\nimport type {\n  ImplementationRef,\n  ImplementationType,\n} from '@contractspec/lib.contracts';\nimport type { FsAdapter } from '../../ports/fs';\nimport type {\n  DiscoveryOptions,\n  ImplementationStatus,\n  ResolvedImplementation,\n  SpecImplementationResult,\n} from './types';\nimport { discoverImplementationsForSpec } from './discovery';\n\n/**\n * Options for resolving implementations.\n */\nexport interface ResolverOptions extends DiscoveryOptions {\n  /** Include explicit implementations from spec */\n  includeExplicit?: boolean;\n  /** Include auto-discovered implementations */\n  includeDiscovered?: boolean;\n  /** Include convention-based implementations */\n  includeConvention?: boolean;\n  /** Output directory for convention-based paths */\n  outputDir?: string;\n}\n\nconst DEFAULT_OPTIONS: ResolverOptions = {\n  includeExplicit: true,\n  includeDiscovered: true,\n  includeConvention: true,\n  computeHashes: true,\n};\n\n/**\n * Convert string to kebab-case.\n */\nfunction toKebabCase(value: string): string {\n  return value\n    .replace(/\\./g, '-')\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .toLowerCase();\n}\n\n/**\n * Compute SHA256 hash of content.\n */\nfunction computeHash(content: string): string {\n  return createHash('sha256').update(content).digest('hex');\n}\n\n/**\n * Get convention-based implementation paths for a spec.\n */\nfunction getConventionPaths(\n  specType: string,\n  specKey: string,\n  outputDir: string\n): { path: string; type: ImplementationType }[] {\n  const kebab = toKebabCase(specKey);\n  const paths: { path: string; type: ImplementationType }[] = [];\n\n  if (specType === 'operation') {\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.ts`,\n      type: 'handler',\n    });\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.test.ts`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'presentation') {\n    paths.push({\n      path: `${outputDir}/components/${kebab}.tsx`,\n      type: 'component',\n    });\n    paths.push({\n      path: `${outputDir}/components/${kebab}.test.tsx`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'form') {\n    paths.push({\n      path: `${outputDir}/forms/${kebab}.form.tsx`,\n      type: 'form',\n    });\n    paths.push({\n      path: `${outputDir}/forms/${kebab}.form.test.tsx`,\n      type: 'test',\n    });\n  }\n\n  if (specType === 'event') {\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.ts`,\n      type: 'handler',\n    });\n    paths.push({\n      path: `${outputDir}/handlers/${kebab}.handler.test.ts`,\n      type: 'test',\n    });\n  }\n\n  return paths;\n}\n\n/**\n * Determine overall implementation status.\n */\nfunction determineStatus(\n  implementations: ResolvedImplementation[]\n): ImplementationStatus {\n  if (implementations.length === 0) {\n    return 'missing';\n  }\n\n  const existingImpls = implementations.filter((i) => i.exists);\n  const _nonTestImpls = implementations.filter((i) => i.type !== 'test');\n  const existingNonTestImpls = existingImpls.filter((i) => i.type !== 'test');\n\n  // If no non-test implementations exist, it's missing\n  if (existingNonTestImpls.length === 0) {\n    return 'missing';\n  }\n\n  // If all expected implementations exist, it's fully implemented\n  if (implementations.every((i) => i.exists)) {\n    return 'implemented';\n  }\n\n  // Some exist, some don't\n  return 'partial';\n}\n\n/**\n * Resolve all implementations for a spec file.\n */\nexport async function resolveImplementations(\n  specFile: string,\n  adapters: { fs: FsAdapter },\n  config: WorkspaceConfig,\n  options: ResolverOptions = {}\n): Promise<SpecImplementationResult> {\n  const opts = { ...DEFAULT_OPTIONS, ...options };\n  const { fs } = adapters;\n\n  // Read and parse spec file\n  const specExists = await fs.exists(specFile);\n  if (!specExists) {\n    throw new Error(`Spec file not found: ${specFile}`);\n  }\n\n  const specContent = await fs.readFile(specFile);\n  const specHash = opts.computeHashes ? computeHash(specContent) : undefined;\n  const scan = scanSpecSource(specContent, specFile);\n\n  const specKey = scan.key ?? fs.basename(specFile).replace(/\\.[jt]s$/, '');\n  const specVersion = scan.version ?? 1;\n  const specType = scan.specType ?? 'operation';\n\n  const implementations: ResolvedImplementation[] = [];\n  const seenPaths = new Set<string>();\n\n  // Helper to add unique implementations\n  const addImpl = async (\n    path: string,\n    type: ImplementationType,\n    source: ResolvedImplementation['source'],\n    description?: string\n  ) => {\n    if (seenPaths.has(path)) return;\n    seenPaths.add(path);\n\n    const exists = await fs.exists(path);\n    let contentHash: string | undefined;\n\n    if (exists && opts.computeHashes) {\n      try {\n        const content = await fs.readFile(path);\n        contentHash = computeHash(content);\n      } catch {\n        // Ignore hash computation errors\n      }\n    }\n\n    implementations.push({\n      path,\n      type,\n      source,\n      exists,\n      contentHash,\n      description,\n    });\n  };\n\n  // 1. Add explicit implementations from spec\n  if (opts.includeExplicit) {\n    // Parse explicit implementations from spec source\n    const explicitImpls = parseExplicitImplementations(specContent);\n    for (const impl of explicitImpls) {\n      await addImpl(impl.path, impl.type, 'explicit', impl.description);\n    }\n  }\n\n  // 2. Add auto-discovered implementations\n  if (opts.includeDiscovered) {\n    const discovered = await discoverImplementationsForSpec(\n      specKey,\n      adapters,\n      opts\n    );\n\n    // Also search for spec key variants\n    const specKeyVariants = getSpecKeyVariants(specKey);\n    for (const variant of specKeyVariants) {\n      const variantDiscovered = await discoverImplementationsForSpec(\n        variant,\n        adapters,\n        opts\n      );\n      discovered.push(...variantDiscovered);\n    }\n\n    for (const ref of discovered) {\n      // Skip the spec file itself\n      if (ref.filePath === specFile) continue;\n\n      await addImpl(ref.filePath, ref.inferredType, 'discovered');\n    }\n  }\n\n  // 3. Add convention-based implementations\n  if (opts.includeConvention) {\n    const outputDir = opts.outputDir ?? config.outputDir ?? './src';\n    const conventionPaths = getConventionPaths(specType, specKey, outputDir);\n\n    for (const { path, type } of conventionPaths) {\n      await addImpl(path, type, 'convention');\n    }\n  }\n\n  // Determine overall status\n  const status = determineStatus(implementations);\n\n  return {\n    specKey,\n    specVersion,\n    specPath: specFile,\n    specType,\n    implementations,\n    status,\n    specHash,\n  };\n}\n\n/**\n * Parse explicit implementations from spec source code.\n * Looks for: implementations: [{ path: '...', type: '...' }]\n */\nfunction parseExplicitImplementations(code: string): ImplementationRef[] {\n  const implementations: ImplementationRef[] = [];\n\n  // Simple regex to find implementations array\n  const implMatch = code.match(/implementations\\s*:\\s*\\[([\\s\\S]*?)\\]/);\n\n  if (!implMatch) return implementations;\n\n  const implBlock = implMatch[1];\n  if (!implBlock) return implementations;\n\n  // Find each { path: '...', type: '...' } object\n  const objRegex =\n    /\\{\\s*path\\s*:\\s*['\"`]([^'\"`]+)['\"`]\\s*,\\s*type\\s*:\\s*['\"`]([^'\"`]+)['\"`](?:\\s*,\\s*description\\s*:\\s*['\"`]([^'\"`]+)['\"`])?\\s*\\}/g;\n\n  let match: RegExpExecArray | null;\n  while ((match = objRegex.exec(implBlock)) !== null) {\n    if (match[1] && match[2]) {\n      implementations.push({\n        path: match[1],\n        type: match[2] as ImplementationType,\n        description: match[3],\n      });\n    }\n  }\n\n  return implementations;\n}\n\n/**\n * Get common variants of a spec key for discovery.\n */\nfunction getSpecKeyVariants(specKey: string): string[] {\n  const variants: string[] = [];\n\n  // Remove common suffixes\n  const base = specKey\n    .replace(/Spec$/, '')\n    .replace(/Contract$/, '')\n    .replace(/Command$/, '')\n    .replace(/Query$/, '');\n\n  if (base !== specKey) {\n    variants.push(base);\n    variants.push(`${base}Spec`);\n    variants.push(`${base}Contract`);\n  }\n\n  // Add PascalCase variant\n  const parts = specKey.split('.');\n  if (parts.length > 1) {\n    const pascalName = parts\n      .map((p) => p.charAt(0).toUpperCase() + p.slice(1))\n      .join('');\n    variants.push(pascalName);\n  }\n\n  return variants;\n}\n\n/**\n * Resolve implementations for multiple spec files.\n */\nexport async function resolveAllImplementations(\n  specFiles: string[],\n  adapters: { fs: FsAdapter },\n  config: WorkspaceConfig,\n  options: ResolverOptions = {}\n): Promise<SpecImplementationResult[]> {\n  const results: SpecImplementationResult[] = [];\n\n  for (const specFile of specFiles) {\n    try {\n      const result = await resolveImplementations(\n        specFile,\n        adapters,\n        config,\n        options\n      );\n      results.push(result);\n    } catch (error) {\n      // Log error but continue with other specs\n      console.error(\n        `Failed to resolve implementations for ${specFile}:`,\n        error\n      );\n    }\n  }\n\n  return results;\n}\n\n/**\n * Get implementation summary statistics.\n */\nexport function getImplementationSummary(results: SpecImplementationResult[]): {\n  total: number;\n  implemented: number;\n  partial: number;\n  missing: number;\n  coverage: number;\n} {\n  const implemented = results.filter((r) => r.status === 'implemented').length;\n  const partial = results.filter((r) => r.status === 'partial').length;\n  const missing = results.filter((r) => r.status === 'missing').length;\n\n  return {\n    total: results.length,\n    implemented,\n    partial,\n    missing,\n    coverage:\n      results.length > 0\n        ? Math.round((implemented / results.length) * 100)\n        : 100,\n  };\n}\n"],"mappings":"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"}