versionary 0.29.0 → 0.31.0

package/README.md

@@ -50,7 +50,7 @@ release/tag.
 Current implementation focuses on:
 
 - strategy-based version updates (`simple`, `node`, `rust`, `r`, `latex`,
-  `python`)
+  `python`, `julia`)
 - release planning and changelog generation
 - review-mode vs direct-mode release flow
 - a static internal SCM client (`github` provider today)
@@ -110,7 +110,7 @@ Current runtime code uses a flat `src/` layout with clear module boundaries:
 - `src/cli/`: command router (`run`, `verify`, `plan`, `changelog`, `pr`, `release`)
 - `src/release/`: release orchestration (plan/changelog/PR/release/state/recovery)
 - `src/strategy/`: strategy contracts, resolver, and built-in implementations
-  (`simple`, `node`, `rust`, `r`, `latex`, `python`)
+  (`simple`, `node`, `rust`, `r`, `latex`, `python`, `julia`)
 - `src/scm/`: SCM client contracts and provider implementation(s)
 - `src/config/`: config loading and schema validation
 - `src/git/`: git commit/range and repository URL helpers
@@ -144,6 +144,9 @@ For a quick trial, use:
   Python source file (e.g. `src/<pkg>/__init__.py`) to update a `__version__`
   assignment instead. Refreshes `poetry.lock`/`uv.lock`/`pdm.lock` at the
   package root if present
+- `release-type: "julia"` uses `Project.toml` (default) as version source and
+  updates the top-level `version` field (Julia keeps `version`/`name` as root
+  keys, not under a section)
 - `release-type` can also be an array of strategy names to compose them across
   manifests, e.g. `["python", "rust"]` for a PyO3/maturin project: the first
   entry is the *primary* (drives `readVersion`, `readPackageName`, and consumes
@@ -190,6 +193,17 @@ For a quick trial, use:
     combining `follows` with `monorepo-mode: "fixed"` are config errors.
     `follows` is non-transitive: A follows B does not imply A follows what B
     follows.
+  - per-package `exclude-paths` drops commits that only touch the listed paths
+    (relative to the package) from that package's bump and changelog. A
+    top-level `exclude-paths` applies to every package; the effective excludes
+    for a package are the union of the top-level list and the package's own
+    list. The top-level list also applies to a single-package (non-`packages`)
+    repository.
+  - per-package `allow-stable-major` overrides the top-level setting for that
+    package's own bump (including dependency-propagation and `follows`-driven
+    bumps), so a `0.y.z` package can transition to `1.0.0` on a breaking release
+    independently of its siblings. In `fixed` mode the single shared version is
+    governed by the top-level `allow-stable-major` only.
 
 ```jsonc
 // Editor extension that bundles the root CLI artifact

package/dist/config/schema.d.ts

@@ -30,6 +30,7 @@ export declare const configSchema: z.ZodObject<{
     "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
     "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
     "include-commit-authors": z.ZodOptional<z.ZodBoolean>;
+    "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
     "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
@@ -39,6 +40,7 @@ export declare const configSchema: z.ZodObject<{
             "markdown-changelog": "markdown-changelog";
             "r-news": "r-news";
         }>>;
+        "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
         "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
         "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{

package/dist/config/schema.js

@@ -57,6 +57,7 @@ const packageSchema = z
     "package-name": z.string().optional(),
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
+    "allow-stable-major": z.boolean().optional(),
     "exclude-paths": z.array(z.string()).optional(),
     "extra-files": z.array(artifactRuleSchema).optional(),
     follows: z.array(z.string().min(1)).optional(),
@@ -82,6 +83,7 @@ export const configSchema = z
     "bump-minor-pre-major": z.boolean().optional(),
     "allow-stable-major": z.boolean().optional(),
     "include-commit-authors": z.boolean().optional(),
+    "exclude-paths": z.array(z.string()).optional(),
     "release-type": z
         .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
         .optional(),

package/dist/release/plan.js

@@ -50,6 +50,8 @@ export function createReleasePlan(cwd = process.cwd()) {
     const baselineSha = readBaselineSha(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
     const releaseTargetByPath = new Map(readReleaseTargets(cwd).map((target) => [target.path, target]));
     const allowStableMajor = loaded.config["allow-stable-major"] ?? false;
+    const allowStableMajorForPath = (packagePath) => loaded.config.packages?.[packagePath]?.["allow-stable-major"] ??
+        allowStableMajor;
     const monorepoMode = getMode(loaded.config["monorepo-mode"]);
     const buildPackagePlan = (pkg) => {
         const packageContext = resolvePackageStrategyContext(loaded.config, pkg.path, pkg.config);
@@ -58,14 +60,29 @@ export function createReleasePlan(cwd = process.cwd()) {
             throw new Error(`Versionary requires ${packageContext.versionFile} to exist for package "${pkg.path}".`);
         }
         const packageCurrentVersion = packageContext.strategy.readVersion(cwd, packageContext.config);
-        const parsedCommits = !hasPackages && pkg.path === "."
-            ? getParsedCommitsSinceLastTag(cwd, baselineSha)
-            : getParsedCommitsForPath(cwd, releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha, pkg.path, pkg.config["exclude-paths"] ?? []);
+        const excludePaths = [
+            ...new Set([
+                ...(loaded.config["exclude-paths"] ?? []),
+                ...(pkg.config["exclude-paths"] ?? []),
+            ]),
+        ];
+        const isImplicitRoot = !hasPackages && pkg.path === ".";
+        let parsedCommits;
+        if (isImplicitRoot && excludePaths.length === 0) {
+            parsedCommits = getParsedCommitsSinceLastTag(cwd, baselineSha);
+        }
+        else {
+            parsedCommits = getParsedCommitsForPath(cwd, isImplicitRoot
+                ? baselineSha
+                : (releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha), pkg.path, excludePaths);
+        }
         const effectiveCommits = applyRevertSuppression(parsedCommits);
         const commits = effectiveCommits;
         const releaseType = analyzeParsedCommits(parsedCommits);
         const nextVersion = releaseType
-            ? bumpVersion(packageCurrentVersion, releaseType, { allowStableMajor })
+            ? bumpVersion(packageCurrentVersion, releaseType, {
+                allowStableMajor: allowStableMajorForPath(pkg.path),
+            })
             : null;
         return {
             path: pkg.path,
@@ -185,7 +202,9 @@ export function createReleasePlan(cwd = process.cwd()) {
         return {
             ...pkgPlan,
             releaseType: "patch",
-            nextVersion: bumpVersion(current, "patch", { allowStableMajor }),
+            nextVersion: bumpVersion(current, "patch", {
+                allowStableMajor: allowStableMajorForPath(pkgPlan.path),
+            }),
             bumpReason: "dependency-propagation",
             dependencySourcePaths,
         };
@@ -221,7 +240,9 @@ export function createReleasePlan(cwd = process.cwd()) {
             pkgPlan.bumpReason === undefined;
         const baseVersion = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
         const nextVersion = combinedReleaseType
-            ? bumpVersion(baseVersion, combinedReleaseType, { allowStableMajor })
+            ? bumpVersion(baseVersion, combinedReleaseType, {
+                allowStableMajor: allowStableMajorForPath(pkgPlan.path),
+            })
             : null;
         return {
             ...pkgPlan,

package/dist/release/release.js

@@ -8,7 +8,7 @@ import { resolveVersionStrategy } from "../strategy/resolve.js";
 import { getChangelogDefaults } from "./plan.js";
 import { isReleaseCommitMessage } from "./pr.js";
 import { executeIdempotentReleaseTarget } from "./recovery.js";
-import { readReleaseTargets } from "./state.js";
+import { readPendingReleaseTargets } from "./state.js";
 function escapeRegExp(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -147,7 +147,7 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     const referenceCommentMode = loaded.config["release-reference-comments"] ?? "off";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    const releaseTargets = readReleaseTargets(cwd);
+    const releaseTargets = readPendingReleaseTargets(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
         : [
@@ -195,7 +195,8 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             tagStatus: outcome.tagStatus,
             metadataStatus: outcome.metadataStatus,
         });
-        if (references.length > 0) {
+        const releaseWasCreated = outcome.tagStatus === "created" || outcome.metadataStatus === "created";
+        if (references.length > 0 && releaseWasCreated) {
             referenceReleases.push({
                 name: resolveTargetPackageName(cwd, loaded.config, target.path),
                 tag: outcome.tag,

package/dist/release/semver.d.ts

@@ -14,14 +14,16 @@ export declare function parseVersion(version: string): ParsedVersion;
 export declare function isValidVersion(version: string): boolean;
 /**
  * Decide whether a changelog heading denotes a released version (e.g.
- * `## [0.28.2](url) (2026-06-02)`, `## 1.2.3`, `## v1.2.3`, `## 0.28.2.9000`)
- * rather than a manual-notes heading (e.g. `## Unreleased`, `## Upcoming`).
+ * `## [0.28.2](url) (2026-06-02)`, `## 1.2.3`, `## v1.2.3`, `## 0.28.2.9000`,
+ * `# pkg 8.0`) rather than a manual-notes heading (e.g. `## Unreleased`,
+ * `## Upcoming`).
  *
  * Intentionally liberal: a heading counts as a version if it contains any
- * version-like token that {@link isValidVersion} accepts. This errs toward
- * "it's a version", so a real release heading is never mistaken for a notes
- * block (and therefore never stripped). Dates such as `2026-06-02` use dashes,
- * not dots, so they never match the three-component token.
+ * version-like token that {@link isValidVersion} accepts, or ends with a bare
+ * `major.minor` token (the R `NEWS.md` convention). This errs toward "it's a
+ * version", so a real release heading is never mistaken for a notes block (and
+ * therefore never stripped). Dates such as `2026-06-02` use dashes, not dots,
+ * so they never match either token.
  */
 export declare function isVersionHeading(heading: string): boolean;
 export declare function compareVersions(leftRaw: string, rightRaw: string): number;

package/dist/release/semver.js

@@ -39,23 +39,30 @@ export function isValidVersion(version) {
     return SEMVER_PATTERN.test(normalizeVersionInput(version));
 }
 const VERSION_TOKEN_PATTERN = /v?(\d+\.\d+\.\d+(?:\.\d+)?)/u;
+// R `NEWS.md` headings conventionally abbreviate to `major.minor` (e.g.
+// `# pkg 8.0`). Accept a bare two-component token only when it is the trailing
+// token of the heading, so genuine R release headings register as versions
+// while prose like `## Notes for 2.0 milestone` does not.
+const TRAILING_MAJOR_MINOR_PATTERN = /\bv?\d+\.\d+\s*$/u;
 /**
  * Decide whether a changelog heading denotes a released version (e.g.
- * `## [0.28.2](url) (2026-06-02)`, `## 1.2.3`, `## v1.2.3`, `## 0.28.2.9000`)
- * rather than a manual-notes heading (e.g. `## Unreleased`, `## Upcoming`).
+ * `## [0.28.2](url) (2026-06-02)`, `## 1.2.3`, `## v1.2.3`, `## 0.28.2.9000`,
+ * `# pkg 8.0`) rather than a manual-notes heading (e.g. `## Unreleased`,
+ * `## Upcoming`).
  *
  * Intentionally liberal: a heading counts as a version if it contains any
- * version-like token that {@link isValidVersion} accepts. This errs toward
- * "it's a version", so a real release heading is never mistaken for a notes
- * block (and therefore never stripped). Dates such as `2026-06-02` use dashes,
- * not dots, so they never match the three-component token.
+ * version-like token that {@link isValidVersion} accepts, or ends with a bare
+ * `major.minor` token (the R `NEWS.md` convention). This errs toward "it's a
+ * version", so a real release heading is never mistaken for a notes block (and
+ * therefore never stripped). Dates such as `2026-06-02` use dashes, not dots,
+ * so they never match either token.
  */
 export function isVersionHeading(heading) {
     const match = heading.match(VERSION_TOKEN_PATTERN);
-    if (!match?.[1]) {
-        return false;
+    if (match?.[1] && isValidVersion(match[1])) {
+        return true;
     }
-    return isValidVersion(match[1]);
+    return TRAILING_MAJOR_MINOR_PATTERN.test(heading);
 }
 function isNumericIdentifier(identifier) {
     return /^(0|[1-9]\d*)$/u.test(identifier);

package/dist/release/state.d.ts

@@ -6,4 +6,5 @@ export interface ReleaseTargetState {
 export declare function getBaselineStatePath(cwd: string): string;
 export declare function readBaselineSha(cwd?: string): string | null;
 export declare function readReleaseTargets(cwd?: string): ReleaseTargetState[];
+export declare function readPendingReleaseTargets(cwd?: string): ReleaseTargetState[];
 export declare function writeBaselineSha(cwd?: string, sha?: string, releaseTargets?: ReleaseTargetState[]): void;

package/dist/release/state.js

@@ -5,6 +5,7 @@ import { loadConfig } from "../config/load-config.js";
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";
+const PENDING_RELEASE_TARGETS_KEY = "pending-release-targets";
 function parseStateFile(raw, filePath) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -19,24 +20,28 @@ function parseStateFile(raw, filePath) {
         typeof manifest[BASELINE_SHA_KEY] !== "string") {
         throw new Error(`Invalid release manifest at ${filePath}: ${BASELINE_SHA_KEY} must be a string.`);
     }
-    if (manifest[RELEASE_TARGETS_KEY] !== undefined &&
-        !Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
-        throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must be an array.`);
+    validateReleaseTargets(manifest[RELEASE_TARGETS_KEY], RELEASE_TARGETS_KEY, filePath);
+    validateReleaseTargets(manifest[PENDING_RELEASE_TARGETS_KEY], PENDING_RELEASE_TARGETS_KEY, filePath);
+    return manifest;
+}
+function validateReleaseTargets(value, key, filePath) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid release manifest at ${filePath}: ${key} must be an array.`);
     }
-    if (Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
-        for (const target of manifest[RELEASE_TARGETS_KEY]) {
-            if (!target || typeof target !== "object" || Array.isArray(target)) {
-                throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
-            }
-            const record = target;
-            if (typeof record.path !== "string" ||
-                typeof record.version !== "string" ||
-                typeof record.tag !== "string") {
-                throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must contain string path, version, and tag.`);
-            }
+    for (const target of value) {
+        if (!target || typeof target !== "object" || Array.isArray(target)) {
+            throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
+        }
+        const record = target;
+        if (typeof record.path !== "string" ||
+            typeof record.version !== "string" ||
+            typeof record.tag !== "string") {
+            throw new Error(`Invalid release manifest at ${filePath}: ${key} must contain string path, version, and tag.`);
         }
     }
-    return manifest;
 }
 export function getBaselineStatePath(cwd) {
     const loaded = loadConfig(cwd);
@@ -62,6 +67,9 @@ export function readBaselineSha(cwd = process.cwd()) {
     const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[BASELINE_SHA_KEY] ?? null;
 }
+// Accumulated per-package baseline: the latest released tag for every package
+// ever released. `plan` uses these tags as the commit-range floor per package,
+// so this list must persist entries across releases rather than be replaced.
 export function readReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
     if (!fs.existsSync(filePath)) {
@@ -70,6 +78,18 @@ export function readReleaseTargets(cwd = process.cwd()) {
     const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
+// 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).
+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] ?? []);
+}
 export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
         execFileSync("git", ["rev-parse", "HEAD"], {
@@ -82,6 +102,9 @@ export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
         ? parseStateFile(fs.readFileSync(filePath, "utf8"), filePath)
         : {};
     const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
+    // Merge the current targets into the accumulated baseline (latest tag per
+    // path wins, since `releaseTargets` is appended last), but record the current
+    // targets verbatim as the pending publish set.
     const nextTargets = releaseTargets === undefined
         ? existingTargets
         : [
@@ -90,10 +113,14 @@ export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
                 target,
             ])).values(),
         ].sort((a, b) => a.path.localeCompare(b.path));
+    const nextPending = releaseTargets === undefined
+        ? (existing[PENDING_RELEASE_TARGETS_KEY] ?? [])
+        : [...releaseTargets].sort((a, b) => a.path.localeCompare(b.path));
     const next = {
         [MANIFEST_VERSION_KEY]: 1,
         [BASELINE_SHA_KEY]: baselineShaValue,
         [RELEASE_TARGETS_KEY]: nextTargets,
+        [PENDING_RELEASE_TARGETS_KEY]: nextPending,
     };
     fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/scm/github-plugin.js

@@ -99,14 +99,30 @@ function groupReleasesByIssue(releases) {
     }
     return new Map([...byIssue.entries()].sort(([a], [b]) => a - b));
 }
+const RELEASE_REFERENCE_COMMENT_FOOTER = "Released by [Versionary](https://github.com/jolars/versionary).";
 function renderReleaseLink(release) {
     if (release.name) {
         return `[\`${release.name}\` v${release.version}](${release.releaseUrl})`;
     }
     return `[version ${release.version}](${release.releaseUrl})`;
 }
+// Reads bodies of prior Versionary release-reference comments on an issue so we
+// can avoid re-announcing a release that has already been posted (e.g. when an
+// already-published target is re-processed on a later release run).
+async function readExistingReferenceComments(octokit, repo, issueNumber) {
+    const response = await octokit.issues.listComments({
+        owner: repo.owner,
+        repo: repo.repo,
+        issue_number: issueNumber,
+        per_page: 100,
+    });
+    return response.data
+        .map((comment) => comment.body ?? "")
+        .filter((body) => body.includes(RELEASE_REFERENCE_COMMENT_FOOTER))
+        .join("\n");
+}
 function renderReleaseReferenceCommentBody(releases) {
-    const footer = "Released by [Versionary](https://github.com/jolars/versionary).";
+    const footer = RELEASE_REFERENCE_COMMENT_FOOTER;
     if (releases.length === 1) {
         const release = releases[0];
         if (!release) {
@@ -312,7 +328,24 @@ export function createGitHubPlugin() {
             const releasesByIssue = groupReleasesByIssue(input.releases);
             const commented = [];
             for (const [reference, releases] of releasesByIssue) {
-                const body = renderReleaseReferenceCommentBody(releases);
+                let announcedText;
+                try {
+                    announcedText = await readExistingReferenceComments(octokit, repo, reference);
+                }
+                catch (error) {
+                    const { message } = parseGitHubError(error);
+                    if (mode === "strict") {
+                        throw new Error(`Failed listing existing comments on #${reference}: [${repoRef(repo)}] ${message}`);
+                    }
+                    context.logger?.warn(`Could not check existing comments on #${reference}, posting anyway: [${repoRef(repo)}] ${message}`);
+                    announcedText = "";
+                }
+                const pendingReleases = releases.filter((release) => !announcedText.includes(release.releaseUrl));
+                if (pendingReleases.length === 0) {
+                    context.logger?.info(`Skipping release reference comment on #${reference}: already announced.`);
+                    continue;
+                }
+                const body = renderReleaseReferenceCommentBody(pendingReleases);
                 try {
                     await octokit.issues.createComment({
                         owner: repo.owner,

package/dist/strategy/julia.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare const juliaVersionStrategy: VersionStrategy;

package/dist/strategy/julia.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
+function parseProjectToml(content, versionFile) {
+    let parsed;
+    try {
+        parsed = parseToml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse ${versionFile}: ${message}`);
+    }
+    if (parsed && typeof parsed === "object") {
+        return parsed;
+    }
+    throw new Error(`Failed to parse ${versionFile}: not a TOML table.`);
+}
+function readProjectVersion(content, versionFile) {
+    const parsed = parseProjectToml(content, versionFile);
+    const version = parsed.version;
+    if (typeof version === "string" && version.trim().length > 0) {
+        return version.trim();
+    }
+    throw new Error(`${versionFile} is missing a valid root "version" field required by release-type "julia".`);
+}
+function writeProjectVersion(rawContent, versionFile, version) {
+    const lineEnding = rawContent.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = rawContent.endsWith("\n") || rawContent.endsWith("\r\n");
+    const lines = rawContent.split(/\r?\n/u);
+    let activeTable = null;
+    let replaced = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            activeTable = sectionMatch[1]?.trim() ?? null;
+            continue;
+        }
+        // The Julia version is a root key: only match before the first table header.
+        if (activeTable !== null) {
+            continue;
+        }
+        const versionMatch = line.match(/^(\s*version\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+        if (!versionMatch) {
+            continue;
+        }
+        const [, prefix = "", quote = '"', , , suffix = ""] = versionMatch;
+        lines[index] = `${prefix}${quote}${version}${quote}${suffix}`;
+        replaced = true;
+        break;
+    }
+    if (!replaced) {
+        throw new Error(`${versionFile} is missing a valid root "version" field required by release-type "julia".`);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+export const juliaVersionStrategy = {
+    name: "julia",
+    getVersionFile(config) {
+        return config["version-file"] ?? "Project.toml";
+    },
+    validateProject(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
+            return null;
+        }
+        try {
+            readProjectVersion(fs.readFileSync(versionPath, "utf8"), versionFile);
+            return null;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        return readProjectVersion(fs.readFileSync(versionPath, "utf8"), versionFile);
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const existing = fs.readFileSync(versionPath, "utf8");
+        const updated = writeProjectVersion(existing, versionFile, version);
+        fs.writeFileSync(versionPath, updated, "utf8");
+        return [versionFile];
+    },
+    readPackageName(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const parsed = parseProjectToml(fs.readFileSync(versionPath, "utf8"), versionFile);
+        const name = parsed.name;
+        if (typeof name === "string" && name.trim().length > 0) {
+            return name.trim();
+        }
+        return null;
+    },
+};

package/dist/strategy/resolve.js

@@ -1,4 +1,5 @@
 import { compositeVersionStrategy } from "./composite.js";
+import { juliaVersionStrategy } from "./julia.js";
 import { latexVersionStrategy } from "./latex.js";
 import { nodeVersionStrategy } from "./node.js";
 import { pythonVersionStrategy } from "./python.js";
@@ -6,6 +7,7 @@ import { rVersionStrategy } from "./r.js";
 import { rustVersionStrategy } from "./rust.js";
 import { simpleVersionStrategy } from "./simple.js";
 const strategyRegistry = {
+    julia: juliaVersionStrategy,
     latex: latexVersionStrategy,
     simple: simpleVersionStrategy,
     node: nodeVersionStrategy,

package/dist/types/config.d.ts

@@ -13,6 +13,7 @@ export interface VersionaryPackage {
     "package-name"?: string;
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
+    "allow-stable-major"?: boolean;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
     follows?: string[];
@@ -33,6 +34,7 @@ export interface VersionaryConfig {
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
     "include-commit-authors"?: boolean;
+    "exclude-paths"?: string[];
     "release-type"?: string | string[];
     packages?: Record<string, VersionaryPackage>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -42,6 +42,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
+    "gen:schema": "tsx scripts/generate-schema.ts && biome format --write schemas/config.json",
     "test": "vitest run",
     "verify": "tsx src/cli/index.ts verify",
     "run": "tsx src/cli/index.ts run",