claude-task-master 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

claude_task_master/core/plan_updater.py

@@ -0,0 +1,199 @@
+"""Plan Updater - Updates existing plans based on change requests.
+
+This module handles the plan update workflow when a change request is
+received via `claudetm resume "message"` or from the mailbox system.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from .agent_phases import run_async_with_cleanup
+from .prompts_plan_update import build_plan_update_prompt
+
+if TYPE_CHECKING:
+    from .agent import AgentWrapper
+    from .logger import TaskLogger
+    from .state import StateManager
+
+
+class PlanUpdater:
+    """Handles updating existing plans based on change requests.
+
+    This class orchestrates the plan update workflow:
+    1. Load the current plan
+    2. Run Claude with plan update prompt
+    3. Extract and save the updated plan
+    4. Update progress tracking
+    """
+
+    def __init__(
+        self,
+        agent: "AgentWrapper",
+        state_manager: "StateManager",
+        logger: "TaskLogger | None" = None,
+    ):
+        """Initialize the plan updater.
+
+        Args:
+            agent: The agent wrapper for running queries.
+            state_manager: The state manager for loading/saving plans.
+            logger: Optional logger for tracking operations.
+        """
+        self.agent = agent
+        self.state_manager = state_manager
+        self.logger = logger
+
+    def update_plan(self, change_request: str) -> dict[str, Any]:
+        """Update the plan based on a change request.
+
+        This method:
+        1. Loads the current plan from state
+        2. Loads optional goal and context
+        3. Runs Claude to analyze and update the plan
+        4. Saves the updated plan
+        5. Returns the result
+
+        Args:
+            change_request: The change request message describing what to update.
+
+        Returns:
+            Dict with keys:
+            - 'success': bool - whether the update succeeded
+            - 'plan': str - the updated plan content
+            - 'raw_output': str - the raw response from Claude
+            - 'changes_made': bool - whether the plan was actually modified
+
+        Raises:
+            ValueError: If no current plan exists to update.
+        """
+        # Load current plan
+        current_plan = self.state_manager.load_plan()
+        if not current_plan:
+            raise ValueError("No plan exists to update. Use 'start' to create a new plan.")
+
+        # Load optional context
+        goal = self.state_manager.load_goal()
+        context = self.state_manager.load_context()
+
+        # Build the update prompt
+        prompt = build_plan_update_prompt(
+            current_plan=current_plan,
+            change_request=change_request,
+            goal=goal if goal else None,
+            context=context if context else None,
+        )
+
+        if self.logger:
+            self.logger.log_prompt(f"Plan update request: {change_request[:100]}...")
+
+        # Run the query using the agent's planning tools (read-only)
+        result = self._run_plan_update_query(prompt)
+
+        # Extract the updated plan from the result
+        updated_plan = self._extract_updated_plan(result)
+
+        # Check if plan actually changed
+        changes_made = updated_plan.strip() != current_plan.strip()
+
+        # Save the updated plan if changes were made
+        if changes_made:
+            self.state_manager.save_plan(updated_plan)
+            if self.logger:
+                self.logger.log_response("Plan updated and saved")
+        else:
+            if self.logger:
+                self.logger.log_response("No changes needed to plan")
+
+        return {
+            "success": True,
+            "plan": updated_plan,
+            "raw_output": result,
+            "changes_made": changes_made,
+        }
+
+    def _run_plan_update_query(self, prompt: str) -> str:
+        """Run the plan update query using the agent.
+
+        Args:
+            prompt: The complete plan update prompt.
+
+        Returns:
+            The raw response from Claude.
+        """
+        from .agent_models import ModelType
+
+        # Use the agent's query executor directly with planning tools
+        # Always use Opus for plan updates (requires strategic thinking)
+        result = run_async_with_cleanup(
+            self.agent._query_executor.run_query(
+                prompt=prompt,
+                tools=self.agent.get_tools_for_phase("planning"),
+                model_override=ModelType.OPUS,
+                get_model_name_func=self.agent._get_model_name,
+                get_agents_func=None,  # No subagents for plan update
+                process_message_func=self.agent._message_processor.process_message,
+            )
+        )
+
+        return result
+
+    def _extract_updated_plan(self, result: str) -> str:
+        """Extract the updated plan from the Claude response.
+
+        Looks for the plan content between Task List header and the
+        PLAN UPDATE COMPLETE marker.
+
+        Args:
+            result: The raw response from Claude.
+
+        Returns:
+            The extracted plan content.
+        """
+        # Try to find the plan content
+        plan_content = result
+
+        # Remove the PLAN UPDATE COMPLETE marker if present
+        if "PLAN UPDATE COMPLETE" in plan_content:
+            plan_content = plan_content.split("PLAN UPDATE COMPLETE")[0]
+
+        # If response has Task List header, extract from there
+        if "## Task List" in plan_content:
+            # Find the start of the plan
+            start_idx = plan_content.find("## Task List")
+            plan_content = plan_content[start_idx:]
+
+        return plan_content.strip()
+
+    def update_plan_from_messages(self, messages: list[str]) -> dict[str, Any]:
+        """Update the plan from multiple messages (e.g., from mailbox).
+
+        Merges multiple messages into a single change request and updates
+        the plan accordingly.
+
+        Args:
+            messages: List of message strings to process.
+
+        Returns:
+            Dict with update results (same as update_plan).
+
+        Raises:
+            ValueError: If no messages provided or no plan exists.
+        """
+        if not messages:
+            raise ValueError("No messages provided for plan update")
+
+        # Merge messages into a single change request
+        if len(messages) == 1:
+            change_request = messages[0]
+        else:
+            # Format multiple messages with clear separation
+            merged_parts = []
+            for i, msg in enumerate(messages, 1):
+                merged_parts.append(f"### Change Request {i}\n{msg}")
+            change_request = "\n\n".join(merged_parts)
+            change_request = (
+                f"**Multiple change requests received ({len(messages)} total):**\n\n"
+                f"{change_request}\n\n"
+                f"**Please address ALL of these change requests in the plan update.**"
+            )
+
+        return self.update_plan(change_request)

claude_task_master/core/pr_context.py

@@ -41,10 +41,6 @@ class PRContextManager:
         if pr_number is None:
             return
 
-        # Also save comments when saving CI failures (for complete context)
-        if _also_save_comments:
-            self.save_pr_comments(pr_number, _also_save_ci=False)
-
         # Clear old CI logs to avoid stale data
         try:
             pr_dir = self.state_manager.get_pr_dir(pr_number)
@@ -72,9 +68,17 @@ class PRContextManager:
         except Exception as e:
             console.warning(f"Could not save CI failures: {e}")
 
+        # Also save comments when saving CI failures (for complete context)
+        # Do this AFTER saving CI failures to ensure CI files exist first
+        if _also_save_comments:
+            self.save_pr_comments(pr_number, _also_save_ci=False)
+
     def save_pr_comments(self, pr_number: int | None, *, _also_save_ci: bool = True) -> int:
         """Fetch and save PR comments to files for Claude to read.
 
+        Uses REST API to get all comments (like tstc), then enriches with
+        resolved status from GraphQL.
+
         Args:
             pr_number: The PR number.
             _also_save_ci: Internal flag to also save CI failures (prevents recursion).
@@ -111,33 +115,97 @@ class PRContextManager:
                 text=True,
             )
             repo_info = result.stdout.strip()
-            owner, repo = repo_info.split("/")
 
-            # GraphQL query to get structured comments with thread IDs
-            query = """
-            query($owner: String!, $repo: String!, $pr: Int!) {
-              repository(owner: $owner, name: $repo) {
-                pullRequest(number: $pr) {
-                  reviewThreads(first: 100) {
+            # Use REST API to get ALL PR review comments (like tstc)
+            result = subprocess.run(
+                ["gh", "api", "--paginate", f"repos/{repo_info}/pulls/{pr_number}/comments"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            all_comments = json.loads(result.stdout)
+
+            # Get resolved status from GraphQL
+            resolved_map = self._get_resolved_status_map(repo_info, pr_number)
+
+            # Get already-addressed comment IDs to skip them
+            addressed_threads = self.state_manager.get_addressed_threads(pr_number)
+
+            # Convert to list of comment dicts - filter unresolved, actionable
+            comments = []
+            for comment in all_comments:
+                comment_id = comment.get("id")
+                # Check if this comment's thread is resolved
+                is_resolved = resolved_map.get(comment_id, False)
+                if is_resolved:
+                    continue  # Skip resolved comments
+
+                # Get thread ID for this comment (for tracking addressed threads)
+                thread_id = self._get_thread_id_for_comment(comment_id, resolved_map)
+
+                # Skip threads we've already addressed (replied to)
+                if thread_id and thread_id in addressed_threads:
+                    continue
+
+                body = comment.get("body", "")
+                author = comment.get("user", {}).get("login", "unknown")
+
+                # Skip non-actionable bot comments
+                if self._is_non_actionable_comment(author, body):
+                    continue
+
+                comments.append(
+                    {
+                        "thread_id": thread_id or f"comment_{comment_id}",
+                        "comment_id": str(comment_id),
+                        "author": author,
+                        "body": body,
+                        "path": comment.get("path"),
+                        "line": comment.get("line") or comment.get("original_line"),
+                        "is_resolved": False,
+                    }
+                )
+
+            # Save to files
+            self.state_manager.save_pr_comments(pr_number, comments)
+            return len(comments)
+
+        except Exception as e:
+            console.warning(f"Could not save PR comments: {e}")
+            return 0
+
+    def _get_resolved_status_map(self, repo_info: str, pr_number: int) -> dict[int, bool]:
+        """Get resolved status for all comments from GraphQL.
+
+        Returns a map of comment_id -> is_resolved.
+        Also stores thread_id for each comment for later lookup.
+        """
+        owner, repo = repo_info.split("/")
+
+        # Store thread info: comment_id -> (is_resolved, thread_id)
+        self._thread_info: dict[int, tuple[bool, str]] = {}
+
+        query = """
+        query($owner: String!, $repo: String!, $pr: Int!) {
+          repository(owner: $owner, name: $repo) {
+            pullRequest(number: $pr) {
+              reviewThreads(first: 100) {
+                nodes {
+                  id
+                  isResolved
+                  comments(first: 100) {
                     nodes {
-                      id
-                      isResolved
-                      comments(first: 10) {
-                        nodes {
-                          id
-                          author { login }
-                          body
-                          path
-                          line
-                        }
-                      }
+                      databaseId
                     }
                   }
                 }
               }
             }
-            """
+          }
+        }
+        """
 
+        try:
             result = subprocess.run(
                 [
                     "gh",
@@ -160,47 +228,26 @@ class PRContextManager:
             data = json.loads(result.stdout)
             threads = data["data"]["repository"]["pullRequest"]["reviewThreads"]["nodes"]
 
-            # Get already-addressed thread IDs to skip them
-            addressed_threads = self.state_manager.get_addressed_threads(pr_number)
-
-            # Convert to list of comment dicts - ONLY unresolved, actionable threads
-            comments = []
+            resolved_map: dict[int, bool] = {}
             for thread in threads:
-                if thread["isResolved"]:
-                    continue  # Skip resolved threads
-                thread_id = thread.get("id")
-
-                # Skip threads we've already addressed (replied to)
-                if thread_id in addressed_threads:
-                    continue
-
-                for comment in thread["comments"]["nodes"]:
-                    body = comment["body"]
-                    author = comment["author"]["login"] if comment.get("author") else "unknown"
-
-                    # Skip non-actionable bot comments
-                    if self._is_non_actionable_comment(author, body):
-                        continue
-
-                    comments.append(
-                        {
-                            "thread_id": thread_id,
-                            "comment_id": comment.get("id"),
-                            "author": author,
-                            "body": body,
-                            "path": comment.get("path"),
-                            "line": comment.get("line"),
-                            "is_resolved": False,
-                        }
-                    )
+                thread_id = thread.get("id", "")
+                is_resolved = thread.get("isResolved", False)
+                for comment in thread.get("comments", {}).get("nodes", []):
+                    db_id = comment.get("databaseId")
+                    if db_id:
+                        resolved_map[db_id] = is_resolved
+                        self._thread_info[db_id] = (is_resolved, thread_id)
+
+            return resolved_map
+        except Exception:
+            return {}
 
-            # Save to files
-            self.state_manager.save_pr_comments(pr_number, comments)
-            return len(comments)
-
-        except Exception as e:
-            console.warning(f"Could not save PR comments: {e}")
-            return 0
+    def _get_thread_id_for_comment(
+        self, comment_id: int, resolved_map: dict[int, bool]
+    ) -> str | None:
+        """Get the thread ID for a comment."""
+        info = getattr(self, "_thread_info", {}).get(comment_id)
+        return info[1] if info else None
 
     def post_comment_replies(self, pr_number: int | None) -> None:
         """Post replies to comments based on resolve-comments.json.
@@ -454,3 +501,70 @@ class PRContextManager:
                 return True
 
         return False
+
+    def has_pr_comments(self, pr_number: int | None) -> bool:
+        """Check if there are unresolved PR comments saved.
+
+        Args:
+            pr_number: The PR number.
+
+        Returns:
+            True if there are saved comment files.
+        """
+        if pr_number is None:
+            return False
+
+        try:
+            pr_dir = self.state_manager.get_pr_dir(pr_number)
+            comments_dir = pr_dir / "comments"
+            if not comments_dir.exists():
+                return False
+            comment_files = list(comments_dir.glob("*.txt"))
+            return len(comment_files) > 0
+        except Exception:
+            return False
+
+    def has_ci_failures(self, pr_number: int | None) -> bool:
+        """Check if there are CI failure logs saved.
+
+        Args:
+            pr_number: The PR number.
+
+        Returns:
+            True if there are saved CI failure files.
+        """
+        if pr_number is None:
+            return False
+
+        try:
+            pr_dir = self.state_manager.get_pr_dir(pr_number)
+            ci_dir = pr_dir / "ci"
+            if not ci_dir.exists():
+                return False
+            ci_files = list(ci_dir.glob("*.txt"))
+            return len(ci_files) > 0
+        except Exception:
+            return False
+
+    def get_combined_feedback(self, pr_number: int | None) -> tuple[bool, bool, str]:
+        """Get combined feedback context for CI failures and PR comments.
+
+        This method checks both CI failures and PR comments, returning information
+        about what types of feedback are present and paths to find them.
+
+        Args:
+            pr_number: The PR number.
+
+        Returns:
+            Tuple of (has_ci_failures, has_comments, pr_dir_path).
+        """
+        if pr_number is None:
+            return (False, False, "")
+
+        pr_dir = self.state_manager.get_pr_dir(pr_number)
+        pr_dir_path = str(pr_dir)
+
+        has_ci = self.has_ci_failures(pr_number)
+        has_comments = self.has_pr_comments(pr_number)
+
+        return (has_ci, has_comments, pr_dir_path)

claude_task_master/core/prompts.py

@@ -2,6 +2,7 @@
 
 This module provides structured prompt templates for different agent phases:
 - Planning: Initial codebase analysis and task creation
+- Plan Update: Modifying existing plans based on change requests
 - Working: Task execution with verification
 - PR Review: Addressing code review feedback
 - Verification: Confirming success criteria
@@ -12,6 +13,7 @@ This module re-exports all prompt functions for backward compatibility.
 The actual implementations are in:
 - prompts_base.py: PromptSection, PromptBuilder
 - prompts_planning.py: build_planning_prompt
+- prompts_plan_update.py: build_plan_update_prompt
 - prompts_working.py: build_work_prompt
 - prompts_verification.py: build_verification_prompt, build_task_completion_check_prompt,
                            build_context_extraction_prompt, build_error_recovery_prompt
@@ -23,6 +25,7 @@ from __future__ import annotations
 from .prompts_base import PromptBuilder, PromptSection
 
 # Re-export planning prompts
+from .prompts_plan_update import build_plan_update_prompt
 from .prompts_planning import build_planning_prompt
 
 # Re-export verification prompts
@@ -42,6 +45,7 @@ __all__ = [
     "PromptBuilder",
     # Planning
     "build_planning_prompt",
+    "build_plan_update_prompt",
     # Working
     "build_work_prompt",
     # Verification and utilities

claude_task_master/core/prompts_plan_update.py

@@ -0,0 +1,148 @@
+"""Plan Update Prompts for Claude Task Master.
+
+This module contains prompts for updating an existing plan when
+a change request is received (via `claudetm resume "message"` or mailbox).
+"""
+
+from __future__ import annotations
+
+from .prompts_base import PromptBuilder
+
+
+def build_plan_update_prompt(
+    current_plan: str,
+    change_request: str,
+    goal: str | None = None,
+    context: str | None = None,
+) -> str:
+    """Build the plan update prompt.
+
+    Args:
+        current_plan: The current plan markdown content.
+        change_request: The change request/message from the user.
+        goal: Optional original goal for context.
+        context: Optional accumulated context from previous sessions.
+
+    Returns:
+        Complete plan update prompt.
+    """
+    builder = PromptBuilder(
+        intro=f"""You are Claude Task Master in PLAN UPDATE MODE.
+
+A change request has been received that may require updating the existing plan.
+
+**Change Request:** {change_request}
+
+Your mission: **Analyze the change request and update the plan accordingly.**
+
+## TOOL RESTRICTIONS (MANDATORY)
+
+**ALLOWED TOOLS (use ONLY these):**
+- `Read` - Read files to understand the codebase
+- `Glob` - Find files by pattern
+- `Grep` - Search for code patterns
+- `Bash` - Run commands (git status, tests, lint checks, etc.)
+
+**FORBIDDEN TOOLS (NEVER use during plan update):**
+- `Write` - Do NOT write any files
+- `Edit` - Do NOT edit any files
+- `Task` - Do NOT launch any agents
+- `TodoWrite` - Do NOT use todo tracking
+- `WebFetch` - Do NOT fetch web pages
+- `WebSearch` - Do NOT search the web
+
+**WHY**: The orchestrator will save your updated plan to `plan.md` automatically.
+You just need to OUTPUT the updated plan as TEXT in your response."""
+    )
+
+    # Original goal if available
+    if goal:
+        builder.add_section("Original Goal", goal)
+
+    # Current plan section
+    builder.add_section(
+        "Current Plan",
+        f"""Here is the current plan that may need updating:
+
+```markdown
+{current_plan}
+```
+
+**IMPORTANT:** Tasks marked with `[x]` are already completed and should NOT be removed or unchecked.
+""",
+    )
+
+    # Context section if available
+    if context:
+        builder.add_section("Previous Context", context.strip())
+
+    # Instructions for updating
+    builder.add_section(
+        "Update Instructions",
+        """Analyze the change request and determine what updates are needed:
+
+1. **Understand the Change**: What is being requested? Is it:
+   - Adding new tasks/features?
+   - Modifying existing tasks?
+   - Removing/deprioritizing tasks?
+   - Changing the approach/architecture?
+   - Fixing a bug or issue?
+
+2. **Preserve Completed Work**:
+   - Keep all `[x]` (completed) tasks as-is
+   - Do NOT uncheck completed tasks
+   - Do NOT remove completed tasks unless explicitly requested
+
+3. **Update Uncompleted Tasks**:
+   - Modify `[ ]` tasks if the approach needs to change
+   - Add new `[ ]` tasks if new requirements are introduced
+   - Remove or mark as obsolete tasks that are no longer needed
+
+4. **Maintain PR Structure**:
+   - Keep the PR grouping structure (### PR N: Title)
+   - Add new PRs if needed for new features
+   - Reorder tasks within PRs if dependencies change
+
+5. **Use Proper Format**:
+   - Keep complexity tags: `[coding]`, `[quick]`, `[general]`
+   - Include file paths and symbols in task descriptions
+   - Maintain the success criteria section""",
+    )
+
+    # Output format
+    builder.add_section(
+        "Output Format",
+        """After analyzing the change request, OUTPUT the complete updated plan.
+
+**CRITICAL:**
+- Start your updated plan with `## Task List`
+- Include ALL tasks (both completed and uncompleted)
+- Keep the same markdown checkbox format
+- End with `## Success Criteria` section
+- Do NOT use Write tool - just OUTPUT the plan as text
+
+**Example structure:**
+```markdown
+## Task List
+
+### PR 1: Infrastructure
+- [x] `[quick]` Setup project structure (COMPLETED - keep as-is)
+- [ ] `[coding]` Add new feature from change request
+
+### PR 2: New Requirements (from change request)
+- [ ] `[coding]` Implement new requirement A
+- [ ] `[general]` Add tests for new requirements
+
+## Success Criteria
+1. All tasks completed
+2. Tests pass
+3. ...
+```
+
+End your response with:
+```
+PLAN UPDATE COMPLETE
+```""",
+    )
+
+    return builder.build()

claude_task_master/core/prompts_planning.py

@@ -36,14 +36,18 @@ testing strategy, and how all pieces fit together. Plan for success.
 - `Glob` - Find files by pattern
 - `Grep` - Search for code patterns
 - `Bash` - Run commands (git status, tests, lint checks, etc.)
+- `WebSearch` - Search the web for current information (use FIRST to find URLs)
+- `WebFetch` - Fetch full content from URLs (only URLs from search results or user-provided)
+
+**Web Research Workflow:** Use `WebSearch` first to find relevant documentation/articles,
+then use `WebFetch` to retrieve full content from specific URLs in the search results.
+WebFetch can also retrieve PDFs for technical documentation.
 
 **FORBIDDEN TOOLS (NEVER use during planning):**
 - ❌ `Write` - Do NOT write any files
 - ❌ `Edit` - Do NOT edit any files
 - ❌ `Task` - Do NOT launch any agents
 - ❌ `TodoWrite` - Do NOT use todo tracking
-- ❌ `WebFetch` - Do NOT fetch web pages
-- ❌ `WebSearch` - Do NOT search the web
 
 **WHY**: The orchestrator will save your plan to `plan.md` automatically.
 You just need to OUTPUT the plan as TEXT in your response.