@voodocs/cli 2.5.1 → 2.5.3

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # 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
+- **CLI Registration**: Fixed analyze, convert, and companion commands not being registered
+  - Converted `analyze.py` from argparse to Click command
+  - Created `convert.py` as Click command for VooDocs Lite conversion
+  - Updated `lib/cli/__init__.py` to import and register all three commands
+  - Updated `__version__` from "2.1.3" to "2.5.2" in Python code
+- v2.5.0 and v2.5.1 had files in package but commands weren't accessible via CLI
+- All Priority Analyzer and VooDocs Lite features now fully functional
+
+---
+
 ## [2.5.1] - 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.1.3"
+__version__ = "2.5.3"
 
 
 @click.group()
@@ -41,6 +41,9 @@ from .generate import generate
 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
 cli.add_command(init)
@@ -50,6 +53,9 @@ cli.add_command(generate)
 cli.add_command(benchmark)
 cli.add_command(fix)
 cli.add_command(context)
+cli.add_command(analyze)
+cli.add_command(convert)
+cli.add_command(companion)
 
 
 def main():

package/lib/cli/analyze.py

@@ -1,29 +1,96 @@
+"""@darkarts
+⊢cli:analyze
+∂{click,pathlib,darkarts.priority_analyzer}
+⚠{python≥3.7,click≥8.0}
+⊨{∀file→analyzed,∀score→calculated}
+🔒{read-only:source-files}
+⚡{O(n):files}
 """
-CLI command for VooDocs Priority Analyzer
 
-Usage: voodocs analyze [path] [options]
 """
+VooDocs Analyze Command
 
+Analyze files to identify which need VooDocs annotations most urgently.
+"""
+
+import click
 import os
 import sys
+import json
+import csv
 from pathlib import Path
 
 # Add parent directory to path for imports
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from darkarts.priority_analyzer.analyzer import PriorityAnalyzer
 
-from lib.darkarts.priority_analyzer.analyzer import PriorityAnalyzer
 
-
-def cmd_analyze(args):
-    """Execute the analyze command."""
-    # Get path (default to current directory)
-    path = args.path if hasattr(args, 'path') and args.path else '.'
+@click.command()
+@click.argument(
+    'path',
+    type=click.Path(exists=True),
+    default='.',
+    required=False
+)
+@click.option(
+    '-r', '--recursive',
+    is_flag=True,
+    default=True,
+    help='Recursively analyze directories (default: true)'
+)
+@click.option(
+    '--top',
+    type=int,
+    default=10,
+    help='Show top N files (default: 10, 0 for all)'
+)
+@click.option(
+    '--priority',
+    type=click.Choice(['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'MINIMAL'], case_sensitive=False),
+    help='Filter by priority level'
+)
+@click.option(
+    '--min-score',
+    type=int,
+    help='Minimum priority score to show'
+)
+@click.option(
+    '--format',
+    'output_format',
+    type=click.Choice(['text', 'json', 'csv', 'markdown']),
+    default='text',
+    help='Output format (default: text)'
+)
+@click.option(
+    '--include-annotated',
+    is_flag=True,
+    help='Include fully annotated files'
+)
+@click.option(
+    '--exclude',
+    help='Comma-separated list of patterns to exclude'
+)
+def analyze(path, recursive, top, priority, min_score, output_format, include_annotated, exclude):
+    """
+    Analyze files to identify which need VooDocs annotations most urgently.
+    
+    Uses heuristics based on:
+    - File complexity (LOC, cyclomatic complexity, function count)
+    - Security keywords (auth, password, token, etc.)
+    - Import/dependency count
+    
+    Examples:
+        voodocs analyze src/
+        voodocs analyze src/ --top 20
+        voodocs analyze src/ --priority critical
+        voodocs analyze src/ --format json
+    """
     path = os.path.abspath(path)
     
     # Check if path exists
     if not os.path.exists(path):
-        print(f"❌ Error: Path not found: {path}")
-        return 1
+        click.echo(f"❌ Error: Path not found: {path}", err=True)
+        sys.exit(1)
     
     # Determine if path is file or directory
     is_file = os.path.isfile(path)
@@ -36,38 +103,34 @@ def cmd_analyze(args):
     if is_file:
         scores = [analyzer.analyze_file(path)]
     else:
-        recursive = getattr(args, 'recursive', True)
-        exclude = getattr(args, 'exclude', None)
         exclude_patterns = exclude.split(',') if exclude else None
         
-        print(f"🔍 Analyzing files in: {path}")
-        if recursive:
-            print("   (recursive mode)")
-        print()
+        if output_format == 'text':
+            click.echo(f"🔍 Analyzing files in: {path}")
+            if recursive:
+                click.echo("   (recursive mode)")
+            click.echo()
         
         scores = analyzer.analyze_directory(path, recursive, exclude_patterns)
     
     # Filter by priority level if specified
-    if hasattr(args, 'priority') and args.priority:
-        priority_filter = args.priority.upper()
+    if priority:
+        priority_filter = priority.upper()
         scores = [s for s in scores if s.priority_level == priority_filter]
     
     # Filter by minimum score
-    if hasattr(args, 'min_score') and args.min_score:
-        scores = [s for s in scores if s.priority_score >= args.min_score]
+    if min_score:
+        scores = [s for s in scores if s.priority_score >= min_score]
     
     # Filter out fully annotated files (unless --include-annotated)
-    if not getattr(args, 'include_annotated', False):
+    if not include_annotated:
         scores = [s for s in scores if s.annotation_coverage < 1.0]
     
     # Limit to top N
-    top_n = getattr(args, 'top', 10)
-    if top_n and top_n > 0:
-        scores = scores[:top_n]
-    
-    # Output format
-    output_format = getattr(args, 'format', 'text')
+    if top and top > 0:
+        scores = scores[:top]
     
+    # Output
     if output_format == 'json':
         _output_json(scores)
     elif output_format == 'csv':
@@ -77,14 +140,14 @@ def cmd_analyze(args):
     else:
         _output_text(scores, path)
     
-    return 0
+    sys.exit(0)
 
 
 def _output_text(scores, path):
     """Output results in human-readable text format."""
     if not scores:
-        print("✅ No files need annotations!")
-        print("   All files are either fully annotated or below priority threshold.")
+        click.echo("✅ No files need annotations!")
+        click.echo("   All files are either fully annotated or below priority threshold.")
         return
     
     # Calculate statistics
@@ -101,34 +164,34 @@ def _output_text(scores, path):
     coverage_pct = (annotated_count / total_files * 100) if total_files > 0 else 0
     
     # Header
-    print("━" * 70)
-    print("VooDocs Priority Analysis")
-    print("━" * 70)
-    print()
-    print(f"Project: {path}")
-    print(f"Files analyzed: {total_files}")
-    print(f"Annotations found: {annotated_count} ({coverage_pct:.0f}% coverage)")
-    print()
+    click.echo("━" * 70)
+    click.echo("VooDocs Priority Analysis")
+    click.echo("━" * 70)
+    click.echo()
+    click.echo(f"Project: {path}")
+    click.echo(f"Files analyzed: {total_files}")
+    click.echo(f"Annotations found: {annotated_count} ({coverage_pct:.0f}% coverage)")
+    click.echo()
     
     # Priority distribution
-    print("Priority Distribution:")
+    click.echo("Priority Distribution:")
     if priority_dist['CRITICAL'] > 0:
-        print(f"🔴 CRITICAL (80-100): {priority_dist['CRITICAL']} files")
+        click.echo(f"🔴 CRITICAL (80-100): {priority_dist['CRITICAL']} files")
     if priority_dist['HIGH'] > 0:
-        print(f"🟠 HIGH (60-79):     {priority_dist['HIGH']} files")
+        click.echo(f"🟠 HIGH (60-79):     {priority_dist['HIGH']} files")
     if priority_dist['MEDIUM'] > 0:
-        print(f"🟡 MEDIUM (40-59):   {priority_dist['MEDIUM']} files")
+        click.echo(f"🟡 MEDIUM (40-59):   {priority_dist['MEDIUM']} files")
     if priority_dist['LOW'] > 0:
-        print(f"🟢 LOW (20-39):      {priority_dist['LOW']} files")
+        click.echo(f"🟢 LOW (20-39):      {priority_dist['LOW']} files")
     if priority_dist['MINIMAL'] > 0:
-        print(f"⚪ MINIMAL (0-19):    {priority_dist['MINIMAL']} files")
-    print()
+        click.echo(f"⚪ MINIMAL (0-19):    {priority_dist['MINIMAL']} files")
+    click.echo()
     
     # Top files
-    print("━" * 70)
-    print(f"Top {len(scores)} Files Needing Annotations")
-    print("━" * 70)
-    print()
+    click.echo("━" * 70)
+    click.echo(f"Top {len(scores)} Files Needing Annotations")
+    click.echo("━" * 70)
+    click.echo()
     
     for i, score in enumerate(scores, 1):
         # Priority emoji
@@ -143,41 +206,39 @@ def _output_text(scores, path):
         # Relative path
         rel_path = os.path.relpath(score.filepath, path) if not os.path.isfile(path) else score.filepath
         
-        print(f"{i}. {emoji} {rel_path} (Score: {score.priority_score:.0f})")
-        print(f"   Complexity: {score.complexity_score}  Security: {score.security_score}  Dependencies: {score.dependency_score}  Annotations: {score.annotation_penalty}")
-        print()
+        click.echo(f"{i}. {emoji} {rel_path} (Score: {score.priority_score:.0f})")
+        click.echo(f"   Complexity: {score.complexity_score}  Security: {score.security_score}  Dependencies: {score.dependency_score}  Annotations: {score.annotation_penalty}")
+        click.echo()
         
         # Reasons
         if score.reasons:
-            print("   Reasons:")
+            click.echo("   Reasons:")
             for reason in score.reasons:
-                print(f"   • {reason}")
-            print()
+                click.echo(f"   • {reason}")
+            click.echo()
         
         # Suggestions
         if score.suggestions:
-            print("   Suggestions:")
+            click.echo("   Suggestions:")
             for suggestion in score.suggestions:
-                print(f"   ✓ {suggestion}")
-            print()
+                click.echo(f"   ✓ {suggestion}")
+            click.echo()
     
     # Footer
-    print("━" * 70)
-    print()
-    print("💡 Tip: Start with CRITICAL files first. Use:")
+    click.echo("━" * 70)
+    click.echo()
+    click.echo("💡 Tip: Start with CRITICAL files first. Use:")
     if scores:
         first_file = scores[0].filepath
-        print(f"   voodocs companion {first_file}")
-    print()
-    print("   Or convert to VooDocs Lite for faster annotation:")
-    print(f"   voodocs convert {path} --to lite --in-place")
-    print()
+        click.echo(f"   voodocs companion {first_file}")
+    click.echo()
+    click.echo("   Or convert to VooDocs Lite for faster annotation:")
+    click.echo(f"   voodocs convert {path} --to lite")
+    click.echo()
 
 
 def _output_json(scores):
     """Output results in JSON format."""
-    import json
-    
     data = []
     for score in scores:
         data.append({
@@ -197,14 +258,11 @@ def _output_json(scores):
             'suggestions': score.suggestions
         })
     
-    print(json.dumps(data, indent=2))
+    click.echo(json.dumps(data, indent=2))
 
 
 def _output_csv(scores):
     """Output results in CSV format."""
-    import csv
-    import sys
-    
     writer = csv.writer(sys.stdout)
     
     # Header
@@ -234,14 +292,14 @@ def _output_csv(scores):
 
 def _output_markdown(scores):
     """Output results in Markdown format."""
-    print("# VooDocs Priority Analysis")
-    print()
-    print("## Summary")
-    print()
-    print(f"- **Files analyzed:** {len(scores)}")
-    print()
-    print("## Top Files")
-    print()
+    click.echo("# VooDocs Priority Analysis")
+    click.echo()
+    click.echo("## Summary")
+    click.echo()
+    click.echo(f"- **Files analyzed:** {len(scores)}")
+    click.echo()
+    click.echo("## Top Files")
+    click.echo()
     
     for i, score in enumerate(scores, 1):
         emoji = {
@@ -252,26 +310,26 @@ def _output_markdown(scores):
             'MINIMAL': '⚪'
         }.get(score.priority_level, '⚪')
         
-        print(f"### {i}. {emoji} {score.filepath}")
-        print()
-        print(f"**Score:** {score.priority_score:.0f} ({score.priority_level})")
-        print()
-        print(f"- Complexity: {score.complexity_score}")
-        print(f"- Security: {score.security_score}")
-        print(f"- Dependencies: {score.dependency_score}")
-        print(f"- Annotation Coverage: {score.annotation_coverage * 100:.0f}%")
-        print()
+        click.echo(f"### {i}. {emoji} {score.filepath}")
+        click.echo()
+        click.echo(f"**Score:** {score.priority_score:.0f} ({score.priority_level})")
+        click.echo()
+        click.echo(f"- Complexity: {score.complexity_score}")
+        click.echo(f"- Security: {score.security_score}")
+        click.echo(f"- Dependencies: {score.dependency_score}")
+        click.echo(f"- Annotation Coverage: {score.annotation_coverage * 100:.0f}%")
+        click.echo()
         
         if score.reasons:
-            print("**Reasons:**")
-            print()
+            click.echo("**Reasons:**")
+            click.echo()
             for reason in score.reasons:
-                print(f"- {reason}")
-            print()
+                click.echo(f"- {reason}")
+            click.echo()
         
         if score.suggestions:
-            print("**Suggestions:**")
-            print()
+            click.echo("**Suggestions:**")
+            click.echo()
             for suggestion in score.suggestions:
-                print(f"- {suggestion}")
-            print()
+                click.echo(f"- {suggestion}")
+            click.echo()

package/lib/cli/convert.py

@@ -0,0 +1,144 @@
+"""@darkarts
+⊢cli:convert
+∂{click,pathlib,darkarts.voodocs_lite_parser}
+⚠{python≥3.7,click≥8.0}
+⊨{∀file→converted|skipped,∀error→reported}
+🔒{read-only:source-files}
+⚡{O(n):files}
+"""
+
+"""
+VooDocs Convert Command
+
+Convert VooDocs annotations between Standard and Lite formats.
+"""
+
+import click
+from pathlib import Path
+import sys
+
+# Import VooDocs Lite parser
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from darkarts.voodocs_lite_parser import VooDocsLiteParser
+
+
+@click.command()
+@click.argument(
+    'paths',
+    nargs=-1,
+    type=click.Path(exists=True),
+    required=True
+)
+@click.option(
+    '--to',
+    'target_format',
+    type=click.Choice(['lite', 'standard']),
+    required=True,
+    help='Target format to convert to'
+)
+@click.option(
+    '-r', '--recursive',
+    is_flag=True,
+    help='Recursively process directories'
+)
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    help='Show what would be converted without modifying files'
+)
+@click.option(
+    '-v', '--verbose',
+    is_flag=True,
+    help='Show detailed conversion information'
+)
+def convert(paths, target_format, recursive, dry_run, verbose):
+    """
+    Convert VooDocs annotations between Standard and Lite formats.
+    
+    Examples:
+        voodocs convert src/ --to lite
+        voodocs convert src/ --to standard --recursive
+        voodocs convert file.ts --to lite --dry-run
+    """
+    parser = VooDocsLiteParser()
+    
+    converted_count = 0
+    skipped_count = 0
+    error_count = 0
+    
+    for path_str in paths:
+        path = Path(path_str)
+        
+        if path.is_file():
+            files = [path]
+        elif path.is_dir():
+            if recursive:
+                files = list(path.rglob('*.ts')) + list(path.rglob('*.js')) + \
+                       list(path.rglob('*.py')) + list(path.rglob('*.sol'))
+            else:
+                files = list(path.glob('*.ts')) + list(path.glob('*.js')) + \
+                       list(path.glob('*.py')) + list(path.glob('*.sol'))
+        else:
+            click.echo(f"❌ Invalid path: {path}", err=True)
+            error_count += 1
+            continue
+        
+        for file_path in files:
+            try:
+                # Read file
+                content = file_path.read_text()
+                
+                # Convert
+                if target_format == 'lite':
+                    converted = parser.convert_file_standard_to_lite(content)
+                else:
+                    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:
+                    if verbose:
+                        click.echo(f"⏭️  Skipped (no changes): {file_path}")
+                    skipped_count += 1
+                    continue
+                
+                # Write or show
+                if dry_run:
+                    click.echo(f"Would convert: {file_path}")
+                    if verbose:
+                        click.echo(f"  {len(content)} → {len(converted)} chars")
+                else:
+                    file_path.write_text(converted)
+                    click.echo(f"✅ Converted: {file_path}")
+                
+                converted_count += 1
+                
+            except Exception as e:
+                click.echo(f"❌ Error converting {file_path}: {e}", err=True)
+                error_count += 1
+    
+    # Summary
+    click.echo()
+    click.echo(f"Summary:")
+    click.echo(f"  ✅ Converted: {converted_count}")
+    click.echo(f"  ⏭️  Skipped: {skipped_count}")
+    if error_count > 0:
+        click.echo(f"  ❌ Errors: {error_count}")
+    
+    if dry_run:
+        click.echo()
+        click.echo("(Dry run - no files were modified)")
+    
+    sys.exit(0 if error_count == 0 else 1)

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.1",
+  "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": {