@voodocs/cli 0.4.2 → 1.0.1

package/lib/cli/validate.py

@@ -0,0 +1,364 @@
+"""@darkarts
+⊢cli:validate
+∂{click,pathlib,typing,sys,darkarts,json}
+⚠{python≥3.7,click≥8.0,rich≥10.0}
+⊨{∀validation→executed,∀result→displayed}
+🔒{read-only:validation}
+⚡{O(n²)|n=files,nested-iteration-for-display}
+"""
+
+"""
+VooDocs CLI - Validate Command
+
+Validates @darkarts annotations in Python files.
+"""
+
+import click
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+# Import validation module
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from darkarts.validation import SemanticValidator, PerformanceTracker
+from darkarts.validation.types import ValidationResult, PerformanceResult
+
+
+@click.command()
+@click.argument('path', type=click.Path(exists=True))
+@click.option(
+    '-r', '--recursive',
+    is_flag=True,
+    help='Recursively validate all Python files in directory'
+)
+@click.option(
+    '--deps/--no-deps',
+    default=True,
+    help='Validate dependencies (default: enabled)'
+)
+@click.option(
+    '--perf/--no-perf',
+    default=True,
+    help='Validate performance claims (default: enabled)'
+)
+@click.option(
+    '--strict',
+    is_flag=True,
+    help='Exit with error code if any validation fails'
+)
+@click.option(
+    '--format',
+    type=click.Choice(['text', 'json', 'html']),
+    default='text',
+    help='Output format (default: text)'
+)
+@click.option(
+    '--output',
+    type=click.Path(),
+    help='Output file (default: stdout)'
+)
+@click.option(
+    '--exclude',
+    multiple=True,
+    help='Exclude patterns (can be used multiple times)'
+)
+@click.option(
+    '--fix',
+    is_flag=True,
+    help='Automatically fix issues (preview with --dry-run)'
+)
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    help='Show what would be fixed without making changes'
+)
+def validate(
+    path: str,
+    recursive: bool,
+    deps: bool,
+    perf: bool,
+    strict: bool,
+    format: str,
+    output: Optional[str],
+    exclude: tuple,
+    fix: bool,
+    dry_run: bool,
+):
+    """
+    Validate @darkarts annotations in Python files.
+    
+    Examples:
+    
+        # Validate a single file
+        voodocs validate myfile.py
+        
+        # Validate all files in a directory
+        voodocs validate lib/ -r
+        
+        # Validate with strict mode (exit code 1 on failure)
+        voodocs validate lib/ -r --strict
+        
+        # Validate only dependencies
+        voodocs validate lib/ -r --no-perf
+        
+        # Output as JSON
+        voodocs validate lib/ -r --format json --output report.json
+        
+        # Auto-fix issues
+        voodocs validate lib/ -r --fix
+    """
+    path_obj = Path(path)
+    
+    # Print header
+    click.echo(f"Validating: {path}")
+    click.echo("━" * 60)
+    click.echo()
+    
+    # Collect results
+    semantic_results: List[ValidationResult] = []
+    performance_results: List[PerformanceResult] = []
+    
+    # Run semantic validation
+    if deps:
+        click.echo("Running semantic validation...")
+        validator = SemanticValidator()
+        
+        if path_obj.is_file():
+            semantic_results = [validator.validate_file(path_obj)]
+        else:
+            semantic_results = validator.validate_directory(path_obj, recursive=recursive)
+        
+        click.echo(f"✓ Validated {len(semantic_results)} files")
+        click.echo()
+    
+    # Run performance validation
+    if perf:
+        click.echo("Running performance validation...")
+        tracker = PerformanceTracker()
+        
+        if path_obj.is_file():
+            performance_results = [tracker.analyze_file(path_obj)]
+        else:
+            performance_results = tracker.analyze_directory(path_obj, recursive=recursive)
+        
+        click.echo(f"✓ Analyzed {len(performance_results)} files")
+        click.echo()
+    
+    # Display results based on format
+    if format == 'text':
+        display_text_results(semantic_results, performance_results)
+    elif format == 'json':
+        display_json_results(semantic_results, performance_results, output)
+    elif format == 'html':
+        display_html_results(semantic_results, performance_results, output)
+    
+    # Summary
+    click.echo()
+    click.echo("━" * 60)
+    
+    total_files = len(semantic_results) if semantic_results else len(performance_results)
+    valid_semantic = sum(1 for r in semantic_results if r.is_valid) if semantic_results else 0
+    valid_perf = sum(1 for r in performance_results if r.is_valid) if performance_results else 0
+    
+    if deps and perf:
+        valid = min(valid_semantic, valid_perf)
+        invalid = total_files - valid
+    elif deps:
+        valid = valid_semantic
+        invalid = total_files - valid
+    elif perf:
+        valid = valid_perf
+        invalid = total_files - valid
+    else:
+        valid = total_files
+        invalid = 0
+    
+    click.echo(f"Total: {total_files} files")
+    click.echo(f"Valid: {valid} ({valid/total_files*100:.1f}%)" if total_files > 0 else "Valid: 0")
+    click.echo(f"Invalid: {invalid} ({invalid/total_files*100:.1f}%)" if total_files > 0 else "Invalid: 0")
+    click.echo("━" * 60)
+    
+    # Exit code
+    if strict and invalid > 0:
+        click.echo()
+        click.echo("❌ Validation failed (strict mode)", err=True)
+        sys.exit(1)
+    elif invalid > 0:
+        click.echo()
+        click.echo("💡 Run 'voodocs fix' to automatically fix issues")
+    else:
+        click.echo()
+        click.echo("✅ All validations passed!")
+
+
+def display_text_results(
+    semantic_results: List[ValidationResult],
+    performance_results: List[PerformanceResult]
+):
+    """Display results in text format."""
+    
+    # Display semantic results
+    if semantic_results:
+        click.echo("Semantic Validation Results:")
+        click.echo()
+        
+        for result in semantic_results:
+            if result.is_valid:
+                click.echo(f"✅ {result.file_path}")
+            else:
+                click.echo(f"❌ {result.file_path}")
+                
+                if result.missing_deps:
+                    click.echo(f"   Missing from ∂{{}}: {', '.join(sorted(result.missing_deps))}")
+                
+                if result.extra_deps:
+                    click.echo(f"   Extra in ∂{{}}: {', '.join(sorted(result.extra_deps))}")
+                
+                if result.errors:
+                    for error in result.errors:
+                        click.echo(f"   Error: {error}")
+                
+                if result.warnings:
+                    for warning in result.warnings:
+                        click.echo(f"   Warning: {warning}")
+            
+            click.echo()
+    
+    # Display performance results
+    if performance_results:
+        click.echo("Performance Validation Results:")
+        click.echo()
+        
+        for result in performance_results:
+            if result.is_valid:
+                click.echo(f"✅ {result.file_path}")
+                if hasattr(result, 'claimed_complexity') and result.claimed_complexity:
+                    click.echo(f"   Complexity: {result.claimed_complexity}")
+            else:
+                click.echo(f"❌ {result.file_path}")
+                if hasattr(result, 'claimed_complexity') and result.claimed_complexity:
+                    click.echo(f"   Claimed: {result.claimed_complexity}")
+                if hasattr(result, 'static_analysis') and result.static_analysis:
+                    click.echo(f"   Static Analysis: {result.static_analysis}")
+                
+                if hasattr(result, 'warnings') and result.warnings:
+                    for warning in result.warnings:
+                        click.echo(f"   Warning: {warning}")
+                
+                if hasattr(result, 'suggestions') and result.suggestions:
+                    for suggestion in result.suggestions:
+                        click.echo(f"   Suggestion: {suggestion}")
+            
+            click.echo()
+
+
+def display_json_results(
+    semantic_results: List[ValidationResult],
+    performance_results: List[PerformanceResult],
+    output: Optional[str]
+):
+    """Display results in JSON format."""
+    import json
+    
+    # Convert results to dicts
+    semantic_dicts = []
+    for r in semantic_results:
+        semantic_dicts.append({
+            "file_path": r.file_path,
+            "is_valid": r.is_valid,
+            "missing_deps": list(r.missing_deps) if hasattr(r, 'missing_deps') else [],
+            "extra_deps": list(r.extra_deps) if hasattr(r, 'extra_deps') else [],
+            "errors": r.errors if hasattr(r, 'errors') else [],
+            "warnings": r.warnings if hasattr(r, 'warnings') else [],
+            "suggestions": r.suggestions if hasattr(r, 'suggestions') else [],
+        })
+    
+    # Performance results
+    perf_dicts = []
+    for r in performance_results:
+        perf_dicts.append({
+            "file_path": r.file_path,
+            "is_valid": r.is_valid,
+            "claimed_complexity": str(r.claimed_complexity) if hasattr(r, 'claimed_complexity') else None,
+            "warnings": r.warnings if hasattr(r, 'warnings') else [],
+            "suggestions": r.suggestions if hasattr(r, 'suggestions') else [],
+        })
+    
+    data = {
+        "semantic": semantic_dicts,
+        "performance": perf_dicts,
+    }
+    
+    json_str = json.dumps(data, indent=2)
+    
+    if output:
+        Path(output).write_text(json_str)
+        click.echo(f"Results written to: {output}")
+    else:
+        click.echo(json_str)
+
+
+def display_html_results(
+    semantic_results: List[ValidationResult],
+    performance_results: List[PerformanceResult],
+    output: Optional[str]
+):
+    """Display results in HTML format."""
+    html = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>VooDocs Validation Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        h1 { color: #333; }
+        .valid { color: green; }
+        .invalid { color: red; }
+        .file { margin: 10px 0; padding: 10px; border: 1px solid #ddd; }
+    </style>
+</head>
+<body>
+    <h1>VooDocs Validation Report</h1>
+    
+    <h2>Semantic Validation</h2>
+"""
+    
+    for result in semantic_results:
+        status = "valid" if result.is_valid else "invalid"
+        html += f'<div class="file {status}">\n'
+        html += f'<strong>{result.file_path}</strong>: {"✅ Valid" if result.is_valid else "❌ Invalid"}<br>\n'
+        
+        if not result.is_valid:
+            if result.missing_deps:
+                html += f'Missing: {", ".join(sorted(result.missing_deps))}<br>\n'
+            if result.extra_deps:
+                html += f'Extra: {", ".join(sorted(result.extra_deps))}<br>\n'
+        
+        html += '</div>\n'
+    
+    html += """
+    <h2>Performance Validation</h2>
+"""
+    
+    for result in performance_results:
+        status = "valid" if result.is_valid else "invalid"
+        html += f'<div class="file {status}">\n'
+        html += f'<strong>{result.file_path}</strong>: {"✅ Valid" if result.is_valid else "❌ Invalid"}<br>\n'
+        html += f'Claimed: {result.claimed_complexity}<br>\n'
+        
+        if not result.is_valid:
+            html += f'Actual: {result.actual_complexity}<br>\n'
+        
+        html += '</div>\n'
+    
+    html += """
+</body>
+</html>
+"""
+    
+    if output:
+        Path(output).write_text(html)
+        click.echo(f"Results written to: {output}")
+    else:
+        click.echo(html)

package/lib/darkarts/__init__.py

@@ -1,11 +1,17 @@
-"""
-DarkArts: An execution engine for mathematical notation.
+"""@darkarts
+⊢init:lib.darkarts.package
+∂{}
+⚠{python≥3.7}
+⊨{∀import→exports-available,namespace:clean,¬side-effects-on-import}
+🔒{pure-init,¬io,¬network,¬exec}
+⚡{O(1):import-time}
+
+Package initialization for lib.darkarts.
 
-DarkArts bridges the gap between AI's natural mathematical reasoning
-and computational reality, allowing AI to express solutions in mathematics
-while getting executable results without writing code.
+Module exports and namespace configuration.
 """
 
+
 __version__ = "0.1.0-alpha"
 __author__ = "Vooodooo"
 

package/lib/darkarts/annotations/__init__.py

@@ -1,9 +1,17 @@
-"""
-DarkArts Annotations
+"""@darkarts
+⊢init:annotations.package
+∂{}
+⚠{python≥3.7}
+⊨{∀import→exports-available,namespace:clean,¬side-effects-on-import}
+🔒{pure-init,¬io,¬network,¬exec}
+⚡{O(1):import-time}
+
+Package initialization for annotations.
 
-AI-native code documentation system using mathematical and logical notation.
+Module exports and namespace configuration.
 """
 
+
 from .types import (
     ParsedAnnotations,
     ModuleAnnotation,

package/lib/darkarts/annotations/darkarts_parser.py

@@ -4,7 +4,7 @@
 ⚠{@darkarts∈docstrings,unicode-support}
 ⊨{∀parse→structured-output,¬modify-src,handle-errors}
 🔒{read-only}
-⚡{O(n)|n=annotation-length}
+⚡{O(n²)|n=annotation-length,4-loops,depth=2}
 
 DarkArts Annotation Parser
 

package/lib/darkarts/annotations/translator.py

@@ -209,7 +209,7 @@ class DarkArtsTranslator:
         Returns:
             Symbolic notation
         """
-        result = text.lower()
+        result = text
         
         # Replace English phrases with symbols
         # Sort by length (longest first) to avoid partial matches
@@ -217,7 +217,14 @@ class DarkArtsTranslator:
                         key=lambda x: len(x[0]), reverse=True)
         
         for english, symbol in phrases:
-            result = result.replace(english, symbol)
+            # Use word boundaries to avoid mid-word replacements
+            # This prevents "or" in "authenticated" from being replaced
+            pattern = r'\b' + re.escape(english) + r'\b'
+            try:
+                result = re.sub(pattern, symbol, result, flags=re.IGNORECASE)
+            except re.error:
+                # Fallback for patterns that don't work with word boundaries
+                pass
         
         return result
     
@@ -311,15 +318,35 @@ class DarkArtsTranslator:
                 symbolic = [self._convert_invariant(inv) for inv in invariants]
                 lines.append(f"⊨{{{','.join(symbolic)}}}")
         
+        # Preconditions
+        if 'preconditions' in voodocs_dict:
+            preconditions = voodocs_dict['preconditions']
+            if isinstance(preconditions, list):
+                symbolic = [self._convert_invariant(pre) for pre in preconditions]
+                lines.append(f"⊳{{{','.join(symbolic)}}}")
+        
+        # Postconditions
+        if 'postconditions' in voodocs_dict:
+            postconditions = voodocs_dict['postconditions']
+            if isinstance(postconditions, list):
+                symbolic = [self._convert_invariant(post) for post in postconditions]
+                lines.append(f"⊲{{{','.join(symbolic)}}}")
+        
         # Security
-        if 'security_model' in voodocs_dict:
-            security = self._simplify_text(voodocs_dict['security_model'])
+        if 'security_model' in voodocs_dict or 'security_implications' in voodocs_dict:
+            security = voodocs_dict.get('security_model') or voodocs_dict.get('security_implications')
+            if isinstance(security, list):
+                security = ', '.join(security)
+            security = self._simplify_text(str(security))
             lines.append(f"🔒{{{security}}}")
         
-        # Performance
+        # Performance/Complexity
         if 'performance_model' in voodocs_dict:
             perf = voodocs_dict['performance_model']
             lines.append(f"⚡{{{perf}}}")
+        elif 'complexity' in voodocs_dict:
+            complexity = voodocs_dict['complexity']
+            lines.append(f"⚡{{{complexity}}}")
         
         lines.append('"""')
         return '\n'.join(lines)

package/lib/darkarts/annotations/types.py

@@ -1,7 +1,20 @@
-"""
+"""@darkarts
+⊢annotation-types:annotations.data-structures
+∂{dataclasses,typing,enum}
+⚠{python≥3.7}
+⊨{∀dataclass:valid-schema,∀enum:valid-values,∀annotation:complete-representation,serializable:to-dict,multi-language:supported}
+🔒{pure-data,¬io,¬side-effects,¬exec}
+⚡{O(1):all-ops,lightweight-dataclasses}
+
 DarkArts Annotation Types
 
-Data structures for representing parsed DarkArts annotations.
+Data structures for parsed @darkarts/@voodocs annotations with:
+- Annotation types (function, method, class, module)
+- Language support (Python, TypeScript, JavaScript, Java, C++, C#, Go, Rust)
+- Complexity annotations (time, space, best/worst/average case)
+- State transitions (from_state → to_state with conditions)
+- Error cases (condition, error_type, description)
+- Structured representations (FunctionAnnotation, ClassAnnotation, ModuleAnnotation)
 """
 
 from dataclasses import dataclass, field