versionary 1.0.1 → 1.2.0

package/dist/strategy/cmake.js

@@ -0,0 +1,283 @@
+import fs from "node:fs";
+import path from "node:path";
+const CMAKE_VERSION_PATTERN = /^(?:0|[1-9]\d*)(?:\.(?:0|[1-9]\d*)){2,3}$/u;
+function bracketDelimiterAt(content, index) {
+    const match = content.slice(index).match(/^\[(=*)\[/u);
+    if (!match) {
+        return null;
+    }
+    const equals = match[1] ?? "";
+    return { openLength: equals.length + 2, close: `]${equals}]` };
+}
+function skipBracket(content, index) {
+    const delimiter = bracketDelimiterAt(content, index);
+    if (!delimiter) {
+        return null;
+    }
+    const closeIndex = content.indexOf(delimiter.close, index + delimiter.openLength);
+    return closeIndex === -1
+        ? content.length
+        : closeIndex + delimiter.close.length;
+}
+function skipComment(content, index) {
+    const bracketEnd = skipBracket(content, index + 1);
+    if (bracketEnd !== null) {
+        return bracketEnd;
+    }
+    const newline = content.indexOf("\n", index + 1);
+    return newline === -1 ? content.length : newline;
+}
+function skipQuoted(content, index) {
+    let cursor = index + 1;
+    while (cursor < content.length) {
+        if (content[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (content[cursor] === '"') {
+            return cursor + 1;
+        }
+        cursor += 1;
+    }
+    return content.length;
+}
+function skipTrivia(content, index) {
+    let cursor = index;
+    while (cursor < content.length) {
+        if (/\s/u.test(content[cursor] ?? "")) {
+            cursor += 1;
+            continue;
+        }
+        if (content[cursor] === "#") {
+            cursor = skipComment(content, cursor);
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+function readQuotedArgument(content, start) {
+    const end = skipQuoted(content, start);
+    const closed = end <= content.length && content[end - 1] === '"';
+    const valueEnd = closed ? end - 1 : end;
+    const value = content.slice(start + 1, valueEnd);
+    return {
+        value,
+        start,
+        end,
+        valueStart: start + 1,
+        valueEnd,
+        literal: closed && !value.includes("$"),
+    };
+}
+function readBracketArgument(content, start) {
+    const delimiter = bracketDelimiterAt(content, start);
+    if (!delimiter) {
+        return null;
+    }
+    const end = skipBracket(content, start) ?? content.length;
+    const closed = end < content.length || content.endsWith(delimiter.close);
+    const valueEnd = closed ? end - delimiter.close.length : end;
+    return {
+        value: content.slice(start + delimiter.openLength, valueEnd),
+        start,
+        end,
+        valueStart: start + delimiter.openLength,
+        valueEnd,
+        literal: closed,
+    };
+}
+function readCommand(content, name, openParen) {
+    const args = [];
+    let cursor = openParen + 1;
+    let depth = 1;
+    while (cursor < content.length) {
+        cursor = skipTrivia(content, cursor);
+        if (cursor >= content.length) {
+            break;
+        }
+        const current = content[cursor];
+        if (current === ")") {
+            depth -= 1;
+            cursor += 1;
+            if (depth === 0) {
+                break;
+            }
+            continue;
+        }
+        if (current === "(") {
+            depth += 1;
+            cursor += 1;
+            continue;
+        }
+        if (current === '"') {
+            const argument = readQuotedArgument(content, cursor);
+            if (depth === 1) {
+                args.push(argument);
+            }
+            cursor = argument.end;
+            continue;
+        }
+        if (current === "[") {
+            const argument = readBracketArgument(content, cursor);
+            if (argument) {
+                if (depth === 1) {
+                    args.push(argument);
+                }
+                cursor = argument.end;
+                continue;
+            }
+        }
+        const start = cursor;
+        while (cursor < content.length) {
+            const character = content[cursor];
+            if (/\s/u.test(character ?? "") ||
+                character === "#" ||
+                character === "(" ||
+                character === ")") {
+                break;
+            }
+            cursor += 1;
+        }
+        if (cursor === start) {
+            cursor += 1;
+            continue;
+        }
+        if (depth === 1) {
+            const value = content.slice(start, cursor);
+            args.push({
+                value,
+                start,
+                end: cursor,
+                valueStart: start,
+                valueEnd: cursor,
+                literal: !value.includes("$"),
+            });
+        }
+    }
+    return { name, arguments: args, end: cursor };
+}
+function findCommands(content) {
+    const commands = [];
+    let cursor = 0;
+    while (cursor < content.length) {
+        const current = content[cursor];
+        if (current === "#") {
+            cursor = skipComment(content, cursor);
+            continue;
+        }
+        if (current === '"') {
+            cursor = skipQuoted(content, cursor);
+            continue;
+        }
+        if (current === "[") {
+            const bracketEnd = skipBracket(content, cursor);
+            if (bracketEnd !== null) {
+                cursor = bracketEnd;
+                continue;
+            }
+        }
+        if (!/[A-Za-z_]/u.test(current ?? "")) {
+            cursor += 1;
+            continue;
+        }
+        const nameStart = cursor;
+        cursor += 1;
+        while (/[A-Za-z0-9_]/u.test(content[cursor] ?? "")) {
+            cursor += 1;
+        }
+        const name = content.slice(nameStart, cursor);
+        const openParen = skipTrivia(content, cursor);
+        if (content[openParen] !== "(") {
+            continue;
+        }
+        const command = readCommand(content, name, openParen);
+        commands.push(command);
+        cursor = command.end;
+    }
+    return commands;
+}
+function parseProjectMetadata(content, versionFile) {
+    const projects = findCommands(content).filter((command) => command.name.toLowerCase() === "project");
+    const versionedProjects = projects.filter((command) => command.arguments.some((argument) => argument.value.toUpperCase() === "VERSION"));
+    if (versionedProjects.length !== 1) {
+        if (versionedProjects.length > 1) {
+            throw new Error(`${versionFile} must contain exactly one project() declaration with a VERSION argument required by release-type "cmake"; found ${versionedProjects.length}.`);
+        }
+        throw new Error(`${versionFile} is missing a literal VERSION argument in project() required by release-type "cmake".`);
+    }
+    const project = versionedProjects[0];
+    if (!project) {
+        throw new Error(`Failed to parse ${versionFile}.`);
+    }
+    const versionIndexes = project.arguments.flatMap((argument, index) => argument.value.toUpperCase() === "VERSION" ? [index] : []);
+    if (versionIndexes.length !== 1) {
+        throw new Error(`${versionFile} must contain exactly one VERSION argument in project() required by release-type "cmake".`);
+    }
+    const versionArgument = project.arguments[(versionIndexes[0] ?? -1) + 1];
+    if (!versionArgument?.literal ||
+        !CMAKE_VERSION_PATTERN.test(versionArgument.value)) {
+        throw new Error(`${versionFile} is missing a valid literal VERSION argument in project() required by release-type "cmake"; expected X.Y.Z or X.Y.Z.W.`);
+    }
+    const nameArgument = project.arguments[0];
+    const name = nameArgument?.literal && nameArgument.value.trim().length > 0
+        ? nameArgument.value.trim()
+        : null;
+    return {
+        name,
+        version: versionArgument.value,
+        versionStart: versionArgument.valueStart,
+        versionEnd: versionArgument.valueEnd,
+    };
+}
+export const cmakeVersionStrategy = {
+    name: "cmake",
+    getVersionFile(config) {
+        return config["version-file"] ?? "CMakeLists.txt";
+    },
+    validateProject(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = path.join(cwd, versionFile);
+        if (!fs.existsSync(versionPath)) {
+            return null;
+        }
+        try {
+            parseProjectMetadata(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 parseProjectMetadata(fs.readFileSync(versionPath, "utf8"), versionFile).version;
+    },
+    writeVersion(cwd, config, version) {
+        if (!CMAKE_VERSION_PATTERN.test(version)) {
+            throw new Error(`release-type "cmake" cannot write version "${version}"; CMake project() requires X.Y.Z or X.Y.Z.W without prerelease or build metadata.`);
+        }
+        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 metadata = parseProjectMetadata(existing, versionFile);
+        const updated = `${existing.slice(0, metadata.versionStart)}${version}${existing.slice(metadata.versionEnd)}`;
+        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.`);
+        }
+        return parseProjectMetadata(fs.readFileSync(versionPath, "utf8"), versionFile).name;
+    },
+};

package/dist/strategy/resolve.js

@@ -1,3 +1,4 @@
+import { cmakeVersionStrategy } from "./cmake.js";
 import { compositeVersionStrategy } from "./composite.js";
 import { juliaVersionStrategy } from "./julia.js";
 import { latexVersionStrategy } from "./latex.js";
@@ -7,6 +8,7 @@ import { rVersionStrategy } from "./r.js";
 import { rustVersionStrategy } from "./rust.js";
 import { simpleVersionStrategy } from "./simple.js";
 const strategyRegistry = {
+    cmake: cmakeVersionStrategy,
     julia: juliaVersionStrategy,
     latex: latexVersionStrategy,
     simple: simpleVersionStrategy,

package/dist/types/config.d.ts

@@ -7,6 +7,7 @@ export interface VersionaryArtifactRule {
     "field-path"?: string;
     pattern?: string;
     replacement?: string;
+    "expected-matches"?: number;
 }
 export interface VersionaryPackage {
     "release-type"?: string | string[];
@@ -27,6 +28,7 @@ export interface VersionaryConfig {
     "release-draft"?: boolean;
     "release-reference-comments"?: ReleaseReferenceCommentsMode;
     "release-branch"?: string;
+    "separate-release-prs"?: boolean;
     "baseline-file"?: string;
     "bootstrap-sha"?: string;
     "monorepo-mode"?: "independent" | "fixed";

package/dist/types/plugins.d.ts

@@ -1,7 +1,9 @@
-import type { ScmClientContext, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReleaseReferenceCommentsInput, ScmReleaseReferenceCommentsResult, ScmReviewRequestInput, ScmReviewRequestResult } from "../scm/types.js";
+import type { ScmClientContext, ScmListReviewRequestsInput, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReleaseReferenceCommentsInput, ScmReleaseReferenceCommentsResult, ScmReviewRequestInput, ScmReviewRequestResult, ScmReviewRequestSummary } from "../scm/types.js";
 export type VersionaryPluginCapability = "scm.reviewRequest" | "scm.releaseMetadata" | "scm.releaseReferenceComments";
 export type VersionaryScmReviewRequestInput = ScmReviewRequestInput;
 export type VersionaryScmReviewRequestResult = ScmReviewRequestResult;
+export type VersionaryScmListReviewRequestsInput = ScmListReviewRequestsInput;
+export type VersionaryScmReviewRequestSummary = ScmReviewRequestSummary;
 export type VersionaryScmReleaseMetadataInput = ScmReleaseMetadataInput;
 export type VersionaryScmReleaseMetadataResult = ScmReleaseMetadataResult;
 export type VersionaryScmReleaseReferenceCommentsInput = ScmReleaseReferenceCommentsInput;

package/package.json

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