patchi 0.7.5__py3-none-any.whl

patchi/core/agents/core_scanner.py

@@ -0,0 +1,269 @@
+"""
+CoreScanner — AST analysis: functions, classes, exports, purpose.
+
+Parses all source files with tree-sitter. Extracts:
+- Functions (name, params, line, is_async, decorators)
+- Classes (name, base classes, line)
+- Exports (named, default, types)
+- Entry points (main, app.listen, etc.)
+- Purpose (via AI classification per file)
+
+Does NOT call AI (that's the fix agents' job).
+Does NOT write to disk.
+Does NOT touch the queue.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import PurePosixPath
+
+from ..brain.languages import (
+    DEFAULT_IGNORE_DIRS,
+    Lang,
+    get_parser,
+)
+from ..brain.scanner import FileScanner
+from .base import (
+    AgentGroup,
+    AgentInput,
+    AgentResult,
+    BaseAgent,
+    Finding,
+    Severity,
+    make_finding,
+    register,
+)
+
+
+@register
+class CoreScanner(BaseAgent):
+    """Core scanner for AST analysis of source files."""
+
+    group = AgentGroup.SCANNER
+    name = "CoreScanner"
+    description = "Main application files: functions, classes, exports, entry points, purpose"
+
+    def _run(self, inp: AgentInput, result: AgentResult) -> None:
+        """Scan core application files for structure and purpose.
+
+        Populates `result.data['file_map']` and `result.data['language_breakdown']`.
+        Adds `parse_error` findings when parsing fails.
+        """
+        start_time = time.time()
+
+        scanner = FileScanner(root=inp.root, ignore_paths=inp.config.get("ignore_paths", []))
+        try:
+            infos = scanner.scan(area=None, on_progress=None)
+        except Exception as e:
+            result.add_error(f"FileScanner failed: {e}")
+            return
+
+        file_map: dict = {}
+        lang_breakdown: dict = {}
+        parsed_count = 0
+
+        for info in infos:
+            # Skip files per restrictions
+            if self._should_skip_file(info.path, inp):
+                continue
+
+            parsed_count += 1
+            file_map[info.path] = {
+                "purpose": info.purpose or "",
+                "type": info.language.value,
+            }
+
+            lang_breakdown.setdefault(info.language.value, 0)
+            lang_breakdown[info.language.value] += 1
+
+            # Report parse errors as findings
+            if info.error:
+                result.add_finding(
+                    make_finding(
+                        agent=self.name,
+                        finding_type="parse_error",
+                        severity=Severity.LOW,
+                        file=info.path,
+                        message="Parse error",
+                        line=0,
+                        detail=info.error,
+                    )
+                )
+
+        duration = time.time() - start_time
+
+        result.data["file_map"] = file_map
+        result.data["language_breakdown"] = lang_breakdown
+        result.data["needs_ai"] = True
+        result.files_scanned = parsed_count
+        result.data["duration"] = round(duration, 2)
+
+    def _should_skip_file(self, file_path: str, inp: AgentInput) -> bool:
+        """Check if file should be skipped based on restrictions."""
+        # Check restrictions
+        # Skip ignored directories (node_modules, .venv, etc.)
+        if any(p in DEFAULT_IGNORE_DIRS for p in PurePosixPath(file_path).parts):
+            return True
+
+        restrictions = inp.config.get("restrictions", [])
+        for r in restrictions:
+            if r.get("enabled", True):
+                path = r["path"]
+                if file_path.startswith(path) or PurePosixPath(file_path).match(path):
+                    if r["type"] == "NO_TOUCH":
+                        return True
+                    elif r["type"] == "SCAN_ONLY" and self.__class__.__name__ == "FixAgent":
+                        return True
+        return False
+
+    def _extract_basic_info(self, file_path: str, content: str) -> list[Finding]:
+        """Extract basic info for unsupported languages."""
+        lines = content.splitlines()
+        findings = []
+
+        # Look for common patterns in any text file
+        for i, line in enumerate(lines, 1):
+            if any(
+                keyword in line.lower()
+                for keyword in ["entry", "main", "start", "init", "constructor"]
+            ):
+                findings.append(
+                    make_finding(
+                        severity=Severity.INFO,
+                        file=file_path,
+                        line_start=i,
+                        title="Potential entry point",
+                        description=line.strip(),
+                        evidence=line.strip(),
+                    )
+                )
+
+        return findings
+
+    def _parse_with_treesitter(self, file_path: str, content: str, lang: Lang) -> list[Finding]:
+        """Parse file with tree-sitter and extract structured info."""
+        try:
+            parser, lang_obj = get_parser(lang)
+            tree = parser.parse(bytes(content, "utf8"))
+
+            findings = []
+            self._walk_tree(tree.root_node, file_path, content, findings, lang)
+            return findings
+        except Exception as e:
+            return [
+                make_finding(
+                    severity=Severity.LOW,
+                    file=file_path,
+                    line_start=0,
+                    title="Tree-sitter parse error",
+                    description=f"Failed to parse with tree-sitter: {str(e)}",
+                    evidence=str(e),
+                )
+            ]
+
+    def _walk_tree(self, node, file_path: str, content: str, findings: list[Finding], lang: Lang):
+        """Walk the AST tree and extract relevant nodes."""
+        if node.type in ["function_definition", "function", "method_definition"]:
+            self._extract_function(node, file_path, content, findings, lang)
+        elif node.type in ["class_definition", "class", "class_declaration"]:
+            self._extract_class(node, file_path, content, findings, lang)
+        elif node.type in ["import_statement", "import_declaration"]:
+            self._extract_import(node, file_path, content, findings, lang)
+        elif node.type in ["export_statement", "export_declaration"]:
+            self._extract_export(node, file_path, content, findings, lang)
+
+        # Recursively walk children
+        for child in node.children:
+            self._walk_tree(child, file_path, content, findings, lang)
+
+    def _extract_function(
+        self, node, file_path: str, content: str, findings: list[Finding], lang: Lang
+    ):
+        """Extract function information."""
+        # Get function name
+        name_node = None
+        for child in node.children:
+            if child.type in ["identifier", "function_name"]:
+                name_node = child
+                break
+
+        if name_node:
+            func_name = content[name_node.start_byte : name_node.end_byte]
+            line_no = name_node.start_point[0] + 1
+
+            findings.append(
+                make_finding(
+                    severity=Severity.INFO,
+                    file=file_path,
+                    line_start=line_no,
+                    title=f"Function: {func_name}",
+                    description=f"Defined at line {line_no}",
+                    evidence=content[node.start_byte : node.end_byte][:100] + "..."
+                    if node.end_byte - node.start_byte > 100
+                    else content[node.start_byte : node.end_byte],
+                )
+            )
+
+    def _extract_class(
+        self, node, file_path: str, content: str, findings: list[Finding], lang: Lang
+    ):
+        """Extract class information."""
+        name_node = None
+        for child in node.children:
+            if child.type in ["identifier", "type_identifier", "class_name"]:
+                name_node = child
+                break
+
+        if name_node:
+            class_name = content[name_node.start_byte : name_node.end_byte]
+            line_no = name_node.start_point[0] + 1
+
+            findings.append(
+                make_finding(
+                    severity=Severity.INFO,
+                    file=file_path,
+                    line_start=line_no,
+                    title=f"Class: {class_name}",
+                    description=f"Defined at line {line_no}",
+                    evidence=content[node.start_byte : node.end_byte][:100] + "..."
+                    if node.end_byte - node.start_byte > 100
+                    else content[node.start_byte : node.end_byte],
+                )
+            )
+
+    def _extract_import(
+        self, node, file_path: str, content: str, findings: list[Finding], lang: Lang
+    ):
+        """Extract import information."""
+        import_text = content[node.start_byte : node.end_byte]
+        line_no = node.start_point[0] + 1
+
+        findings.append(
+            make_finding(
+                severity=Severity.INFO,
+                file=file_path,
+                line_start=line_no,
+                title="Import statement",
+                description=import_text,
+                evidence=import_text,
+            )
+        )
+
+    def _extract_export(
+        self, node, file_path: str, content: str, findings: list[Finding], lang: Lang
+    ):
+        """Extract export information."""
+        export_text = content[node.start_byte : node.end_byte]
+        line_no = node.start_point[0] + 1
+
+        findings.append(
+            make_finding(
+                severity=Severity.INFO,
+                file=file_path,
+                line_start=line_no,
+                title="Export statement",
+                description=export_text,
+                evidence=export_text,
+            )
+        )

patchi/core/agents/coverage_prioritizer.py

@@ -0,0 +1,181 @@
+"""CoveragePrioritizerAgent — ranks uncovered code by git churn frequency.
+
+Covers §6.1.1:
+- Parse coverage reports (.coverage, lcov, cobertura)
+- Cross-ref with git blame frequency per file
+- Highlight \"hot\" files (high churn) with low coverage as priority targets
+"""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+from collections import defaultdict
+from pathlib import Path
+
+from .base import (
+    AgentGroup,
+    AgentInput,
+    AgentResult,
+    AgentStatus,
+    BaseAgent,
+    Severity,
+    make_finding,
+    register,
+    safe_rglob,
+)
+
+_log = logging.getLogger("patchi.agents.coverage_prioritizer")
+
+
+def _get_git_churn(root: Path, max_files: int = 100) -> dict[str, int]:
+    """Get commit count per file via git log."""
+    churn: dict[str, int] = defaultdict(int)
+    try:
+        result = subprocess.run(
+            ["git", "log", "--name-only", "--pretty=format:", "-1000"],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        for line in result.stdout.splitlines():
+            line = line.strip()
+            if line and Path(line).suffix in (
+                ".py",
+                ".js",
+                ".ts",
+                ".rs",
+                ".go",
+                ".java",
+                ".c",
+                ".cpp",
+                ".swift",
+                ".rb",
+                ".svelte",
+                ".jsx",
+                ".tsx",
+            ):
+                churn[line] += 1
+    except Exception as e:
+        _log.debug("_get_git_churn failed: %s", e)
+    return dict(sorted(churn.items(), key=lambda x: -x[1])[:max_files])
+
+
+def _parse_lcov(root: Path) -> set[str]:
+    """Parse lcov coverage files — extract files with <80% coverage."""
+    low_coverage: set[str] = set()
+    for lcov_file in safe_rglob(root, "*.info"):
+        try:
+            content = lcov_file.read_text(encoding="utf-8")
+        except Exception as e:
+            _log.debug("_parse_lcov failed: %s", e)
+            continue
+        current_file = ""
+        total_lines = 0
+        covered_lines = 0
+        for line in content.splitlines():
+            if line.startswith("SF:"):
+                current_file = line[3:]
+            elif line.startswith("DA:"):
+                total_lines += 1
+                _, hits = line.split(",", 1)
+                if int(hits) > 0:
+                    covered_lines += 1
+            elif line.startswith("end_of_record"):
+                if total_lines > 0:
+                    pct = covered_lines / total_lines * 100
+                    if pct < 80:
+                        try:
+                            rel = Path(current_file).relative_to(root).as_posix()
+                            low_coverage.add(rel)
+                        except ValueError:
+                            low_coverage.add(current_file)
+                current_file = ""
+                total_lines = 0
+                covered_lines = 0
+    return low_coverage
+
+
+def _parse_coverage_json(root: Path) -> set[str]:
+    """Parse .coverage or coverage.json files."""
+    low_coverage: set[str] = set()
+    for cov_file in safe_rglob(root, ".coverage"):
+        if cov_file.is_file():
+            continue
+    for cov_file in safe_rglob(root, "coverage.json"):
+        try:
+            import json
+
+            data = json.loads(cov_file.read_text(encoding="utf-8"))
+            for file_path, info in data.items():
+                if isinstance(info, dict):
+                    total = (
+                        info.get("lines", {}).get("total", 0)
+                        or info.get("totals", {}).get("lines", {}).get("count", 0)
+                        or 0
+                    )
+                    covered = (
+                        info.get("lines", {}).get("covered", 0)
+                        or info.get("totals", {}).get("lines", {}).get("covered", 0)
+                        or 0
+                    )
+                    if total > 0 and (covered / total * 100) < 80:
+                        low_coverage.add(file_path)
+        except Exception as e:
+            _log.debug("_parse_coverage_json failed: %s", e)
+    return low_coverage
+
+
+@register
+class CoveragePrioritizerAgent(BaseAgent):
+    """Ranks uncovered code by git churn frequency — hot files missing tests."""
+
+    group = AgentGroup.SCANNER
+    name = "CoveragePrioritizerAgent"
+    description = "Cross-ref git blame frequency with coverage to find hot untested files"
+
+    def _run(self, inp: AgentInput, result: AgentResult) -> None:
+        churn = _get_git_churn(inp.root)
+        low_coverage = _parse_lcov(inp.root) | _parse_coverage_json(inp.root)
+
+        hot_untested: list[dict] = []
+        for file_path, commits in churn.items():
+            if file_path in low_coverage:
+                hot_untested.append({"file": file_path, "commits": commits})
+
+        hot_untested.sort(key=lambda x: -x["commits"])
+
+        result.data["churn_data"] = churn
+        result.data["low_coverage_files"] = list(low_coverage)
+        result.data["hot_untested"] = hot_untested
+        result.data["total_low_coverage"] = len(low_coverage)
+        result.data["total_hot_untested"] = len(hot_untested)
+        result.files_scanned = len(churn)
+
+        for item in hot_untested:
+            result.findings.append(
+                make_finding(
+                    self.name,
+                    "hot_untested",
+                    Severity.MEDIUM,
+                    item["file"],
+                    f"Hot file with low coverage: {item['file']} ({item['commits']} commits)",
+                    detail=f"Modified {item['commits']} times in recent history but coverage <80%",
+                    suggestion="Prioritize writing tests for this frequently-changed file",
+                )
+            )
+
+        if not low_coverage and not churn:
+            result.findings.append(
+                make_finding(
+                    self.name,
+                    "no_coverage_data",
+                    Severity.INFO,
+                    "",
+                    "No coverage data or git history found",
+                )
+            )
+
+        if result.status == AgentStatus.RUNNING:
+            result.status = AgentStatus.DONE