superlocalmemory 3.4.18 → 3.4.21

package/skills/slm-remember/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: slm-remember
+description: Save content to SuperLocalMemory with intelligent indexing and knowledge graph integration. Use when the user wants to remember information, save context, store coding decisions, or persist knowledge for future sessions. Automatically indexes, graphs, and learns patterns.
+version: "3.4.21"
+license: AGPL-3.0-or-later
+compatibility: "Requires SuperLocalMemory V2 installed at ~/.claude-memory/"
+attribution:
+  creator: Varun Pratap Bhardwaj
+  role: Solution Architect & Original Creator
+  project: SuperLocalMemory V2
+---
+
+# SuperLocalMemory: Remember
+
+Save content to your local memory system with automatic indexing, knowledge graph integration, and pattern learning.
+
+## Usage
+
+```bash
+slm remember "<content>" [--tags tag1,tag2] [--project name] [--importance 1-10]
+```
+
+## Examples
+
+### Example 1: Basic Memory
+```bash
+slm remember "We use FastAPI for REST APIs"
+```
+
+**What happens:**
+- Content saved to SQLite database
+- TF-IDF vectors generated for semantic search
+- Entities extracted and added to knowledge graph
+- Pattern learning analyzes for coding preferences
+- Memory ID returned (e.g., 42)
+
+### Example 2: With Tags
+```bash
+slm remember "JWT tokens expire after 24 hours" --tags security,auth,jwt
+```
+
+**Tags help with:**
+- Organization
+- Filtering
+- Related memory discovery
+
+### Example 3: With Project
+```bash
+slm remember "Database uses PostgreSQL 15 with UUID primary keys" --project myapp --tags database,postgresql
+```
+
+**Project isolation:**
+- Separate memories per project
+- Switch profiles with `slm switch-profile`
+- No context bleeding
+
+### Example 4: Important Memory
+```bash
+slm remember "CRITICAL: Production deploy requires approval from @lead" --importance 10 --tags deployment,production
+```
+
+**Importance (1-10):**
+- 1-3: Low priority (notes, ideas)
+- 4-6: Normal (coding patterns, decisions)
+- 7-9: High priority (critical info, warnings)
+- 10: Critical (blockers, security issues)
+
+## Arguments
+
+| Argument | Type | Required | Default | Description |
+|----------|------|----------|---------|-------------|
+| `<content>` | string | Yes | - | The text to remember |
+| `--tags` | string | No | None | Comma-separated tags |
+| `--project` | string | No | "default" | Project name |
+| `--importance` | integer | No | 5 | Priority level (1-10) |
+
+## Output
+
+```
+Memory added with ID: 42
+
+✅ Memory saved successfully
+
+Next steps:
+  • Use `slm recall <query>` to search this memory
+  • Use `slm list` to see recent memories
+```
+
+## What Happens Behind the Scenes
+
+1. **Content Storage:** Saved to SQLite (`~/.claude-memory/memory.db`)
+2. **Semantic Indexing:** TF-IDF vectors generated for similarity search
+3. **Knowledge Graph:** Entities extracted and nodes/edges created
+4. **Pattern Learning:** Analyzes content for coding preferences (frameworks, style, testing)
+5. **Full-Text Index:** FTS5 index updated for fast keyword search
+6. **Timestamp:** Created timestamp recorded
+
+## Advanced Usage
+
+### Natural Language (in AI chat)
+
+Most AI assistants will automatically invoke this skill when you say:
+- "Remember that..."
+- "Save this for later..."
+- "I want to store..."
+- "Keep track of..."
+
+**Example in Cursor/Claude:**
+```
+You: "Remember that we decided to use React hooks over class components"
+AI: [Automatically invokes slm-remember skill]
+✓ Memory saved
+```
+
+### Bulk Import
+
+Save multiple memories from a file:
+```bash
+# From text file (one memory per line)
+while IFS= read -r line; do
+  slm remember "$line" --project bulk-import
+done < memories.txt
+
+# From CSV (content,tags,project)
+while IFS=',' read -r content tags project; do
+  slm remember "$content" --tags "$tags" --project "$project"
+done < memories.csv
+```
+
+### Integration with Git Hooks
+
+**Pre-commit hook** (save commit messages):
+```bash
+#!/bin/bash
+# .git/hooks/post-commit
+
+commit_msg=$(git log -1 --pretty=%B)
+commit_hash=$(git log -1 --pretty=%H)
+
+slm remember "Commit: $commit_msg (${commit_hash:0:7})" \
+  --tags git,commit \
+  --project "$(basename $(git rev-parse --show-toplevel))"
+```
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| "Database locked" | Another process accessing DB | Wait or `killall python3` |
+| "Content cannot be empty" | Empty string passed | Provide content |
+| "Invalid importance" | Value not 1-10 | Use number between 1-10 |
+| "Database not found" | SuperLocalMemory not installed | Run `./install.sh` |
+
+## Notes
+
+- **100% local:** Nothing leaves your machine
+- **Cross-tool sync:** All AI tools access same database (Cursor, ChatGPT, Claude, etc.)
+- **Unlimited:** No memory limits, no quotas
+- **Privacy:** Your data stays on your computer
+- **Profiles:** Use `slm switch-profile` for profile isolation
+
+## Related Commands
+
+- `slm recall "<query>"` - Search memories semantically
+- `slm list` - List recent memories
+- `slm status` - Check system health
+- `slm build-graph` - Rebuild knowledge graph
+- `slm switch-profile <name>` - Switch memory profile
+
+## Technical Details
+
+**Database Schema:**
+- Table: `memories`
+- Fields: id, content, tags, project_name, importance, created_at, etc.
+- Indexes: Full-text search (FTS5), TF-IDF vectors, timestamps
+
+**Performance:**
+- Add memory: ~50ms
+- With knowledge graph: ~300ms
+- Large content (10KB): ~1s
+
+**Limits:**
+- Max content size: 1MB
+- Max tags: 50 per memory
+- Max project name: 64 characters
+
+---
+
+**Created by:** [Varun Pratap Bhardwaj](https://github.com/varun369) (Solution Architect)
+**Project:** SuperLocalMemory V2
+**License:** MIT (see [LICENSE](../../LICENSE))
+**Repository:** https://github.com/varun369/SuperLocalMemoryV2
+
+*Open source doesn't mean removing credit. Attribution must be preserved per MIT License terms.*

package/skills/slm-show-patterns/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: slm-show-patterns
+description: Show what SuperLocalMemory has learned about your preferences, workflow patterns, and project context. Use when the user asks "what have you learned about me?" or wants to see their coding identity patterns. Shows tech preferences, workflow sequences, and engagement health.
+version: "2.7.0"
+license: AGPL-3.0-or-later
+compatibility: "Requires SuperLocalMemory V2.7+ with learning features"
+attribution:
+  creator: Varun Pratap Bhardwaj
+  role: Solution Architect & Original Creator
+  project: SuperLocalMemory V2
+---
+
+# SuperLocalMemory: Show Patterns
+
+Show what SuperLocalMemory has learned about your preferences, workflow, and coding identity.
+
+## Usage
+
+```bash
+slm patterns list [threshold]
+slm learning status
+slm engagement
+```
+
+## Example Output
+
+### Learned Patterns
+```bash
+$ slm patterns list 0.5
+```
+
+**Output:**
+```
+Learned Patterns (confidence >= 0.5)
+=====================================
+
+TECH PREFERENCES (cross-project):
+  #1  preferred_framework: React        confidence: 0.92  (seen in 3 profiles)
+  #2  preferred_language: Python         confidence: 0.88  (seen in 2 profiles)
+  #3  preferred_backend: FastAPI         confidence: 0.85  (seen in 2 profiles)
+  #4  testing_style: pytest              confidence: 0.78  (seen in 1 profile)
+  #5  preferred_db: PostgreSQL           confidence: 0.71  (seen in 2 profiles)
+
+WORKFLOW PATTERNS:
+  #6  morning_sequence: recall -> code -> remember    frequency: 34
+  #7  debug_sequence: recall -> recall -> remember    frequency: 18
+  #8  review_sequence: list -> recall -> remember     frequency: 12
+
+PROJECT CONTEXT:
+  #9  active_project: SuperLocalMemoryV2    last_seen: 2 hours ago
+  #10 active_project: client-dashboard      last_seen: 1 day ago
+
+Total: 10 patterns (7 high confidence)
+```
+
+### Learning Status
+```bash
+$ slm learning status
+```
+
+**Output:**
+```
+SuperLocalMemory v2.7 -- Learning System Status
+==================================================
+LightGBM:  installed (4.5.0)
+SciPy:     installed (1.14.1)
+ML Ranking:  available
+Full Learning: available
+
+Feedback signals: 247
+Unique queries:   89
+Patterns learned: 34 (12 high confidence)
+Workflow patterns: 8
+Sources tracked:  4
+Models trained:   2
+Learning DB size: 128 KB
+```
+
+### Engagement Metrics
+```bash
+$ slm engagement
+```
+
+**Output:**
+```
+SuperLocalMemory -- Engagement Health
+======================================
+Status: HEALTHY
+
+This Week:
+  Memories saved:    12
+  Recalls performed: 28
+  Memories marked useful: 8
+  Feedback ratio:    28.6%
+
+Trends:
+  Recall frequency:  increasing (up 15% from last week)
+  Save frequency:    stable
+  Useful feedback:   increasing (up 40% from last week)
+
+Streaks:
+  Current daily streak: 5 days
+  Longest streak:       14 days
+```
+
+## What the Patterns Mean
+
+### Tech Preferences
+Cross-project patterns that transfer between profiles. These represent your coding identity -- which frameworks, languages, and tools you consistently choose.
+
+**How they are learned:**
+- Extracted from memory content (mentions of frameworks, tools)
+- Weighted by recency and frequency
+- Confidence increases when the same preference appears across multiple profiles
+
+**How they help:**
+- When you `recall`, results matching your preferred stack rank higher
+- Your AI tools can reference these to tailor suggestions
+
+### Workflow Patterns
+Sequences of actions you repeat. The system learns your work rhythm.
+
+**Examples:**
+- `recall -> code -> remember` = "Research, build, document" workflow
+- `recall -> recall -> remember` = "Deep investigation" workflow
+
+**How they help:**
+- System predicts what you will need next
+- Can pre-load relevant context based on your current workflow stage
+
+### Engagement Health
+Overall system usage metrics (fully local, zero telemetry).
+
+**Healthy indicators:**
+- Regular daily usage (streaks)
+- Balanced save/recall ratio
+- Increasing useful feedback
+
+**Warning signs:**
+- No recalls for 7+ days = stale memories
+- No saves for 7+ days = not capturing knowledge
+- Zero feedback = system cannot learn your preferences
+
+## Correcting Patterns
+
+If the system learned something wrong, correct it:
+
+```bash
+# See all patterns
+slm patterns list
+
+# Correct pattern #3 from "FastAPI" to "Django"
+slm patterns correct 3 Django
+```
+
+The correction increases confidence to 1.0 and records the change history.
+
+## Options
+
+| Command | Description | Use Case |
+|---------|-------------|----------|
+| `slm patterns list` | All patterns (no threshold) | See everything learned |
+| `slm patterns list 0.7` | High confidence only | See reliable patterns |
+| `slm patterns correct <id> <value>` | Fix a wrong pattern | Override incorrect learning |
+| `slm learning status` | System health | Check deps and stats |
+| `slm learning retrain` | Force model retrain | After bulk feedback |
+| `slm learning reset` | Delete all learning data | Fresh start (memories preserved) |
+| `slm engagement` | Usage metrics | Track your engagement health |
+
+## Use Cases
+
+### 1. "What Have You Learned About Me?"
+```bash
+slm patterns list
+# Shows all preferences, workflows, and project context
+```
+
+### 2. Pre-Session Context Loading
+```bash
+slm patterns context
+# Returns structured context for AI tools to consume
+```
+
+### 3. Onboarding a New AI Tool
+```bash
+slm learning status
+# Verify learning is active, then use your existing memories
+# New tool benefits from all previously learned patterns
+```
+
+### 4. Weekly Review
+```bash
+slm engagement
+# Check if you are using your memory system effectively
+```
+
+## Requirements
+
+- SuperLocalMemory V2.7+
+- Optional: `lightgbm` and `scipy` for ML-powered ranking
+- Works without optional deps (uses rule-based ranking as fallback)
+
+## Notes
+
+- **Privacy:** All learning is local. Zero telemetry, zero cloud calls.
+- **Separate storage:** Learning data lives in `learning.db`, separate from `memory.db`.
+- **Non-destructive:** `slm learning reset` only deletes learning data, never memories.
+- **Graceful degradation:** If learning deps are missing, core features work normally.
+
+## Related Commands
+
+- `slm recall` - Search memories (results ranked by learned patterns)
+- `slm useful <id>` - Mark memory as useful (feedback for learning)
+- `slm status` - Overall system status
+- `slm patterns update` - Re-learn patterns from existing memories
+
+---
+
+**Created by:** [Varun Pratap Bhardwaj](https://github.com/varun369) (Solution Architect)
+**Project:** SuperLocalMemory V2
+**License:** MIT (see [LICENSE](../../LICENSE))
+**Repository:** https://github.com/varun369/SuperLocalMemoryV2
+
+*Open source doesn't mean removing credit. Attribution must be preserved per MIT License terms.*