┌─────────────────────────────────────────────────────────┐
│                    CHANNELS (Mouths)                     │
│                                                          │
│  Terminal    Telegram    Slack    Web Dashboard         │
│     │            │          │            │              │
└─────┼────────────┼──────────┼────────────┼──────────────┘
      │            │          │            │
      └────────────┴──────────┴────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│                    BRAIN (Context)                       │
│                                                          │
│  CLAUDE.md  →  Identity, rules, behavior                │
│  docs/workflows/  →  Multi-step workflows               │
│  docs/integrations/  →  MCP guides & templates          │
│  docs/design-system/  →  UI/UX standards                │
└─────────────────────────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│                    HANDS (MCPs)                          │
│                                                          │
│  ClickUp   GitHub   Slack   Docs   Sheets   BigQuery    │
└─────────────────────────────────────────────────────────┘

# channels/telegram/bot.py

class ClaudeCodeExecutor:
    async def execute_streaming(self, query: str, session_id: str):
        cmd = [self.claude_path]
        
        if continue_session:
            cmd.append('-c')  # Continue previous conversation
        
        cmd.extend(['-p', query])  # Pass user query
        
        # Execute with MCPs configured in ~/.claude.json
        process = await asyncio.create_subprocess_exec(
            *cmd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
            cwd=self.workspace_path
        )

# channels/slack/bot.py

from slack_bolt.async_app import AsyncApp
from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler

app = AsyncApp(token=SLACK_BOT_TOKEN)

# Handle DMs
@app.event("message")
async def handle_dm(event, say):
    user_id = event["user"]
    message = event["text"]
    
    # Execute with Claude Code CLI
    response = await executor.execute_streaming(message, user_id)
    await say(response)

# Handle mentions
@app.event("app_mention")
async def handle_mention(event, say):
    # Respond in thread
    await say(response, thread_ts=event["ts"])

# Start Socket Mode handler
handler = AsyncSocketModeHandler(app, SLACK_APP_TOKEN)
await handler.start_async()

# channels/web/app.py

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.get("/")
async def dashboard(request: Request):
    return templates.TemplateResponse("dashboard.html", {"request": request})

@app.get("/api/mcps")
async def list_mcps():
    config = json.loads(MCP_CONFIG_PATH.read_text())
    return {"mcps": config["mcpServers"]}

@app.websocket("/ws/chat")
async def websocket_chat(websocket: WebSocket):
    await websocket.accept()
    executor = ClaudeCodeExecutor()
    
    while True:
        message = await websocket.receive_text()
        
        async def stream_callback(chunk):
            await websocket.send_text(chunk)
        
        await executor.execute_streaming(message, stream_callback)

# Claudio - Asistente de Productividad PropHero

## Tu Identidad
- **Nombre**: Claudio
- **Rol**: Asistente de productividad y ejecución técnica
- **Usuarios**: Product Managers, Engineers/Devs
- **Canales**: Terminal, Telegram, Slack, Web

## Personalidad
- **Tono**: Profesional pero cercano, directo y orientado a resultados
- **Idioma**: Español por defecto, inglés si el usuario lo prefiere
- **Estilo**: Conciso, va al grano

## Principios de Comportamiento
1. **Ejecución > Explicación**: Prioriza hacer sobre explicar
2. **Confirmar antes de crear**: Si vas a crear algo, confirma primero
3. **Contexto es rey**: Siempre busca el contexto antes de actuar

docs/workflows/
├── product/
│   ├── daily-standup.md       # Google Docs + Slack
│   ├── create-initiative.md   # ClickUp + Google Docs + Slack
│   └── sprint-report.md       # ClickUp + Google Sheets + Slack
├── revenue/
│   ├── funnel-master.md       # Google Sheets + BigQuery
│   └── hook-script-creator.md # Google Docs
└── monthly-ds-ai-report.md    # ClickUp + Google Docs

# Daily Standup Workflow

## MCPs Utilizados
- Google Docs (crear notas)
- Slack (compartir link)

## Pasos
1. Crear documento en Google Docs con template
2. Obtener link del documento
3. Enviar mensaje a canal de Slack con el link

## Trigger
"Crea las notas para la daily de hoy"

docs/integrations/
├── clickup/
│   ├── guide.md           # Tools and workflows
│   ├── config.md          # List IDs and configuration
│   └── templates/
│       ├── initiative.md  # Template for Initiatives
│       ├── epic.md        # Template for Epics
│       └── user-story.md  # Template for User Stories
├── github/guide.md
├── slack/guide.md
├── google-docs/guide.md
└── google-sheets/guide.md

# ClickUp Integration

## Herramientas Disponibles
| Tool | Descripción |
|------|-------------|
| `get_workspace_tasks` | Buscar tareas por lista |
| `get_task` | Obtener detalles de una tarea |
| `create_task` | Crear nueva tarea |

## Workflow: Crear User Story
1. Buscar contexto (Initiative)
2. Buscar Epic relacionado
3. Crear User Story con template

{
  "mcpServers": {
    "clickup": {
      "command": "npx",
      "args": ["-y", "@taazkareem/clickup-mcp-server@latest"],
      "env": {
        "CLICKUP_API_KEY": "pk_...",
        "CLICKUP_TEAM_ID": "...",
        "CLICKUP_MCP_LICENSE_KEY": "...",
        "DOCUMENT_SUPPORT": "true"
      }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "slack-mcp-server@latest", "--transport", "stdio"],
      "env": {
        "SLACK_MCP_XOXC_TOKEN": "xoxc-...",
        "SLACK_MCP_XOXD_TOKEN": "xoxd-..."
      }
    },
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer YOUR_GITHUB_COPILOT_TOKEN"
      }
    }
  }
}

#!/bin/bash
set -e

WORKSPACE="/path/to/claudio"
CLAUDE_BIN="claude"
LOG_FILE="$WORKSPACE/scripts/logs/weekly-bot-report.log"

cd "$WORKSPACE"

$CLAUDE_BIN --dangerously-skip-permissions -p "Genera el reporte semanal 
del bot de WhatsApp usando los datos del spreadsheet Full Funnel Performance.

Incluye estas métricas para la última semana vs anterior (WoW):
- Nuevos Leads
- Group Calls Booked
- Show Up Rate

Manda el reporte por email en formato HTML a [email protected]" \
  2>&1 | tee -a "$LOG_FILE"

crontab -e

# Weekly bot report — Mondays at 9 AM
0 9 * * 1 /path/to/claudio/scripts/weekly-bot-report.sh

# Monthly DS&AI report — 1st of month at 10 AM
0 10 1 * * /path/to/claudio/scripts/monthly-ds-ai-report.sh

ALLOWED_USER_IDS=123456789,987654321

SLACK_ALLOWED_USER_IDS=U1234567890,U0987654321

# Default: 10 requests per 60 seconds per user
RATE_LIMIT_REQUESTS = 10
RATE_LIMIT_WINDOW = 60

# Track requests per user
user_request_times[user_id].append(current_time)

# Check if over limit
if len(recent_requests) > RATE_LIMIT_REQUESTS:
    raise RateLimitError()

COMMAND_TIMEOUT = 1800  # 30 minutes

try:
    await asyncio.wait_for(process.wait(), timeout=COMMAND_TIMEOUT)
except asyncio.TimeoutError:
    process.kill()
    raise CommandTimeoutError()