monoco-toolkit 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

monoco/core/agent/adapters.py

@@ -1,133 +0,0 @@
-"""
-CLI Adapters for Agent Frameworks.
-"""
-
-import shutil
-from typing import List
-from pathlib import Path
-from .protocol import AgentClient
-
-
-class BaseCLIClient:
-    def __init__(self, executable: str):
-        self._executable = executable
-
-    @property
-    def name(self) -> str:
-        return self._executable
-
-    async def available(self) -> bool:
-        return shutil.which(self._executable) is not None
-
-    def _build_prompt(self, prompt: str, context_files: List[Path]) -> str:
-        """Concatenate prompt and context files."""
-        # Inject Language Rule
-        try:
-            from monoco.core.config import get_config
-
-            settings = get_config()
-            lang = settings.i18n.source_lang
-            if lang:
-                prompt = f"{prompt}\n\n[SYSTEM: LANGUAGE CONSTRAINT]\nThe project source language is '{lang}'. You MUST use '{lang}' for all thinking and reporting unless explicitly instructed otherwise."
-        except Exception:
-            pass
-
-        full_prompt = [prompt]
-        if context_files:
-            full_prompt.append("\n\n--- CONTEXT FILES ---")
-            for file_path in context_files:
-                try:
-                    full_prompt.append(f"\nFile: {file_path}")
-                    full_prompt.append("```")
-                    # Read file content safely
-                    full_prompt.append(
-                        file_path.read_text(encoding="utf-8", errors="replace")
-                    )
-                    full_prompt.append("```")
-                except Exception as e:
-                    full_prompt.append(f"Error reading {file_path}: {e}")
-            full_prompt.append("--- END CONTEXT ---\n")
-        return "\n".join(full_prompt)
-
-    async def _run_command(self, args: List[str]) -> str:
-        """Run the CLI command and return stdout."""
-        # Using synchronous subprocess in async function for now
-        # Ideally this should use asyncio.create_subprocess_exec
-        import asyncio
-
-        proc = await asyncio.create_subprocess_exec(
-            *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
-        )
-
-        stdout, stderr = await proc.communicate()
-
-        if proc.returncode != 0:
-            error_msg = stderr.decode().strip()
-            raise RuntimeError(
-                f"Agent CLI failed (code {proc.returncode}): {error_msg}"
-            )
-
-        return stdout.decode().strip()
-
-
-class GeminiClient(BaseCLIClient, AgentClient):
-    """Adapter for Google Gemini CLI."""
-
-    def __init__(self):
-        super().__init__("gemini")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: gemini "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-class ClaudeClient(BaseCLIClient, AgentClient):
-    """Adapter for Anthropic Claude CLI."""
-
-    def __init__(self):
-        super().__init__("claude")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: claude -p "prompt"
-        return await self._run_command([self._executable, "-p", full_prompt])
-
-
-class QwenClient(BaseCLIClient, AgentClient):
-    """Adapter for Alibaba Qwen CLI."""
-
-    def __init__(self):
-        super().__init__("qwen")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: qwen "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-class KimiClient(BaseCLIClient, AgentClient):
-    """Adapter for Moonshot Kimi CLI."""
-
-    def __init__(self):
-        super().__init__("kimi")
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        full_prompt = self._build_prompt(prompt, context_files)
-        # Usage: kimi "prompt"
-        return await self._run_command([self._executable, full_prompt])
-
-
-_ADAPTERS = {
-    "gemini": GeminiClient,
-    "claude": ClaudeClient,
-    "qwen": QwenClient,
-    "kimi": KimiClient,
-}
-
-
-def get_agent_client(name: str) -> AgentClient:
-    """Factory to get agent client by name."""
-    if name not in _ADAPTERS:
-        raise ValueError(f"Unknown agent provider: {name}")
-    return _ADAPTERS[name]()

monoco/core/agent/protocol.py

@@ -1,32 +0,0 @@
-"""
-Protocol definition for Agent Clients.
-"""
-
-from typing import Protocol, List
-from pathlib import Path
-
-
-class AgentClient(Protocol):
-    """Protocol for interacting with CLI-based agents."""
-
-    @property
-    def name(self) -> str:
-        """Name of the agent provider (e.g. 'gemini', 'claude')."""
-        ...
-
-    async def available(self) -> bool:
-        """Check if the agent is available in the current environment."""
-        ...
-
-    async def execute(self, prompt: str, context_files: List[Path] = []) -> str:
-        """
-        Execute a prompt against the agent.
-
-        Args:
-            prompt: The main instructions.
-            context_files: List of files to provide as context.
-
-        Returns:
-            The raw string response from the agent.
-        """
-        ...

monoco/core/agent/state.py

@@ -1,106 +0,0 @@
-"""
-Agent State Management.
-
-Handles persistence and retrieval of agent availability state.
-"""
-
-import yaml
-import logging
-from pathlib import Path
-from datetime import datetime, timezone
-from typing import Dict, Optional
-from pydantic import BaseModel
-
-logger = logging.getLogger("monoco.core.agent.state")
-
-
-class AgentProviderState(BaseModel):
-    available: bool
-    path: Optional[str] = None
-    error: Optional[str] = None
-    latency_ms: Optional[int] = None
-
-
-class AgentState(BaseModel):
-    last_checked: datetime
-    providers: Dict[str, AgentProviderState]
-
-    @property
-    def is_stale(self) -> bool:
-        """Check if the state is older than 7 days."""
-        delta = datetime.now(timezone.utc) - self.last_checked
-        return delta.days > 7
-
-
-class AgentStateManager:
-    def __init__(self, state_path: Path = Path.home() / ".monoco" / "agent_state.yaml"):
-        self.state_path = state_path
-        self._state: Optional[AgentState] = None
-
-    def load(self) -> Optional[AgentState]:
-        """Load state from file, returning None if missing or invalid."""
-        if not self.state_path.exists():
-            return None
-
-        try:
-            with open(self.state_path, "r") as f:
-                data = yaml.safe_load(f)
-                if not data:
-                    return None
-                # Handle ISO string to datetime conversion if needed provided by Pydantic mostly
-                return AgentState(**data)
-        except Exception as e:
-            logger.warning(f"Failed to load agent state: {e}")
-            return None
-
-    def get_or_refresh(self, force: bool = False) -> AgentState:
-        """Get current state, refreshing if missing, stale, or forced."""
-        if not force:
-            self._state = self.load()
-            if self._state and not self._state.is_stale:
-                return self._state
-
-        return self.refresh()
-
-    def refresh(self) -> AgentState:
-        """Run diagnostics on all integrations and update state."""
-        logger.info("Refreshing agent state...")
-
-        from monoco.core.integrations import get_all_integrations
-        from monoco.core.config import get_config
-
-        # Load config to get possible overrides
-        # Determine root (hacky for now, should be passed)
-        root = Path.cwd()
-        config = get_config(str(root))
-
-        integrations = get_all_integrations(
-            config_overrides=config.agent.integrations, enabled_only=True
-        )
-
-        providers = {}
-        for key, integration in integrations.items():
-            if not integration.bin_name:
-                continue  # Skip integrations that don't have a binary component
-
-            health = integration.check_health()
-            providers[key] = AgentProviderState(
-                available=health.available,
-                path=health.path,
-                error=health.error,
-                latency_ms=health.latency_ms,
-            )
-
-        state = AgentState(last_checked=datetime.now(timezone.utc), providers=providers)
-
-        # Save state
-        self.state_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.state_path, "w") as f:
-            yaml.dump(state.model_dump(mode="json"), f)
-
-        self._state = state
-        return state
-
-    def _find_script(self) -> Optional[Path]:
-        """[Deprecated] No longer used."""
-        return None