@astrosheep/keiyaku 4.6.15 → 4.6.16

package/build/src/cli/commands/install.js

@@ -1,3 +1,4 @@
+import { cliExitCode } from "../streams.js";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CliUsageError, commandGuide, usageLine } from "../usage.js";
@@ -44,7 +45,7 @@ export function parseInstallCommand(argv) {
     };
 }
 export function renderInstallHelp() {
-    return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits 1.`;
+    return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits ${cliExitCode("failed")}.`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../plugins");
@@ -108,6 +109,6 @@ export function renderInstallText(result) {
         .map((item) => item.status === "installed" ? `${item.harness} installed` : `${item.harness} failed: ${item.diagnostic}`)
         .join("\n");
 }
-export function installExitCode(result) {
-    return result.results.some((item) => item.status === "failed") ? 1 : 0;
+export function installOutcome(result) {
+    return result.results.some((item) => item.status === "failed") ? "failed" : "accepted";
 }

package/build/src/cli/commands/whoami.d.ts

@@ -0,0 +1,46 @@
+import type { CliOutcome } from "../streams.js";
+import { type AkumaCaller, type AkumaStatus, type ContractId } from "../../index.js";
+import { type WorldRoot } from "../../world.js";
+import type { CliCoordinates } from "../coordinates.js";
+import type { ParsedWhoamiCommand } from "../parse.js";
+type Self = AkumaCaller | Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "invalid";
+    reason: string;
+}>;
+type Contract = Readonly<{
+    kind: "resolved";
+    id: ContractId;
+}> | Readonly<{
+    kind: "none" | "ambiguous";
+}> | Readonly<{
+    kind: "unavailable";
+    reason: string;
+}>;
+type Profile = Readonly<{
+    kind: "available";
+    archetype: string;
+    aliases: readonly string[];
+    provider: string | null;
+    model: string | null;
+    workdir: string | null;
+    birth: AkumaStatus["birth"];
+    bornAt: string | null;
+    allowed: AkumaStatus["allowed"];
+    contracts: readonly ContractId[];
+}> | Readonly<{
+    kind: "unavailable";
+    reason: string;
+}>;
+export type WhoamiFacts = Readonly<{
+    world: WorldRoot | null;
+    self: Self;
+    initiator: string | null;
+    initiatorUnavailable?: string;
+    requests: "local" | "parent";
+    contract: Contract;
+    profile?: Profile;
+}>;
+export declare function runWhoami(command: ParsedWhoamiCommand, coordinates: CliCoordinates, environment: NodeJS.ProcessEnv): Promise<CliOutcome>;
+export {};

package/build/src/cli/commands/whoami.js

@@ -0,0 +1,127 @@
+import { AKUMA_REQUESTS_ENTRY_ENV, AKUMA_REQUESTS_ENV } from "../../akuma/providers/execution-environment.js";
+import { AkumaOwner } from "../../akuma/akuma-owner.js";
+import { readHeart, readLatestTurnForBody } from "../../akuma/heart/index.js";
+import { parseAkuId, pathsForAkuId } from "../../akuma/identity.js";
+import { Keiyaku, NoGitWorldError, Repo } from "../../index.js";
+import { observeNamedAddress } from "../../library/address.js";
+import { dispatchAssociations } from "../../library/selection.js";
+import { World } from "../../world.js";
+import { akumaCallerFromEnvironment } from "../akuma-caller.js";
+import { renderWhoami } from "../render/whoami.js";
+import { emit } from "../streams.js";
+function reason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function selfFrom(environment) {
+    try {
+        return (await akumaCallerFromEnvironment(environment)) ?? { kind: "none" };
+    }
+    catch (error) {
+        return { kind: "invalid", reason: reason(error) };
+    }
+}
+async function contextualContract(coordinates, world) {
+    if (world === null || coordinates.repo === undefined)
+        return { kind: "none" };
+    try {
+        const result = await Keiyaku.with().resolve({ repo: coordinates.repo, cwd: coordinates.cwd });
+        if (result.kind === "resolved")
+            return result;
+        return { kind: result.refusal.kind === "ambiguous-selector" ? "ambiguous" : "none" };
+    }
+    catch (error) {
+        return { kind: "unavailable", reason: reason(error) };
+    }
+}
+async function callerRepo(world, coordinates, environment) {
+    if (coordinates.repo?.root === world)
+        return coordinates.repo;
+    try {
+        const repo = await Repo.at({
+            path: world,
+            ...(environment.KEIYAKU_GIT_PATH === undefined ? {} : { gitPath: environment.KEIYAKU_GIT_PATH }),
+        });
+        return repo.root === world ? repo : undefined;
+    }
+    catch (error) {
+        if (error instanceof NoGitWorldError)
+            return undefined;
+        throw error;
+    }
+}
+async function currentTurn(self) {
+    let bornAt = null;
+    try {
+        const paths = pathsForAkuId(self.world, self.akuId);
+        const heart = await readHeart(paths);
+        bornAt = heart.soul?.createdAt ?? null;
+        const body = heart.latestBody;
+        if (body === null || body.end !== undefined || body.hung !== undefined)
+            return { initiator: null, bornAt };
+        const turn = await readLatestTurnForBody(paths, body.sequence);
+        if (turn === null || turn.end !== undefined)
+            return { initiator: null, bornAt };
+        // Confirm that the Body was still current and open when this Turn was observed.
+        const latest = (await readHeart(paths)).latestBody;
+        const initiator = latest?.sequence === body.sequence && latest.end === undefined && latest.hung === undefined
+            ? (turn.initiator ?? null)
+            : null;
+        return { initiator, bornAt };
+    }
+    catch (error) {
+        return { initiator: null, bornAt, unavailable: reason(error) };
+    }
+}
+async function callerProfile(caller, coordinates, environment, bornAt) {
+    try {
+        if (!(await World.established(caller.world)))
+            throw new Error("caller World is not established");
+        const id = parseAkuId(caller.akuId);
+        // This is the same status owner as the public read, without its plugin outcome observer.
+        const [status, aliases, repo] = await Promise.all([
+            new AkumaOwner(id.id, caller.world).status(),
+            observeNamedAddress({ world: caller.world, repo: null }),
+            callerRepo(caller.world, coordinates, environment),
+        ]);
+        if (aliases.aliases.kind !== "present") {
+            throw new Error(aliases.aliases.kind === "failed" ? aliases.aliases.failure.message : "aliases unavailable");
+        }
+        const dispatch = (await dispatchAssociations(repo, [id.id])).get(id.id);
+        if (dispatch.kind === "failed")
+            throw new Error(dispatch.diagnostic);
+        return {
+            kind: "available",
+            archetype: id.archetype,
+            aliases: aliases.aliases.value.filter((binding) => binding.akuId === id.id).map((binding) => binding.alias),
+            provider: status.provider ?? null,
+            model: status.model ?? null,
+            workdir: status.cwd ?? null,
+            birth: status.birth,
+            bornAt,
+            allowed: status.allowed,
+            contracts: dispatch.kind === "associated" ? [dispatch.contractId] : [],
+        };
+    }
+    catch (error) {
+        return { kind: "unavailable", reason: reason(error) };
+    }
+}
+export async function runWhoami(command, coordinates, environment) {
+    const world = coordinates.world !== null && (await World.established(coordinates.world)) ? coordinates.world : null;
+    const [self, contract] = await Promise.all([selfFrom(environment), contextualContract(coordinates, world)]);
+    const turn = self.kind === "akuma" ? await currentTurn(self) : undefined;
+    const facts = {
+        world,
+        self,
+        initiator: turn?.initiator ?? null,
+        ...(turn?.unavailable === undefined ? {} : { initiatorUnavailable: turn.unavailable }),
+        requests: environment[AKUMA_REQUESTS_ENV] !== undefined || environment[AKUMA_REQUESTS_ENTRY_ENV] !== undefined
+            ? "parent"
+            : "local",
+        contract,
+        ...(self.kind === "akuma"
+            ? { profile: await callerProfile(self, coordinates, environment, turn?.bornAt ?? null) }
+            : {}),
+    };
+    return emit(command.output, facts, () => renderWhoami(facts), "accepted");
+}

package/build/src/cli/main.js

@@ -1,9 +1,10 @@
 import { CliUsageError, parseArgv, renderHelp } from "./parse.js";
+import { cliExitCode } from "./streams.js";
 import { installedPackageVersion } from "./version.js";
 function handleBrokenPipe(stream) {
     stream.on("error", (error) => {
         if (error.code === "EPIPE")
-            process.exit(0);
+            process.exit(cliExitCode("accepted"));
         throw error;
     });
 }
@@ -16,17 +17,17 @@ export async function main(argv = process.argv.slice(2)) {
             const columns = process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : undefined;
             const help = renderHelp(parsed.help, columns);
             process.stdout.write(help.endsWith("\n") ? help : `${help}\n`);
-            return 0;
+            return cliExitCode("accepted");
         }
         if ("version" in parsed) {
             process.stdout.write(`${await installedPackageVersion()}\n`);
-            return 0;
+            return cliExitCode("accepted");
         }
         return await (await import("./runtime.js")).runCliCommand(parsed);
     }
     catch (error) {
         const diagnostic = error instanceof Error ? error.message : String(error);
         process.stderr.write(diagnostic.endsWith("\n") ? diagnostic : `${diagnostic}\n`);
-        return error instanceof CliUsageError ? 64 : 3;
+        return cliExitCode(error instanceof CliUsageError ? "usage" : "failed");
     }
 }

package/build/src/cli/parse.d.ts

@@ -10,7 +10,11 @@ export type { Command };
 export declare function renderRootHelp(columns?: number): string;
 export declare function usageGuideForCommand(command: ParsedCommand): CliUsageGuide;
 export declare function renderHelp(coordinate: CliHelpCoordinate, columns?: number): string;
-export type ParsedCommand = ParsedContractCommand | ParsedInstallCommand | ParsedAkumaCommand | ParsedDebtCommand;
+export type ParsedWhoamiCommand = Readonly<{
+    command: "whoami";
+    output: "text" | "json";
+}>;
+export type ParsedCommand = ParsedContractCommand | ParsedInstallCommand | ParsedAkumaCommand | ParsedDebtCommand | ParsedWhoamiCommand;
 type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{
@@ -21,6 +25,8 @@ type CliHelpCoordinate = Readonly<{
     action?: DebtAction;
 }> | Readonly<{
     kind: "install";
+}> | Readonly<{
+    kind: "whoami";
 }> | Readonly<{
     kind: "akuma";
     action: AkumaAction;

package/build/src/cli/parse.js

@@ -5,13 +5,15 @@ import { parseContractCommand, } from "./commands/contract-grammar.js";
 import { CONTRACT_COMMAND_SPECS, renderContractHelp as renderContractHelpForOwner, } from "./commands/contract-help.js";
 import { renderOpaqueBlock, renderTextBlock } from "./render/terminal.js";
 import { scanArgs } from "./scan.js";
-import { CliUsageError, commandGuide, isBlankInput, ROOT_USAGE_GUIDE, unknownCommandGuide, } from "./usage.js";
+import { CliUsageError, commandGuide, isBlankInput, ROOT_USAGE_GUIDE, unknownCommandGuide, usageLine, } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 const ROOT_USAGE = [
     "usage  keiyaku <command> [options]",
     "      keiyaku <command> --help   shows that command's complete usage",
 ].join("\n");
 const INVOCATION_PATH_OPTIONS = new Set(["-C", "--cwd", "--repo", "--workdir"]);
+const WHOAMI_USAGE = "whoami [--json]";
+const WHOAMI_PURPOSE = "Observe self, current Turn initiator, and Akuma profile.";
 export function renderRootHelp(columns) {
     return renderHelpText([
         "keiyaku — Contract, Debt, and Akuma control for one repository",
@@ -32,6 +34,7 @@ export function renderRootHelp(columns) {
         "Workspace",
         `  ${"install".padEnd(10)} ${INSTALL_ROOT_PURPOSE}`,
         `  ${"settings".padEnd(10)} ${CONTRACT_COMMAND_SPECS.settings.purpose}`,
+        `  ${"whoami".padEnd(10)} ${WHOAMI_PURPOSE}`,
         "",
         "Package",
         "  --version  Print the running package version.",
@@ -41,7 +44,7 @@ export function renderRootHelp(columns) {
         "  --repo <path>       Select the Git repository coordinate.",
         "  --workdir <path>    Set the execution directory for call only.",
         "",
-        "Outcomes:  exit 0 accepted · 1 refused · 2 retry · 3 failed · 64 usage",
+        "Outcomes:  exit 0 accepted · 1 refused · 2 retryable · 3 failed · 64 usage",
     ].join("\n"), columns);
 }
 function renderHelpText(help, columns) {
@@ -62,6 +65,8 @@ function renderHelpText(help, columns) {
         .join("\n");
 }
 export function usageGuideForCommand(command) {
+    if (command.command === "whoami")
+        return commandGuide("whoami", WHOAMI_USAGE);
     if (command.command === "install")
         return commandGuide("install", INSTALL_USAGE);
     if (command.command === "debt")
@@ -81,6 +86,8 @@ export function renderHelp(coordinate, columns) {
                 return renderDebtHelp(coordinate.action);
             case "install":
                 return renderInstallHelp();
+            case "whoami":
+                return `${WHOAMI_PURPOSE}\n\n${usageLine(WHOAMI_USAGE)}\n\nRead-only; an Akuma's current initiator and birth parent are distinct. Absent, invalid, and unavailable facts remain explicit.`;
             case "akuma":
                 return renderAkumaHelp(coordinate.action);
         }
@@ -102,6 +109,7 @@ export function commandRepoPolicy(command) {
         case "ls":
             return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
         case "status":
+        case "whoami":
         case "tell":
         case "ask":
             return { use: "optional", acceptsExplicit: false };
@@ -240,6 +248,8 @@ function helpCoordinate(argv) {
     }
     if (root === "install")
         return { kind: "install" };
+    if (root === "whoami")
+        return { kind: "whoami" };
     if (isAkumaAction(root))
         return { kind: "akuma", action: root };
     if (root !== undefined && Object.hasOwn(CONTRACT_COMMAND_SPECS, root)) {
@@ -247,6 +257,15 @@ function helpCoordinate(argv) {
     }
     return { kind: "root" };
 }
+function parseWhoami(argv) {
+    const fail = (message) => {
+        throw new CliUsageError(message, commandGuide("whoami", WHOAMI_USAGE));
+    };
+    const scanned = scanArgs(argv, { subject: "whoami", flags: { json: "boolean" }, stdinRefusal: "whoami reads no stdin" }, fail);
+    if (scanned.positionals.length > 0)
+        fail("whoami accepts no arguments");
+    return { command: "whoami", output: scanned.flags.json === true ? "json" : "text" };
+}
 export function parseArgv(argv) {
     const invocation = invocationOptions(argv);
     const help = helpCoordinate(invocation.commandArgv);
@@ -259,10 +278,11 @@ export function parseArgv(argv) {
         return { help: { kind: "debt" } };
     if (invocation.commandArgv.length === 1 && invocation.commandArgv[0] === "--version")
         return { version: true };
+    const whoami = invocation.commandArgv[0] === "whoami" ? parseWhoami(invocation.commandArgv) : undefined;
     const debt = invocation.commandArgv[0] === "debt" ? parseDebtCommand(invocation.commandArgv.slice(1)) : undefined;
     const install = invocation.commandArgv[0] === "install" ? parseInstallCommand(invocation.commandArgv.slice(1)) : undefined;
     const akuma = isAkumaAction(invocation.commandArgv[0]) ? parseAkumaCommand(invocation.commandArgv) : undefined;
-    const command = debt ?? akuma ?? install ?? parseContractCommand(scanArgv(invocation.commandArgv));
+    const command = whoami ?? debt ?? akuma ?? install ?? parseContractCommand(scanArgv(invocation.commandArgv));
     if (invocation.workdir !== undefined && command.command !== "call") {
         throw new CliUsageError(`option --workdir is not valid for ${command.command}`, usageGuideForCommand(command));
     }

package/build/src/cli/render/akuma-activity.d.ts

@@ -37,20 +37,6 @@ export declare function actionReceipt(input: Readonly<{
     alias?: string;
     evidence?: readonly string[];
 }>): readonly string[];
-/**
- * The one place row prefixes live: time, mark, verb, content.
- */
-type RowLayout = Readonly<{
-    head: (time: string | undefined, glyph: string, verb: string, columns: number) => string;
-    continuation: (verb: string) => string;
-    marker: (count: number) => string;
-    history?: true;
-    compactRun?: true;
-    /** A one-row receipt keeps that row on one line; speech can use its two-line budget. */
-    singleLine?: true;
-    /** World-board answer previews keep the conclusion at the tail. */
-    tailAnswer?: true;
-}>;
 /**
  * Shared snapshot activity rendering. Full snapshots render the selected
  * activity evidence; an idle snapshot is settled evidence. `latest` preserves
@@ -75,7 +61,7 @@ export type ActivityStream = ((activity: RenderedActivity) => readonly string[])
  * tools until the next checkpoint fold into one omission marker. Failed tools
  * always print.
  */
-export declare function activityStream(context: TextRenderContext, layout?: RowLayout): ActivityStream;
+export declare function activityStream(context: TextRenderContext): ActivityStream;
 export declare function inputWaitConclusion(observation: AkumaAskObservation, input: Readonly<{
     startedAt: number;
     completedAt?: string | null;
@@ -158,23 +144,24 @@ export declare function askRawAnswer(result: AkumaAskResult, structured: boolean
 export declare function callRawAnswer(result: CallResult, streamed: boolean): string | undefined;
 export declare function historyRawAnswer(result: AkumaHistoryResult, historyId: string | undefined): string | undefined;
 /**
- * One wait's final text: each observed Akuma's own status snapshot, then one
- * failure fact per member the wait could not read. A wait observes to its
- * completion judgment and streams nothing, so an answer is visible only as the
- * snapshot's own outcome row.
+ * One wait's final text: one compact line per observed member, then one failure line per member
+ * the wait could not read. A wait opens no frame and extracts no separate answer, so an answer is
+ * visible only as the snapshot's own bounded summary.
  */
 export declare function waitText(result: AkumaWaitResult, presentation: AkumaPresentation, context: TextRenderContext): string;
 export declare function historyText(result: AkumaHistoryResult, presentation: AkumaPresentation & Readonly<{
     id?: string;
     last?: boolean;
 }>, context: TextRenderContext): string;
-/** One bounded preview of a submitted Tell, indented once beneath its verdict or evidence. */
+/** One bounded, quoted preview of a Tell an outer receipt already admitted, indented beneath it. */
 export declare function tellPayloadLines(text: string, context: TextRenderContext): readonly string[];
-/** One admitted Tell as a timeline row inside a shared input panel; the panel owns the identity. */
+/** One admitted Tell as a timeline input row inside a shared panel; the panel owns the identity. */
 export declare function tellAdmissionRow(tell: AkumaTellResult["tell"], context: TextRenderContext): string;
 /**
- * One Tell action receipt: the delivery verdict and complete subject, then the submitted payload
- * once. A held Tell keeps neutral vocabulary; a failed delivery keeps its own concrete diagnosis.
+ * One Tell action receipt: the delivery verdict and complete subject stand whole on the first line
+ * with the submitted payload folded onto that same line, bounded so only its preview truncates. A
+ * held Tell keeps neutral vocabulary; a failed delivery keeps its concrete diagnosis and native log
+ * coordinates as separate supporting facts.
  */
 export declare function tellText(result: AkumaTellResult, alias: string | undefined, context: TextRenderContext): string;
 export {};