@orionscanner/cli 0.1.0

package/src/orion/engine/lint/engine.py

@@ -0,0 +1,558 @@
+"""Python linting engine - AST-based comprehensive linting without external tools."""
+import ast
+import re
+from pathlib import Path
+from typing import List, Dict, Set, Optional, Any
+from collections import defaultdict
+
+from orion.engine.config import EngineConfig
+from orion.engine.ir import OrionIR
+from orion.engine.results import EngineResult, Finding
+
+
+import builtins
+import sys
+
+class LintEngine:
+    name = "lint"
+    version = "1.0.0"
+
+    STDLIB_MODULES = {
+        "os", "sys", "json", "re", "ast", "typing", "collections", "itertools",
+        "functools", "dataclasses", "enum", "pathlib", "datetime", "time",
+        "math", "random", "string", "hashlib", "hmac", "secrets", "uuid",
+        "subprocess", "threading", "multiprocessing", "asyncio", "socket",
+        "urllib", "http", "email", "html", "xml", "csv", "sqlite3", "pickle",
+        "copy", "pprint", "textwrap", "unicodedata", "fractions", "decimal",
+        "statistics", "inspect", "importlib", "pkgutil", "runpy", "traceback",
+        "warnings", "contextlib", "abc", "numbers", "operator", "keyword",
+        "tokenize", "token", "parser", "symbol", "ast", "sysconfig", "site",
+        "builtins", "__future__", "__main__", "argparse", "getopt", "optparse",
+        "shlex", "cmd", "readline", "rlcompleter", "logging", "logging.config",
+        "logging.handlers", "configparser", "netrc", "xdrlib", "plistlib",
+        "base64", "binascii", "quopri", "uu", "zlib", "gzip", "bz2", "lzma",
+        "zipfile", "tarfile", "tomllib", "tomli", "signal", "mmap", "errno",
+        "ctypes", "concurrent", "queue", "contextvars"
+    }
+
+    THIRD_PARTY_INDICATORS = {
+        "django", "flask", "fastapi", "requests", "httpx", "aiohttp",
+        "sqlalchemy", "pydantic", "numpy", "pandas", "scipy", "matplotlib",
+        "pytest", "unittest", "celery", "redis", "psycopg2", "pymongo",
+        "boto3", "google", "azure", "aws", "kubernetes", "docker",
+        "rich", "click", "typer", "jinja2", "pyyaml", "cryptography"
+    }
+
+    async def check_availability(self) -> bool:
+        return True
+
+    def resource_limits(self):
+        from orion.engine.config import ResourceLimits
+        return ResourceLimits(max_cpu_seconds=60, max_memory_mb=256)
+
+    def _should_exclude(self, filepath: str, config: EngineConfig) -> bool:
+        path = Path(filepath)
+        if config.toggles.get("exclude"):
+            for pattern in config.toggles["exclude"]:
+                if path.match(pattern) or any(p.match(pattern) for p in path.parents):
+                    return True
+        return False
+
+    class LintVisitor(ast.NodeVisitor):
+        def __init__(self, content: str, filepath: str, project_root: str):
+            self.content = content
+            self.filepath = filepath
+            self.project_root = project_root
+            self.lines = content.splitlines()
+            self.findings = []
+            self.scope_stack = [set()]  # Stack of variable scopes
+            self.imports = []  # List of (line, module, names, is_from)
+            self.assignments = defaultdict(list)  # var_name -> list of (line, node)
+            self.usages = defaultdict(list)  # var_name -> list of (line, node)
+            self.function_defs = []  # List of (name, line, node, is_public)
+            self.class_defs = []  # List of (name, line, node, methods, bases)
+            self.current_function = None
+            self.current_class = None
+            self.builtins = set(dir(builtins)) | {
+                "__file__", "__name__", "__doc__", "__package__", "__loader__",
+                "__spec__", "__annotations__", "__builtins__", "__all__", "__path__",
+                "__class__", "__dict__", "cls", "self"
+            }
+
+        def _get_snippet(self, line_num: int, context: int = 2) -> str:
+            start = max(0, line_num - context - 1)
+            end = min(len(self.lines), line_num + context)
+            return '\n'.join(self.lines[start:end])
+
+        def _add_finding(self, severity: str, title: str, description: str, line: int, metadata: dict):
+            self.findings.append({
+                "severity": severity,
+                "title": title,
+                "description": description,
+                "line": line,
+                "snippet": self._get_snippet(line),
+                "metadata": metadata,
+            })
+
+        def push_scope(self):
+            self.scope_stack.append(set())
+
+        def pop_scope(self):
+            if len(self.scope_stack) > 1:
+                self.scope_stack.pop()
+
+        def add_var(self, name: str, line: int, node: ast.AST):
+            if name:
+                self.scope_stack[-1].add(name)
+                self.assignments[name].append((line, node))
+
+        def use_var(self, name: str, line: int, node: ast.AST):
+            if name:
+                self.usages[name].append((line, node))
+
+        def is_defined(self, name: str) -> bool:
+            if not name:
+                return True
+            for scope in reversed(self.scope_stack):
+                if name in scope:
+                    return True
+            return name in self.builtins
+
+        def _extract_target_names(self, node: ast.AST) -> List[str]:
+            names = []
+            if isinstance(node, ast.Name):
+                names.append(node.id)
+            elif isinstance(node, (ast.Tuple, ast.List)):
+                for elt in node.elts:
+                    names.extend(self._extract_target_names(elt))
+            elif isinstance(node, ast.Starred):
+                names.extend(self._extract_target_names(node.value))
+            return names
+
+        def visit_Module(self, node: ast.Module):
+            self.generic_visit(node)
+
+        def visit_FunctionDef(self, node: ast.FunctionDef):
+            is_public = not node.name.startswith('_')
+            self.function_defs.append((node.name, node.lineno, node, is_public))
+            self.add_var(node.name, node.lineno, node)
+
+            for default in node.args.defaults:
+                if isinstance(default, (ast.List, ast.Dict, ast.Set)):
+                    self._add_finding(
+                        "medium",
+                        f"Mutable default argument in function '{node.name}'",
+                        "Mutable default arguments retain state across invocations and can cause unexpected bugs",
+                        node.lineno,
+                        {"rule": "mutable_default_argument", "function": node.name, "type": type(default).__name__},
+                    )
+
+            self.push_scope()
+            self.current_function = node.name
+            for arg in node.args.args:
+                self.add_var(arg.arg, arg.lineno, arg)
+            for arg in getattr(node.args, 'posonlyargs', []):
+                self.add_var(arg.arg, arg.lineno, arg)
+            for arg in getattr(node.args, 'kwonlyargs', []):
+                self.add_var(arg.arg, arg.lineno, arg)
+            if node.args.vararg:
+                self.add_var(node.args.vararg.arg, node.args.vararg.lineno, node.args.vararg)
+            if node.args.kwarg:
+                self.add_var(node.args.kwarg.arg, node.args.kwarg.lineno, node.args.kwarg)
+
+            self.generic_visit(node)
+            self.pop_scope()
+            self.current_function = None
+
+        def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+            self.visit_FunctionDef(node)
+
+        def visit_ClassDef(self, node: ast.ClassDef):
+            is_public = not node.name.startswith('_')
+            self.add_var(node.name, node.lineno, node)
+            methods = [n for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+            self.class_defs.append((node.name, node.lineno, node, methods, node.bases))
+
+            self.push_scope()
+            self.current_class = node.name
+            self.generic_visit(node)
+            self.pop_scope()
+            self.current_class = None
+
+        def visit_Assign(self, node: ast.Assign):
+            for target in node.targets:
+                for name in self._extract_target_names(target):
+                    self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_AnnAssign(self, node: ast.AnnAssign):
+            if node.target:
+                for name in self._extract_target_names(node.target):
+                    self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_AugAssign(self, node: ast.AugAssign):
+            if isinstance(node.target, ast.Name):
+                self.use_var(node.target.id, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_For(self, node: ast.For):
+            for name in self._extract_target_names(node.target):
+                self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_AsyncFor(self, node: ast.AsyncFor):
+            for name in self._extract_target_names(node.target):
+                self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_With(self, node: ast.With):
+            for item in node.items:
+                if item.optional_vars:
+                    for name in self._extract_target_names(item.optional_vars):
+                        self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_AsyncWith(self, node: ast.AsyncWith):
+            for item in node.items:
+                if item.optional_vars:
+                    for name in self._extract_target_names(item.optional_vars):
+                        self.add_var(name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_ExceptHandler(self, node: ast.ExceptHandler):
+            if node.name:
+                self.add_var(node.name, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_comprehension(self, node: ast.comprehension):
+            for name in self._extract_target_names(node.target):
+                self.add_var(name, getattr(node.target, 'lineno', 1), node)
+            self.generic_visit(node)
+
+        def visit_Name(self, node: ast.Name):
+            if isinstance(node.ctx, ast.Load):
+                self.use_var(node.id, node.lineno, node)
+                if not self.is_defined(node.id):
+                    self._add_finding(
+                        "medium",
+                        f"Undefined name '{node.id}'",
+                        f"Name '{node.id}' is used but not defined in visible scopes",
+                        node.lineno,
+                        {"rule": "undefined_name", "name": node.id, "cwe": "CWE-476"},
+                    )
+            elif isinstance(node.ctx, (ast.Store, ast.Del)):
+                self.add_var(node.id, node.lineno, node)
+            self.generic_visit(node)
+
+        def visit_Import(self, node: ast.Import):
+            for alias in node.names:
+                name = alias.asname or alias.name.split('.')[0]
+                self.add_var(name, node.lineno, node)
+                self.imports.append((node.lineno, alias.name, [alias.asname or alias.name], False))
+            self.generic_visit(node)
+
+        def visit_ImportFrom(self, node: ast.ImportFrom):
+            module = node.module or ""
+            names = []
+            for alias in node.names:
+                if alias.name != "*":
+                    name = alias.asname or alias.name
+                    self.add_var(name, node.lineno, node)
+                    names.append(name)
+                else:
+                    names.append("*")
+            self.imports.append((node.lineno, module, names, True))
+            if any(n == '*' for n in names):
+                self._add_finding(
+                    "medium",
+                    f"Wildcard import from '{module}'",
+                    "Wildcard imports make it unclear what names are available",
+                    node.lineno,
+                    {"rule": "wildcard_import", "module": module},
+                )
+            self.generic_visit(node)
+
+        def visit_Compare(self, node: ast.Compare):
+            # Check for comparison to None using ==/!=
+            if len(node.ops) == 1 and len(node.comparators) == 1:
+                op = node.ops[0]
+                comp = node.comparators[0]
+                if isinstance(comp, ast.Constant) and comp.value is None:
+                    if isinstance(op, (ast.Eq, ast.NotEq)):
+                        self._add_finding(
+                            "medium",
+                            "Comparison to None using ==/!=",
+                            "Use 'is None' or 'is not None' instead",
+                            node.lineno,
+                            {"rule": "comparison_to_none", "operator": "==" if isinstance(op, ast.Eq) else "!="},
+                        )
+            self.generic_visit(node)
+
+        def visit_Try(self, node: ast.Try):
+            for handler in node.handlers:
+                if handler.type is None:
+                    # Bare except:
+                    self._add_finding(
+                        "medium",
+                        "Bare except: clause",
+                        "Bare except catches all exceptions including SystemExit and KeyboardInterrupt",
+                        handler.lineno,
+                        {"rule": "bare_except"},
+                    )
+            self.generic_visit(node)
+
+        def visit_Call(self, node: ast.Call):
+            # Check for eval/exec usage
+            if isinstance(node.func, ast.Name):
+                if node.func.id in ("eval", "exec"):
+                    self._add_finding(
+                        "high",
+                        f"Use of {node.func.id}()",
+                        f"{node.func.id}() can execute arbitrary code - security risk",
+                        node.lineno,
+                        {"rule": f"{node.func.id}_usage"},
+                    )
+            self.generic_visit(node)
+
+    def _check_unused_variables(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        for var_name, assignments in visitor.assignments.items():
+            usages = visitor.usages.get(var_name, [])
+            if not usages:
+                # Check if it's a legitimate unused (e.g., _ prefix, or in __all__)
+                if var_name.startswith('_') and len(var_name) == 1:
+                    continue  # Single underscore is often used as throwaway
+                if var_name.startswith('__') and var_name.endswith('__'):
+                    continue  # Dunder methods/vars
+                for line, node in assignments:
+                    findings.append({
+                        "severity": "low",
+                        "title": f"Unused variable '{var_name}'",
+                        "description": f"Variable '{var_name}' is assigned but never used",
+                        "line": line,
+                        "snippet": visitor._get_snippet(line),
+                        "metadata": {"rule": "unused_variable", "variable": var_name},
+                    })
+        return findings
+
+    def _check_import_order(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        if not visitor.imports:
+            return findings
+
+        # Categorize imports
+        stdlib_imports = []
+        third_party_imports = []
+        local_imports = []
+
+        for line, module, names, is_from in visitor.imports:
+            if module.startswith('.'):
+                local_imports.append((line, module, names, is_from))
+            elif module.split('.')[0] in self.STDLIB_MODULES:
+                stdlib_imports.append((line, module, names, is_from))
+            else:
+                third_party_imports.append((line, module, names, is_from))
+
+        # Check order: stdlib -> third-party -> local
+        all_imports = stdlib_imports + third_party_imports + local_imports
+        expected_lines = [imp[0] for imp in all_imports]
+        actual_lines = [imp[0] for imp in visitor.imports]
+
+        # Simple check: stdlib imports should come before third-party, etc.
+        last_stdlib = max([imp[0] for imp in stdlib_imports], default=0)
+        first_third = min([imp[0] for imp in third_party_imports], default=float('inf'))
+        last_third = max([imp[0] for imp in third_party_imports], default=0)
+        first_local = min([imp[0] for imp in local_imports], default=float('inf'))
+
+        if last_stdlib > first_third and first_third != float('inf'):
+            findings.append({
+                "severity": "low",
+                "title": "Import order violation: stdlib after third-party",
+                "description": "Standard library imports should come before third-party imports",
+                "line": first_third,
+                "snippet": visitor._get_snippet(first_third),
+                "metadata": {"rule": "import_order", "issue": "stdlib_after_third_party"},
+            })
+
+        if last_third > first_local and first_local != float('inf'):
+            findings.append({
+                "severity": "low",
+                "title": "Import order violation: third-party after local",
+                "description": "Third-party imports should come before local imports",
+                "line": first_local,
+                "snippet": visitor._get_snippet(first_local),
+                "metadata": {"rule": "import_order", "issue": "third_party_after_local"},
+            })
+
+        # Check for blank lines between groups
+        if stdlib_imports and third_party_imports:
+            last_stdlib_line = max(imp[0] for imp in stdlib_imports)
+            first_third_line = min(imp[0] for imp in third_party_imports)
+            if first_third_line - last_stdlib_line == 1:
+                # Check if there's a blank line
+                if visitor.lines[last_stdlib_line].strip() != "":
+                    findings.append({
+                        "severity": "low",
+                        "title": "Missing blank line between import groups",
+                        "description": "Add a blank line between standard library and third-party imports",
+                        "line": first_third_line,
+                        "snippet": visitor._get_snippet(first_third_line),
+                        "metadata": {"rule": "import_order", "issue": "missing_blank_line"},
+                    })
+
+        return findings
+
+    def _check_line_length(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        for i, line in enumerate(visitor.lines, 1):
+            if len(line) > 100:
+                findings.append({
+                    "severity": "low",
+                    "title": f"Line too long ({len(line)} > 100)",
+                    "description": f"Line exceeds maximum recommended length of 100 characters",
+                    "line": i,
+                    "snippet": visitor._get_snippet(i, 1),
+                    "metadata": {"rule": "line_length", "length": len(line)},
+                })
+        return findings
+
+    def _check_trailing_whitespace(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        for i, line in enumerate(visitor.lines, 1):
+            if line.rstrip() != line:
+                findings.append({
+                    "severity": "low",
+                    "title": "Trailing whitespace",
+                    "description": "Line has trailing whitespace",
+                    "line": i,
+                    "snippet": visitor._get_snippet(i, 1),
+                    "metadata": {"rule": "trailing_whitespace"},
+                })
+        return findings
+
+    def _check_init_not_empty(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        if Path(visitor.filepath).name == "__init__.py":
+            # Check if it's essentially empty (only comments/docstrings)
+            non_empty_lines = [l for l in visitor.lines if l.strip() and not l.strip().startswith('#')]
+            if len(non_empty_lines) <= 1:  # Allow just a docstring
+                # Check if it's a namespace package (has __path__ manipulation)
+                has_namespace = any("__path__" in l for l in visitor.lines)
+                if not has_namespace:
+                    findings.append({
+                        "severity": "low",
+                        "title": "Empty __init__.py",
+                        "description": "__init__.py should not be empty unless it's a namespace package",
+                        "line": 1,
+                        "snippet": visitor._get_snippet(1),
+                        "metadata": {"rule": "empty_init"},
+                    })
+        return findings
+
+    def _check_god_class(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        for class_name, line, node, methods, bases in visitor.class_defs:
+            if len(methods) > 20:
+                findings.append({
+                    "severity": "medium",
+                    "title": f"God class: '{class_name}' has {len(methods)} methods",
+                    "description": f"Class has too many methods ({len(methods)} > 20), consider splitting",
+                    "line": line,
+                    "snippet": visitor._get_snippet(line),
+                    "metadata": {"rule": "god_class", "class": class_name, "method_count": len(methods)},
+                })
+            # Check lines of code in class
+            if hasattr(node, 'end_lineno') and node.end_lineno:
+                class_lines = node.end_lineno - node.lineno + 1
+                if class_lines > 500:
+                    findings.append({
+                        "severity": "medium",
+                        "title": f"God class: '{class_name}' has {class_lines} lines",
+                        "description": f"Class is too long ({class_lines} > 500 lines), consider splitting",
+                        "line": line,
+                        "snippet": visitor._get_snippet(line),
+                        "metadata": {"rule": "god_class_lines", "class": class_name, "line_count": class_lines},
+                    })
+        return findings
+
+    def _check_long_function(self, visitor: 'LintEngine.LintVisitor') -> List[dict]:
+        findings = []
+        for func_name, line, node, is_public in visitor.function_defs:
+            if hasattr(node, 'end_lineno') and node.end_lineno:
+                func_lines = node.end_lineno - node.lineno + 1
+                if func_lines > 50:
+                    findings.append({
+                        "severity": "low",
+                        "title": f"Long function: '{func_name}' has {func_lines} lines",
+                        "description": f"Function is too long ({func_lines} > 50 lines), consider refactoring",
+                        "line": line,
+                        "snippet": visitor._get_snippet(line),
+                        "metadata": {"rule": "long_function", "function": func_name, "line_count": func_lines},
+                    })
+        return findings
+
+    async def run(self, ir: OrionIR, config: EngineConfig) -> EngineResult:
+        filepath = ir.metadata.get("path", "unknown")
+
+        if not filepath.endswith(".py"):
+            return EngineResult(engine=self.name, ok=True, metrics={"skipped": "not_python"})
+
+        if self._should_exclude(filepath, config):
+            return EngineResult(engine=self.name, ok=True, metrics={"skipped": "excluded"})
+
+        try:
+            content = ir.content.decode("utf-8", errors="replace")
+        except Exception:
+            content = str(ir.content)
+
+        project_root = ir.metadata.get("project_root", ".")
+
+        visitor = self.LintVisitor(content, filepath, project_root)
+        try:
+            tree = ast.parse(content)
+            visitor.visit(tree)
+        except SyntaxError as e:
+            return EngineResult(
+                engine=self.name,
+                findings=[Finding(
+                    engine=self.name,
+                    severity="error",
+                    title="Syntax error in file",
+                    description=f"Cannot parse file due to syntax error: {e}",
+                    location=f"{filepath}:{e.lineno}",
+                    metadata={"rule": "syntax_error"},
+                )],
+                ok=True,
+            )
+
+        # Run essential code quality checks only
+        all_findings = visitor.findings
+        all_findings.extend(self._check_unused_variables(visitor))
+        all_findings.extend(self._check_god_class(visitor))
+
+        # Convert to Finding objects
+        findings = []
+        for f in all_findings:
+            findings.append(Finding(
+                engine=self.name,
+                severity=f["severity"],
+                title=f["title"],
+                description=f["description"],
+                location=f"{filepath}:{f['line']}",
+                metadata={**f["metadata"], "file": filepath, "line": f["line"], "snippet": f["snippet"]},
+            ))
+
+        return EngineResult(
+            engine=self.name,
+            findings=findings,
+            ok=True,
+            metrics={
+                "file": filepath,
+                "checks_run": 10,
+                "findings_count": len(findings),
+            },
+        )
+
+
+Engine = LintEngine