patchi 0.7.5__py3-none-any.whl

patchi/core/brain/type_checker/php.py

@@ -0,0 +1,88 @@
+"""PHP 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.php")
+
+
+class PHPTypeChecker(BaseTypeChecker):
+    language = "php"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.PHP)
+        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("PHPTypeChecker.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 ("function_definition", "method_declaration"):
+            line = node.start_point[0] + 1
+            name = (
+                _node_text(source, self._child_by_type(node, "name"))
+                if self._child_by_type(node, "name")
+                else ""
+            )
+            return_type = (
+                self._child_by_type(node, "primitive_type")
+                or self._child_by_type(node, "named_type")
+                or self._child_by_type(node, "nullable_type")
+            )
+            if return_type is None:
+                findings.append(
+                    make_finding(
+                        finding_type="missing_return_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing return type hint",
+                        description=f"Function '{name}' is missing a PHP return type hint",
+                        evidence=f"function {name}()",
+                        severity="low",
+                    )
+                )
+            # Check param type hints
+            params = self._child_by_type(node, "formal_parameters")
+            if params:
+                for child in params.children:
+                    if child.type == "simple_parameter":
+                        ptype = (
+                            self._child_by_type(child, "primitive_type")
+                            or self._child_by_type(child, "named_type")
+                            or self._child_by_type(child, "nullable_type")
+                        )
+                        if ptype is None:
+                            param_name = (
+                                _node_text(source, self._child_by_type(child, "variable_name"))
+                                if self._child_by_type(child, "variable_name")
+                                else "?"
+                            )
+                            findings.append(
+                                make_finding(
+                                    finding_type="missing_param_type",
+                                    file=file_path,
+                                    line=line,
+                                    title="Missing parameter type hint",
+                                    description=f"Parameter '{param_name}' in '{name}' missing type hint",
+                                    severity="low",
+                                )
+                            )
+        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/python.py

@@ -0,0 +1,87 @@
+"""Python type checker — uses stdlib ast."""
+
+from __future__ import annotations
+
+import ast
+
+from .base import BaseTypeChecker, make_finding
+
+
+class PythonTypeChecker(BaseTypeChecker):
+    language = "python"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        try:
+            tree = ast.parse(source)
+        except SyntaxError:
+            return findings
+
+        lines = source.split("\n")
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                self._check_function_def(node, lines, file_path, findings)
+            elif isinstance(node, ast.AnnAssign):
+                self._check_annotation(node, lines, file_path, findings)
+
+        return findings
+
+    def _check_function_def(
+        self,
+        node: ast.FunctionDef | ast.AsyncFunctionDef,
+        lines: list[str],
+        file_path: str,
+        findings: list[dict],
+    ) -> None:
+        line = node.lineno
+
+        # Missing return type annotation
+        if node.returns is None:
+            if node.name not in ("__init__", "__new__", "__post_init__"):
+                findings.append(
+                    make_finding(
+                        finding_type="missing_return_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing return type annotation",
+                        description=f"Function '{node.name}' is missing a return type annotation",
+                        evidence=f"def {node.name}",
+                        severity="low",
+                    )
+                )
+
+        # Parameters without type annotations
+        for arg in node.args.args:
+            if arg.arg == "self":
+                continue
+            if arg.annotation is None:
+                findings.append(
+                    make_finding(
+                        finding_type="missing_param_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing parameter type annotation",
+                        description=f"Parameter '{arg.arg}' in function '{node.name}' is missing a type annotation",
+                        evidence=f"{arg.arg}: ?",
+                        severity="low",
+                    )
+                )
+
+    def _check_annotation(
+        self, node: ast.AnnAssign, lines: list[str], file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.lineno
+        ann = node.annotation
+        if isinstance(ann, ast.Name) and ann.id == "Any":
+            target = ast.unparse(node.target) if hasattr(ast, "unparse") else ""
+            findings.append(
+                make_finding(
+                    finding_type="explicit_any",
+                    file=file_path,
+                    line=line,
+                    title="Variable typed as 'Any'",
+                    description=f"Variable '{target}' is typed as 'Any' (bypasses type checking)",
+                    evidence=f"{target}: Any",
+                    severity="medium",
+                )
+            )

patchi/core/brain/type_checker/rust.py

@@ -0,0 +1,81 @@
+"""Rust 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.rust")
+
+
+class RustTypeChecker(BaseTypeChecker):
+    language = "rust"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.RUST)
+        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("RustTypeChecker.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_item":
+            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, "return_type")
+            if return_type:
+                for child in return_type.children:
+                    if child.type == "type_identifier" and _node_text(source, child) == "Box":
+                        inner = self._child_by_type(child, "type_arguments")
+                        if inner and _node_text(source, inner).find("dyn") >= 0:
+                            findings.append(
+                                make_finding(
+                                    finding_type="trait_object",
+                                    file=file_path,
+                                    line=line,
+                                    title="Returns Box<dyn Trait> — consider generics",
+                                    description=f"Function '{name}' returns Box<dyn ...> — consider `impl Trait` or generics",
+                                    evidence=f"{name}: Box<dyn ...>",
+                                    severity="low",
+                                )
+                            )
+            # Check for unwrap() calls
+            for child in node.children:
+                self._walk(child, source, file_path, findings)
+        elif ntype == "call_expression":
+            line = node.start_point[0] + 1
+            fn_name = _node_text(source, node).split("(")[0].strip()
+            if fn_name == "unwrap" or fn_name.endswith(".unwrap"):
+                findings.append(
+                    make_finding(
+                        finding_type="unwrap_call",
+                        file=file_path,
+                        line=line,
+                        title="Unwrap call — may panic",
+                        description="Call to .unwrap() may panic on None/Err — handle with match or ?",
+                        evidence=fn_name,
+                        severity="medium",
+                    )
+                )
+        else:
+            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/swift.py

@@ -0,0 +1,59 @@
+"""Swift 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.swift")
+
+
+class SwiftTypeChecker(BaseTypeChecker):
+    language = "swift"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.SWIFT)
+        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("SwiftTypeChecker.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, "return_type")
+            if return_type:
+                rt_text = _node_text(source, return_type).replace("-> ", "")
+                if rt_text == "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",
+                        )
+                    )
+        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/typescript.py

@@ -0,0 +1,298 @@
+"""TypeScript type checker — uses tree-sitter AST instead of regex."""
+
+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.typescript")
+
+
+class TypeScriptChecker(BaseTypeChecker):
+    language = "typescript"
+
+    def check(self, source: str, file_path: str) -> list[dict]:
+        findings: list[dict] = []
+        parser = get_parser(Lang.TYPESCRIPT)
+        if parser is None:
+            return findings
+
+        try:
+            tree = parser.parse(source.encode("utf-8"))
+            buf = source.encode("utf-8")
+            self._walk(tree.root_node, buf, source, file_path, findings)
+        except Exception as e:
+            _log.warning("TypeScriptChecker.check failed: %s", e)
+
+        return findings
+
+    def _walk(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        ntype = node.type
+
+        if ntype in ("function_declaration", "method_definition"):
+            self._check_function(node, buf, source, file_path, findings)
+            return
+        elif ntype == "arrow_function":
+            self._check_arrow_function(node, buf, source, file_path, findings)
+            return
+        elif ntype == "variable_declarator":
+            self._check_variable(node, buf, source, file_path, findings)
+        elif ntype == "required_parameter":
+            self._check_parameter(node, buf, source, file_path, findings)
+        elif ntype == "export_statement":
+            for child in node.named_children if hasattr(node, "named_children") else node.children:
+                self._walk(child, buf, source, file_path, findings)
+            return
+        elif ntype == "as_expression":
+            self._check_as_cast(node, buf, source, file_path, findings)
+        elif ntype == "comment":
+            self._check_comment(node, buf, source, file_path, findings)
+            return
+
+        for child in node.named_children if hasattr(node, "named_children") else node.children:
+            self._walk(child, buf, source, file_path, findings)
+
+    def _check_function(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+
+        # Check return type annotation
+        return_type = self._child_by_field(node, "return_type")
+        name = self._child_text_by_field(node, "name", buf) or "anonymous"
+
+        if return_type is None and name != "constructor":
+            body_text = _node_text(source, node)
+            if "=>" not in body_text:
+                findings.append(
+                    make_finding(
+                        finding_type="missing_return_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing return type on function",
+                        description=f"Function '{name}' is missing an explicit return type annotation",
+                        evidence=f"function {name}",
+                        severity="low",
+                    )
+                )
+        elif return_type is not None:
+            # return_type is a type_annotation node — look inside for "any"
+            inner = self._find_predefined_type(return_type)
+            if inner == "any":
+                findings.append(
+                    make_finding(
+                        finding_type="explicit_any",
+                        file=file_path,
+                        line=line,
+                        title="Function returns 'any'",
+                        description=f"Function '{name}' returns 'any' type",
+                        evidence=f"function {name}: any",
+                        severity="medium",
+                    )
+                )
+
+        # Check parameters for 'any'
+        params = self._child_by_field(node, "parameters")
+        if params:
+            self._check_parameter_list(params, buf, source, file_path, findings)
+
+    def _check_arrow_function(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+
+        return_type = self._child_by_field(node, "return_type")
+        if return_type is None:
+            parent = getattr(node, "parent", None)
+            if parent and parent.type == "variable_declarator":
+                name_node = self._child_by_field(parent, "name")
+                name = _node_text(source, name_node) if name_node else "anonymous"
+                findings.append(
+                    make_finding(
+                        finding_type="missing_return_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing return type on arrow function",
+                        description=f"Arrow function '{name}' is missing explicit return type",
+                        evidence=f"const {name} = ... =>",
+                        severity="low",
+                    )
+                )
+        elif return_type is not None:
+            inner = self._find_predefined_type(return_type)
+            if inner == "any":
+                findings.append(
+                    make_finding(
+                        finding_type="explicit_any",
+                        file=file_path,
+                        line=line,
+                        title="Arrow function returns 'any'",
+                        description="Arrow function returns 'any' type",
+                        severity="medium",
+                    )
+                )
+
+        params = self._child_by_field(node, "parameters")
+        if params:
+            self._check_parameter_list(params, buf, source, file_path, findings)
+
+    def _check_variable(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+        name_node = self._child_by_field(node, "name")
+        name = _node_text(source, name_node) if name_node else ""
+
+        # Check if variable has a type annotation
+        type_node = self._child_by_field(node, "type")
+        if type_node is None:
+            value_node = self._child_by_field(node, "value")
+            if value_node and value_node.type not in (
+                "arrow_function",
+                "function",
+                "object",
+                "array",
+            ):
+                findings.append(
+                    make_finding(
+                        finding_type="missing_type",
+                        file=file_path,
+                        line=line,
+                        title="Missing type annotation on variable",
+                        description=f"Variable '{name}' is missing explicit type annotation",
+                        evidence=f"{name} = ...",
+                        severity="low",
+                    )
+                )
+        elif type_node is not None:
+            inner = self._find_predefined_type(type_node)
+            if inner == "any":
+                findings.append(
+                    make_finding(
+                        finding_type="explicit_any",
+                        file=file_path,
+                        line=line,
+                        title="Variable typed as 'any'",
+                        description=f"Variable '{name}' is explicitly typed as 'any'",
+                        evidence=f"{name}: any",
+                        severity="medium",
+                    )
+                )
+
+    def _check_parameter(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+        name_node = self._child_by_field(node, "name")
+        name = _node_text(source, name_node) if name_node else ""
+
+        type_node = self._child_by_field(node, "type")
+        if type_node is not None:
+            inner = self._find_predefined_type(type_node)
+            if inner == "any":
+                findings.append(
+                    make_finding(
+                        finding_type="explicit_any",
+                        file=file_path,
+                        line=line,
+                        title="Parameter typed as 'any'",
+                        description=f"Parameter '{name}' is typed as 'any'",
+                        evidence=f"{name}: any",
+                        severity="medium",
+                    )
+                )
+
+    def _check_parameter_list(
+        self, params_node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        for child in (
+            params_node.named_children
+            if hasattr(params_node, "named_children")
+            else params_node.children
+        ):
+            if child.type == "required_parameter":
+                self._check_parameter(child, buf, source, file_path, findings)
+            elif child.type == "optional_parameter":
+                self._check_parameter(child, buf, source, file_path, findings)
+
+    def _find_predefined_type(self, type_ann: Any) -> str:
+        """Look inside a type_annotation node for a predefined_type like 'any'."""
+        for child in type_ann.children if hasattr(type_ann, "children") else []:
+            if child.type == "predefined_type":
+                try:
+                    raw = child.text
+                    if isinstance(raw, bytes):
+                        return raw.decode("utf-8", errors="replace")
+                    return str(raw)
+                except Exception as e:
+                    _log.warning("TypeScriptChecker._find_predefined_type failed: %s", e)
+        return ""
+
+    def _child_by_field(self, node: Any, field: str) -> Any | None:
+        if hasattr(node, "child_by_field_name"):
+            return node.child_by_field_name(field)
+        return None
+
+    def _child_text_by_field(self, node: Any, field: str, buf: bytes) -> str:
+        child = self._child_by_field(node, field)
+        if child:
+            try:
+                return buf[child.start_byte : child.end_byte].decode("utf-8", errors="replace")
+            except Exception as e:
+                _log.warning("TypeScriptChecker._child_text_by_field failed: %s", e)
+        return ""
+
+    def _check_as_cast(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+        type_node = self._child_by_field(node, "type")
+        type_name = "unknown"
+        if type_node:
+            type_name = _node_text(source, type_node)[:50]
+        findings.append(
+            make_finding(
+                finding_type="unsafe_cast",
+                file=file_path,
+                line=line,
+                title="Unsafe type cast",
+                description=f"Using 'as' type assertion to '{type_name}'",
+                evidence=f"as {type_name}",
+                severity="medium",
+            )
+        )
+
+    def _check_comment(
+        self, node: Any, buf: bytes, source: str, file_path: str, findings: list[dict]
+    ) -> None:
+        line = node.start_point[0] + 1
+        text = _node_text(source, node)
+        if "@ts-ignore" in text:
+            findings.append(
+                make_finding(
+                    finding_type="ts_ignore",
+                    file=file_path,
+                    line=line,
+                    title="@ts-ignore suppression",
+                    description="TypeScript compiler error suppressed with @ts-ignore",
+                    evidence=text.strip(),
+                    severity="medium",
+                )
+            )
+        elif "@ts-expect-error" in text:
+            findings.append(
+                make_finding(
+                    finding_type="ts_ignore",
+                    file=file_path,
+                    line=line,
+                    title="@ts-expect-error suppression",
+                    description="TypeScript compiler error suppressed with @ts-expect-error",
+                    evidence=text.strip(),
+                    severity="medium",
+                )
+            )