gobby 0.2.5__py3-none-any.whl

gobby/tasks/criteria.py

@@ -0,0 +1,342 @@
+"""
+Criteria generation for task expansion.
+
+This module provides:
+- PatternCriteriaInjector: Detects patterns from labels/descriptions and injects criteria
+- CriteriaGenerator: Shared criteria generator for both structured and LLM expansion
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from gobby.config.app import PatternCriteriaConfig, ProjectVerificationConfig
+    from gobby.storage.tasks import Task
+    from gobby.tasks.context import ExpansionContext
+
+logger = logging.getLogger(__name__)
+
+
+class PatternCriteriaInjector:
+    """Injects pattern-specific validation criteria into task expansion.
+
+    Detects patterns from:
+    - Task labels (e.g., 'strangler-fig', 'tdd')
+    - Description keywords (e.g., 'using strangler fig pattern')
+
+    Then injects appropriate criteria templates with placeholders replaced
+    by actual verification commands from project config.
+    """
+
+    def __init__(
+        self,
+        pattern_config: PatternCriteriaConfig,
+        verification_config: ProjectVerificationConfig | None = None,
+    ):
+        """Initialize the injector.
+
+        Args:
+            pattern_config: Pattern criteria configuration with templates
+            verification_config: Project verification commands for placeholder substitution
+        """
+        self.pattern_config = pattern_config
+        self.verification_config = verification_config
+
+    def detect_patterns(
+        self,
+        task: Task,
+        labels: list[str] | None = None,
+    ) -> list[str]:
+        """Detect which patterns apply to a task.
+
+        Args:
+            task: The task to analyze
+            labels: Optional explicit labels (overrides task.labels)
+
+        Returns:
+            List of detected pattern names
+        """
+        detected: list[str] = []
+        task_labels = labels if labels is not None else (task.labels or [])
+
+        # Normalize labels to lowercase for matching
+        normalized_labels = [label.lower() for label in task_labels]
+
+        # Check labels first (direct match)
+        for pattern_name in self.pattern_config.patterns.keys():
+            if pattern_name.lower() in normalized_labels:
+                if pattern_name not in detected:
+                    detected.append(pattern_name)
+                    logger.debug(f"Detected pattern '{pattern_name}' from task labels")
+
+        # Check description keywords
+        description = (task.description or "").lower()
+        title = (task.title or "").lower()
+        text_to_search = f"{title} {description}"
+
+        for pattern_name, keywords in self.pattern_config.detection_keywords.items():
+            if pattern_name in detected:
+                continue  # Already detected from labels
+
+            for keyword in keywords:
+                if keyword.lower() in text_to_search:
+                    detected.append(pattern_name)
+                    logger.debug(
+                        f"Detected pattern '{pattern_name}' from keyword '{keyword}' in description"
+                    )
+                    break
+
+        return detected
+
+    def _get_placeholder_values(self) -> dict[str, str]:
+        """Get placeholder values from verification config.
+
+        Returns:
+            Dict mapping placeholder names to their values
+        """
+        values: dict[str, str] = {}
+
+        if self.verification_config:
+            if self.verification_config.unit_tests:
+                values["unit_tests"] = self.verification_config.unit_tests
+            if self.verification_config.type_check:
+                values["type_check"] = self.verification_config.type_check
+            if self.verification_config.lint:
+                values["lint"] = self.verification_config.lint
+            if self.verification_config.integration:
+                values["integration"] = self.verification_config.integration
+
+            # Add any custom verification commands
+            for name, cmd in self.verification_config.custom.items():
+                values[name] = cmd
+
+        return values
+
+    def _substitute_placeholders(
+        self,
+        template: str,
+        extra_values: dict[str, str] | None = None,
+    ) -> str:
+        """Substitute placeholders in a template string.
+
+        Args:
+            template: Template string with {placeholder} syntax
+            extra_values: Additional values to substitute
+
+        Returns:
+            String with placeholders replaced
+        """
+        values = self._get_placeholder_values()
+        if extra_values:
+            values.update(extra_values)
+
+        # Use a regex to find placeholders and replace only those we have values for
+        def replace_placeholder(match: re.Match[str]) -> str:
+            key = match.group(1)
+            return values.get(key, match.group(0))  # Keep original if no value
+
+        return re.sub(r"\{(\w+)\}", replace_placeholder, template)
+
+    def inject(
+        self,
+        task: Task,
+        context: ExpansionContext | None = None,
+        labels: list[str] | None = None,
+        extra_placeholders: dict[str, str] | None = None,
+    ) -> str:
+        """Generate pattern-specific criteria markdown for a task.
+
+        Args:
+            task: The task to generate criteria for
+            context: Optional expansion context (unused currently, for future extensibility)
+            labels: Optional explicit labels (overrides task.labels)
+            extra_placeholders: Additional placeholder values for substitution
+
+        Returns:
+            Markdown-formatted criteria string, empty if no patterns detected
+        """
+        detected_patterns = self.detect_patterns(task, labels)
+
+        if not detected_patterns:
+            return ""
+
+        sections: list[str] = []
+
+        for pattern_name in detected_patterns:
+            templates = self.pattern_config.patterns.get(pattern_name, [])
+            if not templates:
+                continue
+
+            criteria_lines: list[str] = []
+            for template in templates:
+                substituted = self._substitute_placeholders(template, extra_placeholders)
+                criteria_lines.append(f"- [ ] {substituted}")
+
+            if criteria_lines:
+                # Format pattern name nicely (e.g., "strangler-fig" -> "Strangler-Fig Pattern")
+                pattern_title = pattern_name.replace("-", " ").title()
+                section = f"## {pattern_title} Pattern Criteria\n\n" + "\n".join(criteria_lines)
+                sections.append(section)
+
+        return "\n\n".join(sections)
+
+    def inject_for_labels(
+        self,
+        labels: list[str],
+        task: Task | None = None,
+        extra_placeholders: dict[str, str] | None = None,
+    ) -> str:
+        """Generate criteria based on explicit labels without a full task.
+
+        This is a convenience method when you only have labels and optionally a task.
+
+        Args:
+            labels: List of pattern labels
+            task: Optional task for additional context
+            extra_placeholders: Additional placeholder values
+
+        Returns:
+            Markdown-formatted criteria string
+        """
+        if task:
+            return self.inject(task, labels=labels, extra_placeholders=extra_placeholders)
+
+        # Create minimal criteria from labels only
+        sections: list[str] = []
+        normalized_labels = [label.lower() for label in labels]
+
+        for pattern_name in self.pattern_config.patterns.keys():
+            if pattern_name.lower() not in normalized_labels:
+                continue
+
+            templates = self.pattern_config.patterns.get(pattern_name, [])
+            if not templates:
+                continue
+
+            criteria_lines: list[str] = []
+            for template in templates:
+                substituted = self._substitute_placeholders(template, extra_placeholders)
+                criteria_lines.append(f"- [ ] {substituted}")
+
+            if criteria_lines:
+                pattern_title = pattern_name.replace("-", " ").title()
+                section = f"## {pattern_title} Pattern Criteria\n\n" + "\n".join(criteria_lines)
+                sections.append(section)
+
+        return "\n\n".join(sections)
+
+
+class CriteriaGenerator:
+    """Shared criteria generator for both structured and LLM expansion.
+
+    Generates validation criteria by combining:
+    - Pattern-specific criteria (from labels/description)
+    - Verification command criteria (from project config)
+    - File-specific criteria (when relevant files provided)
+
+    Can be used by:
+    - TaskExpander (LLM expansion)
+    - TaskHierarchyBuilder (structured expansion)
+    """
+
+    def __init__(
+        self,
+        pattern_config: PatternCriteriaConfig,
+        verification_config: ProjectVerificationConfig | None = None,
+    ):
+        """Initialize the generator.
+
+        Args:
+            pattern_config: Pattern criteria configuration with templates
+            verification_config: Project verification commands configuration
+        """
+        self.pattern_injector = PatternCriteriaInjector(
+            pattern_config=pattern_config,
+            verification_config=verification_config,
+        )
+        self.verification_config = verification_config
+
+    def generate(
+        self,
+        title: str,
+        description: str | None = None,
+        labels: list[str] | None = None,
+        relevant_files: list[str] | None = None,
+        verification_commands: dict[str, str] | None = None,
+    ) -> str:
+        """Generate validation criteria markdown.
+
+        Args:
+            title: Task title
+            description: Task description
+            labels: Optional labels for pattern detection
+            relevant_files: Optional list of relevant file paths
+            verification_commands: Optional verification commands override
+
+        Returns:
+            Markdown-formatted validation criteria string
+        """
+        criteria_parts: list[str] = []
+
+        # 1. Pattern-specific criteria from labels
+        if labels:
+            pattern_criteria = self.pattern_injector.inject_for_labels(
+                labels=labels,
+                extra_placeholders=verification_commands,
+            )
+            if pattern_criteria:
+                criteria_parts.append(pattern_criteria)
+
+        # 2. File-specific criteria
+        if relevant_files and description:
+            text_to_check = (title + " " + (description or "")).lower()
+            matching_files = [f for f in relevant_files if f.lower() in text_to_check]
+            if matching_files:
+                file_criteria = ["## File Requirements", ""]
+                for f in matching_files:
+                    file_criteria.append(f"- [ ] `{f}` is correctly modified/created")
+                criteria_parts.append("\n".join(file_criteria))
+
+        # 3. Verification command criteria
+        verification = self._get_verification_commands(verification_commands)
+        if verification:
+            verification_criteria = ["## Verification", ""]
+            for name, cmd in verification.items():
+                if name in ["unit_tests", "type_check", "lint"]:
+                    verification_criteria.append(f"- [ ] `{cmd}` passes")
+            if len(verification_criteria) > 2:  # Has items beyond header
+                criteria_parts.append("\n".join(verification_criteria))
+
+        return "\n\n".join(criteria_parts) if criteria_parts else ""
+
+    def _get_verification_commands(
+        self,
+        override: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        """Get verification commands from config or override.
+
+        Args:
+            override: Optional override commands
+
+        Returns:
+            Dict of verification command name -> command
+        """
+        if override:
+            return override
+
+        commands: dict[str, str] = {}
+        if self.verification_config:
+            if self.verification_config.unit_tests:
+                commands["unit_tests"] = self.verification_config.unit_tests
+            if self.verification_config.type_check:
+                commands["type_check"] = self.verification_config.type_check
+            if self.verification_config.lint:
+                commands["lint"] = self.verification_config.lint
+            if self.verification_config.integration:
+                commands["integration"] = self.verification_config.integration
+            for name, cmd in self.verification_config.custom.items():
+                commands[name] = cmd
+        return commands

gobby/tasks/enhanced_validator.py

@@ -0,0 +1,226 @@
+"""Enhanced task validator with retry and escalation logic.
+
+Provides the core validation loop for Task System V2.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Protocol
+
+from gobby.tasks.validation_models import Issue
+
+if TYPE_CHECKING:
+    from gobby.tasks.validation_history import ValidationHistoryManager
+
+logger = logging.getLogger(__name__)
+
+
+class EscalationReason(Enum):
+    """Reasons for escalating a validation failure."""
+
+    MAX_ITERATIONS = "max_iterations"
+    CONSECUTIVE_ERRORS = "consecutive_errors"
+    RECURRING_ISSUES = "recurring_issues"
+
+
+@dataclass
+class ValidationResult:
+    """Result of a validation attempt.
+
+    Attributes:
+        valid: Whether the task passed validation.
+        iterations: Number of validation iterations performed.
+        feedback: Human-readable feedback from the validator.
+        escalated: Whether the validation was escalated.
+        escalation_reason: Reason for escalation if escalated.
+        issues: List of issues found during validation.
+    """
+
+    valid: bool
+    iterations: int
+    feedback: str
+    escalated: bool = False
+    escalation_reason: EscalationReason | None = None
+    issues: list[Issue] = field(default_factory=list)
+
+
+class LLMValidator(Protocol):
+    """Protocol for LLM-based validators."""
+
+    async def validate(
+        self,
+        task: Any,
+        context: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Validate a task.
+
+        Args:
+            task: The task to validate.
+            context: Optional context for validation.
+
+        Returns:
+            Dictionary with keys:
+                - valid: bool
+                - feedback: str
+                - issues: list[dict]
+        """
+        ...
+
+
+class TaskManager(Protocol):
+    """Protocol for task managers."""
+
+    def get_task(self, task_id: str) -> Any:
+        """Get a task by ID."""
+        ...
+
+
+class EnhancedTaskValidator:
+    """Enhanced task validator with retry and escalation logic.
+
+    Implements a validation loop that:
+    - Retries validation up to max_iterations
+    - Tracks validation history
+    - Detects recurring issues
+    - Escalates when thresholds are exceeded
+    """
+
+    def __init__(
+        self,
+        task_manager: TaskManager,
+        history_manager: "ValidationHistoryManager",
+        llm_validator: LLMValidator,
+        max_iterations: int = 3,
+        error_threshold: int = 2,
+    ):
+        """Initialize EnhancedTaskValidator.
+
+        Args:
+            task_manager: Manager for task CRUD operations.
+            history_manager: Manager for validation history.
+            llm_validator: LLM-based validator for task validation.
+            max_iterations: Maximum validation attempts before escalation.
+            error_threshold: Consecutive errors before escalation.
+        """
+        self.task_manager = task_manager
+        self.history_manager = history_manager
+        self.llm_validator = llm_validator
+        self.max_iterations = max_iterations
+        self.error_threshold = error_threshold
+
+    async def validate_with_retry(
+        self,
+        task_id: str,
+        context: dict[str, Any] | None = None,
+    ) -> ValidationResult:
+        """Validate a task with retry logic.
+
+        Attempts validation up to max_iterations times. Escalates if:
+        - max_iterations is exceeded
+        - Consecutive errors exceed error_threshold
+        - Recurring issues are detected
+
+        Args:
+            task_id: ID of the task to validate.
+            context: Optional context for validation (e.g., git diff).
+
+        Returns:
+            ValidationResult with validation status and details.
+        """
+        task = self.task_manager.get_task(task_id)
+        consecutive_errors = 0
+        last_feedback = ""
+        last_issues: list[Issue] = []
+
+        for iteration in range(1, self.max_iterations + 1):
+            try:
+                # Attempt validation
+                result = await self.llm_validator.validate(task, context=context)
+
+                valid = result.get("valid", False)
+                feedback = result.get("feedback", "")
+                issues_data = result.get("issues", [])
+
+                # Parse issues
+                issues = []
+                for issue_dict in issues_data:
+                    if isinstance(issue_dict, dict):
+                        issues.append(Issue.from_dict(issue_dict))
+                    elif isinstance(issue_dict, Issue):
+                        issues.append(issue_dict)
+
+                last_feedback = feedback
+                last_issues = issues
+
+                # Record this iteration
+                status = "valid" if valid else "invalid"
+                self.history_manager.record_iteration(
+                    task_id=task_id,
+                    iteration=iteration,
+                    status=status,
+                    feedback=feedback,
+                    issues=issues if issues else None,
+                )
+
+                # Reset consecutive errors on success
+                consecutive_errors = 0
+
+                if valid:
+                    # Validation passed
+                    return ValidationResult(
+                        valid=True,
+                        iterations=iteration,
+                        feedback=feedback,
+                        issues=issues,
+                    )
+
+                # Check for recurring issues after recording
+                if self.history_manager.has_recurring_issues(task_id):
+                    logger.info(f"Recurring issues detected for task {task_id}, escalating")
+                    return ValidationResult(
+                        valid=False,
+                        iterations=iteration,
+                        feedback=feedback,
+                        escalated=True,
+                        escalation_reason=EscalationReason.RECURRING_ISSUES,
+                        issues=issues,
+                    )
+
+            except Exception as e:
+                logger.warning(f"Validation error on iteration {iteration}: {e}")
+                consecutive_errors += 1
+
+                # Record error iteration
+                self.history_manager.record_iteration(
+                    task_id=task_id,
+                    iteration=iteration,
+                    status="error",
+                    feedback=str(e),
+                )
+
+                if consecutive_errors >= self.error_threshold:
+                    logger.info(
+                        f"Consecutive error threshold reached for task {task_id}, "
+                        f"escalating after {consecutive_errors} errors"
+                    )
+                    return ValidationResult(
+                        valid=False,
+                        iterations=iteration,
+                        feedback=f"Validation failed with {consecutive_errors} consecutive errors",
+                        escalated=True,
+                        escalation_reason=EscalationReason.CONSECUTIVE_ERRORS,
+                    )
+
+        # Max iterations exceeded
+        logger.info(
+            f"Max iterations ({self.max_iterations}) exceeded for task {task_id}, escalating"
+        )
+        return ValidationResult(
+            valid=False,
+            iterations=self.max_iterations,
+            feedback=last_feedback,
+            escalated=True,
+            escalation_reason=EscalationReason.MAX_ITERATIONS,
+            issues=last_issues,
+        )