vibe-remote 2.1.6__py3-none-any.whl

modules/agents/service.py

@@ -0,0 +1,41 @@
+import logging
+from typing import Dict, Optional
+
+from .base import AgentRequest, BaseAgent
+
+logger = logging.getLogger(__name__)
+
+
+class AgentService:
+    """Registry and dispatcher for agent implementations."""
+
+    def __init__(self, controller):
+        self.controller = controller
+        self.agents: Dict[str, BaseAgent] = {}
+        self.default_agent = "claude"
+
+    def register(self, agent: BaseAgent):
+        self.agents[agent.name] = agent
+        logger.info(f"Registered agent backend: {agent.name}")
+
+    def get(self, agent_name: Optional[str]) -> BaseAgent:
+        target = agent_name or self.default_agent
+        if target in self.agents:
+            return self.agents[target]
+        raise KeyError(target)
+
+    async def handle_message(self, agent_name: str, request: AgentRequest):
+        agent = self.get(agent_name)
+        await agent.handle_message(request)
+
+    async def clear_sessions(self, settings_key: str) -> Dict[str, int]:
+        cleared: Dict[str, int] = {}
+        for name, agent in self.agents.items():
+            count = await agent.clear_sessions(settings_key)
+            if count:
+                cleared[name] = count
+        return cleared
+
+    async def handle_stop(self, agent_name: str, request: AgentRequest) -> bool:
+        agent = self.get(agent_name)
+        return await agent.handle_stop(request)

modules/agents/subagent_router.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, Optional
+
+import yaml
+
+
+_PREFIX_PATTERN = re.compile(r"^([^\s:：]+)\s*[:：]\s*(.*)$", re.DOTALL)
+
+
+def _yaml_safe_load(text: str) -> dict:
+    data = yaml.safe_load(text)
+    return data if isinstance(data, dict) else {}
+
+
+@dataclass(frozen=True)
+class SubagentDefinition:
+    name: str
+    model: Optional[str] = None
+    reasoning_effort: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class PrefixMatch:
+    name: str
+    message: str
+
+
+def parse_subagent_prefix(message: str) -> Optional[PrefixMatch]:
+    if not message:
+        return None
+
+    trimmed = message.lstrip()
+    match = _PREFIX_PATTERN.match(trimmed)
+    if not match:
+        return None
+
+    name = match.group(1).strip()
+    body = match.group(2)
+    if not name:
+        return None
+
+    if not body or not body.strip():
+        return None
+
+    return PrefixMatch(name=name, message=body.strip())
+
+
+def normalize_subagent_name(name: str) -> str:
+    return (name or "").strip().lower()
+
+
+def list_claude_subagents(search_root: Optional[Path] = None) -> Dict[str, SubagentDefinition]:
+    root = search_root or (Path.home() / ".claude")
+    if not root.exists():
+        return {}
+
+    agent_files: list[Path] = []
+    candidate_dirs = _find_claude_agent_dirs(root)
+    for directory in candidate_dirs:
+        agent_files.extend(directory.glob("*.md"))
+
+    definitions: Dict[str, SubagentDefinition] = {}
+    for agent_file in agent_files:
+        definition = _parse_claude_agent_definition(agent_file)
+        if not definition:
+            continue
+        key = normalize_subagent_name(definition.name)
+        if key:
+            definitions[key] = definition
+    return definitions
+
+
+def load_claude_subagent(name: str, search_root: Optional[Path] = None) -> Optional[SubagentDefinition]:
+    normalized = normalize_subagent_name(name)
+    if not normalized:
+        return None
+    return list_claude_subagents(search_root).get(normalized)
+
+
+def _find_claude_agent_dirs(root: Path) -> Iterable[Path]:
+    agent_dirs = []
+    if (root / "agents").exists():
+        agent_dirs.append(root / "agents")
+
+    for path in root.rglob("agents"):
+        if path.is_dir():
+            agent_dirs.append(path)
+
+    seen = set()
+    unique = []
+    for path in agent_dirs:
+        resolved = os.path.normpath(str(path))
+        if resolved in seen:
+            continue
+        seen.add(resolved)
+        unique.append(path)
+    return unique
+
+
+def _parse_claude_agent_definition(path: Path) -> Optional[SubagentDefinition]:
+    try:
+        text = path.read_text(encoding="utf-8")
+    except Exception:
+        return None
+
+    if not text.startswith("---"):
+        return None
+
+    parts = text.split("---", 2)
+    if len(parts) < 3:
+        return None
+
+    header = parts[1]
+    try:
+        data = _yaml_safe_load(header)
+    except Exception:
+        return None
+
+    name = data.get("name")
+    if not isinstance(name, str) or not name.strip():
+        return None
+
+    model = data.get("model")
+    if not isinstance(model, str) or not model.strip():
+        model = None
+
+    reasoning_effort = data.get("reasoning_effort") or data.get("reasoningEffort")
+    if not isinstance(reasoning_effort, str) or not reasoning_effort.strip():
+        reasoning_effort = None
+
+    return SubagentDefinition(name=name.strip(), model=model, reasoning_effort=reasoning_effort)

modules/claude_client.py

@@ -0,0 +1,154 @@
+import logging
+import os
+from typing import Optional, Callable
+from claude_code_sdk import (
+    ClaudeCodeOptions,
+    SystemMessage,
+    AssistantMessage,
+    UserMessage,
+    ResultMessage,
+    TextBlock,
+    ToolUseBlock,
+    ToolResultBlock,
+)
+from config.v2_compat import ClaudeCompatConfig
+from modules.im.formatters import BaseMarkdownFormatter, SlackFormatter
+
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeClient:
+    def __init__(
+        self, config: ClaudeCompatConfig, formatter: Optional[BaseMarkdownFormatter] = None
+    ):
+        self.config = config
+        self.formatter = formatter or SlackFormatter()
+        self.options = ClaudeCodeOptions(
+            permission_mode=config.permission_mode,  # type: ignore[arg-type]
+            cwd=config.cwd,
+            system_prompt=config.system_prompt,
+        )  # type: ignore[arg-type]
+
+    def format_message(
+        self, message, get_relative_path: Optional[Callable[[str], str]] = None
+    ) -> str:
+        """Format different types of messages according to specified rules"""
+        try:
+            if isinstance(message, SystemMessage):
+                return self._format_system_message(message)
+            elif isinstance(message, AssistantMessage):
+                return self._format_assistant_message(message, get_relative_path)
+            elif isinstance(message, UserMessage):
+                return self._format_user_message(message, get_relative_path)
+            elif isinstance(message, ResultMessage):
+                return self._format_result_message(message)
+            else:
+                return self.formatter.format_warning(
+                    f"Unknown message type: {type(message)}"
+                )
+        except Exception as e:
+            logger.error(f"Error formatting message: {e}")
+            return self.formatter.format_error(f"Error formatting message: {str(e)}")
+
+    def _process_content_blocks(
+        self, content_blocks, get_relative_path: Optional[Callable[[str], str]] = None
+    ) -> list:
+        """Process content blocks (TextBlock, ToolUseBlock) and return formatted parts"""
+        formatted_parts = []
+
+        for block in content_blocks:
+            if isinstance(block, TextBlock):
+                # Don't escape here - let the formatter handle it during final formatting
+                # This avoids double escaping
+                formatted_parts.append(block.text)
+            elif isinstance(block, ToolUseBlock):
+                tool_info = self._format_tool_use_block(block, get_relative_path)
+                formatted_parts.append(tool_info)
+            elif isinstance(block, ToolResultBlock):
+                result_info = self._format_tool_result_block(block)
+                formatted_parts.append(result_info)
+
+        return formatted_parts
+
+    def _get_relative_path(self, full_path: str) -> str:
+        """Convert absolute path to relative path based on ClaudeCode cwd"""
+        # Get ClaudeCode's current working directory
+        cwd = self.options.cwd or os.getcwd()
+
+        # Normalize paths for consistent comparison
+        cwd = os.path.normpath(cwd)
+        full_path = os.path.normpath(full_path)
+
+        try:
+            # If the path starts with cwd, make it relative
+            if full_path.startswith(cwd + os.sep) or full_path == cwd:
+                relative = os.path.relpath(full_path, cwd)
+                # Use "./" prefix for current directory files
+                if not relative.startswith(".") and relative != ".":
+                    relative = "./" + relative
+                return relative
+            else:
+                # If not under cwd, just return the path as is
+                return full_path
+        except:
+            # Fallback to original path if any error
+            return full_path
+
+    def _format_tool_use_block(
+        self,
+        block: ToolUseBlock,
+        get_relative_path: Optional[Callable[[str], str]] = None,
+    ) -> str:
+        """Format ToolUseBlock using formatter"""
+        # Prefer caller-provided get_relative_path (per-session cwd), fallback to self
+        rel = get_relative_path if get_relative_path else self._get_relative_path
+        return self.formatter.format_tool_use(
+            block.name, block.input, get_relative_path=rel
+        )
+
+    def _format_tool_result_block(self, block: ToolResultBlock) -> str:
+        """Format ToolResultBlock using formatter"""
+        is_error = bool(block.is_error) if block.is_error is not None else False
+        content = block.content if isinstance(block.content, str) else None
+        return self.formatter.format_tool_result(is_error, content)
+
+    def _format_system_message(self, message: SystemMessage) -> str:
+        """Format SystemMessage using formatter"""
+        cwd = message.data.get("cwd", "Unknown")
+        session_id = message.data.get("session_id", None)
+        return self.formatter.format_system_message(cwd, message.subtype, session_id)
+
+    def _format_assistant_message(
+        self,
+        message: AssistantMessage,
+        get_relative_path: Optional[Callable[[str], str]] = None,
+    ) -> str:
+        """Format AssistantMessage using formatter"""
+        content_parts = self._process_content_blocks(message.content, get_relative_path)
+        return self.formatter.format_assistant_message(content_parts)
+
+    def _format_user_message(
+        self,
+        message: UserMessage,
+        get_relative_path: Optional[Callable[[str], str]] = None,
+    ) -> str:
+        """Format UserMessage using formatter"""
+        content_parts = self._process_content_blocks(message.content, get_relative_path)
+        return self.formatter.format_user_message(content_parts)
+
+    def _format_result_message(self, message: ResultMessage) -> str:
+        """Format ResultMessage using formatter"""
+        return self.formatter.format_result_message(
+            message.subtype, message.duration_ms, message.result
+        )
+
+    def _is_skip_message(self, message) -> bool:
+        """Check if the message should be skipped"""
+        if isinstance(message, AssistantMessage):
+            if not message.content:
+                return True
+        elif isinstance(message, UserMessage):
+            if not message.content:
+                return True
+        return False

modules/im/__init__.py

@@ -0,0 +1,63 @@
+"""IM platform abstraction package
+
+Provides unified interface for different instant messaging platforms.
+
+Example usage:
+    from modules.im import BaseIMClient, IMFactory, MessageContext
+    
+    # Create client via factory
+    client = IMFactory.create_client(config)
+    
+    # Use platform-agnostic messaging
+    context = MessageContext(user_id="123", channel_id="456")
+    await client.send_message(context, "Hello!")
+"""
+
+# Core abstractions
+from .base import (
+    BaseIMClient,
+    BaseIMConfig,
+    MessageContext,
+    InlineButton,
+    InlineKeyboard,
+)
+
+# Factory for client creation
+from .factory import IMFactory
+
+# Platform implementations are available but not imported by default
+# to avoid circular import issues. Import them explicitly if needed:
+# from .slack import SlackBot
+
+__all__ = [
+    "BaseIMClient",
+    "BaseIMConfig",
+    "MessageContext",
+    "InlineButton",
+    "InlineKeyboard",
+    "IMFactory",
+]
+
+# Convenience function for quick client creation
+def create_client(config):
+    """Convenience function to create IM client
+    
+    Args:
+        config: Application configuration
+        
+    Returns:
+        Platform-specific IM client instance
+    """
+    return IMFactory.create_client(config)
+
+
+# Platform information
+def get_supported_platforms():
+    """Get list of supported IM platforms
+    
+    Returns:
+        List of supported platform names
+    """
+    return IMFactory.get_supported_platforms()
+
+