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

emdash_core/agent/__init__.py

@@ -19,6 +19,9 @@ def __getattr__(name: str):
     elif name == "AgentRunner":
         from .runner import AgentRunner
         return AgentRunner
+    elif name == "SafeJSONEncoder":
+        from .runner import SafeJSONEncoder
+        return SafeJSONEncoder
     elif name == "ToolResult":
         from .tools.base import ToolResult
         return ToolResult
@@ -32,6 +35,7 @@ __all__ = [
     "AgentToolkit",
     "AgentSession",
     "AgentRunner",
+    "SafeJSONEncoder",
     "ToolResult",
     "ToolCategory",
 ]

emdash_core/agent/events.py

@@ -17,6 +17,10 @@ class EventType(Enum):
     TOOL_START = "tool_start"
     TOOL_RESULT = "tool_result"
 
+    # Sub-agent lifecycle
+    SUBAGENT_START = "subagent_start"
+    SUBAGENT_END = "subagent_end"
+
     # Agent thinking/progress
     THINKING = "thinking"
     PROGRESS = "progress"
@@ -24,10 +28,12 @@ class EventType(Enum):
     # Output
     RESPONSE = "response"
     PARTIAL_RESPONSE = "partial_response"
+    ASSISTANT_TEXT = "assistant_text"  # Intermediate text between tool calls
 
     # Interaction
     CLARIFICATION = "clarification"
     CLARIFICATION_RESPONSE = "clarification_response"
+    PLAN_MODE_REQUESTED = "plan_mode_requested"
     PLAN_SUBMITTED = "plan_submitted"
 
     # Errors
@@ -144,16 +150,23 @@ class AgentEventEmitter:
 
         return event
 
-    def emit_tool_start(self, name: str, args: dict[str, Any] | None = None) -> AgentEvent:
+    def emit_tool_start(
+        self,
+        name: str,
+        args: dict[str, Any] | None = None,
+        tool_id: str | None = None,
+    ) -> AgentEvent:
         """Convenience method to emit a tool start event.
 
         Args:
             name: Tool name
             args: Tool arguments
+            tool_id: Unique ID for this tool call (for matching with result)
         """
         return self.emit(EventType.TOOL_START, {
             "name": name,
             "args": args or {},
+            "tool_id": tool_id,
         })
 
     def emit_tool_result(
@@ -162,6 +175,7 @@ class AgentEventEmitter:
         success: bool,
         summary: str | None = None,
         data: dict[str, Any] | None = None,
+        tool_id: str | None = None,
     ) -> AgentEvent:
         """Convenience method to emit a tool result event.
 
@@ -170,12 +184,14 @@ class AgentEventEmitter:
             success: Whether the tool succeeded
             summary: Brief summary of the result
             data: Full result data (may be truncated by handlers)
+            tool_id: Unique ID for this tool call (for matching with start)
         """
         return self.emit(EventType.TOOL_RESULT, {
             "name": name,
             "success": success,
             "summary": summary,
             "data": data,
+            "tool_id": tool_id,
         })
 
     def emit_thinking(self, message: str) -> AgentEvent:
@@ -208,6 +224,14 @@ class AgentEventEmitter:
         event_type = EventType.RESPONSE if is_final else EventType.PARTIAL_RESPONSE
         return self.emit(event_type, {"content": content})
 
+    def emit_assistant_text(self, content: str) -> AgentEvent:
+        """Emit intermediate assistant text (shown between tool calls).
+
+        Args:
+            content: Text content from assistant (e.g., "Let me read the file...")
+        """
+        return self.emit(EventType.ASSISTANT_TEXT, {"content": content})
+
     def emit_clarification(
         self,
         question: str,
@@ -227,32 +251,30 @@ class AgentEventEmitter:
             "options": options,
         })
 
-    def emit_plan_submitted(
+    def emit_plan_mode_requested(
         self,
-        title: str,
-        summary: str,
-        files_to_modify: list[dict] | None = None,
-        implementation_steps: list[str] | None = None,
-        risks: list[str] | None = None,
-        testing_strategy: str | None = None,
+        reason: str,
     ) -> AgentEvent:
+        """Convenience method to emit a plan mode request event.
+
+        This is emitted when the agent calls enter_plan_mode tool,
+        requesting user consent to enter plan mode.
+
+        Args:
+            reason: Why the agent wants to enter plan mode
+        """
+        return self.emit(EventType.PLAN_MODE_REQUESTED, {
+            "reason": reason,
+        })
+
+    def emit_plan_submitted(self, plan: str) -> AgentEvent:
         """Convenience method to emit a plan submission event.
 
         Args:
-            title: Plan title
-            summary: Plan summary
-            files_to_modify: List of files with path, lines, changes
-            implementation_steps: Ordered implementation steps
-            risks: Potential risks or considerations
-            testing_strategy: How changes will be tested
+            plan: The implementation plan as markdown
         """
         return self.emit(EventType.PLAN_SUBMITTED, {
-            "title": title,
-            "summary": summary,
-            "files_to_modify": files_to_modify or [],
-            "implementation_steps": implementation_steps or [],
-            "risks": risks or [],
-            "testing_strategy": testing_strategy or "",
+            "plan": plan,
         })
 
     def emit_error(self, message: str, details: str | None = None) -> AgentEvent:

emdash_core/agent/inprocess_subagent.py

@@ -62,6 +62,7 @@ class InProcessSubAgent:
         model: Optional[str] = None,
         max_turns: int = 10,
         agent_id: Optional[str] = None,
+        thoroughness: str = "medium",
     ):
         """Initialize in-process sub-agent.
 
@@ -72,12 +73,14 @@ class InProcessSubAgent:
             model: Model to use (defaults to fast model)
             max_turns: Maximum iterations
             agent_id: Optional agent ID (generated if not provided)
+            thoroughness: Search thoroughness level (quick, medium, thorough)
         """
         self.subagent_type = subagent_type
         self.repo_root = repo_root.resolve()
         self.emitter = emitter
         self.max_turns = max_turns
         self.agent_id = agent_id or str(uuid.uuid4())[:8]
+        self.thoroughness = thoroughness
 
         # Get toolkit for this agent type
         self.toolkit = get_toolkit(subagent_type, repo_root)
@@ -86,13 +89,40 @@ class InProcessSubAgent:
         model_name = model or DEFAULT_MODEL
         self.provider = get_provider(model_name)
 
-        # Get system prompt
-        self.system_prompt = get_subagent_prompt(subagent_type)
+        # Get system prompt and inject thoroughness level
+        base_prompt = get_subagent_prompt(subagent_type)
+        self.system_prompt = self._inject_thoroughness(base_prompt)
 
         # Tracking
         self.files_explored: set[str] = set()
         self.tools_used: list[str] = []
 
+    def _inject_thoroughness(self, prompt: str) -> str:
+        """Inject thoroughness level into the system prompt."""
+        thoroughness_guidance = {
+            "quick": """
+## Thoroughness Level: QUICK
+- Do basic searches only - find the most obvious matches first
+- Stop after finding 2-3 relevant files
+- Don't explore deeply - just locate the key files
+- Prioritize speed over completeness""",
+            "medium": """
+## Thoroughness Level: MEDIUM
+- Do moderate exploration - check multiple locations
+- Follow 1-2 levels of imports/references
+- Balance speed with coverage
+- Stop when you have reasonable confidence""",
+            "thorough": """
+## Thoroughness Level: THOROUGH
+- Do comprehensive analysis across the codebase
+- Check multiple naming conventions and locations
+- Follow import chains and cross-references deeply
+- Explore edge cases and alternative implementations
+- Only stop when you've exhausted relevant areas""",
+        }
+        guidance = thoroughness_guidance.get(self.thoroughness, thoroughness_guidance["medium"])
+        return prompt + "\n" + guidance
+
     def _emit(self, event_type: str, **data) -> None:
         """Emit event with agent tagging.
 
@@ -115,6 +145,50 @@ class InProcessSubAgent:
             if event_type in event_map:
                 self.emitter.emit(event_map[event_type], data)
 
+    def _get_project_context(self) -> str:
+        """Get PROJECT.md and directory structure for context."""
+        context_parts = []
+
+        # Try to read PROJECT.md
+        project_md = self.repo_root / "PROJECT.md"
+        if project_md.exists():
+            try:
+                content = project_md.read_text()
+                # Truncate if too long
+                if len(content) > 8000:
+                    content = content[:8000] + "\n...[truncated]"
+                context_parts.append(f"## PROJECT.md\n\n{content}")
+            except Exception as e:
+                log.debug(f"Could not read PROJECT.md: {e}")
+
+        # Get directory structure (top 2 levels)
+        try:
+            structure_lines = ["## Project Structure\n"]
+            for item in sorted(self.repo_root.iterdir()):
+                if item.name.startswith(".") and item.name not in (".emdash",):
+                    continue
+                if item.name in ("node_modules", "__pycache__", ".git", "dist", "build", ".venv", "venv"):
+                    continue
+                if item.is_dir():
+                    structure_lines.append(f"  {item.name}/")
+                    # Show first level contents
+                    try:
+                        for subitem in sorted(item.iterdir())[:10]:
+                            if not subitem.name.startswith("."):
+                                suffix = "/" if subitem.is_dir() else ""
+                                structure_lines.append(f"    {subitem.name}{suffix}")
+                        if len(list(item.iterdir())) > 10:
+                            structure_lines.append(f"    ...")
+                    except PermissionError:
+                        pass
+                else:
+                    structure_lines.append(f"  {item.name}")
+            context_parts.append("\n".join(structure_lines))
+        except Exception as e:
+            log.debug(f"Could not get directory structure: {e}")
+
+        return "\n\n".join(context_parts) if context_parts else ""
+
     def run(self, prompt: str) -> SubAgentResult:
         """Execute the task and return results.
 
@@ -130,6 +204,19 @@ class InProcessSubAgent:
         last_content = ""
         error = None
 
+        # For Plan agents, inject project context
+        if self.subagent_type == "Plan":
+            context = self._get_project_context()
+            if context:
+                prompt = f"""Here is context about the project:
+
+{context}
+
+---
+
+Now, your task:
+{prompt}"""
+
         # Add user message
         messages.append({"role": "user", "content": prompt})
 
@@ -265,6 +352,7 @@ def run_subagent(
     emitter=None,
     model: Optional[str] = None,
     max_turns: int = 10,
+    thoroughness: str = "medium",
 ) -> SubAgentResult:
     """Run a sub-agent synchronously.
 
@@ -275,18 +363,38 @@ def run_subagent(
         emitter: Event emitter
         model: Model to use
         max_turns: Max iterations
+        thoroughness: Search thoroughness level (quick, medium, thorough)
 
     Returns:
         SubAgentResult
     """
-    agent = InProcessSubAgent(
-        subagent_type=subagent_type,
-        repo_root=repo_root,
-        emitter=emitter,
-        model=model,
-        max_turns=max_turns,
-    )
-    return agent.run(prompt)
+    try:
+        agent = InProcessSubAgent(
+            subagent_type=subagent_type,
+            repo_root=repo_root,
+            emitter=emitter,
+            model=model,
+            max_turns=max_turns,
+            thoroughness=thoroughness,
+        )
+        return agent.run(prompt)
+    except Exception as e:
+        # Return a proper error result instead of letting the exception propagate
+        # This prevents 0.0s "silent" failures and gives clear error messages
+        log.error(f"Failed to create sub-agent: {e}")
+        return SubAgentResult(
+            success=False,
+            agent_type=subagent_type,
+            agent_id="init-failed",
+            task=prompt,
+            summary="",
+            files_explored=[],
+            findings=[],
+            iterations=0,
+            tools_used=[],
+            execution_time=0.0,
+            error=f"Sub-agent initialization failed: {e}",
+        )
 
 
 def run_subagent_async(
@@ -296,6 +404,7 @@ def run_subagent_async(
     emitter=None,
     model: Optional[str] = None,
     max_turns: int = 10,
+    thoroughness: str = "medium",
 ) -> Future[SubAgentResult]:
     """Run a sub-agent asynchronously (returns Future).
 
@@ -306,6 +415,7 @@ def run_subagent_async(
         emitter: Event emitter
         model: Model to use
         max_turns: Max iterations
+        thoroughness: Search thoroughness level (quick, medium, thorough)
 
     Returns:
         Future[SubAgentResult] - call .result() to get result
@@ -319,6 +429,7 @@ def run_subagent_async(
         emitter=emitter,
         model=model,
         max_turns=max_turns,
+        thoroughness=thoroughness,
     )
 
 
@@ -335,6 +446,7 @@ def run_subagents_parallel(
             - prompt: str
             - model: str (optional)
             - max_turns: int (optional)
+            - thoroughness: str (optional, default "medium")
         repo_root: Repository root
         emitter: Shared event emitter
 
@@ -350,6 +462,7 @@ def run_subagents_parallel(
             emitter=emitter,
             model=task.get("model"),
             max_turns=task.get("max_turns", 10),
+            thoroughness=task.get("thoroughness", "medium"),
         )
         futures.append(future)
 

emdash_core/agent/prompts/__init__.py

@@ -15,11 +15,12 @@ from .workflow import (
 )
 from .main_agent import (
     BASE_SYSTEM_PROMPT,
+    CODE_MODE_PROMPT,
+    PLAN_MODE_PROMPT,
     build_system_prompt,
     build_tools_section,
 )
 from .subagents import SUBAGENT_PROMPTS, get_subagent_prompt
-from .plan_mode import PLAN_MODE_PROMPT
 
 __all__ = [
     # Workflow patterns
@@ -33,11 +34,11 @@ __all__ = [
     "PARALLEL_EXECUTION",
     # Main agent
     "BASE_SYSTEM_PROMPT",
+    "CODE_MODE_PROMPT",
+    "PLAN_MODE_PROMPT",
     "build_system_prompt",
     "build_tools_section",
     # Sub-agents
     "SUBAGENT_PROMPTS",
     "get_subagent_prompt",
-    # Plan mode
-    "PLAN_MODE_PROMPT",
 ]

emdash_core/agent/prompts/main_agent.py

@@ -9,13 +9,22 @@ from .workflow import (
     EXPLORATION_STRATEGY,
     OUTPUT_GUIDELINES,
     PARALLEL_EXECUTION,
+    TODO_LIST_GUIDANCE,
 )
 
 # Base system prompt template with placeholder for tools
-BASE_SYSTEM_PROMPT = """You are a code exploration and implementation assistant. You orchestrate focused sub-agents for exploration while maintaining the high-level view.
+_BASE_PROMPT = """You are a code exploration and implementation assistant. You orchestrate focused sub-agents for exploration while maintaining the high-level view.
 
 {tools_section}
-""" + WORKFLOW_PATTERNS + PARALLEL_EXECUTION + EXPLORATION_STRATEGY + OUTPUT_GUIDELINES
+"""
+
+# Main agent system prompt - same for both code and plan modes
+# Main agent is always an orchestrator that delegates to subagents
+BASE_SYSTEM_PROMPT = _BASE_PROMPT + WORKFLOW_PATTERNS + PARALLEL_EXECUTION + EXPLORATION_STRATEGY + TODO_LIST_GUIDANCE + OUTPUT_GUIDELINES
+
+# Legacy aliases
+CODE_MODE_PROMPT = BASE_SYSTEM_PROMPT
+PLAN_MODE_PROMPT = BASE_SYSTEM_PROMPT
 
 
 def build_system_prompt(toolkit) -> str:
@@ -29,8 +38,15 @@ def build_system_prompt(toolkit) -> str:
     """
     tools_section = build_tools_section(toolkit)
     skills_section = build_skills_section()
+    rules_section = build_rules_section()
+
+    # Main agent always uses the same prompt - it orchestrates and delegates
     prompt = BASE_SYSTEM_PROMPT.format(tools_section=tools_section)
 
+    # Add rules section if there are rules defined
+    if rules_section:
+        prompt += "\n" + rules_section
+
     # Add skills section if there are skills available
     if skills_section:
         prompt += "\n" + skills_section
@@ -38,6 +54,20 @@ def build_system_prompt(toolkit) -> str:
     return prompt
 
 
+def build_rules_section() -> str:
+    """Build the rules section of the system prompt.
+
+    Loads rules from .emdash/rules/*.md files.
+
+    Returns:
+        Formatted string with project rules, or empty string if none
+    """
+    from ..rules import load_rules, format_rules_for_prompt
+
+    rules = load_rules()
+    return format_rules_for_prompt(rules)
+
+
 def build_skills_section() -> str:
     """Build the skills section of the system prompt.