@voodocs/cli 2.5.3 → 3.0.0

package/lib/darkarts/voodocs_lite_dict_v2.py

@@ -1,198 +0,0 @@
-"""
-VooDocs Lite - Ultra-Aggressive Abbreviation Dictionary v2
-
-Provides maximum compression by:
-1. Removing articles (a, an, the)
-2. Removing unnecessary words
-3. Using aggressive abbreviations
-4. Using symbols instead of words
-"""
-
-# Core abbreviations
-CORE_ABBR = {
-    # Entities
-    'user': 'u',
-    'users': 'us',
-    'database': 'db',
-    'token': 'tok',
-    'password': 'pw',
-    'authentication': 'auth',
-    'authorization': 'authz',
-    'service': 'svc',
-    'function': 'fn',
-    'identifier': 'id',
-    'configuration': 'cfg',
-    'parameter': 'p',
-    'argument': 'a',
-    'variable': 'v',
-    'constant': 'c',
-    'timestamp': 'ts',
-    'expiration': 'exp',
-    'response': 'r',
-    'request': 'q',
-    'error': 'e',
-    'exception': 'x',
-    
-    # Actions (ultra-short)
-    'initialize': 'init',
-    'validate': 'val',
-    'verify': 'ver',
-    'generate': 'gen',
-    'create': 'cr',
-    'update': 'upd',
-    'delete': 'del',
-    'modify': 'mod',
-    'retrieve': 'get',
-    'query': 'qry',
-    'check': 'chk',
-    'returns': 'ret',
-    'contains': 'has',
-    
-    # Blockchain
-    'address': 'addr',
-    'contract': 'ctr',
-    'transaction': 'tx',
-    'block': 'blk',
-    'balance': 'bal',
-    'amount': 'amt',
-    'subdomain': 'sub',
-    'registry': 'reg',
-    'owner': 'own',
-    
-    # Common words
-    'with': 'w/',
-    'without': 'wo/',
-    'management': 'mgmt',
-    'system': 'sys',
-    'operations': 'ops',
-    'result': 'res',
-    'value': 'val',
-    'length': 'len',
-    'count': 'cnt',
-    'maximum': 'max',
-    'minimum': 'min',
-    'average': 'avg',
-    'information': 'info',
-    'specification': 'spec',
-    'implementation': 'impl',
-    'reference': 'ref',
-    'definition': 'def',
-    'description': 'desc',
-    
-    # Types
-    'string': 'str',
-    'number': 'num',
-    'integer': 'int',
-    'boolean': 'bool',
-    'array': 'arr',
-    'object': 'obj',
-    
-    # Boolean/Values
-    'true': 'T',
-    'false': 'F',
-    'null': 'N',
-    'undefined': 'U',
-    'empty': 'E',
-}
-
-# Words to remove entirely
-REMOVE_WORDS = {'a', 'an', 'the', 'is', 'are', 'be', 'been', 'being', 'was', 'were', 'will', 'would', 'should', 'could', 'may', 'might', 'can', 'must'}
-
-# Symbol replacements
-SYMBOL_REPLACEMENTS = {
-    ' and ': '&',
-    ' or ': '|',
-    ' not ': '!',
-    'greater than or equal': '>=',
-    'less than or equal': '<=',
-    'greater than': '>',
-    'less than': '<',
-    'equal to': '=',
-    'not equal': '!=',
-}
-
-
-def ultra_compress(text: str) -> str:
-    """
-    Ultra-aggressive compression.
-    
-    Steps:
-    1. Replace symbols
-    2. Remove articles and unnecessary words
-    3. Apply abbreviations
-    4. Remove extra whitespace
-    """
-    # Step 1: Symbol replacements (longest first)
-    for phrase, symbol in sorted(SYMBOL_REPLACEMENTS.items(), key=lambda x: -len(x[0])):
-        text = text.replace(phrase, symbol)
-    
-    # Step 2: Split into words
-    words = text.split()
-    
-    # Step 3: Process each word
-    compressed_words = []
-    for word in words:
-        # Check for punctuation
-        punct = ''
-        if word and word[-1] in '.,;:!?':
-            punct = word[-1]
-            word = word[:-1]
-        
-        # Convert to lowercase for matching
-        word_lower = word.lower()
-        
-        # Skip if in remove list
-        if word_lower in REMOVE_WORDS:
-            continue
-        
-        # Apply abbreviation if exists
-        if word_lower in CORE_ABBR:
-            compressed_words.append(CORE_ABBR[word_lower] + punct)
-        else:
-            compressed_words.append(word + punct)
-    
-    # Step 4: Join and clean up
-    result = ' '.join(compressed_words)
-    
-    # Remove spaces around symbols
-    result = result.replace(' & ', '&')
-    result = result.replace(' | ', '|')
-    result = result.replace(' >= ', '>=')
-    result = result.replace(' <= ', '<=')
-    result = result.replace(' != ', '!=')
-    
-    return result
-
-
-def ultra_expand(text: str) -> str:
-    """
-    Expand ultra-compressed text back to full form.
-    """
-    # Reverse mapping
-    ABBR_TO_FULL = {v: k for k, v in CORE_ABBR.items()}
-    
-    # Step 1: Add spaces around symbols
-    text = text.replace('&', ' and ')
-    text = text.replace('|', ' or ')
-    text = text.replace('>=', ' greater than or equal ')
-    text = text.replace('<=', ' less than or equal ')
-    text = text.replace('!=', ' not equal ')
-    
-    # Step 2: Split and expand
-    words = text.split()
-    expanded_words = []
-    
-    for word in words:
-        # Check for punctuation
-        punct = ''
-        if word and word[-1] in '.,;:!?':
-            punct = word[-1]
-            word = word[:-1]
-        
-        # Expand if abbreviation exists
-        if word in ABBR_TO_FULL:
-            expanded_words.append(ABBR_TO_FULL[word] + punct)
-        else:
-            expanded_words.append(word + punct)
-    
-    return ' '.join(expanded_words)

package/lib/darkarts/voodocs_lite_parser.py

@@ -1,404 +0,0 @@
-"""
-VooDocs Lite Parser
-
-Parses VooDocs Lite format and converts between Lite and Standard formats.
-"""
-
-import re
-from typing import Dict, Optional
-from .voodocs_lite_dict import (
-    expand_text,
-    compress_text,
-    get_lite_symbol,
-    get_standard_symbol,
-    LITE_TO_STANDARD,
-    STANDARD_TO_LITE,
-)
-from .voodocs_lite_dict_v2 import ultra_compress, ultra_expand
-
-
-class VooDocsLiteParser:
-    """Parser for VooDocs Lite format."""
-    
-    # Lite format patterns
-    LITE_PATTERNS = {
-        'purpose': r'^>\s*(.+)$',
-        'dependencies': r'^@\s*(.+)$',
-        'assumptions': r'^!\s*(.+)$',
-        'preconditions': r'^<\s*(.+)$',
-        'postconditions': r'^>\s*(.+)$',  # Same as purpose, context-dependent
-        'invariants': r'^=\s*(.+)$',
-        'complexity': r'^~\s*(.+)$',
-        'security': r'^#\s*(.+)$',
-    }
-    
-    # Standard format patterns
-    STANDARD_PATTERNS = {
-        'purpose': r'⊢\{([^}]+)\}',
-        'dependencies': r'∂\{([^}]+)\}',
-        'assumptions': r'⚠\{([^}]+)\}',
-        'preconditions': r'⊳\{([^}]+)\}',
-        'postconditions': r'⊲\{([^}]+)\}',
-        'invariants': r'⊨\{([^}]+)\}',
-        'complexity': r'⚡\{([^}]+)\}',
-        'security': r'🔒\{([^}]+)\}',
-    }
-    
-    @classmethod
-    def convert_file_standard_to_lite(cls, file_content: str) -> str:
-        """
-        Convert entire file from Standard to Lite format.
-        
-        Finds @darkarts annotations and converts them to @darkarts-lite.
-        Preserves all other content unchanged.
-        
-        Args:
-            file_content: Full file content
-            
-        Returns:
-            File content with annotations converted to Lite format
-        """
-        # Pattern to match @darkarts comment blocks
-        pattern = r'/\*\*@darkarts\n(.*?)\*/'
-        
-        def replace_annotation(match):
-            annotation_content = match.group(1)
-            # Convert the annotation
-            lite_content = cls.standard_to_lite(annotation_content, compress_abbreviations=True)
-            # Return as @darkarts-lite
-            return f'/**@darkarts-lite\n{lite_content}\n*/'
-        
-        # Replace all @darkarts annotations
-        result = re.sub(pattern, replace_annotation, file_content, flags=re.DOTALL)
-        
-        return result
-    
-    @classmethod
-    def convert_file_lite_to_standard(cls, file_content: str) -> str:
-        """
-        Convert entire file from Lite to Standard format.
-        
-        Finds @darkarts-lite annotations and converts them to @darkarts.
-        Preserves all other content unchanged.
-        
-        Args:
-            file_content: Full file content
-            
-        Returns:
-            File content with annotations converted to Standard format
-        """
-        # Pattern to match @darkarts-lite comment blocks
-        pattern = r'/\*\*@darkarts-lite\n(.*?)\*/'
-        
-        def replace_annotation(match):
-            annotation_content = match.group(1)
-            # Convert the annotation
-            standard_content = cls.lite_to_standard(annotation_content)
-            # Return as @darkarts
-            return f'/**@darkarts\n{standard_content}\n*/'
-        
-        # Replace all @darkarts-lite annotations
-        result = re.sub(pattern, replace_annotation, file_content, flags=re.DOTALL)
-        
-        return result
-    
-    @classmethod
-    def parse_lite(cls, content: str) -> Dict[str, any]:
-        """
-        Parse VooDocs Lite format annotation.
-        
-        Args:
-            content: Lite format annotation text
-            
-        Returns:
-            Dictionary with parsed fields
-        """
-        result = {
-            'purpose': None,
-            'dependencies': [],
-            'assumptions': [],
-            'preconditions': [],
-            'postconditions': [],
-            'invariants': [],
-            'complexity': None,
-            'security': [],
-        }
-        
-        lines = content.strip().split('\n')
-        
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-            
-            # Check each pattern
-            if line.startswith('>'):
-                # Could be purpose or postcondition
-                # If we already have purpose, it's postcondition
-                match = re.match(cls.LITE_PATTERNS['purpose'], line)
-                if match:
-                    value = match.group(1).strip()
-                    if result['purpose'] is None:
-                        result['purpose'] = value
-                    else:
-                        result['postconditions'].append(value)
-            
-            elif line.startswith('@'):
-                match = re.match(cls.LITE_PATTERNS['dependencies'], line)
-                if match:
-                    deps = match.group(1).strip()
-                    # Split by comma
-                    result['dependencies'] = [d.strip() for d in deps.split(',')]
-            
-            elif line.startswith('!'):
-                match = re.match(cls.LITE_PATTERNS['assumptions'], line)
-                if match:
-                    result['assumptions'].append(match.group(1).strip())
-            
-            elif line.startswith('<'):
-                match = re.match(cls.LITE_PATTERNS['preconditions'], line)
-                if match:
-                    result['preconditions'].append(match.group(1).strip())
-            
-            elif line.startswith('='):
-                match = re.match(cls.LITE_PATTERNS['invariants'], line)
-                if match:
-                    result['invariants'].append(match.group(1).strip())
-            
-            elif line.startswith('~'):
-                match = re.match(cls.LITE_PATTERNS['complexity'], line)
-                if match:
-                    result['complexity'] = match.group(1).strip()
-            
-            elif line.startswith('#'):
-                match = re.match(cls.LITE_PATTERNS['security'], line)
-                if match:
-                    result['security'].append(match.group(1).strip())
-        
-        return result
-    
-    @classmethod
-    def parse_standard(cls, content: str) -> Dict[str, any]:
-        """
-        Parse VooDocs Standard format annotation.
-        
-        Args:
-            content: Standard format annotation text
-            
-        Returns:
-            Dictionary with parsed fields
-        """
-        result = {
-            'purpose': None,
-            'dependencies': [],
-            'assumptions': [],
-            'preconditions': [],
-            'postconditions': [],
-            'invariants': [],
-            'complexity': None,
-            'security': [],
-        }
-        
-        # Purpose
-        match = re.search(cls.STANDARD_PATTERNS['purpose'], content)
-        if match:
-            result['purpose'] = match.group(1).strip()
-        
-        # Dependencies
-        for match in re.finditer(cls.STANDARD_PATTERNS['dependencies'], content):
-            deps = match.group(1).strip()
-            result['dependencies'].extend([d.strip() for d in deps.split(',')])
-        
-        # Assumptions
-        for match in re.finditer(cls.STANDARD_PATTERNS['assumptions'], content):
-            result['assumptions'].append(match.group(1).strip())
-        
-        # Preconditions
-        for match in re.finditer(cls.STANDARD_PATTERNS['preconditions'], content):
-            result['preconditions'].append(match.group(1).strip())
-        
-        # Postconditions
-        for match in re.finditer(cls.STANDARD_PATTERNS['postconditions'], content):
-            result['postconditions'].append(match.group(1).strip())
-        
-        # Invariants
-        for match in re.finditer(cls.STANDARD_PATTERNS['invariants'], content):
-            result['invariants'].append(match.group(1).strip())
-        
-        # Complexity
-        match = re.search(cls.STANDARD_PATTERNS['complexity'], content)
-        if match:
-            result['complexity'] = match.group(1).strip()
-        
-        # Security
-        for match in re.finditer(cls.STANDARD_PATTERNS['security'], content):
-            result['security'].append(match.group(1).strip())
-        
-        return result
-    
-    @classmethod
-    def lite_to_standard(cls, lite_content: str) -> str:
-        """
-        Convert Lite format to Standard format.
-        
-        Args:
-            lite_content: Lite format annotation
-            
-        Returns:
-            Standard format annotation
-        """
-        parsed = cls.parse_lite(lite_content)
-        
-        lines = []
-        
-        # Purpose
-        if parsed['purpose']:
-            text = ultra_expand(parsed['purpose'])
-            lines.append(f"⊢{{{text}}}")
-        
-        # Dependencies
-        if parsed['dependencies']:
-            deps = ','.join([ultra_expand(d) for d in parsed['dependencies']])
-            lines.append(f"∂{{{deps}}}")
-        
-        # Assumptions
-        if parsed['assumptions']:
-            for assumption in parsed['assumptions']:
-                text = ultra_expand(assumption)
-                lines.append(f"⚠{{{text}}}")
-        
-        # Preconditions
-        if parsed['preconditions']:
-            for precond in parsed['preconditions']:
-                text = ultra_expand(precond)
-                lines.append(f"⊳{{{text}}}")
-        
-        # Postconditions
-        if parsed['postconditions']:
-            for postcond in parsed['postconditions']:
-                text = ultra_expand(postcond)
-                lines.append(f"⊲{{{text}}}")
-        
-        # Invariants
-        if parsed['invariants']:
-            for invariant in parsed['invariants']:
-                text = ultra_expand(invariant)
-                lines.append(f"⊨{{{text}}}")
-        
-        # Complexity
-        if parsed['complexity']:
-            lines.append(f"⚡{{{parsed['complexity']}}}")
-        
-        # Security
-        if parsed['security']:
-            for security in parsed['security']:
-                text = ultra_expand(security)
-                lines.append(f"🔒{{{text}}}")
-        
-        return '\n'.join(lines)
-    
-    @classmethod
-    def standard_to_lite(cls, standard_content: str, compress_abbreviations: bool = True) -> str:
-        """
-        Convert Standard format to Lite format.
-        
-        Args:
-            standard_content: Standard format annotation
-            compress_abbreviations: Whether to compress to abbreviations
-            
-        Returns:
-            Lite format annotation
-        """
-        parsed = cls.parse_standard(standard_content)
-        
-        lines = []
-        
-        # Purpose
-        if parsed['purpose']:
-            text = parsed['purpose']
-            if compress_abbreviations:
-                text = ultra_compress(text)
-            lines.append(f">{text}")
-        
-        # Dependencies
-        if parsed['dependencies']:
-            deps = ','.join(parsed['dependencies'])
-            if compress_abbreviations:
-                deps = ultra_compress(deps)
-            lines.append(f"@{deps}")
-        
-        # Assumptions
-        if parsed['assumptions']:
-            for assumption in parsed['assumptions']:
-                text = assumption
-                if compress_abbreviations:
-                    text = ultra_compress(text)
-                lines.append(f"!{text}")
-        
-        # Preconditions
-        if parsed['preconditions']:
-            for precond in parsed['preconditions']:
-                text = precond
-                if compress_abbreviations:
-                    text = ultra_compress(text)
-                lines.append(f"<{text}")
-        
-        # Postconditions
-        if parsed['postconditions']:
-            for postcond in parsed['postconditions']:
-                text = postcond
-                if compress_abbreviations:
-                    text = ultra_compress(text)
-                lines.append(f">{text}")
-        
-        # Invariants
-        if parsed['invariants']:
-            for invariant in parsed['invariants']:
-                text = invariant
-                if compress_abbreviations:
-                    text = ultra_compress(text)
-                lines.append(f"={text}")
-        
-        # Complexity
-        if parsed['complexity']:
-            text = parsed['complexity']
-            # Don't compress complexity
-            lines.append(f"~{text}")
-        
-        # Security
-        if parsed['security']:
-            for security in parsed['security']:
-                text = security
-                if compress_abbreviations:
-                    text = ultra_compress(text)
-                lines.append(f"#{text}")
-        
-        return '\n'.join(lines)
-    
-    @classmethod
-    def detect_format(cls, content: str) -> str:
-        """
-        Detect if content is Standard or Lite format.
-        
-        Args:
-            content: Annotation content
-            
-        Returns:
-            'standard', 'lite', or 'unknown'
-        """
-        # Check for standard symbols
-        if any(symbol in content for symbol in ['⊢', '∂', '⚠', '⊳', '⊲', '⊨', '⚡', '🔒']):
-            return 'standard'
-        
-        # Check for lite symbols at start of lines
-        lines = content.strip().split('\n')
-        lite_symbols = 0
-        for line in lines:
-            line = line.strip()
-            if line and line[0] in ['>', '@', '!', '<', '=', '~', '#']:
-                lite_symbols += 1
-        
-        if lite_symbols > 0:
-            return 'lite'
-        
-        return 'unknown'