claude-code-crash-course

## Claude Code Automation Crash Course: Branch-Based MCP Project for Acme Corp

### Project Setup
Clone the starter repository: `git clone https://github.com/acme-corp/claude-code-crash-course.git`

### Branch 1: MCP Server Setup (dev/mcp-setup)
**Goal:** Create an MCP server that monitors our internal API health endpoints.

1. **Initialize MCP Server:**
```bash
mkdir -p mcp-servers/api-monitor && cd mcp-servers/api-monitor
poetry init -n
poetry add mcp mcp-stdio requests
```

2. **Implement Health Check Endpoint:**
```python
# mcp-servers/api-monitor/api_monitor.py
from mcp.server import Server
import requests

server = Server("api-health-monitor")

@server.list_tool()
async def check_api_health(endpoint: str) -> dict:
    """Check health of internal API endpoints"""
    try:
        response = requests.get(f"https://{endpoint}/health", timeout=5)
        return {
            "status": "healthy" if response.status_code == 200 else "unhealthy",
            "response_time_ms": response.elapsed.total_seconds() * 1000
        }
    except Exception as e:
        return {"status": "error", "error": str(e)}

server.run()
```

3. **Test Locally:**
```bash
python mcp-servers/api-monitor/api_monitor.py
# In another terminal:
claude -m "Check the health of our user-service endpoint" --mcp-server ./mcp-servers/api-monitor
```

### Branch 2: Subagent Integration (dev/subagent-integration)
**Goal:** Create a subagent that handles database backup requests.

1. **Create Subagent:**
```python
# agents/db-backup-agent.py
from claude_code import SubAgent

class DatabaseBackupAgent(SubAgent):
    async def handle_request(self, request: str) -> str:
        if "backup" in request.lower():
            # Execute backup command
            return "Database backup completed successfully. File: backups/db_20240515.sql.gz"
        return "No backup command detected in request"

if __name__ == "__main__":
    agent = DatabaseBackupAgent()
    agent.run()
```

2. **Integrate with Main Agent:**
```python
# main_agent.py
from claude_code import Agent
from db_backup_agent import DatabaseBackupAgent

main_agent = Agent()
backup_agent = DatabaseBackupAgent()

@main_agent.on_message("backup request")
async def handle_backup(user_id: str, message: str):
    result = await backup_agent.handle_request(message)
    return f"Backup processed: {result}"

main_agent.run()
```

### Branch 3: Git Hooks (dev/git-hooks)
**Goal:** Implement pre-commit hooks for code quality checks.

1. **Install Pre-commit:**
```bash
pip install pre-commit
```

2. **Configure Hooks:**
```yaml
# .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
  - repo: local
    hooks:
      - id: claude-code-check
        name: Claude Code Quality Check
        entry: claude --check
        language: system
        files: '\.(py|js|ts|md)$'
```

3. **Test Hooks:**
```bash
git add .pre-commit-config.yaml
pre-commit install
# Make a test commit
echo "test" > test.txt
git add test.txt
git commit -m "Test hooks"
```

### Branch 4: CI/CD Pipeline (dev/ci-cd)
**Goal:** Build a pipeline that deploys our MCP servers to AWS ECS.

1. **Create Dockerfile:**
```dockerfile
# Dockerfile for api-monitor
FROM python:3.11-slim
WORKDIR /app
COPY mcp-servers/api-monitor /app/mcp-servers/api-monitor
RUN pip install poetry && cd /app/mcp-servers/api-monitor && poetry install
CMD ["poetry", "run", "python", "api_monitor.py"]
```

2. **GitHub Actions Workflow:**
```yaml
# .github/workflows/deploy.yml
name: Deploy MCP Servers
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Login to AWS ECR
        run: aws ecr get-login-password | docker login...
      - name: Build and Push
        run: |
          docker build -t api-monitor:latest -f mcp-servers/api-monitor/Dockerfile .
          docker push ${{ secrets.AWS_ACCOUNT_ID }}.dkr.ecr.${{ secrets.AWS_REGION }}.amazonaws.com/api-monitor:latest
      - name: Deploy to ECS
        run: aws ecs update-service...
```

### Final Integration
After completing all branches, merge them into `main` and test the complete workflow:
```bash
claude -m "Monitor our user-service API and create a backup if it's healthy" --mcp-server ./mcp-servers/api-monitor
```

**Expected Output:**
```
[2024-05-15 14:30:00] Monitoring user-service endpoint...
[2024-05-15 14:30:05] API Status: healthy (response time: 124ms)
[2024-05-15 14:30:05] Initiating database backup...
Database backup completed successfully. File: backups/db_20240515.sql.gz
```