attune-ai 2.0.0__py3-none-any.whl

attune/scaffolding/cli.py

@@ -0,0 +1,240 @@
+"""CLI for workflow scaffolding.
+
+Usage:
+    python -m scaffolding create my_workflow --domain healthcare
+    python -m scaffolding create my_workflow --methodology tdd --domain finance
+    python -m scaffolding create my_workflow --interactive
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import argparse
+import logging
+import sys
+
+from patterns import get_pattern_registry
+
+from .methodologies.pattern_compose import PatternCompose
+from .methodologies.tdd_first import TDDFirst
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def cmd_create(args):
+    """Create a new workflow using specified methodology.
+
+    Args:
+        args: Command line arguments
+
+    """
+    workflow_name = args.name
+    domain = args.domain or "general"
+    workflow_type = args.type or "domain"
+    methodology = args.methodology or "pattern"
+
+    print(f"\n{'=' * 60}")
+    print(f"Creating Workflow: {workflow_name}")
+    print(f"{'=' * 60}\n")
+    print(f"Domain: {domain}")
+    print(f"Type: {workflow_type}")
+    print(f"Methodology: {methodology}")
+    print()
+
+    # Get pattern recommendations
+    registry = get_pattern_registry()
+    recommended = registry.recommend_for_workflow(
+        workflow_type=workflow_type,
+        domain=domain,
+    )
+
+    print(f"Recommended Patterns ({len(recommended)}):")
+    for i, pattern in enumerate(recommended, 1):
+        print(f"  {i}. {pattern.name} - {pattern.description[:60]}...")
+
+    # Pattern selection
+    if args.patterns:
+        # User provided patterns
+        selected_patterns = args.patterns.split(",")
+    elif args.interactive:
+        # Interactive selection
+        print("\nSelect patterns (comma-separated numbers, or 'all' for all):")
+        selection = input("> ").strip()
+
+        if selection.lower() == "all":
+            selected_patterns = [p.id for p in recommended]
+        else:
+            try:
+                indices = [int(i.strip()) - 1 for i in selection.split(",")]
+                selected_patterns = [recommended[i].id for i in indices]
+            except (ValueError, IndexError):
+                print("Invalid selection. Using all patterns.")
+                selected_patterns = [p.id for p in recommended]
+    else:
+        # Use all recommended
+        selected_patterns = [p.id for p in recommended]
+
+    print(f"\nUsing {len(selected_patterns)} patterns:")
+    for pid in selected_patterns:
+        print(f"  - {pid}")
+
+    # Create workflow using selected methodology
+    print(f"\nCreating workflow with {methodology} methodology...")
+
+    if methodology == "pattern":
+        method = PatternCompose()
+        result = method.create_workflow(
+            name=workflow_name,
+            domain=domain,
+            workflow_type=workflow_type,
+            selected_patterns=selected_patterns,
+        )
+    elif methodology == "tdd":
+        method = TDDFirst()
+        result = method.create_workflow(
+            name=workflow_name,
+            domain=domain,
+            workflow_type=workflow_type,
+            pattern_ids=selected_patterns,
+        )
+    else:
+        print(f"Unknown methodology: {methodology}")
+        sys.exit(1)
+
+    # Display results
+    print(f"\n{'=' * 60}")
+    print("✅ Workflow Created Successfully!")
+    print(f"{'=' * 60}\n")
+
+    print("Generated Files:")
+    for file_path in result["files"]:
+        print(f"  - {file_path}")
+
+    print("\nPatterns Used:")
+    for pattern_name in result.get("patterns", selected_patterns):
+        print(f"  - {pattern_name}")
+
+    print("\nNext Steps:")
+    for step in result["next_steps"]:
+        print(f"  {step}")
+
+    print()
+
+
+def cmd_list_patterns(args):
+    """List available patterns.
+
+    Args:
+        args: Command line arguments
+
+    """
+    registry = get_pattern_registry()
+
+    print(f"\n{'=' * 60}")
+    print("Available Patterns")
+    print(f"{'=' * 60}\n")
+
+    # Group by category
+    from patterns.core import PatternCategory
+
+    for category in PatternCategory:
+        patterns = registry.list_by_category(category)
+        if not patterns:
+            continue
+
+        print(f"{category.value.upper()} ({len(patterns)} patterns):")
+        for pattern in patterns:
+            print(
+                f"  - {pattern.id:25} | {pattern.name:20} | Reusability: {pattern.reusability_score:.2f}"
+            )
+        print()
+
+    stats = registry.get_statistics()
+    print(f"Total: {stats['total_patterns']} patterns")
+    print(f"Average Reusability: {stats['average_reusability']:.2f}")
+    print()
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Workflow Scaffolding for Empathy Framework",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create healthcare workflow (recommended approach)
+  %(prog)s create patient_intake --domain healthcare
+
+  # Create with TDD methodology
+  %(prog)s create my_workflow --methodology tdd --domain finance
+
+  # Interactive pattern selection
+  %(prog)s create my_workflow --interactive --domain legal
+
+  # Specify patterns manually
+  %(prog)s create my_workflow --patterns linear_flow,approval,structured_fields
+
+  # List available patterns
+  %(prog)s list-patterns
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a new workflow")
+    create_parser.add_argument("name", help="Workflow name (e.g., patient_intake)")
+    create_parser.add_argument(
+        "--domain",
+        "-d",
+        help="Domain (e.g., healthcare, finance, legal)",
+    )
+    create_parser.add_argument(
+        "--type",
+        "-t",
+        choices=["domain", "coach", "ai"],
+        help="Workflow type (default: domain)",
+    )
+    create_parser.add_argument(
+        "--methodology",
+        "-m",
+        choices=["pattern", "tdd"],
+        help="Methodology (default: pattern)",
+    )
+    create_parser.add_argument(
+        "--patterns",
+        "-p",
+        help="Comma-separated pattern IDs",
+    )
+    create_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Interactive pattern selection",
+    )
+
+    # List patterns command
+    subparsers.add_parser("list-patterns", help="List available patterns")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Execute command
+    if args.command == "create":
+        cmd_create(args)
+    elif args.command == "list-patterns":
+        cmd_list_patterns(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

attune/scaffolding/templates/base_wizard.py.jinja2

@@ -0,0 +1,121 @@
+"""{{ wizard_name | title | replace('_', ' ') }} Wizard.
+
+Auto-generated by Empathy Framework Scaffolding
+Methodology: {{ methodology }}
+Domain: {{ domain }}
+Type: {{ wizard_type }}
+Patterns: {{ pattern_ids | join(', ') }}
+Generated: {{ timestamp }}
+"""
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/{{ wizard_name }}", tags=["{{ wizard_name }}"])
+
+
+# Request/Response Models
+class ProcessRequest(BaseModel):
+    """Request to process wizard input."""
+    data: dict[str, Any] = Field(..., description="Input data to process")
+    context: dict[str, Any] = Field(default_factory=dict, description="Additional context")
+
+
+class ProcessResult(BaseModel):
+    """Wizard processing result."""
+    wizard_id: str
+    result: dict[str, Any]
+    status: str = "success"
+
+
+# In-memory session storage (replace with Redis in production)
+sessions: dict[str, dict[str, Any]] = {}
+
+
+@router.post("/process", response_model=ProcessResult)
+async def process(request: ProcessRequest) -> ProcessResult:
+    """Process wizard input.
+
+    Args:
+        request: Processing request with input data
+
+    Returns:
+        Processing result
+
+    Raises:
+        HTTPException: If processing fails
+    """
+    try:
+        # Create session
+        wizard_id = f"{{ wizard_name }}_{len(sessions) + 1}"
+
+        # Process data
+        result = await _process_data(request.data, request.context)
+
+        # Store session
+        sessions[wizard_id] = {
+            "wizard_id": wizard_id,
+            "input_data": request.data,
+            "context": request.context,
+            "result": result,
+        }
+
+        logger.info(f"Processing complete for {wizard_id}")
+
+        return ProcessResult(
+            wizard_id=wizard_id,
+            result=result,
+            status="success",
+        )
+
+    except Exception as e:
+        logger.exception(f"Processing failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Processing failed: {str(e)}")
+
+
+@router.get("/{wizard_id}/result", response_model=dict[str, Any])
+async def get_result(wizard_id: str) -> dict[str, Any]:
+    """Get wizard result.
+
+    Args:
+        wizard_id: Wizard session ID
+
+    Returns:
+        Complete wizard result
+
+    Raises:
+        HTTPException: If session not found
+    """
+    if wizard_id not in sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = sessions[wizard_id]
+    return {
+        "wizard_id": wizard_id,
+        "input_data": session["input_data"],
+        "result": session["result"],
+    }
+
+
+# Helper functions
+async def _process_data(data: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+    """Process wizard data.
+
+    Args:
+        data: Input data to process
+        context: Additional context
+
+    Returns:
+        Processing result
+    """
+    # TODO: Implement actual processing logic
+    return {
+        "processed": True,
+        "data": data,
+        "context": context,
+    }

attune/scaffolding/templates/coach_wizard.py.jinja2

@@ -0,0 +1,321 @@
+"""{{ wizard_name | title | replace('_', ' ') }} Coach Wizard.
+
+Auto-generated by Empathy Framework Scaffolding
+Methodology: {{ methodology }}
+Domain: {{ domain }}
+Patterns: {{ pattern_ids | join(', ') }}
+Generated: {{ timestamp }}
+"""
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from empathy_llm_toolkit.memory_manager import MemoryManager
+from patterns import get_pattern_registry
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/{{ wizard_name }}", tags=["{{ wizard_name }}"])
+
+# Pattern registry for recommendations
+registry = get_pattern_registry()
+
+
+# Request/Response Models
+class AnalysisRequest(BaseModel):
+    """Request to analyze code."""
+    code: str = Field(..., description="Code to analyze")
+    context: dict[str, Any] = Field(default_factory=dict, description="Additional context")
+    {% if 'risk_assessment' in pattern_ids %}
+    include_risk_assessment: bool = Field(default=True, description="Include risk analysis")
+    {% endif %}
+
+
+class AnalysisResult(BaseModel):
+    """Analysis result."""
+    wizard_id: str
+    analysis: dict[str, Any]
+    {% if 'risk_assessment' in pattern_ids %}
+    risk_assessment: dict[str, Any] | None = None
+    {% endif %}
+    {% if 'prediction' in pattern_ids %}
+    predictions: list[dict[str, Any]] = Field(default_factory=list)
+    {% endif %}
+    {% if 'fix_application' in pattern_ids %}
+    suggested_fixes: list[dict[str, Any]] = Field(default_factory=list)
+    {% endif %}
+
+
+{% if 'fix_application' in pattern_ids %}
+class FixRequest(BaseModel):
+    """Request to apply a fix."""
+    wizard_id: str
+    fix_id: str
+    approval: dict[str, Any] = Field(..., description="User approval data")
+
+
+class FixResult(BaseModel):
+    """Fix application result."""
+    wizard_id: str
+    fix_id: str
+    applied: bool
+    modified_code: str | None = None
+    error: str | None = None
+{% endif %}
+
+
+# In-memory session storage (replace with Redis in production)
+sessions: dict[str, dict[str, Any]] = {}
+
+
+@router.post("/analyze", response_model=AnalysisResult)
+async def analyze_code(request: AnalysisRequest) -> AnalysisResult:
+    """Analyze code and provide recommendations.
+
+    Args:
+        request: Analysis request with code and context
+
+    Returns:
+        Analysis results with recommendations
+
+    Raises:
+        HTTPException: If analysis fails
+    """
+    try:
+        # Create session
+        wizard_id = f"{{ wizard_name }}_{len(sessions) + 1}"
+
+        # Perform code analysis
+        analysis = await _analyze_code(request.code, request.context)
+
+        result = AnalysisResult(
+            wizard_id=wizard_id,
+            analysis=analysis,
+        )
+
+        {% if 'risk_assessment' in pattern_ids %}
+        # Perform risk assessment
+        if request.include_risk_assessment:
+            risk_assessment = await _assess_risk(analysis)
+            result.risk_assessment = risk_assessment
+        {% endif %}
+
+        {% if 'prediction' in pattern_ids %}
+        # Generate predictions
+        predictions = await _generate_predictions(analysis)
+        result.predictions = predictions
+        {% endif %}
+
+        {% if 'fix_application' in pattern_ids %}
+        # Suggest fixes
+        fixes = await _suggest_fixes(analysis)
+        result.suggested_fixes = fixes
+        {% endif %}
+
+        # Store session
+        sessions[wizard_id] = {
+            "wizard_id": wizard_id,
+            "code": request.code,
+            "analysis": analysis,
+            "result": result.model_dump(),
+        }
+
+        logger.info(f"Analysis complete for {wizard_id}")
+        return result
+
+    except Exception as e:
+        logger.exception(f"Analysis failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+
+{% if 'fix_application' in pattern_ids %}
+@router.post("/fix/apply", response_model=FixResult)
+async def apply_fix(request: FixRequest) -> FixResult:
+    """Apply a suggested fix to code.
+
+    Args:
+        request: Fix application request
+
+    Returns:
+        Fix application result
+
+    Raises:
+        HTTPException: If session not found or fix fails
+    """
+    # Validate session
+    if request.wizard_id not in sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = sessions[request.wizard_id]
+
+    try:
+        # Validate approval
+        if not request.approval.get("user_approved"):
+            raise HTTPException(status_code=400, detail="User approval required")
+
+        # Find fix
+        suggested_fixes = session["result"].get("suggested_fixes", [])
+        fix = next((f for f in suggested_fixes if f["id"] == request.fix_id), None)
+
+        if not fix:
+            raise HTTPException(status_code=404, detail="Fix not found")
+
+        # Apply fix (placeholder - implement actual fix application)
+        modified_code = await _apply_fix(session["code"], fix)
+
+        # Update session
+        session["modified_code"] = modified_code
+        session["applied_fixes"] = session.get("applied_fixes", []) + [request.fix_id]
+
+        logger.info(f"Fix {request.fix_id} applied for {request.wizard_id}")
+
+        return FixResult(
+            wizard_id=request.wizard_id,
+            fix_id=request.fix_id,
+            applied=True,
+            modified_code=modified_code,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception(f"Fix application failed: {e}")
+        return FixResult(
+            wizard_id=request.wizard_id,
+            fix_id=request.fix_id,
+            applied=False,
+            error=str(e),
+        )
+{% endif %}
+
+
+@router.get("/{wizard_id}/report", response_model=dict[str, Any])
+async def get_report(wizard_id: str) -> dict[str, Any]:
+    """Get analysis report.
+
+    Args:
+        wizard_id: Wizard session ID
+
+    Returns:
+        Complete analysis report
+
+    Raises:
+        HTTPException: If session not found
+    """
+    if wizard_id not in sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = sessions[wizard_id]
+    return {
+        "wizard_id": wizard_id,
+        "analysis": session["analysis"],
+        "result": session["result"],
+        {% if 'fix_application' in pattern_ids %}
+        "applied_fixes": session.get("applied_fixes", []),
+        "modified_code": session.get("modified_code"),
+        {% endif %}
+    }
+
+
+# Helper functions
+async def _analyze_code(code: str, context: dict[str, Any]) -> dict[str, Any]:
+    """Analyze code (placeholder - implement actual analysis).
+
+    Args:
+        code: Code to analyze
+        context: Additional context
+
+    Returns:
+        Analysis results
+    """
+    # TODO: Implement actual code analysis
+    return {
+        "lines_of_code": len(code.split("\n")),
+        "complexity": "medium",
+        "issues_found": 0,
+        "context": context,
+    }
+
+
+{% if 'risk_assessment' in pattern_ids %}
+async def _assess_risk(analysis: dict[str, Any]) -> dict[str, Any]:
+    """Assess risk based on analysis.
+
+    Args:
+        analysis: Code analysis results
+
+    Returns:
+        Risk assessment
+    """
+    # TODO: Implement actual risk assessment
+    return {
+        "alert_level": "LOW",
+        "risk_score": 0.2,
+        "by_risk_level": {
+            "critical": 0,
+            "high": 0,
+            "medium": 0,
+            "low": 0,
+        },
+    }
+{% endif %}
+
+
+{% if 'prediction' in pattern_ids %}
+async def _generate_predictions(analysis: dict[str, Any]) -> list[dict[str, Any]]:
+    """Generate predictions about future issues.
+
+    Args:
+        analysis: Code analysis results
+
+    Returns:
+        List of predictions
+    """
+    # TODO: Implement actual predictions
+    return [
+        {
+            "type": "performance",
+            "confidence": 0.8,
+            "description": "May experience performance issues with large datasets",
+        }
+    ]
+{% endif %}
+
+
+{% if 'fix_application' in pattern_ids %}
+async def _suggest_fixes(analysis: dict[str, Any]) -> list[dict[str, Any]]:
+    """Suggest fixes for identified issues.
+
+    Args:
+        analysis: Code analysis results
+
+    Returns:
+        List of suggested fixes
+    """
+    # TODO: Implement actual fix suggestions
+    return [
+        {
+            "id": "fix_1",
+            "type": "optimization",
+            "description": "Add caching to improve performance",
+            "confidence": 0.9,
+        }
+    ]
+
+
+async def _apply_fix(code: str, fix: dict[str, Any]) -> str:
+    """Apply a fix to code.
+
+    Args:
+        code: Original code
+        fix: Fix to apply
+
+    Returns:
+        Modified code
+    """
+    # TODO: Implement actual fix application
+    return code + f"\n# Applied fix: {fix['id']}\n"
+{% endif %}