@trac3er/oh-my-god 2.2.3 → 2.3.0

package/build/lib/runtime/providers/gemini_provider.py

@@ -1,141 +0,0 @@
-"""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.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(
-        "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=30)
-            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"env CLAUDE_PROJECT_DIR={shlex.quote(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/build/lib/runtime/providers/kimi_provider.py

@@ -1,166 +0,0 @@
-"""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.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"env CLAUDE_PROJECT_DIR={shlex.quote(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/build/lib/runtime/providers/opencode_provider.py

@@ -1,99 +0,0 @@
-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())