Meta-Delegation Tutorial¶

# first_meta_delegation.py
from amplihack.meta_delegation import run_meta_delegation

# Define what we want
goal = "Create a Python function that calculates factorial of a number"
success_criteria = "Function exists, handles edge cases, has tests, all tests pass"

# Run meta-delegation
result = run_meta_delegation(
    goal=goal,
    success_criteria=success_criteria,
    persona_type="junior_dev",
    platform="claude-code"
)

# Check results
print(f"Status: {result.status}")
print(f"Success Score: {result.success_score}/100")
print(f"\nEvidence collected:")
for item in result.evidence:
    print(f"  - {item.type}: {item.path}")

# persona_comparison.py
from amplihack.meta_delegation import run_meta_delegation

goal = "Analyze the security of a user authentication system"
success_criteria = "Identify vulnerabilities, suggest fixes, provide examples"

# Try each persona
personas = ["guide", "qa_engineer", "architect", "junior_dev"]
results = {}

for persona in personas:
    print(f"\n{'='*60}")
    print(f"Running with {persona} persona...")
    print('='*60)

    result = run_meta_delegation(
        goal=goal,
        success_criteria=success_criteria,
        persona_type=persona,
        platform="claude-code"
    )

    results[persona] = result
    print(f"Status: {result.status}")
    print(f"Score: {result.success_score}/100")
    print(f"Evidence: {len(result.evidence)} items")

# Compare results
print("\n" + "="*60)
print("COMPARISON")
print("="*60)
for persona, result in results.items():
    print(f"{persona:12} | Score: {result.success_score:3}/100 | Evidence: {len(result.evidence):2} items")

# Too vague
success_criteria = "Make it good"

# Not measurable
success_criteria = "Code should be clean"

# Too strict
success_criteria = "Must achieve 100% code coverage"

# Specific and measurable
success_criteria = """
- Function accepts integer input
- Returns correct factorial value
- Handles n=0 (returns 1)
- Handles negative numbers (raises ValueError)
- Has at least 5 test cases
- All tests pass
"""

# Clear deliverables
success_criteria = """
Deliverables:
1. Working implementation in calculator.py
2. Test suite in test_calculator.py with >80% coverage
3. README.md with usage examples
4. All tests pass
"""

goal = "Create a REST API"
success_criteria = "API works"

goal = "Create a REST API for user management"
success_criteria = """
- API has GET /users endpoint (returns user list)
- API has POST /users endpoint (creates user)
- API validates required fields (name, email)
- Returns proper HTTP status codes (200, 201, 400)
- Has tests for each endpoint
- All tests pass
"""

# examine_evidence.py
from amplihack.meta_delegation import run_meta_delegation

result = run_meta_delegation(
    goal="Create a module for parsing CSV files",
    success_criteria="Module can read CSV, handle errors, has tests",
    persona_type="junior_dev"
)

print(f"Status: {result.status}\n")

# Group evidence by type
evidence_by_type = {}
for item in result.evidence:
    if item.type not in evidence_by_type:
        evidence_by_type[item.type] = []
    evidence_by_type[item.type].append(item)

# Display organized evidence
for evidence_type, items in evidence_by_type.items():
    print(f"{evidence_type.upper()}:")
    for item in items:
        print(f"  - {item.path}")
        if item.excerpt:
            print(f"    Preview: {item.excerpt[:100]}...")
    print()

# Read specific evidence
code_files = result.get_evidence_by_type("code_file")
if code_files:
    main_code = code_files[0]
    print(f"\nGenerated Code ({main_code.path}):")
    print("=" * 60)
    print(main_code.content)

# handle_failures.py
from amplihack.meta_delegation import run_meta_delegation

# Intentionally difficult task
goal = "Implement a quantum computer simulator in Python"
success_criteria = """
- Simulates quantum gates (Hadamard, CNOT, Pauli)
- Handles multi-qubit systems
- Has comprehensive tests
- All tests pass
"""

result = run_meta_delegation(
    goal=goal,
    success_criteria=success_criteria,
    persona_type="junior_dev",
    platform="claude-code"
)

# Handle different outcomes
if result.status == "SUCCESS":
    print("✓ Task completed successfully!")
    print(f"Score: {result.success_score}/100")

elif result.status == "PARTIAL":
    print("⚠ Task partially completed")
    print(f"Score: {result.success_score}/100")
    print(f"\nWhat was achieved:")
    for item in result.evidence:
        print(f"  - {item.type}: {item.path}")

    print(f"\nWhat's missing:")
    print(result.partial_completion_notes)

else:  # FAILURE
    print("✗ Task failed")
    print(f"Score: {result.success_score}/100")
    print(f"Reason: {result.failure_reason}")

    print(f"\nDiagnostic information:")
    print(f"Execution time: {result.duration_seconds}s")

    # Check logs for clues
    log_evidence = result.get_evidence_by_type("execution_log")
    if log_evidence:
        log = log_evidence[0]
        print(f"\nLast 20 lines of execution log:")
        lines = log.content.split('\n')
        print('\n'.join(lines[-20:]))

# complete_workflow.py
from amplihack.meta_delegation import run_meta_delegation

# Step 1: Design phase
print("Phase 1: Architecture Design")
design_result = run_meta_delegation(
    goal="Design a Python package for sending email notifications",
    success_criteria="""
    - Architecture document with module structure
    - API specification with function signatures
    - Error handling strategy
    - Documentation plan
    """,
    persona_type="architect"
)

if design_result.status != "SUCCESS":
    print(f"Design failed: {design_result.failure_reason}")
    exit(1)

print(f"✓ Design complete (score: {design_result.success_score}/100)\n")

# Step 2: Implementation phase
print("Phase 2: Implementation")
impl_result = run_meta_delegation(
    goal="Implement the email notification package following the architecture",
    success_criteria="""
    - email_notifier.py with send_email() function
    - Support for SMTP and SendGrid backends
    - Configuration via environment variables
    - Has comprehensive tests
    - All tests pass
    """,
    persona_type="junior_dev",
    # Pass context from design phase
    context=design_result.get_evidence_by_type("architecture_doc")[0].content
)

if impl_result.status != "SUCCESS":
    print(f"Implementation failed: {impl_result.failure_reason}")
    exit(1)

print(f"✓ Implementation complete (score: {impl_result.success_score}/100)\n")

# Step 3: QA phase
print("Phase 3: Quality Assurance")
qa_result = run_meta_delegation(
    goal="Perform thorough QA on the email notification package",
    success_criteria="""
    - Identify any bugs or issues
    - Verify test coverage >85%
    - Check error handling
    - Validate documentation
    - Generate QA report
    """,
    persona_type="qa_engineer"
)

print(f"✓ QA complete (score: {qa_result.success_score}/100)\n")

# Summary
print("="*60)
print("PROJECT COMPLETE")
print("="*60)
print(f"Design score: {design_result.success_score}/100")
print(f"Implementation score: {impl_result.success_score}/100")
print(f"QA score: {qa_result.success_score}/100")
print(f"Overall: {(design_result.success_score + impl_result.success_score + qa_result.success_score) / 3:.1f}/100")