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

emdash_core/agent/tools/spec.py

@@ -77,23 +77,41 @@ Creates a structured spec document with requirements and acceptance criteria."""
             ToolResult with spec info
         """
         try:
-            spec = Spec(
-                title=title,
-                summary=summary,
-                requirements=requirements,
-                acceptance_criteria=acceptance_criteria,
-                technical_notes=technical_notes or [],
-                dependencies=dependencies or [],
-                open_questions=open_questions or [],
-            )
+            # Build markdown content from structured fields
+            content_parts = []
+
+            if summary:
+                content_parts.append(f"> {summary}\n")
+
+            if requirements:
+                content_parts.append("## Requirements")
+                content_parts.extend(f"- {req}" for req in requirements)
+                content_parts.append("")
+
+            if acceptance_criteria:
+                content_parts.append("## Acceptance Criteria")
+                content_parts.extend(f"- {crit}" for crit in acceptance_criteria)
+                content_parts.append("")
+
+            if technical_notes:
+                content_parts.append("## Technical Notes")
+                content_parts.extend(f"- {note}" for note in technical_notes)
+                content_parts.append("")
+
+            if dependencies:
+                content_parts.append("## Dependencies")
+                content_parts.extend(f"- {dep}" for dep in dependencies)
+                content_parts.append("")
+
+            if open_questions:
+                content_parts.append("## Open Questions")
+                content_parts.extend(f"- {q}" for q in open_questions)
+                content_parts.append("")
 
-            # Validate
-            errors = spec.validate()
-            if errors:
-                return ToolResult.error_result(
-                    f"Spec validation failed: {', '.join(errors)}",
-                    suggestions=["Ensure all required fields are provided"],
-                )
+            content = "\n".join(content_parts)
+
+            # Create spec with title and content only (matches Spec schema)
+            spec = Spec(title=title, content=content)
 
             # Store in state
             state = SpecState.get_instance()
@@ -195,14 +213,8 @@ Returns the spec in markdown format."""
         return ToolResult.success_result(
             data={
                 "title": spec.title,
-                "summary": spec.summary,
-                "requirements": spec.requirements,
-                "acceptance_criteria": spec.acceptance_criteria,
-                "technical_notes": spec.technical_notes,
-                "dependencies": spec.dependencies,
-                "open_questions": spec.open_questions,
+                "content": spec.content,
                 "markdown": spec.to_markdown(),
-                "is_complete": spec.is_complete(),
             },
         )
 
@@ -216,7 +228,7 @@ class UpdateSpecTool(BaseTool):
 
     name = "update_spec"
     description = """Update the current feature specification.
-Add or modify requirements, criteria, or other fields."""
+Append content or replace the entire spec content."""
     category = ToolCategory.PLANNING
 
     def __init__(self, connection=None):
@@ -225,24 +237,17 @@ Add or modify requirements, criteria, or other fields."""
 
     def execute(
         self,
-        add_requirements: Optional[list[str]] = None,
-        add_acceptance_criteria: Optional[list[str]] = None,
-        add_technical_notes: Optional[list[str]] = None,
-        add_dependencies: Optional[list[str]] = None,
-        add_open_questions: Optional[list[str]] = None,
-        resolve_questions: Optional[list[str]] = None,
-        update_summary: Optional[str] = None,
+        append_content: Optional[str] = None,
+        replace_content: Optional[str] = None,
+        update_title: Optional[str] = None,
+        **kwargs,
     ) -> ToolResult:
         """Update the current spec.
 
         Args:
-            add_requirements: Requirements to add
-            add_acceptance_criteria: Criteria to add
-            add_technical_notes: Notes to add
-            add_dependencies: Dependencies to add
-            add_open_questions: Questions to add
-            resolve_questions: Questions to mark as resolved
-            update_summary: New summary text
+            append_content: Content to append to existing spec
+            replace_content: Content to replace entire spec content
+            update_title: New title for the spec
 
         Returns:
             ToolResult with updated spec
@@ -257,28 +262,15 @@ Add or modify requirements, criteria, or other fields."""
 
         spec = state.current_spec
 
-        # Add new items
-        if add_requirements:
-            spec.requirements.extend(add_requirements)
-        if add_acceptance_criteria:
-            spec.acceptance_criteria.extend(add_acceptance_criteria)
-        if add_technical_notes:
-            spec.technical_notes.extend(add_technical_notes)
-        if add_dependencies:
-            spec.dependencies.extend(add_dependencies)
-        if add_open_questions:
-            spec.open_questions.extend(add_open_questions)
-
-        # Resolve questions
-        if resolve_questions:
-            spec.open_questions = [
-                q for q in spec.open_questions
-                if q not in resolve_questions
-            ]
-
-        # Update summary
-        if update_summary:
-            spec.summary = update_summary
+        # Update title if provided
+        if update_title:
+            spec.title = update_title
+
+        # Replace or append content
+        if replace_content is not None:
+            spec.content = replace_content
+        elif append_content:
+            spec.content = spec.content + "\n\n" + append_content
 
         # Save if configured
         if state.save_path:
@@ -290,10 +282,7 @@ Add or modify requirements, criteria, or other fields."""
         return ToolResult.success_result(
             data={
                 "title": spec.title,
-                "requirements_count": len(spec.requirements),
-                "acceptance_criteria_count": len(spec.acceptance_criteria),
-                "open_questions_count": len(spec.open_questions),
-                "is_complete": spec.is_complete(),
+                "content": spec.content,
                 "markdown": spec.to_markdown(),
             },
         )
@@ -302,39 +291,17 @@ Add or modify requirements, criteria, or other fields."""
         """Get OpenAI function schema."""
         return self._make_schema(
             properties={
-                "add_requirements": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Requirements to add",
-                },
-                "add_acceptance_criteria": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Acceptance criteria to add",
-                },
-                "add_technical_notes": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Technical notes to add",
-                },
-                "add_dependencies": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Dependencies to add",
-                },
-                "add_open_questions": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Open questions to add",
+                "append_content": {
+                    "type": "string",
+                    "description": "Markdown content to append to existing spec",
                 },
-                "resolve_questions": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Questions to mark as resolved",
+                "replace_content": {
+                    "type": "string",
+                    "description": "Markdown content to replace entire spec content",
                 },
-                "update_summary": {
+                "update_title": {
                     "type": "string",
-                    "description": "New summary text",
+                    "description": "New title for the spec",
                 },
             },
             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
@@ -92,6 +94,11 @@ Multiple sub-agents can be launched in parallel."""
                 suggestions=[f"Available types: {available_types}"],
             )
 
+        # 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 +106,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 +133,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 +145,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 +179,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 +187,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 +207,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)
@@ -257,6 +290,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"],
         )

emdash_core/agent/tools/tasks.py

@@ -1,6 +1,6 @@
 """Task management tools for agent workflows."""
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
 
@@ -23,9 +23,6 @@ class Task:
     title: str
     description: str = ""
     status: TaskStatus = TaskStatus.PENDING
-    complexity: str = "M"  # T-shirt size: S, M, L, XL
-    files: list[str] = field(default_factory=list)  # Target files for this task
-    checklist: list[dict] = field(default_factory=list)  # Subtasks: [{text, done}]
 
     def to_dict(self) -> dict:
         return {
@@ -33,9 +30,6 @@ class Task:
             "title": self.title,
             "description": self.description,
             "status": self.status.value,
-            "complexity": self.complexity,
-            "files": self.files,
-            "checklist": self.checklist,
         }
 
 
@@ -68,26 +62,17 @@ class TaskState:
         self,
         title: str,
         description: str = "",
-        complexity: str = "M",
-        files: list[str] = None,
-        checklist: list[str] = None,
     ) -> Task:
         """Add a new task.
 
         Args:
             title: Task title
             description: Detailed description
-            complexity: T-shirt size (S, M, L, XL)
-            files: List of target file paths
-            checklist: List of subtask strings (converted to {text, done} dicts)
         """
         task = Task(
             id=str(self._next_id),
             title=title,
             description=description,
-            complexity=complexity,
-            files=files or [],
-            checklist=[{"text": item, "done": False} for item in (checklist or [])],
         )
         self._next_id += 1
         self.tasks.append(task)
@@ -139,18 +124,15 @@ class TaskManagementTool(BaseTool):
 
 
 class WriteTodoTool(TaskManagementTool):
-    """Create a new sub-task for complex work breakdown."""
+    """Create a new task for tracking work."""
 
     name = "write_todo"
-    description = "Create a new task with target files and checklist items. Use reset=true to clear all existing tasks first."
+    description = "Create a new task. Use reset=true to clear all existing tasks first."
 
     def execute(
         self,
         title: str,
         description: str = "",
-        complexity: str = "M",
-        files: list[str] = None,
-        checklist: list[str] = None,
         reset: bool = False,
         **kwargs,
     ) -> ToolResult:
@@ -159,9 +141,6 @@ class WriteTodoTool(TaskManagementTool):
         Args:
             title: Short task title
             description: Detailed description (optional)
-            complexity: T-shirt size (S, M, L, XL)
-            files: Target file paths this task will modify
-            checklist: List of subtask items to track
             reset: If true, clear all existing tasks before adding this one
 
         Returns:
@@ -177,9 +156,6 @@ class WriteTodoTool(TaskManagementTool):
         task = self.state.add_task(
             title=title.strip(),
             description=description.strip() if description else "",
-            complexity=complexity,
-            files=files or [],
-            checklist=checklist or [],
         )
 
         return ToolResult.success_result({
@@ -201,21 +177,6 @@ class WriteTodoTool(TaskManagementTool):
                     "type": "string",
                     "description": "Detailed description of what needs to be done",
                 },
-                "complexity": {
-                    "type": "string",
-                    "enum": ["S", "M", "L", "XL"],
-                    "description": "T-shirt size complexity: S (trivial), M (moderate), L (significant), XL (complex)",
-                },
-                "files": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Target file paths this task will modify",
-                },
-                "checklist": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "List of subtask items to track (e.g., ['Add imports', 'Update function', 'Add tests'])",
-                },
                 "reset": {
                     "type": "boolean",
                     "description": "Set to true to clear all existing tasks before adding this one",
@@ -227,39 +188,30 @@ class WriteTodoTool(TaskManagementTool):
 
 
 class UpdateTodoListTool(TaskManagementTool):
-    """Update task status or checklist items."""
+    """Update task status."""
 
     name = "update_todo_list"
-    description = "Update task status, mark checklist items done, or add files. Auto-creates tasks if they don't exist."
+    description = "Update task status. Auto-creates tasks if they don't exist."
 
     def execute(
         self,
         task_id: str,
         status: str = None,
-        checklist_done: list[int] = None,
-        checklist: list[int] = None,  # Alias for checklist_done
-        files: list[str] = None,
         title: str = "",
         description: str = "",
         **kwargs,  # Ignore unexpected params from LLM
     ) -> ToolResult:
-        """Update task status or checklist items.
+        """Update task status.
 
         Args:
             task_id: Task ID to update (e.g., "1", "2")
             status: New status (pending, in_progress, completed)
-            checklist_done: Indices of checklist items to mark done (0-based)
-            checklist: Alias for checklist_done
-            files: Additional files to add to the task
             title: Optional title for auto-created tasks
             description: Optional description for auto-created tasks
 
         Returns:
             ToolResult with updated task list
         """
-        # Handle checklist alias
-        if checklist and not checklist_done:
-            checklist_done = checklist
         task = self.state.get_task(task_id)
 
         # Auto-create task if not found
@@ -276,7 +228,6 @@ class UpdateTodoListTool(TaskManagementTool):
                 title=title or f"Task {task_id}",
                 status=new_status,
                 description=description,
-                files=files or [],
             )
             self.state.tasks.append(task)
             return ToolResult.success_result({
@@ -295,18 +246,6 @@ class UpdateTodoListTool(TaskManagementTool):
                     f"Invalid status: {status}. Use: pending, in_progress, completed"
                 )
 
-        # Mark checklist items as done
-        if checklist_done:
-            for idx in checklist_done:
-                if 0 <= idx < len(task.checklist):
-                    task.checklist[idx]["done"] = True
-
-        # Add files
-        if files:
-            for f in files:
-                if f not in task.files:
-                    task.files.append(f)
-
         return ToolResult.success_result({
             "task_id": task_id,
             "task": task.to_dict(),
@@ -326,16 +265,6 @@ class UpdateTodoListTool(TaskManagementTool):
                     "enum": ["pending", "in_progress", "completed"],
                     "description": "New status for the task",
                 },
-                "checklist_done": {
-                    "type": "array",
-                    "items": {"type": "integer"},
-                    "description": "Indices of checklist items to mark done (0-based)",
-                },
-                "files": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Additional file paths to add to the task",
-                },
                 "title": {
                     "type": "string",
                     "description": "Task title (used if auto-creating)",
@@ -353,7 +282,13 @@ class AskFollowupQuestionTool(TaskManagementTool):
     """Request clarification from the user."""
 
     name = "ask_followup_question"
-    description = "Ask the user a clarifying question. Use this when you need more information to proceed."
+    description = """Ask the user a clarifying question when you need more information to proceed.
+
+CRITICAL CONSTRAINTS:
+- Only ask ONE question at a time - never call this tool multiple times in parallel
+- Only ask AFTER doing research first (read files, search code, explore the codebase)
+- Questions should be informed by what you've learned, not generic upfront questionnaires
+- If you need multiple pieces of information, ask the most important one first"""
 
     def execute(
         self,
@@ -452,3 +387,5 @@ class AttemptCompletionTool(TaskManagementTool):
             },
             required=["summary"],
         )
+
+