@oscharko-dev/keiko-contracts 0.2.8 → 0.2.9

package/dist/git-history.js

@@ -0,0 +1,73 @@
+// Read-only Git commit history wire contract (Issue #1573, Epic #1572).
+// Pure types + validation helpers only: no filesystem, no process, no clock, no crypto.
+// Reuses GitRepositoryState / GitUnavailableReason / GitRepositoryValidation from git-repository.
+import { GIT_REPOSITORY_STATES } from "./git-repository.js";
+export const GIT_HISTORY_SCHEMA_VERSION = "1";
+function isRecord(input) {
+    return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function isString(input) {
+    return typeof input === "string";
+}
+function isBoolean(input) {
+    return typeof input === "boolean";
+}
+function isNonNegativeInteger(input) {
+    return typeof input === "number" && Number.isInteger(input) && input >= 0;
+}
+function validateRefs(input, reasons, index) {
+    if (!Array.isArray(input)) {
+        reasons.push(`entries[${String(index)}].refs must be an array`);
+        return;
+    }
+    if (!input.every(isString)) {
+        reasons.push(`entries[${String(index)}].refs must contain only strings`);
+    }
+}
+function validateEntry(input, reasons, index) {
+    if (!isRecord(input)) {
+        reasons.push(`entries[${String(index)}] must be an object`);
+        return;
+    }
+    for (const key of ["sha", "shortSha", "subject", "author", "date"]) {
+        if (!isString(input[key]))
+            reasons.push(`entries[${String(index)}].${key} must be a string`);
+    }
+    for (const key of ["parentCount", "changedFileCount"]) {
+        if (!isNonNegativeInteger(input[key])) {
+            reasons.push(`entries[${String(index)}].${key} must be a non-negative integer`);
+        }
+    }
+    validateRefs(input.refs, reasons, index);
+}
+// History is a paginated wire envelope (entries + limit/skip/truncated); centralizing the
+// validator keeps per-field failure messages predictable for tests and callers.
+// eslint-disable-next-line complexity
+export function validateGitHistoryResponse(input) {
+    const reasons = [];
+    if (!isRecord(input))
+        return { ok: false, reasons: ["response must be an object"] };
+    if (input.schemaVersion !== GIT_HISTORY_SCHEMA_VERSION)
+        reasons.push("schemaVersion invalid");
+    if (!isString(input.root))
+        reasons.push("root must be a string");
+    if (!GIT_REPOSITORY_STATES.includes(input.state)) {
+        reasons.push("state invalid");
+    }
+    if (!isBoolean(input.available))
+        reasons.push("available must be a boolean");
+    if (!isBoolean(input.truncated))
+        reasons.push("truncated must be a boolean");
+    if (!isNonNegativeInteger(input.limit))
+        reasons.push("limit must be a non-negative integer");
+    if (!isNonNegativeInteger(input.skip))
+        reasons.push("skip must be a non-negative integer");
+    if (!Array.isArray(input.entries))
+        reasons.push("entries must be an array");
+    else {
+        input.entries.forEach((entry, index) => {
+            validateEntry(entry, reasons, index);
+        });
+    }
+    return reasons.length === 0 ? { ok: true } : { ok: false, reasons };
+}

package/dist/git-merge.d.ts

@@ -0,0 +1,67 @@
+import type { GitDeliveryExecutionErrorCode, GitDeliveryMergeBlockReason, GitDeliveryMergeStrategyHint, GitDeliveryParseResult } from "./git-delivery.js";
+import type { GitDeliveryRecoveryActionHint } from "./git-delivery-action-sheet.js";
+import type { GitDeliveryRecoveryDisposition } from "./git-delivery-evidence.js";
+import type { GitDeliveryBranchProtection, GitDeliveryChecksState, GitDeliveryPullRequestState } from "./git-delivery-provider.js";
+export declare const GIT_MERGE_SCHEMA_VERSION: "1";
+export type GitMergeLifecycleBlockerCode = "pr-not-open" | "pr-already-merged" | "draft-pr" | "strategy-unavailable" | "readiness-unknown" | "provider-error";
+export declare const GIT_MERGE_LIFECYCLE_BLOCKER_CODES: readonly GitMergeLifecycleBlockerCode[];
+export type GitMergeReadinessBlockerCode = GitDeliveryMergeBlockReason | GitMergeLifecycleBlockerCode;
+export declare const GIT_MERGE_READINESS_BLOCKER_CODES: readonly GitMergeReadinessBlockerCode[];
+export type GitMergeBlockerSeverity = "blocking" | "advisory";
+export type GitMergeRemediationClass = "user-actionable" | "internal";
+export interface GitMergeReadinessBlocker {
+    readonly code: GitMergeReadinessBlockerCode;
+    readonly severity: GitMergeBlockerSeverity;
+    readonly remediation: GitMergeRemediationClass;
+}
+export interface GitMergeReadinessSummary {
+    readonly schemaVersion: typeof GIT_MERGE_SCHEMA_VERSION;
+    readonly mergeable: boolean;
+    readonly blockers: readonly GitMergeReadinessBlocker[];
+}
+export declare function gitMergeBlockerRemediationFor(code: GitMergeReadinessBlockerCode): GitMergeRemediationClass;
+export declare function gitMergeBlockerActionHintFor(code: GitMergeReadinessBlockerCode): GitDeliveryRecoveryActionHint | undefined;
+export interface GitMergeStrategyPolicy {
+    readonly allowedStrategies: readonly GitDeliveryMergeStrategyHint[];
+}
+export interface GitMergeStrategyEligibility {
+    readonly eligible: readonly GitDeliveryMergeStrategyHint[];
+    readonly selectedDefault: GitDeliveryMergeStrategyHint | undefined;
+    readonly requestedEligible: boolean;
+}
+export declare function deriveEligibleMergeStrategies(requested: GitDeliveryMergeStrategyHint, policy: GitMergeStrategyPolicy, providerCapable: readonly GitDeliveryMergeStrategyHint[]): GitMergeStrategyEligibility;
+export type GitMergeRecommendation = "merge-allowed" | "needs-approval" | "blocked" | "already-merged";
+export declare const GIT_MERGE_RECOMMENDATIONS: readonly GitMergeRecommendation[];
+export interface GitMergeApprovalContext {
+    readonly requiresApproval: boolean;
+    readonly approvalSatisfied: boolean;
+}
+export declare function gitMergeRecommendationFor(readiness: GitMergeReadinessSummary, approval: GitMergeApprovalContext): GitMergeRecommendation;
+export type GitMergeRejectionReason = "not-mergeable" | "checks-failing" | "approvals-missing" | "conflict" | "head-modified" | "strategy-unavailable" | "branch-protection" | "already-merged" | "not-found" | "permission-denied" | "rate-limited" | "provider-unavailable" | "unknown";
+export declare const GIT_MERGE_REJECTION_REASONS: readonly GitMergeRejectionReason[];
+export declare const GIT_MERGE_REJECTION_ERROR_CODE: Readonly<Record<GitMergeRejectionReason, GitDeliveryExecutionErrorCode>>;
+export declare const GIT_MERGE_REJECTION_DISPOSITION: Readonly<Record<GitMergeRejectionReason, GitDeliveryRecoveryDisposition>>;
+export declare function gitMergeRejectionToErrorCode(reason: GitMergeRejectionReason): GitDeliveryExecutionErrorCode;
+export declare function gitMergeRejectionToDisposition(reason: GitMergeRejectionReason): GitDeliveryRecoveryDisposition;
+export interface GitMergeRejection {
+    readonly reason: GitMergeRejectionReason;
+    readonly disposition: GitDeliveryRecoveryDisposition;
+    readonly actionHint?: GitDeliveryRecoveryActionHint | undefined;
+}
+export declare function gitMergeRejectionFor(reason: GitMergeRejectionReason): GitMergeRejection;
+export declare const isGitMergeReadinessBlockerCode: (v: unknown) => v is GitMergeReadinessBlockerCode;
+export declare const isGitMergeRecommendation: (v: unknown) => v is GitMergeRecommendation;
+export declare const isGitMergeRejectionReason: (v: unknown) => v is GitMergeRejectionReason;
+export interface GitMergeReadinessInput {
+    readonly pullRequest?: GitDeliveryPullRequestState | undefined;
+    readonly checks?: GitDeliveryChecksState | undefined;
+    readonly branchProtection?: GitDeliveryBranchProtection | undefined;
+    readonly strategyEligible?: boolean | undefined;
+    readonly providerError?: boolean | undefined;
+}
+export declare function gitMergeReadinessFor(input: GitMergeReadinessInput): GitMergeReadinessSummary;
+export declare function gitMergeReadinessBlockerIsPrerequisite(code: GitMergeReadinessBlockerCode): boolean;
+export declare function isGitMergeReadinessBlocker(value: unknown): value is GitMergeReadinessBlocker;
+export declare function isGitMergeReadinessSummary(value: unknown): value is GitMergeReadinessSummary;
+export declare function parseGitMergeReadinessSummary(value: unknown): GitDeliveryParseResult<GitMergeReadinessSummary>;
+//# sourceMappingURL=git-merge.d.ts.map

package/dist/git-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-merge.d.ts","sourceRoot":"","sources":["../src/git-merge.ts"],"names":[],"mappings":"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"}

package/dist/git-merge.js

@@ -0,0 +1,323 @@
+// Governed merge orchestration contracts (Issue #478, Epic #470; ADR-0065). Ownership: the
+// provider-neutral, content-free merge-governance leaf — the merge-readiness model, the strategy
+// eligibility derivation, the merge recommendation, and the provider-failure rejection taxonomy. It is
+// the merge counterpart of git-pull-request.ts (the PR-orchestration leaf) and sits on top of the
+// existing merge action kind, merge inputs, merge strategy hints, the merge block-reason taxonomy, the
+// provider-state interfaces, the execution-error codes, and the recovery vocabulary.
+//
+// Disjoint from git-delivery.ts (the action/risk model), git-delivery-provider.ts (provider-neutral
+// state), git-delivery-evidence.ts (the audit record), git-delivery-action-sheet.ts (the approval
+// surface), and git-pull-request.ts (the PR leaf). The GitHub-specific transport, the mergeable-state
+// mapper, and the raw-error classifier are keiko-tools concerns; this leaf never imports a kernel type
+// and never carries raw provider content.
+//
+// Leaf-package rules (ADR-0019, ADR-0058, ADR-0065): pure types, frozen const tables, and pure
+// functions only. No IO, no clock, no crypto, no randomness, no provider field names. Relative imports
+// end in ".js" and reference only sibling git-delivery*.ts leaves.
+//
+// Content-free by construction: a merge carries no user-authored free content. Its readiness is derived
+// from counts, typed enums, and booleans (the provider-state interfaces), never from raw diffs, commit
+// bodies, or provider error envelopes.
+import { GIT_DELIVERY_MERGE_BLOCK_REASONS, GIT_DELIVERY_MERGE_STRATEGY_HINTS, } from "./git-delivery.js";
+// Pinned schema version. A breaking change adds a NEW literal member; this one is never mutated.
+export const GIT_MERGE_SCHEMA_VERSION = "1";
+export const GIT_MERGE_LIFECYCLE_BLOCKER_CODES = [
+    "pr-not-open",
+    "pr-already-merged",
+    "draft-pr",
+    "strategy-unavailable",
+    "readiness-unknown",
+    "provider-error",
+];
+export const GIT_MERGE_READINESS_BLOCKER_CODES = [
+    ...GIT_DELIVERY_MERGE_BLOCK_REASONS,
+    ...GIT_MERGE_LIFECYCLE_BLOCKER_CODES,
+];
+// Frozen, exhaustive code → remediation table. Keyed on every code so a new code forces an explicit
+// classification here (the Record is not Partial).
+const MERGE_BLOCKER_REMEDIATION = {
+    "checks-failing": "user-actionable",
+    "approvals-missing": "user-actionable",
+    conflicts: "user-actionable",
+    "branch-protection": "user-actionable",
+    "merge-queue-position": "user-actionable",
+    "provider-policy": "internal",
+    "pr-not-open": "user-actionable",
+    "pr-already-merged": "user-actionable",
+    "draft-pr": "user-actionable",
+    "strategy-unavailable": "user-actionable",
+    "readiness-unknown": "internal",
+    "provider-error": "internal",
+};
+export function gitMergeBlockerRemediationFor(code) {
+    return MERGE_BLOCKER_REMEDIATION[code];
+}
+// ─── Recovery action hints (reused #473 vocabulary) ───────────────────────────────────────────────────
+// Hints only where the vocabulary fits cleanly; a blocker with no clean hint carries none rather than a
+// misleading one. The precise blocker code remains the primary user-facing signal.
+const MERGE_BLOCKER_ACTION_HINT = {
+    "checks-failing": "wait-for-provider",
+    "approvals-missing": "request-approval",
+    conflicts: "resolve-conflicts",
+    "branch-protection": "adjust-policy-target",
+    "merge-queue-position": "wait-for-provider",
+    "provider-policy": "adjust-policy-target",
+    "pr-not-open": undefined,
+    "pr-already-merged": undefined,
+    "draft-pr": undefined,
+    "strategy-unavailable": "recover-via-strategy",
+    "readiness-unknown": "wait-for-provider",
+    "provider-error": "wait-for-provider",
+};
+export function gitMergeBlockerActionHintFor(code) {
+    return MERGE_BLOCKER_ACTION_HINT[code];
+}
+// "provider-default" defers strategy choice to the provider; it is eligible iff policy permits it AND at
+// least one CONCRETE strategy is eligible (so the provider has something to default to). Concrete
+// strategies are eligible iff both policy and provider allow them.
+export function deriveEligibleMergeStrategies(requested, policy, providerCapable) {
+    const policySet = new Set(policy.allowedStrategies);
+    const providerSet = new Set(providerCapable);
+    const concrete = GIT_DELIVERY_MERGE_STRATEGY_HINTS.filter((s) => s !== "provider-default" && policySet.has(s) && providerSet.has(s));
+    const providerDefaultEligible = policySet.has("provider-default") && concrete.length > 0;
+    const eligible = [...concrete];
+    if (providerDefaultEligible) {
+        eligible.push("provider-default");
+    }
+    const requestedEligible = eligible.includes(requested);
+    const selectedDefault = requestedEligible ? requested : eligible[0];
+    return {
+        eligible,
+        ...(selectedDefault !== undefined ? { selectedDefault } : { selectedDefault: undefined }),
+        requestedEligible,
+    };
+}
+export const GIT_MERGE_RECOMMENDATIONS = [
+    "merge-allowed",
+    "needs-approval",
+    "blocked",
+    "already-merged",
+];
+export function gitMergeRecommendationFor(readiness, approval) {
+    if (readiness.blockers.some((b) => b.code === "pr-already-merged")) {
+        return "already-merged";
+    }
+    if (readiness.blockers.some((b) => b.severity === "blocking")) {
+        return "blocked";
+    }
+    if (approval.requiresApproval && !approval.approvalSatisfied) {
+        return "needs-approval";
+    }
+    return "merge-allowed";
+}
+export const GIT_MERGE_REJECTION_REASONS = [
+    "not-mergeable",
+    "checks-failing",
+    "approvals-missing",
+    "conflict",
+    "head-modified",
+    "strategy-unavailable",
+    "branch-protection",
+    "already-merged",
+    "not-found",
+    "permission-denied",
+    "rate-limited",
+    "provider-unavailable",
+    "unknown",
+];
+// Exhaustive reason → content-free execution error code (recorded in evidence). Total Record (not
+// Partial): a new reason is a compile error here rather than a silent gap.
+export const GIT_MERGE_REJECTION_ERROR_CODE = {
+    "not-mergeable": "precondition-failed",
+    "checks-failing": "precondition-failed",
+    "approvals-missing": "precondition-failed",
+    conflict: "conflict",
+    "head-modified": "precondition-failed",
+    "strategy-unavailable": "provider-rejected",
+    "branch-protection": "provider-rejected",
+    "already-merged": "precondition-failed",
+    "not-found": "provider-rejected",
+    "permission-denied": "provider-rejected",
+    "rate-limited": "network-failure",
+    "provider-unavailable": "network-failure",
+    unknown: "provider-rejected",
+};
+// Exhaustive reason → three-way recovery disposition (reused #474 vocabulary).
+export const GIT_MERGE_REJECTION_DISPOSITION = {
+    "not-mergeable": "user-fixable",
+    "checks-failing": "user-fixable",
+    "approvals-missing": "user-fixable",
+    conflict: "user-fixable",
+    "head-modified": "retryable",
+    "strategy-unavailable": "user-fixable",
+    "branch-protection": "policy-forbidden",
+    "already-merged": "none",
+    "not-found": "user-fixable",
+    "permission-denied": "policy-forbidden",
+    "rate-limited": "retryable",
+    "provider-unavailable": "retryable",
+    unknown: "user-fixable",
+};
+// Reason → recovery action hint, where the vocabulary fits cleanly (else none).
+const MERGE_REJECTION_ACTION_HINT = {
+    "not-mergeable": undefined,
+    "checks-failing": "wait-for-provider",
+    "approvals-missing": "request-approval",
+    conflict: "resolve-conflicts",
+    "head-modified": "retry",
+    "strategy-unavailable": "recover-via-strategy",
+    "branch-protection": "adjust-policy-target",
+    "already-merged": undefined,
+    "not-found": undefined,
+    "permission-denied": undefined,
+    "rate-limited": "wait-for-provider",
+    "provider-unavailable": "wait-for-provider",
+    unknown: undefined,
+};
+export function gitMergeRejectionToErrorCode(reason) {
+    return GIT_MERGE_REJECTION_ERROR_CODE[reason];
+}
+export function gitMergeRejectionToDisposition(reason) {
+    return GIT_MERGE_REJECTION_DISPOSITION[reason];
+}
+export function gitMergeRejectionFor(reason) {
+    const actionHint = MERGE_REJECTION_ACTION_HINT[reason];
+    return {
+        reason,
+        disposition: gitMergeRejectionToDisposition(reason),
+        ...(actionHint !== undefined ? { actionHint } : {}),
+    };
+}
+// ─── Private predicate helpers ──────────────────────────────────────────────────────────────────────
+function isString(value) {
+    return typeof value === "string";
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInSet(set) {
+    return (v) => isString(v) && set.includes(v);
+}
+// ─── Exported enum guards ─────────────────────────────────────────────────────────────────────────
+export const isGitMergeReadinessBlockerCode = isInSet(GIT_MERGE_READINESS_BLOCKER_CODES);
+export const isGitMergeRecommendation = isInSet(GIT_MERGE_RECOMMENDATIONS);
+export const isGitMergeRejectionReason = isInSet(GIT_MERGE_REJECTION_REASONS);
+function blocking(code) {
+    return { code, severity: "blocking", remediation: gitMergeBlockerRemediationFor(code) };
+}
+function advisory(code) {
+    return { code, severity: "advisory", remediation: gitMergeBlockerRemediationFor(code) };
+}
+const MERGE_PREREQ_CODES = new Set(GIT_DELIVERY_MERGE_BLOCK_REASONS);
+// The provider merge-readiness signal plus the approval/check enrichment, in deterministic order.
+// Duplicates (a blockingReason that coincides with the approvals/checks derivation) are removed by the
+// caller's dedupeByCode, so no `.includes` guards are needed here.
+function mergePrerequisiteCodes(mr, checksFailing) {
+    const codes = [];
+    if (!mr.ready && mr.blockingReason !== undefined) {
+        codes.push(mr.blockingReason);
+    }
+    if (mr.receivedApprovalCount < mr.requiredApprovalCount) {
+        codes.push("approvals-missing");
+    }
+    if (!mr.ready && checksFailing) {
+        codes.push("checks-failing");
+    }
+    return codes;
+}
+// Merge-prerequisite blocker codes for an OPEN PR, in deterministic order. Draft and strategy come
+// first (preview-time facts), then the provider merge-readiness signal, then the readiness-unknown
+// fallback when not ready and nothing concrete was surfaced.
+function collectOpenPrBlockerCodes(pr, input) {
+    const codes = [];
+    if (pr.isDraft) {
+        codes.push("draft-pr");
+    }
+    if (input.strategyEligible === false) {
+        codes.push("strategy-unavailable");
+    }
+    codes.push(...mergePrerequisiteCodes(pr.mergeReadiness, input.checks?.overallStatus === "failing"));
+    if (!pr.mergeReadiness.ready && codes.length === 0) {
+        codes.push("readiness-unknown");
+    }
+    return codes;
+}
+function collectMergeBlocking(input) {
+    if (input.providerError === true) {
+        return [blocking("provider-error")];
+    }
+    const pr = input.pullRequest;
+    if (pr === undefined) {
+        return [blocking("readiness-unknown")];
+    }
+    if (pr.status === "merged") {
+        return [blocking("pr-already-merged")];
+    }
+    if (pr.status === "closed") {
+        return [blocking("pr-not-open")];
+    }
+    return dedupeByCode(collectOpenPrBlockerCodes(pr, input)).map(blocking);
+}
+function collectMergeAdvisory(input) {
+    const pr = input.pullRequest;
+    // A provider-mergeable PR whose non-required checks are failing (e.g. an "unstable" state): merge is
+    // permitted, but the failing checks are worth surfacing as an advisory.
+    if (pr?.status === "open" &&
+        !pr.isDraft &&
+        pr.mergeReadiness.ready &&
+        input.checks?.overallStatus === "failing") {
+        return [advisory("checks-failing")];
+    }
+    return [];
+}
+function dedupeByCode(codes) {
+    const seen = new Set();
+    const out = [];
+    for (const code of codes) {
+        if (!seen.has(code)) {
+            seen.add(code);
+            out.push(code);
+        }
+    }
+    return out;
+}
+export function gitMergeReadinessFor(input) {
+    const blockingBlockers = collectMergeBlocking(input);
+    const advisoryBlockers = collectMergeAdvisory(input);
+    return {
+        schemaVersion: GIT_MERGE_SCHEMA_VERSION,
+        mergeable: blockingBlockers.length === 0,
+        blockers: [...blockingBlockers, ...advisoryBlockers],
+    };
+}
+// `MERGE_PREREQ_CODES` is exported indirectly through gitMergeReadinessBlockerIsPrerequisite so callers
+// can tell a merge-prerequisite blocker (the #471 taxonomy) from a lifecycle/preview blocker.
+export function gitMergeReadinessBlockerIsPrerequisite(code) {
+    return MERGE_PREREQ_CODES.has(code);
+}
+// ─── Structural guards ──────────────────────────────────────────────────────────────────────────────
+export function isGitMergeReadinessBlocker(value) {
+    return (isRecord(value) &&
+        isGitMergeReadinessBlockerCode(value.code) &&
+        (value.severity === "blocking" || value.severity === "advisory") &&
+        (value.remediation === "user-actionable" || value.remediation === "internal"));
+}
+function isBlockerArray(value) {
+    return Array.isArray(value) && value.every(isGitMergeReadinessBlocker);
+}
+export function isGitMergeReadinessSummary(value) {
+    return (isRecord(value) &&
+        value.schemaVersion === GIT_MERGE_SCHEMA_VERSION &&
+        isBoolean(value.mergeable) &&
+        isBlockerArray(value.blockers));
+}
+// ─── Parse ──────────────────────────────────────────────────────────────────────────────────────────
+export function parseGitMergeReadinessSummary(value) {
+    if (!isGitMergeReadinessSummary(value)) {
+        return { ok: false, errors: ["value is not a valid GitMergeReadinessSummary"] };
+    }
+    return { ok: true, value };
+}

package/dist/git-pull-request.d.ts

@@ -0,0 +1,112 @@
+import type { GitDeliveryExecutionErrorCode, GitDeliveryParseResult, GitDeliveryRiskClass } from "./git-delivery.js";
+import type { GitDeliveryRecoveryDisposition } from "./git-delivery-evidence.js";
+import type { GitDeliveryChecksState, GitDeliveryMergeReadiness, GitDeliveryPullRequestState } from "./git-delivery-provider.js";
+export declare const GIT_PULL_REQUEST_SCHEMA_VERSION: "1";
+export type GitPrChangeType = "feat" | "fix" | "refactor" | "docs" | "chore" | "test" | "mixed";
+export declare const GIT_PR_CHANGE_TYPES: readonly GitPrChangeType[];
+export interface GitPullRequestChangeNarrative {
+    readonly commitCount: number;
+    readonly fileCount: number;
+    readonly areaCount: number;
+    readonly areas: readonly string[];
+    readonly touchesTests: boolean;
+    readonly changeType: GitPrChangeType;
+}
+export type GitPrPolicyOutcome = "allowed" | "blocked" | "approval-gated" | "constrained";
+export declare const GIT_PR_POLICY_OUTCOMES: readonly GitPrPolicyOutcome[];
+export interface GitPullRequestRiskDigest {
+    readonly riskClass: GitDeliveryRiskClass;
+    readonly riskSeverity: number;
+    readonly policyOutcome: GitPrPolicyOutcome;
+    readonly isDraft: boolean;
+}
+export interface GitPrSummarySection {
+    readonly changeType: GitPrChangeType;
+    readonly commitCount: number;
+    readonly fileCount: number;
+    readonly areaCount: number;
+    readonly primaryArea?: string | undefined;
+}
+export interface GitPrRiskSection {
+    readonly riskClass: GitDeliveryRiskClass;
+    readonly policyOutcome: GitPrPolicyOutcome;
+    readonly requiresApproval: boolean;
+}
+export interface GitPrChangeNarrativeSection {
+    readonly touchesTests: boolean;
+    readonly areas: readonly string[];
+    readonly changeType: GitPrChangeType;
+}
+export interface GitPullRequestMetadataDraft {
+    readonly schemaVersion: typeof GIT_PULL_REQUEST_SCHEMA_VERSION;
+    readonly composedTitle: string;
+    readonly summarySection: GitPrSummarySection;
+    readonly riskSection: GitPrRiskSection;
+    readonly changeNarrativeSection: GitPrChangeNarrativeSection;
+    readonly riskNarrative: string;
+}
+export type GitPullRequestReadinessBlockerCode = "head-unpublished" | "base-missing" | "head-equals-base" | "draft-pr" | "required-checks-failing" | "checks-pending" | "approval-insufficient" | "merge-conflict" | "provider-error";
+export declare const GIT_PR_READINESS_BLOCKER_CODES: readonly GitPullRequestReadinessBlockerCode[];
+export type GitPrBlockerSeverity = "blocking" | "advisory";
+export type GitPrRemediationClass = "user-actionable" | "internal";
+export interface GitPullRequestReadinessBlocker {
+    readonly code: GitPullRequestReadinessBlockerCode;
+    readonly severity: GitPrBlockerSeverity;
+    readonly remediation: GitPrRemediationClass;
+}
+export interface GitPullRequestReadinessSummary {
+    readonly schemaVersion: typeof GIT_PULL_REQUEST_SCHEMA_VERSION;
+    readonly objectExists: boolean;
+    readonly reviewReady: boolean;
+    readonly blockers: readonly GitPullRequestReadinessBlocker[];
+}
+export type GitPullRequestRecommendation = "create-as-draft" | "create-as-ready" | "update-to-ready" | "keep-as-draft" | "blocked";
+export declare const GIT_PR_RECOMMENDATIONS: readonly GitPullRequestRecommendation[];
+export type GitPrReviewerSuggestionBasis = "area-ownership" | "none";
+export type GitPrLabelSuggestionBasis = "change-type" | "area" | "none";
+export type GitPrLinkageSuggestionBasis = "branch-name" | "none";
+export interface GitPullRequestReviewerSuggestion {
+    readonly suggestedReviewerIds: readonly string[];
+    readonly basis: GitPrReviewerSuggestionBasis;
+}
+export interface GitPullRequestLabelSuggestion {
+    readonly suggestedLabelNames: readonly string[];
+    readonly basis: GitPrLabelSuggestionBasis;
+}
+export interface GitPullRequestLinkageSuggestion {
+    readonly suggestedIssueRefs: readonly string[];
+    readonly basis: GitPrLinkageSuggestionBasis;
+}
+export type GitPullRequestRejectionReason = "already-exists" | "base-missing" | "head-unpublished" | "validation-error" | "permission-denied" | "not-found" | "rate-limited" | "provider-unavailable" | "unknown";
+export declare const GIT_PR_REJECTION_REASONS: readonly GitPullRequestRejectionReason[];
+export declare const GIT_PR_REJECTION_ERROR_CODE: Readonly<Record<GitPullRequestRejectionReason, GitDeliveryExecutionErrorCode>>;
+export declare const GIT_PR_REJECTION_DISPOSITION: Readonly<Record<GitPullRequestRejectionReason, GitDeliveryRecoveryDisposition>>;
+export declare function gitPrRejectionToErrorCode(reason: GitPullRequestRejectionReason): GitDeliveryExecutionErrorCode;
+export declare function gitPrRejectionToDisposition(reason: GitPullRequestRejectionReason): GitDeliveryRecoveryDisposition;
+export declare const isGitPrChangeType: (v: unknown) => v is GitPrChangeType;
+export declare const isGitPrPolicyOutcome: (v: unknown) => v is GitPrPolicyOutcome;
+export declare const isGitPullRequestReadinessBlockerCode: (v: unknown) => v is GitPullRequestReadinessBlockerCode;
+export declare const isGitPullRequestRecommendation: (v: unknown) => v is GitPullRequestRecommendation;
+export declare const isGitPullRequestRejectionReason: (v: unknown) => v is GitPullRequestRejectionReason;
+export declare function synthesizePullRequestMetadata(narrative: GitPullRequestChangeNarrative, riskDigest: GitPullRequestRiskDigest, headBranch: string, _baseBranch: string): GitPullRequestMetadataDraft;
+export interface GitPullRequestReadinessInput {
+    readonly headBranchName: string;
+    readonly baseBranchName: string;
+    readonly headPublished: boolean;
+    readonly baseExists: boolean;
+    readonly pullRequest?: GitDeliveryPullRequestState | undefined;
+    readonly checks?: GitDeliveryChecksState | undefined;
+    readonly mergeReadiness?: GitDeliveryMergeReadiness | undefined;
+    readonly providerError?: boolean | undefined;
+}
+export declare function gitPullRequestReadinessFor(input: GitPullRequestReadinessInput): GitPullRequestReadinessSummary;
+export declare function gitPullRequestRecommendationFor(readiness: GitPullRequestReadinessSummary, riskDigest: GitPullRequestRiskDigest): GitPullRequestRecommendation;
+export declare function gitPullRequestReviewerSuggestionsFor(narrative: GitPullRequestChangeNarrative, areaOwners?: Readonly<Record<string, readonly string[]>>): GitPullRequestReviewerSuggestion;
+export declare function gitPullRequestLabelSuggestionsFor(narrative: GitPullRequestChangeNarrative): GitPullRequestLabelSuggestion;
+export declare function gitPullRequestLinkageSuggestionsFor(headBranch: string): GitPullRequestLinkageSuggestion;
+export declare function isGitPullRequestReadinessBlocker(value: unknown): value is GitPullRequestReadinessBlocker;
+export declare function isGitPullRequestReadinessSummary(value: unknown): value is GitPullRequestReadinessSummary;
+export declare function isGitPullRequestChangeNarrative(value: unknown): value is GitPullRequestChangeNarrative;
+export declare function isGitPullRequestMetadataDraft(value: unknown): value is GitPullRequestMetadataDraft;
+export declare function parseGitPullRequestReadinessSummary(value: unknown): GitDeliveryParseResult<GitPullRequestReadinessSummary>;
+//# sourceMappingURL=git-pull-request.d.ts.map

package/dist/git-pull-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-pull-request.d.ts","sourceRoot":"","sources":["../src/git-pull-request.ts"],"names":[],"mappings":"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"}