tapps-agents 3.5.39__py3-none-any.whl → 3.5.40__py3-none-any.whl

tapps_agents/agents/reviewer/tools/ruff_grouping.py

@@ -0,0 +1,250 @@
+"""
+Ruff Output Grouping - ENH-002-S3
+
+Parses Ruff JSON output and groups issues by error code for cleaner reports.
+Sorts by severity (error > warning > info), then by count.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class RuffParsingError(Exception):
+    """Ruff output parsing failed."""
+
+    def __init__(self, reason: str) -> None:
+        self.reason = reason
+        super().__init__(f"Ruff parsing failed: {reason}")
+
+
+@dataclass(frozen=True)
+class RuffIssue:
+    """Single Ruff linting issue."""
+
+    code: str
+    message: str
+    line: int
+    column: int
+    severity: str
+    fixable: bool
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "code": self.code,
+            "message": self.message,
+            "line": self.line,
+            "column": self.column,
+            "severity": self.severity,
+            "fixable": self.fixable,
+        }
+
+
+@dataclass(frozen=True)
+class GroupedRuffIssues:
+    """Grouped Ruff issues by error code."""
+
+    groups: dict[str, tuple[RuffIssue, ...]]
+    total_issues: int
+    unique_codes: int
+    severity_summary: dict[str, int]
+    fixable_count: int
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "groups": {
+                code: [i.to_dict() for i in issues]
+                for code, issues in self.groups.items()
+            },
+            "total_issues": self.total_issues,
+            "unique_codes": self.unique_codes,
+            "severity_summary": self.severity_summary,
+            "fixable_count": self.fixable_count,
+        }
+
+
+@dataclass(frozen=True)
+class RuffGroupingConfig:
+    """Configuration for Ruff grouping."""
+
+    enabled: bool = True
+    sort_by: str = "severity"
+    include_fix_suggestions: bool = True
+    max_issues_per_group: int = 10
+
+
+def _severity_order(severity: str) -> int:
+    """Lower = higher priority (error=0, warning=1, info=2)."""
+    order = {"error": 0, "warning": 1, "info": 2, "fatal": 0}
+    return order.get(severity.lower(), 1)
+
+
+class RuffGroupingParser:
+    """
+    Parse Ruff JSON and group issues by error code.
+
+    Sorts groups by severity then count; supports markdown, HTML, JSON output.
+    """
+
+    def __init__(self, config: RuffGroupingConfig | None = None) -> None:
+        self.config = config or RuffGroupingConfig()
+
+    def parse_and_group(self, ruff_json: str) -> GroupedRuffIssues:
+        """
+        Parse Ruff JSON output and group by error code.
+
+        Ruff JSON is a list of diagnostics; each has "code" (dict with "name"),
+        "message", "location" (row, column), "fix" (optional).
+        """
+        try:
+            data = json.loads(ruff_json) if ruff_json.strip() else []
+        except json.JSONDecodeError as e:
+            raise RuffParsingError(str(e)) from e
+        if not isinstance(data, list):
+            raise RuffParsingError("Expected a JSON array of diagnostics")
+
+        issues: list[RuffIssue] = []
+        for diag in data:
+            if not isinstance(diag, dict):
+                continue
+            code_info = diag.get("code")
+            if isinstance(code_info, dict):
+                code = code_info.get("name") or code_info.get("code") or "unknown"
+            else:
+                code = str(code_info) if code_info else "unknown"
+            message = diag.get("message", "")
+            loc = diag.get("location", {}) or {}
+            row = int(loc.get("row", 0)) if isinstance(loc, dict) else 0
+            col = int(loc.get("column", 0)) if isinstance(loc, dict) else 0
+            fix = diag.get("fix")
+            fixable = fix is not None and fix != {}
+            severity = "error"
+            if isinstance(code_info, dict):
+                severity = (code_info.get("severity") or "error").lower()
+            if code.startswith("E") or code.startswith("F"):
+                severity = "error"
+            elif code.startswith("W"):
+                severity = "warning"
+            elif code.startswith("I"):
+                severity = "info"
+            issues.append(
+                RuffIssue(
+                    code=code,
+                    message=message,
+                    line=row,
+                    column=col,
+                    severity=severity,
+                    fixable=fixable,
+                )
+            )
+
+        groups: dict[str, list[RuffIssue]] = {}
+        severity_summary: dict[str, int] = {}
+        fixable_count = 0
+        for i in issues:
+            groups.setdefault(i.code, []).append(i)
+            severity_summary[i.severity] = severity_summary.get(i.severity, 0) + 1
+            if i.fixable:
+                fixable_count += 1
+
+        return GroupedRuffIssues(
+            groups={k: tuple(v) for k, v in groups.items()},
+            total_issues=len(issues),
+            unique_codes=len(groups),
+            severity_summary=severity_summary,
+            fixable_count=fixable_count,
+        )
+
+    def sort_groups(
+        self,
+        groups: dict[str, tuple[RuffIssue, ...]],
+        by: str = "severity",
+    ) -> list[tuple[str, tuple[RuffIssue, ...]]]:
+        """
+        Sort groups by severity (error > warning > info), then count, then code.
+        """
+        items = list(groups.items())
+        if by == "code":
+            return sorted(items, key=lambda x: x[0])
+        if by == "count":
+            return sorted(items, key=lambda x: -len(x[1]))
+        # severity: worst severity first, then by count descending
+        def key(item: tuple[str, tuple[RuffIssue, ...]]) -> tuple[int, int, str]:
+            code, iss = item
+            min_sev = min(_severity_order(i.severity) for i in iss)
+            return (min_sev, -len(iss), code)
+
+        return sorted(items, key=key)
+
+    def render_grouped(
+        self,
+        grouped: GroupedRuffIssues,
+        format: str = "markdown",
+    ) -> str:
+        """Render grouped issues as markdown, HTML, or JSON."""
+        sorted_pairs = self.sort_groups(grouped.groups, by=self.config.sort_by)
+        if format == "json":
+            return json.dumps(grouped.to_dict(), indent=2)
+        if format == "markdown":
+            return self._render_markdown(sorted_pairs, grouped)
+        if format == "html":
+            return self._render_html(sorted_pairs, grouped)
+        return self._render_markdown(sorted_pairs, grouped)
+
+    def _render_markdown(
+        self,
+        sorted_pairs: list[tuple[str, tuple[RuffIssue, ...]]],
+        grouped: GroupedRuffIssues,
+    ) -> str:
+        lines = [
+            "### Issues by Code",
+            "",
+            f"Total: {grouped.total_issues} issues in {grouped.unique_codes} categories.",
+        ]
+        if self.config.include_fix_suggestions and grouped.fixable_count:
+            lines.append(f"*{grouped.fixable_count} auto-fixable*")
+            lines.append("")
+        max_per = self.config.max_issues_per_group
+        for code, iss in sorted_pairs:
+            fixable = sum(1 for i in iss if i.fixable)
+            sev = iss[0].severity if iss else "error"
+            lines.append(f"#### {code} ({len(iss)} issues, {sev})")
+            if self.config.include_fix_suggestions and fixable:
+                lines.append(f"*{fixable} auto-fixable*")
+            for i in iss[:max_per]:
+                lines.append(f"- Line {i.line}: {i.message}")
+            if len(iss) > max_per:
+                lines.append(f"- ... and {len(iss) - max_per} more")
+            lines.append("")
+        return "\n".join(lines).strip()
+
+    def _render_html(
+        self,
+        sorted_pairs: list[tuple[str, tuple[RuffIssue, ...]]],
+        grouped: GroupedRuffIssues,
+    ) -> str:
+        lines = [
+            "<div class='ruff-grouped'>",
+            f"<p>Total: {grouped.total_issues} issues in {grouped.unique_codes} categories.</p>",
+        ]
+        for code, iss in sorted_pairs:
+            fixable = sum(1 for i in iss if i.fixable)
+            sev = iss[0].severity if iss else "error"
+            lines.append(f"<details><summary>{code} ({len(iss)} issues, {sev})")
+            if fixable:
+                lines.append(f" — {fixable} auto-fixable")
+            lines.append("</summary><ul>")
+            for i in iss[: self.config.max_issues_per_group]:
+                lines.append(f"<li>Line {i.line}: {i.message}</li>")
+            if len(iss) > self.config.max_issues_per_group:
+                lines.append(f"<li>... and {len(iss) - self.config.max_issues_per_group} more</li>")
+            lines.append("</ul></details>")
+        lines.append("</div>")
+        return "\n".join(lines)

tapps_agents/agents/reviewer/tools/scoped_mypy.py

@@ -0,0 +1,284 @@
+"""
+Scoped Mypy Executor - ENH-002-S2
+
+Runs mypy with file-level scoping for ~70% performance improvement.
+Uses --follow-imports=skip and --no-site-packages; filters results to target file only.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+import subprocess  # nosec B404 - fixed args, no shell
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class MypyTimeoutError(Exception):
+    """Mypy execution timed out."""
+
+    def __init__(self, timeout: int) -> None:
+        self.timeout = timeout
+        super().__init__(f"Mypy timed out after {timeout}s")
+
+
+@dataclass(frozen=True)
+class MypyIssue:
+    """Single mypy type checking issue."""
+
+    file_path: Path
+    line: int
+    column: int
+    severity: str
+    message: str
+    error_code: str | None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "file_path": str(self.file_path),
+            "line": self.line,
+            "column": self.column,
+            "severity": self.severity,
+            "message": self.message,
+            "error_code": self.error_code,
+        }
+
+
+@dataclass(frozen=True)
+class MypyResult:
+    """Result of scoped mypy execution."""
+
+    issues: tuple[MypyIssue, ...]
+    duration_seconds: float
+    files_checked: int
+    success: bool
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "issues": [i.to_dict() for i in self.issues],
+            "duration_seconds": self.duration_seconds,
+            "files_checked": self.files_checked,
+            "success": self.success,
+        }
+
+
+@dataclass(frozen=True)
+class ScopedMypyConfig:
+    """Configuration for scoped mypy execution."""
+
+    enabled: bool = True
+    timeout: int = 10
+    flags: tuple[str, ...] = (
+        "--follow-imports=skip",
+        "--no-site-packages",
+        "--show-column-numbers",
+        "--show-error-codes",
+        "--no-error-summary",
+        "--no-color-output",
+        "--no-incremental",
+    )
+
+
+class ScopedMypyExecutor:
+    """
+    Execute mypy with scoped imports for performance.
+
+    Uses --follow-imports=skip, --no-site-packages and filters results
+    to the target file only. Target: <10s vs 30-60s unscoped.
+    """
+
+    def __init__(self, config: ScopedMypyConfig | None = None) -> None:
+        self.config = config or ScopedMypyConfig()
+        self._logger = logging.getLogger(__name__)
+
+    def get_scoped_flags(self) -> list[str]:
+        """Return mypy flags for scoped execution."""
+        return list(self.config.flags)
+
+    def parse_output(self, raw_output: str, file_path: Path) -> list[MypyIssue]:
+        """
+        Parse mypy stdout and return issues for the target file only.
+
+        Mypy format: file.py:line:col: severity: message [error-code]
+        or file.py:line: severity: message [error-code]
+        """
+        issues: list[MypyIssue] = []
+        target_name = file_path.name
+        target_resolved = str(file_path.resolve()).replace("\\", "/")
+
+        for line in raw_output.splitlines():
+            line = line.strip()
+            if not line or "error:" not in line.lower():
+                continue
+            # Match file:line:col: severity: message [code] or file:line: severity: message [code]
+            match = re.match(
+                r"^(.+?):(\d+):(?:\d+:)?\s*(error|warning|note):\s*(.+)$",
+                line,
+                re.IGNORECASE,
+            )
+            if not match:
+                continue
+            path_part, line_str, severity, rest = match.groups()
+            path_part = path_part.replace("\\", "/")
+            if target_name not in path_part and target_resolved not in path_part:
+                try:
+                    if Path(path_part).resolve() != file_path.resolve():
+                        continue
+                except Exception:
+                    continue
+            try:
+                line_num = int(line_str)
+            except ValueError:
+                continue
+            col_num = 0
+            if ":" in line:
+                col_match = re.match(r"^.+?:\d+:(\d+):", line)
+                if col_match:
+                    try:
+                        col_num = int(col_match.group(1))
+                    except ValueError:
+                        pass
+            error_code = None
+            if "[" in rest and "]" in rest:
+                start = rest.rfind("[")
+                end = rest.rfind("]")
+                if start < end:
+                    error_code = rest[start + 1 : end].strip()
+                    rest = rest[:start].strip()
+            issues.append(
+                MypyIssue(
+                    file_path=file_path,
+                    line=line_num,
+                    column=col_num,
+                    severity=severity.strip().lower(),
+                    message=rest.strip(),
+                    error_code=error_code,
+                )
+            )
+        return issues
+
+    async def execute_scoped(
+        self,
+        file_path: Path,
+        *,
+        timeout: int | None = None,
+    ) -> MypyResult:
+        """
+        Run mypy on a single file with scoped flags and filter to that file.
+
+        On timeout, returns a result with success=False and empty issues
+        (graceful fallback; caller can run full mypy if needed).
+        """
+        timeout_sec = timeout if timeout is not None else self.config.timeout
+        if not file_path.is_file():
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )
+        cmd = [sys.executable, "-m", "mypy"] + self.get_scoped_flags() + [str(file_path)]
+        cwd = file_path.parent if file_path.parent.exists() else None
+        start = time.monotonic()
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=cwd,
+            )
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    proc.communicate(), timeout=timeout_sec
+                )
+            except TimeoutError:
+                proc.kill()
+                await proc.wait()
+                elapsed = time.monotonic() - start
+                self._logger.warning(
+                    "mypy timed out for %s after %.2fs", file_path, elapsed
+                )
+                raise MypyTimeoutError(timeout_sec)
+            elapsed = time.monotonic() - start
+            out = (stdout or b"").decode("utf-8", errors="replace")
+            issues = self.parse_output(out, file_path)
+            return MypyResult(
+                issues=tuple(issues),
+                duration_seconds=elapsed,
+                files_checked=1,
+                success=proc.returncode == 0 or not issues,
+            )
+        except MypyTimeoutError as e:
+            raise e from None
+        except FileNotFoundError:
+            self._logger.debug("mypy not found")
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )
+        except Exception as e:
+            self._logger.warning("mypy failed for %s: %s", file_path, e)
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )
+
+    def run_scoped_sync(
+        self,
+        file_path: Path,
+        *,
+        timeout: int | None = None,
+    ) -> MypyResult:
+        """
+        Run mypy synchronously with scoped flags (for use from scoring.py).
+        Uses subprocess.run to avoid event loop issues in sync callers.
+        """
+        timeout_sec = timeout if timeout is not None else self.config.timeout
+        if not file_path.is_file():
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )
+        cmd = [sys.executable, "-m", "mypy"] + self.get_scoped_flags() + [str(file_path)]
+        cwd = file_path.parent if file_path.parent.exists() else None
+        start = time.monotonic()
+        try:
+            result = subprocess.run(  # nosec B603
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=timeout_sec,
+                cwd=cwd,
+            )
+            elapsed = time.monotonic() - start
+            out = (result.stdout or "").strip()
+            issues = self.parse_output(out, file_path)
+            return MypyResult(
+                issues=tuple(issues),
+                duration_seconds=elapsed,
+                files_checked=1,
+                success=result.returncode == 0 or not issues,
+            )
+        except subprocess.TimeoutExpired:
+            elapsed = time.monotonic() - start
+            self._logger.warning("mypy timed out for %s after %.2fs", file_path, elapsed)
+            return MypyResult(
+                issues=(),
+                duration_seconds=elapsed,
+                files_checked=0,
+                success=False,
+            )
+        except FileNotFoundError:
+            self._logger.debug("mypy not found")
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )
+        except Exception as e:
+            self._logger.warning("mypy failed for %s: %s", file_path, e)
+            return MypyResult(
+                issues=(), duration_seconds=0.0, files_checked=0, success=False
+            )

tapps_agents/beads/__init__.py

@@ -2,6 +2,7 @@
 Beads (bd) integration: optional task-tracking for agents.
 
 Use is_available(project_root) before run_bd. See docs/BEADS_INTEGRATION.md.
+Task specs: .tapps-agents/task-specs/ for hydration/dehydration.
 """
 
 from .client import (
@@ -13,6 +14,9 @@ from .client import (
     run_bd,
 )
 from .parse import parse_bd_id_from_stdout
+from .specs import TaskSpec, load_task_spec, load_task_specs, save_task_spec
+
+from .hydration import HydrationReport, dehydrate_from_beads, hydrate_to_beads
 
 __all__ = [
     "BeadsRequiredError",
@@ -22,4 +26,11 @@ __all__ = [
     "require_beads",
     "resolve_bd_path",
     "run_bd",
+    "TaskSpec",
+    "HydrationReport",
+    "dehydrate_from_beads",
+    "hydrate_to_beads",
+    "load_task_spec",
+    "load_task_specs",
+    "save_task_spec",
 ]