claude-task-master 0.1.7__tar.gz → 0.1.9__tar.gz

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-task-master
-Version: 0.1.7
+Version: 0.1.9
 Summary: Autonomous task orchestration system that keeps Claude working until a goal is achieved
 Author: Claude Task Master Team
 License-Expression: MIT
@@ -19,7 +19,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: claude-agent-sdk>=0.1.0
+Requires-Dist: claude-agent-sdk>=0.1.27
 Requires-Dist: typer>=0.12.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: rich>=13.0.0

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-task-master"
-version = "0.1.7"
+version = "0.1.9"
 description = "Autonomous task orchestration system that keeps Claude working until a goal is achieved"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -24,7 +24,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "claude-agent-sdk>=0.1.0",
+    "claude-agent-sdk>=0.1.27",
     "typer>=0.12.0",
     "pydantic>=2.0.0",
     "rich>=13.0.0",

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/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.7"
+__version__ = "0.1.9"
 __all__ = ["__version__"]

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/src/claude_task_master/api/models.py

@@ -25,6 +25,7 @@ Response Models:
 - CloneRepoResponse: Result of cloning a repository
 - SetupRepoResponse: Result of setting up a repository
 - PlanRepoResponse: Result of planning for a repository
+- DeleteCodingStyleResponse: Result of deleting coding-style.md
 
 Usage:
     from claude_task_master.api.models import (
@@ -860,3 +861,24 @@ class PlanRepoResponse(BaseModel):
     criteria: str | None = None
     run_id: str | None = None
     error: str | None = None
+
+
+# =============================================================================
+# Coding Style Response Models
+# =============================================================================
+
+
+class DeleteCodingStyleResponse(BaseModel):
+    """Response model for deleting the coding-style.md file.
+
+    Attributes:
+        success: Whether the deletion operation succeeded.
+        message: Human-readable result message.
+        file_existed: Whether the file existed before deletion.
+        error: Error message if deletion failed.
+    """
+
+    success: bool
+    message: str
+    file_existed: bool = False
+    error: str | None = None

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/src/claude_task_master/api/routes.py

@@ -10,6 +10,7 @@ Endpoints:
 - GET /progress: Get progress summary
 - GET /context: Get accumulated context/learnings
 - GET /health: Health check endpoint
+- DELETE /coding-style: Delete the coding-style.md file
 - POST /task/init: Initialize a new task
 - DELETE /task: Delete/cleanup current task
 - POST /control/stop: Stop a running task with optional cleanup
@@ -51,6 +52,7 @@ from claude_task_master.api.models import (
     ConfigUpdateRequest,
     ContextResponse,
     ControlResponse,
+    DeleteCodingStyleResponse,
     ErrorResponse,
     HealthResponse,
     LogsResponse,
@@ -613,6 +615,68 @@ def create_info_router() -> APIRouter:
             active_tasks=active_tasks,
         )
 
+    @router.delete(
+        "/coding-style",
+        response_model=DeleteCodingStyleResponse,
+        responses={
+            404: {"model": ErrorResponse, "description": "No active task found"},
+            500: {"model": ErrorResponse, "description": "Internal server error"},
+        },
+        summary="Delete Coding Style",
+        description="Delete the coding-style.md file from the state directory.",
+    )
+    async def delete_coding_style(request: Request) -> DeleteCodingStyleResponse | JSONResponse:
+        """Delete the coding-style.md file.
+
+        Removes the coding-style.md file from the state directory. This file
+        contains extracted coding conventions and is regenerated on the next run.
+
+        Returns:
+            DeleteCodingStyleResponse indicating whether the file was deleted.
+
+        Raises:
+            404: If no active task exists.
+            500: If an error occurs during deletion.
+        """
+        state_manager = _get_state_manager(request)
+
+        if not state_manager.exists():
+            return JSONResponse(
+                status_code=404,
+                content=ErrorResponse(
+                    error="not_found",
+                    message="No active task found",
+                    suggestion="Start a new task with 'claudetm start <goal>'",
+                ).model_dump(),
+            )
+
+        try:
+            file_existed = state_manager.delete_coding_style()
+
+            if file_existed:
+                return DeleteCodingStyleResponse(
+                    success=True,
+                    message="Coding style file deleted successfully",
+                    file_existed=True,
+                )
+            else:
+                return DeleteCodingStyleResponse(
+                    success=True,
+                    message="Coding style file did not exist",
+                    file_existed=False,
+                )
+
+        except Exception as e:
+            logger.exception("Error deleting coding style file")
+            return JSONResponse(
+                status_code=500,
+                content=ErrorResponse(
+                    error="internal_error",
+                    message="Failed to delete coding style file",
+                    detail=str(e),
+                ).model_dump(),
+            )
+
     return router
 
 
@@ -1356,7 +1420,9 @@ def register_routes(app: FastAPI) -> None:
     repo_router = create_repo_router()
     app.include_router(repo_router, prefix="/repo")
 
-    logger.debug("Registered info routes: /status, /plan, /logs, /progress, /context, /health")
+    logger.debug(
+        "Registered info routes: /status, /plan, /logs, /progress, /context, /health, /coding-style"
+    )
     logger.debug("Registered control routes: /control/stop, /control/resume, /config")
     logger.debug("Registered task routes: /task/init, /task")
     logger.debug("Registered webhook routes: /webhooks, /webhooks/{id}, /webhooks/test")

{claude_task_master-0.1.7 → claude_task_master-0.1.9}/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,
@@ -190,6 +210,7 @@ class AgentWrapper:
         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.
 
@@ -203,6 +224,7 @@ class AgentWrapper:
             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.
@@ -218,6 +240,7 @@ class AgentWrapper:
             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.7 → claude_task_master-0.1.9}/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)...")
@@ -152,6 +165,7 @@ class AgentPhaseExecutor:
         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.
 
@@ -165,6 +179,7 @@ class AgentPhaseExecutor:
             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.
@@ -178,6 +193,7 @@ class AgentPhaseExecutor:
             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
@@ -328,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.7 → claude_task_master-0.1.9}/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.9/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.7 → claude_task_master-0.1.9}/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.9/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}"