claude-plugins/plugins/learn/commands/analyze.md

---
description: Analizează conversația și propune lecții de salvat (cu filtrare selectivă)
argument-hint: [auto|patterns|gotchas] - Detectare automată sau categorie specifică
---

# Analiză Conversație pentru Lecții

Examinează conversația curentă și identifică insights pentru documentație.
**Salvează doar lecții cu semnal clar** - nu one-off fixes.

## Workflow

### Pas 0: Încarcă Configurația Domeniilor

Citește `.claude/rules/claude-learn-domains.md` pentru lista domeniilor disponibile.
Dacă fișierul nu există, creează-l din template cu domeniile implicite:
- backend, frontend, database, testing, deployment, global

### Pas 0.5: Verifică Reinforcement pentru Entries Existente

Înainte de a căuta lecții noi, verifică dacă conversația validează entries existente:

1. Încarcă toate entries din domeniile relevante (bazat pe fișierele din conversație)
2. Pentru fiecare entry, verifică dacă:
   - Problema descrisă a fost întâlnită ȘI soluția a funcționat
   - Pattern-ul a fost aplicat cu succes
   - Utilizatorul a menționat/confirmat un gotcha salvat

3. Dacă găsește match-uri, actualizează `Reinforced` count

4. Raportează compact (doar dacă există):
```
Reinforced: "API Error Handling" (4), "Vue Watch" (2)
```

### Pas 1: Scanează Conversația

Identifică:
- **Fișiere accesate**: toate path-urile din Read, Edit, Write, Glob, Grep
- **Tool calls cu erori** → potențiale gotchas
- **Soluții aplicate** → potențiale patterns
- **Decizii tehnice** → posibile reguli noi
- **Mesaje utilizator** → comenzi explicite, corecții, preferințe

### Pas 2: Detectează Domeniul

#### 2.1 Extrage Path-uri
Colectează toate path-urile fișierelor din conversație:
```
src/api/users.ts
src/api/middleware/auth.ts
tests/api/users.test.ts
```

#### 2.2 Match-uiește cu Domeniile
Pentru fiecare path, verifică contra patterns din config:
- `src/api/**/*.ts` → backend
- `tests/**/*.test.ts` → testing

#### 2.3 Determină Domeniul Predominant
Alege domeniul cu cele mai multe match-uri.
Dacă egalitate → preferă în ordine: backend > frontend > database > testing > deployment > global

#### 2.4 Confirmă Domeniul
```
Domeniu: backend [y/n/alt]
```
- `y` → continuă | `n` → listează domenii | `alt`/`nume-nou` → creează nou

### Pas 3: Creare Domeniu Nou (dacă e cazul)

Când utilizatorul introduce un nume de domeniu care nu există:

#### 3.1 Propune Patterns Automat
Bazat pe path-urile din conversație, generalizează:
```
scripts/deploy.sh → scripts/**/*.sh
ansible/roles/web/tasks/main.yml → ansible/**/*.yml
```

Algoritm:
1. Extrage primele 2 nivele de directoare: `scripts/`, `ansible/`
2. Extrage extensia: `.sh`, `.yml`
3. Generează glob: `{dir}**/*{ext}`

#### 3.2 Confirmă Patterns
```
Domeniu nou: devops | scripts/**/*.sh, ansible/**/*.yml [y/edit]
```

#### 3.3 Salvează Domeniul
- Adaugă în `.claude/rules/claude-learn-domains.md`
- Creează `.claude/rules/claude-learn-{domain}.md` cu frontmatter

### Pas 3.5: Detectare Semnal de Salvare

**CRITIC**: Înainte de a propune lecții, verifică dacă există SEMNAL CLAR că lecția merită salvată.

#### Categorii de Semnal (în ordine de prioritate)

##### A. Comandă Explicită (Source: explicit, Confidence: high) - SCOR: +100

Caută în mesajele utilizatorului fraze de tip "ține minte":

**Română:**
- "ține minte", "memorează", "reține", "să nu uiți", "notează-ți"
- "salvează asta", "adaugă în memorie"

**Engleză:**
- "remember", "remember this", "don't forget", "keep in mind"
- "note this", "save this"

**Acțiune:** Salvează IMEDIAT cu source=explicit, confidence=high

##### B. Preferință Explicită (Source: explicit, Confidence: high) - SCOR: +80

Caută pattern-uri de tip regulă permanentă:

**Română:**
- "întotdeauna fă X", "niciodată nu Y", "mereu să fie Z"
- "de acum înainte", "regula e că", "standard e să"

**Engleză:**
- "always do X", "never do Y", "from now on"
- "the rule is", "standard is to", "we always"

##### C. Corecție Repetată (Source: repeated, Confidence: high) - SCOR: +70

Detectează când utilizatorul corectează ACEEAȘI problemă de mai multe ori:

**Română:**
- "nu, fă-o așa", "greșit, e X nu Y", "am mai spus"
- "din nou", "încă o dată", "iar ai făcut", "te-am corectat"

**Engleză:**
- "no, do it like this", "wrong, it's X not Y", "I said before"
- "again", "once more", "I already told you"

**Condiție:** Găsește 2+ corecții pe același subiect → salvează cu source=repeated

##### D. Referință Istorică (Source: inferred, Confidence: medium) - SCOR: +50

Când utilizatorul referă discuții anterioare:

**Română:**
- "cum am discutat", "așa cum am făcut data trecută", "nu uita că"
- "știi deja", "am stabilit că", "după cum știi"

**Engleză:**
- "as we discussed", "like we did before", "don't forget that"
- "you know", "we agreed", "as you know"

**Acțiune:** Salvează CU VERIFICARE - întreabă utilizatorul dacă vrea să salveze

##### E. Pattern Dedus din Erori (Source: inferred, Confidence: medium/low) - SCOR: +30

Detectare din erori și soluții (comportamentul actual).

**Criteriu de Incluziune** (CE să salveze):
- Eroare care a apărut de mai multe ori în conversație
- Soluție care rezolvă o clasă de probleme (nu un singur fișier)
- Configurație care a necesitat research/documentație
- Workaround pentru bug cunoscut

**Criteriu de Excludere** (CE să NU salveze) - SCOR: 0:
- Fix pentru o greșeală de tipar/typo
- Eroare de path sau import greșit (one-time fix)
- Bug specific unui singur fișier fără pattern general
- Ajustări de valori hardcodate
- Syntax errors simple

#### Calculare Scor de Semnal

| Semnal | Puncte |
|--------|--------|
| Comandă explicită ("ține minte") | +100 (auto-salvare) |
| Preferință explicită ("întotdeauna") | +80 |
| Corecție repetată (2+ ori) | +70 |
| Referință istorică | +50 |
| Eroare rezolvată cu pattern general | +30 |
| Configurație descoperită | +30 |
| Eroare one-time | +5 |
| Typo/fix banal | 0 |

**Praguri:**
- **< 30 puncte**: NU se propune (filtrat automat)
- **30-50 puncte**: Se propune cu ⚠️ "Low confidence"
- **50-80 puncte**: Se propune normal
- **80+ puncte**: Marcat ca ⭐ "Recommended"

### Pas 4: Generează Propuneri de Lecții

Pentru fiecare insight cu scor >= 30, generează format compact:
```
[P] Titlu scurt #tag1 #tag2
[G] Titlu scurt #tag1 #tag2
```

Intern, păstrează: source, confidence, scor (pentru filtrare).

### Pas 5: Prezintă Utilizatorului

Format ultra-compact (fără secțiunea EXCLUSE):
```
{domain} | {N} lecții
1. [P] Titlu #tag1 #tag2
2. [G] Titlu #tag1
Salvez? [y/1,2/n]
```

Răspunsuri: `y` = toate | `1,2` = selectiv | `n` = skip

### Pas 6: Salvează în Fișierul Domeniului (Format Minimalist v3.0)

Salvează în `.claude/rules/claude-learn-{domain}.md`

#### 6.1 Header Fișier (OBLIGATORIU)

**Dacă fișierul NU există**, creează-l cu acest header EXACT:
```markdown
# Claude Learn: {domain}
<!-- paths: {patterns_din_domains.md_separate_cu_virgula} -->

```

**Dacă fișierul EXISTĂ dar NU are frontmatter HTML** (linia 2 nu începe cu `<!--`):
1. Păstrează entries-urile existente
2. Inserează `<!-- paths: ... -->` pe linia 2 (după titlu)
3. Citește patterns din `.claude/rules/claude-learn-domains.md`

**Exemplu header complet:**
```markdown
# Claude Learn: backend
<!-- paths: backend/**/*.py, backend/modules/**/*, requirements.txt -->

## P: Prima entry...
```

#### 6.2 Validare Format (înainte de salvare)

Verifică OBLIGATORIU:
- [ ] Linia 1: `# Claude Learn: {domain}`
- [ ] Linia 2: `<!-- paths: ... -->` cu patterns din domains.md
- [ ] Linia 3: linie goală
- [ ] Entries în format `## P:` sau `## G:` (NU `### Titlu`)
- [ ] Fără secțiune `## Statistics` (calculat dinamic)

#### 6.3 Format Pattern (minimalist):
```markdown
## P: {Titlu max 60 char}
@{YYYY-MM-DD} #{tag1} #{tag2} | {source}:{confidence}
{Descriere 1-2 propoziții}
\```{language}
{cod opțional}
\```
```

Exemple metadata:
- `@2026-01-06 #git #workflow | explicit:high` (nou, fără reinforced)
- `@2026-01-05 #vue #reactivity | inferred:med:3` (cu 3 reinforcements)

#### Format Gotcha (minimalist):
```markdown
## G: {Titlu max 60 char}
@{YYYY-MM-DD} #{tag1} #{tag2} | {source}:{confidence}
**P**: {problema scurtă}
**S**: {soluția scurtă}
```

**Reguli format:**
- Titlu: max 60 caractere, imperativ
- Tags: max 3, inline cu `#`
- Confidence: `high`, `med`, `low`
- Reinforced: afișat DOAR dacă > 0, format `:N` la final
- Fără separatori `---` între entries
- Fără secțiune Statistics (calculat dinamic de `/learn:status`)

### Pas 7: Confirmă

```
Salvat: +{N}P +{M}G în {domain}.md
```

---

## Argument: $ARGUMENTS

Dacă argumentul este:
- `auto` sau gol → detectează toate categoriile
- `patterns` → focus doar pe patterns
- `gotchas` → focus doar pe gotchas

---

## Compatibilitate Înapoi

### Format v2.x (verbose)
Entries în format vechi (cu `### Titlu`, `**Discovered**:`, `**Source**:`, etc.) sunt citite normal.
La prima editare, sunt convertite automat la formatul minimalist v3.0.

### Migrare Automată v2.x → v3.0

Când întâlnești un fișier în format vechi, convertește-l:

**Header vechi (de eliminat):**
```markdown
# Claude Learn: Backend

**Domain**: backend
**Last updated**: 2026-01-06
**Sessions recorded**: 1

Knowledge about...

---
```

**Header nou (de creat):**
```markdown
# Claude Learn: backend
<!-- paths: backend/**/*.py, requirements.txt -->

```

**Entry veche (Pattern):**
```markdown
### ProfileRegistry cu Hot-Reload
**Discovered**: 2026-01-06 (feature: xyz)
**Description**: Sistem de înregistrare...
**Example**: ...
**Tags**: registry, hot-reload

---
```

**Entry nouă:**
```markdown
## P: ProfileRegistry cu Hot-Reload
@2026-01-06 #registry #hot-reload | inferred:med
Sistem de înregistrare...
```

**Ce să ștergi:**
- Separatori `---` între entries
- Secțiune `## Statistics` de la final
- Header verbose cu `**Domain**:`, `**Last updated**:`, etc.

### Parsing Entries v3.0
Regex pentru parsing:
```
^## (P|G): (.+)$           → type, title
^@(\d{4}-\d{2}-\d{2}) (.+) \| (.+)$  → date, tags, meta
```

Tags: extrage toate `#(\w+)` din linia metadata
Meta: `{source}:{confidence}[:{reinforced}]`