@contractspec/bundle.workspace 1.46.2 → 1.48.0

package/dist/services/implementation/resolver/index.mjs

@@ -0,0 +1,111 @@
+import { discoverImplementationsForSpec } from "../discovery.mjs";
+import { getConventionPaths, toKebabCase } from "./conventions.mjs";
+import { getSpecKeyVariants, parseExplicitImplementations } from "./parsers.mjs";
+import { determineStatus, getImplementationSummary } from "./status.mjs";
+import { scanSpecSource } from "@contractspec/module.workspace";
+import path from "path";
+import { createHash } from "crypto";
+
+//#region src/services/implementation/resolver/index.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
+};
+/**
+* Compute SHA256 hash of content.
+*/
+function computeHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* 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 ?? path.basename(specFile).replace(/\.[jt]s$/, "");
+	const specVersion = scan.version ?? "1.0.0";
+	const specType = scan.specType ?? "operation";
+	const implementations = [];
+	const seenPaths = /* @__PURE__ */ new Set();
+	const addImpl = async (path$1, type, source, description) => {
+		if (seenPaths.has(path$1)) return;
+		seenPaths.add(path$1);
+		const exists = await fs.exists(path$1);
+		let contentHash;
+		if (exists && opts.computeHashes) try {
+			contentHash = computeHash(await fs.readFile(path$1));
+		} catch {}
+		implementations.push({
+			path: path$1,
+			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: path$1, type } of conventionPaths) await addImpl(path$1, type, "convention");
+	}
+	return {
+		specKey,
+		specVersion,
+		specPath: specFile,
+		specType,
+		implementations,
+		status: determineStatus(implementations),
+		specHash
+	};
+}
+/**
+* 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;
+}
+
+//#endregion
+export { resolveAllImplementations, resolveImplementations };
+//# sourceMappingURL=index.mjs.map

package/dist/services/implementation/resolver/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["path"],"sources":["../../../../src/services/implementation/resolver/index.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 path from 'path';\n\nimport type { WorkspaceConfig } from '@contractspec/module.workspace';\nimport { scanSpecSource } from '@contractspec/module.workspace';\nimport type { ImplementationType } from '@contractspec/lib.contracts';\nimport type { FsAdapter } from '../../../ports/fs';\nimport type {\n  ResolverOptions,\n  ResolvedImplementation,\n  SpecImplementationResult,\n} from '../types';\nimport { discoverImplementationsForSpec } from '../discovery';\n\nimport { getConventionPaths } from './conventions';\nimport { getSpecKeyVariants, parseExplicitImplementations } from './parsers';\nimport { determineStatus } from './status';\n\nexport * from './parsers';\nexport * from './conventions';\nexport * from './status';\n\nconst DEFAULT_OPTIONS: ResolverOptions = {\n  includeExplicit: true,\n  includeDiscovered: true,\n  includeConvention: true,\n  computeHashes: true,\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 * 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 ?? path.basename(specFile).replace(/\\.[jt]s$/, '');\n  const specVersion = scan.version ?? '1.0.0';\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 * 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"],"mappings":";;;;;;;;;;;;;;;;;AA+BA,MAAM,kBAAmC;CACvC,iBAAiB;CACjB,mBAAmB;CACnB,mBAAmB;CACnB,eAAe;CAChB;;;;AAKD,SAAS,YAAY,SAAyB;AAC5C,QAAO,WAAW,SAAS,CAAC,OAAO,QAAQ,CAAC,OAAO,MAAM;;;;;AAM3D,eAAsB,uBACpB,UACA,UACA,QACA,UAA2B,EAAE,EACM;CACnC,MAAM,OAAO;EAAE,GAAG;EAAiB,GAAG;EAAS;CAC/C,MAAM,EAAE,OAAO;AAIf,KAAI,CADe,MAAM,GAAG,OAAO,SAAS,CAE1C,OAAM,IAAI,MAAM,wBAAwB,WAAW;CAGrD,MAAM,cAAc,MAAM,GAAG,SAAS,SAAS;CAC/C,MAAM,WAAW,KAAK,gBAAgB,YAAY,YAAY,GAAG;CACjE,MAAM,OAAO,eAAe,aAAa,SAAS;CAElD,MAAM,UAAU,KAAK,OAAO,KAAK,SAAS,SAAS,CAAC,QAAQ,YAAY,GAAG;CAC3E,MAAM,cAAc,KAAK,WAAW;CACpC,MAAM,WAAW,KAAK,YAAY;CAElC,MAAM,kBAA4C,EAAE;CACpD,MAAM,4BAAY,IAAI,KAAa;CAGnC,MAAM,UAAU,OACd,QACA,MACA,QACA,gBACG;AACH,MAAI,UAAU,IAAIA,OAAK,CAAE;AACzB,YAAU,IAAIA,OAAK;EAEnB,MAAM,SAAS,MAAM,GAAG,OAAOA,OAAK;EACpC,IAAI;AAEJ,MAAI,UAAU,KAAK,cACjB,KAAI;AAEF,iBAAc,YADE,MAAM,GAAG,SAASA,OAAK,CACL;UAC5B;AAKV,kBAAgB,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;;AAIJ,KAAI,KAAK,iBAAiB;EAExB,MAAM,gBAAgB,6BAA6B,YAAY;AAC/D,OAAK,MAAM,QAAQ,cACjB,OAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,YAAY,KAAK,YAAY;;AAKrE,KAAI,KAAK,mBAAmB;EAC1B,MAAM,aAAa,MAAM,+BACvB,SACA,UACA,KACD;EAGD,MAAM,kBAAkB,mBAAmB,QAAQ;AACnD,OAAK,MAAM,WAAW,iBAAiB;GACrC,MAAM,oBAAoB,MAAM,+BAC9B,SACA,UACA,KACD;AACD,cAAW,KAAK,GAAG,kBAAkB;;AAGvC,OAAK,MAAM,OAAO,YAAY;AAE5B,OAAI,IAAI,aAAa,SAAU;AAE/B,SAAM,QAAQ,IAAI,UAAU,IAAI,cAAc,aAAa;;;AAK/D,KAAI,KAAK,mBAAmB;EAE1B,MAAM,kBAAkB,mBAAmB,UAAU,SADnC,KAAK,aAAa,OAAO,aAAa,QACgB;AAExE,OAAK,MAAM,EAAE,cAAM,UAAU,gBAC3B,OAAM,QAAQA,QAAM,MAAM,aAAa;;AAO3C,QAAO;EACL;EACA;EACA,UAAU;EACV;EACA;EACA,QARa,gBAAgB,gBAAgB;EAS7C;EACD;;;;;AAMH,eAAsB,0BACpB,WACA,UACA,QACA,UAA2B,EAAE,EACQ;CACrC,MAAM,UAAsC,EAAE;AAE9C,MAAK,MAAM,YAAY,UACrB,KAAI;EACF,MAAM,SAAS,MAAM,uBACnB,UACA,UACA,QACA,QACD;AACD,UAAQ,KAAK,OAAO;UACb,OAAO;AAEd,UAAQ,MACN,yCAAyC,SAAS,IAClD,MACD;;AAIL,QAAO"}

package/dist/services/implementation/resolver/parsers.d.mts

@@ -0,0 +1,16 @@
+import { ImplementationRef } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/resolver/parsers.d.ts
+
+/**
+ * Parse explicit implementations from spec source code using ts-morph.
+ * Looks for: implementations: [{ path: '...', type: '...' }] inside the main spec object.
+ */
+declare function parseExplicitImplementations(code: string): ImplementationRef[];
+/**
+ * Get common variants of a spec key for discovery.
+ */
+declare function getSpecKeyVariants(specKey: string): string[];
+//#endregion
+export { getSpecKeyVariants, parseExplicitImplementations };
+//# sourceMappingURL=parsers.d.mts.map

package/dist/services/implementation/resolver/parsers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/parsers.ts"],"sourcesContent":[],"mappings":";;;;AAqIA;;;;iBAvHgB,4BAAA,gBAEb;;;;iBAqHa,kBAAA"}

package/dist/services/implementation/resolver/parsers.mjs

@@ -0,0 +1,100 @@
+import { Node, Project, SyntaxKind } from "ts-morph";
+
+//#region src/services/implementation/resolver/parsers.ts
+/**
+* Parse explicit implementations from spec source code using ts-morph.
+* Looks for: implementations: [{ path: '...', type: '...' }] inside the main spec object.
+*/
+function parseExplicitImplementations(code) {
+	const implementations = [];
+	const sourceFile = new Project({ useInMemoryFileSystem: true }).createSourceFile("spec.ts", code);
+	const extractImpls = (obj) => {
+		if (!Node.isObjectLiteralExpression(obj)) return;
+		const prop = obj.getProperty("implementations");
+		if (prop && Node.isPropertyAssignment(prop)) {
+			const init = prop.getInitializer();
+			if (init && Node.isArrayLiteralExpression(init)) {
+				for (const elem of init.getElements()) if (Node.isObjectLiteralExpression(elem)) {
+					let pathVal;
+					let typeVal;
+					let descVal;
+					const pathProp = elem.getProperty("path");
+					if (pathProp && Node.isPropertyAssignment(pathProp)) {
+						const init$1 = pathProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) pathVal = init$1.getLiteralText();
+					}
+					const typeProp = elem.getProperty("type");
+					if (typeProp && Node.isPropertyAssignment(typeProp)) {
+						const init$1 = typeProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) typeVal = init$1.getLiteralText();
+					}
+					const descProp = elem.getProperty("description");
+					if (descProp && Node.isPropertyAssignment(descProp)) {
+						const init$1 = descProp.getInitializer();
+						if (Node.isStringLiteral(init$1)) descVal = init$1.getLiteralText();
+					}
+					if (pathVal && typeVal) implementations.push({
+						path: pathVal,
+						type: typeVal,
+						description: descVal
+					});
+				}
+			}
+		}
+	};
+	const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+	for (const call of callExpressions) {
+		const expr = call.getExpression().getText();
+		if ([
+			"defineCommand",
+			"defineQuery",
+			"defineEvent",
+			"defineFeature"
+		].includes(expr)) {
+			const args = call.getArguments();
+			if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+				extractImpls(args[0]);
+				return implementations;
+			}
+		}
+	}
+	const varStmts = sourceFile.getVariableStatements();
+	for (const stmt of varStmts) if (stmt.isExported()) for (const decl of stmt.getDeclarations()) {
+		const init = decl.getInitializer();
+		if (init && Node.isObjectLiteralExpression(init)) {
+			if (init.getProperty("implementations")) {
+				extractImpls(init);
+				return implementations;
+			}
+		}
+	}
+	const exportAssign = sourceFile.getExportAssignment((d) => !d.isExportEquals());
+	if (exportAssign) {
+		const expr = exportAssign.getExpression();
+		if (Node.isObjectLiteralExpression(expr)) extractImpls(expr);
+		else if (Node.isAsExpression(expr) && Node.isObjectLiteralExpression(expr.getExpression())) extractImpls(expr.getExpression());
+	}
+	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;
+}
+
+//#endregion
+export { getSpecKeyVariants, parseExplicitImplementations };
+//# sourceMappingURL=parsers.mjs.map

package/dist/services/implementation/resolver/parsers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.mjs","names":["init"],"sources":["../../../../src/services/implementation/resolver/parsers.ts"],"sourcesContent":["/**\n * Parser utilities for extracting implementation references from source code.\n */\n\nimport type {\n  ImplementationRef,\n  ImplementationType,\n} from '@contractspec/lib.contracts';\nimport { Node, Project, SyntaxKind } from 'ts-morph';\n\n/**\n * Parse explicit implementations from spec source code using ts-morph.\n * Looks for: implementations: [{ path: '...', type: '...' }] inside the main spec object.\n */\nexport function parseExplicitImplementations(\n  code: string\n): ImplementationRef[] {\n  const implementations: ImplementationRef[] = [];\n  const project = new Project({ useInMemoryFileSystem: true });\n  // Create a SourceFile\n  const sourceFile = project.createSourceFile('spec.ts', code);\n\n  // Helper to extract fields from an object literal\n  const extractImpls = (obj: Node) => {\n    if (!Node.isObjectLiteralExpression(obj)) return;\n    const prop = obj.getProperty('implementations');\n    if (prop && Node.isPropertyAssignment(prop)) {\n      const init = prop.getInitializer();\n      if (init && Node.isArrayLiteralExpression(init)) {\n        for (const elem of init.getElements()) {\n          if (Node.isObjectLiteralExpression(elem)) {\n            let pathVal: string | undefined;\n            let typeVal: ImplementationType | undefined;\n            let descVal: string | undefined;\n\n            const pathProp = elem.getProperty('path');\n            if (pathProp && Node.isPropertyAssignment(pathProp)) {\n              const init = pathProp.getInitializer();\n              if (Node.isStringLiteral(init)) {\n                pathVal = init.getLiteralText();\n              }\n            }\n\n            const typeProp = elem.getProperty('type');\n            if (typeProp && Node.isPropertyAssignment(typeProp)) {\n              const init = typeProp.getInitializer();\n              if (Node.isStringLiteral(init)) {\n                typeVal = init.getLiteralText() as ImplementationType;\n              }\n            }\n\n            const descProp = elem.getProperty('description');\n            if (descProp && Node.isPropertyAssignment(descProp)) {\n              const init = descProp.getInitializer();\n              if (Node.isStringLiteral(init)) {\n                descVal = init.getLiteralText();\n              }\n            }\n\n            if (pathVal && typeVal) {\n              implementations.push({\n                path: pathVal,\n                type: typeVal,\n                description: descVal,\n              });\n            }\n          }\n        }\n      }\n    }\n  };\n\n  // Find the spec object\n  // 1. defineCommand/Event/etc CallExpression\n  // 2. Exported object literal or variable\n\n  const callExpressions = sourceFile.getDescendantsOfKind(\n    SyntaxKind.CallExpression\n  );\n  for (const call of callExpressions) {\n    const expr = call.getExpression().getText();\n    if (\n      ['defineCommand', 'defineQuery', 'defineEvent', 'defineFeature'].includes(\n        expr\n      )\n    ) {\n      const args = call.getArguments();\n      if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {\n        extractImpls(args[0]);\n        return implementations; // Assume only one main definition per file\n      }\n    }\n  }\n\n  // Fallback: search exported variables\n  const varStmts = sourceFile.getVariableStatements();\n  for (const stmt of varStmts) {\n    if (stmt.isExported()) {\n      for (const decl of stmt.getDeclarations()) {\n        const init = decl.getInitializer();\n        if (init && Node.isObjectLiteralExpression(init)) {\n          // Check if it has 'implementations'\n          if (init.getProperty('implementations')) {\n            extractImpls(init);\n            return implementations;\n          }\n        }\n      }\n    }\n  }\n\n  // Fallback: default export\n  const exportAssign = sourceFile.getExportAssignment(\n    (d) => !d.isExportEquals()\n  );\n  if (exportAssign) {\n    const expr = exportAssign.getExpression();\n    if (Node.isObjectLiteralExpression(expr)) {\n      extractImpls(expr);\n    } else if (\n      Node.isAsExpression(expr) &&\n      Node.isObjectLiteralExpression(expr.getExpression())\n    ) {\n      extractImpls(expr.getExpression());\n    }\n  }\n\n  return implementations;\n}\n\n/**\n * Get common variants of a spec key for discovery.\n */\nexport function 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"],"mappings":"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"}

package/dist/services/implementation/resolver/status.d.mts

@@ -0,0 +1,21 @@
+import { ImplementationStatus, ResolvedImplementation, SpecImplementationResult } from "../types.mjs";
+
+//#region src/services/implementation/resolver/status.d.ts
+
+/**
+ * Determine overall implementation status.
+ */
+declare function determineStatus(implementations: ResolvedImplementation[]): ImplementationStatus;
+/**
+ * Get implementation summary statistics.
+ */
+declare function getImplementationSummary(results: SpecImplementationResult[]): {
+  total: number;
+  implemented: number;
+  partial: number;
+  missing: number;
+  coverage: number;
+};
+//#endregion
+export { determineStatus, getImplementationSummary };
+//# sourceMappingURL=status.d.mts.map

package/dist/services/implementation/resolver/status.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/status.ts"],"sourcesContent":[],"mappings":";;;;AAyCA;;;iBA5BgB,eAAA,kBACG,2BAChB;;;;iBA0Ba,wBAAA,UAAkC"}

package/dist/services/implementation/resolver/status.mjs

@@ -0,0 +1,31 @@
+//#region src/services/implementation/resolver/status.ts
+/**
+* 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";
+}
+/**
+* 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 { determineStatus, getImplementationSummary };
+//# sourceMappingURL=status.mjs.map

package/dist/services/implementation/resolver/status.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.mjs","names":[],"sources":["../../../../src/services/implementation/resolver/status.ts"],"sourcesContent":["/**\n * Logic for determining implementation status.\n */\n\nimport type {\n  ImplementationStatus,\n  ResolvedImplementation,\n  SpecImplementationResult,\n} from '../types';\n\n/**\n * Determine overall implementation status.\n */\nexport function 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 * 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":";;;;AAaA,SAAgB,gBACd,iBACsB;AACtB,KAAI,gBAAgB,WAAW,EAC7B,QAAO;CAGT,MAAM,gBAAgB,gBAAgB,QAAQ,MAAM,EAAE,OAAO;AACvC,iBAAgB,QAAQ,MAAM,EAAE,SAAS,OAAO;AAItE,KAH6B,cAAc,QAAQ,MAAM,EAAE,SAAS,OAAO,CAGlD,WAAW,EAClC,QAAO;AAIT,KAAI,gBAAgB,OAAO,MAAM,EAAE,OAAO,CACxC,QAAO;AAIT,QAAO;;;;;AAMT,SAAgB,yBAAyB,SAMvC;CACA,MAAM,cAAc,QAAQ,QAAQ,MAAM,EAAE,WAAW,cAAc,CAAC;CACtE,MAAM,UAAU,QAAQ,QAAQ,MAAM,EAAE,WAAW,UAAU,CAAC;CAC9D,MAAM,UAAU,QAAQ,QAAQ,MAAM,EAAE,WAAW,UAAU,CAAC;AAE9D,QAAO;EACL,OAAO,QAAQ;EACf;EACA;EACA;EACA,UACE,QAAQ,SAAS,IACb,KAAK,MAAO,cAAc,QAAQ,SAAU,IAAI,GAChD;EACP"}

package/dist/services/implementation/types.d.mts

@@ -0,0 +1,89 @@
+import { ImplementationType } from "@contractspec/lib.contracts";
+
+//#region src/services/implementation/types.d.ts
+
+/**
+ * Source of how an implementation was discovered/linked.
+ */
+type ImplementationSource = 'explicit' | 'discovered' | 'convention';
+/**
+ * Status of a spec's implementation coverage.
+ */
+type ImplementationStatus = 'implemented' | 'partial' | 'missing';
+/**
+ * A resolved implementation file for a spec.
+ */
+interface ResolvedImplementation {
+  /** Path to the implementation file (relative to workspace root) */
+  path: string;
+  /** Type of implementation artifact */
+  type: ImplementationType;
+  /** How this implementation was found */
+  source: ImplementationSource;
+  /** Whether the file exists on disk */
+  exists: boolean;
+  /** Content hash for cache invalidation (SHA256) */
+  contentHash?: string;
+  /** Optional description */
+  description?: string;
+}
+/**
+ * Full resolution result for a spec's implementations.
+ */
+interface SpecImplementationResult {
+  /** Spec key */
+  specKey: string;
+  /** Spec version */
+  specVersion: string;
+  /** Path to the spec file */
+  specPath: string;
+  /** Spec type (operation, event, presentation, etc.) */
+  specType: string;
+  /** All resolved implementations */
+  implementations: ResolvedImplementation[];
+  /** Overall implementation status */
+  status: ImplementationStatus;
+  /** Content hash of the spec file */
+  specHash?: string;
+}
+/**
+ * Options for implementation discovery.
+ */
+interface DiscoveryOptions {
+  /** Workspace root directory */
+  workspaceRoot?: string;
+  /** Glob patterns to search */
+  includePatterns?: string[];
+  /** Glob patterns to exclude */
+  excludePatterns?: string[];
+  /** Whether to compute content hashes */
+  computeHashes?: boolean;
+}
+/**
+ * Options for resolving implementations.
+ */
+interface ResolverOptions {
+  includeExplicit?: boolean;
+  includeDiscovered?: boolean;
+  includeConvention?: boolean;
+  computeHashes?: boolean;
+  outputDir?: string;
+}
+/**
+ * Result of scanning for spec references in a file.
+ */
+interface SpecReferenceMatch {
+  /** Path to the file containing the reference */
+  filePath: string;
+  /** Key of the spec being referenced */
+  specKey: string;
+  /** Type of reference (import, typeof, handler) */
+  referenceType: 'import' | 'typeof' | 'handler' | 'unknown';
+  /** Line number where reference was found */
+  lineNumber?: number;
+  /** Inferred implementation type based on context */
+  inferredType: ImplementationType;
+}
+//#endregion
+export { DiscoveryOptions, ImplementationSource, ImplementationStatus, ResolvedImplementation, ResolverOptions, SpecImplementationResult, SpecReferenceMatch };
+//# sourceMappingURL=types.d.mts.map

package/dist/services/implementation/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/services/implementation/types.ts"],"sourcesContent":[],"mappings":";;;;AAcA;AAKA;AAkBA;AAoBiB,KAhDL,oBAAA,GAgDqB,UAAA,GAAA,YAAA,GAAA,YAAA;AAcjC;AAWA;;KApEY,oBAAA;;;;UAKK,sBAAA;;;;QAIT;;UAEE;;;;;;;;;;;UAYO,wBAAA;;;;;;;;;;mBAUE;;UAET;;;;;;;UAQO,gBAAA;;;;;;;;;;;;;UAcA,eAAA;;;;;;;;;;UAWA,kBAAA;;;;;;;;;;gBAUD"}

package/dist/services/import/import-service.d.mts

@@ -0,0 +1,47 @@
+import { FsAdapter } from "../../ports/fs.mjs";
+import { LoggerAdapter } from "../../ports/logger.mjs";
+import { ResolvedContractsrcConfig } from "@contractspec/lib.contracts";
+import { ImportIR } from "@contractspec/lib.source-extractors";
+import { GenerationResult } from "@contractspec/lib.source-extractors/codegen";
+
+//#region src/services/import/import-service.d.ts
+
+/**
+ * Options for the import service.
+ */
+interface ImportServiceOptions {
+  /** Limit extraction to specific paths */
+  scope?: string[];
+  /** Force specific framework */
+  framework?: string;
+  /** Dry run mode - don't write files */
+  dryRun?: boolean;
+  /** Analysis only - extract IR without generating code */
+  analyzeOnly?: boolean;
+  /** Output directory for generated contracts */
+  outputDir?: string;
+}
+/**
+ * Result of the import service.
+ */
+interface ImportServiceResult {
+  success: boolean;
+  ir?: ImportIR;
+  generation?: GenerationResult;
+  report: string;
+  errors?: string[];
+}
+/**
+ * Adapters needed by the import service.
+ */
+interface ImportServiceAdapters {
+  fs: FsAdapter;
+  logger: LoggerAdapter;
+}
+/**
+ * Import contracts from source code.
+ */
+declare function importFromSourceService(config: ResolvedContractsrcConfig, options: ImportServiceOptions, adapters: ImportServiceAdapters, cwd?: string): Promise<ImportServiceResult>;
+//#endregion
+export { ImportServiceAdapters, ImportServiceOptions, ImportServiceResult, importFromSourceService };
+//# sourceMappingURL=import-service.d.mts.map

package/dist/services/import/import-service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-service.d.mts","names":[],"sources":["../../../src/services/import/import-service.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAkEA;;;AAGY,UAtCK,oBAAA,CAsCL;EAED;EAAR,KAAA,CAAA,EAAA,MAAA,EAAA;EAAO;;;;;;;;;;;;UAxBO,mBAAA;;OAEV;eACQ;;;;;;;UAQE,qBAAA;MACX;UACI;;;;;iBAMY,uBAAA,SACZ,oCACC,gCACC,sCAET,QAAQ"}

package/dist/services/import/import-service.mjs

@@ -0,0 +1,196 @@
+import { dirname, join } from "path";
+import { detectFramework, extractFromProject } from "@contractspec/lib.source-extractors";
+import { registerAllExtractors } from "@contractspec/lib.source-extractors/extractors";
+import { generateOperations, generateRegistry, generateSchemas } from "@contractspec/lib.source-extractors/codegen";
+
+//#region src/services/import/import-service.ts
+/**
+* Import contracts from source code.
+*/
+async function importFromSourceService(config, options, adapters, cwd) {
+	const { fs, logger } = adapters;
+	const rootPath = cwd ?? process.cwd();
+	registerAllExtractors();
+	logger.info(`Scanning source code in ${rootPath}...`);
+	const extractorFs = {
+		readFile: (path$1) => fs.readFile(path$1),
+		glob: (pattern, opts) => fs.glob({
+			pattern,
+			cwd: opts?.cwd
+		}),
+		exists: (path$1) => fs.exists(path$1)
+	};
+	const project = await detectFramework(rootPath, {
+		readFile: (path$1) => fs.readFile(path$1),
+		glob: (pattern) => fs.glob({ pattern })
+	});
+	if (project.frameworks.length === 0) {
+		logger.warn("No supported frameworks detected");
+		return {
+			success: false,
+			report: generateNoFrameworkReport(),
+			errors: ["No supported frameworks detected in project"]
+		};
+	}
+	logger.info(`Detected frameworks: ${project.frameworks.map((f) => f.name).join(", ")}`);
+	const { extractorRegistry } = await import("@contractspec/lib.source-extractors");
+	for (const extractor of extractorRegistry.getAll()) if ("setFs" in extractor && typeof extractor.setFs === "function") extractor.setFs(extractorFs);
+	const extractResult = await extractFromProject(project, {
+		scope: options.scope,
+		framework: options.framework
+	});
+	if (!extractResult.success || !extractResult.ir) return {
+		success: false,
+		report: generateErrorReport(extractResult.errors ?? []),
+		errors: extractResult.errors?.map((e) => e.message)
+	};
+	const ir = extractResult.ir;
+	logger.info(`Extracted ${ir.endpoints.length} endpoints, ${ir.schemas.length} schemas`);
+	if (options.analyzeOnly) return {
+		success: true,
+		ir,
+		report: generateAnalysisReport(ir)
+	};
+	const outputDir = options.outputDir ?? join(config.outputDir, "generated");
+	const generationOptions = {
+		outputDir,
+		defaultAuth: "user"
+	};
+	const operationFiles = generateOperations(ir, generationOptions);
+	const schemaFiles = generateSchemas(ir, generationOptions);
+	const registryFile = generateRegistry(operationFiles);
+	const allFiles = [
+		...operationFiles,
+		...schemaFiles,
+		registryFile
+	];
+	if (!options.dryRun) for (const file of allFiles) {
+		const fullPath = join(outputDir, file.path);
+		const dir = dirname(fullPath);
+		if (!await fs.exists(dir)) await fs.mkdir(dir);
+		await fs.writeFile(fullPath, file.content);
+		logger.info(`Created: ${fullPath}`);
+	}
+	else for (const file of allFiles) logger.info(`[DRY RUN] Would create: ${join(outputDir, file.path)}`);
+	const generationResult = {
+		files: allFiles,
+		operationsGenerated: operationFiles.length,
+		schemasGenerated: schemaFiles.length,
+		warnings: []
+	};
+	return {
+		success: true,
+		ir,
+		generation: generationResult,
+		report: generateSuccessReport(ir, generationResult, options)
+	};
+}
+/**
+* Generate report when no frameworks are detected.
+*/
+function generateNoFrameworkReport() {
+	return `# Import Report
+
+## ❌ No Supported Frameworks Detected
+
+No supported frameworks were detected in the project.
+
+### Supported Frameworks
+
+- NestJS
+- Express
+- Fastify
+- Hono
+- Elysia
+- tRPC
+- Next.js API Routes
+
+Please ensure your project uses one of these frameworks and has the appropriate dependencies installed.
+`;
+}
+/**
+* Generate error report.
+*/
+function generateErrorReport(errors) {
+	return `# Import Report
+
+## ❌ Extraction Failed
+
+${errors.map((e) => `- ${e.message}`).join("\n")}
+`;
+}
+/**
+* Generate analysis-only report.
+*/
+function generateAnalysisReport(ir) {
+	return `# Import Analysis Report
+
+## Summary
+
+- **Files Scanned**: ${ir.stats.filesScanned}
+- **Endpoints Found**: ${ir.stats.endpointsFound}
+- **Schemas Found**: ${ir.stats.schemasFound}
+- **Errors Found**: ${ir.stats.errorsFound}
+- **Events Found**: ${ir.stats.eventsFound}
+
+## Confidence Breakdown
+
+| Level | Count |
+|-------|-------|
+| High | ${ir.stats.highConfidence} |
+| Medium | ${ir.stats.mediumConfidence} |
+| Low/Ambiguous | ${ir.stats.lowConfidence} |
+
+## Detected Frameworks
+
+${ir.project.frameworks.map((f) => `- ${f.name} (${f.confidence})`).join("\n")}
+
+## Endpoints
+
+${ir.endpoints.map((e) => `- \`${e.method} ${e.path}\` - ${e.confidence.level}`).join("\n")}
+
+## Ambiguities (Require Review)
+
+${ir.ambiguities.length > 0 ? ir.ambiguities.map((a) => `- ${a.description}`).join("\n") : "None"}
+`;
+}
+/**
+* Generate success report.
+*/
+function generateSuccessReport(ir, gen, options) {
+	return `# Import Report${options.dryRun ? " (Dry Run)" : ""}
+
+## ✅ Import Successful
+
+### Extraction Summary
+
+- **Files Scanned**: ${ir.stats.filesScanned}
+- **Endpoints Found**: ${ir.stats.endpointsFound}
+- **Schemas Found**: ${ir.stats.schemasFound}
+
+### Generation Summary
+
+- **Operations Generated**: ${gen.operationsGenerated}
+- **Schemas Generated**: ${gen.schemasGenerated}
+- **Total Files**: ${gen.files.length}
+
+### Confidence Breakdown
+
+| Level | Count |
+|-------|-------|
+| High | ${ir.stats.highConfidence} |
+| Medium | ${ir.stats.mediumConfidence} |
+| Low/Ambiguous | ${ir.stats.lowConfidence} |
+
+### Next Steps
+
+1. Review generated contracts in \`${options.outputDir ?? "generated/"}\`
+2. Fill in TODO placeholders with business context
+3. Run \`contractspec validate\` to verify contracts
+4. Move stable contracts from \`generated/\` to \`curated/\`
+`;
+}
+
+//#endregion
+export { importFromSourceService };
+//# sourceMappingURL=import-service.mjs.map