versionary 1.0.0 → 1.1.0

package/dist/release/cohorts.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+function normalizedCohorts(cohorts) {
+    return cohorts
+        .map((cohort) => [...new Set(cohort)].sort((a, b) => a.localeCompare(b)))
+        .filter((cohort) => cohort.length > 0)
+        .sort((a, b) => (a[0] ?? "").localeCompare(b[0] ?? ""));
+}
+export function buildInitialReleaseCohorts(plan) {
+    const releasing = (plan.packages ?? [])
+        .filter((pkg) => pkg.nextVersion)
+        .map((pkg) => pkg.path)
+        .sort((a, b) => a.localeCompare(b));
+    const releasingSet = new Set(releasing);
+    const parent = new Map(releasing.map((packagePath) => [packagePath, packagePath]));
+    const find = (packagePath) => {
+        const current = parent.get(packagePath) ?? packagePath;
+        if (current === packagePath) {
+            return current;
+        }
+        const root = find(current);
+        parent.set(packagePath, root);
+        return root;
+    };
+    const union = (left, right) => {
+        const leftRoot = find(left);
+        const rightRoot = find(right);
+        if (leftRoot === rightRoot) {
+            return;
+        }
+        const [first, second] = [leftRoot, rightRoot].sort((a, b) => a.localeCompare(b));
+        if (first && second) {
+            parent.set(second, first);
+        }
+    };
+    for (const pkg of plan.packages ?? []) {
+        if (!pkg.nextVersion || !releasingSet.has(pkg.path)) {
+            continue;
+        }
+        for (const sourcePath of pkg.dependencySourcePaths ?? []) {
+            if (releasingSet.has(sourcePath)) {
+                union(pkg.path, sourcePath);
+            }
+        }
+    }
+    const grouped = new Map();
+    for (const packagePath of releasing) {
+        const root = find(packagePath);
+        grouped.set(root, [...(grouped.get(root) ?? []), packagePath]);
+    }
+    return normalizedCohorts([...grouped.values()]);
+}
+function overlaps(left, right) {
+    for (const value of left) {
+        if (right.has(value)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function stabilizeReleaseCohorts(initial, changedFilesFor) {
+    let cohorts = normalizedCohorts(initial);
+    while (cohorts.length > 1) {
+        const footprints = cohorts.map((cohort) => new Set(changedFilesFor(cohort).map((file) => file.replaceAll("\\", "/"))));
+        const parent = cohorts.map((_, index) => index);
+        const find = (index) => {
+            const current = parent[index] ?? index;
+            if (current === index) {
+                return current;
+            }
+            const root = find(current);
+            parent[index] = root;
+            return root;
+        };
+        const union = (left, right) => {
+            const leftRoot = find(left);
+            const rightRoot = find(right);
+            if (leftRoot !== rightRoot) {
+                parent[Math.max(leftRoot, rightRoot)] = Math.min(leftRoot, rightRoot);
+            }
+        };
+        for (let left = 0; left < cohorts.length; left += 1) {
+            for (let right = left + 1; right < cohorts.length; right += 1) {
+                if (overlaps(footprints[left] ?? new Set(), footprints[right] ?? new Set())) {
+                    union(left, right);
+                }
+            }
+        }
+        const merged = new Map();
+        for (let index = 0; index < cohorts.length; index += 1) {
+            const root = find(index);
+            merged.set(root, [
+                ...(merged.get(root) ?? []),
+                ...(cohorts[index] ?? []),
+            ]);
+        }
+        const next = normalizedCohorts([...merged.values()]);
+        if (next.length === cohorts.length) {
+            return cohorts;
+        }
+        cohorts = next;
+    }
+    return cohorts;
+}
+// The prefix shared by every separate release branch. It is the configured
+// release branch itself, so listing on it also matches the legacy single
+// release branch left behind by repos migrating from the combined PR flow.
+export function resolveSeparateReleaseBranchPrefix(prefix) {
+    return prefix.replace(/\/+$/gu, "");
+}
+export function resolveSeparateReleaseBranch(prefix, releaseName, packagePath) {
+    const normalizedPrefix = resolveSeparateReleaseBranchPrefix(prefix);
+    const slug = releaseName
+        .trim()
+        .replace(/^@/u, "")
+        .replace(/[^A-Za-z0-9._-]+/gu, "-")
+        .replace(/^-+|-+$/gu, "") || "package";
+    const digest = createHash("sha256")
+        .update(packagePath)
+        .digest("hex")
+        .slice(0, 12);
+    // A sibling of the legacy release branch, not a child of it: git cannot hold
+    // both `refs/heads/<prefix>` and `refs/heads/<prefix>/<name>`, and repos
+    // migrating from the combined PR flow still have the former on the remote.
+    return `${normalizedPrefix}-${slug}-${digest}`;
+}

package/dist/release/plan.d.ts

@@ -34,6 +34,28 @@ export declare function getChangelogDefaults(config: {
     changelogFormat: VersionaryChangelogFormat;
 };
 export declare function createReleasePlan(cwd?: string): ReleasePlan;
+/**
+ * The root package's own release, as distinct from the plan-level aggregate.
+ *
+ * `plan.releaseType`/`plan.nextVersion`/`plan.commits` describe the repository
+ * as a whole: the aggregate release type folds in every package's commits and
+ * is then applied to root's version number. That answers "is anything
+ * releasing, and how large is the biggest change anywhere" — not "what is root
+ * releasing". A sibling's `feat` therefore lifts the aggregate to a minor even
+ * when root's own `exclude-paths` drop that commit, so anything that names or
+ * describes root's release must go through here instead. Using the aggregate
+ * would report a version no version file carries and list commits root
+ * deliberately excluded.
+ *
+ * Falls back to the aggregate when the plan has no explicit root package: the
+ * top-level changelog is then a repository-wide summary with no package of its
+ * own to describe.
+ */
+export declare function resolveRootReleaseView(plan: ReleasePlan): {
+    currentVersion: string;
+    nextVersion: string | null;
+    commits: ParsedCommit[];
+};
 export declare function resolvePackageDependencies(plan: ReleasePlan, packagePath: string): Array<{
     name: string;
     version: string;

package/dist/release/plan.js

@@ -259,6 +259,50 @@ export function createReleasePlan(cwd = process.cwd()) {
         }
         return reachable;
     };
+    const withReleasingDependencies = (plans) => {
+        const releasingPaths = new Set(plans
+            .filter((pkgPlan) => pkgPlan.nextVersion)
+            .map((pkgPlan) => pkgPlan.path));
+        for (const pkgPlan of plans) {
+            const strategyContext = strategyContextByPath.get(pkgPlan.path);
+            if (strategyContext) {
+                strategyContext.nextVersion = pkgPlan.nextVersion;
+            }
+        }
+        const dependencySourcePathsByPackage = new Map();
+        for (const sourcePackage of plans) {
+            if (!sourcePackage.nextVersion) {
+                continue;
+            }
+            for (const impactedPath of findDependents(sourcePackage.path)) {
+                if (impactedPath === sourcePackage.path) {
+                    continue;
+                }
+                const existing = dependencySourcePathsByPackage.get(impactedPath);
+                if (existing) {
+                    existing.add(sourcePackage.path);
+                }
+                else {
+                    dependencySourcePathsByPackage.set(impactedPath, new Set([sourcePackage.path]));
+                }
+            }
+        }
+        return plans.map((pkgPlan) => {
+            const dependencySourcePaths = [
+                ...(dependencySourcePathsByPackage.get(pkgPlan.path) ??
+                    new Set()),
+            ]
+                .filter((sourcePath) => releasingPaths.has(sourcePath))
+                .sort((a, b) => a.localeCompare(b));
+            if (dependencySourcePaths.length === 0) {
+                return pkgPlan;
+            }
+            return {
+                ...pkgPlan,
+                dependencySourcePaths,
+            };
+        });
+    };
     // Both rules below can enable each other: forcing a bump creates a dependent
     // whose requirement must be rewritten, and rewriting a dependent can in turn
     // expose a stale dependency a further level up. Iterating to a fixpoint
@@ -302,51 +346,9 @@ export function createReleasePlan(cwd = process.cwd()) {
             break;
         }
     }
-    const packageNextVersionByPath = {};
-    for (const pkgPlan of workingPlans) {
-        if (pkgPlan.nextVersion) {
-            packageNextVersionByPath[pkgPlan.path] = pkgPlan.nextVersion;
-        }
-    }
-    const dependencySourcePathsByPackage = new Map();
-    const addDependencySourcePath = (targetPath, sourcePath) => {
-        if (targetPath === sourcePath) {
-            return;
-        }
-        const existing = dependencySourcePathsByPackage.get(targetPath);
-        if (existing) {
-            existing.add(sourcePath);
-            return;
-        }
-        dependencySourcePathsByPackage.set(targetPath, new Set([sourcePath]));
-    };
     // Attribute each dependent's requirement rewrite to the specific sources
     // driving it, using the settled version set so chained bumps are credited.
-    for (const strategyGroup of strategyPackagesByName.values()) {
-        for (const sourcePackage of strategyGroup.packages) {
-            if (!sourcePackage.nextVersion) {
-                continue;
-            }
-            for (const impactedPath of findDependents(sourcePackage.packagePath)) {
-                addDependencySourcePath(impactedPath, sourcePackage.packagePath);
-            }
-        }
-    }
-    const propagatedPackages = workingPlans.map((pkgPlan) => {
-        const dependencySourcePaths = [
-            ...(dependencySourcePathsByPackage.get(pkgPlan.path) ??
-                new Set()),
-        ]
-            .filter((sourcePath) => Boolean(packageNextVersionByPath[sourcePath]))
-            .sort((a, b) => a.localeCompare(b));
-        if (dependencySourcePaths.length === 0) {
-            return pkgPlan;
-        }
-        return {
-            ...pkgPlan,
-            dependencySourcePaths,
-        };
-    });
+    const propagatedPackages = withReleasingDependencies(workingPlans);
     const followsByPath = new Map();
     for (const [packagePath, packageConfig] of Object.entries(loaded.config.packages ?? {})) {
         const follows = packageConfig.follows ?? [];
@@ -429,11 +431,13 @@ export function createReleasePlan(cwd = process.cwd()) {
             : analyzedFixedType
                 ? bumpVersion(fixedBaseVersion, analyzedFixedType, { allowStableMajor })
                 : null;
-        const adjusted = adjustedPackages.map((pkgPlan) => ({
+        // Fixed mode can promote unchanged dependencies into the release, so the
+        // final shared version set must drive dependency attribution.
+        const adjusted = withReleasingDependencies(adjustedPackages.map((pkgPlan) => ({
             ...pkgPlan,
             releaseType: fixedType,
             nextVersion: fixedNextVersion,
-        }));
+        })));
         return {
             mode: "simple",
             releaseType: fixedType,
@@ -480,6 +484,38 @@ export function createReleasePlan(cwd = process.cwd()) {
         packages: visiblePackages.map(({ implicitRoot: _implicitRoot, ...pkgPlan }) => pkgPlan),
     };
 }
+/**
+ * The root package's own release, as distinct from the plan-level aggregate.
+ *
+ * `plan.releaseType`/`plan.nextVersion`/`plan.commits` describe the repository
+ * as a whole: the aggregate release type folds in every package's commits and
+ * is then applied to root's version number. That answers "is anything
+ * releasing, and how large is the biggest change anywhere" — not "what is root
+ * releasing". A sibling's `feat` therefore lifts the aggregate to a minor even
+ * when root's own `exclude-paths` drop that commit, so anything that names or
+ * describes root's release must go through here instead. Using the aggregate
+ * would report a version no version file carries and list commits root
+ * deliberately excluded.
+ *
+ * Falls back to the aggregate when the plan has no explicit root package: the
+ * top-level changelog is then a repository-wide summary with no package of its
+ * own to describe.
+ */
+export function resolveRootReleaseView(plan) {
+    const rootPackage = plan.packages?.find((pkg) => pkg.path === ".");
+    if (!rootPackage) {
+        return {
+            currentVersion: plan.currentVersion,
+            nextVersion: plan.nextVersion,
+            commits: plan.commits,
+        };
+    }
+    return {
+        currentVersion: rootPackage.currentVersion,
+        nextVersion: rootPackage.nextVersion,
+        commits: rootPackage.commits,
+    };
+}
 export function resolvePackageDependencies(plan, packagePath) {
     const target = plan.packages?.find((pkg) => pkg.path === packagePath);
     if (!target) {

package/dist/release/pr.d.ts

@@ -2,6 +2,7 @@ import type { ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat, VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
 import { type ReleasePlan } from "./plan.js";
+import { type ReleaseTargetState } from "./state.js";
 /**
  * Read the manual-notes ("Unreleased") prose from the top of a changelog file.
  * Returns an empty string when the file is absent or has no notes block.
@@ -20,6 +21,31 @@ export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
 };
+export interface PendingReleasePrResult {
+    branch: string;
+    title: string;
+    updated: boolean;
+    targets: ReleaseTargetState[];
+    body: string;
+}
+export declare function renderPendingReleaseReviewRequestBody(targets: ReleaseTargetState[]): string;
+/**
+ * Recreate the release marker on the corrected base without advancing an
+ * untagged version. The empty commit is intentional: the version and
+ * changelog changes were already reviewed in the original release PR.
+ */
+export declare function preparePendingReleasePr(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+}): PendingReleasePrResult;
+/**
+ * Recreate each unpublished package cohort on its own corrected-base branch.
+ * A temporary worktree keeps the caller on the trunk commit that triggered
+ * recovery while still leaving local branch refs available for pushing.
+ */
+export declare function preparePendingSeparateReleasePrs(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+    "dry-run"?: boolean;
+}): SeparateReviewCandidate[];
 export declare function prepareReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
 }): {
@@ -32,11 +58,54 @@ export declare function prepareReleasePr(cwd?: string, options?: {
     updated: boolean;
     highlights: string;
 };
+export interface PreparedSeparateReleasePr {
+    branch: string;
+    title: string;
+    version: string;
+    previousVersion: string;
+    commits: ParsedCommit[];
+    plan: ReleasePlan;
+    updated: boolean;
+    highlights: string;
+    packagePaths: string[];
+    targets: ReleaseTargetState[];
+    body: string;
+}
+export interface SeparateReviewCandidate {
+    branch: string;
+    title: string;
+    updated: boolean;
+    packagePaths: string[];
+    targets: ReleaseTargetState[];
+    body: string;
+}
+/**
+ * Build every independently mergeable release branch from the same immutable
+ * base without moving or modifying the caller's worktree.
+ */
+export declare function prepareSeparateReleasePrs(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+    "dry-run"?: boolean;
+}): PreparedSeparateReleasePr[];
 export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: ReleasePlan | null, cwd?: string, highlights?: string, loadedConfig?: VersionaryConfig): string;
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: ReleasePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
     highlights?: string;
+    body?: string;
 }): Promise<string>;
+export interface ReviewRequestRunResult {
+    packagePaths: string[];
+    branch: string;
+    title: string;
+    reviewUrl?: string;
+    status: "prepared" | "up-to-date" | "dry-run" | "recovered";
+    targets: ReleaseTargetState[];
+}
+export declare function reconcileSeparateReviewRequests(cwd: string, prepared: SeparateReviewCandidate[], options?: {
+    logger?: VersionaryPluginContext["logger"];
+    "dry-run"?: boolean;
+    recovered?: boolean;
+}): Promise<ReviewRequestRunResult[]>;
 export declare function closeStaleReviewRequestIfExists(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
 }): Promise<{