@orionscanner/cli 0.1.0 → 0.1.1

package/src/orion/engine/architecture/engine.py

@@ -1,463 +0,0 @@
-"""Architecture violations engine - detects structural issues in codebase."""
-import ast
-import os
-from pathlib import Path
-from typing import Dict, List, Set, Optional, Tuple
-from collections import defaultdict, deque
-
-from orion.engine.config import EngineConfig
-from orion.engine.ir import OrionIR
-from orion.engine.results import EngineResult, Finding
-
-
-class ArchitectureEngine:
-    name = "architecture"
-    version = "1.0.0"
-
-    LAYER_ORDER = ["domain", "application", "infrastructure", "presentation"]
-    LAYER_PATTERNS = {
-        "domain": ["domain", "entities", "value_objects", "aggregates", "events", "specifications"],
-        "application": ["application", "use_cases", "services", "commands", "queries", "dtos", "ports"],
-        "infrastructure": ["infrastructure", "repositories", "persistence", "external", "adapters", "gateways", "orm", "database", "migrations"],
-        "presentation": ["presentation", "api", "controllers", "views", "handlers", "endpoints", "routes", "graphql", "rest", "cli", "web", "ui"],
-    }
-
-    EXCLUDED_DIRS = {"__pycache__", ".git", ".venv", "venv", "env", "node_modules", "dist", "build", "tests", "test", "scripts", "migrations"}
-
-    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)
-        for part in path.parts:
-            if part in self.EXCLUDED_DIRS:
-                return True
-        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
-
-    def _is_python_file(self, filepath: str) -> bool:
-        return Path(filepath).suffix == ".py"
-
-    def _get_layer(self, filepath: str) -> Optional[str]:
-        """Determine architectural layer from file path."""
-        path_str = str(Path(filepath)).replace('\\', '/').lower()
-        for layer, patterns in self.LAYER_PATTERNS.items():
-            for pattern in patterns:
-                if f"/{pattern}/" in path_str or path_str.startswith(f"{pattern}/"):
-                    return layer
-        return None
-
-    def _get_module_name(self, filepath: str, project_root: str) -> Optional[str]:
-        try:
-            path = Path(filepath).relative_to(Path(project_root))
-        except ValueError:
-            return None
-
-        if path.suffix == ".py":
-            path = path.with_suffix("")
-
-        parts = list(path.parts)
-        if parts and parts[-1] == "__init__":
-            parts = parts[:-1]
-
-        return ".".join(parts) if parts else None
-
-    def _extract_imports(self, content: str) -> List[str]:
-        imports = []
-        try:
-            tree = ast.parse(content)
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Import):
-                    for alias in node.names:
-                        imports.append(alias.name.split('.')[0])
-                elif isinstance(node, ast.ImportFrom):
-                    if node.module:
-                        imports.append(node.module.split('.')[0])
-        except SyntaxError:
-            pass
-        return imports
-
-    def _detect_cycles(self, graph: Dict[str, Set[str]]) -> List[List[str]]:
-        """Detect cycles in directed graph using Tarjan's algorithm."""
-        index = 0
-        stack = []
-        on_stack = set()
-        indices = {}
-        lowlinks = {}
-        cycles = []
-
-        def strongconnect(v: str):
-            nonlocal index
-            indices[v] = index
-            lowlinks[v] = index
-            index += 1
-            stack.append(v)
-            on_stack.add(v)
-
-            for w in graph.get(v, set()):
-                if w not in indices:
-                    strongconnect(w)
-                    lowlinks[v] = min(lowlinks[v], lowlinks[w])
-                elif w in on_stack:
-                    lowlinks[v] = min(lowlinks[v], indices[w])
-
-            if lowlinks[v] == indices[v]:
-                scc = []
-                while True:
-                    w = stack.pop()
-                    on_stack.remove(w)
-                    scc.append(w)
-                    if w == v:
-                        break
-                if len(scc) > 1:
-                    cycles.append(scc)
-
-        for v in graph:
-            if v not in indices:
-                strongconnect(v)
-
-        return cycles
-
-    def _find_cycle_paths(self, graph: Dict[str, Set[str]], cycles: List[List[str]]) -> List[List[str]]:
-        """Find actual paths for each cycle."""
-        paths = []
-        for cycle in cycles:
-            # Find a path that forms the cycle
-            start = cycle[0]
-            visited = set()
-            path = []
-
-            def dfs(node, target):
-                if node in visited:
-                    return False
-                visited.add(node)
-                path.append(node)
-                if node == target and len(path) > 1:
-                    return True
-                for neighbor in graph.get(node, set()):
-                    if neighbor in cycle:
-                        if dfs(neighbor, target):
-                            return True
-                path.pop()
-                return False
-
-            dfs(start, start)
-            if path:
-                paths.append(path)
-        return paths
-
-    def _check_layer_violations(self, module_layers: Dict[str, str], imports_map: Dict[str, Set[str]]) -> List[Finding]:
-        findings = []
-        layer_index = {layer: i for i, layer in enumerate(self.LAYER_ORDER)}
-
-        for importer, imported_set in imports_map.items():
-            importer_layer = module_layers.get(importer)
-            if not importer_layer:
-                continue
-
-            importer_idx = layer_index.get(importer_layer, 999)
-
-            for imported in imported_set:
-                imported_layer = module_layers.get(imported)
-                if not imported_layer:
-                    continue
-
-                imported_idx = layer_index.get(imported_layer, 999)
-
-                # Check for violations: LOWER layer importing HIGHER layer
-                # domain (0) should not import application (1), infrastructure (2), presentation (3)
-                # application (1) should not import infrastructure (2), presentation (3)
-                # infrastructure (2) should not import presentation (3)
-                if importer_idx < imported_idx:
-                    # VIOLATION: lower layer importing higher layer
-                    violation_type = ""
-                    if importer_layer == "domain" and imported_layer in ("application", "infrastructure", "presentation"):
-                        violation_type = "domain_imports_higher_layer"
-                    elif importer_layer == "application" and imported_layer in ("infrastructure", "presentation"):
-                        violation_type = "application_imports_higher_layer"
-                    elif importer_layer == "infrastructure" and imported_layer == "presentation":
-                        violation_type = "infrastructure_imports_presentation"
-                    else:
-                        violation_type = "layer_violation"
-
-                    findings.append(Finding(
-                        engine=self.name,
-                        severity="high",
-                        title=f"Layer violation: {importer_layer} imports {imported_layer}",
-                        description=f"Module '{importer}' (layer: {importer_layer}) imports '{imported}' (layer: {imported_layer}) - violates layered architecture",
-                        location=importer,
-                        metadata={
-                            "violation": violation_type,
-                            "importer": importer,
-                            "importer_layer": importer_layer,
-                            "imported": imported,
-                            "imported_layer": imported_layer,
-                        },
-                    ))
-        return findings
-
-    def _check_god_modules(self, module_to_file: Dict[str, str], all_files: Dict[str, OrionIR]) -> List[Finding]:
-        findings = []
-        for module, filepath in module_to_file.items():
-            file_ir = all_files.get(filepath)
-            if not file_ir:
-                continue
-            try:
-                content = file_ir.content.decode("utf-8", errors="replace")
-                lines = content.splitlines()
-                if len(lines) > 1000:
-                    findings.append(Finding(
-                        engine=self.name,
-                        severity="medium",
-                        title=f"God module: {module} has {len(lines)} lines",
-                        description=f"Module exceeds 1000 lines ({len(lines)}), consider splitting",
-                        location=filepath,
-                        metadata={
-                            "violation": "god_module",
-                            "module": module,
-                            "file": filepath,
-                            "line_count": len(lines),
-                        },
-                    ))
-            except Exception:
-                pass
-        return findings
-
-    def _check_feature_envy(self, all_files: Dict[str, OrionIR], module_to_file: Dict[str, str], project_root: str) -> List[Finding]:
-        findings = []
-        # Feature envy: method uses more attributes of another class than its own
-        # This is a simplified check - we look for methods that heavily use another class
-        for module, filepath in module_to_file.items():
-            file_ir = all_files.get(filepath)
-            if not file_ir:
-                continue
-            try:
-                content = file_ir.content.decode("utf-8", errors="replace")
-                tree = ast.parse(content)
-            except Exception:
-                continue
-
-            for node in ast.walk(tree):
-                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                    # Count attribute accesses
-                    attr_accesses = defaultdict(int)
-                    for n in ast.walk(node):
-                        if isinstance(n, ast.Attribute) and isinstance(n.ctx, ast.Load):
-                            # Get the base object name
-                            if isinstance(n.value, ast.Name):
-                                attr_accesses[n.value.id] += 1
-
-                    if attr_accesses:
-                        # Find the most accessed object
-                        max_obj = max(attr_accesses, key=attr_accesses.get)
-                        max_count = attr_accesses[max_obj]
-                        total = sum(attr_accesses.values())
-
-                        # If more than 60% of attribute accesses are to another object
-                        if max_count > 3 and max_count / total > 0.6 and max_obj != "self":
-                            findings.append(Finding(
-                                engine=self.name,
-                                severity="low",
-                                title=f"Possible feature envy in {node.name}",
-                                description=f"Method '{node.name}' accesses '{max_obj}' {max_count} times out of {total} total attribute accesses",
-                                location=f"{filepath}:{node.lineno}",
-                                metadata={
-                                    "violation": "feature_envy",
-                                    "function": node.name,
-                                    "file": filepath,
-                                    "envied_object": max_obj,
-                                    "access_count": max_count,
-                                    "total_accesses": total,
-                                },
-                            ))
-        return findings
-
-    def _check_data_class_behavior(self, all_files: Dict[str, OrionIR], module_to_file: Dict[str, str]) -> List[Finding]:
-        findings = []
-        for module, filepath in module_to_file.items():
-            file_ir = all_files.get(filepath)
-            if not file_ir:
-                continue
-            try:
-                content = file_ir.content.decode("utf-8", errors="replace")
-                tree = ast.parse(content)
-            except Exception:
-                continue
-
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    # Check if it looks like a data class (has __dataclass_fields__ or @dataclass)
-                    is_dataclass = False
-                    for decorator in node.decorator_list:
-                        if isinstance(decorator, ast.Name) and decorator.id == "dataclass":
-                            is_dataclass = True
-                        elif isinstance(decorator, ast.Attribute) and decorator.attr == "dataclass":
-                            is_dataclass = True
-
-                    if is_dataclass:
-                        methods = [n for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
-                        allowed = {"__init__", "__post_init__", "__repr__", "__eq__", "__hash__", "__str__", "__lt__", "__le__", "__gt__", "__ge__"}
-                        extra_methods = [m.name for m in methods if m.name not in allowed and not m.name.startswith('_')]
-                        if extra_methods:
-                            findings.append(Finding(
-                                engine=self.name,
-                                severity="low",
-                                title=f"Data class with behavior: {node.name}",
-                                description=f"Data class has methods beyond data protocols: {', '.join(extra_methods)}",
-                                location=f"{filepath}:{node.lineno}",
-                                metadata={
-                                    "violation": "data_class_with_behavior",
-                                    "class": node.name,
-                                    "file": filepath,
-                                    "methods": extra_methods,
-                                },
-                            ))
-        return findings
-
-    def _check_circular_package_deps(self, module_to_file: Dict[str, str], imports_map: Dict[str, Set[str]]) -> List[Finding]:
-        """Check for circular dependencies at package level."""
-        findings = []
-        # Group modules by package (top-level)
-        package_map = defaultdict(set)
-        for module in module_to_file:
-            top_level = module.split('.')[0] if '.' in module else module
-            package_map[top_level].add(module)
-
-        # Build package-level graph
-        package_graph = defaultdict(set)
-        for importer, imported_set in imports_map.items():
-            importer_pkg = importer.split('.')[0] if '.' in importer else importer
-            for imported in imported_set:
-                imported_pkg = imported.split('.')[0] if '.' in imported else imported
-                if importer_pkg != imported_pkg:
-                    package_graph[importer_pkg].add(imported_pkg)
-
-        # Detect cycles at package level
-        cycles = self._detect_cycles(package_graph)
-        for cycle in cycles:
-            findings.append(Finding(
-                engine=self.name,
-                severity="high",
-                title=f"Circular package dependency: {' -> '.join(cycle)}",
-                description=f"Packages form a circular dependency",
-                location=cycle[0],
-                metadata={
-                    "violation": "circular_package_dependency",
-                    "packages": cycle,
-                },
-            ))
-        return findings
-
-    async def run(self, ir: OrionIR, config: EngineConfig) -> EngineResult:
-        project_root = ir.metadata.get("project_root", ".")
-        all_files = ir.metadata.get("all_files", {})
-
-        if not all_files:
-            return EngineResult(engine=self.name, ok=True, metrics={"mode": "single_file"})
-
-        # Build module map
-        module_to_file = {}
-        file_to_module = {}
-        module_layers = {}
-
-        for filepath, file_ir in all_files.items():
-            if not self._is_python_file(filepath):
-                continue
-            if self._should_exclude(filepath, config):
-                continue
-
-            module_name = self._get_module_name(filepath, project_root)
-            if not module_name:
-                continue
-
-            module_to_file[module_name] = filepath
-            file_to_module[filepath] = module_name
-            layer = self._get_layer(filepath)
-            if layer:
-                module_layers[module_name] = layer
-
-        # Build import graph
-        imports_map = defaultdict(set)
-        for filepath, file_ir in all_files.items():
-            if not self._is_python_file(filepath):
-                continue
-            if self._should_exclude(filepath, config):
-                continue
-
-            module_name = file_to_module.get(filepath)
-            if not module_name:
-                continue
-
-            try:
-                content = file_ir.content.decode("utf-8", errors="replace")
-            except Exception:
-                continue
-
-            imports = self._extract_imports(content)
-            for imp in imports:
-                # Resolve to known modules
-                if imp in module_to_file:
-                    imports_map[module_name].add(imp)
-                else:
-                    # Try to match partial
-                    for known_module in module_to_file:
-                        if known_module.startswith(imp + ".") or imp.startswith(known_module + "."):
-                            imports_map[module_name].add(known_module)
-                            break
-
-        all_findings = []
-
-        # 1. Cyclic imports (module level)
-        cycles = self._detect_cycles(imports_map)
-        cycle_paths = self._find_cycle_paths(imports_map, cycles)
-        for path in cycle_paths:
-            all_findings.append(Finding(
-                engine=self.name,
-                severity="high",
-                title=f"Cyclic import: {' -> '.join(path)}",
-                description=f"Modules form a circular import dependency",
-                location=path[0],
-                metadata={
-                    "violation": "cyclic_import",
-                    "modules": path,
-                    "files": [module_to_file.get(m, "") for m in path],
-                },
-            ))
-
-        # 2. Layer violations
-        all_findings.extend(self._check_layer_violations(module_layers, imports_map))
-
-        # 3. God modules
-        all_findings.extend(self._check_god_modules(module_to_file, all_files))
-
-        # 4. Feature envy
-        all_findings.extend(self._check_feature_envy(all_files, module_to_file, project_root))
-
-        # 5. Data class with behavior
-        all_findings.extend(self._check_data_class_behavior(all_files, module_to_file))
-
-        # 6. Circular package dependencies
-        all_findings.extend(self._check_circular_package_deps(module_to_file, imports_map))
-
-        return EngineResult(
-            engine=self.name,
-            findings=all_findings,
-            ok=True,
-            metrics={
-                "modules_analyzed": len(module_to_file),
-                "import_edges": sum(len(v) for v in imports_map.values()),
-                "cycles_found": len(cycles),
-                "layers_detected": len(set(module_layers.values())),
-                "findings_count": len(all_findings),
-            },
-        )
-
-
-Engine = ArchitectureEngine