@oracle-agent/oracle 0.9.6 → 0.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oracle-agent/oracle",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "Oracle: prepare-only multichain agent control plane. Policy-bounded intents for a user-signed wallet. Self-custody by default — the public package never takes your key. Built for Hermes; no model key required.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli/commands/chat.mjs

@@ -5,6 +5,7 @@ import { PACKAGE_ROOT, hermesRoot, ensureDir } from "../paths.mjs";
 import { activeChainEnv } from "../chain-state.mjs";
 import { spawnChild } from "../spawn-child.mjs";
 import { installManagedHermes, resolveHermes } from "../runtime.mjs";
+import { runOracleTui } from "../../tui/app.mjs";
 
 const PROFILE = "oracle";
 const SKIN_NAME = "oracle";
@@ -241,7 +242,7 @@ function modelReady(profile = PROFILE) {
 
 function usage() {
   return [
-    "oracle chat — filled lowercase oracle chat",
+    "oracle chat, filled lowercase oracle chat",
     "",
     "  oracle chat                 open interactive oracle chat",
     "  oracle chat -q \"...\"        one-shot query",
@@ -257,6 +258,23 @@ function usage() {
   ].join("\n");
 }
 
+function terminalColumns() {
+  const columns = Number(process.stdout?.columns || process.env.COLUMNS || 80);
+  return Number.isFinite(columns) && columns > 0 ? Math.floor(columns) : 80;
+}
+
+function visibleWidth(text) {
+  return Array.from(String(text)).length;
+}
+
+function centerBlock(lines, width) {
+  const clean = lines.map((line) => line.trimEnd());
+  const blockWidth = Math.max(0, ...clean.map((line) => visibleWidth(line)));
+  const left = Math.max(0, Math.floor((width - blockWidth) / 2));
+  const pad = " ".repeat(left);
+  return clean.map((line) => (line ? `${pad}${line}` : ""));
+}
+
 function printBanner() {
   const lines = [
     "",
@@ -270,7 +288,7 @@ function printBanner() {
     " ░░░░░░  ░░░░░      ░░░░░░░░  ░░░░░░  ░░░░░  ░░░░░░",
     "",
   ];
-  process.stdout.write(lines.join("\n") + "\n");
+  process.stdout.write(centerBlock(lines, terminalColumns()).join("\n") + "\n");
 }
 
 export default {
@@ -368,6 +386,17 @@ export default {
       ORACLE_CLI_ENTRY: path.join(PACKAGE_ROOT, "bin", "oracle.mjs"),
     });
 
+    const hermesPython = resolveHermesPython(hermes);
+    const native = await runOracleTui({
+      hermesPython,
+      args,
+      env: cleanEnv,
+      cwd: process.cwd(),
+      stdin: process.stdin,
+      stdout: process.stdout,
+    });
+    if (native.native) return native.code;
+
     const launch = oracleHarnessInvocation(hermes, [...hermesArgs, ...pass]);
 
     return spawnChild(

package/src/cli/oracle-harness.py

@@ -109,13 +109,25 @@ def patch_cli(module):
         from rich.align import Align
         from rich.console import Group
         from rich.panel import Panel
-        from rich.table import Table
         from rich.text import Text
         from rich import box
 
         self.console.clear()
         width = shutil.get_terminal_size((100, 28)).columns
+
+        panel_width = max(36, min(width - 4, 76))
+        panel_left = (width - panel_width) // 2
+        content_left = panel_left + 3
+        inner = panel_width - 6
+
+        def pad_for(ink_width, ink_offset=0):
+            target = int(round((width - ink_width) / 2.0))
+            pad = target - ink_offset - content_left
+            return max(0, min(max(0, inner - ink_width - ink_offset), pad))
+
         content = []
+        tagline = "THE FUTURE IS AGENTIC  /  by DEMI"
+
         if width >= 72:
             colors = (
                 "#B8F0FF",
@@ -125,18 +137,27 @@ def patch_cli(module):
                 "#9FCBDD",
                 "#B8F0FF",
             )
-            wordmark = Table.grid(padding=0, collapse_padding=True)
-            wordmark.add_column(width=58, no_wrap=True)
+            span = max(len(row) for row in WORDMARK)
+            ink_cols = [
+                index
+                for index in range(span)
+                if any(index < len(row) and row[index] != " " for row in WORDMARK)
+            ]
+            ink_offset = ink_cols[0]
+            ink_width = ink_cols[-1] - ink_cols[0] + 1
+            pad = " " * pad_for(ink_width, ink_offset)
             for index, line in enumerate(WORDMARK):
-                wordmark.add_row(Text(line, style=f"bold {colors[index]}"))
-            content.append(Align.center(wordmark))
+                content.append(
+                    Text(pad + line.rstrip(), style=f"bold {colors[index]}", no_wrap=True)
+                )
         else:
-            content.append(Align.center(Text("oracle", style="bold #B8F0FF")))
+            content.append(Text(" " * pad_for(6) + "oracle", style="bold #B8F0FF"))
 
         content.append(Text(""))
-        content.append(Align.center(Text("THE FUTURE IS AGENTIC  /  by DEMI", style="bold #EAF2F8")))
+        content.append(
+            Text(" " * pad_for(len(tagline)) + tagline, style="bold #EAF2F8", no_wrap=True)
+        )
 
-        panel_width = max(36, min(width - 4, 76))
         panel = Panel(
             Group(*content),
             width=panel_width,

package/src/tui/app.mjs

@@ -0,0 +1,427 @@
+import { EventEmitter } from "node:events";
+import { activeChainEnv } from "../cli/chain-state.mjs";
+import { createGatewayClient } from "./gateway-client.mjs";
+import { createInput } from "./input.mjs";
+import { createRenderer } from "./renderer.mjs";
+import {
+  formatElapsed,
+  renderBanner,
+  renderBox,
+  renderStatusBar,
+  visibleWidth,
+  wrapText,
+} from "./format.mjs";
+import { createPalette, THEME } from "./theme.mjs";
+
+const LIVE_TAIL_LINES = 6;
+
+function parseChatArgs(args = []) {
+  const out = { pass: [], query: null, model: null, provider: null, quiet: false, cont: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = args[i];
+    if ((a === "-q" || a === "--query") && args[i + 1]) {
+      out.query = args[++i];
+      out.pass.push("-q", out.query);
+      continue;
+    }
+    if ((a === "--model" || a === "-m") && args[i + 1]) {
+      out.model = args[++i];
+      out.pass.push("--model", out.model);
+      continue;
+    }
+    if (a === "--provider" && args[i + 1]) {
+      out.provider = args[++i];
+      out.pass.push("--provider", out.provider);
+      continue;
+    }
+    if (a === "--quiet" || a === "-Q") {
+      out.quiet = true;
+      out.pass.push(a);
+      continue;
+    }
+    if (a === "--continue" || a === "-c") {
+      out.cont = true;
+      out.pass.push("--continue");
+      continue;
+    }
+    out.pass.push(a);
+  }
+  return out;
+}
+
+export function applyUsage(state, usage) {
+  if (!usage || typeof usage !== "object") return;
+  const used = Number(usage.context_used ?? usage.context_tokens ?? usage.input ?? usage.prompt);
+  const max = Number(usage.context_max ?? usage.context_length);
+  if (Number.isFinite(used) && used > 0) state.contextTokens = used;
+  if (Number.isFinite(max) && max > 0) state.contextLength = max;
+  const percent = Number(usage.context_percent);
+  if (Number.isFinite(percent)) state.contextPercent = percent;
+  else if (state.contextLength > 0) {
+    state.contextPercent = Math.round((state.contextTokens / state.contextLength) * 100);
+  }
+}
+
+export function composerLines(state) {
+  const width = state.width;
+  const label = `${state.promptLabel} `;
+  const room = Math.max(1, width - 2 - visibleWidth(label));
+  const buffer = state.buffer || "";
+  const cursor = Math.max(0, Math.min(state.cursor ?? buffer.length, buffer.length));
+  let start = 0;
+  if (cursor > room) start = cursor - room;
+  const view = buffer.slice(start, start + room);
+  const rel = cursor - start;
+  const head = view.slice(0, rel);
+  const at = view.slice(rel, rel + 1) || " ";
+  const tail = view.slice(rel + 1);
+  const palette = state.palette;
+  const painted = `${palette.fg(THEME.accent, label)}${head}${palette.bg(THEME.selection_bg, at)}${tail}`;
+  return [painted];
+}
+
+export function fixedLines(state) {
+  const width = state.width;
+  const out = [];
+
+  if (state.liveLines.length > 0) {
+    for (const line of state.liveLines.slice(-LIVE_TAIL_LINES)) out.push(line);
+    out.push("");
+  }
+
+  out.push(...renderBox({
+    lines: composerLines(state),
+    width,
+    palette: state.palette,
+    title: "Ask Oracle ›",
+  }));
+
+  out.push(renderStatusBar({
+    model: state.model,
+    contextTokens: state.contextTokens,
+    contextLength: state.contextLength,
+    percent: state.contextPercent,
+    effort: state.effort,
+    thinking: state.thinking,
+    chain: state.chain,
+    width,
+    palette: state.palette,
+  }));
+  return out;
+}
+
+function eventShape(frame) {
+  const params = frame?.params || frame || {};
+  return {
+    type: params.type || frame?.type || "",
+    sessionId: params.session_id || frame?.session_id || "",
+    payload: params.payload || frame?.payload || {},
+  };
+}
+
+function textPayload(payload = {}) {
+  if (typeof payload.text === "string") return payload.text;
+  if (typeof payload.rendered === "string") return payload.rendered;
+  if (typeof payload.message === "string") return payload.message;
+  return "";
+}
+
+export function createOracleTui(options = {}) {
+  const stdout = options.stdout || process.stdout;
+  const stdin = options.stdin || process.stdin;
+  const width = Math.max(20, Number(stdout.columns || options.columns || 80));
+  const palette = options.palette || createPalette({ color: stdout.isTTY !== false });
+  const renderer = options.renderer || createRenderer({ stdout, rows: stdout.rows, columns: width });
+  const client = options.client || createGatewayClient({
+    python: options.python,
+    pythonArgs: options.pythonArgs || [],
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env,
+    spawnFn: options.spawnFn,
+    startupTimeoutMs: options.startupTimeoutMs,
+    requestTimeoutMs: options.requestTimeoutMs,
+  });
+  const emitter = new EventEmitter();
+  const now = options.now || (() => Date.now());
+  const state = {
+    palette,
+    width,
+    promptLabel: "oracle ›",
+    buffer: "",
+    cursor: 0,
+    model: options.model || "model",
+    contextTokens: 0,
+    contextLength: 0,
+    contextPercent: 0,
+    effort: options.effort || "",
+    thinking: "0s",
+    chain: (options.env || process.env).ORACLE_ACTIVE_CHAIN || "",
+    busy: false,
+    cancelled: false,
+    sessionId: null,
+    assistantBuffer: "",
+    flushedLines: 0,
+    liveLines: [],
+    startedAt: 0,
+  };
+  let input = null;
+  let ticker = null;
+
+  const ui = { renderer, state };
+
+  function renderNow() {
+    renderer.render(fixedLines(state));
+  }
+
+  function emitLine(text) {
+    renderer.writeAbove(`${text}\n`);
+  }
+
+  function recomputeLive() {
+    const parts = state.assistantBuffer.split("\n");
+    const partial = parts[parts.length - 1] || "";
+    state.liveLines = partial ? wrapText(partial, state.width) : [];
+  }
+
+  function flushAssistant({ final = false } = {}) {
+    const parts = state.assistantBuffer.split("\n");
+    const ready = final ? parts.length : parts.length - 1;
+    let wrote = false;
+    while (state.flushedLines < ready) {
+      const line = parts[state.flushedLines];
+      for (const wrapped of wrapText(line, state.width)) emitLine(wrapped);
+      state.flushedLines += 1;
+      wrote = true;
+    }
+    if (final) state.liveLines = [];
+    else recomputeLive();
+    return wrote;
+  }
+
+  function startTicker() {
+    if (ticker) return;
+    ticker = setInterval(() => {
+      if (!state.busy) return;
+      state.thinking = formatElapsed(now() - state.startedAt);
+      renderNow();
+    }, 250);
+    if (typeof ticker.unref === "function") ticker.unref();
+  }
+
+  function stopTicker() {
+    if (!ticker) return;
+    clearInterval(ticker);
+    ticker = null;
+  }
+
+  async function submit(text) {
+    const value = String(text || "").trim();
+    if (!value) return;
+    if (value === "/exit" || value === "/quit") {
+      await stop();
+      return;
+    }
+    if (value === "/clear") {
+      renderer.clear();
+      for (const line of renderBanner({ width: state.width, palette })) emitLine(line);
+      renderNow();
+      return;
+    }
+    state.busy = true;
+    state.assistantBuffer = "";
+    state.flushedLines = 0;
+    state.liveLines = [];
+    state.startedAt = now();
+    state.thinking = "0s";
+    emitLine(`${palette.bold(palette.fg(THEME.prompt, "you"))}  ${value}`);
+    emitLine("");
+    startTicker();
+    renderNow();
+    await client.request("prompt.submit", { session_id: state.sessionId, text: value });
+  }
+
+  function handleEvent(frame) {
+    const event = eventShape(frame);
+    if (event.type === "gateway.ready") return;
+
+    if (event.type === "session.info" && event.payload) {
+      if (event.payload.model) state.model = event.payload.model;
+      if (event.payload.reasoning_effort) state.effort = event.payload.reasoning_effort;
+      applyUsage(state, event.payload.usage);
+      renderNow();
+      return;
+    }
+    if (event.type === "message.start") {
+      state.busy = true;
+      state.cancelled = false;
+      state.assistantBuffer = "";
+      state.flushedLines = 0;
+      state.liveLines = [];
+      emitLine(palette.bold(palette.fg(THEME.accent, "oracle")));
+      renderNow();
+      return;
+    }
+    if (event.type === "thinking.delta" || event.type === "reasoning.delta") {
+      if (state.cancelled) return;
+      const text = textPayload(event.payload).trim();
+      if (text) state.thinking = `${formatElapsed(now() - state.startedAt)}`;
+      renderNow();
+      return;
+    }
+    if (event.type === "message.delta") {
+      if (state.cancelled) return;
+      state.assistantBuffer += textPayload(event.payload);
+      flushAssistant();
+      renderNow();
+      return;
+    }
+    if (event.type === "message.complete") {
+      if (state.cancelled) {
+        state.cancelled = false;
+        return;
+      }
+      const finalText = textPayload(event.payload);
+      if (finalText && finalText.length >= state.assistantBuffer.length) {
+        state.assistantBuffer = finalText;
+      }
+      flushAssistant({ final: true });
+      emitLine("");
+      state.busy = false;
+      stopTicker();
+      applyUsage(state, event.payload?.usage || event.payload?.context);
+      state.thinking = formatElapsed(now() - state.startedAt);
+      renderNow();
+      return;
+    }
+    if (event.type === "error") {
+      state.busy = false;
+      stopTicker();
+      emitLine(palette.fg(THEME.error, `error: ${textPayload(event.payload) || "unknown"}`));
+      renderNow();
+    }
+  }
+
+  async function start() {
+    await client.start();
+    client.on("event", handleEvent);
+    client.on("log", (line) => emitter.emit("log", line));
+    client.on("error", (error) => emitter.emit("error", error));
+    const session = await client.request("session.create", {
+      cols: state.width,
+      cwd: options.cwd || process.cwd(),
+      source: "cli",
+      profile: options.profile || "oracle",
+      close_on_disconnect: true,
+      ...(options.model ? { model: options.model } : {}),
+      ...(options.provider ? { provider: options.provider } : {}),
+    });
+    state.sessionId = session.session_id;
+    state.model = session.info?.model || state.model;
+    if (session.info?.reasoning_effort) state.effort = session.info.reasoning_effort;
+    applyUsage(state, session.info?.usage);
+    for (const line of renderBanner({ width: state.width, palette })) emitLine(line);
+    emitLine("");
+    renderNow();
+    input = createInput({
+      stdin,
+      stdout,
+      onSubmit: (value) => { submit(value).catch((error) => emitter.emit("error", error)); },
+      onCancel: () => {
+        if (!state.busy) return;
+        state.busy = false;
+        state.cancelled = true;
+        stopTicker();
+        flushAssistant({ final: true });
+        emitLine(palette.fg(THEME.warn, "interrupted"));
+        emitLine("");
+        renderNow();
+        client.request("session.interrupt", { session_id: state.sessionId })
+          .catch((error) => emitter.emit("error", error));
+      },
+      onEof: () => { stop().catch((error) => emitter.emit("error", error)); },
+      onClear: () => {
+        renderer.clear();
+        renderNow();
+      },
+      onRender: (editorState) => {
+        state.buffer = editorState.buffer || "";
+        state.cursor = editorState.cursor ?? state.buffer.length;
+        renderNow();
+      },
+    });
+    input.start();
+  }
+
+  async function stop() {
+    stopTicker();
+    if (input) input.stop();
+    renderer.dispose();
+    await client.stop();
+    emitter.emit("stop");
+  }
+
+  return Object.freeze({
+    start,
+    stop,
+    on: emitter.on.bind(emitter),
+    off: emitter.off.bind(emitter),
+    state,
+    handleEvent,
+    submit,
+  });
+}
+
+export async function runOracleTui({ hermesPython, args = [], env = process.env, cwd = process.cwd(), stdout = process.stdout, stdin = process.stdin } = {}) {
+  const parsed = parseChatArgs(args);
+  if (parsed.query) return { native: false, pass: parsed.pass };
+  if (!stdin.isTTY || !stdout.isTTY) return { native: false, pass: parsed.pass };
+  // Native TUI is intentionally opt-in while the stable oracle shim remains pinned.
+  if (env.ORACLE_NATIVE_TUI !== "1") return { native: false, pass: parsed.pass };
+  const invocation = hermesPython;
+  if (!invocation) return { native: false, pass: parsed.pass };
+  const cleanEnv = activeChainEnv({
+    ...env,
+    ORACLE_CHAT_SURFACE: "1",
+    ORACLE_PROFILE: "oracle",
+    ORACLE_NODE_BIN: process.execPath,
+  });
+  const tui = createOracleTui({
+    python: invocation.command,
+    pythonArgs: invocation.prefix || [],
+    cwd,
+    env: cleanEnv,
+    stdin,
+    stdout,
+    model: parsed.model,
+    provider: parsed.provider,
+    profile: "oracle",
+  });
+  tui.on("log", (line) => {
+    if (env.ORACLE_CLI_DEBUG) process.stderr.write(`${line}\n`);
+  });
+  tui.on("error", (error) => {
+    process.stderr.write(`oracle chat: ${error.message}\n`);
+  });
+  await tui.start();
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = async () => {
+      if (done) return;
+      done = true;
+      await tui.stop();
+      resolve({ native: true, code: 0 });
+    };
+    tui.on("stop", () => {
+      if (done) return;
+      done = true;
+      resolve({ native: true, code: 0 });
+    });
+    process.once("SIGINT", finish);
+    process.once("SIGTERM", finish);
+  });
+}
+
+export default {
+  createOracleTui,
+  runOracleTui,
+};