@sofer_agent/cli 0.3.10 → 0.3.12

package/bin/sofer

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+// Register the @opentui/solid JSX transform plugin BEFORE any .tsx file is parsed.
+// Static imports are all hoisted by bun, so we must use a dynamic import for the
+// app entry so the plugin is active before bun touches tui.tsx.
+import '@opentui/solid/preload'
+await import('../src/bin.ts')

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@sofer_agent/cli",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "type": "module",
   "bin": {
-    "sofer": "./dist/bin.js"
+    "sofer": "./bin/sofer"
   },
-  "files": ["dist", "src"],
+  "files": ["dist", "src", "bin"],
   "publishConfig": {
     "access": "public"
   },
@@ -15,12 +15,15 @@
   },
   "keywords": ["sui", "ai", "agent", "walrus", "sovereign", "cli"],
   "scripts": {
-    "build": "tsc -b && chmod +x dist/bin.js",
+    "build": "tsc -b && chmod +x bin/sofer",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@clack/prompts": "^1.5.1",
-    "@sofer_agent/core": "workspace:*"
+    "@opentui/core": "0.4.1",
+    "@opentui/solid": "0.4.1",
+    "@sofer_agent/core": "0.3.3",
+    "solid-js": "1.9.13"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",

package/src/bin.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { agentPaths } from "@sofer_agent/core";
 import { chatCommand } from "./chat.js";
 import { infoCommand } from "./info.js";

package/src/chat.ts

@@ -8,52 +8,34 @@ import {
   SoferAgent,
 } from "@sofer_agent/core";
 import { loadSecrets } from "./env.js";
-import { SoferTui } from "./tui.js";
+import { addMessage, setInfo, runTui } from "./tui.tsx";
 
-/** Serializable message for JSONL session storage. */
 interface SessionMessage {
   role: string;
-  content: unknown; // Anthropic ContentBlock[]
-}
-
-interface SessionLine {
-  role: SessionMessage["role"];
-  content: SessionMessage["content"];
+  content: unknown;
 }
 
 function sessionPath(config: SoferConfig): string | null {
-  if (config.agentObjectId) {
-    return agentPaths.agent(shortAgentId(config.agentObjectId)).activityLog;
-  }
-  if (config.memwal.accountId) {
-    return agentPaths.agent(shortAgentId(config.memwal.accountId)).activityLog;
-  }
+  if (config.agentObjectId) return agentPaths.agent(shortAgentId(config.agentObjectId)).activityLog;
+  if (config.memwal.accountId) return agentPaths.agent(shortAgentId(config.memwal.accountId)).activityLog;
   return null;
 }
 
 function loadSession(path: string): SessionMessage[] {
   if (!existsSync(path)) return [];
   const messages: SessionMessage[] = [];
-  const raw = readFileSync(path, "utf8");
-  for (const line of raw.split("\n")) {
+  for (const line of readFileSync(path, "utf8").split("\n")) {
     if (!line.trim()) continue;
-    try {
-      const entry = JSON.parse(line) as SessionLine;
-      messages.push({ role: entry.role, content: entry.content });
-    } catch {
-      // skip malformed lines
-    }
+    try { messages.push(JSON.parse(line) as SessionMessage); } catch { /* skip */ }
   }
   return messages;
 }
 
 function saveSession(path: string, messages: SessionMessage[]): void {
-  const lines = messages.map((m) => JSON.stringify({ role: m.role, content: m.content }));
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${lines.join("\n")}\n`, "utf8");
+  writeFileSync(path, messages.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf8");
 }
 
-/** Interactive chat TUI with promus-style polish + session resume. */
 export async function chatCommand(): Promise<void> {
   const config = loadConfig();
   const secrets = loadSecrets();
@@ -61,50 +43,35 @@ export async function chatCommand(): Promise<void> {
     console.error("Missing secrets. Run `sofer init` first.");
     process.exit(1);
   }
-  const agent = await SoferAgent.create(config, { suiSecretKey: secrets.suiSecretKey, anthropicApiKey: secrets.anthropicApiKey });
+  const agent = await SoferAgent.create(config, {
+    suiSecretKey: secrets.suiSecretKey,
+    anthropicApiKey: secrets.anthropicApiKey,
+  });
 
-  // Session resume
   const sp = sessionPath(config);
   if (sp) {
     const history = loadSession(sp);
-    if (history.length > 0) {
-      agent.loadHistory(history);
-    }
+    if (history.length > 0) agent.loadHistory(history);
   }
 
-  const tui = new SoferTui(agent, config);
-
-  // Show initial balance
-  try {
-    const bal = await agent.getBalance();
-    tui.setInfo({ balance: (Number(bal) / 1e9).toFixed(4) });
-  } catch {
-    // RPC unavailable, skip
-  }
+  // Fetch initial balance non-blocking
+  agent.getBalance().then((bal) => {
+    setInfo({ balance: (Number(bal) / 1e9).toFixed(4) });
+  }).catch(() => {});
 
-  await tui.run(async (line, signal) => {
+  await runTui(agent, config, async (line, signal) => {
     try {
       const { text, turnUsage } = await agent.chat(line, signal);
-      tui.addMessage("agent", text);
-      tui.setInfo({ lastTurnIn: turnUsage.inputTokens, lastTurnOut: turnUsage.outputTokens });
+      addMessage("agent", text);
+      setInfo({ lastTurnIn: turnUsage.inputTokens, lastTurnOut: turnUsage.outputTokens });
     } catch (e) {
-      if (signal?.aborted) {
-        tui.addMessage("system", "turn interrupted (esc).");
+      if (signal.aborted) {
+        addMessage("system", "turn interrupted.");
       } else {
-        tui.addMessage("error", e instanceof Error ? e.message : String(e));
+        addMessage("error", e instanceof Error ? e.message : String(e));
       }
     }
-    // Query SUI balance (non-blocking — skip if RPC down)
-    try {
-      const bal = await agent.getBalance();
-      tui.setInfo({ balance: (Number(bal) / 1e9).toFixed(4) });
-    } catch {
-      // RPC unavailable, skip
-    }
-    // Save session after each turn
-    if (sp) {
-      saveSession(sp, agent.getHistory());
-    }
-    tui.render();
+    agent.getBalance().then((bal) => setInfo({ balance: (Number(bal) / 1e9).toFixed(4) })).catch(() => {});
+    if (sp) saveSession(sp, agent.getHistory());
   });
 }

package/src/tui.tsx

@@ -0,0 +1,227 @@
+import { render, useKeyboard, useTerminalDimensions } from "@opentui/solid";
+import type { SoferAgent, SoferConfig } from "@sofer_agent/core";
+import { For, Show, createEffect, createSignal, onCleanup } from "solid-js";
+
+const SPINNER_FRAMES = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"] as const;
+const SPINNER_MS = 80;
+
+export interface ChatLine {
+  role: "you" | "agent" | "system" | "error";
+  text: string;
+}
+
+export interface TuiInfo {
+  lastTurnIn: number;
+  lastTurnOut: number;
+  balance?: string;
+}
+
+// ── State signals (module-level so chat.ts can push into them) ──────────────
+
+const [rows, setRows] = createSignal<ChatLine[]>([]);
+const [status, setStatus] = createSignal<"idle" | "thinking">("idle");
+const [input, setInput] = createSignal("");
+const [info, setInfoSignal] = createSignal<TuiInfo>({ lastTurnIn: 0, lastTurnOut: 0 });
+const [turnStartedAt, setTurnStartedAt] = createSignal<number | null>(null);
+const [spinnerFrame, setSpinnerFrame] = createSignal(0);
+const [activeAbort, setActiveAbort] = createSignal<AbortController | null>(null);
+
+// ── Exported imperative API (used by chat.ts) ────────────────────────────────
+
+export function addMessage(role: ChatLine["role"], text: string): void {
+  setRows((prev) => [...prev, { role, text }]);
+}
+
+export function setInfo(patch: Partial<TuiInfo>): void {
+  setInfoSignal((prev) => ({ ...prev, ...patch }));
+}
+
+// ── Helper ───────────────────────────────────────────────────────────────────
+
+function formatElapsed(startedAt: number | null): string {
+  if (!startedAt) return "";
+  const sec = Math.floor((Date.now() - startedAt) / 1000);
+  if (sec < 60) return `${sec}s`;
+  const m = Math.floor(sec / 60);
+  return `${m}m${String(sec % 60).padStart(2, "0")}s`;
+}
+
+function shortModel(model: string): string {
+  const m = model.toLowerCase();
+  if (m.includes("sonnet")) return "sonnet-4";
+  if (m.includes("haiku")) return "haiku";
+  if (m.includes("opus")) return "opus-4";
+  return model.length > 16 ? `${model.slice(0, 15)}…` : model;
+}
+
+const LABEL: Record<ChatLine["role"], string> = {
+  you: "you",
+  agent: "agent",
+  system: "sys",
+  error: "err",
+};
+
+const COLOR: Record<ChatLine["role"], string> = {
+  you: "#67e8f9",
+  agent: "#86efac",
+  system: "#9ca3af",
+  error: "#fca5a5",
+};
+
+// ── Components ────────────────────────────────────────────────────────────────
+
+function MessageRow(props: { line: ChatLine }) {
+  return (
+    <box flexDirection="row" marginBottom={1}>
+      <text fg={COLOR[props.line.role]} flexShrink={0}>
+        {`   ${LABEL[props.line.role].padEnd(5)}  `}
+      </text>
+      <text wrapMode="word" flexGrow={1} fg="#e5e7eb">
+        {props.line.text}
+      </text>
+    </box>
+  );
+}
+
+function App(props: {
+  agent: SoferAgent;
+  config: SoferConfig;
+  onSubmit: (line: string, signal: AbortSignal) => Promise<void>;
+  onExit: () => void;
+}) {
+  const dims = useTerminalDimensions();
+
+  // Spinner tick — only while thinking
+  createEffect(() => {
+    if (status() !== "thinking") { setSpinnerFrame(0); return; }
+    const id = setInterval(
+      () => setSpinnerFrame((f) => (f + 1) % SPINNER_FRAMES.length),
+      SPINNER_MS,
+    );
+    onCleanup(() => clearInterval(id));
+  });
+
+  useKeyboard((evt) => {
+    if (evt.ctrl && evt.name === "c") { evt.preventDefault(); props.onExit(); return; }
+
+    if (evt.name === "escape") {
+      const ab = activeAbort();
+      if (ab && !ab.signal.aborted) ab.abort();
+      return;
+    }
+
+    if (status() === "thinking") return; // block input during turns
+
+    if (evt.name === "return") {
+      const text = input().trim();
+      if (!text) return;
+      if (text === "/exit" || text === "/quit") { props.onExit(); return; }
+      addMessage("you", text);
+      setInput("");
+      const ctrl = new AbortController();
+      setActiveAbort(ctrl);
+      setStatus("thinking");
+      setTurnStartedAt(Date.now());
+      props.onSubmit(text, ctrl.signal).finally(() => {
+        setStatus("idle");
+        setTurnStartedAt(null);
+        setActiveAbort(null);
+      });
+      return;
+    }
+
+    if (evt.name === "backspace" || evt.name === "delete") {
+      setInput((p) => p.slice(0, -1));
+      return;
+    }
+
+    if (evt.sequence && !evt.ctrl && !evt.meta && !evt.option) {
+      setInput((p) => p + evt.sequence);
+    }
+  });
+
+  const { agent, config } = props;
+  const addr = () => `${agent.address.slice(0, 6)}…${agent.address.slice(-4)}`;
+
+  return (
+    <box flexDirection="column" width={dims().width} height={dims().height}>
+      {/* Scrollable chat history */}
+      <scrollbox
+        flexGrow={1}
+        flexShrink={1}
+        stickyScroll
+        stickyStart="bottom"
+        contentOptions={{ flexDirection: "column", paddingLeft: 0, paddingRight: 1, paddingTop: 1, paddingBottom: 1 }}
+      >
+        <For each={rows()}>{(line) => <MessageRow line={line} />}</For>
+      </scrollbox>
+
+      {/* Spinner / hint row */}
+      <box flexDirection="row" flexShrink={0} paddingLeft={3} paddingRight={2} marginTop={1}>
+        <text fg="#67e8f9" flexGrow={1}>
+          {(() => {
+            if (status() !== "thinking") return " ";
+            spinnerFrame(); // reactive dependency
+            const elapsed = formatElapsed(turnStartedAt());
+            const frame = SPINNER_FRAMES[spinnerFrame()];
+            return elapsed
+              ? `${frame} thinking… ${elapsed} (esc to interrupt)`
+              : `${frame} thinking… (esc to interrupt)`;
+          })()}
+        </text>
+      </box>
+
+      {/* Input box */}
+      <box
+        flexDirection="row"
+        flexShrink={0}
+        minHeight={3}
+        maxHeight={8}
+        borderStyle="rounded"
+        borderColor="#374151"
+        paddingLeft={1}
+        paddingRight={1}
+        marginLeft={2}
+        marginRight={2}
+      >
+        <text fg="#67e8f9" flexShrink={0}>{"› "}</text>
+        <text wrapMode="word" flexGrow={1} fg="#e5e7eb">
+          {`${input()}${status() === "idle" ? "▋" : ""}`}
+        </text>
+      </box>
+
+      {/* Footer */}
+      <box flexDirection="row" flexShrink={0} paddingLeft={2} paddingRight={2}>
+        <text fg="#9ca3af">
+          {[
+            addr(),
+            `${config.network}`,
+            shortModel(config.brain.model),
+            info().balance ? `${info().balance} SUI` : null,
+            `in ${agent.usage.tokens.inputTokens}  out ${agent.usage.tokens.outputTokens}  $${agent.usage.costUsd.toFixed(4)}`,
+            "/exit",
+          ].filter(Boolean).join("  ·  ")}
+        </text>
+      </box>
+    </box>
+  );
+}
+
+// ── Main entry ────────────────────────────────────────────────────────────────
+
+export async function runTui(
+  agent: SoferAgent,
+  config: SoferConfig,
+  onSubmit: (line: string, signal: AbortSignal) => Promise<void>,
+): Promise<void> {
+  return new Promise<void>((resolve) => {
+    render(() => (
+      <App
+        agent={agent}
+        config={config}
+        onSubmit={onSubmit}
+        onExit={resolve}
+      />
+    ));
+  });
+}