@kb-labs/release-manager-cli 0.5.0

package/dist/cli/commands/report.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/commands/report.ts"],"names":["join","readFile"],"mappings":"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","file":"report.js","sourcesContent":["/**\n * Release report command\n */\n\nimport { readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { defineCommand, type CLIInput, type CommandResult, type PluginContextV3 } from '@kb-labs/sdk';\nimport type { ReleaseReport } from '@kb-labs/release-manager-core';\nimport { findRepoRoot } from '../../shared/utils';\n\ninterface ReportFlags {\n  json?: boolean;\n}\n\ntype ReleaseReportResult = CommandResult & {\n  report?: ReleaseReport;\n};\n\nexport default defineCommand({\n  id: 'release:report',\n  description: 'Show last release report',\n\n  handler: {\n    async execute(ctx: PluginContextV3, input: CLIInput<ReportFlags>): Promise<ReleaseReportResult> {\n      const { flags } = input;\n      const cwd = ctx.cwd || process.cwd();\n      const repoRoot = await findRepoRoot(cwd);\n\n      const reportPath = join(repoRoot, '.kb', 'release', 'report.json');\n\n      try {\n        const reportContent = await readFile(reportPath, 'utf-8');\n        const report = JSON.parse(reportContent) as ReleaseReport;\n\n        // Platform services with optional chaining\n        ctx.platform?.logger?.info?.('Release report completed', {\n          stage: report.stage,\n          ok: report.result.ok,\n        });\n\n        if (flags.json) {\n          ctx.ui?.json?.(report);\n        } else {\n          if (!ctx.ui) {\n            throw new Error('UI not available');\n          }\n\n          const sections: Array<{ header?: string; items: string[] }> = [\n            {\n              header: 'Summary',\n              items: [\n                `Timestamp: ${report.ts}`,\n                `Stage: ${report.stage}`,\n                `Result: ${report.result.ok ? 'SUCCESS' : 'FAILED'}`,\n              ],\n            },\n          ];\n\n          if (report.result.errors && report.result.errors.length > 0) {\n            const errorItems: string[] = [];\n            for (const error of report.result.errors) {\n              errorItems.push(error);\n            }\n            sections.push({\n              header: 'Errors',\n              items: errorItems,\n            });\n          }\n\n          const status = report.result.ok ? 'success' : 'error';\n          ctx.ui.sideBox({\n            title: 'Release Report',\n            sections,\n            status,\n          });\n        }\n\n        return { exitCode: report.result.ok ? 0 : 1, report };\n      } catch (error) {\n        if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n          // Platform services with optional chaining\n          ctx.platform?.logger?.warn?.('No release report found');\n\n          if (flags.json) {\n            ctx.ui?.json?.({ exitCode: 3, meta: { error: 'No release report found' } });\n          } else {\n            ctx.ui?.error?.(new Error('No release report found. Run \"kb release run\" first.'));\n          }\n          // Return exit code 3 for misconfiguration\n          return { exitCode: 3, meta: { error: 'No release report found' } };\n        }\n        throw error;\n      }\n    },\n  },\n});\n"]}

package/dist/cli/commands/rollback.d.ts

@@ -0,0 +1,9 @@
+import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';
+import { CLIInput } from '@kb-labs/sdk';
+
+interface RollbackFlags {
+    json?: boolean;
+}
+declare const _default: _kb_labs_shared_command_kit.CommandHandlerV3<unknown, CLIInput<RollbackFlags>, unknown>;
+
+export { _default as default };

package/dist/cli/commands/rollback.js

@@ -0,0 +1,42 @@
+import { defineCommand, findRepoRoot } from '@kb-labs/sdk';
+import { restoreSnapshot } from '@kb-labs/release-manager-core';
+import 'path';
+import 'fs/promises';
+import 'globby';
+
+// src/cli/commands/rollback.ts
+
+// src/cli/commands/rollback.ts
+var rollback_default = defineCommand({
+  id: "release:rollback",
+  description: "Rollback last release",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const cwd = ctx.cwd || process.cwd();
+      const repoRoot = await findRepoRoot(cwd);
+      await restoreSnapshot(repoRoot);
+      ctx.platform?.logger?.info?.("Release rollback completed");
+      if (flags.json) {
+        ctx.ui?.json?.({ exitCode: 4, message: "Rollback completed" });
+      } else {
+        ctx.ui.sideBox({
+          title: "Rollback",
+          sections: [
+            {
+              items: [
+                `${ctx.ui.symbols.success} ${ctx.ui.colors.success("Release state restored from backup snapshot")}`
+              ]
+            }
+          ],
+          status: "success"
+        });
+      }
+      return { exitCode: 4, message: "Rollback completed" };
+    }
+  }
+});
+
+export { rollback_default as default };
+//# sourceMappingURL=rollback.js.map
+//# sourceMappingURL=rollback.js.map

package/dist/cli/commands/rollback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/cli/commands/rollback.ts"],"names":[],"mappings":";;;;;;;;;AAgBA,IAAO,mBAAQ,aAAA,CAAc;AAAA,EAC3B,EAAA,EAAI,kBAAA;AAAA,EACJ,WAAA,EAAa,uBAAA;AAAA,EAEb,OAAA,EAAS;AAAA,IACP,MAAM,OAAA,CAAQ,GAAA,EAAsB,KAAA,EAAgE;AAClG,MAAA,MAAM,EAAE,OAAM,GAAI,KAAA;AAClB,MAAA,MAAM,GAAA,GAAM,GAAA,CAAI,GAAA,IAAO,OAAA,CAAQ,GAAA,EAAI;AACnC,MAAA,MAAM,QAAA,GAAW,MAAM,YAAA,CAAa,GAAG,CAAA;AAEvC,MAAA,MAAM,gBAAgB,QAAQ,CAAA;AAE9B,MAAA,GAAA,CAAI,QAAA,EAAU,MAAA,EAAQ,IAAA,GAAO,4BAA4B,CAAA;AAEzD,MAAA,IAAI,MAAM,IAAA,EAAM;AACd,QAAA,GAAA,CAAI,IAAI,IAAA,GAAO,EAAE,UAAU,CAAA,EAAG,OAAA,EAAS,sBAAsB,CAAA;AAAA,MAC/D,CAAA,MAAO;AACL,QAAA,GAAA,CAAI,GAAG,OAAA,CAAQ;AAAA,UACb,KAAA,EAAO,UAAA;AAAA,UACP,QAAA,EAAU;AAAA,YACR;AAAA,cACE,KAAA,EAAO;AAAA,gBACL,CAAA,EAAG,GAAA,CAAI,EAAA,CAAG,OAAA,CAAQ,OAAO,CAAA,CAAA,EAAI,GAAA,CAAI,EAAA,CAAG,MAAA,CAAO,OAAA,CAAQ,6CAA6C,CAAC,CAAA;AAAA;AACnG;AACF,WACF;AAAA,UACA,MAAA,EAAQ;AAAA,SACT,CAAA;AAAA,MACH;AAGA,MAAA,OAAO,EAAE,QAAA,EAAU,CAAA,EAAG,OAAA,EAAS,oBAAA,EAAqB;AAAA,IACtD;AAAA;AAEJ,CAAC","file":"rollback.js","sourcesContent":["/**\n * Release rollback command\n */\n\nimport { defineCommand, type CLIInput, type CommandResult, type PluginContextV3 } from '@kb-labs/sdk';\nimport { restoreSnapshot } from '@kb-labs/release-manager-core';\nimport { findRepoRoot } from '../../shared/utils';\n\ninterface RollbackFlags {\n  json?: boolean;\n}\n\ntype ReleaseRollbackResult = CommandResult & {\n  message?: string;\n};\n\nexport default defineCommand({\n  id: 'release:rollback',\n  description: 'Rollback last release',\n\n  handler: {\n    async execute(ctx: PluginContextV3, input: CLIInput<RollbackFlags>): Promise<ReleaseRollbackResult> {\n      const { flags } = input;\n      const cwd = ctx.cwd || process.cwd();\n      const repoRoot = await findRepoRoot(cwd);\n\n      await restoreSnapshot(repoRoot);\n\n      ctx.platform?.logger?.info?.('Release rollback completed');\n\n      if (flags.json) {\n        ctx.ui?.json?.({ exitCode: 4, message: 'Rollback completed' });\n      } else {\n        ctx.ui.sideBox({\n          title: 'Rollback',\n          sections: [\n            {\n              items: [\n                `${ctx.ui.symbols.success} ${ctx.ui.colors.success('Release state restored from backup snapshot')}`,\n              ],\n            },\n          ],\n          status: 'success',\n        });\n      }\n\n      // Return exit code 4 for rollback executed\n      return { exitCode: 4, message: 'Rollback completed' };\n    },\n  },\n});\n"]}

package/dist/cli/commands/run.d.ts

@@ -0,0 +1,16 @@
+import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';
+import { CLIInput } from '@kb-labs/sdk';
+
+interface RunFlags {
+    scope?: string;
+    bump?: 'patch' | 'minor' | 'major' | 'auto';
+    strict?: boolean;
+    'dry-run'?: boolean;
+    'skip-checks'?: boolean;
+    'skip-build'?: boolean;
+    'skip-verify'?: boolean;
+    json?: boolean;
+}
+declare const _default: _kb_labs_shared_command_kit.CommandHandlerV3<unknown, CLIInput<RunFlags>, unknown>;
+
+export { _default as default };

package/dist/cli/commands/run.js

@@ -0,0 +1,539 @@
+import { defineCommand, findRepoRoot, useLoader, useConfig, useLLM, useLogger } from '@kb-labs/sdk';
+import { resolveScopePath, runReleasePipeline } from '@kb-labs/release-manager-core';
+import { join } from 'path';
+import 'fs/promises';
+import 'globby';
+import { generateChangelog, generateSimpleChangelog } from '@kb-labs/release-manager-changelog';
+import { spawn } from 'child_process';
+import { readFileSync, readdirSync, writeFileSync } from 'fs';
+import * as readline from 'readline/promises';
+
+// src/cli/commands/run.ts
+function createChangelogGenerator(config, llm) {
+  return {
+    async generate(plan, opts) {
+      const locale = config.changelog?.locale || "en";
+      const packages = plan.packages.map((pkg) => ({
+        name: pkg.name,
+        path: pkg.path,
+        currentVersion: pkg.currentVersion,
+        nextVersion: pkg.nextVersion,
+        bump: pkg.bump === "auto" ? "patch" : pkg.bump
+      }));
+      try {
+        const result = await generateChangelog({
+          repoRoot: opts.repoRoot,
+          gitCwd: opts.gitCwd,
+          packages,
+          range: { to: "HEAD" },
+          changelog: {
+            template: config.changelog?.template ?? void 0,
+            locale,
+            metadata: config.changelog?.metadata,
+            ignoreAuthors: config.changelog?.ignoreAuthors,
+            includeTypes: config.changelog?.includeTypes,
+            excludeTypes: config.changelog?.excludeTypes,
+            collapseMerges: config.changelog?.collapseMerges,
+            collapseReverts: config.changelog?.collapseReverts,
+            preferMergeSummary: config.changelog?.preferMergeSummary
+          },
+          git: {
+            autoUnshallow: config.git?.autoUnshallow,
+            requireSignedTags: config.git?.requireSignedTags,
+            baseUrl: config.git?.baseUrl ?? void 0
+          },
+          platform: llm ? { llm } : void 0
+        });
+        return result.markdown;
+      } catch {
+        return generateSimpleChangelog(packages, locale);
+      }
+    }
+  };
+}
+function resolveToken(token) {
+  return token ?? process.env.NPM_TOKEN ?? process.env.NODE_AUTH_TOKEN;
+}
+function publishSinglePackage(options) {
+  const { packagePath, token, otp, dryRun, tag, access, registry } = options;
+  return new Promise((resolve, reject) => {
+    const args = ["publish"];
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (tag) {
+      args.push(`--tag=${tag}`);
+    }
+    if (access) {
+      args.push(`--access=${access}`);
+    }
+    if (registry) {
+      args.push(`--registry=${registry}`);
+    }
+    if (otp) {
+      args.push(`--otp=${otp}`);
+    }
+    const env = { ...process.env };
+    if (token) {
+      env["NODE_AUTH_TOKEN"] = token;
+    }
+    const child = spawn("npm", args, {
+      cwd: packagePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+      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) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(stderr || stdout || `npm publish exited with code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function publishPackagesProgrammatic(options) {
+  const { packages, dryRun, otp, tag, access, registry } = options;
+  const logger = useLogger();
+  const token = resolveToken(options.token);
+  if (!token && !dryRun) {
+    const error = "No npm token found. Set NPM_TOKEN (or NODE_AUTH_TOKEN) in environment.";
+    logger.error(error);
+    return {
+      results: [],
+      published: [],
+      failed: packages.map((p) => `${p.name}@${p.version}`),
+      skipped: [],
+      errors: [error]
+    };
+  }
+  const results = [];
+  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
+  for (const pkg of packages) {
+    logger.info(`Publishing ${pkg.name}@${pkg.version}`, { path: pkg.path, dryRun });
+    const pkgJsonPath = join(pkg.path, "package.json");
+    const originalPkgJson = readFileSync(pkgJsonPath, "utf-8");
+    let restored = false;
+    try {
+      const pkgJson = JSON.parse(originalPkgJson);
+      let modified = false;
+      for (const section of ["dependencies", "peerDependencies"]) {
+        const deps = pkgJson[section];
+        if (!deps) continue;
+        for (const [depName, depValue] of Object.entries(deps)) {
+          if (typeof depValue !== "string") continue;
+          const val = depValue;
+          if (val.startsWith("link:")) {
+            const planVersion = versionMap.get(depName);
+            if (planVersion) {
+              deps[depName] = `^${planVersion}`;
+              modified = true;
+            } else {
+              try {
+                const linkPath = val.replace("link:", "");
+                const linkedPkg = JSON.parse(readFileSync(join(pkg.path, linkPath, "package.json"), "utf-8"));
+                deps[depName] = `^${linkedPkg.version}`;
+                modified = true;
+              } catch {
+                deps[depName] = "*";
+                modified = true;
+              }
+            }
+          } else if (val.startsWith("workspace:")) {
+            const planVersion = versionMap.get(depName);
+            if (planVersion) {
+              deps[depName] = val === "workspace:*" ? `^${planVersion}` : val.replace("workspace:", "");
+              modified = true;
+            } else {
+              try {
+                const repoRoot = join(pkg.path, "..");
+                const candidates = readdirSync(repoRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join(repoRoot, d.name, "package.json"));
+                for (const candidate of candidates) {
+                  try {
+                    const cPkg = JSON.parse(readFileSync(candidate, "utf-8"));
+                    if (cPkg.name === depName) {
+                      deps[depName] = `^${cPkg.version}`;
+                      modified = true;
+                      break;
+                    }
+                  } catch {
+                  }
+                }
+              } catch {
+                deps[depName] = "*";
+                modified = true;
+              }
+            }
+          }
+        }
+      }
+      if (modified) {
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+        logger.info(`Replaced link: deps for ${pkg.name}`);
+      }
+      await publishSinglePackage({
+        packagePath: pkg.path,
+        token,
+        otp,
+        dryRun,
+        tag,
+        access: access ?? "public",
+        registry
+      });
+      results.push({ name: pkg.name, version: pkg.version, success: true });
+      logger.info(`Published ${pkg.name}@${pkg.version}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to publish ${pkg.name}@${pkg.version}`, void 0, { error: message });
+      results.push({
+        name: pkg.name,
+        version: pkg.version,
+        success: false,
+        error: message
+      });
+    } finally {
+      if (!restored) {
+        writeFileSync(pkgJsonPath, originalPkgJson);
+        restored = true;
+      }
+    }
+  }
+  const published = results.filter((r) => r.success).map((r) => `${r.name}@${r.version}`);
+  const failed = results.filter((r) => !r.success).map((r) => `${r.name}@${r.version}`);
+  const errors = results.filter((r) => !r.success && r.error).map((r) => `${r.name}: ${r.error}`);
+  return {
+    results,
+    published,
+    failed,
+    skipped: dryRun ? packages.map((p) => `${p.name}@${p.version} (dry-run)`) : [],
+    errors
+  };
+}
+async function publishPackagesWithOTP(options) {
+  const { packages, dryRun, tag, access, ui, logger } = options;
+  let otp = options.otp;
+  const results = [];
+  const versionMap = new Map(packages.map((p) => [p.name, p.version]));
+  for (const pkg of packages) {
+    logger?.info("Publishing package", { name: pkg.name, version: pkg.version });
+    const pkgJsonPath = join(pkg.path, "package.json");
+    const originalPkgJson = readFileSync(pkgJsonPath, "utf-8");
+    let restored = false;
+    try {
+      const pkgJson = JSON.parse(originalPkgJson);
+      let modified = false;
+      for (const section of ["dependencies", "peerDependencies"]) {
+        const deps = pkgJson[section];
+        if (!deps) continue;
+        for (const [depName, depValue] of Object.entries(deps)) {
+          if (typeof depValue !== "string") continue;
+          const val = depValue;
+          if (val.startsWith("link:")) {
+            const planVersion = versionMap.get(depName);
+            if (planVersion) {
+              deps[depName] = `^${planVersion}`;
+              modified = true;
+            } else {
+              try {
+                const linkPath = val.replace("link:", "");
+                const linkedPkg = JSON.parse(readFileSync(join(pkg.path, linkPath, "package.json"), "utf-8"));
+                deps[depName] = `^${linkedPkg.version}`;
+                modified = true;
+              } catch {
+                deps[depName] = "*";
+                modified = true;
+              }
+            }
+          } else if (val.startsWith("workspace:")) {
+            const planVersion = versionMap.get(depName);
+            if (planVersion) {
+              deps[depName] = val === "workspace:*" ? `^${planVersion}` : val.replace("workspace:", "");
+              modified = true;
+            } else {
+              try {
+                const repoRoot = join(pkg.path, "..");
+                const candidates = readdirSync(repoRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join(repoRoot, d.name, "package.json"));
+                for (const candidate of candidates) {
+                  try {
+                    const cPkg = JSON.parse(readFileSync(candidate, "utf-8"));
+                    if (cPkg.name === depName) {
+                      deps[depName] = `^${cPkg.version}`;
+                      modified = true;
+                      break;
+                    }
+                  } catch {
+                  }
+                }
+              } catch {
+                deps[depName] = "*";
+                modified = true;
+              }
+            }
+          }
+        }
+      }
+      if (modified) {
+        writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+        logger?.info(`Replaced link: deps for ${pkg.name}`);
+      }
+      const loader = useLoader(`Publishing ${pkg.name}@${pkg.version}...`);
+      loader.start();
+      let attempts = 0;
+      const maxAttempts = 3;
+      let published2 = false;
+      while (!published2 && attempts < maxAttempts) {
+        attempts++;
+        try {
+          await publishSinglePackage2({
+            packagePath: pkg.path,
+            otp,
+            dryRun,
+            tag,
+            access
+          });
+          published2 = true;
+          results.push({ name: pkg.name, version: pkg.version, success: true });
+          const successMsg = dryRun ? `Dry-run succeeded for ${pkg.name}@${pkg.version}` : `Published ${pkg.name}@${pkg.version}`;
+          loader.succeed(successMsg);
+          logger?.info("Package published successfully", {
+            name: pkg.name,
+            version: pkg.version,
+            dryRun
+          });
+        } catch (error) {
+          const errorMessage = error.message || String(error);
+          if (errorMessage.includes("EOTP") || errorMessage.includes("one-time password")) {
+            if (attempts < maxAttempts) {
+              loader.succeed(`\u{1F510} 2FA required for ${pkg.name}`);
+              logger?.info("OTP required for publishing", {
+                name: pkg.name,
+                attempt: attempts
+              });
+              const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+              });
+              try {
+                otp = await rl.question("   Enter OTP code: ");
+                rl.close();
+                if (!otp || otp.trim().length !== 6) {
+                  ui.write?.("   \u26A0\uFE0F  Invalid OTP code (must be 6 digits)\n");
+                  logger?.warn("Invalid OTP code provided", { length: otp?.trim().length });
+                  otp = void 0;
+                  continue;
+                }
+                loader.update({ text: `Publishing ${pkg.name}@${pkg.version} with OTP...` });
+                loader.start();
+                logger?.debug("Retrying with OTP");
+              } catch (e) {
+                rl.close();
+                throw e;
+              }
+            } else {
+              loader.fail("Max OTP attempts reached");
+              logger?.error("Max OTP attempts reached", {
+                name: pkg.name,
+                attempts: maxAttempts
+              });
+              results.push({
+                name: pkg.name,
+                version: pkg.version,
+                success: false,
+                error: "Max OTP attempts reached"
+              });
+              break;
+            }
+          } else {
+            loader.fail(`Failed: ${errorMessage}`);
+            logger?.error("Package publish failed", {
+              name: pkg.name,
+              version: pkg.version,
+              error: errorMessage
+            });
+            results.push({
+              name: pkg.name,
+              version: pkg.version,
+              success: false,
+              error: errorMessage
+            });
+            break;
+          }
+        }
+      }
+    } finally {
+      if (!restored) {
+        writeFileSync(pkgJsonPath, originalPkgJson);
+        restored = true;
+      }
+    }
+  }
+  const published = results.filter((r) => r.success).map((r) => `${r.name}@${r.version}`);
+  const failed = results.filter((r) => !r.success).map((r) => `${r.name}@${r.version}`);
+  const errors = results.filter((r) => !r.success && r.error).map((r) => `${r.name}: ${r.error}`);
+  return {
+    results,
+    published,
+    failed,
+    skipped: dryRun ? packages.map((p) => `${p.name}@${p.version} (dry-run)`) : [],
+    errors
+  };
+}
+function publishSinglePackage2(options) {
+  const { packagePath, otp, dryRun, tag, access } = options;
+  return new Promise((resolve, reject) => {
+    const args = ["publish"];
+    if (dryRun) {
+      args.push("--dry-run");
+    }
+    if (otp) {
+      args.push(`--otp=${otp}`);
+    }
+    if (tag) {
+      args.push(`--tag=${tag}`);
+    }
+    if (access) {
+      args.push(`--access=${access}`);
+    }
+    const child = spawn("npm", args, {
+      cwd: packagePath,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const errorOutput = stderr || stdout;
+        reject(new Error(errorOutput));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/cli/commands/run.ts
+var run_default = defineCommand({
+  id: "release:run",
+  description: "Execute release process (plan, check, publish)",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const cwd = ctx.cwd || process.cwd();
+      const repoRoot = await findRepoRoot(cwd);
+      const dryRun = flags["dry-run"] === true;
+      const configLoader = useLoader("Loading configuration...");
+      configLoader.start();
+      const fileConfig = await useConfig();
+      const config = {
+        ...fileConfig,
+        ...flags.bump && { bump: flags.bump },
+        ...flags.strict !== void 0 && { strict: flags.strict }
+      };
+      configLoader.succeed("Configuration loaded");
+      const llm = useLLM();
+      const changelog = createChangelogGenerator(config, llm ?? void 0);
+      const token = process.env.NPM_TOKEN ?? process.env.NODE_AUTH_TOKEN;
+      const publisher = {
+        async publish(packages, opts) {
+          if (token) {
+            return publishPackagesProgrammatic({ packages, dryRun: opts.dryRun });
+          }
+          return publishPackagesWithOTP({
+            packages,
+            dryRun: opts.dryRun,
+            access: opts.access ?? "public",
+            ui: ctx.ui,
+            logger: ctx.platform?.logger
+          });
+        }
+      };
+      const pipelineLoader = useLoader("Running release pipeline...");
+      pipelineLoader.start();
+      const scopeCwd = await resolveScopePath(repoRoot, flags.scope || "root");
+      const result = await runReleasePipeline({
+        cwd,
+        repoRoot,
+        scopeCwd,
+        scope: flags.scope,
+        config,
+        dryRun,
+        skipChecks: flags["skip-checks"],
+        skipBuild: flags["skip-build"],
+        skipVerify: flags["skip-verify"],
+        checks: (flags.scope ? config.scopes?.[flags.scope]?.checks : void 0) ?? config.checks ?? [],
+        publisher,
+        changelog,
+        logger: ctx.platform?.logger,
+        onProgress: (_stage, message) => pipelineLoader.update({ text: message })
+      });
+      pipelineLoader.succeed(result.success ? "Release completed" : "Release failed");
+      if (flags.json) {
+        ctx.ui?.json?.(result.report);
+      } else {
+        const report = result.report;
+        const sections = [];
+        if (report.result.published?.length) {
+          sections.push({
+            header: "Published",
+            items: report.result.published.map((p) => `${ctx.ui.symbols.success} ${p}`)
+          });
+        }
+        if (report.result.skipped?.length) {
+          sections.push({
+            header: "Skipped (dry-run)",
+            items: report.result.skipped.map((p) => `${ctx.ui.symbols.info} ${p}`)
+          });
+        }
+        if (report.result.errors?.length) {
+          sections.push({
+            header: "Errors",
+            items: report.result.errors.map((e) => `${ctx.ui.symbols.error} ${e}`)
+          });
+        }
+        if (report.result.git) {
+          const g = report.result.git;
+          sections.push({
+            header: "Git",
+            items: [
+              `Committed: ${g.committed}`,
+              `Tags: ${g.tagged?.join(", ") || "none"}`,
+              `Pushed: ${g.pushed}`
+            ]
+          });
+        }
+        ctx.ui.sideBox({
+          title: "Release",
+          sections,
+          status: result.success ? "success" : "error",
+          timing: report.result.timingMs
+        });
+      }
+      return { exitCode: result.success ? 0 : 1, report: result.report };
+    }
+  }
+});
+
+export { run_default as default };
+//# sourceMappingURL=run.js.map
+//# sourceMappingURL=run.js.map