@voodocs/cli 0.1.0

package/lib/darkarts/annotations/types.py

@@ -0,0 +1,181 @@
+"""
+DarkArts Annotation Types
+
+Data structures for representing parsed DarkArts annotations.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Any
+from enum import Enum
+
+
+class AnnotationType(Enum):
+    """Types of annotations supported."""
+    FUNCTION = "function"
+    METHOD = "method"
+    CLASS = "class"
+    MODULE = "module"
+
+
+class Language(Enum):
+    """Supported programming languages."""
+    PYTHON = "python"
+    TYPESCRIPT = "typescript"
+    JAVASCRIPT = "javascript"
+    JAVA = "java"
+    CPP = "cpp"
+    CSHARP = "csharp"
+    GO = "go"
+    RUST = "rust"
+
+
+@dataclass
+class ComplexityAnnotation:
+    """Complexity annotations."""
+    time: str = "O(1)"
+    space: str = "O(1)"
+    best_case: Optional[str] = None
+    worst_case: Optional[str] = None
+    average_case: Optional[str] = None
+
+
+@dataclass
+class StateTransition:
+    """State transition annotation."""
+    from_state: str
+    to_state: str
+    condition: Optional[str] = None
+    
+    def __str__(self) -> str:
+        if self.condition:
+            return f"{self.from_state} → {self.to_state}: {self.condition}"
+        return f"{self.from_state} → {self.to_state}"
+
+
+@dataclass
+class ErrorCase:
+    """Error case annotation."""
+    condition: str
+    error_type: str
+    
+    def __str__(self) -> str:
+        return f"{self.condition} → {self.error_type}"
+
+
+@dataclass
+class FunctionAnnotation:
+    """Annotations for a function or method."""
+    name: str
+    solve: Optional[str] = None
+    preconditions: List[str] = field(default_factory=list)
+    postconditions: List[str] = field(default_factory=list)
+    invariants: List[str] = field(default_factory=list)
+    optimize: Optional[str] = None
+    complexity: Optional[ComplexityAnnotation] = None
+    error_cases: List[ErrorCase] = field(default_factory=list)
+    side_effects: List[str] = field(default_factory=list)
+    
+    # Source location
+    line_number: int = 0
+    source_file: str = ""
+    
+    # Raw annotation text
+    raw_annotation: str = ""
+
+
+@dataclass
+class ClassAnnotation:
+    """Annotations for a class."""
+    name: str
+    class_invariants: List[str] = field(default_factory=list)
+    state_transitions: List[StateTransition] = field(default_factory=list)
+    
+    # Methods in this class
+    methods: List[FunctionAnnotation] = field(default_factory=list)
+    
+    # Source location
+    line_number: int = 0
+    source_file: str = ""
+    
+    # Raw annotation text
+    raw_annotation: str = ""
+
+
+@dataclass
+class ModuleAnnotation:
+    """Annotations for a module/file."""
+    name: str
+    module_purpose: Optional[str] = None
+    dependencies: List[str] = field(default_factory=list)
+    assumptions: List[str] = field(default_factory=list)
+    
+    # Classes and functions in this module
+    classes: List[ClassAnnotation] = field(default_factory=list)
+    functions: List[FunctionAnnotation] = field(default_factory=list)
+    
+    # Source file
+    source_file: str = ""
+    language: Language = Language.PYTHON
+
+
+@dataclass
+class ParsedAnnotations:
+    """Complete set of parsed annotations from a source file."""
+    module: ModuleAnnotation
+    language: Language
+    source_file: str
+    
+    def get_all_functions(self) -> List[FunctionAnnotation]:
+        """Get all function annotations (module-level and class methods)."""
+        functions = list(self.module.functions)
+        for cls in self.module.classes:
+            functions.extend(cls.methods)
+        return functions
+    
+    def get_all_classes(self) -> List[ClassAnnotation]:
+        """Get all class annotations."""
+        return self.module.classes
+    
+    def has_annotations(self) -> bool:
+        """Check if any annotations were found."""
+        return (
+            bool(self.module.module_purpose) or
+            bool(self.module.dependencies) or
+            bool(self.module.assumptions) or
+            bool(self.module.classes) or
+            bool(self.module.functions)
+        )
+
+
+@dataclass
+class VerificationResult:
+    """Result of annotation verification."""
+    valid: bool
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    
+    def add_error(self, error: str):
+        """Add an error."""
+        self.errors.append(error)
+        self.valid = False
+    
+    def add_warning(self, warning: str):
+        """Add a warning."""
+        self.warnings.append(warning)
+    
+    def __str__(self) -> str:
+        if self.valid and not self.warnings:
+            return "✓ All annotations are valid"
+        
+        result = []
+        if self.errors:
+            result.append(f"❌ {len(self.errors)} error(s):")
+            for error in self.errors:
+                result.append(f"  - {error}")
+        
+        if self.warnings:
+            result.append(f"⚠️  {len(self.warnings)} warning(s):")
+            for warning in self.warnings:
+                result.append(f"  - {warning}")
+        
+        return "\n".join(result)

package/lib/darkarts/cli.py

@@ -0,0 +1,128 @@
+"""
+Command-line interface for DarkArts.
+"""
+
+import sys
+import argparse
+from pathlib import Path
+from darkarts.core import DarkArts
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="DarkArts - General-purpose AI reasoning platform",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Solve a math problem
+  darkarts solve "Solve x^2 + 5x + 6 = 0" --plugin math
+  
+  # Generate code documentation
+  darkarts solve myfile.py --plugin voodocs --file
+  
+  # Auto-detect plugin
+  darkarts solve "Find the largest n where n^2 < 100"
+  
+  # List available plugins
+  darkarts list
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+    
+    # Solve command
+    solve_parser = subparsers.add_parser("solve", help="Solve a problem")
+    solve_parser.add_argument("input", help="Problem text or file path")
+    solve_parser.add_argument("--plugin", "-p", help="Plugin to use (auto-detect if not specified)")
+    solve_parser.add_argument("--file", "-f", action="store_true", help="Treat input as file path")
+    solve_parser.add_argument("--explain", "-e", action="store_true", help="Generate explanation")
+    solve_parser.add_argument("--level", "-l", default="student", 
+                            choices=["student", "teacher", "expert"],
+                            help="Explanation level")
+    solve_parser.add_argument("--output", "-o", help="Output file path")
+    
+    # List command
+    list_parser = subparsers.add_parser("list", help="List available plugins")
+    
+    # Parse arguments
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        return 1
+    
+    # Initialize DarkArts
+    da = DarkArts()
+    
+    if args.command == "list":
+        return list_plugins(da)
+    
+    elif args.command == "solve":
+        return solve_problem(da, args)
+    
+    return 0
+
+
+def list_plugins(da: DarkArts) -> int:
+    """List available plugins."""
+    print("Available Plugins:")
+    print("=" * 60)
+    
+    for plugin in da.list_plugins():
+        print(f"\n{plugin.name} v{plugin.version}")
+        print(f"  {plugin.description}")
+        print(f"  Capabilities: {', '.join(plugin.capabilities)}")
+        if plugin.dependencies:
+            print(f"  Dependencies: {', '.join(plugin.dependencies)}")
+    
+    print()
+    return 0
+
+
+def solve_problem(da: DarkArts, args) -> int:
+    """Solve a problem."""
+    # Get input
+    if args.file:
+        try:
+            input_text = Path(args.input).read_text()
+        except Exception as e:
+            print(f"Error reading file: {e}", file=sys.stderr)
+            return 1
+    else:
+        input_text = args.input
+    
+    # Solve
+    try:
+        result = da.solve(input_text, plugin=args.plugin)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    
+    if not result.success:
+        print(f"Failed: {result.error}", file=sys.stderr)
+        return 1
+    
+    # Output result
+    output_text = str(result.result)
+    
+    if args.explain:
+        explanation = da.explain(result, level=args.level, plugin=args.plugin)
+        output_text = f"{output_text}\n\n{'=' * 60}\nExplanation:\n{'=' * 60}\n\n{explanation}"
+    
+    # Write output
+    if args.output:
+        try:
+            Path(args.output).write_text(output_text)
+            print(f"Output written to: {args.output}")
+        except Exception as e:
+            print(f"Error writing output: {e}", file=sys.stderr)
+            return 1
+    else:
+        print(output_text)
+    
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/darkarts/core/__init__.py

@@ -0,0 +1,32 @@
+"""
+DarkArts Core - Domain-agnostic reasoning engine.
+"""
+
+from .plugin import (
+    DarkArtsPlugin,
+    PluginMetadata,
+    PluginInput,
+    PluginOutput,
+    PluginCapability,
+    ParseError,
+    ExecutionError,
+    PluginError,
+)
+from .registry import PluginRegistry, get_global_registry
+from .loader import PluginLoader
+from .interface import DarkArts
+
+__all__ = [
+    "DarkArtsPlugin",
+    "PluginMetadata",
+    "PluginInput",
+    "PluginOutput",
+    "PluginCapability",
+    "ParseError",
+    "ExecutionError",
+    "PluginError",
+    "PluginRegistry",
+    "get_global_registry",
+    "PluginLoader",
+    "DarkArts",
+]

package/lib/darkarts/core/interface.py

@@ -0,0 +1,256 @@
+"""
+Unified interface to the DarkArts platform.
+"""
+
+from typing import Any, Dict, List, Optional
+from .plugin import DarkArtsPlugin, PluginInput, PluginOutput, PluginMetadata, PluginError
+from .registry import PluginRegistry, get_global_registry
+from .loader import PluginLoader
+
+
+class DarkArts:
+    """Unified interface to DarkArts platform."""
+    
+    def __init__(self, plugin: Optional[str] = None, registry: Optional[PluginRegistry] = None):
+        """
+        Initialize DarkArts interface.
+        
+        Args:
+            plugin: Optional default plugin name
+            registry: Optional custom registry (uses global if not provided)
+        """
+        self.registry = registry or get_global_registry()
+        self.loader = PluginLoader(self.registry)
+        self.default_plugin = plugin
+        
+        # Try to load built-in plugins if registry is empty
+        if len(self.registry) == 0:
+            try:
+                self.loader.load_and_register_builtin()
+            except Exception:
+                pass  # Silently fail if no built-in plugins available
+    
+    def solve(self, problem: str, plugin: Optional[str] = None, **options) -> PluginOutput:
+        """
+        Solve a problem using specified or default plugin.
+        
+        Args:
+            problem: The problem to solve
+            plugin: Optional plugin name (uses default if not provided)
+            **options: Additional options to pass to the plugin
+            
+        Returns:
+            Plugin output with results
+            
+        Raises:
+            PluginError: If plugin not found or execution fails
+        """
+        plugin_name = plugin or self.default_plugin
+        
+        if not plugin_name:
+            # Try to auto-detect plugin
+            plugin_name = self._auto_detect_plugin(problem)
+        
+        if not plugin_name:
+            raise PluginError("No plugin specified and auto-detection failed")
+        
+        plugin_obj = self.registry.get(plugin_name)
+        
+        if not plugin_obj:
+            raise PluginError(f"Plugin '{plugin_name}' not found")
+        
+        # Create input
+        input_obj = PluginInput(content=problem, options=options)
+        
+        # Validate input
+        if not plugin_obj.validate_input(input_obj):
+            return PluginOutput(
+                success=False,
+                result=None,
+                error="Invalid input",
+            )
+        
+        # Preprocess
+        input_obj = plugin_obj.preprocess(input_obj)
+        
+        try:
+            # Execute pipeline
+            parsed = plugin_obj.parse(input_obj)
+            analysis = plugin_obj.analyze(parsed)
+            output = plugin_obj.execute(parsed, analysis)
+            
+            # Postprocess
+            output = plugin_obj.postprocess(output)
+            
+            # Learn from execution
+            if plugin_obj.is_learning_enabled():
+                plugin_obj.learn(input_obj, output)
+            
+            return output
+            
+        except Exception as e:
+            return PluginOutput(
+                success=False,
+                result=None,
+                error=str(e),
+            )
+    
+    def explain(self, result: PluginOutput, level: str = "student", 
+                plugin: Optional[str] = None) -> str:
+        """
+        Generate explanation for a result.
+        
+        Args:
+            result: The result to explain
+            level: Explanation level (student, teacher, expert)
+            plugin: Optional plugin name (uses default if not provided)
+            
+        Returns:
+            Natural language explanation
+            
+        Raises:
+            PluginError: If plugin not found
+        """
+        plugin_name = plugin or self.default_plugin
+        
+        if not plugin_name:
+            raise PluginError("No plugin specified")
+        
+        plugin_obj = self.registry.get(plugin_name)
+        
+        if not plugin_obj:
+            raise PluginError(f"Plugin '{plugin_name}' not found")
+        
+        return plugin_obj.explain(result, level)
+    
+    def list_plugins(self) -> List[PluginMetadata]:
+        """
+        List all available plugins.
+        
+        Returns:
+            List of plugin metadata
+        """
+        return self.registry.list()
+    
+    def get_plugin(self, name: str) -> Optional[DarkArtsPlugin]:
+        """
+        Get a plugin by name.
+        
+        Args:
+            name: Plugin name
+            
+        Returns:
+            The plugin, or None if not found
+        """
+        return self.registry.get(name)
+    
+    def has_plugin(self, name: str) -> bool:
+        """
+        Check if a plugin is available.
+        
+        Args:
+            name: Plugin name
+            
+        Returns:
+            True if available, False otherwise
+        """
+        return self.registry.has_plugin(name)
+    
+    def register_plugin(self, plugin: DarkArtsPlugin) -> None:
+        """
+        Register a new plugin.
+        
+        Args:
+            plugin: The plugin to register
+            
+        Raises:
+            PluginError: If registration fails
+        """
+        self.registry.register(plugin)
+    
+    def load_plugin(self, source: str, source_type: str = "module") -> DarkArtsPlugin:
+        """
+        Load and register a plugin.
+        
+        Args:
+            source: Module path, file path, or directory path
+            source_type: Type of source ('module', 'file', or 'directory')
+            
+        Returns:
+            The loaded plugin (or list of plugins for directory)
+            
+        Raises:
+            PluginError: If loading fails
+        """
+        return self.loader.load_and_register(source, source_type)
+    
+    def set_default_plugin(self, name: str) -> None:
+        """
+        Set the default plugin.
+        
+        Args:
+            name: Plugin name
+            
+        Raises:
+            PluginError: If plugin not found
+        """
+        if not self.registry.has_plugin(name):
+            raise PluginError(f"Plugin '{name}' not found")
+        
+        self.default_plugin = name
+    
+    def enable_learning(self, plugin: Optional[str] = None, enabled: bool = True) -> None:
+        """
+        Enable or disable learning for a plugin.
+        
+        Args:
+            plugin: Optional plugin name (applies to default if not provided)
+            enabled: Whether to enable learning
+            
+        Raises:
+            PluginError: If plugin not found
+        """
+        plugin_name = plugin or self.default_plugin
+        
+        if not plugin_name:
+            raise PluginError("No plugin specified")
+        
+        plugin_obj = self.registry.get(plugin_name)
+        
+        if not plugin_obj:
+            raise PluginError(f"Plugin '{plugin_name}' not found")
+        
+        plugin_obj.enable_learning(enabled)
+    
+    def _auto_detect_plugin(self, problem: str) -> Optional[str]:
+        """
+        Auto-detect which plugin to use based on problem content.
+        
+        Args:
+            problem: The problem text
+            
+        Returns:
+            Plugin name, or None if detection fails
+        """
+        # Simple heuristics for now
+        problem_lower = problem.lower()
+        
+        # Check for math keywords
+        math_keywords = ["solve", "maximize", "minimize", "find", "calculate", "compute"]
+        if any(keyword in problem_lower for keyword in math_keywords):
+            if self.registry.has_plugin("math"):
+                return "math"
+        
+        # Check for code keywords
+        code_keywords = ["def ", "class ", "import ", "function", "method"]
+        if any(keyword in problem_lower for keyword in code_keywords):
+            if self.registry.has_plugin("voodocs"):
+                return "voodocs"
+        
+        # Default to math if available
+        if self.registry.has_plugin("math"):
+            return "math"
+        
+        # Return first available plugin
+        plugins = self.registry.list_names()
+        return plugins[0] if plugins else None