code-oracle 0.1.0__py3-none-any.whl

code_oracle/perf_lint/__init__.py

@@ -0,0 +1,38 @@
+"""
+Static Performance Anti-Patterns & Resource Leak Detector.
+Detects nested loop complexity, N+1 queries, resource leaks, and blocking async calls.
+"""
+
+from code_oracle.perf_lint.engine import (
+    PerfLintEngine,
+    lint_performance,
+    lint_performance_patterns,
+)
+from code_oracle.perf_lint.models import (
+    PerfDiagnostic,
+    PerfReport,
+    PerfRule,
+    Severity,
+)
+from code_oracle.perf_lint.rules import (
+    AsyncBlockingRule,
+    NPlusOneRule,
+    NestedLoopsRule,
+    UnclosedResourceRule,
+)
+from code_oracle.perf_lint.visitor import PerfLintVisitor
+
+__all__ = [
+    "AsyncBlockingRule",
+    "NPlusOneRule",
+    "NestedLoopsRule",
+    "PerfDiagnostic",
+    "PerfLintEngine",
+    "PerfLintVisitor",
+    "PerfReport",
+    "PerfRule",
+    "Severity",
+    "UnclosedResourceRule",
+    "lint_performance",
+    "lint_performance_patterns",
+]

code_oracle/perf_lint/engine.py

@@ -0,0 +1,234 @@
+"""
+Orchestration Engine for Static Performance Anti-Patterns & Resource Leak Detector.
+Coordinates workspace and file-level scans, applies diff patches in-memory,
+filters diagnostics by severity thresholds, and benchmarks analysis latency.
+"""
+
+import os
+from pathlib import Path
+import time
+from typing import Any, Dict, List, Optional, Set, Union
+
+from code_oracle.indexer import IGNORE_DIRS
+from code_oracle.languages import SUPPORTED_EXTENSIONS, detect_language
+from code_oracle.locator import apply_patch
+from code_oracle.perf_lint.models import PerfDiagnostic, PerfReport, Severity
+from code_oracle.perf_lint.visitor import PerfLintVisitor
+
+
+def _filter_dirs(dirs: List[str]) -> List[str]:
+    return [d for d in dirs if d not in IGNORE_DIRS and not d.startswith(".")]
+
+
+def _walk_supported_files(directory: Path) -> Set[Path]:
+    """Discover all supported source code files within target directory."""
+    result: Set[Path] = set()
+    for root, dirs, files in os.walk(directory):  # code-oracle: ignore-perf[PERF001]
+        dirs[:] = _filter_dirs(dirs)
+        for file in files:
+            p = Path(root) / file
+            if p.suffix.lower() in SUPPORTED_EXTENSIONS:
+                result.add(p)
+    return result
+
+
+class PerfLintEngine:
+    """
+    Sub-50ms Static Performance Anti-Pattern & Resource Leak Engine.
+    Executes Tree-sitter AST visitor passes over Python, TypeScript, Go, and Rust files.
+    """
+
+    def __init__(self, workspace_root: Optional[Union[str, Path]] = None) -> None:
+        self.workspace_root = Path(workspace_root or Path.cwd()).resolve()
+
+    def lint_source(
+        self,
+        source: str,
+        file_path: str = "",
+        language: Optional[str] = None,
+        severity: str = "warn",
+        max_depth: Optional[int] = None,
+    ) -> List[PerfDiagnostic]:
+        """
+        Analyze in-memory source code string and return active diagnostics.
+        Filters findings by minimum severity threshold.
+        """
+        visitor = PerfLintVisitor(
+            source=source,
+            file_path=file_path,
+            language=language,
+            max_depth=max_depth,
+        )
+        diagnostics = visitor.run()
+
+        # Apply minimum severity filter
+        min_sev = Severity.from_str(severity)
+        if min_sev == Severity.ERROR:
+            diagnostics = [d for d in diagnostics if d.severity == Severity.ERROR]
+
+        return diagnostics
+
+    def lint_file(
+        self,
+        file_path: Union[str, Path],
+        severity: str = "warn",
+        max_depth: Optional[int] = None,
+    ) -> List[PerfDiagnostic]:
+        """Read and analyze a single source file from disk."""
+        target_path = Path(file_path)
+        if not target_path.is_absolute():
+            target_path = (self.workspace_root / target_path).resolve()
+
+        if not target_path.is_file():
+            return []
+
+        ext = target_path.suffix.lower()
+        if ext not in SUPPORTED_EXTENSIONS:
+            return []
+
+        try:
+            content = target_path.read_text(encoding="utf-8")
+        except Exception:
+            return []
+
+        try:
+            rel_path = str(target_path.relative_to(self.workspace_root)).replace("\\", "/")
+        except ValueError:
+            rel_path = str(target_path).replace("\\", "/")
+
+        return self.lint_source(
+            source=content,
+            file_path=rel_path,
+            severity=severity,
+            max_depth=max_depth,
+        )
+
+    def lint_workspace(
+        self,
+        paths: Optional[List[str]] = None,
+        severity: str = "warn",
+        max_depth: Optional[int] = None,
+    ) -> PerfReport:
+        """
+        Scan workspace files or specific file/directory targets for performance anti-patterns.
+        """
+        start_time = time.perf_counter()
+        target_files: Set[Path] = set()
+
+        if paths:
+            for p in paths:
+                raw_path = Path(p)
+                abs_path = raw_path if raw_path.is_absolute() else (self.workspace_root / raw_path).resolve()
+
+                if abs_path.is_file():
+                    if abs_path.suffix.lower() in SUPPORTED_EXTENSIONS:
+                        target_files.add(abs_path)
+                elif abs_path.is_dir():
+                    target_files.update(_walk_supported_files(abs_path))
+        else:
+            target_files.update(_walk_supported_files(self.workspace_root))
+
+        all_diagnostics: List[PerfDiagnostic] = []
+        scanned_count = len(target_files)
+
+        for f_path in target_files:
+            try:
+                rel_path = str(f_path.relative_to(self.workspace_root)).replace("\\", "/")
+            except ValueError:
+                rel_path = str(f_path).replace("\\", "/")
+
+            try:
+                content = f_path.read_text(encoding="utf-8")
+            except Exception:
+                continue
+
+            diags = self.lint_source(
+                source=content,
+                file_path=rel_path,
+                severity=severity,
+                max_depth=max_depth,
+            )
+            all_diagnostics.extend(diags)
+
+        # Sort diagnostics by file path and line number
+        all_diagnostics.sort(key=lambda d: (d.file_path, d.lineno, d.col_offset))
+        elapsed_ms = (time.perf_counter() - start_time) * 1000.0
+
+        return PerfReport(
+            workspace_root=str(self.workspace_root),
+            diagnostics=all_diagnostics,
+            scanned_files_count=scanned_count,
+            latency_ms=elapsed_ms,
+        )
+
+
+def lint_performance(
+    workspace_root: Optional[Union[str, Path]] = None,
+    paths: Optional[List[str]] = None,
+    severity: str = "warn",
+    max_depth: Optional[int] = None,
+) -> PerfReport:
+    """Convenience function to scan a workspace or path list for performance anti-patterns."""
+    engine = PerfLintEngine(workspace_root=workspace_root)
+    return engine.lint_workspace(paths=paths, severity=severity, max_depth=max_depth)
+
+
+def lint_performance_patterns(
+    file_path: str,
+    patch_content: Optional[str] = None,
+    workspace_root: Optional[Union[str, Path]] = None,
+    severity: str = "warn",
+    max_depth: Optional[int] = None,
+) -> PerfReport:
+    """
+    FastMCP and patch-level performance evaluation endpoint.
+    Applies unified diff or replacement patch in-memory with zero side-effects.
+    """
+    start_time = time.perf_counter()
+    engine = PerfLintEngine(workspace_root=workspace_root)
+
+    target_path = Path(file_path)
+    if not target_path.is_absolute():
+        target_path = (engine.workspace_root / target_path).resolve()
+
+    try:
+        norm_path = str(target_path.relative_to(engine.workspace_root)).replace("\\", "/")
+    except ValueError:
+        norm_path = str(file_path).replace("\\", "/")
+
+    orig_content = ""
+    if target_path.is_file():
+        try:
+            orig_content = target_path.read_text(encoding="utf-8")
+        except Exception:
+            orig_content = ""
+
+    if patch_content is not None:
+        patched_content, _, _ = apply_patch(orig_content, patch_content)
+        content_to_lint = patched_content
+    else:
+        content_to_lint = orig_content
+
+    diags = engine.lint_source(
+        source=content_to_lint,
+        file_path=norm_path,
+        severity=severity,
+        max_depth=max_depth,
+    )
+    diags.sort(key=lambda d: (d.file_path, d.lineno, d.col_offset))
+    elapsed_ms = (time.perf_counter() - start_time) * 1000.0
+
+    return PerfReport(
+        workspace_root=str(engine.workspace_root),
+        diagnostics=diags,
+        scanned_files_count=1,
+        latency_ms=elapsed_ms,
+    )
+
+
+__all__ = [
+    "PerfLintEngine",
+    "PerfLintVisitor",
+    "lint_performance",
+    "lint_performance_patterns",
+]

code_oracle/perf_lint/models.py

@@ -0,0 +1,229 @@
+"""
+Data models for the Static Performance Anti-Patterns & Resource Leak Detector.
+Defines representations for diagnostics, severity levels, rules, and reports.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class Severity(str, Enum):
+    """Diagnostic severity levels."""
+    WARN = "warn"
+    ERROR = "error"
+
+    @classmethod
+    def from_str(cls, value: str) -> "Severity":
+        """Convert string to Severity enum value safely."""
+        val = value.strip().lower()
+        if val in ("error", "err"):
+            return cls.ERROR
+        return cls.WARN
+
+
+class PerfRule(str, Enum):
+    """Identifier codes for performance and leak linting rules."""
+    PERF001 = "PERF001"
+    PERF002 = "PERF002"
+    PERF003 = "PERF003"
+    PERF004 = "PERF004"
+
+
+RULE_METADATA: Dict[str, Dict[str, Any]] = {
+    PerfRule.PERF001.value: {
+        "name": "Nested Loops Complexity",
+        "description": "Nested loop complexity escalation (O(N^2) warning, O(N^3) error)",
+        "default_severity": Severity.WARN,
+    },
+    PerfRule.PERF002.value: {
+        "name": "N+1 I/O in Loop",
+        "description": "N+1 database queries or network I/O calls inside iteration loop bodies",
+        "default_severity": Severity.WARN,
+    },
+    PerfRule.PERF003.value: {
+        "name": "Resource Leak / Unclosed Descriptor",
+        "description": "File or socket descriptor opened without scoped context manager or defer Close",
+        "default_severity": Severity.ERROR,
+    },
+    PerfRule.PERF004.value: {
+        "name": "Blocking Call in Async Context",
+        "description": "Blocking synchronous call inside asynchronous function",
+        "default_severity": Severity.ERROR,
+    },
+}
+
+
+@dataclass
+class PerfDiagnostic:
+    """Represents a single performance anti-pattern or resource leak finding."""
+    rule_id: str
+    message: str
+    severity: Severity
+    file_path: str
+    lineno: int
+    end_lineno: int = 0
+    col_offset: int = 0
+    end_col_offset: int = 0
+    context_line: Optional[str] = None
+    rule_name: Optional[str] = None
+    suppressed: bool = False
+
+    def __post_init__(self) -> None:
+        if hasattr(self.rule_id, "value"):
+            self.rule_id = self.rule_id.value
+        if isinstance(self.severity, str):
+            self.severity = Severity.from_str(self.severity)
+        if not self.rule_name and self.rule_id in RULE_METADATA:
+            self.rule_name = RULE_METADATA[self.rule_id]["name"]
+        if self.end_lineno <= 0:
+            self.end_lineno = self.lineno
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize diagnostic to dictionary."""
+        return {
+            "rule_id": self.rule_id,
+            "rule_name": self.rule_name or self.rule_id,
+            "message": self.message,
+            "severity": self.severity.value,
+            "file_path": self.file_path,
+            "lineno": self.lineno,
+            "end_lineno": self.end_lineno,
+            "col_offset": self.col_offset,
+            "end_col_offset": self.end_col_offset,
+            "context_line": self.context_line,
+            "suppressed": self.suppressed,
+        }
+
+
+@dataclass
+class PerfReport:
+    """Complete static performance and resource leak evaluation report."""
+    workspace_root: str
+    diagnostics: List[PerfDiagnostic] = field(default_factory=list)
+    scanned_files_count: int = 0
+    latency_ms: float = 0.0
+    rules_checked: List[str] = field(
+        default_factory=lambda: [r.value for r in PerfRule]
+    )
+
+    @property
+    def total_diagnostics_count(self) -> int:
+        """Total number of active (non-suppressed) diagnostics."""
+        return len([d for d in self.diagnostics if not d.suppressed])
+
+    @property
+    def errors_count(self) -> int:
+        """Number of error-severity diagnostics."""
+        return len([
+            d for d in self.diagnostics
+            if not d.suppressed and d.severity == Severity.ERROR
+        ])
+
+    @property
+    def warnings_count(self) -> int:
+        """Number of warn-severity diagnostics."""
+        return len([
+            d for d in self.diagnostics
+            if not d.suppressed and d.severity == Severity.WARN
+        ])
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert report to dictionary."""
+        active = [d for d in self.diagnostics if not d.suppressed]
+        return {
+            "workspace_root": self.workspace_root,
+            "total_diagnostics_count": self.total_diagnostics_count,
+            "errors_count": self.errors_count,
+            "warnings_count": self.warnings_count,
+            "scanned_files_count": self.scanned_files_count,
+            "latency_ms": round(self.latency_ms, 2),
+            "rules_checked": self.rules_checked,
+            "diagnostics": [d.to_dict() for d in active],
+        }
+
+    def format_table(self) -> str:
+        """Format report into clean, colored ASCII terminal table."""
+        active = [d for d in self.diagnostics if not d.suppressed]
+        if not active:
+            return (
+                f"\033[92m✔ No performance anti-patterns or resource leaks detected\033[0m "
+                f"across {self.scanned_files_count} files ({self.latency_ms:.2f} ms)."
+            )
+
+        headers = ["Rule", "Severity", "Location", "Message"]
+        rows: List[List[str]] = []
+        for d in active:
+            loc = f"{d.file_path}:{d.lineno}"
+            sev = d.severity.value.upper()
+            rows.append([d.rule_id, sev, loc, d.message])
+
+        col_widths = [len(h) for h in headers]
+        for row in rows:
+            for i, val in enumerate(row):
+                col_widths[i] = max(col_widths[i], len(val))
+
+        # Enforce maximum column width for message to prevent terminal overflow
+        if col_widths[3] > 80:
+            col_widths[3] = 80
+
+        def make_separator(char: str = "-") -> str:
+            parts = [char * (w + 2) for w in col_widths]
+            return f"+{'+'.join(parts)}+"
+
+        lines = [
+            make_separator("-"),
+            "| " + " | ".join(h.ljust(col_widths[i]) for i, h in enumerate(headers)) + " |",
+            make_separator("="),
+        ]
+
+        for row in rows:
+            color = "\033[91m" if row[1] == "ERROR" else "\033[93m"
+            color_reset = "\033[0m"
+            msg = row[3]
+            if len(msg) > col_widths[3]:
+                msg = msg[: col_widths[3] - 3] + "..."
+            formatted_cells = [
+                row[0].ljust(col_widths[0]),
+                row[1].ljust(col_widths[1]),
+                row[2].ljust(col_widths[2]),
+                msg.ljust(col_widths[3]),
+            ]
+            lines.append(f"| {color}{' | '.join(formatted_cells)}{color_reset} |")
+
+        lines.append(make_separator("-"))
+
+        summary = (
+            f"\033[91m✖ Found {self.total_diagnostics_count} performance anti-patterns\033[0m "
+            f"({self.errors_count} errors, {self.warnings_count} warnings) "
+            f"across {self.scanned_files_count} files in {self.latency_ms:.2f} ms."
+        )
+        lines.append(summary)
+        return "\n".join(lines)
+
+    def format_text(self) -> str:
+        """Format report into concise text lines."""
+        active = [d for d in self.diagnostics if not d.suppressed]
+        if not active:
+            return (
+                f"✔ No performance anti-patterns or resource leaks detected "
+                f"across {self.scanned_files_count} files ({self.latency_ms:.2f} ms)."
+            )
+
+        lines = [
+            f"Performance Anti-Patterns & Resource Leaks ({self.total_diagnostics_count} issues: "
+            f"{self.errors_count} errors, {self.warnings_count} warnings):",
+            "--------------------------------------------------------------------------------",
+        ]
+        for d in active:
+            sev = d.severity.value.upper()
+            lines.append(
+                f"  • {d.file_path}:{d.lineno} [{d.rule_id}] ({sev}): {d.message}"
+            )
+            if d.context_line:
+                lines.append(f"    Line: {d.context_line}")
+        lines.append("--------------------------------------------------------------------------------")
+        lines.append(
+            f"Scan completed in {self.latency_ms:.2f} ms across {self.scanned_files_count} files."
+        )
+        return "\n".join(lines)

code_oracle/perf_lint/rules/__init__.py

@@ -0,0 +1,31 @@
+"""
+Performance and resource leak lint rules.
+"""
+
+from code_oracle.perf_lint.rules.async_blocking import (
+    AsyncBlockingRule,
+    check_async_blocking,
+)
+from code_oracle.perf_lint.rules.n_plus_one import (
+    NPlusOneRule,
+    check_n_plus_one,
+)
+from code_oracle.perf_lint.rules.nested_loops import (
+    NestedLoopsRule,
+    check_nested_loop,
+)
+from code_oracle.perf_lint.rules.unclosed_res import (
+    UnclosedResourceRule,
+    check_unclosed_resource,
+)
+
+__all__ = [
+    "AsyncBlockingRule",
+    "NPlusOneRule",
+    "NestedLoopsRule",
+    "UnclosedResourceRule",
+    "check_async_blocking",
+    "check_n_plus_one",
+    "check_nested_loop",
+    "check_unclosed_resource",
+]

code_oracle/perf_lint/rules/async_blocking.py

@@ -0,0 +1,143 @@
+"""
+PERF004: Blocking Calls in Async Context Rule.
+Detects synchronous blocking primitives like time.sleep or sync file I/O
+inside async def / async function bodies across Python, TypeScript, and Rust.
+"""
+
+from typing import List, Optional
+from tree_sitter import Node
+
+from code_oracle.perf_lint.models import PerfDiagnostic, PerfRule, Severity
+
+
+class AsyncBlockingRule:
+    """Evaluates PERF004: Blocking Calls in Async Context."""
+
+    RULE_ID = PerfRule.PERF004.value
+
+    @staticmethod
+    def is_async_func_node(node: Node, language: str) -> bool:
+        """Determine if a function AST node is asynchronous."""
+        if language == "python":
+            return any(c.type == "async" for c in node.children)
+        elif language in ("typescript", "javascript"):
+            return any(c.type == "async" for c in node.children)
+        elif language == "rust":
+            for c in node.children:
+                if c.type == "function_modifiers":
+                    return any(mc.type == "async" for mc in c.children)
+            return False
+        return False
+
+    @staticmethod
+    def is_blocking_call(callee_text: str, language: str) -> bool:
+        """Check if callee is a blocking synchronous primitive."""
+        clean = callee_text.strip()
+        clean_lower = clean.lower()
+
+        if language == "python":
+            # Exclude async constructors and configuration primitives
+            if clean in (
+                "httpx.AsyncClient",
+                "httpx.Timeout",
+                "httpx.Limits",
+                "httpx.AsyncHTTPTransport",
+            ) or clean.startswith("httpx.Async"):
+                return False
+
+            if clean in ("time.sleep", "sleep", "open", "urllib.request.urlopen", "os.system", "os.popen"):
+                return True
+            if clean.startswith(("requests.", "subprocess.", "urllib.", "urllib3.", "httpx.")):
+                return True
+            return False
+
+        elif language in ("typescript", "javascript"):
+            if "sync" in clean_lower and (
+                clean_lower.startswith("fs.")
+                or clean_lower.startswith("child_process.")
+                or clean_lower.startswith("crypto.")
+                or clean_lower.endswith("sync")
+            ):
+                return True
+            if clean in ("Atomics.wait", "crypto.pbkdf2Sync", "crypto.randomBytesSync"):
+                return True
+            return False
+
+        elif language == "rust":
+            if clean in ("std::thread::sleep", "thread::sleep"):
+                return True
+            if clean.startswith(("std::fs::", "fs::")):
+                return True
+            return False
+
+        return False
+
+    @staticmethod
+    def is_awaited(call_node: Node) -> bool:
+        """Check if call_node is directly enclosed in an await expression."""
+        curr = call_node.parent
+        while curr is not None and curr.type == "parenthesized_expression":
+            curr = curr.parent
+        return curr is not None and curr.type in ("await", "await_expression")
+
+    @classmethod
+    def check(
+        cls,
+        call_node: Node,
+        callee_text: str,
+        is_async_context: bool,
+        current_func_name: str,
+        language: str,
+        file_path: str,
+        lines: List[str],
+    ) -> Optional[PerfDiagnostic]:
+        """Evaluate if call is a blocking synchronous primitive in an async function."""
+        if not is_async_context or not cls.is_blocking_call(callee_text, language):
+            return None
+
+        # Awaited expressions are non-blocking (e.g. await sleep(1))
+        if cls.is_awaited(call_node):
+            return None
+
+        lineno = call_node.start_point.row + 1
+        end_lineno = call_node.end_point.row + 1
+        col = call_node.start_point.column
+        end_col = call_node.end_point.column
+        ctx = lines[lineno - 1].strip() if 1 <= lineno <= len(lines) else None
+
+        msg = (
+            f"Blocking synchronous call '{callee_text}' inside async "
+            f"function '{current_func_name}'"
+        )
+        return PerfDiagnostic(
+            rule_id=cls.RULE_ID,
+            message=msg,
+            severity=Severity.ERROR,
+            file_path=file_path,
+            lineno=lineno,
+            end_lineno=end_lineno,
+            col_offset=col,
+            end_col_offset=end_col,
+            context_line=ctx,
+        )
+
+
+def check_async_blocking(
+    call_node: Node,
+    callee_text: str,
+    is_async_context: bool,
+    current_func_name: str,
+    language: str,
+    file_path: str,
+    lines: List[str],
+) -> Optional[PerfDiagnostic]:
+    """Convenience helper for PERF004 evaluation."""
+    return AsyncBlockingRule.check(
+        call_node=call_node,
+        callee_text=callee_text,
+        is_async_context=is_async_context,
+        current_func_name=current_func_name,
+        language=language,
+        file_path=file_path,
+        lines=lines,
+    )