gobby 0.2.5__py3-none-any.whl

gobby/tasks/validation_history.py

@@ -0,0 +1,357 @@
+"""Validation history management for Task System V2.
+
+Provides storage and retrieval of validation iteration history.
+"""
+
+import json
+import logging
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from typing import TYPE_CHECKING, Any
+
+from gobby.tasks.validation_models import Issue
+
+if TYPE_CHECKING:
+    from gobby.storage.database import DatabaseProtocol
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ValidationIteration:
+    """Represents a single validation iteration for a task.
+
+    Attributes:
+        id: Database ID of the iteration record
+        task_id: ID of the task being validated
+        iteration: Iteration number (1-based)
+        status: Validation status ("valid", "invalid", "error")
+        feedback: Human-readable feedback from validator
+        issues: List of Issue objects found during validation
+        context_type: Type of context provided (e.g., "git_diff", "code_review")
+        context_summary: Summary of the context provided
+        validator_type: Type of validator used (e.g., "llm", "external_webhook")
+        created_at: Timestamp when iteration was recorded
+    """
+
+    id: int
+    task_id: str
+    iteration: int
+    status: str
+    feedback: str | None = None
+    issues: list[Issue] | None = None
+    context_type: str | None = None
+    context_summary: str | None = None
+    validator_type: str | None = None
+    created_at: str | None = None
+
+
+class ValidationHistoryManager:
+    """Manages validation iteration history for tasks.
+
+    Stores and retrieves validation history from the task_validation_history table.
+    """
+
+    def __init__(self, db: "DatabaseProtocol"):
+        """Initialize ValidationHistoryManager.
+
+        Args:
+            db: LocalDatabase instance for database operations.
+        """
+        self.db = db
+
+    def record_iteration(
+        self,
+        task_id: str,
+        iteration: int,
+        status: str,
+        feedback: str | None = None,
+        issues: list[Issue] | None = None,
+        context_type: str | None = None,
+        context_summary: str | None = None,
+        validator_type: str | None = None,
+    ) -> None:
+        """Record a validation iteration for a task.
+
+        Args:
+            task_id: ID of the task being validated.
+            iteration: Iteration number (1-based).
+            status: Validation status ("valid", "invalid", "error").
+            feedback: Human-readable feedback from validator.
+            issues: List of Issue objects found during validation.
+            context_type: Type of context provided.
+            context_summary: Summary of the context provided.
+            validator_type: Type of validator used.
+        """
+        # Serialize issues to JSON
+        issues_json = None
+        if issues:
+            issues_json = json.dumps([issue.to_dict() for issue in issues])
+
+        with self.db.transaction() as conn:
+            conn.execute(
+                """INSERT INTO task_validation_history
+                   (task_id, iteration, status, feedback, issues, context_type,
+                    context_summary, validator_type)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    task_id,
+                    iteration,
+                    status,
+                    feedback,
+                    issues_json,
+                    context_type,
+                    context_summary,
+                    validator_type,
+                ),
+            )
+
+        logger.debug(f"Recorded validation iteration {iteration} for task {task_id}: {status}")
+
+    def get_iteration_history(self, task_id: str) -> list[ValidationIteration]:
+        """Get all validation iterations for a task.
+
+        Args:
+            task_id: ID of the task to get history for.
+
+        Returns:
+            List of ValidationIteration objects ordered by iteration number.
+        """
+        rows = self.db.fetchall(
+            """SELECT * FROM task_validation_history
+               WHERE task_id = ?
+               ORDER BY iteration ASC""",
+            (task_id,),
+        )
+
+        return [self._row_to_iteration(row) for row in rows]
+
+    def get_latest_iteration(self, task_id: str) -> ValidationIteration | None:
+        """Get the most recent validation iteration for a task.
+
+        Args:
+            task_id: ID of the task to get latest iteration for.
+
+        Returns:
+            Latest ValidationIteration or None if no history exists.
+        """
+        row = self.db.fetchone(
+            """SELECT * FROM task_validation_history
+               WHERE task_id = ?
+               ORDER BY iteration DESC
+               LIMIT 1""",
+            (task_id,),
+        )
+
+        if row:
+            return self._row_to_iteration(row)
+        return None
+
+    def clear_history(self, task_id: str) -> None:
+        """Remove all validation history for a task.
+
+        Args:
+            task_id: ID of the task to clear history for.
+        """
+        with self.db.transaction() as conn:
+            conn.execute(
+                "DELETE FROM task_validation_history WHERE task_id = ?",
+                (task_id,),
+            )
+
+        logger.debug(f"Cleared validation history for task {task_id}")
+
+    def _row_to_iteration(self, row: Any) -> ValidationIteration:
+        """Convert a database row to a ValidationIteration object.
+
+        Args:
+            row: Database row from task_validation_history.
+
+        Returns:
+            ValidationIteration object.
+        """
+        # Parse issues from JSON
+        issues = None
+        issues_json = row["issues"]
+        if issues_json:
+            issues_data = json.loads(issues_json)
+            issues = [Issue.from_dict(d) for d in issues_data]
+
+        return ValidationIteration(
+            id=row["id"],
+            task_id=row["task_id"],
+            iteration=row["iteration"],
+            status=row["status"],
+            feedback=row["feedback"],
+            issues=issues,
+            context_type=row["context_type"],
+            context_summary=row["context_summary"],
+            validator_type=row["validator_type"],
+            created_at=row["created_at"],
+        )
+
+    # =========================================================================
+    # Recurring Issue Detection
+    # =========================================================================
+
+    def group_similar_issues(
+        self,
+        issues: list[Issue],
+        similarity_threshold: float = 0.8,
+    ) -> list[list[Issue]]:
+        """Group issues by similarity.
+
+        Uses fuzzy string matching on titles and exact matching on locations.
+        Issues at the same location are always grouped together.
+
+        Args:
+            issues: List of Issue objects to group.
+            similarity_threshold: Minimum similarity ratio (0-1) for title matching.
+
+        Returns:
+            List of groups, where each group is a list of similar Issues.
+        """
+        if not issues:
+            return []
+
+        groups: list[list[Issue]] = []
+        used: set[int] = set()
+
+        for i, issue in enumerate(issues):
+            if i in used:
+                continue
+
+            # Start a new group with this issue
+            group = [issue]
+            used.add(i)
+
+            # Find similar issues
+            for j, other in enumerate(issues):
+                if j in used:
+                    continue
+
+                if self._issues_are_similar(issue, other, similarity_threshold):
+                    group.append(other)
+                    used.add(j)
+
+            groups.append(group)
+
+        return groups
+
+    def _issues_are_similar(
+        self,
+        issue1: Issue,
+        issue2: Issue,
+        threshold: float,
+    ) -> bool:
+        """Check if two issues are similar.
+
+        Args:
+            issue1: First issue to compare.
+            issue2: Second issue to compare.
+            threshold: Minimum similarity ratio for title matching.
+
+        Returns:
+            True if issues are considered similar.
+        """
+        # Same location is a strong match signal
+        if issue1.location and issue2.location and issue1.location == issue2.location:
+            return True
+
+        # Check title similarity using SequenceMatcher
+        ratio = SequenceMatcher(None, issue1.title.lower(), issue2.title.lower()).ratio()
+        return ratio >= threshold
+
+    def has_recurring_issues(
+        self,
+        task_id: str,
+        threshold: int = 2,
+        similarity_threshold: float = 0.8,
+    ) -> bool:
+        """Check if a task has recurring issues across iterations.
+
+        Args:
+            task_id: ID of the task to check.
+            threshold: Minimum number of occurrences to consider recurring.
+            similarity_threshold: Minimum similarity ratio for grouping issues.
+
+        Returns:
+            True if any issue recurs at least `threshold` times.
+        """
+        history = self.get_iteration_history(task_id)
+        if not history:
+            return False
+
+        # Collect all issues from all iterations
+        all_issues: list[Issue] = []
+        for iteration in history:
+            if iteration.issues:
+                all_issues.extend(iteration.issues)
+
+        if not all_issues:
+            return False
+
+        # Group similar issues
+        groups = self.group_similar_issues(all_issues, similarity_threshold)
+
+        # Check if any group exceeds the threshold
+        return any(len(group) >= threshold for group in groups)
+
+    def get_recurring_issue_summary(
+        self,
+        task_id: str,
+        threshold: int = 2,
+        similarity_threshold: float = 0.8,
+    ) -> dict[str, Any]:
+        """Get a summary of recurring issues for a task.
+
+        Args:
+            task_id: ID of the task to analyze.
+            threshold: Minimum occurrences to consider an issue recurring.
+            similarity_threshold: Minimum similarity ratio for grouping.
+
+        Returns:
+            Dictionary with:
+                - recurring_issues: List of recurring issue summaries
+                - total_iterations: Total number of validation iterations
+        """
+        history = self.get_iteration_history(task_id)
+
+        if not history:
+            return {
+                "recurring_issues": [],
+                "total_iterations": 0,
+            }
+
+        # Collect all issues
+        all_issues: list[Issue] = []
+        for iteration in history:
+            if iteration.issues:
+                all_issues.extend(iteration.issues)
+
+        # Group similar issues
+        groups = self.group_similar_issues(all_issues, similarity_threshold)
+
+        # Filter to only recurring issues (meeting threshold)
+        recurring_issues = []
+        for group in groups:
+            if len(group) >= threshold:
+                # Use the first issue as the representative
+                representative = group[0]
+                recurring_issues.append(
+                    {
+                        "title": representative.title,
+                        "type": representative.issue_type.value,
+                        "severity": representative.severity.value,
+                        "location": representative.location,
+                        "count": len(group),
+                    }
+                )
+
+        # Sort by count descending
+        recurring_issues.sort(key=lambda x: int(x["count"] or 0), reverse=True)
+
+        return {
+            "recurring_issues": recurring_issues,
+            "total_iterations": len(history),
+        }

gobby/tasks/validation_models.py

@@ -0,0 +1,89 @@
+"""Validation models for Task System V2.
+
+Provides Issue dataclass and related enums for representing validation issues.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class IssueType(Enum):
+    """Types of issues that can occur during task validation."""
+
+    TEST_FAILURE = "test_failure"
+    LINT_ERROR = "lint_error"
+    ACCEPTANCE_GAP = "acceptance_gap"
+    TYPE_ERROR = "type_error"
+    SECURITY = "security"
+
+
+class IssueSeverity(Enum):
+    """Severity levels for validation issues."""
+
+    BLOCKER = "blocker"
+    MAJOR = "major"
+    MINOR = "minor"
+
+
+@dataclass
+class Issue:
+    """Represents a validation issue found during task verification.
+
+    Attributes:
+        issue_type: The category of issue (test failure, lint error, etc.)
+        severity: How critical the issue is (blocker, major, minor)
+        title: A short summary of the issue
+        location: File path and line number where the issue occurred (optional)
+        details: Extended description of the issue (optional)
+        suggested_fix: Recommended action to resolve the issue (optional)
+        recurring_count: Number of times this issue has recurred across iterations
+    """
+
+    issue_type: IssueType
+    severity: IssueSeverity
+    title: str
+    location: str | None = None
+    details: str | None = None
+    suggested_fix: str | None = None
+    recurring_count: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize Issue to dictionary for JSON storage."""
+        return {
+            "type": self.issue_type.value,
+            "severity": self.severity.value,
+            "title": self.title,
+            "location": self.location,
+            "details": self.details,
+            "suggested_fix": self.suggested_fix,
+            "recurring_count": self.recurring_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Issue":
+        """Deserialize Issue from dictionary.
+
+        Args:
+            data: Dictionary with issue fields. Required: type, severity, title.
+
+        Returns:
+            Issue instance
+
+        Raises:
+            KeyError: If required fields ("type", "severity", "title") are missing
+            ValueError: If type or severity values are invalid
+        """
+        # Parse enums - these will raise ValueError if invalid
+        issue_type = IssueType(data["type"])
+        severity = IssueSeverity(data["severity"])
+
+        return cls(
+            issue_type=issue_type,
+            severity=severity,
+            title=data["title"],
+            location=data.get("location"),
+            details=data.get("details"),
+            suggested_fix=data.get("suggested_fix"),
+            recurring_count=data.get("recurring_count", 0),
+        )

gobby/tools/summarizer.py

@@ -0,0 +1,170 @@
+"""
+Tool description summarization using Claude Agent SDK.
+
+Intelligently summarizes long MCP tool descriptions to fit within
+the 200-character limit for config file storage.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.config.app import ToolSummarizerConfig
+
+logger = logging.getLogger(__name__)
+
+# Maximum description length for tool summaries
+MAX_DESCRIPTION_LENGTH = 200
+
+# Module-level config reference (set by init_summarizer_config)
+_config: ToolSummarizerConfig | None = None
+
+
+def init_summarizer_config(config: ToolSummarizerConfig) -> None:
+    """Initialize the summarizer with configuration."""
+    global _config
+    _config = config
+
+
+def _get_config() -> ToolSummarizerConfig:
+    """Get the current config, with fallback to defaults."""
+    if _config is not None:
+        return _config
+    # Import here to avoid circular imports
+    from gobby.config.app import ToolSummarizerConfig
+
+    return ToolSummarizerConfig()
+
+
+async def _summarize_description_with_claude(description: str) -> str:
+    """
+    Summarize a tool description using Claude Agent SDK.
+
+    Args:
+        description: Long tool description to summarize
+
+    Returns:
+        Summarized description (max 180 chars)
+    """
+    config = _get_config()
+
+    try:
+        from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
+
+        prompt = config.prompt.format(description=description)
+
+        # Configure for single-turn completion
+        options = ClaudeAgentOptions(
+            system_prompt=config.system_prompt,
+            max_turns=1,
+            model=config.model,
+            allowed_tools=[],
+            permission_mode="default",
+        )
+
+        # Run async query
+        summary_text = ""
+        async for message in query(prompt=prompt, options=options):
+            if isinstance(message, AssistantMessage):
+                for block in message.content:
+                    if isinstance(block, TextBlock):
+                        summary_text = block.text
+        return summary_text.strip()
+
+    except Exception as e:
+        logger.warning(f"Failed to summarize description with Claude: {e}")
+        # Fallback: truncate to 200 chars with ellipsis
+        return description[:197] + "..." if len(description) > 200 else description
+
+
+async def summarize_tools(tools: list[Any]) -> list[dict[str, Any]]:
+    """
+    Create lightweight tool summaries with intelligent description shortening.
+
+    Args:
+        tools: List of MCP Tool objects with name, description, and inputSchema
+
+    Returns:
+        List of dicts with name, summarized description, and args:
+        [{"name": "tool_name", "description": "Short summary...", "args": {...}}]
+    """
+    summaries = []
+
+    for tool in tools:
+        description = tool.description or ""
+
+        # Summarize if needed
+        if len(description) > MAX_DESCRIPTION_LENGTH:
+            logger.debug(
+                f"Summarizing description for tool '{tool.name}' ({len(description)} chars)"
+            )
+            description = await _summarize_description_with_claude(description)
+
+        summaries.append(
+            {
+                "name": tool.name,
+                "description": description,
+                "args": tool.inputSchema if hasattr(tool, "inputSchema") else {},
+            }
+        )
+
+    return summaries
+
+
+async def generate_server_description(
+    server_name: str, tool_summaries: list[dict[str, Any]]
+) -> str:
+    """
+    Generate a concise server description from tool summaries.
+
+    Uses Claude Haiku to synthesize a single-sentence description of what
+    the MCP server does based on all its available tools.
+
+    Args:
+        server_name: Name of the MCP server
+        tool_summaries: List of tool summaries from summarize_tools()
+
+    Returns:
+        Single-sentence description (aiming for <100 chars)
+    """
+    config = _get_config()
+
+    try:
+        from claude_agent_sdk import AssistantMessage, ClaudeAgentOptions, TextBlock, query
+
+        # Build tools list for prompt
+        tools_list = "\n".join([f"- {t['name']}: {t['description']}" for t in tool_summaries])
+
+        prompt = config.server_description_prompt.format(
+            server_name=server_name,
+            tools_list=tools_list,
+        )
+
+        # Configure for single-turn completion
+        options = ClaudeAgentOptions(
+            system_prompt=config.server_description_system_prompt,
+            max_turns=1,
+            model=config.model,
+            allowed_tools=[],
+            permission_mode="default",
+        )
+
+        # Run async query
+        description = ""
+        async for message in query(prompt=prompt, options=options):
+            if isinstance(message, AssistantMessage):
+                for block in message.content:
+                    if isinstance(block, TextBlock):
+                        description = block.text
+
+        return description.strip()
+
+    except Exception as e:
+        logger.warning(f"Failed to generate server description for '{server_name}': {e}")
+        # Fallback: Generate simple description from first few tools
+        if tool_summaries:
+            first_tools = ", ".join([t["name"] for t in tool_summaries[:3]])
+            return f"Provides {first_tools} and more"
+        return f"MCP server: {server_name}"

gobby/tui/__init__.py

@@ -0,0 +1,5 @@
+"""Gobby TUI - Textual-based dashboard for Gobby daemon."""
+
+from gobby.tui.app import GobbyApp, run_tui
+
+__all__ = ["GobbyApp", "run_tui"]