@contractspec/bundle.workspace 0.0.0-canary-20260113162409

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

@@ -0,0 +1,501 @@
+import { findPackageRoot, getPackageName } from "../../adapters/workspace.mjs";
+import { formatChangelogJson, formatKeepAChangelog } from "./changelog-formatter.mjs";
+import { commitsToChangeEntries, getHighestBumpType, parseConventionalCommit } from "./conventional-commits.mjs";
+import { bumpVersion, determineBumpType } from "@contractspec/lib.contracts";
+
+//#region src/services/versioning/versioning-service.ts
+/**
+* Versioning service.
+*
+* Provides version analysis, version bumping, and changelog generation
+* for ContractSpec specs.
+*/
+/**
+* Analyze specs and suggest version bumps based on changes.
+*
+* Compares the current state against a baseline (git ref) and determines
+* which specs need version bumps based on detected changes.
+*/
+async function analyzeVersions(adapters, options = {}) {
+	const { fs, git, logger } = adapters;
+	const workspaceRoot = options.workspaceRoot ?? process.cwd();
+	logger.info("Starting version analysis...", { baseline: options.baseline });
+	const pattern = options.pattern ?? "**/*.{operation,event,presentation}.ts";
+	const specFiles = (await fs.glob({
+		pattern,
+		cwd: workspaceRoot
+	})).filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("node_modules"));
+	logger.debug(`Found ${specFiles.length} spec files`);
+	const analyses = [];
+	let totalBreaking = 0;
+	let totalNonBreaking = 0;
+	for (const specPath of specFiles) try {
+		const currentContent = await fs.readFile(specPath);
+		const currentMeta = extractSpecMeta(currentContent);
+		if (!currentMeta) continue;
+		let baselineContent = null;
+		if (options.baseline) try {
+			baselineContent = await git.showFile(options.baseline, specPath);
+		} catch {
+			baselineContent = null;
+		}
+		const changes = analyzeSpecChanges(currentContent, baselineContent);
+		const hasBreaking = changes.some((c) => c.type === "breaking");
+		const hasNonBreaking = changes.length > 0 && !hasBreaking;
+		const needsBump = changes.length > 0;
+		if (hasBreaking) totalBreaking++;
+		if (hasNonBreaking) totalNonBreaking++;
+		const bumpType = determineBumpType(hasBreaking, hasNonBreaking);
+		const suggestedVersion = needsBump ? bumpVersion(currentMeta.version, bumpType) : currentMeta.version;
+		analyses.push({
+			specPath,
+			specKey: currentMeta.key,
+			currentVersion: currentMeta.version,
+			suggestedVersion,
+			bumpType,
+			changes,
+			hasBreaking,
+			needsBump
+		});
+	} catch (error) {
+		logger.warn(`Failed to analyze ${specPath}:`, { error: error instanceof Error ? error.message : String(error) });
+	}
+	const specsNeedingBump = analyses.filter((a) => a.needsBump).length;
+	logger.info("Version analysis complete", {
+		totalSpecs: analyses.length,
+		specsNeedingBump,
+		totalBreaking,
+		totalNonBreaking
+	});
+	return {
+		analyses,
+		totalSpecs: analyses.length,
+		specsNeedingBump,
+		totalBreaking,
+		totalNonBreaking,
+		baseline: options.baseline
+	};
+}
+/**
+* Analyze version bump based on git commits.
+*
+* Parses conventional commits since the baseline and determines
+* the appropriate version bump type.
+*/
+async function analyzeVersionsFromCommits(adapters, options = {}) {
+	const { git, logger } = adapters;
+	const baseline = options.baseline ?? "HEAD~10";
+	logger.info("Analyzing commits for version bump...", { baseline });
+	try {
+		const commitLog = await git.log(baseline);
+		const parsedCommits = [];
+		const conventionalCommits = [];
+		for (const commit of commitLog) {
+			const parsed = parseConventionalCommit(commit.message);
+			if (parsed) {
+				parsedCommits.push({
+					hash: commit.hash,
+					message: commit.message,
+					type: parsed.type,
+					scope: parsed.scope,
+					breaking: parsed.breaking
+				});
+				conventionalCommits.push(parsed);
+			}
+		}
+		const suggestedBumpType = getHighestBumpType(conventionalCommits);
+		const changes = commitsToChangeEntries(conventionalCommits);
+		const breakingCommits = parsedCommits.filter((c) => c.breaking).length;
+		logger.info("Commit analysis complete", {
+			totalCommits: parsedCommits.length,
+			breakingCommits,
+			suggestedBumpType
+		});
+		return {
+			suggestedBumpType,
+			commits: parsedCommits,
+			changes,
+			totalCommits: parsedCommits.length,
+			breakingCommits
+		};
+	} catch (error) {
+		logger.warn("Failed to analyze commits", { error: error instanceof Error ? error.message : String(error) });
+		return {
+			suggestedBumpType: null,
+			commits: [],
+			changes: [],
+			totalCommits: 0,
+			breakingCommits: 0
+		};
+	}
+}
+/**
+* Apply a version bump to a spec file.
+*
+* Updates the version in the spec file and creates a changelog entry.
+*/
+async function applyVersionBump(adapters, options) {
+	const { fs, logger } = adapters;
+	const { specPath, dryRun = false, config } = options;
+	logger.info("Applying version bump...", {
+		specPath,
+		bumpType: options.bumpType
+	});
+	try {
+		const content = await fs.readFile(specPath);
+		const meta = extractSpecMeta(content);
+		if (!meta) return {
+			success: false,
+			specPath,
+			specKey: "unknown",
+			previousVersion: "unknown",
+			newVersion: "unknown",
+			bumpType: "patch",
+			changelogEntry: createEmptyChangelogEntry(),
+			error: "Could not extract spec metadata"
+		};
+		const bumpType = options.bumpType ?? "patch";
+		const newVersion = bumpVersion(meta.version, bumpType);
+		const changes = options.changes ?? [];
+		if (options.changeDescription) changes.push({
+			type: bumpType === "major" ? "breaking" : "changed",
+			description: options.changeDescription
+		});
+		const changelogEntry = {
+			version: newVersion,
+			date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+			bumpType,
+			changes,
+			breakingChanges: changes.filter((c) => c.type === "breaking")
+		};
+		if (!dryRun) {
+			const updatedContent = updateSpecVersion(content, meta.version, newVersion);
+			await fs.writeFile(specPath, updatedContent);
+		}
+		logger.info("Version bump applied", {
+			specPath,
+			previousVersion: meta.version,
+			newVersion
+		});
+		if (config?.integrateWithChangesets) await generateChangeset(adapters, {
+			specPath,
+			bumpType,
+			summary: options.changeDescription ?? `Bump ${meta.key} to ${newVersion}`,
+			dryRun
+		});
+		return {
+			success: true,
+			specPath,
+			specKey: meta.key,
+			previousVersion: meta.version,
+			newVersion,
+			bumpType,
+			changelogEntry
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error("Version bump failed", {
+			specPath,
+			error: errorMessage
+		});
+		return {
+			success: false,
+			specPath,
+			specKey: "unknown",
+			previousVersion: "unknown",
+			newVersion: "unknown",
+			bumpType: options.bumpType ?? "patch",
+			changelogEntry: createEmptyChangelogEntry(),
+			error: errorMessage
+		};
+	}
+}
+/**
+* Generate changelogs at all configured tiers.
+*/
+async function generateChangelogs(adapters, options = {}) {
+	const { logger } = adapters;
+	const tiers = options.tiers ?? [
+		"spec",
+		"library",
+		"monorepo"
+	];
+	const format = options.format ?? "keep-a-changelog";
+	logger.info("Generating changelogs...", {
+		tiers,
+		format
+	});
+	const analysis = await analyzeVersions(adapters, {
+		baseline: options.baseline,
+		workspaceRoot: options.workspaceRoot
+	});
+	const specChangelogs = [];
+	const libraryMarkdown = /* @__PURE__ */ new Map();
+	let monorepoMarkdown = "";
+	let totalEntries = 0;
+	if (tiers.includes("spec")) for (const spec of analysis.analyses.filter((a) => a.needsBump)) {
+		const docBlock = {
+			id: `changelog.${spec.specKey}`,
+			title: `Changelog for ${spec.specKey}`,
+			body: formatSpecChangelog(spec),
+			kind: "changelog",
+			specKey: spec.specKey,
+			specVersion: spec.suggestedVersion,
+			entries: [{
+				version: spec.suggestedVersion,
+				date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+				bumpType: spec.bumpType,
+				changes: spec.changes,
+				breakingChanges: spec.changes.filter((c) => c.type === "breaking")
+			}]
+		};
+		specChangelogs.push(docBlock);
+		totalEntries++;
+	}
+	if (tiers.includes("library")) {
+		const libraryGroups = groupByLibrary(analysis.analyses);
+		for (const [libPath, specs] of libraryGroups) {
+			const entries = specs.filter((s) => s.needsBump);
+			if (entries.length > 0) {
+				libraryMarkdown.set(libPath, formatKeepAChangelog(entries.map(specToChangelogEntry)));
+				totalEntries += entries.length;
+			}
+		}
+	}
+	if (tiers.includes("monorepo")) monorepoMarkdown = formatKeepAChangelog(analysis.analyses.filter((a) => a.needsBump).map(specToChangelogEntry));
+	const json = formatChangelogJson(analysis, options.baseline);
+	logger.info("Changelog generation complete", { totalEntries });
+	return {
+		specChangelogs,
+		libraryMarkdown,
+		monorepoMarkdown,
+		json,
+		totalEntries
+	};
+}
+/**
+* Extract spec metadata from file content.
+*/
+function extractSpecMeta(content) {
+	const keyMatch = content.match(/key:\s*['"`]([^'"`]+)['"`]/);
+	const versionMatch = content.match(/version:\s*['"`]([^'"`]+)['"`]/);
+	if (!keyMatch || !versionMatch) return null;
+	const key = keyMatch[1];
+	const version = versionMatch[1];
+	if (!key || !version) return null;
+	return {
+		key,
+		version
+	};
+}
+/**
+* Analyze changes between current and baseline spec content.
+*/
+function analyzeSpecChanges(current, baseline) {
+	const changes = [];
+	if (!baseline) {
+		changes.push({
+			type: "added",
+			description: "New spec added"
+		});
+		return changes;
+	}
+	const currentMeta = extractSpecMeta(current);
+	const baselineMeta = extractSpecMeta(baseline);
+	if (!currentMeta || !baselineMeta) return changes;
+	if (currentMeta.version !== baselineMeta.version) changes.push({
+		type: "changed",
+		description: `Version updated from ${baselineMeta.version} to ${currentMeta.version}`,
+		path: "meta.version"
+	});
+	const hasIoChanges = detectIoChanges(current, baseline);
+	if (hasIoChanges.breaking) changes.push({
+		type: "breaking",
+		description: "Breaking changes to input/output schema",
+		path: "io"
+	});
+	else if (hasIoChanges.nonBreaking) changes.push({
+		type: "changed",
+		description: "Non-breaking changes to input/output schema",
+		path: "io"
+	});
+	return changes;
+}
+/**
+* Detect I/O changes between specs (simplified).
+*/
+function detectIoChanges(current, baseline) {
+	const ioPattern = /io:\s*\{[\s\S]*?\}/;
+	const currentIo = current.match(ioPattern)?.[0] ?? "";
+	const baselineIo = baseline.match(ioPattern)?.[0] ?? "";
+	if (currentIo === baselineIo) return {
+		breaking: false,
+		nonBreaking: false
+	};
+	const currentFields = extractFields(currentIo);
+	const baselineFields = extractFields(baselineIo);
+	const removedFields = baselineFields.filter((f) => !currentFields.includes(f));
+	const addedFields = currentFields.filter((f) => !baselineFields.includes(f));
+	return {
+		breaking: removedFields.length > 0,
+		nonBreaking: addedFields.length > 0 && removedFields.length === 0
+	};
+}
+/**
+* Extract field names from a code block (simplified).
+*/
+function extractFields(code) {
+	return [...code.matchAll(/(\w+):/g)].map((m) => m[1]).filter((field) => !!field);
+}
+/**
+* Update version in spec content.
+*/
+function updateSpecVersion(content, oldVersion, newVersion) {
+	return content.replace(/* @__PURE__ */ new RegExp(`version:\\s*['"\`]${oldVersion}['"\`]`), `version: '${newVersion}'`);
+}
+/**
+* Create an empty changelog entry.
+*/
+function createEmptyChangelogEntry() {
+	return {
+		version: "0.0.0",
+		date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+		bumpType: "patch",
+		changes: []
+	};
+}
+/**
+* Format a single spec's changelog.
+*/
+function formatSpecChangelog(spec) {
+	const lines = [`## [${spec.suggestedVersion}] - ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`, ""];
+	const breaking = spec.changes.filter((c) => c.type === "breaking");
+	const changed = spec.changes.filter((c) => c.type === "changed");
+	const added = spec.changes.filter((c) => c.type === "added");
+	if (breaking.length > 0) {
+		lines.push("### Breaking Changes");
+		breaking.forEach((c) => lines.push(`- ${c.description}`));
+		lines.push("");
+	}
+	if (added.length > 0) {
+		lines.push("### Added");
+		added.forEach((c) => lines.push(`- ${c.description}`));
+		lines.push("");
+	}
+	if (changed.length > 0) {
+		lines.push("### Changed");
+		changed.forEach((c) => lines.push(`- ${c.description}`));
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/**
+* Group specs by library (package path).
+*/
+function groupByLibrary(analyses) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const analysis of analyses) {
+		const libPath = analysis.specPath.match(/(.+?\/src\/)/)?.[1] ?? analysis.specPath;
+		const existing = groups.get(libPath) ?? [];
+		existing.push(analysis);
+		groups.set(libPath, existing);
+	}
+	return groups;
+}
+/**
+* Convert SpecVersionAnalysis to ChangelogEntry.
+*/
+function specToChangelogEntry(spec) {
+	return {
+		version: spec.suggestedVersion,
+		date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0] ?? "",
+		bumpType: spec.bumpType,
+		changes: spec.changes,
+		breakingChanges: spec.changes.filter((c) => c.type === "breaking")
+	};
+}
+/**
+* Generate a changeset file for a spec update.
+*/
+async function generateChangeset(adapters, options) {
+	const { fs, logger } = adapters;
+	const { specPath, bumpType, summary, dryRun } = options;
+	try {
+		const pkgRoot = findPackageRoot(specPath);
+		const pkgName = getPackageName(pkgRoot);
+		if (!pkgName) {
+			logger.warn("Could not determine package name for changeset", { specPath });
+			return;
+		}
+		let currentDir = pkgRoot;
+		let changesetDir = null;
+		while (true) {
+			const candidate = fs.join(currentDir, ".changeset");
+			if (await fs.exists(candidate)) {
+				changesetDir = candidate;
+				break;
+			}
+			const parent = fs.dirname(currentDir);
+			if (parent === currentDir) break;
+			currentDir = parent;
+		}
+		if (!changesetDir) {
+			logger.warn("No .changeset directory found, skipping changeset generation");
+			return;
+		}
+		const fileName = `${generateRandomName()}.md`;
+		const filePath = fs.join(changesetDir, fileName);
+		const content = `---
+"${pkgName}": ${bumpType}
+---
+
+${summary}
+`;
+		if (!dryRun) {
+			await fs.writeFile(filePath, content);
+			logger.info("Generated changeset", { filePath });
+		} else logger.info("Would generate changeset", {
+			filePath,
+			content
+		});
+	} catch (error) {
+		logger.error("Failed to generate changeset", { error: error instanceof Error ? error.message : String(error) });
+	}
+}
+/**
+* Generate a random human-readable-ish name (simplified).
+*/
+function generateRandomName() {
+	const adjectives = [
+		"neat",
+		"calm",
+		"wild",
+		"soft",
+		"bold",
+		"fair",
+		"cool"
+	];
+	const nouns = [
+		"fox",
+		"cat",
+		"dog",
+		"bat",
+		"ant",
+		"elk",
+		"owl"
+	];
+	const verbs = [
+		"run",
+		"fly",
+		"hop",
+		"eat",
+		"nap",
+		"cry",
+		"sing"
+	];
+	return `${adjectives[Math.floor(Math.random() * adjectives.length)]}-${nouns[Math.floor(Math.random() * nouns.length)]}-${verbs[Math.floor(Math.random() * verbs.length)]}-${Math.floor(Math.random() * 1e3)}`;
+}
+
+//#endregion
+export { analyzeVersions, analyzeVersionsFromCommits, applyVersionBump, generateChangelogs };
+//# sourceMappingURL=versioning-service.mjs.map

package/dist/services/versioning/versioning-service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioning-service.mjs","names":[],"sources":["../../../src/services/versioning/versioning-service.ts"],"sourcesContent":["/**\n * Versioning service.\n *\n * Provides version analysis, version bumping, and changelog generation\n * for ContractSpec specs.\n */\n\nimport {\n  bumpVersion,\n  determineBumpType,\n  type ChangeEntry,\n  type ChangelogEntry,\n  type ChangelogDocBlock,\n  type VersionBumpType,\n} from '@contractspec/lib.contracts';\nimport { findPackageRoot, getPackageName } from '../../adapters/workspace';\nimport type { FsAdapter } from '../../ports/fs';\nimport type { GitAdapter } from '../../ports/git';\nimport type { LoggerAdapter } from '../../ports/logger';\nimport type {\n  VersionAnalyzeOptions,\n  VersionAnalyzeResult,\n  VersionBumpOptions,\n  VersionBumpResult,\n  ChangelogGenerateOptions,\n  ChangelogGenerateResult,\n  SpecVersionAnalysis,\n} from './types';\nimport {\n  formatKeepAChangelog,\n  formatChangelogJson,\n} from './changelog-formatter';\nimport {\n  parseConventionalCommit,\n  getHighestBumpType,\n  commitsToChangeEntries,\n} from './conventional-commits';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Adapters Type\n// ─────────────────────────────────────────────────────────────────────────────\n\ninterface ServiceAdapters {\n  fs: FsAdapter;\n  git: GitAdapter;\n  logger: LoggerAdapter;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Version Analysis\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Analyze specs and suggest version bumps based on changes.\n *\n * Compares the current state against a baseline (git ref) and determines\n * which specs need version bumps based on detected changes.\n */\nexport async function analyzeVersions(\n  adapters: ServiceAdapters,\n  options: VersionAnalyzeOptions = {}\n): Promise<VersionAnalyzeResult> {\n  const { fs, git, logger } = adapters;\n  const workspaceRoot = options.workspaceRoot ?? process.cwd();\n\n  logger.info('Starting version analysis...', { baseline: options.baseline });\n\n  // Discover spec files\n  const pattern = options.pattern ?? '**/*.{operation,event,presentation}.ts';\n  const files = await fs.glob({ pattern, cwd: workspaceRoot });\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  const analyses: SpecVersionAnalysis[] = [];\n  let totalBreaking = 0;\n  let totalNonBreaking = 0;\n\n  for (const specPath of specFiles) {\n    try {\n      // Read current spec\n      const currentContent = await fs.readFile(specPath);\n      const currentMeta = extractSpecMeta(currentContent);\n\n      if (!currentMeta) {\n        continue; // Skip files that don't have valid spec meta\n      }\n\n      // Get baseline content if baseline specified\n      let baselineContent: string | null = null;\n      if (options.baseline) {\n        try {\n          baselineContent = await git.showFile(options.baseline, specPath);\n        } catch {\n          // File doesn't exist in baseline (new file)\n          baselineContent = null;\n        }\n      }\n\n      // Analyze changes\n      const changes = analyzeSpecChanges(currentContent, baselineContent);\n      const hasBreaking = changes.some((c) => c.type === 'breaking');\n      const hasNonBreaking = changes.length > 0 && !hasBreaking;\n      const needsBump = changes.length > 0;\n\n      if (hasBreaking) totalBreaking++;\n      if (hasNonBreaking) totalNonBreaking++;\n\n      const bumpType = determineBumpType(hasBreaking, hasNonBreaking);\n      const suggestedVersion = needsBump\n        ? bumpVersion(currentMeta.version, bumpType)\n        : currentMeta.version;\n\n      analyses.push({\n        specPath,\n        specKey: currentMeta.key,\n        currentVersion: currentMeta.version,\n        suggestedVersion,\n        bumpType,\n        changes,\n        hasBreaking,\n        needsBump,\n      });\n    } catch (error) {\n      logger.warn(`Failed to analyze ${specPath}:`, {\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  const specsNeedingBump = analyses.filter((a) => a.needsBump).length;\n\n  logger.info('Version analysis complete', {\n    totalSpecs: analyses.length,\n    specsNeedingBump,\n    totalBreaking,\n    totalNonBreaking,\n  });\n\n  return {\n    analyses,\n    totalSpecs: analyses.length,\n    specsNeedingBump,\n    totalBreaking,\n    totalNonBreaking,\n    baseline: options.baseline,\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Commit-Based Version Analysis\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Options for commit-based version analysis.\n */\nexport interface CommitAnalyzeOptions {\n  /** Git ref to compare against (branch, tag, commit) */\n  baseline?: string;\n  /** Workspace root directory */\n  workspaceRoot?: string;\n  /** Include commits matching these paths (glob patterns) */\n  include?: string[];\n  /** Exclude commits matching these paths (glob patterns) */\n  exclude?: string[];\n}\n\n/**\n * Result of commit-based version analysis.\n */\nexport interface CommitAnalyzeResult {\n  /** Suggested bump type based on commits */\n  suggestedBumpType: VersionBumpType | null;\n  /** Parsed conventional commits */\n  commits: {\n    hash: string;\n    message: string;\n    type: string;\n    scope?: string;\n    breaking: boolean;\n  }[];\n  /** Change entries for changelog */\n  changes: ChangeEntry[];\n  /** Total commits analyzed */\n  totalCommits: number;\n  /** Breaking commits count */\n  breakingCommits: number;\n}\n\n/**\n * Analyze version bump based on git commits.\n *\n * Parses conventional commits since the baseline and determines\n * the appropriate version bump type.\n */\nexport async function analyzeVersionsFromCommits(\n  adapters: ServiceAdapters,\n  options: CommitAnalyzeOptions = {}\n): Promise<CommitAnalyzeResult> {\n  const { git, logger } = adapters;\n  const baseline = options.baseline ?? 'HEAD~10';\n\n  logger.info('Analyzing commits for version bump...', { baseline });\n\n  try {\n    // Get commit messages since baseline\n    const commitLog = await git.log(baseline);\n\n    const parsedCommits: CommitAnalyzeResult['commits'] = [];\n    const conventionalCommits = [];\n\n    for (const commit of commitLog) {\n      const parsed = parseConventionalCommit(commit.message);\n\n      if (parsed) {\n        parsedCommits.push({\n          hash: commit.hash,\n          message: commit.message,\n          type: parsed.type,\n          scope: parsed.scope,\n          breaking: parsed.breaking,\n        });\n        conventionalCommits.push(parsed);\n      }\n    }\n\n    const suggestedBumpType = getHighestBumpType(conventionalCommits);\n    const changes = commitsToChangeEntries(conventionalCommits);\n    const breakingCommits = parsedCommits.filter((c) => c.breaking).length;\n\n    logger.info('Commit analysis complete', {\n      totalCommits: parsedCommits.length,\n      breakingCommits,\n      suggestedBumpType,\n    });\n\n    return {\n      suggestedBumpType,\n      commits: parsedCommits,\n      changes,\n      totalCommits: parsedCommits.length,\n      breakingCommits,\n    };\n  } catch (error) {\n    logger.warn('Failed to analyze commits', {\n      error: error instanceof Error ? error.message : String(error),\n    });\n\n    return {\n      suggestedBumpType: null,\n      commits: [],\n      changes: [],\n      totalCommits: 0,\n      breakingCommits: 0,\n    };\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Version Bump\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Apply a version bump to a spec file.\n *\n * Updates the version in the spec file and creates a changelog entry.\n */\nexport async function applyVersionBump(\n  adapters: ServiceAdapters,\n  options: VersionBumpOptions\n): Promise<VersionBumpResult> {\n  const { fs, logger } = adapters;\n  const { specPath, dryRun = false, config } = options;\n\n  logger.info('Applying version bump...', {\n    specPath,\n    bumpType: options.bumpType,\n  });\n\n  try {\n    // Read current spec\n    const content = await fs.readFile(specPath);\n    const meta = extractSpecMeta(content);\n\n    if (!meta) {\n      return {\n        success: false,\n        specPath,\n        specKey: 'unknown',\n        previousVersion: 'unknown',\n        newVersion: 'unknown',\n        bumpType: 'patch',\n        changelogEntry: createEmptyChangelogEntry(),\n        error: 'Could not extract spec metadata',\n      };\n    }\n\n    // Determine bump type\n    const bumpType = options.bumpType ?? 'patch';\n    const newVersion = bumpVersion(meta.version, bumpType);\n\n    // Create changelog entry\n    const changes: ChangeEntry[] = options.changes ?? [];\n    if (options.changeDescription) {\n      changes.push({\n        type: bumpType === 'major' ? 'breaking' : 'changed',\n        description: options.changeDescription,\n      });\n    }\n\n    const changelogEntry: ChangelogEntry = {\n      version: newVersion,\n      date: new Date().toISOString().split('T')[0] ?? '',\n      bumpType,\n      changes,\n      breakingChanges: changes.filter((c) => c.type === 'breaking'),\n    };\n\n    // Update the spec file\n    if (!dryRun) {\n      const updatedContent = updateSpecVersion(\n        content,\n        meta.version,\n        newVersion\n      );\n      await fs.writeFile(specPath, updatedContent);\n    }\n\n    logger.info('Version bump applied', {\n      specPath,\n      previousVersion: meta.version,\n      newVersion,\n    });\n\n    // Generate changeset if enabled\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    if ((config as any)?.integrateWithChangesets) {\n      await generateChangeset(adapters, {\n        specPath,\n        bumpType,\n        summary:\n          options.changeDescription ?? `Bump ${meta.key} to ${newVersion}`,\n        dryRun,\n      });\n    }\n\n    return {\n      success: true,\n      specPath,\n      specKey: meta.key,\n      previousVersion: meta.version,\n      newVersion,\n      bumpType,\n      changelogEntry,\n    };\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    logger.error('Version bump failed', { specPath, error: errorMessage });\n\n    return {\n      success: false,\n      specPath,\n      specKey: 'unknown',\n      previousVersion: 'unknown',\n      newVersion: 'unknown',\n      bumpType: options.bumpType ?? 'patch',\n      changelogEntry: createEmptyChangelogEntry(),\n      error: errorMessage,\n    };\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Changelog Generation\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Generate changelogs at all configured tiers.\n */\nexport async function generateChangelogs(\n  adapters: ServiceAdapters,\n  options: ChangelogGenerateOptions = {}\n): Promise<ChangelogGenerateResult> {\n  const { logger } = adapters;\n  const tiers = options.tiers ?? ['spec', 'library', 'monorepo'];\n  const format = options.format ?? 'keep-a-changelog';\n\n  logger.info('Generating changelogs...', { tiers, format });\n\n  // First, analyze versions to get changes\n  const analysis = await analyzeVersions(adapters, {\n    baseline: options.baseline,\n    workspaceRoot: options.workspaceRoot,\n  });\n\n  const specChangelogs: ChangelogDocBlock[] = [];\n  const libraryMarkdown = new Map<string, string>();\n  let monorepoMarkdown = '';\n  let totalEntries = 0;\n\n  // Generate per-spec changelogs\n  if (tiers.includes('spec')) {\n    for (const spec of analysis.analyses.filter((a) => a.needsBump)) {\n      const docBlock: ChangelogDocBlock = {\n        id: `changelog.${spec.specKey}`,\n        title: `Changelog for ${spec.specKey}`,\n        body: formatSpecChangelog(spec),\n        kind: 'changelog',\n        specKey: spec.specKey,\n        specVersion: spec.suggestedVersion,\n        entries: [\n          {\n            version: spec.suggestedVersion,\n            date: new Date().toISOString().split('T')[0] ?? '',\n            bumpType: spec.bumpType,\n            changes: spec.changes,\n            breakingChanges: spec.changes.filter((c) => c.type === 'breaking'),\n          },\n        ],\n      };\n      specChangelogs.push(docBlock);\n      totalEntries++;\n    }\n  }\n\n  // Generate library-level changelogs\n  if (tiers.includes('library')) {\n    const libraryGroups = groupByLibrary(analysis.analyses);\n    for (const [libPath, specs] of libraryGroups) {\n      const entries = specs.filter((s) => s.needsBump);\n      if (entries.length > 0) {\n        libraryMarkdown.set(\n          libPath,\n          formatKeepAChangelog(entries.map(specToChangelogEntry))\n        );\n        totalEntries += entries.length;\n      }\n    }\n  }\n\n  // Generate monorepo-level changelog\n  if (tiers.includes('monorepo')) {\n    const allEntries = analysis.analyses\n      .filter((a) => a.needsBump)\n      .map(specToChangelogEntry);\n    monorepoMarkdown = formatKeepAChangelog(allEntries);\n  }\n\n  // Generate JSON export\n  const json = formatChangelogJson(analysis, options.baseline);\n\n  logger.info('Changelog generation complete', { totalEntries });\n\n  return {\n    specChangelogs,\n    libraryMarkdown,\n    monorepoMarkdown,\n    json,\n    totalEntries,\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Helpers\n// ─────────────────────────────────────────────────────────────────────────────\n\ninterface SpecMeta {\n  key: string;\n  version: string;\n}\n\n/**\n * Extract spec metadata from file content.\n */\nfunction extractSpecMeta(content: string): SpecMeta | null {\n  // Match meta.key and meta.version patterns\n  const keyMatch = content.match(/key:\\s*['\"`]([^'\"`]+)['\"`]/);\n  const versionMatch = content.match(/version:\\s*['\"`]([^'\"`]+)['\"`]/);\n\n  if (!keyMatch || !versionMatch) {\n    return null;\n  }\n\n  const key = keyMatch[1];\n  const version = versionMatch[1];\n\n  // Type guard for regex capture groups\n  if (!key || !version) {\n    return null;\n  }\n\n  return {\n    key,\n    version,\n  };\n}\n\n/**\n * Analyze changes between current and baseline spec content.\n */\nfunction analyzeSpecChanges(\n  current: string,\n  baseline: string | null\n): ChangeEntry[] {\n  const changes: ChangeEntry[] = [];\n\n  if (!baseline) {\n    // New spec\n    changes.push({\n      type: 'added',\n      description: 'New spec added',\n    });\n    return changes;\n  }\n\n  // Simple diff analysis - check for structural changes\n  const currentMeta = extractSpecMeta(current);\n  const baselineMeta = extractSpecMeta(baseline);\n\n  if (!currentMeta || !baselineMeta) {\n    return changes;\n  }\n\n  // Version change\n  if (currentMeta.version !== baselineMeta.version) {\n    changes.push({\n      type: 'changed',\n      description: `Version updated from ${baselineMeta.version} to ${currentMeta.version}`,\n      path: 'meta.version',\n    });\n  }\n\n  // Check for io changes (simplified)\n  const hasIoChanges = detectIoChanges(current, baseline);\n  if (hasIoChanges.breaking) {\n    changes.push({\n      type: 'breaking',\n      description: 'Breaking changes to input/output schema',\n      path: 'io',\n    });\n  } else if (hasIoChanges.nonBreaking) {\n    changes.push({\n      type: 'changed',\n      description: 'Non-breaking changes to input/output schema',\n      path: 'io',\n    });\n  }\n\n  return changes;\n}\n\n/**\n * Detect I/O changes between specs (simplified).\n */\nfunction detectIoChanges(\n  current: string,\n  baseline: string\n): { breaking: boolean; nonBreaking: boolean } {\n  // Simple heuristic: check if io section differs\n  const ioPattern = /io:\\s*\\{[\\s\\S]*?\\}/;\n  const currentIo = current.match(ioPattern)?.[0] ?? '';\n  const baselineIo = baseline.match(ioPattern)?.[0] ?? '';\n\n  if (currentIo === baselineIo) {\n    return { breaking: false, nonBreaking: false };\n  }\n\n  // Check for removed fields (breaking) vs added fields (non-breaking)\n  const currentFields = extractFields(currentIo);\n  const baselineFields = extractFields(baselineIo);\n\n  const removedFields = baselineFields.filter(\n    (f) => !currentFields.includes(f)\n  );\n  const addedFields = currentFields.filter((f) => !baselineFields.includes(f));\n\n  return {\n    breaking: removedFields.length > 0,\n    nonBreaking: addedFields.length > 0 && removedFields.length === 0,\n  };\n}\n\n/**\n * Extract field names from a code block (simplified).\n */\nfunction extractFields(code: string): string[] {\n  const fieldPattern = /(\\w+):/g;\n  const matches = [...code.matchAll(fieldPattern)];\n  return matches.map((m) => m[1]).filter((field): field is string => !!field);\n}\n\n/**\n * Update version in spec content.\n */\nfunction updateSpecVersion(\n  content: string,\n  oldVersion: string,\n  newVersion: string\n): string {\n  return content.replace(\n    new RegExp(`version:\\\\s*['\"\\`]${oldVersion}['\"\\`]`),\n    `version: '${newVersion}'`\n  );\n}\n\n/**\n * Create an empty changelog entry.\n */\nfunction createEmptyChangelogEntry(): ChangelogEntry {\n  return {\n    version: '0.0.0',\n    date: new Date().toISOString().split('T')[0] ?? '',\n    bumpType: 'patch',\n    changes: [],\n  };\n}\n\n/**\n * Format a single spec's changelog.\n */\nfunction formatSpecChangelog(spec: SpecVersionAnalysis): string {\n  const lines: string[] = [\n    `## [${spec.suggestedVersion}] - ${new Date().toISOString().split('T')[0]}`,\n    '',\n  ];\n\n  const breaking = spec.changes.filter((c) => c.type === 'breaking');\n  const changed = spec.changes.filter((c) => c.type === 'changed');\n  const added = spec.changes.filter((c) => c.type === 'added');\n\n  if (breaking.length > 0) {\n    lines.push('### Breaking Changes');\n    breaking.forEach((c) => lines.push(`- ${c.description}`));\n    lines.push('');\n  }\n\n  if (added.length > 0) {\n    lines.push('### Added');\n    added.forEach((c) => lines.push(`- ${c.description}`));\n    lines.push('');\n  }\n\n  if (changed.length > 0) {\n    lines.push('### Changed');\n    changed.forEach((c) => lines.push(`- ${c.description}`));\n    lines.push('');\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Group specs by library (package path).\n */\nfunction groupByLibrary(\n  analyses: SpecVersionAnalysis[]\n): Map<string, SpecVersionAnalysis[]> {\n  const groups = new Map<string, SpecVersionAnalysis[]>();\n\n  for (const analysis of analyses) {\n    // Extract library path (up to src/)\n    const libMatch = analysis.specPath.match(/(.+?\\/src\\/)/);\n    const matchedPath = libMatch?.[1];\n    const libPath = matchedPath ?? analysis.specPath;\n\n    const existing = groups.get(libPath) ?? [];\n    existing.push(analysis);\n    groups.set(libPath, existing);\n  }\n\n  return groups;\n}\n\n/**\n * Convert SpecVersionAnalysis to ChangelogEntry.\n */\nfunction specToChangelogEntry(spec: SpecVersionAnalysis): ChangelogEntry {\n  return {\n    version: spec.suggestedVersion,\n    date: new Date().toISOString().split('T')[0] ?? '',\n    bumpType: spec.bumpType,\n    changes: spec.changes,\n    breakingChanges: spec.changes.filter((c) => c.type === 'breaking'),\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Changeset Generation\n// ─────────────────────────────────────────────────────────────────────────────\n\ninterface GenerateChangesetOptions {\n  specPath: string;\n  bumpType: VersionBumpType;\n  summary: string;\n  dryRun?: boolean;\n}\n\n/**\n * Generate a changeset file for a spec update.\n */\nasync function generateChangeset(\n  adapters: ServiceAdapters,\n  options: GenerateChangesetOptions\n): Promise<void> {\n  const { fs, logger } = adapters;\n  const { specPath, bumpType, summary, dryRun } = options;\n\n  try {\n    const pkgRoot = findPackageRoot(specPath);\n    const pkgName = getPackageName(pkgRoot);\n\n    if (!pkgName) {\n      logger.warn('Could not determine package name for changeset', {\n        specPath,\n      });\n      return;\n    }\n\n    // Find git root to locate .changeset folder\n    // This is a simplification; ideally we find the monorepo root\n    // We'll walk up from pkgRoot until we find a .changeset folder or hit root\n    let currentDir = pkgRoot;\n    let changesetDir: string | null = null;\n\n    while (true) {\n      const candidate = fs.join(currentDir, '.changeset');\n      if (await fs.exists(candidate)) {\n        changesetDir = candidate;\n        break;\n      }\n      const parent = fs.dirname(currentDir);\n      if (parent === currentDir) break;\n      currentDir = parent;\n    }\n\n    if (!changesetDir) {\n      // Create .changeset in package root if not found elsewhere (fallback)\n      // But typically it initiates in workspace root.\n      // We will skip if we absolutely can't find it to avoid polluting non-monorepos unexpected\n      logger.warn(\n        'No .changeset directory found, skipping changeset generation'\n      );\n      return;\n    }\n\n    const fileName = `${generateRandomName()}.md`;\n    const filePath = fs.join(changesetDir, fileName);\n\n    const content = `---\n\"${pkgName}\": ${bumpType}\n---\n\n${summary}\n`;\n\n    if (!dryRun) {\n      await fs.writeFile(filePath, content);\n      logger.info('Generated changeset', { filePath });\n    } else {\n      logger.info('Would generate changeset', { filePath, content });\n    }\n  } catch (error) {\n    logger.error('Failed to generate changeset', {\n      error: error instanceof Error ? error.message : String(error),\n    });\n  }\n}\n\n/**\n * Generate a random human-readable-ish name (simplified).\n */\nfunction generateRandomName(): string {\n  const adjectives = ['neat', 'calm', 'wild', 'soft', 'bold', 'fair', 'cool'];\n  const nouns = ['fox', 'cat', 'dog', 'bat', 'ant', 'elk', 'owl'];\n  const verbs = ['run', 'fly', 'hop', 'eat', 'nap', 'cry', 'sing'];\n\n  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];\n  const noun = nouns[Math.floor(Math.random() * nouns.length)];\n  const verb = verbs[Math.floor(Math.random() * verbs.length)];\n  const random = Math.floor(Math.random() * 1000);\n\n  return `${adj}-${noun}-${verb}-${random}`;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,12 @@
+import { DEFAULT_VIBE_CONFIG, VibeConfig } from "./types.mjs";
+
+//#region src/services/vibe/config.d.ts
+
+/**
+ * Load vibe configuration from workspace.
+ * Merges defaults with any user-provided config.
+ */
+declare function loadVibeConfig(cwd?: string): Promise<VibeConfig>;
+//#endregion
+export { loadVibeConfig };
+//# sourceMappingURL=config.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../../../src/services/vibe/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;iBAoBsB,cAAA,gBAA8B,QAAQ"}

package/dist/services/vibe/config.mjs

@@ -0,0 +1,43 @@
+import { findWorkspaceRoot } from "../../adapters/workspace.mjs";
+import { DEFAULT_VIBE_CONFIG } from "./types.mjs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import yaml from "js-yaml";
+
+//#region src/services/vibe/config.ts
+/**
+* Vibe configuration loader.
+*
+* Loads vibe configuration from .contractspec/vibe/config.* files.
+*/
+/**
+* Load vibe configuration from workspace.
+* Merges defaults with any user-provided config.
+*/
+async function loadVibeConfig(cwd) {
+	const workingDir = cwd ?? process.cwd();
+	const root = findWorkspaceRoot(workingDir) ?? workingDir;
+	const possiblePaths = [
+		join(root, ".contractspec", "vibe", "config.json"),
+		join(root, ".contractspec", "vibe", "config.yaml"),
+		join(root, ".contractspec", "vibe", "config.yml")
+	];
+	let localConfig = {};
+	for (const p of possiblePaths) if (existsSync(p)) try {
+		const content = await readFile(p, "utf-8");
+		if (p.endsWith(".json")) localConfig = JSON.parse(content);
+		else localConfig = yaml.load(content);
+		break;
+	} catch (e) {
+		console.warn(`Warning: Failed to parse ${p}`, e);
+	}
+	return {
+		...DEFAULT_VIBE_CONFIG,
+		...localConfig
+	};
+}
+
+//#endregion
+export { loadVibeConfig };
+//# sourceMappingURL=config.mjs.map

package/dist/services/vibe/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../../src/services/vibe/config.ts"],"sourcesContent":["/**\n * Vibe configuration loader.\n *\n * Loads vibe configuration from .contractspec/vibe/config.* files.\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { existsSync } from 'node:fs';\nimport yaml from 'js-yaml';\nimport { findWorkspaceRoot } from '../../adapters/workspace';\nimport type { VibeConfig } from './types';\nimport { DEFAULT_VIBE_CONFIG } from './types';\n\nexport { DEFAULT_VIBE_CONFIG };\n\n/**\n * Load vibe configuration from workspace.\n * Merges defaults with any user-provided config.\n */\nexport async function loadVibeConfig(cwd?: string): Promise<VibeConfig> {\n  const workingDir = cwd ?? process.cwd();\n  const root = findWorkspaceRoot(workingDir) ?? workingDir;\n\n  const possiblePaths = [\n    join(root, '.contractspec', 'vibe', 'config.json'),\n    join(root, '.contractspec', 'vibe', 'config.yaml'),\n    join(root, '.contractspec', 'vibe', 'config.yml'),\n  ];\n\n  let localConfig: Partial<VibeConfig> = {};\n\n  for (const p of possiblePaths) {\n    if (existsSync(p)) {\n      try {\n        const content = await readFile(p, 'utf-8');\n        if (p.endsWith('.json')) {\n          localConfig = JSON.parse(content);\n        } else {\n          localConfig = yaml.load(content) as Partial<VibeConfig>;\n        }\n        break;\n      } catch (e) {\n        console.warn(`Warning: Failed to parse ${p}`, e);\n      }\n    }\n  }\n\n  return { ...DEFAULT_VIBE_CONFIG, ...localConfig };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,eAAsB,eAAe,KAAmC;CACtE,MAAM,aAAa,OAAO,QAAQ,KAAK;CACvC,MAAM,OAAO,kBAAkB,WAAW,IAAI;CAE9C,MAAM,gBAAgB;EACpB,KAAK,MAAM,iBAAiB,QAAQ,cAAc;EAClD,KAAK,MAAM,iBAAiB,QAAQ,cAAc;EAClD,KAAK,MAAM,iBAAiB,QAAQ,aAAa;EAClD;CAED,IAAI,cAAmC,EAAE;AAEzC,MAAK,MAAM,KAAK,cACd,KAAI,WAAW,EAAE,CACf,KAAI;EACF,MAAM,UAAU,MAAM,SAAS,GAAG,QAAQ;AAC1C,MAAI,EAAE,SAAS,QAAQ,CACrB,eAAc,KAAK,MAAM,QAAQ;MAEjC,eAAc,KAAK,KAAK,QAAQ;AAElC;UACO,GAAG;AACV,UAAQ,KAAK,4BAA4B,KAAK,EAAE;;AAKtD,QAAO;EAAE,GAAG;EAAqB,GAAG;EAAa"}

package/dist/services/vibe/context.d.mts

@@ -0,0 +1,19 @@
+//#region src/services/vibe/context.d.ts
+/**
+ * Context export service.
+ *
+ * Exports a safe context bundle for AI agents.
+ */
+interface ContextExportResult {
+  success: boolean;
+  files: string[];
+  indexPath: string;
+  error?: string;
+}
+/**
+ * Export a context bundle for AI agents.
+ */
+declare function exportContext(cwd?: string): Promise<ContextExportResult>;
+//#endregion
+export { ContextExportResult, exportContext };
+//# sourceMappingURL=context.d.mts.map

package/dist/services/vibe/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../../../src/services/vibe/context.ts"],"sourcesContent":[],"mappings":";;AAwBA;AAUA;;;UAViB,mBAAA;;;;;;;;;iBAUK,aAAA,gBAEnB,QAAQ"}