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