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

emdash_core/agent/inprocess_subagent.py

@@ -16,6 +16,12 @@ from .toolkits import get_toolkit
 from .subagent_prompts import get_subagent_prompt
 from .providers import get_provider
 from .providers.factory import DEFAULT_MODEL
+from .context_manager import (
+    truncate_tool_output,
+    reduce_context_for_retry,
+    is_context_overflow_error,
+)
+from .runner.context import estimate_context_tokens
 from ..utils.logger import log
 
 
@@ -62,6 +68,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 +79,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 +95,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, repo_root=repo_root)
+        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 +151,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 +210,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})
 
@@ -147,12 +240,39 @@ class InProcessSubAgent:
 
                 log.debug(f"SubAgent {self.agent_id} turn {iterations}/{self.max_turns}")
 
-                # Call LLM
-                response = self.provider.chat(
-                    messages=messages,
-                    tools=self.toolkit.get_all_schemas(),
-                    system=self.system_prompt,
-                )
+                # Check context size and compact if needed
+                context_tokens = estimate_context_tokens(messages, self.system_prompt)
+                context_limit = self.provider.get_context_limit()
+
+                if context_tokens > context_limit * 0.8:
+                    log.info(
+                        f"SubAgent {self.agent_id} context at {context_tokens:,}/{context_limit:,} "
+                        f"({context_tokens/context_limit:.0%}), reducing..."
+                    )
+                    messages = reduce_context_for_retry(messages, keep_recent=6)
+
+                # Call LLM with retry on context overflow
+                response = None
+                max_retries = 2
+                for retry in range(max_retries + 1):
+                    try:
+                        response = self.provider.chat(
+                            messages=messages,
+                            tools=self.toolkit.get_all_schemas(),
+                            system=self.system_prompt,
+                        )
+                        break  # Success
+                    except Exception as e:
+                        if is_context_overflow_error(e) and retry < max_retries:
+                            log.warning(
+                                f"SubAgent {self.agent_id} context overflow on attempt {retry + 1}, reducing..."
+                            )
+                            messages = reduce_context_for_retry(messages, keep_recent=4 - retry)
+                        else:
+                            raise  # Re-raise if not overflow or out of retries
+
+                if response is None:
+                    raise RuntimeError("Failed to get response from LLM")
 
                 # Add assistant response
                 assistant_msg = self.provider.format_assistant_message(response)
@@ -196,10 +316,12 @@ class InProcessSubAgent:
                         summary=summary,
                     )
 
-                    # Add tool result to messages
+                    # Add tool result to messages (truncated to avoid context overflow)
+                    tool_output = json.dumps(result.to_dict(), indent=2)
+                    tool_output = truncate_tool_output(tool_output, max_tokens=15000)
                     tool_result_msg = self.provider.format_tool_result(
                         tool_call.id,
-                        json.dumps(result.to_dict(), indent=2),
+                        tool_output,
                     )
                     if tool_result_msg:
                         messages.append(tool_result_msg)
@@ -265,6 +387,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 +398,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 +439,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 +450,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 +464,7 @@ def run_subagent_async(
         emitter=emitter,
         model=model,
         max_turns=max_turns,
+        thoroughness=thoroughness,
     )
 
 
@@ -335,6 +481,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 +497,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:
@@ -28,9 +37,21 @@ def build_system_prompt(toolkit) -> str:
         Complete system prompt string
     """
     tools_section = build_tools_section(toolkit)
+    agents_section = build_agents_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 agents section so main agent knows what agents are available
+    if agents_section:
+        prompt += "\n" + agents_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 +59,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.
 
@@ -50,6 +85,36 @@ def build_skills_section() -> str:
     return registry.get_skills_for_prompt()
 
 
+def build_agents_section(toolkit) -> str:
+    """Build the agents section describing available sub-agents.
+
+    Args:
+        toolkit: The agent toolkit (to access repo_root)
+
+    Returns:
+        Formatted string with agent descriptions, or empty string if none
+    """
+    from ..toolkits import get_agents_with_descriptions
+
+    repo_root = getattr(toolkit, '_repo_root', None)
+    agents = get_agents_with_descriptions(repo_root)
+
+    if not agents:
+        return ""
+
+    lines = [
+        "## Available Agents",
+        "",
+        "Use the `task` tool to delegate work to these specialized agents:",
+        "",
+    ]
+
+    for agent in agents:
+        lines.append(f"- **{agent['name']}**: {agent['description']}")
+
+    return "\n".join(lines)
+
+
 def build_tools_section(toolkit) -> str:
     """Build the tools section of the system prompt from registered tools.