from aegis_memory import AegisClient

client = AegisClient(api_key="...")

# After successfully using a strategy
client.vote(
    memory_id=strategy.id,
    vote="helpful",
    voter_agent_id="executor",
    context="Successfully paginated through all API results",
    task_id="task-12345"
)

# After a strategy caused an error
client.vote(
    memory_id=strategy.id,
    vote="harmful",
    voter_agent_id="executor",
    context="Caused infinite loop - range(10) wasn't enough pages",
    task_id="task-12345"
)

# Only get well-rated strategies
strategies = client.playbook(
    query="API pagination handling",
    agent_id="executor",
    min_effectiveness=0.3  # Filter by (helpful-harmful)/(total+1) > 0.3
)

result = client.delta([
    # Add a new strategy
    {
        "type": "add",
        "content": "For pagination, always use while True loop instead of range(n)",
        "memory_type": "strategy",
        "agent_id": "reflector",
        "scope": "global"
    },
    # Deprecate outdated strategy (soft delete)
    {
        "type": "deprecate",
        "memory_id": "old-pagination-strategy",
        "superseded_by": None,
        "deprecation_reason": "Caused incomplete data collection"
    }
])

client.reflection(
    content="When identifying roommates, always use Phone app contacts. "
            "Never rely on Venmo transaction descriptions - they are unreliable.",
    agent_id="reflector",
    source_trajectory_id="task-12345",
    error_pattern="identity_resolution",
    correct_approach="First authenticate with Phone app, use search_contacts() "
                     "to find contacts with 'roommate' relationship.",
    applicable_contexts=["financial_tasks", "contact_tasks"],
    scope="global"
)

# Create session at start of project
session = client.progress.create(
    session_id="build-dashboard-v2",
    agent_id="coding-agent"
)

# Update as work progresses
client.progress.update(
    session_id="build-dashboard-v2",
    completed=["auth", "routing", "api-client"],
    in_progress="dashboard-components",
    next=["data-visualization", "testing"],
    blocked=[
        {"item": "payment-integration", "reason": "Waiting for Stripe API keys"}
    ],
    summary="Core infrastructure complete. Starting UI components."
)

# Initialize features at project start
client.features.create(
    feature_id="new-chat",
    description="User can create a new chat and receive AI response",
    test_steps=[
        "Navigate to main interface",
        "Click 'New Chat' button",
        "Verify new conversation created",
        "Type message and press Enter",
        "Verify AI response appears"
    ]
)

# Only mark complete after verification
async def verify_and_complete(feature_id: str):
    feature = client.features.get(feature_id)

    for step in feature.test_steps:
        result = await run_test_step(step)
        if not result.passed:
            client.features.mark_failed(feature_id, reason=f"Failed: {step}")
            return False

    client.features.mark_complete(feature_id, verified_by="qa-agent")
    return True

from aegis_memory import AegisClient

client = AegisClient(api_key="...")

# 1. Query playbook before starting
playbook = client.get_playbook_for_agent(
    "executor",
    query="API pagination task",
    task_type="api-integration",
)
memory_ids = [e.id for e in playbook.entries]

# 2. Start tracking the run
run = client.start_run(
    run_id="task-42",
    agent_id="executor",
    task_type="api-integration",
    memory_ids_used=memory_ids,
)

# 3. Execute the task...
# (agent does its work here)

# 4. Complete the run with outcome
result = client.complete_run(
    "task-42",
    success=True,
    evaluation={"score": 0.95, "pages_fetched": 150},
)
# Auto-votes 'helpful' on all memory_ids_used!

# On failure:
result = client.complete_run(
    "task-42",
    success=False,
    evaluation={"error": "Timeout after 30s", "error_pattern": "timeout"},
)
# Auto-votes 'harmful' AND creates a reflection memory!

# Trigger curation
curation = client.curate(
    namespace="production",
    agent_id="executor",
    top_k=10,
    min_effectiveness_threshold=-0.3,
)

# Review promoted entries (high effectiveness, validated by runs)
for entry in curation.promoted:
    print(f"[+{entry.effectiveness_score:.2f}] {entry.content}")

# Review flagged entries (low effectiveness, candidates for deprecation)
for entry in curation.flagged:
    print(f"[-{entry.effectiveness_score:.2f}] {entry.content}")
    # Optionally deprecate:
    # client.deprecate(entry.id, reason="Low effectiveness after curation")

# Review consolidation candidates (similar entries to merge)
for c in curation.consolidation_candidates:
    print(f"Similar: {c.content_a[:50]} <-> {c.content_b[:50]}")

# Preview without changing anything
plan = client.consolidate_memories(namespace="production", dry_run=True,
                                   similarity_threshold=0.92)

# Apply the merges
result = client.consolidate_memories(namespace="production", dry_run=False)

score = (helpful - harmful) / (helpful + harmful + 1)
# Range: -1.0 to 1.0
# Positive = net helpful
# Negative = net harmful