patchi 0.7.5__py3-none-any.whl

patchi/core/brain/team.py

@@ -0,0 +1,28 @@
+"""
+Team Collaboration §10.3.1-4 — CODEOWNERS routing, knowledge base, gamification.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+def route_to_team(root: Path, finding: dict) -> str:
+    co=root/".github/CODEOWNERS"
+    if co.exists():
+        for line in co.read_text(encoding="utf-8", errors="replace").splitlines():
+            if line.strip().startswith("#") or not line.strip(): continue
+            parts=line.split()
+            if len(parts)>=2 and finding.get("file","").startswith(parts[0].lstrip("/")):
+                return parts[-1]
+    return "unassigned"
+
+def leaderboard(root: Path) -> list[dict]:
+    try:
+        # count fixes per author via git log
+        import subprocess
+        out=subprocess.run(["git","log","--pretty=format:%an","--since=1.month.ago"], capture_output=True, text=True, timeout=5, cwd=str(root))
+        from collections import Counter
+        cnt=Counter(out.stdout.splitlines()) if out.returncode==0 else Counter()
+        return [{"author": a, "fixes": c} for a,c in cnt.most_common(5)]
+    except Exception:
+        return []

patchi/core/brain/trace_log.py

@@ -0,0 +1,132 @@
+"""
+Structured logging for agent execution traces.
+
+Provides a lightweight trace logger that records:
+  - Agent name, start/end time, duration
+  - Input file count, finding count
+  - Success/failure status
+  - Error messages
+
+Uses loguru if available, falls back to stdlib logging.
+
+Usage:
+    from patchi.core.brain.trace_log import trace_agent
+    with trace_agent("InjectionAgent", root=path) as trace:
+        result = AgentResult()
+        agent._run(inp, result)
+        trace.findings = len(result.findings)
+"""
+
+from __future__ import annotations
+
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+try:
+    from loguru import logger as _logger
+
+    _HAS_LOGURU = True
+except ImportError:
+    import logging
+
+    _logger = logging.getLogger("patchi.trace")
+    _HAS_LOGURU = False
+
+
+@dataclass
+class AgentTrace:
+    """Record of a single agent execution."""
+
+    agent_name: str
+    root: Path
+    start_time: float = 0.0
+    end_time: float = 0.0
+    duration_ms: int = 0
+    files_scanned: int = 0
+    findings: int = 0
+    status: str = "ok"
+    error: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "agent": self.agent_name,
+            "root": str(self.root),
+            "duration_ms": self.duration_ms,
+            "files_scanned": self.files_scanned,
+            "findings": self.findings,
+            "status": self.status,
+            "error": self.error,
+            **self.metadata,
+        }
+
+
+_TRACE_LOG: list[AgentTrace] = []
+
+
+def get_trace_log() -> list[AgentTrace]:
+    """Return all recorded traces."""
+    return _TRACE_LOG
+
+
+def clear_trace_log() -> None:
+    """Clear the trace log."""
+    _TRACE_LOG.clear()
+
+
+@contextmanager
+def trace_agent(agent_name: str, root: Path):
+    """Context manager that traces an agent execution."""
+    trace = AgentTrace(agent_name=agent_name, root=root)
+    trace.start_time = time.perf_counter()
+    _TRACE_LOG.append(trace)
+
+    try:
+        yield trace
+    except Exception as e:
+        trace.status = "error"
+        trace.error = str(e)
+        raise
+    finally:
+        trace.end_time = time.perf_counter()
+        trace.duration_ms = int((trace.end_time - trace.start_time) * 1000)
+
+        if _HAS_LOGURU:
+            _logger.debug(
+                "agent_trace | {agent} | {duration}ms | {findings} findings | {status}",
+                agent=trace.agent_name,
+                duration=trace.duration_ms,
+                findings=trace.findings,
+                status=trace.status,
+            )
+        else:
+            _logger.debug(
+                "agent_trace | %s | %dms | %d findings | %s",
+                trace.agent_name,
+                trace.duration_ms,
+                trace.findings,
+                trace.status,
+            )
+
+
+def format_trace_summary() -> str:
+    """Format a summary of all traces as a table string."""
+    if not _TRACE_LOG:
+        return "No agent traces recorded."
+
+    lines = ["Agent Trace Summary", "=" * 60]
+    total_ms = 0
+    total_findings = 0
+    for t in _TRACE_LOG:
+        total_ms += t.duration_ms
+        total_findings += t.findings
+        status_icon = "ok" if t.status == "ok" else "FAIL"
+        lines.append(
+            f"  {t.agent_name:25s} {t.duration_ms:6d}ms  {t.findings:3d} findings  [{status_icon}]"
+        )
+    lines.append("-" * 60)
+    lines.append(f"  {'TOTAL':25s} {total_ms:6d}ms  {total_findings:3d} findings")
+    return "\n".join(lines)

patchi/core/brain/type_checker/__init__.py

@@ -0,0 +1,65 @@
+"""
+Type checker registry — dispatches to per-language type checkers.
+
+Usage:
+    from patchi.core.brain.type_checker import check_types
+    findings = check_types(source, lang, file_path)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..languages import Lang
+
+
+def check_types(source: str, lang: Lang, file_path: str) -> list[dict]:
+    """Run the type checker for the given language. Returns list of findings."""
+    checker = _get_checker(lang)
+    if checker is None:
+        return []
+    return checker.check(source, file_path)
+
+
+def _get_checker(lang: Lang) -> Any | None:
+    if lang == Lang.TYPESCRIPT:
+        from .typescript import TypeScriptChecker
+
+        return TypeScriptChecker()
+    if lang == Lang.PYTHON:
+        from .python import PythonTypeChecker
+
+        return PythonTypeChecker()
+    if lang == Lang.JAVA:
+        from .java import JavaTypeChecker
+
+        return JavaTypeChecker()
+    if lang == Lang.GO:
+        from .go import GoTypeChecker
+
+        return GoTypeChecker()
+    if lang == Lang.RUST:
+        from .rust import RustTypeChecker
+
+        return RustTypeChecker()
+    if lang == Lang.C_SHARP:
+        from .csharp import CSharpTypeChecker
+
+        return CSharpTypeChecker()
+    if lang == Lang.KOTLIN:
+        from .kotlin import KotlinTypeChecker
+
+        return KotlinTypeChecker()
+    if lang == Lang.SWIFT:
+        from .swift import SwiftTypeChecker
+
+        return SwiftTypeChecker()
+    if lang == Lang.PHP:
+        from .php import PHPTypeChecker
+
+        return PHPTypeChecker()
+    if lang == Lang.DART:
+        from .dart import DartTypeChecker
+
+        return DartTypeChecker()
+    return None

patchi/core/brain/type_checker/base.py

@@ -0,0 +1,60 @@
+"""Base class for per-language type checkers."""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+
+_log = logging.getLogger("patchi.brain.base")
+
+
+class BaseTypeChecker(ABC):
+    """Abstract base for language-specific type checkers."""
+
+    language: str = ""
+
+    @abstractmethod
+    def check(self, source: str, file_path: str) -> list[dict]:
+        """Return list of type issue findings.
+        Each finding: {
+            "type": str,      # e.g. "explicit_any", "missing_return_type"
+            "file": str,
+            "line": int,
+            "title": str,
+            "description": str,
+            "evidence": str,
+            "severity": str,  # "low", "medium", "high"
+        }
+        """
+        ...
+
+
+def _node_text(source: str, node: Any) -> str:
+    """Extract text from a tree-sitter node using the source string."""
+    try:
+        buf = source.encode("utf-8")
+        return buf[node.start_byte : node.end_byte].decode("utf-8", errors="replace")
+    except Exception as e:
+        _log.debug("_node_text failed: %s", e)
+        return ""
+
+
+def make_finding(
+    finding_type: str,
+    file: str,
+    line: int,
+    title: str,
+    description: str,
+    evidence: str = "",
+    severity: str = "medium",
+) -> dict:
+    return {
+        "type": finding_type,
+        "file": file,
+        "line": line,
+        "title": title,
+        "description": description,
+        "evidence": evidence,
+        "severity": severity,
+    }

patchi/core/brain/type_checker/csharp.py

@@ -0,0 +1,59 @@
+"""C# type checker — uses tree-sitter."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..languages import Lang, get_parser
+from .base import BaseTypeChecker, _node_text, make_finding
+
+_log = logging.getLogger("patchi.brain.csharp")
+
+
+class CSharpTypeChecker(BaseTypeChecker):
+    language = "c_sharp"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.C_SHARP)
+        if parser is None:
+            return findings
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            self._walk(tree.root_node, source, file_path, findings)
+        except Exception as e:
+            _log.warning("CSharpTypeChecker.check failed: %s", e)
+        return findings
+
+    def _walk(self, node: Any, source: str, file_path: str, findings: list[dict]) -> None:
+        ntype = node.type
+        if ntype == "method_declaration":
+            line = node.start_point[0] + 1
+            name = (
+                _node_text(source, self._child_by_type(node, "identifier"))
+                if self._child_by_type(node, "identifier")
+                else ""
+            )
+            return_type = self._child_by_type(node, "predefined_type") or self._child_by_type(
+                node, "identifier"
+            )
+            if return_type and _node_text(source, return_type) in ("object", "dynamic"):
+                findings.append(
+                    make_finding(
+                        finding_type="untyped_return",
+                        file=file_path,
+                        line=line,
+                        title=f"Method returns '{_node_text(source, return_type)}'",
+                        description=f"Method '{name}' returns untyped '{_node_text(source, return_type)}' — consider a specific type",
+                        severity="medium",
+                    )
+                )
+        for child in node.children:
+            self._walk(child, source, file_path, findings)
+
+    def _child_by_type(self, node: Any, ntype: str) -> Any | None:
+        for child in node.children:
+            if child.type == ntype:
+                return child
+        return None

patchi/core/brain/type_checker/dart.py

@@ -0,0 +1,59 @@
+"""Dart type checker — uses tree-sitter."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..languages import Lang, get_parser
+from .base import BaseTypeChecker, _node_text, make_finding
+
+_log = logging.getLogger("patchi.brain.dart")
+
+
+class DartTypeChecker(BaseTypeChecker):
+    language = "dart"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.DART)
+        if parser is None:
+            return findings
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            self._walk(tree.root_node, source, file_path, findings)
+        except Exception as e:
+            _log.warning("DartTypeChecker.check failed: %s", e)
+        return findings
+
+    def _walk(self, node: Any, source: str, file_path: str, findings: list[dict]) -> None:
+        ntype = node.type
+        if ntype in ("method_declaration", "function_declaration"):
+            line = node.start_point[0] + 1
+            name = (
+                _node_text(source, self._child_by_type(node, "identifier"))
+                if self._child_by_type(node, "identifier")
+                else ""
+            )
+            return_type = self._child_by_type(node, "type_identifier") or self._child_by_type(
+                node, "generic_type"
+            )
+            if return_type and _node_text(source, return_type) == "dynamic":
+                findings.append(
+                    make_finding(
+                        finding_type="dynamic_type",
+                        file=file_path,
+                        line=line,
+                        title="Function returns 'dynamic'",
+                        description=f"Function '{name}' returns 'dynamic' — prefer a specific type for sound null safety",
+                        severity="medium",
+                    )
+                )
+        for child in node.children:
+            self._walk(child, source, file_path, findings)
+
+    def _child_by_type(self, node: Any, ntype: str) -> Any | None:
+        for child in node.children:
+            if child.type == ntype:
+                return child
+        return None

patchi/core/brain/type_checker/go.py

@@ -0,0 +1,81 @@
+"""Go type checker — uses tree-sitter."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..languages import Lang, get_parser
+from .base import BaseTypeChecker, _node_text, make_finding
+
+_log = logging.getLogger("patchi.brain.go")
+
+
+class GoTypeChecker(BaseTypeChecker):
+    language = "go"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.GO)
+        if parser is None:
+            return findings
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            self._walk(tree.root_node, source, file_path, findings)
+        except Exception as e:
+            _log.warning("GoTypeChecker.check failed: %s", e)
+        return findings
+
+    def _walk(self, node: Any, source: str, file_path: str, findings: list[dict]) -> None:
+        ntype = node.type
+        if ntype == "function_declaration":
+            line = node.start_point[0] + 1
+            name_node = self._child_by_type(node, "identifier")
+            name = _node_text(source, name_node) if name_node else ""
+            result = self._child_by_type(node, "result")
+            if result is not None:
+                for child in result.children:
+                    if (
+                        child.type == "type_identifier"
+                        and _node_text(source, child) == "interface{}"
+                    ):
+                        findings.append(
+                            make_finding(
+                                finding_type="empty_interface",
+                                file=file_path,
+                                line=line,
+                                title="Function returns 'interface{}'",
+                                description=f"Function '{name}' returns empty interface — consider a concrete type",
+                                evidence=f"{name}: interface{{}}",
+                                severity="medium",
+                            )
+                        )
+                        break
+            params = self._child_by_type(node, "parameter_list")
+            if params:
+                for child in params.children:
+                    if child.type == "parameter_declaration":
+                        ptype = (
+                            self._child_by_type(child, "type_identifier")
+                            or self._child_by_type(child, "pointer_type")
+                            or self._child_by_type(child, "generic_type")
+                        )
+                        if ptype and _node_text(source, ptype) == "interface{}":
+                            findings.append(
+                                make_finding(
+                                    finding_type="empty_interface",
+                                    file=file_path,
+                                    line=line,
+                                    title="Parameter is 'interface{}'",
+                                    description=f"Parameter in '{name}' is empty interface — consider a concrete type",
+                                    severity="medium",
+                                )
+                            )
+        for child in node.children:
+            self._walk(child, source, file_path, findings)
+
+    def _child_by_type(self, node: Any, ntype: str) -> Any | None:
+        for child in node.children:
+            if child.type == ntype:
+                return child
+        return None

patchi/core/brain/type_checker/java.py

@@ -0,0 +1,75 @@
+"""Java type checker — uses tree-sitter."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..languages import Lang, get_parser
+from .base import BaseTypeChecker, _node_text, make_finding
+
+_log = logging.getLogger("patchi.brain.java")
+
+
+class JavaTypeChecker(BaseTypeChecker):
+    language = "java"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.JAVA)
+        if parser is None:
+            return findings
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            self._walk(tree.root_node, source, file_path, findings)
+        except Exception as e:
+            _log.warning("JavaTypeChecker.check failed: %s", e)
+        return findings
+
+    def _walk(self, node: Any, source: str, file_path: str, findings: list[dict]) -> None:
+        ntype = node.type
+        if ntype == "method_declaration":
+            line = node.start_point[0] + 1
+            name_node = self._child_by_type(node, "identifier")
+            name = _node_text(source, name_node) if name_node else ""
+            return_type_node = self._child_by_type(node, "type_identifier") or self._child_by_type(
+                node, "generic_type"
+            )
+            if return_type_node and _node_text(source, return_type_node) == "Object":
+                findings.append(
+                    make_finding(
+                        finding_type="explicit_object",
+                        file=file_path,
+                        line=line,
+                        title="Method returns 'Object'",
+                        description=f"Method '{name}' returns raw 'Object' type — consider generics",
+                        evidence=f"{name}: Object",
+                        severity="medium",
+                    )
+                )
+            params = self._child_by_type(node, "formal_parameters")
+            if params:
+                for child in params.children:
+                    if child.type == "formal_parameter":
+                        ptype = self._child_by_type(
+                            child, "type_identifier"
+                        ) or self._child_by_type(child, "generic_type")
+                        if ptype and _node_text(source, ptype) == "Object":
+                            findings.append(
+                                make_finding(
+                                    finding_type="explicit_object",
+                                    file=file_path,
+                                    line=line,
+                                    title="Parameter typed as 'Object'",
+                                    description=f"Parameter in '{name}' is raw 'Object' type",
+                                    severity="medium",
+                                )
+                            )
+        for child in node.children:
+            self._walk(child, source, file_path, findings)
+
+    def _child_by_type(self, node: Any, ntype: str) -> Any | None:
+        for child in node.children:
+            if child.type == ntype:
+                return child
+        return None

patchi/core/brain/type_checker/kotlin.py

@@ -0,0 +1,75 @@
+"""Kotlin type checker — uses tree-sitter."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from ..languages import Lang, get_parser
+from .base import BaseTypeChecker, _node_text, make_finding
+
+_log = logging.getLogger("patchi.brain.kotlin")
+
+
+class KotlinTypeChecker(BaseTypeChecker):
+    language = "kotlin"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.KOTLIN)
+        if parser is None:
+            return findings
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            self._walk(tree.root_node, source, file_path, findings)
+        except Exception as e:
+            _log.warning("KotlinTypeChecker.check failed: %s", e)
+        return findings
+
+    def _walk(self, node: Any, source: str, file_path: str, findings: list[dict]) -> None:
+        ntype = node.type
+        if ntype == "function_declaration":
+            line = node.start_point[0] + 1
+            name = (
+                _node_text(source, self._child_by_type(node, "identifier"))
+                if self._child_by_type(node, "identifier")
+                else ""
+            )
+            return_type = self._child_by_type(node, "type_identifier") or self._child_by_type(
+                node, "user_type"
+            )
+            if return_type and _node_text(source, return_type) == "Any":
+                findings.append(
+                    make_finding(
+                        finding_type="any_type",
+                        file=file_path,
+                        line=line,
+                        title="Function returns 'Any'",
+                        description=f"Function '{name}' returns 'Any' — consider a specific type",
+                        severity="medium",
+                    )
+                )
+            # Check for !! non-null assertions
+            body = self._child_by_type(node, "function_body") or self._child_by_type(node, "block")
+            if body:
+                body_text = _node_text(source, body)
+                if "!!" in body_text:
+                    findings.append(
+                        make_finding(
+                            finding_type="non_null_assertion",
+                            file=file_path,
+                            line=line,
+                            title="Non-null assertion '!!' used",
+                            description=f"Function '{name}' uses '!!' — may throw NPE",
+                            evidence="!!",
+                            severity="medium",
+                        )
+                    )
+        for child in node.children:
+            self._walk(child, source, file_path, findings)
+
+    def _child_by_type(self, node: Any, ntype: str) -> Any | None:
+        for child in node.children:
+            if child.type == ntype:
+                return child
+        return None