openshain 0.1.1 → 0.3.1

package/dist/tui/controller.js

@@ -0,0 +1,325 @@
+import { connectInMemory, createSession } from "@openshain/agent";
+import { loadConfig, OpenshainError, WorkStore, } from "@openshain/core";
+import { createMcpServer } from "@openshain/mcp";
+import { toolsList } from "../commands/tools.js";
+import { workList, workShow } from "../commands/work.js";
+import { plain } from "../format.js";
+import { statusLabel } from "../labels.js";
+import { progressLine, report } from "../report.js";
+import { LOGO_ROWS, VERSION } from "./banner.js";
+const HELP = [
+    "/work list         Work の一覧",
+    "/work show <id>    Work の詳細",
+    "/work resume <id>  止まった Work を候補にする。次の依頼がそれに沿えば続ける",
+    "/tools             使える Tool",
+    "/quit              終わる",
+    "↑ ↓                前に送った行を入力欄に呼び戻す。いちばん下は新しい入力",
+    "← → Home End       入力欄でカーソルを動かす。Backspace と Delete はカーソルの位置で消す",
+    "ホイール、PageUp/PageDown  会話を遡る。送ると最新に戻る",
+    "Ctrl-C             動いている Work を止める。質問待ちなら質問を取り下げる。何も動いていなければ終わる",
+];
+/** What the session's model hears when the person stops a work that waits for their answer. */
+const QUESTION_WITHDRAWN = "the person stopped the work while it waited for their answer; the question is still pending and the work can be resumed";
+/**
+ * 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 async function createController(options) {
+    const { workspaceRoot, providers } = options;
+    const config = await loadConfig(workspaceRoot, { modelProviders: Object.keys(providers.models) });
+    if (!config.model) {
+        throw new OpenshainError("config", "対話にはモデルが要ります。openshain.yaml に model を書いてください。Claude Code や Codex から使うだけなら要りません。");
+    }
+    const modelFactory = Object.hasOwn(providers.models, config.model.provider)
+        ? providers.models[config.model.provider]
+        : undefined;
+    if (!modelFactory) {
+        throw new OpenshainError("config", `unknown model provider "${config.model.provider}"`);
+    }
+    const model = modelFactory(config.model);
+    if (!model.describe().capabilities.tools) {
+        throw new OpenshainError("config", `model ${config.model.provider}/${config.model.model} cannot call tools; openshain needs a model with tool support`);
+    }
+    const server = await createMcpServer({ workspaceRoot, tools: providers.tools });
+    const client = await connectInMemory(server);
+    const store = new WorkStore(workspaceRoot);
+    const listeners = new Set();
+    let nextId = 1;
+    const state = {
+        entries: [],
+        busy: false,
+        closed: false,
+        status: {
+            company: config.company.name,
+            model: `${config.model.provider}/${config.model.model}`,
+            usage: { modelCalls: 0, inputTokens: 0, outputTokens: 0 },
+        },
+    };
+    // A listener may act on the controller and cause another notification; those run after this one.
+    let notifying = false;
+    let again = false;
+    const notify = () => {
+        if (notifying) {
+            again = true;
+            return;
+        }
+        notifying = true;
+        try {
+            do {
+                again = false;
+                for (const listener of listeners)
+                    listener();
+            } while (again);
+        }
+        finally {
+            notifying = false;
+        }
+    };
+    const push = (kind, text) => {
+        state.entries = [...state.entries, { id: nextId++, kind, text: plain(text) }];
+        notify();
+    };
+    let pending;
+    let aborter;
+    let running;
+    let closing;
+    const names = new Map();
+    const ask = (workId, question) => {
+        state.question = question;
+        push("question", `${question}(${workId})`);
+        return new Promise((resolve, reject) => {
+            pending = { resolve, reject };
+        });
+    };
+    /** Answers the pending question, or takes it back when there is no answer. */
+    const settleQuestion = (answer) => {
+        const waiting = pending;
+        pending = undefined;
+        if (state.question !== undefined) {
+            delete state.question;
+            notify();
+        }
+        if (!waiting)
+            return;
+        if (answer === undefined)
+            waiting.reject(new Error(QUESTION_WITHDRAWN));
+        else
+            waiting.resolve(answer);
+    };
+    /** The lines the CLI prints when a work ends, shown among the progress lines. */
+    const closingLines = async (workId) => {
+        for (const line of await workReport(store, workId))
+            push("progress", line.trimStart());
+    };
+    let sessionId;
+    const session = await createSession(client, {
+        model,
+        config,
+        onEvent: (workId, event) => {
+            if (workId === sessionId) {
+                if (event.type === "usage.recorded") {
+                    const { payload } = event;
+                    if (payload.kind === "model_inference") {
+                        state.status.usage.modelCalls += 1;
+                        state.status.usage.inputTokens += payload.usage.inputTokens;
+                        state.status.usage.outputTokens += payload.usage.outputTokens;
+                        notify();
+                    }
+                }
+                return;
+            }
+            if (event.type === "work.status_changed") {
+                state.status.work = {
+                    id: workId,
+                    status: event.payload.to,
+                };
+                notify();
+                return;
+            }
+            if (event.type === "work.completed" || event.type === "work.failed") {
+                state.status.work = {
+                    id: workId,
+                    status: event.type === "work.completed" ? "completed" : "failed",
+                };
+                return closingLines(workId);
+            }
+            // The work_* calls are the loop's own bookkeeping; the closing lines already say the work ended.
+            if (event.type === "tool.called" &&
+                event.payload.name.startsWith("work_")) {
+                names.set(event.payload.callId, event.payload.name);
+                return;
+            }
+            const line = progressLine(event, names);
+            if (line)
+                push("progress", line);
+            else
+                notify();
+        },
+        onInput: ask,
+    });
+    sessionId = session.id;
+    state.status.agentName = session.agentName;
+    for (const row of LOGO_ROWS)
+        push("logo", row);
+    push("banner", `openshain ${VERSION}`);
+    push("banner", workspaceRoot);
+    const stopped = (workId) => workId
+        ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられるようにします。`
+        : "止めました。";
+    const explain = (result) => {
+        switch (result.stopped) {
+            case "turn_limit":
+                return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きは改めて依頼してください。";
+            case "aborted":
+                return stopped(result.work);
+            case "max_tokens":
+                return "返答が長さの上限で切れました。";
+            case "refusal":
+                return "社員エージェントが続けられないと言っています。";
+            case "model_error":
+                return `model の呼び出しに失敗しました。${result.detail ?? ""}`.trim();
+            default:
+                return undefined;
+        }
+    };
+    const message = (err) => (err instanceof Error ? err.message : String(err));
+    /** Runs one thing the person can stop with Ctrl-C, and keeps the screen busy meanwhile. */
+    const stoppable = async (fn) => {
+        const stopper = new AbortController();
+        aborter = stopper;
+        state.busy = true;
+        notify();
+        running = fn(stopper.signal);
+        try {
+            await running;
+        }
+        finally {
+            running = undefined;
+            aborter = undefined;
+            state.busy = false;
+            notify();
+        }
+    };
+    const capture = async (fn) => {
+        try {
+            await fn((line) => push("line", line));
+        }
+        catch (err) {
+            push("notice", message(err));
+        }
+    };
+    const command = async (line) => {
+        const [name, ...args] = line.slice(1).trim().split(/\s+/);
+        const sub = args[0] ?? "";
+        const id = args[1] ?? args[0] ?? "";
+        if (name === "help")
+            for (const h of HELP)
+                push("line", h);
+        else if (name === "quit" || name === "exit")
+            await close();
+        else if (name === "tools")
+            await capture((write) => toolsList({ ...options, write }));
+        else if (name === "work" && sub === "list")
+            await capture((write) => workList({ workspaceRoot: options.workspaceRoot, write }));
+        else if (name === "work" && (sub === "show" || sub === "resume") && !args[1])
+            push("notice", `/work ${sub} には Work の id が要ります。/work list で確かめてください。`);
+        else if (name === "work" && sub === "show" && id)
+            await capture((write) => workShow({ workspaceRoot: options.workspaceRoot, id, write }));
+        else if (name === "work" && sub === "resume" && id) {
+            try {
+                const work = await session.select(id);
+                push("notice", `${work.id}(${statusLabel(work.status)}、${work.objective})を候補にしました。次の依頼がこの Work に沿えば続けます。`);
+            }
+            catch (err) {
+                push("notice", message(err));
+            }
+        }
+        else if (name === "resume") {
+            push("notice", "セッションの再開はまだありません。止まった Work を続けるなら /work resume <id> です。");
+        }
+        else {
+            push("notice", `分からないコマンドです。/help で一覧が表示されます。`);
+        }
+    };
+    function close() {
+        closing ??= (async () => {
+            aborter?.abort();
+            settleQuestion();
+            await running;
+            try {
+                await session.close();
+            }
+            catch (err) {
+                push("notice", `会話の記録を閉じられませんでした。${message(err)}`);
+            }
+            finally {
+                await client.close().catch(() => undefined);
+                state.closed = true;
+                notify();
+            }
+        })();
+        return closing;
+    }
+    return {
+        sessionId: session.id,
+        state: () => state,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        async submit(line) {
+            const text = line.trim();
+            if (text === "" || closing)
+                return;
+            if (pending) {
+                push("user", text);
+                // Everything typed answers the question, except leaving: that takes the question back.
+                if (text === "/quit" || text === "/exit")
+                    await close();
+                else
+                    settleQuestion(text);
+                return;
+            }
+            if (state.busy) {
+                push("notice", "いま動いています。止めるなら Ctrl-C。");
+                return;
+            }
+            if (text.startsWith("/")) {
+                push("user", text);
+                await command(text);
+                return;
+            }
+            push("user", text);
+            await stoppable(async (signal) => {
+                try {
+                    const result = await session.turn(text, { signal });
+                    if (result.reply)
+                        push("assistant", result.reply);
+                    const note = explain(result);
+                    if (note)
+                        push("notice", note);
+                }
+                catch (err) {
+                    push("notice", message(err));
+                }
+            });
+        },
+        interrupt() {
+            if (!aborter)
+                return false;
+            aborter.abort();
+            settleQuestion();
+            return true;
+        },
+        close,
+    };
+}
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the agent relays. */
+export async function workReport(store, workId) {
+    const work = await store.get(workId);
+    const events = await store.events(workId);
+    const lines = report(work, events);
+    return work.status === "completed" ? ["完了。", ...lines.slice(1)] : lines;
+}
+export { statusLabel };

package/dist/tui/index.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeProviders } from "@openshain/core";
+export interface TuiOptions {
+    workspaceRoot: string;
+    providers: RuntimeProviders;
+}
+/** Opens the conversation screen and returns when the person leaves it. */
+export declare function startTui(options: TuiOptions): Promise<number>;

package/dist/tui/index.js

@@ -0,0 +1,45 @@
+import { render } from "ink";
+import React from "react";
+import { App } from "./app.js";
+import { createController } from "./controller.js";
+/** The alternate screen, cleared, with the terminal reporting the mouse (SGR) so the wheel reaches the screen. */
+const ENTER_SCREEN = "\x1b[?1049h\x1b[H\x1b[2J\x1b[?1000h\x1b[?1006h";
+const LEAVE_SCREEN = "\x1b[?1006l\x1b[?1000l\x1b[?1049l";
+/** Opens the conversation screen and returns when the person leaves it. */
+export async function startTui(options) {
+    const controller = await createController(options);
+    // Whatever ends the process, the terminal gets its screen and its mouse back: an error thrown
+    // while drawing, a signal, or a crash. Written once.
+    let left = false;
+    const leave = () => {
+        if (left)
+            return;
+        left = true;
+        process.stdout.write(LEAVE_SCREEN);
+    };
+    process.once("exit", leave);
+    process.stdout.write(ENTER_SCREEN);
+    try {
+        const { waitUntilExit } = render(React.createElement(App, { controller }), {
+            exitOnCtrlC: false,
+        });
+        // A closed terminal or a stop signal stops what runs and still ends the session in the record.
+        // Registered after render: Ink's own signal handling re-raises a signal when it thinks nobody
+        // else listens.
+        const closeAndExit = () => {
+            controller.close().finally(() => {
+                leave();
+                process.exit(0);
+            });
+        };
+        for (const signal of ["SIGHUP", "SIGTERM", "SIGINT"])
+            process.once(signal, closeAndExit);
+        await waitUntilExit();
+        await controller.close();
+    }
+    finally {
+        leave();
+    }
+    console.log(`会話を終えました。記録は openshain work show ${controller.sessionId} で参照します。`);
+    return 0;
+}

package/dist/tui/lines.d.ts

@@ -0,0 +1,12 @@
+import { type Segment } from "./banner.ts";
+import type { Entry, EntryKind } from "./controller.ts";
+export interface ScreenLine {
+    kind: EntryKind | "blank";
+    text: string;
+    /** Colored pieces of a logo row; the other rows are one color. */
+    segments?: Segment[];
+}
+/** Breaks text into lines no wider than `width` display columns, counting East Asian wide characters as two. */
+export declare function wrapText(text: string, width: number): string[];
+/** The rows the screen shows for the entries, wrapped to the width, with markers and blank rows between blocks. */
+export declare function screenLines(entries: readonly Entry[], width: number): ScreenLine[];

package/dist/tui/lines.js

@@ -0,0 +1,68 @@
+import { displayWidth } from "../format.js";
+import { logoSegments } from "./banner.js";
+/** What starts a line of each kind. The continuation lines of a wrapped entry are indented to match. */
+const MARKERS = {
+    user: "> ",
+    assistant: "⏺ ",
+    progress: "  ⎿ ",
+    notice: "! ",
+    question: "? ",
+    line: "  ",
+    logo: "",
+    banner: "",
+};
+/** Breaks text into lines no wider than `width` display columns, counting East Asian wide characters as two. */
+export function wrapText(text, width) {
+    const out = [];
+    for (const paragraph of text.split("\n")) {
+        let line = "";
+        let used = 0;
+        for (const ch of paragraph) {
+            const w = displayWidth(ch);
+            if (used + w > width && line !== "") {
+                out.push(line);
+                line = "";
+                used = 0;
+            }
+            line += ch;
+            used += w;
+        }
+        out.push(line);
+    }
+    return out;
+}
+/** A blank row goes before an entry that starts something new: a message, a reply, a notice, a question. */
+function startsBlock(kind, previous) {
+    if (previous === undefined)
+        return false;
+    if (kind === "logo" || kind === "banner")
+        return false;
+    if (kind === "progress")
+        return previous === "user";
+    if (kind === "line")
+        return previous !== "line";
+    return true;
+}
+/** The rows the screen shows for the entries, wrapped to the width, with markers and blank rows between blocks. */
+export function screenLines(entries, width) {
+    const lines = [];
+    let previous;
+    for (const entry of entries) {
+        if (startsBlock(entry.kind, previous))
+            lines.push({ kind: "blank", text: "" });
+        if (entry.kind === "logo") {
+            // Never wrapped: a cut row of the wordmark reads better than a broken one.
+            lines.push({ kind: "logo", text: entry.text, segments: logoSegments(entry.text) });
+            previous = entry.kind;
+            continue;
+        }
+        const marker = MARKERS[entry.kind];
+        const indent = " ".repeat(displayWidth(marker));
+        const body = wrapText(entry.text, Math.max(8, width - displayWidth(marker)));
+        for (const [i, text] of body.entries()) {
+            lines.push({ kind: entry.kind, text: (i === 0 ? marker : indent) + text });
+        }
+        previous = entry.kind;
+    }
+    return lines;
+}

package/dist/usage.d.ts

@@ -0,0 +1,12 @@
+import { type AnyEvent } from "@openshain/core";
+export interface UsageSummary {
+    modelCalls: number;
+    toolCalls: number;
+    inputTokens: number;
+    /** The part of inputTokens a prompt cache served. */
+    cachedInputTokens: number;
+    outputTokens: number;
+}
+/** Totals over a work's events: calls and tokens. */
+export declare function summarizeUsage(events: AnyEvent[]): UsageSummary;
+export declare function formatUsage(summary: UsageSummary): string;

package/dist/usage.js

@@ -0,0 +1,32 @@
+import { countToolCalls } from "@openshain/core";
+/** Totals over a work's events: calls and tokens. */
+export function summarizeUsage(events) {
+    const summary = {
+        modelCalls: 0,
+        toolCalls: 0,
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+    };
+    for (const event of events) {
+        if (event.type === "model.requested")
+            summary.modelCalls += 1;
+        if (event.type === "usage.recorded") {
+            const { payload } = event;
+            if (payload.kind === "model_inference") {
+                summary.inputTokens += payload.usage.inputTokens;
+                summary.cachedInputTokens += payload.usage.cachedInputTokens ?? 0;
+                summary.outputTokens += payload.usage.outputTokens;
+            }
+        }
+    }
+    summary.toolCalls = countToolCalls(events);
+    return summary;
+}
+export function formatUsage(summary) {
+    if (summary.modelCalls === 0 && summary.inputTokens === 0 && summary.outputTokens === 0) {
+        return `model 呼び出し 0 回、Tool 呼び出し ${summary.toolCalls} 回。model の使用量の記録はない`;
+    }
+    const cached = summary.cachedInputTokens > 0 ? `(うちキャッシュ ${summary.cachedInputTokens})` : "";
+    return `model 呼び出し ${summary.modelCalls} 回、Tool 呼び出し ${summary.toolCalls} 回、入力 ${summary.inputTokens} トークン${cached}、出力 ${summary.outputTokens} トークン`;
+}

package/dist/workspace.d.ts

@@ -0,0 +1,2 @@
+/** The nearest directory at or above `start` that holds openshain.yaml. */
+export declare function findWorkspace(start: string): Promise<string>;

package/dist/workspace.js

@@ -0,0 +1,20 @@
+import { access } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { CONFIG_FILE_NAME, OpenshainError } from "@openshain/core";
+/** The nearest directory at or above `start` that holds openshain.yaml. */
+export async function findWorkspace(start) {
+    let dir = resolve(start);
+    for (;;) {
+        try {
+            await access(join(dir, CONFIG_FILE_NAME));
+            return dir;
+        }
+        catch {
+            const parent = dirname(dir);
+            if (parent === dir) {
+                throw new OpenshainError("config", `${CONFIG_FILE_NAME} が見つかりません。${resolve(start)} から上に向かって探しました。openshain init で作成します。`);
+            }
+            dir = parent;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openshain",
-  "version": "0.1.1",
+  "version": "0.3.1",
   "description": "Reference CLI of the openshain agent harness",
   "keywords": [
     "openshain",
@@ -21,9 +21,11 @@
   "bugs": "https://github.com/openshain/openshain/issues",
   "type": "module",
   "engines": {
+    "node": ">=22",
     "bun": ">=1.3"
   },
   "files": [
+    "dist",
     "src",
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
@@ -31,17 +33,25 @@
     "LICENSE"
   ],
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "bin": {
-    "openshain": "./src/bin.ts"
+    "openshain": "./dist/bin.js"
+  },
+  "scripts": {
+    "build": "../../node_modules/.bin/tsc -p tsconfig.build.json",
+    "prepublishOnly": "rm -rf dist && ../../node_modules/.bin/tsc -p tsconfig.build.json"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@openshain/agent": "0.1.0",
-    "@openshain/core": "0.1.0",
-    "@openshain/mcp": "0.1.0",
-    "@openshain/tools": "0.1.0",
+    "@openshain/agent": "0.3.1",
+    "@openshain/core": "0.3.1",
+    "@openshain/mcp": "0.3.1",
+    "@openshain/tools": "0.3.1",
     "ink": "7.1.1",
     "react": "19.2.8"
   },

package/src/bin.ts

@@ -1,14 +1,12 @@
-#!/usr/bin/env bun
-import { createInterface } from "node:readline/promises";
+#!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { anthropicProvider, openaiCompatibleProvider } from "@openshain/agent";
 import { isOpenshainError, type RuntimeProviders } from "@openshain/core";
 import { standardTools } from "@openshain/tools";
 import { init } from "./commands/init.ts";
 import { mcp } from "./commands/mcp.ts";
-import { run } from "./commands/run.ts";
 import { toolsList } from "./commands/tools.ts";
-import { workList, workResume, workShow } from "./commands/work.ts";
+import { workList, workShow } from "./commands/work.ts";
 import { plain } from "./format.ts";
 import { errorLabel } from "./labels.ts";
 import { startTui } from "./tui/index.ts";
@@ -17,11 +15,9 @@ import { findWorkspace } from "./workspace.ts";
 const USAGE = `使い方:
   openshain                      端末で対話を始める
   openshain init                 openshain.yaml のひな型を書く
-  openshain run "<依頼>"          依頼を Work として進める
   openshain tools list           使える Tool の一覧
   openshain work list            Work の一覧
   openshain work show <id>       Work の詳細
-  openshain work resume <id>     途中で止まった Work を続ける
   openshain mcp                  MCP Server を stdio で起動する
 
   --workspace <dir>              起点のディレクトリ。省略時はカレントディレクトリ
@@ -67,17 +63,6 @@ async function main(argv: string[]): Promise<number> {
     case "init":
       await init({ workspaceRoot: values.workspace ?? process.cwd(), write });
       return 0;
-    case "run": {
-      const objective = rest.join(" ").trim();
-      if (!objective) {
-        write('依頼の文を指定してください。openshain run "今月の経理を進めて" のように。');
-        return 2;
-      }
-      const workspaceRoot = await findWorkspace(values.workspace ?? process.cwd());
-      return withTerminal((ask) =>
-        run({ workspaceRoot, providers, objective, write, ...(ask && { ask }) }),
-      );
-    }
     case "mcp": {
       const workspaceRoot = await findWorkspace(values.workspace ?? process.cwd());
       await mcp({ workspaceRoot, providers });
@@ -95,7 +80,7 @@ async function main(argv: string[]): Promise<number> {
     case "work": {
       const sub = rest[0];
       const id = rest[1] ?? "";
-      if (!(sub === "list" || ((sub === "show" || sub === "resume") && id))) {
+      if (!(sub === "list" || (sub === "show" && id))) {
         write(USAGE);
         return 2;
       }
@@ -104,13 +89,8 @@ async function main(argv: string[]): Promise<number> {
         await workList({ workspaceRoot, write });
         return 0;
       }
-      if (sub === "show") {
-        await workShow({ workspaceRoot, id, write });
-        return 0;
-      }
-      return withTerminal((ask) =>
-        workResume({ workspaceRoot, providers, id, write, ...(ask && { ask }) }),
-      );
+      await workShow({ workspaceRoot, id, write });
+      return 0;
     }
     default:
       write(`不明なコマンド ${command}`);
@@ -119,20 +99,6 @@ async function main(argv: string[]): Promise<number> {
   }
 }
 
-/** Runs `fn` with a way to ask the person when a terminal is there to answer; otherwise without one. */
-async function withTerminal(
-  fn: (ask?: (question: string) => Promise<string>) => Promise<number>,
-): Promise<number> {
-  // Without a terminal there is no one to answer; the work waits instead.
-  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) return fn();
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return await fn((question) => rl.question(`${plain(question)}\n> `));
-  } finally {
-    rl.close();
-  }
-}
-
 main(process.argv.slice(2)).then(
   (code) => process.exit(code),
   (err: unknown) => {