versionary 0.30.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
@@ -196,6 +199,11 @@ For a quick trial, use:
     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

@@ -40,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(),

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);
@@ -78,7 +80,9 @@ export function createReleasePlan(cwd = process.cwd()) {
         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,
@@ -198,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,
         };
@@ -234,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/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/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[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.30.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",