feat: v2.0.0 - Domain-based memory + multi-plugin marketplace structure

## Domain-based Memory (v2.0.0) - Memory split into domains (backend, frontend, database, testing, deployment, global) - Selective loading via `paths` frontmatter - only relevant memories load - Automatic domain detection from file paths in conversation - Auto-generated glob patterns when creating new domains - Cross-domain analysis in /learn:reflect ## Repository Reorganization - Restructured for multi-plugin marketplace: plugin/ → plugins/learn/ - Marketplace renamed: romfast-tools → romfast-plugins - Repository to be renamed on Gitea: claude-learn → claude-plugins 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-06 21:45:31 +00:00
parent 30b73ac7e6
commit d6c71536e7
22 changed files with 1192 additions and 716 deletions
--- a/plugins/learn/.claude-plugin/plugin.json
+++ b/plugins/learn/.claude-plugin/plugin.json
@@ -0,0 +1,8 @@
+{
+  "name": "learn",
+  "description": "Claude Learn: Session analysis for patterns and gotchas with domain-based memory",
+  "version": "2.0.0",
+  "author": {
+    "name": "Romfast Team"
+  }
+}
--- a/plugins/learn/README.md
+++ b/plugins/learn/README.md
@@ -0,0 +1,54 @@
+# Claude Learn
+
+A Claude Code plugin for capturing lessons learned during development sessions with **domain-based memory** and **selective loading**.
+
+## Installation
+
+```bash
+claude plugin install learn@romfast-plugins
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/learn:analyze` | Analyze conversation and propose lessons |
+| `/learn:status` | Show memory statistics by domain |
+| `/learn:import <file>` | Import from another memory file |
+| `/learn:reflect` | Consolidate and clean up memory |
+
+## Features
+
+- **Domain-based memory**: Organized by backend, frontend, database, testing, etc.
+- **Selective loading**: Only relevant memories load via `paths` frontmatter
+- **Automatic domain detection**: Detects domain from files in conversation
+- **Auto-generated patterns**: Glob patterns suggested when creating new domains
+
+## Plugin Structure
+
+```
+learn/
+├── .claude-plugin/plugin.json
+├── commands/
+│   ├── analyze.md
+│   ├── import.md
+│   ├── reflect.md
+│   └── status.md
+├── hooks/hooks.json
+├── rules/memory-format.md
+├── templates/
+│   ├── domain-memory.md
+│   ├── domains-config.md
+│   └── memory-entry.json
+└── README.md
+```
+
+## Development
+
+```bash
+claude --plugin-dir ./plugins/learn
+```
+
+## License
+
+MIT
--- a/plugins/learn/commands/analyze.md
+++ b/plugins/learn/commands/analyze.md
@@ -0,0 +1,205 @@
+---
+description: Analizează conversația și propune lecții de salvat
+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.
+
+## 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 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
+
+### 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 Prezintă Utilizatorului
+```
+📁 Domeniu detectat: backend (bazat pe src/api/users.ts, src/api/middleware/auth.ts)
+
+Este corect? [y/n/altul]
+```
+
+Răspunsuri posibile:
+- **y** → continuă cu domeniul detectat
+- **n** → listează toate domeniile disponibile pentru selecție
+- **altul** sau **nume-nou** → creează domeniu nou (vezi Pas 3)
+
+### 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 Prezintă pentru Confirmare
+```
+📁 Domeniu nou: "devops"
+
+Bazat pe fișierele din conversație, propun aceste patterns:
+  scripts/**/*.sh
+  ansible/**/*.yml
+
+Accept? [y/edit/+more]
+```
+
+#### 3.3 Salvează Domeniul
+- Adaugă în `.claude/rules/claude-learn-domains.md`
+- Creează `.claude/rules/claude-learn-{domain}.md` cu frontmatter
+
+### Pas 4: Generează Propuneri de Lecții
+
+Ce să cauți:
+
+#### Patterns (Soluții Repetabile)
+- Abordări care au funcționat bine
+- Configurații utile descoperite
+- Tehnici noi aplicate cu succes
+- Workflow-uri eficiente
+
+#### Gotchas (Capcane de Evitat)
+- Erori întâlnite și cum s-au rezolvat
+- Confuzii cauzate de documentație
+- Comportamente neașteptate
+- Anti-patterns descoperite
+
+Format pentru fiecare insight:
+```
+**[PATTERN/GOTCHA] Titlu Scurt**
+- **Categorie**: patterns | gotchas
+- **Descriere**: Ce s-a învățat
+- **Context**: În ce situație e relevant
+- **Exemplu**: Cod sau pași concreți
+- **Tags**: [tag1, tag2, tag3]
+```
+
+### Pas 5: Prezintă Utilizatorului
+
+```
+📚 Am identificat {N} lecții din această conversație:
+
+1. [PATTERN] {Titlu}
+   {Descriere scurtă}
+
+2. [GOTCHA] {Titlu}
+   {Descriere scurtă}
+
+📁 Domeniu: {domain}
+
+Care dintre acestea vrei să le salvez?
+- [1, 2, 3] - Selectează specific
+- [all] - Toate
+- [none] - Niciuna
+- [edit N] - Modifică propunerea N
+```
+
+### Pas 6: Salvează în Fișierul Domeniului
+
+Salvează în `.claude/rules/claude-learn-{domain}.md`
+
+Dacă fișierul nu există, creează-l din template cu frontmatter corect.
+
+Format Pattern:
+```markdown
+### {Titlu}
+**Discovered**: {YYYY-MM-DD} (feature: {context})
+**Description**: {descriere}
+
+**Example** (`{file}:{lines}`):
+\```{language}
+{code}
+\```
+
+**Tags**: {tags}
+
+---
+```
+
+Format Gotcha:
+```markdown
+### {Titlu}
+**Discovered**: {YYYY-MM-DD} (feature: {context})
+**Problem**: {problema}
+**Solution**: {soluția}
+
+**Tags**: {tags}
+
+---
+```
+
+### Pas 7: Actualizează Statistici
+
+La sfârșitul fișierului domeniului, actualizează:
+- Incrementează Total Patterns/Gotchas
+- Actualizează Last Session la data curentă
+- Incrementează Sessions Recorded
+
+### Pas 8: Confirmă
+
+```
+✅ Salvat în claude-learn-{domain}.md:
+- {N} patterns adăugate
+- {M} gotchas adăugate
+
+Statistici {domain}: {X} patterns, {Y} gotchas total
+```
+
+---
+
+## Argument: $ARGUMENTS
+
+Dacă argumentul este:
+- `auto` sau gol → detectează toate categoriile
+- `patterns` → focus doar pe patterns
+- `gotchas` → focus doar pe gotchas
+
+---
+
+## Compatibilitate Înapoi
+
+Dacă există fișierul vechi `claude-learn-memory.md` fără frontmatter:
+```
+⚠️ Detectat format vechi de memorie (claude-learn-memory.md)
+
+Vrei să migrez memoria existentă către noul sistem cu domenii? [y/n]
+- y → rulează /learn:import pe fișierul vechi
+- n → continuă fără migrare
+```
--- a/plugins/learn/commands/import.md
+++ b/plugins/learn/commands/import.md
@@ -0,0 +1,200 @@
+---
+description: Importă patterns și gotchas din alte fișiere de memorie
+argument-hint: <file-path> - Calea către fișierul sursă (ex: .claude/rules/auto-build-memory.md)
+---
+
+# Import Memorie din Alt Fișier
+
+Importă patterns și gotchas dintr-un fișier existent și le distribuie pe domenii.
+
+## Argument: $ARGUMENTS
+
+Calea către fișierul sursă. Exemple:
+- `.claude/rules/auto-build-memory.md`
+- `.claude/rules/claude-learn-memory.md` (format vechi, pentru migrare)
+- `/path/to/other-project/.claude/rules/memory.md`
+- `./backup/memories.json`
+
+## Fișiere Suportate
+
+- `.claude/rules/auto-build-memory.md` (format auto-build plugin)
+- `.claude/rules/*.md` (orice fișier markdown cu secțiuni Patterns/Gotchas)
+- Fișiere JSON cu structură `{patterns: [], gotchas: []}`
+
+## Workflow
+
+### 1. Verifică Fișierul Sursă
+
+Dacă `$ARGUMENTS` este gol:
+```
+⚠️ Specifică fișierul sursă:
+
+/learn:import .claude/rules/auto-build-memory.md
+
+Fișiere comune de importat:
+- .claude/rules/auto-build-memory.md (auto-build plugin)
+- .claude/rules/claude-learn-memory.md (format vechi, pentru migrare)
+- .claude/rules/*-memory.md (alte plugins)
+```
+
+### 2. Încarcă Configurația Domeniilor
+
+Citește `.claude/rules/claude-learn-domains.md` pentru patterns.
+Dacă nu există, creează-l din template.
+
+### 3. Detectează Formatul și Extrage Entries
+
+- Markdown cu `## Patterns` și `## Gotchas` → parsează secțiuni
+- JSON cu array-uri → convertește direct
+- Alt format → eroare cu instrucțiuni
+
+Pentru fiecare pattern/gotcha găsit, extrage:
+- Titlu (din ### heading)
+- Descriere/Problem/Solution
+- Tags (dacă există)
+- Exemple cu path-uri (dacă există)
+- Data descoperirii (dacă există, altfel data curentă)
+
+### 4. Detectează Domeniul pentru Fiecare Entry
+
+Pentru fiecare entry:
+
+#### 4.1 Încearcă detectare din path-uri în exemple
+```
+**Example** (`src/api/users.ts:45`)
+→ match cu src/api/**/*.ts → backend
+```
+
+#### 4.2 Dacă nu găsește path, încearcă din tags
+```
+**Tags**: api, middleware, express
+→ "api" sugerează backend
+```
+
+#### 4.3 Dacă nici tags nu match-uiesc, marchează ca "unassigned"
+
+### 5. Prezintă Preview cu Domenii
+
+```
+📥 Am găsit în {file}:
+- {N} patterns
+- {M} gotchas
+
+Preview cu domenii detectate:
+
+[backend] (5 entries)
+  1. [PATTERN] API Rate Limiting
+  2. [PATTERN] Error Response Format
+  3. [GOTCHA] TypeScript enum import
+  ...
+
+[frontend] (3 entries)
+  4. [PATTERN] Vue Watch Immediate
+  5. [GOTCHA] CSS Grid IE11
+  ...
+
+[unassigned] (2 entries)
+  6. [PATTERN] Git Commit Hooks
+  7. [GOTCHA] Memory Leak Detection
+
+Opțiuni:
+- [all] - Importă toate în domeniile detectate
+- [1, 3, 5] - Selectează specific
+- [move 6 deployment] - Mută entry 6 în domeniul deployment
+- [none] - Anulează
+```
+
+### 6. Procesează Entries "Unassigned"
+
+Pentru fiecare entry fără domeniu clar:
+```
+📁 Entry: "Git Commit Hooks"
+
+Nu am putut detecta automat domeniul.
+
+Alege domeniu:
+1. backend
+2. frontend
+3. deployment
+4. testing
+5. global
+6. [nou] Creează domeniu nou
+
+Sau: [skip] pentru a sări peste acest entry
+```
+
+### 7. Verifică Duplicate
+
+Pentru fiecare entry și domeniul țintă:
+- Verifică dacă există deja în `claude-learn-{domain}.md` (după titlu)
+- Dacă există → skip și raportează
+- Dacă nu există → adaugă
+
+### 8. Salvează în Fișierele Corespunzătoare
+
+Pentru fiecare domeniu cu entries:
+- Dacă fișierul nu există, creează-l din template cu frontmatter
+- Adaugă entries noi
+- Păstrează ordinea: Patterns apoi Gotchas
+- Actualizează statisticile
+
+### 9. Confirmă
+
+```
+✅ Import complet:
+
+┌────────────┬──────────┬─────────┬─────────┐
+│ Domain     │ Patterns │ Gotchas │ Skipped │
+├────────────┼──────────┼─────────┼─────────┤
+│ backend    │ 3        │ 1       │ 0       │
+│ frontend   │ 2        │ 1       │ 1       │
+│ deployment │ 1        │ 0       │ 0       │
+├────────────┼──────────┼─────────┼─────────┤
+│ TOTAL      │ 6        │ 2       │ 1       │
+└────────────┴──────────┴─────────┴─────────┘
+
+Skipped (duplicate): "Vue Watch Immediate" (deja în frontend)
+```
+
+### 10. Opțional: Curățare Fișier Sursă
+
+Dacă importul a fost din formatul vechi (`claude-learn-memory.md`):
+```
+🗑️ Vrei să șterg fișierul vechi claude-learn-memory.md? [y/n]
+- y → șterge (sau redenumește în .backup)
+- n → păstrează
+```
+
+## Exemple Utilizare
+
+```bash
+# Migrare din format vechi
+/learn:import .claude/rules/claude-learn-memory.md
+
+# Import din auto-build memory
+/learn:import .claude/rules/auto-build-memory.md
+
+# Import din alt proiect
+/learn:import /path/to/other-project/.claude/rules/memory.md
+```
+
+## Tratare Erori
+
+Dacă fișierul nu există:
+```
+❌ Fișierul nu a fost găsit: {path}
+
+Verifică:
+1. Calea este corectă
+2. Fișierul există
+3. Ai permisiuni de citire
+```
+
+Dacă formatul nu este recunoscut:
+```
+❌ Format nerecunoscut pentru: {path}
+
+Formate suportate:
+- Markdown cu secțiuni ## Patterns și ## Gotchas
+- JSON cu structură {patterns: [], gotchas: []}
+```
--- a/plugins/learn/commands/reflect.md
+++ b/plugins/learn/commands/reflect.md
@@ -0,0 +1,202 @@
+---
+description: Sintetizează patterns din mai multe sesiuni și curăță duplicatele
+---
+
+# Reflecție și Sinteză Memory
+
+Analizează toate domeniile și:
+1. Identifică duplicate în cadrul și între domenii
+2. Consolidează patterns similare
+3. Propune mutări între domenii
+4. Identifică candidați pentru promovare în CLAUDE.md sau în `global`
+
+## Workflow
+
+### 1. Scanează Toate Fișierele de Memorie
+
+Încarcă toate `claude-learn-*.md` din `.claude/rules/`:
+- backend, frontend, database, testing, deployment, global
+- + orice domeniu custom
+
+Dacă nu există niciun fișier:
+```
+ℹ️ Nu există încă fișiere de memorie.
+Rulează /learn:analyze pentru a crea primul entry.
+```
+
+### 2. Construiește Index Global
+
+Pentru toate entries din toate domeniile:
+- Colectează tags
+- Colectează titluri
+- Mapează dependencies între domenii
+
+### 3. Analizează Conținut
+
+#### 3.1 Duplicate Intra-Domeniu
+Entries similare în același domeniu:
+```
+🔄 Duplicate în [backend]:
+- "API Rate Limiting" și "Rate Limit Middleware" sunt similare
+```
+
+#### 3.2 Duplicate Cross-Domeniu
+Entries similare în domenii diferite:
+```
+🔄 Duplicate cross-domain:
+- [backend] "TypeScript Strict Mode"
+- [frontend] "TypeScript Configuration"
+→ Propun consolidare în [global]
+```
+
+#### 3.3 Entries în Domeniu Greșit
+Bazat pe tags și path-uri din exemple:
+```
+⚠️ Posibile entries în domeniu greșit:
+- [backend] "CSS Grid Layout" → propun mutare în [frontend]
+- [testing] "Database Migrations" → propun mutare în [database]
+```
+
+#### 3.4 Candidați pentru Global
+Patterns care apar în 2+ domenii sau au tags universale:
+```
+⭐ Candidați pentru [global]:
+- Tag "typescript" apare în backend (5), frontend (4), testing (2)
+- Tag "error-handling" apare în backend (3), frontend (2)
+```
+
+#### 3.5 Candidați pentru CLAUDE.md
+Patterns frecvente (3+ entries cu aceleași tags):
+```
+⭐ Candidați pentru CLAUDE.md:
+- "api" (7 entries) → propun secțiune "API Conventions"
+- "vue" (5 entries) → propun secțiune "Vue Development"
+```
+
+#### 3.6 Entries Învechite
+Entries mai vechi de 90 zile:
+```
+🗑️ Posibil învechite (>90 zile):
+- [backend] "Express 4.x Middleware" - 120 zile
+- [frontend] "Webpack 4 Config" - 95 zile
+```
+
+### 4. Prezintă Raport
+
+```
+📊 Raport Reflecție Memory
+
+Statistici per domeniu:
+┌────────────┬──────────┬─────────┐
+│ Domain     │ Patterns │ Gotchas │
+├────────────┼──────────┼─────────┤
+│ backend    │ 12       │ 5       │
+│ frontend   │ 8        │ 3       │
+│ database   │ 4        │ 2       │
+│ global     │ 2        │ 1       │
+├────────────┼──────────┼─────────┤
+│ TOTAL      │ 26       │ 11      │
+└────────────┴──────────┴─────────┘
+
+🔄 Duplicate găsite: 3
+- [backend] "API Rate Limiting" ↔ "Rate Limit Middleware"
+- [backend/frontend] "TypeScript Strict" (cross-domain)
+- ...
+
+⚠️ Domeniu greșit: 2
+- [backend] "CSS Grid" → frontend
+- [testing] "DB Migrations" → database
+
+⭐ Promovare în [global]: 2
+- "TypeScript Configuration" (apare în 3 domenii)
+- "Error Handling Pattern" (apare în 2 domenii)
+
+⭐ Promovare în CLAUDE.md: 1
+- "API Conventions" (7 entries cu tag "api")
+
+🗑️ Învechite: 2
+- [backend] "Express 4.x" - 120 zile
+- [frontend] "Webpack 4" - 95 zile
+
+Acțiuni disponibile:
+- [consolidate] - Consolidează duplicatele
+- [move] - Mută entries în domeniile corecte
+- [promote-global] - Mută candidații în [global]
+- [promote-claude] - Adaugă în CLAUDE.md
+- [archive] - Arhivează entries vechi
+- [all] - Toate acțiunile
+- [none] - Doar raportul
+```
+
+### 5. Consolidează Duplicate (dacă selectat)
+
+Pentru duplicate intra-domeniu:
+- Merge în entry-ul mai recent/complet
+- Șterge duplicatul
+- Păstrează toate tags-urile
+
+Pentru duplicate cross-domeniu:
+- Creează entry nou în `global`
+- Șterge din domeniile originale
+
+### 6. Mută în Domeniu Corect (dacă selectat)
+
+- Mută entry-ul în fișierul domeniului corect
+- Șterge din fișierul original
+- Actualizează statisticile ambelor fișiere
+
+### 7. Promovează în Global (dacă selectat)
+
+- Creează entry consolidat în `claude-learn-global.md`
+- Opțional: șterge duplicatele din domeniile originale
+
+### 8. Promovează în CLAUDE.md (dacă selectat)
+
+- Identifică CLAUDE.md din proiect
+- Propune secțiuni noi bazate pe patterns frecvente
+- Prezintă diff pentru aprobare
+
+```markdown
+## Propunere pentru CLAUDE.md
+
+### API Conventions
+
+Bazat pe 7 patterns din memory:
+
+- All API responses follow the format: `{data, error, meta}`
+- Use middleware for validation
+- Rate limit all public endpoints
+
+[Accept? y/n/edit]
+```
+
+### 9. Arhivează Vechi (dacă selectat)
+
+Două opțiuni:
+1. Mută în secțiune `## Archived` la sfârșitul fișierului
+2. Șterge complet (cu confirmare explicită)
+
+### 10. Confirmă
+
+```
+✅ Reflecție completă:
+
+Acțiuni efectuate:
+- 2 duplicate consolidate
+- 2 entries mutate în domeniile corecte
+- 1 pattern promovat în [global]
+- 1 secțiune adăugată în CLAUDE.md
+- 2 entries arhivate
+
+Statistici actualizate:
+- Total: 24 patterns, 10 gotchas în 5 domenii
+- Global: 3 patterns, 1 gotcha
+```
+
+## Când să rulezi /learn:reflect
+
+- După 10+ sesiuni de /learn:analyze
+- Când ai 20+ entries total
+- Când observi duplicate evidente
+- Înainte de release-uri mari
+- Lunar, pentru mentenanță
--- a/plugins/learn/commands/status.md
+++ b/plugins/learn/commands/status.md
@@ -0,0 +1,135 @@
+---
+description: Arată statistici memory și patterns frecvente
+---
+
+# Status Memory
+
+Afișează statistici agregate din toate fișierele de memorie pe domenii.
+
+## Workflow
+
+### 1. Scanează Fișierele de Memorie
+
+Caută toate fișierele `.claude/rules/claude-learn-*.md`:
+- `claude-learn-backend.md`
+- `claude-learn-frontend.md`
+- `claude-learn-database.md`
+- `claude-learn-testing.md`
+- `claude-learn-deployment.md`
+- `claude-learn-global.md`
+- + orice domeniu custom
+
+Ignoră:
+- `claude-learn-domains.md` (config, nu memorie)
+- `claude-learn-memory.md` (format vechi, dacă există)
+
+### 2. Verifică Existența
+
+Dacă nu există niciun fișier de memorie:
+```
+ℹ️ Nu există încă fișiere de memorie.
+
+Pentru a începe:
+1. Lucrează normal cu Claude Code
+2. Când termini o sesiune semnificativă, rulează /learn:analyze
+3. Sau importă memorie existentă cu /learn:import
+
+Comenzi disponibile:
+- /learn:analyze - Analizează conversația curentă
+- /learn:import <file> - Importă din alt fișier
+- /learn:reflect - Consolidează și curăță memory
+```
+
+Dacă există doar formatul vechi (`claude-learn-memory.md`):
+```
+⚠️ Detectat format vechi de memorie.
+
+Rulează /learn:import .claude/rules/claude-learn-memory.md
+pentru a migra către noul sistem cu domenii.
+```
+
+### 3. Parsează Fiecare Fișier
+
+Pentru fiecare `claude-learn-{domain}.md`:
+- Numără patterns (secțiunea ## Patterns)
+- Numără gotchas (secțiunea ## Gotchas)
+- Extrage tags
+- Extrage data ultimei actualizări
+
+### 4. Afișează Raport Agregat
+
+```
+📊 Claude Learn Memory Status
+
+┌────────────┬──────────┬─────────┬─────────────┐
+│ Domain     │ Patterns │ Gotchas │ Last Update │
+├────────────┼──────────┼─────────┼─────────────┤
+│ backend    │ 12       │ 5       │ 2025-01-06  │
+│ frontend   │ 8        │ 3       │ 2025-01-05  │
+│ database   │ 4        │ 2       │ 2025-01-04  │
+│ testing    │ 3        │ 1       │ 2025-01-03  │
+│ global     │ 2        │ 1       │ 2025-01-06  │
+├────────────┼──────────┼─────────┼─────────────┤
+│ TOTAL      │ 29       │ 12      │ -           │
+└────────────┴──────────┴─────────┴─────────────┘
+
+🏷️ Top 5 Tags (global):
+1. typescript (15 entries)
+2. api (12 entries)
+3. vue (8 entries)
+4. database (6 entries)
+5. auth (5 entries)
+
+📅 Activitate Recentă (ultimele 7 zile):
+- 5 patterns adăugate
+- 2 gotchas adăugate
+
+💡 Sugestii:
+{Dacă > 20 entries în vreun domeniu}
+- Domeniul {domain} are multe entries. Rulează /learn:reflect.
+
+{Dacă niciun entry în ultimele 14 zile}
+- Nu ai salvat lecții recent. Rulează /learn:analyze după sesiuni importante.
+
+{Dacă există posibile duplicate cross-domain}
+- Am detectat entries similare în {domain1} și {domain2}. Consideră mutarea în global.
+```
+
+### 5. Detalii per Domeniu (opțional)
+
+Dacă utilizatorul întreabă despre un domeniu specific:
+```
+/learn:status backend
+```
+
+Afișează detalii extinse pentru acel domeniu:
+```
+📊 Domeniu: backend
+
+📁 Fișier: .claude/rules/claude-learn-backend.md
+📌 Patterns: src/api/**/*.ts, src/server/**/*.ts, services/**/*
+
+📈 Statistici:
+- Patterns: 12
+- Gotchas: 5
+- Tags unice: 8
+- Ultima sesiune: 2025-01-06
+- Sesiuni înregistrate: 4
+
+🏷️ Tags în acest domeniu:
+api (7), middleware (4), auth (3), validation (2), error-handling (2)
+
+📋 Entries Recente:
+1. [PATTERN] API Rate Limiting (2025-01-06)
+2. [GOTCHA] TypeScript enum import (2025-01-06)
+3. [PATTERN] Error Response Format (2025-01-05)
+```
+
+## Output Minimal
+
+Pentru afișare rapidă (dacă totul e în stare bună):
+```
+📊 Claude Learn: 29 patterns, 12 gotchas în 5 domenii
+   Ultima actualizare: 2025-01-06
+   Top domains: backend (17), frontend (11)
+```
--- a/plugins/learn/hooks/hooks.json
+++ b/plugins/learn/hooks/hooks.json
@@ -0,0 +1,17 @@
+{
+  "description": "Claude Learn hooks",
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "Analizează rapid conversația. Dacă au fost: (1) rezolvate erori semnificative, (2) descoperite soluții noi, (3) luate decizii tehnice importante, sau (4) întâlnite probleme neașteptate - sugerează utilizatorului: '💡 Rulează /learn:analyze pentru a captura lecțiile din această sesiune.' Dacă conversația a fost simplă (întrebări, citire fișiere, task-uri banale), nu afișa nimic.",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}
--- a/plugins/learn/rules/memory-format.md
+++ b/plugins/learn/rules/memory-format.md
@@ -0,0 +1,140 @@
+---
+paths: ".claude/rules/claude-learn-*.md"
+---
+
+# Claude Learn Memory Format
+
+Acest fișier definește formatul pentru fișierele de memorie per domeniu.
+
+## Arhitectura Fișierelor
+
+```
+.claude/rules/
+├── claude-learn-domains.md      # Configurația domeniilor
+├── claude-learn-backend.md      # Memorie backend (paths: src/api/**)
+├── claude-learn-frontend.md     # Memorie frontend (paths: src/components/**)
+├── claude-learn-database.md     # Memorie database (paths: src/db/**)
+├── claude-learn-testing.md      # Memorie testing (paths: **/*.test.ts)
+├── claude-learn-deployment.md   # Memorie deployment (paths: Dockerfile, *.yml)
+└── claude-learn-global.md       # Memorie globală (fără paths - mereu încărcat)
+```
+
+## Template Fișier Domeniu
+
+```markdown
+---
+paths: src/api/**/*.ts, src/server/**/*.ts
+---
+
+# Claude Learn Memory: backend
+
+Patterns și Gotchas pentru domeniul **backend**.
+
+---
+
+## Patterns
+
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Description**: {Descriere clară a pattern-ului și când să-l folosești}
+
+**Example** (`{file}:{lines}`):
+\```{language}
+{cod exemplu}
+\```
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+
+## Gotchas
+
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Problem**: {Ce problemă a apărut}
+**Solution**: {Cum s-a rezolvat}
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+
+## Domain Statistics
+
+- **Total Patterns**: 0
+- **Total Gotchas**: 0
+- **Last Session**: -
+- **Sessions Recorded**: 0
+```
+
+## Template Fișier Global
+
+Fișierul `claude-learn-global.md` NU are frontmatter `paths:` și se încarcă întotdeauna:
+
+```markdown
+# Claude Learn Memory: global
+
+Patterns și Gotchas universale, aplicabile tuturor domeniilor.
+
+---
+
+## Patterns
+
+...
+
+## Gotchas
+
+...
+
+## Domain Statistics
+
+...
+```
+
+## Format Pattern
+
+```markdown
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Description**: {Descriere clară a pattern-ului și când să-l folosești}
+
+**Example** (`{file}:{lines}`):
+\```{language}
+{cod exemplu}
+\```
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+```
+
+## Format Gotcha
+
+```markdown
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Problem**: {Ce problemă a apărut}
+**Solution**: {Cum s-a rezolvat}
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+```
+
+## Convenții
+
+1. **Titluri**: Folosește titluri descriptive, nu generice
+   - ✅ "Vue Watch Needs Immediate Flag for Initial Load"
+   - ❌ "Vue Problem"
+
+2. **Tags**: Folosește kebab-case, maxim 5 tags per entry
+   - ✅ `vue`, `reactivity`, `watch`, `initialization`
+   - ❌ `Vue.js`, `REACTIVITY`, `this is a tag`
+
+3. **Exemple**: Include întotdeauna cod exemplu când e posibil
+
+4. **Context**: Folosește feature name scurt pentru context
+   - ✅ `(feature: user-dashboard)`
+   - ❌ `(feature: implementing the new user dashboard with stats and charts)`
+
+5. **Frontmatter**: Fiecare fișier de domeniu (exceptând global) TREBUIE să aibă frontmatter cu `paths:`
+   - Paths-urile trebuie să corespundă cu cele din `claude-learn-domains.md`
--- a/plugins/learn/templates/domain-memory.md
+++ b/plugins/learn/templates/domain-memory.md
@@ -0,0 +1,28 @@
+---
+paths: {DOMAIN_PATTERNS}
+---
+
+# Claude Learn Memory: {DOMAIN_NAME}
+
+Patterns și Gotchas pentru domeniul **{DOMAIN_NAME}**.
+
+---
+
+## Patterns
+
+<!-- Patterns vor fi adăugate aici -->
+
+---
+
+## Gotchas
+
+<!-- Gotchas vor fi adăugate aici -->
+
+---
+
+## Domain Statistics
+
+- **Total Patterns**: 0
+- **Total Gotchas**: 0
+- **Last Session**: -
+- **Sessions Recorded**: 0
--- a/plugins/learn/templates/domains-config.md
+++ b/plugins/learn/templates/domains-config.md
@@ -0,0 +1,42 @@
+# Claude Learn Domains Configuration
+
+Acest fișier definește domeniile pentru organizarea memoriei.
+Fiecare domeniu are propriul fișier cu `paths` frontmatter pentru încărcare selectivă.
+
+---
+
+## Domenii Definite
+
+| Domain     | Patterns (globs)                                         |
+|------------|----------------------------------------------------------|
+| backend    | src/api/**/*.ts, src/server/**/*.ts, services/**/*       |
+| frontend   | src/components/**/*.tsx, src/pages/**/*.tsx, **/*.css    |
+| database   | src/db/**/*.ts, migrations/**/*.ts, **/*.sql             |
+| testing    | **/*.test.ts, **/*.spec.ts, tests/**/*                   |
+| deployment | Dockerfile, docker-compose.yml, **/*.yml, infra/**/*    |
+| global     | (întotdeauna încărcat)                                   |
+
+---
+
+## Cum Funcționează
+
+1. La `/learn:analyze`, plugin-ul detectează domeniul bazat pe fișierele din conversație
+2. Memoria se salvează în `claude-learn-{domain}.md` cu frontmatter `paths:`
+3. La încărcarea sesiunii, doar domeniile relevante se încarcă
+
+## Adaugă Domeniu Nou
+
+Adaugă o linie în tabelul de mai sus cu formatul:
+```
+| nume-domeniu | pattern1, pattern2, pattern3 |
+```
+
+Plugin-ul va crea automat fișierul `claude-learn-{nume-domeniu}.md`.
+
+## Editare Patterns
+
+Pentru a modifica patterns-urile unui domeniu:
+1. Editează tabelul de mai sus
+2. Editează frontmatter-ul din `claude-learn-{domain}.md`
+
+Ambele locații trebuie sincronizate pentru consistență.
--- a/plugins/learn/templates/memory-entry.json
+++ b/plugins/learn/templates/memory-entry.json
@@ -0,0 +1,51 @@
+{
+  "pattern": {
+    "title": "",
+    "discovered": "",
+    "feature": "",
+    "domain": "",
+    "description": "",
+    "example": {
+      "file": "",
+      "lines": "",
+      "language": "",
+      "code": ""
+    },
+    "tags": []
+  },
+  "gotcha": {
+    "title": "",
+    "discovered": "",
+    "feature": "",
+    "domain": "",
+    "problem": "",
+    "solution": "",
+    "tags": []
+  },
+  "statistics": {
+    "total_patterns": 0,
+    "total_gotchas": 0,
+    "last_session": "",
+    "sessions_recorded": 0
+  },
+  "domains": {
+    "backend": {
+      "patterns": ["src/api/**/*.ts", "src/server/**/*.ts", "services/**/*"]
+    },
+    "frontend": {
+      "patterns": ["src/components/**/*.tsx", "src/pages/**/*.tsx", "**/*.css"]
+    },
+    "database": {
+      "patterns": ["src/db/**/*.ts", "migrations/**/*.ts", "**/*.sql"]
+    },
+    "testing": {
+      "patterns": ["**/*.test.ts", "**/*.spec.ts", "tests/**/*"]
+    },
+    "deployment": {
+      "patterns": ["Dockerfile", "docker-compose.yml", "**/*.yml", "infra/**/*"]
+    },
+    "global": {
+      "patterns": []
+    }
+  }
+}