@voodocs/cli 2.4.0 → 2.5.1

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.4.0",
+  "version": "2.5.1",
   "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",