@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/cli/render/tool-presentation.js

@@ -1,97 +0,0 @@
-import { compactText } from "./compact-text.js";
-export function activitySemanticClass(call) {
-    switch (call.kind) {
-        case "run": return "run";
-        case "read": return "read";
-        case "search": return "search";
-        case "other": return "tool";
-        case "fileChange":
-            return call.changes.length > 1 || call.changes.some((change) => change.op === "add")
-                ? "write"
-                : "edit";
-    }
-}
-function rangeText(call) {
-    const offset = call.range?.offset;
-    const limit = call.range?.limit;
-    if (offset !== undefined && limit !== undefined && limit > 0)
-        return `L${offset}–${offset + limit - 1}`;
-    if (offset !== undefined)
-        return `from L${offset}`;
-    if (limit !== undefined && limit > 0)
-        return `${limit} lines`;
-    return undefined;
-}
-function subject(call, presentPath) {
-    switch (call.kind) {
-        case "run": return compactText(call.description ?? `$ ${call.command}`);
-        case "read": return presentPath(call.path);
-        case "search": return `“${compactText(call.query)}”`;
-        case "other": return compactText(call.display);
-        case "fileChange": {
-            const paths = call.changes.map((change) => presentPath(change.path));
-            if (paths.length === 1)
-                return paths[0];
-            if (paths.length > 1)
-                return `${paths.length + (call.omittedChanges ?? 0)} files · ${paths.join(", ")}`;
-            return call.omittedChanges ? `${call.omittedChanges} files` : "files";
-        }
-    }
-}
-export function presentToolActivity(input) {
-    const presentPath = input.presentPath ?? ((value) => value);
-    const range = input.call.kind === "read" ? rangeText(input.call) : undefined;
-    const primary = `${subject(input.call, presentPath)}${range ? ` · ${range}` : ""}`;
-    const message = input.result?.message ? compactText(input.result.message) : undefined;
-    let variableText = primary;
-    let fixedSuffix = "";
-    if (input.state === "unresolved") {
-        fixedSuffix = " — state unknown";
-    }
-    else if (input.state === "interrupted") {
-        fixedSuffix = " — never finished";
-    }
-    else if (input.state === "running") {
-        if (message)
-            variableText = `${primary} — ${message}`;
-        else
-            fixedSuffix = ` — ${input.duration ?? "0s"}…`;
-    }
-    else if (input.result?.status === "error") {
-        if (input.result.exitCode !== undefined) {
-            fixedSuffix = ` — exit ${input.result.exitCode}${input.call.kind === "run" && input.duration ? ` · ${input.duration}` : ""}`;
-        }
-        else {
-            variableText = `${primary}${message ? ` — error: ${message}` : " — error"}`;
-        }
-    }
-    else if (input.call.kind === "fileChange") {
-        if (input.result?.diffstat)
-            fixedSuffix = ` — +${input.result.diffstat.additions} −${input.result.diffstat.deletions}`;
-    }
-    else if (input.call.kind === "run") {
-        fixedSuffix = input.duration ? ` — ${input.duration}` : "";
-    }
-    else if (input.call.kind === "other") {
-        fixedSuffix = " — done";
-    }
-    if (input.truncated && !variableText.endsWith("…"))
-        variableText = `${variableText}…`;
-    return {
-        semanticClass: activitySemanticClass(input.call),
-        subject: primary,
-        variableText,
-        fixedSuffix,
-        error: input.result?.status === "error",
-    };
-}
-export function presentFoldedToolActivity(row, input, presentPath) {
-    return presentToolActivity({
-        call: row.call,
-        ...(row.result === undefined ? {} : { result: row.result }),
-        state: input.state,
-        ...(input.duration === undefined ? {} : { duration: input.duration }),
-        ...(row.truncated ? { truncated: true } : {}),
-        ...(presentPath === undefined ? {} : { presentPath }),
-    });
-}

package/build/cli/render/types.js

@@ -1,2 +0,0 @@
-;
-export {};

package/build/cli/render/wait.js

@@ -1,275 +0,0 @@
-import { formatTimelineDuration, renderPendingProjectionTell, renderProjectionActivity, } from "./projection-activity.js";
-import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
-import { coreTextResponse, formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
-import { renderTerminalFailureFace } from "./terminal-failure.js";
-function shortAddress(projectionId) {
-    return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
-}
-function phaseState(phase) {
-    switch (phase) {
-        case "done": return "returned";
-        case "failed": return "dead";
-        case "lost": return "lost";
-        case "killed":
-        case "dismissed": return "dismissed";
-        case "startup-timeout": return "stalled";
-        case "unknown": return "unknown";
-        case "minting":
-        case "active":
-        case "quiescent": return "running";
-    }
-}
-function isTerminalPhase(phase) {
-    // `lost` is intentionally absent: it can be an observation failure without
-    // a verdict. Core marks the excluded lost-runner-verdict case explicitly.
-    return ["done", "failed", "killed", "dismissed"].includes(phase);
-}
-function waitStateText(snapshot) {
-    const idle = snapshot.activityAgeMs === undefined
-        ? formatTimelineDuration(snapshot.durationMs)
-        : formatTimelineDuration(snapshot.activityAgeMs);
-    return `up ${formatTimelineDuration(snapshot.durationMs)} · idle ${idle}`;
-}
-function projectionIdentityParts(projectionId) {
-    const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
-    return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
-}
-function waitHeader(projectionId, akuma, snapshot, maxColumns) {
-    const state = waitStateText(snapshot);
-    const identity = projectionIdentityParts(projectionId);
-    // Slug often mirrors the Akuma name; print once when they are the same fact.
-    const description = identity.slug && akuma && identity.slug === akuma
-        ? identity.slug
-        : [identity.slug, akuma].filter(Boolean).join(" · ");
-    const descriptionBudget = Math.max(0, maxColumns - displayColumns(`${identity.shortId} ·  ─ ${state}`));
-    const visibleDescription = truncateColumns(description, descriptionBudget);
-    const prefix = visibleDescription ? `${identity.shortId} · ${visibleDescription}` : identity.shortId;
-    const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
-    return `${prefix} ${"─".repeat(dashCount)} ${state}`;
-}
-function pendingTellRows(snapshot, maxColumns, orderOffset) {
-    return snapshot.tells.window.map((tell, index) => ({
-        line: renderPendingProjectionTell(tell, {
-            anchorMs: snapshot.observedAtMs,
-            maxColumns,
-        }),
-        at: tell.createdAt,
-        order: orderOffset + index,
-    }));
-}
-function orderFlowRows(rows) {
-    return rows.slice().sort((left, right) => {
-        const leftAt = Date.parse(left.at ?? "");
-        const rightAt = Date.parse(right.at ?? "");
-        const safeLeft = Number.isFinite(leftAt) ? leftAt : Number.POSITIVE_INFINITY;
-        const safeRight = Number.isFinite(rightAt) ? rightAt : Number.POSITIVE_INFINITY;
-        return safeLeft - safeRight || left.order - right.order;
-    });
-}
-function ledgerHint(projectionId, snapshot) {
-    const file = snapshot.eventLedgerFile ?? "events.jsonl";
-    return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
-}
-function recordReviveLines(artifactId) {
-    return [
-        `record: ${artifactId}`,
-        "revive starts a new projection from the record:",
-        `  » keiyaku revive ${artifactId}`,
-    ];
-}
-function nextActionLines(projectionId, result, state) {
-    const snapshot = result.snapshot;
-    const address = shortAddress(projectionId);
-    if (state === "running") {
-        return [...projectionRejoinHintLines(address)];
-    }
-    if (state === "returned") {
-        return [
-            "The akuma is back.",
-            ...(snapshot.artifactId ? [`record: ${snapshot.artifactId}`] : []),
-            "talk to it:",
-            `  » ${formatTellCommand(projectionId, '"your words"')}`,
-        ];
-    }
-    if (result.state === "terminal" && (result.verdict.terminalFailure
-        || result.verdict.state === "failed"
-        || result.verdict.state === "launch-failed"
-        || result.verdict.state === "lost-runner")) {
-        return renderTerminalFailureFace(projectionId, result.verdict.terminalFailure);
-    }
-    if (snapshot.phase === "lost") {
-        return snapshot.artifactId
-            ? [
-                "The projection is lost — no terminal truth exists.",
-                ...recordReviveLines(snapshot.artifactId),
-            ]
-            : [
-                "The projection is lost — no terminal truth exists.",
-                "no record survived — there is nothing to revive.",
-            ];
-    }
-    if (state === "stalled" || state === "unknown") {
-        return [ledgerHint(projectionId, snapshot), "» keiyaku status"];
-    }
-    return [];
-}
-function startupTimeoutResponse(projectionId, akuma) {
-    return {
-        ...textResponse([
-            `… ${akuma} · projection: ${projectionId} · startup timed out`,
-            "the launch was never adopted — no akuma exists",
-            "",
-            "the next wake retries the launch:",
-            `  » ${formatTellCommand(projectionId, '"your words"')}`,
-        ].join("\n")),
-        exitCode: 1,
-    };
-}
-function unknownResponse(projectionId, akuma, snapshot, maxColumns) {
-    const rendered = renderProjectionActivity(snapshot.activity, {
-        anchorMs: snapshot.observedAtMs,
-        state: "unknown",
-        showPlan: false,
-        showSilence: false,
-        showTerminalFiles: false,
-        ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-        maxColumns,
-        leadingOmittedCount: snapshot.activity.omittedSettledCount,
-    });
-    const historicalLines = rendered.lines.map((line) => line.replace(/[┆├]/, "│"));
-    return {
-        ...textResponse([
-            `? ${akuma} · projection: ${projectionId} · unknown`,
-            "the projection could not be observed",
-            "nothing is asserted — not alive, not dead",
-            ...historicalLines,
-            "",
-            "observation failed — look again:",
-            "  » keiyaku status",
-        ].join("\n")),
-        // CliOutput currently owns only the existing failure and interrupt codes.
-        // #615 requires a distinct unknown code; the owning exit-code surface must
-        // add it before this temporary existing failure code can be replaced.
-        exitCode: 1,
-    };
-}
-function identityUnavailableResponse(projectionId, diagnostic) {
-    return {
-        ...textResponse([
-            `? projection: ${projectionId} · unknown`,
-            "the projection could not be observed",
-            diagnostic,
-            "",
-            "observation failed — look again:",
-            "  » keiyaku status",
-        ].join("\n")),
-        exitCode: 1,
-    };
-}
-function returnedResponse(projectionId, result) {
-    // Successful terminal wait is response-only: no header, activity rows,
-    // diagnostics, or rollup. Typed outcomeText is the first byte when present.
-    const nextActions = nextActionLines(projectionId, result, "returned");
-    if (result.state === "terminal" && result.outcomeText) {
-        return textResponse([result.outcomeText, "", ...nextActions].join("\n"));
-    }
-    return textResponse(nextActions.join("\n"));
-}
-export function buildWaitResponse(projectionId, result, options = {}) {
-    if (result.state === "unknown") {
-        return identityUnavailableResponse(projectionId, result.diagnostic);
-    }
-    // A plural deadline may observe a verdict whose timestamp is at or after
-    // the cutoff. The typed timeout result owns presentation in that case; the
-    // later terminal-looking snapshot must not turn it into a terminal face.
-    const snapshot = result.state === "timeout"
-        && (result.terminalSnapshot || isTerminalPhase(result.snapshot.phase))
-        ? { ...result.snapshot, phase: "active" }
-        : result.snapshot;
-    const maxColumns = Math.min(120, options.maxColumns ?? resolveLineColumns());
-    if (result.state === "terminal" && result.verdict.state === "killed") {
-        return {
-            ...textResponse(`× killed ${projectionId}`),
-            exitCode: 1,
-        };
-    }
-    if (snapshot.phase === "startup-timeout") {
-        return startupTimeoutResponse(projectionId, result.pact.akuma);
-    }
-    if (snapshot.phase === "unknown") {
-        return unknownResponse(projectionId, result.pact.akuma, snapshot, maxColumns);
-    }
-    const state = phaseState(snapshot.phase);
-    if (state === "returned") {
-        return returnedResponse(projectionId, result);
-    }
-    const rendered = renderProjectionActivity(snapshot.activity, {
-        anchorMs: snapshot.observedAtMs,
-        state,
-        showPlan: false,
-        showSilence: false,
-        showTerminalFiles: false,
-        ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-        maxColumns,
-        leadingOmittedCount: snapshot.activity.omittedSettledCount,
-    });
-    const diagnosticLines = (snapshot.eventDiagnostics ?? [])
-        .map((diagnostic) => `‼ ${diagnostic.kind} · ${diagnostic.detail}`);
-    const activityRows = rendered.lines.map((line, index) => ({
-        line,
-        at: rendered.rowAts[index],
-        order: index,
-    }));
-    const flowLines = orderFlowRows([
-        ...activityRows,
-        ...pendingTellRows(snapshot, maxColumns, activityRows.length),
-    ]).map((row) => truncateColumns(row.line, maxColumns));
-    const lines = [
-        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns),
-        ...diagnosticLines,
-        ...flowLines,
-    ];
-    const nextActions = state === "running" && options.runningActions === false
-        ? []
-        : nextActionLines(options.alias ?? projectionId, result, state);
-    if (nextActions.length > 0)
-        lines.push("");
-    lines.push(...nextActions);
-    const response = coreTextResponse(lines.join("\n"), result);
-    if (snapshot.phase === "dismissed")
-        return { ...response, exitCode: 130 };
-    if (["failed", "lost", "startup-timeout", "unknown"].includes(snapshot.phase)) {
-        return { ...response, exitCode: 1 };
-    }
-    return response;
-}
-/** The plural face labels every member because a successful singleton face is answer-only. */
-export function buildProjectionWaitSetResponse(result) {
-    const rendered = result.results
-        .slice()
-        .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
-        .map((member) => ({
-        id: member.id,
-        result: member.result,
-        response: buildWaitResponse(member.id, member.result, { runningActions: false }),
-    }));
-    const liveIds = rendered
-        .filter((member) => member.result.state === "timeout")
-        .map((member) => member.id);
-    const blocks = rendered.map(({ id, response }) => `${id}\n${response.text}`);
-    if (liveIds.length > 0) {
-        blocks.push([
-            "Come back for the result:",
-            `  » keiyaku wait ${liveIds.join(" ")} --${result.selection} [--timeout DURATION]`,
-            "Steer them while they work:",
-            `  » ${formatTellCommand("<projection-id>", '"your words"')}`,
-        ].join("\n"));
-    }
-    const text = blocks.join("\n\n");
-    const exitCode = rendered.reduce((current, { response }) => {
-        if (response.exitCode === 130)
-            return 130;
-        return response.exitCode === 1 ? 1 : current;
-    }, undefined);
-    return exitCode === undefined ? textResponse(text) : { ...textResponse(text), exitCode };
-}