@git.zone/cli 4.0.0 → 5.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@git.zone/cli",
   "private": false,
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",

package/readme.md

@@ -133,23 +133,28 @@ Commit flags:
 
 ## Release Workflow
 
-`gitzone release` performs the release core once, then publishes to configured targets.
+`gitzone release` releases from `main`. Running it on another branch fails before release metadata or ref mutation unless the bare `--merge` flag is explicitly supplied.
+
+`--merge` is intentionally strict: the source and existing `main` worktree must be clean, the source must be linearly rebased onto current remote `main`, and the Git target must push both the branch and tag. GitZone pins the single configured push URL, compare-and-swap fast-forwards local `main`, updates its verified worktree, and lease-pushes that exact source commit before creating release metadata. It rejects diverged or merged history, local replacement refs or grafts, stale worktrees, incomplete shallow history, changed destinations, and remote races. If the pre-release push fails, GitZone restores local `main` only when doing so cannot overwrite concurrent work. This plumbing-level integration intentionally does not run merge hooks or write `ORIG_HEAD`.
+
+`gitzone release` performs the release core once, then publishes to configured targets. An active Git target must succeed before npm or Docker publication can start.
 
 The release core is not configurable plumbing. It always follows the same professional release transaction:
 
-1. Run configured preflight checks.
-2. Read `changelog.md` `## Pending` entries.
-3. Infer or accept a semver bump.
-4. Update version files and baked commit info.
-5. Move pending changelog entries into the new version section.
-6. Create the local release commit.
-7. Create the local release tag.
+1. Verify the release branch, clean state, and `main` worktree ownership.
+2. Read `changelog.md` `## Pending` entries and infer or accept a semver bump.
+3. Run configured tests.
+4. With `--merge`, fast-forward and lease-push `main` before release metadata is created.
+5. Update version files and baked commit info.
+6. Move pending changelog entries into the new version section.
+7. Create the local release commit and tag on `main`.
+8. Run the configured release build, require a clean tree, and revalidate the release checkout.
 
 Targets decide what happens after that:
 
 | Target | What it does |
 | --- | --- |
-| `git` | Pushes the release commit and tags, often triggering remote CI release builds |
+| `git` | Atomically pushes the exact `main` release commit and new tag, often triggering remote CI release builds |
 | `npm` | Publishes the package to configured npm registries |
 | `docker` | Delegates container builds and pushes to `tsdocker` |
 
@@ -160,6 +165,9 @@ gitzone release --plan
 # Release to configured targets
 gitzone release
 
+# From a clean feature branch already rebased onto current main
+gitzone release --merge
+
 # Release only to npm
 gitzone release --target npm
 
@@ -179,15 +187,16 @@ Release flags:
 | --- | --- |
 | `-y`, `--yes` | Run without interactive confirmation |
 | `-t`, `--test` | Enable preflight tests |
-| `-b`, `--build` | Enable preflight build |
+| `-b`, `--build` | Enable the release build after local release metadata is created |
 | `-p`, `--push` | Enable the `git` target |
 | `--target <csv>` | Use only selected targets, e.g. `git,npm` |
 | `--npm` | Enable the `npm` target |
 | `--docker` | Enable the `docker` target |
 | `--no-publish` | Keep release core and `git` target only |
-| `--no-build` | Disable preflight build for this run |
+| `--no-build` | Disable the post-metadata release build for this run |
+| `--merge` | Fast-forward and lease-push a cleanly rebased feature branch into `main`, then release from `main` |
 | `--major`, `--minor`, `--patch` | Override inferred semver level |
-| `--plan` | Show resolved workflow only |
+| `--plan` | Show the resolved workflow without fetching or mutating refs, files, the index, or worktrees |
 
 ## Standard Changelog
 
@@ -223,7 +232,6 @@ CLI workflow config lives under `@git.zone/cli` in `.smartconfig.json`. Docker b
     "release": {
       "confirmation": "prompt",
       "preflight": {
-        "requireCleanTree": true,
         "test": false,
         "build": true
       },

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '4.0.0',
+  version: '5.0.0',
   description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

package/ts/helpers.workflow.ts

@@ -70,7 +70,6 @@ export interface IReleaseWorkflowConfig {
     source?: "pendingChangelog" | "manual";
   };
   preflight?: {
-    requireCleanTree?: boolean;
     test?: boolean;
     build?: boolean;
     testCommand?: string;
@@ -101,7 +100,6 @@ export interface IResolvedReleaseWorkflow {
   confirmation: TConfirmationMode;
   plan: string[];
   targets: TReleaseTarget[];
-  requireCleanTree: boolean;
   runTests: boolean;
   runBuild: boolean;
   testCommand: string;
@@ -202,6 +200,22 @@ export const resolveDockerTestSetting = (valueArg: unknown): boolean => {
   return valueArg;
 };
 
+const resolveGitPushSetting = (
+  valueArg: unknown,
+  settingArg: "pushBranch" | "pushTags",
+  gitEnabledArg: boolean,
+): boolean => {
+  if (!gitEnabledArg) {
+    return valueArg === undefined ? true : valueArg === true;
+  }
+  if (valueArg !== undefined && valueArg !== true) {
+    throw new Error(
+      `release.targets.git.${settingArg} must be true when the Git target is enabled`,
+    );
+  }
+  return true;
+};
+
 const isStringRecord = (valueArg: unknown): valueArg is Record<string, unknown> => {
   return typeof valueArg === "object" && valueArg !== null && !Array.isArray(valueArg);
 };
@@ -340,15 +354,19 @@ const getTargetOverride = (argvArg: any): TReleaseTarget[] | undefined => {
   return targets.length > 0 ? targets : undefined;
 };
 
+const releaseTargetOrder: TReleaseTarget[] = ["git", "npm", "docker"];
+
 const buildReleasePlan = (options: {
-  requireCleanTree: boolean;
+  mergeRequested: boolean;
   runTests: boolean;
   runBuild: boolean;
   targets: TReleaseTarget[];
 }): string[] => {
-  const plan: string[] = [];
-  if (options.requireCleanTree) plan.push("preflight.cleanTree");
+  const plan: string[] = ["preflight.branch", "preflight.cleanTree"];
   if (options.runTests) plan.push("preflight.test");
+  if (options.mergeRequested) {
+    plan.push("integration.main", "integration.pushMain");
+  }
   plan.push("core.version", "core.changelog", "core.commit", "core.tag");
   if (options.runBuild) plan.push("core.build");
   for (const target of options.targets) {
@@ -421,6 +439,16 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
   const npmEnabled = npmConfig.enabled ?? npmRegistries.length > 0;
   const gitEnabled = gitConfig.enabled ?? true;
   const dockerEnabled = dockerConfig.enabled ?? false;
+  const pushBranch = resolveGitPushSetting(
+    gitConfig.pushBranch,
+    "pushBranch",
+    gitEnabled,
+  );
+  const pushTags = resolveGitPushSetting(
+    gitConfig.pushTags,
+    "pushTags",
+    gitEnabled,
+  );
 
   let confirmation = normalizeConfirmation(releaseConfig.confirmation, "prompt");
   if (argvArg.plan) {
@@ -429,14 +457,12 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
     confirmation = "auto";
   }
 
-  let requireCleanTree = releaseConfig.preflight?.requireCleanTree ?? true;
   let runTests = releaseConfig.preflight?.test ?? false;
   let runBuild = releaseConfig.preflight?.build ?? true;
   if (argvArg.t || argvArg.test) runTests = true;
   if (argvArg.b || argvArg.build) runBuild = true;
   if (isDisabled(argvArg, "test")) runTests = false;
   if (isDisabled(argvArg, "build")) runBuild = false;
-  if (isDisabled(argvArg, "preflight")) requireCleanTree = false;
 
   const configuredTargets: TReleaseTarget[] = [];
   if (gitEnabled) configuredTargets.push("git");
@@ -449,13 +475,16 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
   if (isDisabled(argvArg, "publish")) {
     targets = targets.filter((target) => target === "git");
   }
-  targets = unique(targets);
+  const selectedTargets = unique(targets);
+  targets = releaseTargetOrder.filter((target) =>
+    selectedTargets.includes(target),
+  );
+  const mergeRequested = argvArg.merge === true;
 
   return {
     confirmation,
-    plan: buildReleasePlan({ requireCleanTree, runTests, runBuild, targets }),
+    plan: buildReleasePlan({ mergeRequested, runTests, runBuild, targets }),
     targets,
-    requireCleanTree,
     runTests,
     runBuild,
     testCommand: releaseConfig.preflight?.testCommand || "pnpm test",
@@ -465,8 +494,8 @@ export const resolveReleaseWorkflow = async (argvArg: any): Promise<IResolvedRel
     changelogVersionHeading: "## {{date}} - {{version}}",
     gitEnabled,
     gitRemote: gitConfig.remote || "origin",
-    pushBranch: gitConfig.pushBranch ?? true,
-    pushTags: gitConfig.pushTags ?? true,
+    pushBranch,
+    pushTags,
     npmEnabled,
     npmRegistries,
     npmAccessLevel: npmConfig.accessLevel || "public",

package/ts/mod_commit/mod.helpers.ts

@@ -37,9 +37,9 @@ export async function detectCurrentBranch(): Promise<string> {
  * Detects the project type based on presence of package.json and/or deno.json
  * @returns The project type
  */
-export async function detectProjectType(): Promise<ProjectType> {
-  const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+export async function detectProjectType(cwdArg = paths.cwd): Promise<ProjectType> {
+  const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
+  const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
 
   const hasPackageJson = await plugins.smartfs.file(packageJsonPath).exists();
   const hasDenoJson = await plugins.smartfs.file(denoJsonPath).exists();
@@ -96,9 +96,12 @@ export function calculateNewVersion(currentVersion: string, versionType: Version
  * @param projectType The project type to determine which file to read
  * @returns The current version string
  */
-export async function readCurrentVersion(projectType: ProjectType): Promise<string> {
+export async function readCurrentVersion(
+  projectType: ProjectType,
+  cwdArg = paths.cwd,
+): Promise<string> {
   if (projectType === 'npm' || projectType === 'both') {
-    const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+    const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
     const content = (await plugins.smartfs
       .file(packageJsonPath)
       .encoding('utf8')
@@ -110,7 +113,7 @@ export async function readCurrentVersion(projectType: ProjectType): Promise<stri
     }
     return packageJson.version;
   } else {
-    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
     const content = (await plugins.smartfs
       .file(denoJsonPath)
       .encoding('utf8')
@@ -148,10 +151,11 @@ export async function updateVersionFile(filePath: string, newVersion: string): P
 export async function updateProjectVersionFiles(
   projectType: ProjectType,
   newVersion: string,
+  cwdArg = paths.cwd,
 ): Promise<string[]> {
   const filesToUpdate: string[] = [];
-  const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+  const packageJsonPath = plugins.path.join(cwdArg, 'package.json');
+  const denoJsonPath = plugins.path.join(cwdArg, 'deno.json');
 
   if (projectType === 'npm' || projectType === 'both') {
     await updateVersionFile(packageJsonPath, newVersion);

package/ts/mod_config/index.ts

@@ -293,7 +293,7 @@ async function handleShow(mode: ICliMode): Promise<void> {
   const targets = release.targets || {};
   printConfigSection("Release Workflow", [
     ["confirmation", formatValue(release.confirmation)],
-    ["require clean tree", formatValue(release.preflight?.requireCleanTree)],
+    ["clean tree", "required"],
     ["run tests", formatValue(release.preflight?.test)],
     ["run build", formatValue(release.preflight?.build)],
     ["test command", formatValue(release.preflight?.testCommand)],
@@ -773,12 +773,6 @@ async function handleRelease(mode: ICliMode): Promise<void> {
     choices: ["prompt", "auto", "plan"],
     default: currentRelease.confirmation || "prompt",
   });
-  const requireCleanTree = await askValue<boolean>(interactInstance, {
-    type: "confirm",
-    name: "requireCleanTree",
-    message: "Require a clean git tree before release?",
-    default: currentRelease.preflight?.requireCleanTree ?? true,
-  });
   const runTests = await askValue<boolean>(interactInstance, {
     type: "confirm",
     name: "runTests",
@@ -828,18 +822,8 @@ async function handleRelease(mode: ICliMode): Promise<void> {
         message: "Git remote:",
         default: currentTargets.git?.remote || "origin",
       }),
-      pushBranch: await askValue<boolean>(interactInstance, {
-        type: "confirm",
-        name: "pushBranch",
-        message: "Push release commit branch?",
-        default: currentTargets.git?.pushBranch ?? true,
-      }),
-      pushTags: await askValue<boolean>(interactInstance, {
-        type: "confirm",
-        name: "pushTags",
-        message: "Push release tags?",
-        default: currentTargets.git?.pushTags ?? true,
-      }),
+      pushBranch: true,
+      pushTags: true,
     };
   } else {
     releaseTargets.git = { ...(currentTargets.git || {}), enabled: false };
@@ -947,12 +931,13 @@ async function handleRelease(mode: ICliMode): Promise<void> {
   }
 
   setCliConfigValueInData(smartconfigData, "schemaVersion", CURRENT_GITZONE_CLI_SCHEMA_VERSION);
+  const currentPreflight = { ...(currentRelease.preflight || {}) };
+  delete currentPreflight.requireCleanTree;
   setCliConfigValueInData(smartconfigData, "release", {
     ...currentRelease,
     confirmation,
     preflight: {
-      ...(currentRelease.preflight || {}),
-      requireCleanTree,
+      ...currentPreflight,
       test: runTests,
       build: runBuild,
       testCommand: testCommand.trim(),
@@ -1704,7 +1689,7 @@ async function validateReleaseConfig(
   if (preflight.build === true && preflight.buildCommand === "") {
     findings.push({
       level: "warn",
-      message: "Release build preflight has an empty command",
+      message: "Release build has an empty command",
       fix: "Set release.preflight.buildCommand or unset it to use pnpm build.",
     });
   }
@@ -1816,6 +1801,20 @@ async function validateGitTarget(
     });
     return;
   }
+  if (gitTarget.pushBranch !== undefined && gitTarget.pushBranch !== true) {
+    findings.push({
+      level: "error",
+      message: "Enabled Git release targets must push main",
+      fix: "Set release.targets.git.pushBranch to true or disable the Git target.",
+    });
+  }
+  if (gitTarget.pushTags !== undefined && gitTarget.pushTags !== true) {
+    findings.push({
+      level: "error",
+      message: "Enabled Git release targets must push release tags",
+      fix: "Set release.targets.git.pushTags to true or disable the Git target.",
+    });
+  }
   findings.push({
     level: "ok",
     message: `Git release target is enabled (${gitTarget.remote || "origin"})`,