@voodocs/cli 0.4.2 → 1.0.1

package/lib/darkarts/validation/types.py

@@ -0,0 +1,97 @@
+"""@darkarts
+⊢validation:types
+∂{dataclasses,typing}
+⚠{python≥3.7}
+⊨{∀type→immutable,∀result→serializable}
+🔒{read-only:dataclasses}
+⚡{O(1):creation}
+"""
+
+"""
+Shared type definitions for validation module.
+"""
+
+from dataclasses import dataclass, field
+from typing import Set, List, Dict, Optional, Any
+
+
+@dataclass
+class ValidationResult:
+    """Result of semantic validation."""
+    file_path: str
+    is_valid: bool
+    missing_deps: Set[str] = field(default_factory=set)
+    extra_deps: Set[str] = field(default_factory=set)
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    suggestions: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "file_path": self.file_path,
+            "is_valid": self.is_valid,
+            "missing_deps": list(self.missing_deps),
+            "extra_deps": list(self.extra_deps),
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "suggestions": self.suggestions,
+        }
+
+
+@dataclass
+class PerformanceResult:
+    """Result of performance validation."""
+    file_path: str
+    is_valid: bool
+    claimed_complexity: str
+    actual_complexity: str
+    loop_count: int
+    max_depth: int
+    has_recursion: bool
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    suggestions: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "file_path": self.file_path,
+            "is_valid": self.is_valid,
+            "claimed_complexity": self.claimed_complexity,
+            "actual_complexity": self.actual_complexity,
+            "loop_count": self.loop_count,
+            "max_depth": self.max_depth,
+            "has_recursion": self.has_recursion,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "suggestions": self.suggestions,
+        }
+
+
+@dataclass
+class BenchmarkResult:
+    """Result of performance benchmarking."""
+    function_name: str
+    input_sizes: List[int]
+    execution_times: List[float]
+    claimed_complexity: str
+    fitted_complexity: str
+    is_valid: bool
+    confidence: float
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "function_name": self.function_name,
+            "input_sizes": self.input_sizes,
+            "execution_times": self.execution_times,
+            "claimed_complexity": self.claimed_complexity,
+            "fitted_complexity": self.fitted_complexity,
+            "is_valid": self.is_valid,
+            "confidence": self.confidence,
+            "errors": self.errors,
+            "warnings": self.warnings,
+        }

package/lib/darkarts/validation/watch.py

@@ -0,0 +1,239 @@
+"""@darkarts
+⊢watch:validation.continuous-monitoring
+∂{time,pathlib,typing,hashlib,semantic_validator}
+⚠{python≥3.7,filesystem:accessible}
+⊨{∀change→validated,∀error→reported,continuous:non-blocking,responsive:sub-second}
+🔒{read-only:files,¬write,¬network,¬exec}
+⚡{O(n²):per-check|n=watched-files,hash-based:change-detection}
+
+Watch Mode for Continuous Validation
+
+Monitors files for changes and validates annotations in real-time with:
+- File system monitoring (efficient hash-based change detection)
+- Instant validation (validates on save)
+- Live feedback (immediate error reporting)
+- Selective watching (specific files or directories)
+- Debouncing (prevents validation spam)
+- Background operation (non-blocking)
+"""
+
+import time
+import hashlib
+from pathlib import Path
+from typing import Dict, Set, Optional, Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from semantic_validator import validate_file, ValidationResult
+
+
+@dataclass
+class FileState:
+    """State of a monitored file."""
+    path: Path
+    hash: str
+    last_validated: datetime
+    last_result: Optional[ValidationResult] = None
+
+
+class FileWatcher:
+    """Watches Python files for changes and validates annotations."""
+    
+    def __init__(
+        self,
+        paths: Set[Path],
+        interval: float = 1.0,
+        on_change: Optional[Callable[[Path, ValidationResult], None]] = None,
+        debounce: float = 0.5
+    ):
+        """
+        Initialize the file watcher.
+        
+        Args:
+            paths: Set of file or directory paths to watch
+            interval: Check interval in seconds (default: 1.0)
+            on_change: Callback function called when a file changes
+            debounce: Minimum time between validations of the same file
+        """
+        self.paths = paths
+        self.interval = interval
+        self.on_change = on_change
+        self.debounce = debounce
+        
+        self.file_states: Dict[Path, FileState] = {}
+        self.running = False
+        
+        # Initialize file states
+        self._discover_files()
+    
+    def _discover_files(self):
+        """Discover all Python files in the watched paths."""
+        for path in self.paths:
+            if path.is_file() and path.suffix == '.py':
+                self._add_file(path)
+            elif path.is_dir():
+                for py_file in path.rglob("*.py"):
+                    if not py_file.name.startswith('.'):
+                        self._add_file(py_file)
+    
+    def _add_file(self, file_path: Path):
+        """Add a file to the watch list."""
+        if file_path not in self.file_states:
+            file_hash = self._compute_hash(file_path)
+            self.file_states[file_path] = FileState(
+                path=file_path,
+                hash=file_hash,
+                last_validated=datetime.now()
+            )
+    
+    def _compute_hash(self, file_path: Path) -> str:
+        """Compute SHA256 hash of a file."""
+        try:
+            content = file_path.read_bytes()
+            return hashlib.sha256(content).hexdigest()
+        except Exception:
+            return ""
+    
+    def _check_file(self, file_path: Path) -> Optional[ValidationResult]:
+        """
+        Check if a file has changed and validate if needed.
+        
+        Args:
+            file_path: Path to the file
+        
+        Returns:
+            ValidationResult if file changed and was validated, None otherwise
+        """
+        if not file_path.exists():
+            # File was deleted
+            if file_path in self.file_states:
+                del self.file_states[file_path]
+            return None
+        
+        current_hash = self._compute_hash(file_path)
+        state = self.file_states.get(file_path)
+        
+        if state is None:
+            # New file discovered
+            self._add_file(file_path)
+            state = self.file_states[file_path]
+        
+        # Check if file changed
+        if current_hash != state.hash:
+            # Check debounce
+            time_since_last = (datetime.now() - state.last_validated).total_seconds()
+            if time_since_last < self.debounce:
+                return None
+            
+            # File changed - validate it
+            try:
+                result = validate_file(file_path)
+                
+                # Update state
+                state.hash = current_hash
+                state.last_validated = datetime.now()
+                state.last_result = result
+                
+                return result
+            except Exception as e:
+                print(f"Error validating {file_path}: {e}")
+                return None
+        
+        return None
+    
+    def watch(self):
+        """Start watching files for changes."""
+        self.running = True
+        
+        print(f"👀 Watching {len(self.file_states)} files...")
+        print(f"   Interval: {self.interval}s")
+        print(f"   Debounce: {self.debounce}s")
+        print("   Press Ctrl+C to stop\n")
+        
+        try:
+            while self.running:
+                # Check all files
+                for file_path in list(self.file_states.keys()):
+                    result = self._check_file(file_path)
+                    
+                    if result is not None:
+                        # File changed and was validated
+                        self._report_result(file_path, result)
+                        
+                        # Call callback if provided
+                        if self.on_change:
+                            self.on_change(file_path, result)
+                
+                # Sleep before next check
+                time.sleep(self.interval)
+        
+        except KeyboardInterrupt:
+            print("\n\n⏹️  Watch stopped")
+            self.running = False
+    
+    def _report_result(self, file_path: Path, result: ValidationResult):
+        """Report validation result to console."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        
+        if result.is_valid:
+            print(f"[{timestamp}] ✅ {file_path.name}: Valid")
+        else:
+            print(f"[{timestamp}] ❌ {file_path.name}: Invalid")
+            
+            if result.missing_deps:
+                print(f"           Missing: {', '.join(sorted(result.missing_deps))}")
+            
+            if result.extra_deps:
+                print(f"           Extra: {', '.join(sorted(result.extra_deps))}")
+            
+            if result.suggestions:
+                for suggestion in result.suggestions[:2]:  # Show first 2 suggestions
+                    print(f"           💡 {suggestion}")
+        
+        print()
+    
+    def stop(self):
+        """Stop watching files."""
+        self.running = False
+
+
+def watch_with_autofix(
+    paths: Set[Path],
+    interval: float = 1.0,
+    auto_fix: bool = False
+):
+    """
+    Watch files and optionally auto-fix on change.
+    
+    Args:
+        paths: Set of paths to watch
+        interval: Check interval in seconds
+        auto_fix: Whether to automatically fix invalid annotations
+    """
+    if auto_fix:
+        from autofix import AutoFixer
+        fixer = AutoFixer(dry_run=False)
+        
+        def on_change_callback(file_path: Path, result: ValidationResult):
+            if not result.is_valid:
+                print(f"   🔧 Auto-fixing {file_path.name}...")
+                fix_result = fixer.fix_file(file_path)
+                if fix_result.success:
+                    print(f"   ✅ Fixed!")
+                else:
+                    print(f"   ❌ Fix failed: {fix_result.error}")
+                print()
+        
+        watcher = FileWatcher(
+            paths=paths,
+            interval=interval,
+            on_change=on_change_callback
+        )
+    else:
+        watcher = FileWatcher(paths=paths, interval=interval)
+    
+    watcher.watch()
+
+
+
+# CLI interface removed - use darkarts.validation API or voodocs CLI instead

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@voodocs/cli",
-  "version": "0.4.2",
-  "description": "AI-Native Documentation System - Generate docs, tests, and API specs from @voodocs annotations using the DarkArts language",
-  "main": "cli.py",
+  "version": "1.0.1",
+  "description": "AI-Native Documentation System with Validation - The only documentation tool that validates your annotations and guarantees accuracy",
+  "main": "voodocs_cli.py",
   "bin": {
-    "voodocs": "./cli.py"
+    "voodocs": "./voodocs_cli.py"
   },
   "scripts": {
     "postinstall": "cd lib/darkarts/parsers/typescript && npm install && npm run build",
@@ -13,6 +13,7 @@
   },
   "keywords": [
     "documentation",
+    "validation",
     "ai",
     "voodocs",
     "darkarts",
@@ -24,7 +25,13 @@
     "cursor",
     "claude",
     "property-based-testing",
-    "hypothesis"
+    "hypothesis",
+    "annotation-validation",
+    "semantic-validation",
+    "performance-validation",
+    "benchmarking",
+    "auto-fix",
+    "ci-cd"
   ],
   "author": "3vilEnterprises <contact@3vil.enterprises>",
   "license": "Commercial",
@@ -44,11 +51,13 @@
   "dependencies": {},
   "devDependencies": {},
   "files": [
-    "cli.py",
+    "voodocs_cli.py",
+    "lib/cli/",
     "lib/darkarts/cli_darkarts.py",
     "lib/darkarts/annotations/",
     "lib/darkarts/context/",
     "lib/darkarts/core/",
+    "lib/darkarts/validation/",
     "lib/darkarts/exceptions.py",
     "lib/darkarts/telemetry.py",
     "lib/darkarts/parsers/typescript/dist/",
@@ -58,6 +67,9 @@
     "lib/darkarts/parsers/typescript/tsconfig.json",
     "lib/darkarts/plugins/voodocs/",
     "lib/darkarts/__init__.py",
+    "docs/darkarts/USER_GUIDE.md",
+    "docs/darkarts/API_REFERENCE.md",
+    "docs/darkarts/TUTORIALS.md",
     "examples/",
     "templates/",
     "README.md",
@@ -65,6 +77,7 @@
     "USAGE.md",
     "PRIVACY.md",
     "CHANGELOG.md",
+    "RELEASE_NOTES_v1.0.0.md",
     "requirements.txt"
   ],
   "os": [

package/voodocs_cli.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""@darkarts
+⊢voodocs:cli.entry
+∂{sys,pathlib}
+⚠{python≥3.7}
+⊨{∀command→executable}
+🔒{read-only:cli-entry}
+⚡{O(1):startup}
+"""
+
+"""
+VooDocs CLI Entry Point
+
+This is the main entry point for the voodocs command-line tool.
+"""
+
+import sys
+from pathlib import Path
+
+# Add lib to path
+lib_path = Path(__file__).parent / "lib"
+sys.path.insert(0, str(lib_path))
+
+# Import and run CLI
+from cli import main
+
+if __name__ == "__main__":
+    main()