@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,7 +1,6 @@
-import { DEFAULT_CLI_COLUMNS, checkoutNotFollowableLines, displayColumns, gitShortStat, renderOpaqueBlock, safeText, } from "./terminal.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { usageAcceptanceLines } from "../usage.js";
+import { shortGitId } from "./contract-observation.js";
+import { DEFAULT_CLI_COLUMNS, checkoutNotFollowableLines, gitShortStat, orderRefusalFacts, renderOpaqueBlock, safeText, } from "./terminal.js";
 function wrap(lines, text, indent, columns) {
     lines.push(...renderOpaqueBlock(text, indent, columns));
 }
@@ -10,9 +9,6 @@ function collectionLines(name, members, indent) {
         return [];
     return [`${indent}${name}`, ...members.map((member) => `${indent}  ${safeText(member)}`)];
 }
-function shortGitId(value) {
-    return /^[0-9a-f]{40}$/iu.test(value) ? value.slice(0, 7) : value;
-}
 function skipAddressedContract(addressed, contractId) {
     return addressed !== undefined && contractId === addressed;
 }
@@ -20,8 +16,14 @@ function refusalIdentity(refusal, addressed) {
     const contractId = "contractId" in refusal ? refusal.contractId : undefined;
     return skipAddressedContract(addressed, contractId) ? undefined : contractId;
 }
+const REFUSAL_WORDS = {
+    "contract-missing": "contract missing",
+};
+function refusalWords(kind) {
+    return REFUSAL_WORDS[kind] ?? kind.replaceAll("-", " ");
+}
 function refusalHead(kind, identity, details) {
-    return [kind, identity, ...details].filter((part) => part !== undefined).join("  ");
+    return [refusalWords(kind), identity, ...details].filter((part) => part !== undefined).join("  ");
 }
 function renderDirtyRefusal(refusal, indent, columns, identity) {
     const lines = [];
@@ -41,69 +43,94 @@ function renderDirtyRefusal(refusal, indent, columns, identity) {
     }
     return lines;
 }
-export function renderRefusalFacts(refusal, indent, columns, addressed) {
+// eslint-disable-next-line complexity -- one closed projection preserves every refusal fact.
+function refusalFacts(refusal, indent, columns, addressed) {
     const identity = refusalIdentity(refusal, addressed);
     if (refusal.kind === "nuke-confirmation-mismatch" || refusal.kind === "nuke-confirmation-required") {
         const world = safeText(refusal.world);
         return [
-            `${indent}nuke confirmation ${refusal.kind === "nuke-confirmation-mismatch" ? "mismatch" : "required"}`,
+            `${indent}reason  ${refusalWords(refusal.kind)}`,
             `${indent}world  ${world}`,
             ...(refusal.kind === "nuke-confirmation-mismatch"
                 ? [`${indent}confirmation  ${safeText(refusal.confirmation)}`]
                 : []),
-            `${indent}nuke  keiyaku nuke --confirm '${world.replaceAll("'", "'\"'\"'")}'`,
+            `${indent}option  keiyaku nuke --confirm '${world.replaceAll("'", "'\"'\"'")}'`,
+        ];
+    }
+    if (refusal.kind === "verification-declaration-invalid") {
+        return [
+            ...(identity === undefined ? [] : [`${indent}contract  ${safeText(identity)}`]),
+            `${indent}reason  gate 'verified' requires a declared Verification; the Contract declares none`,
         ];
     }
     if (refusal.kind === "dirty-workspace")
         return renderDirtyRefusal(refusal, indent, columns, identity);
     if (refusal.kind === "unmerged-paths") {
-        return [
-            ...renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns),
-            ...collectionLines("paths", refusal.paths, indent),
-        ];
+        return [`${indent}reason  ${refusalWords(refusal.kind)}`, ...collectionLines("paths", refusal.paths, indent)];
     }
     if (refusal.kind === "integration-failed") {
-        const lines = [...renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns)];
+        const lines = [
+            `${indent}reason  ${refusalWords(refusal.kind)}`,
+            ...(identity === undefined ? [] : [`${indent}contract  ${safeText(identity)}`]),
+        ];
         lines.push(`${indent}reason  ${safeText(refusal.reason)}`, `${indent}target  ${safeText(refusal.targetHead)}`);
         if (refusal.conflictPaths !== undefined)
             lines.push(...collectionLines("conflicts", refusal.conflictPaths, indent));
         if ("recovery" in refusal && refusal.recovery !== undefined) {
-            lines.push(`${indent}materialize  ${safeText(refusal.recovery.materialize)}`);
-            lines.push(`${indent}deliver  ${safeText(refusal.recovery.deliver)}`);
+            lines.push(`${indent}option  materialize  ${safeText(refusal.recovery.materialize)}`);
+            lines.push(`${indent}option  deliver  ${safeText(refusal.recovery.deliver)}`);
         }
         return lines;
     }
     if (refusal.kind === "merge-state-present") {
         return [
-            ...renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns),
+            `${indent}reason  ${refusalWords(refusal.kind)}`,
+            ...(identity === undefined ? [] : [`${indent}contract  ${safeText(identity)}`]),
             `${indent}workspace kind  ${refusal.workspace.kind}`,
             `${indent}workspace  ${safeText(refusal.workspace.path)}`,
         ];
     }
     if (refusal.kind === "integration-unsupported") {
         return [
-            ...renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns),
+            `${indent}reason  ${refusalWords(refusal.kind)}`,
+            ...(identity === undefined ? [] : [`${indent}contract  ${safeText(identity)}`]),
             `${indent}required Git  ${safeText(refusal.requiredGit)}`,
         ];
     }
     if (refusal.kind === "checkout-not-followable") {
         return checkoutNotFollowableLines(refusal);
     }
-    return renderOpaqueBlock(refusalHead(refusal.kind, identity, []), indent, columns);
+    const lines = [`${indent}reason  ${refusalWords(refusal.kind)}`];
+    if (identity !== undefined)
+        lines.push(`${indent}contract  ${safeText(identity)}`);
+    if ("diagnostic" in refusal && typeof refusal.diagnostic === "string")
+        lines.push(`${indent}detail  ${safeText(refusal.diagnostic)}`);
+    return lines;
+}
+export function renderRefusalFacts(refusal, indent, columns, addressed) {
+    return orderRefusalFacts(refusalFacts(refusal, indent, columns, addressed).map((line) => line.slice(indent.length))).map((line) => `${indent}${line}`);
+}
+function refusalTitle(verb) {
+    return `× ${verb} refused`;
 }
-export function renderRefusal(result, context) {
+/**
+ * The one refusal receipt assembly: a denied-verdict title, a labeled reason, labeled facts, and the
+ * applicable acceptance grammar. Typed refusals and bare command refusals both render through here.
+ */
+export function renderStructuredRefusal(verb, reason, facts = [], guide) {
+    const lines = [refusalTitle(verb), `  reason  ${safeText(reason)}`, ...facts.map((fact) => `  ${safeText(fact)}`)];
+    if (guide !== undefined)
+        lines.push(...usageAcceptanceLines(guide));
+    return lines.join("\n");
+}
+export function renderRefusal(refused, draft, context) {
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
-    const base = `× ${result.verb} refused`;
-    const lines = result.contract === undefined
-        ? [base]
-        : displayColumns(`${base}  ${result.contract}`) <= columns
-            ? [`${base}  ${result.contract}`]
-            : [base, `  contract  ${safeText(result.contract)}`];
-    if (isRecord(result.refusal) && typeof result.refusal.kind === "string") {
-        lines.push(...renderRefusalFacts(result.refusal, "  ", columns, result.contract));
-    }
+    const lines = [refusalTitle(refused.operation)];
+    if (refused.contract !== undefined)
+        lines.push(`  contract  ${safeText(refused.contract)}`);
+    lines.push(...renderRefusalFacts(refused.refusal, "  ", columns, refused.contract));
     const output = lines.join("\n");
-    return result.draft === undefined ? output : `${output}\n${renderBindDraftReceipt(result.draft)}`;
+    return draft === undefined ? output : `${output}\n${renderBindDraftReceipt(draft)}`;
 }
 export function renderConflictMaterialized(result, _context) {
     const indent = "  ";
@@ -116,7 +143,7 @@ export function renderConflictMaterialized(result, _context) {
         `${indent}handoff base  ${shortGitId(result.handoffBase)}`,
         ...collectionLines("conflicts", result.conflictPaths, indent),
         `${indent}workspace  ${safeText(result.workspace.path)}`,
-        `${indent}deliver  ${safeText(result.recovery.deliver)} · reads worktree bytes, not index`,
+        `${indent}option  deliver  ${safeText(result.recovery.deliver)} · reads worktree bytes, not index`,
     ].join("\n");
 }
 export function renderBindDraftReceipt(receipt) {

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

@@ -1,3 +1,4 @@
+import { emptyCatalogue } from "./terminal.js";
 function overlapBlocks(overlaps) {
     return overlaps.flatMap((overlap) => {
         const patterns = overlap.patterns.filter((pattern) => pattern.mine !== pattern.theirs);
@@ -14,11 +15,11 @@ function rows(section) {
     if (section.kind === "absent")
         return [];
     if (section.kind === "failed")
-        return [`× region`, `  diagnostic  ${section.failure.message}`];
+        return [`× region`, `  reason  ${section.failure.message}`];
     const value = section.value;
     if (value.kind === "declarations") {
         if (value.declarations.length === 0)
-            return ["region  none"];
+            return [emptyCatalogue("region")];
         return value.declarations.map((declaration) => `region  ${declaration.contract}  ${declaration.patterns.join(" ")}`);
     }
     if (value.kind === "contract") {

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

@@ -1,15 +1,5 @@
 import { DEFAULT_CLI_COLUMNS, displayColumns, renderTextBlock } from "./terminal.js";
-import { fieldName } from "./value.js";
-function settingValueLines(name, value, indent) {
-    const secret = /(?:key|token|secret|password|credential)/iu.test(name);
-    if (secret && value !== undefined && value !== null && String(value).length > 0)
-        return [`${indent}${fieldName(name)}  [redacted]`];
-    if (value === null || typeof value !== "object")
-        return [`${indent}${fieldName(name)}  ${String(value)}`];
-    if (Array.isArray(value))
-        return value.flatMap((item, index) => settingValueLines(`${name}.${index}`, item, indent));
-    return Object.entries(value).flatMap(([key, item]) => settingValueLines(`${name}.${key}`, item, indent));
-}
+import { fieldName, namedValueLines } from "./value.js";
 function namespaceNames(value) {
     return [
         ...new Set([value.scopes.user, value.scopes.project].flatMap((scope) => (scope.kind === "read" ? scope.namespaces : []))),
@@ -48,7 +38,7 @@ export function renderSettingsText(value, columns = DEFAULT_CLI_COLUMNS) {
         }
         for (const entry of view.entries) {
             lines.push(`    entry  ${fieldName(entry.name)} · ${entry.source}${entry.shadows ? " · shadows user" : ""}`);
-            lines.push(...settingValueLines("value", entry.value, "      "));
+            lines.push(...namedValueLines("value", entry.value, "      "));
         }
     }
     return lines.join("\n");

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

@@ -1,10 +1,41 @@
-import type { TaskCompositionResult } from "../../task/index.js";
-import type { TaskInvocationResult } from "../commands/task-invoke.js";
-import type { ParsedTaskCommand } from "../commands/task.js";
+import type { BlockedTaskList, TaskBatchResult, TaskCompositionResult, TaskContextResult, TaskDecompositionTree, TaskDetail, TaskDoctorReport, TaskList, TaskMutationResult, TaskQueryResult, TaskUpdateResult } from "../../task/index.js";
 import { type TextRenderContext } from "./terminal.js";
-export declare function taskMark(word: string): string;
+export { taskMark } from "./marks.js";
+type TaskListOutcome = TaskList | BlockedTaskList | TaskQueryResult;
+/** One addressed show selection: native details, or a refusal naming a missing addressed read. */
+export type TaskShowResult = TaskDetail | TaskDetail[] | Extract<TaskMutationResult, {
+    kind: "refused";
+}>;
+/** Presentation-only list scope the leaf acquired; never part of a product value. */
+export type TaskListScope = "world" | "current" | Readonly<{
+    namespace: string;
+}>;
+/** The union of native Task SDK answers one leaf renders directly; the CLI adds no result envelope. */
+type TaskNativeResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskShowResult | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskContextResult;
+type TaskFailure = Extract<TaskMutationResult, {
+    kind: "refused" | "retry";
+}> | Extract<TaskContextResult, {
+    kind: "refused" | "retry";
+}> | Extract<TaskCompositionResult, {
+    kind: "refused";
+}>;
 /** Task dispositions and relation states are snake_case facts; people read them as words. */
 export declare function dispositionText(word: string): string;
-export declare function renderTaskText(command: ParsedTaskCommand, result: TaskInvocationResult, context?: TextRenderContext): string;
+export declare function taskFrameHead(view: string, scope: string): string;
+/** One addressed show selection rendered directly from its native answer. */
+export declare function renderTaskShow(result: TaskShowResult, context?: TextRenderContext): string;
+/** One list read rendered from its native answer and the leaf's presentation-only scope. */
+export declare function renderTaskList(action: "ls" | "ready" | "blocked" | "query", scope: TaskListScope, result: TaskListOutcome, context?: TextRenderContext): string;
+export declare function renderTaskTree(result: TaskDecompositionTree, context?: TextRenderContext): string;
+export declare function renderTaskDoctor(result: TaskDoctorReport): string;
+export declare function renderTaskContext(result: TaskContextResult, context?: TextRenderContext): string;
+export declare function renderTaskCompose(result: TaskCompositionResult, context?: TextRenderContext): string;
+/** One single-Task mutation answer; `verb` is the literal action the leaf invoked. */
+export declare function renderTaskMutation(verb: string, result: TaskMutationResult, context?: TextRenderContext): string;
+export declare function renderTaskUpdate(result: TaskUpdateResult, context?: TextRenderContext): string;
+/** One lifecycle answer: a single mutation or a plural batch, both native shapes. */
+export declare function renderTaskLifecycle(verb: string, result: TaskMutationResult | TaskBatchResult, context?: TextRenderContext): string;
+/** A native refusal the CLI edge raised for one action, through the shared refusal grammar. */
+export declare function renderTaskFailure(verb: string, result: TaskFailure, context?: TextRenderContext): string;
 export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
-export declare function taskExitCode(result: TaskInvocationResult): number;
+export declare function taskExitCode(result: TaskNativeResult): number;