@astrosheep/keiyaku 2.9.13 → 4.0.1

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

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

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

@@ -0,0 +1,102 @@
+function effectLine(effect) {
+    if (effect.kind === "worktree")
+        return `effect worktree ${effect.action} ${effect.path}`.trimEnd();
+    if (effect.kind === "contract-file")
+        return `effect contract-file ${effect.action} ${effect.path}`;
+    if (effect.kind === "target-checkout") {
+        return `effect target-checkout ${effect.action} ${effect.target} ${effect.path}`;
+    }
+    return `effect ref ${effect.action} ${effect.name} ${effect.before ?? "null"} -> ${effect.after ?? "null"}`;
+}
+function lagLine(lag) {
+    if (lag.kind === "worktree-retained")
+        return `lag worktree-retained ${lag.path}`;
+    if (lag.kind === "unsealed-bytes") {
+        const head = lag.head === undefined ? "" : ` head=${lag.head}`;
+        const paths = lag.paths.length === 0 ? "" : ` paths=${lag.paths.join(",")}`;
+        return `lag unsealed-bytes ${lag.path}${head}${paths}`;
+    }
+    if (lag.kind === "target-checkout-retained") {
+        return `lag target-checkout-retained ${lag.target} ${lag.path} ${lag.diagnostic}`;
+    }
+    if (lag.kind === "worktree-hook-failed") {
+        return `lag worktree-hook-failed ${lag.phase} ${lag.path} command=${lag.command} ${JSON.stringify(lag.failure)}`;
+    }
+    if (lag.kind === "contract-file-failed") {
+        return `lag contract-file-failed ${lag.worktree} ${lag.path} ${lag.diagnostic}`;
+    }
+    return `lag reconcile-failed ${lag.stage} ${lag.diagnostic}`;
+}
+function leakLine(leak) {
+    if (leak === undefined)
+        return undefined;
+    return `leak worktree ${leak.path} ${leak.diagnostic}`;
+}
+function workspaceLine(workspace) {
+    return workspace === undefined ? undefined : `workspace ${JSON.stringify(workspace)}`;
+}
+export function obligationLines(value) {
+    const lines = [];
+    for (const name of ["verification", "placement"]) {
+        const stop = value[name];
+        if (stop === undefined)
+            continue;
+        lines.push(`stop ${name} ${JSON.stringify(stop)}`);
+    }
+    if (value.cleanup !== undefined)
+        lines.push(`cleanup ${value.cleanup.phase} command=${value.cleanup.command} ${JSON.stringify(value.cleanup.detail)}`);
+    const leak = leakLine(value.leak);
+    if (leak !== undefined)
+        lines.push(leak);
+    return lines;
+}
+function observationLines(result) {
+    const lines = [];
+    if (result.target !== undefined)
+        lines.push(`target ${result.target ?? "null"}`);
+    const reportLeak = leakLine(result.report?.leak);
+    if (reportLeak !== undefined)
+        lines.push(reportLeak);
+    if (result.report?.cleanup !== undefined) {
+        const cleanup = result.report.cleanup;
+        lines.push(`cleanup ${cleanup.phase} command=${cleanup.command} ${JSON.stringify(cleanup.detail)}`);
+    }
+    for (const overlap of result.overlaps ?? []) {
+        for (const pattern of overlap.patterns) {
+            lines.push(`overlap ${overlap.contract} ${pattern.mine} ~ ${pattern.theirs}`);
+        }
+    }
+    if (result.overlapFailure !== undefined)
+        lines.push(`overlap unavailable ${result.overlapFailure}`);
+    if (result.report !== undefined)
+        lines.push(`report ${JSON.stringify(result.report)}`);
+    const workspace = workspaceLine(result.workspace);
+    if (workspace !== undefined)
+        lines.push(workspace);
+    if (result.diff !== undefined)
+        lines.push(typeof result.diff === "string" ? result.diff : JSON.stringify(result.diff));
+    return lines;
+}
+export function renderAccepted(result) {
+    const lines = [`accepted ${result.verb} ${result.contract} head=${result.head ?? "null"}`];
+    for (const fact of result.facts)
+        lines.push(`fact ${fact.contract} ${fact.entry} ${fact.kind}`);
+    lines.push(...obligationLines(result));
+    lines.push(...observationLines(result));
+    for (const effect of result.effects)
+        lines.push(effectLine(effect));
+    for (const lag of result.lag ?? [])
+        lines.push(lagLine(lag));
+    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}`);
+    }
+    for (const lag of result.settlement.lags)
+        lines.push(`settlement lag ${JSON.stringify(lag)}`);
+    return lines.join("\n");
+}
+export function renderRetry(result) {
+    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
+    return `retry ${result.verb}${contract} ${JSON.stringify(result.detail)}`;
+}

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

@@ -0,0 +1,3 @@
+import type { KanshiReport } from "../../kanshi/index.js";
+import { type TextRenderContext } from "./terminal.js";
+export declare function renderKanshiText(report: KanshiReport, context?: TextRenderContext, selection?: "world" | "contract"): string;

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

@@ -0,0 +1,252 @@
+import { displayColumns, renderTextBlock, safeText, tone } from "./terminal.js";
+function contractMark(phase) {
+    if (phase === "claimed")
+        return "✓";
+    if (phase === "abandoned")
+        return "×";
+    if (phase === "waiting" || phase === "pending-delivery")
+        return "⧗";
+    return "●";
+}
+function taskMark(row) {
+    if (row.disposition === "done")
+        return "✓";
+    if (row.disposition === "drop")
+        return "×";
+    if (row.disposition === "on_hold")
+        return "‖";
+    if (row.disposition === "in_progress")
+        return "●";
+    return row.disposition === "blocked" ? "⧗" : "○";
+}
+function akumaMark(life) {
+    if (life === "running")
+        return "●";
+    if (life === "stillborn")
+        return "!";
+    if (life === "asleep")
+        return "○";
+    if (life === "killed")
+        return "×";
+    return "?";
+}
+function gateMark(report) {
+    if (report.current.kind !== "attested")
+        return "?";
+    return report.current.verdict === "satisfied" ? "✓" : "!";
+}
+function hotFirst(rows, hot) {
+    return [...rows.filter(hot), ...rows.filter((row) => !hot(row))];
+}
+function stablePriority(rows, priority) {
+    const priorities = [...new Set(rows.map(priority))].sort((left, right) => left - right);
+    return priorities.flatMap((value) => rows.filter((row) => priority(row) === value));
+}
+function wrapChain(parts, columns) {
+    if (parts.length === 0)
+        return [];
+    const lines = [];
+    let current = "  ";
+    for (const part of parts.map(safeText)) {
+        const candidate = current === "  " ? `${current}${part}` : `${current} · ${part}`;
+        if (current !== "  " && displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${part}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+function wrapHeading(primary, facts, columns) {
+    const head = safeText(primary);
+    const lines = [];
+    let current = head;
+    for (const fact of facts.map(safeText)) {
+        const candidate = `${current} · ${fact}`;
+        if (displayColumns(candidate) > columns) {
+            lines.push(current);
+            current = `  ${fact}`;
+        }
+        else
+            current = candidate;
+    }
+    lines.push(current);
+    return lines;
+}
+function renderGates(reports, context, includeSummaries) {
+    const lines = [...wrapChain(reports.map((report) => `${gateMark(report)} ${safeText(report.gate)}`), context.columns)];
+    if (!includeSummaries)
+        return lines;
+    for (const report of reports) {
+        if (report.current.kind !== "attested" || report.current.summary === undefined)
+            continue;
+        lines.push(...renderTextBlock(`${safeText(report.gate)}: ${report.current.summary}`, "  ", context.columns)
+            .map((line) => tone(line, "dim", context.color)));
+    }
+    return lines;
+}
+function failure(name, section, context) {
+    return `${name} failed\n${tone(`! ${safeText(section.failure.message)}`, "alert", context.color)}`;
+}
+function renderContracts(report, context, selection) {
+    const section = report.contracts;
+    if (section.kind === "absent")
+        return "keiyaku absent";
+    if (section.kind === "failed")
+        return failure("keiyaku", section, context);
+    const rows = stablePriority(section.value.rows, (row) => {
+        if (row.holder.kind === "unavailable")
+            return 0;
+        if (row.phase === "waiting" || row.phase === "pending-delivery")
+            return 1;
+        return 2;
+    });
+    const lines = [`keiyaku ${rows.length}`];
+    for (const row of rows) {
+        const deliveryFacts = row.delivery === null
+            ? []
+            : selection === "world"
+                ? [`integration ${safeText(row.delivery.integration.snapshot).slice(0, 8)}`]
+                : [
+                    `tender ${row.delivery.tenderSnapshot}`,
+                    `predecessor ${row.delivery.integration.predecessor}`,
+                    `integration ${row.delivery.integration.snapshot}`,
+                    `change ${row.delivery.integration.changeId}`,
+                ];
+        const targetFacts = selection !== "contract" || row.targetObservation === null
+            ? []
+            : [
+                `target head ${row.targetObservation.head ?? "missing"}`,
+                `target ${row.targetObservation.drift ? "drifted" : "current"}`,
+            ];
+        const facts = [
+            row.workspace,
+            ...deliveryFacts,
+            ...(row.target === null ? [] : [`-> ${row.target}`]),
+            ...targetFacts,
+        ];
+        lines.push(`${contractMark(row.phase)} ${safeText(row.id)} ${row.phase}`);
+        lines.push(...wrapChain(facts, context.columns));
+        lines.push(...renderGates(row.gates.reports, context, selection === "contract"));
+        if (row.holder.kind === "held")
+            lines.push(...wrapChain([`held by ${row.holder.taskId}`], context.columns));
+        if (row.holder.kind === "unavailable")
+            lines.push(...wrapChain(["holder unavailable"], context.columns));
+    }
+    return lines.join("\n");
+}
+function renderTasks(report, context) {
+    const section = report.tasks;
+    if (section.kind === "absent")
+        return "task absent";
+    if (section.kind === "failed")
+        return failure("task", section, context);
+    const active = section.value.rows.filter((row) => row.disposition !== "done" && row.disposition !== "drop");
+    const ready = active.filter((row) => row.disposition === "ready").length;
+    const onHold = active.filter((row) => row.disposition === "on_hold").length;
+    const visible = hotFirst(active.filter((row) => row.disposition === "in_progress" || row.disposition === "blocked"), (row) => row.disposition === "blocked");
+    const lines = [...wrapHeading(`task ${active.length}`, [`${ready} ready`, `${onHold} held`], context.columns)];
+    for (const row of visible) {
+        const contract = row.contract === undefined ? [] : [`keiyaku ${row.contract.id} (${row.contract.observed})`];
+        lines.push(`${taskMark(row)} ${safeText(row.id)} ${row.disposition}`);
+        lines.push(...renderTextBlock(row.title, "  ", context.columns));
+        lines.push(...wrapChain([`P${row.priority}`, ...contract], context.columns));
+        for (const blocker of row.blockers ?? []) {
+            lines.push(...wrapChain([`blocked by ${blocker.id} (${blocker.state})`], context.columns));
+        }
+    }
+    return lines.join("\n");
+}
+function isLost(life) {
+    return life === "stranded" || life === "headless";
+}
+function akumaPriority(row) {
+    if (isLost(row.life) || row.life === "stillborn")
+        return 0;
+    return row.life === "running" ? 1 : 2;
+}
+function firstLine(value) {
+    return value.split(/[\r\n\u2028\u2029]/u, 1)[0] ?? "";
+}
+function truncateDisplay(value, columns) {
+    if (displayColumns(value) <= columns)
+        return value;
+    if (columns <= 0)
+        return "";
+    const ellipsis = "…";
+    if (columns <= displayColumns(ellipsis))
+        return ellipsis;
+    let result = "";
+    let used = 0;
+    for (const character of value) {
+        const width = displayColumns(character);
+        if (used + width + displayColumns(ellipsis) > columns)
+            break;
+        result += character;
+        used += width;
+    }
+    return `${result}${ellipsis}`;
+}
+function bornFacts(row) {
+    const association = [
+        ...(row.aliases ?? []).map((alias) => `alias ${alias}`),
+        ...(row.contract === undefined ? [] : [`keiyaku ${row.contract.id} (${row.contract.observed})`]),
+    ];
+    if (!("pending" in row) || (row.life !== "running" && !isLost(row.life)))
+        return association;
+    const confinement = row.confinement.kind === "unconfined"
+        ? ["unconfined"]
+        : row.confinement.writableRoots.map((root, index) => index === 0 ? `writes ${root}` : root);
+    return [
+        ...association,
+        ...(row.pending.length === 0 ? [] : [`pending ${row.pending.length}`]),
+        ...confinement,
+    ];
+}
+function stillbornEvidence(row, columns) {
+    if (row.life !== "stillborn" || !("seal" in row) || row.seal === undefined)
+        return null;
+    const prefix = "  seal ";
+    const evidence = safeText(firstLine(row.seal.evidence)).trim();
+    if (evidence.length === 0)
+        return null;
+    return `${prefix}${truncateDisplay(evidence, Math.max(0, columns - displayColumns(prefix)))}`;
+}
+function renderAkuma(report, context) {
+    const section = report.akuma;
+    if (section.kind === "absent")
+        return "akuma absent";
+    if (section.kind === "failed")
+        return failure("akuma", section, context);
+    const rows = [
+        ...section.value.rows.filter((row) => akumaPriority(row) === 0),
+        ...section.value.rows.filter((row) => akumaPriority(row) === 1),
+        ...section.value.rows.filter((row) => akumaPriority(row) === 2),
+    ];
+    const lines = [`akuma ${rows.length}`];
+    for (const row of rows) {
+        lines.push(`${akumaMark(row.life)} ${safeText(row.id)} ${row.life}`);
+        lines.push(...wrapChain(bornFacts(row), context.columns));
+        const evidence = stillbornEvidence(row, context.columns);
+        if (evidence !== null)
+            lines.push(evidence);
+    }
+    return lines.join("\n");
+}
+export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
+    const branch = report.branch?.startsWith("refs/heads/") === true
+        ? report.branch.slice("refs/heads/".length)
+        : report.branch;
+    const state = report.contracts.kind === "present" ? report.contracts.value.state : null;
+    return [
+        [
+            `kanshi ${report.root === null ? "none" : safeText(report.root)}`,
+            `state ${state?.slice(0, 8) ?? "none"} · ${branch === null ? "none" : safeText(branch)} · observed ${safeText(report.observedAt)}`,
+        ].join("\n"),
+        renderContracts(report, context, selection),
+        renderTasks(report, context),
+        renderAkuma(report, context),
+    ].join("\n\n");
+}

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

@@ -0,0 +1,2 @@
+import type { RefusedResult } from "../result.js";
+export declare function renderRefusal(result: RefusedResult): string;

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

@@ -0,0 +1,21 @@
+function dirtyWorkspace(value) {
+    return typeof value === "object" && value !== null && "kind" in value && value.kind === "dirty-workspace";
+}
+export function renderRefusal(result) {
+    const contract = result.contract === undefined ? "" : ` ${result.contract}`;
+    if (dirtyWorkspace(result.refusal)) {
+        const lines = [`refused ${result.verb}${contract} dirty-workspace`];
+        for (const category of ["staged", "unstaged", "untracked", "submodules"]) {
+            const label = category === "submodules" ? "submodule" : category;
+            for (const path of result.refusal[category])
+                lines.push(`dirty ${label} ${path}`);
+        }
+        const { filesChanged, insertions, deletions } = result.refusal.shortStat;
+        lines.push(`shortstat files=${filesChanged} insertions=${insertions} deletions=${deletions}`);
+        if (result.refusal.option !== undefined) {
+            lines.push(`option ${result.refusal.option.flag} ${result.refusal.option.available ? "available" : "unavailable"}`);
+        }
+        return lines.join("\n");
+    }
+    return `refused ${result.verb}${contract} ${JSON.stringify(result.refusal)}`;
+}

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

@@ -0,0 +1,3 @@
+import type { Settings } from "../../settings.js";
+export declare function settingsJsonValue(value: Settings): unknown;
+export declare function renderSettingsText(value: Settings): string;

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

@@ -0,0 +1,30 @@
+function namespaceNames(value) {
+    return [...new Set([value.scopes.user, value.scopes.project].flatMap((scope) => scope.kind === "read" ? scope.namespaces : []))].sort();
+}
+function scope(name, value) {
+    const path = value.path === undefined ? "" : ` ${value.path}`;
+    return value.kind === "failed"
+        ? `${name} failed${path} ${value.diagnostic}`
+        : `${name} ${value.kind}${path}`;
+}
+export function settingsJsonValue(value) {
+    return {
+        scopes: value.scopes,
+        namespaces: namespaceNames(value).map((name) => value.namespace(name)),
+    };
+}
+export function renderSettingsText(value) {
+    const lines = [scope("user", value.scopes.user), scope("project", value.scopes.project)];
+    for (const name of namespaceNames(value)) {
+        const view = value.namespace(name);
+        lines.push(`namespace ${name} ${view.kind}`);
+        if (view.kind === "failed") {
+            for (const failure of view.failures)
+                lines.push(`failure ${failure.scope} ${failure.diagnostic}`);
+        }
+        for (const entry of view.entries) {
+            lines.push(`entry ${entry.name} ${entry.source}${entry.shadows ? " shadows user" : ""} ${JSON.stringify(entry.value)}`);
+        }
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,6 @@
+import type { TaskCompositionResult } from "../../task/index.js";
+import type { TaskInvocationResult } from "../commands/task-invoke.js";
+import type { ParsedTaskCommand } from "../commands/task.js";
+export declare function renderTaskText(command: ParsedTaskCommand, result: TaskInvocationResult): string;
+export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
+export declare function taskExitCode(result: TaskInvocationResult): number;

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

@@ -0,0 +1,105 @@
+function row(value) {
+    const disposition = "disposition" in value ? value.disposition : value.state;
+    return `${value.id} - P${value.priority} - ${disposition} - ${value.title}`;
+}
+function changes(values) {
+    return values.map((change) => change.documentDiff).filter((diff) => diff.length > 0).join("\n");
+}
+function failure(result) {
+    return result.kind === "retry" ? `retry ${JSON.stringify(result.reason)}` : `refused ${JSON.stringify(result.refusal)}`;
+}
+function renderRows(result) {
+    if (result.kind !== "accepted")
+        return failure(result);
+    return result.value.map((item) => {
+        const blockers = "blockers" in item ? item.blockers.map((blocker) => blocker.id).join(", ") : undefined;
+        return `${row(item)}${blockers === undefined ? "" : ` <- ${blockers}`}`;
+    }).join("\n");
+}
+function renderShow(result) {
+    if ("kind" in result)
+        return result.kind === "accepted" ? row(result.value) : failure(result);
+    const task = result.task, lines = [
+        row(task), `namespace: ${task.namespace.join("/") || "root"}`,
+        `createdAt: ${task.createdAt}`, `updatedAt: ${task.updatedAt}`, `note: ${task.note}`,
+    ];
+    for (const [label, values] of [
+        ["needs", task.needs], ["blockers", result.blockers.map((item) => item.id)], ["blocks", result.blocks.map((item) => item.id)],
+        ["children", result.children.map((item) => item.id)], ["supersedes", task.supersedes],
+        ["superseded by", result.supersededBy.map((item) => item.id)], ["related", result.related.map((item) => item.id)],
+    ])
+        if (values.length > 0)
+            lines.push(`${label}: ${values.join(", ")}`);
+    if (task.parent !== null)
+        lines.push(`parent: ${task.parent}`);
+    if (task.body.length > 0)
+        lines.push("", task.body);
+    return lines.join("\n");
+}
+function treeLines(node, depth = 0) {
+    const marker = node.cycle ? "cycle" : node.reference ? "reference" : node.task.state;
+    const line = `${"  ".repeat(depth)}${node.task.id} - ${node.task.priority === null ? "P?" : `P${node.task.priority}`} - ${marker}${node.task.title === null ? "" : ` - ${node.task.title}`}`;
+    return [line, ...node.needs.flatMap((child) => treeLines(child, depth + 1))];
+}
+function doctorIssue(issue) {
+    if (issue.kind === "missing-target")
+        return `${issue.taskId}: ${issue.relation} target missing: ${issue.target}`;
+    if (issue.kind === "self-relation")
+        return `${issue.taskId}: self ${issue.relation}`;
+    return `${issue.relation} cycle: ${issue.tasks.join(" -> ")}`;
+}
+export function renderTaskText(command, result) {
+    if (command.action === "show")
+        return renderShow(result);
+    if (command.action === "ls" || command.action === "ready" || command.action === "blocked")
+        return renderRows(result);
+    if (command.action === "tree") {
+        const tree = result;
+        return tree.kind === "accepted" ? treeLines(tree.value).join("\n") : failure(tree);
+    }
+    if (command.action === "doctor") {
+        const report = result;
+        return report.issues.length === 0 ? "healthy" : report.issues.map(doctorIssue).join("\n");
+    }
+    if (command.action === "namespace") {
+        const namespace = result;
+        return namespace.kind === "accepted" ? namespace.value.join("/") || "root" : failure(namespace);
+    }
+    if (command.action === "compose") {
+        const composition = result;
+        return composition.kind === "accepted" ? changes(composition.documentChanges) : composition.kind === "incomplete" ? "" : failure(composition);
+    }
+    if (command.action === "hold" || command.action === "done" || command.action === "drop") {
+        const batch = result;
+        return batch.items.map((item) => item.outcome.kind === "accepted" ? `accepted ${item.id}` : `${item.id}: ${failure(item.outcome)}`).join("\n");
+    }
+    const mutation = result;
+    if (mutation.kind !== "accepted")
+        return failure(mutation);
+    if (command.action === "update") {
+        const value = mutation.value;
+        return [row(value.task), value.documentDiff].filter((line) => line.length > 0).join("\n");
+    }
+    return row(mutation.value);
+}
+export function renderTaskIncompleteDiagnostic(result) {
+    if (result.kind !== "incomplete")
+        return "";
+    return [`incomplete ${JSON.stringify(result.stopped)}`, changes(result.documentChanges)].filter((line) => line.length > 0).join("\n");
+}
+export function taskExitCode(result) {
+    if (typeof result === "object" && result !== null && "issues" in result)
+        return result.issues.length === 0 ? 0 : 1;
+    if (typeof result === "object" && result !== null && "items" in result) {
+        const kinds = result.items.map((item) => item.outcome.kind);
+        return kinds.includes("retry") ? 2 : kinds.includes("refused") ? 1 : 0;
+    }
+    if (typeof result === "object" && result !== null && "kind" in result) {
+        const outcome = result;
+        if (outcome.kind === "retry")
+            return 2;
+        if (outcome.kind === "refused" || outcome.kind === "incomplete")
+            return 1;
+    }
+    return 0;
+}

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

@@ -0,0 +1,23 @@
+export type TextRenderContext = Readonly<{
+    columns: number;
+    color: boolean;
+}>;
+export declare function displayColumns(value: string): number;
+export declare function takeDisplayColumns(value: string, maximum: number): Readonly<{
+    text: string;
+    rest: string;
+}>;
+export declare function truncateDisplayText(value: string, maximum: number): string;
+export declare function truncateMiddleDisplayText(value: string, maximum: number): string;
+export declare function renderBoundedTextBlock(value: string, input: Readonly<{
+    first: string;
+    continuation: string;
+    columns: number;
+    lines?: number;
+    truncated?: boolean;
+}>): readonly string[];
+export declare function safeText(value: string): string;
+export declare function renderFacts(primary: string, facts: readonly string[], columns: number): readonly string[];
+export declare function renderTextBlock(value: string, indent: string, columns: number): readonly string[];
+export declare function renderVoiceRuler(left: string, right: string, columns: number): string;
+export declare function tone(value: string, kind: "dim" | "alert", color: boolean): string;