@voodocs/cli 2.5.0 → 2.5.1

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

package/lib/darkarts/priority_analyzer/security.py

@@ -0,0 +1,200 @@
+"""
+Security Analyzer for VooDocs Priority System
+
+Detects security-sensitive code based on keyword analysis.
+"""
+
+import re
+from typing import Dict, List, Set
+
+
+class SecurityAnalyzer:
+    """Analyzes code for security-sensitive keywords and patterns."""
+    
+    # Critical security keywords (10 points each)
+    CRITICAL_KEYWORDS = {
+        'password', 'secret', 'token', 'key', 'private',
+        'auth', 'authentication', 'authorization',
+        'admin', 'root', 'sudo', 'privilege',
+        'encrypt', 'decrypt', 'hash', 'crypto',
+        'payment', 'credit', 'card', 'billing',
+        'sql', 'query', 'execute', 'eval',
+        'unsafe', 'dangerous', 'vulnerable',
+    }
+    
+    # High priority security keywords (5 points each)
+    HIGH_KEYWORDS = {
+        'user', 'session', 'cookie', 'jwt',
+        'login', 'logout', 'signin', 'signup',
+        'access', 'permission', 'role', 'grant',
+        'sanitize', 'validate', 'escape', 'filter',
+        'upload', 'download', 'file', 'path',
+        'api', 'endpoint', 'route', 'handler',
+    }
+    
+    # Medium priority security keywords (2 points each)
+    MEDIUM_KEYWORDS = {
+        'input', 'output', 'request', 'response',
+        'data', 'database', 'db', 'storage',
+        'config', 'settings', 'env', 'environment',
+        'error', 'exception', 'fail', 'crash',
+    }
+    
+    def __init__(self):
+        """Initialize security analyzer."""
+        pass
+    
+    def analyze_file(self, filepath: str) -> Dict:
+        """
+        Analyze a file for security-sensitive keywords.
+        
+        Args:
+            filepath: Path to file to analyze
+            
+        Returns:
+            Dictionary with security analysis results
+        """
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            return {
+                'critical_keywords': [],
+                'high_keywords': [],
+                'medium_keywords': [],
+                'total_score': 0,
+                'error': str(e)
+            }
+        
+        # Scan for keywords
+        critical_found = self._scan_keywords(content, self.CRITICAL_KEYWORDS)
+        high_found = self._scan_keywords(content, self.HIGH_KEYWORDS)
+        medium_found = self._scan_keywords(content, self.MEDIUM_KEYWORDS)
+        
+        # Calculate score
+        score = (
+            len(critical_found) * 10 +
+            len(high_found) * 5 +
+            len(medium_found) * 2
+        )
+        
+        # Cap at 100
+        total_score = min(100, score)
+        
+        return {
+            'critical_keywords': sorted(list(critical_found)),
+            'high_keywords': sorted(list(high_found)),
+            'medium_keywords': sorted(list(medium_found)),
+            'total_score': total_score,
+            'keyword_count': len(critical_found) + len(high_found) + len(medium_found)
+        }
+    
+    def _scan_keywords(self, content: str, keywords: Set[str]) -> Set[str]:
+        """
+        Scan content for keywords (case-insensitive).
+        
+        Args:
+            content: File content
+            keywords: Set of keywords to search for
+            
+        Returns:
+            Set of found keywords
+        """
+        found = set()
+        content_lower = content.lower()
+        
+        for keyword in keywords:
+            # Use word boundaries to avoid partial matches
+            pattern = r'\b' + re.escape(keyword) + r'\b'
+            if re.search(pattern, content_lower):
+                found.add(keyword)
+        
+        return found
+    
+    def get_security_reasons(self, analysis: Dict) -> List[str]:
+        """
+        Generate human-readable reasons for security score.
+        
+        Args:
+            analysis: Security analysis results
+            
+        Returns:
+            List of reason strings
+        """
+        reasons = []
+        
+        if analysis['critical_keywords']:
+            keywords_str = ', '.join(analysis['critical_keywords'][:5])
+            if len(analysis['critical_keywords']) > 5:
+                keywords_str += f" (+{len(analysis['critical_keywords']) - 5} more)"
+            reasons.append(f"Critical security keywords: {keywords_str}")
+        
+        if analysis['high_keywords']:
+            keywords_str = ', '.join(analysis['high_keywords'][:5])
+            if len(analysis['high_keywords']) > 5:
+                keywords_str += f" (+{len(analysis['high_keywords']) - 5} more)"
+            reasons.append(f"High-priority keywords: {keywords_str}")
+        
+        if analysis['total_score'] >= 80:
+            reasons.append("Highly security-sensitive code")
+        elif analysis['total_score'] >= 50:
+            reasons.append("Security-sensitive code")
+        
+        return reasons
+    
+    def get_security_suggestions(self, analysis: Dict) -> List[str]:
+        """
+        Generate security-specific suggestions.
+        
+        Args:
+            analysis: Security analysis results
+            
+        Returns:
+            List of suggestion strings
+        """
+        suggestions = []
+        
+        critical = set(analysis['critical_keywords'])
+        high = set(analysis['high_keywords'])
+        
+        # Authentication/Authorization
+        if critical & {'auth', 'authentication', 'authorization', 'login', 'logout'}:
+            suggestions.append("Document authentication/authorization flow")
+            suggestions.append("Specify security invariants and assumptions")
+        
+        # Cryptography
+        if critical & {'encrypt', 'decrypt', 'hash', 'crypto', 'key', 'secret'}:
+            suggestions.append("Document encryption algorithms and key management")
+            suggestions.append("Specify cryptographic assumptions")
+        
+        # Payment/Financial
+        if critical & {'payment', 'credit', 'card', 'billing'}:
+            suggestions.append("Document payment processing flow")
+            suggestions.append("Add PCI-DSS compliance notes")
+        
+        # SQL/Database
+        if critical & {'sql', 'query', 'execute'}:
+            suggestions.append("Document SQL injection prevention measures")
+            suggestions.append("Specify query sanitization rules")
+        
+        # Input Validation
+        if high & {'sanitize', 'validate', 'escape', 'filter', 'input'}:
+            suggestions.append("Document input validation rules")
+            suggestions.append("Specify allowed input formats")
+        
+        # File Operations
+        if high & {'upload', 'download', 'file', 'path'}:
+            suggestions.append("Document file validation and size limits")
+            suggestions.append("Specify path traversal prevention")
+        
+        # Session Management
+        if high & {'session', 'cookie', 'jwt', 'token'}:
+            suggestions.append("Document session/token lifecycle")
+            suggestions.append("Specify expiration and refresh logic")
+        
+        # Generic security suggestions
+        if analysis['total_score'] >= 60 and not suggestions:
+            suggestions.append("Add security assumptions and invariants")
+            suggestions.append("Document security-critical logic")
+        
+        return suggestions

package/lib/darkarts/voodocs_lite_dict.py

@@ -0,0 +1,216 @@
+"""
+VooDocs Lite - Abbreviation Dictionary
+
+Provides bidirectional mapping between full words and abbreviations
+for ultra-compact symbolic notation.
+"""
+
+# Abbreviation dictionary: abbr -> full
+ABBREVIATIONS = {
+    # Storage & Data
+    'db': 'database',
+    'cfg': 'configuration',
+    'var': 'variable',
+    'const': 'constant',
+    'param': 'parameter',
+    'arg': 'argument',
+    'id': 'identifier',
+    
+    # Common verbs
+    'must': 'must',
+    'be': 'be',
+    'is': 'is',
+    'are': 'are',
+    'has': 'has',
+    'have': 'have',
+    'does': 'does',
+    'do': 'do',
+    'will': 'will',
+    'can': 'can',
+    'should': 'should',
+    'may': 'may',
+    'contains': 'contains',
+    'returns': 'returns',
+    'expire': 'expire',
+    'expires': 'expires',
+    'stored': 'stored',
+    'signed': 'signed',
+    'hashed': 'hashed',
+    'valid': 'valid',
+    'logged': 'logged',
+    
+    # Actions
+    'init': 'initialize',
+    'val': 'validate',
+    'ver': 'verify',
+    'gen': 'generate',
+    'cr': 'create',
+    'upd': 'update',
+    'del': 'delete',
+    'mod': 'modify',
+    'get': 'retrieve',
+    'qry': 'query',
+    'chk': 'check',
+    
+    # Security
+    'auth': 'authentication',
+    'authz': 'authorization',
+    'pwd': 'password',
+    'tok': 'token',
+    
+    # Entities
+    'usr': 'user',
+    'usrs': 'users',
+    
+    # Time
+    'ts': 'timestamp',
+    'exp': 'expiration',
+    
+    # Communication
+    'resp': 'response',
+    'req': 'request',
+    'msg': 'message',
+    
+    # Status & Errors
+    'err': 'error',
+    'exc': 'exception',
+    'ok': 'success',
+    'fail': 'failure',
+    
+    # Boolean & Values
+    'T': 'true',
+    'F': 'false',
+    'N': 'null',
+    'U': 'undefined',
+    'E': 'empty',
+    
+    # Types
+    'str': 'string',
+    'num': 'number',
+    'int': 'integer',
+    'bool': 'boolean',
+    'arr': 'array',
+    'obj': 'object',
+    'fn': 'function',
+    
+    # Blockchain
+    'addr': 'address',
+    'ctr': 'contract',
+    'tx': 'transaction',
+    'blk': 'block',
+    'bal': 'balance',
+    'amt': 'amount',
+    
+    # Domain-specific
+    'sub': 'subdomain',
+    'subs': 'subdomains',
+    'reg': 'registry',
+    'own': 'owner',
+    'mgmt': 'management',
+    
+    # Common words
+    'w/': 'with',
+    'wo/': 'without',
+    'svc': 'service',
+    'sys': 'system',
+    'ops': 'operations',
+    'ret': 'returns',
+    'res': 'result',
+    'val': 'value',
+    'vals': 'values',
+    'len': 'length',
+    'cnt': 'count',
+    'max': 'maximum',
+    'min': 'minimum',
+    'avg': 'average',
+    'sum': 'summary',
+    'desc': 'description',
+    'info': 'information',
+    'spec': 'specification',
+    'impl': 'implementation',
+    'ref': 'reference',
+    'def': 'definition',
+    'decl': 'declaration',
+}
+
+# Reverse mapping: full -> abbr
+EXPANSIONS = {v: k for k, v in ABBREVIATIONS.items()}
+
+# Symbol mappings
+LITE_TO_STANDARD = {
+    '>': '⊢',  # Purpose/Postcondition (context-dependent)
+    '@': '∂',  # Dependencies
+    '!': '⚠',  # Assumptions
+    '<': '⊳',  # Preconditions
+    '=': '⊨',  # Invariants
+    '~': '⚡',  # Complexity
+    '#': '🔒',  # Security
+}
+
+STANDARD_TO_LITE = {v: k for k, v in LITE_TO_STANDARD.items()}
+
+
+def expand_abbreviation(abbr: str) -> str:
+    """Expand an abbreviation to its full form."""
+    return ABBREVIATIONS.get(abbr, abbr)
+
+
+def compress_word(word: str) -> str:
+    """Compress a word to its abbreviation."""
+    return EXPANSIONS.get(word.lower(), word)
+
+
+def expand_text(text: str) -> str:
+    """
+    Expand abbreviated text to full form.
+    
+    Example:
+        "usr auth svc w/ JWT gen" -> "user authentication service with JWT generation"
+    """
+    words = text.split()
+    expanded = []
+    
+    for word in words:
+        # Check if word has punctuation
+        if word[-1] in '.,;:!?':
+            punct = word[-1]
+            word_part = word[:-1]
+            expanded_word = expand_abbreviation(word_part)
+            expanded.append(expanded_word + punct)
+        else:
+            expanded.append(expand_abbreviation(word))
+    
+    return ' '.join(expanded)
+
+
+def compress_text(text: str) -> str:
+    """
+    Compress text using abbreviations.
+    
+    Example:
+        "user authentication service with JWT generation" -> "usr auth svc w/ JWT gen"
+    """
+    words = text.split()
+    compressed = []
+    
+    for word in words:
+        # Check if word has punctuation
+        if word[-1] in '.,;:!?':
+            punct = word[-1]
+            word_part = word[:-1]
+            compressed_word = compress_word(word_part)
+            compressed.append(compressed_word + punct)
+        else:
+            compressed.append(compress_word(word))
+    
+    return ' '.join(compressed)
+
+
+def get_lite_symbol(standard_symbol: str) -> str:
+    """Convert standard VooDocs symbol to Lite symbol."""
+    return STANDARD_TO_LITE.get(standard_symbol, standard_symbol)
+
+
+def get_standard_symbol(lite_symbol: str) -> str:
+    """Convert Lite symbol to standard VooDocs symbol."""
+    return LITE_TO_STANDARD.get(lite_symbol, lite_symbol)