feat: Initial release of claude-learn plugin v1.0.0

Commands:
- /learn:analyze - Analyze conversation for patterns and gotchas
- /learn:import - Import from other memory files (auto-build-memory.md, JSON)
- /learn:reflect - Consolidate and clean memory
- /learn:status - Show memory statistics

Features:
- Stop hook suggests /learn:analyze after significant sessions
- Uses single memory file: .claude/rules/claude-learn-memory.md
- Structured format for patterns (solutions) and gotchas (problems)
- Import support for migrating existing memories

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Claude Agent
2026-01-06 19:02:02 +00:00
commit 30b73ac7e6
15 changed files with 853 additions and 0 deletions

View File

@@ -0,0 +1,18 @@
{
"name": "romfast-tools",
"owner": {
"name": "Romfast Team"
},
"metadata": {
"description": "Claude Code plugins for learning and memory"
},
"plugins": [
{
"name": "learn",
"source": "./plugin",
"description": "Lessons Learned: Automatic pattern and gotcha detection with CLAUDE.md updates",
"version": "1.0.0",
"keywords": ["learn", "memory", "patterns", "gotchas", "documentation"]
}
]
}

13
.gitignore vendored Normal file
View File

@@ -0,0 +1,13 @@
# OS
.DS_Store
Thumbs.db
# IDE
.idea/
.vscode/
*.swp
*.swo
# Local testing
.claude/
*.local.*

17
CHANGELOG.md Normal file
View File

@@ -0,0 +1,17 @@
# Changelog
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).
## [1.0.0] - 2025-01-06
### Added
- Initial release
- `/learn:analyze` - Analyze conversation for patterns and gotchas
- `/learn:import` - Import from other memory files
- `/learn:reflect` - Consolidate and clean memory
- `/learn:status` - Show memory statistics
- Stop hook for automatic suggestions
- Support for markdown and JSON import formats

44
CLAUDE.md Normal file
View File

@@ -0,0 +1,44 @@
# CLAUDE.md
Development instructions for the claude-learn plugin.
## Project Structure
```
claude-learn/
├── .claude-plugin/marketplace.json # Marketplace entry
├── plugin/ # Plugin code
│ ├── .claude-plugin/plugin.json # Plugin manifest
│ ├── commands/ # Slash commands
│ ├── hooks/ # Event hooks
│ ├── rules/ # Rule files
│ └── templates/ # JSON templates
├── README.md # User documentation
├── CLAUDE.md # This file
└── CHANGELOG.md # Version history
```
## Key Decisions
1. **Single Memory File**: Plugin uses only `.claude/rules/claude-learn-memory.md`
2. **Import for Migration**: Use `/learn:import` to bring in existing memories
3. **User Confirmation**: Always list proposals before saving
4. **Stop Hook**: Suggests, doesn't auto-run
## Testing
```bash
# Test locally
claude --plugin-dir ./plugin
# Verify commands appear
/learn:status
```
## Release Process
1. Update version in `plugin/.claude-plugin/plugin.json`
2. Update version in `.claude-plugin/marketplace.json`
3. Update CHANGELOG.md
4. Commit and push to main
5. Tag release: `git tag v1.0.0 && git push --tags`

21
LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2025 Romfast Team
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

128
README.md Normal file
View File

@@ -0,0 +1,128 @@
# Claude Learn
A Claude Code plugin for capturing lessons learned during development sessions.
## Features
- **Automatic Detection**: Stop hook suggests capturing lessons after significant sessions
- **Pattern & Gotcha Tracking**: Structured format for reusable solutions and problems to avoid
- **Import Support**: Bring in existing memories from other formats
- **Reflection Tools**: Consolidate and promote patterns to CLAUDE.md
## Installation
### Option 1: Marketplace (Recommended)
Add to your `~/.claude/settings.json`:
```json
{
"plugin-marketplaces": [
"git@gitea.romfast.ro:romfast/claude-learn.git"
]
}
```
Then install:
```bash
claude plugin install learn@romfast-tools
```
### Option 2: Direct from Git
```bash
git clone git@gitea.romfast.ro:romfast/claude-learn.git
claude --plugin-dir /path/to/claude-learn/plugin
```
## Commands
| Command | Description |
|---------|-------------|
| `/learn:analyze` | Analyze conversation and propose lessons |
| `/learn:analyze auto` | Auto-detect all categories |
| `/learn:analyze patterns` | Focus on patterns only |
| `/learn:analyze gotchas` | Focus on gotchas only |
| `/learn:import <file>` | Import from another memory file |
| `/learn:reflect` | Consolidate and clean up memory |
| `/learn:status` | Show memory statistics |
## Usage Flow
```
1. Work normally with Claude Code
2. Claude finishes a significant response
3. Stop Hook analyzes (15s)
4. "💡 Run /learn:analyze to capture lessons"
5. User: /learn:analyze
6. Claude lists proposals (patterns, gotchas)
7. User selects: [1, 3, all, none]
8. Claude updates .claude/rules/claude-learn-memory.md
9. Periodically: /learn:reflect for consolidation
```
## Memory File Format
The plugin creates and maintains `.claude/rules/claude-learn-memory.md` with this structure:
```markdown
# Claude Learn Memory
## Patterns
### Pattern Title
**Discovered**: 2025-01-06 (feature: user-dashboard)
**Description**: What the pattern does and when to use it
**Example** (`src/components/Dashboard.vue:45-52`):
\```vue
<template>...</template>
\```
**Tags**: vue, components, dashboard
---
## Gotchas
### Gotcha Title
**Discovered**: 2025-01-06 (feature: api-integration)
**Problem**: What went wrong
**Solution**: How to fix it
**Tags**: api, axios, error-handling
---
## Memory Statistics
- **Total Patterns**: 5
- **Total Gotchas**: 3
- **Last Session**: 2025-01-06
- **Sessions Recorded**: 8
```
## Importing Existing Memories
If you have an existing memory file (e.g., from auto-build plugin):
```bash
/learn:import .claude/rules/auto-build-memory.md
```
Supported formats:
- Markdown with `## Patterns` and `## Gotchas` sections
- JSON with `{patterns: [], gotchas: []}` structure
## License
MIT

View File

@@ -0,0 +1,8 @@
{
"name": "learn",
"description": "Claude Learn: Session analysis for patterns and gotchas",
"version": "1.0.0",
"author": {
"name": "Romfast Team"
}
}

49
plugin/README.md Normal file
View File

@@ -0,0 +1,49 @@
# Claude Learn Plugin
This is the main plugin directory. For installation and usage instructions, see the [main README](../README.md).
## Plugin Structure
```
plugin/
├── .claude-plugin/
│ └── plugin.json # Plugin manifest
├── commands/
│ ├── analyze.md # /learn:analyze command
│ ├── import.md # /learn:import command
│ ├── reflect.md # /learn:reflect command
│ └── status.md # /learn:status command
├── hooks/
│ └── hooks.json # Stop hook configuration
├── rules/
│ └── memory-format.md # Memory file format spec
├── templates/
│ └── memory-entry.json # JSON templates
└── README.md # This file
```
## Development
To test locally:
```bash
claude --plugin-dir /path/to/claude-learn/plugin
```
## Commands Overview
### /learn:analyze
Analyzes the current conversation and proposes patterns/gotchas to save.
### /learn:import
Imports memories from other files (auto-build-memory.md, JSON, etc.)
### /learn:reflect
Consolidates duplicates, promotes frequent patterns to CLAUDE.md.
### /learn:status
Shows memory statistics and suggestions.
## Hook
The Stop hook triggers after significant conversations, suggesting `/learn:analyze` when appropriate.

130
plugin/commands/analyze.md Normal file
View File

@@ -0,0 +1,130 @@
---
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.
## 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
### Reguli CLAUDE.md
- Convenții noi de documentat
- Comenzi de adăugat
- Workflow-uri de standardizat
## Workflow
### 1. Scanează Conversația
- Identifică tool calls cu erori → potențiale gotchas
- Identifică soluții aplicate → potențiale patterns
- Identifică decizii tehnice → posibile reguli noi
### 2. Generează Propuneri
Format pentru fiecare insight:
**[PATTERN/GOTCHA] Titlu Scurt**
- **Categorie**: patterns | gotchas | rules
- **Descriere**: Ce s-a învățat
- **Context**: În ce situație e relevant
- **Exemplu**: Cod sau pași concreți
- **Tags**: [tag1, tag2, tag3]
### 3. Prezintă Utilizatorului
```
📚 Am identificat {N} lecții din această conversație:
1. [PATTERN] {Titlu}
{Descriere scurtă}
2. [GOTCHA] {Titlu}
{Descriere scurtă}
Care dintre acestea vrei să le salvez în documentație?
- [1, 2, 3] - Selectează specific
- [all] - Toate
- [none] - Niciuna
- [edit N] - Modifică propunerea N
```
### 4. Salvează în .claude/rules/claude-learn-memory.md
Dacă fișierul nu există, creează-l cu template-ul de mai jos.
Folosește formatul:
```markdown
# Claude Learn Memory
Patterns și Gotchas învățate din sesiuni de lucru.
---
## Patterns
### {Titlu}
**Discovered**: {YYYY-MM-DD} (feature: {context})
**Description**: {descriere}
**Example** (`{file}:{lines}`):
\```{language}
{code}
\```
**Tags**: {tags}
---
## Gotchas
### {Titlu}
**Discovered**: {YYYY-MM-DD} (feature: {context})
**Problem**: {problema}
**Solution**: {soluția}
**Tags**: {tags}
---
## Memory Statistics
- **Total Patterns**: {N}
- **Total Gotchas**: {N}
- **Last Session**: {YYYY-MM-DD}
- **Sessions Recorded**: {N}
```
### 5. Actualizează Statistici
La sfârșitul fișierului memory.md, actualizează secțiunea Memory Statistics:
- Incrementează Total Patterns/Gotchas
- Actualizează Last Session la data curentă
- Incrementează Sessions Recorded
### 6. Confirmă
```
✅ Salvat în .claude/rules/claude-learn-memory.md:
- 2 patterns adăugate
- 1 gotcha adăugată
Statistici actualizate: 15 patterns, 8 gotchas
```
## Argument: $ARGUMENTS
Dacă argumentul este:
- `auto` sau gol → detectează toate categoriile
- `patterns` → focus doar pe patterns
- `gotchas` → focus doar pe gotchas

125
plugin/commands/import.md Normal file
View File

@@ -0,0 +1,125 @@
---
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 în formatul claude-learn-memory.md.
## Argument: $ARGUMENTS
Calea către fișierul sursă. Exemple:
- `.claude/rules/auto-build-memory.md`
- `/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ă
```
Verifică dacă fișierul există și poate fi citit.
Dacă nu există, afișează eroare și sugestii.
```
Dacă `$ARGUMENTS` este gol, afișează:
```
⚠️ 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/*-memory.md (alte plugins)
```
### 2. Detectează Formatul
- Markdown cu `## Patterns` și `## Gotchas` → parsează secțiuni
- JSON cu array-uri → convertește direct
- Alt format → eroare cu instrucțiuni
### 3. Extrage Entries
Pentru fiecare pattern/gotcha găsit:
- Titlu (din ### heading)
- Descriere/Problem/Solution
- Tags (dacă există)
- Data descoperirii (dacă există, altfel data curentă)
### 4. Prezintă Preview
```
📥 Am găsit în {file}:
- {N} patterns
- {M} gotchas
Preview:
1. [PATTERN] {Titlu1}
2. [PATTERN] {Titlu2}
3. [GOTCHA] {Titlu3}
...
Vrei să le import toate în claude-learn-memory.md?
- [all] - Importă toate
- [1, 3, 5] - Selectează specific
- [none] - Anulează
```
### 5. Verifică Duplicate
Pentru fiecare entry:
- Verifică dacă există deja în claude-learn-memory.md (după titlu)
- Dacă există → skip și raportează
- Dacă nu există → adaugă
### 6. Merge și Salvează
- Dacă `.claude/rules/claude-learn-memory.md` nu există, creează-l cu template gol
- Adaugă entries noi la claude-learn-memory.md
- Păstrează ordinea: Patterns apoi Gotchas
- Actualizează statisticile
### 7. Confirmă
```
✅ Import complet:
- {X} patterns importate (Y skipped - duplicate)
- {Z} gotchas importate
Statistici actualizate: {total} patterns, {total} gotchas
```
## Exemple Utilizare
```bash
# Import din auto-build memory (comun pentru proiecte cu auto-build plugin)
/learn:import .claude/rules/auto-build-memory.md
# Import din alt proiect
/learn:import /path/to/other-project/.claude/rules/memory.md
# Import din JSON backup
/learn:import ./backup/memories.json
```
## 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: []}
```

View File

@@ -0,0 +1,95 @@
---
description: Sintetizează patterns din mai multe sesiuni și curăță duplicatele
---
# Reflecție și Sinteză Memory
Analizează toate patterns și gotchas și:
1. Identifică duplicate sau suprapuneri
2. Consolidează patterns similare
3. Identifică patterns care lipsesc din CLAUDE.md principal
4. Propune actualizări pentru CLAUDE.md proiect
## Workflow
### 1. Citește Memory
Citește `.claude/rules/claude-learn-memory.md`
Dacă fișierul nu există:
```
Nu există încă un fișier de memorie.
Rulează /learn:analyze pentru a crea primul entry.
```
### 2. Analizează Conținut
#### Duplicate
- Identifică patterns/gotchas cu titluri similare
- Propune consolidare
#### Patterns Frecvente
- Identifică tags care apar de 3+ ori
- Aceste patterns sunt candidați pentru CLAUDE.md principal
#### Patterns Învechite
- Identifică entries mai vechi de 90 zile fără utilizare
- Propune arhivare sau ștergere
### 3. Prezintă Raport
```
📊 Raport Reflecție Memory
Statistici curente:
- {N} patterns
- {M} gotchas
- {K} tags unice
🔄 Duplicate găsite: {X}
- "{Pattern A}" și "{Pattern B}" sunt similare
⭐ Candidați pentru CLAUDE.md: {Y}
- Tag "vue" apare în 5 patterns → propun secțiune Vue în CLAUDE.md
- Tag "api" apare în 4 patterns → propun secțiune API în CLAUDE.md
🗑️ Posibil învechite: {Z}
- "{Gotcha veche}" - 120 zile, nicio referință
Ce vrei să fac?
- [consolidate] - Consolidează duplicatele
- [promote] - Mută candidații în CLAUDE.md
- [archive] - Arhivează entries vechi
- [all] - Toate acțiunile
- [none] - Doar raportul
```
### 4. Consolidează Duplicate (dacă selectat)
- Merge entries similare
- Păstrează cel mai recent/complet
- Actualizează statistici
### 5. Promovează în CLAUDE.md (dacă selectat)
- Identifică CLAUDE.md din proiect
- Propune secțiuni noi bazate pe patterns frecvente
- Prezintă diff pentru aprobare
- După aprobare, actualizează CLAUDE.md
### 6. Arhivează Vechi (dacă selectat)
- Mută entries vechi la sfârșitul fișierului într-o secțiune `## Archived`
- Sau șterge complet (cu confirmare)
### 7. Confirmă
```
✅ Reflecție completă:
- {X} duplicate consolidate
- {Y} patterns promovate în CLAUDE.md
- {Z} entries arhivate
Statistici actualizate: {total} patterns, {total} gotchas
```
## Când să rulezi /learn:reflect
- După 10+ sesiuni de /learn:analyze
- Când ai 20+ entries în memory
- Înainte de release-uri mari
- Lunar, pentru mentenanță

77
plugin/commands/status.md Normal file
View File

@@ -0,0 +1,77 @@
---
description: Arată statistici memory și patterns frecvente
---
# Status Memory
Afișează statistici despre `.claude/rules/claude-learn-memory.md`.
## Workflow
### 1. Verifică Fișierul
Citește `.claude/rules/claude-learn-memory.md`
Dacă nu există:
```
Nu există încă un fișier 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
```
### 2. Parsează Conținut
- Numără patterns (secțiunea ## Patterns)
- Numără gotchas (secțiunea ## Gotchas)
- Extrage tags
- Calculează statistici
### 3. Afișează Raport
```
📊 Claude Learn Memory Status
📁 Fișier: .claude/rules/claude-learn-memory.md
📈 Statistici:
- Total patterns: {N}
- Total gotchas: {M}
- Tags unice: {K}
- Ultima sesiune: {YYYY-MM-DD}
- Sesiuni înregistrate: {S}
🏷️ Top 5 Tags:
1. vue (8 entries)
2. api (5 entries)
3. typescript (4 entries)
4. database (3 entries)
5. auth (3 entries)
📅 Activitate Recentă (ultimele 7 zile):
- {X} patterns adăugate
- {Y} gotchas adăugate
💡 Sugestii:
{Dacă > 20 entries fără reflect}
- Rulează /learn:reflect pentru a consolida memory
{Dacă ultimul entry > 14 zile}
- Nu ai salvat lecții recent. Rulează /learn:analyze după sesiuni importante.
{Dacă există duplicate evidente}
- Am detectat {N} posibile duplicate. Rulează /learn:reflect.
```
## Output Minimal (fără sugestii)
Dacă memory-ul e în stare bună:
```
📊 Claude Learn Memory: {N} patterns, {M} gotchas
Ultima actualizare: {YYYY-MM-DD}
Top tags: vue, api, typescript
```

17
plugin/hooks/hooks.json Normal file
View File

@@ -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
}
]
}
]
}
}

View File

@@ -0,0 +1,82 @@
---
paths: ".claude/rules/claude-learn-memory.md"
---
# Claude Learn Memory Format
Acest fișier definește formatul pentru `.claude/rules/claude-learn-memory.md`.
## Template Gol
```markdown
# Claude Learn Memory
Patterns și Gotchas învățate din sesiuni de lucru.
---
## Patterns
<!-- Patterns vor fi adăugate aici -->
---
## Gotchas
<!-- Gotchas vor fi adăugate aici -->
---
## Memory Statistics
- **Total Patterns**: 0
- **Total Gotchas**: 0
- **Last Session**: -
- **Sessions Recorded**: 0
```
## 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)`

View File

@@ -0,0 +1,29 @@
{
"pattern": {
"title": "",
"discovered": "",
"feature": "",
"description": "",
"example": {
"file": "",
"lines": "",
"language": "",
"code": ""
},
"tags": []
},
"gotcha": {
"title": "",
"discovered": "",
"feature": "",
"problem": "",
"solution": "",
"tags": []
},
"statistics": {
"total_patterns": 0,
"total_gotchas": 0,
"last_session": "",
"sessions_recorded": 0
}
}