openshain 0.1.1 → 0.3.1

package/dist/report.js

@@ -0,0 +1,73 @@
+import { pendingQuestions, } from "@openshain/core";
+import { describeInput, truncate } from "./format.js";
+import { failureLabel, rejectionLabel, statusLabel } from "./labels.js";
+import { formatUsage, summarizeUsage } from "./usage.js";
+/** One line for a tool call, a rejection or a failure; nothing for the other events. `names` maps call ids to tool names. */
+export function progressLine(event, names) {
+    switch (event.type) {
+        case "tool.called": {
+            const { callId, name, input } = event.payload;
+            names.set(callId, name);
+            return `${name} ${describeInput(input)}`.trimEnd();
+        }
+        case "tool.rejected": {
+            const { name, code, reason } = event.payload;
+            return `${name} は拒否されました。${rejectionLabel(code)}。${reason}`;
+        }
+        case "tool.completed": {
+            const { callId, content, isError } = event.payload;
+            if (!isError)
+                return undefined;
+            return `${names.get(callId) ?? callId} は失敗しました。${truncate(firstLine(content))}`;
+        }
+        default:
+            return undefined;
+    }
+}
+function firstLine(content) {
+    for (const part of content) {
+        if (part.type === "text")
+            return part.text.split("\n")[0] ?? "";
+    }
+    return "";
+}
+/** The closing lines: what happened, what it cost, and who acts next. */
+export function report(work, events) {
+    const lines = [];
+    switch (work.status) {
+        case "completed":
+            lines.push(`完了。${work.outcome?.summary ?? ""}`.trimEnd());
+            for (const artifact of work.outcome?.artifacts ?? []) {
+                lines.push(`  書き込み ${artifact.path}${artifact.missing ? "  完了時には読めなかった" : ""}${artifact.claimed ? "  エージェントの申告(この Work の Tool は書いていない)" : ""}`);
+            }
+            break;
+        case "failed":
+            lines.push(`失敗。${failureLabel(work.failure?.reason)}。${work.failure?.detail ?? ""}`.trimEnd());
+            break;
+        case "waiting_input":
+            lines.push("利用者の入力を待っています。");
+            for (const { question } of pendingQuestions(events))
+                lines.push(`  質問 ${question}`);
+            break;
+        default:
+            lines.push(`状態は ${statusLabel(work.status)} です。`);
+    }
+    lines.push(formatUsage(summarizeUsage(events)));
+    lines.push(nextActor(work));
+    return lines;
+}
+export function nextActor(work) {
+    switch (work.status) {
+        case "completed":
+        case "cancelled":
+            return "次に動く人はいません。";
+        case "waiting_input":
+            return `次は利用者の番です。openshain の会話で /work resume ${work.id} を実行し、続きを依頼すると質問に答えられます。`;
+        case "waiting_approval":
+            return "次は利用者の番です。承認が要ります。";
+        case "failed":
+            return "次は利用者の番です。原因を修正して、もう一度依頼してください。";
+        default:
+            return "次は model の番です。";
+    }
+}

package/dist/tui/app.d.ts

@@ -0,0 +1,9 @@
+import type { Controller } from "./controller.ts";
+/**
+ * The whole terminal: a header, the conversation with the newest rows at the bottom, the input
+ * box, and a status line. The conversation scrolls inside the screen with the mouse wheel, PageUp
+ * and PageDown. The up and down arrows recall the lines sent before; the input is edited in place.
+ */
+export declare function App({ controller }: {
+    controller: Controller;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/tui/app.js

@@ -0,0 +1,191 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { useEffect, useMemo, useState } from "react";
+import { screenLines } from "./lines.js";
+const COLORS = {
+    user: "cyan",
+    assistant: undefined,
+    progress: "gray",
+    notice: "yellow",
+    question: "magenta",
+    line: undefined,
+    logo: undefined,
+    banner: undefined,
+    blank: undefined,
+};
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Rows that are not history: the header, the input box (three rows) and the status line. */
+const CHROME_ROWS = 5;
+function statusText(state, scrolled) {
+    if (scrolled > 0)
+        return `↑ ${scrolled} 行上を表示中。End で最新へ、ホイールか PageUp と PageDown で移動`;
+    const { work, usage } = state.status;
+    const parts = [];
+    if (work)
+        parts.push(`${work.id} ${work.status}`);
+    parts.push(`model ${usage.modelCalls} 回、入力 ${usage.inputTokens}、出力 ${usage.outputTokens} トークン`);
+    parts.push("/help で使い方");
+    return parts.join(" · ");
+}
+/**
+ * The whole terminal: a header, the conversation with the newest rows at the bottom, the input
+ * box, and a status line. The conversation scrolls inside the screen with the mouse wheel, PageUp
+ * and PageDown. The up and down arrows recall the lines sent before; the input is edited in place.
+ */
+export function App({ controller }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [state, setState] = useState(() => ({ ...controller.state() }));
+    const [input, setInput] = useState("");
+    /** Where the next character goes, counted in characters, not bytes. */
+    const [cursor, setCursor] = useState(0);
+    const [history, setHistory] = useState([]);
+    /** While the arrows walk the history: where we are, and what the input held before. */
+    const [recall, setRecall] = useState();
+    const [scroll, setScroll] = useState(0);
+    const [size, setSize] = useState({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+    const [tick, setTick] = useState(0);
+    useEffect(() => controller.subscribe(() => setState({ ...controller.state() })), [controller]);
+    useEffect(() => {
+        if (state.closed)
+            exit();
+    }, [state.closed, exit]);
+    useEffect(() => {
+        const onResize = () => setSize({ columns: stdout.columns ?? 80, rows: stdout.rows ?? 24 });
+        stdout.on("resize", onResize);
+        return () => {
+            stdout.off("resize", onResize);
+        };
+    }, [stdout]);
+    useEffect(() => {
+        if (!state.busy)
+            return;
+        const timer = setInterval(() => setTick((t) => t + 1), 100);
+        return () => clearInterval(timer);
+    }, [state.busy]);
+    // One row is left to the terminal: drawing exactly its height makes it scroll on every redraw.
+    const height = Math.max(CHROME_ROWS + 1, size.rows - 1);
+    const width = Math.max(20, size.columns);
+    const paneRows = height - CHROME_ROWS;
+    const lines = useMemo(() => screenLines(state.entries, width).map((line, row) => ({ ...line, row })), [state.entries, width]);
+    const maxScroll = Math.max(0, lines.length - paneRows);
+    const scrolled = Math.min(scroll, maxScroll);
+    const end = lines.length - scrolled;
+    const visible = lines.slice(Math.max(0, end - paneRows), end);
+    const page = Math.max(1, paneRows - 1);
+    /** Replaces the input and puts the cursor after it. */
+    const replaceInput = (text) => {
+        setInput(text);
+        setCursor([...text].length);
+    };
+    useInput((ch, key) => {
+        // The terminal reports the mouse (SGR). The wheel scrolls the conversation; the rest is ignored.
+        if (/\[<\d+;\d+;\d+[Mm]/.test(ch)) {
+            let delta = 0;
+            for (const m of ch.matchAll(/\[<(6[45]);\d+;\d+M/g))
+                delta += m[1] === "64" ? 3 : -3;
+            if (delta !== 0)
+                setScroll((s) => Math.max(0, Math.min(maxScroll, s + delta)));
+            return;
+        }
+        if (key.ctrl && ch === "c") {
+            if (!controller.interrupt())
+                void controller.close();
+            return;
+        }
+        if (key.pageUp)
+            return setScroll((s) => Math.min(maxScroll, s + page));
+        if (key.pageDown)
+            return setScroll((s) => Math.max(0, s - page));
+        // Up and down walk the lines sent before; below the newest one is what was being typed.
+        if (key.upArrow) {
+            const index = (recall?.index ?? history.length) - 1;
+            if (index < 0)
+                return;
+            setRecall({ index, draft: recall?.draft ?? input });
+            replaceInput(history[index] ?? "");
+            return;
+        }
+        if (key.downArrow) {
+            if (!recall)
+                return;
+            const index = recall.index + 1;
+            if (index >= history.length) {
+                replaceInput(recall.draft);
+                setRecall(undefined);
+                return;
+            }
+            setRecall({ ...recall, index });
+            replaceInput(history[index] ?? "");
+            return;
+        }
+        // Editing: the cursor moves with the arrows, Home and End (also Ctrl-A and Ctrl-E); Backspace
+        // deletes before it, Delete at it, Ctrl-U everything before it, Ctrl-K everything after it.
+        const chars = [...input];
+        const at = Math.min(cursor, chars.length);
+        if (key.leftArrow)
+            return setCursor(Math.max(0, at - 1));
+        if (key.rightArrow)
+            return setCursor(Math.min(chars.length, at + 1));
+        if (key.home || (key.ctrl && ch === "a"))
+            return setCursor(0);
+        if (key.end || (key.ctrl && ch === "e"))
+            return setCursor(chars.length);
+        if (key.backspace) {
+            if (at === 0)
+                return;
+            setInput([...chars.slice(0, at - 1), ...chars.slice(at)].join(""));
+            setCursor(at - 1);
+            return;
+        }
+        if (key.delete) {
+            setInput([...chars.slice(0, at), ...chars.slice(at + 1)].join(""));
+            return;
+        }
+        if (key.ctrl && ch === "u") {
+            setInput(chars.slice(at).join(""));
+            setCursor(0);
+            return;
+        }
+        if (key.ctrl && ch === "k")
+            return setInput(chars.slice(0, at).join(""));
+        // Ink hands a pasted or quickly typed chunk over whole, and a newline inside it does not set
+        // key.return. The line ends at the first newline; what follows becomes the next input.
+        const newline = key.return ? 0 : ch.search(/[\r\n]/);
+        if (newline >= 0) {
+            const line = [...chars.slice(0, at), ch.slice(0, newline), ...chars.slice(at)].join("");
+            if (line.trim() !== "")
+                setHistory((h) => (h.at(-1) === line ? h : [...h, line]));
+            setRecall(undefined);
+            replaceInput(ch.slice(newline + 1).replace(/^\n/, ""));
+            setScroll(0);
+            void controller.submit(line);
+            return;
+        }
+        if (key.tab || key.escape || key.ctrl || key.meta)
+            return;
+        setInput([...chars.slice(0, at), ch, ...chars.slice(at)].join(""));
+        setCursor(at + [...ch].length);
+    });
+    const asking = state.question !== undefined;
+    const chars = [...input];
+    const at = Math.min(cursor, chars.length);
+    const before = chars.slice(0, at).join("");
+    const under = chars[at] ?? "";
+    const after = chars.slice(at + 1).join("");
+    const bottom = state.busy
+        ? `${SPINNER[tick % SPINNER.length]} 作業中。Ctrl-C で止める`
+        : statusText(state, scrolled);
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height, children: [_jsx(Text, { dimColor: true, wrap: "truncate", children: [
+                    "openshain",
+                    state.status.company,
+                    ...(state.status.agentName ? [`社員エージェント ${state.status.agentName}`] : []),
+                    state.status.model,
+                ].join(" · ") }), _jsx(Box, { flexDirection: "column", height: paneRows, children: visible.map((line) => {
+                    const color = COLORS[line.kind];
+                    if (line.segments) {
+                        return (_jsx(Text, { wrap: "truncate", children: line.segments.map((s) => (_jsx(Text, { color: s.color, children: s.text }, s.at))) }, line.row));
+                    }
+                    return (_jsx(Text, { wrap: "truncate", dimColor: line.kind === "banner", ...(color && { color }), children: line.text || " " }, line.row));
+                }) }), _jsxs(Box, { borderStyle: "round", borderColor: asking ? "magenta" : "gray", paddingX: 1, children: [_jsx(Text, { color: asking ? "magenta" : "cyan", children: asking ? "答え> " : "> " }), _jsx(Text, { children: before }), under === "" ? _jsx(Text, { dimColor: true, children: "\u258C" }) : _jsx(Text, { inverse: true, children: under }), _jsx(Text, { children: after })] }), _jsx(Text, { dimColor: true, wrap: "truncate", children: bottom })] }));
+}

package/dist/tui/banner.d.ts

@@ -0,0 +1,15 @@
+/** The version of the openshain command, from its package.json. */
+export declare const VERSION: string;
+/**
+ * The wordmark as `oh-my-logo "openshain" --filled --block-font chrome` draws it, kept here so the
+ * screen needs neither the network nor another dependency to show it.
+ */
+export declare const LOGO_ROWS: readonly string[];
+export interface Segment {
+    text: string;
+    color: string;
+    /** Position in the row; the screen keys by it. */
+    at: number;
+}
+/** One colored segment per character, so the gradient runs across the row. */
+export declare function logoSegments(row: string): Segment[];

package/dist/tui/banner.js

@@ -0,0 +1,29 @@
+import cli from "../../package.json" with { type: "json" };
+/** The version of the openshain command, from its package.json. */
+export const VERSION = cli.version;
+/**
+ * The wordmark as `oh-my-logo "openshain" --filled --block-font chrome` draws it, kept here so the
+ * screen needs neither the network nor another dependency to show it.
+ */
+export const LOGO_ROWS = Object.freeze([
+    " ╔═╗ ╔═╗ ╔═╗ ╔╗╔ ╔═╗ ╦ ╦ ╔═╗ ╦ ╔╗╔",
+    " ║ ║ ╠═╝ ║╣  ║║║ ╚═╗ ╠═╣ ╠═╣ ║ ║║║",
+    " ╚═╝ ╩   ╚═╝ ╝╚╝ ╚═╝ ╩ ╩ ╩ ╩ ╩ ╝╚╝",
+]);
+/** oh-my-logo's grad-blue palette, from the left edge of the wordmark to the right. */
+const GRADIENT = [
+    [78, 168, 255],
+    [127, 136, 255],
+];
+/** One colored segment per character, so the gradient runs across the row. */
+export function logoSegments(row) {
+    const chars = [...row];
+    const last = Math.max(1, chars.length - 1);
+    return chars.map((text, at) => {
+        const t = at / last;
+        const [from, to] = GRADIENT;
+        const channel = (k) => Math.round(from[k] + (to[k] - from[k]) * t);
+        const hex = [channel(0), channel(1), channel(2)].map((v) => v.toString(16).padStart(2, "0"));
+        return { text, color: `#${hex.join("")}`, at };
+    });
+}

package/dist/tui/controller.d.ts

@@ -0,0 +1,59 @@
+import { type RuntimeProviders, type WorkId, WorkStore } from "@openshain/core";
+import { statusLabel } from "../labels.ts";
+/** logo and banner are the rows shown once when the screen opens: the wordmark, the version, the folder. */
+export type EntryKind = "user" | "assistant" | "progress" | "notice" | "question" | "line" | "logo" | "banner";
+export interface Entry {
+    id: number;
+    kind: EntryKind;
+    text: string;
+}
+export interface ControllerState {
+    /**
+     * Everything shown so far, in order. An entry never changes once added, and the array is
+     * replaced rather than mutated: the screen tells new entries apart by the array's identity.
+     */
+    entries: Entry[];
+    busy: boolean;
+    /** A question a work is asking; the next line the person types answers it. */
+    question?: string;
+    closed: boolean;
+    status: {
+        company: string;
+        model: string;
+        /** The name the agent goes by in this conversation. */
+        agentName?: string;
+        work?: {
+            id: string;
+            status: string;
+        };
+        usage: {
+            modelCalls: number;
+            inputTokens: number;
+            outputTokens: number;
+        };
+    };
+}
+export interface Controller {
+    readonly sessionId: WorkId;
+    state(): ControllerState;
+    subscribe(listener: () => void): () => void;
+    /** A line the person typed: an answer, a slash command, or something to say. */
+    submit(line: string): Promise<void>;
+    /** Ctrl-C: stops the running work, taking back a question it waits on; false when nothing was running. */
+    interrupt(): boolean;
+    /** Stops whatever is running, then ends the session. A second call waits for the same close. */
+    close(): Promise<void>;
+}
+export interface ControllerOptions {
+    workspaceRoot: string;
+    providers: RuntimeProviders;
+}
+/**
+ * The state behind the screen: a session, the works it starts, and the lines to show. The
+ * conversation reaches the runtime only as an MCP client of the workspace's own server, the way
+ * any other agent does; the records are read directly for the closing lines.
+ */
+export declare function createController(options: ControllerOptions): Promise<Controller>;
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the agent relays. */
+export declare function workReport(store: WorkStore, workId: WorkId): Promise<string[]>;
+export { statusLabel };