@voodocs/cli 2.4.0 → 2.5.1

package/lib/darkarts/priority_analyzer/complexity.py

@@ -0,0 +1,271 @@
+"""
+Complexity Analyzer for VooDocs Priority System
+
+Analyzes file complexity based on:
+- Lines of code (LOC)
+- Cyclomatic complexity (control flow)
+- Function count
+"""
+
+import re
+from pathlib import Path
+from typing import Dict
+
+
+class ComplexityAnalyzer:
+    """Analyzes code complexity for priority scoring."""
+    
+    # Control flow keywords by language
+    CONTROL_FLOW_PATTERNS = {
+        'if': r'\bif\s*\(',
+        'else': r'\belse\b',
+        'elif': r'\b(elif|else\s+if)\s*\(',
+        'for': r'\bfor\s*\(',
+        'while': r'\bwhile\s*\(',
+        'switch': r'\bswitch\s*\(',
+        'case': r'\bcase\s+',
+        'try': r'\btry\s*\{',
+        'catch': r'\bcatch\s*\(',
+        'except': r'\bexcept\s*:',
+    }
+    
+    # Function definition patterns by language
+    FUNCTION_PATTERNS = {
+        'python': r'^\s*def\s+\w+\s*\(',
+        'typescript': r'^\s*(export\s+)?(async\s+)?function\s+\w+\s*\(',
+        'javascript': r'^\s*(export\s+)?(async\s+)?function\s+\w+\s*\(',
+        'arrow_function': r'^\s*(const|let|var)\s+\w+\s*=\s*(\([^)]*\)|[^=]+)\s*=>',
+        'method': r'^\s*(public|private|protected)?\s*(static\s+)?(async\s+)?\w+\s*\(',
+        'solidity': r'^\s*function\s+\w+\s*\(',
+    }
+    
+    def __init__(self):
+        """Initialize complexity analyzer."""
+        pass
+    
+    def analyze_file(self, filepath: str) -> Dict[str, int]:
+        """
+        Analyze a file's complexity.
+        
+        Args:
+            filepath: Path to file to analyze
+            
+        Returns:
+            Dictionary with complexity metrics and scores
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            return {
+                'loc': 0,
+                'loc_score': 0,
+                'cyclomatic': 0,
+                'cyclomatic_score': 0,
+                'functions': 0,
+                'function_score': 0,
+                'total_score': 0,
+                'error': str(e)
+            }
+        
+        # Calculate metrics
+        loc = self._count_lines_of_code(content)
+        cyclomatic = self._calculate_cyclomatic_complexity(content)
+        functions = self._count_functions(content, filepath)
+        
+        # Calculate scores
+        loc_score = self._calculate_loc_score(loc)
+        cyclomatic_score = self._calculate_cyclomatic_score(cyclomatic)
+        function_score = self._calculate_function_score(functions)
+        
+        # Total score (capped at 100)
+        total_score = min(100, loc_score + cyclomatic_score + function_score)
+        
+        return {
+            'loc': loc,
+            'loc_score': loc_score,
+            'cyclomatic': cyclomatic,
+            'cyclomatic_score': cyclomatic_score,
+            'functions': functions,
+            'function_score': function_score,
+            'total_score': total_score
+        }
+    
+    def _count_lines_of_code(self, content: str) -> int:
+        """
+        Count non-empty, non-comment lines of code.
+        
+        Args:
+            content: File content
+            
+        Returns:
+            Line count
+        """
+        lines = content.split('\n')
+        loc = 0
+        
+        in_multiline_comment = False
+        
+        for line in lines:
+            stripped = line.strip()
+            
+            # Skip empty lines
+            if not stripped:
+                continue
+            
+            # Handle multi-line comments
+            if '/*' in stripped:
+                in_multiline_comment = True
+            if '*/' in stripped:
+                in_multiline_comment = False
+                continue
+            if in_multiline_comment:
+                continue
+            
+            # Skip single-line comments
+            if stripped.startswith('//') or stripped.startswith('#'):
+                continue
+            
+            # Count as LOC
+            loc += 1
+        
+        return loc
+    
+    def _calculate_cyclomatic_complexity(self, content: str) -> int:
+        """
+        Calculate cyclomatic complexity by counting control flow statements.
+        
+        Args:
+            content: File content
+            
+        Returns:
+            Cyclomatic complexity score
+        """
+        complexity = 0
+        
+        # Count each type of control flow
+        for keyword, pattern in self.CONTROL_FLOW_PATTERNS.items():
+            matches = re.findall(pattern, content, re.MULTILINE)
+            count = len(matches)
+            
+            # Weight different constructs
+            if keyword in ['if', 'elif', 'else']:
+                complexity += count * 2
+            elif keyword in ['for', 'while']:
+                complexity += count * 3
+            elif keyword in ['try', 'catch', 'except']:
+                complexity += count * 3
+            elif keyword in ['switch', 'case']:
+                complexity += count * 2
+            else:
+                complexity += count
+        
+        # Count nesting depth (rough estimate)
+        nesting_depth = self._estimate_nesting_depth(content)
+        complexity += nesting_depth
+        
+        return complexity
+    
+    def _estimate_nesting_depth(self, content: str) -> int:
+        """
+        Estimate maximum nesting depth by counting indentation.
+        
+        Args:
+            content: File content
+            
+        Returns:
+            Estimated nesting depth
+        """
+        max_depth = 0
+        lines = content.split('\n')
+        
+        for line in lines:
+            if not line.strip():
+                continue
+            
+            # Count leading spaces/tabs
+            leading_spaces = len(line) - len(line.lstrip())
+            
+            # Assume 2 or 4 spaces per indent level
+            if '\t' in line[:leading_spaces]:
+                depth = line[:leading_spaces].count('\t')
+            else:
+                # Try 4 spaces first, then 2
+                depth = leading_spaces // 4
+                if depth == 0 and leading_spaces >= 2:
+                    depth = leading_spaces // 2
+            
+            max_depth = max(max_depth, depth)
+        
+        return max_depth
+    
+    def _count_functions(self, content: str, filepath: str) -> int:
+        """
+        Count function definitions in file.
+        
+        Args:
+            content: File content
+            filepath: File path (to determine language)
+            
+        Returns:
+            Function count
+        """
+        function_count = 0
+        
+        # Determine language from extension
+        ext = Path(filepath).suffix.lower()
+        
+        # Apply appropriate patterns
+        if ext in ['.py']:
+            pattern = self.FUNCTION_PATTERNS['python']
+            function_count += len(re.findall(pattern, content, re.MULTILINE))
+        
+        elif ext in ['.ts', '.tsx']:
+            # TypeScript: regular functions + arrow functions + methods
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['typescript'], content, re.MULTILINE))
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['arrow_function'], content, re.MULTILINE))
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['method'], content, re.MULTILINE))
+        
+        elif ext in ['.js', '.jsx']:
+            # JavaScript: regular functions + arrow functions
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['javascript'], content, re.MULTILINE))
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['arrow_function'], content, re.MULTILINE))
+        
+        elif ext in ['.sol']:
+            # Solidity: function definitions
+            function_count += len(re.findall(self.FUNCTION_PATTERNS['solidity'], content, re.MULTILINE))
+        
+        return function_count
+    
+    def _calculate_loc_score(self, loc: int) -> int:
+        """Calculate score based on lines of code."""
+        if loc < 50:
+            return 0
+        elif loc < 100:
+            return 10
+        elif loc < 200:
+            return 20
+        elif loc < 500:
+            return 40
+        elif loc < 1000:
+            return 60
+        else:
+            return 80
+    
+    def _calculate_cyclomatic_score(self, cyclomatic: int) -> int:
+        """Calculate score based on cyclomatic complexity."""
+        # Cap at 100
+        return min(100, cyclomatic)
+    
+    def _calculate_function_score(self, functions: int) -> int:
+        """Calculate score based on function count."""
+        if functions <= 5:
+            return 0
+        elif functions <= 10:
+            return 5
+        elif functions <= 20:
+            return 10
+        elif functions <= 50:
+            return 20
+        else:
+            return 30

package/lib/darkarts/priority_analyzer/dependencies.py

@@ -0,0 +1,275 @@
+"""
+Dependency Analyzer for VooDocs Priority System
+
+Analyzes import/dependency relationships between files.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, List, Set
+
+
+class DependencyAnalyzer:
+    """Analyzes file dependencies for priority scoring."""
+    
+    # Import patterns by language
+    IMPORT_PATTERNS = {
+        'python': [
+            r'^\s*import\s+([^\s]+)',
+            r'^\s*from\s+([^\s]+)\s+import',
+        ],
+        'typescript': [
+            r'^\s*import\s+.*\s+from\s+["\']([^"\']+)["\']',
+            r'^\s*import\s+["\']([^"\']+)["\']',
+            r'^\s*export\s+.*\s+from\s+["\']([^"\']+)["\']',
+        ],
+        'javascript': [
+            r'^\s*import\s+.*\s+from\s+["\']([^"\']+)["\']',
+            r'^\s*import\s+["\']([^"\']+)["\']',
+            r'^\s*const\s+.*\s*=\s*require\(["\']([^"\']+)["\']\)',
+            r'^\s*export\s+.*\s+from\s+["\']([^"\']+)["\']',
+        ],
+        'solidity': [
+            r'^\s*import\s+["\']([^"\']+)["\']',
+        ],
+    }
+    
+    def __init__(self, project_root: str = None):
+        """
+        Initialize dependency analyzer.
+        
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root) if project_root else None
+        self.file_cache = {}  # Cache for file analysis
+    
+    def analyze_file(self, filepath: str, all_files: List[str] = None) -> Dict:
+        """
+        Analyze a file's dependencies.
+        
+        Args:
+            filepath: Path to file to analyze
+            all_files: List of all files in project (for dependent analysis)
+            
+        Returns:
+            Dictionary with dependency analysis results
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            return {
+                'imports': [],
+                'import_count': 0,
+                'dependents': [],
+                'dependent_count': 0,
+                'depends_score': 0,
+                'depended_score': 0,
+                'total_score': 0,
+                'error': str(e)
+            }
+        
+        # Find imports (what this file depends on)
+        imports = self._find_imports(content, filepath)
+        
+        # Find dependents (what depends on this file)
+        dependents = []
+        if all_files:
+            dependents = self._find_dependents(filepath, all_files)
+        
+        # Calculate scores
+        depends_score = min(50, len(imports) * 2)
+        depended_score = min(50, len(dependents) * 5)
+        total_score = depends_score + depended_score
+        
+        return {
+            'imports': imports,
+            'import_count': len(imports),
+            'dependents': dependents,
+            'dependent_count': len(dependents),
+            'depends_score': depends_score,
+            'depended_score': depended_score,
+            'total_score': total_score
+        }
+    
+    def _find_imports(self, content: str, filepath: str) -> List[str]:
+        """
+        Find all imports in a file.
+        
+        Args:
+            content: File content
+            filepath: File path (to determine language)
+            
+        Returns:
+            List of imported module/file paths
+        """
+        imports = set()
+        
+        # Determine language from extension
+        ext = Path(filepath).suffix.lower()
+        
+        # Select appropriate patterns
+        patterns = []
+        if ext in ['.py']:
+            patterns = self.IMPORT_PATTERNS['python']
+        elif ext in ['.ts', '.tsx']:
+            patterns = self.IMPORT_PATTERNS['typescript']
+        elif ext in ['.js', '.jsx']:
+            patterns = self.IMPORT_PATTERNS['javascript']
+        elif ext in ['.sol']:
+            patterns = self.IMPORT_PATTERNS['solidity']
+        
+        # Find all imports
+        for pattern in patterns:
+            matches = re.findall(pattern, content, re.MULTILINE)
+            imports.update(matches)
+        
+        # Filter out external packages (keep only relative imports)
+        local_imports = []
+        for imp in imports:
+            # Relative imports start with . or /
+            if imp.startswith('.') or imp.startswith('/'):
+                local_imports.append(imp)
+            # Or are within the project structure
+            elif self.project_root and not imp.startswith('@') and '/' in imp:
+                local_imports.append(imp)
+        
+        return sorted(list(local_imports))
+    
+    def _find_dependents(self, filepath: str, all_files: List[str]) -> List[str]:
+        """
+        Find all files that import/depend on this file.
+        
+        Args:
+            filepath: Path to file
+            all_files: List of all files in project
+            
+        Returns:
+            List of files that depend on this file
+        """
+        dependents = []
+        
+        # Convert filepath to relative path for matching
+        file_path = Path(filepath)
+        
+        # Check each file for imports of this file
+        for other_file in all_files:
+            if other_file == filepath:
+                continue
+            
+            # Get imports from other file (use cache if available)
+            if other_file not in self.file_cache:
+                try:
+                    with open(other_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    imports = self._find_imports(content, other_file)
+                    self.file_cache[other_file] = imports
+                except:
+                    self.file_cache[other_file] = []
+            
+            imports = self.file_cache[other_file]
+            
+            # Check if any import matches this file
+            for imp in imports:
+                if self._import_matches_file(imp, filepath, other_file):
+                    dependents.append(other_file)
+                    break
+        
+        return sorted(dependents)
+    
+    def _import_matches_file(self, import_path: str, target_file: str, source_file: str) -> bool:
+        """
+        Check if an import path matches a target file.
+        
+        Args:
+            import_path: Import statement path
+            target_file: File to check against
+            source_file: File containing the import
+            
+        Returns:
+            True if import matches target file
+        """
+        # Convert to Path objects
+        target = Path(target_file)
+        source = Path(source_file)
+        
+        # Handle relative imports
+        if import_path.startswith('.'):
+            # Resolve relative to source file's directory
+            resolved = (source.parent / import_path).resolve()
+            
+            # Try with and without extension
+            if resolved == target.resolve():
+                return True
+            
+            # Try adding common extensions
+            for ext in ['.ts', '.tsx', '.js', '.jsx', '.py', '.sol']:
+                if (resolved.parent / (resolved.name + ext)).resolve() == target.resolve():
+                    return True
+            
+            # Try index files
+            for index_name in ['index.ts', 'index.tsx', 'index.js', 'index.jsx', '__init__.py']:
+                if (resolved / index_name).resolve() == target.resolve():
+                    return True
+        
+        # Handle absolute imports (check if target path ends with import path)
+        else:
+            target_str = str(target.resolve())
+            if import_path.replace('/', Path('/').as_posix()) in target_str:
+                return True
+        
+        return False
+    
+    def get_dependency_reasons(self, analysis: Dict) -> List[str]:
+        """
+        Generate human-readable reasons for dependency score.
+        
+        Args:
+            analysis: Dependency analysis results
+            
+        Returns:
+            List of reason strings
+        """
+        reasons = []
+        
+        if analysis['dependent_count'] > 0:
+            reasons.append(f"Depended upon by {analysis['dependent_count']} file(s)")
+        
+        if analysis['import_count'] > 10:
+            reasons.append(f"High dependency count ({analysis['import_count']} imports)")
+        elif analysis['import_count'] > 5:
+            reasons.append(f"Medium dependency count ({analysis['import_count']} imports)")
+        
+        if analysis['dependent_count'] >= 10:
+            reasons.append("Critical shared module")
+        elif analysis['dependent_count'] >= 5:
+            reasons.append("Widely-used module")
+        
+        return reasons
+    
+    def get_dependency_suggestions(self, analysis: Dict) -> List[str]:
+        """
+        Generate dependency-specific suggestions.
+        
+        Args:
+            analysis: Dependency analysis results
+            
+        Returns:
+            List of suggestion strings
+        """
+        suggestions = []
+        
+        if analysis['dependent_count'] >= 5:
+            suggestions.append("Document public API and contracts")
+            suggestions.append("Add usage examples for common patterns")
+        
+        if analysis['import_count'] > 10:
+            suggestions.append("Document key dependencies and their roles")
+            suggestions.append("Consider documenting dependency graph")
+        
+        if analysis['dependent_count'] >= 10:
+            suggestions.append("Critical module - prioritize comprehensive documentation")
+            suggestions.append("Add integration examples")
+        
+        return suggestions