algomath-extract 1.0.0

package/src/workflows/extract.py

@@ -0,0 +1,181 @@
+"""Extraction workflow for AlgoMath."""
+
+from typing import Dict, List, Optional, Any
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+# Import extraction components
+from src.extraction.llm_extraction import HybridExtractor
+from src.extraction.review import ReviewInterface
+from src.extraction.schema import algorithm_to_json
+
+
+def show_progress(phase: str, current: int, total: int) -> str:
+    """
+    Generate a progress bar string.
+
+    Args:
+        phase: Name of the current phase
+        current: Current step number
+        total: Total number of steps
+
+    Returns:
+        Formatted progress bar string
+
+    Example:
+    >>> show_progress("Extract", 8, 10)
+    "Extract: ████████░░ 80%"
+    """
+    if total <= 0:
+        return f"{phase}: ░░░░░░░░░░ 0%"
+
+    filled = int(10 * current / total)
+    filled = max(0, min(filled, 10))  # Clamp to 0-10 range
+    bar = '█' * filled + '░' * (10 - filled)
+    pct = int(100 * current / total)
+    return f"{phase}: {bar} {pct}%"
+
+
+def run_extraction(
+    context: Any,
+    text: Optional[str] = None,
+    name: Optional[str] = None,
+    skip_review: bool = False
+) -> Dict[str, Any]:
+    """
+    Run the extraction workflow with hybrid extraction.
+
+    Per EXT-01, EXT-02, EXT-03, EXT-04, EXT-05, EXT-06.
+    """
+    # Import here to avoid circular imports
+    from algomath.context import ContextManager
+    from algomath.state import WorkflowState
+
+    # Progress: Parsing
+    progress = show_progress("Extract", 1, 5)
+
+    # Check if we have algorithm text
+    if text is None:
+        return {
+            'status': 'needs_input',
+            'progress': progress,
+            'message': 'Please provide algorithm text to extract',
+            'next_steps': [
+                'Provide algorithm text',
+                'Cancel extraction'
+            ]
+        }
+
+    # Save text to context
+    context.save_text(text)
+
+    # Progress: Extracting
+    progress = show_progress("Extract", 2, 5)
+
+    # Run hybrid extraction
+    extractor = HybridExtractor()
+    result = extractor.extract(text, prefer_llm=True)
+
+    if not result.success:
+        return {
+            'status': 'extraction_failed',
+            'progress': progress,
+            'errors': result.errors,
+            'message': 'Failed to extract algorithm from text',
+            'next_steps': [
+                'Try again with clearer text',
+                'Cancel extraction'
+            ]
+        }
+
+    # Progress: Structuring
+    progress = show_progress("Extract", 3, 5)
+
+    # Convert steps to JSON-serializable format
+    algorithm = result.algorithm
+    steps_data = []
+    for step in algorithm.steps:
+        steps_data.append({
+            'id': step.id,
+            'type': step.type.value,
+            'description': step.description,
+            'inputs': step.inputs,
+            'outputs': step.outputs,
+            'line_refs': step.line_refs,
+            'condition': step.condition,
+            'body': step.body,
+            'else_body': step.else_body,
+            'iter_var': step.iter_var,
+            'iter_range': step.iter_range,
+            'expression': step.expression,
+            'call_target': step.call_target,
+            'arguments': step.arguments,
+            'annotation': step.annotation
+        })
+
+    # Prepare review interface
+    review = ReviewInterface(algorithm)
+
+    # Progress: Validating
+    progress = show_progress("Extract", 4, 5)
+
+    if skip_review:
+        # Auto-approve
+        context.save_steps(steps_data)
+    else:
+        # Return for review
+        context.save_steps(steps_data)  # Save tentative steps
+
+        return {
+            'status': 'needs_review',
+            'progress': progress,
+            'algorithm': {
+                'name': algorithm.name,
+                'inputs': algorithm.inputs,
+                'outputs': algorithm.outputs,
+                'steps': steps_data
+            },
+            'review_interface': review,
+            'method': result.method,
+            'message': 'Algorithm extracted. Please review before proceeding.',
+            'next_steps': [
+                'Review and approve extracted steps',
+                'Edit steps if needed',
+                'Regenerate with clearer text'
+            ]
+        }
+
+    # Progress: Complete
+    progress = show_progress("Extract", 5, 5)
+
+    return {
+        'status': 'extraction_complete',
+        'progress': progress,
+        'steps_extracted': len(steps_data),
+        'algorithm_name': algorithm.name or (name if name else 'unnamed'),
+        'method': result.method,
+        'next_steps': [
+            'Generate code with /algo-generate',
+            'Review extracted steps: /algo-status',
+            'Extract a different algorithm: /algo-extract'
+        ]
+    }
+
+
+def get_progress_bar(step: int, total: int) -> str:
+    """
+    Generate progress bar string: Extract: ████████░░ 80%
+
+    Args:
+        step: Current step
+        total: Total steps
+
+    Returns:
+        Progress bar string
+    """
+    return show_progress("Extract", step, total)

package/src/workflows/generate.py

@@ -0,0 +1,155 @@
+"""
+Generation workflow for AlgoMath.
+
+This module implements the code generation phase, transforming
+extracted algorithm steps into executable Python code.
+"""
+
+from typing import Dict, List, Optional, Any
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+
+def show_progress(phase: str, current: int, total: int) -> str:
+    """
+    Generate a progress bar string.
+
+    Args:
+        phase: Name of the current phase
+        current: Current step number
+        total: Total number of steps
+
+    Returns:
+        Formatted progress bar string
+    """
+    if total <= 0:
+        return f"{phase}: ░░░░░░░░░░ 0%"
+
+    filled = int(10 * current / total)
+    filled = max(0, min(filled, 10))  # Clamp to 0-10 range
+    bar = '█' * filled + '░' * (10 - filled)
+    pct = int(100 * current / total)
+    return f"{phase}: {bar} {pct}%"
+
+
+def run_generation(context: "ContextManager") -> Dict[str, Any]:
+    """
+    Generate Python code from extracted steps using TemplateCodeGenerator.
+
+    Args:
+        context: ContextManager instance
+
+    Returns:
+        Dict with status and code generation result
+
+    Example:
+        >>> ctx = ContextManager()
+        >>> ctx.start_session()
+        >>> ctx.save_steps([{"step": 1, "action": "init"}])
+        >>> result = run_generation(ctx)
+        >>> print(result['status'])
+        'code_generated'
+    """
+    # Import here to avoid circular imports
+    from algomath.context import ContextManager
+    from src.extraction.schema import Algorithm
+    from src.generation import HybridCodeGenerator
+
+    # Progress indicator
+    progress = show_progress("Generate", 1, 10)
+
+    # Load algorithm
+    try:
+        algorithm_data = context.store.load_session()
+        if not algorithm_data.get('algorithm'):
+            return {
+                'status': 'needs_extraction',
+                'progress': progress,
+                'message': 'No algorithm found. Extract algorithm first with /algo-extract',
+                'next_steps': [
+                    'Extract algorithm with /algo-extract',
+                    'Check status with /algo-status'
+                ]
+            }
+    except Exception:
+        return {
+            'status': 'error',
+            'progress': progress,
+            'message': 'Could not load algorithm data',
+            'next_steps': [
+                'Start over with /algo-extract',
+                'Show help with /algo-help'
+            ]
+        }
+
+    # Convert to Algorithm object
+    try:
+        algorithm = Algorithm.from_dict(algorithm_data['algorithm'])
+    except Exception as e:
+        return {
+            'status': 'error',
+            'progress': progress,
+            'message': f'Failed to parse algorithm: {e}',
+            'next_steps': ['Extract algorithm again with /algo-extract']
+        }
+
+    # Update progress
+    progress = show_progress("Generate", 5, 10)
+
+    # Generate code using hybrid generator (Template → LLM → Stub)
+    try:
+        generator = HybridCodeGenerator()
+        result = generator.generate_for_workflow(algorithm)
+        generated = result['generated']
+
+        # Validate syntax
+        if not generated.validation_result.is_valid:
+            return {
+                'status': 'generation_error',
+                'progress': show_progress("Generate", 7, 10),
+                'error': generated.validation_result.errors,
+                'message': 'Generated code has syntax errors',
+                'next_steps': ['Review extraction with /algo-extract', 'Try again with /algo-generate']
+            }
+
+        # Save to context
+        context.save_code(generated.source)
+
+        # Determine message based on strategy
+        strategy = result['strategy']
+        messages = {
+            'template': 'Generated code using templates',
+            'llm': 'Generated code using LLM for complex expressions',
+            'stub': 'Generated stub code (full generation failed)'
+        }
+
+        # Final progress
+        progress = show_progress("Generate", 10, 10)
+
+        return {
+            'status': 'code_generated',
+            'progress': progress,
+            'lines_of_code': len(generated.source.split('\n')),
+            'algorithm_name': generated.algorithm_name,
+            'strategy': strategy,
+            'message': messages.get(strategy, 'Code generated'),
+            'next_steps': [
+                'Review code with /algo-review',
+                'Execute with /algo-run',
+                'Regenerate with /algo-generate',
+                'Check status with /algo-status'
+            ]
+        }
+    except Exception as e:
+        return {
+            'status': 'generation_error',
+            'progress': show_progress("Generate", 5, 10),
+            'error': str(e),
+            'message': f'Code generation failed: {e}',
+            'next_steps': ['Try again with /algo-generate', 'Review extraction with /algo-extract']
+        }

package/src/workflows/run.py

@@ -0,0 +1,187 @@
+"""
+Execution workflow for AlgoMath.
+
+This module implements the code execution phase, running
+generated code in a controlled environment.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+project_root = Path(__file__).parent.parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from src.execution import execute_code, ExecutionConfig, ExecutionStatus
+
+
+def show_progress(phase: str, current: int, total: int) -> str:
+    """
+    Generate a progress bar string.
+
+    Args:
+        phase: Name of the current phase
+        current: Current step number
+        total: Total number of steps
+
+    Returns:
+        Formatted progress bar string
+    """
+    if total <= 0:
+        return f"{phase}: ░░░░░░░░░░ 0%"
+
+    filled = int(10 * current / total)
+    filled = max(0, min(filled, 10))  # Clamp to 0-10 range
+    bar = '█' * filled + '░' * (10 - filled)
+    pct = int(100 * current / total)
+    return f"{phase}: {bar} {pct}%"
+
+
+def run_execution(
+    context,
+    inputs: Optional[Dict[str, Any]] = None,
+    skip_execution: bool = False
+) -> Dict[str, Any]:
+    """
+    Execute generated code.
+
+    Per D-21: Auto-triggered after code approval.
+    Per D-22: Transitions CODE_GENERATED → EXECUTING → EXECUTION_COMPLETE.
+    Per D-23: Shows progress during execution.
+    Per D-25: Can skip execution (user controls flow).
+
+    Args:
+        context: ContextManager instance
+        inputs: Optional input data for the algorithm
+        skip_execution: If True, skip execution and return mock results
+
+    Returns:
+        Dict with execution status and results
+
+    Example:
+        >>> ctx = ContextManager()
+        >>> ctx.start_session()
+        >>> ctx.save_code("def test(): pass")
+        >>> result = run_execution(ctx)
+        >>> print(result['status'])
+        'success'
+    """
+    # Progress: Starting per D-23
+    progress = show_progress("Execute", 2, 10)
+    print(f"\n{progress}")
+    print("Setting up execution environment...")
+
+    # Check if code exists
+    try:
+        algorithm_data = context.store.load_session()
+        code = algorithm_data.get('code', '')
+
+        if not code:
+            return {
+                'status': 'needs_generation',
+                'progress': progress,
+                'message': 'No code found. Generate code first with /algo-generate',
+                'next_steps': [
+                    'Generate code with /algo-generate',
+                    'Extract algorithm with /algo-extract',
+                    'Check status with /algo-status'
+                ]
+            }
+    except Exception as e:
+        return {
+            'status': 'error',
+            'progress': progress,
+            'message': f'Could not load algorithm data: {e}',
+            'next_steps': [
+                'Start over with /algo-extract',
+                'Show help with /algo-help'
+            ]
+        }
+
+    # Per D-25: Skip execution if requested
+    if skip_execution:
+        mock_results = {
+            'status': 'skipped',
+            'stdout': 'Execution skipped per user request.',
+            'stderr': '',
+            'execution_time': 0.0,
+            'return_value': None,
+            'error_type': None,
+            'error_message': None,
+            'timestamp': datetime.now().isoformat()
+        }
+        context.save_results(mock_results)
+        progress = show_progress("Execute", 10, 10)
+        return {
+            'status': 'skipped',
+            'progress': progress,
+            'message': 'Execution skipped. Proceed to verification.',
+            'next_steps': [
+                'Verify manually with /algo-verify',
+                'Run with /algo-run',
+                'Regenerate with /algo-generate'
+            ]
+        }
+
+    # Progress: Executing
+    progress = show_progress("Execute", 5, 10)
+    print(f"\n{progress}")
+    print("Running algorithm (timeout: 30s)...")
+
+    # Configure execution per D-05, D-02
+    config = ExecutionConfig(
+        timeout=30,
+        max_memory_mb=512
+    )
+
+    # Execute code
+    result = execute_code(code, inputs=inputs, config=config)
+
+    # Progress: Saving
+    progress = show_progress("Execute", 8, 10)
+    print(f"\n{progress}")
+    print("Capturing results...")
+
+    # Format results for context per D-16
+    results_data = {
+        'status': result.status.value,
+        'stdout': result.stdout,
+        'stderr': result.stderr,
+        'execution_time': result.runtime_seconds,
+        'return_value': result.return_value,
+        'error_type': result.error_type,
+        'error_message': result.error_message,
+        'timestamp': datetime.now().isoformat()
+    }
+
+    # Save to context (triggers EXECUTION_COMPLETE transition per D-22)
+    context.save_results(results_data)
+
+    # Final progress per D-23
+    progress = show_progress("Execute", 10, 10)
+
+    # Build response per D-18
+    if result.status == ExecutionStatus.SUCCESS:
+        message = f"✓ Execution complete in {result.runtime_seconds:.3f}s"
+    elif result.status == ExecutionStatus.TIMEOUT:
+        message = "⚠ Execution timed out (30s limit). Check for infinite loops."
+    else:
+        message = f"✗ Execution failed: {result.error_message or result.error_type or 'Unknown error'}"
+
+    return {
+        'status': result.status.value,
+        'progress': progress,
+        'execution_time': result.runtime_seconds,
+        'stdout': result.stdout[:2000] if result.stdout else '',  # per D-15
+        'stderr': result.stderr[:1000] if result.stderr else '',
+        'error': result.error_message if result.status != ExecutionStatus.SUCCESS else None,
+        'message': message,
+        'next_steps': [
+            'Verify results with /algo-verify',
+            'Run again with /algo-run',
+            'Regenerate code with /algo-generate'
+        ]
+    }