@voodocs/cli 2.5.0 → 2.5.2

package/lib/darkarts/voodocs_lite_dict_v2.py

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

@@ -0,0 +1,343 @@
+"""
+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 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 standard VooDocs format annotation.
+        
+        Args:
+            content: Standard format annotation text
+            
+        Returns:
+            Dictionary with parsed fields
+        """
+        result = {
+            'purpose': None,
+            'dependencies': [],
+            'assumptions': [],
+            'preconditions': [],
+            'postconditions': [],
+            'invariants': [],
+            'complexity': None,
+            'security': [],
+        }
+        
+        # Extract each field
+        for field, pattern in cls.STANDARD_PATTERNS.items():
+            matches = re.findall(pattern, content)
+            
+            if field in ['purpose', 'complexity']:
+                # Single value fields
+                if matches:
+                    result[field] = matches[0].strip()
+            elif field == 'dependencies':
+                # Comma-separated list
+                if matches:
+                    deps = matches[0].strip()
+                    result[field] = [d.strip() for d in deps.split(',')]
+            else:
+                # Multiple value fields
+                result[field] = [m.strip() for m in matches]
+        
+        return result
+    
+    @classmethod
+    def lite_to_standard(cls, lite_content: str, expand_abbreviations: bool = True) -> str:
+        """
+        Convert Lite format to Standard format.
+        
+        Args:
+            lite_content: Lite format annotation
+            expand_abbreviations: Whether to expand abbreviations
+            
+        Returns:
+            Standard format annotation
+        """
+        parsed = cls.parse_lite(lite_content)
+        
+        lines = []
+        
+        # Purpose
+        if parsed['purpose']:
+            text = parsed['purpose']
+            if expand_abbreviations:
+                text = expand_text(text)
+            lines.append(f"⊢{{{text}}}")
+        
+        # Dependencies
+        if parsed['dependencies']:
+            deps = ', '.join(parsed['dependencies'])
+            if expand_abbreviations:
+                deps = expand_text(deps)
+            lines.append(f"∂{{{deps}}}")
+        
+        # Assumptions
+        if parsed['assumptions']:
+            for assumption in parsed['assumptions']:
+                text = assumption
+                if expand_abbreviations:
+                    text = expand_text(text)
+                lines.append(f"⚠{{{text}}}")
+        
+        # Preconditions
+        if parsed['preconditions']:
+            for precond in parsed['preconditions']:
+                text = precond
+                if expand_abbreviations:
+                    text = expand_text(text)
+                lines.append(f"⊳{{{text}}}")
+        
+        # Postconditions
+        if parsed['postconditions']:
+            for postcond in parsed['postconditions']:
+                text = postcond
+                if expand_abbreviations:
+                    text = expand_text(text)
+                lines.append(f"⊲{{{text}}}")
+        
+        # Invariants
+        if parsed['invariants']:
+            for invariant in parsed['invariants']:
+                text = invariant
+                if expand_abbreviations:
+                    text = expand_text(text)
+                lines.append(f"⊨{{{text}}}")
+        
+        # Complexity
+        if parsed['complexity']:
+            text = parsed['complexity']
+            # Don't expand complexity (O(n) should stay as-is)
+            lines.append(f"⚡{{{text}}}")
+        
+        # Security
+        if parsed['security']:
+            for security in parsed['security']:
+                text = security
+                if expand_abbreviations:
+                    text = expand_text(text)
+                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 whether content is Lite or Standard format.
+        
+        Returns:
+            'lite', 'standard', or 'unknown'
+        """
+        # Check for Lite symbols at start of lines
+        lite_indicators = ['>', '@', '!', '<', '=', '~', '#']
+        has_lite = any(line.strip().startswith(sym) for sym in lite_indicators for line in content.split('\n'))
+        
+        # Check for Standard symbols
+        standard_indicators = ['⊢', '∂', '⚠', '⊳', '⊲', '⊨', '⚡', '🔒']
+        has_standard = any(sym in content for sym in standard_indicators)
+        
+        if has_lite and not has_standard:
+            return 'lite'
+        elif has_standard and not has_lite:
+            return 'standard'
+        elif has_lite and has_standard:
+            # Mixed format, prefer standard
+            return 'standard'
+        else:
+            return 'unknown'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voodocs/cli",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "description": "AI-Native Symbolic Documentation System - The world's first documentation tool using mathematical notation with semantic validation",
   "main": "voodocs_cli.py",
   "bin": {
@@ -64,6 +64,10 @@
     "lib/darkarts/exceptions.py",
     "lib/darkarts/telemetry.py",
     "lib/darkarts/companion_files.py",
+    "lib/darkarts/voodocs_lite_dict.py",
+    "lib/darkarts/voodocs_lite_dict_v2.py",
+    "lib/darkarts/voodocs_lite_parser.py",
+    "lib/darkarts/priority_analyzer/",
     "lib/darkarts/parsers/typescript/dist/",
     "lib/darkarts/parsers/typescript/src/",
     "lib/darkarts/parsers/typescript/package.json",