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

tapps_agents/agents/reviewer/scoring.py

@@ -964,9 +964,7 @@ class CodeScorer(BaseScorer):
 
         Phase 6.2: Modern Quality Analysis - mypy Integration
         Phase 5 (P1): Fixed to actually run mypy and return real scores (not static 5.0).
-
-        Returns:
-            Type checking score (0-10), where 10 = no issues, 0 = many issues
+        ENH-002-S2: Prefer ScopedMypyExecutor (--follow-imports=skip, <10s) with fallback to full mypy.
         """
         if not self.has_mypy:
             logger.debug("mypy not available - returning neutral score")
@@ -976,10 +974,25 @@ class CodeScorer(BaseScorer):
         if file_path.suffix != ".py":
             return 10.0  # Perfect score for non-Python files (can't type check)
 
+        # ENH-002-S2: Try scoped mypy first (faster)
+        try:
+            from .tools.scoped_mypy import ScopedMypyExecutor
+            executor = ScopedMypyExecutor()
+            result = executor.run_scoped_sync(file_path, timeout=10)
+            if result.files_checked == 1 or result.issues:
+                error_count = len(result.issues)
+                if error_count == 0:
+                    return 10.0
+                score = 10.0 - (error_count * 0.5)
+                logger.debug(
+                    "mypy (scoped) found %s errors for %s, score: %s/10",
+                    error_count, file_path, score,
+                )
+                return max(0.0, min(10.0, score))
+        except Exception as e:
+            logger.debug("scoped mypy not used, falling back to full mypy: %s", e)
+
         try:
-            # Phase 5 fix: Actually run mypy and parse errors
-            # Run mypy with show-error-codes for better error parsing
-            # Optimization (ENH-002): Scoped to single file with --no-incremental for 6x speedup
             result = subprocess.run(  # nosec B603
                 [
                     sys.executable,
@@ -988,63 +1001,44 @@ class CodeScorer(BaseScorer):
                     "--show-error-codes",
                     "--no-error-summary",
                     "--no-color-output",
-                    "--no-incremental",  # Skip cache for single-file check (faster)
+                    "--no-incremental",
                     str(file_path),
                 ],
                 capture_output=True,
                 text=True,
                 encoding="utf-8",
                 errors="replace",
-                timeout=30,  # 30 second timeout (optimized from 60s for single file)
+                timeout=30,
                 cwd=file_path.parent if file_path.parent.exists() else None,
             )
-
-            # Phase 5 fix: Parse mypy output correctly
             if result.returncode == 0:
-                # No type errors found - return perfect score
-                logger.debug(f"mypy found no errors for {file_path}")
+                logger.debug("mypy found no errors for %s", file_path)
                 return 10.0
-
-            # mypy returns non-zero exit code when errors found
-            # mypy outputs errors to stdout (not stderr)
             output = result.stdout.strip()
             if not output:
-                # No output but non-zero return code - assume success
-                logger.debug(f"mypy returned non-zero but no output for {file_path}")
+                logger.debug("mypy returned non-zero but no output for %s", file_path)
                 return 10.0
-
-            # Parse mypy error output
-            # Format: filename:line: error: message [error-code]
-            # Or: filename:line:column: error: message [error-code]
             error_lines = [
                 line
                 for line in output.split("\n")
                 if "error:" in line.lower() and file_path.name in line
             ]
             error_count = len(error_lines)
-
             if error_count == 0:
-                # No errors found despite non-zero return code (e.g., config issues)
-                logger.debug(f"mypy returned non-zero but no parseable errors for {file_path}")
+                logger.debug("mypy returned non-zero but no parseable errors for %s", file_path)
                 return 10.0
-
-            # Phase 5 fix: Calculate score based on actual error count
-            # Formula: 10 - (errors * 0.5), but cap at 0.0
             score = 10.0 - (error_count * 0.5)
-            logger.debug(f"mypy found {error_count} errors for {file_path}, score: {score:.1f}/10")
+            logger.debug("mypy found %s errors for %s, score: %s/10", error_count, file_path, score)
             return max(0.0, min(10.0, score))
-
         except subprocess.TimeoutExpired:
-            logger.warning(f"mypy timed out for {file_path}")
-            return 5.0  # Neutral on timeout
+            logger.warning("mypy timed out for %s", file_path)
+            return 5.0
         except FileNotFoundError:
-            # mypy not found in PATH
-            logger.debug(f"mypy not found in PATH for {file_path}")
-            self.has_mypy = False  # Update availability flag
+            logger.debug("mypy not found in PATH for %s", file_path)
+            self.has_mypy = False
             return 5.0
         except Exception as e:
-            # Any other error
-            logger.warning(f"mypy failed for {file_path}: {e}", exc_info=True)
+            logger.warning("mypy failed for %s: %s", file_path, e, exc_info=True)
             return 5.0
 
     def get_mypy_errors(self, file_path: Path) -> list[dict[str, Any]]:
@@ -1052,15 +1046,30 @@ class CodeScorer(BaseScorer):
         Get detailed mypy type checking errors for a file.
 
         Phase 6.2: Modern Quality Analysis - mypy Integration
-
-        Returns:
-            List of error dictionaries with line, message, error_code, etc.
+        ENH-002-S2: Prefer ScopedMypyExecutor with fallback to full mypy.
         """
         if not self.has_mypy or file_path.suffix != ".py":
             return []
 
         try:
-            # Optimization (ENH-002): Scoped to single file with --no-incremental for 6x speedup
+            from .tools.scoped_mypy import ScopedMypyExecutor
+            executor = ScopedMypyExecutor()
+            result = executor.run_scoped_sync(file_path, timeout=10)
+            if result.files_checked == 1 or result.issues:
+                return [
+                    {
+                        "filename": str(i.file_path),
+                        "line": i.line,
+                        "message": i.message,
+                        "error_code": i.error_code,
+                        "severity": i.severity,
+                    }
+                    for i in result.issues
+                ]
+        except Exception:
+            pass
+
+        try:
             result = subprocess.run(  # nosec B603
                 [
                     sys.executable,
@@ -1068,32 +1077,22 @@ class CodeScorer(BaseScorer):
                     "mypy",
                     "--show-error-codes",
                     "--no-error-summary",
-                    "--no-incremental",  # Skip cache for single-file check (faster)
+                    "--no-incremental",
                     str(file_path),
                 ],
                 capture_output=True,
                 text=True,
                 encoding="utf-8",
                 errors="replace",
-                timeout=30,  # Optimized from 60s for single file
+                timeout=30,
                 cwd=file_path.parent if file_path.parent.exists() else None,
             )
-
-            if result.returncode == 0:
-                # No errors
-                return []
-
-            if not result.stdout.strip():
+            if result.returncode == 0 or not result.stdout.strip():
                 return []
-
-            # Parse mypy error output
-            # Format: filename:line: error: message [error-code]
             errors = []
             for line in result.stdout.strip().split("\n"):
                 if "error:" not in line.lower():
                     continue
-
-                # Parse line: "file.py:12: error: Missing return type [func-returns]"
                 parts = line.split(":", 3)
                 if len(parts) >= 4:
                     filename = parts[0]
@@ -1101,10 +1100,7 @@ class CodeScorer(BaseScorer):
                         line_num = int(parts[1])
                     except ValueError:
                         continue
-
                     error_msg = parts[3].strip()
-
-                    # Extract error code (if present)
                     error_code = None
                     if "[" in error_msg and "]" in error_msg:
                         start = error_msg.rfind("[")
@@ -1112,19 +1108,14 @@ class CodeScorer(BaseScorer):
                         if start < end:
                             error_code = error_msg[start + 1 : end]
                             error_msg = error_msg[:start].strip()
-
-                    errors.append(
-                        {
-                            "filename": filename,
-                            "line": line_num,
-                            "message": error_msg,
-                            "error_code": error_code,
-                            "severity": "error",
-                        }
-                    )
-
+                    errors.append({
+                        "filename": filename,
+                        "line": line_num,
+                        "message": error_msg,
+                        "error_code": error_code,
+                        "severity": "error",
+                    })
             return errors
-
         except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
             return []
 

tapps_agents/agents/reviewer/tools/__init__.py

@@ -8,9 +8,33 @@ from .parallel_executor import (
     ToolResult,
     ToolStatus,
 )
+from .ruff_grouping import (
+    GroupedRuffIssues,
+    RuffGroupingConfig,
+    RuffGroupingParser,
+    RuffIssue,
+    RuffParsingError,
+)
+from .scoped_mypy import (
+    MypyIssue,
+    MypyResult,
+    MypyTimeoutError,
+    ScopedMypyConfig,
+    ScopedMypyExecutor,
+)
 
 __all__ = [
+    "GroupedRuffIssues",
+    "MypyIssue",
+    "MypyResult",
+    "MypyTimeoutError",
     "ParallelToolExecutor",
+    "RuffGroupingConfig",
+    "RuffGroupingParser",
+    "RuffIssue",
+    "RuffParsingError",
+    "ScopedMypyConfig",
+    "ScopedMypyExecutor",
     "ToolExecutionConfig",
     "ToolResult",
     "ToolStatus",

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)