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

emdash_core/agent/runner/plan.py

@@ -0,0 +1,217 @@
+"""Plan management mixin for the agent runner.
+
+This module provides plan approval/rejection functionality as a mixin class.
+"""
+
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..toolkit import AgentToolkit
+
+
+class PlanMixin:
+    """Mixin class providing plan management methods for AgentRunner.
+
+    This mixin expects the following attributes on the class:
+    - _pending_plan: Optional[dict] - stores pending plan
+    - toolkit: AgentToolkit - the agent's toolkit
+    - emitter: AgentEventEmitter - event emitter
+    - system_prompt: str - current system prompt
+
+    And the following methods:
+    - run(message: str) -> str - to continue execution
+    """
+
+    _pending_plan: Optional[dict]
+
+    def _get_plan_file_path(self) -> str:
+        """Get the plan file path based on repo root.
+
+        Returns:
+            Path to the plan file (e.g., .emdash/plan.md)
+        """
+        repo_root = self.toolkit._repo_root
+        return str(repo_root / ".emdash" / "plan.md")
+
+    def has_pending_plan(self) -> bool:
+        """Check if there's a plan awaiting approval.
+
+        Returns:
+            True if a plan has been submitted and is awaiting approval.
+        """
+        return self._pending_plan is not None
+
+    def get_pending_plan(self) -> Optional[dict]:
+        """Get the pending plan if one exists.
+
+        Returns:
+            The pending plan dict, or None if no plan is pending.
+        """
+        return self._pending_plan
+
+    def approve_plan(self) -> str:
+        """Approve the pending plan and transition back to code mode.
+
+        This method should be called after the user approves a submitted plan.
+        It transitions the agent from plan mode back to code mode, allowing
+        it to implement the approved plan.
+
+        Returns:
+            The agent's response after transitioning to code mode.
+        """
+        if not self._pending_plan:
+            return "No pending plan to approve."
+
+        plan_content = self._pending_plan.get("plan", "")
+        plan_file_path = None
+
+        # Try to get plan file path for reference in the approval message
+        from ..tools.modes import ModeState, AgentMode
+        state = ModeState.get_instance()
+        plan_file_path = state.get_plan_file_path()
+
+        self._pending_plan = None  # Clear pending plan
+
+        # Reset ModeState singleton to code mode
+        state.current_mode = AgentMode.CODE
+        state.plan_content = plan_content
+        state.plan_file_path = None  # Clear plan file path
+
+        # Import AgentToolkit here to avoid circular imports
+        from ..toolkit import AgentToolkit
+        from ..prompts import build_system_prompt
+
+        # Rebuild toolkit with plan_mode=False (code mode)
+        self.toolkit = AgentToolkit(
+            connection=self.toolkit.connection,
+            repo_root=self.toolkit._repo_root,
+            plan_mode=False,
+        )
+        self.toolkit.set_emitter(self.emitter)
+
+        # Update system prompt back to code mode
+        self.system_prompt = build_system_prompt(self.toolkit)
+
+        # Resume execution with approval message
+        plan_reference = f"(Plan file: {plan_file_path})" if plan_file_path else ""
+        approval_message = f"""Your plan has been APPROVED. {plan_reference}
+
+You are now in code mode. Implement the following plan:
+
+{plan_content}
+
+Proceed with implementation step by step using the available tools."""
+
+        return self.run(approval_message)
+
+    def reject_plan(self, feedback: str = "") -> str:
+        """Reject the pending plan and provide feedback.
+
+        The agent remains in plan mode to revise the plan based on feedback.
+
+        Args:
+            feedback: Optional feedback explaining why the plan was rejected.
+
+        Returns:
+            The agent's response after receiving the rejection.
+        """
+        if not self._pending_plan:
+            return "No pending plan to reject."
+
+        plan_title = self._pending_plan.get("title", "Untitled")
+        self._pending_plan = None  # Clear pending plan (but stay in plan mode)
+
+        rejection_message = f"""Your plan "{plan_title}" was REJECTED.
+
+{f"Feedback: {feedback}" if feedback else "Please revise the plan."}
+
+You are still in plan mode. Please address the feedback and submit a revised plan using exit_plan."""
+
+        return self.run(rejection_message)
+
+    def approve_plan_mode(self) -> str:
+        """Approve entering plan mode.
+
+        This method should be called after the user approves a plan mode request
+        (triggered by enter_plan_mode tool). It transitions the agent into plan mode.
+
+        Returns:
+            The agent's response after entering plan mode.
+        """
+        from ..tools.modes import ModeState
+        state = ModeState.get_instance()
+
+        if not state.plan_mode_requested:
+            return "No pending plan mode request."
+
+        reason = state.plan_mode_reason or ""
+
+        # Set the plan file path before approving
+        plan_file_path = self._get_plan_file_path()
+        state.set_plan_file_path(plan_file_path)
+
+        # Actually enter plan mode
+        state.approve_plan_mode()
+
+        # Import here to avoid circular imports
+        from ..toolkit import AgentToolkit
+        from ..prompts import build_system_prompt
+
+        # Rebuild toolkit with plan_mode=True and plan_file_path
+        self.toolkit = AgentToolkit(
+            connection=self.toolkit.connection,
+            repo_root=self.toolkit._repo_root,
+            plan_mode=True,
+            plan_file_path=plan_file_path,
+        )
+        self.toolkit.set_emitter(self.emitter)
+
+        # Main agent uses normal prompt - it delegates to Plan subagent
+        self.system_prompt = build_system_prompt(self.toolkit)
+
+        # Resume execution - tell main agent to spawn Plan subagent
+        approval_message = f"""Your request to enter plan mode has been APPROVED.
+
+Reason: {reason}
+
+You are now in plan mode. Follow these steps:
+
+1. **Spawn Plan subagent NOW**:
+   `task(subagent_type="Plan", prompt="<your planning request>")`
+
+2. **After the Plan subagent returns**, take its response (the plan content) and:
+   a) Write it to `{plan_file_path}` using `write_to_file(path="{plan_file_path}", content=<plan>)`
+   b) Call `exit_plan()` to present the plan for user approval
+
+Start by spawning the Plan subagent."""
+
+        return self.run(approval_message)
+
+    def reject_plan_mode(self, feedback: str = "") -> str:
+        """Reject entering plan mode.
+
+        The agent remains in code mode and continues with the task.
+
+        Args:
+            feedback: Optional feedback explaining why plan mode was rejected.
+
+        Returns:
+            The agent's response after rejection.
+        """
+        from ..tools.modes import ModeState
+        state = ModeState.get_instance()
+
+        if not state.plan_mode_requested:
+            return "No pending plan mode request."
+
+        # Reset the request
+        state.reject_plan_mode()
+
+        rejection_message = f"""Your request to enter plan mode was REJECTED.
+
+{f"Feedback: {feedback}" if feedback else "The user prefers to proceed without detailed planning."}
+
+You are still in code mode. Please proceed with the task directly, or ask for clarification if needed."""
+
+        return self.run(rejection_message)

emdash_core/agent/runner/sdk_runner.py

@@ -0,0 +1,324 @@
+"""SDK Agent Runner - Uses Anthropic Agent SDK for Claude models.
+
+This module provides an alternative runner that uses the official Anthropic
+Agent SDK (claude-agent-sdk) for Claude models. This enables native support
+for Skills, MCP tools, and extended thinking.
+
+For non-Claude models (Fireworks, OpenAI, etc.), use the standard AgentRunner.
+"""
+
+from pathlib import Path
+from typing import AsyncIterator, Optional, TYPE_CHECKING
+import json
+
+from ...utils.logger import log
+
+if TYPE_CHECKING:
+    from ..events import AgentEventEmitter
+
+
+class SDKAgentRunner:
+    """Agent runner using Anthropic Agent SDK directly.
+
+    This runner uses the official claude-agent-sdk package which bundles
+    Claude Code CLI. It provides native support for:
+    - Skills (.claude/skills/)
+    - MCP servers (in-process and external)
+    - Extended thinking
+    - Built-in tools (Read, Write, Bash, Glob, Grep)
+
+    Example:
+        runner = SDKAgentRunner(
+            model="claude-sonnet-4-20250514",
+            cwd="/path/to/project",
+        )
+
+        async for event in runner.run("Find authentication code"):
+            print(event)
+    """
+
+    # Default model for SDK (must be a Claude model)
+    DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+    def __init__(
+        self,
+        model: str = DEFAULT_MODEL,
+        cwd: Optional[str] = None,
+        emitter: Optional["AgentEventEmitter"] = None,
+        system_prompt: Optional[str] = None,
+        plan_mode: bool = False,
+    ):
+        """Initialize the SDK runner.
+
+        Args:
+            model: Claude model to use (e.g., "claude-sonnet-4-20250514")
+            cwd: Working directory for the agent
+            emitter: Event emitter for streaming events to UI
+            system_prompt: Custom system prompt
+            plan_mode: If True, restrict to read-only tools
+        """
+        self.model = model
+        self.cwd = cwd or str(Path.cwd())
+        self.emitter = emitter
+        self.system_prompt = system_prompt
+        self.plan_mode = plan_mode
+        self._emdash_server = None  # Lazy init
+
+    def _get_emdash_mcp_server(self):
+        """Get or create in-process MCP server for emdash-specific tools."""
+        if self._emdash_server is not None:
+            return self._emdash_server
+
+        from claude_agent_sdk import tool, create_sdk_mcp_server
+
+        @tool(
+            "semantic_search",
+            "Search code using natural language. Returns relevant functions, classes, and files.",
+            {"query": str, "limit": int, "entity_types": list}
+        )
+        async def semantic_search(args):
+            """Run semantic search on the codebase."""
+            try:
+                from ...graph.connection import get_connection
+                from ..tools.search import SemanticSearchTool
+
+                conn = get_connection()
+                search_tool = SemanticSearchTool(conn)
+                result = search_tool.execute(
+                    query=args["query"],
+                    limit=args.get("limit", 10),
+                    entity_types=args.get("entity_types"),
+                )
+
+                if result.success:
+                    # Format result for LLM
+                    result_text = json.dumps(result.to_dict(), indent=2)
+                    return {
+                        "content": [
+                            {"type": "text", "text": result_text}
+                        ]
+                    }
+                else:
+                    return {
+                        "content": [
+                            {"type": "text", "text": f"Search failed: {result.error}"}
+                        ],
+                        "isError": True,
+                    }
+            except Exception as e:
+                log.exception("Semantic search failed")
+                return {
+                    "content": [
+                        {"type": "text", "text": f"Search error: {str(e)}"}
+                    ],
+                    "isError": True,
+                }
+
+        self._emdash_server = create_sdk_mcp_server(
+            name="emdash",
+            version="1.0.0",
+            tools=[semantic_search]
+        )
+        return self._emdash_server
+
+    def _get_options(self):
+        """Build SDK options with native features."""
+        from claude_agent_sdk import ClaudeAgentOptions
+
+        # Base allowed tools - SDK built-ins
+        allowed_tools = [
+            # Read-only tools (always available)
+            "Read", "Glob", "Grep", "Skill",
+            # emdash custom tools
+            "mcp__emdash__semantic_search",
+        ]
+
+        # Add write tools unless in plan mode
+        if not self.plan_mode:
+            allowed_tools.extend([
+                "Write", "Bash",
+            ])
+
+        # Build MCP servers config
+        mcp_servers = {
+            "emdash": self._get_emdash_mcp_server(),  # In-process (semantic search)
+        }
+
+        # Add graph MCP if available
+        graph_mcp_path = Path(self.cwd) / ".emdash" / "mcp.json"
+        if graph_mcp_path.exists():
+            # External graph MCP server for code analysis
+            mcp_servers["graph"] = {
+                "type": "stdio",
+                "command": "python",
+                "args": ["-m", "emdash_graph_mcp.server"],
+                "env": {"REPO_ROOT": self.cwd},
+            }
+            allowed_tools.extend([
+                "mcp__graph__expand_node",
+                "mcp__graph__get_callers",
+                "mcp__graph__get_callees",
+            ])
+
+        return ClaudeAgentOptions(
+            model=self.model,
+            cwd=self.cwd,
+            system_prompt=self.system_prompt,
+
+            # Native Skills support - load from .claude/skills/
+            setting_sources=["user", "project"],
+
+            # MCP servers
+            mcp_servers=mcp_servers,
+
+            # Allowed tools
+            allowed_tools=allowed_tools,
+
+            # Permission mode
+            permission_mode="acceptEdits" if not self.plan_mode else "plan",
+        )
+
+    def _emit(self, event_type, data: dict):
+        """Emit event to emitter if available."""
+        if self.emitter:
+            from ..events import EventType
+            self.emitter.emit(getattr(EventType, event_type), data)
+
+    async def run(self, prompt: str) -> AsyncIterator[dict]:
+        """Execute agent with SDK.
+
+        Args:
+            prompt: User prompt/task
+
+        Yields:
+            Event dicts for UI streaming
+        """
+        from claude_agent_sdk import (
+            ClaudeSDKClient,
+            AssistantMessage,
+            TextBlock,
+            ToolUseBlock,
+            ToolResultBlock,
+            ResultMessage,
+        )
+
+        options = self._get_options()
+
+        # Emit session start
+        self._emit("SESSION_START", {
+            "model": self.model,
+            "agent_name": "Emdash Code (SDK)",
+        })
+
+        try:
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(prompt)
+
+                async for message in client.receive_response():
+                    # Process message and yield events
+                    if isinstance(message, AssistantMessage):
+                        for block in message.content:
+                            if isinstance(block, TextBlock):
+                                self._emit("PARTIAL_RESPONSE", {"text": block.text})
+                                yield {"type": "text", "content": block.text}
+
+                            elif isinstance(block, ToolUseBlock):
+                                self._emit("TOOL_START", {
+                                    "tool": block.name,
+                                    "input": block.input,
+                                })
+                                yield {
+                                    "type": "tool_use",
+                                    "name": block.name,
+                                    "input": block.input,
+                                }
+
+                            elif isinstance(block, ToolResultBlock):
+                                self._emit("TOOL_RESULT", {
+                                    "tool": block.tool_use_id,
+                                    "result": str(block.content)[:500],
+                                })
+                                yield {
+                                    "type": "tool_result",
+                                    "tool_use_id": block.tool_use_id,
+                                    "content": block.content,
+                                }
+
+                    elif isinstance(message, ResultMessage):
+                        yield {
+                            "type": "result",
+                            "duration_ms": getattr(message, "duration_ms", None),
+                            "cost_usd": getattr(message, "total_cost_usd", None),
+                        }
+
+        except Exception as e:
+            log.exception("SDK agent execution failed")
+            self._emit("ERROR", {"error": str(e)})
+            yield {"type": "error", "error": str(e)}
+
+        finally:
+            self._emit("SESSION_END", {})
+
+    async def chat(self, message: str) -> str:
+        """Simple chat method for compatibility.
+
+        Args:
+            message: User message
+
+        Returns:
+            Assistant response text
+        """
+        response_text = ""
+        async for event in self.run(message):
+            if event.get("type") == "text":
+                response_text += event.get("content", "")
+        return response_text
+
+
+def is_claude_model(model: str) -> bool:
+    """Check if a model string refers to a Claude model.
+
+    Args:
+        model: Model string (e.g., "claude-sonnet-4", "haiku", "fireworks:...")
+
+    Returns:
+        True if this is a Claude model that can use the SDK
+    """
+    model_lower = model.lower()
+
+    # Check for non-Claude providers first (more specific)
+    non_claude_patterns = [
+        "fireworks:",
+        "openai:",
+        "gpt-",
+        "o1",
+        "o3",
+        "o4",
+        "accounts/fireworks",
+        "minimax",
+        "glm",
+        "gemini",
+        "llama",
+        "mistral",
+        "qwen",
+    ]
+
+    for pattern in non_claude_patterns:
+        if pattern in model_lower:
+            return False
+
+    # Check for Claude indicators
+    claude_indicators = [
+        "claude",
+        "anthropic",
+        "haiku",
+        "sonnet",
+        "opus",
+    ]
+
+    for indicator in claude_indicators:
+        if indicator in model_lower:
+            return True
+
+    # Default: assume not Claude (safer)
+    return False

emdash_core/agent/runner/utils.py

@@ -0,0 +1,67 @@
+"""Utility classes and functions for the agent runner."""
+
+import json
+from datetime import datetime, date
+from typing import Any
+
+
+class SafeJSONEncoder(json.JSONEncoder):
+    """JSON encoder that handles Neo4j types and other non-serializable objects."""
+
+    def default(self, obj: Any) -> Any:
+        # Handle datetime objects
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()
+
+        # Handle Neo4j DateTime
+        if hasattr(obj, 'isoformat'):
+            return obj.isoformat()
+
+        # Handle Neo4j Date, Time, etc.
+        if hasattr(obj, 'to_native'):
+            return str(obj.to_native())
+
+        # Handle sets
+        if isinstance(obj, set):
+            return list(obj)
+
+        # Handle bytes
+        if isinstance(obj, bytes):
+            return obj.decode('utf-8', errors='replace')
+
+        # Fallback to string representation
+        try:
+            return str(obj)
+        except Exception:
+            return f"<non-serializable: {type(obj).__name__}>"
+
+
+def summarize_tool_result(result: Any) -> str:
+    """Create a brief summary of a tool result.
+
+    Args:
+        result: ToolResult object with success, error, and data attributes.
+
+    Returns:
+        Brief summary string.
+    """
+    if not result.success:
+        return f"Error: {result.error}"
+
+    if not result.data:
+        return "Empty result"
+
+    data = result.data
+
+    if "results" in data:
+        return f"{len(data['results'])} results"
+    elif "root_node" in data:
+        node = data["root_node"]
+        name = node.get("qualified_name") or node.get("file_path", "unknown")
+        return f"Expanded: {name}"
+    elif "callers" in data:
+        return f"{len(data['callers'])} callers"
+    elif "callees" in data:
+        return f"{len(data['callees'])} callees"
+
+    return "Completed"