@voodocs/cli 2.5.0 → 2.5.2

package/lib/darkarts/priority_analyzer/analyzer.py

@@ -0,0 +1,301 @@
+"""
+Main Priority Analyzer for VooDocs
+
+Combines complexity, security, and dependency analysis to prioritize files.
+"""
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from .complexity import ComplexityAnalyzer
+from .security import SecurityAnalyzer
+from .dependencies import DependencyAnalyzer
+
+
+@dataclass
+class FileScore:
+    """Score and analysis for a single file."""
+    filepath: str
+    priority_score: float
+    complexity_score: int
+    security_score: int
+    dependency_score: int
+    annotation_penalty: int
+    priority_level: str
+    reasons: List[str]
+    suggestions: List[str]
+    
+    # Detailed metrics
+    loc: int = 0
+    cyclomatic: int = 0
+    functions: int = 0
+    security_keywords: List[str] = None
+    import_count: int = 0
+    dependent_count: int = 0
+    annotation_coverage: float = 0.0
+
+
+class PriorityAnalyzer:
+    """Main analyzer that combines all scoring components."""
+    
+    # Scoring weights
+    COMPLEXITY_WEIGHT = 0.30
+    SECURITY_WEIGHT = 0.40
+    DEPENDENCY_WEIGHT = 0.20
+    ANNOTATION_WEIGHT = 0.10
+    
+    # Priority level thresholds
+    PRIORITY_THRESHOLDS = {
+        'CRITICAL': 80,
+        'HIGH': 60,
+        'MEDIUM': 40,
+        'LOW': 20,
+        'MINIMAL': 0
+    }
+    
+    # Supported file extensions
+    SUPPORTED_EXTENSIONS = {'.py', '.ts', '.tsx', '.js', '.jsx', '.sol'}
+    
+    def __init__(self, project_root: str = None):
+        """
+        Initialize priority analyzer.
+        
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = project_root
+        self.complexity_analyzer = ComplexityAnalyzer()
+        self.security_analyzer = SecurityAnalyzer()
+        self.dependency_analyzer = DependencyAnalyzer(project_root)
+    
+    def analyze_file(self, filepath: str, all_files: List[str] = None) -> FileScore:
+        """
+        Analyze a single file and calculate priority score.
+        
+        Args:
+            filepath: Path to file to analyze
+            all_files: List of all files (for dependency analysis)
+            
+        Returns:
+            FileScore object with complete analysis
+        """
+        # Run individual analyzers
+        complexity = self.complexity_analyzer.analyze_file(filepath)
+        security = self.security_analyzer.analyze_file(filepath)
+        dependencies = self.dependency_analyzer.analyze_file(filepath, all_files)
+        
+        # Check annotation coverage
+        annotation_coverage, annotation_penalty = self._check_annotation_coverage(filepath)
+        
+        # Calculate weighted priority score
+        priority_score = (
+            complexity['total_score'] * self.COMPLEXITY_WEIGHT +
+            security['total_score'] * self.SECURITY_WEIGHT +
+            dependencies['total_score'] * self.DEPENDENCY_WEIGHT +
+            annotation_penalty * self.ANNOTATION_WEIGHT
+        )
+        
+        # Determine priority level
+        priority_level = self._get_priority_level(priority_score)
+        
+        # Generate reasons and suggestions
+        reasons = self._generate_reasons(complexity, security, dependencies, annotation_coverage)
+        suggestions = self._generate_suggestions(complexity, security, dependencies, annotation_coverage)
+        
+        # Combine all security keywords
+        all_keywords = (
+            security.get('critical_keywords', []) +
+            security.get('high_keywords', []) +
+            security.get('medium_keywords', [])
+        )
+        
+        return FileScore(
+            filepath=filepath,
+            priority_score=round(priority_score, 1),
+            complexity_score=complexity['total_score'],
+            security_score=security['total_score'],
+            dependency_score=dependencies['total_score'],
+            annotation_penalty=annotation_penalty,
+            priority_level=priority_level,
+            reasons=reasons,
+            suggestions=suggestions,
+            loc=complexity.get('loc', 0),
+            cyclomatic=complexity.get('cyclomatic', 0),
+            functions=complexity.get('functions', 0),
+            security_keywords=all_keywords[:10],  # Top 10
+            import_count=dependencies.get('import_count', 0),
+            dependent_count=dependencies.get('dependent_count', 0),
+            annotation_coverage=annotation_coverage
+        )
+    
+    def analyze_directory(self, dirpath: str, recursive: bool = True, 
+                         exclude_patterns: List[str] = None) -> List[FileScore]:
+        """
+        Analyze all files in a directory.
+        
+        Args:
+            dirpath: Directory path to analyze
+            recursive: Whether to scan subdirectories
+            exclude_patterns: Patterns to exclude (e.g., ['node_modules', 'dist'])
+            
+        Returns:
+            List of FileScore objects, sorted by priority (highest first)
+        """
+        if exclude_patterns is None:
+            exclude_patterns = ['node_modules', 'dist', 'build', '.git', '__pycache__']
+        
+        # Find all files
+        all_files = self._find_files(dirpath, recursive, exclude_patterns)
+        
+        # Analyze each file
+        scores = []
+        for filepath in all_files:
+            try:
+                score = self.analyze_file(filepath, all_files)
+                scores.append(score)
+            except Exception as e:
+                print(f"Warning: Failed to analyze {filepath}: {e}")
+        
+        # Sort by priority score (highest first)
+        scores.sort(key=lambda x: x.priority_score, reverse=True)
+        
+        return scores
+    
+    def _find_files(self, dirpath: str, recursive: bool, exclude_patterns: List[str]) -> List[str]:
+        """Find all supported files in directory."""
+        files = []
+        
+        if recursive:
+            for root, dirs, filenames in os.walk(dirpath):
+                # Filter out excluded directories
+                dirs[:] = [d for d in dirs if not any(pattern in d for pattern in exclude_patterns)]
+                
+                for filename in filenames:
+                    filepath = os.path.join(root, filename)
+                    if Path(filepath).suffix in self.SUPPORTED_EXTENSIONS:
+                        files.append(filepath)
+        else:
+            for filename in os.listdir(dirpath):
+                filepath = os.path.join(dirpath, filename)
+                if os.path.isfile(filepath) and Path(filepath).suffix in self.SUPPORTED_EXTENSIONS:
+                    files.append(filepath)
+        
+        return files
+    
+    def _check_annotation_coverage(self, filepath: str) -> tuple:
+        """
+        Check VooDocs annotation coverage in file.
+        
+        Returns:
+            Tuple of (coverage_percentage, penalty_score)
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except:
+            return (0.0, -50)
+        
+        # Count @darkarts annotations
+        darkarts_count = len(re.findall(r'@darkarts(-lite)?', content))
+        
+        # Count total functions (rough estimate)
+        function_patterns = [
+            r'^\s*def\s+\w+\s*\(',  # Python
+            r'^\s*(export\s+)?(async\s+)?function\s+\w+\s*\(',  # JS/TS function
+            r'^\s*(const|let|var)\s+\w+\s*=\s*(\([^)]*\)|[^=]+)\s*=>',  # Arrow function
+            r'^\s*function\s+\w+\s*\(',  # Solidity
+        ]
+        
+        total_functions = 0
+        for pattern in function_patterns:
+            total_functions += len(re.findall(pattern, content, re.MULTILINE))
+        
+        # Calculate coverage
+        if total_functions == 0:
+            # No functions, check if file has any annotations
+            coverage = 1.0 if darkarts_count > 0 else 0.0
+        else:
+            coverage = min(1.0, darkarts_count / total_functions)
+        
+        # Calculate penalty
+        if coverage == 0:
+            penalty = -50
+        elif coverage < 0.5:
+            penalty = -25
+        else:
+            penalty = 0
+        
+        return (coverage, penalty)
+    
+    def _get_priority_level(self, score: float) -> str:
+        """Determine priority level from score."""
+        if score >= self.PRIORITY_THRESHOLDS['CRITICAL']:
+            return 'CRITICAL'
+        elif score >= self.PRIORITY_THRESHOLDS['HIGH']:
+            return 'HIGH'
+        elif score >= self.PRIORITY_THRESHOLDS['MEDIUM']:
+            return 'MEDIUM'
+        elif score >= self.PRIORITY_THRESHOLDS['LOW']:
+            return 'LOW'
+        else:
+            return 'MINIMAL'
+    
+    def _generate_reasons(self, complexity: Dict, security: Dict, 
+                         dependencies: Dict, annotation_coverage: float) -> List[str]:
+        """Generate human-readable reasons for priority score."""
+        reasons = []
+        
+        # Complexity reasons
+        if complexity['total_score'] >= 60:
+            reasons.append(f"High complexity: {complexity['loc']} LOC, {complexity['functions']} functions")
+        elif complexity['total_score'] >= 30:
+            reasons.append(f"Medium complexity: {complexity['loc']} LOC, {complexity['functions']} functions")
+        
+        # Security reasons
+        if security.get('critical_keywords'):
+            keywords = ', '.join(security['critical_keywords'][:5])
+            reasons.append(f"Security keywords: {keywords}")
+        
+        # Dependency reasons
+        if dependencies.get('dependent_count', 0) > 0:
+            reasons.append(f"Depended upon by {dependencies['dependent_count']} file(s)")
+        
+        # Annotation reasons
+        if annotation_coverage == 0:
+            reasons.append("No VooDocs annotations found")
+        elif annotation_coverage < 0.5:
+            reasons.append(f"Partial annotations ({int(annotation_coverage * 100)}% coverage)")
+        
+        return reasons
+    
+    def _generate_suggestions(self, complexity: Dict, security: Dict, 
+                            dependencies: Dict, annotation_coverage: float) -> List[str]:
+        """Generate actionable suggestions."""
+        suggestions = []
+        
+        # Security suggestions
+        suggestions.extend(self.security_analyzer.get_security_suggestions(security))
+        
+        # Dependency suggestions
+        suggestions.extend(self.dependency_analyzer.get_dependency_suggestions(dependencies))
+        
+        # Complexity suggestions
+        if complexity['total_score'] >= 60:
+            suggestions.append("Break down complex logic into smaller functions")
+            suggestions.append("Document high-complexity sections")
+        
+        # Annotation suggestions
+        if annotation_coverage == 0:
+            suggestions.append("Add @darkarts annotations to all functions")
+            suggestions.append("Start with module-level purpose annotation")
+        elif annotation_coverage < 1.0:
+            suggestions.append("Complete remaining function annotations")
+        
+        # Generic suggestions
+        if not suggestions:
+            suggestions.append("Add comprehensive VooDocs annotations")
+        
+        return suggestions[:5]  # Limit to top 5

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