versionary 0.31.0 → 1.0.0

package/dist/release/release.d.ts

@@ -30,11 +30,3 @@ export interface RunReleaseOptions {
     "dry-run"?: boolean;
 }
 export declare function runReleaseDetailed(cwd?: string, options?: RunReleaseOptions): Promise<RunReleaseResult>;
-/** @deprecated Use RunReleaseResult. */
-export type SimpleRunReleaseResult = RunReleaseResult;
-/** @deprecated Use RunReleaseOptions. */
-export type RunSimpleReleaseOptions = RunReleaseOptions;
-/** @deprecated Use runRelease. */
-export declare function runSimpleRelease(cwd?: string): Promise<string>;
-/** @deprecated Use runReleaseDetailed. */
-export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;

package/dist/release/release.js

@@ -224,11 +224,3 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
         message: `Published releases ${published.join(", ")}`,
     };
 }
-/** @deprecated Use runRelease. */
-export async function runSimpleRelease(cwd = process.cwd()) {
-    return runRelease(cwd);
-}
-/** @deprecated Use runReleaseDetailed. */
-export async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
-    return runReleaseDetailed(cwd, options);
-}

package/dist/release/state.js

@@ -49,15 +49,7 @@ export function getBaselineStatePath(cwd) {
     if (configured) {
         return path.join(cwd, configured);
     }
-    const preferred = path.join(cwd, ".versionary-manifest.json");
-    if (fs.existsSync(preferred)) {
-        return preferred;
-    }
-    const legacy = path.join(cwd, "versionary.versions.json");
-    if (fs.existsSync(legacy)) {
-        return legacy;
-    }
-    return preferred;
+    return path.join(cwd, ".versionary-manifest.json");
 }
 export function readBaselineSha(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
@@ -80,15 +72,14 @@ export function readReleaseTargets(cwd = process.cwd()) {
 }
 // The publish set introduced by the current release PR. `release` consumes this
 // so it only publishes/announces what this PR bumped, not every package in the
-// accumulated baseline. Falls back to the accumulated targets for manifests
-// written before this key existed (legacy compatibility).
+// accumulated baseline.
 export function readPendingReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
     if (!fs.existsSync(filePath)) {
         return [];
     }
     const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
-    return (parsed[PENDING_RELEASE_TARGETS_KEY] ?? parsed[RELEASE_TARGETS_KEY] ?? []);
+    return parsed[PENDING_RELEASE_TARGETS_KEY] ?? [];
 }
 export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??

package/dist/strategy/composite.js

@@ -71,6 +71,17 @@ export function compositeVersionStrategy(strategies) {
             return primary.readPackageName?.(cwd, config) ?? null;
         };
     }
+    if (primary.isPublishable || secondaries.some((s) => s.isPublishable)) {
+        composite.isPublishable = (cwd, pkg) => {
+            // Only strategies that recognize this package's version file have an
+            // opinion; among those, one publishing facet is enough to expose the
+            // package on a registry.
+            const opinions = [primary, ...secondaries]
+                .map((strategy) => strategy.isPublishable?.(cwd, pkg))
+                .filter((opinion) => typeof opinion === "boolean");
+            return opinions.length === 0 ? undefined : opinions.some(Boolean);
+        };
+    }
     if (primary.propagateDependentPatchImpacts ||
         secondaries.some((strategy) => strategy.propagateDependentPatchImpacts)) {
         composite.propagateDependentPatchImpacts = (cwd, packages) => {

package/dist/strategy/node.js

@@ -71,4 +71,19 @@ export const nodeVersionStrategy = {
         }
         return name.trim();
     },
+    isPublishable(cwd, pkg) {
+        if (path.basename(pkg.versionFile) !== "package.json") {
+            return undefined;
+        }
+        const versionPath = path.join(cwd, pkg.versionFile);
+        if (!fs.existsSync(versionPath)) {
+            return true;
+        }
+        try {
+            return readJsonFile(versionPath).private !== true;
+        }
+        catch {
+            return true;
+        }
+    },
 };

package/dist/strategy/rust.js

@@ -253,13 +253,53 @@ function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
         : `"${versionFile}" has neither [package] nor [workspace].`;
     throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. ${detail} Either remove the "packages" config so the workspace is auto-discovered, or point a package at a member crate path (e.g. "packages": { "crates/foo": {} }).`);
 }
-function isWorkspaceInheritedVersion(rawVersion) {
+function isWorkspaceInheritedValue(rawVersion) {
     if (!rawVersion || typeof rawVersion !== "object") {
         return false;
     }
     const versionRecord = rawVersion;
     return versionRecord.workspace === true;
 }
+function isPublishValueUnpublishable(rawPublish) {
+    // Cargo treats both `publish = false` and an empty registry list as
+    // "never publish"; a non-empty list still reaches a registry.
+    return (rawPublish === false ||
+        (Array.isArray(rawPublish) && rawPublish.length === 0));
+}
+function readManifestPublishable(cwd, manifest) {
+    const manifestPath = path.join(cwd, manifest);
+    if (!fs.existsSync(manifestPath)) {
+        return true;
+    }
+    const cargoTomlRaw = fs.readFileSync(manifestPath, "utf8");
+    let packageTable;
+    try {
+        ({ packageTable } = parseCargoManifest(manifest, cargoTomlRaw));
+    }
+    catch {
+        return true;
+    }
+    if (!packageTable) {
+        return true;
+    }
+    const rawPublish = packageTable.publish;
+    if (!isWorkspaceInheritedValue(rawPublish)) {
+        return !isPublishValueUnpublishable(rawPublish);
+    }
+    let workspaceManifest;
+    try {
+        workspaceManifest = findWorkspaceManifestForMember(cwd, manifest);
+    }
+    catch {
+        return true;
+    }
+    const workspaceRaw = fs.readFileSync(path.join(cwd, workspaceManifest), "utf8");
+    const { workspaceTable } = parseCargoManifest(workspaceManifest, workspaceRaw);
+    const workspacePackage = workspaceTable?.package && typeof workspaceTable.package === "object"
+        ? workspaceTable.package
+        : null;
+    return !isPublishValueUnpublishable(workspacePackage?.publish);
+}
 function readWorkspacePackageVersion(cargoTomlRaw, versionFile) {
     const { workspaceTable } = parseCargoManifest(versionFile, cargoTomlRaw);
     if (!workspaceTable || typeof workspaceTable !== "object") {
@@ -314,7 +354,7 @@ function readResolvedCargoVersion(cwd, manifest, cargoTomlRaw) {
     if (typeof rawVersion === "string" && rawVersion.trim().length > 0) {
         return rawVersion.trim();
     }
-    if (!isWorkspaceInheritedVersion(rawVersion)) {
+    if (!isWorkspaceInheritedValue(rawVersion)) {
         throw new Error(`${manifest} has invalid [package].version. Expected a non-empty SemVer string or version.workspace = true.`);
     }
     const workspaceManifest = findWorkspaceManifestForMember(cwd, manifest);
@@ -425,7 +465,7 @@ function usesWorkspaceInheritedVersion(cargoTomlRaw, versionFile) {
         return false;
     }
     const rawVersion = packageTable.version;
-    return isWorkspaceInheritedVersion(rawVersion);
+    return isWorkspaceInheritedValue(rawVersion);
 }
 function isDependencySection(section) {
     if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
@@ -733,6 +773,13 @@ export const rustVersionStrategy = {
         }
         return readCargoPackageName(cargoTomlRaw, selectedManifest);
     },
+    isPublishable(cwd, pkg) {
+        const manifest = normalizeSlashPath(pkg.versionFile);
+        if (path.posix.basename(manifest) !== "Cargo.toml") {
+            return undefined;
+        }
+        return readManifestPublishable(cwd, manifest);
+    },
     propagateDependentPatchImpacts(cwd, packages) {
         const manifestToVersion = {};
         const candidateManifests = [];

package/dist/strategy/types.d.ts

@@ -22,6 +22,17 @@ export interface VersionStrategy {
     writeVersion(cwd: string, config: VersionaryConfig, version: string): string[];
     validateProject?(cwd: string, config: VersionaryConfig): string | null;
     readPackageName?(cwd: string, config: VersionaryConfig): string | null;
+    /**
+     * Whether this package is published to a registry. A package that never
+     * reaches a registry cannot leave a stale published copy behind, so release
+     * planning exempts it from published-dependency freshness enforcement.
+     *
+     * Returns `undefined` to abstain, which a strategy must do for a version
+     * file it does not recognize — otherwise, composed with another strategy, it
+     * would outvote the one that actually owns the manifest. Strategies that
+     * omit this hook entirely are assumed to publish everything.
+     */
+    isPublishable?(cwd: string, pkg: StrategyPackagePlanContext): boolean | undefined;
     propagateDependentPatchImpacts?(cwd: string, packages: StrategyPackagePlanContext[]): string[];
     finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[], context: StrategyFinalizeContext): string[];
 }

package/dist/types/config.d.ts

@@ -5,8 +5,8 @@ export interface VersionaryArtifactRule {
     type: "json" | "toml" | "yaml" | "nix" | "regex";
     path: string;
     "field-path"?: string;
-    jsonpath?: string;
     pattern?: string;
+    replacement?: string;
 }
 export interface VersionaryPackage {
     "release-type"?: string | string[];
@@ -20,7 +20,7 @@ export interface VersionaryPackage {
 }
 export interface VersionaryConfig {
     version: 1;
-    "review-mode"?: "direct" | "pr" | "review";
+    "review-mode"?: "direct" | "pr";
     "version-file"?: string;
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
@@ -28,7 +28,6 @@ export interface VersionaryConfig {
     "release-reference-comments"?: ReleaseReferenceCommentsMode;
     "release-branch"?: string;
     "baseline-file"?: string;
-    "next-release-file"?: string;
     "bootstrap-sha"?: string;
     "monorepo-mode"?: "independent" | "fixed";
     "bump-minor-pre-major"?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.31.0",
+  "version": "1.0.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -27,16 +27,18 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "smol-toml": "^1.4.2",
     "@octokit/rest": "^22.0.0",
     "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.4.2",
     "yaml": "^2.8.3",
     "zod": "^4.1.12"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
+    "@types/node": "^26.0.1",
     "tsx": "^4.20.6",
-    "typescript": "^6.0.3",
+    "typescript": "^7.0.2",
+    "vite": "^8.0.0",
+    "vitepress": "^1.6.4",
     "vitest": "^4.1.4"
   },
   "scripts": {
@@ -49,6 +51,9 @@
     "plan": "tsx src/cli/index.ts plan",
     "changelog": "tsx src/cli/index.ts changelog",
     "pr": "tsx src/cli/index.ts pr",
-    "release": "tsx src/cli/index.ts release"
+    "release": "tsx src/cli/index.ts release",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
   }
 }