versionary 1.0.1 → 1.1.0

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,

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<{