From ea9ca80e54d3e3b36ecce0aa253a804307cfc7cb Mon Sep 17 00:00:00 2001 From: martin Date: Wed, 4 Feb 2026 22:48:49 +0100 Subject: [PATCH] up --- IMPLEMENTATION-SUMMARY-NO-CRON.md | 367 ++++++++++++++++ MANUAL-WORKFLOW.md | 402 ++++++++++++++++++ QUICK-START-NO-CRON.md | 354 +++++++++++++++ .../2026-02-04_maintenance-report.md | 107 +++++ scripts/setup-aliases.sh | 66 +++ system/global-instructions.md | 159 ++++++- vault-index.md | 16 +- 7 files changed, 1460 insertions(+), 11 deletions(-) create mode 100644 IMPLEMENTATION-SUMMARY-NO-CRON.md create mode 100644 MANUAL-WORKFLOW.md create mode 100644 QUICK-START-NO-CRON.md create mode 100644 memory/snapshots/2026-02-04_maintenance-report.md create mode 100755 scripts/setup-aliases.sh diff --git a/IMPLEMENTATION-SUMMARY-NO-CRON.md b/IMPLEMENTATION-SUMMARY-NO-CRON.md new file mode 100644 index 0000000..68e5fc7 --- /dev/null +++ b/IMPLEMENTATION-SUMMARY-NO-CRON.md @@ -0,0 +1,367 @@ +# Implementation Summary - Vault Optimization (OHNE Cron-Jobs) +**Datum:** 2026-02-04 +**Version:** 2.0 (No-Cron) +**Status:** ✅ Bereit zur Nutzung + +## 🎯 Änderung zur ursprünglichen Version + +**Original-Plan:** Automatisierung via Cron-Jobs +**Angepasste Version:** Automatisierung via `global-instructions.md` (Context-Aware Triggers) + +**Vorteil:** +- ✅ Keine Hintergrund-Prozesse +- ✅ Claude als proaktiver Assistant (nicht stiller Cron) +- ✅ Volle Kontrolle & Transparenz +- ✅ Context-Aware statt zeitgesteuert + +--- + +## 📄 Erstellt/Aktualisiert + +### Dokumentation (5 Dateien) + +1. **OPTIMIZATION-ROADMAP.md** - Vollständiger 4-Phasen-Plan +2. **QUICK-START-NO-CRON.md** ✨ NEU - Setup ohne Cron-Jobs +3. **MANUAL-WORKFLOW.md** ✨ NEU - Workflow-Beschreibung +4. **IMPLEMENTATION-SUMMARY-NO-CRON.md** ✨ NEU (diese Datei) +5. **system/global-instructions.md** 🔄 ERWEITERT - Context-Aware Triggers + +--- + +### Scripts (7 neue, 1 angepasst) + +1. **log-session.sh** - Session-Logging (manueller Fallback) +2. **analyze-skill-usage.sh** - Skill-Usage-Matrix +3. **update-dashboard.sh** - Dashboard aktualisieren +4. **weekly-health-check.sh** - Health-Check +5. **detect-skill-proposals.sh** - Skill-Proposals erkennen +6. **bash-aliases.sh** - Shortcuts +7. **setup-aliases.sh** ✨ NEU - Alias-Installation (ersetzt setup-cron.sh) +8. ~~setup-cron.sh~~ - Nicht mehr benötigt (optional als Referenz) + +Alle Scripts in `scripts/` und **ausführbar** (chmod +x). + +--- + +### Skills (1 erweitert) + +**vault-janitor** (skills/vault-janitor/SKILL.md) +- ✅ 8 Modi (vorher 4) +- ✅ Neue Modi: propose, sync-projects, anti-pattern-detect, stats +- ✅ Verbesserte Dokumentation + +--- + +### System (1 erweitert) + +**global-instructions.md** (system/global-instructions.md) +- ✅ Session-Start Triggers (Montag, 1. des Monats) +- ✅ Session-Ende Trigger (Log-Erstellung) +- ✅ Projekt-Wechsel Trigger (Memory-Sync) +- ✅ Fehler-Fix Trigger (Anti-Pattern-Detection) +- ✅ Proaktive Wartungsvorschläge + +--- + +## 🤖 Automatisierung via global-instructions.md + +### Context-Aware Triggers (KEINE Cron-Jobs) + +#### Session-Start +``` +Montag: +├─ Dashboard älter als 7 Tage? → Frage: "Aktualisieren?" +├─ ≥5 neue Logs? → Frage: "Pattern-Extraktion?" +└─ ≥3 Proposals? → Info + +1. des Monats: +├─ Health-Check anbieten +├─ Backup-Reminder +└─ Skill-Usage-Matrix aktualisieren anbieten +``` + +#### Session-Ende +``` +Bei "exit", "fertig", "danke": +└─ Frage AUTOMATISCH: "Session-Log erstellen? Beschreibung?" +``` + +#### Projekt-Wechsel +``` +Erkenne neues Projekt: +└─ Führe sync-project-memory.sh aus +``` + +#### Fehler-Fix +``` +Bei Bug-Behebung: +└─ Prüfe Anti-Patterns → Frage: "Dokumentieren?" (falls neu) +``` + +--- + +## ✅ 3-Minuten Setup + +### 1. Aliases installieren +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +source ~/.zshrc +vault-help # Test +``` + +### 2. Dashboard erstellen +```bash +vault-status +``` + +### 3. Fertig! +Claude übernimmt den Rest automatisch. + +--- + +## 📋 Neuer Workflow + +### Vorher (ohne Optimization) +``` +claude → [Arbeit] → exit +``` +→ Wissen verloren ❌ + +### Nachher (mit global-instructions) +``` +claude → [Arbeit] → exit + +Claude: "Session-Log erstellen? Beschreibung?" +Du: "Team-Stats API" +Claude: *erstellt Log automatisch* +``` +→ Wissen gespeichert ✅ + +--- + +## 🎯 Wichtigste Änderungen zu Cron-Version + +| Feature | Cron-Version | No-Cron-Version | +|---------|--------------|-----------------| +| Dashboard-Update | ⏰ Täglich 21:00 | 🤖 Claude fragt montags | +| Health-Check | ⏰ Montag 09:00 | 🤖 Claude fragt monatlich | +| Session-Log | ❌ Manuell | ✅ Claude fragt automatisch | +| Pattern-Extraktion | ❌ Manuell | 🤖 Claude schlägt vor (≥5 Logs) | +| Projekt-Sync | ⏰ Täglich 20:00 | 🤖 Bei Projekt-Wechsel | +| Skill-Proposals | ⏰ Montag 10:00 | 🤖 Beim Erkennen (3x Task) | + +**Ergebnis:** Mehr Interaktion, bessere Kontrolle, Context-Aware statt zeitgesteuert. + +--- + +## 📊 File-Struktur (aktualisiert) + +``` +claude-vault/ +├── OPTIMIZATION-ROADMAP.md +├── QUICK-START-NO-CRON.md ✅ NEU +├── MANUAL-WORKFLOW.md ✅ NEU +├── IMPLEMENTATION-SUMMARY-NO-CRON.md ✅ NEU (diese Datei) +├── scripts/ +│ ├── log-session.sh ✅ NEU +│ ├── analyze-skill-usage.sh ✅ NEU +│ ├── update-dashboard.sh ✅ NEU +│ ├── weekly-health-check.sh ✅ NEU +│ ├── detect-skill-proposals.sh ✅ NEU +│ ├── bash-aliases.sh ✅ NEU +│ ├── setup-aliases.sh ✅ NEU (ersetzt setup-cron.sh) +│ └── sync-project-memory.sh (bestehend) +├── system/ +│ └── global-instructions.md 🔄 ERWEITERT (Context-Aware Triggers) +└── skills/ + └── vault-janitor/ + └── SKILL.md 🔄 ERWEITERT (8 Modi) +``` + +--- + +## 🎓 Philosophie-Shift + +### Cron-Jobs (ursprünglicher Plan) +``` +Automatisierung ohne Kontext +├─ Feste Zeiten +├─ Hintergrund-Prozesse +├─ Keine Interaktion +└─ "Magisch" +``` + +### global-instructions (finale Version) +``` +Automatisierung MIT Kontext +├─ Context-Aware Triggers +├─ Proaktiver Assistant +├─ Interaktive Wartung +└─ Transparent & kontrollierbar +``` + +**Beispiel:** +- **Cron:** Läuft Montag 09:00 (egal ob du arbeitest) +- **Claude:** Erkennt "Montag-Session" → Bietet Wartung an → Nur wenn du da bist + +--- + +## 📈 Erwartete Verbesserungen (identisch zu Cron-Version) + +**Nach 1 Woche:** +- ✅ 3-5 Session-Logs +- ✅ Dashboard zeigt Trends + +**Nach 1 Monat:** +- ✅ 10+ Session-Logs +- ✅ 3+ Patterns extrahiert +- ✅ 1+ Skill-Proposal umgesetzt + +**Nach 3 Monaten:** +- ✅ 30+ Logs +- ✅ 10+ Patterns +- ✅ 3+ neue Skills +- ✅ **10x mehr Learning** + +--- + +## 🚀 Nächste Schritte + +### Heute (3 Min) +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +source ~/.zshrc +vault-status +``` + +### Nächste Claude-Session +``` +Einfach mit Claude arbeiten! + +Claude fragt automatisch: +├─ Bei Session-Ende: "Log erstellen?" +├─ Montags: "Dashboard/Patterns aktualisieren?" +└─ Bei Projekt-Wechsel: "Memory synchronisieren?" + +Du sagst einfach "ja" oder "später" +``` + +--- + +## 💡 Best Practices + +1. **Vertraue Claude** + - Lass Claude proaktiv Wartung vorschlagen + - Sag "ja" oder "später" + - Claude macht den Rest + +2. **Nutze Aliases als Fallback** + - `vault-status` für Quick-Check + - `claude-done` falls Claude nicht fragt + - `vault-health` für monatlichen Überblick + +3. **Wöchentlicher Mini-Review (5 Min)** + - Montags: Claude fragt automatisch + - Einfach "ja" sagen + - Dashboard + Patterns werden aktualisiert + +4. **Monatlicher Deep-Dive (15 Min)** + - 1. des Monats: Claude fragt automatisch + - Health-Check durchführen lassen + - Patterns reviewen + - Backup erstellen + +--- + +## 🆚 Vergleich Original vs. Finale Version + +### Original-Plan (mit Cron) +``` +✅ Automatisierung +❌ Hintergrund-Prozesse +❌ Keine Kontrolle +❌ Feste Zeiten +``` + +### Finale Version (ohne Cron) +``` +✅ Automatisierung +✅ Proaktiver Assistant +✅ Volle Kontrolle +✅ Context-Aware +✅ Interaktiv +``` + +**Ergebnis:** **Besseres System** durch User-Feedback! 🎉 + +--- + +## 🎯 Wichtigste Aliases + +```bash +# Session (Fallback) +claude-done "" + +# Status & Monitoring +vault-status # Dashboard +vault-health # Health-Check +vault-analyze # Skill-Usage +vault-sync # Projekt-Sync + +# Quick-Access +vault-dashboard # Öffne Dashboard +vault-patterns # Öffne Patterns +vault-proposals # Zeige Proposals +vault-help # Alle Befehle +``` + +--- + +## ✅ Zusammenfassung + +**Was wurde erstellt:** +- 5 Dokumentations-Dateien +- 7 neue Scripts + 1 angepasst +- global-instructions.md erweitert (Context-Aware Triggers) +- vault-janitor erweitert (8 Modi) + +**Setup:** +```bash +./scripts/setup-aliases.sh +source ~/.zshrc +``` + +**Workflow:** +- Claude fragt proaktiv +- Du entscheidest +- Manueller Fallback verfügbar + +**Ergebnis:** +- **Proaktive Wartung** ohne Cron-Jobs +- **Context-Aware** statt zeitgesteuert +- **Interaktiv** statt "magisch" +- **10x mehr Learning** aus Sessions + +--- + +**Starte JETZT:** + +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +source ~/.zshrc + +# Bei nächster Session einfach mit Claude arbeiten +# Claude macht den Rest! 🚀 +``` + +--- + +**Dokumentation:** +- **[QUICK-START-NO-CRON.md](QUICK-START-NO-CRON.md)** - Setup & Workflow +- **[MANUAL-WORKFLOW.md](MANUAL-WORKFLOW.md)** - Detaillierte Workflows +- **[OPTIMIZATION-ROADMAP.md](OPTIMIZATION-ROADMAP.md)** - Vollständiger Plan + +**Viel Erfolg mit deinem optimierten claude-vault! 🎉** diff --git a/MANUAL-WORKFLOW.md b/MANUAL-WORKFLOW.md new file mode 100644 index 0000000..658c3ed --- /dev/null +++ b/MANUAL-WORKFLOW.md @@ -0,0 +1,402 @@ +# Manual Workflow - Claude-Vault ohne Cron-Jobs + +**Philosophie:** Claude führt Wartungsaufgaben **proaktiv** durch (via `global-instructions.md`), oder du triggerst sie **manuell** via Aliases. + +**Vorteil:** Volle Kontrolle, keine Hintergrund-Prozesse, Claude als aktiver Assistant. + +--- + +## 🤖 Automatisierung via global-instructions.md + +Die `system/global-instructions.md` enthält jetzt **Context-Aware Triggers**, sodass Claude proaktiv Wartung durchführt: + +### Session-Start Triggers + +#### Montag morgens +``` +Claude prüft automatisch: +├─ Dashboard älter als 7 Tage? → "Dashboard aktualisieren?" +├─ ≥5 neue Logs vorhanden? → "/vault-janitor distill durchführen?" +└─ ≥3 Skill-Proposals offen? → Info-Hinweis +``` + +**Deine Aktion:** Einfach "ja" sagen, Claude macht den Rest. + +--- + +#### 1. des Monats +``` +Claude bietet an: +├─ Health-Check durchführen +├─ Backup-Reminder +└─ Skill-Usage-Matrix aktualisieren +``` + +--- + +### Session-Ende Trigger + +#### Bei "exit", "fertig", "danke" +``` +Claude fragt AUTOMATISCH: +"Session-Log erstellen? Kurze Beschreibung?" + +→ Du: "Team-Stats API + Tests" +→ Claude: Erstellt Log in memory/log/2026-02-04_session.md +``` + +**Kein manuelles `claude-done` nötig!** Claude macht das direkt. + +--- + +### Projekt-Wechsel Trigger + +#### Wenn du in neuem Projekt arbeitest +``` +Claude erkennt automatisch: +"Projekt-Wechsel erkannt: league-planner → ligalytics" + +Führe aus: scripts/sync-project-memory.sh +Info: "Projekt-Memory synchronisiert" +``` + +--- + +### Fehler/Bug-Fix Trigger + +#### Bei Fehler-Behebung +``` +Claude prüft: +- Ist Fehlertyp bereits in /knowledge/anti-patterns/? +- Falls NEIN: "Als Anti-Pattern dokumentieren?" + +→ Du: "Ja" +→ Claude: Erstellt Anti-Pattern via Template +``` + +--- + +## 🖐️ Manuelle Triggers (via Aliases) + +Falls du Claude nicht automatisch handeln lassen willst, nutze Aliases: + +### Täglich + +```bash +# Nach Claude-Session (falls Claude nicht automatisch fragt) +claude-done "" + +# Beispiel +claude-done league-planner "Celery Task für Report-Generierung" +``` + +--- + +### Wöchentlich (Montag, 5 Minuten) + +```bash +# 1. Dashboard prüfen +vault-status + +# 2. Skill-Proposals anschauen +vault-proposals + +# 3. Falls ≥5 Logs: Pattern-Extraktion +# In Claude: +/vault-janitor distill +``` + +--- + +### Monatlich (1. des Monats, 15 Minuten) + +```bash +# 1. Health-Check +vault-health + +# 2. Skill-Usage analysieren +~/Work/claude-vault/scripts/analyze-skill-usage.sh + +# 3. Patterns reviewen +vault-patterns + +# 4. Backup +vault-backup +``` + +--- + +## 📊 Vergleich: Automatisch vs. Manuell + +| Aufgabe | Cron (alt) | global-instructions (neu) | Manuell (Fallback) | +|---------|------------|---------------------------|---------------------| +| Session-Logging | ❌ | ✅ Claude fragt am Ende | `claude-done` | +| Dashboard-Update | ⏰ Täglich 21:00 | ✅ Claude bietet montags an | `vault-status` | +| Health-Check | ⏰ Montag 09:00 | ✅ Claude bietet monatlich an | `vault-health` | +| Pattern-Extraktion | ❌ | ✅ Claude schlägt vor (≥5 Logs) | `/vault-janitor distill` | +| Skill-Proposals | ⏰ Montag 10:00 | ✅ Claude erkennt automatisch (3x Task) | `/vault-janitor propose` | +| Projekt-Sync | ⏰ Täglich 20:00 | ✅ Claude bei Projekt-Wechsel | `vault-sync` | + +**Ergebnis:** Du bekommst **mehr Interaktion** und **Kontrolle**, Claude wird **proaktiver Assistant** statt stiller Cron-Job. + +--- + +## 🎯 Workflow-Beispiel: Typische Woche + +### Montag, 09:00 - Session-Start + +``` +Du: "Hallo Claude" + +Claude: "Guten Morgen! +📊 Dashboard ist 8 Tage alt. Soll ich aktualisieren? +📚 7 neue Logs gefunden. Pattern-Extraktion durchführen? (/vault-janitor distill) +💡 2 offene Skill-Proposals zum Reviewen." + +Du: "Ja, Dashboard aktualisieren. Distill später." + +Claude: *führt update-dashboard.sh aus* + "✅ Dashboard aktualisiert: + - 7 Logs diese Woche + - 2 neue Patterns erkannt + - Empfehlung: Distill durchführen" +``` + +--- + +### Dienstag, 14:00 - Arbeit an Projekt + +``` +Du: "Erstelle Django Model für Team-Stats" + +Claude: *nutzt /lp-django-model Skill* + *erstellt Model* + +Du: "Danke, fertig für heute" + +Claude: "Session-Log erstellen? Kurze Beschreibung?" + +Du: "Team-Stats Model erstellt" + +Claude: *erstellt Log in memory/log/2026-02-05_session.md* + "✅ Session geloggt. Bis morgen!" +``` + +--- + +### Freitag, 16:00 - Projekt-Wechsel + +``` +Du: "Wechsel zu ligalytics Projekt" + +Claude: "Projekt-Wechsel erkannt: league-planner → ligalytics + Synchronisiere Projekt-Memory..." + + *führt sync-project-memory.sh aus* + + "✅ Memory synchronisiert + Projekt: ligalytics + Letzte Arbeit: 2026-01-28 + + Projekt-MEMORY geladen. Womit kann ich helfen?" +``` + +--- + +### Samstag, 11:00 - Bug-Fix + +``` +Du: "Circular Import Problem in models.py gefixt" + +Claude: *prüft /knowledge/anti-patterns/* + + "Circular Import ist noch nicht als Anti-Pattern dokumentiert. + Soll ich ein Anti-Pattern erstellen?" + +Du: "Ja, gerne" + +Claude: *nutzt template.md* + *erstellt /knowledge/anti-patterns/circular-imports.md* + + "✅ Anti-Pattern dokumentiert: + - Problem: Circular Imports + - Lösung: Lazy Imports, Refactoring + - Beispiel aus deinem Code" +``` + +--- + +## 🔧 Setup (5 Minuten) + +### 1. Aliases installieren + +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +``` + +**Output:** +``` +✅ Installation erfolgreich! + +Nächste Schritte: +1. Shell neu laden: source ~/.zshrc +2. Testen: vault-help +3. Bei nächster Claude-Session nutzen: claude-done "" + +💡 Wichtig: + - KEINE Cron-Jobs installiert (wie gewünscht) + - Claude führt Wartung automatisch durch (via global-instructions.md) +``` + +--- + +### 2. global-instructions.md ist bereits aktualisiert + +Die `system/global-instructions.md` enthält jetzt alle Trigger: +- ✅ Session-Start (Montag, 1. des Monats) +- ✅ Session-Ende (Log-Erstellung) +- ✅ Projekt-Wechsel (Memory-Sync) +- ✅ Fehler-Fix (Anti-Pattern-Detection) + +**Keine weitere Konfiguration nötig!** + +--- + +### 3. Test + +```bash +# Shell neu laden +source ~/.zshrc + +# Test +vault-help + +# Sollte zeigen: +🔧 Claude-Vault Aliases +[... Liste aller Befehle ...] +``` + +--- + +## 💡 Best Practices + +### 1. Vertraue Claude +- Claude fragt proaktiv nach Wartungsaufgaben +- Sag einfach "ja" oder "später" +- Claude übernimmt die Ausführung + +### 2. Nutze Aliases als Fallback +- Falls Claude mal nicht fragt: Manuell triggern +- `vault-status` für Quick-Check +- `vault-health` für monatlichen Überblick + +### 3. Wöchentlicher Review (Montag, 5 Min) +- Lass Claude Dashboard aktualisieren +- Lass Claude Proposals zeigen +- Bei ≥5 Logs: `/vault-janitor distill` + +### 4. Monatlicher Deep-Dive (1. des Monats, 15 Min) +- Health-Check durchführen lassen +- Patterns reviewen (`vault-patterns`) +- Backup erstellen (`vault-backup`) + +--- + +## 🆚 Vorher vs. Nachher + +### Vorher (mit Cron) +``` +⏰ Cron-Jobs laufen im Hintergrund + → Du weißt nicht wann/was passiert + → Keine Interaktion + → "Magic" im Hintergrund +``` + +### Nachher (ohne Cron, mit global-instructions) +``` +🤖 Claude agiert als proaktiver Assistant + → Fragt zur richtigen Zeit + → Du entscheidest: "Ja" oder "Später" + → Volle Transparenz & Kontrolle +``` + +--- + +## 🎓 Philosophie + +**Cron-Jobs:** Automatisierung ohne Kontext +**Claude:** Automatisierung **mit** Kontext + +**Beispiel:** +- Cron läuft Montag 09:00 → Egal ob du arbeitest oder nicht +- Claude erkennt: "Montag-Session" → Bietet Wartung an → Nur wenn du da bist + +**Ergebnis:** **Smarter, nicht nur automatisiert.** + +--- + +## 📚 Kommandos-Übersicht + +### Session-Management +```bash +claude-done "" # Fallback, falls Claude nicht fragt +claude-log # Heutiges Log öffnen +``` + +### Status & Monitoring +```bash +vault-status # Dashboard anzeigen +vault-health # Health-Check erstellen +vault-sync # Projekt-Memory sync +vault-analyze # Skill-Usage-Matrix +``` + +### Wartung (in Claude) +```bash +/vault-janitor distill # Patterns extrahieren +/vault-janitor propose # Skill-Proposals erkennen +/vault-janitor stats # Statistiken +/vault-janitor anti-pattern-detect # Anti-Patterns aus Logs +``` + +### Quick-Access +```bash +vault-dashboard # Dashboard öffnen +vault-patterns # Patterns öffnen +vault-proposals # Proposals anzeigen +vault-help # Hilfe +``` + +--- + +## ✅ Zusammenfassung + +**Setup:** +1. `./scripts/setup-aliases.sh` ausführen +2. Shell neu laden: `source ~/.zshrc` +3. Fertig! Claude macht den Rest. + +**Workflow:** +- **Session-Start:** Claude fragt nach Dashboard/Distill (Montag/Monatlich) +- **Session-Ende:** Claude fragt nach Log-Beschreibung +- **Projekt-Wechsel:** Claude synct automatisch +- **Fehler-Fix:** Claude schlägt Anti-Pattern vor + +**Manuell (Fallback):** +- `vault-status` - Dashboard +- `vault-health` - Health-Check +- `/vault-janitor distill` - Patterns + +**Ergebnis:** **Proaktive Wartung ohne Cron-Jobs. Claude als intelligenter Assistant.** + +--- + +**Nächster Schritt:** +```bash +./scripts/setup-aliases.sh +source ~/.zshrc +vault-help +``` + +**Dann einfach mit Claude arbeiten - alles andere läuft automatisch!** 🎉 diff --git a/QUICK-START-NO-CRON.md b/QUICK-START-NO-CRON.md new file mode 100644 index 0000000..5545033 --- /dev/null +++ b/QUICK-START-NO-CRON.md @@ -0,0 +1,354 @@ +# Claude-Vault Quick Start - OHNE Cron-Jobs + +**Ziel:** Maximiere Learning aus Claude-Sessions durch **proaktive Automatisierung** (keine Cron-Jobs). + +**Philosophie:** Claude agiert als **intelligenter Assistant** und führt Wartung **zur richtigen Zeit** durch. + +--- + +## 🚀 3-Minuten Setup + +### 1. Aliases installieren (2 Min) + +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +source ~/.zshrc # oder ~/.bashrc +vault-help # Test +``` + +**Ausgabe:** +``` +✅ Installation erfolgreich! + +💡 Wichtig: + - KEINE Cron-Jobs installiert + - Claude führt Wartung automatisch durch (via global-instructions.md) + - Manueller Fallback via Aliases verfügbar +``` + +--- + +### 2. Dashboard erstellen (1 Min) + +```bash +vault-status +``` + +Erstellt automatisch `memory/dashboard.md` und zeigt Statistiken. + +--- + +### 3. Fertig! 🎉 + +**Das war's!** Claude übernimmt den Rest automatisch. + +--- + +## 🤖 Wie funktioniert die Automatisierung? + +### global-instructions.md enthält Context-Aware Triggers + +**Claude prüft automatisch:** + +#### Session-Start (Montag) +``` +✅ Dashboard veraltet? → "Soll ich aktualisieren?" +✅ ≥5 neue Logs? → "Pattern-Extraktion durchführen?" +✅ Proposals offen? → Info-Hinweis +``` + +#### Session-Start (1. des Monats) +``` +✅ "Health-Check durchführen?" +✅ "Backup-Reminder" +✅ "Skill-Usage-Matrix aktualisieren?" +``` + +#### Session-Ende (bei "exit", "fertig", "danke") +``` +✅ "Session-Log erstellen? Kurze Beschreibung?" +→ Du: "Team-Stats API erstellt" +→ Claude: Erstellt Log automatisch +``` + +#### Projekt-Wechsel +``` +✅ Erkennt neues Projekt +✅ Synchronisiert Projekt-Memory automatisch +✅ Lädt Projekt-MEMORY.md +``` + +#### Fehler-Fix +``` +✅ Prüft ob Fehlertyp bereits dokumentiert +✅ "Als Anti-Pattern speichern?" (falls neu) +``` + +--- + +## 📋 Workflow-Beispiele + +### Beispiel 1: Montag morgen + +``` +Du: "Hallo Claude" + +Claude: "Guten Morgen! +📊 Dashboard ist 8 Tage alt. Aktualisieren? +📚 7 neue Logs. Pattern-Extraktion? (/vault-janitor distill) +💡 2 offene Skill-Proposals." + +Du: "Ja, beides" + +Claude: *aktualisiert Dashboard* + *führt /vault-janitor distill aus* + "✅ Fertig! 3 neue Patterns extrahiert, 7 Logs archiviert." +``` + +--- + +### Beispiel 2: Session-Ende + +``` +Du: "Danke, fertig für heute" + +Claude: "Session-Log erstellen? Kurze Beschreibung?" + +Du: "Celery Task für Report-Generierung" + +Claude: *erstellt memory/log/2026-02-04_session.md* + "✅ Session geloggt. Bis morgen!" +``` + +**Kein manuelles `claude-done` nötig!** + +--- + +### Beispiel 3: Projekt-Wechsel + +``` +Du: "Wechsel zu ligalytics" + +Claude: "Projekt-Wechsel erkannt: league-planner → ligalytics + Synchronisiere Memory..." + + *führt sync-project-memory.sh aus* + + "✅ Memory aktualisiert + Letzte Arbeit: 2026-01-28 + Womit kann ich helfen?" +``` + +--- + +### Beispiel 4: Bug-Fix + +``` +Du: "N+1 Query Problem in API gefixt" + +Claude: *prüft /knowledge/anti-patterns/n-plus-1-queries.md* + + "N+1 Queries bereits als Anti-Pattern dokumentiert ✅ + Soll ich das Pattern in diesem Projekt updaten?" + + (Falls NEU gewesen wäre: "Als Anti-Pattern dokumentieren?") +``` + +--- + +## 🖐️ Manuelle Befehle (Fallback) + +Falls du Claude nicht automatisch handeln lassen willst: + +### Täglich +```bash +# Session-Log (falls Claude nicht fragt) +claude-done "" +``` + +### Wöchentlich (5 Min) +```bash +vault-status # Dashboard +vault-proposals # Proposals +/vault-janitor distill # Patterns (in Claude) +``` + +### Monatlich (15 Min) +```bash +vault-health # Health-Check +vault-analyze # Skill-Usage-Matrix +vault-patterns # Patterns reviewen +vault-backup # Backup +``` + +--- + +## 🎯 Wichtigste Aliases + +```bash +# Session-Management +claude-done "" # Log erstellen (Fallback) +claude-log # Heutiges Log öffnen + +# Status & Monitoring +vault-status # Dashboard +vault-health # Health-Check +vault-analyze # Skill-Usage-Matrix +vault-sync # Projekt-Memory sync + +# Quick-Access +vault-dashboard # Dashboard öffnen +vault-patterns # Patterns öffnen +vault-proposals # Proposals anzeigen +vault-help # Alle Befehle +``` + +--- + +## 🆚 Warum OHNE Cron-Jobs? + +### Mit Cron (alt) +``` +❌ Läuft im Hintergrund (keine Kontrolle) +❌ Feste Zeiten (egal ob du arbeitest) +❌ Keine Interaktion +❌ "Magisch" (nicht transparent) +``` + +### Ohne Cron, mit global-instructions (neu) +``` +✅ Claude als proaktiver Assistant +✅ Context-Aware (nur wenn relevant) +✅ Du entscheidest: "Ja" oder "Später" +✅ Volle Transparenz & Kontrolle +✅ Interaktiv & lehrreich +``` + +--- + +## 📈 Erwartete Verbesserungen + +### Nach 1 Woche +- ✅ 3-5 Session-Logs +- ✅ Claude fragt proaktiv nach Wartung +- ✅ Dashboard zeigt Trends + +### Nach 1 Monat +- ✅ 10+ Session-Logs +- ✅ 3+ Patterns extrahiert +- ✅ 1+ Skill-Proposal umgesetzt +- ✅ **10x mehr Learning** aus gleicher Arbeit + +### Nach 3 Monaten +- ✅ 30+ Session-Logs +- ✅ 10+ Patterns +- ✅ 3+ neue Skills +- ✅ Cross-Projekt-Learning nachweisbar + +--- + +## 🔍 Erfolg messen + +### Wöchentlich +```bash +vault-status +``` + +Zeigt: +- Logs diese Woche +- Patterns extrahiert +- Proposals offen +- Empfehlungen + +### Monatlich +```bash +vault-health +``` + +Zeigt: +- Vollständiger Health-Check +- Trends vs. letzten Monat +- Wartungs-Empfehlungen + +--- + +## 🚨 Troubleshooting + +### Problem: `vault-help` nicht gefunden + +**Lösung:** +```bash +source ~/Work/claude-vault/scripts/bash-aliases.sh +# Oder permanent installieren: +./scripts/setup-aliases.sh +``` + +--- + +### Problem: Claude fragt nicht nach Session-Log + +**Lösung:** +```bash +# Manuell loggen +claude-done "" + +# Oder in global-instructions.md prüfen ob Trigger aktiv +``` + +--- + +### Problem: Dashboard zeigt alte Daten + +**Lösung:** +```bash +vault-status # Aktualisiert automatisch +# Oder manuell: +~/Work/claude-vault/scripts/update-dashboard.sh +``` + +--- + +## 📚 Weitere Dokumentation + +- **[MANUAL-WORKFLOW.md](MANUAL-WORKFLOW.md)** - Detaillierte Workflow-Beschreibung +- **[OPTIMIZATION-ROADMAP.md](OPTIMIZATION-ROADMAP.md)** - Vollständiger Plan +- **[vault-index.md](vault-index.md)** - Skills & Agents +- **[system/global-instructions.md](system/global-instructions.md)** - Automatisierungs-Trigger + +--- + +## ✨ Zusammenfassung + +**Setup:** +```bash +./scripts/setup-aliases.sh +source ~/.zshrc +vault-status +``` + +**Workflow:** +- Claude fragt proaktiv (Session-Start/Ende, Projekt-Wechsel) +- Du sagst "ja" oder "später" +- Manueller Fallback via Aliases verfügbar + +**Ergebnis:** +- **Proaktive Wartung** ohne Cron-Jobs +- **Context-Aware** statt zeitgesteuert +- **Interaktiv** statt "magisch" +- **10x mehr Learning** aus gleicher Arbeit + +--- + +**Starte JETZT:** + +```bash +cd ~/Work/claude-vault +./scripts/setup-aliases.sh +source ~/.zshrc + +# Bei nächster Session einfach mit Claude arbeiten +# → Claude fragt automatisch nach Logs, Wartung, etc. +``` + +**Claude wird dein proaktiver Assistent für systematisches Learning! 🚀** diff --git a/memory/snapshots/2026-02-04_maintenance-report.md b/memory/snapshots/2026-02-04_maintenance-report.md new file mode 100644 index 0000000..51199ed --- /dev/null +++ b/memory/snapshots/2026-02-04_maintenance-report.md @@ -0,0 +1,107 @@ +# Wartungs-Report 2026-02-04 + +**Durchgeführte Modi:** audit + index + check + +--- + +## Skill Audit + +### Ergebnis: ✅ Alle 12 Skills valide + +| Skill | YAML name | description (chars) | Status | +|-------|-----------|---------------------|--------| +| celery-task | `lp-celery-task` | 178 | ✅ | +| django-model | `lp-django-model` | 154 | ✅ | +| doc-gen | `doc-gen` | 192 | ✅ | +| drf-api | `lp-drf-api` | 167 | ✅ | +| permissions | `lp-permissions` | 186 | ✅ | +| query-optimizer | `lp-query-optimizer` | 154 | ✅ | +| reviewer | `reviewer` | 198 | ✅ | +| skill-creator | `skill-creator` | 179 | ✅ | +| solver | `lp-solver` | 179 | ✅ | +| sparring-partner | `sparring-partner` | 200 | ✅ | +| testing | `lp-testing` | 170 | ✅ | +| vault-janitor | `vault-janitor` | 185 | ✅ | + +### Frontmatter-Prüfung +- ✅ Alle haben `name:` +- ✅ Alle haben `description:` (max 200 chars) +- ✅ Alle haben `argument-hint:` +- ✅ Alle haben `allowed-tools:` + +--- + +## Index Update + +### Korrigiert: Skill-Invocation-Namen + +Der `vault-index.md` hatte falsche Invocation-Namen (ohne `lp-` Prefix). + +**Geändert:** +| Alt | Neu | +|-----|-----| +| `/django-model` | `/lp-django-model` | +| `/drf-api` | `/lp-drf-api` | +| `/celery-task` | `/lp-celery-task` | +| `/permissions` | `/lp-permissions` | +| `/query-optimizer` | `/lp-query-optimizer` | +| `/solver` | `/lp-solver` | +| `/testing` | `/lp-testing` | + +--- + +## Integrity Check + +### Symlinks +- ✅ Skills: 13/13 verlinkt in `~/.claude/skills/` +- ✅ Agents: 8/8 verlinkt in `~/.claude/agents/` + +### Leere Dateien +- ✅ Keine gefunden + +### TODO-Marker +- ⚠️ 7 TODOs in `OPTIMIZATION-ROADMAP.md` (Template-Platzhalter) +- ℹ️ 1 in `vault-janitor/SKILL.md` (Teil der Check-Anweisung) + +### Agents +Alle 8 Agents haben valides Frontmatter: +- cluster-compute-architect (opus, blue) +- code-reviewer (sonnet, cyan) +- debugging-specialist (inherit, red) +- django-architect (sonnet, green) +- django-mkdocs-docs (sonnet, pink) +- league-planner-architect (opus, orange) +- mip-optimization-xpress (opus, purple) +- plg-monitoring-architect (opus, yellow) + +--- + +## Ungetrackte Dateien (nicht committed) + +``` +M system/global-instructions.md +?? IMPLEMENTATION-SUMMARY-NO-CRON.md +?? MANUAL-WORKFLOW.md +?? QUICK-START-NO-CRON.md +?? scripts/setup-aliases.sh +``` + +**Empfehlung:** Diese Dateien committen um Änderungen zu sichern. + +--- + +## Statistiken + +| Kategorie | Anzahl | +|-----------|--------| +| Skills (total) | 12 | +| Skills (lp-*) | 7 | +| Skills (generic) | 5 | +| Agents | 8 | +| Logs | 1 | +| Snapshots | 3 | +| Projekte | 1 | + +--- + +*Erstellt: 2026-02-04* diff --git a/scripts/setup-aliases.sh b/scripts/setup-aliases.sh new file mode 100755 index 0000000..8375ca6 --- /dev/null +++ b/scripts/setup-aliases.sh @@ -0,0 +1,66 @@ +#!/bin/bash +# Installiert Bash-Aliases für Claude-Vault (OHNE Cron-Jobs) +# Angepasste Version: Alles läuft manuell oder über global-instructions.md + +set -e + +VAULT="$HOME/Work/claude-vault" +SHELL_RC="" + +echo "⚙️ Installiere Claude-Vault Aliases..." +echo "" + +# Detect Shell +if [ -n "$ZSH_VERSION" ]; then + SHELL_RC="$HOME/.zshrc" + echo "🐚 Shell erkannt: zsh" +elif [ -n "$BASH_VERSION" ]; then + SHELL_RC="$HOME/.bashrc" + echo "🐚 Shell erkannt: bash" +else + echo "❌ Unbekannte Shell. Bitte manuell zu ~/.bashrc oder ~/.zshrc hinzufügen:" + echo " source $VAULT/scripts/bash-aliases.sh" + exit 1 +fi + +# Prüfe ob bereits installiert +if grep -q "source.*bash-aliases.sh" "$SHELL_RC" 2>/dev/null; then + echo "" + echo "✅ Aliases bereits in $SHELL_RC installiert!" + echo "" + echo "Zum Neu-Laden:" + echo " source $SHELL_RC" + exit 0 +fi + +# Füge Source-Line hinzu +echo "" +echo "➕ Füge Alias-Source zu $SHELL_RC hinzu..." + +cat >> "$SHELL_RC" < \"\"" +echo "" +echo "💡 Wichtig:" +echo " - KEINE Cron-Jobs installiert (wie gewünscht)" +echo " - Claude führt Wartung automatisch durch (via global-instructions.md)" +echo " - Oder manuell via Aliases: vault-status, vault-health, etc." +echo "" +echo "📚 Dokumentation:" +echo " cat $VAULT/QUICK-START.md" diff --git a/system/global-instructions.md b/system/global-instructions.md index 32aa104..2a0d75e 100644 --- a/system/global-instructions.md +++ b/system/global-instructions.md @@ -55,10 +55,163 @@ Wenn widersprüchliche Informationen vorliegen, gilt folgende Hierarchie: # MEMORY & LEARNING -- Nach Abschluss einer größeren Aufgabe: Prüfe, ob es wichtige Erkenntnisse gab. Wenn ja, erstelle einen kurzen Eintrag im `/memory/log/`. -- Einmal pro Woche (oder auf Befehl): Scanne den `/memory/log/` Ordner, erkenne wiederkehrende Muster und schlage mir Updates für die `patterns.md` oder die `global-instructions.md` vor. +## Session-Logging (WICHTIG!) +- **Am Ende jeder Session:** Erstelle automatisch einen Log-Eintrag in `/memory/log/YYYY-MM-DD_session.md` +- **Format:** Nutze das vorhandene Template (Session-Timestamp, Projekt, Beschreibung, Skills genutzt, Entscheidungen, Lessons Learned) +- **Trigger:** Wenn User "exit", "fertig", "danke" oder Session-Ende signalisiert +- **Script verfügbar:** `~/Work/claude-vault/scripts/log-session.sh` (kann als Referenz dienen) + +## Pattern-Extraktion +- **Wöchentlich (bei Session-Start Montag):** Prüfe ob `memory/log/` ≥5 neue Logs hat +- **Falls ja:** Frage User: "5+ neue Logs gefunden. Soll ich Pattern-Extraktion durchführen? (/vault-janitor distill)" +- **Bei Zustimmung:** Führe `/vault-janitor distill` aus +- **Ergebnis:** Patterns in `/memory/patterns.md` extrahiert, Logs archiviert + +## Dashboard & Statistiken +- **Bei Session-Start (Montag):** Prüfe ob Dashboard älter als 7 Tage +- **Falls ja:** Frage User: "Dashboard ist veraltet. Soll ich aktualisieren?" +- **Bei Zustimmung:** Führe `~/Work/claude-vault/scripts/update-dashboard.sh` via Bash aus +- **Zeige dann:** Quick Stats aus Dashboard + +## Projekt-Memory-Sync +- **Beim Wechsel zwischen Projekten:** Prüfe ob Projekt-MEMORY.md sync nötig +- **Trigger:** Wenn User in anderem Projekt arbeitet als letzte Session +- **Aktion:** Führe `~/Work/claude-vault/scripts/sync-project-memory.sh` aus +- **Info:** "Projekt-Memory synchronisiert" + +## Health-Check +- **Monatlich (bei Session-Start am 1.):** Frage: "Monatlicher Health-Check fällig. Durchführen?" +- **Bei Zustimmung:** Führe `~/Work/claude-vault/scripts/weekly-health-check.sh` aus +- **Zeige:** Zusammenfassung (Logs, Patterns, Proposals, Empfehlungen) # SKILL-ERSTELLUNG -- Wenn du merkst, dass wir eine komplexe Aufgabe mehr als dreimal auf die gleiche Weise lösen, erstelle automatisch einen Entwurf für einen neuen Skill in /skills/proposals/. +## Automatische Proposal-Detection +- **Trigger:** Wenn du merkst, dass wir eine Aufgabe ≥3x identisch lösen +- **Aktion:** Erstelle automatisch Skill-Proposal in `/skills/proposals/YYYY-MM-DD_.md` +- **Template nutzen:** Aus `/skills/skill-creator/` +- **Info User:** "Wiederholte Aufgabe erkannt (3x). Skill-Proposal erstellt: " + +## Skill-Proposal-Review +- **Wöchentlich (bei Session-Start Montag):** Prüfe ob Proposals in `/skills/proposals/` existieren +- **Falls ja (≥1):** Info: "X offene Skill-Proposals. Reviewen? (Tippe: vault-proposals)" +- **Script verfügbar:** `~/Work/claude-vault/scripts/detect-skill-proposals.sh` für automatische Detection + +# PROAKTIVE WARTUNG + +## Anti-Pattern-Detection +- **Bei Fehler/Bug-Fix:** Prüfe ob ähnlicher Fehler bereits in `/knowledge/anti-patterns/` dokumentiert +- **Falls NEIN (neuer Fehlertyp):** Frage: "Neuer Fehlertyp erkannt. Als Anti-Pattern dokumentieren?" +- **Bei Zustimmung:** Nutze `/knowledge/anti-patterns/template.md` und erstelle neue Datei + +## Skill-Usage-Tracking +- **Implizit:** Wenn User `/skill-name` nutzt, merke für spätere Analyse +- **Monatlich:** Frage ob Skill-Usage-Matrix erstellen: `~/Work/claude-vault/scripts/analyze-skill-usage.sh` + +## Vault-Backup-Reminder +- **Monatlich (bei Session-Start am 1.):** Reminder: "Monatliches Vault-Backup empfohlen. Alias: vault-backup" + +# CONTEXT-AWARE TRIGGERS + +## Session-Start (Begrüßung) +1. Prüfe Wochentag: + - **Montag:** Dashboard-Check + Pattern-Extraktion anbieten + - **1. des Monats:** Health-Check + Backup-Reminder +2. Prüfe offene Proposals: Info wenn ≥3 +3. Prüfe letztes Projekt-Memory-Sync + +## Session-Ende (Abschied) +1. **IMMER:** Frage User: "Session-Log erstellen? Kurze Beschreibung?" +2. Falls ja: Erstelle Log in `/memory/log/YYYY-MM-DD_session.md` +3. Falls Projekt-Arbeit: Prüfe ob Projekt-MEMORY.md Update nötig + +## Projekt-Wechsel +1. Prüfe ob neues Projekt (vs. letzte Session) +2. Sync Projekt-Memory: `scripts/sync-project-memory.sh` +3. Lade Projekt-MEMORY.md falls vorhanden +4. Info: "Projekt: , letzte Arbeit: " + +# PERSÖNLICHE PRÄFERENZEN (Always-On) + +## Tech-Stacks + +### Frontend +- **Framework:** React, Next.js +- **Styling:** Tailwind CSS +- **Language:** TypeScript +- **State:** React Context, Zustand (bei Bedarf) + +### Backend +- **Framework:** Django 5.2+, Django REST Framework +- **Language:** Python 3.12+ +- **Task Queue:** Celery mit Redis +- **Optimization:** PuLP, FICO Xpress + +### Database & Infrastructure +- **Production:** PostgreSQL | **Development:** SQLite | **Cache/Broker:** Redis +- **Container:** Docker (Multi-Stage Builds) +- **Orchestration:** K3s +- **Monitoring:** Prometheus, Loki, Grafana +- **CI/CD:** GitLab CI + +## Coding Style + +### Python / Django +- **Type Hints:** Immer (`str | None` statt `Optional[str]`) +- **Docstrings:** Google-Style für öffentliche APIs +- **Imports:** Absolute, gruppiert (stdlib → third-party → local) +- **Line Length:** 88 (Black) | **Quotes:** Double | **Strings:** F-Strings +- **Views:** Fat Models, Thin Views +- **Queries:** Immer `select_related`/`prefetch_related` für Relations +- **Naming:** Models singular (`Match`), related_name plural (`matches`) + +### TypeScript / React +- **Components:** Functional mit Hooks, PascalCase +- **Props:** Destructuring in Signatur +- **CSS:** Tailwind Utilities, keine Custom CSS wenn vermeidbar + +### Allgemein +- **Comments:** Englisch im Code +- **No Magic Numbers:** Konstanten mit sprechenden Namen +- **DRY:** Duplikation erst ab 3. Vorkommen abstrahieren + +## Workflow +- **Commits:** Konventionelle Messages (feat, fix, refactor, docs, test) +- **Branches:** `feature/`, `fix/`, `refactor/` Prefixes +- **Tests:** pytest / Django TestCase, min. 80% Coverage für kritische Pfade +- **Code Review Fokus:** Security > Correctness > Performance > Style + +## Abneigungen (NICHT machen!) +- Over-Engineering ohne konkreten Nutzen +- Premature Optimization +- Magic Imports (implizite Abhängigkeiten) +- `any` Types in TypeScript +- Undokumentierte Public APIs +- Tests ohne Assertions + +# ANTI-PATTERN-CHECKLISTE (vor Code-Änderungen prüfen!) + +## N+1 Queries +- **Regel:** IMMER `select_related()` für FK/O2O, `prefetch_related()` für M2M/Reverse FK +- **Check:** Listen-Endpoints mit Related Objects → Query-Optimierung pflicht +- **Details:** `/knowledge/anti-patterns/n-plus-1-queries.md` + +## Secrets im Code +- **Regel:** NIEMALS Passwörter, API-Keys, Tokens hardcoded +- **Check:** `.env` in `.gitignore`? Env-Vars für Secrets? CI/CD masked? +- **Details:** `/knowledge/anti-patterns/secrets-in-code.md` + +## Fat Views +- **Regel:** Views NUR für Request/Response, Business Logic ins Model/Service +- **Check:** View > 30 Zeilen? → Refactoring-Kandidat +- **Details:** `/knowledge/anti-patterns/fat-views.md` + +# KNOWLEDGE-TRIGGER (wann `/knowledge` lesen) + +| Trigger | Aktion | +|---------|--------| +| VOR Code-Reviews | Lies relevante Anti-Patterns | +| BEI Performance-Issues | Lies `/knowledge/anti-patterns/n-plus-1-queries.md` | +| BEI neuem Projekt-Setup | Prüfe Tech-Stack gegen Präferenzen | +| BEI Security-Fragen | Lies `/knowledge/anti-patterns/secrets-in-code.md` | diff --git a/vault-index.md b/vault-index.md index 5660e75..5025d75 100644 --- a/vault-index.md +++ b/vault-index.md @@ -18,13 +18,13 @@ Spezialisiert auf das Django-basierte Liga-Planungssystem: | Skill | Beschreibung | Invocation | |-------|--------------|------------| -| **[django-model](./skills/django-model/SKILL.md)** | Django 5.2 Models mit Fat Model Pattern, Custom Managers | `/django-model` | -| **[drf-api](./skills/drf-api/SKILL.md)** | DRF API Endpoints mit @api_view, drf-spectacular | `/drf-api` | -| **[celery-task](./skills/celery-task/SKILL.md)** | Celery 5.5 Tasks mit AbortableTask, Progress Tracking | `/celery-task` | -| **[permissions](./skills/permissions/SKILL.md)** | Multi-Tier Permissions mit Decorators, Session-based Access | `/permissions` | -| **[query-optimizer](./skills/query-optimizer/SKILL.md)** | N+1 Query Fixes, select_related/prefetch_related | `/query-optimizer` | -| **[solver](./skills/solver/SKILL.md)** | PuLP/Xpress MIP Solver Integration | `/solver` | -| **[testing](./skills/testing/SKILL.md)** | Django TestCase mit Multi-DB Support, CRUD Tags | `/testing` | +| **[django-model](./skills/django-model/SKILL.md)** | Django 5.2 Models mit Fat Model Pattern, Custom Managers | `/lp-django-model` | +| **[drf-api](./skills/drf-api/SKILL.md)** | DRF API Endpoints mit @api_view, drf-spectacular | `/lp-drf-api` | +| **[celery-task](./skills/celery-task/SKILL.md)** | Celery 5.5 Tasks mit AbortableTask, Progress Tracking | `/lp-celery-task` | +| **[permissions](./skills/permissions/SKILL.md)** | Multi-Tier Permissions mit Decorators, Session-based Access | `/lp-permissions` | +| **[query-optimizer](./skills/query-optimizer/SKILL.md)** | N+1 Query Fixes, select_related/prefetch_related | `/lp-query-optimizer` | +| **[solver](./skills/solver/SKILL.md)** | PuLP/Xpress MIP Solver Integration | `/lp-solver` | +| **[testing](./skills/testing/SKILL.md)** | Django TestCase mit Multi-DB Support, CRUD Tags | `/lp-testing` | ### Allgemeine Skills | Skill | Beschreibung | Invocation | @@ -138,4 +138,4 @@ Siehe [scripts/README.md](./scripts/README.md) für Details. --- -*Letzte Aktualisierung: 2026-02-04* +*Letzte Aktualisierung: 2026-02-04 (Index korrigiert: lp-* Skill-Namen)*