versionary 0.4.0 → 0.5.0

package/dist/app/release/pr.js

@@ -14,7 +14,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../../config/load-config.js");
 const changelog_js_1 = require("../../domain/release/changelog.js");
 const plan_js_1 = require("../../domain/release/plan.js");
+const package_context_js_1 = require("../../domain/strategy/package-context.js");
 const resolve_js_1 = require("../../domain/strategy/resolve.js");
+const rust_js_1 = require("../../domain/strategy/rust.js");
 const capabilities_js_1 = require("../../plugins/capabilities.js");
 const runtime_js_1 = require("../../plugins/runtime.js");
 const artifact_rules_js_1 = require("./artifact-rules.js");
@@ -74,7 +76,27 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         throw new Error("No releasable commits found. Nothing to open a release PR for.");
     }
     ensureCleanWorktree(cwd, options.logger);
-    const updatedVersionFiles = strategy.writeVersion(cwd, loaded.config, plan.nextVersion);
+    const updatedVersionFiles = [];
+    const rustManifestVersionTargets = {};
+    if (plan.packages && plan.packages.length > 0) {
+        for (const packagePlan of plan.packages) {
+            if (!packagePlan.nextVersion) {
+                continue;
+            }
+            const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+            const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
+            const packageUpdated = packageContext.strategy.writeVersion(cwd, packageContext.config, packagePlan.nextVersion);
+            updatedVersionFiles.push(...packageUpdated);
+            if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
+                rustManifestVersionTargets[packageContext.versionFile] =
+                    packagePlan.nextVersion;
+            }
+        }
+        updatedVersionFiles.push(...(0, rust_js_1.applyRustWorkspaceDependencyUpdates)(cwd, rustManifestVersionTargets));
+    }
+    else {
+        updatedVersionFiles.push(...strategy.writeVersion(cwd, loaded.config, plan.nextVersion));
+    }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);

package/dist/domain/release/plan.js

@@ -9,7 +9,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const state_js_1 = require("../../app/release/state.js");
 const load_config_js_1 = require("../../config/load-config.js");
 const commits_js_1 = require("../../infra/git/commits.js");
+const package_context_js_1 = require("../strategy/package-context.js");
 const resolve_js_1 = require("../strategy/resolve.js");
+const rust_js_1 = require("../strategy/rust.js");
 const semver_js_1 = require("./semver.js");
 function getMode(configMode) {
     return configMode ?? "independent";
@@ -21,11 +23,6 @@ function createSimplePlan(cwd = process.cwd()) {
     const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
     const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
     const baselineSha = (0, state_js_1.readBaselineSha)(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
-    const versionPath = node_path_1.default.join(cwd, versionFile);
-    if (!node_fs_1.default.existsSync(versionPath)) {
-        throw new Error(`Versionary requires ${versionFile} to exist.`);
-    }
-    const currentVersion = strategy.readVersion(cwd, loaded.config);
     const allowStableMajor = loaded.config["allow-stable-major"] ?? false;
     const configuredPackages = Object.entries(loaded.config.packages ?? {}).map(([pkgPath, cfg]) => ({
         path: pkgPath,
@@ -34,6 +31,11 @@ function createSimplePlan(cwd = process.cwd()) {
     const monorepoMode = getMode(loaded.config["monorepo-mode"]);
     const hasPackages = configuredPackages.length > 0;
     if (!hasPackages) {
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const currentVersion = strategy.readVersion(cwd, loaded.config);
         const parsedCommits = (0, commits_js_1.getParsedCommitsSinceLastTag)(cwd, baselineSha);
         const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
         const commits = effectiveCommits;
@@ -55,29 +57,70 @@ function createSimplePlan(cwd = process.cwd()) {
     }
     const packagePlans = configuredPackages
         .map((pkg) => {
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, pkg.path, pkg);
+        const packageCurrentVersion = packageContext.strategy.readVersion(cwd, packageContext.config);
         const parsedCommits = (0, commits_js_1.getParsedCommitsForPath)(cwd, baselineSha, pkg.path, pkg["exclude-paths"] ?? []);
         const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
         const commits = effectiveCommits;
         const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
         const nextVersion = releaseType
-            ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType, { allowStableMajor })
+            ? (0, semver_js_1.bumpVersion)(packageCurrentVersion, releaseType, { allowStableMajor })
             : null;
         return {
             path: pkg.path,
             releaseType,
-            currentVersion,
+            currentVersion: packageCurrentVersion,
             nextVersion,
             commits,
             parsedCommits,
         };
     })
         .sort((a, b) => a.path.localeCompare(b.path));
+    const rustManifestVersionTargets = {};
+    const rustPackageManifestByPath = {};
+    const packageCurrentVersionByPath = {};
+    for (const packagePlan of packagePlans) {
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
+        if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
+            rustPackageManifestByPath[packagePlan.path] = (0, rust_js_1.toCargoManifestPath)(packagePlan.path);
+        }
+        packageCurrentVersionByPath[packagePlan.path] = packagePlan.currentVersion;
+        if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
+            const next = packagePlan.nextVersion;
+            if (next) {
+                rustManifestVersionTargets[packageContext.versionFile] = next;
+            }
+        }
+    }
+    const impactedRustManifests = (0, rust_js_1.detectRustDependencyImpact)(cwd, rustManifestVersionTargets, Object.values(rustPackageManifestByPath));
+    const impactedPaths = new Set();
+    for (const [pkgPath, manifest] of Object.entries(rustPackageManifestByPath)) {
+        if (impactedRustManifests.includes(manifest)) {
+            impactedPaths.add(pkgPath);
+        }
+    }
+    const adjustedPackages = packagePlans.map((pkgPlan) => {
+        if (pkgPlan.nextVersion || !impactedPaths.has(pkgPlan.path)) {
+            return pkgPlan;
+        }
+        const current = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
+        return {
+            ...pkgPlan,
+            releaseType: "patch",
+            nextVersion: (0, semver_js_1.bumpVersion)(current, "patch", { allowStableMajor }),
+        };
+    });
     if (monorepoMode === "fixed") {
-        const fixedType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+        const fixedType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+        const fixedBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")
+            ?.currentVersion ??
+            adjustedPackages[0]?.currentVersion ??
+            "0.0.0";
         const fixedNextVersion = fixedType
-            ? (0, semver_js_1.bumpVersion)(currentVersion, fixedType, { allowStableMajor })
+            ? (0, semver_js_1.bumpVersion)(fixedBaseVersion, fixedType, { allowStableMajor })
             : null;
-        const adjusted = packagePlans.map((pkgPlan) => ({
+        const adjusted = adjustedPackages.map((pkgPlan) => ({
             ...pkgPlan,
             releaseType: fixedType,
             nextVersion: fixedNextVersion,
@@ -85,7 +128,7 @@ function createSimplePlan(cwd = process.cwd()) {
         return {
             mode: "simple",
             releaseType: fixedType,
-            currentVersion,
+            currentVersion: fixedBaseVersion,
             nextVersion: fixedNextVersion,
             versionFile,
             changelogFile,
@@ -95,20 +138,23 @@ function createSimplePlan(cwd = process.cwd()) {
             packages: adjusted,
         };
     }
-    const overallType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+    const overallType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+    const overallBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")?.currentVersion ??
+        adjustedPackages[0]?.currentVersion ??
+        "0.0.0";
     const overallNextVersion = overallType
-        ? (0, semver_js_1.bumpVersion)(currentVersion, overallType, { allowStableMajor })
+        ? (0, semver_js_1.bumpVersion)(overallBaseVersion, overallType, { allowStableMajor })
         : null;
     return {
         mode: "simple",
         releaseType: overallType,
-        currentVersion,
+        currentVersion: overallBaseVersion,
         nextVersion: overallNextVersion,
         versionFile,
         changelogFile,
         releaseBranchPrefix,
         baselineSha,
-        commits: packagePlans.flatMap((pkgPlan) => pkgPlan.commits),
-        packages: packagePlans,
+        commits: adjustedPackages.flatMap((pkgPlan) => pkgPlan.commits),
+        packages: adjustedPackages,
     };
 }

package/dist/domain/strategy/package-context.d.ts

@@ -0,0 +1,7 @@
+import type { VersionaryConfig, VersionaryPackage } from "../../types/config.js";
+import type { VersionStrategy } from "./types.js";
+export declare function resolvePackageStrategyContext(rootConfig: VersionaryConfig, packagePath: string, packageConfig: VersionaryPackage): {
+    strategy: VersionStrategy;
+    config: VersionaryConfig;
+    versionFile: string;
+};

package/dist/domain/strategy/package-context.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackageStrategyContext = resolvePackageStrategyContext;
+const node_path_1 = __importDefault(require("node:path"));
+const resolve_js_1 = require("./resolve.js");
+function withVersionFile(config, versionFile) {
+    return {
+        ...config,
+        "version-file": versionFile,
+    };
+}
+function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
+    const packageReleaseType = packageConfig["release-type"];
+    const baseConfig = packageReleaseType
+        ? {
+            ...rootConfig,
+            "release-type": packageReleaseType,
+        }
+        : { ...rootConfig };
+    const baseStrategy = (0, resolve_js_1.resolveVersionStrategy)(baseConfig);
+    if (!packageReleaseType) {
+        const versionFile = baseConfig["version-file"] ?? baseStrategy.getVersionFile(baseConfig);
+        const config = withVersionFile(baseConfig, versionFile);
+        return {
+            strategy: baseStrategy,
+            config,
+            versionFile,
+        };
+    }
+    const packageVersionFile = packagePath === "."
+        ? (baseConfig["version-file"] ?? baseStrategy.getVersionFile(baseConfig))
+        : node_path_1.default.posix.join(packagePath, baseStrategy.getVersionFile({
+            ...baseConfig,
+            "version-file": undefined,
+        }));
+    const config = withVersionFile({
+        ...baseConfig,
+        packages: undefined,
+    }, packageVersionFile);
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(config);
+    return {
+        strategy,
+        config,
+        versionFile: packageVersionFile,
+    };
+}

package/dist/domain/strategy/rust.d.ts

@@ -1,2 +1,5 @@
 import type { VersionStrategy } from "./types.js";
+export declare function applyRustWorkspaceDependencyUpdates(cwd: string, manifestToVersion: Record<string, string>): string[];
+export declare function detectRustDependencyImpact(cwd: string, manifestToVersion: Record<string, string>, candidateManifests: string[]): string[];
+export declare function toCargoManifestPath(packagePath: string): string;
 export declare const rustVersionStrategy: VersionStrategy;

package/dist/domain/strategy/rust.js

@@ -4,6 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rustVersionStrategy = void 0;
+exports.applyRustWorkspaceDependencyUpdates = applyRustWorkspaceDependencyUpdates;
+exports.detectRustDependencyImpact = detectRustDependencyImpact;
+exports.toCargoManifestPath = toCargoManifestPath;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const toml_1 = __importDefault(require("@iarna/toml"));
@@ -74,6 +77,25 @@ function findCargoManifestDirectories(rootDir) {
     }
     return [...results].sort((a, b) => a.localeCompare(b));
 }
+function collectAllCrateManifests(cwd) {
+    const manifests = [];
+    const cargoDirs = findCargoManifestDirectories(cwd);
+    for (const dir of cargoDirs) {
+        const manifest = dir === "."
+            ? "Cargo.toml"
+            : normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml"));
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        manifests.push(manifest);
+    }
+    return manifests.sort((a, b) => a.localeCompare(b));
+}
 function parseCargoManifest(versionFile, cargoTomlRaw) {
     let parsed;
     try {
@@ -156,7 +178,7 @@ function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
     });
     return filtered.sort((a, b) => a.localeCompare(b));
 }
-function collectRustTargetManifests(cwd, versionFile) {
+function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
     if (node_path_1.default.basename(versionFile) !== "Cargo.toml") {
         throw new Error(`Rust strategy requires "version-file" to point to a Cargo.toml manifest (received "${versionFile}").`);
     }
@@ -168,7 +190,9 @@ function collectRustTargetManifests(cwd, versionFile) {
     const parsedRoot = parseCargoManifest(versionFile, rootRaw);
     const rootIsCrate = parsedRoot.packageTable !== null;
     const rootDir = node_path_1.default.dirname(rootManifestPath);
-    const workspaceMembers = resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable);
+    const workspaceMembers = includeWorkspaceMembers
+        ? resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable)
+        : [];
     if (rootIsCrate) {
         const relRoot = normalizeSlashPath(node_path_1.default.relative(cwd, rootManifestPath));
         return [...new Set([relRoot, ...workspaceMembers])].sort((a, b) => a.localeCompare(b));
@@ -263,21 +287,22 @@ function parseDependencyName(line) {
     const match = line.match(/^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*=/u);
     return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
 }
-function writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version) {
-    if (!internalCrates.has(dependencyName)) {
+function writeInternalDependencyVersionInLine(line, dependencyName, versionByDependency) {
+    const nextVersion = versionByDependency.get(dependencyName);
+    if (!nextVersion) {
         return line;
     }
     const stringVersionMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
     if (stringVersionMatch) {
         const [, prefix = "", quote = '"', , , suffix = ""] = stringVersionMatch;
-        return `${prefix}${quote}${version}${quote}${suffix}`;
+        return `${prefix}${quote}${nextVersion}${quote}${suffix}`;
     }
     const inlineTableMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*\{)(.*)(\}\s*(?:#.*)?)$/u);
     if (!inlineTableMatch) {
         return line;
     }
     const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
-    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${version}$4`);
+    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${nextVersion}$4`);
     if (updatedTableBody === tableBody) {
         return line;
     }
@@ -287,6 +312,16 @@ function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version)
     if (internalCrates.size === 0) {
         return cargoTomlRaw;
     }
+    const versionByDependency = new Map();
+    for (const crateName of internalCrates) {
+        versionByDependency.set(crateName, version);
+    }
+    return writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+}
+function writeMappedDependencyVersions(cargoTomlRaw, versionByDependency) {
+    if (versionByDependency.size === 0) {
+        return cargoTomlRaw;
+    }
     const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
     const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
     const lines = cargoTomlRaw.split(/\r?\n/u);
@@ -305,7 +340,7 @@ function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version)
         if (!dependencyName) {
             continue;
         }
-        lines[index] = writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version);
+        lines[index] = writeInternalDependencyVersionInLine(line, dependencyName, versionByDependency);
     }
     let updated = lines.join(lineEnding);
     if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
@@ -316,6 +351,79 @@ function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version)
     }
     return updated;
 }
+function readPackageNameForManifest(cwd, manifest) {
+    const manifestPath = node_path_1.default.join(cwd, manifest);
+    const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+    if (!isCrateManifest(manifest, cargoTomlRaw)) {
+        throw new Error(`Configured rust target "${manifest}" is not a Rust crate manifest to update.`);
+    }
+    return readCargoPackageName(cargoTomlRaw, manifest);
+}
+function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
+    const versionByDependency = new Map();
+    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+        if (!version) {
+            continue;
+        }
+        const crateName = readPackageNameForManifest(cwd, manifest);
+        versionByDependency.set(crateName, version);
+    }
+    if (versionByDependency.size === 0) {
+        return [];
+    }
+    const updatedFiles = [];
+    const manifests = collectAllCrateManifests(cwd);
+    for (const manifest of manifests) {
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        const next = writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+        if (next !== cargoTomlRaw) {
+            node_fs_1.default.writeFileSync(manifestPath, next, "utf8");
+            updatedFiles.push(manifest);
+        }
+    }
+    return updatedFiles;
+}
+function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests) {
+    const versionByDependency = new Map();
+    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+        if (!version) {
+            continue;
+        }
+        const crateName = readPackageNameForManifest(cwd, manifest);
+        versionByDependency.set(crateName, version);
+    }
+    if (versionByDependency.size === 0) {
+        return [];
+    }
+    const impacted = [];
+    for (const manifest of [...new Set(candidateManifests)].sort((a, b) => a.localeCompare(b))) {
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        if (!isCrateManifest(manifest, cargoTomlRaw)) {
+            continue;
+        }
+        const next = writeMappedDependencyVersions(cargoTomlRaw, versionByDependency);
+        if (next !== cargoTomlRaw) {
+            impacted.push(manifest);
+        }
+    }
+    return impacted;
+}
+function toCargoManifestPath(packagePath) {
+    return packagePath === "."
+        ? "Cargo.toml"
+        : normalizeSlashPath(node_path_1.default.posix.join(packagePath, "Cargo.toml"));
+}
 exports.rustVersionStrategy = {
     name: "rust",
     getVersionFile(config) {
@@ -323,7 +431,7 @@ exports.rustVersionStrategy = {
     },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
-        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
         const selectedManifest = manifests[0];
         if (!selectedManifest) {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
@@ -333,7 +441,7 @@ exports.rustVersionStrategy = {
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
-        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
         const updatedFiles = [];
         const internalCrates = new Set();
         for (const manifest of manifests) {

package/dist/verify/verify-project.js

@@ -7,6 +7,7 @@ exports.verifyProject = verifyProject;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
+const package_context_js_1 = require("../domain/strategy/package-context.js");
 const resolve_js_1 = require("../domain/strategy/resolve.js");
 function verifyProject(cwd = process.cwd()) {
     const checks = [];
@@ -25,7 +26,7 @@ function verifyProject(cwd = process.cwd()) {
         details: exists ? "Version file exists" : `Missing ${versionFile}`,
     });
     if (config.config.packages) {
-        for (const pkgPathRaw of Object.keys(config.config.packages)) {
+        for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
             const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
             const exists = node_fs_1.default.existsSync(pkgPath);
             checks.push({
@@ -33,6 +34,18 @@ function verifyProject(cwd = process.cwd()) {
                 ok: exists,
                 details: exists ? "Path exists" : `Missing path: ${pkgPathRaw}`,
             });
+            if (exists) {
+                const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
+                const packageVersionFile = packageContext.versionFile;
+                const packageVersionExists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, packageVersionFile));
+                checks.push({
+                    name: `version-file:${packageVersionFile}`,
+                    ok: packageVersionExists,
+                    details: packageVersionExists
+                        ? "Version file exists"
+                        : `Missing ${packageVersionFile}`,
+                });
+            }
         }
     }
     const ok = checks.every((c) => c.ok);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",