@oracle-agent/oracle 0.8.0 → 0.9.1

package/src/cli/oracle-harness.py

@@ -1,23 +1,80 @@
+#!/usr/bin/env python3
 import importlib
 import importlib.abc
 import importlib.machinery
-import re
+import json
+import os
+import shutil
+import subprocess
 import sys
 
-LOGO = (
-    "                 _",
-    " ___ _ _ __ _ __| |___",
-    "/ _ \\ '_/ _` / _| / -_)",
-    "\\___/_| \\__,_\\__|_\\___|",
+
+WORDMARK = (
+    "                                       ████          ",
+    "                                      ░░███          ",
+    "  ██████  ████████   ██████    ██████  ░███   ██████ ",
+    " ███░░███░░███░░███ ░░░░░███  ███░░███ ░███  ███░░███",
+    "░███ ░███ ░███ ░░░   ███████ ░███ ░░░  ░███ ░███████ ",
+    "░███ ░███ ░███      ███░░███ ░███  ███ ░███ ░███░░░  ",
+    "░░██████  █████    ░░████████░░██████  █████░░██████  ",
+    " ░░░░░░  ░░░░░      ░░░░░░░░  ░░░░░░  ░░░░░  ░░░░░░   ",
 )
 
-SILENT_STDERR = {
+SILENT_OUTPUT = {
     "[anthropic_billing_bypass] Bypass installed",
     "[anthropic_billing_bypass] Transport unwrap hook installed",
 }
 
 
-class OracleStderr:
+def _oracle_chain(command):
+    node = os.environ.get("ORACLE_NODE_BIN")
+    entry = os.environ.get("ORACLE_CLI_ENTRY")
+    if not node or not entry:
+        return False, "oracle chain is unavailable in this session"
+
+    parts = command.strip().split()[1:]
+    args = parts or ["list"]
+    try:
+        result = subprocess.run(
+            [node, entry, "chain", *args],
+            capture_output=True,
+            text=True,
+            timeout=15,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, f"oracle chain failed: {exc}"
+
+    output = "\n".join(
+        part.strip() for part in (result.stdout, result.stderr) if part.strip()
+    )
+    if result.returncode != 0:
+        return False, output or "oracle chain failed"
+
+    state = subprocess.run(
+        [node, entry, "chain", "show", "--json"],
+        capture_output=True,
+        text=True,
+        timeout=15,
+        check=False,
+    )
+    if state.returncode in (0, 1):
+        try:
+            active = json.loads(state.stdout).get("active") or {}
+            if active:
+                os.environ["ORACLE_ACTIVE_CHAIN"] = str(active.get("key", ""))
+                os.environ["ORACLE_ACTIVE_CHAIN_ID"] = str(active.get("chainId", ""))
+                os.environ["ORACLE_ACTIVE_AGENT"] = str(active.get("agent", ""))
+            else:
+                os.environ.pop("ORACLE_ACTIVE_CHAIN", None)
+                os.environ.pop("ORACLE_ACTIVE_CHAIN_ID", None)
+                os.environ.pop("ORACLE_ACTIVE_AGENT", None)
+        except (TypeError, ValueError):
+            pass
+    return True, output
+
+
+class OracleOutput:
     def __init__(self, wrapped):
         self.wrapped = wrapped
 
@@ -25,8 +82,12 @@ class OracleStderr:
         kept = "".join(
             line
             for line in data.splitlines(keepends=True)
-            if line.rstrip("\r\n") not in SILENT_STDERR
+            if line.rstrip("\r\n") not in SILENT_OUTPUT
         )
+        kept = kept.replace("hermes model", "oracle model")
+        kept = kept.replace("hermes --resume", "oracle --resume")
+        kept = kept.replace("hermes -c", "oracle -c")
+        kept = kept.replace(" in ~/.hermes/.env", " through oracle model")
         if kept:
             self.wrapped.write(kept)
         return len(data)
@@ -39,74 +100,213 @@ class OracleStderr:
 
 
 def patch_cli(module):
-    hermes_cli = getattr(module, "HermesCLI")
-    original_layout = hermes_cli._build_tui_layout_children
-    original_emit = hermes_cli._emit_stream_text
-    original_flush = hermes_cli._flush_stream
-    original_cprint = getattr(module, "_cprint")
-    frame_filter = [0]
-
-    def cprint(text="", *args, **kwargs):
-        if frame_filter[0] and isinstance(text, str):
-            plain = re.sub(r"\x1b\[[0-9;]*m", "", text).lstrip("\n")
-            if plain.startswith("\u256d\u2500oracle") or plain.startswith("\u2570"):
-                return None
-        return original_cprint(text, *args, **kwargs)
-
-    setattr(module, "_cprint", cprint)
+    cls = getattr(module, "HermesCLI", None)
+    if cls is None or getattr(cls, "_oracle_patched", False):
+        return
+
+    original_style = getattr(cls, "_build_tui_style_dict", None)
+    original_process_command = cls.process_command
 
     def show_banner(self):
+        from rich.align import Align
+        from rich.console import Group
+        from rich.panel import Panel
+        from rich.text import Text
+        from rich import box
+
         self.console.clear()
-        self._console_print()
-        for line in LOGO:
-            self._console_print(f"[#e6edf3]{line}[/]")
-        self._console_print()
+        width = shutil.get_terminal_size((100, 28)).columns
+        body = Text(justify="center")
+        if width >= 72:
+            colors = (
+                "#B8F0FF",
+                "#B8F0FF",
+                "#ACDEEF",
+                "#A5D9EB",
+                "#9FCBDD",
+                "#9FCBDD",
+                "#ACDEEF",
+                "#B8F0FF",
+            )
+            for index, line in enumerate(WORDMARK):
+                body.append(line.rstrip(), style=f"bold {colors[index]}")
+                if index != len(WORDMARK) - 1:
+                    body.append("\n")
+        else:
+            body.append("oracle", style="bold #B8F0FF")
+
+        body.append("\n\nTHE FUTURE IS AGENTIC", style="bold #EAF2F8")
+        body.append("  /  ", style="#52606D")
+        model = str(getattr(self, "model", "") or "choose model")
+        body.append(model, style="#91A2B1")
+
+        panel_width = max(36, min(width - 4, 76))
+        panel = Panel(
+            Group(Align.center(body)),
+            width=panel_width,
+            padding=(1, 2),
+            border_style="#3B4A56",
+            box=box.ROUNDED,
+            subtitle="[dim #6F7F8D]/model   /chain   /setup[/]",
+            subtitle_align="right",
+        )
+        self.console.print(Align.center(panel))
+        self.console.print()
 
     def prompt_fragments(self):
-        if self._approval_state or getattr(self, "_slash_confirm_state", None):
-            marker = "!"
-        elif self._clarify_state or self._clarify_freetext:
-            marker = "?"
-        elif self._command_running or self._agent_running:
-            marker = "..."
-        else:
-            marker = ">"
-        return [("class:prompt", f"oracle {marker} ")]
-
-    def layout_children(self, **kwargs):
-        kwargs["status_bar"] = None
-        kwargs["input_rule_top"] = None
-        kwargs["input_rule_bot"] = None
-        return original_layout(self, **kwargs)
-
-    def emit_stream_text(self, text):
-        first = not self._stream_box_opened
-        if first:
-            original_cprint()
-        frame_filter[0] += 1
-        try:
-            return original_emit(self, text)
-        finally:
-            frame_filter[0] -= 1
+        if getattr(self, "_voice_recording", False):
+            return [("class:voice-recording", "recording ")]
+        if getattr(self, "_voice_processing", False):
+            return [("class:voice-processing", "transcribing ")]
+        if getattr(self, "_sudo_state", None) or getattr(self, "_secret_state", None):
+            return [("class:sudo-prompt", "secure › ")]
+        if getattr(self, "_approval_state", None) or getattr(self, "_slash_confirm_state", None):
+            return [("class:prompt-working", "confirm › ")]
+        if getattr(self, "_clarify_freetext", False):
+            return [("class:clarify-selected", "answer › ")]
+        if getattr(self, "_clarify_state", None):
+            return [("class:prompt-working", "choose › ")]
+        if getattr(self, "_command_running", False):
+            return [("class:prompt-working", "working ")]
+        if getattr(self, "_agent_running", False):
+            return [("class:prompt-working", "thinking ")]
+        return [("class:prompt", "  Ask Oracle  › ")]
 
-    def flush_stream(self):
-        frame_filter[0] += 1
+    def status_fragments(self):
+        if not getattr(self, "_status_bar_visible", True) or getattr(self, "_model_picker_state", None):
+            return []
         try:
-            return original_flush(self)
-        finally:
-            frame_filter[0] -= 1
+            snapshot = self._get_status_bar_snapshot()
+            width = self._get_tui_terminal_width()
+            model = snapshot.get("model_short") or "model"
+            percent = snapshot.get("context_percent")
+            context = f"{percent}% context" if percent is not None else "context ready"
+            duration = snapshot.get("duration") or "0s"
+            if width < 58:
+                return [
+                    ("class:status-bar", "  "),
+                    ("class:status-bar-strong", model),
+                    ("class:status-bar-dim", f"  ·  {duration}  "),
+                ]
+            return [
+                ("class:status-bar", "  "),
+                ("class:status-bar-brand", "oracle"),
+                ("class:status-bar-dim", "  /  "),
+                ("class:status-bar-strong", model),
+                ("class:status-bar-dim", "  /  "),
+                ("class:status-bar-context", context),
+                ("class:status-bar-dim", "  /  "),
+                ("class:status-bar-dim", f"{duration}  "),
+            ]
+        except Exception:
+            return [("class:status-bar-brand", "  oracle  ")]
 
-    hermes_cli.show_banner = show_banner
-    hermes_cli._get_tui_prompt_fragments = prompt_fragments
-    hermes_cli._build_tui_layout_children = layout_children
-    hermes_cli._emit_stream_text = emit_stream_text
-    hermes_cli._flush_stream = flush_stream
-    tips = importlib.import_module("hermes_cli.tips")
+    def layout_children(
+        self,
+        *,
+        sudo_widget,
+        secret_widget,
+        approval_widget,
+        slash_confirm_widget=None,
+        clarify_widget,
+        model_picker_widget=None,
+        spinner_widget=None,
+        spacer,
+        status_bar,
+        input_rule_top,
+        image_bar,
+        input_area,
+        input_rule_bot,
+        voice_status_bar,
+        completions_menu,
+    ):
+        from prompt_toolkit.layout.containers import HSplit, VSplit, Window
+        from prompt_toolkit.widgets import Frame
+        from prompt_toolkit.widgets.base import Border
 
-    def no_tip():
-        raise LookupError("oracle quiet startup")
+        Border.TOP_LEFT = "╭"
+        Border.TOP_RIGHT = "╮"
+        Border.BOTTOM_LEFT = "╰"
+        Border.BOTTOM_RIGHT = "╯"
 
-    setattr(tips, "get_random_tip", no_tip)
+        composer = VSplit(
+            [
+                Window(width=1),
+                Frame(
+                    HSplit([item for item in (image_bar, input_area) if item is not None]),
+                    style="class:oracle-composer",
+                ),
+                Window(width=1),
+            ]
+        )
+        return [
+            item
+            for item in (
+                Window(height=0),
+                sudo_widget,
+                secret_widget,
+                approval_widget,
+                slash_confirm_widget,
+                clarify_widget,
+                model_picker_widget,
+                spinner_widget,
+                spacer,
+                composer,
+                completions_menu,
+                voice_status_bar,
+                status_bar,
+            )
+            if item is not None
+        ]
+
+    def build_style(self):
+        style = original_style(self) if original_style else {}
+        style.update(
+            {
+                "frame": "bg:#0B0E11 #EAF2F8",
+                "frame.border": "#455867",
+                "frame.label": "bold #B8F0FF",
+                "oracle-composer": "bg:#0B0E11 #EAF2F8",
+                "input-area": "bg:#0B0E11 #EAF2F8",
+                "prompt": "bold #B8F0FF",
+                "prompt-working": "bold #91C2D7",
+                "status-bar": "bg:#11161B #91A2B1",
+                "status-bar-brand": "bg:#11161B bold #B8F0FF",
+                "status-bar-strong": "bg:#11161B #EAF2F8",
+                "status-bar-context": "bg:#11161B #A5D9EB",
+                "status-bar-dim": "bg:#11161B #60717F",
+            }
+        )
+        return style
+
+    def process_command(self, command):
+        parts = command.strip().lower().split(maxsplit=1)
+        if parts and parts[0] == "/chain":
+            ok, output = _oracle_chain(command)
+            prefix = "" if ok else "error: "
+            lines = output.splitlines() or [""]
+            for index, line in enumerate(lines):
+                module._cprint(f"{prefix if index == 0 else ''}{line}")
+            return True
+        return original_process_command(self, command)
+
+    setattr(cls, "show_banner", show_banner)
+    setattr(cls, "_get_tui_prompt_fragments", prompt_fragments)
+    setattr(cls, "_get_status_bar_fragments", status_fragments)
+    setattr(cls, "_build_tui_layout_children", layout_children)
+    setattr(cls, "_build_tui_style_dict", build_style)
+    setattr(cls, "process_command", process_command)
+    setattr(cls, "_oracle_patched", True)
+
+    try:
+        tips = importlib.import_module("hermes_cli.tips")
+
+        def no_tip():
+            raise LookupError("oracle quiet startup")
+
+        setattr(tips, "get_random_tip", no_tip)
+    except Exception:
+        pass
 
 
 class OracleLoader(importlib.abc.Loader):
@@ -138,9 +338,11 @@ class OracleFinder(importlib.abc.MetaPathFinder):
 
 
 def main():
-    sys.stderr = OracleStderr(sys.stderr)
+    sys.stdout = OracleOutput(sys.stdout)
+    sys.stderr = OracleOutput(sys.stderr)
     sys.meta_path.insert(0, OracleFinder())
-    hermes_main = getattr(importlib.import_module("hermes_cli.main"), "main")
+    from hermes_cli.main import main as hermes_main
+
     return hermes_main()