@orionscanner/cli 0.1.0 → 0.5.1

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

@@ -1,558 +0,0 @@
-"""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