@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/library/contract-bind.js

@@ -1,140 +0,0 @@
-import { decodeContractDocument } from "../body/decode.js";
-import { contractId } from "../core/facts/types.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
-import { admitForkBindWithAppointment, prepareMarkdownBind } from "./bind.js";
-import { actorOption, normalizedGates, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
-import { completionInput, completeHolderMutation, completeMutation } from "./mutation.js";
-import { reconcileLagScope } from "./reconcile.js";
-import { requireAccepted } from "./refusal.js";
-import { observeRegion } from "./region.js";
-import { regionWarnings } from "../body/region.js";
-import { scopeForRepo } from "./repo.js";
-import { worktreeHooksOption } from "./configuration.js";
-import { placeRegisterPath, readManagedWorktreeAppointment, } from "../workspace-place.js";
-async function acceptedBindResult(result, region, scope, contractId, warnings = []) {
-    const { value: keiyaku, ...base } = result;
-    const appointment = await readManagedWorktreeAppointment(scope, contractId);
-    const registerPath = placeRegisterPath(scope);
-    const appointmentLag = appointment.kind === "appointed" ||
-        base.lags.some((lag) => lag.kind === "contract-file-failed" && lag.path === registerPath)
-        ? []
-        : [
-            {
-                kind: "contract-file-failed",
-                worktree: scope.primaryWorktree,
-                path: registerPath,
-                diagnostic: appointment.kind === "failed" ? appointment.diagnostic : "Place appointment missing",
-            },
-        ];
-    const scopedAppointmentLag = appointmentLag.map((lag) => ({ ...lag, affects: reconcileLagScope(lag) }));
-    return {
-        ...base,
-        keiyaku,
-        ...(appointment.kind !== "appointed" ? {} : { workspace: { kind: "worktree", path: appointment.path } }),
-        lags: [...base.lags, ...scopedAppointmentLag],
-        pending: scopedAppointmentLag.length === 0
-            ? base.pending
-            : [...base.pending, { surface: "reconciliation", required: true }],
-        ...(warnings.length === 0 ? {} : { warnings }),
-        ...region,
-    };
-}
-export async function bindKeiyaku(input, createHandle) {
-    const values = requireInput(input, "Keiyaku.bind input");
-    const hooks = worktreeHooksOption(values.hooks);
-    const forkOf = values.forkOf;
-    if (forkOf !== undefined) {
-        for (const key of Object.keys(values)) {
-            if (!["repo", "forkOf", "target", "workspace", "actor", "hooks"].includes(key)) {
-                throw new TypeError(`fork bind input has unknown field: ${key}`);
-            }
-        }
-        if (typeof forkOf !== "string")
-            throw new TypeError("forkOf must be a ContractId");
-        let sourceId;
-        try {
-            sourceId = contractId(forkOf);
-        }
-        catch (error) {
-            throw new TypeError(error instanceof Error ? error.message : "forkOf must be a ContractId");
-        }
-        const sourceScope = scopeForRepo(values.repo);
-        if ((values.workspace ?? "worktree") !== "worktree")
-            throw new TypeError("workspace must be worktree");
-        const target = values.target;
-        if (target !== undefined && typeof target !== "string")
-            throw new TypeError("target must be a string");
-        const actor = actorOption(values.actor);
-        return withGitDecodeChannel(sourceScope, async (channel) => {
-            const fork = await admitForkBindWithAppointment({
-                scope: sourceScope,
-                channel,
-                sourceId,
-                ...(target === undefined ? {} : { target }),
-                ...actor,
-            });
-            const admission = requireAccepted(fork.admission);
-            const id = admission.value.contractId;
-            const toHandle = ({ contractId: contract }) => createHandle(contract, sourceScope);
-            const result = await completeMutation({
-                ...completionInput({ operation: "bind", scope: sourceScope, channel, contractId: id, value: toHandle, hooks }),
-                accepted: admission,
-            });
-            const region = await observeRegion(sourceScope, channel, id, fork.document.region);
-            return await acceptedBindResult(result, region, sourceScope, id);
-        });
-    }
-    return bindMarkdownFromValues(values, "targetless", createHandle);
-}
-export function parseMarkdownBindDocument(markdown) {
-    return decodeContractDocument(requireMarkdown(markdown), { requireTimeout: true });
-}
-/** Internal CLI composition; not exported from the package root. */
-export async function bindFromCli(input, createHandle) {
-    const values = requireInput(input, "Keiyaku.bind input");
-    return values.forkOf !== undefined
-        ? bindKeiyaku(input, createHandle)
-        : bindMarkdownFromValues(values, "current-branch", createHandle);
-}
-async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
-    const hooks = worktreeHooksOption(values.hooks);
-    const scope = scopeForRepo(values.repo);
-    const task = taskOption(values.task);
-    const document = parseMarkdownBindDocument(requireMarkdown(values.markdown));
-    if ((values.workspace ?? "worktree") !== "worktree")
-        throw new TypeError("workspace must be worktree");
-    const target = values.target;
-    if (target !== undefined && typeof target !== "string")
-        throw new TypeError("target must be a string");
-    const actor = actorOption(values.actor);
-    const gates = normalizedGates(values.gates);
-    const after = normalizedList(values.after, "after", contractId);
-    const targetSelection = target !== undefined ? { kind: "explicit", target } : { kind: omittedTarget };
-    return withGitDecodeChannel(scope, async (channel) => {
-        const admission = await prepareMarkdownBind({
-            scope,
-            channel,
-            document,
-            gates,
-            after,
-            workspace: "worktree",
-            targetSelection,
-            ...(task === undefined ? {} : { task }),
-            ...actor,
-        });
-        const accepted = requireAccepted(admission.admission === null ? admission.result : admission.admission.result);
-        const id = accepted.value.contractId;
-        const toHandle = ({ contractId: contract }) => createHandle(contract, scope);
-        const result = admission.admission === null
-            ? await completeMutation({
-                ...completionInput({ operation: "bind", scope, channel, contractId: id, value: toHandle, hooks }),
-                accepted,
-            })
-            : await completeHolderMutation({
-                completion: completionInput({ operation: "bind", scope, channel, contractId: id, value: toHandle, hooks }),
-                admission: admission.admission,
-                requireAccepted,
-            });
-        return await acceptedBindResult(result, await observeRegion(scope, channel, id, document.region), scope, id, regionWarnings(document.region));
-    });
-}

package/build/src/library/contract-forwarding.d.ts

@@ -1,55 +0,0 @@
-import type { ActorId, ContractId } from "../core/facts/types.js";
-import type { ExecutionObserver } from "../protocol/execution-observation.js";
-import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
-import type { AuditReport } from "../protocol/audit.js";
-import { type AuditComposition } from "./audit.js";
-import { executeLocalDelivery, executeLocalReview, type AttestationVerdict } from "./contract-execution.js";
-import type { DeliveryValue } from "./delivery.js";
-import type { MutationResult, Review } from "./mutation.js";
-import { Repo } from "./repo.js";
-export { executeLocalDelivery, executeLocalReview } from "./contract-execution.js";
-export type { AttestationVerdict, DeliveryExecutionInput, ReviewExecutionInput } from "./contract-execution.js";
-export type { Review } from "./mutation.js";
-export declare function executeForwardedDeliver(input: Readonly<{
-    repo: Repo;
-    contractId: ContractId;
-    requester: ActorId;
-    message?: string;
-    includeDirty: boolean;
-    materializeConflict: boolean;
-    overwrite?: boolean;
-    requireBranchesToBeUpToDate: boolean;
-    hooks: Parameters<typeof executeLocalDelivery>[0]["hooks"];
-    signal?: AbortSignal;
-    observe?: ExecutionObserver;
-}>): Promise<Readonly<{
-    result: MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
-    deliveryFactId?: string;
-}>>;
-export declare function executeForwardedReview(input: Readonly<{
-    repo: Repo;
-    contractId: ContractId;
-    requester: ActorId;
-    verdict: AttestationVerdict;
-    summary?: string;
-    signal?: AbortSignal;
-    hooks: Parameters<typeof executeLocalReview>[0]["hooks"];
-    observe?: ExecutionObserver;
-}>): Promise<Readonly<{
-    result: MutationResult<Review>;
-    reviewFactId?: string;
-}>>;
-export declare function executeForwardedAudit(input: Readonly<{
-    repo: Repo;
-    contractId: ContractId;
-    requester: ActorId;
-    includeDirty: boolean;
-    showDiff: boolean;
-    requireBranchesToBeUpToDate: boolean;
-    hooks: NonNullable<AuditComposition["hooks"]>;
-    signal?: AbortSignal;
-    observe?: ExecutionObserver;
-}>): Promise<Readonly<{
-    result: MutationResult<AuditReport>;
-    auditReport?: AuditReport;
-}>>;

package/build/src/library/contract-forwarding.js

@@ -1,67 +0,0 @@
-import { auditContract } from "./audit.js";
-import { executeLocalDelivery, executeLocalReview } from "./contract-execution.js";
-import { scopeForRepo } from "./repo.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
-import { observeContractAt } from "../git/observe.js";
-export { executeLocalDelivery, executeLocalReview } from "./contract-execution.js";
-export async function executeForwardedDeliver(input) {
-    const result = await executeLocalDelivery({
-        scope: scopeForRepo(input.repo),
-        contractId: input.contractId,
-        actor: input.requester,
-        ...(input.message === undefined ? {} : { message: input.message }),
-        requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-        includeDirty: input.includeDirty,
-        materializeConflict: input.materializeConflict,
-        overwrite: input.overwrite ?? false,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        hooks: input.hooks,
-        ...(input.observe === undefined ? {} : { observe: input.observe }),
-    });
-    if (result.kind !== "accepted")
-        return { result };
-    const delivery = result.facts.find((fact) => fact.kind === "deliver");
-    if (delivery !== undefined)
-        return { result, deliveryFactId: delivery.entry };
-    if (result.value.leading !== undefined)
-        return { result, deliveryFactId: result.value.leading.fact };
-    const scope = scopeForRepo(input.repo);
-    const record = await withGitDecodeChannel(scope, (channel) => observeContractAt(scope, channel, input.contractId));
-    if (record.state?.delivery === null || record.state?.delivery === undefined)
-        throw new Error("accepted delivery is missing its journal fact");
-    return { result, deliveryFactId: record.state.delivery.entry };
-}
-export async function executeForwardedReview(input) {
-    const result = await executeLocalReview({
-        scope: scopeForRepo(input.repo),
-        contractId: input.contractId,
-        actor: input.requester,
-        verdict: input.verdict,
-        ...(input.summary === undefined ? {} : { summary: input.summary }),
-        hooks: input.hooks,
-        ...(input.observe === undefined ? {} : { observe: input.observe }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    const review = result.facts.find((fact) => fact.kind === "attestation");
-    if (review === undefined)
-        throw new Error("accepted review is missing its journal fact");
-    return { result, reviewFactId: review.entry };
-}
-export async function executeForwardedAudit(input) {
-    const result = await auditContract({
-        scope: scopeForRepo(input.repo),
-        contractId: input.contractId,
-        ...(input.observe === undefined ? {} : { observe: input.observe }),
-        input: {
-            includeDirty: input.includeDirty,
-            showDiff: input.showDiff,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        },
-        composition: {
-            actor: input.requester,
-            hooks: input.hooks,
-            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-        },
-    });
-    return { result, auditReport: result.value };
-}

package/build/src/library/contract-handle.d.ts

@@ -1,45 +0,0 @@
-import { type ContractExecution } from "./execution.js";
-import { type ContractId, type ContractState } from "../core/facts/types.js";
-import { type RepositoryScope } from "../protocol/operations.js";
-import type { AuditReport } from "../protocol/audit.js";
-import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
-import { type ReconcileInput } from "./repo.js";
-import { type ExecutionContext } from "../akuma/requests.js";
-import { type AuditInput } from "./audit.js";
-import { Delivery } from "./delivery.js";
-import { type MutationResult } from "./mutation.js";
-import type { AbandonInput, AmendInput, AmendResult, ArcInput, DeliverInput, ReconcileReport, ReviewInput, ContractHistory } from "./contract-types.js";
-import { type Review as OperationReview } from "./contract-operations.js";
-import type { LocalContractCompositionCapture } from "./contract.js";
-type Review = OperationReview;
-export declare class KeiyakuHandle {
-    private readonly id;
-    private readonly scope;
-    private readonly execution;
-    private readonly composition;
-    constructor(id: ContractId, scope: RepositoryScope, execution: ExecutionContext | undefined, composition: LocalContractCompositionCapture);
-    state(): Promise<ContractState>;
-    history(): Promise<ContractHistory>;
-    guidance(): Promise<string>;
-    delivery(): Promise<Delivery | null>;
-    amend(input: AmendInput): Promise<AmendResult>;
-    startDelivery(input?: DeliverInput): ContractExecution<MutationResult<Delivery> | IntegrationConflictMaterialized>;
-    deliver(input?: DeliverInput): Promise<MutationResult<Delivery> | IntegrationConflictMaterialized>;
-    private runDelivery;
-    startReview(input: ReviewInput): ContractExecution<MutationResult<Review>>;
-    review(input: ReviewInput): Promise<MutationResult<Review>>;
-    private runReview;
-    abandon(input?: AbandonInput): Promise<MutationResult<void>>;
-    arc(input: ArcInput): Promise<MutationResult<void>>;
-    startAudit(input?: AuditInput): ContractExecution<MutationResult<AuditReport>>;
-    audit(input?: AuditInput): Promise<MutationResult<AuditReport>>;
-    private runAudit;
-    reconcile(input?: ReconcileInput): Promise<ReconcileReport>;
-    private deliveryHandle;
-}
-/** Internal package composition capability; not exported from the package root. */
-export declare function seatForKeiyaku(value: unknown): Readonly<{
-    id: ContractId;
-    scope: RepositoryScope;
-}> | null;
-export {};