versionary 0.19.0 → 0.20.1

package/dist/config/schema.d.ts

@@ -44,6 +44,7 @@ export declare const configSchema: z.ZodObject<{
                 json: "json";
                 toml: "toml";
                 yaml: "yaml";
+                nix: "nix";
                 regex: "regex";
             }>;
             path: z.ZodString;

package/dist/config/schema.js

@@ -4,14 +4,17 @@ exports.configSchema = void 0;
 const zod_1 = require("zod");
 const artifactRuleSchema = zod_1.z
     .object({
-    type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
+    type: zod_1.z.enum(["json", "toml", "yaml", "nix", "regex"]),
     path: zod_1.z.string().min(1),
     "field-path": zod_1.z.string().optional(),
     jsonpath: zod_1.z.string().optional(),
     pattern: zod_1.z.string().optional(),
 })
     .superRefine((value, ctx) => {
-    const needsJsonPath = value.type === "json" || value.type === "toml" || value.type === "yaml";
+    const needsJsonPath = value.type === "json" ||
+        value.type === "toml" ||
+        value.type === "yaml" ||
+        value.type === "nix";
     const hasFieldPath = Boolean(value["field-path"] ?? value.jsonpath);
     if (needsJsonPath && !hasFieldPath) {
         ctx.addIssue({

package/dist/release/artifact-rules.js

@@ -160,6 +160,164 @@ function applyTomlRulePreservingFormatting(content, fieldPath, version) {
     const [, prefix = "", quote = '"', , , suffix = ""] = match;
     return content.replace(linePattern, `${prefix}${quote}${version}${quote}${suffix}`);
 }
+function findMatchingBrace(content, openBraceIndex, endExclusive) {
+    let depth = 0;
+    let inDoubleQuoted = false;
+    let inMultiSingleQuoted = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = openBraceIndex; index < endExclusive; index += 1) {
+        const current = content[index] ?? "";
+        const next = content[index + 1] ?? "";
+        if (inLineComment) {
+            if (current === "\n") {
+                inLineComment = false;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (current === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (inDoubleQuoted) {
+            if (current === "\\") {
+                index += 1;
+                continue;
+            }
+            if (current === '"') {
+                inDoubleQuoted = false;
+            }
+            continue;
+        }
+        if (inMultiSingleQuoted) {
+            if (current === "'" && next === "'") {
+                inMultiSingleQuoted = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (current === "#") {
+            inLineComment = true;
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        if (current === '"') {
+            inDoubleQuoted = true;
+            continue;
+        }
+        if (current === "'" && next === "'") {
+            inMultiSingleQuoted = true;
+            index += 1;
+            continue;
+        }
+        if (current === "{") {
+            depth += 1;
+            continue;
+        }
+        if (current === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
+}
+function resolveNixPathTokens(fieldPath) {
+    const tokens = parseFieldPath(fieldPath);
+    if (tokens.some((token) => typeof token === "number")) {
+        throw new Error(`Nix artifact rules do not support array index segments in field-path "${fieldPath}".`);
+    }
+    return tokens;
+}
+function escapeForRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function buildNixKeyPattern(key) {
+    const escaped = escapeForRegex(key);
+    return `(?:${escaped}|"${escaped}")`;
+}
+function findNixScopeRanges(content, key, rangeStart, rangeEnd) {
+    const keyPattern = buildNixKeyPattern(key);
+    const assignmentPattern = new RegExp(`^\\s*${keyPattern}\\s*=.*\\{(?:\\s*(?:#.*)?)$`, "gmu");
+    const scopedContent = content.slice(rangeStart, rangeEnd);
+    const ranges = [];
+    let match = assignmentPattern.exec(scopedContent);
+    while (match) {
+        const matchText = match[0] ?? "";
+        const relLineStart = match.index;
+        const relBracePos = matchText.lastIndexOf("{");
+        if (relLineStart >= 0 && relBracePos >= 0) {
+            const absoluteBrace = rangeStart + relLineStart + relBracePos;
+            const closingBrace = findMatchingBrace(content, absoluteBrace, rangeEnd);
+            if (closingBrace < 0) {
+                throw new Error(`Nix field-path segment "${key}" has an unterminated attrset.`);
+            }
+            ranges.push({ start: absoluteBrace + 1, end: closingBrace });
+        }
+        match = assignmentPattern.exec(scopedContent);
+    }
+    return ranges;
+}
+function applyNixRulePreservingFormatting(content, fieldPath, version) {
+    const tokens = resolveNixPathTokens(fieldPath);
+    const parentTokens = tokens.slice(0, -1);
+    const leaf = tokens.at(-1);
+    if (!leaf) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
+    let candidateRanges = [
+        { start: 0, end: content.length },
+    ];
+    for (const parent of parentTokens) {
+        const nextRanges = [];
+        for (const range of candidateRanges) {
+            const nested = findNixScopeRanges(content, parent, range.start, range.end);
+            nextRanges.push(...nested);
+        }
+        candidateRanges = nextRanges;
+        if (candidateRanges.length === 0) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
+    }
+    const leafPattern = new RegExp(`(^\\s*${buildNixKeyPattern(leaf)}\\s*=\\s*)(["'])([^"']*)(\\2)(\\s*;)`, "gmu");
+    const replacements = [];
+    for (const range of candidateRanges) {
+        const segment = content.slice(range.start, range.end);
+        let match = leafPattern.exec(segment);
+        while (match) {
+            const full = match[0] ?? "";
+            const prefix = match[1] ?? "";
+            const quote = match[2] ?? '"';
+            const suffix = match[5] ?? ";";
+            const relStart = match.index;
+            replacements.push({
+                start: range.start + relStart,
+                end: range.start + relStart + full.length,
+                replacement: `${prefix}${quote}${version}${quote}${suffix}`,
+            });
+            match = leafPattern.exec(segment);
+        }
+    }
+    if (replacements.length === 0) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
+    if (replacements.length > 1) {
+        throw new Error(`Nix artifact rule field-path "${fieldPath}" matched multiple assignments; refine the path to match exactly one field.`);
+    }
+    const [target] = replacements;
+    if (!target) {
+        throw new Error("Nix replacement target missing.");
+    }
+    return `${content.slice(0, target.start)}${target.replacement}${content.slice(target.end)}`;
+}
 function applyArtifactRuleToContent(content, rule, version) {
     if (rule.type === "regex") {
         if (!rule.pattern) {
@@ -175,6 +333,9 @@ function applyArtifactRuleToContent(content, rule, version) {
     if (rule.type === "toml") {
         return applyTomlRulePreservingFormatting(content, resolveFieldPath(rule), version);
     }
+    if (rule.type === "nix") {
+        return applyNixRulePreservingFormatting(content, resolveFieldPath(rule), version);
+    }
     const parsed = yaml_1.default.parse(content);
     setVersionAtJsonPath(parsed, resolveFieldPath(rule), version);
     return `${yaml_1.default.stringify(parsed)}`;

package/dist/release/changelog.js

@@ -173,14 +173,25 @@ function renderReleasePlanChangelog(plan, options = {}) {
     if (!plan.nextVersion) {
         return "";
     }
-    const propagatedRootPackage = plan.packages?.find((pkg) => pkg.path === "." && pkg.bumpReason === "dependency-propagation");
+    const propagatedRootPackage = plan.packages?.find((pkg) => pkg.path === ".");
     const isDirectBump = (pkg) => pkg.bumpReason === "direct" ||
         (pkg.bumpReason === undefined &&
             Boolean(pkg.nextVersion) &&
             pkg.commits.length > 0);
-    const dependencies = propagatedRootPackage && plan.packages
+    const legacyDependencySources = propagatedRootPackage?.bumpReason === "dependency-propagation" &&
+        plan.packages
         ? plan.packages
             .filter((pkg) => pkg.path !== "." && isDirectBump(pkg) && pkg.nextVersion)
+            .map((pkg) => pkg.path)
+        : [];
+    const dependencySourcePaths = [
+        ...(propagatedRootPackage?.dependencySourcePaths ??
+            legacyDependencySources),
+    ].sort((a, b) => a.localeCompare(b));
+    const dependencies = plan.packages
+        ? dependencySourcePaths
+            .map((sourcePath) => plan.packages?.find((pkg) => pkg.path === sourcePath && pkg.nextVersion))
+            .filter((sourcePackage) => Boolean(sourcePackage))
             .map((pkg) => ({
             name: pkg.path,
             version: pkg.nextVersion,

package/dist/release/plan.d.ts

@@ -19,6 +19,7 @@ export interface ReleasePlan {
         currentVersion: string;
         nextVersion: string | null;
         bumpReason?: "direct" | "dependency-propagation";
+        dependencySourcePaths?: string[];
         commits: ParsedCommit[];
     }>;
 }

package/dist/release/plan.js

@@ -108,6 +108,7 @@ function createReleasePlan(cwd = process.cwd()) {
         ...(implicitRootPlan ? [implicitRootPlan] : []),
     ].sort((a, b) => a.path.localeCompare(b.path));
     const packageCurrentVersionByPath = {};
+    const packageNextVersionByPath = {};
     const strategyPackagesByName = new Map();
     for (const packagePlan of packagePlans) {
         const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
@@ -135,17 +136,56 @@ function createReleasePlan(cwd = process.cwd()) {
             });
         }
         packageCurrentVersionByPath[packagePlan.path] = packagePlan.currentVersion;
+        if (packagePlan.nextVersion) {
+            packageNextVersionByPath[packagePlan.path] = packagePlan.nextVersion;
+        }
     }
     const impactedPaths = new Set();
+    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]));
+    };
     for (const strategyGroup of strategyPackagesByName.values()) {
-        const impacted = strategyGroup.strategy.propagateDependentPatchImpacts?.(cwd, strategyGroup.packages);
-        for (const pkgPath of impacted ?? []) {
+        const impactedByAll = strategyGroup.strategy.propagateDependentPatchImpacts?.(cwd, strategyGroup.packages) ?? [];
+        for (const pkgPath of impactedByAll) {
             impactedPaths.add(pkgPath);
         }
+        const sourcePackages = strategyGroup.packages.filter((pkg) => Boolean(pkg.nextVersion));
+        for (const sourcePackage of sourcePackages) {
+            const scopedImpacts = strategyGroup.strategy.propagateDependentPatchImpacts?.(cwd, strategyGroup.packages.map((pkg) => ({
+                ...pkg,
+                nextVersion: pkg.packagePath === sourcePackage.packagePath
+                    ? sourcePackage.nextVersion
+                    : null,
+            }))) ?? [];
+            for (const impactedPath of scopedImpacts) {
+                addDependencySourcePath(impactedPath, sourcePackage.packagePath);
+            }
+        }
     }
     const adjustedPackages = packagePlans.map((pkgPlan) => {
+        const dependencySourcePaths = [
+            ...(dependencySourcePathsByPackage.get(pkgPlan.path) ??
+                new Set()),
+        ]
+            .filter((sourcePath) => Boolean(packageNextVersionByPath[sourcePath]))
+            .sort((a, b) => a.localeCompare(b));
         if (pkgPlan.nextVersion || !impactedPaths.has(pkgPlan.path)) {
-            return pkgPlan;
+            if (dependencySourcePaths.length === 0) {
+                return pkgPlan;
+            }
+            return {
+                ...pkgPlan,
+                dependencySourcePaths,
+            };
         }
         const current = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
         return {
@@ -153,6 +193,7 @@ function createReleasePlan(cwd = process.cwd()) {
             releaseType: "patch",
             nextVersion: (0, semver_js_1.bumpVersion)(current, "patch", { allowStableMajor }),
             bumpReason: "dependency-propagation",
+            dependencySourcePaths,
         };
     });
     const visiblePackages = adjustedPackages.filter((pkgPlan) => !pkgPlan.implicitRoot || hasExplicitRootPackage);

package/dist/release/pr.js

@@ -336,18 +336,23 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             pkg.commits.length > 0);
     const findPropagatedDependencies = (packagePath, packages) => {
         const target = packages.find((pkg) => pkg.path === packagePath);
-        if (!target || target.bumpReason !== "dependency-propagation") {
+        if (!target) {
             return [];
         }
-        const directSources = packages
-            .filter((pkg) => isDirectBump(pkg))
+        const sourcePaths = target.dependencySourcePaths && target.dependencySourcePaths.length > 0
+            ? target.dependencySourcePaths
+            : target.bumpReason === "dependency-propagation"
+                ? packages.filter((pkg) => isDirectBump(pkg)).map((pkg) => pkg.path)
+                : [];
+        return sourcePaths
+            .map((sourcePath) => packages.find((pkg) => pkg.path === sourcePath))
+            .filter((sourcePackage) => Boolean(sourcePackage))
             .map((pkg) => ({
             name: formatPackageLabel(pkg.path),
             version: pkg.nextVersion ?? "",
         }))
             .filter((dependency) => dependency.version.length > 0)
             .sort((a, b) => a.name.localeCompare(b.name));
-        return directSources;
     };
     if (plan?.packages && plan.packages.length > 1) {
         const sections = [];

package/dist/strategy/rust.js

@@ -243,17 +243,24 @@ function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
     const parsedRoot = parseCargoManifest(versionFile, rootRaw);
     const rootIsCrate = parsedRoot.packageTable !== null;
     const rootDir = node_path_1.default.dirname(rootManifestPath);
-    const workspaceMembers = includeWorkspaceMembers
+    const augmentingMembers = 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));
+        return [...new Set([relRoot, ...augmentingMembers])].sort((a, b) => a.localeCompare(b));
     }
-    if (workspaceMembers.length > 0) {
-        return workspaceMembers;
+    const fallbackMembers = includeWorkspaceMembers
+        ? augmentingMembers
+        : resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable);
+    if (fallbackMembers.length > 0) {
+        return fallbackMembers;
     }
-    throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. Expected [package].version or [workspace].members with crate Cargo.toml files.`);
+    const isWorkspaceOnly = parsedRoot.workspaceTable !== null;
+    const detail = isWorkspaceOnly
+        ? `Workspace root "${versionFile}" has no [workspace].members resolving to crate Cargo.toml files.`
+        : `"${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) {
     if (!rawVersion || typeof rawVersion !== "object") {
@@ -529,9 +536,40 @@ function readPackageNameForManifest(cwd, manifest) {
     }
     return readCargoPackageName(cargoTomlRaw, manifest);
 }
+function expandWorkspaceOnlyManifests(cwd, manifestToVersion) {
+    const expanded = {};
+    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+        const manifestPath = node_path_1.default.join(cwd, manifest);
+        if (!node_fs_1.default.existsSync(manifestPath)) {
+            expanded[manifest] = version;
+            continue;
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(manifestPath, "utf8");
+        const parsed = parseCargoManifest(manifest, cargoTomlRaw);
+        if (parsed.packageTable !== null || parsed.workspaceTable === null) {
+            expanded[manifest] = version;
+            continue;
+        }
+        const rootDir = node_path_1.default.dirname(manifestPath);
+        const memberManifests = resolveWorkspaceMemberManifests(rootDir, parsed.workspaceTable);
+        if (memberManifests.length === 0) {
+            expanded[manifest] = version;
+            continue;
+        }
+        const manifestDir = normalizeSlashPath(node_path_1.default.posix.dirname(manifest));
+        for (const memberManifest of memberManifests) {
+            const joined = manifestDir === "." || manifestDir === ""
+                ? memberManifest
+                : normalizeSlashPath(node_path_1.default.posix.join(manifestDir, memberManifest));
+            expanded[joined] = version;
+        }
+    }
+    return expanded;
+}
 function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
+    const expandedManifestToVersion = expandWorkspaceOnlyManifests(cwd, manifestToVersion);
     const versionByDependency = new Map();
-    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+    for (const [manifest, version] of Object.entries(expandedManifestToVersion)) {
         if (!version) {
             continue;
         }
@@ -561,8 +599,9 @@ function applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion) {
     return updatedFiles;
 }
 function detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests) {
+    const expandedManifestToVersion = expandWorkspaceOnlyManifests(cwd, manifestToVersion);
     const versionByDependency = new Map();
-    for (const [manifest, version] of Object.entries(manifestToVersion)) {
+    for (const [manifest, version] of Object.entries(expandedManifestToVersion)) {
         if (!version) {
             continue;
         }

package/dist/types/config.d.ts

@@ -2,7 +2,7 @@ export type ConfigFileFormat = "jsonc" | "json" | "toml" | "js";
 export type VersionaryChangelogFormat = "markdown-changelog" | "r-news";
 export type ReleaseReferenceCommentsMode = "off" | "best-effort" | "strict";
 export interface VersionaryArtifactRule {
-    type: "json" | "toml" | "yaml" | "regex";
+    type: "json" | "toml" | "yaml" | "nix" | "regex";
     path: string;
     "field-path"?: string;
     jsonpath?: string;

package/package.json

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