immortal-brain

What this skill does

# Immortal Brain v5.0 - AGENT AUTONOM PROACTIV

## 🧬 Overview

**Immortal Brain v5.0** este un **Agent AI Autonom Avansat** care transformă task-urile într-un ecosistem inteligent, proactiv și auto-învățător.

### Caracteristici Unice:

🤖 **Autonomie Completă**:
- Gândește, cercetează, analizează și execută SINGUR
- Workflow automat: research → analysis → planning → execution → complete
- Auto-aprobat după 6 minute fără răspuns

📊 **Inteligență Proactivă**:
- Conexiuni automate între task-uri similare
- Sugestii îmbunătățiri din experiențe trecute
- Combinări creative de tag-uri pentru idei noi
- Profil utilizator care învață din comportament

⏱️ **Real-Time Monitoring**:
- Bătăi de inimă la fiecare 2 minute
- Raportare progres procentual continuu
- Alertă task-uri urgente
- Status detaliat în timp real

## 🏗️ Arhitectură Workflow

```
┌─────────────────────────────────────────────────────────────┐
│                    🫀 HEARTBEAT (2 min)                    │
└─────────────────────────────────────────────────────────────┘
                            ↓
        ┌───────────────────┼───────────────────┐
        ↓                   ↓                   ↓
   ┌─────────┐        ┌─────────┐        ┌──────────┐
   │ Procesează│        │ Graf    │        │ Creative │
   │ Task-uri │        │ Conexiuni│        │ Sugestii │
   │ Active   │        │         │        │          │
   └────┬────┘        └─────────┘        └──────────┘
        ↓
   ┌─────────────────────────────────────────────────────┐
   │              WORKFLOW STATE MACHINE                 │
   ├─────────────────────────────────────────────────────┤
   │                                                     │
   │   received ──→ research ──→ analysis ──→ planning  │
   │      ↑                                          ↓   │
   │      │                                 awaiting_approval│
   │      │                                          │   │
   │      │                    (timeout 6 min)       │   │
   │      │                    ↓                     │   │
   │      └──────── completed ←─ execution ←── auto_approved│
   │                              ↓                     │
   │                          monitoring                │
   │                                                     │
   └─────────────────────────────────────────────────────┘
```

### Stări Task:

| Stare | Progres | Descriere |
|-------|---------|-----------|
| `received` | 0% | Task primit, așteaptă procesare |
| `research` | 10% | Cercetare informații similare |
| `analysis` | 25% | Analiză complexitate și dependențe |
| `planning` | 40% | Generare pași execuție |
| `awaiting_approval` | 50% | Așteaptă OK de la utilizator |
| `auto_approved` | 55% | Aprobat automat (timeout) |
| `execution` | 60-85% | Execuție pași activi |
| `monitoring` | 85% | Monitorizare finală |
| `completed` | 100% | Finalizat cu succes |
| `enhanced` | 100% | Îmbunătățit prin conexiuni |

## 📁 Structura Sistemului

```
workspace/
├── memory/                    # Input task-uri (Telegram/fișiere)
│   └── *.md
├── Creier/                    # Memorie organizată
│   ├── TOPIC.md              # Task-uri active pe topic
│   ├── _TASKS/               # Detalii task-uri individuale
│   ├── _RESEARCH/            # Note cercetare
│   ├── _APPROVALS/           # Cereri aprobare
│   ├── _PROGRESS/            # Rapoarte progres
│   └── _ARHIVA/              # Task-uri completate
├── brain_index.json          # Toate task-urile cu metadate
├── brain_state.json          # Stare sistem (heartbeat count)
├── brain_graph.json          # Graf conexiuni task-uri
└── user_profile.json         # Profil utilizator (învățare)
```

## 🚀 Comenzi

### 1. `heartbeat` - Bătăia Inimii (Principală)

```bash
python brain_service.py heartbeat
```

**Rulează la fiecare 2 minute** și:
1. Procesează toate task-urile active prin workflow
2. Citește task-uri noi din `memory/`
3. Reconstruiește graf conexiuni
4. Generează raport progres procentual
5. Sugestii creative (la fiecare 10 minute)

**Output JSON**:
```json
{
  "success": true,
  "action": "heartbeat",
  "heartbeat_number": 42,
  "active_tasks": 5,
  "new_tasks": 1,
  "notifications": [
    "📊 RAPORT PROGRES...",
    "🔬 Task 'X': Cercetare completă",
    "📈 Task 'Y': Progres 65%"
  ],
  "progress": "📊 Progres mediu: 45%"
}
```

### 2. `status` - Status Sistem

```bash
python brain_service.py status
```

**Returnează**:
```json
{
  "success": true,
  "heartbeat_count": 42,
  "total_tasks": 15,
  "active_tasks": 5,
  "completed_tasks": 10,
  "last_heartbeat": "2026-02-09T15:30:00"
}
```

### 3. `list` - Listează Task-uri

```bash
python brain_service.py list
```

**Returnează** toate task-urile cu:
- ID, conținut (truncat)
- Stare, progres procentual
- Topic, prioritate

## 🔄 Workflow Automat Detaliat

### Etapa 1: 🔬 RESEARCH (Cercetare)

**Ce face**:
- Caută task-uri similare în memorie
- Identifică topic-uri conexe
- Compilează note de cercetare

**Notificare**:
```
🔬 CERCETARE COMPLETĂ

Task: "Implementare API REST"

**Rezultate:**
• Task-uri similare găsite: 3 (relevanță 85%)
  - "API endpoints documentation" 
  - "Authentication middleware"
• Topic 'dev': 12 task-uri existente
• Dependențe identificate: 2
```

### Etapa 2: 📊 ANALYSIS (Analiză)

**Ce face**:
- Evaluează complexitatea
- Identifică prioritatea
- Sugerează îmbunătățiri din task-uri conectate

**Notificare**:
```
📊 ANALIZĂ COMPLETĂ

Task: "Implementare API REST"

**Rezultate:**
• Complexitate: high
• Prioritate: urgent
• Topic: dev

**💡 Sugestii de Îmbunătățire:**
(din task-uri similare completate)
• Folosește biblioteca FastAPI pentru rapiditate
• Implementează rate limiting de la început
• Adaugă documentație automată cu Swagger
```

### Etapa 3: 📋 PLANNING (Planificare)

**Ce face**:
- Generează pași detaliați de implementare
- Estimează timp pentru fiecare pas
- Identifică dependențe și blocaje potențiale

**Notificare**:
```
📋 PLANIFICARE COMPLETĂ

Task: "Implementare API REST"

**Plan (7 pași):**
1. Definire completă cerințe endpoint-uri
2. Research soluții existente (FastAPI vs Flask)
3. Proiectare arhitectură și structură
4. Implementare endpoints principale
5. Implementare autentificare JWT
6. Testare unitară și integrare
7. Documentare și deployment

**Aștept aprobarea ta pentru a începe execuția...**
⏱️ Auto-aprobat în 6 minute.
```

### Etapa 4: ⏳ AWAITING_APPROVAL (Așteptare)

**Timeout**: 3 bătăi = 6 minute

**Comportament**:
- Bătaia 1: Trimite planul detaliat
- Bătaia 2: Reminder cu progres 50%
- Bătaia 3: **Auto-aprobat** și continuă

**Răspunsuri posibile**:
- ✅ `"OK"` / `"DA"` → Aprobă și continuă
- ❌ `"STOP"` / `"NU"` → Anulează task-ul
- 💡 `"Modifică X"` → Ajustează planul
- 🤐 **Fără răspuns** → Auto-aprobat după 6 minute

### Etapa 5: 🚀 EXECUTION (Execuție)

**Ce face**:
- Execută pașii din plan
- Raportează progres la fiecare bătaie
- Identifică blocaje și le raportează

**Notificare Progres**:
```
📈 PROGRES: "Implementare API REST"

• Progres: 65%
• Stare: În execuție
• ETA: ~4 minute rămase

**Pași finalizați:**
✅ Definire cerințe
✅ Research soluții
✅ Proiectare arhitectură

**Pași activi:**
▶️ Implementare endpoints (60%)
```

### Etapa 6: ✅ COMPLETED (Finalizare)

**Notificare Finală**:
```
✅ TASK FINALIZAT

Task: "Implementare API REST"
Progres: 100%

**Statistici:**
• Timp total: 8 bătăi de inimă (16 minute)
• Pași executați: 7
• Îmbunătățiri aplicate: 3

🎉 Task finalizat cu succes!

**💡 Recomandare:**
Pe baza acestui task, sugerez să explorezi:
• "Documentare API automată"
• "Testare integrare CI/CD"
```

## 🧠 Inteligență și Conexiuni

### Graf de Conexiuni

Sistemul construiește automat un **graf de conexiuni** între task-uri:

```python
# Similaritate calculată pe baza tag-urilor comune
similarity = len(tags_comune) / len(tags_totale)

# Dacă similarity > 0.3 → Creează conexiune
```

**Exemplu**:
```
Task A: "API login #dev #security #urgent"
Task B: "JWT middleware #dev #security #active"

Conexiune: