emdash-core 0.1.33__py3-none-any.whl → 0.1.60__py3-none-any.whl

emdash_core/agent/toolkits/__init__.py

@@ -2,10 +2,13 @@
 
 Provides specialized toolkits for different agent types.
 Each toolkit contains a curated set of tools appropriate for the agent's purpose.
+
+Custom agents from .emdash/agents/*.md are also supported and use the Explore toolkit
+by default (unless they specify different tools in their frontmatter).
 """
 
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING, Dict, Type, Optional
 
 if TYPE_CHECKING:
     from .base import BaseToolkit
@@ -20,45 +23,141 @@ TOOLKIT_REGISTRY: Dict[str, str] = {
 }
 
 
+def _get_custom_agents(repo_root: Optional[Path] = None) -> dict:
+    """Load custom agents from .emdash/agents/ directory.
+
+    Args:
+        repo_root: Repository root (defaults to cwd)
+
+    Returns:
+        Dict mapping agent name to CustomAgent
+    """
+    from ..agents import load_agents
+    from ...utils.logger import log
+
+    agents_dir = (repo_root or Path.cwd()) / ".emdash" / "agents"
+    log.debug(f"Loading custom agents from: {agents_dir} (exists={agents_dir.exists()})")
+    agents = load_agents(agents_dir)
+    log.debug(f"Loaded custom agents: {list(agents.keys())}")
+    return agents
+
+
 def get_toolkit(subagent_type: str, repo_root: Path) -> "BaseToolkit":
     """Get toolkit for agent type.
 
     Args:
-        subagent_type: Type of agent (e.g., "Explore", "Plan")
+        subagent_type: Type of agent (e.g., "Explore", "Plan", or custom agent name)
         repo_root: Root directory of the repository
 
     Returns:
         Toolkit instance
 
     Raises:
-        ValueError: If agent type is not registered
+        ValueError: If agent type is not registered or found
+    """
+    # Check built-in agents first
+    if subagent_type in TOOLKIT_REGISTRY:
+        import importlib
+        module_path, class_name = TOOLKIT_REGISTRY[subagent_type].rsplit(":", 1)
+        module = importlib.import_module(module_path)
+        toolkit_class = getattr(module, class_name)
+        return toolkit_class(repo_root)
+
+    # Check custom agents
+    custom_agents = _get_custom_agents(repo_root)
+    if subagent_type in custom_agents:
+        # Custom agents use Explore toolkit by default (read-only, safe)
+        # This gives them: glob, grep, read_file, list_files, semantic_search
+        # Plus any MCP servers defined in the agent's frontmatter
+        import importlib
+        from ...utils.logger import log
+
+        custom_agent = custom_agents[subagent_type]
+        module_path, class_name = TOOLKIT_REGISTRY["Explore"].rsplit(":", 1)
+        module = importlib.import_module(module_path)
+        toolkit_class = getattr(module, class_name)
+
+        # Pass MCP servers if defined
+        mcp_servers = custom_agent.mcp_servers if custom_agent.mcp_servers else None
+        if mcp_servers:
+            log.info(f"Custom agent '{subagent_type}' has {len(mcp_servers)} MCP servers")
+
+        return toolkit_class(repo_root, mcp_servers=mcp_servers)
+
+    # Not found
+    available = list_agent_types(repo_root)
+    raise ValueError(
+        f"Unknown agent type: {subagent_type}. Available: {available}"
+    )
+
+
+def list_agent_types(repo_root: Optional[Path] = None) -> list[str]:
+    """List all available agent types (built-in + custom).
+
+    Args:
+        repo_root: Repository root for finding custom agents
+
+    Returns:
+        List of agent type names
     """
-    if subagent_type not in TOOLKIT_REGISTRY:
-        available = list(TOOLKIT_REGISTRY.keys())
-        raise ValueError(
-            f"Unknown agent type: {subagent_type}. Available: {available}"
-        )
+    # Start with built-in agents
+    types = list(TOOLKIT_REGISTRY.keys())
 
-    # Import lazily to avoid circular imports
-    import importlib
+    # Add custom agents
+    custom_agents = _get_custom_agents(repo_root)
+    for name in custom_agents.keys():
+        if name not in types:
+            types.append(name)
 
-    module_path, class_name = TOOLKIT_REGISTRY[subagent_type].rsplit(":", 1)
-    module = importlib.import_module(module_path)
-    toolkit_class = getattr(module, class_name)
-    return toolkit_class(repo_root)
+    return types
 
 
-def list_agent_types() -> list[str]:
-    """List all available agent types.
+def get_agents_with_descriptions(repo_root: Optional[Path] = None) -> list[dict]:
+    """Get all agents with their names and descriptions.
+
+    Args:
+        repo_root: Repository root for finding custom agents
 
     Returns:
-        List of agent type names
+        List of dicts with 'name' and 'description' keys
+    """
+    from ..prompts.subagents import BUILTIN_AGENTS
+
+    agents = []
+
+    # Built-in agents
+    for name, description in BUILTIN_AGENTS.items():
+        agents.append({"name": name, "description": description})
+
+    # Custom agents
+    custom_agents = _get_custom_agents(repo_root)
+    for name, agent in custom_agents.items():
+        agents.append({
+            "name": name,
+            "description": agent.description or "Custom agent"
+        })
+
+    return agents
+
+
+def get_custom_agent(name: str, repo_root: Optional[Path] = None):
+    """Get a specific custom agent by name.
+
+    Args:
+        name: Agent name
+        repo_root: Repository root
+
+    Returns:
+        CustomAgent or None
     """
-    return list(TOOLKIT_REGISTRY.keys())
+    custom_agents = _get_custom_agents(repo_root)
+    return custom_agents.get(name)
 
 
 __all__ = [
     "get_toolkit",
     "list_agent_types",
+    "get_agents_with_descriptions",
+    "get_custom_agent",
     "TOOLKIT_REGISTRY",
 ]

emdash_core/agent/toolkits/base.py

@@ -2,10 +2,14 @@
 
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from ..tools.base import BaseTool, ToolResult
 
+if TYPE_CHECKING:
+    from ..agents import AgentMCPServerConfig
+    from ..mcp.manager import MCPServerManager
+
 
 class BaseToolkit(ABC):
     """Abstract base class for sub-agent toolkits.
@@ -15,20 +19,30 @@ class BaseToolkit(ABC):
     - Registering appropriate tools
     - Providing OpenAI function schemas
     - Executing tools by name
+    - Managing per-agent MCP servers (optional)
     """
 
     # List of tool names this toolkit provides (for documentation)
     TOOLS: list[str] = []
 
-    def __init__(self, repo_root: Path):
+    def __init__(
+        self,
+        repo_root: Path,
+        mcp_servers: Optional[list["AgentMCPServerConfig"]] = None,
+    ):
         """Initialize the toolkit.
 
         Args:
             repo_root: Root directory of the repository
+            mcp_servers: Optional list of MCP server configurations for this agent
         """
         self.repo_root = repo_root.resolve()
         self._tools: dict[str, BaseTool] = {}
+        self._mcp_manager: Optional["MCPServerManager"] = None
+        self._mcp_servers_config = mcp_servers or []
+
         self._register_tools()
+        self._init_mcp_servers()
 
     @abstractmethod
     def _register_tools(self) -> None:
@@ -38,6 +52,77 @@ class BaseToolkit(ABC):
         """
         pass
 
+    def _init_mcp_servers(self) -> None:
+        """Initialize MCP servers for this agent if configured.
+
+        Creates an MCPServerManager with the agent's MCP server configs
+        and registers the tools from those servers. Only enabled servers
+        are started.
+        """
+        if not self._mcp_servers_config:
+            return
+
+        # Filter to only enabled servers
+        enabled_servers = [s for s in self._mcp_servers_config if s.enabled]
+        if not enabled_servers:
+            return
+
+        from ..mcp.config import MCPServerConfig, MCPConfigFile
+        from ..mcp.manager import MCPServerManager
+        from ..mcp.tool_factory import create_tools_from_mcp
+        from ...utils.logger import log
+
+        log.info(f"Initializing {len(enabled_servers)} MCP servers for agent")
+
+        # Create a temporary config file object with our servers
+        config = MCPConfigFile()
+        for server_cfg in enabled_servers:
+            mcp_config = MCPServerConfig(
+                name=server_cfg.name,
+                command=server_cfg.command,
+                args=server_cfg.args,
+                env=server_cfg.env,
+                enabled=True,
+                timeout=server_cfg.timeout,
+            )
+            config.add_server(mcp_config)
+
+        # Create manager with in-memory config (not from file)
+        self._mcp_manager = MCPServerManager(repo_root=self.repo_root)
+        self._mcp_manager._config = config  # Inject our config directly
+
+        # Start all servers and register tools
+        try:
+            started = self._mcp_manager.start_all_enabled()
+            log.info(f"Started MCP servers for agent: {started}")
+
+            # Create tool wrappers and register them
+            mcp_tools = create_tools_from_mcp(self._mcp_manager)
+            for tool in mcp_tools:
+                self.register_tool(tool)
+                log.debug(f"Registered MCP tool: {tool.name}")
+
+        except Exception as e:
+            log.warning(f"Failed to initialize MCP servers for agent: {e}")
+
+    def shutdown(self) -> None:
+        """Shutdown the toolkit and cleanup resources.
+
+        Stops any running MCP servers.
+        """
+        if self._mcp_manager:
+            from ...utils.logger import log
+            log.info("Shutting down agent MCP servers")
+            self._mcp_manager.shutdown_all()
+            self._mcp_manager = None
+
+    def __del__(self):
+        """Cleanup on garbage collection."""
+        try:
+            self.shutdown()
+        except Exception:
+            pass
+
     def register_tool(self, tool: BaseTool) -> None:
         """Register a tool.
 

emdash_core/agent/toolkits/explore.py

@@ -1,12 +1,16 @@
 """Explorer toolkit - read-only tools for fast codebase exploration."""
 
 from pathlib import Path
+from typing import TYPE_CHECKING, Optional
 
 from .base import BaseToolkit
 from ..tools.coding import ReadFileTool, ListFilesTool
 from ..tools.search import SemanticSearchTool, GrepTool, GlobTool
 from ...utils.logger import log
 
+if TYPE_CHECKING:
+    from ..agents import AgentMCPServerConfig
+
 
 class ExploreToolkit(BaseToolkit):
     """Read-only toolkit for fast codebase exploration.
@@ -16,6 +20,7 @@ class ExploreToolkit(BaseToolkit):
     - Listing directory contents
     - Searching with patterns (grep, glob)
     - Semantic code search
+    - MCP server tools (if configured)
 
     All tools are read-only - no file modifications allowed.
     """
@@ -28,6 +33,19 @@ class ExploreToolkit(BaseToolkit):
         "semantic_search",
     ]
 
+    def __init__(
+        self,
+        repo_root: Path,
+        mcp_servers: Optional[list["AgentMCPServerConfig"]] = None,
+    ):
+        """Initialize the explore toolkit.
+
+        Args:
+            repo_root: Root directory of the repository
+            mcp_servers: Optional MCP server configurations for this agent
+        """
+        super().__init__(repo_root, mcp_servers=mcp_servers)
+
     def _register_tools(self) -> None:
         """Register read-only exploration tools."""
         # File reading

emdash_core/agent/toolkits/plan.py

@@ -5,12 +5,16 @@ The main agent (in plan mode) writes the plan to .emdash/<feature>.md.
 """
 
 from pathlib import Path
+from typing import TYPE_CHECKING, Optional
 
 from .base import BaseToolkit
 from ..tools.coding import ReadFileTool, ListFilesTool
 from ..tools.search import SemanticSearchTool, GrepTool, GlobTool
 from ...utils.logger import log
 
+if TYPE_CHECKING:
+    from ..agents import AgentMCPServerConfig
+
 
 class PlanToolkit(BaseToolkit):
     """Read-only toolkit for Plan subagent.
@@ -24,6 +28,7 @@ class PlanToolkit(BaseToolkit):
     - glob: Find files by pattern
     - grep: Search file contents
     - semantic_search: AI-powered code search
+    - MCP server tools (if configured)
     """
 
     TOOLS = [
@@ -34,6 +39,19 @@ class PlanToolkit(BaseToolkit):
         "semantic_search",
     ]
 
+    def __init__(
+        self,
+        repo_root: Path,
+        mcp_servers: Optional[list["AgentMCPServerConfig"]] = None,
+    ):
+        """Initialize the plan toolkit.
+
+        Args:
+            repo_root: Root directory of the repository
+            mcp_servers: Optional MCP server configurations for this agent
+        """
+        super().__init__(repo_root, mcp_servers=mcp_servers)
+
     def _register_tools(self) -> None:
         """Register read-only exploration tools."""
         # All read-only exploration tools

emdash_core/agent/tools/__init__.py

@@ -56,6 +56,7 @@ from .coding import (
     CodingTool,
     ReadFileTool,
     WriteToFileTool,
+    EditFileTool,
     ApplyDiffTool,
     DeleteFileTool,
     ListFilesTool,
@@ -124,6 +125,7 @@ __all__ = [
     "CodingTool",
     "ReadFileTool",
     "WriteToFileTool",
+    "EditFileTool",
     "ApplyDiffTool",
     "DeleteFileTool",
     "ListFilesTool",