openshain 0.2.0 → 0.4.0

package/src/preview.ts

@@ -0,0 +1,157 @@
+import { readFile } from "node:fs/promises";
+import { resolveWorkspacePath } from "@openshain/core";
+import { csvText } from "@openshain/tools";
+
+/** How much of a change the screen shows before it says the rest is cut. */
+const MAX_LINES = 24;
+/** Above this many lines on either side, the diff is replaced by the line counts. */
+const MAX_DIFF_LINES = 400;
+/** A single line longer than this is cut: one line must not fill the screen. */
+const MAX_LINE_CHARS = 300;
+
+export interface PreviewLine {
+  kind: "added" | "removed" | "context" | "note";
+  text: string;
+}
+
+/** The tools whose input the screen can render as the file it would leave behind. */
+const DIFFABLE: ReadonlySet<string> = new Set(["fs_write", "csv_write"]);
+
+/**
+ * What a held call would change, for the person about to approve it. A call of a tool that writes
+ * a whole file is shown as a line diff against the file as it is now; anything else is shown as
+ * its input. Reads the file directly: this is the person's own workspace, on their own screen.
+ */
+export async function previewCall(
+  workspaceRoot: string,
+  call: { name: string; input: unknown },
+): Promise<PreviewLine[]> {
+  if (!DIFFABLE.has(call.name)) return [{ kind: "note", text: JSON.stringify(call.input) }];
+  const input = (call.input ?? {}) as {
+    path?: unknown;
+    content?: unknown;
+    rows?: unknown;
+    columns?: unknown;
+  };
+  const path = typeof input.path === "string" ? input.path : undefined;
+  const content =
+    typeof input.content === "string"
+      ? input.content
+      : Array.isArray(input.rows)
+        ? csvText(
+            input.rows as Record<string, unknown>[],
+            Array.isArray(input.columns) ? (input.columns as string[]) : undefined,
+          )
+        : undefined;
+  if (path === undefined || content === undefined) {
+    return [{ kind: "note", text: JSON.stringify(call.input) }];
+  }
+  // The same guard the tools run under: a path outside the workspace, a reserved one or a
+  // symlink that leads out is refused here too, so the screen never shows what the call cannot
+  // touch. The model chooses this path; the person is about to read what it says.
+  let resolved: string;
+  try {
+    resolved = await resolveWorkspacePath(workspaceRoot, path);
+  } catch (err) {
+    return [
+      {
+        kind: "note",
+        text: `${path} は読めません(${err instanceof Error ? err.message : String(err)})。この呼び出しは実行しても拒否されます。`,
+      },
+    ];
+  }
+  const before = await readFile(resolved, "utf8").catch(() => undefined);
+  if (before === undefined) {
+    const lines = content.split("\n");
+    return cap([
+      { kind: "note", text: `${path} を新しく作ります(${lines.length} 行)` },
+      ...lines.map((text): PreviewLine => ({ kind: "added", text })),
+    ]);
+  }
+  const oldLines = before.split("\n");
+  const newLines = content.split("\n");
+  if (oldLines.length > MAX_DIFF_LINES || newLines.length > MAX_DIFF_LINES) {
+    return [
+      {
+        kind: "note",
+        text: `${path} を書き換えます(${oldLines.length} 行 → ${newLines.length} 行。大きいので差分は出しません)`,
+      },
+    ];
+  }
+  const body = diff(oldLines, newLines);
+  return cap([{ kind: "note", text: `${path} を書き換えます` }, ...body]);
+}
+
+function cap(lines: PreviewLine[]): PreviewLine[] {
+  const short = lines.map((line) =>
+    line.text.length > MAX_LINE_CHARS
+      ? { ...line, text: `${line.text.slice(0, MAX_LINE_CHARS)}…` }
+      : line,
+  );
+  if (short.length <= MAX_LINES) return short;
+  const rest = short.length - MAX_LINES;
+  return [...short.slice(0, MAX_LINES), { kind: "note", text: `ほか ${rest} 行` }];
+}
+
+/**
+ * A line diff by the longest common subsequence, with the unchanged lines around a change kept
+ * as context. Small files only; the caller checks the size first.
+ */
+function diff(before: string[], after: string[]): PreviewLine[] {
+  const table: number[][] = Array.from({ length: before.length + 1 }, () =>
+    new Array<number>(after.length + 1).fill(0),
+  );
+  for (let i = before.length - 1; i >= 0; i--) {
+    for (let j = after.length - 1; j >= 0; j--) {
+      const row = table[i] as number[];
+      const next = table[i + 1] as number[];
+      row[j] =
+        before[i] === after[j]
+          ? (next[j + 1] as number) + 1
+          : Math.max(next[j] as number, row[j + 1] as number);
+    }
+  }
+  const all: PreviewLine[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < before.length && j < after.length) {
+    if (before[i] === after[j]) {
+      all.push({ kind: "context", text: before[i] as string });
+      i++;
+      j++;
+    } else if ((table[i + 1]?.[j] ?? 0) >= (table[i]?.[j + 1] ?? 0)) {
+      all.push({ kind: "removed", text: before[i] as string });
+      i++;
+    } else {
+      all.push({ kind: "added", text: after[j] as string });
+      j++;
+    }
+  }
+  for (; i < before.length; i++) all.push({ kind: "removed", text: before[i] as string });
+  for (; j < after.length; j++) all.push({ kind: "added", text: after[j] as string });
+  return trimContext(all);
+}
+
+/** Keeps two unchanged lines on each side of a change and marks what was left out. */
+function trimContext(lines: PreviewLine[], keep = 2): PreviewLine[] {
+  const wanted = new Set<number>();
+  lines.forEach((line, index) => {
+    if (line.kind === "context") return;
+    for (let k = index - keep; k <= index + keep; k++) wanted.add(k);
+  });
+  const out: PreviewLine[] = [];
+  let skipped = 0;
+  lines.forEach((line, index) => {
+    if (wanted.has(index)) {
+      if (skipped > 0) {
+        out.push({ kind: "note", text: `… 変わらない ${skipped} 行 …` });
+        skipped = 0;
+      }
+      out.push(line);
+    } else {
+      skipped++;
+    }
+  });
+  if (skipped > 0) out.push({ kind: "note", text: `… 変わらない ${skipped} 行 …` });
+  return out;
+}

package/src/{commands/run.ts → report.ts}

@@ -1,66 +1,13 @@
-import { pendingQuestions, runWork } from "@openshain/agent";
 import {
   type AnyEvent,
-  createRuntime,
   type Event,
-  type Runtime,
-  type RuntimeProviders,
+  pendingQuestions,
   type ToolContent,
   type Work,
-  type WorkId,
 } from "@openshain/core";
-import { describeInput, truncate } from "../format.ts";
-import { failureLabel, rejectionLabel, statusLabel } from "../labels.ts";
-import { formatUsage, summarizeUsage } from "../usage.ts";
-
-export interface DriveOptions {
-  write: (line: string) => void;
-  /** Answers the model's questions. Without it, a question leaves the work waiting and the run ends. */
-  ask?: (question: string) => Promise<string>;
-  /** Stops the run. The work stays where it is and can be resumed. */
-  signal?: AbortSignal;
-}
-
-export interface RunOptions extends DriveOptions {
-  workspaceRoot: string;
-  providers: RuntimeProviders;
-  objective: string;
-}
-
-/** Creates a work for the request and drives it. Exit code 0 when the work completed. */
-export async function run(options: RunOptions): Promise<number> {
-  const runtime = await createRuntime({
-    workspaceRoot: options.workspaceRoot,
-    providers: options.providers,
-  });
-  const work = await runtime.works.create({
-    objective: options.objective,
-    principal: runtime.config.principal.id,
-    profession: runtime.config.profession.id,
-  });
-  options.write(`${work.id} を開始`);
-  return drive(runtime, work.id, options);
-}
-
-/** Drives a work from its current state, printing one line per tool call, and closes with the report. */
-export async function drive(
-  runtime: Runtime,
-  workId: WorkId,
-  options: DriveOptions,
-): Promise<number> {
-  const names = new Map<string, string>();
-  const done = await runWork(runtime, workId, {
-    ...(options.ask && { onInput: options.ask }),
-    ...(options.signal && { signal: options.signal }),
-    onEvent: (event) => {
-      const line = progressLine(event, names);
-      if (line) options.write(line);
-    },
-  });
-  const events = await runtime.works.events(workId);
-  for (const line of report(done, events)) options.write(line);
-  return done.status === "completed" ? 0 : 1;
-}
+import { describeInput, truncate } from "./format.ts";
+import { failureLabel, rejectionLabel, statusLabel } from "./labels.ts";
+import { formatUsage, summarizeUsage } from "./usage.ts";
 
 /** 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: AnyEvent, names: Map<string, string>): string | undefined {
@@ -126,9 +73,9 @@ export function nextActor(work: Work): string {
     case "cancelled":
       return "次に動く人はいません。";
     case "waiting_input":
-      return `次は利用者の番です。openshain work resume ${work.id} で質問に答えると続きます。`;
+      return `次は利用者の番です。openshain の会話で /work resume ${work.id} を実行し、続きを依頼すると質問に答えられます。`;
     case "waiting_approval":
-      return "次は利用者の番です。承認が要ります。";
+      return "次は利用者の番です。承認が要ります。openshain の会話で /approvals を確かめ、/approve <id> か /reject <id> で決めます。";
     case "failed":
       return "次は利用者の番です。原因を修正して、もう一度依頼してください。";
     default:

package/src/tui/app.tsx

@@ -18,7 +18,10 @@ const COLORS: Record<ScreenLine["kind"], string | undefined> = {
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 /** Rows that are not history: the header, the input box (three rows) and the status line. */
+/** The rows around the conversation: the header, the input box (3) and the status line. */
 const CHROME_ROWS = 5;
+/** The approval palette is taller: its two lines of heading plus one row per choice. */
+const APPROVAL_EXTRA_ROWS = 2;
 
 function statusText(state: ControllerState, scrolled: number): string {
   if (scrolled > 0)
@@ -70,9 +73,13 @@ export function App({ controller }: { controller: Controller }) {
   }, [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 chromeRows =
+    (state.approval
+      ? CHROME_ROWS + APPROVAL_EXTRA_ROWS + state.approval.choices.length
+      : CHROME_ROWS) + (state.queued.length > 0 && !state.approval ? 1 : 0);
+  const height = Math.max(chromeRows + 1, size.rows - 1);
   const width = Math.max(20, size.columns);
-  const paneRows = height - CHROME_ROWS;
+  const paneRows = height - chromeRows;
   const lines = useMemo(
     () => screenLines(state.entries, width).map((line, row) => ({ ...line, row })),
     [state.entries, width],
@@ -101,6 +108,17 @@ export function App({ controller }: { controller: Controller }) {
       if (!controller.interrupt()) void controller.close();
       return;
     }
+    // While a call waits for approval, the keys pick a choice instead of typing.
+    if (state.approval) {
+      if (key.upArrow) return controller.moveApproval(-1);
+      if (key.downArrow) return controller.moveApproval(1);
+      if (key.return) return controller.decideApproval();
+      if (key.escape) return controller.decideApproval("reject");
+      const index = Number.parseInt(ch, 10) - 1;
+      const chosen = state.approval.choices[index];
+      if (chosen) return controller.decideApproval(chosen.key);
+      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.
@@ -164,7 +182,9 @@ export function App({ controller }: { controller: Controller }) {
     setCursor(at + [...ch].length);
   });
 
+  const approval = state.approval;
   const asking = state.question !== undefined;
+  const queued = state.queued;
   const chars = [...input];
   const at = Math.min(cursor, chars.length);
   const before = chars.slice(0, at).join("");
@@ -186,11 +206,25 @@ export function App({ controller }: { controller: Controller }) {
       <Box flexDirection="column" height={paneRows}>
         {visible.map((line) => {
           const color = COLORS[line.kind];
-          if (line.segments) {
+          if (line.spans) {
+            // Each piece is named by the column it starts at, which does not move.
+            let column = 0;
+            const pieces = line.spans.map((span) => {
+              const at = column;
+              column += span.text.length;
+              return { ...span, at };
+            });
             return (
-              <Text key={line.row} wrap="truncate">
-                {line.segments.map((s) => (
-                  <Text key={s.at} color={s.color}>
+              <Text key={line.row} wrap="truncate" {...(color && { color })}>
+                {pieces.map((s) => (
+                  <Text
+                    key={`${line.row}-${s.at}`}
+                    {...(s.color && { color: s.color })}
+                    {...(s.bold && { bold: true })}
+                    {...(s.italic && { italic: true })}
+                    {...(s.dim && { dimColor: true })}
+                    {...(s.strikethrough && { strikethrough: true })}
+                  >
                     {s.text}
                   </Text>
                 ))}
@@ -209,14 +243,42 @@ export function App({ controller }: { controller: Controller }) {
           );
         })}
       </Box>
-      <Box borderStyle="round" borderColor={asking ? "magenta" : "gray"} paddingX={1}>
-        <Text color={asking ? "magenta" : "cyan"}>{asking ? "答え> " : "> "}</Text>
-        <Text>{before}</Text>
-        {under === "" ? <Text dimColor>▌</Text> : <Text inverse>{under}</Text>}
-        <Text>{after}</Text>
-      </Box>
+      {approval ? (
+        <Box borderStyle="round" borderColor="yellow" paddingX={1} flexDirection="column">
+          <Text color="yellow" wrap="truncate">
+            承認が要ります: {approval.title}
+          </Text>
+          <Text dimColor wrap="truncate">
+            規則 {approval.ruleId}
+          </Text>
+          {approval.choices.map((choice, index) => (
+            <Text
+              key={choice.key}
+              {...(index === approval.at && { color: "yellow" })}
+              wrap="truncate"
+            >
+              {index === approval.at ? "❯ " : "  "}
+              {index + 1}. {choice.label}
+            </Text>
+          ))}
+        </Box>
+      ) : (
+        <Box borderStyle="round" borderColor={asking ? "magenta" : "gray"} paddingX={1}>
+          <Text color={asking ? "magenta" : "cyan"}>{asking ? "答え> " : "> "}</Text>
+          <Text>{before}</Text>
+          {under === "" ? <Text dimColor>▌</Text> : <Text inverse>{under}</Text>}
+          <Text>{after}</Text>
+        </Box>
+      )}
+      {queued.length > 0 && !approval ? (
+        <Text dimColor wrap="truncate">
+          順番待ち {queued.length} 件: {queued.join(" / ")}
+        </Text>
+      ) : null}
       <Text dimColor wrap="truncate">
-        {bottom}
+        {approval
+          ? "↑ ↓ と Enter、または数字で選ぶ。Esc は拒否します。Ctrl-C は保留のまま止めます"
+          : bottom}
       </Text>
     </Box>
   );

package/src/tui/banner.ts

@@ -1,4 +1,5 @@
 import cli from "../../package.json" with { type: "json" };
+import type { Span } from "./markdown.ts";
 
 /** The version of the openshain command, from its package.json. */
 export const VERSION: string = cli.version;
@@ -19,15 +20,8 @@ const GRADIENT: readonly [readonly [number, number, number], readonly [number, n
   [127, 136, 255],
 ];
 
-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 function logoSegments(row: string): Segment[] {
+/** One colored piece per character, so the gradient runs across the row. */
+export function logoSegments(row: string): Span[] {
   const chars = [...row];
   const last = Math.max(1, chars.length - 1);
   return chars.map((text, at) => {
@@ -35,6 +29,6 @@ export function logoSegments(row: string): Segment[] {
     const [from, to] = GRADIENT;
     const channel = (k: 0 | 1 | 2) => 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 };
+    return { text, color: `#${hex.join("")}` };
   });
 }