From 7aafcd5562ccb49c657f3b95825457e8aacc3efd Mon Sep 17 00:00:00 2001 From: Claude Agent Date: Tue, 6 Jan 2026 23:12:31 +0000 Subject: [PATCH] feat: v2.1.0 - Selective saving, cleanup command, and SessionEnd hook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit New features: - /learn:analyze now uses signal detection to save only valuable lessons - Explicit commands: "ține minte", "remember", "memorează" - Stated preferences: "întotdeauna", "always", "never" - Repeated corrections (2+ times) - Historical references: "cum am discutat", "as we discussed" - New /learn:cleanup command for memory hygiene - Scoring system for entry quality - Conservative mode with confirmation - Upgrade option to rewrite entries - SessionEnd hook shows reminder on /exit, /clear, Ctrl+D - Metadata tracking: source, confidence, reinforced, trigger Changes: - analyze.md: Added Pas 3.5 for signal detection - cleanup.md: New command for reviewing/deleting entries - hooks.json: Changed from Stop to SessionEnd - scripts/session-end-reminder.sh: New reminder script - Templates updated with metadata fields - Documentation updated for v2.1.0 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- .claude-plugin/marketplace.json | 6 +- CHANGELOG.md | 32 +++ plugins/learn/.claude-plugin/plugin.json | 4 +- plugins/learn/README.md | 106 ++++++- plugins/learn/commands/analyze.md | 180 +++++++++++- plugins/learn/commands/cleanup.md | 269 ++++++++++++++++++ plugins/learn/hooks/hooks.json | 11 +- plugins/learn/rules/memory-format.md | 99 ++++++- plugins/learn/scripts/session-end-reminder.sh | 14 + plugins/learn/templates/domain-memory.md | 36 ++- plugins/learn/templates/memory-entry.json | 32 ++- 11 files changed, 746 insertions(+), 43 deletions(-) create mode 100644 plugins/learn/commands/cleanup.md create mode 100755 plugins/learn/scripts/session-end-reminder.sh diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json index 658df9b..df32b18 100644 --- a/.claude-plugin/marketplace.json +++ b/.claude-plugin/marketplace.json @@ -10,9 +10,9 @@ { "name": "learn", "source": "./plugins/learn", - "description": "Domain-based memory with selective loading via paths frontmatter", - "version": "2.0.0", - "keywords": ["learn", "memory", "patterns", "gotchas", "domains"] + "description": "Domain-based memory with selective saving, signal detection, and memory hygiene", + "version": "2.1.0", + "keywords": ["learn", "memory", "patterns", "gotchas", "domains", "cleanup", "hygiene"] } ] } diff --git a/CHANGELOG.md b/CHANGELOG.md index 67a730b..579e189 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,38 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [2.1.0] - 2026-01-06 + +### Added +- **Selective saving with signal detection**: `/learn:analyze` now only saves lessons with clear signals + - Explicit commands: "ține minte", "memorează", "remember", "don't forget" + - Stated preferences: "întotdeauna", "niciodată", "always", "never", "from now on" + - Repeated corrections: Same issue corrected 2+ times + - Historical references: "cum am discutat", "as we discussed" +- **New `/learn:cleanup` command**: Review and remove low-value entries + - Scoring system based on source, confidence, age, and reinforcement + - Conservative mode: always confirms before deleting + - Upgrade option: rewrite entries to make them useful +- **Metadata tracking for entries**: + - `source`: explicit | inferred | repeated + - `confidence`: high | medium | low + - `reinforced`: count of times used in subsequent sessions + - `trigger`: original phrase that triggered saving +- **Reinforcement tracking**: Entries are validated when used in subsequent sessions + +### Changed +- `/learn:analyze` output now shows: + - Recommended lessons (high signal) + - Possible lessons (low signal) + - Excluded one-time fixes +- **Hook changed from Stop to SessionEnd** - reminder shows on `/exit`, `/clear`, `Ctrl+D` +- Templates updated with new metadata fields +- Statistics now include Total Reinforcements and Last Cleanup + +### Backward Compatibility +- Entries without metadata are treated as: source=inferred, confidence=medium, reinforced=0 +- Metadata added automatically on first edit or reinforcement + ## [2.0.0] - 2026-01-06 ### Changed (Repository) diff --git a/plugins/learn/.claude-plugin/plugin.json b/plugins/learn/.claude-plugin/plugin.json index f70ee44..99d9aba 100644 --- a/plugins/learn/.claude-plugin/plugin.json +++ b/plugins/learn/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "name": "learn", - "description": "Claude Learn: Session analysis for patterns and gotchas with domain-based memory", - "version": "2.0.0", + "description": "Claude Learn: Session analysis for patterns and gotchas with domain-based memory, selective saving, and memory hygiene", + "version": "2.1.0", "author": { "name": "Romfast Team" } diff --git a/plugins/learn/README.md b/plugins/learn/README.md index 53b2230..c07d2c8 100644 --- a/plugins/learn/README.md +++ b/plugins/learn/README.md @@ -1,6 +1,6 @@ # Claude Learn -A Claude Code plugin for capturing lessons learned during development sessions with **domain-based memory** and **selective loading**. +A Claude Code plugin for capturing lessons learned during development sessions with **domain-based memory**, **selective saving**, and **memory hygiene**. ## Installation @@ -12,17 +12,59 @@ claude plugin install learn@romfast-plugins | Command | Description | |---------|-------------| -| `/learn:analyze` | Analyze conversation and propose lessons | +| `/learn:analyze` | Analyze conversation and propose lessons (selective) | | `/learn:status` | Show memory statistics by domain | | `/learn:import ` | Import from another memory file | | `/learn:reflect` | Consolidate and clean up memory | +| `/learn:cleanup` | Review and remove low-value entries | ## 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 +### Domain-based Memory +- Organized by backend, frontend, database, testing, etc. +- Selective loading via `paths` frontmatter +- Automatic domain detection from files in conversation + +### Selective Saving (v2.1.0) + +The plugin now uses intelligent signal detection to save only valuable lessons: + +**What Gets Saved (High Priority):** +- Explicit commands: "ține minte", "remember this", "memorează" +- Stated preferences: "întotdeauna fă X", "always do Y" +- Repeated corrections: Same issue corrected 2+ times +- Historical references: "cum am discutat", "as we discussed" + +**What Gets Filtered Out:** +- One-time typo fixes +- Single-file specific bugs +- Import path corrections +- Hardcoded value adjustments + +### Memory Hygiene (v2.1.0) + +Each entry now tracks metadata for cleanup: + +| Field | Description | +|-------|-------------| +| `source` | How it was captured: explicit, inferred, or repeated | +| `confidence` | Signal strength: high, medium, or low | +| `reinforced` | Times used in subsequent sessions | +| `trigger` | Original phrase that triggered saving | + +Run `/learn:cleanup` periodically to review and remove low-value entries. + +### SessionEnd Hook + +When you exit a session (`/exit`, `/clear`, `Ctrl+D`), the plugin shows a reminder: + +``` +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +💡 Tip: Rulează /learn:analyze pentru a captura lecțiile din sesiune +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +``` + +**Note**: Requires Claude Code 2.0.50+ for `/clear` to trigger the hook. ## Plugin Structure @@ -30,11 +72,14 @@ claude plugin install learn@romfast-plugins learn/ ├── .claude-plugin/plugin.json ├── commands/ -│ ├── analyze.md -│ ├── import.md -│ ├── reflect.md -│ └── status.md -├── hooks/hooks.json +│ ├── analyze.md # Main analysis with signal detection +│ ├── cleanup.md # Memory hygiene command +│ ├── import.md # Import from other formats +│ ├── reflect.md # Cross-domain consolidation +│ └── status.md # Statistics display +├── hooks/hooks.json # SessionEnd hook config +├── scripts/ +│ └── session-end-reminder.sh # Reminder script ├── rules/memory-format.md ├── templates/ │ ├── domain-memory.md @@ -43,12 +88,51 @@ learn/ └── README.md ``` +## Memory Format + +Entries are saved with metadata: + +```markdown +### API Response Format Standard +**Discovered**: 2025-01-06 (feature: user-api) +**Source**: explicit | **Confidence**: high | **Reinforced**: 3 +**Trigger**: "ține minte să folosești acest format" +**Description**: All API responses must use {data, error, meta} structure + +**Example** (`src/api/users.ts:45`): +```typescript +return { data: users, error: null, meta: { count: 10 } } +``` + +**Tags**: api, response, format +``` + ## Development ```bash +# Test the plugin claude --plugin-dir ./plugins/learn + +# Verify commands +/learn:status +/learn:analyze +/learn:cleanup --dry-run ``` +## Changelog + +### v2.1.0 +- Added selective saving with signal detection +- Added `/learn:cleanup` command for memory hygiene +- Added metadata tracking (source, confidence, reinforced, trigger) +- Improved Stop hook with specific criteria +- Backward compatible with v2.0.0 entries + +### v2.0.0 +- Domain-based memory organization +- Selective loading via paths frontmatter +- Automatic domain detection + ## License MIT diff --git a/plugins/learn/commands/analyze.md b/plugins/learn/commands/analyze.md index 3a98950..aae6a1d 100644 --- a/plugins/learn/commands/analyze.md +++ b/plugins/learn/commands/analyze.md @@ -1,11 +1,12 @@ --- -description: Analizează conversația și propune lecții de salvat +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 @@ -15,6 +16,27 @@ Citește `.claude/rules/claude-learn-domains.md` pentru lista domeniilor disponi 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ă: + - Incrementează `Reinforced` count + - Actualizează `Last Reinforced` la data curentă + +4. Raportează la final (dacă există): +``` +📈 Entries validate în această sesiune: +- [backend] "API Error Handling" - reinforced (3→4) +- [frontend] "Vue Watch Pattern" - reinforced (1→2) +``` + ### Pas 1: Scanează Conversația Identifică: @@ -22,6 +44,7 @@ Identifică: - **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 @@ -85,9 +108,105 @@ Accept? [y/edit/+more] - Adaugă în `.claude/rules/claude-learn-domains.md` - Creează `.claude/rules/claude-learn-{domain}.md` cu frontmatter -### Pas 4: Generează Propuneri de Lecții +### Pas 3.5: Detectare Semnal de Salvare -Ce să cauți: +**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 (cu Metadata) + +Pentru fiecare insight identificat cu scor >= 30, generează: #### Patterns (Soluții Repetabile) - Abordări care au funcționat bine @@ -101,46 +220,64 @@ Ce să cauți: - Comportamente neașteptate - Anti-patterns descoperite -Format pentru fiecare insight: +Format extins pentru fiecare insight: ``` -**[PATTERN/GOTCHA] Titlu Scurt** +**[PATTERN/GOTCHA] Titlu Scurt** ⭐ Recommended | ⚠️ Low confidence - **Categorie**: patterns | gotchas +- **Source**: explicit | inferred | repeated +- **Confidence**: high | medium | low +- **Scor**: {punctaj} +- **Semnal detectat**: "{fraza/contextul care a declanșat}" - **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 +### Pas 5: Prezintă Utilizatorului (Extins) ``` 📚 Am identificat {N} lecții din această conversație: -1. [PATTERN] {Titlu} +⭐ RECOMANDATE (semnal puternic): + +1. [PATTERN] {Titlu} (explicit: "întotdeauna fă X") {Descriere scurtă} -2. [GOTCHA] {Titlu} +2. [GOTCHA] {Titlu} (repeated: corectat de 3 ori) {Descriere scurtă} +⚠️ POSIBILE (semnal slab): + +3. [PATTERN] {Titlu} (inferred: eroare rezolvată) + {Descriere scurtă} + +❌ EXCLUSE (one-time fixes, nu se salvează): +- Fix typo în auth.ts +- Import path corectat în utils.ts + 📁 Domeniu: {domain} Care dintre acestea vrei să le salvez? -- [1, 2, 3] - Selectează specific -- [all] - Toate +- [1, 2] - Selectează specific (implicit: doar recomandate) +- [1, 2, 3] - Include și cele cu semnal slab +- [all] - Toate (inclusiv cele slabe) - [none] - Niciuna - [edit N] - Modifică propunerea N ``` -### Pas 6: Salvează în Fișierul Domeniului +### Pas 6: Salvează în Fișierul Domeniului (cu Metadata) Salvează în `.claude/rules/claude-learn-{domain}.md` Dacă fișierul nu există, creează-l din template cu frontmatter corect. -Format Pattern: +Format Pattern (extins): ```markdown ### {Titlu} **Discovered**: {YYYY-MM-DD} (feature: {context}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: 0 +**Trigger**: "{fraza care a declanșat salvarea}" **Description**: {descriere} **Example** (`{file}:{lines}`): @@ -153,10 +290,12 @@ Format Pattern: --- ``` -Format Gotcha: +Format Gotcha (extins): ```markdown ### {Titlu} **Discovered**: {YYYY-MM-DD} (feature: {context}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: 0 +**Trigger**: "{fraza care a declanșat salvarea}" **Problem**: {problema} **Solution**: {soluția} @@ -171,6 +310,7 @@ La sfârșitul fișierului domeniului, actualizează: - Incrementează Total Patterns/Gotchas - Actualizează Last Session la data curentă - Incrementează Sessions Recorded +- Actualizează Total Reinforcements (dacă s-au făcut în Pas 0.5) ### Pas 8: Confirmă @@ -179,7 +319,9 @@ La sfârșitul fișierului domeniului, actualizează: - {N} patterns adăugate - {M} gotchas adăugate -Statistici {domain}: {X} patterns, {Y} gotchas total +📈 Entries reinforced: {X} + +Statistici {domain}: {P} patterns, {G} gotchas, {R} reinforcements total ``` --- @@ -195,6 +337,7 @@ Dacă argumentul este: ## Compatibilitate Înapoi +### Format Vechi de Memorie Dacă există fișierul vechi `claude-learn-memory.md` fără frontmatter: ``` ⚠️ Detectat format vechi de memorie (claude-learn-memory.md) @@ -203,3 +346,12 @@ 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 ``` + +### Entries Fără Metadata +Entries vechi fără câmpurile noi (Source, Confidence, Reinforced, Trigger) sunt tratate ca: +- Source: inferred +- Confidence: medium +- Reinforced: 0 +- Trigger: "" + +La prima editare sau reinforcement, metadata va fi adăugată automat. diff --git a/plugins/learn/commands/cleanup.md b/plugins/learn/commands/cleanup.md new file mode 100644 index 0000000..0c67955 --- /dev/null +++ b/plugins/learn/commands/cleanup.md @@ -0,0 +1,269 @@ +--- +description: Revizuiește memoria și propune ștergeri pentru entries nefolositoare +argument-hint: [domain|--dry-run] - Opțional: curăță doar un domeniu sau doar raport +--- + +# Curățare și Igienă Memorie + +Analizează toate entries din memorie și identifică candidați pentru ștergere. +**Mod conservator**: Întotdeauna confirmă cu utilizatorul înainte de ștergere. + +## Workflow + +### Pas 1: Încarcă Toate Fișierele de Memorie + +Citește toate `claude-learn-*.md` din `.claude/rules/`. + +Pentru fiecare entry, parsează și extrage: +- Titlu +- Discovered date +- Source (explicit/inferred/repeated) - default: inferred dacă lipsește +- Confidence (high/medium/low) - default: medium dacă lipsește +- Reinforced count - default: 0 dacă lipsește +- Last reinforced date +- Tags +- Descriere/Problem/Solution +- Example (dacă există) + +### Pas 2: Calculare Scor pentru Fiecare Entry + +#### 2.1 Criterii de Ștergere (Scor Negativ) + +| Criteriu | Puncte | Descriere | +|----------|--------|-----------| +| Fără reinforcement (0) și > 30 zile | -30 | Entry vechi nefolosit | +| Confidence: low | -20 | Inferență slabă la salvare | +| Source: inferred (nu explicit/repeated) | -10 | Nu a fost cerut explicit | +| Descriere generică (< 20 caractere) | -25 | Ex: "Fix bug", "Update config" | +| Fără example code | -15 | Lipsă context practic | +| Fără tags sau 1 singur tag | -10 | Greu de căutat/categorizat | +| Path specific în titlu | -20 | Ex: "Fix users.ts error" - prea specific | +| Menționează un singur fișier în descriere | -15 | One-time fix probabil | +| Niciun tag comun cu alte entries | -10 | Entry izolat | + +#### 2.2 Criterii de Păstrare (Scor Pozitiv) + +| Criteriu | Puncte | Descriere | +|----------|--------|-----------| +| Reinforced >= 3 | +50 | Folosit de multe ori - foarte valoros | +| Reinforced >= 1 | +20 | Folosit cel puțin o dată | +| Source: explicit | +40 | Utilizatorul a cerut explicit salvarea | +| Source: repeated | +30 | Corectat de mai multe ori - important | +| Confidence: high | +20 | Semnal puternic la salvare | +| Tags comune cu 3+ alte entries | +15 | Parte din pattern mai mare | +| Example code prezent | +10 | Are context practic | +| Discovered recent (< 14 zile) | +10 | Nou, încă de evaluat | + +#### 2.3 Calculare Scor Final + +``` +scor_final = suma(criterii_păstrare) + suma(criterii_ștergere) +``` + +**Praguri de decizie:** +- **Scor < -30**: Candidat PUTERNIC pentru ștergere +- **Scor -30 la -10**: Candidat POSIBIL pentru ștergere +- **Scor -10 la +20**: Neutru (păstrează dar monitorizează) +- **Scor > +20**: Păstrează definitiv + +### Pas 3: Prezintă Raportul + +``` +🧹 Curățare Memorie - Raport + +📊 Analizat: {N} entries din {M} domenii + +🗑️ CANDIDAȚI PENTRU ȘTERGERE: + +━━━ Scor foarte negativ (< -30) ━━━ + +1. [backend] "Fix auth bug" + Scor: -45 | Discovered: 2024-11-15 | Reinforced: 0 + ❌ Descriere generică (< 20 char) + ❌ Fără example code + ❌ Vechi (> 30 zile) fără reinforcement + ❌ Path specific în titlu + +2. [frontend] "CSS margin adjustment" + Scor: -40 | Discovered: 2024-12-01 | Reinforced: 0 + ❌ One-time fix (un singur fișier) + ❌ Confidence: low + ❌ Fără tags comune + +━━━ Scor negativ (-30 la -10) ━━━ + +3. [database] "Index creation tip" + Scor: -15 | Discovered: 2024-12-20 | Reinforced: 0 + ⚠️ Fără example code + ⚠️ Source: inferred + +━━━ Monitorizare (scor neutru) ━━━ + +4. [testing] "Mock setup pattern" + Scor: +5 | Discovered: 2025-01-02 | Reinforced: 0 + ℹ️ Nou - necesită mai mult timp pentru evaluare + +✅ PĂSTRATE DEFINITIV: {X} entries (scor > +20) + +Acțiuni disponibile: +- [delete 1, 2] - Șterge entries specifice +- [delete-negative] - Șterge toate cu scor < -30 +- [review N] - Vezi detalii complete pentru entry N +- [upgrade N] - Rescrie entry N pentru a-l îmbunătăți +- [none] - Nu șterge nimic +- [export] - Exportă lista pentru review manual +``` + +### Pas 4: Confirmare pentru Fiecare Ștergere + +Pentru fiecare entry selectat, afișează detalii și cere confirmare: + +``` +🗑️ Confirmare ștergere (1/{total}): + +Entry: [backend] "Fix auth bug" +━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +**Discovered**: 2024-11-15 (feature: login-page) +**Source**: inferred | **Confidence**: low | **Reinforced**: 0 +**Problem**: Auth token expired +**Solution**: Refresh token + +**Tags**: auth + +Motive pentru ștergere: +- Descriere prea generică pentru a fi utilă +- Niciodată folosit (0 reinforcements în 52 zile) +- Fix specific pentru un singur caz + +[delete] Confirmă ștergerea +[keep] Păstrează entry-ul +[upgrade] Rescrie pentru a-l face util +[skip] Treci la următorul +``` + +### Pas 5: Opțiune Upgrade (Rescrie Entry) + +Dacă utilizatorul alege [upgrade]: + +``` +📝 Upgrade Entry: + +Entry actual: "Fix auth bug" + +Bazat pe context, propun rescrierea: + +**Titlu nou**: "JWT Token Refresh on 401 Response" +**Descriere nouă**: When API returns 401, check if refresh token + is available and attempt automatic refresh before failing. +**Source nou**: explicit (rescris manual) +**Confidence nouă**: high + +**Example** îmbunătățit: +```typescript +if (response.status === 401 && hasRefreshToken()) { + const newToken = await refreshToken(); + return retryRequest(config, newToken); +} +``` + +Accept rescrierea? [y/n/edit] +``` + +Dacă acceptă: +- Înlocuiește entry-ul cu versiunea îmbunătățită +- Resetează Reinforced la 0 +- Actualizează Discovered la data curentă +- Setează Source: explicit +- Setează Confidence: high + +### Pas 6: Execută Ștergerile + +Pentru fiecare entry confirmat pentru ștergere: +1. Găsește entry-ul în fișierul markdown +2. Elimină complet secțiunea (de la ### până la următorul ---) +3. Actualizează statisticile (decrementează Total Patterns/Gotchas) +4. Actualizează Last Cleanup date + +**IMPORTANT**: Ștergerea este totală și ireversibilă. + +### Pas 7: Raport Final + +``` +✅ Curățare completă! + +Acțiuni efectuate: +- 3 entries șterse +- 1 entry rescris (upgraded) +- 2 entries păstrate (manual) +- 5 entries monitorizate (scor neutru) + +Statistici actualizate: +┌────────────┬──────────┬─────────┬─────────────┐ +│ Domain │ Înainte │ După │ Șterse │ +├────────────┼──────────┼─────────┼─────────────┤ +│ backend │ 15 │ 13 │ 2 │ +│ frontend │ 10 │ 9 │ 1 │ +│ database │ 8 │ 8 │ 0 │ +├────────────┼──────────┼─────────┼─────────────┤ +│ TOTAL │ 33 │ 30 │ 3 │ +└────────────┴──────────┴─────────┴─────────────┘ + +💡 Sugestie: Rulează /learn:cleanup lunar pentru mentenanță. +``` + +--- + +## Argument: $ARGUMENTS + +Dacă argumentul este: +- gol → curăță toate domeniile +- `backend` (sau alt nume de domeniu) → curăță doar acel domeniu +- `--dry-run` → doar raport, fără acțiuni de ștergere +- `--stats` → doar statistici sumare, fără detalii + +--- + +## Exemple de Entries Problematice + +### Candidați tipici pentru ștergere: + +```markdown +### Fix typo +**Discovered**: 2024-10-15 (feature: misc) +**Problem**: Typo in variable name +**Solution**: Fixed typo +**Tags**: fix +``` +❌ Titlu generic, descriere vagă, tag singular, vechi + +```markdown +### Update users.ts +**Discovered**: 2024-11-20 (feature: users) +**Problem**: Wrong import +**Solution**: Changed import path +**Tags**: import +``` +❌ Path în titlu, one-time fix, fără context reutilizabil + +### Entries bune (de păstrat): + +```markdown +### TypeScript Strict Mode Configuration +**Discovered**: 2024-12-01 (feature: project-setup) +**Source**: explicit | **Confidence**: high | **Reinforced**: 4 +**Trigger**: "ține minte setările pentru strict mode" +**Description**: Enable all strict mode options for better type safety... +**Example** (`tsconfig.json:5-15`): +```json +{ + "compilerOptions": { + "strict": true, + "noImplicitAny": true, + ... + } +} +``` +**Tags**: typescript, config, strict-mode, project-setup +``` +✅ Titlu descriptiv, reinforced de 4 ori, explicit, exemple, tags multiple diff --git a/plugins/learn/hooks/hooks.json b/plugins/learn/hooks/hooks.json index bdcc93e..75ecd27 100644 --- a/plugins/learn/hooks/hooks.json +++ b/plugins/learn/hooks/hooks.json @@ -1,14 +1,13 @@ { - "description": "Claude Learn hooks", + "description": "Claude Learn hooks - session end reminders", "hooks": { - "Stop": [ + "SessionEnd": [ { - "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 + "type": "command", + "command": "${CLAUDE_PLUGIN_ROOT}/scripts/session-end-reminder.sh", + "timeout": 5 } ] } diff --git a/plugins/learn/rules/memory-format.md b/plugins/learn/rules/memory-format.md index ea781b6..4632da9 100644 --- a/plugins/learn/rules/memory-format.md +++ b/plugins/learn/rules/memory-format.md @@ -36,6 +36,8 @@ Patterns și Gotchas pentru domeniul **backend**. ### {Titlu Descriptiv} **Discovered**: {YYYY-MM-DD} (feature: {context-scurt}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: 0 +**Trigger**: "{fraza care a declanșat salvarea}" **Description**: {Descriere clară a pattern-ului și când să-l folosești} **Example** (`{file}:{lines}`): @@ -51,6 +53,8 @@ Patterns și Gotchas pentru domeniul **backend**. ### {Titlu Descriptiv} **Discovered**: {YYYY-MM-DD} (feature: {context-scurt}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: 0 +**Trigger**: "{fraza care a declanșat salvarea}" **Problem**: {Ce problemă a apărut} **Solution**: {Cum s-a rezolvat} @@ -62,8 +66,10 @@ Patterns și Gotchas pentru domeniul **backend**. - **Total Patterns**: 0 - **Total Gotchas**: 0 +- **Total Reinforcements**: 0 - **Last Session**: - - **Sessions Recorded**: 0 +- **Last Cleanup**: - ``` ## Template Fișier Global @@ -90,11 +96,58 @@ Patterns și Gotchas universale, aplicabile tuturor domeniilor. ... ``` -## Format Pattern +--- + +## Câmpuri Metadata (v2.1.0) + +Fiecare entry include acum metadata pentru tracking și curățare. + +### Source + +Cum a fost capturat entry-ul: + +| Valoare | Descriere | Scor Cleanup | +|---------|-----------|--------------| +| `explicit` | Utilizatorul a cerut explicit salvarea ("ține minte", "remember") | +40 | +| `repeated` | Corecție repetată de 2+ ori pe același subiect | +30 | +| `inferred` | Dedus din conversație (eroare rezolvată, pattern detectat) | -10 | + +### Confidence + +Nivelul de încredere în utilitatea entry-ului: + +| Valoare | Descriere | Scor Cleanup | +|---------|-----------|--------------| +| `high` | Semnal puternic (comandă explicită, corecție repetată) | +20 | +| `medium` | Semnal moderat (preferință inferată, referință istorică) | 0 | +| `low` | Semnal slab (one-time fix posibil util) | -20 | + +### Reinforced + +Numărul de ori când entry-ul a fost folosit sau validat în sesiuni ulterioare. + +| Valoare | Interpretare | Scor Cleanup | +|---------|--------------|--------------| +| 0 | Niciodată folosit | -30 (dacă > 30 zile) | +| 1-2 | Folosit ocazional | +20 | +| 3+ | Entry valoros, foarte folosit | +50 | + +### Trigger + +Fraza originală care a declanșat salvarea. Util pentru: +- Audit: de ce a fost salvat acest entry? +- Cleanup: context pentru decizia de ștergere +- Debugging: verificare sistem de detecție semnal + +--- + +## Format Pattern (Complet) ```markdown ### {Titlu Descriptiv} **Discovered**: {YYYY-MM-DD} (feature: {context-scurt}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: {count} +**Trigger**: "{fraza care a declanșat salvarea}" **Description**: {Descriere clară a pattern-ului și când să-l folosești} **Example** (`{file}:{lines}`): @@ -107,11 +160,13 @@ Patterns și Gotchas universale, aplicabile tuturor domeniilor. --- ``` -## Format Gotcha +## Format Gotcha (Complet) ```markdown ### {Titlu Descriptiv} **Discovered**: {YYYY-MM-DD} (feature: {context-scurt}) +**Source**: {source} | **Confidence**: {confidence} | **Reinforced**: {count} +**Trigger**: "{fraza care a declanșat salvarea}" **Problem**: {Ce problemă a apărut} **Solution**: {Cum s-a rezolvat} @@ -120,6 +175,8 @@ Patterns și Gotchas universale, aplicabile tuturor domeniilor. --- ``` +--- + ## Convenții 1. **Titluri**: Folosește titluri descriptive, nu generice @@ -138,3 +195,41 @@ Patterns și Gotchas universale, aplicabile tuturor domeniilor. 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` + +6. **Trigger**: Păstrează fraza originală, fără modificări + - ✅ `"ține minte să folosești camelCase"` + - ❌ `"utilizatorul a cerut camelCase"` + +--- + +## Backward Compatibility + +Entries vechi fără câmpurile noi sunt tratate ca: +- Source: `inferred` +- Confidence: `medium` +- Reinforced: `0` +- Trigger: `""` + +La prima editare sau reinforcement, metadata va fi adăugată automat. + +--- + +## Statistici Domeniu + +Fiecare fișier de domeniu include statistici la final: + +```markdown +## Domain Statistics + +- **Total Patterns**: {N} +- **Total Gotchas**: {M} +- **Total Reinforcements**: {R} +- **Last Session**: {YYYY-MM-DD} +- **Sessions Recorded**: {X} +- **Last Cleanup**: {YYYY-MM-DD} +``` + +Aceste statistici sunt actualizate automat de: +- `/learn:analyze` - incrementează patterns/gotchas, sessions +- `/learn:cleanup` - decrementează la ștergeri, actualizează Last Cleanup +- Reinforcement tracking - incrementează Total Reinforcements diff --git a/plugins/learn/scripts/session-end-reminder.sh b/plugins/learn/scripts/session-end-reminder.sh new file mode 100755 index 0000000..8809dcb --- /dev/null +++ b/plugins/learn/scripts/session-end-reminder.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Claude Learn - Session End Reminder +# This script runs at session end and reminds the user to save lessons + +# Colors for terminal output +YELLOW='\033[1;33m' +CYAN='\033[0;36m' +NC='\033[0m' # No Color + +echo "" +echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}" +echo -e "${CYAN}💡 Tip: Rulează ${YELLOW}/learn:analyze${CYAN} pentru a captura lecțiile din sesiune${NC}" +echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}" +echo "" diff --git a/plugins/learn/templates/domain-memory.md b/plugins/learn/templates/domain-memory.md index 576d468..6cd08ec 100644 --- a/plugins/learn/templates/domain-memory.md +++ b/plugins/learn/templates/domain-memory.md @@ -10,13 +10,43 @@ Patterns și Gotchas pentru domeniul **{DOMAIN_NAME}**. ## Patterns - + --- ## Gotchas - + --- @@ -24,5 +54,7 @@ Patterns și Gotchas pentru domeniul **{DOMAIN_NAME}**. - **Total Patterns**: 0 - **Total Gotchas**: 0 +- **Total Reinforcements**: 0 - **Last Session**: - - **Sessions Recorded**: 0 +- **Last Cleanup**: - diff --git a/plugins/learn/templates/memory-entry.json b/plugins/learn/templates/memory-entry.json index 2784b8e..a162031 100644 --- a/plugins/learn/templates/memory-entry.json +++ b/plugins/learn/templates/memory-entry.json @@ -11,7 +11,12 @@ "language": "", "code": "" }, - "tags": [] + "tags": [], + "source": "explicit|inferred|repeated", + "confidence": "high|medium|low", + "reinforced": 0, + "last_reinforced": "", + "trigger": "" }, "gotcha": { "title": "", @@ -20,13 +25,20 @@ "domain": "", "problem": "", "solution": "", - "tags": [] + "tags": [], + "source": "explicit|inferred|repeated", + "confidence": "high|medium|low", + "reinforced": 0, + "last_reinforced": "", + "trigger": "" }, "statistics": { "total_patterns": 0, "total_gotchas": 0, + "total_reinforcements": 0, "last_session": "", - "sessions_recorded": 0 + "sessions_recorded": 0, + "last_cleanup": "" }, "domains": { "backend": { @@ -47,5 +59,19 @@ "global": { "patterns": [] } + }, + "_metadata_fields": { + "source": { + "explicit": "Utilizatorul a cerut explicit salvarea (ține minte, remember)", + "inferred": "Dedus din conversație (eroare rezolvată, pattern detectat)", + "repeated": "Corecție repetată de 2+ ori pe același subiect" + }, + "confidence": { + "high": "Semnal puternic (comandă explicită, corecție repetată)", + "medium": "Semnal moderat (preferință inferată, referință istorică)", + "low": "Semnal slab (one-time fix posibil util)" + }, + "reinforced": "Numărul de ori când entry-ul a fost folosit/validat în sesiuni ulterioare", + "trigger": "Fraza originală care a declanșat salvarea (pentru audit/cleanup)" } }