@voodocs/cli 2.5.2 → 3.0.0

package/lib/cli/__init__.py

@@ -16,7 +16,7 @@ This module provides the command-line interface for VooDocs.
 import click
 from typing import Optional
 
-__version__ = "2.5.2"
+__version__ = "3.0.0"
 
 
 @click.group()
@@ -42,7 +42,6 @@ from .benchmark import benchmark
 from .fix import fix
 from .context import context
 from .analyze import analyze
-from .convert import convert
 from .companion import companion
 
 # Register commands
@@ -54,7 +53,6 @@ cli.add_command(benchmark)
 cli.add_command(fix)
 cli.add_command(context)
 cli.add_command(analyze)
-cli.add_command(convert)
 cli.add_command(companion)
 
 

package/lib/cli/init.py

@@ -636,24 +636,22 @@ def _create_darkarts_examples(examples_dir: Path):
     """Create example files with symbolic @darkarts annotations."""
     
     ts_example = '''/**@darkarts
-⊢{Example TypeScript module demonstrating symbolic @darkarts annotations}
+⊢{Example TypeScript module demonstrating DarkArts v3.0.0 annotations}
 ∂{}
-⚠{TypeScript environment available}
+⚠{TypeScript env available}
 */
 
 /**@darkarts
-⊳{
-  name must be a non-empty string
-  age must be a positive number
-}
-⊲{
-  Returns a greeting message
-  Message includes the provided name
-}
-⊨{
-  Does ¬ modify input parameters
-}
+⊢{greet fn w/ name & age}
+∂{}
+⊳{name:string,age>0}
+⊲{ret greeting msg}
+⊨{no input mod}
 ⚡{O(1)}
+⇄{greet↔farewell}
+∴{invalid→err}
+∀{name is string}
+≈{~1ms}
 */
 export function greet(name: string, age: number): string {
   return `Hello, ${name}! You are ${age} years old.`;

package/lib/darkarts/annotations/darkarts_parser.py

@@ -1,78 +1,151 @@
 """@darkarts
-⊢parser:darkarts.annotations
-∂{re,typing,symbols}
-⚠{@darkarts∈docstrings,unicode-support}
-⊨{∀parse→structured-output,¬modify-src,handle-errors}
+⊢{parser:darkarts.annotations.v3-wrapper}
+∂{re,typing,darkarts_parser_v3}
+⚠{@darkarts∈docstrings,unicode-support,v3-compatible}
+⊨{∀parse→structured-output,¬modify-src,handle-errors,backward-compat}
 🔒{read-only}
-⚡{O(n²)|n=annotation-length,4-loops,depth=2}
+⚡{O(n)|n=annotation-length}
 
-DarkArts Annotation Parser
+DarkArts Annotation Parser (v3.0.0 Wrapper)
 
-Parses @darkarts symbolic annotations from source code.
+Wraps the v3.0.0 parser to maintain backward compatibility with existing code.
 """
 
 import re
+import sys
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field
+from pathlib import Path
+
+# Import v3.0.0 parser
+sys.path.insert(0, str(Path(__file__).parent.parent))
+try:
+    from darkarts.darkarts_parser_v3 import DarkArtsParserV3, DarkArtsAnnotation as V3Annotation
+except ImportError:
+    # Fallback for direct import
+    import darkarts_parser_v3
+    DarkArtsParserV3 = darkarts_parser_v3.DarkArtsParserV3
+    V3Annotation = darkarts_parser_v3.DarkArtsAnnotation
 
 from .symbols import VOCABULARY, get_meta_symbols
 
 
 @dataclass
 class DarkArtsAnnotation:
-    """Parsed DarkArts annotation."""
-    module: Optional[str] = None  # From ⊢
+    """Parsed DarkArts annotation (v3.0.0 compatible)."""
+    # Core fields (v2.x compatible)
+    module: Optional[str] = None  # From ⊢ (purpose)
     dependencies: List[str] = field(default_factory=list)  # From ∂
     assumptions: List[str] = field(default_factory=list)  # From ⚠
     invariants: List[str] = field(default_factory=list)  # From ⊨
-    security: Optional[str] = None  # From 🔒
-    performance: Optional[str] = None  # From ⚡
-    complexity: Optional[str] = None  # From 📊
-    objectives: Optional[str] = None  # From 🎯
-    configuration: Optional[str] = None  # From ⚙️
+    security: List[str] = field(default_factory=list)  # From 🔒
+    performance: Optional[str] = None  # From ⚡ (complexity)
+    complexity: Optional[str] = None  # From ⚡
+    
+    # v3.0.0 new fields
+    preconditions: List[str] = field(default_factory=list)  # From ⊳
+    postconditions: List[str] = field(default_factory=list)  # From ⊲
+    bidirectional: List[str] = field(default_factory=list)  # From ⇄
+    side_effects: List[str] = field(default_factory=list)  # From ⊕
+    forbidden: List[str] = field(default_factory=list)  # From ⊗
+    approximation: List[str] = field(default_factory=list)  # From ≈
+    consequence: List[str] = field(default_factory=list)  # From ∴
+    universal: List[str] = field(default_factory=list)  # From ∀
+    existential: List[str] = field(default_factory=list)  # From ∃
+    
+    # Metadata
     raw_text: str = ""  # Original annotation text
+    line_number: int = 0
+    
+    # Legacy fields (for backward compatibility)
+    objectives: Optional[str] = None  # Deprecated
+    configuration: Optional[str] = None  # Deprecated
     
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary."""
         return {
             'module': self.module,
+            'purpose': self.module,  # Alias
             'dependencies': self.dependencies,
             'assumptions': self.assumptions,
+            'preconditions': self.preconditions,
+            'postconditions': self.postconditions,
             'invariants': self.invariants,
             'security': self.security,
             'performance': self.performance,
             'complexity': self.complexity,
-            'objectives': self.objectives,
-            'configuration': self.configuration,
+            'bidirectional': self.bidirectional,
+            'side_effects': self.side_effects,
+            'forbidden': self.forbidden,
+            'approximation': self.approximation,
+            'consequence': self.consequence,
+            'universal': self.universal,
+            'existential': self.existential,
+            'raw_text': self.raw_text,
+            'line_number': self.line_number,
         }
+    
+    @classmethod
+    def from_v3_annotation(cls, v3_ann: V3Annotation) -> 'DarkArtsAnnotation':
+        """Create from v3.0.0 annotation."""
+        return cls(
+            module=v3_ann.purpose,
+            dependencies=v3_ann.dependencies,
+            assumptions=v3_ann.assumptions,
+            preconditions=v3_ann.preconditions,
+            postconditions=v3_ann.postconditions,
+            invariants=v3_ann.invariants,
+            security=v3_ann.security,
+            complexity=v3_ann.complexity,
+            performance=v3_ann.complexity,  # Alias
+            bidirectional=v3_ann.bidirectional,
+            side_effects=v3_ann.side_effects,
+            forbidden=v3_ann.forbidden,
+            approximation=v3_ann.approximation,
+            consequence=v3_ann.consequence,
+            universal=v3_ann.universal,
+            existential=v3_ann.existential,
+            raw_text=v3_ann.raw_text,
+            line_number=v3_ann.line_number,
+        )
 
 
 class DarkArtsParser:
     """
-    Parser for DarkArts symbolic annotations.
+    Parser for DarkArts symbolic annotations (v3.0.0).
     
-    Extracts and parses @darkarts annotations from source code.
+    Wraps the v3.0.0 parser to maintain backward compatibility.
     """
     
     # Pattern to match @darkarts annotations
     PATTERN = r'"""@darkarts\s*(.*?)\s*"""'
     
-    # Meta symbol mappings
+    # Meta symbol mappings (v3.0.0)
     META_SYMBOLS = {
-        '⊢': 'module',
+        '⊢': 'purpose',
         '∂': 'dependencies',
         '⚠': 'assumptions',
+        '⊳': 'preconditions',
+        '⊲': 'postconditions',
         '⊨': 'invariants',
+        '⚡': 'complexity',
         '🔒': 'security',
-        '⚡': 'performance',
-        '📊': 'complexity',
-        '🎯': 'objectives',
-        '⚙️': 'configuration',
+        '⇄': 'bidirectional',
+        '⊕': 'side_effects',
+        '⊗': 'forbidden',
+        '≈': 'approximation',
+        '∴': 'consequence',
+        '∀': 'universal',
+        '∃': 'existential',
     }
     
-    def __init__(self):
+    def __init__(self, enable_validation: bool = False):
         """Initialize the parser."""
-        self.meta_symbols = get_meta_symbols()
+        self.v3_parser = DarkArtsParserV3(enable_validation=enable_validation)
+        try:
+            self.meta_symbols = get_meta_symbols()
+        except:
+            self.meta_symbols = self.META_SYMBOLS
     
     def parse(self, source_code: str) -> List[DarkArtsAnnotation]:
         """
@@ -84,15 +157,14 @@ class DarkArtsParser:
         Returns:
             List of parsed annotations
         """
-        annotations = []
+        # Use v3.0.0 parser
+        v3_annotations = self.v3_parser.parse(source_code)
         
-        # Find all @darkarts blocks
-        matches = re.finditer(self.PATTERN, source_code, re.DOTALL)
-        
-        for match in matches:
-            annotation_text = match.group(1)
-            annotation = self.parse_annotation(annotation_text)
-            annotations.append(annotation)
+        # Convert to legacy format
+        annotations = []
+        for v3_ann in v3_annotations:
+            ann = DarkArtsAnnotation.from_v3_annotation(v3_ann)
+            annotations.append(ann)
         
         return annotations
     
@@ -106,133 +178,78 @@ class DarkArtsParser:
         Returns:
             Parsed annotation
         """
-        annotation = DarkArtsAnnotation(raw_text=text)
-        
-        # Split into lines
-        lines = text.strip().split('\n')
-        
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-            
-            # Check for meta symbols
-            for symbol, field_name in self.META_SYMBOLS.items():
-                if line.startswith(symbol):
-                    # Extract content after symbol
-                    content = line[len(symbol):].strip()
-                    self._parse_field(annotation, field_name, content)
-                    break
-        
-        return annotation
-    
-    def _parse_field(self, annotation: DarkArtsAnnotation, field_name: str, content: str):
-        """
-        Parse a field and update annotation.
-        
-        Args:
-            annotation: Annotation to update
-            field_name: Name of field (module, dependencies, etc.)
-            content: Content to parse
-        """
-        if field_name == 'module':
-            annotation.module = content
-        
-        elif field_name == 'dependencies':
-            annotation.dependencies = self._parse_set(content)
-        
-        elif field_name == 'assumptions':
-            annotation.assumptions = self._parse_set(content)
-        
-        elif field_name == 'invariants':
-            annotation.invariants = self._parse_set(content)
-        
-        elif field_name == 'security':
-            annotation.security = content
+        # Wrap in @darkarts marker for v3 parser
+        source = f'"""@darkarts\n{text}\n"""'
         
-        elif field_name == 'performance':
-            annotation.performance = content
+        # Parse with v3.0.0 parser
+        v3_annotations = self.v3_parser.parse(source)
         
-        elif field_name == 'complexity':
-            annotation.complexity = content
-        
-        elif field_name == 'objectives':
-            annotation.objectives = content
-        
-        elif field_name == 'configuration':
-            annotation.configuration = content
+        if v3_annotations:
+            return DarkArtsAnnotation.from_v3_annotation(v3_annotations[0])
+        else:
+            # Return empty annotation
+            return DarkArtsAnnotation(raw_text=text)
     
-    def _parse_set(self, content: str) -> List[str]:
+    def extract_field(self, text: str, symbol: str) -> Optional[str]:
         """
-        Parse a set notation {a,b,c} into a list.
+        Extract a specific field from annotation text.
         
         Args:
-            content: Content like "{a,b,c}" or "a,b,c"
+            text: Annotation text
+            symbol: Symbol to extract (e.g., '⊢', '∂')
             
         Returns:
-            List of items
+            Extracted field value or None
         """
-        # Remove braces if present
-        content = content.strip()
-        if content.startswith('{') and content.endswith('}'):
-            content = content[1:-1]
-        
-        # Split by comma
-        items = []
-        current = []
-        depth = 0
-        in_string = False
-        
-        for char in content:
-            if char == '{' and not in_string:
-                depth += 1
-            elif char == '}' and not in_string:
-                depth -= 1
-            elif char == '"':
-                in_string = not in_string
-            elif char == ',' and depth == 0 and not in_string:
-                item = ''.join(current).strip()
-                if item:
-                    items.append(item)
-                current = []
-                continue
-            
-            current.append(char)
-        
-        # Add last item
-        if current:
-            item = ''.join(current).strip()
-            if item:
-                items.append(item)
-        
-        return items
+        # Parse full annotation
+        ann = self.parse_annotation(text)
+        
+        # Map symbol to field
+        field_name = self.META_SYMBOLS.get(symbol)
+        if field_name:
+            value = getattr(ann, field_name, None)
+            if isinstance(value, list):
+                return ', '.join(value) if value else None
+            return value
+        
+        return None
     
-    def parse_file(self, file_path: str) -> List[DarkArtsAnnotation]:
+    def validate(self, source_code: str) -> List[str]:
         """
-        Parse @darkarts annotations from a file.
+        Validate @darkarts annotations in source code.
         
         Args:
-            file_path: Path to source file
+            source_code: Source code containing @darkarts annotations
             
         Returns:
-            List of parsed annotations
+            List of validation errors
         """
-        with open(file_path, 'r', encoding='utf-8') as f:
-            source_code = f.read()
+        # Use v3.0.0 parser with validation enabled
+        parser = DarkArtsParserV3(enable_validation=True)
+        annotations = parser.parse(source_code)
         
-        return self.parse(source_code)
+        errors = []
+        for ann in annotations:
+            if ann.validation_errors:
+                errors.extend(ann.validation_errors)
+        
+        return errors
+
+
+# Backward compatibility aliases
+def parse_darkarts_annotation(text: str) -> DarkArtsAnnotation:
+    """Parse a single @darkarts annotation (legacy function)."""
+    parser = DarkArtsParser()
+    return parser.parse_annotation(text)
+
+
+def extract_darkarts_annotations(source_code: str) -> List[DarkArtsAnnotation]:
+    """Extract all @darkarts annotations from source code (legacy function)."""
+    parser = DarkArtsParser()
+    return parser.parse(source_code)
 
 
-# Convenience function
 def parse_darkarts(source_code: str) -> List[DarkArtsAnnotation]:
-    """
-    Parse @darkarts annotations from source code.
-    
-    Args:
-        source_code: Source code containing @darkarts annotations
-        
-    Returns:
-        List of parsed annotations
-    """
+    """Parse @darkarts annotations from source code (legacy function)."""
     parser = DarkArtsParser()
     return parser.parse(source_code)

package/lib/darkarts/annotations/darkarts_parser_v2.py.bak

@@ -0,0 +1,238 @@
+"""@darkarts
+⊢parser:darkarts.annotations
+∂{re,typing,symbols}
+⚠{@darkarts∈docstrings,unicode-support}
+⊨{∀parse→structured-output,¬modify-src,handle-errors}
+🔒{read-only}
+⚡{O(n²)|n=annotation-length,4-loops,depth=2}
+
+DarkArts Annotation Parser
+
+Parses @darkarts symbolic annotations from source code.
+"""
+
+import re
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, field
+
+from .symbols import VOCABULARY, get_meta_symbols
+
+
+@dataclass
+class DarkArtsAnnotation:
+    """Parsed DarkArts annotation."""
+    module: Optional[str] = None  # From ⊢
+    dependencies: List[str] = field(default_factory=list)  # From ∂
+    assumptions: List[str] = field(default_factory=list)  # From ⚠
+    invariants: List[str] = field(default_factory=list)  # From ⊨
+    security: Optional[str] = None  # From 🔒
+    performance: Optional[str] = None  # From ⚡
+    complexity: Optional[str] = None  # From 📊
+    objectives: Optional[str] = None  # From 🎯
+    configuration: Optional[str] = None  # From ⚙️
+    raw_text: str = ""  # Original annotation text
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            'module': self.module,
+            'dependencies': self.dependencies,
+            'assumptions': self.assumptions,
+            'invariants': self.invariants,
+            'security': self.security,
+            'performance': self.performance,
+            'complexity': self.complexity,
+            'objectives': self.objectives,
+            'configuration': self.configuration,
+        }
+
+
+class DarkArtsParser:
+    """
+    Parser for DarkArts symbolic annotations.
+    
+    Extracts and parses @darkarts annotations from source code.
+    """
+    
+    # Pattern to match @darkarts annotations
+    PATTERN = r'"""@darkarts\s*(.*?)\s*"""'
+    
+    # Meta symbol mappings
+    META_SYMBOLS = {
+        '⊢': 'module',
+        '∂': 'dependencies',
+        '⚠': 'assumptions',
+        '⊨': 'invariants',
+        '🔒': 'security',
+        '⚡': 'performance',
+        '📊': 'complexity',
+        '🎯': 'objectives',
+        '⚙️': 'configuration',
+    }
+    
+    def __init__(self):
+        """Initialize the parser."""
+        self.meta_symbols = get_meta_symbols()
+    
+    def parse(self, source_code: str) -> List[DarkArtsAnnotation]:
+        """
+        Parse all @darkarts annotations from source code.
+        
+        Args:
+            source_code: Source code containing @darkarts annotations
+            
+        Returns:
+            List of parsed annotations
+        """
+        annotations = []
+        
+        # Find all @darkarts blocks
+        matches = re.finditer(self.PATTERN, source_code, re.DOTALL)
+        
+        for match in matches:
+            annotation_text = match.group(1)
+            annotation = self.parse_annotation(annotation_text)
+            annotations.append(annotation)
+        
+        return annotations
+    
+    def parse_annotation(self, text: str) -> DarkArtsAnnotation:
+        """
+        Parse a single @darkarts annotation.
+        
+        Args:
+            text: Annotation text (without @darkarts marker)
+            
+        Returns:
+            Parsed annotation
+        """
+        annotation = DarkArtsAnnotation(raw_text=text)
+        
+        # Split into lines
+        lines = text.strip().split('\n')
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Check for meta symbols
+            for symbol, field_name in self.META_SYMBOLS.items():
+                if line.startswith(symbol):
+                    # Extract content after symbol
+                    content = line[len(symbol):].strip()
+                    self._parse_field(annotation, field_name, content)
+                    break
+        
+        return annotation
+    
+    def _parse_field(self, annotation: DarkArtsAnnotation, field_name: str, content: str):
+        """
+        Parse a field and update annotation.
+        
+        Args:
+            annotation: Annotation to update
+            field_name: Name of field (module, dependencies, etc.)
+            content: Content to parse
+        """
+        if field_name == 'module':
+            annotation.module = content
+        
+        elif field_name == 'dependencies':
+            annotation.dependencies = self._parse_set(content)
+        
+        elif field_name == 'assumptions':
+            annotation.assumptions = self._parse_set(content)
+        
+        elif field_name == 'invariants':
+            annotation.invariants = self._parse_set(content)
+        
+        elif field_name == 'security':
+            annotation.security = content
+        
+        elif field_name == 'performance':
+            annotation.performance = content
+        
+        elif field_name == 'complexity':
+            annotation.complexity = content
+        
+        elif field_name == 'objectives':
+            annotation.objectives = content
+        
+        elif field_name == 'configuration':
+            annotation.configuration = content
+    
+    def _parse_set(self, content: str) -> List[str]:
+        """
+        Parse a set notation {a,b,c} into a list.
+        
+        Args:
+            content: Content like "{a,b,c}" or "a,b,c"
+            
+        Returns:
+            List of items
+        """
+        # Remove braces if present
+        content = content.strip()
+        if content.startswith('{') and content.endswith('}'):
+            content = content[1:-1]
+        
+        # Split by comma
+        items = []
+        current = []
+        depth = 0
+        in_string = False
+        
+        for char in content:
+            if char == '{' and not in_string:
+                depth += 1
+            elif char == '}' and not in_string:
+                depth -= 1
+            elif char == '"':
+                in_string = not in_string
+            elif char == ',' and depth == 0 and not in_string:
+                item = ''.join(current).strip()
+                if item:
+                    items.append(item)
+                current = []
+                continue
+            
+            current.append(char)
+        
+        # Add last item
+        if current:
+            item = ''.join(current).strip()
+            if item:
+                items.append(item)
+        
+        return items
+    
+    def parse_file(self, file_path: str) -> List[DarkArtsAnnotation]:
+        """
+        Parse @darkarts annotations from a file.
+        
+        Args:
+            file_path: Path to source file
+            
+        Returns:
+            List of parsed annotations
+        """
+        with open(file_path, 'r', encoding='utf-8') as f:
+            source_code = f.read()
+        
+        return self.parse(source_code)
+
+
+# Convenience function
+def parse_darkarts(source_code: str) -> List[DarkArtsAnnotation]:
+    """
+    Parse @darkarts annotations from source code.
+    
+    Args:
+        source_code: Source code containing @darkarts annotations
+        
+    Returns:
+        List of parsed annotations
+    """
+    parser = DarkArtsParser()
+    return parser.parse(source_code)