emdash-core 0.1.25__py3-none-any.whl → 0.1.37__py3-none-any.whl

emdash_core/agent/tools/coding.py

@@ -64,6 +64,8 @@ Returns the file content as text."""
         path: str,
         start_line: Optional[int] = None,
         end_line: Optional[int] = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
     ) -> ToolResult:
         """Read a file.
 
@@ -71,6 +73,8 @@ Returns the file content as text."""
             path: Path to the file
             start_line: Optional starting line (1-indexed)
             end_line: Optional ending line (1-indexed)
+            offset: Alternative to start_line - line number to start from (1-indexed)
+            limit: Alternative to end_line - number of lines to read
 
         Returns:
             ToolResult with file content
@@ -89,8 +93,14 @@ Returns the file content as text."""
             content = full_path.read_text()
             lines = content.split("\n")
 
-            # Handle line ranges
-            if start_line or end_line:
+            # Handle line ranges - support both start_line/end_line and offset/limit
+            # offset/limit take precedence if provided
+            if offset is not None or limit is not None:
+                start_idx = (offset - 1) if offset else 0
+                end_idx = start_idx + limit if limit else len(lines)
+                lines = lines[start_idx:end_idx]
+                content = "\n".join(lines)
+            elif start_line or end_line:
                 start_idx = (start_line - 1) if start_line else 0
                 end_idx = end_line if end_line else len(lines)
                 lines = lines[start_idx:end_idx]
@@ -123,6 +133,14 @@ Returns the file content as text."""
                     "type": "integer",
                     "description": "Ending line number (1-indexed)",
                 },
+                "offset": {
+                    "type": "integer",
+                    "description": "Line number to start reading from (1-indexed). Alternative to start_line.",
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of lines to read. Alternative to end_line.",
+                },
             },
             required=["path"],
         )
@@ -135,6 +153,18 @@ class WriteToFileTool(CodingTool):
     description = """Write content to a file.
 Creates the file if it doesn't exist, or overwrites if it does."""
 
+    def __init__(self, repo_root: Path, connection=None, allowed_paths: list[str] | None = None):
+        """Initialize with optional path restrictions.
+
+        Args:
+            repo_root: Root directory of the repository
+            connection: Optional connection (not used for file ops)
+            allowed_paths: If provided, only these paths can be written to.
+                          Used in plan mode to restrict writes to the plan file.
+        """
+        super().__init__(repo_root, connection)
+        self.allowed_paths = allowed_paths
+
     def execute(
         self,
         path: str,
@@ -153,6 +183,19 @@ Creates the file if it doesn't exist, or overwrites if it does."""
         if not valid:
             return ToolResult.error_result(error)
 
+        # Check allowed paths restriction (used in plan mode)
+        if self.allowed_paths is not None:
+            path_str = str(full_path)
+            is_allowed = any(
+                path_str == allowed or path_str.endswith(allowed.lstrip("/"))
+                for allowed in self.allowed_paths
+            )
+            if not is_allowed:
+                return ToolResult.error_result(
+                    f"In plan mode, you can only write to: {', '.join(self.allowed_paths)}",
+                    suggestions=["Write your plan to the designated plan file"],
+                )
+
         try:
             # Create parent directories
             full_path.parent.mkdir(parents=True, exist_ok=True)
@@ -218,8 +261,9 @@ The diff should be in standard unified diff format."""
 
         try:
             # Try to apply with patch command
+            # --batch: suppress questions, --forward: skip already-applied patches
             result = subprocess.run(
-                ["patch", "-p0", "--forward"],
+                ["patch", "-p0", "--forward", "--batch"],
                 input=diff,
                 capture_output=True,
                 text=True,
@@ -230,7 +274,7 @@ The diff should be in standard unified diff format."""
             if result.returncode != 0:
                 # Try with -p1
                 result = subprocess.run(
-                    ["patch", "-p1", "--forward"],
+                    ["patch", "-p1", "--forward", "--batch"],
                     input=diff,
                     capture_output=True,
                     text=True,

emdash_core/agent/tools/modes.py

@@ -4,7 +4,6 @@ Provides tools for entering and exiting modes, following
 Claude Code's approach of explicit mode transitions.
 """
 
-from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
 
@@ -21,15 +20,19 @@ class AgentMode(Enum):
 SUPPORTED_MODES = ["plan"]  # Extensible list
 
 
-@dataclass
 class ModeState:
     """Singleton state for agent mode."""
 
-    current_mode: AgentMode = AgentMode.CODE
-    plan_content: Optional[str] = None  # Stores the current plan
-
     _instance: Optional["ModeState"] = None
 
+    def __init__(self):
+        self.current_mode: AgentMode = AgentMode.CODE
+        self.plan_content: Optional[str] = None  # Stores the current plan
+        self.plan_submitted: bool = False  # Track if exit_plan was called this cycle
+        self.plan_mode_requested: bool = False  # Track if enter_plan_mode was called
+        self.plan_mode_reason: Optional[str] = None  # Reason for plan mode request
+        self.plan_file_path: Optional[str] = None  # Path to the plan file (set when entering plan mode)
+
     @classmethod
     def get_instance(cls) -> "ModeState":
         """Get the singleton instance."""
@@ -42,17 +45,63 @@ class ModeState:
         """Reset the singleton instance."""
         cls._instance = None
 
+    def reset_cycle(self) -> None:
+        """Reset per-cycle state (called on new user message)."""
+        self.plan_submitted = False
+        self.plan_mode_requested = False
+        self.plan_mode_reason = None
+
+    def approve_plan_mode(self) -> None:
+        """Approve plan mode entry (called when user approves)."""
+        self.current_mode = AgentMode.PLAN
+        self.plan_content = None
+        self.plan_mode_requested = False
+        self.plan_mode_reason = None
+        # plan_file_path should already be set by the caller
+
+    def reject_plan_mode(self) -> None:
+        """Reject plan mode entry (called when user rejects)."""
+        self.plan_mode_requested = False
+        self.plan_mode_reason = None
+        self.plan_file_path = None
+
+    def set_plan_file_path(self, path: str) -> None:
+        """Set the plan file path (called when entering plan mode)."""
+        self.plan_file_path = path
+
+    def get_plan_file_path(self) -> Optional[str]:
+        """Get the current plan file path."""
+        return self.plan_file_path
+
+
+class EnterPlanModeTool(BaseTool):
+    """Tool for requesting to enter plan mode - REQUIRES USER CONSENT.
+
+    This follows Claude Code's pattern where entering plan mode is a proposal
+    that requires user approval, not an automatic switch.
+    """
+
+    name = "enter_plan_mode"
+    description = """Request to enter plan mode for implementation planning.
 
-class EnterModeTool(BaseTool):
-    """Tool for entering a different mode from code mode."""
+This tool REQUIRES USER APPROVAL before plan mode is activated.
 
-    name = "enter_mode"
-    description = """Enter a different operating mode.
+Use this proactively when you're about to start a non-trivial implementation task.
+Getting user sign-off on your approach before writing code prevents wasted effort.
 
-Currently supported modes:
-- plan: Enter plan mode to explore the codebase and design an implementation plan.
-        In plan mode you can ONLY use read-only tools (no file modifications).
-        Use exit_plan when your plan is ready for user approval."""
+When to use:
+- New feature implementation requiring architectural decisions
+- Multiple valid approaches exist (user should choose)
+- Multi-file changes expected (more than 2-3 files)
+- Unclear requirements that need exploration first
+
+When NOT to use:
+- Single-line or few-line fixes
+- Trivial tasks with obvious implementation
+- Pure research/exploration (just explore directly)
+- Tasks with very specific, detailed instructions already provided
+
+The user will see your reason and can approve or reject entering plan mode."""
     category = ToolCategory.PLANNING
 
     def __init__(self, connection=None):
@@ -61,92 +110,78 @@ Currently supported modes:
 
     def execute(
         self,
-        mode: str,
         reason: str = "",
         **kwargs,
     ) -> ToolResult:
-        """Enter a new mode.
+        """Request to enter plan mode (requires user approval).
 
         Args:
-            mode: Mode to enter (currently only "plan" supported)
-            reason: Why you're entering this mode (helps context)
+            reason: Why you want to enter plan mode (shown to user)
 
         Returns:
-            ToolResult indicating mode switch
+            ToolResult requesting user approval
         """
-        mode_lower = mode.lower()
+        state = ModeState.get_instance()
 
-        if mode_lower not in SUPPORTED_MODES:
+        if state.current_mode == AgentMode.PLAN:
             return ToolResult.error_result(
-                f"Unsupported mode: {mode}",
-                suggestions=[f"Supported modes: {', '.join(SUPPORTED_MODES)}"],
+                "Already in plan mode",
+                suggestions=["Use exit_plan to submit your plan for approval"],
             )
 
-        state = ModeState.get_instance()
-
-        if mode_lower == "plan":
-            if state.current_mode == AgentMode.PLAN:
-                return ToolResult.error_result(
-                    "Already in plan mode",
-                    suggestions=["Use exit_plan to submit your plan for approval"],
-                )
-
-            state.current_mode = AgentMode.PLAN
-            state.plan_content = None  # Reset plan content
+        # Check if already requested this cycle
+        if state.plan_mode_requested:
+            return ToolResult.error_result(
+                "Plan mode already requested. Wait for user response.",
+                suggestions=["Do not call enter_plan_mode again until user responds."],
+            )
 
-            return ToolResult.success_result(
-                data={
-                    "status": "entered_plan_mode",
-                    "mode": "plan",
-                    "reason": reason,
-                    "message": "You are now in plan mode. Explore the codebase and design your plan. Use exit_plan when ready.",
-                },
+        if not reason or not reason.strip():
+            return ToolResult.error_result(
+                "Reason is required",
+                suggestions=["Explain why you need plan mode (helps user decide)"],
             )
 
-        # Placeholder for future modes
-        return ToolResult.error_result(f"Mode '{mode}' not yet implemented")
+        # Mark as requested (not entered - user must approve)
+        state.plan_mode_requested = True
+        state.plan_mode_reason = reason.strip()
+
+        return ToolResult.success_result(
+            data={
+                "status": "plan_mode_requested",
+                "reason": reason.strip(),
+                "message": "Plan mode requested. Waiting for user approval.",
+            },
+        )
 
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
         return self._make_schema(
             properties={
-                "mode": {
-                    "type": "string",
-                    "enum": SUPPORTED_MODES,
-                    "description": "Mode to enter",
-                },
                 "reason": {
                     "type": "string",
-                    "description": "Brief reason for entering this mode",
+                    "description": "Why you want to enter plan mode (explain the task complexity)",
                 },
             },
-            required=["mode"],
+            required=["reason"],
         )
 
 
 class ExitPlanModeTool(BaseTool):
-    """Tool for exiting plan mode and submitting plan for approval."""
+    """Tool for submitting a plan for user approval."""
 
     name = "exit_plan"
-    description = """Exit plan mode and submit your plan for user approval.
-
-Scale detail based on task complexity:
-- Simple task: title, summary, files_to_modify (steps optional)
-- Complex task: all fields including phases, risks, open questions
+    description = """Submit an implementation plan for user approval.
 
-Required fields:
-- title: Clear, concise plan title
-- summary: What will be implemented and why
-- files_to_modify: List of file changes with paths, line numbers, and descriptions
+Use this tool to present a plan to the user for approval. The plan can come from:
+1. A Plan sub-agent you spawned via task(subagent_type="Plan", ...)
+2. Your own planning (if in plan mode)
 
-Optional fields (include only if needed - each must "earn its place"):
-- implementation_steps: For complex tasks needing ordered steps
-- risks: Non-trivial risks only
-- testing_strategy: Beyond obvious test cases
+Pass the plan content as the 'plan' parameter.
 
 The user will either:
-- Approve: You'll return to code mode to implement the plan
-- Reject: You'll receive feedback and can revise in plan mode"""
+- Approve: You can proceed with implementation
+- Reject: You'll receive feedback and can revise"""
     category = ToolCategory.PLANNING
 
     def __init__(self, connection=None):
@@ -155,60 +190,73 @@ The user will either:
 
     def execute(
         self,
-        title: str,
-        summary: str,
-        files_to_modify: list[dict] = None,
-        implementation_steps: list[str] = None,
-        risks: list[str] = None,
-        testing_strategy: str = None,
+        plan: Optional[str] = None,
         **kwargs,
     ) -> ToolResult:
-        """Exit plan mode and submit plan for approval.
+        """Submit plan for user approval.
 
         Args:
-            title: Title of the plan
-            summary: Summary of what will be implemented and why
-            files_to_modify: List of file changes, each with:
-                - path: File path (e.g., "src/auth.py")
-                - lines: Line range (e.g., "45-60" or "new file")
-                - changes: Description of what changes
-            implementation_steps: Ordered list of detailed implementation steps
-            risks: List of potential risks or considerations
-            testing_strategy: Description of how changes will be tested
+            plan: The plan content (required in code mode, optional in plan mode).
 
         Returns:
             ToolResult triggering user approval flow
         """
         state = ModeState.get_instance()
 
-        if state.current_mode != AgentMode.PLAN:
+        # Prevent multiple exit_plan calls per cycle
+        if state.plan_submitted:
             return ToolResult.error_result(
-                "Not in plan mode",
-                suggestions=["Use enter_mode with mode='plan' to enter plan mode first"],
+                "Plan already submitted. Wait for user approval.",
+                suggestions=["Do not call exit_plan again until user responds."],
             )
 
-        if not title or not title.strip():
-            return ToolResult.error_result("Title is required")
-        if not summary or not summary.strip():
-            return ToolResult.error_result("Summary is required")
-        if not files_to_modify:
+        # Get plan content from parameter or file
+        plan_content = plan
+
+        # In plan mode, try to read from plan file if not provided
+        if state.current_mode == AgentMode.PLAN:
+            if not plan_content or not plan_content.strip():
+                plan_file_path = state.get_plan_file_path()
+                if plan_file_path:
+                    try:
+                        from pathlib import Path
+                        plan_path = Path(plan_file_path)
+                        if plan_path.exists():
+                            plan_content = plan_path.read_text()
+                    except Exception as e:
+                        return ToolResult.error_result(
+                            f"Failed to read plan file: {e}",
+                            suggestions=[f"Write your plan to {plan_file_path} first"],
+                        )
+
+        # In code mode, plan content is required (from Plan subagent)
+        if state.current_mode == AgentMode.CODE:
+            if not plan_content or not plan_content.strip():
+                return ToolResult.error_result(
+                    "Plan content is required when submitting from code mode",
+                    suggestions=[
+                        "Pass the plan from your Plan sub-agent as the 'plan' parameter",
+                        "Example: exit_plan(plan=<plan_from_subagent>)",
+                    ],
+                )
+
+        if not plan_content or not plan_content.strip():
+            plan_file_path = state.get_plan_file_path() or "the plan file"
             return ToolResult.error_result(
-                "files_to_modify is required",
-                suggestions=["Include at least one file with path, lines, and changes"],
+                "Plan content is required",
+                suggestions=[
+                    f"Write your plan to {plan_file_path} using write_to_file, then call exit_plan",
+                    "Or pass the plan directly as a parameter",
+                ],
             )
-        # implementation_steps optional for simple tasks where files_to_modify is self-explanatory
 
-        # Store plan content for reference
-        state.plan_content = summary
+        # Store plan content for reference and mark as submitted
+        state.plan_content = plan_content.strip()
+        state.plan_submitted = True
 
         return ToolResult.success_result({
             "status": "plan_submitted",
-            "title": title.strip(),
-            "summary": summary.strip(),
-            "files_to_modify": files_to_modify,
-            "implementation_steps": implementation_steps or [],
-            "risks": risks or [],
-            "testing_strategy": testing_strategy or "",
+            "plan": plan_content.strip(),
             "message": "Plan submitted for user approval. Waiting for user response.",
         })
 
@@ -216,52 +264,12 @@ The user will either:
         """Get OpenAI function schema."""
         return self._make_schema(
             properties={
-                "title": {
-                    "type": "string",
-                    "description": "Clear, concise title of the plan",
-                },
-                "summary": {
-                    "type": "string",
-                    "description": "Detailed summary of what will be implemented and why",
-                },
-                "files_to_modify": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "path": {
-                                "type": "string",
-                                "description": "File path (e.g., 'src/auth.py')",
-                            },
-                            "lines": {
-                                "type": "string",
-                                "description": "Line range (e.g., '45-60') or 'new file'",
-                            },
-                            "changes": {
-                                "type": "string",
-                                "description": "Description of what changes in this file",
-                            },
-                        },
-                        "required": ["path", "changes"],
-                    },
-                    "description": "List of files to modify with line numbers and change descriptions",
-                },
-                "implementation_steps": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Detailed ordered list of implementation steps with sub-tasks",
-                },
-                "risks": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Potential risks, breaking changes, or considerations",
-                },
-                "testing_strategy": {
+                "plan": {
                     "type": "string",
-                    "description": "How the changes will be tested (unit tests, integration tests, etc.)",
+                    "description": "Optional: The implementation plan as markdown. If not provided, reads from the plan file.",
                 },
             },
-            required=["title", "summary", "files_to_modify"],
+            required=[],
         )
 
 

emdash_core/agent/tools/task.py

@@ -62,6 +62,7 @@ Multiple sub-agents can be launched in parallel."""
         max_turns: int = 10,
         run_in_background: bool = False,
         resume: Optional[str] = None,
+        thoroughness: str = "medium",
         **kwargs,
     ) -> ToolResult:
         """Spawn a sub-agent to perform a task.
@@ -74,6 +75,7 @@ Multiple sub-agents can be launched in parallel."""
             max_turns: Maximum API round-trips
             run_in_background: Run asynchronously
             resume: Agent ID to resume from
+            thoroughness: Search thoroughness level (quick, medium, thorough)
 
         Returns:
             ToolResult with agent results or background task info
@@ -85,13 +87,22 @@ Multiple sub-agents can be launched in parallel."""
                 suggestions=["Provide a clear task description in 'prompt'"],
             )
 
-        available_types = list_agent_types()
+        available_types = list_agent_types(self.repo_root)
+        log.info(f"TaskTool: repo_root={self.repo_root}, available_types={available_types}")
         if subagent_type not in available_types:
             return ToolResult.error_result(
                 f"Unknown agent type: {subagent_type}",
-                suggestions=[f"Available types: {available_types}"],
+                suggestions=[
+                    f"Available types: {available_types}",
+                    f"Searched in: {self.repo_root / '.emdash' / 'agents'}",
+                ],
             )
 
+        # Log current mode for debugging
+        from .modes import ModeState
+        mode_state = ModeState.get_instance()
+        log.info(f"TaskTool: current_mode={mode_state.current_mode}, subagent_type={subagent_type}")
+
         log.info(
             "Spawning sub-agent type={} model={} prompt={}",
             subagent_type,
@@ -99,16 +110,26 @@ Multiple sub-agents can be launched in parallel."""
             prompt[:50] + "..." if len(prompt) > 50 else prompt,
         )
 
+        # Emit subagent start event for UI visibility
+        if self.emitter:
+            from ..events import EventType
+            self.emitter.emit(EventType.SUBAGENT_START, {
+                "agent_type": subagent_type,
+                "prompt": prompt[:100] + "..." if len(prompt) > 100 else prompt,
+                "description": description,
+            })
+
         if run_in_background:
-            return self._run_background(subagent_type, prompt, max_turns)
+            return self._run_background(subagent_type, prompt, max_turns, thoroughness)
         else:
-            return self._run_sync(subagent_type, prompt, max_turns)
+            return self._run_sync(subagent_type, prompt, max_turns, thoroughness)
 
     def _run_sync(
         self,
         subagent_type: str,
         prompt: str,
         max_turns: int,
+        thoroughness: str = "medium",
     ) -> ToolResult:
         """Run sub-agent synchronously in the same process.
 
@@ -116,6 +137,7 @@ Multiple sub-agents can be launched in parallel."""
             subagent_type: Agent type
             prompt: Task prompt
             max_turns: Maximum API round-trips
+            thoroughness: Search thoroughness level
 
         Returns:
             ToolResult with agent results
@@ -127,8 +149,20 @@ Multiple sub-agents can be launched in parallel."""
                 repo_root=self.repo_root,
                 emitter=self.emitter,
                 max_turns=max_turns,
+                thoroughness=thoroughness,
             )
 
+            # Emit subagent end event
+            if self.emitter:
+                from ..events import EventType
+                self.emitter.emit(EventType.SUBAGENT_END, {
+                    "agent_type": subagent_type,
+                    "success": result.success,
+                    "iterations": result.iterations,
+                    "files_explored": len(result.files_explored),
+                    "execution_time": result.execution_time,
+                })
+
             if result.success:
                 return ToolResult.success_result(
                     data=result.to_dict(),
@@ -149,6 +183,7 @@ Multiple sub-agents can be launched in parallel."""
         subagent_type: str,
         prompt: str,
         max_turns: int,
+        thoroughness: str = "medium",
     ) -> ToolResult:
         """Run sub-agent in background using a thread.
 
@@ -156,6 +191,7 @@ Multiple sub-agents can be launched in parallel."""
             subagent_type: Agent type
             prompt: Task prompt
             max_turns: Maximum API round-trips
+            thoroughness: Search thoroughness level
 
         Returns:
             ToolResult with task info
@@ -175,6 +211,7 @@ Multiple sub-agents can be launched in parallel."""
                 repo_root=self.repo_root,
                 emitter=self.emitter,
                 max_turns=max_turns,
+                thoroughness=thoroughness,
             )
 
             # Store future for later retrieval (attach to class for now)
@@ -221,6 +258,9 @@ Multiple sub-agents can be launched in parallel."""
 
     def get_schema(self) -> dict:
         """Get OpenAI function schema."""
+        # Get available agent types dynamically (includes custom agents)
+        available_types = list_agent_types(self.repo_root)
+
         return self._make_schema(
             properties={
                 "description": {
@@ -233,8 +273,8 @@ Multiple sub-agents can be launched in parallel."""
                 },
                 "subagent_type": {
                     "type": "string",
-                    "enum": ["Explore", "Plan"],
-                    "description": "Type of specialized agent",
+                    "enum": available_types,
+                    "description": f"Type of specialized agent. Available: {', '.join(available_types)}",
                     "default": "Explore",
                 },
                 "model_tier": {
@@ -257,6 +297,12 @@ Multiple sub-agents can be launched in parallel."""
                     "type": "string",
                     "description": "Agent ID to resume from previous execution",
                 },
+                "thoroughness": {
+                    "type": "string",
+                    "enum": ["quick", "medium", "thorough"],
+                    "description": "Search thoroughness: quick (basic searches), medium (moderate exploration), thorough (comprehensive analysis)",
+                    "default": "medium",
+                },
             },
             required=["prompt"],
         )