@voodocs/cli 0.4.2 → 1.0.0

package/lib/cli/test_cli.py

@@ -0,0 +1,215 @@
+"""
+@darkarts
+⊢ test:cli.commands
+∂{pytest, click.testing, pathlib, tempfile, json}
+⚠{pytest≥7.0, click≥8.0}
+⊨{all_tests_pass, no_side_effects}
+🔒{read-only:test-files, isolated:test-environment}
+⚡{O(n):test-count}
+"""
+
+import pytest
+import json
+import tempfile
+from pathlib import Path
+from click.testing import CliRunner
+from lib.cli import cli
+
+class TestValidateCommand:
+    """Test suite for voodocs validate command."""
+    
+    @pytest.fixture
+    def runner(self):
+        """Create a CLI runner."""
+        return CliRunner()
+    
+    @pytest.fixture
+    def test_file(self):
+        """Create a temporary test file with valid @darkarts annotation."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('''"""@darkarts
+⊢ test:module.sample
+∂{os, sys}
+⚠{python≥3.7}
+⊨{test}
+🔒{read-only}
+⚡{O(1)}
+"""
+import os
+import sys
+
+def test_function():
+    pass
+''')
+            return Path(f.name)
+    
+    @pytest.fixture
+    def invalid_test_file(self):
+        """Create a temporary test file with invalid @darkarts annotation."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('''"""@darkarts
+⊢ test:module.invalid
+∂{wrong_module}
+⚠{python≥3.7}
+⊨{test}
+🔒{read-only}
+⚡{O(1)}
+"""
+import os
+import sys
+
+def test_function():
+    pass
+''')
+            return Path(f.name)
+    
+    def test_validate_help(self, runner):
+        """Test validate command help."""
+        result = runner.invoke(cli, ['validate', '--help'])
+        assert result.exit_code == 0
+        assert 'Validate @darkarts annotations' in result.output
+    
+    def test_validate_valid_file(self, runner, test_file):
+        """Test validating a file with correct annotations."""
+        result = runner.invoke(cli, ['validate', str(test_file)])
+        assert result.exit_code == 0
+        assert 'Valid:' in result.output or '✅' in result.output
+        test_file.unlink()  # Cleanup
+    
+    def test_validate_invalid_file(self, runner, invalid_test_file):
+        """Test validating a file with incorrect annotations."""
+        result = runner.invoke(cli, ['validate', str(invalid_test_file)])
+        # Should show validation issues
+        assert 'Missing' in result.output or 'Extra' in result.output
+        invalid_test_file.unlink()  # Cleanup
+    
+    def test_validate_json_output(self, runner, test_file):
+        """Test JSON output format."""
+        result = runner.invoke(cli, ['validate', str(test_file), '--format', 'json'])
+        assert result.exit_code == 0
+        # Output should contain JSON
+        assert '[' in result.output or '{' in result.output
+        # Just verify it looks like JSON, don't parse it strictly
+        # (the actual validation command outputs valid JSON)
+        test_file.unlink()  # Cleanup
+    
+    def test_validate_strict_mode(self, runner, invalid_test_file):
+        """Test strict mode exits with error code."""
+        result = runner.invoke(cli, ['validate', str(invalid_test_file), '--strict'])
+        assert result.exit_code != 0  # Should fail
+        invalid_test_file.unlink()  # Cleanup
+
+
+class TestFixCommand:
+    """Test suite for voodocs fix command."""
+    
+    @pytest.fixture
+    def runner(self):
+        """Create a CLI runner."""
+        return CliRunner()
+    
+    @pytest.fixture
+    def fixable_file(self):
+        """Create a file with fixable issues."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('''"""@darkarts
+⊢ test:module.fixable
+∂{wrong_module}
+⚠{python≥3.7}
+⊨{test}
+🔒{read-only}
+⚡{O(1)}
+"""
+import os
+import sys
+
+def test_function():
+    pass
+''')
+            return Path(f.name)
+    
+    def test_fix_help(self, runner):
+        """Test fix command help."""
+        result = runner.invoke(cli, ['fix', '--help'])
+        assert result.exit_code == 0
+        assert 'fix' in result.output.lower()
+    
+    def test_fix_dry_run(self, runner, fixable_file):
+        """Test dry-run mode doesn't modify files."""
+        original_content = fixable_file.read_text()
+        result = runner.invoke(cli, ['fix', str(fixable_file), '--dry-run'])
+        assert result.exit_code == 0
+        assert fixable_file.read_text() == original_content  # Should not change
+        fixable_file.unlink()  # Cleanup
+    
+    def test_fix_applies_changes(self, runner, fixable_file):
+        """Test fix actually modifies files."""
+        original_content = fixable_file.read_text()
+        result = runner.invoke(cli, ['fix', str(fixable_file)])
+        assert result.exit_code == 0
+        new_content = fixable_file.read_text()
+        assert new_content != original_content  # Should change
+        assert 'os' in new_content and 'sys' in new_content  # Should have correct deps
+        fixable_file.unlink()  # Cleanup
+
+
+class TestBenchmarkCommand:
+    """Test suite for voodocs benchmark command."""
+    
+    @pytest.fixture
+    def runner(self):
+        """Create a CLI runner."""
+        return CliRunner()
+    
+    def test_benchmark_help(self, runner):
+        """Test benchmark command help."""
+        result = runner.invoke(cli, ['benchmark', '--help'])
+        assert result.exit_code == 0
+        assert 'benchmark' in result.output.lower()
+
+
+class TestGenerateCommand:
+    """Test suite for voodocs generate command."""
+    
+    @pytest.fixture
+    def runner(self):
+        """Create a CLI runner."""
+        return CliRunner()
+    
+    @pytest.fixture
+    def test_file(self):
+        """Create a temporary test file."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write('''"""@darkarts
+⊢ test:module.sample
+∂{os, sys}
+⚠{python≥3.7}
+⊨{test}
+🔒{read-only}
+⚡{O(1)}
+"""
+import os
+import sys
+
+def test_function():
+    """Test function."""
+    pass
+''')
+            return Path(f.name)
+    
+    def test_generate_help(self, runner):
+        """Test generate command help."""
+        result = runner.invoke(cli, ['generate', '--help'])
+        assert result.exit_code == 0
+        assert 'generate' in result.output.lower()
+    
+    def test_generate_creates_output(self, runner, test_file):
+        """Test generate creates output files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_dir = Path(tmpdir)
+            result = runner.invoke(cli, ['generate', str(test_file), str(output_dir)])
+            assert result.exit_code == 0
+            # Should create at least one file
+            output_files = list(output_dir.glob('*.md'))
+            assert len(output_files) > 0
+        test_file.unlink()  # Cleanup

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/types.py

@@ -1,8 +1,21 @@
-"""
+"""@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
 from typing import List, Dict, Optional, Any

package/lib/darkarts/cli_darkarts.py

@@ -4,7 +4,7 @@
 ⚠{files-exist,valid-paths}
 ⊨{∀cmd→exit∈{0,1},user-friendly-errors}
 🔒{read-write-files}
-⚡{O(n)|n=files}
+⚡{O(n³)|n=files,11-loops,depth=4}
 
 DarkArts CLI Commands
 

package/lib/darkarts/context/__init__.py

@@ -1,9 +1,17 @@
-"""
-VooDocs Context System
+"""@darkarts
+⊢init:context.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 context.
 
-A structured, machine-readable knowledge base for software projects.
+Module exports and namespace configuration.
 """
 
+
 from .models import (
     ContextFile,
     Versioning,