@kb-labs/release-manager-core 0.6.0

package/dist/index.js

@@ -0,0 +1,1457 @@
+import { readFile, writeFile, mkdir, rm, rename, cp } from 'fs/promises';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, rmSync, statSync } from 'fs';
+import { join, relative, resolve, dirname } from 'path';
+import simpleGit from 'simple-git';
+import semver2 from 'semver';
+import globby from 'globby';
+import { discoverSubRepoPaths } from '@kb-labs/sdk';
+import { execa } from 'execa';
+import { spawn, execSync } from 'child_process';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+
+// src/planner.ts
+function applyVersionStrategy(packages, options) {
+  if (options.strategy === "lockstep") {
+    return applyLockstep(packages);
+  }
+  if (options.strategy === "adaptive") {
+    return applyAdaptive(packages);
+  }
+  return packages;
+}
+function applyLockstep(packages) {
+  if (packages.length === 0) {
+    return packages;
+  }
+  const maxBump = getMaxBump(packages);
+  const maxVersion = packages.reduce((max, pkg) => {
+    return semver2.gt(pkg.currentVersion, max) ? pkg.currentVersion : max;
+  }, packages[0].currentVersion);
+  const releaseType = maxBump === "auto" ? "patch" : maxBump;
+  const nextVersion = semver2.inc(maxVersion, releaseType) || maxVersion;
+  return packages.map((pkg) => ({
+    ...pkg,
+    bump: maxBump,
+    nextVersion
+  }));
+}
+function applyAdaptive(packages) {
+  const hasBreaking = packages.some((pkg) => pkg.bump === "major");
+  if (hasBreaking) {
+    return applyLockstep(packages);
+  }
+  return packages;
+}
+function getMaxBump(packages) {
+  let maxBump = "patch";
+  for (const pkg of packages) {
+    if (pkg.bump === "major") {
+      return "major";
+    }
+    if (pkg.bump === "minor") {
+      maxBump = "minor";
+    }
+  }
+  return maxBump;
+}
+
+// src/planner.ts
+async function planRelease(options) {
+  const { cwd, config, scope, bumpOverride } = options;
+  const allPackages = await discoverPackages(cwd, config);
+  let packages;
+  if (scope && scope !== "root") {
+    const isWorkspace = existsSync(join(cwd, ".gitmodules"));
+    if (isWorkspace) {
+      const matchedRoots = filterByScope(allPackages, scope, config);
+      const innerPackages = [];
+      for (const root of matchedRoots) {
+        innerPackages.push(root);
+        const inner = await discoverPackages(root.path, config);
+        for (const pkg of inner) {
+          if (!innerPackages.some((p) => p.name === pkg.name)) {
+            innerPackages.push(pkg);
+          }
+        }
+      }
+      packages = innerPackages;
+    } else {
+      packages = filterByScope(allPackages, scope, config);
+    }
+  } else {
+    packages = allPackages;
+  }
+  const isWorkspaceRoot = existsSync(join(cwd, ".gitmodules")) && !scope;
+  let modifiedPackages;
+  if (isWorkspaceRoot) {
+    modifiedPackages = packages;
+  } else {
+    const git = simpleGit(cwd, { timeout: { block: 6e4 } });
+    modifiedPackages = await detectModifiedPackages(git, packages);
+  }
+  let planPackages = [];
+  for (const pkg of modifiedPackages) {
+    const bump = bumpOverride || config.bump || "auto";
+    const git = isWorkspaceRoot ? simpleGit(pkg.path, { timeout: { block: 6e4 } }) : simpleGit(cwd, { timeout: { block: 6e4 } });
+    const nextVersion = await computeNextVersion(
+      pkg.path,
+      pkg.currentVersion,
+      bump,
+      git
+    );
+    planPackages.push({
+      ...pkg,
+      nextVersion,
+      bump: bump === "auto" ? detectBumpType(pkg.currentVersion, nextVersion) : bump
+    });
+  }
+  const bumpStrategy = config.versioningStrategy || config.changelog?.bumpStrategy || "independent";
+  const versionStrategy = mapBumpStrategyToVersionStrategy(bumpStrategy);
+  planPackages = applyVersionStrategy(planPackages, {
+    strategy: versionStrategy});
+  return {
+    packages: planPackages,
+    strategy: config.strategy || "semver",
+    registry: config.registry || "https://registry.npmjs.org",
+    rollbackEnabled: config.rollback?.enabled ?? true
+  };
+}
+function mapBumpStrategyToVersionStrategy(bumpStrategy) {
+  if (bumpStrategy === "lockstep") {
+    return "lockstep";
+  }
+  if (bumpStrategy === "ripple" || bumpStrategy === "adaptive") {
+    return "adaptive";
+  }
+  return "independent";
+}
+async function discoverPackages(cwd, config) {
+  const isWorkspaceRoot = existsSync(join(cwd, ".gitmodules"));
+  if (isWorkspaceRoot) {
+    return discoverSubRepoPackages(cwd, config);
+  }
+  const packages = [];
+  const configPaths = config?.packages?.paths;
+  const pattern = configPaths?.length ? configPaths.map((p) => `${p}/package.json`) : "**/package.json";
+  const packageJsonPaths = await globby(pattern, {
+    cwd,
+    absolute: true,
+    onlyFiles: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/.*/**"
+    ]
+  });
+  for (let i = 0; i < packageJsonPaths.length; i++) {
+    if (i % 10 === 0) {
+      await new Promise((resolve2) => {
+        setImmediate(resolve2);
+      });
+    }
+    const packageJsonPath = packageJsonPaths[i];
+    const packagePath = join(packageJsonPath, "..");
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    const isRootPackageJson = packageJsonPath === join(cwd, "package.json");
+    if (packageJson.private) {
+      continue;
+    }
+    if (isRootPackageJson && existsSync(join(packagePath, "pnpm-workspace.yaml"))) {
+      continue;
+    }
+    if (isRootPackageJson && !packageJson.name) {
+      continue;
+    }
+    const globalFilter = config?.packages;
+    if (globalFilter?.include?.length || globalFilter?.exclude?.length) {
+      const rel = relative(cwd, packagePath);
+      if (globalFilter.include?.length && !matchesPackagePattern(packageJson.name, rel, globalFilter.include)) {
+        continue;
+      }
+      if (globalFilter.exclude?.length && matchesPackagePattern(packageJson.name, rel, globalFilter.exclude)) {
+        continue;
+      }
+    }
+    packages.push({
+      name: packageJson.name,
+      path: packagePath,
+      currentVersion: packageJson.version,
+      nextVersion: packageJson.version,
+      bump: "auto",
+      isPublished: false
+    });
+  }
+  return packages;
+}
+function filterByScope(packages, scope, config) {
+  const scopeFilter = config?.scopes?.[scope]?.packages;
+  const globalFilter = config?.packages;
+  const mergedInclude = [...globalFilter?.include ?? [], ...scopeFilter?.include ?? []];
+  const mergedExclude = [...globalFilter?.exclude ?? [], ...scopeFilter?.exclude ?? []];
+  const isExactName = !scope.includes("*") && (scope.startsWith("@") || !scope.includes("/"));
+  const scopeRegex = new RegExp(
+    "^" + scope.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*") + "$"
+  );
+  const result = [];
+  for (const pkg of packages) {
+    const isPathPattern2 = scope.includes("/") && !scope.startsWith("@");
+    const matchTarget = isPathPattern2 ? pkg.path : pkg.name;
+    const matches = isExactName ? pkg.name === scope : scopeRegex.test(matchTarget);
+    if (!matches) {
+      continue;
+    }
+    if (mergedInclude.length && !matchesPackagePattern(pkg.name, pkg.path, mergedInclude)) {
+      continue;
+    }
+    if (mergedExclude.length && matchesPackagePattern(pkg.name, pkg.path, mergedExclude)) {
+      continue;
+    }
+    result.push(pkg);
+  }
+  if (result.length === 0) {
+    const wouldMatchExcluded = packages.some((p) => {
+      const matchTarget = isPathPattern(scope) ? p.path : p.name;
+      const scopeMatches = isExactName ? p.name === scope : scopeRegex.test(matchTarget);
+      if (!scopeMatches) {
+        return false;
+      }
+      return mergedExclude.length > 0 && matchesPackagePattern(p.name, p.path, mergedExclude);
+    });
+    if (wouldMatchExcluded) {
+      throw new Error(`Scope "${scope}" matches packages that are excluded by configuration`);
+    }
+    const globalInclude = globalFilter?.include;
+    if (globalInclude?.length) {
+      throw new Error(`Scope "${scope}" did not match any packages. Note: packages.include restricts discovery to: ${globalInclude.join(", ")}`);
+    }
+    throw new Error(`Scope "${scope}" did not match any discovered packages`);
+  }
+  return result;
+}
+function isPathPattern(scope) {
+  return scope.includes("/") && !scope.startsWith("@");
+}
+async function discoverSubRepoPackages(workspaceRoot, config) {
+  const subRepoPaths = discoverSubRepoPaths(workspaceRoot);
+  const packages = [];
+  const globalFilter = config?.packages;
+  for (const subRepoPath of subRepoPaths) {
+    try {
+      const pkgJson = JSON.parse(
+        await readFile(join(subRepoPath, "package.json"), "utf-8")
+      );
+      if (!pkgJson.name) {
+        continue;
+      }
+      const rel = relative(workspaceRoot, subRepoPath);
+      if (globalFilter?.include?.length && !matchesPackagePattern(pkgJson.name, rel, globalFilter.include)) {
+        continue;
+      }
+      if (globalFilter?.exclude?.length && matchesPackagePattern(pkgJson.name, rel, globalFilter.exclude)) {
+        continue;
+      }
+      packages.push({
+        name: pkgJson.name,
+        path: subRepoPath,
+        currentVersion: pkgJson.version || "0.0.0",
+        nextVersion: pkgJson.version || "0.0.0",
+        bump: "auto",
+        isPublished: false
+      });
+    } catch {
+    }
+  }
+  return packages;
+}
+function shouldIgnoreFile(file) {
+  const ignoredPaths = [
+    "node_modules/",
+    ".git/",
+    "dist/",
+    "build/",
+    ".next/",
+    ".nuxt/",
+    "coverage/",
+    ".cache/",
+    "tmp/"
+  ];
+  return ignoredPaths.some((path) => file.includes(path));
+}
+async function detectModifiedPackages(git, packages) {
+  const status = await git.status();
+  const diffSummary = await git.diffSummary(["HEAD"]);
+  const modifiedPaths = [
+    ...status.files.map((f) => f.path),
+    ...diffSummary.files.map((f) => f.file)
+  ].filter((path) => !shouldIgnoreFile(path));
+  const modified = [];
+  for (let i = 0; i < packages.length; i++) {
+    if (i % 10 === 0) {
+      await new Promise((resolve2) => {
+        setImmediate(resolve2);
+      });
+    }
+    const pkg = packages[i];
+    const packageModified = modifiedPaths.some(
+      (path) => path.startsWith(pkg.path) || path.includes(pkg.name)
+    );
+    if (packageModified) {
+      modified.push(pkg);
+    }
+  }
+  return modified.length > 0 ? modified : packages;
+}
+async function computeNextVersion(packagePath, currentVersion, bump, git) {
+  if (bump === "auto") {
+    const detectedBump = await detectVersionFromCommits(git, packagePath);
+    return semver2.inc(currentVersion, detectedBump) || currentVersion;
+  }
+  return semver2.inc(currentVersion, bump) || currentVersion;
+}
+async function detectVersionFromCommits(git, packagePath) {
+  try {
+    const log = await git.log({
+      maxCount: 50,
+      file: packagePath
+    });
+    let hasMinor = false;
+    let hasBreaking = false;
+    for (const commit of log.all) {
+      const message = commit.message.toLowerCase();
+      if (message.includes("!:")) {
+        hasBreaking = true;
+      } else if (message.startsWith("feat") || message.startsWith("feature")) {
+        hasMinor = true;
+      }
+    }
+    if (hasBreaking) {
+      return "major";
+    }
+    if (hasMinor) {
+      return "minor";
+    }
+    return "patch";
+  } catch (error) {
+    return "patch";
+  }
+}
+function detectBumpType(currentVersion, nextVersion) {
+  if (semver2.major(currentVersion) < semver2.major(nextVersion)) {
+    return "major";
+  }
+  if (semver2.minor(currentVersion) < semver2.minor(nextVersion)) {
+    return "minor";
+  }
+  return "patch";
+}
+function matchesPackagePattern(pkgName, relativePath, patterns) {
+  for (const pattern of patterns) {
+    const isPathPattern2 = pattern.includes("/") && !pattern.startsWith("@");
+    const target = isPathPattern2 ? relativePath : pkgName;
+    const regex = new RegExp(
+      "^" + pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*") + "$"
+    );
+    if (regex.test(target)) {
+      return true;
+    }
+  }
+  return false;
+}
+function createExecaShellAdapter() {
+  return {
+    async exec(command, args, options) {
+      try {
+        const result = await execa(command, args || [], {
+          cwd: options?.cwd,
+          timeout: options?.timeout,
+          preferLocal: true,
+          env: options?.env || process.env
+        });
+        return {
+          ok: result.exitCode === 0,
+          code: result.exitCode,
+          stdout: result.stdout || "",
+          stderr: result.stderr || ""
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          code: error.exitCode || 1,
+          stdout: error.stdout || "",
+          stderr: error.stderr || error.message || ""
+        };
+      }
+    }
+  };
+}
+
+// src/publisher.ts
+async function publishPackages(options) {
+  const { plan, dryRun, shell } = options;
+  const shellApi = shell || createExecaShellAdapter();
+  const result = {
+    published: [],
+    skipped: [],
+    errors: [],
+    versionUpdates: []
+  };
+  if (dryRun) {
+    for (const pkg of plan.packages) {
+      result.skipped.push(`${pkg.name}@${pkg.nextVersion} (dry-run)`);
+      result.versionUpdates.push({
+        package: pkg.name,
+        from: pkg.currentVersion || "unknown",
+        to: pkg.nextVersion || "unknown",
+        updated: false
+      });
+    }
+    return result;
+  }
+  for (const pkg of plan.packages) {
+    try {
+      const registry = plan.registry || "https://registry.npmjs.org";
+      try {
+        await updatePackageVersion(pkg);
+        result.versionUpdates.push({
+          package: pkg.name,
+          from: pkg.currentVersion || "unknown",
+          to: pkg.nextVersion || "unknown",
+          updated: true
+        });
+      } catch (versionError) {
+        const msg = `Failed to update version for ${pkg.name}: ${versionError instanceof Error ? versionError.message : String(versionError)}`;
+        result.errors.push(msg);
+        result.versionUpdates.push({
+          package: pkg.name,
+          from: pkg.currentVersion || "unknown",
+          to: pkg.nextVersion || "unknown",
+          updated: false
+        });
+        continue;
+      }
+      const pm = options.config?.publish?.packageManager ?? "pnpm";
+      const access = options.config?.publish?.access ?? "public";
+      const publishResult = await shellApi.exec(
+        pm,
+        ["publish", "--access", access, "--registry", registry],
+        {
+          cwd: pkg.path,
+          timeout: 6e4
+        }
+      );
+      if (publishResult.ok) {
+        result.published.push(`${pkg.name}@${pkg.nextVersion}`);
+      } else {
+        const errorDetails = publishResult.stderr || publishResult.stdout || "Unknown error";
+        result.errors.push(`Failed to publish ${pkg.name}: ${errorDetails}`);
+      }
+    } catch (error) {
+      const msg = `Failed to publish ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`;
+      result.errors.push(msg);
+    }
+  }
+  return result;
+}
+async function updatePackageVersion(pkg) {
+  const packageJsonPath = join(pkg.path, "package.json");
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+  packageJson.version = pkg.nextVersion;
+  await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+}
+async function updatePackageVersions(plan) {
+  const results = [];
+  for (const pkg of plan.packages) {
+    try {
+      await updatePackageVersion(pkg);
+      results.push({
+        package: pkg.name,
+        from: pkg.currentVersion || "unknown",
+        to: pkg.nextVersion || "unknown",
+        updated: true
+      });
+    } catch (error) {
+      console.warn(`Failed to update version for ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`);
+      results.push({
+        package: pkg.name,
+        from: pkg.currentVersion || "unknown",
+        to: pkg.nextVersion || "unknown",
+        updated: false
+      });
+    }
+  }
+  return results;
+}
+async function generateChangelog(options) {
+  const { cwd, plan } = options;
+  const changelogPath = join(cwd, "CHANGELOG.md");
+  let existingChangelog = "";
+  try {
+    existingChangelog = await readFile(changelogPath, "utf-8");
+  } catch {
+  }
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const header = `## [${date}] Release
+
+`;
+  const entries = [];
+  for (const pkg of plan.packages) {
+    entries.push(`- **${pkg.name}**: ${pkg.currentVersion} \u2192 ${pkg.nextVersion}`);
+  }
+  const newEntry = header + entries.join("\n") + "\n\n";
+  const updatedChangelog = newEntry + existingChangelog;
+  try {
+    await mkdir(join(cwd, ".kb", "release"), { recursive: true });
+    await writeFile(changelogPath, updatedChangelog, "utf-8");
+  } catch (error) {
+    console.warn(`Failed to write changelog: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return newEntry;
+}
+async function generateEnhancedChangelog(options) {
+  const simpleChangelog = await generateChangelog({
+    cwd: options.cwd,
+    plan: options.plan
+  });
+  return {
+    changelog: simpleChangelog,
+    manifest: null
+  };
+}
+async function copyChangelogToPackages(options) {
+  const { plan, changelog } = options;
+  for (const pkg of plan.packages) {
+    try {
+      let packageChangelog;
+      if (plan.packages.length === 1) {
+        packageChangelog = changelog;
+      } else {
+        packageChangelog = createPackageChangelog(pkg, changelog);
+      }
+      if (!packageChangelog || packageChangelog.trim().length === 0) {
+        console.warn(`No changelog content for ${pkg.name}, skipping`);
+        continue;
+      }
+      const changelogPath = join(pkg.path, "CHANGELOG.md");
+      let existingChangelog = "";
+      try {
+        existingChangelog = await readFile(changelogPath, "utf-8");
+      } catch {
+      }
+      const versionPattern = new RegExp(
+        `^##\\s+${pkg.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+${pkg.nextVersion.replace(/\./g, "\\.")}`,
+        "m"
+      );
+      let updatedChangelog;
+      if (existingChangelog && versionPattern.test(existingChangelog)) {
+        const lines = existingChangelog.split("\n");
+        let startIdx = -1;
+        let endIdx = lines.length;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line && versionPattern.test(line)) {
+            startIdx = i;
+          } else if (startIdx !== -1 && line && /^##\s+@?[\w-]+/.test(line)) {
+            endIdx = i;
+            break;
+          }
+        }
+        if (startIdx !== -1) {
+          const before = lines.slice(0, startIdx).join("\n");
+          const after = lines.slice(endIdx).join("\n");
+          updatedChangelog = (before ? before + "\n" : "") + packageChangelog + (after ? "\n" + after : "");
+        } else {
+          updatedChangelog = packageChangelog;
+        }
+      } else {
+        updatedChangelog = packageChangelog + (existingChangelog ? "\n" + existingChangelog : "");
+      }
+      await writeFile(changelogPath, updatedChangelog.trim() + "\n", "utf-8");
+    } catch (error) {
+      console.warn(`Failed to write changelog for ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+function createPackageChangelog(pkg, changelog) {
+  const packageHeaderPattern = new RegExp(
+    `^##\\s+${pkg.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+\\d+\\.\\d+\\.\\d+`,
+    "gm"
+  );
+  const allHeaders = Array.from(changelog.matchAll(/^##\s+(@[\w-]+\/)?[\w-]+\s+\d+\.\d+\.\d+/gm));
+  let startIdx = -1;
+  let endIdx = changelog.length;
+  for (let i = 0; i < allHeaders.length; i++) {
+    const match = allHeaders[i];
+    if (!match || !match.index) {
+      continue;
+    }
+    if (packageHeaderPattern.test(match[0])) {
+      startIdx = match.index;
+      if (i + 1 < allHeaders.length) {
+        endIdx = allHeaders[i + 1].index;
+      }
+      break;
+    }
+  }
+  if (startIdx === -1) {
+    return "";
+  }
+  return changelog.substring(startIdx, endIdx).trim();
+}
+async function commitAndTagRelease(options) {
+  const { cwd, plan, dryRun } = options;
+  const simpleGit2 = (await import('simple-git')).default;
+  const result = {
+    committed: false,
+    tagged: [],
+    pushed: false
+  };
+  if (dryRun) {
+    return result;
+  }
+  try {
+    const commitMessage = createCommitMessage(plan);
+    for (const pkg of plan.packages) {
+      const pkgGit = simpleGit2(pkg.path);
+      const filesToStage = ["package.json"];
+      const changelogPath = join(pkg.path, "CHANGELOG.md");
+      if (existsSync(changelogPath)) {
+        filesToStage.push("CHANGELOG.md");
+      }
+      await pkgGit.add(filesToStage);
+      try {
+        await pkgGit.commit(commitMessage);
+        result.committed = true;
+      } catch (commitError) {
+        const msg = commitError instanceof Error ? commitError.message : String(commitError);
+        if (!msg.includes("nothing to commit") && !msg.includes("nothing added to commit")) {
+          throw commitError;
+        }
+      }
+    }
+    const git = simpleGit2(cwd);
+    const uniqueVersions = new Set(plan.packages.map((p) => p.nextVersion));
+    const isLockstep = plan.packages.length > 1 && uniqueVersions.size === 1;
+    if (isLockstep) {
+      const version = plan.packages[0].nextVersion;
+      const tagName = `v${version}`;
+      await git.addTag(tagName);
+      result.tagged.push(tagName);
+    } else {
+      for (const pkg of plan.packages) {
+        const pkgGit = simpleGit2(pkg.path);
+        const tagName = `${pkg.name}@${pkg.nextVersion}`;
+        await pkgGit.addTag(tagName);
+        result.tagged.push(tagName);
+      }
+    }
+    for (const pkg of plan.packages) {
+      const pkgGit = simpleGit2(pkg.path);
+      if (result.committed) {
+        await pkgGit.push(["--no-verify"]);
+      }
+      await pkgGit.pushTags("--no-verify");
+    }
+    result.pushed = true;
+  } catch (error) {
+    console.error(`Git operations failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw error;
+  }
+  return result;
+}
+function createCommitMessage(plan) {
+  const lines = [];
+  if (plan.packages.length === 1 && plan.packages[0]) {
+    const pkg = plan.packages[0];
+    lines.push(`chore(release): publish ${pkg.name}@${pkg.nextVersion}`);
+  } else {
+    lines.push(`chore(release): publish ${plan.packages.length} packages`);
+  }
+  lines.push("");
+  for (const pkg of plan.packages) {
+    lines.push(`- ${pkg.name}@${pkg.nextVersion}`);
+  }
+  return lines.join("\n");
+}
+async function saveSnapshot(options) {
+  const { cwd, plan } = options;
+  const snapshot = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    packages: plan.packages.map((pkg) => ({
+      ...pkg,
+      nextVersion: pkg.currentVersion
+      // Store current before update
+    }))
+  };
+  const snapshotDir = join(cwd, ".kb", "release");
+  await mkdir(snapshotDir, { recursive: true });
+  const snapshotPath = join(snapshotDir, "backup.json");
+  await writeFile(snapshotPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  await cleanupOldSnapshots();
+}
+async function restoreSnapshot(cwd) {
+  const snapshotPath = join(cwd, ".kb", "release", "backup.json");
+  if (!existsSync(snapshotPath)) {
+    throw new Error("No backup snapshot found");
+  }
+  const snapshotContent = await readFile(snapshotPath, "utf-8");
+  const snapshot = JSON.parse(snapshotContent);
+  for (const pkg of snapshot.packages) {
+    const packageJsonPath = join(pkg.path, "package.json");
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    packageJson.version = pkg.currentVersion;
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+  }
+}
+async function cleanupOldSnapshots(_snapshotDir) {
+}
+
+// src/runner.ts
+async function runRelease(options) {
+  const {
+    config,
+    runChecks,
+    executePlan,
+    onStageChange
+  } = options;
+  const startTime = Date.now();
+  const errors = [];
+  let checks;
+  try {
+    onStageChange?.("planning");
+    if (config.verify && config.verify.length > 0 && runChecks) {
+      onStageChange?.("checking");
+      checks = await runChecks("checking");
+      const failedChecks = Object.entries(checks).filter(([_, result]) => result && !result.ok).map(([id]) => id);
+      if (failedChecks.length > 0) {
+        errors.push(`Pre-release checks failed: ${failedChecks.join(", ")}`);
+        if (config.strict) {
+          return {
+            ok: false,
+            timingMs: Date.now() - startTime,
+            errors,
+            checks
+          };
+        }
+      }
+    }
+    onStageChange?.("publishing");
+    if (executePlan) {
+      await executePlan();
+    }
+    onStageChange?.("verifying");
+    return {
+      ok: errors.length === 0,
+      timingMs: Date.now() - startTime,
+      errors: errors.length > 0 ? errors : void 0,
+      checks
+    };
+  } catch (error) {
+    onStageChange?.("rollback");
+    errors.push(error instanceof Error ? error.message : String(error));
+    return {
+      ok: false,
+      timingMs: Date.now() - startTime,
+      errors,
+      checks
+    };
+  }
+}
+
+// src/reporters/json.ts
+function renderJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+
+// src/reporters/markdown.ts
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push("# \u{1F9E9} KB Labs Release Summary");
+  lines.push("");
+  lines.push(`**Timestamp**: ${report.ts}`);
+  lines.push(`**Stage**: ${report.stage}`);
+  lines.push("");
+  if (report.result.ok) {
+    lines.push("## \u2705 Release: SUCCESS");
+  } else {
+    lines.push("## \u274C Release: FAILED");
+  }
+  lines.push("");
+  if (report.result.checks) {
+    lines.push("## Quality Checks");
+    lines.push("");
+    for (const [id, result] of Object.entries(report.result.checks)) {
+      if (!result) {
+        continue;
+      }
+      const icon = result.ok ? "\u2705" : "\u274C";
+      lines.push(`- ${icon} **${id}**: ${result.ok ? "PASSED" : "FAILED"}`);
+      if (result.hint && !result.ok) {
+        lines.push(`  - ${result.hint}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.result.checksPerPackage) {
+    lines.push("## Package Quality Checks");
+    lines.push("");
+    for (const [pkgName, pkgChecks] of Object.entries(report.result.checksPerPackage)) {
+      lines.push(`### ${pkgName}`);
+      lines.push("");
+      for (const [id, result] of Object.entries(pkgChecks)) {
+        if (!result) {
+          continue;
+        }
+        const icon = result.ok ? "\u2705" : "\u274C";
+        lines.push(`- ${icon} **${id}**: ${result.ok ? "PASSED" : "FAILED"}`);
+        if (result.hint && !result.ok) {
+          lines.push(`  - ${result.hint}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (report.result.published && report.result.published.length > 0) {
+    lines.push("## \u{1F680} Published Packages");
+    lines.push("");
+    for (const pkg of report.result.published) {
+      lines.push(`- ${pkg}`);
+    }
+    lines.push("");
+  }
+  if (report.result.errors && report.result.errors.length > 0) {
+    lines.push("## \u274C Errors");
+    lines.push("");
+    for (const error of report.result.errors) {
+      lines.push(`- ${error}`);
+    }
+    lines.push("");
+  }
+  lines.push(`**Duration**: ${formatTiming(report.result.timingMs)}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTiming(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  return `${(ms / 6e4).toFixed(1)}m`;
+}
+
+// src/reporters/text.ts
+function renderText(report) {
+  const lines = [];
+  lines.push("[release] " + (report.result.ok ? "OK" : "FAILED"));
+  lines.push("");
+  if (report.result.checks) {
+    for (const [id, result] of Object.entries(report.result.checks)) {
+      if (!result) {
+        continue;
+      }
+      lines.push(`[${id}] ${result.ok ? "pass" : "fail"}`);
+      if (result.hint && !result.ok) {
+        lines.push(`  ${result.hint}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.result.checksPerPackage) {
+    for (const [pkgName, pkgChecks] of Object.entries(report.result.checksPerPackage)) {
+      lines.push(`[${pkgName}]`);
+      for (const [id, result] of Object.entries(pkgChecks)) {
+        if (!result) {
+          continue;
+        }
+        lines.push(`  [${id}] ${result.ok ? "pass" : "fail"}`);
+        if (result.hint && !result.ok) {
+          lines.push(`    ${result.hint}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (report.result.published && report.result.published.length > 0) {
+    lines.push("[published] " + report.result.published.length + " package(s)");
+    for (const pkg of report.result.published) {
+      lines.push(`  ${pkg}`);
+    }
+    lines.push("");
+  }
+  if (report.result.errors && report.result.errors.length > 0) {
+    lines.push("[errors]");
+    for (const error of report.result.errors) {
+      lines.push(`  ${error}`);
+    }
+    lines.push("");
+  }
+  lines.push(`[timing] ${formatTiming2(report.result.timingMs)}`);
+  return lines.join("\n");
+}
+function formatTiming2(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  return `${(ms / 6e4).toFixed(1)}m`;
+}
+async function buildPackages(packages, options) {
+  const results = [];
+  for (const pkg of packages) {
+    options?.logger?.info?.(`Building ${pkg.name}...`);
+    const result = await runSafeBuild(pkg.path, pkg.name);
+    results.push({ ...result, name: pkg.name });
+    options?.onProgress?.(pkg.name, { ...result, name: pkg.name });
+    if (!result.success) {
+      options?.logger?.error?.(`Build failed for ${pkg.name}: ${result.error}`);
+      break;
+    }
+    options?.logger?.info?.(`Built ${pkg.name} in ${result.durationMs}ms`);
+  }
+  return results;
+}
+async function runSafeBuild(packagePath, packageName) {
+  const usesTsup = existsSync(join(packagePath, "tsup.config.ts")) || existsSync(join(packagePath, "tsup.config.js"));
+  if (usesTsup) {
+    return runTsupSafeBuild(packagePath, packageName);
+  }
+  return runDirectBuild(packagePath, packageName);
+}
+function isBuildCommand(command, args) {
+  const full = [command, ...args ?? []].join(" ").trim();
+  return /\b(pnpm|npm|yarn)\s+(run\s+)?build\b/.test(full);
+}
+async function runTsupSafeBuild(packagePath, packageName) {
+  const startTime = Date.now();
+  const buildId = randomBytes(6).toString("hex");
+  const tempDir = join(tmpdir(), `kb-release-build-${buildId}`);
+  const distDir = join(packagePath, "dist");
+  const backupDir = join(packagePath, `dist.bak-${buildId}`);
+  try {
+    const buildResult = await spawnCommand(`npx tsup -d ${tempDir}`, packagePath);
+    if (!buildResult.success) {
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+      return { ...buildResult, name: packageName, durationMs: Date.now() - startTime };
+    }
+    if (existsSync(distDir)) {
+      await rename(distDir, backupDir);
+    }
+    try {
+      await rename(tempDir, distDir);
+    } catch {
+      await cp(tempDir, distDir, { recursive: true });
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await rm(backupDir, { recursive: true, force: true }).catch(() => {
+    });
+    return { success: true, name: packageName, durationMs: Date.now() - startTime };
+  } catch (err) {
+    if (existsSync(backupDir) && !existsSync(distDir)) {
+      await rename(backupDir, distDir).catch(() => {
+      });
+    }
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+    return {
+      success: false,
+      name: packageName,
+      error: err instanceof Error ? err.message : String(err),
+      durationMs: Date.now() - startTime
+    };
+  }
+}
+async function runDirectBuild(packagePath, packageName) {
+  const result = await spawnCommand("pnpm run build", packagePath);
+  return { ...result, name: packageName };
+}
+function spawnCommand(command, cwd, timeoutMs = 5 * 60 * 1e3) {
+  const startTime = Date.now();
+  return new Promise((resolve2) => {
+    const child = spawn(command, [], {
+      cwd,
+      stdio: "pipe",
+      shell: true,
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      const durationMs = Date.now() - startTime;
+      if (exitCode === 0) {
+        resolve2({ success: true, durationMs, stdout, stderr, exitCode });
+        return;
+      }
+      const combined = (stderr || stdout).trim();
+      const tail = combined.split("\n").slice(-30).join("\n");
+      resolve2({
+        success: false,
+        error: tail || `Build failed with exit code ${exitCode}`,
+        durationMs,
+        stdout,
+        stderr,
+        exitCode
+      });
+    });
+    child.on("error", (err) => {
+      resolve2({ success: false, error: err.message, durationMs: Date.now() - startTime, stdout: "", stderr: "", exitCode: 1 });
+    });
+    setTimeout(() => {
+      child.kill();
+      resolve2({ success: false, error: `Timed out after ${timeoutMs / 1e3}s`, durationMs: Date.now() - startTime, stdout: "", stderr: "", exitCode: 1 });
+    }, timeoutMs);
+  });
+}
+async function runReleaseChecks(checks, options) {
+  const results = [];
+  for (const check of checks) {
+    const result = await runSingleCheck(check, options);
+    results.push(result);
+    options.logger?.info?.(`Check ${check.id}: ${result.ok ? "passed" : "failed"} (${result.timingMs}ms)`);
+    if (!result.ok && !check.optional) {
+      break;
+    }
+  }
+  return results;
+}
+async function runSingleCheck(check, options) {
+  const runIn = check.runIn ?? "perPackage";
+  let pathsToRun;
+  if (runIn === "repoRoot") {
+    pathsToRun = [options.repoRoot];
+  } else if (runIn === "scopePath") {
+    pathsToRun = [options.scopePath ?? options.repoRoot];
+  } else {
+    pathsToRun = options.packagePaths.length > 0 ? options.packagePaths : [options.repoRoot];
+  }
+  let checkOk = true;
+  let checkError;
+  let totalDurationMs = 0;
+  for (const pkgPath of pathsToRun) {
+    const resolvedArgs = (check.args ?? []).map(
+      (arg) => arg.match(/\.(sh|js|ts|mjs|cjs)$/) ? join(options.repoRoot, arg) : arg
+    );
+    const fullCommand = [check.command, ...resolvedArgs].join(" ");
+    const timeoutMs = check.timeoutMs ?? 12e4;
+    const result = await spawnCommand(fullCommand, pkgPath, timeoutMs);
+    totalDurationMs += result.durationMs;
+    const ok = evaluateParser(check, result.stdout, result.stderr, result.exitCode);
+    if (!ok) {
+      checkOk = false;
+      checkError = result.error ?? (result.stderr || result.stdout || `exit code ${result.exitCode}`);
+      break;
+    }
+  }
+  return {
+    id: check.id,
+    ok: checkOk,
+    details: checkError ? { error: checkError } : void 0,
+    hint: check.optional ? "optional" : void 0,
+    timingMs: totalDurationMs
+  };
+}
+function evaluateParser(check, stdout, stderr, exitCode) {
+  const parser = check.parser ?? "exitcode";
+  if (parser === "exitcode") {
+    return exitCode === 0;
+  }
+  if (parser === "json") {
+    try {
+      const parsed = JSON.parse(stdout);
+      return parsed.ok === true || parsed.success === true || parsed.status === "ok";
+    } catch {
+      return false;
+    }
+  }
+  if (typeof parser === "function") {
+    return parser(stdout, stderr, exitCode);
+  }
+  return exitCode === 0;
+}
+async function verifyPackages(packages, options) {
+  const results = [];
+  for (const pkg of packages) {
+    const result = verifyPackage(pkg.path, pkg.name);
+    results.push(result);
+    options?.onProgress?.(pkg.name, result);
+  }
+  return results;
+}
+function verifyPackage(packagePath, packageName) {
+  const pkgJsonPath = join(packagePath, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    return { name: packageName ?? packagePath, success: true, issues: [] };
+  }
+  const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+  const name = packageName ?? pkg.name ?? packagePath;
+  if (pkg.private) {
+    return { name, success: true, issues: [] };
+  }
+  if (!existsSync(join(packagePath, "dist"))) {
+    return { name, success: true, issues: [] };
+  }
+  const issues = [];
+  const tmpDir = join(tmpdir(), `kb-verify-${randomBytes(6).toString("hex")}`);
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+    const origPkg = readFileSync(pkgJsonPath, "utf-8");
+    const modPkg = JSON.parse(origPkg);
+    for (const section of ["dependencies", "devDependencies", "peerDependencies"]) {
+      const deps = modPkg[section];
+      if (!deps) {
+        continue;
+      }
+      for (const [k, v] of Object.entries(deps)) {
+        if (typeof v === "string" && v.startsWith("link:")) {
+          deps[k] = "*";
+        }
+      }
+    }
+    writeFileSync(pkgJsonPath, JSON.stringify(modPkg, null, 2) + "\n");
+    let tgzFile;
+    try {
+      execSync(`npm pack --pack-destination ${tmpDir}`, { cwd: packagePath, stdio: "pipe", timeout: 3e4 });
+      const files = readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+      tgzFile = files[0] ? join(tmpDir, files[0]) : void 0;
+    } finally {
+      writeFileSync(pkgJsonPath, origPkg);
+    }
+    if (!tgzFile) {
+      issues.push("npm pack produced no tarball");
+      return { name, success: false, issues };
+    }
+    execSync(`tar xzf ${tgzFile}`, { cwd: tmpDir, stdio: "pipe" });
+    const extractedDir = join(tmpDir, "package");
+    const testFiles = findFiles(
+      join(extractedDir, "dist"),
+      (f) => f.includes(".spec.") || f.includes(".test.") || f.includes("__tests__")
+    );
+    if (testFiles.length > 0) {
+      issues.push(`Test files in dist/: ${testFiles.slice(0, 3).join(", ")}`);
+    }
+    const extractedPkg = JSON.parse(readFileSync(join(extractedDir, "package.json"), "utf-8"));
+    for (const field of ["main", "module", "types"]) {
+      const val = extractedPkg[field];
+      if (val && !existsSync(join(extractedDir, val))) {
+        issues.push(`${field}: ${val} does not exist in published package`);
+      }
+    }
+    if (extractedPkg.exports) {
+      checkExportsExist(extractedPkg.exports, extractedDir, "exports", issues);
+    }
+    const esmEntry = resolveEsmEntry(extractedPkg);
+    if (esmEntry) {
+      const esmPath = join(extractedDir, esmEntry);
+      if (existsSync(esmPath)) {
+        checkDirectoryImports(esmPath, join(extractedDir, "dist"), issues);
+        try {
+          execSync(`node --check ${esmPath}`, { stdio: "pipe", timeout: 1e4 });
+        } catch {
+          issues.push(`ESM syntax error in ${esmEntry}`);
+        }
+      }
+    }
+    const cjsEntry = resolveCjsEntry(extractedPkg);
+    if (cjsEntry) {
+      const cjsPath = join(extractedDir, cjsEntry);
+      if (existsSync(cjsPath)) {
+        try {
+          execSync(`node --check ${cjsPath}`, { stdio: "pipe", timeout: 1e4 });
+        } catch {
+          issues.push(`CJS syntax error in ${cjsEntry}`);
+        }
+      }
+    }
+  } catch (err) {
+    issues.push(`Verification error: ${err instanceof Error ? err.message : String(err)}`);
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+  return { name, success: issues.length === 0, issues };
+}
+function resolveEsmEntry(pkg) {
+  return pkg.exports?.["."]?.import ?? pkg.module ?? pkg.main;
+}
+function resolveCjsEntry(pkg) {
+  const req = pkg.exports?.["."]?.require;
+  if (req) {
+    return req;
+  }
+  if (pkg.main?.endsWith(".cjs")) {
+    return pkg.main;
+  }
+  return void 0;
+}
+function checkExportsExist(exports$1, baseDir, prefix, issues) {
+  if (typeof exports$1 === "string") {
+    if (exports$1.includes("*")) {
+      return;
+    }
+    if (!existsSync(join(baseDir, exports$1))) {
+      issues.push(`${prefix}: ${exports$1} missing`);
+    }
+  } else if (exports$1 && typeof exports$1 === "object") {
+    for (const [k, v] of Object.entries(exports$1)) {
+      if (k.includes("*")) {
+        continue;
+      }
+      checkExportsExist(v, baseDir, `${prefix}.${k}`, issues);
+    }
+  }
+}
+function checkDirectoryImports(filePath, distDir, issues) {
+  const content = readFileSync(filePath, "utf-8");
+  const importRegex = /(?:export|import)\s.*?from\s+['"](\.[^'"]*)['"]/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const target = match[1];
+    if (!target || target.includes(".")) {
+      continue;
+    }
+    const targetPath = resolve(dirname(filePath), target);
+    if (existsSync(targetPath) && statSync(targetPath).isDirectory()) {
+      issues.push(`Directory import '${target}' in ${filePath.split("/").pop()}`);
+    }
+  }
+}
+function findFiles(dir, predicate) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const results = [];
+  function walk(d) {
+    try {
+      for (const entry of readdirSync(d, { withFileTypes: true })) {
+        const full = join(d, entry.name);
+        if (entry.isDirectory()) {
+          walk(full);
+        } else if (predicate(full)) {
+          results.push(entry.name);
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+// src/pipeline.ts
+async function runReleasePipeline(options) {
+  const {
+    cwd,
+    repoRoot,
+    scopeCwd,
+    scope,
+    config,
+    dryRun = false,
+    skipChecks = false,
+    skipBuild = false,
+    skipVerify = false,
+    checks: checkConfigs,
+    publisher,
+    changelog: changelogGen,
+    logger,
+    onProgress
+  } = options;
+  const startTime = Date.now();
+  const progress = (stage, msg) => {
+    logger?.info?.(msg);
+    onProgress?.(stage, msg);
+  };
+  progress("planning", "Discovering packages and planning release...");
+  const plan = await planRelease({
+    cwd: repoRoot,
+    config,
+    scope,
+    bumpOverride: config.bump
+  });
+  if (plan.packages.length === 0) {
+    return {
+      success: false,
+      plan,
+      report: buildReport("planning", plan, repoRoot, dryRun, startTime, {
+        ok: false,
+        errors: [`No packages found for scope: ${scope || "all"}`],
+        timingMs: 0
+      })
+    };
+  }
+  progress("planning", `Found ${plan.packages.length} package(s) to release`);
+  await saveSnapshot({ cwd: repoRoot, plan });
+  if (!skipChecks && checkConfigs && checkConfigs.length > 0) {
+    progress("checking", `Running ${checkConfigs.length} pre-release check(s)...`);
+    const packagePaths = plan.packages.map((p) => p.path);
+    const checkResults = await runReleaseChecks(checkConfigs, {
+      repoRoot,
+      packagePaths,
+      scopePath: scopeCwd,
+      logger
+    });
+    const failed = checkResults.filter((r) => !r.ok && r.hint !== "optional");
+    if (failed.length > 0) {
+      await restoreSnapshot(repoRoot);
+      return {
+        success: false,
+        plan,
+        report: buildReport("checking", plan, repoRoot, dryRun, startTime, {
+          ok: false,
+          checks: Object.fromEntries(checkResults.map((r) => [r.id, r])),
+          errors: [`Pre-release checks failed: ${failed.map((f) => f.id).join(", ")}`],
+          timingMs: Date.now() - startTime
+        })
+      };
+    }
+    progress("checking", "Pre-release checks passed");
+  }
+  if (!skipBuild && !dryRun) {
+    progress("versioning", `Building ${plan.packages.length} package(s)...`);
+    const buildResults = await buildPackages(plan.packages, { logger });
+    const buildFailed = buildResults.filter((r) => !r.success);
+    if (buildFailed.length > 0) {
+      await restoreSnapshot(repoRoot);
+      return {
+        success: false,
+        plan,
+        report: buildReport("versioning", plan, repoRoot, dryRun, startTime, {
+          ok: false,
+          errors: buildFailed.map((f) => `Build failed: ${f.name} \u2014 ${f.error}`),
+          timingMs: Date.now() - startTime
+        })
+      };
+    }
+  }
+  if (!skipVerify && !dryRun) {
+    progress("verifying", "Verifying package artifacts...");
+    const verifyResults = await verifyPackages(plan.packages, { logger });
+    const verifyFailed = verifyResults.filter((r) => !r.success);
+    if (verifyFailed.length > 0) {
+      await restoreSnapshot(repoRoot);
+      const allIssues = verifyFailed.flatMap((r) => r.issues.map((i) => `${r.name}: ${i}`));
+      return {
+        success: false,
+        plan,
+        report: buildReport("verifying", plan, repoRoot, dryRun, startTime, {
+          ok: false,
+          errors: [`Package verification failed:
+  ${allIssues.join("\n  ")}`],
+          timingMs: Date.now() - startTime
+        })
+      };
+    }
+    progress("verifying", "Package artifacts verified");
+  }
+  progress("versioning", "Updating package versions...");
+  if (!dryRun) {
+    const versionUpdates = await updatePackageVersions(plan);
+    const failedUpdates = versionUpdates.filter((u) => !u.updated);
+    if (failedUpdates.length > 0) {
+      await restoreSnapshot(repoRoot);
+      return {
+        success: false,
+        plan,
+        report: buildReport("versioning", plan, repoRoot, dryRun, startTime, {
+          ok: false,
+          errors: failedUpdates.map((u) => `Version update failed: ${u.package}`),
+          versionUpdates,
+          timingMs: Date.now() - startTime
+        })
+      };
+    }
+  }
+  let changelogMd = "";
+  if (changelogGen) {
+    progress("versioning", "Generating changelog...");
+    try {
+      changelogMd = await changelogGen.generate(plan, { repoRoot, gitCwd: scopeCwd, config });
+    } catch (err) {
+      logger?.warn?.(`Changelog generation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (changelogMd && !dryRun) {
+    await copyChangelogToPackages({ plan, changelog: changelogMd });
+    const changelogPath = join(repoRoot, ".kb", "release", "CHANGELOG.md");
+    await mkdir(join(repoRoot, ".kb", "release"), { recursive: true });
+    await writeFile(changelogPath, changelogMd, "utf-8");
+  }
+  progress("publishing", dryRun ? "Simulating publish (dry-run)..." : "Publishing packages...");
+  const packagesToPublish = plan.packages.map((pkg) => ({
+    name: pkg.name,
+    version: pkg.nextVersion,
+    path: pkg.path
+  }));
+  const publishResult = await publisher.publish(packagesToPublish, {
+    dryRun,
+    access: "public"
+  });
+  let gitResult;
+  if (!dryRun && publishResult.errors.length === 0) {
+    progress("verifying", "Committing and tagging release...");
+    gitResult = await commitAndTagRelease({ cwd: scopeCwd, plan, dryRun });
+  }
+  const report = buildReport("verifying", plan, repoRoot, dryRun, startTime, {
+    ok: publishResult.errors.length === 0,
+    published: publishResult.published,
+    skipped: publishResult.skipped,
+    changelog: changelogMd || void 0,
+    git: gitResult ?? void 0,
+    errors: publishResult.errors.length > 0 ? publishResult.errors : void 0,
+    timingMs: Date.now() - startTime
+  });
+  const scopeDir = scope ? scope.replace(/[@/]/g, "-").replace(/^-/, "") : "root";
+  const historyDir = join(repoRoot, ".kb", "release", "history", scopeDir, (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-"));
+  await mkdir(historyDir, { recursive: true });
+  await writeFile(join(historyDir, "report.json"), JSON.stringify(report, null, 2), "utf-8");
+  return { success: report.result.ok, plan, report };
+}
+function buildReport(stage, plan, repoRoot, dryRun, startTime, result) {
+  return {
+    schemaVersion: "1.0",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    context: { repo: repoRoot, cwd: repoRoot, branch: "unknown", dryRun },
+    stage,
+    plan,
+    result: { ...result, timingMs: result.timingMs ?? Date.now() - startTime }
+  };
+}
+async function resolveScopePath(repoRoot, scope) {
+  if (!scope || scope === "root") {
+    return repoRoot;
+  }
+  if (scope.startsWith("@")) {
+    const packageJsonPaths = await globby("**/package.json", {
+      cwd: repoRoot,
+      absolute: true,
+      onlyFiles: true,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**", "**/.*/**"]
+    });
+    for (const pkgJsonPath of packageJsonPaths) {
+      try {
+        const pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+        if (pkg.name === scope) {
+          return join(pkgJsonPath, "..");
+        }
+      } catch {
+      }
+    }
+  }
+  return join(repoRoot, scope);
+}
+
+export { applyVersionStrategy, buildPackages, commitAndTagRelease, copyChangelogToPackages, createExecaShellAdapter, generateChangelog, generateEnhancedChangelog, isBuildCommand, matchesPackagePattern, planRelease, publishPackages, renderJson, renderMarkdown, renderText, resolveScopePath, restoreSnapshot, runRelease, runReleaseChecks, runReleasePipeline, runSafeBuild, saveSnapshot, spawnCommand, updatePackageVersion, updatePackageVersions, verifyPackage, verifyPackages };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map