@contractspec/bundle.workspace 1.57.0 → 1.58.0

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

@@ -1,113 +0,0 @@
-import { discoverImplementationsForSpec } from "../discovery.mjs";
-import { getConventionPaths, toKebabCase } from "./conventions.mjs";
-import { parseExplicitImplementations } from "./parsers.mjs";
-import { determineStatus, getImplementationSummary } from "./status.mjs";
-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 = {}, spinner) {
-	const opts = {
-		...DEFAULT_OPTIONS,
-		...options
-	};
-	const specHash = opts.computeHashes ? computeHash(specFile.sourceBlock || "") : void 0;
-	const specKey = specFile.key ?? path.basename(specFile.filePath).replace(/\.[jt]s$/, "");
-	const specVersion = specFile.version ?? "1.0.0";
-	const { fs } = adapters;
-	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 implementationSourceContent = void 0;
-		let implementationSourceHash = void 0;
-		if (exists && opts.computeHashes) try {
-			implementationSourceContent = await fs.readFile(path);
-			implementationSourceHash = computeHash(implementationSourceContent);
-		} catch {}
-		implementations.push({
-			path,
-			type,
-			source,
-			exists,
-			implementationSourceContent,
-			implementationSourceHash,
-			description
-		});
-	};
-	if (opts.includeExplicit && specFile.sourceBlock) {
-		if (spinner) spinner.suffixText = `Discover explicit implementations`;
-		const explicitImpls = parseExplicitImplementations(specFile.sourceBlock);
-		for (const impl of explicitImpls) await addImpl(impl.path, impl.type, "explicit", impl.description);
-	}
-	if (opts.includeDiscovered) {
-		if (spinner) spinner.suffixText = `Discover implementations`;
-		const discovered = await discoverImplementationsForSpec(specKey, adapters, opts);
-		for (const ref of discovered) {
-			if (ref.filePath === specFile.filePath) continue;
-			await addImpl(ref.filePath, ref.inferredType, "discovered");
-		}
-	}
-	if (opts.includeConvention) {
-		if (spinner) spinner.suffixText = `Discover implementations based on conventions`;
-		const outputDir = opts.outputDir ?? config.outputDir ?? "./src";
-		const conventionPaths = getConventionPaths(specFile.specType, specKey, outputDir);
-		for (const { path, type } of conventionPaths) await addImpl(path, type, "convention");
-	}
-	if (spinner) spinner.suffixText = `Determine implementation status`;
-	const status = determineStatus(implementations);
-	return {
-		specKey,
-		specVersion,
-		specPath: specFile.filePath,
-		specType: specFile.specType,
-		implementations,
-		status,
-		specHash
-	};
-}
-/**
-* Resolve implementations for multiple spec files.
-*/
-async function resolveAllImplementations(specFiles, adapters, config, options = {}, spinner) {
-	const results = [];
-	for (const specFile of specFiles) {
-		if (spinner) spinner.text = `Resolving implementation... (${results.length}/${specFiles.length})`;
-		try {
-			const result = await resolveImplementations(specFile, adapters, config, options, spinner);
-			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

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"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';\n\nimport type { SpecScanResult } from '@contractspec/module.workspace';\nimport type {\n  ImplementationType,\n  ResolvedContractsrcConfig,\n} from '@contractspec/lib.contracts';\nimport type { FsAdapter } from '../../../ports/fs';\nimport type {\n  ResolvedImplementation,\n  ResolverOptions,\n  SpecImplementationResult,\n} from '../types';\nimport { discoverImplementationsForSpec } from '../discovery';\n\nimport { getConventionPaths } from './conventions';\nimport { parseExplicitImplementations } from './parsers';\nimport { determineStatus } from './status';\nimport path from 'path';\nimport type { Ora } from 'ora';\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: SpecScanResult,\n  adapters: { fs: FsAdapter },\n  config: ResolvedContractsrcConfig,\n  options: ResolverOptions = {},\n  spinner?: Ora\n): Promise<SpecImplementationResult> {\n  const opts = { ...DEFAULT_OPTIONS, ...options };\n  const specHash = opts.computeHashes\n    ? computeHash(specFile.sourceBlock || '')\n    : undefined;\n\n  const specKey =\n    specFile.key ?? path.basename(specFile.filePath).replace(/\\.[jt]s$/, '');\n  const specVersion = specFile.version ?? '1.0.0';\n\n  const { fs } = adapters;\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 implementationSourceContent: string | undefined = undefined;\n    let implementationSourceHash: string | undefined = undefined;\n\n    if (exists && opts.computeHashes) {\n      try {\n        implementationSourceContent = await fs.readFile(path);\n        implementationSourceHash = computeHash(implementationSourceContent);\n      } catch {\n        // Ignore hash computation errors\n      }\n    }\n\n    implementations.push({\n      path,\n      type,\n      source,\n      exists,\n      implementationSourceContent,\n      implementationSourceHash,\n      description,\n    });\n  };\n\n  // 1. Add explicit implementations from spec\n  if (opts.includeExplicit && specFile.sourceBlock) {\n    if (spinner) spinner.suffixText = `Discover explicit implementations`;\n\n    // Parse explicit implementations from spec source\n    const explicitImpls = parseExplicitImplementations(specFile.sourceBlock);\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    if (spinner) spinner.suffixText = `Discover implementations`;\n\n    const discovered = await discoverImplementationsForSpec(\n      specKey,\n      adapters,\n      opts\n    );\n\n    for (const ref of discovered) {\n      // Skip the spec file itself\n      if (ref.filePath === specFile.filePath) continue;\n\n      await addImpl(ref.filePath, ref.inferredType, 'discovered');\n    }\n  }\n\n  // 3. Add convention-based implementations\n  if (opts.includeConvention) {\n    if (spinner)\n      spinner.suffixText = `Discover implementations based on conventions`;\n\n    const outputDir = opts.outputDir ?? config.outputDir ?? './src';\n    const conventionPaths = getConventionPaths(\n      specFile.specType,\n      specKey,\n      outputDir\n    );\n\n    for (const { path, type } of conventionPaths) {\n      await addImpl(path, type, 'convention');\n    }\n  }\n\n  if (spinner) spinner.suffixText = `Determine implementation status`;\n  // Determine overall status\n  const status = determineStatus(implementations);\n\n  return {\n    specKey,\n    specVersion,\n    specPath: specFile.filePath,\n    specType: specFile.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: SpecScanResult[],\n  adapters: { fs: FsAdapter },\n  config: ResolvedContractsrcConfig,\n  options: ResolverOptions = {},\n  spinner?: Ora\n): Promise<SpecImplementationResult[]> {\n  const results: SpecImplementationResult[] = [];\n\n  for (const specFile of specFiles) {\n    if (spinner)\n      spinner.text = `Resolving implementation... (${results.length}/${specFiles.length})`;\n\n    try {\n      const result = await resolveImplementations(\n        specFile,\n        adapters,\n        config,\n        options,\n        spinner\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":";;;;;;;;;;;;;;;;AAkCA,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,EAC7B,SACmC;CACnC,MAAM,OAAO;EAAE,GAAG;EAAiB,GAAG;EAAS;CAC/C,MAAM,WAAW,KAAK,gBAClB,YAAY,SAAS,eAAe,GAAG,GACvC;CAEJ,MAAM,UACJ,SAAS,OAAO,KAAK,SAAS,SAAS,SAAS,CAAC,QAAQ,YAAY,GAAG;CAC1E,MAAM,cAAc,SAAS,WAAW;CAExC,MAAM,EAAE,OAAO;CAEf,MAAM,kBAA4C,EAAE;CACpD,MAAM,4BAAY,IAAI,KAAa;CAGnC,MAAM,UAAU,OACd,MACA,MACA,QACA,gBACG;AACH,MAAI,UAAU,IAAI,KAAK,CAAE;AACzB,YAAU,IAAI,KAAK;EAEnB,MAAM,SAAS,MAAM,GAAG,OAAO,KAAK;EACpC,IAAI,8BAAkD;EACtD,IAAI,2BAA+C;AAEnD,MAAI,UAAU,KAAK,cACjB,KAAI;AACF,iCAA8B,MAAM,GAAG,SAAS,KAAK;AACrD,8BAA2B,YAAY,4BAA4B;UAC7D;AAKV,kBAAgB,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;;AAIJ,KAAI,KAAK,mBAAmB,SAAS,aAAa;AAChD,MAAI,QAAS,SAAQ,aAAa;EAGlC,MAAM,gBAAgB,6BAA6B,SAAS,YAAY;AACxE,OAAK,MAAM,QAAQ,cACjB,OAAM,QAAQ,KAAK,MAAM,KAAK,MAAM,YAAY,KAAK,YAAY;;AAKrE,KAAI,KAAK,mBAAmB;AAC1B,MAAI,QAAS,SAAQ,aAAa;EAElC,MAAM,aAAa,MAAM,+BACvB,SACA,UACA,KACD;AAED,OAAK,MAAM,OAAO,YAAY;AAE5B,OAAI,IAAI,aAAa,SAAS,SAAU;AAExC,SAAM,QAAQ,IAAI,UAAU,IAAI,cAAc,aAAa;;;AAK/D,KAAI,KAAK,mBAAmB;AAC1B,MAAI,QACF,SAAQ,aAAa;EAEvB,MAAM,YAAY,KAAK,aAAa,OAAO,aAAa;EACxD,MAAM,kBAAkB,mBACtB,SAAS,UACT,SACA,UACD;AAED,OAAK,MAAM,EAAE,MAAM,UAAU,gBAC3B,OAAM,QAAQ,MAAM,MAAM,aAAa;;AAI3C,KAAI,QAAS,SAAQ,aAAa;CAElC,MAAM,SAAS,gBAAgB,gBAAgB;AAE/C,QAAO;EACL;EACA;EACA,UAAU,SAAS;EACnB,UAAU,SAAS;EACnB;EACA;EACA;EACD;;;;;AAMH,eAAsB,0BACpB,WACA,UACA,QACA,UAA2B,EAAE,EAC7B,SACqC;CACrC,MAAM,UAAsC,EAAE;AAE9C,MAAK,MAAM,YAAY,WAAW;AAChC,MAAI,QACF,SAAQ,OAAO,gCAAgC,QAAQ,OAAO,GAAG,UAAU,OAAO;AAEpF,MAAI;GACF,MAAM,SAAS,MAAM,uBACnB,UACA,UACA,QACA,SACA,QACD;AACD,WAAQ,KAAK,OAAO;WACb,OAAO;AAEd,WAAQ,MACN,yCAAyC,SAAS,IAClD,MACD;;;AAIL,QAAO"}

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

@@ -1,11 +0,0 @@
-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[];
-//#endregion
-export { parseExplicitImplementations };
-//# sourceMappingURL=parsers.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parsers.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/parsers.ts"],"mappings":";;;;;;;iBAcgB,4BAAA,CACd,IAAA,WACC,iBAAA"}

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

@@ -1,82 +0,0 @@
-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 = pathProp.getInitializer();
-						if (Node.isStringLiteral(init)) pathVal = init.getLiteralText();
-					}
-					const typeProp = elem.getProperty("type");
-					if (typeProp && Node.isPropertyAssignment(typeProp)) {
-						const init = typeProp.getInitializer();
-						if (Node.isStringLiteral(init)) typeVal = init.getLiteralText();
-					}
-					const descProp = elem.getProperty("description");
-					if (descProp && Node.isPropertyAssignment(descProp)) {
-						const init = descProp.getInitializer();
-						if (Node.isStringLiteral(init)) descVal = init.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;
-}
-
-//#endregion
-export { parseExplicitImplementations };
-//# sourceMappingURL=parsers.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parsers.mjs","names":[],"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"],"mappings":";;;;;;;AAcA,SAAgB,6BACd,MACqB;CACrB,MAAM,kBAAuC,EAAE;CAG/C,MAAM,aAFU,IAAI,QAAQ,EAAE,uBAAuB,MAAM,CAAC,CAEjC,iBAAiB,WAAW,KAAK;CAG5D,MAAM,gBAAgB,QAAc;AAClC,MAAI,CAAC,KAAK,0BAA0B,IAAI,CAAE;EAC1C,MAAM,OAAO,IAAI,YAAY,kBAAkB;AAC/C,MAAI,QAAQ,KAAK,qBAAqB,KAAK,EAAE;GAC3C,MAAM,OAAO,KAAK,gBAAgB;AAClC,OAAI,QAAQ,KAAK,yBAAyB,KAAK,EAC7C;SAAK,MAAM,QAAQ,KAAK,aAAa,CACnC,KAAI,KAAK,0BAA0B,KAAK,EAAE;KACxC,IAAI;KACJ,IAAI;KACJ,IAAI;KAEJ,MAAM,WAAW,KAAK,YAAY,OAAO;AACzC,SAAI,YAAY,KAAK,qBAAqB,SAAS,EAAE;MACnD,MAAM,OAAO,SAAS,gBAAgB;AACtC,UAAI,KAAK,gBAAgB,KAAK,CAC5B,WAAU,KAAK,gBAAgB;;KAInC,MAAM,WAAW,KAAK,YAAY,OAAO;AACzC,SAAI,YAAY,KAAK,qBAAqB,SAAS,EAAE;MACnD,MAAM,OAAO,SAAS,gBAAgB;AACtC,UAAI,KAAK,gBAAgB,KAAK,CAC5B,WAAU,KAAK,gBAAgB;;KAInC,MAAM,WAAW,KAAK,YAAY,cAAc;AAChD,SAAI,YAAY,KAAK,qBAAqB,SAAS,EAAE;MACnD,MAAM,OAAO,SAAS,gBAAgB;AACtC,UAAI,KAAK,gBAAgB,KAAK,CAC5B,WAAU,KAAK,gBAAgB;;AAInC,SAAI,WAAW,QACb,iBAAgB,KAAK;MACnB,MAAM;MACN,MAAM;MACN,aAAa;MACd,CAAC;;;;;CAYd,MAAM,kBAAkB,WAAW,qBACjC,WAAW,eACZ;AACD,MAAK,MAAM,QAAQ,iBAAiB;EAClC,MAAM,OAAO,KAAK,eAAe,CAAC,SAAS;AAC3C,MACE;GAAC;GAAiB;GAAe;GAAe;GAAgB,CAAC,SAC/D,KACD,EACD;GACA,MAAM,OAAO,KAAK,cAAc;AAChC,OAAI,KAAK,SAAS,KAAK,KAAK,0BAA0B,KAAK,GAAG,EAAE;AAC9D,iBAAa,KAAK,GAAG;AACrB,WAAO;;;;CAMb,MAAM,WAAW,WAAW,uBAAuB;AACnD,MAAK,MAAM,QAAQ,SACjB,KAAI,KAAK,YAAY,CACnB,MAAK,MAAM,QAAQ,KAAK,iBAAiB,EAAE;EACzC,MAAM,OAAO,KAAK,gBAAgB;AAClC,MAAI,QAAQ,KAAK,0BAA0B,KAAK,EAE9C;OAAI,KAAK,YAAY,kBAAkB,EAAE;AACvC,iBAAa,KAAK;AAClB,WAAO;;;;CAQjB,MAAM,eAAe,WAAW,qBAC7B,MAAM,CAAC,EAAE,gBAAgB,CAC3B;AACD,KAAI,cAAc;EAChB,MAAM,OAAO,aAAa,eAAe;AACzC,MAAI,KAAK,0BAA0B,KAAK,CACtC,cAAa,KAAK;WAElB,KAAK,eAAe,KAAK,IACzB,KAAK,0BAA0B,KAAK,eAAe,CAAC,CAEpD,cAAa,KAAK,eAAe,CAAC;;AAItC,QAAO"}

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

@@ -1,20 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"status.d.mts","names":[],"sources":["../../../../src/services/implementation/resolver/status.ts"],"mappings":";;;;;;iBAagB,eAAA,CACd,eAAA,EAAiB,sBAAA,KAChB,oBAAA;;;;iBA0Ba,wBAAA,CAAyB,OAAA,EAAS,wBAAA;EAChD,KAAA;EACA,WAAA;EACA,OAAA;EACA,OAAA;EACA,QAAA;AAAA"}

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

@@ -1,31 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,90 +0,0 @@
-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 */
-  implementationSourceContent?: string;
-  /** Content hash for cache invalidation (SHA256) */
-  implementationSourceHash?: 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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/services/implementation/types.ts"],"mappings":";;;;;;KASY,oBAAA;AAKZ;;;AAAA,KAAY,oBAAA;;AAKZ;;UAAiB,sBAAA;EAMa;EAJ5B,IAAA;EAEA;EAAA,IAAA,EAAM,kBAAA;EAEN;EAAA,MAAA,EAAQ,oBAAA;EAER;EAAA,MAAA;EAIA;EAFA,2BAAA;EAIW;EAFX,wBAAA;EAQe;EANf,WAAA;AAAA;;;;UAMe,wBAAA;EAQf;EANA,OAAA;EAQiB;EANjB,WAAA;EAQQ;EANR,QAAA;EAQQ;EANR,QAAA;EAYe;EAVf,eAAA,EAAiB,sBAAA;;EAEjB,MAAA,EAAQ,oBAAA;EAUR;EARA,QAAA;AAAA;;;;UAMe,gBAAA;EAce;EAZ9B,aAAA;EAY8B;EAV9B,eAAA;EAYA;EAVA,eAAA;EAYA;EAVA,aAAA;AAAA;;AAiBF;;UAXiB,eAAA;EACf,eAAA;EACA,iBAAA;EACA,iBAAA;EACA,aAAA;EACA,SAAA;AAAA;;;;UAMe,kBAAA;;EAEf,QAAA;;EAEA,OAAA;;EAEA,aAAA;;EAEA,UAAA;;EAEA,YAAA,EAAc,kBAAA;AAAA"}

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

@@ -1,46 +0,0 @@
-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

@@ -1 +0,0 @@
-{"version":3,"file":"import-service.d.mts","names":[],"sources":["../../../src/services/import/import-service.ts"],"mappings":";;;;;;;;;;UA+BiB,oBAAA;EAQf;EANA,KAAA;EAQS;EANT,SAAA;EAYe;EAVf,MAAA;;EAEA,WAAA;EASA;EAPA,SAAA;AAAA;;;;UAMe,mBAAA;EACf,OAAA;EACA,EAAA,GAAK,QAAA;EACL,UAAA,GAAa,gBAAA;EACb,MAAA;EACA,MAAA;AAAA;;;;UAMe,qBAAA;EACf,EAAA,EAAI,SAAA;EACJ,MAAA,EAAQ,aAAA;AAAA;;;;iBAMY,uBAAA,CACpB,MAAA,EAAQ,yBAAA,EACR,OAAA,EAAS,oBAAA,EACT,QAAA,EAAU,qBAAA,EACV,GAAA,YACC,OAAA,CAAQ,mBAAA"}

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

@@ -1,196 +0,0 @@
-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) => fs.readFile(path),
-		glob: (pattern, opts) => fs.glob({
-			pattern,
-			cwd: opts?.cwd
-		}),
-		exists: (path) => fs.exists(path)
-	};
-	const project = await detectFramework(rootPath, {
-		readFile: (path) => fs.readFile(path),
-		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