versionary 0.15.1 → 0.17.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/config/load-config.js

@@ -8,6 +8,7 @@ exports.loadConfig = loadConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const jsonc_parser_1 = require("jsonc-parser");
+const resolve_js_1 = require("../strategy/resolve.js");
 const schema_js_1 = require("./schema.js");
 const SUPPORTED_FILES = [
     { file: "versionary.jsonc", format: "jsonc" },
@@ -22,6 +23,34 @@ function parseConfig(raw, format) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function validateReleaseTypes(config) {
+    try {
+        (0, resolve_js_1.resolveVersionStrategy)(config);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+        throw new Error(`Unsupported release-type. Supported release types: ${known}.`);
+    }
+    for (const [packagePath, packageConfig] of Object.entries(config.packages ?? {})) {
+        const packageReleaseType = packageConfig["release-type"];
+        if (!packageReleaseType) {
+            continue;
+        }
+        try {
+            (0, resolve_js_1.resolveVersionStrategy)({ ...config, "release-type": packageReleaseType });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`${error.message} (in packages["${packagePath}"])`);
+            }
+            const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+            throw new Error(`Unsupported release-type in packages["${packagePath}"]. Supported release types: ${known}.`);
+        }
+    }
+}
 function findConfigFile(cwd) {
     for (const candidate of SUPPORTED_FILES) {
         const candidatePath = node_path_1.default.join(cwd, candidate.file);
@@ -45,6 +74,7 @@ function loadConfig(cwd = process.cwd()) {
         throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
     }
     const validated = schema_js_1.configSchema.parse(parsed);
+    validateReleaseTypes(validated);
     return {
         path: found.path,
         format: found.format,

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.d.ts

@@ -12,8 +12,14 @@ export declare function renderSimpleReleaseNotes(input: {
     }>;
 }, options?: {
     includeFooter?: boolean;
+    headerLabel?: string;
+}): string;
+export declare function renderReviewRequestFooter(): string;
+export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?: {
+    headerLabel?: string;
+    includeFooter?: boolean;
+    cwd?: string;
 }): string;
-export declare function renderReleasePlanChangelog(plan: ReleasePlan): string;
 /** @deprecated Use renderReleasePlanChangelog. */
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
 export declare function renderPackageChangelogSection(input: {

package/dist/release/changelog.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
+exports.renderReviewRequestFooter = renderReviewRequestFooter;
 exports.renderReleasePlanChangelog = renderReleasePlanChangelog;
 exports.renderSimpleChangelog = renderSimpleChangelog;
 exports.renderPackageChangelogSection = renderPackageChangelogSection;
@@ -13,6 +14,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const commits_js_1 = require("../git/commits.js");
 const repo_url_js_1 = require("../git/repo-url.js");
+const REVIEW_REQUEST_FOOTER = "---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).";
 function formatDate() {
     return new Date().toISOString().slice(0, 10);
 }
@@ -31,17 +33,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(", ");
@@ -112,9 +138,10 @@ function groupCommitLines(commits, repoUrl) {
 }
 function renderSimpleReleaseNotes(input, options = {}) {
     const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const headerLabel = options.headerLabel ?? input.nextVersion;
     const header = repoUrl
-        ? `## [${input.nextVersion}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
-        : `## ${input.nextVersion} (${formatDate()})`;
+        ? `## [${headerLabel}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
+        : `## ${headerLabel} (${formatDate()})`;
     const grouped = groupCommitLines(input.commits, repoUrl);
     const sections = [];
     if (grouped.breaking.length > 0) {
@@ -132,13 +159,16 @@ function renderSimpleReleaseNotes(input, options = {}) {
     if (input.dependencies && input.dependencies.length > 0) {
         sections.push("### Dependencies", ...input.dependencies.map((dependency) => `- updated ${dependency.name} to v${dependency.version}`), "");
     }
-    const lines = [header, "", ...sections];
+    const body = [header, "", ...sections].join("\n").trimEnd();
     if (options.includeFooter) {
-        lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
+        return `${body}\n\n${renderReviewRequestFooter()}`;
     }
-    return lines.join("\n");
+    return body;
+}
+function renderReviewRequestFooter() {
+    return REVIEW_REQUEST_FOOTER;
 }
-function renderReleasePlanChangelog(plan) {
+function renderReleasePlanChangelog(plan, options = {}) {
     if (!plan.nextVersion) {
         return "";
     }
@@ -170,8 +200,11 @@ function renderReleasePlanChangelog(plan) {
         currentVersion: plan.currentVersion,
         nextVersion: plan.nextVersion,
         commits: dedupedCommits,
-        cwd: process.cwd(),
+        cwd: options.cwd ?? process.cwd(),
         dependencies,
+    }, {
+        includeFooter: options.includeFooter,
+        headerLabel: options.headerLabel,
     });
 }
 /** @deprecated Use renderReleasePlanChangelog. */

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)
@@ -337,25 +348,15 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             .sort((a, b) => a.name.localeCompare(b.name));
         return directSources;
     };
-    const relabelSectionHeader = (notes, packageLabel, nextVersion) => {
-        const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
-        if (linkedHeader) {
-            const [, , compareUrl, date] = linkedHeader;
-            return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${packageLabel}: ${nextVersion}](${compareUrl}) (${date})`);
-        }
-        const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
-        if (plainHeader) {
-            const [, , date] = plainHeader;
-            return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${packageLabel}: ${nextVersion} (${date})`);
-        }
-        return notes;
-    };
     if (plan?.packages && plan.packages.length > 1) {
         const sections = [];
         const rootPackage = plan.packages.find((pkg) => pkg.path === "." && pkg.nextVersion);
         if (rootPackage?.nextVersion) {
-            const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
-            sections.push(relabelSectionHeader(rootNotes, formatPackageLabel("."), rootPackage.nextVersion));
+            const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan, {
+                headerLabel: `${formatPackageLabel(".")}: ${rootPackage.nextVersion}`,
+                cwd,
+            });
+            sections.push(rootNotes);
         }
         const packageSections = plan.packages
             .filter((pkg) => pkg.path !== "." && pkg.nextVersion)
@@ -368,15 +369,18 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
                 commits: pkg.commits,
                 cwd,
                 dependencies: propagatedDependencies,
-            }, { includeFooter: false });
-            return relabelSectionHeader(notes, packageLabel, pkg.nextVersion ?? "");
+            }, {
+                includeFooter: false,
+                headerLabel: `${packageLabel}: ${pkg.nextVersion ?? ""}`,
+            });
+            return notes;
         });
         sections.push(...packageSections);
         const bodySections = sections.join("\n\n");
         if (bodySections.length === 0) {
-            return "This PR was generated by Versionary.";
+            return (0, changelog_js_1.renderReviewRequestFooter)();
         }
-        return `${bodySections}\n\nThis PR was generated by Versionary.`;
+        return `${bodySections}\n\n${(0, changelog_js_1.renderReviewRequestFooter)()}`;
     }
     return (0, changelog_js_1.renderSimpleReleaseNotes)({
         currentVersion: previousVersion,

package/dist/release/recovery.d.ts

@@ -5,6 +5,7 @@ export interface ReleaseTargetInput {
     version: string;
     notes: string;
     draft?: boolean;
+    makeLatest?: "true" | "false" | "legacy";
 }
 export interface ReleaseExecutionContext {
     createReleaseMetadata: (input: ReleaseTargetInput) => Promise<VersionaryScmReleaseMetadataResult>;

package/dist/release/release.js

@@ -183,6 +183,7 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             version: target.version,
             notes: releaseNotes,
             draft: loaded.config["release-draft"] ?? false,
+            makeLatest: target.path === "." ? "true" : "false",
         }, {
             createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {
                 cwd,

package/dist/scm/github-plugin.js

@@ -200,6 +200,7 @@ function createGitHubPlugin() {
                     name: input.tag,
                     body: input.notes,
                     draft: input.draft ?? false,
+                    make_latest: input.makeLatest,
                 });
                 data = response.data;
             }

package/dist/scm/types.d.ts

@@ -25,6 +25,7 @@ export interface ScmReleaseMetadataInput {
     version: string;
     notes: string;
     draft?: boolean;
+    makeLatest?: "true" | "false" | "legacy";
 }
 export interface ScmReleaseMetadataResult {
     url: string;

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,
@@ -17,5 +19,10 @@ function listKnownReleaseTypes() {
 }
 function resolveVersionStrategy(config) {
     const releaseType = config["release-type"] ?? "simple";
-    return strategyRegistry[releaseType] ?? simple_js_1.simpleVersionStrategy;
+    const strategy = strategyRegistry[releaseType];
+    if (!strategy) {
+        const known = listKnownReleaseTypes().join(", ");
+        throw new Error(`Unsupported release-type "${releaseType}". Supported release types: ${known}.`);
+    }
+    return strategy;
 }

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.17.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",