omnimancer-cli 0.2.24__tar.gz → 0.2.26__tar.gz

{omnimancer_cli-0.2.24/omnimancer_cli.egg-info → omnimancer_cli-0.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.24
+Version: 0.2.26
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT
@@ -22,7 +22,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0.0
-Requires-Dist: rich>=13.0.0
+Requires-Dist: rich>=15.0.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: cryptography>=41.0.0
@@ -35,10 +35,13 @@ Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: jsonschema>=4.17.0
 Requires-Dist: readability-lxml>=0.8.1
+Requires-Dist: lxml_html_clean>=0.1.0
 Requires-Dist: PyYAML>=6.0.0
 Requires-Dist: toml>=0.10.2
 Requires-Dist: mcp<2,>=1.0.0
 Requires-Dist: prompt-toolkit<4.0,>=3.0.43
+Provides-Extra: tui
+Requires-Dist: textual>=8.0; extra == "tui"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -48,6 +51,7 @@ Requires-Dist: black>=23.0.0; extra == "dev"
 Requires-Dist: isort>=5.12.0; extra == "dev"
 Requires-Dist: flake8>=6.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: textual>=8.0; extra == "dev"
 Dynamic: license-file
 
 <p align="center">
@@ -129,7 +133,8 @@ object — including the tool calls the agent made along the way:
   ],
   "usage": {"input_tokens": 1523, "output_tokens": 892, "total_cost_usd": 0.04},
   "total_cost_usd": 0.04,
-  "stop_reason": "end_turn"
+  "stop_reason": "end_turn",
+  "stop_cause": "done"
 }
 ```
 
@@ -139,6 +144,14 @@ On failure it stays valid JSON (stdout), with the error and any tool calls made:
 {"type": "result", "subtype": "error", "is_error": true, "error": "…", "tool_calls": [...]}
 ```
 
+`stop_cause` reports why the run ended: `done` (model declared completion), `nudge_exhausted` (model stopped acting without declaring completion), `max_iterations` (tool-iteration cap hit), or `repeat_abort` (aborted after repeating an identical tool call). Exit codes:
+
+| Exit code | Meaning |
+|---|---|
+| 0 | Run completed (`stop_cause` of `done` or `nudge_exhausted`) |
+| 1 | Provider or engine error (`subtype: "error"`) |
+| 3 | Run truncated: `max_iterations` or `repeat_abort` — the result is partial |
+
 For a live, line-by-line stream of what the agent is doing (assistant text,
 each `tool_use`, each `tool_result`, then the final `result`), use
 `--output-format stream-json`.

{omnimancer_cli-0.2.24 → omnimancer_cli-0.2.26}/README.md

@@ -77,7 +77,8 @@ object — including the tool calls the agent made along the way:
   ],
   "usage": {"input_tokens": 1523, "output_tokens": 892, "total_cost_usd": 0.04},
   "total_cost_usd": 0.04,
-  "stop_reason": "end_turn"
+  "stop_reason": "end_turn",
+  "stop_cause": "done"
 }
 ```
 
@@ -87,6 +88,14 @@ On failure it stays valid JSON (stdout), with the error and any tool calls made:
 {"type": "result", "subtype": "error", "is_error": true, "error": "…", "tool_calls": [...]}
 ```
 
+`stop_cause` reports why the run ended: `done` (model declared completion), `nudge_exhausted` (model stopped acting without declaring completion), `max_iterations` (tool-iteration cap hit), or `repeat_abort` (aborted after repeating an identical tool call). Exit codes:
+
+| Exit code | Meaning |
+|---|---|
+| 0 | Run completed (`stop_cause` of `done` or `nudge_exhausted`) |
+| 1 | Provider or engine error (`subtype: "error"`) |
+| 3 | Run truncated: `max_iterations` or `repeat_abort` — the result is partial |
+
 For a live, line-by-line stream of what the agent is doing (assistant text,
 each `tool_use`, each `tool_result`, then the final `result`), use
 `--output-format stream-json`.

omnimancer_cli-0.2.26/omn_fleet_hook.py

@@ -0,0 +1,215 @@
+"""Claude Code hook adapter for the omnimancer fleet event feed.
+
+Registered in ``~/.claude/settings.json`` (all events, ``async: true``) as
+the ``omn-fleet-hook`` console script. Each invocation reads ONE hook
+payload from stdin, maps it to an omn.event.v1 line, and appends it to
+``~/.omnimancer/events/omn-<session_id>.jsonl`` — the same files the
+``omn fleet`` dashboard tails, so Claude Code sessions appear on the board
+next to omn and codex agents.
+
+DELIBERATELY a top-level, stdlib-only module: importing the omnimancer
+package pulls pydantic and friends, and this process starts once per hook
+event. Schema constants are duplicated from ``omnimancer/events/schema.py``
+(the owner of the omn.event.v1 vocabulary) — keep them in sync.
+
+Never blocks, never fails: any error exits 0 silently (a monitoring hook
+must not be able to break a Claude session). ``OMNIMANCER_EVENTS=0``
+disables it; ``OMNIMANCER_EVENTS_DIR`` overrides the output directory.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+# Owner of these values: omnimancer/events/schema.py (omn.event.v1).
+SCHEMA_VERSION = 1
+PREVIEW_CHARS = 200
+MESSAGE_PREVIEW_CHARS = 500
+
+MAX_STDIN_BYTES = 1_000_000
+# Strict uuid shape: anything looser produces filenames that fall outside
+# SESSION_FILE_RE and would escape the retention/budget sweeps entirely.
+SESSION_ID_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+TARGET_KEYS = ("command", "file_path", "path", "url", "pattern")
+
+# Claude hook_event_name -> omn.event.v1 event name.
+EVENT_MAP = {
+    "SessionStart": "session_start",
+    "UserPromptSubmit": "turn_start",
+    "PreToolUse": "tool_start",
+    "PostToolUse": "tool_end",
+    "PostToolUseFailure": "tool_end",
+    "Stop": "turn_end",
+    "SessionEnd": "session_end",
+}
+
+
+def _truncate(text: str, limit: int) -> str:
+    """Truncate to limit chars with a single-char ellipsis (schema rule)."""
+    if len(text) <= limit:
+        return text
+    return text[: limit - 1] + "…"
+
+
+def _utc_now_iso() -> str:
+    """UTC ISO8601 with millisecond precision (schema rule)."""
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+
+
+def _events_dir() -> str:
+    """Resolve the events directory (env override for tests/relocation)."""
+    override = os.environ.get("OMNIMANCER_EVENTS_DIR")
+    if override:
+        return override
+    return os.path.join(os.path.expanduser("~"), ".omnimancer", "events")
+
+
+def _target_from(tool_input: Any) -> Optional[str]:
+    """First actionable string from a tool_input dict, clipped."""
+    if not isinstance(tool_input, dict):
+        return None
+    for key in TARGET_KEYS:
+        value = tool_input.get(key)
+        if isinstance(value, str) and value:
+            return _truncate(value, PREVIEW_CHARS)
+    return None
+
+
+def _build_data(payload: Dict[str, Any], event: str) -> Dict[str, Any]:
+    """Per-event data payload (fields mirror the omn emitters)."""
+    hook_event = payload.get("hook_event_name")
+    if event == "session_start":
+        return {
+            "harness": "claude",
+            "model": payload.get("model"),
+            "source": payload.get("source"),
+            "permission_mode": payload.get("permission_mode"),
+        }
+    if event == "turn_start":
+        # Live payloads carry "prompt"; "prompt_text" kept as a fallback
+        # for older documented shapes (live-verified 2026-08-01).
+        prompt = payload.get("prompt") or payload.get("prompt_text")
+        return {
+            "prompt_preview": (
+                _truncate(prompt, PREVIEW_CHARS) if isinstance(prompt, str) else None
+            ),
+        }
+    if event == "tool_start":
+        return {
+            "tool": payload.get("tool_name"),
+            "target": _target_from(payload.get("tool_input")),
+            "op_id": payload.get("tool_use_id"),
+            "invocation": "claude",
+        }
+    if event == "tool_end":
+        data: Dict[str, Any] = {
+            "tool": payload.get("tool_name"),
+            "op_id": payload.get("tool_use_id"),
+            "success": hook_event == "PostToolUse",
+        }
+        if hook_event == "PostToolUseFailure":
+            # Live payloads carry "error" (+ "is_interrupt" for user
+            # cancellation); "tool_output" kept as a fallback for older
+            # documented shapes (live-verified 2026-08-01).
+            error = payload.get("error") or payload.get("tool_output")
+            if isinstance(error, str):
+                data["error"] = _truncate(error, MESSAGE_PREVIEW_CHARS)
+            if payload.get("is_interrupt"):
+                data["was_cancelled"] = True
+        return data
+    if event == "turn_end":
+        message = payload.get("last_assistant_message")
+        return {
+            "last_message_preview": (
+                _truncate(message, MESSAGE_PREVIEW_CHARS)
+                if isinstance(message, str)
+                else None
+            ),
+        }
+    if event == "session_end":
+        return {"reason": payload.get("reason")}
+    return {}
+
+
+def _agent_identity(payload: Dict[str, Any]) -> tuple:
+    """(agent_id, parent_id): subagent payloads carry agent_id/agent_type."""
+    agent_id = payload.get("agent_id")
+    if isinstance(agent_id, str) and agent_id:
+        agent_type = payload.get("agent_type") or "agent"
+        return f"subagent-{agent_type}-{agent_id[:8]}", "main"
+    return "main", None
+
+
+def build_line(payload: Dict[str, Any]) -> Optional[str]:
+    """Map one Claude hook payload to an omn.event.v1 JSON line, or None."""
+    event = EVENT_MAP.get(str(payload.get("hook_event_name")))
+    if event is None:
+        return None
+    session_id = payload.get("session_id")
+    # fullmatch, not match: $ tolerates a trailing newline, which would
+    # mint a filename that escapes the retention/budget sweeps.
+    if not isinstance(session_id, str) or not SESSION_ID_RE.fullmatch(session_id):
+        return None
+    agent_id, parent_id = _agent_identity(payload)
+    envelope = {
+        "v": SCHEMA_VERSION,
+        "ts": _utc_now_iso(),
+        "event": event,
+        "session_id": session_id.lower(),
+        "agent_id": agent_id,
+        "parent_id": parent_id,
+        "pid": os.getpid(),
+        # -1: out-of-band producer (no shared counter across hook processes);
+        # consumers order by file-append position and ts.
+        "seq": -1,
+        "mode": "claude",
+        "cwd": payload.get("cwd"),
+        "data": _build_data(payload, event),
+    }
+    return json.dumps(envelope, ensure_ascii=False, separators=(",", ":"))
+
+
+def main() -> int:
+    """Read one payload from stdin, append one line; always exit 0."""
+    try:
+        if os.environ.get("OMNIMANCER_EVENTS", "") == "0":
+            return 0
+        raw = sys.stdin.buffer.read(MAX_STDIN_BYTES)
+        payload = json.loads(raw.decode("utf-8", errors="replace"))
+        if not isinstance(payload, dict):
+            return 0
+        line = build_line(payload)
+        if line is None:
+            return 0
+        directory = _events_dir()
+        os.makedirs(directory, mode=0o700, exist_ok=True)
+        # mode= only applies at creation: repair pre-existing permissive
+        # dirs/files too — these paths carry prompt/command previews.
+        os.chmod(directory, 0o700)
+        path = os.path.join(directory, f"omn-{payload['session_id'].lower()}.jsonl")
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
+        try:
+            if hasattr(os, "fchmod"):
+                os.fchmod(fd, 0o600)
+            else:
+                # Windows has no fchmod; best-effort by path so the write
+                # below still happens instead of dying on AttributeError.
+                os.chmod(path, 0o600)
+            os.write(fd, (line + "\n").encode("utf-8"))
+        finally:
+            os.close(fd)
+    except Exception:
+        # A monitoring hook must never surface an error into the session.
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{omnimancer_cli-0.2.24 → omnimancer_cli-0.2.26}/omnimancer/cli/agent_loop.py

@@ -10,13 +10,12 @@ import ipaddress
 import logging
 import re
 import shlex
-import subprocess
 from difflib import SequenceMatcher
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, cast
 from urllib.parse import urlparse, urlunparse
 
-from ..core.agent.types import Operation, OperationType
+from ..core.agent.types import Operation, OperationResult, OperationType
 
 # ---------------------------------------------------------------------------
 # Web request constants and helpers
@@ -238,6 +237,7 @@ class AgentLoopMixin:
         until complete.
         """
         current_response = initial_response
+        self._turn_final_response = initial_response
 
         while True:
             self._show_assistant_message(
@@ -307,6 +307,8 @@ class AgentLoopMixin:
                 )
                 break
 
+            self._turn_final_response = next_response
+
             done_indicators = [
                 "task is complete",
                 "analysis complete",
@@ -447,6 +449,44 @@ class AgentLoopMixin:
 
         return best_match
 
+    async def _execute_marker_command(
+        self,
+        command: str,
+        args: list[str],
+        description: str,
+    ) -> OperationResult:
+        """Execute a marker command through the shared permission gate.
+
+        Args:
+            command: Executable name.
+            args: Command arguments without shell interpolation.
+            description: Human-readable operation description.
+
+        Returns:
+            The gated command result, or a failure if no agent engine exists.
+        """
+        agent_engine = getattr(self.engine, "agent_engine", None)
+        if agent_engine is None:
+            return OperationResult(
+                success=False,
+                error="Agent engine not available - command execution disabled",
+            )
+        operation = Operation(
+            type=OperationType.COMMAND_EXECUTE,
+            description=description,
+            data={"command": command, "args": args},
+            requires_approval=False,
+        )
+        result = await agent_engine.execute_with_approval(operation)
+        return cast(OperationResult, result)
+
+    @staticmethod
+    def _marker_command_output(result: OperationResult) -> str:
+        """Extract displayable stdout from an operation result."""
+        if isinstance(result.data, dict):
+            return str(result.data.get("stdout", ""))
+        return str(result.data or "")
+
     async def _parse_and_execute_operations(self, response_content: str) -> str:
         """Parse model response for operation markers and execute them."""
         updated_response = response_content
@@ -608,23 +648,28 @@ class AgentLoopMixin:
                 pattern = match.group(1).strip()
 
                 try:
-                    result = subprocess.run(
-                        f"find . -name '{pattern}' -type f 2>/dev/null | head -20",
-                        shell=True,
-                        capture_output=True,
-                        text=True,
-                        timeout=10,
+                    result = await self._execute_marker_command(
+                        "find",
+                        [".", "-name", pattern, "-type", "f"],
+                        f"Find files matching: {pattern}",
                     )
-                    files = result.stdout.strip()
-                    if files:
+                    if not result.success:
                         updated_response = updated_response.replace(
                             match.group(0),
-                            f"🔍 Found files matching '{pattern}':\n{files}",
+                            f"❌ Find failed: {result.error}",
                         )
                     else:
+                        files = "\n".join(
+                            self._marker_command_output(result).splitlines()[:20]
+                        ).strip()
+                        if files:
+                            replacement = (
+                                f"🔍 Found files matching '{pattern}':\n{files}"
+                            )
+                        else:
+                            replacement = f"🔍 No files found matching '{pattern}'"
                         updated_response = updated_response.replace(
-                            match.group(0),
-                            f"🔍 No files found matching '{pattern}'",
+                            match.group(0), replacement
                         )
                 except Exception as e:
                     updated_response = updated_response.replace(
@@ -638,23 +683,26 @@ class AgentLoopMixin:
                 search_text = match.group(1).strip()
 
                 try:
-                    result = subprocess.run(
-                        f"grep -r -n '{search_text}' . 2>/dev/null | head -20",
-                        shell=True,
-                        capture_output=True,
-                        text=True,
-                        timeout=10,
+                    result = await self._execute_marker_command(
+                        "grep",
+                        ["-r", "-n", search_text, "."],
+                        f"Search files for: {search_text}",
                     )
-                    matches = result.stdout.strip()
-                    if matches:
+                    if not result.success:
                         updated_response = updated_response.replace(
                             match.group(0),
-                            f"🔍 Found '{search_text}' in:\n{matches}",
+                            f"❌ Search failed: {result.error}",
                         )
                     else:
+                        matches = "\n".join(
+                            self._marker_command_output(result).splitlines()[:20]
+                        ).strip()
+                        if matches:
+                            replacement = f"🔍 Found '{search_text}' in:\n{matches}"
+                        else:
+                            replacement = f"🔍 No matches found for '{search_text}'"
                         updated_response = updated_response.replace(
-                            match.group(0),
-                            f"🔍 No matches found for '{search_text}'",
+                            match.group(0), replacement
                         )
                 except Exception as e:
                     updated_response = updated_response.replace(
@@ -707,22 +755,19 @@ class AgentLoopMixin:
 
                 if cmd_base in safe_commands:
                     try:
-                        result = subprocess.run(
-                            command,
-                            shell=True,
-                            capture_output=True,
-                            text=True,
-                            timeout=10,
-                            executable="/bin/bash",
-                        )
-                        output = (
-                            result.stdout.strip()
-                            if result.returncode == 0
-                            else f"Error: {result.stderr}"
+                        parts = shlex.split(command)
+                        result = await self._execute_marker_command(
+                            parts[0],
+                            parts[1:],
+                            f"Execute safe command: {command[:50]}",
                         )
+                        if result.success:
+                            output = self._marker_command_output(result).strip()
+                            replacement = f"✅ `{command}`\n{output}"
+                        else:
+                            replacement = f"❌ Failed: {result.error}"
                         updated_response = updated_response.replace(
-                            match.group(0),
-                            f"✅ `{command}`\n{output}",
+                            match.group(0), replacement
                         )
                     except Exception as e:
                         updated_response = updated_response.replace(

{omnimancer_cli-0.2.24 → omnimancer_cli-0.2.26}/omnimancer/cli/display.py

@@ -412,6 +412,9 @@ Model available: {'Yes' if model_info else 'No'}"""
         self.display_manager.show_message(message, MessageType.WARNING)
 
     def _show_token_status(self, response: Any) -> None:
+        notifier = getattr(self, "turn_notifier", None)
+        if notifier is not None:
+            notifier.record_assistant(getattr(response, "content", None), response)
         usage = getattr(self, "usage", None)
         if usage is not None:
             usage.add(response)