@oracle-agent/oracle 0.13.0 → 0.14.0

package/src/tui/app.mjs

@@ -0,0 +1,438 @@
+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,
+  client,
+  tuiFactory = createOracleTui,
+  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 };
+  if (env.ORACLE_NATIVE_TUI === "0") return { native: false, pass: parsed.pass };
+  const invocation = hermesPython;
+  if (!client && !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 = tuiFactory({
+    ...(client ? { client } : {}),
+    ...(invocation ? {
+      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,
+};

package/src/tui/backend.mjs

@@ -0,0 +1,215 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const PROVIDERS = Object.freeze({
+  openrouter: {
+    key: "OPENROUTER_API_KEY",
+    baseUrl: "https://openrouter.ai/api/v1",
+    model: "openrouter/auto",
+  },
+  openai: {
+    key: "OPENAI_API_KEY",
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-4.1-mini",
+  },
+  xai: {
+    key: "XAI_API_KEY",
+    baseUrl: "https://api.x.ai/v1",
+    model: "grok-4-latest",
+  },
+  deepseek: {
+    key: "DEEPSEEK_API_KEY",
+    baseUrl: "https://api.deepseek.com/v1",
+    model: "deepseek-chat",
+  },
+  gemini: {
+    key: "GEMINI_API_KEY",
+    alternateKey: "GOOGLE_API_KEY",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    model: "gemini-2.5-flash",
+  },
+});
+
+const OAUTH_PROVIDERS = Object.freeze({
+  "anthropic-oauth": {
+    key: "ANTHROPIC_API_KEY",
+    baseUrl: "https://api.anthropic.com/v1",
+    model: "claude-sonnet-4-20250514",
+    protocol: "anthropic-messages",
+  },
+  "openai-codex": {
+    key: "OPENAI_API_KEY",
+    baseUrl: "https://chatgpt.com/backend-api/codex",
+    model: "gpt-5.4",
+    protocol: "responses",
+  },
+  "xai-oauth": {
+    key: "XAI_API_KEY",
+    baseUrl: "https://api.x.ai/v1",
+    model: "grok-4-latest",
+    protocol: "responses",
+  },
+});
+
+function positiveInteger(value, fallback) {
+  const n = Number(value);
+  return Number.isSafeInteger(n) && n > 0 ? n : fallback;
+}
+
+function providerFromEnv(env, stored) {
+  const explicit = String(env.ORACLE_PROVIDER || stored.provider || "").trim().toLowerCase();
+  if (explicit) return explicit;
+  if (env.ORACLE_BASE_URL || stored.baseUrl) return "custom";
+  for (const [name, preset] of Object.entries(PROVIDERS)) {
+    if (env[preset.key] || (preset.alternateKey && env[preset.alternateKey])) return name;
+  }
+  return null;
+}
+
+export function standaloneConfigFromEnv(
+  env = process.env,
+  stored = {},
+  oauthAvailable = () => false,
+  apiKeyResolver = () => "",
+) {
+  const provider = providerFromEnv(env, stored);
+  if (!provider) return null;
+
+  const oauthPreset = OAUTH_PROVIDERS[provider];
+  const preset = PROVIDERS[provider] || oauthPreset;
+  const apiKeyEnv = String(env.ORACLE_API_KEY_ENV || stored.apiKeyEnv || "");
+  const apiKey = String(
+    env.ORACLE_API_KEY ||
+    (apiKeyEnv && env[apiKeyEnv]) ||
+    (preset && (env[preset.key] || (preset.alternateKey && env[preset.alternateKey]))) ||
+    apiKeyResolver(provider) ||
+    "",
+  );
+  const baseUrl = String(
+    oauthPreset
+      ? oauthPreset.baseUrl
+      : provider === "custom"
+        ? (env.ORACLE_BASE_URL || stored.baseUrl || "")
+        : (preset?.baseUrl || ""),
+  ).replace(/\/+$/, "");
+  const model = String(env.ORACLE_MODEL || stored.model || preset?.model || "");
+  if (!baseUrl || !model) return null;
+  const hasOAuth = Boolean(oauthPreset && oauthAvailable(provider));
+  if (oauthPreset && !hasOAuth) return null;
+  if (!oauthPreset && provider !== "custom" && !apiKey) return null;
+
+  return {
+    kind: "standalone",
+    provider,
+    model,
+    baseUrl,
+    ...(hasOAuth ? { authType: "oauth", protocol: oauthPreset.protocol } : { apiKey }),
+    contextLength: positiveInteger(env.ORACLE_CONTEXT_LENGTH || stored.contextLength, 128000),
+    reasoningEffort: String(env.ORACLE_REASONING_EFFORT || stored.reasoningEffort || "high"),
+  };
+}
+
+function setupReason(extra = "") {
+  return [
+    "Oracle runs its own native chat — no Hermes or external agent required.",
+    "Set OPENROUTER_API_KEY, run `oracle auth login claude|codex|grok`, or configure a custom OpenAI-compatible endpoint.",
+    "`oracle harness detect` finds any Agent Plugins-compatible clients installed on this machine.",
+    extra,
+  ].filter(Boolean).join("\n");
+}
+
+function remoteConfigFromEnv(env = process.env, stored = {}) {
+  if (env.ORACLE_PUBLIC_DESKTOP === "1" || env.ORACLE_REMOTE_COMPUTE_DISABLE === "1") return null;
+  const requested = String(env.ORACLE_CHAT_BACKEND || stored.backend || "auto").trim().toLowerCase();
+  const host = String(env.ORACLE_COMPUTE_HOST || stored.computeHost || "").trim();
+  if (!["remote", "arch"].includes(requested) && !env.ORACLE_COMPUTE_HOST) return null;
+  if (!host) return null;
+  const user = String(env.ORACLE_COMPUTE_USER || stored.computeUser || "").trim();
+  const p = String(env.ORACLE_COMPUTE_PATH || stored.computePath || "$HOME/.local/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin").trim();
+  return { kind: "remote", host, user, path: p };
+}
+
+/** Known harnesses Oracle can detect. Ordered: prefer Oracle-native first. */
+const KNOWN_HARNESSES = Object.freeze([
+  { name: "oracle", bin: "oracle", label: "Oracle Native (default)", kind: "oracle" },
+  { name: "hermes", bin: "hermes", label: "Hermes Agent", kind: "hermes" },
+  { name: "opencode", bin: "opencode", label: "OpenCode", kind: "mcp" },
+  { name: "claude", bin: "claude", label: "Claude Code", kind: "mcp" },
+  { name: "codex", bin: "codex", label: "OpenAI Codex CLI", kind: "mcp" },
+  { name: "cursor", bin: "cursor", label: "Cursor IDE", kind: "mcp" },
+  { name: "windsurf", bin: "windsurf", label: "Windsurf", kind: "mcp" },
+  { name: "aider", bin: "aider", label: "Aider", kind: "mcp" },
+  { name: "continue", bin: "continue", label: "Continue", kind: "mcp" },
+]);
+
+function which(bin) {
+  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+    const c = path.join(dir, bin);
+    try { if (fs.existsSync(c)) return c; } catch {}
+  }
+  return null;
+}
+
+/**
+ * Scan PATH for installed Agent Plugins-compatible harnesses.
+ * Returns objects: { name, bin, label, kind, path }
+ */
+export function detectInstalledHarnesses() {
+  const found = [];
+  for (const h of KNOWN_HARNESSES) {
+    if (h.name === "oracle") { found.push({ ...h, path: process.argv[1] || "oracle" }); continue; }
+    const p = which(h.bin);
+    if (p) found.push({ ...h, path: p });
+  }
+  return found;
+}
+
+export function resolveChatBackend({
+  env = process.env,
+  hermes = { ok: false },
+  storedConfig = null,
+  oauthAvailable = () => false,
+  apiKeyResolver = () => "",
+} = {}) {
+  const requested = String(env.ORACLE_CHAT_BACKEND || storedConfig?.backend || "auto").trim().toLowerCase();
+  const remote = remoteConfigFromEnv(env, storedConfig || {});
+
+  if (requested === "remote" || requested === "arch") {
+    return remote
+      ? { kind: "remote", config: remote }
+      : { kind: "unconfigured", reason: setupReason(`${requested} compute backend was requested, but no compute host is configured.`) };
+  }
+
+  const standalone = standaloneConfigFromEnv(env, storedConfig || {}, oauthAvailable, apiKeyResolver);
+
+  if (requested === "standalone") {
+    return standalone
+      ? { kind: "standalone", config: standalone }
+      : { kind: "unconfigured", reason: setupReason("ORACLE_CHAT_BACKEND=standalone was requested, but no standalone model is configured.") };
+  }
+
+  if (requested === "hermes") {
+    return hermes?.ok
+      ? { kind: "hermes", bin: hermes.bin }
+      : { kind: "unconfigured", reason: setupReason("ORACLE_CHAT_BACKEND=hermes was requested, but Hermes was not found.") };
+  }
+
+  // Any named harness: check if it's installed
+  if (requested !== "auto") {
+    for (const h of KNOWN_HARNESSES) {
+      if (h.name === requested) {
+        const p = which(h.bin);
+        if (p) return { kind: "harness", harness: { ...h, path: p } };
+        return { kind: "unconfigured", reason: setupReason(`ORACLE_CHAT_BACKEND=${requested} was requested, but ${h.bin} was not found on PATH.`) };
+      }
+    }
+    return { kind: "unconfigured", reason: setupReason(`Unknown ORACLE_CHAT_BACKEND value: ${requested}`) };
+  }
+
+  if (remote) return { kind: "remote", config: remote };
+  if (standalone) return { kind: "standalone", config: standalone };
+  if (hermes?.ok) return { kind: "hermes", bin: hermes.bin };
+  return { kind: "unconfigured", reason: setupReason() };
+}
+
+export default { resolveChatBackend, standaloneConfigFromEnv, detectInstalledHarnesses };