@trac3er/oh-my-god 2.0.0 → 2.0.2

package/runtime/providers/kimi_provider.py

@@ -0,0 +1,151 @@
+"""Kimi Code CLI provider -- implements CLIProvider for the ``kimi`` binary."""
+
+from __future__ import annotations
+
+import json
+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.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+
+
+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,
+            )
+            return {
+                "model": "kimi-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }
+        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,
+            )
+            return {
+                "model": "kimi-cli",
+                "output": result.stdout,
+                "exit_code": result.returncode,
+            }
+        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)
+            output = mgr.send_command(session, f"kimi --print -p {shlex.quote(prompt)}", timeout=timeout)
+            mgr.kill_session(session)
+            return {"model": "kimi-cli", "output": output, "exit_code": 0}
+        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.
+        """
+        config_path = self.get_config_path()
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+
+        # Load existing config or start fresh
+        existing: dict[str, Any] = {}  # pyright: ignore[reportExplicitAny]
+        if os.path.exists(config_path):
+            with open(config_path) as fh:
+                try:
+                    existing = json.load(fh)
+                except (json.JSONDecodeError, ValueError):
+                    existing = {}
+
+        # Ensure mcpServers dict exists
+        if "mcpServers" not in existing:
+            existing["mcpServers"] = {}
+
+        existing["mcpServers"][server_name] = {"type": "http", "url": server_url}
+
+        with open(config_path, "w") as fh:
+            json.dump(existing, fh, indent=2)
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(KimiCodeProvider())

package/runtime/providers/opencode_provider.py

@@ -0,0 +1,144 @@
+"""OpenCode CLI provider -- implements CLIProvider for the ``opencode`` binary."""
+
+from __future__ import annotations
+
+import json
+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.tmux_session_manager import TmuxSessionManager
+
+_logger = logging.getLogger(__name__)
+
+
+class OpenCodeProvider(CLIProvider):
+    """CLIProvider implementation for the OpenCode CLI (``opencode``)."""
+
+    # -- identity -----------------------------------------------------------
+
+    def get_name(self) -> str:  # noqa: D401
+        """Return the canonical provider name."""
+        return "opencode"
+
+    # -- detection ----------------------------------------------------------
+
+    def detect(self) -> bool:
+        """Return ``True`` when the ``opencode`` binary is available on PATH."""
+        return shutil.which("opencode") is not None
+
+    # -- authentication -----------------------------------------------------
+
+    def check_auth(self) -> tuple[bool | None, str]:
+        """Check OpenCode authentication status via ``opencode auth list``."""
+        try:
+            result = self.run_tool(["opencode", "auth", "list"], 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"opencode auth check failed: {exc}"
+
+    # -- invocation ---------------------------------------------------------
+
+    def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``opencode run`` via subprocess."""
+        try:
+            result = self.run_tool(
+                ["opencode", "run", prompt],
+                timeout=timeout,
+            )
+            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_json(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+        """Invoke ``opencode run --format json`` for raw JSON event stream output."""
+        try:
+            result = self.run_tool(
+                ["opencode", "run", "--format", "json", prompt],
+                timeout=timeout,
+            )
+            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]
+        """Invoke ``opencode run`` via a persistent tmux session.
+
+        Falls back to :meth:`invoke` on failure.
+        """
+        try:
+            mgr = TmuxSessionManager()
+            session_name = mgr.make_session_name("opencode", unique_id=str(uuid.uuid4())[:8])
+            session = mgr.get_or_create_session(session_name)
+            output = mgr.send_command(session, f"opencode run {shlex.quote(prompt)}", timeout=timeout)
+            mgr.kill_session(session)
+            return {"model": "opencode-cli", "output": output, "exit_code": 0}
+        except Exception as exc:
+            _logger.warning("tmux opencode 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 opencode."""
+        return ["opencode", "run", prompt]
+
+    # -- configuration ------------------------------------------------------
+
+    def get_config_path(self) -> str:
+        """Return the OpenCode configuration file path."""
+        return os.path.expanduser("~/.config/opencode/opencode.json")
+
+    def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
+        """Write an MCP server entry to ``~/.config/opencode/opencode.json``.
+
+        Uses JSON format with ``mcp`` key, ``type: "remote"``, and ``url`` field,
+        merging into any existing configuration.
+        """
+        config_path = self.get_config_path()
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+
+        # Load existing config or start fresh
+        existing: dict[str, Any] = {}  # pyright: ignore[reportExplicitAny]
+        if os.path.exists(config_path):
+            with open(config_path) as fh:
+                try:
+                    existing = json.load(fh)
+                except (json.JSONDecodeError, ValueError):
+                    existing = {}
+
+        # Ensure mcp dict exists
+        if "mcp" not in existing:
+            existing["mcp"] = {}
+
+        existing["mcp"][server_name] = {"type": "remote", "url": server_url}
+
+        with open(config_path, "w") as fh:
+            json.dump(existing, fh, indent=2)
+
+
+# -- auto-register on import -----------------------------------------------
+register_provider(OpenCodeProvider())

package/runtime/subagent_dispatcher.py

@@ -0,0 +1,362 @@
+"""Parallel Execution Backend — concurrent subagent job management.
+
+Manages concurrent subagent jobs with isolation, artifact streaming,
+and a 100-job limit using stdlib ThreadPoolExecutor.
+
+Feature flag: OMG_PARALLEL_SUBAGENTS_ENABLED (default: False)
+"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+import uuid
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from typing import Any
+
+# --- Path resolution (never relies on CWD) ---
+_DISPATCHER_DIR = os.path.dirname(os.path.abspath(__file__))
+_OMG_ROOT = os.path.dirname(_DISPATCHER_DIR)
+
+# --- Constants ---
+MAX_JOBS = 100
+
+# --- Module-level singletons ---
+_executor: ThreadPoolExecutor | None = None
+_jobs: dict[str, dict[str, Any]] = {}
+_lock = threading.Lock()
+
+
+def _get_feature_flag() -> Any:
+    """Lazy-import get_feature_flag from hooks/_common.py."""
+    hooks_dir = os.path.join(_OMG_ROOT, "hooks")
+    if hooks_dir not in sys.path:
+        sys.path.insert(0, hooks_dir)
+    try:
+        from _common import get_feature_flag  # pyright: ignore[reportMissingImports]
+        return get_feature_flag
+    except ImportError:
+        return None
+
+
+def _get_atomic_json_write() -> Any:
+    """Lazy-import atomic_json_write from hooks/_common.py."""
+    hooks_dir = os.path.join(_OMG_ROOT, "hooks")
+    if hooks_dir not in sys.path:
+        sys.path.insert(0, hooks_dir)
+    try:
+        from _common import atomic_json_write  # pyright: ignore[reportMissingImports]
+        return atomic_json_write
+    except ImportError:
+        return None
+
+
+def _is_enabled() -> bool:
+    """Check if parallel subagents feature is enabled.
+
+    Resolution: env var OMG_PARALLEL_SUBAGENTS_ENABLED → settings.json → default False.
+    """
+    # Fast path: check env var directly
+    env_val = os.environ.get("OMG_PARALLEL_SUBAGENTS_ENABLED", "").lower()
+    if env_val in ("0", "false", "no"):
+        return False
+    if env_val in ("1", "true", "yes"):
+        return True
+
+    # Slow path: check via get_feature_flag
+    get_flag = _get_feature_flag()
+    if get_flag is not None:
+        return get_flag("PARALLEL_SUBAGENTS", default=False)
+    return False
+
+
+def _get_project_dir() -> str:
+    """Get project directory from env or cwd."""
+    return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
+
+
+def _jobs_dir() -> str:
+    """Return the jobs state directory path."""
+    return os.path.join(_get_project_dir(), ".omg", "state", "jobs")
+
+
+def _job_path(job_id: str) -> str:
+    """Return the file path for a specific job."""
+    return os.path.join(_jobs_dir(), f"{job_id}.json")
+
+
+def _persist_job(job_id: str, record: dict[str, Any]) -> None:
+    """Persist job record to disk via atomic_json_write."""
+    writer = _get_atomic_json_write()
+    if writer is not None:
+        writer(_job_path(job_id), record)
+
+
+def _load_job_from_disk(job_id: str) -> dict[str, Any] | None:
+    """Load a job record from disk if it exists."""
+    path = _job_path(job_id)
+    if not os.path.exists(path):
+        return None
+    try:
+        import json
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, ValueError):
+        return None
+
+
+def get_executor() -> ThreadPoolExecutor:
+    """Lazy-init and return the module-level ThreadPoolExecutor singleton."""
+    global _executor
+    if _executor is None:
+        _executor = ThreadPoolExecutor(max_workers=MAX_JOBS)
+    return _executor
+
+
+def _running_count() -> int:
+    """Count jobs with status 'running'."""
+    return len([j for j in _jobs.values() if j["status"] == "running"])
+
+
+def submit_job(
+    agent_name: str,
+    task_text: str,
+    isolation: str = "none",
+) -> str:
+    """Submit a subagent job for concurrent execution.
+
+    Args:
+        agent_name: Name of the agent to dispatch.
+        task_text: Task description / prompt for the agent.
+        isolation: Isolation backend — "none" (default) or "worktree".
+
+    Returns:
+        job_id (8-char hex string).
+
+    Raises:
+        RuntimeError: If feature is disabled or job limit reached.
+    """
+    if not _is_enabled():
+        raise RuntimeError("feature disabled")
+
+    with _lock:
+        if _running_count() >= MAX_JOBS:
+            raise RuntimeError("job limit reached")
+
+        job_id = uuid.uuid4().hex[:8]
+        now = datetime.now(timezone.utc).isoformat()
+        record: dict[str, Any] = {
+            "job_id": job_id,
+            "agent_name": agent_name,
+            "task_text": task_text,
+            "isolation": isolation,
+            "status": "queued",
+            "created_at": now,
+            "artifacts": [],
+            "error": None,
+        }
+        _jobs[job_id] = record
+
+    # Persist initial state
+    _persist_job(job_id, record)
+
+    # Submit to thread pool — returns immediately
+    executor = get_executor()
+    executor.submit(_run_job, job_id)
+
+    return job_id
+
+
+def _check_git_available() -> bool:
+    """Return True if git is available on PATH."""
+    import shutil
+    return shutil.which("git") is not None
+
+
+def _setup_worktree(job_id: str) -> str | None:
+    """Attempt to create a git worktree for job isolation.
+
+    Returns worktree path on success, None on failure.
+    """
+    if not _check_git_available():
+        return None
+
+    import subprocess
+
+    project_dir = _get_project_dir()
+    worktree_dir = os.path.join(project_dir, ".omg", "worktrees", job_id)
+
+    try:
+        os.makedirs(os.path.dirname(worktree_dir), exist_ok=True)
+        subprocess.run(
+            ["git", "worktree", "add", "--detach", worktree_dir],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=30,
+            cwd=project_dir,
+        )
+        return worktree_dir
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def _cleanup_worktree(worktree_dir: str) -> None:
+    """Remove a git worktree (best-effort)."""
+    import subprocess
+    import shutil
+
+    project_dir = _get_project_dir()
+    try:
+        subprocess.run(
+            ["git", "worktree", "remove", "--force", worktree_dir],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=15,
+            cwd=project_dir,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    # Fallback: remove directory if still exists
+    try:
+        if os.path.isdir(worktree_dir):
+            shutil.rmtree(worktree_dir, ignore_errors=True)
+    except OSError:
+        pass
+
+
+def _run_job(job_id: str) -> None:
+    """Execute a subagent job in the thread pool.
+
+    Updates job status and persists artifacts as they are produced.
+    NOTE: Does NOT actually spawn Claude — simulates execution for now.
+    """
+    with _lock:
+        record = _jobs.get(job_id)
+        if record is None:
+            return
+        if record["status"] == "cancelled":
+            return
+        record["status"] = "running"
+        record["started_at"] = datetime.now(timezone.utc).isoformat()
+
+    _persist_job(job_id, record)
+
+    worktree_dir: str | None = None
+    try:
+        # Setup isolation if requested
+        if record.get("isolation") == "worktree":
+            worktree_dir = _setup_worktree(job_id)
+            if worktree_dir:
+                with _lock:
+                    record["worktree"] = worktree_dir
+                _persist_job(job_id, record)
+
+        # --- Simulated execution ---
+        # Real implementation would dispatch to an agent here.
+        # For now, simulate work + produce an artifact.
+        time.sleep(0.05)  # Simulate brief work
+
+        artifact = {
+            "type": "result",
+            "agent": record["agent_name"],
+            "content": f"Simulated output for: {record['task_text'][:100]}",
+            "produced_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+        with _lock:
+            # Check for cancellation mid-execution
+            if record["status"] == "cancelled":
+                return
+            record["artifacts"].append(artifact)
+            record["status"] = "completed"
+            record["completed_at"] = datetime.now(timezone.utc).isoformat()
+
+        _persist_job(job_id, record)
+
+    except Exception as exc:
+        with _lock:
+            record["status"] = "failed"
+            record["error"] = str(exc)
+            record["completed_at"] = datetime.now(timezone.utc).isoformat()
+        _persist_job(job_id, record)
+
+    finally:
+        # Cleanup worktree if created
+        if worktree_dir:
+            _cleanup_worktree(worktree_dir)
+
+
+def get_job_status(job_id: str) -> dict[str, Any]:
+    """Get the current status and artifacts for a job.
+
+    Args:
+        job_id: Job identifier returned by submit_job().
+
+    Returns:
+        Job record dict, or {"error": "not found"} if job doesn't exist.
+    """
+    with _lock:
+        record = _jobs.get(job_id)
+        if record is not None:
+            return dict(record)
+
+    # Not in memory — try loading from disk
+    disk_record = _load_job_from_disk(job_id)
+    if disk_record is not None:
+        return disk_record
+
+    return {"error": "not found"}
+
+
+def cancel_job(job_id: str) -> bool:
+    """Cancel a queued or running job.
+
+    Args:
+        job_id: Job identifier to cancel.
+
+    Returns:
+        True if the job was cancelled, False if not found or already terminal.
+    """
+    with _lock:
+        record = _jobs.get(job_id)
+        if record is None:
+            return False
+        if record["status"] in ("completed", "failed", "cancelled"):
+            return False
+        record["status"] = "cancelled"
+        record["completed_at"] = datetime.now(timezone.utc).isoformat()
+
+    _persist_job(job_id, record)
+    return True
+
+
+def list_jobs(status_filter: str | None = None) -> list[dict[str, Any]]:
+    """List all jobs, optionally filtered by status.
+
+    Args:
+        status_filter: If provided, only return jobs matching this status.
+
+    Returns:
+        List of job record dicts.
+    """
+    with _lock:
+        if status_filter is None:
+            return [dict(j) for j in _jobs.values()]
+        return [dict(j) for j in _jobs.values() if j["status"] == status_filter]
+
+
+def shutdown(wait: bool = True) -> None:
+    """Shut down the executor gracefully.
+
+    Args:
+        wait: If True, wait for running jobs to complete before returning.
+    """
+    global _executor
+    if _executor is not None:
+        _executor.shutdown(wait=wait)
+        _executor = None