versionary 0.23.0 → 0.24.0

package/README.md

@@ -49,7 +49,8 @@ release/tag.
 
 Current implementation focuses on:
 
-- strategy-based version updates (`simple`, `node`, `rust`, `r`, `latex`)
+- strategy-based version updates (`simple`, `node`, `rust`, `r`, `latex`,
+  `python`)
 - release planning and changelog generation
 - review-mode vs direct-mode release flow
 - a static internal SCM client (`github` provider today)
@@ -64,7 +65,7 @@ changing release orchestration. A new strategy should implement the
 `VersionStrategy` contract in `src/strategy/types.ts` and be wired in
 `src/strategy/resolve.ts`.
 
-Checklist for new strategies (for example `python`):
+Checklist for new strategies:
 
 - define strategy `name`
 - define `getVersionFile(config)` defaults and config override behavior
@@ -94,6 +95,10 @@ Current ecosystem policy defaults:
   - Node strategy updates root `package-lock.json`/`npm-shrinkwrap.json` when
     present
   - Rust release PR prep refreshes all discovered `Cargo.lock` files
+  - Python strategy refreshes any `poetry.lock`/`uv.lock`/`pdm.lock` at the
+    package root by shelling out to the matching tool (`poetry lock
+    --no-update`, `uv lock`, `pdm lock --update-reuse`); the corresponding
+    binary must be on `PATH`
 - workspace/inheritance:
   - Rust supports `version.workspace = true` via `[workspace.package].version`
   - other strategies should document equivalent inheritance behavior explicitly
@@ -105,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`)
+  (`simple`, `node`, `rust`, `r`, `latex`, `python`)
 - `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
@@ -134,6 +139,11 @@ For a quick trial, use:
 - `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
+- `release-type: "python"` uses `pyproject.toml` (default) and updates
+  `[project].version` and/or `[tool.poetry].version`; point `version-file` at a
+  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
 - 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

package/dist/release/changelog.d.ts

@@ -1,7 +1,7 @@
 import { type ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat } from "../types/config.js";
-import type { ReleasePlan, SimplePlan } from "./plan.js";
-export declare function renderSimpleReleaseNotes(input: {
+import { type ReleasePlan, type SimplePlan } from "./plan.js";
+export declare function renderReleaseNotesSection(input: {
     currentVersion: string;
     nextVersion: string;
     commits: ParsedCommit[];
@@ -11,9 +11,10 @@ export declare function renderSimpleReleaseNotes(input: {
         version: string;
     }>;
     highlights?: string;
+    tagPrefix?: string;
+    headerLabel?: string;
 }, options?: {
     includeFooter?: boolean;
-    headerLabel?: string;
 }): string;
 export declare function renderReviewRequestFooter(): string;
 export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?: {
@@ -24,13 +25,6 @@ export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?:
 }): string;
 /** @deprecated Use renderReleasePlanChangelog. */
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
-export declare function renderPackageChangelogSection(input: {
-    currentVersion: string;
-    nextVersion: string;
-    commits: ParsedCommit[];
-    tagPrefix: string;
-    cwd?: string;
-}): string;
 export declare function prependChangelog(cwd: string, changelogFile: string, section: string, format?: VersionaryChangelogFormat): void;
 export declare function renderRNewsReleaseNotes(input: {
     packageName: string;

package/dist/release/changelog.js

@@ -3,17 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
+exports.renderReleaseNotesSection = renderReleaseNotesSection;
 exports.renderReviewRequestFooter = renderReviewRequestFooter;
 exports.renderReleasePlanChangelog = renderReleasePlanChangelog;
 exports.renderSimpleChangelog = renderSimpleChangelog;
-exports.renderPackageChangelogSection = renderPackageChangelogSection;
 exports.prependChangelog = prependChangelog;
 exports.renderRNewsReleaseNotes = renderRNewsReleaseNotes;
 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 plan_js_1 = require("./plan.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);
@@ -140,11 +140,12 @@ function groupCommitLines(commits, repoUrl) {
     }
     return { breaking, features, fixes, performance, reverts };
 }
-function renderSimpleReleaseNotes(input, options = {}) {
+function renderReleaseNotesSection(input, options = {}) {
     const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
-    const headerLabel = options.headerLabel ?? input.nextVersion;
+    const headerLabel = input.headerLabel ?? input.nextVersion;
+    const versionPrefix = input.tagPrefix ? `${input.tagPrefix}-v` : "v";
     const header = repoUrl
-        ? `## [${headerLabel}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
+        ? `## [${headerLabel}](${repoUrl}/compare/${versionPrefix}${input.currentVersion}...${versionPrefix}${input.nextVersion}) (${formatDate()})`
         : `## ${headerLabel} (${formatDate()})`;
     const grouped = groupCommitLines(input.commits, repoUrl);
     const sections = [];
@@ -183,30 +184,6 @@ function renderReleasePlanChangelog(plan, options = {}) {
     if (!plan.nextVersion) {
         return "";
     }
-    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 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,
-        }))
-        : [];
     const dedupedCommits = [
         ...new Map(plan.commits.map((commit) => [commit.hash, commit])).values(),
     ];
@@ -219,46 +196,22 @@ function renderReleasePlanChangelog(plan, options = {}) {
             highlights: options.highlights,
         });
     }
-    return renderSimpleReleaseNotes({
+    return renderReleaseNotesSection({
         currentVersion: plan.currentVersion,
         nextVersion: plan.nextVersion,
         commits: dedupedCommits,
         cwd: options.cwd ?? process.cwd(),
-        dependencies,
+        dependencies: (0, plan_js_1.resolvePackageDependencies)(plan, "."),
         highlights: options.highlights,
+        headerLabel: options.headerLabel,
     }, {
         includeFooter: options.includeFooter,
-        headerLabel: options.headerLabel,
     });
 }
 /** @deprecated Use renderReleasePlanChangelog. */
 function renderSimpleChangelog(plan) {
     return renderReleasePlanChangelog(plan);
 }
-function renderPackageChangelogSection(input) {
-    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
-    const header = repoUrl
-        ? `## [${input.nextVersion}](${repoUrl}/compare/${input.tagPrefix}-v${input.currentVersion}...${input.tagPrefix}-v${input.nextVersion}) (${formatDate()})`
-        : `## ${input.nextVersion} (${formatDate()})`;
-    const grouped = groupCommitLines(input.commits, repoUrl);
-    const sections = [];
-    if (grouped.breaking.length > 0) {
-        sections.push("### Breaking changes", ...grouped.breaking, "");
-    }
-    if (grouped.features.length > 0) {
-        sections.push("### Features", ...grouped.features, "");
-    }
-    if (grouped.fixes.length > 0) {
-        sections.push("### Bug Fixes", ...grouped.fixes, "");
-    }
-    if (grouped.performance.length > 0) {
-        sections.push("### Performance Improvements", ...grouped.performance, "");
-    }
-    if (grouped.reverts.length > 0) {
-        sections.push("### Reverts", ...grouped.reverts, "");
-    }
-    return [header, "", ...sections].join("\n");
-}
 function prependChangelog(cwd, changelogFile, section, format = "markdown-changelog") {
     const changelogPath = node_path_1.default.join(cwd, changelogFile);
     const existing = node_fs_1.default.existsSync(changelogPath)

package/dist/release/plan.d.ts

@@ -37,3 +37,7 @@ export declare function getChangelogDefaults(config: {
 export declare function createReleasePlan(cwd?: string): ReleasePlan;
 /** @deprecated Use createReleasePlan. */
 export declare function createSimplePlan(cwd?: string): ReleasePlan;
+export declare function resolvePackageDependencies(plan: ReleasePlan, packagePath: string): Array<{
+    name: string;
+    version: string;
+}>;

package/dist/release/plan.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getChangelogDefaults = getChangelogDefaults;
 exports.createReleasePlan = createReleasePlan;
 exports.createSimplePlan = createSimplePlan;
+exports.resolvePackageDependencies = resolvePackageDependencies;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
@@ -311,3 +312,15 @@ function createReleasePlan(cwd = process.cwd()) {
 function createSimplePlan(cwd = process.cwd()) {
     return createReleasePlan(cwd);
 }
+function resolvePackageDependencies(plan, packagePath) {
+    const target = plan.packages?.find((pkg) => pkg.path === packagePath);
+    if (!target) {
+        return [];
+    }
+    const sources = target.dependencySourcePaths ?? [];
+    return sources
+        .map((sourcePath) => plan.packages?.find((pkg) => pkg.path === sourcePath && pkg.nextVersion))
+        .filter((sourcePackage) => Boolean(sourcePackage))
+        .map((pkg) => ({ name: pkg.path, version: pkg.nextVersion }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/release/pr.d.ts

@@ -26,7 +26,7 @@ export declare function prepareReleasePr(cwd?: string, options?: {
     updated: boolean;
     highlights: string;
 };
-export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string, highlights?: string): string;
+export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string, highlights?: string, loadedConfig?: VersionaryConfig): string;
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
     highlights?: string;

package/dist/release/pr.js

@@ -315,12 +315,13 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         if (!packageMetadata) {
             continue;
         }
-        const packageSection = (0, changelog_js_1.renderPackageChangelogSection)({
+        const packageSection = (0, changelog_js_1.renderReleaseNotesSection)({
             currentVersion: packagePlan.currentVersion,
             nextVersion: packagePlan.nextVersion,
             commits: packagePlan.commits,
             tagPrefix: packageMetadata.tagPrefix,
             cwd,
+            dependencies: (0, plan_js_1.resolvePackageDependencies)(plan, packagePlan.path),
         });
         (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection, "markdown-changelog");
         updatedChangelogFiles.push(node_path_1.default.posix.join(packagePlan.path, packageChangelogFile));
@@ -374,32 +375,20 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         highlights,
     };
 }
-function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd(), highlights = "") {
+function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd(), highlights = "", loadedConfig) {
     const rootPackageLabel = node_path_1.default.basename(cwd);
     const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
-    const isDirectBump = (pkg) => pkg.bumpReason === "direct" ||
-        (pkg.bumpReason === undefined &&
-            Boolean(pkg.nextVersion) &&
-            pkg.commits.length > 0);
-    const findPropagatedDependencies = (packagePath, packages) => {
-        const target = packages.find((pkg) => pkg.path === packagePath);
-        if (!target) {
-            return [];
+    const resolveTagPrefix = (packagePath) => {
+        if (packagePath === ".") {
+            return undefined;
         }
-        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));
+        if (!loadedConfig) {
+            return normalizeReleaseNameForTag(packagePath);
+        }
+        const packageConfig = loadedConfig.packages?.[packagePath] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loadedConfig, packagePath, packageConfig);
+        const releaseName = resolveReleaseName(cwd, packagePath, packageConfig, packageContext.strategy, packageContext.config);
+        return normalizeReleaseNameForTag(releaseName);
     };
     if (plan?.packages && plan.packages.length > 1) {
         const sections = [];
@@ -414,21 +403,15 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         }
         const packageSections = plan.packages
             .filter((pkg) => pkg.path !== "." && pkg.nextVersion)
-            .map((pkg) => {
-            const packageLabel = formatPackageLabel(pkg.path);
-            const propagatedDependencies = findPropagatedDependencies(pkg.path, plan.packages ?? []);
-            const notes = (0, changelog_js_1.renderSimpleReleaseNotes)({
-                currentVersion: pkg.currentVersion,
-                nextVersion: pkg.nextVersion ?? "",
-                commits: pkg.commits,
-                cwd,
-                dependencies: propagatedDependencies,
-            }, {
-                includeFooter: false,
-                headerLabel: `${packageLabel}: ${pkg.nextVersion ?? ""}`,
-            });
-            return notes;
-        });
+            .map((pkg) => (0, changelog_js_1.renderReleaseNotesSection)({
+            currentVersion: pkg.currentVersion,
+            nextVersion: pkg.nextVersion ?? "",
+            commits: pkg.commits,
+            cwd,
+            dependencies: (0, plan_js_1.resolvePackageDependencies)(plan, pkg.path),
+            tagPrefix: resolveTagPrefix(pkg.path),
+            headerLabel: `${formatPackageLabel(pkg.path)}: ${pkg.nextVersion ?? ""}`,
+        }));
         sections.push(...packageSections);
         const bodySections = sections.join("\n\n");
         if (bodySections.length === 0) {
@@ -436,7 +419,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         }
         return `${bodySections}\n\n${(0, changelog_js_1.renderReviewRequestFooter)()}`;
     }
-    return (0, changelog_js_1.renderSimpleReleaseNotes)({
+    return (0, changelog_js_1.renderReleaseNotesSection)({
         currentVersion: previousVersion,
         nextVersion: version,
         commits,
@@ -455,7 +438,7 @@ async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVe
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
-        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? ""),
+        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? "", loaded.config),
         labels: ["release"],
     }, {
         cwd,

package/dist/strategy/python.d.ts

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

package/dist/strategy/python.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonVersionStrategy = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const SOURCE_FILE_VERSION_PATTERN = /^(\s*__version__\s*=\s*)(["'])([^"']+)(\2)(\s*(?:#.*)?)?$/mu;
+function isSourceFileMode(versionFile) {
+    return versionFile.toLowerCase().endsWith(".py");
+}
+function parsePyProject(content, versionFile) {
+    let parsed;
+    try {
+        parsed = toml_1.default.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse ${versionFile}: ${message}`);
+    }
+    const root = parsed;
+    const project = root.project && typeof root.project === "object"
+        ? root.project
+        : null;
+    const toolPoetry = root.tool &&
+        typeof root.tool === "object" &&
+        "poetry" in root.tool &&
+        typeof root.tool.poetry === "object" &&
+        root.tool.poetry !== null
+        ? root.tool.poetry
+        : null;
+    return { project, toolPoetry };
+}
+function lookupPyProjectVersions(parsed) {
+    const projectVersionRaw = parsed.project?.version;
+    const poetryVersionRaw = parsed.toolPoetry?.version;
+    return {
+        projectVersion: typeof projectVersionRaw === "string" &&
+            projectVersionRaw.trim().length > 0
+            ? projectVersionRaw.trim()
+            : null,
+        poetryVersion: typeof poetryVersionRaw === "string" && poetryVersionRaw.trim().length > 0
+            ? poetryVersionRaw.trim()
+            : null,
+    };
+}
+function readPyProjectVersion(content, versionFile) {
+    const parsed = parsePyProject(content, versionFile);
+    const { projectVersion, poetryVersion } = lookupPyProjectVersions(parsed);
+    const version = projectVersion ?? poetryVersion;
+    if (!version) {
+        throw new Error(`${versionFile} is missing a valid "[project].version" or "[tool.poetry].version" field required by release-type "python".`);
+    }
+    return version;
+}
+function replaceVersionInTable(rawContent, targetTables, 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);
+    const replaced = new Set();
+    let activeTable = null;
+    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;
+        }
+        if (!activeTable || !targetTables.has(activeTable)) {
+            continue;
+        }
+        if (replaced.has(activeTable)) {
+            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.add(activeTable);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return { content: updated, replaced };
+}
+function writePyProjectVersion(rawContent, versionFile, version) {
+    const parsed = parsePyProject(rawContent, versionFile);
+    const { projectVersion, poetryVersion } = lookupPyProjectVersions(parsed);
+    if (!projectVersion && !poetryVersion) {
+        throw new Error(`${versionFile} is missing a valid "[project].version" or "[tool.poetry].version" field required by release-type "python".`);
+    }
+    const targets = new Set();
+    if (projectVersion) {
+        targets.add("project");
+    }
+    if (poetryVersion) {
+        targets.add("tool.poetry");
+    }
+    const { content, replaced } = replaceVersionInTable(rawContent, targets, version);
+    for (const target of targets) {
+        if (!replaced.has(target)) {
+            throw new Error(`Failed to update [${target}].version in ${versionFile}; ensure the version line uses the form \`version = "X.Y.Z"\`.`);
+        }
+    }
+    return content;
+}
+function readSourceFileVersion(content, versionFile) {
+    const match = content.match(SOURCE_FILE_VERSION_PATTERN);
+    if (!match?.[3]) {
+        throw new Error(`${versionFile} is missing a valid \`__version__ = "X.Y.Z"\` assignment required by release-type "python".`);
+    }
+    return match[3].trim();
+}
+function writeSourceFileVersion(content, versionFile, version) {
+    if (!SOURCE_FILE_VERSION_PATTERN.test(content)) {
+        throw new Error(`${versionFile} is missing a valid \`__version__ = "X.Y.Z"\` assignment required by release-type "python".`);
+    }
+    return content.replace(SOURCE_FILE_VERSION_PATTERN, (_full, prefix, quote, _value, _close, suffix = "") => `${prefix}${quote}${version}${quote}${suffix ?? ""}`);
+}
+const LOCKFILE_SPECS = [
+    {
+        lockfile: "poetry.lock",
+        command: "poetry",
+        args: ["lock", "--no-update"],
+        installHint: "install Poetry (https://python-poetry.org/)",
+    },
+    {
+        lockfile: "uv.lock",
+        command: "uv",
+        args: ["lock"],
+        installHint: "install uv (https://docs.astral.sh/uv/)",
+    },
+    {
+        lockfile: "pdm.lock",
+        command: "pdm",
+        args: ["lock", "--update-reuse"],
+        installHint: "install PDM (https://pdm-project.org/)",
+    },
+];
+function refreshLockfile(cwd, spec) {
+    try {
+        (0, node_child_process_1.execFileSync)(spec.command, [...spec.args], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to refresh ${spec.lockfile} via "${spec.command} ${spec.args.join(" ")}". Ensure ${spec.command} is on PATH (${spec.installHint}) or remove ${spec.lockfile} from the working tree. Details: ${message}`);
+    }
+}
+function readPyProjectFromCwd(cwd) {
+    const target = node_path_1.default.join(cwd, "pyproject.toml");
+    if (!node_fs_1.default.existsSync(target)) {
+        return null;
+    }
+    const content = node_fs_1.default.readFileSync(target, "utf8");
+    return { parsed: parsePyProject(content, "pyproject.toml"), rawPath: target };
+}
+exports.pythonVersionStrategy = {
+    name: "python",
+    getVersionFile(config) {
+        return config["version-file"] ?? "pyproject.toml";
+    },
+    validateProject(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            return null;
+        }
+        try {
+            const content = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (isSourceFileMode(versionFile)) {
+                readSourceFileVersion(content, versionFile);
+            }
+            else {
+                readPyProjectVersion(content, versionFile);
+            }
+            return null;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    },
+    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");
+        return isSourceFileMode(versionFile)
+            ? readSourceFileVersion(content, versionFile)
+            : readPyProjectVersion(content, versionFile);
+    },
+    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 existing = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const updated = isSourceFileMode(versionFile)
+            ? writeSourceFileVersion(existing, versionFile, version)
+            : writePyProjectVersion(existing, versionFile, version);
+        node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+        return [versionFile];
+    },
+    readPackageName(cwd, _config) {
+        const found = readPyProjectFromCwd(cwd);
+        if (!found) {
+            return null;
+        }
+        const projectName = found.parsed.project?.name;
+        if (typeof projectName === "string" && projectName.trim().length > 0) {
+            return projectName.trim();
+        }
+        const poetryName = found.parsed.toolPoetry?.name;
+        if (typeof poetryName === "string" && poetryName.trim().length > 0) {
+            return poetryName.trim();
+        }
+        return null;
+    },
+    finalizeVersionWrites(cwd, _writes, _context) {
+        const refreshed = [];
+        for (const spec of LOCKFILE_SPECS) {
+            const lockPath = node_path_1.default.join(cwd, spec.lockfile);
+            if (!node_fs_1.default.existsSync(lockPath)) {
+                continue;
+            }
+            refreshLockfile(cwd, spec);
+            refreshed.push(spec.lockfile);
+        }
+        return refreshed.sort((a, b) => a.localeCompare(b));
+    },
+};

package/dist/strategy/resolve.js

@@ -4,6 +4,7 @@ exports.listKnownReleaseTypes = listKnownReleaseTypes;
 exports.resolveVersionStrategy = resolveVersionStrategy;
 const latex_js_1 = require("./latex.js");
 const node_js_1 = require("./node.js");
+const python_js_1 = require("./python.js");
 const r_js_1 = require("./r.js");
 const rust_js_1 = require("./rust.js");
 const simple_js_1 = require("./simple.js");
@@ -13,6 +14,7 @@ const strategyRegistry = {
     node: node_js_1.nodeVersionStrategy,
     rust: rust_js_1.rustVersionStrategy,
     r: r_js_1.rVersionStrategy,
+    python: python_js_1.pythonVersionStrategy,
 };
 function listKnownReleaseTypes() {
     return Object.keys(strategyRegistry).sort((a, b) => a.localeCompare(b));

package/package.json

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