@orionscanner/cli 0.1.0

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

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