@mannyc1/ts-release 0.0.2 → 0.0.5

package/dist/planner/release-eligibility.d.ts

@@ -1,33 +1,39 @@
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
 import { ReleaseEligibilityDecision, ReleaseEligibilityInput } from "../domain/remote-state.js";
-import { ReleaseIntent } from "../domain/release.js";
+import { ReleaseIdentity, ReleaseIntent, ReleasePackageManifest } from "../domain/release.js";
+import { GitHubReleaseTarget, NpmRegistryTarget } from "../domain/target.js";
 import { ReleaseCommandRunner } from "../host/host.js";
 import { ReleaseEligibilityCheckError } from "./errors.js";
 export type * from "../types/effect-internal.js";
-declare const ReleasePackageManifest_base: Schema.Class<ReleasePackageManifest, Schema.Struct<{
-    readonly name: Schema.String;
-    readonly version: Schema.String;
-}>, {}>;
-export declare class ReleasePackageManifest extends ReleasePackageManifest_base {
-}
+export { ReleasePackageManifest } from "../domain/release.js";
 declare const ReleaseEligibilityRemoteCheck_base: Schema.Class<ReleaseEligibilityRemoteCheck, Schema.Struct<{
-    readonly packageName: Schema.String;
-    readonly packageVersion: Schema.String;
-    readonly npmTargetId: Schema.String;
+    readonly packageName: Schema.NonEmptyString;
+    readonly packageVersion: Schema.NonEmptyString;
+    readonly npmTargetId: Schema.NonEmptyString;
     readonly npmRegistry: Schema.String;
-    readonly githubTargetId: Schema.String;
+    readonly githubTargetId: Schema.NonEmptyString;
     readonly githubRepository: Schema.String;
+    readonly githubTag: Schema.NonEmptyString;
     readonly githubTokenEnv: Schema.optionalKey<Schema.String>;
     readonly expectedGithubDraft: Schema.Boolean;
 }>, {}>;
 export declare class ReleaseEligibilityRemoteCheck extends ReleaseEligibilityRemoteCheck_base {
 }
+interface ReleaseEligibilityMetadata {
+    readonly strategy?: string | undefined;
+    readonly source?: string | undefined;
+}
 export declare const decideReleaseEligibility: (input: ReleaseEligibilityInput) => ReleaseEligibilityDecision;
+export declare const releaseEligibilityRemoteCheckFromIdentity: (identity: ReleaseIdentity, targets: readonly (NpmRegistryTarget | GitHubReleaseTarget | import("../domain/target.js").HomebrewTapTarget | import("../domain/target.js").PyPiRegistryTarget | import("../domain/target.js").ScoopBucketTarget)[]) => Effect.Effect<ReleaseEligibilityRemoteCheck, ReleaseEligibilityCheckError, never>;
 export declare const releaseEligibilityRemoteCheckFromIntent: (manifest: ReleasePackageManifest, intent: ReleaseIntent) => Effect.Effect<ReleaseEligibilityRemoteCheck, ReleaseEligibilityCheckError, never>;
-export declare const classifyNpmRemoteState: (input: ReleaseEligibilityRemoteCheck) => Effect.Effect<"missing" | "published", ReleaseEligibilityCheckError | import("../host/host.js").CommandRunnerError, ReleaseCommandRunner>;
-export declare const classifyGitHubReleaseAvailability: (input: ReleaseEligibilityRemoteCheck) => Effect.Effect<"missing" | "published" | "draft", ReleaseEligibilityCheckError | import("../host/host.js").CommandRunnerError, ReleaseCommandRunner>;
-export declare const checkReleaseEligibility: (input: ReleaseEligibilityRemoteCheck) => Effect.Effect<ReleaseEligibilityDecision, ReleaseEligibilityCheckError | import("../host/host.js").CommandRunnerError, ReleaseCommandRunner>;
+export declare const classifyNpmRemoteState: (input: ReleaseEligibilityRemoteCheck) => Effect.Effect<"missing" | "published", import("../host/host.js").CommandRunnerError | ReleaseEligibilityCheckError, ReleaseCommandRunner>;
+export declare const classifyGitHubReleaseAvailability: (input: ReleaseEligibilityRemoteCheck) => Effect.Effect<"missing" | "published" | "draft", import("../host/host.js").CommandRunnerError | ReleaseEligibilityCheckError, ReleaseCommandRunner>;
+export declare const checkReleaseEligibility: (input: ReleaseEligibilityRemoteCheck, metadata?: ReleaseEligibilityMetadata | undefined) => Effect.Effect<ReleaseEligibilityDecision, import("../host/host.js").CommandRunnerError | ReleaseEligibilityCheckError, ReleaseCommandRunner>;
+export declare const checkReleaseDecision: (intent: ReleaseIntent, root?: string | undefined) => Effect.Effect<ReleaseEligibilityDecision, import("../host/host.js").CommandRunnerError | import("./errors.js").ReleaseNormalizationError | ReleaseEligibilityCheckError, FileSystem.FileSystem | Path.Path | ReleaseCommandRunner>;
+export declare const checkReleaseIntentRequirement: (intent: ReleaseIntent, root?: string | undefined) => Effect.Effect<ReleaseEligibilityDecision, import("./errors.js").ReleaseNormalizationError | ReleaseEligibilityCheckError, FileSystem.FileSystem | Path.Path>;
 export declare const renderReleaseEligibilityText: (decision: ReleaseEligibilityDecision) => string;
 export declare const renderReleaseEligibilityJson: (decision: ReleaseEligibilityDecision) => string;
 //# sourceMappingURL=release-eligibility.d.ts.map

package/dist/planner/release-eligibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"release-eligibility.d.ts","sourceRoot":"","sources":["../../src/planner/release-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAGL,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAE1D,mBAAmB,6BAA6B,CAAA;;;;;AAEhD,qBAAa,sBAAuB,SAAQ,2BAG1C;CAAG;;;;;;;;;;;AAEL,qBAAa,6BAA8B,SAAQ,kCAWjD;CAAG;AAgBL,eAAO,MAAM,wBAAwB,GACnC,OAAO,uBAAuB,KAC7B,0BAwCF,CAAA;AAsBD,eAAO,MAAM,uCAAuC,gJA2BlD,CAAA;AAkEF,eAAO,MAAM,sBAAsB,qLAiBjC,CAAA;AAEF,eAAO,MAAM,iCAAiC,+LAiB5C,CAAA;AAEF,eAAO,MAAM,uBAAuB,wLAclC,CAAA;AAEF,eAAO,MAAM,4BAA4B,GAAI,UAAU,0BAA0B,KAAG,MACkD,CAAA;AAEtI,eAAO,MAAM,4BAA4B,GAAI,UAAU,0BAA0B,KAAG,MAC1C,CAAA"}
+{"version":3,"file":"release-eligibility.d.ts","sourceRoot":"","sources":["../../src/planner/release-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAGL,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EASL,eAAe,EACf,aAAa,EAGb,sBAAsB,EAIvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAA0B,MAAM,qBAAqB,CAAA;AACpG,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAS1D,mBAAmB,6BAA6B,CAAA;AAEhD,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;;;;;;;;;;;;AAE7D,qBAAa,6BAA8B,SAAQ,kCAYjD;CAAG;AAQL,UAAU,0BAA0B;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACrC;AAuED,eAAO,MAAM,wBAAwB,GACnC,OAAO,uBAAuB,KAC7B,0BAwCF,CAAA;AAgCD,eAAO,MAAM,yCAAyC,wUAqCpD,CAAA;AAEF,eAAO,MAAM,uCAAuC,gJAalD,CAAA;AAgGF,eAAO,MAAM,sBAAsB,qLAiBjC,CAAA;AAEF,eAAO,MAAM,iCAAiC,+LAiB5C,CAAA;AAEF,eAAO,MAAM,uBAAuB,2OAmBlC,CAAA;AAscF,eAAO,MAAM,oBAAoB,0RAW/B,CAAA;AAEF,eAAO,MAAM,6BAA6B,oNA4BxC,CAAA;AAEF,eAAO,MAAM,4BAA4B,GAAI,UAAU,0BAA0B,KAAG,MAQnF,CAAA;AAED,eAAO,MAAM,4BAA4B,GAAI,UAAU,0BAA0B,KAAG,MAC1C,CAAA"}

package/dist/planner/release-eligibility.js

@@ -1,21 +1,24 @@
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
+import * as Semver from "semver";
 import { CommandSpec } from "../domain/operation.js";
 import { ReleaseEligibilityDecision, ReleaseEligibilityInput } from "../domain/remote-state.js";
+import { ConventionalCommitReleaseRule, GitTag, IntentFilesReleaseDecision, PackageManifestReleaseIdentitySource, ReleaseIdentity, ReleaseIntentFile, ReleaseName, ReleaseVersion, RemoteStateReleaseDecision, StaticReleaseIdentitySource } from "../domain/release.js";
+import { TargetId } from "../domain/target.js";
 import { ReleaseCommandRunner } from "../host/host.js";
 import { ReleaseEligibilityCheckError } from "./errors.js";
-export class ReleasePackageManifest extends Schema.Class("ReleasePackageManifest")({
-    name: Schema.String,
-    version: Schema.String
-}) {
-}
+import { readReleasePackageManifest, renderReleaseVersionTemplate, resolveIdentityCommit, resolveReleaseIdentitySource, validateNonEmptySafeRelativePath } from "./normalize-release.js";
+export { ReleasePackageManifest } from "../domain/release.js";
 export class ReleaseEligibilityRemoteCheck extends Schema.Class("ReleaseEligibilityRemoteCheck")({
-    packageName: Schema.String,
-    packageVersion: Schema.String,
-    npmTargetId: Schema.String,
+    packageName: ReleaseName,
+    packageVersion: ReleaseVersion,
+    npmTargetId: TargetId,
     npmRegistry: Schema.String,
-    githubTargetId: Schema.String,
+    githubTargetId: TargetId,
     githubRepository: Schema.String,
+    githubTag: GitTag,
     githubTokenEnv: Schema.optionalKey(Schema.String),
     expectedGithubDraft: Schema.Boolean
 }) {
@@ -25,8 +28,35 @@ class GitHubCliReleaseViewResponse extends Schema.Class("GitHubCliReleaseViewRes
 }) {
 }
 const decodeGitHubCliReleaseViewResponse = Schema.decodeUnknownEffect(GitHubCliReleaseViewResponse);
+const decodeReleaseIntentFile = Schema.decodeUnknownEffect(ReleaseIntentFile);
+const defaultReleaseRules = [
+    ConventionalCommitReleaseRule.make({ breaking: true, release: "major" }),
+    ConventionalCommitReleaseRule.make({ type: "feat", release: "minor" }),
+    ConventionalCommitReleaseRule.make({ type: "fix", release: "patch" })
+];
 const releaseLabel = (input) => `${input.packageName}@${input.packageVersion}`;
 const expectedGithubState = (input) => input.expectedGithubDraft ? "draft" : "published";
+const decisionStrategy = (metadata) => metadata?.strategy;
+const enrichDecision = (decision, input, metadata) => {
+    const strategy = decisionStrategy(metadata);
+    return ReleaseEligibilityDecision.make({
+        shouldRelease: decision.shouldRelease,
+        status: decision.status,
+        reason: decision.reason,
+        ...(strategy === undefined ? {} : { strategy }),
+        packageName: input.packageName,
+        packageVersion: input.packageVersion,
+        githubTag: input.githubTag,
+        ...(metadata?.source === undefined ? {} : { source: metadata.source })
+    });
+};
+const skippedDecision = (reason, metadata) => ReleaseEligibilityDecision.make({
+    shouldRelease: false,
+    status: "skipped",
+    reason,
+    ...(metadata.strategy === undefined ? {} : { strategy: metadata.strategy }),
+    ...(metadata.source === undefined ? {} : { source: metadata.source })
+});
 export const decideReleaseEligibility = (input) => {
     if (input.npm === "missing" && input.github === "missing") {
         return ReleaseEligibilityDecision.make({
@@ -63,32 +93,48 @@ export const decideReleaseEligibility = (input) => {
         reason: `${releaseLabel(input)} has partial remote state: npm=${input.npm}, github=${input.github}, expected-github=${expectedGithub}.`
     });
 };
-const eligibilityError = (reason, targetId) => ReleaseEligibilityCheckError.make({
+const eligibilityError = (reason, targetId, cause) => ReleaseEligibilityCheckError.make({
     ...(targetId === undefined ? {} : { targetId }),
-    reason
+    reason,
+    ...(cause === undefined ? {} : { cause })
 });
-const findNpmTarget = (intent, packageName) => intent.targets.find((target) => target._tag === "NpmRegistryTarget" && (target.packageName === packageName || target.id === "npm"));
-const findGitHubTarget = (intent) => intent.targets.find((target) => target._tag === "GitHubReleaseTarget");
-export const releaseEligibilityRemoteCheckFromIntent = Effect.fn("releaseEligibilityRemoteCheckFromIntent")(function* (manifest, intent) {
-    const npmTarget = findNpmTarget(intent, manifest.name);
+const findNpmTarget = (targets, packageName) => targets.find((target) => target._tag === "NpmRegistryTarget" && target.packageName === packageName);
+const findNpmTargetById = (targets, targetId) => targets.find((target) => target._tag === "NpmRegistryTarget" && target.id === targetId);
+const findGitHubTarget = (targets) => targets.find((target) => target._tag === "GitHubReleaseTarget");
+export const releaseEligibilityRemoteCheckFromIdentity = Effect.fn("releaseEligibilityRemoteCheckFromIdentity")(function* (identity, targets) {
+    const npmTarget = findNpmTarget(targets, identity.name);
     if (npmTarget === undefined) {
-        return yield* Effect.fail(eligibilityError(`release config must include an npm target for ${manifest.name}`));
+        const npmTargetById = findNpmTargetById(targets, "npm");
+        if (npmTargetById !== undefined) {
+            return yield* Effect.fail(eligibilityError(`npm target ${npmTargetById.id} packageName ${npmTargetById.packageName} does not match release identity ${identity.name}.`, npmTargetById.id));
+        }
+        return yield* Effect.fail(eligibilityError(`release config must include an npm target for ${identity.name}`));
     }
-    const githubTarget = findGitHubTarget(intent);
+    const githubTarget = findGitHubTarget(targets);
     if (githubTarget === undefined) {
         return yield* Effect.fail(eligibilityError("release config must include a GitHub release target"));
     }
     return ReleaseEligibilityRemoteCheck.make({
-        packageName: manifest.name,
-        packageVersion: manifest.version,
+        packageName: identity.name,
+        packageVersion: identity.version,
         npmTargetId: npmTarget.id,
         npmRegistry: npmTarget.registry,
         githubTargetId: githubTarget.id,
         githubRepository: githubTarget.repository,
+        githubTag: identity.tag ?? identity.version,
         ...(githubTarget.tokenEnv === undefined ? {} : { githubTokenEnv: githubTarget.tokenEnv }),
         expectedGithubDraft: githubTarget.draft ?? false
     });
 });
+export const releaseEligibilityRemoteCheckFromIntent = Effect.fn("releaseEligibilityRemoteCheckFromIntent")(function* (manifest, intent) {
+    const staticTag = intent.identity instanceof StaticReleaseIdentitySource ? intent.identity.tag : undefined;
+    return yield* releaseEligibilityRemoteCheckFromIdentity(ReleaseIdentity.make({
+        name: manifest.name,
+        version: manifest.version,
+        commit: "HEAD",
+        ...(staticTag === undefined ? {} : { tag: staticTag })
+    }), intent.targets);
+});
 const looksMissing = (stdout, stderr) => {
     const text = `${stdout}\n${stderr}`.toLowerCase();
     return text.includes("not found") || text.includes("404") || text.includes("e404");
@@ -117,7 +163,7 @@ const githubReleaseViewCommand = (input) => CommandSpec.make({
     args: [
         "release",
         "view",
-        `v${input.packageVersion}`,
+        input.githubTag,
         "--repo",
         input.githubRepository,
         "--json",
@@ -126,10 +172,33 @@ const githubReleaseViewCommand = (input) => CommandSpec.make({
     requiredEnv: input.githubTokenEnv === undefined ? [] : [input.githubTokenEnv],
     redactedEnv: input.githubTokenEnv === undefined ? [] : [input.githubTokenEnv]
 });
+const gitTagsAtHeadCommand = (root) => CommandSpec.make({
+    executable: "git",
+    args: ["tag", "--points-at", "HEAD"],
+    cwd: root,
+    requiredEnv: [],
+    redactedEnv: []
+});
+const gitListTagsCommand = (root) => CommandSpec.make({
+    executable: "git",
+    args: ["tag", "--list", "--merged", "HEAD"],
+    cwd: root,
+    requiredEnv: [],
+    redactedEnv: []
+});
+const gitLogCommand = (root, sinceTag) => CommandSpec.make({
+    executable: "git",
+    args: sinceTag === undefined
+        ? ["log", "--format=%B%x1e"]
+        : ["log", `${sinceTag}..HEAD`, "--format=%B%x1e"],
+    cwd: root,
+    requiredEnv: [],
+    redactedEnv: []
+});
 const parseGitHubCliReleaseView = Effect.fn("parseGitHubCliReleaseView")(function* (input, stdout) {
     const parsed = yield* Effect.try({
         try: () => JSON.parse(stdout),
-        catch: (cause) => eligibilityError(cause instanceof Error ? cause.message : String(cause), input.githubTargetId)
+        catch: (cause) => eligibilityError("gh release view returned invalid JSON.", input.githubTargetId, cause)
     });
     const response = yield* decodeGitHubCliReleaseViewResponse(parsed).pipe(Effect.mapError((error) => eligibilityError(`gh release view returned malformed JSON: ${error.message}`, input.githubTargetId)));
     return response.isDraft ? "draft" : "published";
@@ -156,17 +225,354 @@ export const classifyGitHubReleaseAvailability = Effect.fn("classifyGitHubReleas
     }
     return yield* Effect.fail(eligibilityError(`gh release view failed while checking release state: ${firstDiagnosticLine(result)}`, input.githubTargetId));
 });
-export const checkReleaseEligibility = Effect.fn("checkReleaseEligibility")(function* (input) {
+export const checkReleaseEligibility = Effect.fn("checkReleaseEligibility")(function* (input, metadata = undefined) {
     const npm = yield* classifyNpmRemoteState(input);
     const github = yield* classifyGitHubReleaseAvailability(input);
-    return decideReleaseEligibility(ReleaseEligibilityInput.make({
+    return enrichDecision(decideReleaseEligibility(ReleaseEligibilityInput.make({
         packageName: input.packageName,
         packageVersion: input.packageVersion,
         expectedGithubDraft: input.expectedGithubDraft,
         npm,
         github
-    }));
+    })), input, metadata);
 });
-export const renderReleaseEligibilityText = (decision) => `release eligibility status=${decision.status} should-release=${decision.shouldRelease} reason=${JSON.stringify(decision.reason)}\n`;
+const strategyFromIntent = (intent) => intent.releaseDecision ?? RemoteStateReleaseDecision.make({});
+const identitySourceName = (intent) => intent.identity instanceof PackageManifestReleaseIdentitySource
+    ? "PackageManifestReleaseIdentitySource"
+    : "StaticReleaseIdentitySource";
+const checkRemoteStateForIdentity = Effect.fn("checkRemoteStateForIdentity")(function* (identity, targets, metadata) {
+    const remoteCheck = yield* releaseEligibilityRemoteCheckFromIdentity(identity, targets);
+    return yield* checkReleaseEligibility(remoteCheck, metadata);
+});
+const skippedReleaseResolution = (decision) => ({
+    _tag: "Skipped",
+    decision
+});
+const resolvedReleaseResolution = (identity, targets, metadata) => ({
+    _tag: "Resolved",
+    identity,
+    targets,
+    metadata
+});
+const resolveRemoteStateDecision = Effect.fn("resolveRemoteStateDecision")(function* (strategy, intent, root) {
+    const identity = yield* resolveReleaseIdentitySource(intent.identity, root);
+    return resolvedReleaseResolution(identity, intent.targets, {
+        strategy: strategy._tag,
+        source: identitySourceName(intent)
+    });
+});
+const templateParts = (template, field) => {
+    const placeholder = "{version}";
+    const firstIndex = template.indexOf(placeholder);
+    const lastIndex = template.lastIndexOf(placeholder);
+    if (firstIndex >= 0 && firstIndex === lastIndex) {
+        return Effect.succeed({
+            prefix: template.slice(0, firstIndex),
+            suffix: template.slice(firstIndex + placeholder.length)
+        });
+    }
+    return Effect.fail(eligibilityError(`${field} must contain exactly one {version} placeholder.`));
+};
+const versionFromTag = (tag, parts) => {
+    if (!tag.startsWith(parts.prefix) || !tag.endsWith(parts.suffix)) {
+        return undefined;
+    }
+    const suffixStart = tag.length - parts.suffix.length;
+    const version = tag.slice(parts.prefix.length, suffixStart);
+    return version.length === 0 ? undefined : version;
+};
+const stdoutLines = (stdout) => stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+const readMatchingCurrentTags = Effect.fn("readMatchingCurrentTags")(function* (root, template, providedTag, requireCurrentRef) {
+    const parts = yield* templateParts(template, "releaseDecision.tagTemplate");
+    const tags = providedTag !== undefined && !requireCurrentRef
+        ? [providedTag]
+        : yield* Effect.gen(function* () {
+            const commandRunner = yield* ReleaseCommandRunner;
+            const result = yield* commandRunner.runCommand(gitTagsAtHeadCommand(root));
+            if (result.exitCode !== 0) {
+                return yield* Effect.fail(eligibilityError(`git tag --points-at HEAD failed: ${firstDiagnosticLine(result)}`));
+            }
+            const currentTags = stdoutLines(result.stdout);
+            return providedTag === undefined
+                ? currentTags
+                : currentTags.filter((tag) => tag === providedTag);
+        });
+    return tags.flatMap((tag) => {
+        const version = versionFromTag(tag, parts);
+        return version === undefined ? [] : [{ tag, version }];
+    });
+});
+const resolveTagIdentity = Effect.fn("resolveTagIdentity")(function* (root, manifest, tag) {
+    return yield* resolveIdentityCommit(ReleaseIdentity.make({
+        name: manifest.name,
+        version: tag.version,
+        commit: "HEAD",
+        tag: tag.tag
+    }), root);
+});
+const resolveGitTagDecision = Effect.fn("resolveGitTagDecision")(function* (strategy, intent, root) {
+    const metadata = {
+        strategy: strategy._tag,
+        source: strategy.tag === undefined ? "git tag --points-at HEAD" : `tag ${strategy.tag}`
+    };
+    const manifest = yield* readReleasePackageManifest(root, strategy.packagePath ?? "package.json", "releaseDecision.packagePath");
+    const tagTemplate = strategy.tagTemplate ?? "v{version}";
+    const requireCurrentRef = strategy.requireCurrentRef ?? true;
+    const matchingTags = yield* readMatchingCurrentTags(root, tagTemplate, strategy.tag, requireCurrentRef);
+    if (matchingTags.length === 0) {
+        if (strategy.tag !== undefined && requireCurrentRef) {
+            return skippedReleaseResolution(skippedDecision(`Release tag ${strategy.tag} does not point at HEAD.`, metadata));
+        }
+        return skippedReleaseResolution(skippedDecision("No release tag matching releaseDecision.tagTemplate points at HEAD.", metadata));
+    }
+    if (matchingTags.length > 1) {
+        return yield* Effect.fail(eligibilityError(`Multiple release tags match ${tagTemplate}: ${matchingTags.map((tag) => tag.tag).join(", ")}.`));
+    }
+    const tag = matchingTags[0];
+    if (tag === undefined) {
+        return skippedReleaseResolution(skippedDecision("No release tag matching releaseDecision.tagTemplate points at HEAD.", metadata));
+    }
+    const identity = yield* resolveTagIdentity(root, manifest, tag);
+    return resolvedReleaseResolution(identity, intent.targets, metadata);
+});
+const matchingTagsFromList = Effect.fn("matchingTagsFromList")(function* (stdout, template) {
+    const parts = yield* templateParts(template, "releaseDecision.tagTemplate");
+    const candidates = [];
+    for (const tag of stdoutLines(stdout)) {
+        const version = versionFromTag(tag, parts);
+        if (version === undefined) {
+            continue;
+        }
+        const validVersion = Semver.valid(version);
+        if (validVersion !== null) {
+            candidates.push({ tag, version: validVersion });
+        }
+    }
+    return candidates.sort((left, right) => Semver.rcompare(left.version, right.version));
+});
+const latestMatchingTag = Effect.fn("latestMatchingTag")(function* (root, template) {
+    const commandRunner = yield* ReleaseCommandRunner;
+    const result = yield* commandRunner.runCommand(gitListTagsCommand(root));
+    if (result.exitCode !== 0) {
+        return yield* Effect.fail(eligibilityError(`git tag --list failed: ${firstDiagnosticLine(result)}`));
+    }
+    const matching = yield* matchingTagsFromList(result.stdout, template);
+    return matching[0];
+});
+const parseCommit = (message) => {
+    const firstLine = message.split(/\r?\n/)[0]?.trim() ?? "";
+    const match = /^([A-Za-z][A-Za-z0-9-]*)(?:\([^)]+\))?(!)?:/.exec(firstLine);
+    const type = match?.[1];
+    const breakingSubject = match?.[2] === "!";
+    const breakingBody = /^BREAKING[ -]CHANGE:/m.test(message);
+    return {
+        type,
+        breaking: breakingSubject || breakingBody
+    };
+};
+const bumpRank = (bump) => {
+    switch (bump) {
+        case "major":
+            return 3;
+        case "minor":
+            return 2;
+        case "patch":
+            return 1;
+        case "none":
+            return 0;
+    }
+};
+const higherBump = (left, right) => bumpRank(right) > bumpRank(left) ? right : left;
+const ruleMatches = (rule, commit) => {
+    if (rule.breaking !== undefined && rule.breaking !== commit.breaking) {
+        return false;
+    }
+    if (rule.type !== undefined && rule.type !== commit.type) {
+        return false;
+    }
+    return rule.breaking !== undefined || rule.type !== undefined;
+};
+const classifyConventionalCommitBump = (message, rules) => {
+    const commit = parseCommit(message);
+    let bump = "none";
+    for (const rule of rules) {
+        if (ruleMatches(rule, commit)) {
+            bump = higherBump(bump, rule.release);
+        }
+    }
+    return bump;
+};
+const readCommitMessages = Effect.fn("readCommitMessages")(function* (root, sinceTag) {
+    const commandRunner = yield* ReleaseCommandRunner;
+    const result = yield* commandRunner.runCommand(gitLogCommand(root, sinceTag));
+    if (result.exitCode !== 0) {
+        return yield* Effect.fail(eligibilityError(`git log failed: ${firstDiagnosticLine(result)}`));
+    }
+    return result.stdout
+        .split("\x1e")
+        .map((message) => message.trim())
+        .filter((message) => message.length > 0);
+});
+const nextSemverVersion = (version, bump, field) => {
+    const validVersion = Semver.valid(version);
+    if (validVersion === null) {
+        return Effect.fail(eligibilityError(`${field} must be a valid SemVer version.`));
+    }
+    const nextVersion = Semver.inc(validVersion, bump);
+    if (nextVersion !== null) {
+        return Effect.succeed(nextVersion);
+    }
+    return Effect.fail(eligibilityError(`Unable to increment ${validVersion} as ${bump}.`));
+};
+const highestConventionalBump = (messages, rules) => {
+    let bump = "none";
+    for (const message of messages) {
+        bump = higherBump(bump, classifyConventionalCommitBump(message, rules));
+    }
+    return bump;
+};
+const resolveConventionalCommitsDecision = Effect.fn("resolveConventionalCommitsDecision")(function* (strategy, intent, root) {
+    const metadata = {
+        strategy: strategy._tag,
+        source: "git commits"
+    };
+    const tagTemplate = strategy.tagTemplate ?? "v{version}";
+    const manifest = yield* readReleasePackageManifest(root, strategy.packagePath ?? "package.json", "releaseDecision.packagePath");
+    const latest = yield* latestMatchingTag(root, tagTemplate);
+    const messages = yield* readCommitMessages(root, latest?.tag);
+    if (messages.length === 0) {
+        return skippedReleaseResolution(skippedDecision("No commits were found for conventional commit analysis.", metadata));
+    }
+    const bump = highestConventionalBump(messages, strategy.releaseRules ?? defaultReleaseRules);
+    if (bump === "none") {
+        return skippedReleaseResolution(skippedDecision("No releasable conventional commits were found.", metadata));
+    }
+    const baseVersion = latest?.version ?? manifest.version;
+    const nextVersion = yield* nextSemverVersion(baseVersion, bump, latest === undefined ? "package.json version" : "release tag version");
+    const identity = yield* resolveIdentityCommit(ReleaseIdentity.make({
+        name: manifest.name,
+        version: nextVersion,
+        commit: "HEAD",
+        tag: renderReleaseVersionTemplate(tagTemplate, nextVersion)
+    }), root);
+    return resolvedReleaseResolution(identity, intent.targets, metadata);
+});
+const readIntentFiles = Effect.fn("readIntentFiles")(function* (root, strategy) {
+    const directory = strategy.directory ?? ".release/intents";
+    yield* validateNonEmptySafeRelativePath("releaseDecision.directory", directory);
+    const manifest = yield* readReleasePackageManifest(root, strategy.packagePath ?? "package.json", "releaseDecision.packagePath");
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const absoluteDirectory = path.resolve(root, directory);
+    const entries = yield* fs.readDirectory(absoluteDirectory).pipe(Effect.catch(() => Effect.succeed([])));
+    const files = [];
+    for (const entry of entries.filter((item) => item.endsWith(".json")).sort()) {
+        yield* validateNonEmptySafeRelativePath("releaseDecision.intentFile", entry);
+        const intentPath = path.join(absoluteDirectory, entry);
+        const contents = yield* fs.readFileString(intentPath).pipe(Effect.mapError((error) => eligibilityError(`Unable to read release intent file ${entry}: ${error.message}`, undefined, error)));
+        const parsed = yield* Effect.try({
+            try: () => JSON.parse(contents),
+            catch: (cause) => eligibilityError(`Release intent file ${entry} is not valid JSON.`, undefined, cause)
+        });
+        const decoded = yield* decodeReleaseIntentFile(parsed).pipe(Effect.mapError((error) => eligibilityError(`Release intent file ${entry} is invalid: ${error.message}`)));
+        if (decoded.package === manifest.name) {
+            files.push(decoded);
+        }
+    }
+    return {
+        manifest,
+        packageName: manifest.name,
+        directory,
+        files
+    };
+});
+const highestIntentBump = (files) => {
+    let bump = "none";
+    for (const file of files) {
+        const release = file.empty === true ? "none" : file.release;
+        bump = higherBump(bump, release);
+    }
+    return bump;
+};
+const resolveIntentFilesDecision = Effect.fn("resolveIntentFilesDecision")(function* (strategy, intent, root) {
+    const metadata = {
+        strategy: strategy._tag,
+        source: strategy.directory ?? ".release/intents"
+    };
+    const intentFiles = yield* readIntentFiles(root, strategy);
+    const manifest = intentFiles.manifest;
+    if (intentFiles.files.length === 0) {
+        return skippedReleaseResolution(skippedDecision(`No release intent files were found for ${manifest.name}.`, metadata));
+    }
+    const bump = highestIntentBump(intentFiles.files);
+    if (bump === "none") {
+        return skippedReleaseResolution(skippedDecision(`Release intent files for ${manifest.name} request no release.`, metadata));
+    }
+    const nextVersion = yield* nextSemverVersion(manifest.version, bump, "package.json version");
+    const tagTemplate = strategy.tagTemplate ?? "v{version}";
+    yield* templateParts(tagTemplate, "releaseDecision.tagTemplate");
+    const identity = yield* resolveIdentityCommit(ReleaseIdentity.make({
+        name: manifest.name,
+        version: nextVersion,
+        commit: "HEAD",
+        tag: renderReleaseVersionTemplate(tagTemplate, nextVersion)
+    }), root);
+    return resolvedReleaseResolution(identity, intent.targets, metadata);
+});
+const resolveReleaseDecision = Effect.fn("resolveReleaseDecision")(function* (intent, root = ".") {
+    const strategy = strategyFromIntent(intent);
+    switch (strategy._tag) {
+        case "RemoteStateReleaseDecision":
+            return yield* resolveRemoteStateDecision(strategy, intent, root);
+        case "GitTagReleaseDecision":
+            return yield* resolveGitTagDecision(strategy, intent, root);
+        case "ConventionalCommitsReleaseDecision":
+            return yield* resolveConventionalCommitsDecision(strategy, intent, root);
+        case "IntentFilesReleaseDecision":
+            return yield* resolveIntentFilesDecision(strategy, intent, root);
+    }
+});
+export const checkReleaseDecision = Effect.fn("checkReleaseDecision")(function* (intent, root = ".") {
+    const resolution = yield* resolveReleaseDecision(intent, root);
+    switch (resolution._tag) {
+        case "Skipped":
+            return resolution.decision;
+        case "Resolved":
+            return yield* checkRemoteStateForIdentity(resolution.identity, resolution.targets, resolution.metadata);
+    }
+});
+export const checkReleaseIntentRequirement = Effect.fn("checkReleaseIntentRequirement")(function* (intent, root = ".") {
+    const strategy = strategyFromIntent(intent);
+    if (!(strategy instanceof IntentFilesReleaseDecision)) {
+        return skippedDecision("Release config is not using IntentFilesReleaseDecision.", {
+            strategy: strategy._tag,
+            source: "releaseDecision"
+        });
+    }
+    const intentFiles = yield* readIntentFiles(root, strategy);
+    if (intentFiles.files.length === 0 && (strategy.requireIntent ?? true)) {
+        return yield* Effect.fail(eligibilityError(`release intent files are required for ${intentFiles.packageName} in ${intentFiles.directory}.`));
+    }
+    const bump = highestIntentBump(intentFiles.files);
+    return ReleaseEligibilityDecision.make({
+        shouldRelease: bump !== "none",
+        status: bump === "none" ? "skipped" : "ready",
+        reason: bump === "none"
+            ? `Release intent files for ${intentFiles.packageName} request no release.`
+            : `Release intent files for ${intentFiles.packageName} request a ${bump} release.`,
+        strategy: strategy._tag,
+        packageName: intentFiles.packageName,
+        source: intentFiles.directory
+    });
+});
+export const renderReleaseEligibilityText = (decision) => {
+    const strategy = decision.strategy === undefined ? "" : ` strategy=${decision.strategy}`;
+    const source = decision.source === undefined ? "" : ` source=${JSON.stringify(decision.source)}`;
+    const release = decision.packageName === undefined || decision.packageVersion === undefined
+        ? ""
+        : ` release=${decision.packageName}@${decision.packageVersion}`;
+    const tag = decision.githubTag === undefined ? "" : ` github-tag=${decision.githubTag}`;
+    return `release eligibility status=${decision.status} should-release=${decision.shouldRelease}${strategy}${source}${release}${tag} reason=${JSON.stringify(decision.reason)}\n`;
+};
 export const renderReleaseEligibilityJson = (decision) => `${JSON.stringify(decision, null, 2)}\n`;
 //# sourceMappingURL=release-eligibility.js.map