@contractspec/bundle.workspace 4.1.3 → 4.2.0

package/dist/index.js

@@ -9763,7 +9763,7 @@ function generateWorkflowSpec(data) {
 ${transition.condition ? `      condition: '${escapeString4(transition.condition)}',` : ""}
     }`).join(`,
 `);
-  return `import type { WorkflowSpec } from '@contractspec/lib.contracts-spec/workflow';
+  return `import type { WorkflowSpec } from '@contractspec/lib.contracts-spec/workflow/spec';
 
 /**
  * Workflow generated via contractspec CLI.
@@ -9836,11 +9836,9 @@ function generateWorkflowRunnerTemplate({
   runnerName,
   workflowName
 }) {
-  return `import {
-  InMemoryStateStore,
-  WorkflowRegistry,
-  WorkflowRunner,
-} from '@contractspec/lib.contracts-spec/workflow';
+  return `import { InMemoryStateStore } from '@contractspec/lib.contracts-spec/workflow/adapters';
+import { WorkflowRunner } from '@contractspec/lib.contracts-spec/workflow/runner';
+import { WorkflowRegistry } from '@contractspec/lib.contracts-spec/workflow/spec';
 import { ${exportName} } from '${specImportPath}';
 
 /**
@@ -14667,8 +14665,10 @@ __export(exports_upgrade, {
   getPackageUpgradeCommand: () => getPackageUpgradeCommand,
   getDefaultVersioningConfig: () => getDefaultVersioningConfig,
   getDefaultHooksConfig: () => getDefaultHooksConfig,
+  applyGuidedUpgrade: () => applyGuidedUpgrade,
   applyConfigUpgrades: () => applyConfigUpgrades,
-  analyzeUpgrades: () => analyzeUpgrades
+  analyzeUpgrades: () => analyzeUpgrades,
+  analyzeGuidedUpgrade: () => analyzeGuidedUpgrade
 });
 
 // src/services/upgrade/upgrade-service.ts
@@ -14676,14 +14676,16 @@ var API_HOST = process.env["CONTRACTSPEC_API_HOST"] ?? "api.contractspec.io";
 var LATEST_SCHEMA_URL = `https://${API_HOST}/schemas/contractsrc.json`;
 async function analyzeUpgrades(adapters, options) {
   const { fs: fs5, logger: logger3 } = adapters;
+  const packageRoot = findPackageRoot(options.workspaceRoot);
   const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
   const packageManager = detectPackageManager(workspaceRoot);
   logger3.info("Analyzing available upgrades...", {
     workspaceRoot,
+    packageRoot,
     packageManager
   });
-  const packages = await analyzePackages(fs5, workspaceRoot);
-  const configUpgrades = await analyzeConfig(fs5, workspaceRoot);
+  const packages = await analyzePackages(fs5, packageRoot);
+  const configUpgrades = await analyzeConfig(fs5, packageRoot);
   const hasUpgrades = packages.length > 0 || configUpgrades.length > 0;
   return {
     packageManager,
@@ -14762,6 +14764,22 @@ async function analyzeConfig(fs5, workspaceRoot) {
         isNew: true
       });
     }
+    if (!config["release"]) {
+      upgrades.push({
+        key: "release",
+        currentValue: undefined,
+        suggestedValue: getDefaultReleaseConfig(),
+        isNew: true
+      });
+    }
+    if (!config["upgrade"]) {
+      upgrades.push({
+        key: "upgrade",
+        currentValue: undefined,
+        suggestedValue: getDefaultUpgradeConfig(),
+        isNew: true
+      });
+    }
     return upgrades;
   } catch {
     return [];
@@ -14769,11 +14787,11 @@ async function analyzeConfig(fs5, workspaceRoot) {
 }
 async function applyConfigUpgrades(adapters, options) {
   const { fs: fs5, logger: logger3 } = adapters;
-  const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
+  const packageRoot = findPackageRoot(options.workspaceRoot);
   if (options.dryRun) {
     logger3.info("Dry run - no changes will be made");
   }
-  const configPath = fs5.join(workspaceRoot, ".contractsrc.json");
+  const configPath = fs5.join(packageRoot, ".contractsrc.json");
   if (!await fs5.exists(configPath)) {
     return {
       success: false,
@@ -14806,6 +14824,14 @@ async function applyConfigUpgrades(adapters, options) {
       config["hooks"] = getDefaultHooksConfig();
       sectionsUpgraded++;
     }
+    if (!config["release"]) {
+      config["release"] = getDefaultReleaseConfig();
+      sectionsUpgraded++;
+    }
+    if (!config["upgrade"]) {
+      config["upgrade"] = getDefaultUpgradeConfig();
+      sectionsUpgraded++;
+    }
     if (sectionsUpgraded === 0) {
       return {
         success: true,
@@ -14865,6 +14891,446 @@ function getDefaultHooksConfig() {
     "pre-commit": ["contractspec validate", "contractspec integrity check"]
   };
 }
+function getDefaultReleaseConfig() {
+  return {
+    enforceOn: "release-branch",
+    requireChangesetForPublished: true,
+    requireReleaseCapsule: true,
+    publishArtifacts: [
+      "manifest.json",
+      "patch-notes.md",
+      "customer-guide.md",
+      "upgrade-manifest.json"
+    ],
+    agentTargets: ["codex"]
+  };
+}
+function getDefaultUpgradeConfig() {
+  return {
+    manifestPaths: ["generated/releases/upgrade-manifest.json"],
+    defaultAgentTarget: "codex",
+    enableInteractiveGuidance: true,
+    applyCodemods: true
+  };
+}
+// src/services/upgrade/guided-upgrade.ts
+import {
+  GeneratedReleaseManifestSchema
+} from "@contractspec/lib.contracts-spec";
+import {
+  ContractsrcSchema as ContractsrcSchema3,
+  DEFAULT_CONTRACTSRC as DEFAULT_CONTRACTSRC4
+} from "@contractspec/lib.contracts-spec/workspace-config/contractsrc-schema";
+
+// src/services/versioning/release-plan.ts
+import {
+  compareVersions,
+  countUpgradePlanStepLevels,
+  createAgentPromptBundles,
+  dedupeUpgradePlanSteps,
+  sortReleaseManifest
+} from "@contractspec/lib.contracts-spec";
+function selectUpgradeReleases(manifest, packages) {
+  if (packages.length === 0) {
+    return sortReleaseManifest(manifest);
+  }
+  const packageVersions = new Map(packages.map((pkg) => [pkg.name, pkg.currentVersion ?? "0.0.0"]));
+  return sortReleaseManifest({
+    ...manifest,
+    releases: manifest.releases.filter((release) => release.packages.some((pkg) => {
+      const currentVersion = packageVersions.get(pkg.name);
+      if (!currentVersion || !pkg.version) {
+        return false;
+      }
+      return compareVersions(pkg.version, currentVersion) === 1;
+    }))
+  });
+}
+function createUpgradePlan(manifest, packages, agentTargets, renderPrompt) {
+  const releases = selectUpgradeReleases(manifest, packages);
+  const targetPackages = buildUpgradeTargets(releases, packages);
+  const steps = dedupeUpgradePlanSteps(releases.flatMap((release) => release.upgradeSteps));
+  const counts = countUpgradePlanStepLevels(steps);
+  const basePlan = {
+    generatedAt: new Date().toISOString(),
+    targetPackages,
+    releases,
+    steps,
+    autofixCount: counts.auto,
+    manualCount: counts.manual,
+    assistedCount: counts.assisted,
+    agentPrompts: []
+  };
+  const agentPrompts = createAgentPromptBundles(basePlan, agentTargets, renderPrompt);
+  return {
+    ...basePlan,
+    agentPrompts
+  };
+}
+function buildUpgradeTargets(releases, packages) {
+  const currentVersions = new Map(packages.map((pkg) => [pkg.name, pkg.currentVersion]));
+  const targets = new Map;
+  for (const release of releases) {
+    for (const pkg of release.packages) {
+      const current = currentVersions.get(pkg.name);
+      const existing = targets.get(pkg.name);
+      if (!existing) {
+        targets.set(pkg.name, {
+          name: pkg.name,
+          currentVersion: current,
+          targetVersion: pkg.version
+        });
+        continue;
+      }
+      if (pkg.version && existing.targetVersion && compareVersions(pkg.version, existing.targetVersion) === 1) {
+        existing.targetVersion = pkg.version;
+      }
+    }
+  }
+  return Array.from(targets.values()).sort((left, right) => left.name.localeCompare(right.name));
+}
+
+// src/services/versioning/release-formatters.ts
+function formatPackages(entry) {
+  return entry.packages.map((pkg) => {
+    const version = pkg.version ? `@${pkg.version}` : "";
+    return `- ${pkg.name}${version} (${pkg.releaseType})`;
+  });
+}
+function formatSteps(steps) {
+  return steps.map((step) => `  - ${step}`);
+}
+function renderMaintainerSummary(entry) {
+  const lines = [
+    `### ${entry.summary}`,
+    `- Slug: ${entry.slug}`,
+    `- Date: ${entry.date}`,
+    `- Breaking: ${entry.isBreaking ? "yes" : "no"}`,
+    ...formatPackages(entry)
+  ];
+  if (entry.deprecations.length > 0) {
+    lines.push("- Deprecations:");
+    lines.push(...entry.deprecations.map((item) => `  - ${item}`));
+  }
+  return lines.join(`
+`);
+}
+function renderCustomerPatchNote(entry) {
+  const lines = [`### ${entry.summary}`, ...formatPackages(entry)];
+  for (const instruction of entry.migrationInstructions) {
+    lines.push(`- ${instruction.title}: ${instruction.summary}`);
+  }
+  return lines.join(`
+`);
+}
+function renderMigrationGuide(entry) {
+  const lines = [`### ${entry.summary}`];
+  if (entry.migrationInstructions.length === 0) {
+    lines.push("- No manual migration steps recorded.");
+    return lines.join(`
+`);
+  }
+  for (const instruction of entry.migrationInstructions) {
+    lines.push(`- ${instruction.title}: ${instruction.summary}`);
+    lines.push(...formatSteps(instruction.steps));
+  }
+  return lines.join(`
+`);
+}
+function renderPatchNotes(manifest) {
+  return ["# Patch Notes", "", ...manifest.releases.map(renderMaintainerSummary)].join(`
+
+`);
+}
+function renderCustomerGuide(manifest) {
+  return [
+    "# Customer Upgrade Guide",
+    "",
+    ...manifest.releases.map(renderMigrationGuide)
+  ].join(`
+
+`);
+}
+function renderUpgradeChecklist(plan) {
+  if (plan.steps.length === 0) {
+    return "- No release-managed upgrade steps were found.";
+  }
+  return plan.steps.map((step) => [`- [${step.level}] ${step.title}: ${step.summary}`, ...formatSteps(step.instructions)].join(`
+`)).join(`
+`);
+}
+function renderUpgradePrompt(agent, plan) {
+  const targets = plan.targetPackages.map((pkg) => `${pkg.name}: ${pkg.currentVersion ?? "unknown"} -> ${pkg.targetVersion ?? "latest"}`).join(`
+`);
+  return [
+    `Apply the ContractSpec upgrade plan in this workspace using ${agent}.`,
+    "",
+    "Target packages:",
+    targets || "- No package version targets were inferred.",
+    "",
+    "Required steps:",
+    renderUpgradeChecklist(plan)
+  ].join(`
+`);
+}
+
+// src/services/upgrade/guided-upgrade.ts
+var IMPORT_REWRITE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs}";
+var DEFAULT_UPGRADE_CONFIG = DEFAULT_CONTRACTSRC4.upgrade ?? {
+  manifestPaths: ["generated/releases/upgrade-manifest.json"],
+  defaultAgentTarget: "codex",
+  enableInteractiveGuidance: true,
+  applyCodemods: true
+};
+async function analyzeGuidedUpgrade(adapters, options) {
+  const { fs: fs5 } = adapters;
+  const packageRoot = findPackageRoot(options.workspaceRoot);
+  const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
+  const config = await readWorkspaceUpgradeConfig(fs5, packageRoot, workspaceRoot);
+  const manifestResolution = await resolveUpgradeManifest(fs5, packageRoot, workspaceRoot, options.manifestPaths ?? config.manifestPaths);
+  const analysis = await analyzeUpgrades(adapters, {
+    workspaceRoot: packageRoot,
+    dryRun: options.dryRun
+  });
+  const agentTargets = [
+    options.agentTarget ?? config.defaultAgentTarget ?? "codex"
+  ];
+  const plan = createUpgradePlan(manifestResolution.manifest, analysis.packages.map((pkg) => ({
+    name: pkg.name,
+    currentVersion: pkg.currentVersion
+  })), agentTargets, renderUpgradePrompt);
+  const augmentedPlan = augmentUpgradePlan(plan, analysis.packages, analysis.configUpgrades);
+  return {
+    packageManager: analysis.packageManager,
+    manifestPath: manifestResolution.path,
+    plan: augmentedPlan,
+    humanChecklist: buildChecklist(augmentedPlan)
+  };
+}
+async function applyGuidedUpgrade(adapters, options) {
+  const { fs: fs5, logger: logger3 } = adapters;
+  const packageRoot = findPackageRoot(options.workspaceRoot);
+  const analysis = await analyzeGuidedUpgrade(adapters, options);
+  const appliedAutofixes = [];
+  if (!options.dryRun) {
+    for (const step of analysis.plan.steps) {
+      if (step.level !== "auto") {
+        continue;
+      }
+      for (const fix of step.autofixes ?? []) {
+        const applied = await applyAutofix(fs5, packageRoot, fix);
+        if (applied) {
+          appliedAutofixes.push(fix.id);
+        }
+      }
+    }
+    logger3.info("Applied guided upgrade autofixes", {
+      count: appliedAutofixes.length,
+      workspaceRoot: packageRoot
+    });
+  }
+  const remainingSteps = analysis.plan.steps.filter((step) => step.level !== "auto");
+  return {
+    success: true,
+    packagesUpgraded: appliedAutofixes.filter((id) => id.startsWith("pkg:")).length,
+    configSectionsUpgraded: appliedAutofixes.filter((id) => id.startsWith("config:")).length,
+    summary: options.dryRun ? `Would apply ${analysis.plan.autofixCount} deterministic upgrade step(s)` : `Applied ${appliedAutofixes.length} deterministic upgrade autofix(es)`,
+    appliedAutofixes,
+    remainingSteps,
+    humanChecklist: analysis.humanChecklist,
+    promptBundle: analysis.plan.agentPrompts[0],
+    plan: analysis.plan,
+    manifestPath: analysis.manifestPath
+  };
+}
+async function resolveUpgradeManifest(fs5, packageRoot, workspaceRoot, manifestPaths) {
+  const candidatePaths = manifestPaths ?? ["generated/releases/upgrade-manifest.json"];
+  const searchRoots = Array.from(new Set([packageRoot, workspaceRoot]));
+  for (const candidatePath of candidatePaths) {
+    const resolvedPaths = candidatePath.startsWith("/") ? [candidatePath] : searchRoots.map((root) => fs5.join(root, candidatePath));
+    for (const resolvedPath of resolvedPaths) {
+      if (!await fs5.exists(resolvedPath)) {
+        continue;
+      }
+      const manifest = GeneratedReleaseManifestSchema.parse(JSON.parse(await fs5.readFile(resolvedPath)));
+      return { path: resolvedPath, manifest };
+    }
+  }
+  return {
+    manifest: GeneratedReleaseManifestSchema.parse({
+      generatedAt: new Date().toISOString(),
+      releases: []
+    })
+  };
+}
+async function readWorkspaceUpgradeConfig(fs5, packageRoot, workspaceRoot) {
+  for (const configPath of Array.from(new Set([
+    fs5.join(packageRoot, ".contractsrc.json"),
+    fs5.join(workspaceRoot, ".contractsrc.json")
+  ]))) {
+    if (!await fs5.exists(configPath)) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(await fs5.readFile(configPath));
+      const validated = ContractsrcSchema3.safeParse(parsed);
+      if (validated.success) {
+        return {
+          ...DEFAULT_UPGRADE_CONFIG,
+          ...validated.data.upgrade
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return DEFAULT_UPGRADE_CONFIG;
+}
+function augmentUpgradePlan(plan, packages, configUpgrades) {
+  const packageFixes = [];
+  for (const pkg of packages) {
+    const target = plan.targetPackages.find((entry) => entry.name === pkg.name);
+    if (!target?.targetVersion || target.targetVersion === pkg.currentVersion) {
+      continue;
+    }
+    packageFixes.push({
+      id: `pkg:${pkg.name}`,
+      kind: "package-json",
+      title: `Update ${pkg.name}`,
+      summary: `Update ${pkg.name} to ${target.targetVersion}`,
+      packageName: pkg.name,
+      dependencyType: pkg.isDevDependency ? "devDependencies" : "dependencies",
+      from: pkg.currentVersion,
+      to: target.targetVersion
+    });
+  }
+  const configFixes = configUpgrades.map((upgrade) => ({
+    id: `config:${upgrade.key}`,
+    kind: "contractsrc",
+    title: `Update ${upgrade.key}`,
+    summary: `Update .contractsrc.json at ${upgrade.key}`,
+    configPath: upgrade.key,
+    value: upgrade.suggestedValue
+  }));
+  const implicitSteps = [];
+  if (packageFixes.length > 0) {
+    implicitSteps.push({
+      id: "upgrade-contractspec-packages",
+      title: "Update ContractSpec packages",
+      summary: "Apply package version upgrades from the release manifest.",
+      level: "auto",
+      instructions: packageFixes.map((fix) => `${fix.packageName}: ${fix.from ?? "current"} -> ${fix.to ?? "latest"}`),
+      packages: packageFixes.map((fix) => fix.packageName ?? ""),
+      autofixes: packageFixes
+    });
+  }
+  if (configFixes.length > 0) {
+    implicitSteps.push({
+      id: "upgrade-contractsrc-config",
+      title: "Refresh .contractsrc.json defaults",
+      summary: "Bring workspace release and upgrade config in line with current defaults.",
+      level: "auto",
+      instructions: configFixes.map((fix) => `${fix.configPath} -> updated`),
+      autofixes: configFixes
+    });
+  }
+  const steps = [...implicitSteps, ...plan.steps];
+  const autoCount = steps.filter((step) => step.level === "auto").length;
+  const assistedCount = steps.filter((step) => step.level === "assisted").length;
+  const manualCount = steps.filter((step) => step.level === "manual").length;
+  return {
+    ...plan,
+    steps,
+    autofixCount: autoCount,
+    assistedCount,
+    manualCount,
+    agentPrompts: createUpgradePlan({
+      generatedAt: plan.generatedAt,
+      releases: plan.releases
+    }, plan.targetPackages.map((pkg) => ({
+      name: pkg.name,
+      currentVersion: pkg.currentVersion
+    })), plan.agentPrompts.map((prompt) => prompt.agent), renderUpgradePrompt).agentPrompts
+  };
+}
+function buildChecklist(plan) {
+  return plan.steps.map((step) => `${step.title}: ${step.summary}`);
+}
+async function applyAutofix(fs5, workspaceRoot, fix) {
+  switch (fix.kind) {
+    case "package-json":
+      return applyPackageJsonAutofix(fs5, workspaceRoot, fix);
+    case "contractsrc":
+      return applyContractsrcAutofix(fs5, workspaceRoot, fix);
+    case "import-rewrite":
+      return applyImportRewriteAutofix(fs5, workspaceRoot, fix);
+    case "codemod":
+      return false;
+  }
+}
+async function applyPackageJsonAutofix(fs5, workspaceRoot, fix) {
+  const packageJsonPath = fs5.join(workspaceRoot, "package.json");
+  if (!await fs5.exists(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = JSON.parse(await fs5.readFile(packageJsonPath));
+  const dependencyType = fix.dependencyType ?? "dependencies";
+  const dependencies2 = packageJson[dependencyType] ?? {};
+  if (!fix.packageName || !fix.to || !dependencies2[fix.packageName]) {
+    return false;
+  }
+  dependencies2[fix.packageName] = fix.to;
+  packageJson[dependencyType] = dependencies2;
+  await fs5.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + `
+`);
+  return true;
+}
+async function applyContractsrcAutofix(fs5, workspaceRoot, fix) {
+  const configPath = fs5.join(workspaceRoot, ".contractsrc.json");
+  const config = await fs5.exists(configPath) ? JSON.parse(await fs5.readFile(configPath)) : {};
+  if (!fix.configPath) {
+    return false;
+  }
+  setNestedValue(config, fix.configPath, fix.value);
+  await fs5.writeFile(configPath, JSON.stringify(config, null, 2) + `
+`);
+  return true;
+}
+async function applyImportRewriteAutofix(fs5, workspaceRoot, fix) {
+  if (!fix.from || !fix.to) {
+    return false;
+  }
+  const files = await fs5.glob({
+    pattern: fix.path ?? IMPORT_REWRITE_GLOB,
+    cwd: workspaceRoot,
+    absolute: true
+  });
+  let changed = false;
+  for (const filePath of files) {
+    const content = await fs5.readFile(filePath);
+    if (!content.includes(fix.from)) {
+      continue;
+    }
+    await fs5.writeFile(filePath, content.split(fix.from).join(fix.to));
+    changed = true;
+  }
+  return changed;
+}
+function setNestedValue(target, path9, value) {
+  const segments = path9.split(".");
+  let current = target;
+  for (const segment of segments.slice(0, -1)) {
+    const next = current[segment];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments.at(-1);
+  if (lastSegment) {
+    current[lastSegment] = value;
+  }
+}
 // src/services/verification-cache/adapters/filesystem.ts
 import {
   existsSync as existsSync3,
@@ -16233,8 +16699,16 @@ var verifyService = new VerifyService;
 // src/services/versioning/index.ts
 var exports_versioning = {};
 __export(exports_versioning, {
+  renderUpgradePrompt: () => renderUpgradePrompt,
+  renderUpgradeChecklist: () => renderUpgradeChecklist,
+  renderPatchNotes: () => renderPatchNotes,
+  renderMigrationGuide: () => renderMigrationGuide,
+  renderMaintainerSummary: () => renderMaintainerSummary,
+  renderCustomerPatchNote: () => renderCustomerPatchNote,
+  renderCustomerGuide: () => renderCustomerGuide,
   parseConventionalCommit: () => parseConventionalCommit,
   isConventionalCommit: () => isConventionalCommit,
+  initReleaseArtifacts: () => initReleaseArtifacts,
   getHighestBumpType: () => getHighestBumpType,
   getBumpTypeFromCommit: () => getBumpTypeFromCommit,
   generateChangelogs: () => generateChangelogs,
@@ -16245,6 +16719,8 @@ __export(exports_versioning, {
   filterBumpableCommits: () => filterBumpableCommits,
   commitsToChangeEntries: () => commitsToChangeEntries,
   commitToChangeEntry: () => commitToChangeEntry,
+  checkReleaseArtifacts: () => checkReleaseArtifacts,
+  buildReleaseArtifacts: () => buildReleaseArtifacts,
   applyVersionBump: () => applyVersionBump,
   analyzeVersionsFromCommits: () => analyzeVersionsFromCommits,
   analyzeVersions: () => analyzeVersions,
@@ -17021,6 +17497,390 @@ function generateRandomName() {
   const random = Math.floor(Math.random() * 1000);
   return `${adj}-${noun}-${verb}-${random}`;
 }
+// src/services/versioning/release-service.ts
+import {
+  GeneratedReleaseManifestSchema as GeneratedReleaseManifestSchema2
+} from "@contractspec/lib.contracts-spec";
+import {
+  ContractsrcSchema as ContractsrcSchema4,
+  DEFAULT_CONTRACTSRC as DEFAULT_CONTRACTSRC5
+} from "@contractspec/lib.contracts-spec/workspace-config/contractsrc-schema";
+
+// src/services/versioning/release-files.ts
+import { ReleaseCapsuleSchema } from "@contractspec/lib.contracts-spec";
+import { dump, load } from "js-yaml";
+var CHANGESET_PATTERN = ".changeset/*.md";
+var RELEASE_CAPSULE_PATTERN = ".changeset/*.release.yaml";
+var CHANGESET_FRONTMATTER = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+var CHANGESET_RELEASE_LINE = /^["']?([^"':]+(?:\/[^"':]+)?)["']?\s*:\s*(major|minor|patch|none)\s*$/;
+async function listChangesetFiles(fs5, workspaceRoot) {
+  const files = await fs5.glob({
+    pattern: CHANGESET_PATTERN,
+    cwd: workspaceRoot,
+    absolute: true
+  });
+  return files.filter((file) => fs5.basename(file) !== "README.md");
+}
+async function readChangesets(fs5, workspaceRoot) {
+  const files = await listChangesetFiles(fs5, workspaceRoot);
+  const changesets = [];
+  for (const filePath of files) {
+    const content = await fs5.readFile(filePath);
+    changesets.push(parseChangesetContent(fs5.basename(filePath), content));
+  }
+  return changesets;
+}
+async function readReleaseCapsules(fs5, workspaceRoot, changesets) {
+  const files = await fs5.glob({
+    pattern: RELEASE_CAPSULE_PATTERN,
+    cwd: workspaceRoot,
+    absolute: true
+  });
+  const fallbackPackages = new Map(changesets.map((changeset) => [changeset.slug, changeset.packages]));
+  const capsules = new Map;
+  for (const filePath of files) {
+    const slug = fs5.basename(filePath).replace(/\.release\.yaml$/, "");
+    const parsed = load(await fs5.readFile(filePath));
+    const capsule = normalizeCapsule(parsed, slug, fallbackPackages.get(slug) ?? []);
+    capsules.set(slug, capsule);
+  }
+  return capsules;
+}
+async function discoverWorkspacePackages(fs5, workspaceRoot) {
+  const packageJsonFiles = await fs5.glob({
+    patterns: ["package.json", "packages/*/*/package.json"],
+    cwd: workspaceRoot,
+    absolute: true
+  });
+  const packages = [];
+  for (const filePath of packageJsonFiles) {
+    const manifest = JSON.parse(await fs5.readFile(filePath));
+    if (!manifest.name || !manifest.version || manifest.private === true) {
+      continue;
+    }
+    const dir = fs5.relative(workspaceRoot, fs5.dirname(filePath)) || ".";
+    packages.push({ name: manifest.name, dir, version: manifest.version });
+  }
+  return packages.sort((left, right) => left.dir.localeCompare(right.dir));
+}
+function matchChangedFilesToPackages(changedFiles, packages) {
+  const names = new Set;
+  for (const changedFile of changedFiles) {
+    const match = packages.find((pkg) => pkg.dir === "." ? !changedFile.startsWith("packages/") : changedFile === pkg.dir || changedFile.startsWith(`${pkg.dir}/`));
+    if (match) {
+      names.add(match.name);
+    }
+  }
+  return Array.from(names).sort((left, right) => left.localeCompare(right));
+}
+function renderChangesetMarkdown(summary, packages) {
+  const header = packages.map((pkg) => `"${pkg.name}": ${pkg.releaseType}`).join(`
+`);
+  return `---
+${header}
+---
+
+${summary}
+`;
+}
+function renderReleaseCapsuleYaml(capsule) {
+  return dump(ReleaseCapsuleSchema.parse(capsule), {
+    noRefs: true,
+    lineWidth: 100
+  });
+}
+function parseChangesetContent(fileName, content) {
+  const slug = fileName.replace(/\.md$/, "");
+  const match = content.match(CHANGESET_FRONTMATTER);
+  if (!match) {
+    return { slug, summary: content.trim(), packages: [] };
+  }
+  const header = match[1] ?? "";
+  const summary = (match[2] ?? "").trim();
+  const packages = [];
+  for (const line of header.split(`
+`)) {
+    const parsed = line.trim().match(CHANGESET_RELEASE_LINE);
+    if (!parsed) {
+      continue;
+    }
+    const packageName = parsed[1];
+    const releaseType = parsed[2];
+    if (!packageName || releaseType === "none") {
+      continue;
+    }
+    packages.push({ name: packageName, releaseType });
+  }
+  return { slug, summary, packages };
+}
+function normalizeCapsule(value, slug, fallbackPackages) {
+  const record = typeof value === "object" && value !== null ? value : {};
+  const legacyPackageNames = Array.isArray(record["packageNames"]) ? record["packageNames"].filter((entry) => typeof entry === "string").map((name) => ({
+    name,
+    releaseType: record["releaseType"] ?? "patch"
+  })) : [];
+  return ReleaseCapsuleSchema.parse({
+    ...record,
+    slug,
+    packages: Array.isArray(record["packages"]) && record["packages"].length > 0 ? record["packages"] : legacyPackageNames.length > 0 ? legacyPackageNames : fallbackPackages
+  });
+}
+
+// src/services/versioning/release-service.ts
+var DEFAULT_OUTPUT_DIR = "generated/releases";
+var DEFAULT_RELEASE_CONFIG = DEFAULT_CONTRACTSRC5.release ?? {
+  enforceOn: "release-branch",
+  requireChangesetForPublished: true,
+  requireReleaseCapsule: true,
+  publishArtifacts: [],
+  agentTargets: ["codex"]
+};
+async function initReleaseArtifacts(adapters2, options = {}) {
+  const { fs: fs5, git: git3, logger: logger3 } = adapters2;
+  const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
+  const workspacePackages = await discoverWorkspacePackages(fs5, workspaceRoot);
+  const changedFiles = options.baseline ? await git3.diffFiles(options.baseline) : [];
+  const packageNames = options.packages && options.packages.length > 0 ? options.packages : matchChangedFilesToPackages(changedFiles, workspacePackages);
+  const commitAnalysis = options.baseline ? await analyzeVersionsFromCommits(adapters2, {
+    baseline: options.baseline,
+    workspaceRoot
+  }) : null;
+  const impact = options.baseline ? await detectImpact(adapters2, {
+    baseline: options.baseline,
+    workspaceRoot
+  }) : null;
+  const inferredReleaseType = (impact?.summary.breaking ?? 0) > 0 ? "major" : commitAnalysis?.suggestedBumpType ?? inferReleaseType(packageNames);
+  const releaseType = options.releaseType ?? inferredReleaseType;
+  const summary = options.summary ?? `Describe the ${releaseType} release for ${packageNames[0] ?? "the workspace"}`;
+  const slug = options.slug ?? slugify(summary);
+  const packages = packageNames.map((name) => ({
+    name,
+    releaseType,
+    version: workspacePackages.find((pkg) => pkg.name === name)?.version
+  }));
+  const capsule = {
+    schemaVersion: "1",
+    slug,
+    summary,
+    isBreaking: releaseType === "major" || (impact?.summary.breaking ?? 0) > 0,
+    packages,
+    affectedRuntimes: [],
+    affectedFrameworks: [],
+    audiences: [
+      { kind: "maintainer", summary },
+      { kind: "customer", summary }
+    ],
+    deprecations: [],
+    migrationInstructions: [],
+    upgradeSteps: [],
+    validation: {
+      commands: [
+        "contractspec impact --baseline main --format markdown",
+        "contractspec version analyze --baseline main"
+      ],
+      evidence: []
+    }
+  };
+  const changesetPath = fs5.join(workspaceRoot, ".changeset", `${slug}.md`);
+  const capsulePath = fs5.join(workspaceRoot, ".changeset", `${slug}.release.yaml`);
+  if (!options.force) {
+    if (await fs5.exists(changesetPath)) {
+      throw new Error(`Changeset already exists: ${changesetPath}`);
+    }
+    if (await fs5.exists(capsulePath)) {
+      throw new Error(`Release capsule already exists: ${capsulePath}`);
+    }
+  }
+  const changesetContent = renderChangesetMarkdown(summary, packages);
+  const capsuleContent = renderReleaseCapsuleYaml(capsule);
+  if (!options.dryRun) {
+    await fs5.writeFile(changesetPath, changesetContent);
+    await fs5.writeFile(capsulePath, capsuleContent);
+  }
+  logger3.info("Initialized release artifacts", { slug, workspaceRoot });
+  return {
+    slug,
+    changesetPath,
+    capsulePath,
+    changesetContent,
+    capsuleContent,
+    packages,
+    releaseType,
+    isBreaking: capsule.isBreaking
+  };
+}
+async function buildReleaseArtifacts(adapters2, options = {}) {
+  const { fs: fs5, logger: logger3 } = adapters2;
+  const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
+  const config = await readWorkspaceReleaseConfig(fs5, workspaceRoot);
+  const outputDir = fs5.join(workspaceRoot, options.outputDir ?? DEFAULT_OUTPUT_DIR);
+  const changesets = await readChangesets(fs5, workspaceRoot);
+  const capsules = await readReleaseCapsules(fs5, workspaceRoot, changesets);
+  const workspacePackages = await discoverWorkspacePackages(fs5, workspaceRoot);
+  const releases = await Promise.all(Array.from(capsules.entries()).map(async ([slug, capsule]) => {
+    const filePath = fs5.join(workspaceRoot, ".changeset", `${slug}.release.yaml`);
+    const stats = await fs5.stat(filePath);
+    return {
+      slug,
+      version: resolveReleaseVersion(capsule, workspacePackages),
+      summary: capsule.summary,
+      date: stats.mtime.toISOString().split("T")[0] ?? new Date().toISOString(),
+      isBreaking: capsule.isBreaking,
+      packages: capsule.packages.map((pkg) => ({
+        ...pkg,
+        version: workspacePackages.find((candidate) => candidate.name === pkg.name)?.version ?? pkg.version
+      })),
+      affectedRuntimes: [...capsule.affectedRuntimes],
+      affectedFrameworks: [...capsule.affectedFrameworks],
+      audiences: [...capsule.audiences],
+      deprecations: [...capsule.deprecations],
+      migrationInstructions: [...capsule.migrationInstructions],
+      upgradeSteps: [...capsule.upgradeSteps],
+      validation: capsule.validation
+    };
+  }));
+  const manifest = GeneratedReleaseManifestSchema2.parse({
+    generatedAt: new Date().toISOString(),
+    releases
+  });
+  const agentTargets = options.agentTargets ?? config.agentTargets ?? ["codex"];
+  const upgradePlan = createUpgradePlan(manifest, [], agentTargets, renderUpgradePrompt);
+  const manifestPath = fs5.join(outputDir, "manifest.json");
+  const upgradeManifestPath = fs5.join(outputDir, "upgrade-manifest.json");
+  const patchNotesPath = fs5.join(outputDir, "patch-notes.md");
+  const customerGuidePath = fs5.join(outputDir, "customer-guide.md");
+  const promptPaths = Object.fromEntries(upgradePlan.agentPrompts.map((prompt) => [
+    prompt.agent,
+    fs5.join(outputDir, "prompts", `${prompt.agent}.md`)
+  ]));
+  if (!options.dryRun) {
+    await fs5.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+    await fs5.writeFile(upgradeManifestPath, JSON.stringify(manifest, null, 2));
+    await fs5.writeFile(patchNotesPath, renderPatchNotes(manifest));
+    await fs5.writeFile(customerGuidePath, renderCustomerGuide(manifest));
+    for (const prompt of upgradePlan.agentPrompts) {
+      await fs5.writeFile(promptPaths[prompt.agent] ?? "", prompt.prompt);
+    }
+  }
+  logger3.info("Built release artifacts", {
+    outputDir,
+    releasesBuilt: manifest.releases.length
+  });
+  return {
+    outputDir,
+    manifestPath,
+    upgradeManifestPath,
+    patchNotesPath,
+    customerGuidePath,
+    promptPaths,
+    manifest,
+    upgradePlan,
+    releasesBuilt: manifest.releases.length
+  };
+}
+async function checkReleaseArtifacts(adapters2, options = {}) {
+  const { fs: fs5 } = adapters2;
+  const workspaceRoot = findWorkspaceRoot(options.workspaceRoot);
+  const config = await readWorkspaceReleaseConfig(fs5, workspaceRoot);
+  const outputDir = fs5.join(workspaceRoot, options.outputDir ?? DEFAULT_OUTPUT_DIR);
+  const checks = [];
+  const warnings = [];
+  const errors = [];
+  const changesets = await readChangesets(fs5, workspaceRoot);
+  const capsules = await readReleaseCapsules(fs5, workspaceRoot, changesets);
+  recordCheck(checks, changesets.length > 0, "changesets", changesets.length > 0 ? `Found ${changesets.length} release changeset(s).` : "No release changesets found.");
+  for (const changeset of changesets) {
+    if (!capsules.has(changeset.slug) && config.requireReleaseCapsule) {
+      errors.push(`Missing release capsule for changeset ${changeset.slug}.`);
+    }
+  }
+  for (const [slug, capsule] of capsules) {
+    if (capsule.isBreaking && capsule.migrationInstructions.length === 0) {
+      errors.push(`Breaking release ${slug} is missing migration instructions.`);
+    }
+    if (capsule.validation.commands.length === 0) {
+      errors.push(`Release capsule ${slug} is missing validation commands.`);
+    }
+    if (capsule.validation.evidence.length === 0) {
+      errors.push(`Release capsule ${slug} is missing validation evidence.`);
+    }
+  }
+  if (options.baseline) {
+    try {
+      const impact = await detectImpact(adapters2, {
+        baseline: options.baseline,
+        workspaceRoot
+      });
+      recordCheck(checks, true, "impact", `Impact status: ${impact.status}`);
+      if (impact.summary.breaking > 0 && !Array.from(capsules.values()).some((capsule) => capsule.isBreaking)) {
+        errors.push("Breaking impact detected without a breaking release capsule.");
+      }
+    } catch (error) {
+      recordCheck(checks, false, "impact", failureMessage(error));
+      errors.push(`Impact detection failed: ${failureMessage(error)}`);
+    }
+    try {
+      const analysis = await analyzeVersions(adapters2, {
+        baseline: options.baseline,
+        workspaceRoot
+      });
+      recordCheck(checks, true, "versioning", `${analysis.specsNeedingBump} spec(s) need version review.`);
+    } catch (error) {
+      recordCheck(checks, false, "versioning", failureMessage(error));
+      errors.push(`Version analysis failed: ${failureMessage(error)}`);
+    }
+  }
+  if (options.strict) {
+    for (const artifact of config.publishArtifacts ?? []) {
+      const artifactPath = fs5.join(outputDir, artifact);
+      if (!await fs5.exists(artifactPath)) {
+        errors.push(`Missing generated release artifact: ${artifactPath}`);
+      }
+    }
+  }
+  recordCheck(checks, errors.length === 0, "capsules", errors.length === 0 ? "All release capsules are complete." : errors[0] ?? "");
+  if (changesets.length === 0) {
+    warnings.push("No pending release changesets were found.");
+  }
+  return {
+    success: errors.length === 0,
+    errors,
+    warnings,
+    checks
+  };
+}
+async function readWorkspaceReleaseConfig(fs5, workspaceRoot) {
+  const configPath = fs5.join(workspaceRoot, ".contractsrc.json");
+  if (!await fs5.exists(configPath)) {
+    return DEFAULT_RELEASE_CONFIG;
+  }
+  try {
+    const parsed = JSON.parse(await fs5.readFile(configPath));
+    const validated = ContractsrcSchema4.safeParse(parsed);
+    return validated.success ? {
+      ...DEFAULT_RELEASE_CONFIG,
+      ...validated.data.release
+    } : DEFAULT_RELEASE_CONFIG;
+  } catch {
+    return DEFAULT_RELEASE_CONFIG;
+  }
+}
+function inferReleaseType(packageNames) {
+  return packageNames.length > 0 ? "minor" : "patch";
+}
+function resolveReleaseVersion(capsule, workspacePackages) {
+  const version = capsule.packages.map((pkg) => workspacePackages.find((candidate) => candidate.name === pkg.name)?.version ?? pkg.version).find((value) => typeof value === "string");
+  return version ?? "0.0.0";
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+}
+function recordCheck(checks, ok, name, message) {
+  checks.push({ name, ok, message });
+}
+function failureMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 // src/services/vibe/index.ts
 var exports_vibe = {};
 __export(exports_vibe, {