@voodocs/cli 2.5.2 → 2.5.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## [2.5.3] - 2024-12-24
+
+### Fixed - CRITICAL BUG
+- **Convert Command File Corruption**: Fixed critical bug where `voodocs convert` emptied all files
+  - Root cause: `standard_to_lite()` and `lite_to_standard()` only converted annotation blocks, not entire files
+  - Added `convert_file_standard_to_lite()` and `convert_file_lite_to_standard()` methods
+  - These new methods find and replace annotations while preserving all other file content
+  - Updated `convert.py` to use file-level conversion methods
+- **Safety Checks**: Added validation to prevent file corruption
+  - Reject conversions that result in nearly empty files (<10 chars)
+  - Reject conversions that shrink file size by >90%
+  - Display warnings when safety checks trigger
+
+**IMPORTANT**: If you used `voodocs convert` from v2.5.2, restore your files from git immediately!
+
+---
+
 ## [2.5.2] - 2024-12-24
 
 ### Fixed

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__ = "2.5.3"
 
 
 @click.group()

package/lib/cli/convert.py

@@ -90,9 +90,22 @@ def convert(paths, target_format, recursive, dry_run, verbose):
                 
                 # Convert
                 if target_format == 'lite':
-                    converted = parser.standard_to_lite(content)
+                    converted = parser.convert_file_standard_to_lite(content)
                 else:
-                    converted = parser.lite_to_standard(content)
+                    converted = parser.convert_file_lite_to_standard(content)
+                
+                # Safety check: Ensure conversion didn't empty the file
+                if not converted or len(converted.strip()) < 10:
+                    click.echo(f"⚠️  Warning: Conversion resulted in nearly empty file, skipping: {file_path}", err=True)
+                    error_count += 1
+                    continue
+                
+                # Safety check: Ensure file size didn't shrink by more than 90%
+                if len(converted) < len(content) * 0.1:
+                    click.echo(f"⚠️  Warning: Conversion would reduce file size by >90%, skipping: {file_path}", err=True)
+                    click.echo(f"   Original: {len(content)} chars, Converted: {len(converted)} chars", err=True)
+                    error_count += 1
+                    continue
                 
                 # Check if anything changed
                 if converted == content:

package/lib/darkarts/voodocs_lite_parser.py

@@ -44,6 +44,64 @@ class VooDocsLiteParser:
         '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]:
         """
@@ -122,7 +180,7 @@ class VooDocsLiteParser:
     @classmethod
     def parse_standard(cls, content: str) -> Dict[str, any]:
         """
-        Parse standard VooDocs format annotation.
+        Parse VooDocs Standard format annotation.
         
         Args:
             content: Standard format annotation text
@@ -141,33 +199,50 @@ class VooDocsLiteParser:
             '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]
+        # 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, expand_abbreviations: bool = True) -> str:
+    def lite_to_standard(cls, lite_content: str) -> str:
         """
         Convert Lite format to Standard format.
         
         Args:
             lite_content: Lite format annotation
-            expand_abbreviations: Whether to expand abbreviations
             
         Returns:
             Standard format annotation
@@ -178,62 +253,46 @@ class VooDocsLiteParser:
         
         # Purpose
         if parsed['purpose']:
-            text = parsed['purpose']
-            if expand_abbreviations:
-                text = expand_text(text)
+            text = ultra_expand(parsed['purpose'])
             lines.append(f"⊢{{{text}}}")
         
         # Dependencies
         if parsed['dependencies']:
-            deps = ', '.join(parsed['dependencies'])
-            if expand_abbreviations:
-                deps = expand_text(deps)
+            deps = ','.join([ultra_expand(d) for d in parsed['dependencies']])
             lines.append(f"∂{{{deps}}}")
         
         # Assumptions
         if parsed['assumptions']:
             for assumption in parsed['assumptions']:
-                text = assumption
-                if expand_abbreviations:
-                    text = expand_text(text)
+                text = ultra_expand(assumption)
                 lines.append(f"⚠{{{text}}}")
         
         # Preconditions
         if parsed['preconditions']:
             for precond in parsed['preconditions']:
-                text = precond
-                if expand_abbreviations:
-                    text = expand_text(text)
+                text = ultra_expand(precond)
                 lines.append(f"⊳{{{text}}}")
         
         # Postconditions
         if parsed['postconditions']:
             for postcond in parsed['postconditions']:
-                text = postcond
-                if expand_abbreviations:
-                    text = expand_text(text)
+                text = ultra_expand(postcond)
                 lines.append(f"⊲{{{text}}}")
         
         # Invariants
         if parsed['invariants']:
             for invariant in parsed['invariants']:
-                text = invariant
-                if expand_abbreviations:
-                    text = expand_text(text)
+                text = ultra_expand(invariant)
                 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}}}")
+            lines.append(f"⚡{{{parsed['complexity']}}}")
         
         # Security
         if parsed['security']:
             for security in parsed['security']:
-                text = security
-                if expand_abbreviations:
-                    text = expand_text(text)
+                text = ultra_expand(security)
                 lines.append(f"🔒{{{text}}}")
         
         return '\n'.join(lines)
@@ -319,25 +378,27 @@ class VooDocsLiteParser:
     @classmethod
     def detect_format(cls, content: str) -> str:
         """
-        Detect whether content is Lite or Standard format.
+        Detect if content is Standard or Lite format.
         
+        Args:
+            content: Annotation content
+            
         Returns:
-            'lite', 'standard', or 'unknown'
+            'standard', 'lite', 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
+        if any(symbol in content for symbol in ['⊢', '∂', '⚠', '⊳', '⊲', '⊨', '⚡', '🔒']):
+            return 'standard'
         
-        # Check for Standard symbols
-        standard_indicators = ['⊢', '∂', '⚠', '⊳', '⊲', '⊨', '⚡', '🔒']
-        has_standard = any(sym in content for sym in standard_indicators)
+        # 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 has_lite and not has_standard:
+        if lite_symbols > 0:
             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'
+        
+        return 'unknown'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voodocs/cli",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "description": "AI-Native Symbolic Documentation System - The world's first documentation tool using mathematical notation with semantic validation",
   "main": "voodocs_cli.py",
   "bin": {