@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/cli/render/catalog.js

@@ -0,0 +1,16 @@
+import { safeText } from "./terminal.js";
+export function renderCatalogText(catalog) {
+    if (catalog.kind === "tasks") {
+        return catalog.rows.map((row) => `${safeText(row.id)} - P${row.priority} - ${row.disposition} - ${safeText(row.title)}`).join("\n");
+    }
+    if (catalog.kind === "contracts") {
+        return catalog.rows.map((row) => `${safeText(row.id)} - ${row.phase}`).join("\n");
+    }
+    if (catalog.kind === "archetypes") {
+        return catalog.rows.flatMap((row) => [
+            `${safeText(row.name)}${row.model === undefined ? "" : ` - ${safeText(row.model)}`}`,
+            ...(row.description === undefined ? [] : [`  ${safeText(row.description)}`]),
+        ]).join("\n");
+    }
+    return catalog.rows.map((row) => `${safeText(row.id)} - ${row.life}`).join("\n");
+}

package/build/src/cli/render/contract.d.ts

@@ -1,4 +1,4 @@
 import type { AcceptedResult, RetryResult } from "../result.js";
-export declare function obligationLines(value: Pick<AcceptedResult, "verification" | "placement" | "leak">): readonly string[];
-export declare function renderAccepted(result: AcceptedResult): string;
-export declare function renderRetry(result: RetryResult): string;
+import { type TextRenderContext } from "./terminal.js";
+export declare function renderAccepted(result: AcceptedResult, context?: TextRenderContext): string;
+export declare function renderRetry(result: RetryResult, context?: TextRenderContext): string;

package/build/src/cli/render/contract.js

@@ -1,69 +1,215 @@
-function effectLine(effect) {
-    if (effect.kind === "worktree")
-        return `effect worktree ${effect.action} ${effect.path}`.trimEnd();
-    return `effect ref ${effect.action} ${effect.name} ${effect.before ?? "null"} -> ${effect.after ?? "null"}`;
+import { renderAcceptedAudit } from "./audit.js";
+import { appendHookPayload, cleanupLines, hookFailureSummary, leakLines, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, } from "./receipt.js";
+import { gitShortStat, renderOpaqueBlock } from "./terminal.js";
+const HANG = "   ";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function lagLine(lag) {
-    if (lag.kind === "worktree-retained")
-        return `lag worktree-retained ${lag.path}`;
-    if (lag.kind === "worktree-hook-failed") {
-        return `lag worktree-hook-failed ${lag.phase} ${lag.path} command=${lag.command} ${JSON.stringify(lag.failure)}`;
+function retryLines(detail, indent, columns) {
+    if (detail.kind === "publication-failed") {
+        return [...renderOpaqueBlock("publication-failed", indent, columns), ...["diagnostic", "", detail.diagnostic, ""]];
     }
-    return `lag reconcile-failed ${lag.stage} ${lag.diagnostic}`;
+    return renderOpaqueBlock(detail.kind, indent, columns);
 }
-function leakLine(leak) {
-    if (leak === undefined)
-        return undefined;
-    return `leak worktree ${leak.path} ${leak.diagnostic}`;
+function changedEffect(effect) {
+    return effect.action !== "unchanged";
 }
-export function obligationLines(value) {
+function effectRows(effect, columns) {
+    const mark = changedEffect(effect) ? "✓" : "·";
     const lines = [];
-    for (const name of ["verification", "placement"]) {
-        const stop = value[name];
-        if (stop === undefined)
-            continue;
-        lines.push(`stop ${name} ${JSON.stringify(stop)}`);
-    }
-    const leak = leakLine(value.leak);
-    if (leak !== undefined)
-        lines.push(leak);
+    if (effect.kind === "worktree") {
+        receiptRow(lines, mark, "worktree", [{ text: effect.action }, { text: effect.path, opaque: true }], columns);
+    }
+    else if (effect.kind === "contract-file") {
+        receiptRow(lines, mark, "contract-file", [{ text: effect.action }, { text: effect.path, opaque: true }], columns);
+    }
+    else if (effect.kind === "target-checkout") {
+        receiptRow(lines, mark, "target-checkout", [
+            { text: effect.action },
+            { text: effect.target, opaque: true },
+            { text: effect.path, opaque: true },
+        ], columns);
+    }
+    else {
+        receiptRow(lines, mark, "ref", [
+            { text: effect.action },
+            { text: effect.name, opaque: true },
+            { text: `${effect.before ?? "null"} -> ${effect.after ?? "null"}`, opaque: true },
+        ], columns);
+    }
     return lines;
 }
-export function renderAccepted(result) {
-    const lines = [`accepted ${result.verb} ${result.contract} head=${result.head ?? "null"}`];
-    if (result.target !== undefined)
-        lines.push(`target ${result.target ?? "null"}`);
-    for (const fact of result.facts)
-        lines.push(`fact ${fact.contract} ${fact.entry} ${fact.kind}`);
-    lines.push(...obligationLines(result));
-    const reportLeak = leakLine(result.report?.leak);
-    if (reportLeak !== undefined)
-        lines.push(reportLeak);
-    for (const overlap of result.overlaps ?? []) {
+function lagRows(lag, columns) {
+    const lines = [];
+    if (lag.kind === "worktree-retained") {
+        receiptRow(lines, "!", "lag", [{ text: `worktree-retained ${lag.path}`, opaque: true }], columns);
+    }
+    else if (lag.kind === "unsealed-bytes") {
+        receiptRow(lines, "!", "lag", [{ text: `unsealed-bytes ${lag.path}${lag.head === undefined ? "" : ` head=${lag.head}`}${lag.paths.length === 0 ? "" : ` paths=${lag.paths.join(",")}`}`, opaque: true }], columns);
+    }
+    else if (lag.kind === "target-checkout-retained") {
+        receiptRow(lines, "!", "lag", [{ text: `target-checkout-retained ${lag.target} ${lag.path}`, opaque: true }], columns);
+        receiptPayload(lines, "diagnostic", lag.diagnostic);
+    }
+    else if (lag.kind === "worktree-hook-failed") {
+        receiptRow(lines, "!", "lag", [{ text: `worktree-hook-failed ${lag.phase} ${lag.path} command=${lag.command} ${hookFailureSummary(lag.failure)}`, opaque: true }], columns);
+        appendHookPayload(lines, lag.failure);
+    }
+    else if (lag.kind === "contract-file-failed") {
+        receiptRow(lines, "!", "lag", [{ text: `contract-file-failed ${lag.worktree} ${lag.path}`, opaque: true }], columns);
+        receiptPayload(lines, "diagnostic", lag.diagnostic);
+    }
+    else {
+        receiptRow(lines, "!", "lag", [{ text: `reconcile-failed ${lag.stage}`, opaque: true }], columns);
+        receiptPayload(lines, "diagnostic", lag.diagnostic);
+    }
+    return lines;
+}
+function settlementLagRows(lag, columns) {
+    const lines = [];
+    receiptRow(lines, "!", "settlement", [{ text: [
+                `surface=${lag.surface}`,
+                lag.taskId === undefined ? undefined : `task=${lag.taskId}`,
+                lag.path === undefined ? undefined : `path=${lag.path}`,
+            ].filter((part) => part !== undefined).join(" "), opaque: true }], columns);
+    receiptPayload(lines, "diagnostic", lag.diagnostic);
+    return lines;
+}
+function workspaceRows(workspace, columns) {
+    const lines = [];
+    receiptRow(lines, "~", "workspace", [{ text: gitShortStat(workspace.shortStat) }], columns);
+    for (const name of ["staged", "unstaged", "untracked"]) {
+        for (const path of workspace[name]) {
+            receiptRow(lines, " ", name, [{ text: path, opaque: true }], columns);
+        }
+    }
+    return lines;
+}
+function overlapRows(overlaps, columns) {
+    const lines = [];
+    for (const overlap of overlaps) {
         for (const pattern of overlap.patterns) {
-            lines.push(`overlap ${overlap.contract} ${pattern.mine} ~ ${pattern.theirs}`);
+            receiptRow(lines, "~", "overlap", [
+                { text: overlap.contract, opaque: true },
+                { text: `${pattern.mine} ~ ${pattern.theirs}`, opaque: true },
+            ], columns);
         }
     }
-    if (result.overlapFailure !== undefined)
-        lines.push(`overlap unavailable ${result.overlapFailure}`);
-    if (result.report !== undefined)
-        lines.push(`report ${JSON.stringify(result.report)}`);
-    if (result.diff !== undefined)
-        lines.push(typeof result.diff === "string" ? result.diff : JSON.stringify(result.diff));
-    for (const effect of result.effects)
-        lines.push(effectLine(effect));
-    for (const lag of result.lag ?? [])
-        lines.push(lagLine(lag));
+    return lines;
+}
+function pushBlock(lines, block) {
+    if (block.length === 0)
+        return;
+    lines.push(...block);
+}
+function acceptedRecord(result, columns) {
+    const record = [];
+    receiptRow(record, " ", "head", [{ text: result.head, opaque: true }], columns);
+    for (const fact of result.facts) {
+        const contract = fact.contract === result.contract ? [] : [{ text: fact.contract, opaque: true }];
+        receiptRow(record, " ", "journal", [
+            ...contract,
+            { text: fact.entry, opaque: true },
+            { text: `· ${fact.kind}` },
+        ], columns);
+    }
+    if (result.verb === "bind") {
+        receiptRow(record, " ", "target", [{ text: result.target ?? "null", opaque: true }], columns);
+    }
+    if (result.verb === "deliver") {
+        pushBlock(record, reuseLines(result.verificationReuse, columns));
+    }
+    if (result.verb === "amend") {
+        receiptPayload(record, "diff", result.diff);
+    }
+    const changed = result.effects.filter(changedEffect);
+    const unchanged = result.effects.filter((effect) => !changedEffect(effect));
+    for (const effect of [...changed, ...unchanged])
+        pushBlock(record, effectRows(effect, columns));
     for (const action of result.settlement.actions) {
-        lines.push(action.kind === "task"
-            ? `settlement task ${action.action} ${action.taskId}`
-            : `settlement namespace-context ${action.action} ${action.path}`);
+        receiptRow(record, "·", "settle", [
+            { text: action.kind },
+            { text: action.action },
+            { text: action.kind === "task" ? action.taskId : action.path, opaque: true },
+        ], columns);
+    }
+    return record;
+}
+function acceptedLagRows(result, columns) {
+    const obligations = [];
+    if (result.lag !== undefined) {
+        for (const lag of result.lag)
+            pushBlock(obligations, lagRows(lag, columns));
+    }
+    for (const lag of result.settlement.lags) {
+        pushBlock(obligations, settlementLagRows(lag, columns));
+    }
+    return obligations;
+}
+function acceptedObligations(result, columns) {
+    const obligations = [];
+    if (result.verb === "deliver" && result.verification !== undefined) {
+        obligations.push(...stopLines("verification", result.verification, columns, result.contract));
     }
-    for (const lag of result.settlement.lags)
-        lines.push(`settlement lag ${JSON.stringify(lag)}`);
+    if (result.placement !== undefined) {
+        obligations.push(...stopLines("claim", result.placement, columns, result.contract));
+    }
+    if (result.verb === "deliver") {
+        if (result.cleanup !== undefined)
+            pushBlock(obligations, cleanupLines(result.cleanup, columns));
+        if (result.leak !== undefined)
+            pushBlock(obligations, leakLines(result.leak, columns));
+    }
+    obligations.push(...acceptedLagRows(result, columns));
+    return obligations;
+}
+function acceptedDeviations(result, columns) {
+    const deviations = [];
+    if (result.verb === "review") {
+        if (result.workspace !== undefined)
+            pushBlock(deviations, workspaceRows(result.workspace, columns));
+        return deviations;
+    }
+    if (result.overlaps !== undefined)
+        pushBlock(deviations, overlapRows(result.overlaps, columns));
+    if (result.overlapFailure !== undefined) {
+        receiptRow(deviations, "~", "overlap", [{ text: "unavailable" }], columns);
+        receiptPayload(deviations, "diagnostic", result.overlapFailure);
+    }
+    return deviations;
+}
+function renderAcceptedReceipt(result, context) {
+    const columns = context?.columns ?? 80;
+    const lines = outcomeLines("✓", result.verb, "accepted", result.contract, columns);
+    if (result.verb === "deliver" || result.verb === "review") {
+        lines.push(...acceptedObligations(result, columns));
+    }
+    else {
+        lines.push(...acceptedLagRows(result, columns));
+    }
+    if (result.verb === "bind" || result.verb === "amend" || result.verb === "review") {
+        lines.push(...acceptedDeviations(result, columns));
+    }
+    lines.push(...acceptedRecord(result, columns));
     return lines.join("\n");
 }
-export function renderRetry(result) {
-    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
-    return `retry ${result.verb}${contract} ${JSON.stringify(result.detail)}`;
+export function renderAccepted(result, context) {
+    switch (result.verb) {
+        case "audit":
+            return renderAcceptedAudit(result, context);
+        case "bind":
+        case "amend":
+        case "deliver":
+        case "review":
+        case "arc":
+        case "abandon":
+            return renderAcceptedReceipt(result, context);
+    }
+}
+export function renderRetry(result, context) {
+    const columns = context?.columns ?? 80;
+    const detail = isRecord(result.detail) && typeof result.detail.kind === "string"
+        ? retryLines(result.detail, HANG, columns)
+        : [];
+    return [...outcomeLines("?", result.verb, "retry", result.contract, columns), ...detail].join("\n");
 }