@trac3r/oh-my-god 2.2.11

package/runtime/providers/codex_provider.py

@@ -0,0 +1,129 @@
+"""Codex CLI provider — implements CLIProvider for the ``codex`` binary."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import uuid
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.host_parity import normalize_output
+from runtime.mcp_config_writers import write_codex_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
+from runtime.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+_AUTH_CHECK_TIMEOUT_SECONDS = 5
+
+
+def _attach_normalized_output(payload: dict[str, Any], *, prompt: str, project_dir: str) -> dict[str, Any]:
+    normalized = normalize_output(
+        "codex",
+        payload,
+        context={"prompt": prompt, "project_dir": project_dir},
+    )
+    merged = dict(payload)
+    merged["normalized_output"] = normalized
+    return merged
+
+
+class CodexProvider(CLIProvider):
+    """CLIProvider implementation for the Codex CLI (``codex``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "codex"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``codex`` binary is available on PATH."""
+        return shutil.which("codex") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check Codex authentication status via ``codex auth status``."""
+        try:
+            result = self.run_tool(["codex", "auth", "status"], timeout=_AUTH_CHECK_TIMEOUT_SECONDS)
+            if result.returncode == 0:
+                return True, result.stdout.strip()
+            return False, result.stderr.strip() or result.stdout.strip()
+        except Exception as exc:
+            return None, f"codex auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``codex exec --json`` via subprocess."""
+        try:
+            result = self.run_tool(
+                ["codex", "exec", "--json", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
+            return _attach_normalized_output({
+                "model": "codex-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }, prompt=prompt, project_dir=project_dir)
+        except subprocess.TimeoutExpired:
+            return {"error": "codex-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "codex-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``codex exec --json`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("codex", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"{build_release_env_prefix(project_dir)}"
+                    f"codex exec --json {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
+            mgr.kill_session(session)
+            return _attach_normalized_output(
+                {"model": "codex-cli", "output": output, "exit_code": 0},
+                prompt=prompt,
+                project_dir=project_dir,
+            )
+        except Exception as exc:
+            _logger.warning("tmux codex invocation failed, falling back to subprocess: %s", exc)
+            return self.invoke(prompt, project_dir, timeout=timeout)
+
+    # -- command helpers ----------------------------------------------------
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return the non-interactive command for codex."""
+        return ["codex", "exec", "--json", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the Codex configuration file path."""
+        return os.path.expanduser("~/.codex/config.toml")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.codex/config.toml``."""
+        write_codex_mcp_config(server_url, server_name, config_path=self.get_config_path())
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(CodexProvider())

package/runtime/providers/gemini_provider.py

@@ -0,0 +1,143 @@
+"""Gemini CLI provider — implements CLIProvider for the ``gemini`` binary."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import uuid
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.host_parity import normalize_output
+from runtime.mcp_config_writers import write_gemini_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
+from runtime.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+_AUTH_CHECK_TIMEOUT_SECONDS = 5
+
+
+def _attach_normalized_output(payload: dict[str, Any], *, prompt: str, project_dir: str) -> dict[str, Any]:
+    normalized = normalize_output(
+        "gemini",
+        payload,
+        context={"prompt": prompt, "project_dir": project_dir, "no_json_mode": True},
+    )
+    merged = dict(payload)
+    merged["normalized_output"] = normalized
+    return merged
+
+HOST_RULES = {
+    "compilation_targets": [".gemini/settings.json"],
+    "mcp": ["omg-control"],
+    "skills": ["omg/control-plane", "omg/mcp-fabric"],
+    "automations": ["contract-validate", "provider-routing"],
+}
+
+
+class GeminiProvider(CLIProvider):
+    """CLIProvider implementation for the Gemini CLI (``gemini``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "gemini"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``gemini`` binary is available on PATH."""
+        return shutil.which("gemini") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check Gemini authentication status via ``gemini auth status``."""
+        try:
+            result = self.run_tool(["gemini", "auth", "status"], timeout=_AUTH_CHECK_TIMEOUT_SECONDS)
+            if result.returncode == 0:
+                return True, result.stdout.strip()
+            return False, result.stderr.strip() or result.stdout.strip()
+        except Exception as exc:
+            return None, f"gemini auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``gemini -p`` via subprocess.
+
+        Gemini CLI has no ``--json`` flag — output is plain text stdout.
+        """
+        try:
+            result = self.run_tool(
+                ["gemini", "-p", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
+            return _attach_normalized_output({
+                "model": "gemini-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }, prompt=prompt, project_dir=project_dir)
+        except subprocess.TimeoutExpired:
+            return {"error": "gemini-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "gemini-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``gemini -p`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("gemini", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"{build_release_env_prefix(project_dir)}"
+                    f"gemini -p {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
+            mgr.kill_session(session)
+            return _attach_normalized_output(
+                {"model": "gemini-cli", "output": output, "exit_code": 0},
+                prompt=prompt,
+                project_dir=project_dir,
+            )
+        except Exception as exc:
+            _logger.warning("tmux gemini invocation failed, falling back to subprocess: %s", exc)
+            return self.invoke(prompt, project_dir, timeout=timeout)
+
+    # -- command helpers ----------------------------------------------------
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return the non-interactive command for gemini."""
+        return ["gemini", "-p", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the Gemini configuration file path."""
+        return os.path.expanduser("~/.gemini/settings.json")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.gemini/settings.json``.
+
+        Uses JSON format with ``mcpServers`` key and ``httpUrl`` field,
+        merging into any existing configuration.
+        """
+        write_gemini_mcp_config(server_url, server_name, config_path=self.get_config_path())
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(GeminiProvider())

package/runtime/providers/kimi_provider.py

@@ -0,0 +1,167 @@
+"""Kimi Code CLI provider -- implements CLIProvider for the ``kimi`` binary."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import uuid
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.host_parity import normalize_output
+from runtime.mcp_config_writers import write_kimi_mcp_config
+from runtime.release_run_coordinator import build_release_env_prefix
+from runtime.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+
+
+def _attach_normalized_output(payload: dict[str, Any], *, prompt: str, project_dir: str) -> dict[str, Any]:
+    normalized = normalize_output(
+        "kimi",
+        payload,
+        context={"prompt": prompt, "project_dir": project_dir},
+    )
+    merged = dict(payload)
+    merged["normalized_output"] = normalized
+    return merged
+
+HOST_RULES = {
+    "compilation_targets": [".kimi/mcp.json"],
+    "mcp": ["omg-control"],
+    "skills": ["omg/control-plane", "omg/mcp-fabric"],
+    "automations": ["contract-validate", "provider-routing"],
+}
+
+
+class KimiCodeProvider(CLIProvider):
+    """CLIProvider implementation for the Kimi Code CLI (``kimi``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "kimi"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``kimi`` binary is available on PATH."""
+        return shutil.which("kimi") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check Kimi authentication by parsing ``~/.kimi/config.toml`` for stored credentials."""
+        try:
+            config_path = os.path.expanduser("~/.kimi/config.toml")
+            if not os.path.exists(config_path):
+                return False, "not authenticated — config file not found"
+
+            with open(config_path) as fh:
+                content = fh.read()
+
+            # Look for a token entry in the TOML file
+            if "token" in content:
+                return True, "authenticated"
+            return False, "not authenticated — no token in config"
+        except Exception as exc:
+            return None, f"kimi auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``kimi --print -p`` via subprocess."""
+        try:
+            result = self.run_tool(
+                ["kimi", "--print", "-p", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
+            return _attach_normalized_output({
+                "model": "kimi-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }, prompt=prompt, project_dir=project_dir)
+        except subprocess.TimeoutExpired:
+            return {"error": "kimi-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "kimi-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_json(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``kimi --print --output-format stream-json -p`` for JSONL event stream output."""
+        try:
+            result = self.run_tool(
+                ["kimi", "--print", "--output-format", "stream-json", "-p", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
+            return _attach_normalized_output({
+                "model": "kimi-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }, prompt=prompt, project_dir=project_dir)
+        except subprocess.TimeoutExpired:
+            return {"error": "kimi-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "kimi-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``kimi --print -p`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("kimi", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"{build_release_env_prefix(project_dir)}"
+                    f"kimi --print -p {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
+            mgr.kill_session(session)
+            return _attach_normalized_output(
+                {"model": "kimi-cli", "output": output, "exit_code": 0},
+                prompt=prompt,
+                project_dir=project_dir,
+            )
+        except Exception as exc:
+            _logger.warning("tmux kimi invocation failed, falling back to subprocess: %s", exc)
+            return self.invoke(prompt, project_dir, timeout=timeout)
+
+    # -- command helpers ----------------------------------------------------
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:
+        """Return the non-interactive command for kimi."""
+        return ["kimi", "--print", "-p", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the Kimi MCP configuration file path."""
+        return os.path.expanduser("~/.kimi/mcp.json")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.kimi/mcp.json``.
+
+        Uses standard ``mcpServers`` JSON format with ``type: "http"`` and ``url`` field,
+        merging into any existing configuration.
+        """
+        write_kimi_mcp_config(server_url, server_name, config_path=self.get_config_path())
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(KimiCodeProvider())

package/runtime/providers/opencode_provider.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import cast
+from typing import Any
+
+from runtime.cli_provider import CLIProvider, register_provider
+from runtime.mcp_config_writers import _atomic_write_text  # pyright: ignore[reportPrivateUsage]
+
+HOST_RULES = {
+    "compilation_targets": ["opencode.json"],
+    "mcp": ["omg-control"],
+    "mcp_key": "mcp",
+}
+
+
+class OpenCodeProvider(CLIProvider):
+    def get_name(self) -> str:  # pyright: ignore[reportImplicitOverride]
+        return "opencode"
+
+    def detect(self) -> bool:  # pyright: ignore[reportImplicitOverride]
+        return shutil.which("opencode") is not None
+
+    def check_auth(self) -> tuple[bool | None, str]:  # pyright: ignore[reportImplicitOverride]
+        auth_path = Path(os.path.expanduser("~/.local/share/opencode/auth.json"))
+        if not auth_path.exists():
+            return False, f"auth not found: missing {auth_path}"
+        try:
+            parsed = cast(object, json.loads(auth_path.read_text()))
+        except (json.JSONDecodeError, ValueError) as exc:
+            return False, f"auth not found: invalid json: {exc}"
+        except OSError as exc:
+            return False, f"auth not found: unreadable file: {exc}"
+
+        if not parsed:
+            return False, "auth not found: empty auth content"
+        return True, "auth found"
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny, reportImplicitOverride]
+        try:
+            result = self.run_tool(
+                ["opencode", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
+            return {
+                "model": "opencode-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "opencode-cli timeout", "fallback": "claude"}
+        except FileNotFoundError:
+            return {"error": "opencode-cli not found", "fallback": "claude"}
+        except Exception as exc:
+            return {"error": str(exc), "fallback": "claude"}
+
+    def invoke_tmux(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny, reportImplicitOverride]
+        return self.invoke(prompt, project_dir, timeout=timeout)
+
+    def get_non_interactive_cmd(self, prompt: str) -> list[str]:  # pyright: ignore[reportImplicitOverride]
+        return ["opencode", prompt]
+
+    def get_config_path(self) -> str:  # pyright: ignore[reportImplicitOverride]
+        return os.path.expanduser("~/.config/opencode/opencode.json")
+
+    def get_project_config_path(self, root: str = ".") -> str:
+        return str(Path(root) / "opencode.json")
+
+    def get_plugin_dir(self, root: str = ".") -> str:
+        return str(Path(root) / ".opencode" / "plugins")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:  # pyright: ignore[reportImplicitOverride]
+        config_path = Path(self.get_config_path())
+        config: dict[str, object]
+        if config_path.exists():
+            try:
+                loaded = cast(object, json.loads(config_path.read_text()))
+                config = cast(dict[str, object], loaded) if isinstance(loaded, dict) else {}
+            except (json.JSONDecodeError, ValueError):
+                config = {}
+        else:
+            config = {}
+
+        mcp = config.get("mcp")
+        if not isinstance(mcp, dict):
+            mcp = {}
+            config["mcp"] = mcp
+
+        mcp[server_name] = {"type": "http", "url": server_url}
+        _atomic_write_text(config_path, json.dumps(config, indent=2) + "\n")
+
+
+register_provider(OpenCodeProvider())