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

## Domain-based Memory (v2.0.0)
- Memory split into domains (backend, frontend, database, testing, deployment, global)
- Selective loading via `paths` frontmatter - only relevant memories load
- Automatic domain detection from file paths in conversation
- Auto-generated glob patterns when creating new domains
- Cross-domain analysis in /learn:reflect

## Repository Reorganization
- Restructured for multi-plugin marketplace: plugin/ → plugins/learn/
- Marketplace renamed: romfast-tools → romfast-plugins
- Repository to be renamed on Gitea: claude-learn → claude-plugins

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Claude Agent
2026-01-06 21:45:31 +00:00
parent 30b73ac7e6
commit d6c71536e7
22 changed files with 1192 additions and 716 deletions

View File

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

View File

@@ -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/), 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). 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 ## [1.0.0] - 2025-01-06
### Added ### Added

View File

@@ -1,44 +1,79 @@
# CLAUDE.md # CLAUDE.md
Development instructions for the claude-learn plugin. Development instructions for the claude-plugins repository.
## Project Structure ## Repository Structure
``` ```
claude-learn/ claude-plugins/
├── .claude-plugin/marketplace.json # Marketplace entry ├── .claude-plugin/
├── plugin/ # Plugin code │ └── marketplace.json # Lists all plugins
│ ├── .claude-plugin/plugin.json # Plugin manifest ├── plugins/
│ └── learn/ # Learn plugin
│ ├── .claude-plugin/plugin.json
│ ├── commands/ # Slash commands │ ├── commands/ # Slash commands
│ ├── hooks/ # Event hooks │ ├── hooks/ # Event hooks
│ ├── rules/ # Rule files │ ├── rules/ # Rule files
│ └── templates/ # JSON templates └── templates/ # Templates
├── README.md # User documentation ├── README.md # Marketplace README
├── CLAUDE.md # This file ├── CLAUDE.md # This file
└── CHANGELOG.md # Version history └── CHANGELOG.md # Version history
``` ```
## Key Decisions ## Adding a New Plugin
1. **Single Memory File**: Plugin uses only `.claude/rules/claude-learn-memory.md` 1. Create plugin directory:
2. **Import for Migration**: Use `/learn:import` to bring in existing memories ```bash
3. **User Confirmation**: Always list proposals before saving mkdir -p plugins/new-plugin/.claude-plugin
4. **Stop Hook**: Suggests, doesn't auto-run 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 ## Testing
```bash ```bash
# Test locally # Test specific plugin
claude --plugin-dir ./plugin claude --plugin-dir ./plugins/learn
# Verify commands appear # Verify commands appear
/learn:status /learn:status
``` ```
## Release Process ## Git
1. Update version in `plugin/.claude-plugin/plugin.json` ```bash
2. Update version in `.claude-plugin/marketplace.json` git remote: git@gitea.romfast.ro:romfast/claude-plugins.git
3. Update CHANGELOG.md git push origin main
4. Commit and push to main ```
5. Tag release: `git tag v1.0.0 && git push --tags`
## 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

134
README.md
View File

@@ -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 | Plugin | Description | Version |
- **Pattern & Gotcha Tracking**: Structured format for reusable solutions and problems to avoid |--------|-------------|---------|
- **Import Support**: Bring in existing memories from other formats | [learn](./plugins/learn/) | Domain-based memory with selective loading | 2.0.0 |
- **Reflection Tools**: Consolidate and promote patterns to CLAUDE.md
## Installation ## Installation
### Option 1: Marketplace (Recommended) ### 1. Add Marketplace
Add to your `~/.claude/settings.json`: Add to your `~/.claude/settings.json`:
```json ```json
{ {
"plugin-marketplaces": [ "plugin-marketplaces": [
"git@gitea.romfast.ro:romfast/claude-learn.git" "git@gitea.romfast.ro:romfast/claude-plugins.git"
] ]
} }
``` ```
Then install: ### 2. Install Plugin
```bash ```bash
claude plugin install learn@romfast-tools claude plugin install learn@romfast-plugins
``` ```
### Option 2: Direct from Git ## Plugins
```bash ### learn
git clone git@gitea.romfast.ro:romfast/claude-learn.git
claude --plugin-dir /path/to/claude-learn/plugin
```
## Commands Captures lessons learned (patterns & gotchas) during development sessions with **domain-based memory** and **selective loading**.
| Command | Description | **Features:**
|---------|-------------| - Automatic session analysis with `/learn:analyze`
| `/learn:analyze` | Analyze conversation and propose lessons | - Domain organization (backend, frontend, database, testing, etc.)
| `/learn:analyze auto` | Auto-detect all categories | - Selective loading via `paths` frontmatter
| `/learn:analyze patterns` | Focus on patterns only | - Import from other memory formats
| `/learn:analyze gotchas` | Focus on gotchas only | - Cross-domain consolidation with `/learn:reflect`
| `/learn:import <file>` | Import from another memory file |
| `/learn:reflect` | Consolidate and clean up memory |
| `/learn:status` | Show memory statistics |
## Usage Flow [Full documentation →](./plugins/learn/README.md)
## Repository Structure
``` ```
1. Work normally with Claude Code claude-plugins/
├── .claude-plugin/
2. Claude finishes a significant response │ └── marketplace.json # Plugin registry
├── plugins/
3. Stop Hook analyzes (15s) │ └── learn/ # Learn plugin
│ ├── .claude-plugin/plugin.json
4. "💡 Run /learn:analyze to capture lessons" │ ├── commands/
│ ├── hooks/
5. User: /learn:analyze │ ├── rules/
│ └── templates/
6. Claude lists proposals (patterns, gotchas) ├── README.md # This file
└── CLAUDE.md # Development instructions
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 ## Adding a New Plugin
The plugin creates and maintains `.claude/rules/claude-learn-memory.md` with this structure: 1. Create directory: `plugins/your-plugin/`
2. Add `.claude-plugin/plugin.json` with metadata
```markdown 3. Add plugin to `marketplace.json`
# Claude Learn Memory 4. Create commands, hooks, rules as needed
## 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 ## License

View File

@@ -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.

View File

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

View File

@@ -1,125 +0,0 @@
---
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

@@ -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ță

View File

@@ -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 <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
```

View File

@@ -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
<!-- 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

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

View File

@@ -1,7 +1,7 @@
{ {
"name": "learn", "name": "learn",
"description": "Claude Learn: Session analysis for patterns and gotchas", "description": "Claude Learn: Session analysis for patterns and gotchas with domain-based memory",
"version": "1.0.0", "version": "2.0.0",
"author": { "author": {
"name": "Romfast Team" "name": "Romfast Team"
} }

54
plugins/learn/README.md Normal file
View File

@@ -0,0 +1,54 @@
# Claude Learn
A Claude Code plugin for capturing lessons learned during development sessions with **domain-based memory** and **selective loading**.
## Installation
```bash
claude plugin install learn@romfast-plugins
```
## Commands
| Command | Description |
|---------|-------------|
| `/learn:analyze` | Analyze conversation and propose lessons |
| `/learn:status` | Show memory statistics by domain |
| `/learn:import <file>` | Import from another memory file |
| `/learn:reflect` | Consolidate and clean up memory |
## Features
- **Domain-based memory**: Organized by backend, frontend, database, testing, etc.
- **Selective loading**: Only relevant memories load via `paths` frontmatter
- **Automatic domain detection**: Detects domain from files in conversation
- **Auto-generated patterns**: Glob patterns suggested when creating new domains
## Plugin Structure
```
learn/
├── .claude-plugin/plugin.json
├── commands/
│ ├── analyze.md
│ ├── import.md
│ ├── reflect.md
│ └── status.md
├── hooks/hooks.json
├── rules/memory-format.md
├── templates/
│ ├── domain-memory.md
│ ├── domains-config.md
│ └── memory-entry.json
└── README.md
```
## Development
```bash
claude --plugin-dir ./plugins/learn
```
## License
MIT

View File

@@ -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
```

View File

@@ -0,0 +1,200 @@
---
description: Importă patterns și gotchas din alte fișiere de memorie
argument-hint: <file-path> - Calea către fișierul sursă (ex: .claude/rules/auto-build-memory.md)
---
# Import Memorie din Alt Fișier
Importă patterns și gotchas dintr-un fișier existent și le distribuie pe domenii.
## Argument: $ARGUMENTS
Calea către fișierul sursă. Exemple:
- `.claude/rules/auto-build-memory.md`
- `.claude/rules/claude-learn-memory.md` (format vechi, pentru migrare)
- `/path/to/other-project/.claude/rules/memory.md`
- `./backup/memories.json`
## Fișiere Suportate
- `.claude/rules/auto-build-memory.md` (format auto-build plugin)
- `.claude/rules/*.md` (orice fișier markdown cu secțiuni Patterns/Gotchas)
- Fișiere JSON cu structură `{patterns: [], gotchas: []}`
## Workflow
### 1. Verifică Fișierul Sursă
Dacă `$ARGUMENTS` este gol:
```
⚠️ Specifică fișierul sursă:
/learn:import .claude/rules/auto-build-memory.md
Fișiere comune de importat:
- .claude/rules/auto-build-memory.md (auto-build plugin)
- .claude/rules/claude-learn-memory.md (format vechi, pentru migrare)
- .claude/rules/*-memory.md (alte plugins)
```
### 2. Încarcă Configurația Domeniilor
Citește `.claude/rules/claude-learn-domains.md` pentru patterns.
Dacă nu există, creează-l din template.
### 3. Detectează Formatul și Extrage Entries
- Markdown cu `## Patterns` și `## Gotchas` → parsează secțiuni
- JSON cu array-uri → convertește direct
- Alt format → eroare cu instrucțiuni
Pentru fiecare pattern/gotcha găsit, extrage:
- Titlu (din ### heading)
- Descriere/Problem/Solution
- Tags (dacă există)
- Exemple cu path-uri (dacă există)
- Data descoperirii (dacă există, altfel data curentă)
### 4. Detectează Domeniul pentru Fiecare Entry
Pentru fiecare entry:
#### 4.1 Încearcă detectare din path-uri în exemple
```
**Example** (`src/api/users.ts:45`)
→ match cu src/api/**/*.ts → backend
```
#### 4.2 Dacă nu găsește path, încearcă din tags
```
**Tags**: api, middleware, express
→ "api" sugerează backend
```
#### 4.3 Dacă nici tags nu match-uiesc, marchează ca "unassigned"
### 5. Prezintă Preview cu Domenii
```
📥 Am găsit în {file}:
- {N} patterns
- {M} gotchas
Preview cu domenii detectate:
[backend] (5 entries)
1. [PATTERN] API Rate Limiting
2. [PATTERN] Error Response Format
3. [GOTCHA] TypeScript enum import
...
[frontend] (3 entries)
4. [PATTERN] Vue Watch Immediate
5. [GOTCHA] CSS Grid IE11
...
[unassigned] (2 entries)
6. [PATTERN] Git Commit Hooks
7. [GOTCHA] Memory Leak Detection
Opțiuni:
- [all] - Importă toate în domeniile detectate
- [1, 3, 5] - Selectează specific
- [move 6 deployment] - Mută entry 6 în domeniul deployment
- [none] - Anulează
```
### 6. Procesează Entries "Unassigned"
Pentru fiecare entry fără domeniu clar:
```
📁 Entry: "Git Commit Hooks"
Nu am putut detecta automat domeniul.
Alege domeniu:
1. backend
2. frontend
3. deployment
4. testing
5. global
6. [nou] Creează domeniu nou
Sau: [skip] pentru a sări peste acest entry
```
### 7. Verifică Duplicate
Pentru fiecare entry și domeniul țintă:
- Verifică dacă există deja în `claude-learn-{domain}.md` (după titlu)
- Dacă există → skip și raportează
- Dacă nu există → adaugă
### 8. Salvează în Fișierele Corespunzătoare
Pentru fiecare domeniu cu entries:
- Dacă fișierul nu există, creează-l din template cu frontmatter
- Adaugă entries noi
- Păstrează ordinea: Patterns apoi Gotchas
- Actualizează statisticile
### 9. Confirmă
```
✅ Import complet:
┌────────────┬──────────┬─────────┬─────────┐
│ Domain │ Patterns │ Gotchas │ Skipped │
├────────────┼──────────┼─────────┼─────────┤
│ backend │ 3 │ 1 │ 0 │
│ frontend │ 2 │ 1 │ 1 │
│ deployment │ 1 │ 0 │ 0 │
├────────────┼──────────┼─────────┼─────────┤
│ TOTAL │ 6 │ 2 │ 1 │
└────────────┴──────────┴─────────┴─────────┘
Skipped (duplicate): "Vue Watch Immediate" (deja în frontend)
```
### 10. Opțional: Curățare Fișier Sursă
Dacă importul a fost din formatul vechi (`claude-learn-memory.md`):
```
🗑️ Vrei să șterg fișierul vechi claude-learn-memory.md? [y/n]
- y → șterge (sau redenumește în .backup)
- n → păstrează
```
## Exemple Utilizare
```bash
# Migrare din format vechi
/learn:import .claude/rules/claude-learn-memory.md
# Import din auto-build memory
/learn:import .claude/rules/auto-build-memory.md
# Import din alt proiect
/learn:import /path/to/other-project/.claude/rules/memory.md
```
## Tratare Erori
Dacă fișierul nu există:
```
❌ Fișierul nu a fost găsit: {path}
Verifică:
1. Calea este corectă
2. Fișierul există
3. Ai permisiuni de citire
```
Dacă formatul nu este recunoscut:
```
❌ Format nerecunoscut pentru: {path}
Formate suportate:
- Markdown cu secțiuni ## Patterns și ## Gotchas
- JSON cu structură {patterns: [], gotchas: []}
```

View File

@@ -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ță

View File

@@ -0,0 +1,135 @@
---
description: Arată statistici memory și patterns frecvente
---
# Status Memory
Afișează statistici agregate din toate fișierele de memorie pe domenii.
## Workflow
### 1. Scanează Fișierele de Memorie
Caută toate fișierele `.claude/rules/claude-learn-*.md`:
- `claude-learn-backend.md`
- `claude-learn-frontend.md`
- `claude-learn-database.md`
- `claude-learn-testing.md`
- `claude-learn-deployment.md`
- `claude-learn-global.md`
- + orice domeniu custom
Ignoră:
- `claude-learn-domains.md` (config, nu memorie)
- `claude-learn-memory.md` (format vechi, dacă există)
### 2. Verifică Existența
Dacă nu există niciun fișier de memorie:
```
Nu există încă fișiere de memorie.
Pentru a începe:
1. Lucrează normal cu Claude Code
2. Când termini o sesiune semnificativă, rulează /learn:analyze
3. Sau importă memorie existentă cu /learn:import
Comenzi disponibile:
- /learn:analyze - Analizează conversația curentă
- /learn:import <file> - Importă din alt fișier
- /learn:reflect - Consolidează și curăță memory
```
Dacă există doar formatul vechi (`claude-learn-memory.md`):
```
⚠️ Detectat format vechi de memorie.
Rulează /learn:import .claude/rules/claude-learn-memory.md
pentru a migra către noul sistem cu domenii.
```
### 3. Parsează Fiecare Fișier
Pentru fiecare `claude-learn-{domain}.md`:
- Numără patterns (secțiunea ## Patterns)
- Numără gotchas (secțiunea ## Gotchas)
- Extrage tags
- Extrage data ultimei actualizări
### 4. Afișează Raport Agregat
```
📊 Claude Learn Memory Status
┌────────────┬──────────┬─────────┬─────────────┐
│ Domain │ Patterns │ Gotchas │ Last Update │
├────────────┼──────────┼─────────┼─────────────┤
│ backend │ 12 │ 5 │ 2025-01-06 │
│ frontend │ 8 │ 3 │ 2025-01-05 │
│ database │ 4 │ 2 │ 2025-01-04 │
│ testing │ 3 │ 1 │ 2025-01-03 │
│ global │ 2 │ 1 │ 2025-01-06 │
├────────────┼──────────┼─────────┼─────────────┤
│ TOTAL │ 29 │ 12 │ - │
└────────────┴──────────┴─────────┴─────────────┘
🏷️ Top 5 Tags (global):
1. typescript (15 entries)
2. api (12 entries)
3. vue (8 entries)
4. database (6 entries)
5. auth (5 entries)
📅 Activitate Recentă (ultimele 7 zile):
- 5 patterns adăugate
- 2 gotchas adăugate
💡 Sugestii:
{Dacă > 20 entries în vreun domeniu}
- Domeniul {domain} are multe entries. Rulează /learn:reflect.
{Dacă niciun entry în ultimele 14 zile}
- Nu ai salvat lecții recent. Rulează /learn:analyze după sesiuni importante.
{Dacă există posibile duplicate cross-domain}
- Am detectat entries similare în {domain1} și {domain2}. Consideră mutarea în global.
```
### 5. Detalii per Domeniu (opțional)
Dacă utilizatorul întreabă despre un domeniu specific:
```
/learn:status backend
```
Afișează detalii extinse pentru acel domeniu:
```
📊 Domeniu: backend
📁 Fișier: .claude/rules/claude-learn-backend.md
📌 Patterns: src/api/**/*.ts, src/server/**/*.ts, services/**/*
📈 Statistici:
- Patterns: 12
- Gotchas: 5
- Tags unice: 8
- Ultima sesiune: 2025-01-06
- Sesiuni înregistrate: 4
🏷️ Tags în acest domeniu:
api (7), middleware (4), auth (3), validation (2), error-handling (2)
📋 Entries Recente:
1. [PATTERN] API Rate Limiting (2025-01-06)
2. [GOTCHA] TypeScript enum import (2025-01-06)
3. [PATTERN] Error Response Format (2025-01-05)
```
## Output Minimal
Pentru afișare rapidă (dacă totul e în stare bună):
```
📊 Claude Learn: 29 patterns, 12 gotchas în 5 domenii
Ultima actualizare: 2025-01-06
Top domains: backend (17), frontend (11)
```

View File

@@ -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`

View File

@@ -0,0 +1,28 @@
---
paths: {DOMAIN_PATTERNS}
---
# Claude Learn Memory: {DOMAIN_NAME}
Patterns și Gotchas pentru domeniul **{DOMAIN_NAME}**.
---
## Patterns
<!-- Patterns vor fi adăugate aici -->
---
## Gotchas
<!-- Gotchas vor fi adăugate aici -->
---
## Domain Statistics
- **Total Patterns**: 0
- **Total Gotchas**: 0
- **Last Session**: -
- **Sessions Recorded**: 0

View File

@@ -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ță.

View File

@@ -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": []
}
}
}