claude-task-master 0.1.6__tar.gz → 0.1.8__tar.gz

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-task-master
-Version: 0.1.6
+Version: 0.1.8
 Summary: Autonomous task orchestration system that keeps Claude working until a goal is achieved
 Author: Claude Task Master Team
 License-Expression: MIT

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-task-master"
-version = "0.1.6"
+version = "0.1.8"
 description = "Autonomous task orchestration system that keeps Claude working until a goal is achieved"
 readme = "README.md"
 requires-python = ">=3.12"

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/__init__.py

@@ -3,5 +3,5 @@
 Uses Claude Agent SDK to keep Claude working until a goal is achieved.
 """
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"
 __all__ = ["__version__"]

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/core/agent.py

@@ -170,15 +170,35 @@ class AgentWrapper:
                 ValueError("query must be callable"),
             )
 
-    def run_planning_phase(self, goal: str, context: str = "") -> dict[str, Any]:
+    def run_planning_phase(
+        self, goal: str, context: str = "", coding_style: str | None = None
+    ) -> dict[str, Any]:
         """Run planning phase with read-only tools.
 
         Always uses Opus (smartest model) for planning to ensure
         high-quality task breakdown and complexity classification.
 
+        Args:
+            goal: The goal to plan for.
+            context: Additional context for planning.
+            coding_style: Optional coding style guide to inject into prompt.
+
+        Delegates to AgentPhaseExecutor for implementation.
+        """
+        return self._phase_executor.run_planning_phase(goal, context, coding_style)
+
+    def generate_coding_style(self) -> dict[str, Any]:
+        """Generate a coding style guide by analyzing the codebase.
+
+        Analyzes CLAUDE.md, convention files, and codebase to create a
+        concise coding style guide with workflow and conventions.
+
+        Returns:
+            Dict with 'coding_style' and 'raw_output' keys.
+
         Delegates to AgentPhaseExecutor for implementation.
         """
-        return self._phase_executor.run_planning_phase(goal, context)
+        return self._phase_executor.generate_coding_style()
 
     def run_work_session(
         self,
@@ -189,6 +209,8 @@ class AgentWrapper:
         required_branch: str | None = None,
         create_pr: bool = True,
         pr_group_info: dict | None = None,
+        target_branch: str = "main",
+        coding_style: str | None = None,
     ) -> dict[str, Any]:
         """Run a work session with full tools.
 
@@ -201,6 +223,8 @@ class AgentWrapper:
             required_branch: Optional branch name the agent should be on.
             create_pr: If True, instruct agent to create PR. If False, commit only.
             pr_group_info: Optional dict with PR group context (name, completed_tasks, etc).
+            target_branch: The target branch for rebasing (default: "main").
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'output', 'success', and 'model_used' keys.
@@ -215,6 +239,8 @@ class AgentWrapper:
             required_branch=required_branch,
             create_pr=create_pr,
             pr_group_info=pr_group_info,
+            target_branch=target_branch,
+            coding_style=coding_style,
         )
 
     def verify_success_criteria(self, criteria: str, context: str = "") -> dict[str, Any]:

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/core/agent_phases.py

@@ -13,7 +13,13 @@ from typing import TYPE_CHECKING, Any, TypeVar
 
 from . import console
 from .agent_models import ModelType, get_tools_for_phase
-from .prompts import build_planning_prompt, build_verification_prompt, build_work_prompt
+from .prompts import (
+    build_coding_style_prompt,
+    build_planning_prompt,
+    build_verification_prompt,
+    build_work_prompt,
+    extract_coding_style,
+)
 
 if TYPE_CHECKING:
     from .agent_query import AgentQueryExecutor
@@ -104,7 +110,9 @@ class AgentPhaseExecutor:
         self.get_agents_func = get_agents_func
         self.process_message_func = process_message_func
 
-    def run_planning_phase(self, goal: str, context: str = "") -> dict[str, Any]:
+    def run_planning_phase(
+        self, goal: str, context: str = "", coding_style: str | None = None
+    ) -> dict[str, Any]:
         """Run planning phase with read-only tools.
 
         Always uses Opus (smartest model) for planning to ensure
@@ -113,12 +121,17 @@ class AgentPhaseExecutor:
         Args:
             goal: The goal to plan for.
             context: Additional context for planning.
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'plan', 'criteria', and 'raw_output' keys.
         """
         # Build prompt for planning
-        prompt = build_planning_prompt(goal=goal, context=context if context else None)
+        prompt = build_planning_prompt(
+            goal=goal,
+            context=context if context else None,
+            coding_style=coding_style,
+        )
 
         # Always use Opus for planning (smartest model)
         console.info("Planning with Opus (smartest model)...")
@@ -151,6 +164,8 @@ class AgentPhaseExecutor:
         required_branch: str | None = None,
         create_pr: bool = True,
         pr_group_info: dict | None = None,
+        target_branch: str = "main",
+        coding_style: str | None = None,
     ) -> dict[str, Any]:
         """Run a work session with full tools.
 
@@ -163,6 +178,8 @@ class AgentPhaseExecutor:
             required_branch: Optional branch name the agent should be on.
             create_pr: If True, instruct agent to create PR. If False, commit only.
             pr_group_info: Optional dict with PR group context (name, completed_tasks, etc).
+            target_branch: The target branch for rebasing (default: "main").
+            coding_style: Optional coding style guide to inject into prompt.
 
         Returns:
             Dict with 'output', 'success', and 'model_used' keys.
@@ -175,6 +192,8 @@ class AgentPhaseExecutor:
             required_branch=required_branch,
             create_pr=create_pr,
             pr_group_info=pr_group_info,
+            target_branch=target_branch,
+            coding_style=coding_style,
         )
 
         # Run async query with optional model override
@@ -325,3 +344,37 @@ class AgentPhaseExecutor:
 
         # Default criteria if none specified
         return "All tasks in the task list are completed successfully."
+
+    def generate_coding_style(self) -> dict[str, Any]:
+        """Generate a coding style guide by analyzing the codebase.
+
+        Analyzes CLAUDE.md, convention files, and sample source files
+        to create a concise coding style guide.
+
+        Returns:
+            Dict with 'coding_style' and 'raw_output' keys.
+        """
+        # Build prompt for coding style generation
+        prompt = build_coding_style_prompt()
+
+        console.info("Generating coding style guide with Opus...")
+
+        # Run with planning tools (read-only) and Opus for quality
+        result = run_async_with_cleanup(
+            self.query_executor.run_query(
+                prompt=prompt,
+                tools=self.get_tools_for_phase("planning"),
+                model_override=ModelType.OPUS,  # Use Opus for quality
+                get_model_name_func=self.get_model_name_func,
+                get_agents_func=self.get_agents_func,
+                process_message_func=self.process_message_func,
+            )
+        )
+
+        # Extract the coding style content
+        coding_style = extract_coding_style(result)
+
+        return {
+            "coding_style": coding_style,
+            "raw_output": result,
+        }

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/core/orchestrator.py

@@ -1337,11 +1337,15 @@ After fixing everything, run the tests again to confirm they pass.
 After completing your fixes, end with: TASK COMPLETE"""
 
         try:
+            # Load coding style for consistent style in fix session
+            coding_style = self.state_manager.load_coding_style()
+
             self.agent.run_work_session(
                 task_description=task_description,
                 context=context,
                 model_override=ModelType.OPUS,
                 create_pr=True,
+                coding_style=coding_style,
             )
             state.session_count += 1
             self.state_manager.save_state(state)

claude_task_master-0.1.8/src/claude_task_master/core/planner.py

@@ -0,0 +1,84 @@
+"""Planner - Orchestrates initial planning phase (read-only tools)."""
+
+from typing import Any
+
+from . import console
+from .agent import AgentWrapper
+from .state import StateManager
+
+
+class Planner:
+    """Handles the initial planning phase."""
+
+    def __init__(self, agent: AgentWrapper, state_manager: StateManager):
+        """Initialize planner."""
+        self.agent = agent
+        self.state_manager = state_manager
+
+    def ensure_coding_style(self) -> str | None:
+        """Ensure coding style guide exists, generating it if needed.
+
+        Checks if coding-style.md exists. If not, generates it by analyzing
+        CLAUDE.md and convention files in the codebase.
+
+        Returns:
+            The coding style guide content, or None if generation failed.
+        """
+        # Check if coding style already exists
+        coding_style = self.state_manager.load_coding_style()
+        if coding_style:
+            console.info("Using existing coding style guide")
+            return coding_style
+
+        # Generate coding style by analyzing codebase
+        console.info("Generating coding style guide from codebase...")
+        result = self.agent.generate_coding_style()
+
+        coding_style_content: str = result.get("coding_style", "")
+        if coding_style_content:
+            self.state_manager.save_coding_style(coding_style_content)
+            console.success("Coding style guide generated and saved")
+            return coding_style_content
+
+        console.warning("Could not generate coding style guide")
+        return None
+
+    def create_plan(self, goal: str) -> dict[str, Any]:
+        """Create initial task plan using read-only tools.
+
+        First generates coding style guide if it doesn't exist, then
+        runs planning phase with the coding style injected.
+        """
+        # Ensure coding style exists (generate if needed)
+        coding_style = self.ensure_coding_style()
+
+        # Load any existing context
+        context = self.state_manager.load_context()
+
+        # Run planning phase with Claude (with coding style)
+        result = self.agent.run_planning_phase(
+            goal=goal, context=context, coding_style=coding_style
+        )
+
+        # Extract plan and criteria from result
+        plan = result.get("plan", "")
+        criteria = result.get("criteria", "")
+
+        # Save to state
+        if plan:
+            self.state_manager.save_plan(plan)
+        if criteria:
+            self.state_manager.save_criteria(criteria)
+
+        return result
+
+    def update_plan_progress(self, task_index: int, completed: bool) -> None:
+        """Update task completion status in plan."""
+        plan = self.state_manager.load_plan()
+        if not plan:
+            return
+
+        # TODO: Parse markdown checkboxes and update status
+        # This will require parsing the plan.md file and toggling checkboxes
+
+        self.state_manager.save_plan(plan)

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/core/prompts.py

@@ -1,6 +1,7 @@
 """Prompt Templates - Centralized, maintainable prompt generation.
 
 This module provides structured prompt templates for different agent phases:
+- Coding Style: Generate concise coding style guide from codebase analysis
 - Planning: Initial codebase analysis and task creation
 - Plan Update: Modifying existing plans based on change requests
 - Working: Task execution with verification
@@ -12,6 +13,7 @@ All prompts are designed to be concise, structured, and token-efficient.
 This module re-exports all prompt functions for backward compatibility.
 The actual implementations are in:
 - prompts_base.py: PromptSection, PromptBuilder
+- prompts_coding_style.py: build_coding_style_prompt, extract_coding_style
 - prompts_planning.py: build_planning_prompt
 - prompts_plan_update.py: build_plan_update_prompt
 - prompts_working.py: build_work_prompt
@@ -24,6 +26,9 @@ from __future__ import annotations
 # Re-export base classes
 from .prompts_base import PromptBuilder, PromptSection
 
+# Re-export coding style prompts
+from .prompts_coding_style import build_coding_style_prompt, extract_coding_style
+
 # Re-export planning prompts
 from .prompts_plan_update import build_plan_update_prompt
 from .prompts_planning import build_planning_prompt
@@ -43,6 +48,9 @@ __all__ = [
     # Base classes
     "PromptSection",
     "PromptBuilder",
+    # Coding Style
+    "build_coding_style_prompt",
+    "extract_coding_style",
     # Planning
     "build_planning_prompt",
     "build_plan_update_prompt",

claude_task_master-0.1.8/src/claude_task_master/core/prompts_coding_style.py

@@ -0,0 +1,160 @@
+"""Coding Style Generation Prompt for Claude Task Master.
+
+This module contains the prompt for generating a concise coding style guide
+by analyzing CLAUDE.md and convention files. The generated guide captures:
+- Coding workflow (TDD, development process)
+- Code style conventions (naming, formatting)
+- Project-specific requirements
+
+The guide is saved to coding-style.md and injected into planning and work
+prompts to save tokens while ensuring consistent code quality.
+"""
+
+from __future__ import annotations
+
+from .prompts_base import PromptBuilder
+
+
+def build_coding_style_prompt() -> str:
+    """Build the prompt for generating a coding style guide.
+
+    This prompt instructs Claude to analyze CLAUDE.md and convention files
+    to create a concise coding style guide that captures the project's
+    workflow (TDD, development process) and code conventions.
+
+    Returns:
+        Complete coding style generation prompt.
+    """
+    builder = PromptBuilder(
+        intro="""You are analyzing a codebase to extract its coding workflow and style guide.
+
+Your mission: **Create a CONCISE coding guide (under 600 words).**
+
+Focus on extracting:
+1. **Development workflow** (TDD, test-first, iteration patterns)
+2. **Code conventions** (naming, formatting, imports)
+3. **Project-specific requirements** (from CLAUDE.md)
+
+This guide will be injected into every coding task, so keep it SHORT and ACTIONABLE.
+
+## TOOL RESTRICTIONS (MANDATORY)
+
+**ALLOWED TOOLS (use ONLY these):**
+- `Read` - Read files to understand patterns
+- `Glob` - Find files by pattern
+- `Grep` - Search for code patterns
+- `Bash` - Run commands (check configs, linters, etc.)
+
+**FORBIDDEN TOOLS (NEVER use):**
+- `Write` - Do NOT write any files
+- `Edit` - Do NOT edit any files
+- `Task` - Do NOT launch any agents"""
+    )
+
+    builder.add_section(
+        "Step 1: Read CLAUDE.md (PRIORITY)",
+        """**Start by reading `CLAUDE.md` at the repository root.**
+
+This file contains the project's coding requirements and workflow instructions.
+Extract:
+- Development workflow (TDD, test-driven, iteration patterns)
+- Code quality requirements
+- Testing approach (test first? mock patterns?)
+- Any specific coding rules or constraints
+
+Also check these if CLAUDE.md doesn't exist:
+- `.claude/instructions.md`
+- `CONTRIBUTING.md`
+- `.cursorrules`, `.github/copilot-instructions.md`""",
+    )
+
+    builder.add_section(
+        "Step 2: Check Configs",
+        """Quickly scan linter/formatter configs for conventions:
+
+- Python: `pyproject.toml` [tool.ruff], `ruff.toml`
+- JS/TS: `.eslintrc`, `.prettierrc`, `biome.json`
+- General: `.editorconfig`
+
+Note line length, quote style, import ordering rules.""",
+    )
+
+    builder.add_section(
+        "Step 3: Generate Coding Guide",
+        """Create a CONCISE guide with these sections (skip if not applicable):
+
+```markdown
+# Coding Style
+
+## Workflow
+- [TDD approach? Test-first? Iteration pattern?]
+- [Required checks before commit: tests, lint, types?]
+
+## Code Style
+- [Naming: snake_case, camelCase, etc.]
+- [Formatting: line length, quotes, indentation]
+- [Imports: ordering, grouping]
+
+## Types
+- [Type annotations required? Strictness level?]
+
+## Testing
+- [Test file naming, location]
+- [Assertion style, mock patterns]
+- [Coverage requirements?]
+
+## Error Handling
+- [Exception patterns, logging approach]
+
+## Project-Specific
+- [Any unique requirements from CLAUDE.md]
+```
+
+**Rules:**
+- Each section: 2-4 bullet points MAX
+- Be SPECIFIC and ACTIONABLE: "Run `pytest` before commit" not "Test your code"
+- Capture the WORKFLOW, not just style
+- Include actual commands where relevant
+- Total guide: under 600 words""",
+    )
+
+    builder.add_section(
+        "Output Format",
+        """Output ONLY the coding guide in markdown format.
+
+Start with `# Coding Style` and include only relevant sections.
+
+Do NOT include explanations or meta-commentary - just the guide itself.
+
+End with:
+```
+CODING_STYLE_COMPLETE
+```""",
+    )
+
+    return builder.build()
+
+
+def extract_coding_style(result: str) -> str:
+    """Extract the coding style guide from the generation result.
+
+    Args:
+        result: The raw output from the coding style generation.
+
+    Returns:
+        The extracted coding style guide content.
+    """
+    # Remove the completion marker if present
+    content = result.replace("CODING_STYLE_COMPLETE", "").strip()
+
+    # If it starts with markdown header, return as-is
+    if content.startswith("# Coding Style") or content.startswith("# coding style"):
+        return content
+
+    # Try to find the coding style section
+    if "# Coding Style" in content:
+        idx = content.index("# Coding Style")
+        return content[idx:].strip()
+
+    # Fallback: wrap the content
+    return f"# Coding Style\n\n{content}"

{claude_task_master-0.1.6 → claude_task_master-0.1.8}/src/claude_task_master/core/prompts_planning.py

@@ -9,12 +9,15 @@ from __future__ import annotations
 from .prompts_base import PromptBuilder
 
 
-def build_planning_prompt(goal: str, context: str | None = None) -> str:
+def build_planning_prompt(
+    goal: str, context: str | None = None, coding_style: str | None = None
+) -> str:
     """Build the planning phase prompt.
 
     Args:
         goal: The user's goal to achieve.
         context: Optional accumulated context from previous sessions.
+        coding_style: Optional coding style guide to inject.
 
     Returns:
         Complete planning prompt.
@@ -65,16 +68,37 @@ You just need to OUTPUT the plan as TEXT in your response.
     if context:
         builder.add_section("Previous Context", context.strip())
 
+    # Coding style section if available (generated from codebase analysis)
+    if coding_style:
+        builder.add_section(
+            "Project Coding Style",
+            f"""The following coding style guide was extracted from this codebase.
+**Tasks you create MUST respect these conventions.**
+
+{coding_style.strip()}""",
+        )
+
     # Exploration phase - READ ONLY
     builder.add_section(
         "Step 1: Explore Codebase (READ ONLY)",
         """Thoroughly analyze the codebase using READ-ONLY operations:
-1. **Read** key files (README, configs, main modules)
-2. **Glob** to find patterns (`**/*.py`, `src/**/*.ts`)
-3. **Grep** for specific code (class definitions, imports)
-4. **Identify** tests, CI config, and coding standards
 
-Understand the architecture before creating tasks.""",
+**CRITICAL: Read Project Conventions FIRST**
+1. **Read `CLAUDE.md`** (if exists) - Contains coding requirements, project instructions,
+   and conventions that MUST be followed. This file defines how code should be written.
+2. Also check: `.claude/instructions.md`, `CONTRIBUTING.md`, `.cursorrules`, `.github/copilot-instructions.md`
+
+**Then explore the codebase:**
+3. **Read** key files (README, configs, main modules)
+4. **Glob** to find patterns (`**/*.py`, `src/**/*.ts`)
+5. **Grep** for specific code (class definitions, imports)
+6. **Identify** tests, CI config, and existing code patterns
+
+**Remember:** Any coding requirements found in `CLAUDE.md` or similar convention files
+MUST be respected when creating tasks. Include relevant requirements in task descriptions
+so the working phase follows project standards.
+
+Understand the architecture AND coding standards before creating tasks.""",
     )
 
     # Task creation phase - organized by PR