From d6c71536e74987cc78c84ee8f3e610116277d091 Mon Sep 17 00:00:00 2001 From: Claude Agent Date: Tue, 6 Jan 2026 21:45:31 +0000 Subject: [PATCH] feat: v2.0.0 - Domain-based memory + multi-plugin marketplace structure MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## 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 --- .claude-plugin/marketplace.json | 12 +- CHANGELOG.md | 27 +++ CLAUDE.md | 87 +++++--- README.md | 134 ++++-------- plugin/README.md | 49 ----- plugin/commands/analyze.md | 130 ----------- plugin/commands/import.md | 125 ----------- plugin/commands/reflect.md | 95 -------- plugin/commands/status.md | 77 ------- plugin/rules/memory-format.md | 82 ------- plugin/templates/memory-entry.json | 29 --- .../learn}/.claude-plugin/plugin.json | 4 +- plugins/learn/README.md | 54 +++++ plugins/learn/commands/analyze.md | 205 ++++++++++++++++++ plugins/learn/commands/import.md | 200 +++++++++++++++++ plugins/learn/commands/reflect.md | 202 +++++++++++++++++ plugins/learn/commands/status.md | 135 ++++++++++++ {plugin => plugins/learn}/hooks/hooks.json | 0 plugins/learn/rules/memory-format.md | 140 ++++++++++++ plugins/learn/templates/domain-memory.md | 28 +++ plugins/learn/templates/domains-config.md | 42 ++++ plugins/learn/templates/memory-entry.json | 51 +++++ 22 files changed, 1192 insertions(+), 716 deletions(-) delete mode 100644 plugin/README.md delete mode 100644 plugin/commands/analyze.md delete mode 100644 plugin/commands/import.md delete mode 100644 plugin/commands/reflect.md delete mode 100644 plugin/commands/status.md delete mode 100644 plugin/rules/memory-format.md delete mode 100644 plugin/templates/memory-entry.json rename {plugin => plugins/learn}/.claude-plugin/plugin.json (69%) create mode 100644 plugins/learn/README.md create mode 100644 plugins/learn/commands/analyze.md create mode 100644 plugins/learn/commands/import.md create mode 100644 plugins/learn/commands/reflect.md create mode 100644 plugins/learn/commands/status.md rename {plugin => plugins/learn}/hooks/hooks.json (100%) create mode 100644 plugins/learn/rules/memory-format.md create mode 100644 plugins/learn/templates/domain-memory.md create mode 100644 plugins/learn/templates/domains-config.md create mode 100644 plugins/learn/templates/memory-entry.json diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json index 39be798..658df9b 100644 --- a/.claude-plugin/marketplace.json +++ b/.claude-plugin/marketplace.json @@ -1,18 +1,18 @@ { - "name": "romfast-tools", + "name": "romfast-plugins", "owner": { "name": "Romfast Team" }, "metadata": { - "description": "Claude Code plugins for learning and memory" + "description": "Claude Code plugins by Romfast Team" }, "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"] + "source": "./plugins/learn", + "description": "Domain-based memory with selective loading via paths frontmatter", + "version": "2.0.0", + "keywords": ["learn", "memory", "patterns", "gotchas", "domains"] } ] } diff --git a/CHANGELOG.md b/CHANGELOG.md index 7cc216f..67a730b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,33 @@ 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.0.0] - 2026-01-06 + +### Changed (Repository) +- **Reorganized for multi-plugin marketplace**: `plugin/` → `plugins/learn/` +- Repository to be renamed: `claude-learn` → `claude-plugins` +- Updated marketplace.json source path + +### Added +- **Domain-based memory**: Memory is now split into domains (backend, frontend, database, testing, deployment, global) +- **Selective loading via `paths` frontmatter**: Each domain file has a `paths:` frontmatter that triggers loading only when working with matching files +- **Automatic domain detection**: `/learn:analyze` detects the domain based on file paths in the conversation +- **Automatic pattern suggestion**: When creating new domains, glob patterns are auto-generated from conversation files +- **Cross-domain analysis**: `/learn:reflect` now analyzes duplicates and misplaced entries across domains +- **Domain configuration file**: `.claude/rules/claude-learn-domains.md` for user-editable domain definitions +- New templates: `domains-config.md`, `domain-memory.md` + +### Changed +- `/learn:analyze` now prompts for domain confirmation before saving +- `/learn:status` aggregates statistics from all domain files with breakdown table +- `/learn:import` routes entries to appropriate domains with detection +- `/learn:reflect` includes cross-domain duplicate detection and domain migration suggestions +- Memory files now use format `claude-learn-{domain}.md` instead of single `claude-learn-memory.md` + +### Migration +- Run `/learn:import .claude/rules/claude-learn-memory.md` to migrate from v1.0 format +- Old format is auto-detected and migration is offered + ## [1.0.0] - 2025-01-06 ### Added diff --git a/CLAUDE.md b/CLAUDE.md index 5f0800b..851643f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,44 +1,79 @@ # CLAUDE.md -Development instructions for the claude-learn plugin. +Development instructions for the claude-plugins repository. -## Project Structure +## Repository 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 +claude-plugins/ +├── .claude-plugin/ +│ └── marketplace.json # Lists all plugins +├── plugins/ +│ └── learn/ # Learn plugin +│ ├── .claude-plugin/plugin.json +│ ├── commands/ # Slash commands +│ ├── hooks/ # Event hooks +│ ├── rules/ # Rule files +│ └── templates/ # Templates +├── README.md # Marketplace README +├── CLAUDE.md # This file +└── CHANGELOG.md # Version history ``` -## Key Decisions +## Adding a New Plugin -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 +1. Create plugin directory: + ```bash + mkdir -p plugins/new-plugin/.claude-plugin + mkdir -p plugins/new-plugin/commands + ``` + +2. Create `plugins/new-plugin/.claude-plugin/plugin.json`: + ```json + { + "name": "new-plugin", + "description": "What the plugin does", + "version": "1.0.0", + "author": { "name": "Romfast Team" } + } + ``` + +3. Add to `.claude-plugin/marketplace.json`: + ```json + { + "name": "new-plugin", + "source": "./plugins/new-plugin", + "description": "...", + "version": "1.0.0", + "keywords": [...] + } + ``` + +4. Create commands in `plugins/new-plugin/commands/` ## Testing ```bash -# Test locally -claude --plugin-dir ./plugin +# Test specific plugin +claude --plugin-dir ./plugins/learn # Verify commands appear /learn:status ``` -## Release Process +## Git -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` +```bash +git remote: git@gitea.romfast.ro:romfast/claude-plugins.git +git push origin main +``` + +## Learn Plugin Details + +See [plugins/learn/README.md](./plugins/learn/README.md) for full documentation. + +Key files: +- `plugins/learn/commands/analyze.md` - Main analysis command +- `plugins/learn/commands/status.md` - Statistics display +- `plugins/learn/commands/import.md` - Import from other formats +- `plugins/learn/commands/reflect.md` - Cross-domain consolidation diff --git a/README.md b/README.md index 41d5a52..3de9100 100644 --- a/README.md +++ b/README.md @@ -1,127 +1,71 @@ -# Claude Learn +# Romfast Claude Code Plugins -A Claude Code plugin for capturing lessons learned during development sessions. +A collection of Claude Code plugins by Romfast Team. -## Features +## Available Plugins -- **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 +| Plugin | Description | Version | +|--------|-------------|---------| +| [learn](./plugins/learn/) | Domain-based memory with selective loading | 2.0.0 | ## Installation -### Option 1: Marketplace (Recommended) +### 1. Add Marketplace Add to your `~/.claude/settings.json`: ```json { "plugin-marketplaces": [ - "git@gitea.romfast.ro:romfast/claude-learn.git" + "git@gitea.romfast.ro:romfast/claude-plugins.git" ] } ``` -Then install: +### 2. Install Plugin ```bash -claude plugin install learn@romfast-tools +claude plugin install learn@romfast-plugins ``` -### Option 2: Direct from Git +## Plugins -```bash -git clone git@gitea.romfast.ro:romfast/claude-learn.git -claude --plugin-dir /path/to/claude-learn/plugin -``` +### learn -## Commands +Captures lessons learned (patterns & gotchas) during development sessions with **domain-based memory** and **selective loading**. -| 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 ` | Import from another memory file | -| `/learn:reflect` | Consolidate and clean up memory | -| `/learn:status` | Show memory statistics | +**Features:** +- Automatic session analysis with `/learn:analyze` +- Domain organization (backend, frontend, database, testing, etc.) +- Selective loading via `paths` frontmatter +- Import from other memory formats +- Cross-domain consolidation with `/learn:reflect` -## Usage Flow +[Full documentation →](./plugins/learn/README.md) + +## Repository Structure ``` -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 +claude-plugins/ +├── .claude-plugin/ +│ └── marketplace.json # Plugin registry +├── plugins/ +│ └── learn/ # Learn plugin +│ ├── .claude-plugin/plugin.json +│ ├── commands/ +│ ├── hooks/ +│ ├── rules/ +│ └── templates/ +├── README.md # This file +└── CLAUDE.md # Development instructions ``` -## Memory File Format +## Adding a New Plugin -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 - -\``` - -**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 +1. Create directory: `plugins/your-plugin/` +2. Add `.claude-plugin/plugin.json` with metadata +3. Add plugin to `marketplace.json` +4. Create commands, hooks, rules as needed ## License diff --git a/plugin/README.md b/plugin/README.md deleted file mode 100644 index 5cdba33..0000000 --- a/plugin/README.md +++ /dev/null @@ -1,49 +0,0 @@ -# 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. diff --git a/plugin/commands/analyze.md b/plugin/commands/analyze.md deleted file mode 100644 index 6cfa5ab..0000000 --- a/plugin/commands/analyze.md +++ /dev/null @@ -1,130 +0,0 @@ ---- -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 diff --git a/plugin/commands/import.md b/plugin/commands/import.md deleted file mode 100644 index e597332..0000000 --- a/plugin/commands/import.md +++ /dev/null @@ -1,125 +0,0 @@ ---- -description: Importă patterns și gotchas din alte fișiere de memorie -argument-hint: - 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: []} -``` diff --git a/plugin/commands/reflect.md b/plugin/commands/reflect.md deleted file mode 100644 index 2b2af9f..0000000 --- a/plugin/commands/reflect.md +++ /dev/null @@ -1,95 +0,0 @@ ---- -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ță diff --git a/plugin/commands/status.md b/plugin/commands/status.md deleted file mode 100644 index 654cf80..0000000 --- a/plugin/commands/status.md +++ /dev/null @@ -1,77 +0,0 @@ ---- -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 - 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 -``` diff --git a/plugin/rules/memory-format.md b/plugin/rules/memory-format.md deleted file mode 100644 index 4f3f6f7..0000000 --- a/plugin/rules/memory-format.md +++ /dev/null @@ -1,82 +0,0 @@ ---- -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 - - - ---- - -## Gotchas - - - ---- - -## 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)` diff --git a/plugin/templates/memory-entry.json b/plugin/templates/memory-entry.json deleted file mode 100644 index d3044f1..0000000 --- a/plugin/templates/memory-entry.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "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 - } -} diff --git a/plugin/.claude-plugin/plugin.json b/plugins/learn/.claude-plugin/plugin.json similarity index 69% rename from plugin/.claude-plugin/plugin.json rename to plugins/learn/.claude-plugin/plugin.json index 79ee6a6..f70ee44 100644 --- a/plugin/.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", - "version": "1.0.0", + "description": "Claude Learn: Session analysis for patterns and gotchas with domain-based memory", + "version": "2.0.0", "author": { "name": "Romfast Team" } diff --git a/plugins/learn/README.md b/plugins/learn/README.md new file mode 100644 index 0000000..53b2230 --- /dev/null +++ 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 ` | 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 diff --git a/plugins/learn/commands/analyze.md b/plugins/learn/commands/analyze.md new file mode 100644 index 0000000..3a98950 --- /dev/null +++ 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 +``` diff --git a/plugins/learn/commands/import.md b/plugins/learn/commands/import.md new file mode 100644 index 0000000..f3ca176 --- /dev/null +++ b/plugins/learn/commands/import.md @@ -0,0 +1,200 @@ +--- +description: Importă patterns și gotchas din alte fișiere de memorie +argument-hint: - 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: []} +``` diff --git a/plugins/learn/commands/reflect.md b/plugins/learn/commands/reflect.md new file mode 100644 index 0000000..4e401b1 --- /dev/null +++ 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ță diff --git a/plugins/learn/commands/status.md b/plugins/learn/commands/status.md new file mode 100644 index 0000000..55c38b4 --- /dev/null +++ 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 - 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) +``` diff --git a/plugin/hooks/hooks.json b/plugins/learn/hooks/hooks.json similarity index 100% rename from plugin/hooks/hooks.json rename to plugins/learn/hooks/hooks.json diff --git a/plugins/learn/rules/memory-format.md b/plugins/learn/rules/memory-format.md new file mode 100644 index 0000000..ea781b6 --- /dev/null +++ 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` diff --git a/plugins/learn/templates/domain-memory.md b/plugins/learn/templates/domain-memory.md new file mode 100644 index 0000000..576d468 --- /dev/null +++ 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 + + + +--- + +## Gotchas + + + +--- + +## Domain Statistics + +- **Total Patterns**: 0 +- **Total Gotchas**: 0 +- **Last Session**: - +- **Sessions Recorded**: 0 diff --git a/plugins/learn/templates/domains-config.md b/plugins/learn/templates/domains-config.md new file mode 100644 index 0000000..cb75863 --- /dev/null +++ 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ță. diff --git a/plugins/learn/templates/memory-entry.json b/plugins/learn/templates/memory-entry.json new file mode 100644 index 0000000..2784b8e --- /dev/null +++ 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": [] + } + } +}