@astra-kit/rp 0.0.0-stage → 0.10.0

package/src/version-files.js

@@ -0,0 +1,142 @@
+/**
+ * `versionFiles`: files besides `package.json` that carry the version (a CLI
+ * `--version`, a user agent, a constant) and are rewritten in the release
+ * commit. Only marked lines change:
+ *
+ * - a line with `astra-rp-version` (or release-please's `x-release-please-version`);
+ * - every line between `astra-rp-start-version` and `astra-rp-end` (or
+ *   `x-release-please-start-version` / `x-release-please-end`).
+ *
+ * @module version-files
+ */
+
+import {
+  LINE_TERMINATOR_BOUNDARY_PATTERN,
+  MARKED_VERSION_PATTERN,
+  VERSION_BLOCK_END_MARKERS,
+  VERSION_BLOCK_PROBLEM,
+  VERSION_BLOCK_START_MARKERS,
+  VERSION_LINE_MARKERS,
+} from "./constants/version-files.js";
+
+/**
+ * @typedef {{ content: string, markedLines: number, replacements: number }} VersionFileUpdate
+ *   `markedLines` counts the lines the markers selected; `replacements` the versions rewritten.
+ */
+
+/**
+ * @typedef {"unterminated" | "unopened" | "nested" | "mismatched"} VersionBlockProblem
+ *   How the block markers are paired wrongly; see `VERSION_BLOCK_PROBLEM`.
+ */
+
+/**
+ * Version block markers paired wrongly: nothing is rewritten, since guessing where the block ends
+ * could change versions outside the intended section.
+ */
+export class VersionBlockError extends Error {
+  /**
+   * @param {{ problem: VersionBlockProblem, lineNumber: number, marker: string, openingLineNumber?: number, openingMarker?: string }} details
+   *   `lineNumber` (1-based) and `marker` locate the offending marker; `openingLineNumber` and
+   *   `openingMarker` the start marker of the block still open, when there is one.
+   */
+  constructor({ problem, lineNumber, marker, openingLineNumber, openingMarker }) {
+    super(`astra-rp:updateVersionMarkers ${problem} version block: ${marker} at line ${lineNumber}`);
+    this.name = "VersionBlockError";
+    this.problem = problem;
+    this.lineNumber = lineNumber;
+    this.marker = marker;
+    this.openingLineNumber = openingLineNumber;
+    this.openingMarker = openingMarker;
+  }
+}
+
+/**
+ * @param {string} line - Line of the file.
+ * @param {readonly string[]} markers - Markers to look for.
+ * @returns {number} Index of the first marker the line carries, or `-1` when it carries none.
+ */
+function findMarkerIndex(line, markers) {
+  return markers.findIndex((marker) => line.includes(marker));
+}
+
+/**
+ * Rewrites the versions of the marked lines of a file, keeping everything else (line endings
+ * included) byte for byte. `\n`, `\r\n` and a lone `\r` all end a line.
+ *
+ * @param {string} content - File content.
+ * @param {string} version - Version to write.
+ * @returns {VersionFileUpdate} New content and what the markers selected.
+ * @throws {VersionBlockError} When a block is left open, closed without being opened, opened
+ *   inside another block or closed with the end marker of the other tool.
+ */
+export function updateVersionMarkers(content, version) {
+  /** @type {{ markerIndex: number, lineNumber: number } | null} */
+  let openBlock = null;
+  let markedLines = 0;
+  let replacements = 0;
+
+  /** @type {string[]} */
+  const lines = [];
+
+  for (const [index, line] of content.split(LINE_TERMINATOR_BOUNDARY_PATTERN).entries()) {
+    const lineNumber = index + 1;
+    const startMarkerIndex = findMarkerIndex(line, VERSION_BLOCK_START_MARKERS);
+    const endMarkerIndex = findMarkerIndex(line, VERSION_BLOCK_END_MARKERS);
+
+    if (startMarkerIndex !== -1) {
+      if (openBlock !== null) {
+        throw new VersionBlockError({
+          problem: VERSION_BLOCK_PROBLEM.nested,
+          lineNumber,
+          marker: VERSION_BLOCK_START_MARKERS[startMarkerIndex],
+          openingLineNumber: openBlock.lineNumber,
+          openingMarker: VERSION_BLOCK_START_MARKERS[openBlock.markerIndex],
+        });
+      }
+      openBlock = { markerIndex: startMarkerIndex, lineNumber };
+      lines.push(line);
+      continue;
+    }
+    if (endMarkerIndex !== -1) {
+      if (openBlock === null) {
+        throw new VersionBlockError({ problem: VERSION_BLOCK_PROBLEM.unopened, lineNumber, marker: VERSION_BLOCK_END_MARKERS[endMarkerIndex] });
+      }
+      if (endMarkerIndex !== openBlock.markerIndex) {
+        throw new VersionBlockError({
+          problem: VERSION_BLOCK_PROBLEM.mismatched,
+          lineNumber,
+          marker: VERSION_BLOCK_END_MARKERS[endMarkerIndex],
+          openingLineNumber: openBlock.lineNumber,
+          openingMarker: VERSION_BLOCK_START_MARKERS[openBlock.markerIndex],
+        });
+      }
+      openBlock = null;
+      lines.push(line);
+      continue;
+    }
+    if (openBlock === null && findMarkerIndex(line, VERSION_LINE_MARKERS) === -1) {
+      lines.push(line);
+      continue;
+    }
+    markedLines += 1;
+    lines.push(
+      line.replace(MARKED_VERSION_PATTERN, () => {
+        replacements += 1;
+        return version;
+      })
+    );
+  }
+
+  if (openBlock !== null) {
+    const openingMarker = VERSION_BLOCK_START_MARKERS[openBlock.markerIndex];
+    throw new VersionBlockError({
+      problem: VERSION_BLOCK_PROBLEM.unterminated,
+      lineNumber: openBlock.lineNumber,
+      marker: openingMarker,
+      openingLineNumber: openBlock.lineNumber,
+      openingMarker,
+    });
+  }
+
+  return { content: lines.join(""), markedLines, replacements };
+}

package/src/versions.js

@@ -0,0 +1,303 @@
+/**
+ * Release version rules: only stable `X.Y.Z` versions exist, and after a
+ * version only its next patch, minor or major is allowed (from `1.2.3`:
+ * `1.2.4`, `1.3.0` or `2.0.0`). No version can be skipped, repeated or
+ * lowered, and prereleases or build metadata are never released.
+ *
+ * @module versions
+ */
+
+import {
+  BREAKING_CHANGE_FOOTER_PATTERN,
+  CONVENTIONAL_HEADER_PATTERN,
+  FEATURE_COMMIT_TYPE,
+  LEGACY_FEATURE_SUBJECT_PATTERN,
+  PRE_MAJOR_SHIFTED_RELEASE_TYPE,
+  PRE_MAJOR_VERSION,
+  RELEASE_TAG_PREFIX,
+  RELEASE_TYPE,
+  RELEASE_TYPE_ORDER,
+  RELEASE_VERSION_PATTERN,
+  SEMVER_PATTERN,
+  UNRELEASED_PLACEHOLDER_VERSION,
+} from "./constants/versions.js";
+
+/**
+ * @typedef {"patch" | "minor" | "major"} ReleaseType
+ * @typedef {{ releaseType: ReleaseType, version: string }} NextVersion
+ */
+
+/**
+ * Returns whether a value is a stable `X.Y.Z` release version.
+ *
+ * @param {unknown} version - Candidate version.
+ * @returns {boolean} `true` only for plain `X.Y.Z` without prerelease, metadata, prefix or leading zeros.
+ */
+export function isStableReleaseVersion(version) {
+  return typeof version === "string" && RELEASE_VERSION_PATTERN.test(version);
+}
+
+/**
+ * Parses a stable `X.Y.Z` version.
+ *
+ * @param {string} version - Version such as `0.93.0`.
+ * @returns {[number, number, number]} Major, minor and patch numbers.
+ * @throws {Error} When the version is not a stable release version.
+ */
+export function parseReleaseVersion(version) {
+  const match = RELEASE_VERSION_PATTERN.exec(String(version));
+
+  if (!match) {
+    throw new Error(`astra-rp:parseReleaseVersion expected X.Y.Z, received "${version}"`);
+  }
+
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+/**
+ * Compares two stable `X.Y.Z` versions numerically.
+ *
+ * @param {string} leftVersion - First version.
+ * @param {string} rightVersion - Second version.
+ * @returns {number} Negative when `leftVersion` is lower, `0` when equal, positive when higher.
+ * @throws {Error} When either version is not a stable release version.
+ */
+export function compareReleaseVersions(leftVersion, rightVersion) {
+  const left = parseReleaseVersion(leftVersion);
+  const right = parseReleaseVersion(rightVersion);
+  const differentIndex = left.findIndex((part, index) => part !== right[index]);
+  return differentIndex === -1 ? 0 : left[differentIndex] - right[differentIndex];
+}
+
+/**
+ * Tells whether a stable version is above any semver version, prereleases included: `1.0.0` is
+ * above `1.0.0-beta.1` and `0.9.0`, but not above `1.1.0-beta.1`.
+ *
+ * @param {string} stableVersion - Stable `X.Y.Z` version.
+ * @param {string} otherVersion - Version to compare with, such as the `latest` dist-tag of npm.
+ * @returns {boolean} `true` when `stableVersion` is higher; `false` otherwise or when `otherVersion` is not semver.
+ */
+export function isStableVersionAbove(stableVersion, otherVersion) {
+  const match = SEMVER_PATTERN.exec(String(otherVersion));
+
+  if (!match) {
+    return false;
+  }
+
+  const [, core, prerelease] = match;
+  const difference = compareReleaseVersions(stableVersion, core);
+  return difference > 0 || (difference === 0 && Boolean(prerelease));
+}
+
+/**
+ * Returns the highest stable version of a list, ignoring prereleases and invalid entries.
+ *
+ * @param {unknown[]} versions - Versions, such as the ones `npm view <pkg> versions` lists.
+ * @returns {string | null} Highest stable `X.Y.Z` version, or `null` when there is none.
+ */
+export function findHighestStableVersion(versions) {
+  /** @type {string | null} */
+  let highest = null;
+
+  for (const version of versions) {
+    if (typeof version === "string" && isStableReleaseVersion(version) && (highest === null || compareReleaseVersions(version, highest) > 0)) {
+      highest = version;
+    }
+  }
+
+  return highest;
+}
+
+/**
+ * Returns the next version for a semver release type.
+ *
+ * @param {string} version - Current `X.Y.Z` version.
+ * @param {ReleaseType} releaseType - One of {@link RELEASE_TYPE}.
+ * @returns {string} Next `X.Y.Z` version.
+ * @throws {Error} When the version is not stable or the release type is unknown.
+ */
+export function bumpReleaseVersion(version, releaseType) {
+  const [major, minor, patch] = parseReleaseVersion(version);
+
+  switch (releaseType) {
+    case RELEASE_TYPE.major:
+      return `${major + 1}.0.0`;
+    case RELEASE_TYPE.minor:
+      return `${major}.${minor + 1}.0`;
+    case RELEASE_TYPE.patch:
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      throw new Error(`astra-rp:bumpReleaseVersion unknown release type "${releaseType}"`);
+  }
+}
+
+/**
+ * Lists the only versions allowed after the current one: the next patch,
+ * minor and major. Anything else would skip versions or go backwards.
+ *
+ * @param {string} currentVersion - Current `X.Y.Z` version.
+ * @returns {NextVersion[]} Allowed next versions, patch first.
+ */
+export function listNextVersions(currentVersion) {
+  return RELEASE_TYPE_ORDER.map((releaseType) => ({
+    releaseType,
+    version: bumpReleaseVersion(currentVersion, releaseType),
+  }));
+}
+
+/**
+ * Lists the versions allowed after any previous semver version. A previous
+ * prerelease is also followed by its own stable release (`1.0.0-beta.1` →
+ * `1.0.0`).
+ *
+ * @param {string} previousVersion - Previous version, stable or prerelease.
+ * @returns {string[] | null} Allowed versions, or `null` when the previous version is not semver.
+ */
+export function listAllowedVersionsAfter(previousVersion) {
+  const match = SEMVER_PATTERN.exec(String(previousVersion));
+
+  if (!match) {
+    return null;
+  }
+
+  const [, core, prerelease] = match;
+  const nextVersions = listNextVersions(core).map((candidate) => candidate.version);
+
+  return prerelease ? [core, ...nextVersions] : nextVersions;
+}
+
+/**
+ * Resolves the version requested through `--bump` or `--set-version`.
+ *
+ * @param {string} currentVersion - Current `X.Y.Z` version.
+ * @param {{ bump: ReleaseType | null, setVersion: string | null }} request - Parsed CLI options.
+ * @returns {NextVersion | null} Requested version, or `null` to ask interactively.
+ * @throws {Error} With a Spanish message when the request is invalid.
+ */
+export function resolveRequestedVersion(currentVersion, { bump, setVersion }) {
+  const nextVersions = listNextVersions(currentVersion);
+
+  if (bump) {
+    return nextVersions.find((candidate) => candidate.releaseType === bump) ?? null;
+  }
+
+  if (setVersion === null || setVersion === undefined) {
+    return null;
+  }
+
+  if (!isStableReleaseVersion(setVersion)) {
+    throw new Error(`--set-version espera el formato X.Y.Z y recibió "${setVersion}".`);
+  }
+
+  const match = nextVersions.find((candidate) => candidate.version === setVersion);
+
+  if (!match) {
+    const allowed = nextVersions.map((candidate) => candidate.version).join(", ");
+    throw new Error(
+      `--set-version ${setVersion} no es válida después de ${currentVersion}: tiene que ser mayor y no saltear versiones. Opciones: ${allowed}.`
+    );
+  }
+
+  return match;
+}
+
+/**
+ * Builds the Git tag name of a release version.
+ *
+ * @param {string} version - `X.Y.Z` version.
+ * @returns {string} Tag such as `v0.94.0`.
+ */
+export function toReleaseTag(version) {
+  return `${RELEASE_TAG_PREFIX}${version}`;
+}
+
+/**
+ * Returns whether a commit subject is a release bump commit (`0.93.0`).
+ *
+ * @param {string} subject - Commit subject.
+ * @returns {boolean} `true` for version-only subjects.
+ */
+export function isReleaseCommitSubject(subject) {
+  return isStableReleaseVersion(subject.trim());
+}
+
+/**
+ * Suggests the semver release type for the commits that will ship.
+ *
+ * Breaking changes suggest `major`; features (conventional `feat` or legacy
+ * imperative subjects such as "Add ...") suggest `minor`; a set made only of
+ * conventional maintenance commits (`fix`, `chore`, `docs`, ...) suggests
+ * `patch`. Unknown legacy subjects suggest `minor`.
+ *
+ * @param {{ subject: string, body?: string }[]} commits - Commits since the last release.
+ * @returns {{ releaseType: ReleaseType, reason: string }} Suggested type and a Spanish explanation.
+ */
+export function suggestReleaseType(commits) {
+  const shippedCommits = commits.filter((commit) => !isReleaseCommitSubject(commit.subject));
+  let hasFeature = false;
+  let hasUnknownSubject = false;
+
+  for (const commit of shippedCommits) {
+    const header = CONVENTIONAL_HEADER_PATTERN.exec(commit.subject);
+
+    if (header?.groups?.breaking || BREAKING_CHANGE_FOOTER_PATTERN.test(commit.body ?? "")) {
+      return { releaseType: RELEASE_TYPE.major, reason: "hay cambios incompatibles (breaking change)" };
+    }
+
+    if (header?.groups) {
+      hasFeature ||= header.groups.type.toLowerCase() === FEATURE_COMMIT_TYPE;
+      continue;
+    }
+
+    if (LEGACY_FEATURE_SUBJECT_PATTERN.test(commit.subject)) {
+      hasFeature = true;
+    } else {
+      hasUnknownSubject = true;
+    }
+  }
+
+  if (hasFeature) {
+    return { releaseType: RELEASE_TYPE.minor, reason: "hay funcionalidades nuevas" };
+  }
+
+  if (hasUnknownSubject || shippedCommits.length === 0) {
+    return { releaseType: RELEASE_TYPE.minor, reason: "criterio habitual del repositorio" };
+  }
+
+  return { releaseType: RELEASE_TYPE.patch, reason: "solo hay arreglos y mantenimiento" };
+}
+
+/**
+ * Tells whether `preMajorShift` lowers the release levels after `currentVersion`: only when the
+ * option is on and the version is `0.x`, except the `0.0.0` placeholder of a package never released.
+ *
+ * @param {string} currentVersion - Current `X.Y.Z` version.
+ * @param {{ preMajorShift?: boolean }} [options] - Project versioning options.
+ * @returns {boolean} `true` when the release levels move one level down.
+ */
+export function isPreMajorShiftActive(currentVersion, { preMajorShift = false } = {}) {
+  return preMajorShift && currentVersion !== UNRELEASED_PLACEHOLDER_VERSION && parseReleaseVersion(currentVersion)[0] === PRE_MAJOR_VERSION;
+}
+
+/**
+ * Suggests the release type of the next version after `currentVersion`: {@link suggestReleaseType},
+ * shifted one level down while the version is `0.x` when `preMajorShift` is on (breaking changes
+ * suggest `minor` and features `patch`, so a suggestion never jumps to `1.0.0`). The first release
+ * of a `0.0.0` package is not shifted.
+ *
+ * @param {{ subject: string, body?: string }[]} commits - Commits since the last release.
+ * @param {string} currentVersion - Current `X.Y.Z` version.
+ * @param {{ preMajorShift?: boolean }} [options] - Project versioning options.
+ * @returns {{ releaseType: ReleaseType, reason: string }} Suggested type and a Spanish explanation.
+ */
+export function suggestNextReleaseType(commits, currentVersion, { preMajorShift = false } = {}) {
+  const suggestion = suggestReleaseType(commits);
+  if (!isPreMajorShiftActive(currentVersion, { preMajorShift })) {
+    return suggestion;
+  }
+
+  const shiftedReleaseType = PRE_MAJOR_SHIFTED_RELEASE_TYPE[suggestion.releaseType];
+  return shiftedReleaseType === suggestion.releaseType
+    ? suggestion
+    : { releaseType: shiftedReleaseType, reason: `${suggestion.reason}; antes de 1.0.0 baja un nivel` };
+}

package/types/build-gate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Decides whether Vercel builds a commit (`vercel.json` → `ignoreCommand`).
+ *
+ * Only a stable `X.Y.Z` version that is the next patch, minor or major of the
+ * previous commit's version ships, the same rule `create-version` applies. An
+ * unchanged, lower or skipped version (`1.0.0` → `3.0.0`) and any prerelease
+ * or build-metadata version skip the build. When the previous version cannot
+ * be read there is nothing to compare, so a stable version builds.
+ *
+ * A release delegated to CI is skipped only on the commit that changes
+ * `.astra-rp/release.json` against its first parent, the same commit scoping the
+ * generated `.astra-rp/vercel-ignore-build.mjs` applies (that template stays
+ * dependency-free, so it inlines the check). Later commits keep the metadata
+ * untouched and fall through to the version rule. Without a readable parent
+ * (shallow clone or first commit) the release commit is recognized by its own
+ * `Astra-Rp-Execution: ci` trailer, which later commits never carry, so the
+ * deployment still waits for the release workflow.
+ *
+ * @module build-gate
+ */
+export type BuildDecision = {
+    shouldBuild: boolean;
+    reason: string;
+};
+/**
+ * @typedef {{ shouldBuild: boolean, reason: string }} BuildDecision
+ */
+/**
+ * Decides whether a commit is built.
+ *
+ * @param {string | null} previousVersion - Version of the previous commit, or `null` when unreadable.
+ * @param {string | null} currentVersion - Version of the commit being deployed, or `null` when unreadable.
+ * @returns {BuildDecision} Decision and a log line.
+ */
+export declare function decideBuild(previousVersion: string | null, currentVersion: string | null): BuildDecision;
+/**
+ * Reads the previous and the current `package.json` versions of a Git
+ * checkout and decides whether it is built.
+ *
+ * @param {string} repositoryRoot - Checkout whose `HEAD` is being deployed.
+ * @returns {BuildDecision} Decision and a log line.
+ */
+export declare function decideBuildForCheckout(repositoryRoot: string): BuildDecision;

package/types/changelog-blocks.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Internal helpers that split `CHANGELOG.md` into release blocks and rewrite the `[Unreleased]`
+ * block. Shared by the public `@astra-kit/rp/changelog` module and by `create-version`; not part of the
+ * package's public API (no `exports` entry and no reexport from `@astra-kit/rp`).
+ *
+ * @module changelog-blocks
+ */
+export type ChangelogBlock = {
+    label: string;
+    heading: string;
+    start: number;
+    bodyStart: number;
+    end: number;
+};
+/**
+ * @typedef {{ label: string, heading: string, start: number, bodyStart: number, end: number }} ChangelogBlock
+ */
+/**
+ * Splits the changelog into release blocks in document order.
+ *
+ * @param {string} changelog - CHANGELOG.md contents.
+ * @returns {ChangelogBlock[]} Blocks.
+ */
+export declare function listBlocks(changelog: string): ChangelogBlock[];
+/**
+ * Replaces the `[Unreleased]` block with `body`, or inserts the block above the newest release.
+ *
+ * @param {string} changelog - Existing contents, or an empty string for a new file.
+ * @param {string} body - New block body, already using `lineBreak`.
+ * @param {string} lineBreak - Line break written around the body.
+ * @returns {string} Changelog with the new `[Unreleased]` block.
+ */
+export declare function replaceUnreleasedBody(changelog: string, body: string, lineBreak: string): string;

package/types/changelog.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Generates CHANGELOG.md entries from commits and releases `[Unreleased]`.
+ *
+ * A release lists the hash and original subject of every commit since the
+ * previous version, then moves the block under `## [X.Y.Z] - YYYY-MM-DD`.
+ * Published history, including legacy unbracketed headings, is preserved.
+ *
+ * `astra-rp create-version` does not generate entries from commits: it requires entries under
+ * `[Unreleased]`, written by hand or, with `changelogDraft`, drafted by an agent CLI, and in the
+ * release commit only renames that heading to `## [X.Y.Z] - YYYY-MM-DD` and adds an empty
+ * `[Unreleased]` on top, keeping any section names.
+ *
+ * @module changelog
+ */
+/**
+ * Replaces `[Unreleased]` with the exact commit list for the next version.
+ * Creates the block or document when missing and preserves released history.
+ *
+ * @param {string} changelog - Existing contents, or an empty string for a new file.
+ * @param {{ sha: string, subject: string }[]} commits - Commits since the previous release, newest first.
+ * @returns {string} Changelog with one hash and original subject per commit.
+ * @throws {Error} When there are no commits to release.
+ */
+export declare function fillUnreleasedFromCommits(changelog: string, commits: {
+    sha: string;
+    subject: string;
+}[]): string;
+export type ChangelogBlock = import("./changelog-blocks.js").ChangelogBlock;
+export type UnreleasedState = {
+    exists: boolean;
+    entryCount: number;
+    unknownSections: string[];
+    body: string;
+};
+/**
+ * Describes the `## [Unreleased]` block.
+ *
+ * @param {string} changelog - CHANGELOG.md contents.
+ * @returns {UnreleasedState} Unreleased state.
+ */
+export declare function readUnreleased(changelog: string): UnreleasedState;
+/**
+ * Returns the newest released block (the first one that is not `[Unreleased]`).
+ *
+ * @param {string} changelog - CHANGELOG.md contents.
+ * @returns {{ version: string, entryCount: number } | null} Latest release entry.
+ */
+export declare function readLatestRelease(changelog: string): {
+    version: string;
+    entryCount: number;
+} | null;
+/**
+ * Moves the `[Unreleased]` changes under a new version heading and leaves an empty `[Unreleased]` block.
+ *
+ * @param {string} changelog - CHANGELOG.md contents.
+ * @param {string} version - Version being released.
+ * @param {string} releaseDate - Date in `YYYY-MM-DD` format.
+ * @returns {string} Released changelog.
+ * @throws {Error} When `[Unreleased]` is missing, empty or uses an unknown section.
+ */
+export declare function releaseUnreleased(changelog: string, version: string, releaseDate: string): string;

package/types/constants/build-gate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Contract between the `astra-rp ignore-build` command and the Vercel
+ * `ignoreCommand` wrapper that reads its output.
+ *
+ * @module constants/build-gate
+ */
+/** Decision printed as the last output line of `astra-rp ignore-build`. */
+export declare const BUILD_DECISION: Readonly<{
+    build: "BUILD";
+    skip: "SKIP";
+}>;
+/** Git revision whose `package.json` holds the previous version. */
+export declare const PREVIOUS_REVISION = "HEAD^";
+/** Git revision being deployed. */
+export declare const CURRENT_REVISION = "HEAD";
+/** `git diff --quiet` status reporting that the compared path changed between both revisions. */
+export declare const GIT_DIFF_CHANGED_STATUS = 1;
+/** Manifest that holds the version. */
+export declare const PACKAGE_MANIFEST_FILE = "package.json";
+/** Exit code of `astra-rp ignore-build` when a decision was printed. */
+export declare const DECISION_EXIT_CODE = 0;
+/** Exit code of `astra-rp ignore-build` when it could not decide; wrappers must skip the build. */
+export declare const GATE_FAILURE_EXIT_CODE = 2;