@reliverse/publish 2.2.8 → 2.3.1

package/dist/impl/release.d.ts

@@ -0,0 +1,38 @@
+import type { LoadedConfig } from "@reliverse/config";
+export interface ReleaseOptions {
+    version?: string | "patch" | "minor" | "major";
+    tag?: string;
+    npm?: boolean;
+    github?: boolean;
+    dryRun?: boolean;
+    test?: boolean;
+    build?: boolean;
+}
+/**
+ * Check if git repository is clean
+ */
+export declare function checkGitClean(dryRun: boolean): Promise<void>;
+/**
+ * Create git tag and push
+ */
+export declare function createGitTag(version: string, config: LoadedConfig | null, tagFormat?: string): Promise<void>;
+/**
+ * Get GitHub repository name from git remote
+ */
+export declare function getGitHubRepo(): Promise<string>;
+/**
+ * Create GitHub release using gh CLI
+ */
+export declare function createGitHubRelease(version: string, config: LoadedConfig | null): Promise<void>;
+/**
+ * Run tests
+ */
+export declare function runTests(): Promise<void>;
+/**
+ * Build project
+ */
+export declare function buildProject(): Promise<void>;
+/**
+ * Simple version bump (for release command compatibility)
+ */
+export declare function bumpVersionSimple(version: string, type: "patch" | "minor" | "major"): string;

package/dist/impl/release.js

@@ -0,0 +1,62 @@
+import { logger } from "@reliverse/relinka";
+import { $ } from "bun";
+export async function checkGitClean(dryRun) {
+  try {
+    const status = await $`git status --porcelain`.text();
+    if (status.trim() && !dryRun) {
+      logger.error("Working directory is not clean. Please commit or stash changes first.");
+      process.exit(1);
+    }
+  } catch {
+    logger.error("Not a git repository");
+    process.exit(1);
+  }
+}
+export async function createGitTag(version, config, tagFormat) {
+  const format = tagFormat || config?.release?.tagFormat || "v${version}";
+  const tag = format.replace("${version}", version);
+  await $`git add package.json`;
+  await $`git commit -m "chore: release v${version}"`;
+  await $`git tag ${tag}`;
+  await $`git push origin main --tags`.nothrow();
+}
+export async function getGitHubRepo() {
+  try {
+    const remote = await $`git remote get-url origin`.text();
+    const match = remote.match(/github\.com[:/]([^\s/]+\/[^\s/]+?)(?:\.git)?(?:\s|$)/);
+    return match?.[1] ?? "unknown/repo";
+  } catch {
+    return "unknown/repo";
+  }
+}
+export async function createGitHubRelease(version, config) {
+  if (!(config?.release?.github ?? false)) {
+    return;
+  }
+  const tag = `v${version}`;
+  try {
+    await $`gh --version`.quiet();
+  } catch {
+    logger.warn("GitHub CLI not found, skipping GitHub release");
+    return;
+  }
+  await $`gh release create ${tag} --title "Release ${tag}" --generate-notes`.nothrow();
+}
+export async function runTests() {
+  await $`bun test`;
+}
+export async function buildProject() {
+  await $`bun run build`;
+}
+export function bumpVersionSimple(version, type) {
+  const parts = version.split(".").map(Number);
+  const [major = 0, minor = 0, patch = 0] = parts;
+  switch (type) {
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "major":
+      return `${major + 1}.0.0`;
+  }
+}

package/dist/mod.d.ts

@@ -23,9 +23,6 @@ export interface PublishConfig extends BaseConfig {
         config: PackagePublishConfig;
     }>;
 }
-export interface DlerConfig {
-    publish?: PublishConfig;
-}
 export interface PublishOptions {
     dryRun?: boolean;
     tag?: string;
@@ -49,8 +46,14 @@ export interface PublishOptions {
     bunRegistry?: string;
     skipTip2FA?: boolean;
     filter?: string | string[];
+    release?: boolean;
+    test?: boolean;
+    build?: boolean;
+    github?: boolean;
+    gitTag?: boolean;
+    version?: string | "patch" | "minor" | "major";
 }
-export type { PackageKind, RegistryType, } from "@reliverse/config/impl/publish";
+export type { PackageKind, RegistryType } from "@reliverse/config/impl/publish";
 export interface PublishResult {
     success: boolean;
     packageName: string;
@@ -74,3 +77,4 @@ export declare function publishPackage(packagePath: string, options?: PublishOpt
  * Publish all workspace packages
  */
 export declare function publishAllPackages(cwd?: string, ignore?: string | string[], options?: PublishOptions): Promise<PublishAllResult>;
+export { buildProject, bumpVersionSimple, checkGitClean, createGitHubRelease, createGitTag, getGitHubRepo, runTests, } from "./impl/release.js";

package/dist/mod.js

@@ -14,6 +14,16 @@ import {
 import { re } from "@reliverse/relico";
 import { logger } from "@reliverse/relinka";
 import { readPackageJSON, writePackageJSON } from "@reliverse/typerso";
+import { config } from "dotenv";
+import {
+  buildProject,
+  bumpVersionSimple,
+  checkGitClean,
+  createGitHubRelease,
+  createGitTag,
+  getGitHubRepo,
+  runTests
+} from "./impl/release.js";
 const THROW_2FA_ERROR = false;
 let hasShown2FATip = false;
 async function runBunPublishCommand(packagePath, args, verbose, withNpmLogs) {
@@ -22,9 +32,7 @@ async function runBunPublishCommand(packagePath, args, verbose, withNpmLogs) {
       logger.debug(`Spawning bun publish command: bun ${args.join(" ")}`);
       logger.debug(`Working directory: ${packagePath}`);
       if (withNpmLogs) {
-        logger.debug(
-          "With npm logs enabled - output will be displayed directly"
-        );
+        logger.debug("With npm logs enabled - output will be displayed directly");
       }
     }
     const proc = Bun.spawn(args, {
@@ -106,7 +114,7 @@ Error: Publishing timed out after 5 minutes. This may indicate an authentication
         );
       }
       throw new Error(
-        "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (note: .env files are not automatically loaded - export it in your shell or use a tool like dotenv-cli), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
+        "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (.env files are automatically loaded), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
       );
     }
     return { stdout, stderr, exitCode };
@@ -147,15 +155,11 @@ function validateKindRegistryCombination(kind, registry, verbose) {
   };
   const allowedRegistries = allowedCombinations[kind];
   if (verbose) {
-    logger.debug(
-      `Allowed registries for kind "${kind}": ${allowedRegistries.join(", ")}`
-    );
+    logger.debug(`Allowed registries for kind "${kind}": ${allowedRegistries.join(", ")}`);
   }
   if (!allowedRegistries.includes(registry)) {
     if (verbose) {
-      logger.debug(
-        `Validation failed: registry "${registry}" not allowed for kind "${kind}"`
-      );
+      logger.debug(`Validation failed: registry "${registry}" not allowed for kind "${kind}"`);
     }
     return {
       valid: false,
@@ -176,9 +180,7 @@ async function validateDistFolder(packagePath, verbose) {
     const stat = await Bun.file(distPath).stat();
     const isValid = stat.isDirectory();
     if (verbose) {
-      logger.debug(
-        `Dist folder ${isValid ? "exists and is a directory" : "is not a directory"}`
-      );
+      logger.debug(`Dist folder ${isValid ? "exists and is a directory" : "is not a directory"}`);
     }
     return isValid;
   } catch (error) {
@@ -209,7 +211,7 @@ function validatePackageJsonFields(pkg, _packageName, kind, verbose) {
       "Package has 'private: true' - cannot publish. Run 'dler build' to prepare the package."
     );
   }
-  if (!pkg.files || !Array.isArray(pkg.files) || pkg.files.length === 0) {
+  if (!(pkg.files && Array.isArray(pkg.files)) || pkg.files.length === 0) {
     errors.push("Missing or empty 'files' field - Run 'dler build' to add it.");
   } else {
     if (verbose) {
@@ -225,23 +227,19 @@ function validatePackageJsonFields(pkg, _packageName, kind, verbose) {
     logger.debug(`Has bin field: ${hasBinField}`);
     logger.debug(`Has exports field: ${!!pkg.exports}`);
   }
-  if (!pkg.exports && !hasBinField) {
+  if (!(pkg.exports || hasBinField)) {
     errors.push("Missing 'exports' field - Run 'dler build' to add it.");
   }
   if (!pkg.publishConfig) {
     errors.push("Missing 'publishConfig' field - Run 'dler build' to add it.");
   } else if (!pkg.publishConfig.access) {
-    errors.push(
-      "Missing 'publishConfig.access' field - Run 'dler build' to add it."
-    );
+    errors.push("Missing 'publishConfig.access' field - Run 'dler build' to add it.");
   } else if (verbose) {
     logger.debug(`PublishConfig access: ${pkg.publishConfig.access}`);
   }
   if (kind === "cli") {
     if (!pkg.bin) {
-      errors.push(
-        "CLI package missing 'bin' field - Run 'dler build' to add it."
-      );
+      errors.push("CLI package missing 'bin' field - Run 'dler build' to add it.");
     } else if (typeof pkg.bin === "object") {
       const binEntries = Object.keys(pkg.bin);
       if (verbose) {
@@ -279,25 +277,19 @@ async function restoreOriginalDependencies(packagePath, originalDependencies, or
     if (pkg) {
       if (originalDependencies !== void 0) {
         if (verbose) {
-          logger.debug(
-            `Restoring ${Object.keys(originalDependencies).length} dependencies`
-          );
+          logger.debug(`Restoring ${Object.keys(originalDependencies).length} dependencies`);
         }
         pkg.dependencies = originalDependencies;
       }
       if (originalDevDependencies !== void 0) {
         if (verbose) {
-          logger.debug(
-            `Restoring ${Object.keys(originalDevDependencies).length} devDependencies`
-          );
+          logger.debug(`Restoring ${Object.keys(originalDevDependencies).length} devDependencies`);
         }
         pkg.devDependencies = originalDevDependencies;
       }
       if (originalScripts !== void 0) {
         if (verbose) {
-          logger.debug(
-            `Restoring ${Object.keys(originalScripts).length} scripts`
-          );
+          logger.debug(`Restoring ${Object.keys(originalScripts).length} scripts`);
         }
         pkg.scripts = originalScripts;
       }
@@ -354,9 +346,7 @@ async function resolveWorkspaceVersion(packagePath, depName, workspacePackages,
     const workspacePkg = workspacePackages.find((pkg) => pkg.name === depName);
     if (workspacePkg?.pkg?.version) {
       if (verbose) {
-        logger.debug(
-          `Resolved workspace version for ${depName}: ${workspacePkg.pkg.version}`
-        );
+        logger.debug(`Resolved workspace version for ${depName}: ${workspacePkg.pkg.version}`);
       }
       return workspacePkg.pkg.version;
     }
@@ -400,12 +390,11 @@ async function resolveCatalogVersion(packagePath, depName, verbose) {
               const catalogVersion = catalog[depName];
               if (catalogVersion) {
                 if (verbose) {
-                  logger.debug(
-                    `Resolved catalog version for ${depName}: ${catalogVersion}`
-                  );
+                  logger.debug(`Resolved catalog version for ${depName}: ${catalogVersion}`);
                 }
                 return catalogVersion;
-              } else if (verbose) {
+              }
+              if (verbose) {
                 logger.debug(`Catalog found but ${depName} not in catalog`);
               }
             }
@@ -452,32 +441,30 @@ async function preparePackageForPublishing(packagePath, options, workspacePackag
     if (options.verbose) {
       logger.debug("Created backup of original package.json");
     }
-    if (shouldBumpVersion && options.bump && !options.bumpDisable && !options.dryRun && pkg.version) {
-      if (options.verbose) {
-        logger.debug(`Bumping version: ${pkg.version} -> ${options.bump}`);
-      }
-      const bumpResult = bumpVersion(pkg.version, options.bump);
-      if (!bumpResult) {
+    if (shouldBumpVersion && !options.dryRun && bumpedVersions && pkg.name) {
+      const bumpedVersion = bumpedVersions.get(pkg.name);
+      if (bumpedVersion) {
         if (options.verbose) {
-          logger.debug(`Invalid version bump: ${options.bump}`);
+          logger.log(
+            re.blue(
+              `  Bumping version from ${re.bold(pkg.version || "none")} to ${re.bold(re.green(bumpedVersion))}`
+            )
+          );
+        }
+        pkg.version = bumpedVersion;
+      } else if (options.bump && !options.bumpDisable && pkg.version) {
+        const bumpResult = bumpVersion(pkg.version, options.bump);
+        if (bumpResult) {
+          if (options.verbose) {
+            logger.log(
+              re.blue(
+                `  Bumping version from ${re.bold(pkg.version)} to ${re.bold(re.green(bumpResult.bumped))} (${options.bump})`
+              )
+            );
+          }
+          pkg.version = bumpResult.bumped;
         }
-        return {
-          success: false,
-          error: `Invalid version bump: ${options.bump}`
-        };
-      }
-      if (options.verbose) {
-        logger.log(
-          re.blue(
-            `  Bumping version from ${re.bold(pkg.version)} to ${re.bold(re.green(bumpResult.bumped))} (${options.bump})`
-          )
-        );
       }
-      pkg.version = bumpResult.bumped;
-    } else if (options.verbose) {
-      logger.debug(
-        `Skipping version bump: shouldBumpVersion=${shouldBumpVersion}, bump=${options.bump}, bumpDisable=${options.bumpDisable}, dryRun=${options.dryRun}`
-      );
     }
     if (!pkg.publishConfig) {
       pkg.publishConfig = {};
@@ -497,8 +484,8 @@ async function preparePackageForPublishing(packagePath, options, workspacePackag
         `Stored originals: ${originalDependencies ? Object.keys(originalDependencies).length : 0} deps, ${originalDevDependencies ? Object.keys(originalDevDependencies).length : 0} devDeps, ${originalScripts ? Object.keys(originalScripts).length : 0} scripts`
       );
     }
-    delete pkg.devDependencies;
-    delete pkg.scripts;
+    pkg.devDependencies = void 0;
+    pkg.scripts = void 0;
     if (options.verbose) {
       logger.debug("Removed devDependencies and scripts for publishing");
     }
@@ -625,9 +612,7 @@ export async function publishPackage(packagePath, options = {}, bumpedVersions)
       workspacePackages = await getWorkspacePackages(monorepoRoot);
       if (options.verbose) {
         logger.log(
-          re.blue(
-            `  Found ${re.bold(workspacePackages.length)} workspace packages`
-          )
+          re.blue(`  Found ${re.bold(String(workspacePackages.length))} workspace packages`)
         );
       }
     } else if (options.verbose) {
@@ -702,17 +687,11 @@ export async function publishPackage(packagePath, options = {}, bumpedVersions)
               await Bun.write(targetPath, content);
               copiedFiles.push(targetPath);
               if (options.verbose) {
-                logger.log(
-                  re.blue(`  Copied ${re.bold(fileName)} from monorepo root`)
-                );
-                logger.debug(
-                  `Copied ${fileName} from ${sourcePath} to ${targetPath}`
-                );
+                logger.log(re.blue(`  Copied ${re.bold(fileName)} from monorepo root`));
+                logger.debug(`Copied ${fileName} from ${sourcePath} to ${targetPath}`);
               }
             } else if (options.verbose) {
-              logger.debug(
-                `${fileName} already exists in package, skipping copy`
-              );
+              logger.debug(`${fileName} already exists in package, skipping copy`);
             }
           } else if (options.verbose) {
             logger.debug(`${fileName} not found in monorepo root`);
@@ -737,9 +716,7 @@ export async function publishPackage(packagePath, options = {}, bumpedVersions)
     );
     if (!pkgValidation.valid) {
       if (options.verbose) {
-        logger.debug(
-          `Package validation failed with ${pkgValidation.errors.length} error(s)`
-        );
+        logger.debug(`Package validation failed with ${pkgValidation.errors.length} error(s)`);
       }
       return {
         success: false,
@@ -785,9 +762,7 @@ export async function publishPackage(packagePath, options = {}, bumpedVersions)
       };
     }
     if (options.verbose) {
-      logger.debug(
-        `Package prepared successfully, version: ${prepResult.version}`
-      );
+      logger.debug(`Package prepared successfully, version: ${prepResult.version}`);
     }
     originalDependencies = prepResult.originalDependencies;
     originalDevDependencies = prepResult.originalDevDependencies;
@@ -847,16 +822,14 @@ export async function publishPackage(packagePath, options = {}, bumpedVersions)
         hasShown2FATip = true;
         logger.log(
           `
-${re.cyan.bold("\u{1F4A1} 2FA Authentication Tip")}
+${re.bold(re.cyan("\u{1F4A1} 2FA Authentication Tip"))}
 If you have 2FA enabled on npm, you may be prompted for a one-time password during publishing (on each publish attempt).
 ${re.bold("Quick fix:")}
   When prompted, check the box: "Do not challenge npm publish operations from your IP address for the next 5 minutes"
 ${re.bold("Permanent solution:")}
   https://npmjs.com \u2192 Avatar \u2192 Account \u2192 Modify 2FA \u2192 Uncheck "Require two-factor authentication for write actions"
 
-${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
-
-`)}`
+${re.bold("Use --skip-tip-2fa to skip this information and the 3s wait.\n\n")}`
         );
         await new Promise((resolve2) => setTimeout(resolve2, 3e3));
       }
@@ -870,9 +843,7 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
         if (result.exitCode !== 0) {
           const errorOutput = result.stderr || result.stdout;
           if (options.verbose) {
-            logger.debug(
-              `Publish command failed with exit code ${result.exitCode}`
-            );
+            logger.debug(`Publish command failed with exit code ${result.exitCode}`);
             logger.debug(`Error output: ${errorOutput}`);
           }
           if (THROW_2FA_ERROR && errorOutput.includes("This operation requires a one-time password.")) {
@@ -888,7 +859,7 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
               );
             }
             throw new Error(
-              "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (note: .env files are not automatically loaded - export it in your shell or use a tool like dotenv-cli), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
+              "2FA authentication required. The publish command cannot read OTP input when output is captured. Please either:\n  1. Set NPM_CONFIG_TOKEN environment variable with your npm token (.env files are automatically loaded), or\n  2. Use --with-npm-logs flag to allow interactive OTP input."
             );
           }
           throw new Error(
@@ -897,7 +868,7 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
         }
         const output = result.stdout || result.stderr;
         if (options.verbose) {
-          logger.debug(`Publish command succeeded`);
+          logger.debug("Publish command succeeded");
           logger.debug(`Output length: ${output.length} bytes`);
         }
         const versionMatch = output.match(/published\s+([^\s]+)/i) || output.match(/@([0-9]+\.[0-9]+\.[0-9]+)/);
@@ -907,22 +878,16 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
         }
         if (options.verbose) {
           logger.log(
-            re.green(
-              `\u2713 Published ${re.bold(packageName)}@${re.bold(version || "unknown")}`
-            )
+            re.green(`\u2713 Published ${re.bold(packageName)}@${re.bold(version || "unknown")}`)
           );
         } else {
           logger.log(
-            re.green(
-              `\u2713 Published ${re.bold(packageName)}${version ? `@${re.bold(version)}` : ""}`
-            )
+            re.green(`\u2713 Published ${re.bold(packageName)}${version ? `@${re.bold(version)}` : ""}`)
           );
         }
       } catch (error) {
         if (options.verbose) {
-          logger.debug(
-            `Publish error: ${error instanceof Error ? error.message : String(error)}`
-          );
+          logger.debug(`Publish error: ${error instanceof Error ? error.message : String(error)}`);
         }
         throw new Error(
           `Failed to publish ${packageName}: ${error instanceof Error ? error.message : String(error)}`
@@ -1004,9 +969,7 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
         await Bun.file(copiedFile).unlink();
         if (options.verbose) {
           const fileName = copiedFile.split(/[/\\]/).pop();
-          logger.log(
-            re.blue(`  Removed copied file: ${re.bold(fileName || "")}`)
-          );
+          logger.log(re.blue(`  Removed copied file: ${re.bold(fileName || "")}`));
           logger.debug(`Removed copied file: ${copiedFile}`);
         }
       } catch (error) {
@@ -1021,6 +984,13 @@ ${re.bold(`Use --skip-tip-2fa to skip this information and the 3s wait.
 }
 export async function publishAllPackages(cwd, ignore, options = {}) {
   try {
+    const monorepoRoot = cwd ? resolve(cwd) : await findMonorepoRoot(process.cwd());
+    if (monorepoRoot) {
+      config({ path: resolve(monorepoRoot, ".env") });
+      config({ path: resolve(monorepoRoot, ".env.local") });
+    }
+    config({ path: resolve(process.cwd(), ".env") });
+    config({ path: resolve(process.cwd(), ".env.local") });
     if (options.verbose) {
       logger.debug(`Starting publishAllPackages, cwd: ${cwd ?? "current"}`);
       if (options.filter) {
@@ -1037,6 +1007,33 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
       logger.debug("Loading dler.ts configuration...");
     }
     const dlerConfig = await loadDlerConfig(cwd);
+    if (options.release) {
+      const shouldTest = options.test !== false;
+      const shouldBuild = options.build !== false;
+      if (shouldTest || shouldBuild) {
+        await checkGitClean(options.dryRun ?? false);
+      }
+      if (shouldTest && !options.dryRun) {
+        logger.info("Running tests...");
+        try {
+          await runTests();
+          logger.success("\u2713 Tests passed");
+        } catch (error) {
+          logger.error("\u2717 Tests failed");
+          throw error;
+        }
+      }
+      if (shouldBuild && !options.dryRun) {
+        logger.info("Building project...");
+        try {
+          await buildProject();
+          logger.success("\u2713 Build complete");
+        } catch (error) {
+          logger.error("\u2717 Build failed");
+          throw error;
+        }
+      }
+    }
     if (options.verbose) {
       logger.debug("Discovering workspace packages...");
     }
@@ -1054,7 +1051,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
         const filterPatterns = Array.isArray(options.filter) ? options.filter : [options.filter];
         logger.info(
           re.blue(
-            `   Filtering to ${re.bold(filteredPackages.length)} packages matching: ${re.bold(filterPatterns.join(", "))}`
+            `   Filtering to ${re.bold(String(filteredPackages.length))} packages matching: ${re.bold(filterPatterns.join(", "))}`
           )
         );
       }
@@ -1069,11 +1066,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
         warningCount: 0
       };
     }
-    logger.info(
-      re.blue(
-        `Found ${re.bold(filteredPackages.length)} package(s) to publish`
-      )
-    );
+    logger.info(re.blue(`Found ${re.bold(String(filteredPackages.length))} package(s) to publish`));
     const results = [];
     const concurrency = options.concurrency || 3;
     if (options.verbose) {
@@ -1083,21 +1076,15 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
       const packageConfig = getPackagePublishConfig(pkg.name, dlerConfig);
       if (packageConfig?.enable === false) {
         if (options.verbose) {
-          logger.info(
-            re.yellow(`Skipping ${re.bold(pkg.name)} (disabled in config)`)
-          );
-          logger.debug(
-            `Package config for ${pkg.name}: ${JSON.stringify(packageConfig)}`
-          );
+          logger.info(re.yellow(`Skipping ${re.bold(pkg.name)} (disabled in config)`));
+          logger.debug(`Package config for ${pkg.name}: ${JSON.stringify(packageConfig)}`);
         }
         return false;
       }
       return true;
     });
     if (options.verbose) {
-      logger.debug(
-        `After enable filter: ${packagesToPublish.length} package(s) enabled`
-      );
+      logger.debug(`After enable filter: ${packagesToPublish.length} package(s) enabled`);
     }
     if (packagesToPublish.length === 0) {
       logger.warn("No packages enabled for publishing");
@@ -1110,9 +1097,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
       };
     }
     logger.info(
-      re.blue(
-        `Publishing ${re.bold(packagesToPublish.length)} enabled package(s)`
-      )
+      re.blue(`Publishing ${re.bold(String(packagesToPublish.length))} enabled package(s)`)
     );
     const bumpedVersions = /* @__PURE__ */ new Map();
     if (options.verbose) {
@@ -1120,41 +1105,63 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
     }
     for (const pkg of packagesToPublish) {
       const mergedOptions = mergePublishOptions(options, pkg.name, dlerConfig);
-      const bumpType = mergedOptions.bump || (mergedOptions.bumpDisable ? void 0 : "patch");
-      if (options.verbose) {
-        logger.debug(
-          `Pre-bumping ${pkg.name}: current=${pkg.pkg.version}, bumpType=${bumpType ?? "none"}, bumpDisable=${mergedOptions.bumpDisable}`
-        );
-      }
-      if (bumpType && !mergedOptions.bumpDisable && pkg.pkg.version) {
-        try {
-          const nextVersion = getNextVersion(pkg.pkg.version, bumpType);
-          if (nextVersion) {
-            bumpedVersions.set(pkg.name, nextVersion);
-            if (options.verbose) {
-              logger.log(
-                re.blue(
-                  `  ${re.bold(pkg.name)}: ${pkg.pkg.version} -> ${re.green.bold(nextVersion)}`
-                )
-              );
-            }
-          } else if (options.verbose) {
-            logger.debug(`Failed to calculate next version for ${pkg.name}`);
-          }
-        } catch (error) {
-          if (options.verbose) {
-            logger.debug(
-              `Error bumping ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`
+      if (options.release && options.version) {
+        let releaseVersion;
+        if (typeof options.version === "string" && !["patch", "minor", "major"].includes(options.version)) {
+          releaseVersion = options.version;
+        } else {
+          if (pkg.pkg.version) {
+            releaseVersion = bumpVersionSimple(
+              pkg.pkg.version,
+              options.version || "patch"
             );
+          } else {
+            releaseVersion = "1.0.0";
           }
         }
-      } else if (pkg.pkg.version) {
-        bumpedVersions.set(pkg.name, pkg.pkg.version);
+        bumpedVersions.set(pkg.name, releaseVersion);
+        if (options.verbose) {
+          logger.log(
+            re.blue(
+              `  ${re.bold(pkg.name)}: ${pkg.pkg.version || "none"} -> ${re.bold(re.green(releaseVersion))} (release)`
+            )
+          );
+        }
+      } else {
+        const bumpType = mergedOptions.bump || (mergedOptions.bumpDisable ? void 0 : "patch");
         if (options.verbose) {
           logger.debug(
-            `Using current version for ${pkg.name}: ${pkg.pkg.version}`
+            `Pre-bumping ${pkg.name}: current=${pkg.pkg.version}, bumpType=${bumpType ?? "none"}, bumpDisable=${mergedOptions.bumpDisable}`
           );
         }
+        if (bumpType && !mergedOptions.bumpDisable && pkg.pkg.version) {
+          try {
+            const nextVersion = getNextVersion(pkg.pkg.version, bumpType);
+            if (nextVersion) {
+              bumpedVersions.set(pkg.name, nextVersion);
+              if (options.verbose) {
+                logger.log(
+                  re.blue(
+                    `  ${re.bold(pkg.name)}: ${pkg.pkg.version} -> ${re.bold(re.green(nextVersion))}`
+                  )
+                );
+              }
+            } else if (options.verbose) {
+              logger.debug(`Failed to calculate next version for ${pkg.name}`);
+            }
+          } catch (error) {
+            if (options.verbose) {
+              logger.debug(
+                `Error bumping ${pkg.name}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+        } else if (pkg.pkg.version) {
+          bumpedVersions.set(pkg.name, pkg.pkg.version);
+          if (options.verbose) {
+            logger.debug(`Using current version for ${pkg.name}: ${pkg.pkg.version}`);
+          }
+        }
       }
     }
     if (options.verbose) {
@@ -1162,9 +1169,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
     }
     const totalBatches = Math.ceil(packagesToPublish.length / concurrency);
     if (options.verbose) {
-      logger.debug(
-        `Processing ${totalBatches} batch(es) with concurrency ${concurrency}`
-      );
+      logger.debug(`Processing ${totalBatches} batch(es) with concurrency ${concurrency}`);
     }
     for (let i = 0; i < packagesToPublish.length; i += concurrency) {
       const batch = packagesToPublish.slice(i, i + concurrency);
@@ -1175,18 +1180,12 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
         );
       }
       const batchPromises = batch.map(async (pkg) => {
-        const mergedOptions = mergePublishOptions(
-          options,
-          pkg.name,
-          dlerConfig
-        );
-        if (!mergedOptions.bump && !mergedOptions.bumpDisable) {
+        const mergedOptions = mergePublishOptions(options, pkg.name, dlerConfig);
+        if (!(mergedOptions.bump || mergedOptions.bumpDisable)) {
           mergedOptions.bump = "patch";
         }
         if (options.verbose) {
-          logger.debug(
-            `Merged options for ${pkg.name}: ${JSON.stringify(mergedOptions)}`
-          );
+          logger.debug(`Merged options for ${pkg.name}: ${JSON.stringify(mergedOptions)}`);
         }
         if (mergedOptions.verbose) {
           logger.info(re.blue(`Publishing ${re.bold(pkg.name)}...`));
@@ -1205,9 +1204,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
       const hasBatchErrors = batchResults.some((r) => !r.success);
       if (hasBatchErrors) {
         if (options.verbose) {
-          logger.debug(
-            `Batch ${batchNumber} had errors, stopping processing of remaining batches`
-          );
+          logger.debug(`Batch ${batchNumber} had errors, stopping processing of remaining batches`);
         }
         break;
       }
@@ -1223,6 +1220,45 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
         `Publish all completed: ${successCount} success, ${errorCount} error(s), ${warningCount} warning(s)`
       );
     }
+    if (options.release && !hasErrors && !options.dryRun) {
+      const shouldGitTag = options.gitTag !== false;
+      const shouldGitHub = options.github ?? dlerConfig?.release?.github ?? false;
+      let publishedVersion;
+      if (options.version && typeof options.version === "string" && !["patch", "minor", "major"].includes(options.version)) {
+        publishedVersion = options.version;
+      } else {
+        const firstSuccess = results.find((r) => r.success && r.version);
+        publishedVersion = firstSuccess?.version;
+      }
+      if (publishedVersion) {
+        if (shouldGitTag) {
+          logger.info("Creating git tag...");
+          try {
+            await createGitTag(publishedVersion, dlerConfig, options.tag);
+            logger.success("\u2713 Git tag created");
+          } catch (error) {
+            logger.error("\u2717 Git tag failed");
+            if (options.verbose) {
+              logger.error(error instanceof Error ? error.message : String(error));
+            }
+          }
+        }
+        if (shouldGitHub) {
+          logger.info("Creating GitHub release...");
+          try {
+            await createGitHubRelease(publishedVersion, dlerConfig);
+            logger.success("\u2713 GitHub release created");
+            const repo = await getGitHubRepo();
+            logger.info(`GitHub: https://github.com/${repo}/releases/tag/v${publishedVersion}`);
+          } catch (error) {
+            logger.error("\u2717 GitHub release failed");
+            if (options.verbose) {
+              logger.error(error instanceof Error ? error.message : String(error));
+            }
+          }
+        }
+      }
+    }
     return {
       results,
       hasErrors,
@@ -1232,9 +1268,7 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
     };
   } catch (error) {
     if (options.verbose) {
-      logger.debug(
-        `Publish all failed: ${error instanceof Error ? error.message : String(error)}`
-      );
+      logger.debug(`Publish all failed: ${error instanceof Error ? error.message : String(error)}`);
     }
     logger.error(
       re.red("Failed to publish packages:"),
@@ -1249,3 +1283,12 @@ export async function publishAllPackages(cwd, ignore, options = {}) {
     };
   }
 }
+export {
+  buildProject,
+  bumpVersionSimple,
+  checkGitClean,
+  createGitHubRelease,
+  createGitTag,
+  getGitHubRepo,
+  runTests
+} from "./impl/release.js";

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@reliverse/publish",
-  "version": "2.2.8",
+  "version": "2.3.1",
   "private": false,
+  "license": "MIT",
+  "files": [
+    "dist",
+    "package.json"
+  ],
   "type": "module",
   "exports": {
     ".": {
@@ -9,21 +14,17 @@
       "default": "./dist/mod.js"
     }
   },
-  "dependencies": {
-    "c12": "^3.3.3",
-    "@reliverse/typerso": "2.2.8",
-    "@reliverse/config": "2.2.8",
-    "@reliverse/relinka": "2.2.8",
-    "@reliverse/bump": "2.2.9",
-    "@reliverse/relico": "2.2.8",
-    "@reliverse/build": "2.2.8"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "license": "MIT"
+  "dependencies": {
+    "@reliverse/build": "2.3.1",
+    "@reliverse/bump": "2.3.1",
+    "@reliverse/config": "2.3.1",
+    "@reliverse/relico": "2.3.1",
+    "@reliverse/relinka": "2.3.1",
+    "@reliverse/typerso": "2.3.1",
+    "c12": "^3.3.3",
+    "dotenv": "^17.2.3"
+  }
 }