@voodocs/cli 0.1.0

package/examples/test_math_example.py

@@ -0,0 +1,186 @@
+"""
+Automated tests for math_example
+Generated from @voodocs annotations
+"""
+
+import pytest
+from hypothesis import given, strategies as st, assume
+from hypothesis import settings, HealthCheck
+from math_example import *
+
+
+class TestAddPositive:
+    """Tests for add_positive()"""
+
+    @given(x=st.integers(min_value=1), y=st.integers(min_value=1))
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    def test_property_based_add_positive(self, x, y):
+        """Property-based test for add_positive()"""
+        # Assume preconditions hold
+        assume(x > 0)
+        assume(y > 0)
+        result = add_positive(x, y)
+        # Assert postconditions
+
+    def test_precondition_enforcement(self):
+        """Test that add_positive() enforces its preconditions"""
+        # Precondition 1: x > 0
+        # Test violation: add_positive(x=0)
+        # Precondition 2: y > 0
+        # Test violation: add_positive(y=0)
+        # TODO: Implement specific precondition violation tests
+        pass
+
+    def test_postconditions_hold(self):
+        """Test that postconditions hold after add_positive() executes"""
+        # Postcondition 1: result > x
+        # Postcondition 2: result > y
+        # TODO: Call function with valid inputs and verify postconditions
+        pass
+
+    def test_edge_cases(self):
+        """Test edge cases for add_positive()"""
+        # Common edge cases to consider:
+        # - Empty inputs (empty strings, empty lists, None)
+        # - Boundary values (0, -1, max int, min int)
+        # - Special values (NaN, Infinity for numbers)
+        # TODO: Implement edge case tests based on function signature
+        pass
+
+    def test_performance(self):
+        """Test performance characteristics of add_positive()"""
+        # Expected complexity: Time=O(1), Space=O(1)
+        import time
+        
+        # TODO: Implement performance test
+        # Measure execution time for various input sizes
+        # Verify it matches the expected complexity
+        pass
+
+    def test_happy_path(self):
+        """Test normal execution of add_positive()"""
+        # Ensure all preconditions are met:
+        #   - x > 0
+        #   - y > 0
+        # result = add_positive(...)  # TODO: Provide valid arguments
+        # Verify all postconditions hold:
+        #   - result > x
+        #   - result > y
+        pass
+
+class TestFactorial:
+    """Tests for factorial()"""
+
+    @given(n=st.integers(min_value=0))
+    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
+    def test_property_based_factorial(self, n):
+        """Property-based test for factorial()"""
+        # Assume preconditions hold
+        assume(n >= 0)
+        result = factorial(n)
+        # Assert postconditions
+        assert result >= 1
+
+    def test_precondition_enforcement(self):
+        """Test that factorial() enforces its preconditions"""
+        # Precondition 1: n >= 0
+        # TODO: Implement specific precondition violation tests
+        pass
+
+    def test_postconditions_hold(self):
+        """Test that postconditions hold after factorial() executes"""
+        # Postcondition 1: result >= 1
+        # assert result >= 1
+        # Postcondition 2: n = 0 ⇒ result = 1
+        # Postcondition 3: n > 0 ⇒ result = n * factorial(n-1)
+        # TODO: Call function with valid inputs and verify postconditions
+        pass
+
+    def test_error_case_1_n_0(self):
+        """Test error case: n < 0"""
+        with pytest.raises(ValueError):
+            # Create condition: n < 0
+            factorial(...)  # TODO: Provide arguments that trigger n < 0
+
+
+    def test_edge_cases(self):
+        """Test edge cases for factorial()"""
+        # Common edge cases to consider:
+        # - Empty inputs (empty strings, empty lists, None)
+        # - Boundary values (0, -1, max int, min int)
+        # - Special values (NaN, Infinity for numbers)
+        # TODO: Implement edge case tests based on function signature
+        pass
+
+    def test_performance(self):
+        """Test performance characteristics of factorial()"""
+        # Expected complexity: Time=O(1), Space=O(1)
+        import time
+        
+        # TODO: Implement performance test
+        # Measure execution time for various input sizes
+        # Verify it matches the expected complexity
+        pass
+
+    def test_happy_path(self):
+        """Test normal execution of factorial()"""
+        # Ensure all preconditions are met:
+        #   - n >= 0
+        # result = factorial(...)  # TODO: Provide valid arguments
+        # Verify all postconditions hold:
+        #   - result >= 1
+        #   - n = 0 ⇒ result = 1
+        #   - n > 0 ⇒ result = n * factorial(n-1)
+        pass
+
+class TestFindMax:
+    """Tests for find_max()"""
+
+    @given(st.data())
+    def test_property_based_find_max(self, data):
+        """Property-based test for find_max()"""
+        # Assume preconditions hold
+        # result = find_max(...) # TODO: Provide appropriate arguments
+        pass  # Remove this when implementing
+
+    def test_precondition_enforcement(self):
+        """Test that find_max() enforces its preconditions"""
+        # Precondition 1: len(items) > 0
+        # TODO: Implement specific precondition violation tests
+        pass
+
+    def test_postconditions_hold(self):
+        """Test that postconditions hold after find_max() executes"""
+        # Postcondition 1: result ∈ items
+        # Postcondition 2: ∀ x ∈ items: result >= x
+        # TODO: Call function with valid inputs and verify postconditions
+        pass
+
+    def test_edge_cases(self):
+        """Test edge cases for find_max()"""
+        # Common edge cases to consider:
+        # - Empty inputs (empty strings, empty lists, None)
+        # - Boundary values (0, -1, max int, min int)
+        # - Special values (NaN, Infinity for numbers)
+        # TODO: Implement edge case tests based on function signature
+        pass
+
+    def test_performance(self):
+        """Test performance characteristics of find_max()"""
+        # Expected complexity: Time=O(1), Space=O(1)
+        import time
+        
+        # TODO: Implement performance test
+        # Measure execution time for various input sizes
+        # Verify it matches the expected complexity
+        pass
+
+    def test_happy_path(self):
+        """Test normal execution of find_max()"""
+        # Ensure all preconditions are met:
+        #   - len(items) > 0
+        # result = find_max(...)  # TODO: Provide valid arguments
+        # Verify all postconditions hold:
+        #   - result ∈ items
+        #   - ∀ x ∈ items: result >= x
+        pass

package/lib/darkarts/README.md

@@ -0,0 +1,115 @@
+# DarkArts Execution Engine
+
+**An execution engine that understands and executes mathematical notation directly.**
+
+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.
+
+---
+
+## Quick Start
+
+```python
+from darkarts import execute
+
+# AI expresses in mathematical notation
+result = execute("Find max x ∈ ℤ⁺ where x² + 5x + 6 < 100")
+# → 8
+
+# Verify
+verify = execute("8² + 5(8) + 6")
+# → 110
+
+# Iterate
+result = execute("Find max x ∈ ℤ⁺ where x² + 5x + 6 < 100 and x < 8")
+# → 7
+```
+
+---
+
+## Architecture
+
+```
+darkarts/
+├── parser/          # Mathematical notation parser
+│   ├── latex.py     # LaTeX notation parser
+│   ├── unicode.py   # Unicode symbol recognizer
+│   └── natural.py   # Natural language math parser
+├── executor/        # Execution engine
+│   ├── symbolic.py  # SymPy integration
+│   ├── smt.py       # Z3 constraint solver
+│   └── router.py    # Problem type router
+├── verifier/        # Verification system
+│   ├── checker.py   # Solution verification
+│   └── feedback.py  # Error feedback
+├── tests/           # Test suite
+└── examples/        # Example problems
+```
+
+---
+
+## Core Components
+
+### 1. Parser
+Understands mathematical notation:
+- LaTeX: `x^2 + 5x + 6 < 100`
+- Unicode: `x² + 5x + 6 < 100`
+- Natural: "x squared plus 5x plus 6 less than 100"
+
+### 2. Executor
+Routes to appropriate computational tools:
+- **SymPy**: Symbolic algebra, calculus
+- **Z3**: Constraint solving, optimization
+- **NumPy/SciPy**: Numerical computation
+- **Custom**: Number theory, combinatorics, geometry
+
+### 3. Verifier
+Checks solutions and provides feedback:
+- Constraint verification
+- Counterexample generation
+- Correction suggestions
+
+---
+
+## Development Status
+
+**Current Phase**: Architecture & Parser Implementation
+
+- [x] Vision document
+- [x] Architecture design
+- [ ] Parser implementation
+- [ ] Executor implementation
+- [ ] Verifier implementation
+- [ ] AI loop integration
+- [ ] AIMO benchmark
+
+---
+
+## Documentation
+
+- [DARKARTS_VISION.md](./DARKARTS_VISION.md) - Complete vision and purpose
+- [THE_MISSING_PIECE.md](./THE_MISSING_PIECE.md) - Discovery of the execution gap
+- [PATTERN_ANALYSIS.md](./PATTERN_ANALYSIS.md) - AI's natural language analysis
+
+---
+
+## Benchmark: AIMO
+
+**Target**: 60%+ accuracy on AI Mathematical Olympiad problems
+
+**Method**: AI expresses solutions in mathematical notation, DarkArts executes
+
+**Baseline**: 
+- AI + Python: ~40% (with fine-tuning)
+- AI + DarkArts: TBD
+
+---
+
+## License
+
+Proprietary - See parent repository
+
+---
+
+**Status**: Active Development  
+**Version**: 0.1.0-alpha  
+**Last Updated**: December 2025

package/lib/darkarts/__init__.py

@@ -0,0 +1,16 @@
+"""
+DarkArts: An execution engine for mathematical notation.
+
+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.
+"""
+
+__version__ = "0.1.0-alpha"
+__author__ = "Vooodooo"
+
+# Main API will be exposed here once implemented
+# from .parser import parse
+# from .executor import execute
+# from .verifier import verify
+# from .loop import ai_loop

package/lib/darkarts/annotations/__init__.py

@@ -0,0 +1,34 @@
+"""
+DarkArts Annotations
+
+AI-native code documentation system using mathematical and logical notation.
+"""
+
+from .types import (
+    ParsedAnnotations,
+    ModuleAnnotation,
+    ClassAnnotation,
+    FunctionAnnotation,
+    ComplexityAnnotation,
+    ErrorCase,
+    StateTransition,
+    Language,
+    AnnotationType,
+    VerificationResult,
+)
+
+from .parser import AnnotationParser
+
+__all__ = [
+    'ParsedAnnotations',
+    'ModuleAnnotation',
+    'ClassAnnotation',
+    'FunctionAnnotation',
+    'ComplexityAnnotation',
+    'ErrorCase',
+    'StateTransition',
+    'Language',
+    'AnnotationType',
+    'VerificationResult',
+    'AnnotationParser',
+]