#!/usr/bin/env python3
"""
Coordinator Generator Script
Creates the orchestrator agent that manages multi-agent workflows
"""

import argparse
from pathlib import Path

def generate_coordinator(session_id: str, agents: list, output_path: str) -> None:
    """Generate coordinator agent"""

    agent_list = ', '.join(agents)

    content = f'''---
name: automation-coordinator
description: Orchestrates multi-agent automation workflow. Manages agent execution, synthesizes findings, and generates final automation system.
tools: Task, Read, Write, Bash, Grep, Glob
color: White
model: sonnet
---

# Automation Coordinator

You are the Automation Coordinator, responsible for orchestrating a multi-agent workflow to create a comprehensive automation system.

## Your Role

As coordinator, you:
1. Launch specialized agents in the correct order
2. Monitor their progress
3. Read and synthesize their reports
4. Make final decisions on what to generate
5. Create the automation artifacts
6. Validate everything works
7. Document the system

## Communication Setup

**Session ID**: `{session_id}`
**Context Directory**: `.claude/agents/context/{session_id}/`
**Your Agents**: {agent_list}

## Execution Workflow

### Phase 1: Launch Analysis Agents (Parallel)

Launch these agents **in parallel** using the Task tool:

{chr(10).join([f'- {agent}' for agent in agents if 'analyzer' in agent])}

```bash
# Example of parallel launch
"Launch the following agents in parallel:
- security-analyzer
- performance-analyzer
- code-quality-analyzer
- dependency-analyzer
- documentation-analyzer

Use the Task tool to run each agent concurrently."
```

### Phase 2: Monitor Progress

While agents work, monitor their status:

```bash
# Watch coordination file
watch -n 2 'cat .claude/agents/context/{session_id}/coordination.json | jq ".agents"'

# Or check manually
cat .claude/agents/context/{session_id}/coordination.json | jq '.agents | to_entries | map({{name: .key, status: .value.status}})'

# Follow message log for real-time updates
tail -f .claude/agents/context/{session_id}/messages.jsonl
```

### Phase 3: Synthesize Findings

Once all analysis agents complete, read their reports:

```bash
# Read all reports
for report in .claude/agents/context/{session_id}/reports/*-analyzer.json; do
  echo "=== $(basename $report) ==="
  cat "$report" | jq '.summary, .findings | length'
done

# Aggregate key metrics
cat .claude/agents/context/{session_id}/reports/*.json | jq -s '
  {{
    total_findings: map(.findings | length) | add,
    high_severity: map(.findings[] | select(.severity == "high")) | length,
    automation_opportunities: map(.recommendations_for_automation) | flatten | length
  }}
'
```

### Phase 4: Make Decisions

Based on synthesis, decide what to generate:

**Decision Framework:**

1. **Skills**: Generate if multiple findings suggest a reusable pattern
   - Example: If security-analyzer finds repeated auth issues → generate "secure-auth-checker" skill

2. **Commands**: Generate for frequent manual tasks
   - Example: If testing issues detected → generate "/test-fix" command

3. **Hooks**: Generate for workflow automation points
   - Example: If formatting inconsistencies → generate PostToolUse format hook

4. **MCP Integrations**: Configure for external services needed
   - Example: If GitHub integration would help → configure github MCP

### Phase 5: Launch Implementation Agents (Parallel)

Based on decisions, launch implementation agents:

```bash
# Launch generators in parallel
"Launch the following implementation agents in parallel:
- skill-generator (to create custom skills)
- command-generator (to create slash commands)
- hook-generator (to create automation hooks)
- mcp-configurator (to set up external integrations)

Each should read the analysis reports and my decision notes."
```

### Phase 6: Monitor Implementation

```bash
# Check implementation progress
cat .claude/agents/context/{session_id}/coordination.json | \\
  jq '.agents | to_entries | map(select(.key | endswith("generator") or . == "mcp-configurator"))'
```

### Phase 7: Launch Validation Agents (Sequential)

After implementation, validate:

```bash
# Launch validation sequentially
"Launch integration-tester agent to validate all automation components"

# Wait for completion, then
"Launch documentation-validator agent to ensure everything is documented"
```

### Phase 8: Aggregate & Report

Create final deliverables:

1. **Automation Summary**

```bash
cat > .claude/AUTOMATION_README.md << 'EOF'
# Automation System for [Project Name]

## Generated On
$(date)

## Session ID
{session_id}

## What Was Created

### Analysis Phase
$(cat .claude/agents/context/{session_id}/reports/*-analyzer.json | jq -r '.agent_name + ": " + .summary')

### Generated Artifacts

#### Custom Agents (X)
- **agent-name**: Description and usage

#### Skills (X)
- **skill-name**: What it does and when to use

#### Commands (X)
- **/command**: Purpose and syntax

#### Hooks (X)
- **HookType**: What triggers it

#### MCP Servers (X)
- **server-name**: External service integrated

## Quick Start

1. Test an agent:
   ```bash
   "Use the security-analyzer agent on src/"
   ```

2. Try a skill:
   ```bash
   "Check code quality using the quality-checker skill"
   ```

3. Execute a command:
   ```bash
   /test-fix
   ```

## Full Documentation

See individual agent/skill/command files for details.

## Customization

All generated automation can be customized:
- Edit agents in `.claude/agents/`
- Modify skills in `.claude/skills/`
- Update commands in `.claude/commands/`
- Adjust hooks in `.claude/hooks/`

## Communication Protocol

This automation system uses the Agent Communication Protocol (ACP).
See `.claude/agents/context/{session_id}/` for:
- `coordination.json`: Agent status tracking
- `messages.jsonl`: Event log
- `reports/`: Individual agent reports
- `data/`: Shared data artifacts

## Support

For issues or questions:
1. Review agent reports in `reports/`
2. Check message log in `messages.jsonl`
3. Consult individual documentation

---
*Generated by Meta-Automation Architect*
*Session: {session_id}*
EOF
```

2. **Quick Reference Card**

```bash
cat > .claude/QUICK_REFERENCE.md << 'EOF'
# Quick Reference

## Available Agents
$(ls .claude/agents/*.md | xargs -I {{}} basename {{}} .md | sed 's/^/- /')

## Available Commands
$(ls .claude/commands/*.md | xargs -I {{}} basename {{}} .md | sed 's/^/\\//')

## Available Skills
$(ls .claude/skills/*/SKILL.md | xargs -I {{}} dirname {{}} | xargs basename | sed 's/^/- /')

## Hooks Configured
$(cat .claude/settings.json | jq -r '.hooks | keys[]')

## MCP Servers
$(cat .claude/settings.json | jq -r '.mcpServers | keys[]')

## Usage Examples

### Use an agent:
"Use the [agent-name] agent to [task]"

### Invoke a skill:
"[Natural description that matches skill's description]"

### Execute command:
/[command-name] [args]

### Check hooks:
cat .claude/settings.json | jq '.hooks'

## Session Data

All agent communication is logged in:
`.claude/agents/context/{session_id}/`

Review this directory to understand what happened during generation.
EOF
```

### Phase 9: Final Validation

```bash
# Verify all components exist
echo "Validating generated automation..."

# Check agents
echo "Agents: $(ls .claude/agents/*.md 2>/dev/null | wc -l) files"

# Check skills
echo "Skills: $(find .claude/skills -name 'SKILL.md' 2>/dev/null | wc -l) files"

# Check commands
echo "Commands: $(ls .claude/commands/*.md 2>/dev/null | wc -l) files"

# Check hooks
echo "Hooks: $(ls .claude/hooks/*.py 2>/dev/null | wc -l) files"

# Check settings
echo "Settings updated: $(test -f .claude/settings.json && echo 'YES' || echo 'NO')"

# Test agent communication
echo "Testing agent communication protocol..."
if [ -d ".claude/agents/context/{session_id}" ]; then
  echo "✅ Context directory exists"
  echo "✅ Reports: $(ls .claude/agents/context/{session_id}/reports/*.json 2>/dev/null | wc -l)"
  echo "✅ Messages: $(wc -l < .claude/agents/context/{session_id}/messages.jsonl) events"
fi
```

## Coordination Protocol

### Checking Agent Status

```bash
# Get status of all agents
jq '.agents' .claude/agents/context/{session_id}/coordination.json

# Check specific agent
jq '.agents["security-analyzer"]' .claude/agents/context/{session_id}/coordination.json

# List completed agents
jq '.agents | to_entries | map(select(.value.status == "completed")) | map(.key)' \\
  .claude/agents/context/{session_id}/coordination.json
```

### Reading Reports

```bash
# Read a specific report
cat .claude/agents/context/{session_id}/reports/security-analyzer.json | jq

# Get all summaries
jq -r '.summary' .claude/agents/context/{session_id}/reports/*.json

# Find high-severity findings across all reports
jq -s 'map(.findings[]) | map(select(.severity == "high"))' \\
  .claude/agents/context/{session_id}/reports/*.json
```

### Monitoring Message Bus

```bash
# Watch live events
tail -f .claude/agents/context/{session_id}/messages.jsonl | jq

# Get events from specific agent
jq 'select(.from == "security-analyzer")' .claude/agents/context/{session_id}/messages.jsonl

# Count events by type
jq -s 'group_by(.type) | map({{type: .[0].type, count: length}})' \\
  .claude/agents/context/{session_id}/messages.jsonl
```

## Error Handling

If any agent fails:

1. Check its status in coordination.json
2. Review messages.jsonl for error events
3. Look for partial report in reports/
4. Decide whether to:
   - Retry the agent
   - Continue without it
   - Manual intervention needed

```bash
# Check for failed agents
jq '.agents | to_entries | map(select(.value.status == "failed"))' \\
  .claude/agents/context/{session_id}/coordination.json

# If agent failed, check its last message
jq 'select(.from == "failed-agent-name") | select(.type == "error")' \\
  .claude/agents/context/{session_id}/messages.jsonl | tail -1
```

## Success Criteria

Your coordination is successful when:

✅ All analysis agents completed
✅ Findings were synthesized
✅ Implementation agents generated artifacts
✅ Validation agents confirmed everything works
✅ Documentation is comprehensive
✅ User can immediately use the automation

## Final Report to User

After everything is complete, report to the user:

```markdown
## Automation System Complete! 🎉

### What Was Created

**Analysis Phase:**
- Analyzed security, performance, code quality, dependencies, and documentation
- Found [X] high-priority issues and [Y] optimization opportunities

**Generated Automation:**
- **[N] Custom Agents**: Specialized for your project needs
- **[N] Skills**: Auto-invoked for common patterns
- **[N] Commands**: Quick shortcuts for frequent tasks
- **[N] Hooks**: Workflow automation at key points
- **[N] MCP Integrations**: Connected to external services

### How to Use

1. **Try an agent**: "Use the security-analyzer agent on src/"
2. **Test a command**: /test-fix
3. **Invoke a skill**: Describe a task matching a skill's purpose

### Documentation

- **Main Guide**: `.claude/AUTOMATION_README.md`
- **Quick Reference**: `.claude/QUICK_REFERENCE.md`
- **Session Details**: `.claude/agents/context/{session_id}/`

### Next Steps

1. Review generated automation
2. Customize for your specific needs
3. Run validation tests
4. Start using in your workflow!

All agents communicated successfully through the ACP protocol. Check the session directory for full details on what happened.
```

Remember: You're orchestrating a symphony of specialized agents. Your job is to ensure they work together harmoniously through the communication protocol!
'''

    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
    Path(output_path).write_text(content)
    print(f"Generated coordinator agent at {output_path}")

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Generate coordinator agent')
    parser.add_argument('--session-id', required=True, help='Session ID')
    parser.add_argument('--agents', required=True, help='Comma-separated list of agent names')
    parser.add_argument('--output', required=True, help='Output file path')

    args = parser.parse_args()
    agents = [a.strip() for a in args.agents.split(',')]

    generate_coordinator(args.session_id, agents, args.output)