versionary 0.15.1 → 0.16.0

package/README.md

@@ -49,7 +49,7 @@ release/tag.
 
 Current implementation focuses on:
 
-- strategy-based version updates (`simple`, `node`, `rust`, `r`)
+- strategy-based version updates (`simple`, `node`, `rust`, `r`, `latex`)
 - release planning and changelog generation
 - review-mode vs direct-mode release flow
 - a static internal SCM client (`github` provider today)
@@ -76,8 +76,8 @@ Checklist for new strategies (for example `python`):
 - optionally implement `propagateDependentPatchImpacts(cwd, packages)` if
   dependency updates in this ecosystem should trigger dependent package patch
   bumps
-- optionally implement `finalizeVersionWrites(cwd, writes)` for ecosystem
-  post-processing after all target version files are written
+- optionally implement `finalizeVersionWrites(cwd, writes, context)` for
+  ecosystem post-processing after all target version files are written
 - add focused strategy tests for ecosystem-specific behavior and edge cases
 - add/extend strategy contract tests in `tests/strategy-contract.test.ts`
 - update schema/docs for new `release-type` behavior and defaults
@@ -105,7 +105,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`)
+  (`simple`, `node`, `rust`, `r`, `latex`)
 - `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
@@ -131,6 +131,9 @@ For a quick trial, use:
   `Version:` field
 - `release-type: "rust"` uses Cargo manifests (`Cargo.toml`) as version source;
   `version-file` must point to a `Cargo.toml` (default: `Cargo.toml`)
+- `release-type: "latex"` uses `build.lua` as version source and updates LaTeX
+  `\ProvidesPackage{...}[YYYY-MM-DD vX.Y.Z ...]` metadata in `src/**/*.dtx`
+  using the release commit date
 - simple/default strategy keeps `version.txt` as source of truth and does not
   update `package.json`
 - stable release branch (`release-branch`, default: `versionary/release`) so
@@ -249,6 +252,27 @@ Commands:
 through the SCM client. `pnpm run` is the recommended CI entrypoint and
 auto-dispatches between PR/update and release publish.
 
+### Moloch migration example (semantic-release -> versionary)
+
+For LaTeX projects like `moloch`, use `release-type: "latex"` so Versionary:
+
+- bumps `build.lua` version
+- updates `src/**/*.dtx` `\ProvidesPackage{...}[YYYY-MM-DD vX.Y.Z ...]` entries
+  with the release commit date (`git show --format=%cs <sha>`)
+
+Example `versionary.jsonc` for `moloch`:
+
+```jsonc
+{
+  "version": 1,
+  "review-mode": "pr",
+  "release-type": "latex",
+  "version-file": "build.lua",
+  "changelog-file": "CHANGELOG.md",
+  "release-branch": "versionary/release"
+}
+```
+
 For first-run bootstrapping, set `bootstrap-sha` (similar to release-please).
 Subsequent runs use the baseline state file.
 

package/dist/git/commits.js

@@ -270,12 +270,14 @@ function parseFooters(body) {
         extractReferences(`${footer.token}: ${footer.value}`, footer.token);
     }
     extractInlineSentenceReferences(body);
-    const dedupedReferences = [
-        ...new Map(references.map((reference) => [
-            `${reference.action ?? ""}:${reference.owner ?? ""}/${reference.repository ?? ""}:${reference.prefix}:${reference.issue ?? ""}`,
-            reference,
-        ])).values(),
-    ];
+    const dedupedReferenceMap = new Map();
+    for (const reference of references) {
+        const key = `${reference.action?.trim().toLowerCase() ?? ""}:${reference.owner?.trim().toLowerCase() ?? ""}/${reference.repository?.trim().toLowerCase() ?? ""}:${reference.prefix}:${reference.issue ?? ""}`;
+        if (!dedupedReferenceMap.has(key)) {
+            dedupedReferenceMap.set(key, reference);
+        }
+    }
+    const dedupedReferences = [...dedupedReferenceMap.values()];
     return {
         bodyText: bodyLines.join("\n").trim() || "",
         footerText: footerLines.length > 0 ? footerLines.join("\n").trim() : null,

package/dist/release/changelog.js

@@ -31,17 +31,41 @@ function formatCommitReferences(commit, repoBaseUrl) {
     if (references.length === 0) {
         return "";
     }
-    return references
-        .map((reference) => {
+    const formatIssueList = (issues) => {
+        if (issues.length === 0) {
+            return "";
+        }
+        if (issues.length === 1) {
+            return issues[0] ?? "";
+        }
+        if (issues.length === 2) {
+            return `${issues[0] ?? ""} and ${issues[1] ?? ""}`;
+        }
+        return `${issues.slice(0, -1).join(", ")}, and ${issues[issues.length - 1] ?? ""}`;
+    };
+    const referencesByAction = new Map();
+    for (const reference of references) {
         const issue = reference.issue;
         if (!issue) {
-            return "";
+            continue;
         }
         const action = (reference.action?.trim() || "refs").toLowerCase();
-        if (!repoBaseUrl) {
-            return `${action} #${issue}`;
+        const formattedIssue = repoBaseUrl
+            ? `[#${issue}](${repoBaseUrl}/issues/${issue})`
+            : `#${issue}`;
+        const existing = referencesByAction.get(action) ?? [];
+        if (!existing.includes(formattedIssue)) {
+            existing.push(formattedIssue);
+            referencesByAction.set(action, existing);
+        }
+    }
+    return [...referencesByAction.entries()]
+        .map(([action, issues]) => {
+        const list = formatIssueList(issues);
+        if (list.length === 0) {
+            return "";
         }
-        return `${action} [#${issue}](${repoBaseUrl}/issues/${issue})`;
+        return `${action} ${list}`;
     })
         .filter((entry) => entry.length > 0)
         .join(", ");

package/dist/release/pr.js

@@ -82,6 +82,13 @@ function getCommitTreeSha(cwd, revision) {
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
+function resolveCommitDate(cwd, revision) {
+    return (0, node_child_process_1.execFileSync)("git", ["show", "-s", "--format=%cs", revision], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
 function hasOriginRemote(cwd) {
     const remotes = (0, node_child_process_1.execFileSync)("git", ["remote"], {
         cwd,
@@ -191,6 +198,15 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         throw new Error("No releasable commits found. Nothing to open a release PR for.");
     }
     ensureCleanWorktree(cwd, options.logger);
+    const releaseBaselineSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const finalizeContext = {
+        releaseCommitSha: releaseBaselineSha,
+        releaseDate: resolveCommitDate(cwd, releaseBaselineSha),
+    };
     const updatedVersionFiles = [];
     const writesByStrategy = new Map();
     const addStrategyWrite = (strategy, write) => {
@@ -230,7 +246,7 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         });
     }
     for (const strategyGroup of writesByStrategy.values()) {
-        updatedVersionFiles.push(...(strategyGroup.strategy.finalizeVersionWrites?.(cwd, strategyGroup.writes) ?? []));
+        updatedVersionFiles.push(...(strategyGroup.strategy.finalizeVersionWrites?.(cwd, strategyGroup.writes, finalizeContext) ?? []));
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
@@ -266,11 +282,6 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
     const branch = plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
-    const releaseBaselineSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
-        cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
     const hasRemoteReleaseBranch = remoteReleaseBranchExists(cwd, branch);
     const remoteReleaseRef = hasRemoteReleaseBranch
         ? fetchRemoteReleaseBranch(cwd, branch)

package/dist/strategy/latex.d.ts

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

package/dist/strategy/latex.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latexVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const BUILD_LUA_VERSION_PATTERN = /^(\s*version\s*=\s*")([^"]+)(")/mu;
+const PROVIDES_PACKAGE_PATTERN = /\\ProvidesPackage\{([^}]+)\}\[\d{4}-\d{2}-\d{2} v([0-9]+\.[0-9]+\.[0-9]+) ([^\]]+)\]/gu;
+function normalizeRelative(base, target) {
+    return node_path_1.default.relative(base, target).replaceAll("\\", "/");
+}
+function collectDtxFiles(dir) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const entries = node_fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const target = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectDtxFiles(target));
+            continue;
+        }
+        if (entry.isFile() && target.endsWith(".dtx")) {
+            files.push(target);
+        }
+    }
+    return files.sort((a, b) => a.localeCompare(b));
+}
+function replaceBuildLuaVersion(content, version, versionFile) {
+    const match = content.match(BUILD_LUA_VERSION_PATTERN);
+    if (!match) {
+        throw new Error(`${versionFile} is missing a valid version field required by release-type "latex".`);
+    }
+    return content.replace(BUILD_LUA_VERSION_PATTERN, `$1${version}$3`);
+}
+function replaceProvidesPackageMetadata(content, version, releaseDate, relativePath) {
+    const matches = [...content.matchAll(PROVIDES_PACKAGE_PATTERN)];
+    if (matches.length !== 1) {
+        throw new Error(`${relativePath} must contain exactly one \\ProvidesPackage metadata entry; matched ${matches.length}.`);
+    }
+    return content.replace(PROVIDES_PACKAGE_PATTERN, (_full, pkg, _prevVersion, desc) => `\\ProvidesPackage{${pkg}}[${releaseDate} v${version} ${desc}]`);
+}
+exports.latexVersionStrategy = {
+    name: "latex",
+    getVersionFile(config) {
+        return config["version-file"] ?? "build.lua";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        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 content = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const match = content.match(BUILD_LUA_VERSION_PATTERN);
+        if (!match?.[2]) {
+            throw new Error(`${versionFile} is missing a valid version field required by release-type "latex".`);
+        }
+        return match[2].trim();
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        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 next = replaceBuildLuaVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), version, versionFile);
+        node_fs_1.default.writeFileSync(versionPath, next, "utf8");
+        return [versionFile];
+    },
+    finalizeVersionWrites(cwd, writes, context) {
+        const updated = new Set();
+        for (const write of writes) {
+            const packageRoot = write.packagePath === "." ? cwd : node_path_1.default.join(cwd, write.packagePath);
+            const srcDir = node_path_1.default.join(packageRoot, "src");
+            const dtxFiles = collectDtxFiles(srcDir);
+            if (dtxFiles.length === 0) {
+                throw new Error(`release-type "latex" requires at least one .dtx file under ${normalizeRelative(cwd, srcDir)}.`);
+            }
+            for (const dtxPath of dtxFiles) {
+                const relativePath = normalizeRelative(cwd, dtxPath);
+                const existing = node_fs_1.default.readFileSync(dtxPath, "utf8");
+                const next = replaceProvidesPackageMetadata(existing, write.version, context.releaseDate, relativePath);
+                if (next === existing) {
+                    continue;
+                }
+                node_fs_1.default.writeFileSync(dtxPath, next, "utf8");
+                updated.add(relativePath);
+            }
+        }
+        return [...updated].sort((a, b) => a.localeCompare(b));
+    },
+};

package/dist/strategy/resolve.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listKnownReleaseTypes = listKnownReleaseTypes;
 exports.resolveVersionStrategy = resolveVersionStrategy;
+const latex_js_1 = require("./latex.js");
 const node_js_1 = require("./node.js");
 const r_js_1 = require("./r.js");
 const rust_js_1 = require("./rust.js");
 const simple_js_1 = require("./simple.js");
 const strategyRegistry = {
+    latex: latex_js_1.latexVersionStrategy,
     simple: simple_js_1.simpleVersionStrategy,
     node: node_js_1.nodeVersionStrategy,
     rust: rust_js_1.rustVersionStrategy,

package/dist/strategy/rust.js

@@ -721,7 +721,7 @@ exports.rustVersionStrategy = {
             .filter((pkgPath) => Boolean(pkgPath))
             .sort((a, b) => a.localeCompare(b));
     },
-    finalizeVersionWrites(cwd, writes) {
+    finalizeVersionWrites(cwd, writes, _context) {
         const manifestToVersion = {};
         for (const write of writes) {
             manifestToVersion[write.versionFile] = write.version;

package/dist/strategy/types.d.ts

@@ -10,6 +10,10 @@ export interface StrategyVersionWriteContext {
     versionFile: string;
     version: string;
 }
+export interface StrategyFinalizeContext {
+    releaseCommitSha: string;
+    releaseDate: string;
+}
 export interface VersionStrategy {
     name: string;
     getVersionFile(config: VersionaryConfig): string;
@@ -19,5 +23,5 @@ export interface VersionStrategy {
     validateProject?(cwd: string, config: VersionaryConfig): string | null;
     readPackageName?(cwd: string, config: VersionaryConfig): string | null;
     propagateDependentPatchImpacts?(cwd: string, packages: StrategyPackagePlanContext[]): string[];
-    finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[]): string[];
+    finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[], context: StrategyFinalizeContext): string[];
 }

package/package.json

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