@contractspec/bundle.workspace 1.45.1 → 1.45.3

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

@@ -0,0 +1,133 @@
+import { ChangeEntry, ChangelogDocBlock, ChangelogEntry as ChangelogEntry$1, ChangelogTier, VersionBumpType } from "@contractspec/lib.contracts";
+
+//#region src/services/versioning/types.d.ts
+
+/** Options for version analysis */
+interface VersionAnalyzeOptions {
+  /** Git ref to compare against (branch, tag, commit) */
+  baseline?: string;
+  /** Glob pattern for spec discovery */
+  pattern?: string;
+  /** Workspace root directory */
+  workspaceRoot?: string;
+  /** Include paths (glob patterns) */
+  include?: string[];
+  /** Exclude paths (glob patterns) */
+  exclude?: string[];
+}
+/** Options for version bump */
+interface VersionBumpOptions {
+  /** Spec file path to bump */
+  specPath: string;
+  /** Bump type (auto-detected if not specified) */
+  bumpType?: VersionBumpType;
+  /** Change description for changelog entry */
+  changeDescription?: string;
+  /** Additional change entries */
+  changes?: ChangeEntry[];
+  /** Dry run (don't write changes) */
+  dryRun?: boolean;
+}
+/** Options for changelog generation */
+interface ChangelogGenerateOptions {
+  /** Git ref to compare against */
+  baseline?: string;
+  /** Workspace root directory */
+  workspaceRoot?: string;
+  /** Changelog tiers to generate */
+  tiers?: ChangelogTier[];
+  /** Output format */
+  format?: 'keep-a-changelog' | 'conventional' | 'custom';
+  /** Custom template (for 'custom' format) */
+  template?: string;
+}
+/** Result of version analysis for a single spec */
+interface SpecVersionAnalysis {
+  /** Path to the spec file */
+  specPath: string;
+  /** Spec key (e.g., "auth.login") */
+  specKey: string;
+  /** Current version in the spec */
+  currentVersion: string;
+  /** Suggested new version based on changes */
+  suggestedVersion: string;
+  /** Suggested bump type */
+  bumpType: VersionBumpType;
+  /** Detected changes requiring version bump */
+  changes: ChangeEntry[];
+  /** Whether breaking changes were detected */
+  hasBreaking: boolean;
+  /** Whether the spec needs a version bump */
+  needsBump: boolean;
+}
+/** Aggregated version analysis result */
+interface VersionAnalyzeResult {
+  /** Individual spec analyses */
+  analyses: SpecVersionAnalysis[];
+  /** Total specs analyzed */
+  totalSpecs: number;
+  /** Specs needing version bump */
+  specsNeedingBump: number;
+  /** Total breaking changes across all specs */
+  totalBreaking: number;
+  /** Total non-breaking changes */
+  totalNonBreaking: number;
+  /** Git baseline used for comparison */
+  baseline?: string;
+}
+/** Result of version bump operation */
+interface VersionBumpResult {
+  /** Whether the bump was successful */
+  success: boolean;
+  /** Path to the updated spec file */
+  specPath: string;
+  /** Spec key */
+  specKey: string;
+  /** Previous version */
+  previousVersion: string;
+  /** New version */
+  newVersion: string;
+  /** Bump type applied */
+  bumpType: VersionBumpType;
+  /** Changelog entry created */
+  changelogEntry: ChangelogEntry$1;
+  /** Error message if failed */
+  error?: string;
+}
+/** Result of changelog generation */
+interface ChangelogGenerateResult {
+  /** Per-spec DocBlock entries */
+  specChangelogs: ChangelogDocBlock[];
+  /** Library-level markdown by package path */
+  libraryMarkdown: Map<string, string>;
+  /** Monorepo-level markdown */
+  monorepoMarkdown: string;
+  /** JSON format for programmatic use */
+  json: ChangelogJsonExport;
+  /** Total entries generated */
+  totalEntries: number;
+}
+/** JSON export format for changelogs */
+interface ChangelogJsonExport {
+  generatedAt: string;
+  baseline?: string;
+  specs: SpecChangelogJson[];
+  libraries: LibraryChangelogJson[];
+}
+/** Spec-level changelog in JSON format */
+interface SpecChangelogJson {
+  key: string;
+  version: string;
+  path: string;
+  entries: ChangelogEntry$1[];
+}
+/** Library-level changelog in JSON format */
+interface LibraryChangelogJson {
+  name: string;
+  path: string;
+  version: string;
+  entries: ChangelogEntry$1[];
+}
+//#endregion
+export { type ChangeEntry, type ChangelogDocBlock, type ChangelogEntry$1 as ChangelogEntry, ChangelogGenerateOptions, ChangelogGenerateResult, ChangelogJsonExport, type ChangelogTier, LibraryChangelogJson, SpecChangelogJson, SpecVersionAnalysis, VersionAnalyzeOptions, VersionAnalyzeResult, VersionBumpOptions, VersionBumpResult, type VersionBumpType };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/services/versioning/types.ts"],"sourcesContent":[],"mappings":";;;;AA8GA;AAoBiB,UAtGA,qBAAA,CAsGuB;EAEtB;EAEC,QAAA,CAAA,EAAA,MAAA;EAIX;EAAmB,OAAA,CAAA,EAAA,MAAA;EAMV;EAQA,aAAA,CAAA,EAAA,MAAiB;EAQjB;;;;;;UAtHA,kBAAA;;;;aAIJ;;;;YAID;;;;;UAMK,wBAAA;;;;;;UAMP;;;;;;;UAYO,mBAAA;;;;;;;;;;YAUL;;WAED;;;;;;;UAQM,oBAAA;;YAEL;;;;;;;;;;;;;UAcK,iBAAA;;;;;;;;;;;;YAYL;;kBAEM;;;;;UAMD,uBAAA;;kBAEC;;mBAEC;;;;QAIX;;;;;UAMS,mBAAA;;;SAGR;aACI;;;UAII,iBAAA;;;;WAIN;;;UAIM,oBAAA;;;;WAIN"}

package/dist/services/versioning/versioning-service.d.ts

@@ -0,0 +1,32 @@
+import { FsAdapter } from "../../ports/fs.js";
+import { GitAdapter } from "../../ports/git.js";
+import { LoggerAdapter } from "../../ports/logger.js";
+import { ChangelogGenerateOptions, ChangelogGenerateResult, VersionAnalyzeOptions, VersionAnalyzeResult, VersionBumpOptions, VersionBumpResult } from "./types.js";
+
+//#region src/services/versioning/versioning-service.d.ts
+
+interface ServiceAdapters {
+  fs: FsAdapter;
+  git: GitAdapter;
+  logger: LoggerAdapter;
+}
+/**
+ * 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.
+ */
+declare function analyzeVersions(adapters: ServiceAdapters, options?: VersionAnalyzeOptions): Promise<VersionAnalyzeResult>;
+/**
+ * Apply a version bump to a spec file.
+ *
+ * Updates the version in the spec file and creates a changelog entry.
+ */
+declare function applyVersionBump(adapters: ServiceAdapters, options: VersionBumpOptions): Promise<VersionBumpResult>;
+/**
+ * Generate changelogs at all configured tiers.
+ */
+declare function generateChangelogs(adapters: ServiceAdapters, options?: ChangelogGenerateOptions): Promise<ChangelogGenerateResult>;
+//#endregion
+export { analyzeVersions, applyVersionBump, generateChangelogs };
+//# sourceMappingURL=versioning-service.d.ts.map

package/dist/services/versioning/versioning-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioning-service.d.ts","names":[],"sources":["../../../src/services/versioning/versioning-service.ts"],"sourcesContent":[],"mappings":";;;;;;;UAmCU,eAAA,CAGa;EAaD,EAAA,EAfhB,SAegB;EACV,GAAA,EAfL,UAeK;EACD,MAAA,EAfD,aAeC;;;;AAwGX;;;;AAGG,iBA7GmB,eAAA,CA6GnB,QAAA,EA5GS,eA4GT,EAAA,OAAA,CAAA,EA3GQ,qBA2GR,CAAA,EA1GA,OA0GA,CA1GQ,oBA0GR,CAAA;;AAiGH;;;;AAGG,iBAvGmB,gBAAA,CAuGnB,QAAA,EAtGS,eAsGT,EAAA,OAAA,EArGQ,kBAqGR,CAAA,EApGA,OAoGA,CApGQ,iBAoGR,CAAA;;;;iBAHmB,kBAAA,WACV,2BACD,2BACR,QAAQ"}

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

@@ -0,0 +1,359 @@
+import { formatChangelogJson, formatKeepAChangelog } from "./changelog-formatter.js";
+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
+	};
+}
+/**
+* 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 } = 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
+		});
+		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")
+	};
+}
+
+//#endregion
+export { analyzeVersions, applyVersionBump, generateChangelogs };
+//# sourceMappingURL=versioning-service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"versioning-service.js","names":["analyses: SpecVersionAnalysis[]","baselineContent: string | null","changes: ChangeEntry[]","changelogEntry: ChangelogEntry","specChangelogs: ChangelogDocBlock[]","docBlock: ChangelogDocBlock","lines: string[]"],"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} from '@contractspec/lib.contracts';\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';\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// 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 } = 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    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"],"mappings":"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"}

package/dist/templates/app-config.template.js

@@ -40,24 +40,24 @@ function buildMappingSection(prop, mappings) {
 	if (mappings.length === 0) return "";
 	return `  ${prop}: {\n${mappings.map((mapping) => `    ${mapping.slot}: {
       name: '${escapeString(mapping.name)}',
-      ${typeof mapping.version === "number" ? `version: ${mapping.version},` : ""}
+      ${mapping.version !== void 0 ? `version: '${mapping.version}',` : ""}
     }`).join(",\n")}\n  },\n`;
 }
 function buildPolicySection(data) {
 	if (data.policyRefs.length === 0) return "";
 	return `  policies: [\n${data.policyRefs.map((policy) => `    {
-      name: '${escapeString(policy.name)}'${typeof policy.version === "number" ? `,\n      version: ${policy.version}` : ""}
+      name: '${escapeString(policy.name)}'${policy.version !== void 0 ? `,\n      version: '${policy.version}'` : ""}
     }`).join(",\n")}\n  ],\n`;
 }
 function buildThemeSection(data) {
 	if (!data.theme) return "";
-	return `  theme: {\n${`    primary: { name: '${escapeString(data.theme.name)}', version: ${data.theme.version} },\n`}${data.themeFallbacks.length > 0 ? `    fallbacks: [${data.themeFallbacks.map((theme) => `{ name: '${escapeString(theme.name)}', version: ${theme.version} }`).join(", ")}],\n` : ""}  },\n`;
+	return `  theme: {\n${`    primary: { name: '${escapeString(data.theme.name)}', version: '${data.theme.version}' },\n`}${data.themeFallbacks.length > 0 ? `    fallbacks: [${data.themeFallbacks.map((theme) => `{ name: '${escapeString(theme.name)}', version: '${theme.version}' }`).join(", ")}],\n` : ""}  },\n`;
 }
 function buildTelemetrySection(data) {
 	if (!data.telemetry) return "";
 	return `  telemetry: {
     spec: {
-      name: '${escapeString(data.telemetry.name)}'${typeof data.telemetry.version === "number" ? `,\n      version: ${data.telemetry.version}` : ""}
+      name: '${escapeString(data.telemetry.name)}'${data.telemetry.version !== void 0 ? `\n      version: '${data.telemetry.version}'` : ""}
     },
   },\n`;
 }
@@ -82,9 +82,9 @@ function buildRoutesSection(data) {
 			route.label ? `label: '${escapeString(route.label)}'` : null,
 			route.dataView ? `dataView: '${escapeString(route.dataView)}'` : null,
 			route.workflow ? `workflow: '${escapeString(route.workflow)}'` : null,
-			route.guardName ? `guard: { name: '${escapeString(route.guardName)}'${typeof route.guardVersion === "number" ? `, version: ${route.guardVersion}` : ""} }` : null,
+			route.guardName ? `guard: { name: '${escapeString(route.guardName)}'${route.guardVersion !== void 0 ? `, version: '${route.guardVersion}'` : ""} }` : null,
 			route.featureFlag ? `featureFlag: '${escapeString(route.featureFlag)}'` : null,
-			route.experimentName ? `experiment: { name: '${escapeString(route.experimentName)}'${typeof route.experimentVersion === "number" ? `, version: ${route.experimentVersion}` : ""} }` : null
+			route.experimentName ? `experiment: { name: '${escapeString(route.experimentName)}'${route.experimentVersion !== void 0 ? `, version: '${route.experimentVersion}'` : ""} }` : null
 		].filter(Boolean).join(", ")} }`;
 	}).join(",\n")}\n  ],\n`;
 }
@@ -92,7 +92,7 @@ function formatCapabilityRef(key) {
 	return `{ key: '${escapeString(key)}' }`;
 }
 function formatExperimentRef(exp) {
-	const version = typeof exp.version === "number" ? `, version: ${exp.version}` : "";
+	const version = exp.version !== void 0 ? `, version: '${exp.version}'` : "";
 	return `{ name: '${escapeString(exp.name)}'${version} }`;
 }
 function toPascalCase(value) {