superlocalmemory 2.3.0

package/hooks/memory-recall-skill.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Memory Recall CLI Skill
+ * Search and retrieve memories with advanced filtering
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+
+const execFileAsync = promisify(execFile);
+
+async function memoryRecallSkill() {
+  const memoryScript = path.join(process.env.HOME, '.claude-memory', 'memory_store_v2.py');
+  const args = process.argv.slice(2);
+
+  // Show help if no args or --help
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                                                          ║
+║     SuperLocalMemory V2 - Recall (Search Memories)       ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+
+Search your memory store using semantic search and filters.
+Finds relevant memories using TF-IDF similarity and metadata.
+
+Usage: memory-recall <query> [options]
+
+Arguments:
+  <query>                 Search query (required)
+
+Options:
+  --limit <n>            Maximum results to return (default: 10)
+
+Examples:
+  memory-recall "authentication bug"
+
+  memory-recall "API configuration" --limit 5
+
+  memory-recall "security best practices"
+
+  memory-recall "user preferences"
+
+Output Format:
+  • Ranked by relevance (TF-IDF cosine similarity)
+  • Shows: ID, Content, Tags, Importance, Timestamp
+  • Higher scores = better matches
+
+Notes:
+  • Uses local TF-IDF search (no external APIs)
+  • Searches content, summary, and tags
+  • Empty query returns recent memories
+  • Use quotes for multi-word queries
+`);
+    return;
+  }
+
+  // Parse query and options
+  let query = null;
+  const pythonArgs = ['search'];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--limit' && i + 1 < args.length) {
+      // Note: V1 store doesn't support --limit in search, will truncate output instead
+      i++; // Skip but don't add to pythonArgs
+    } else if (!arg.startsWith('--') && query === null) {
+      query = arg;
+    }
+  }
+
+  // Validate query
+  if (!query || query.trim().length === 0) {
+    console.log(`
+❌ ERROR: Search query required
+
+Usage: memory-recall <query> [options]
+
+Example:
+  memory-recall "search term" --limit 10
+
+Use --help for more information
+`);
+    return;
+  }
+
+  // Add query to Python args
+  pythonArgs.push(query);
+
+  try {
+    const { stdout, stderr } = await execFileAsync('python3', [memoryScript, ...pythonArgs]);
+
+    if (stderr) {
+      console.error('⚠️  Warning:', stderr);
+    }
+
+    console.log(stdout);
+
+  } catch (error) {
+    console.error('❌ Error searching memories:', error.message);
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(error.stderr);
+  }
+}
+
+memoryRecallSkill();

package/hooks/memory-remember-skill.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Memory Remember CLI Skill
+ * Save memories with tags, project context, and importance levels
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+
+const execFileAsync = promisify(execFile);
+
+async function memoryRememberSkill() {
+  const memoryScript = path.join(process.env.HOME, '.claude-memory', 'memory_store_v2.py');
+  const args = process.argv.slice(2);
+
+  // Show help if no args or --help
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                                                          ║
+║     SuperLocalMemory V2 - Remember (Save Memory)         ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+
+Save important information to your persistent memory store.
+Memories are indexed, searchable, and integrated with graph knowledge.
+
+Usage: memory-remember <content> [options]
+
+Arguments:
+  <content>               The memory content to save (required)
+
+Options:
+  --tags <tag1,tag2>      Comma-separated tags for categorization
+  --project <path>        Project path context
+
+Examples:
+  memory-remember "API key stored in .env file" --tags security,config
+
+  memory-remember "User prefers tabs over spaces"
+
+  memory-remember "Bug in auth.js line 42" --project ~/work/app --tags bug
+
+  memory-remember "Meeting notes: Q1 launch March 15" --tags meeting,deadline
+
+Notes:
+  • Content is deduplicated automatically
+  • Tags enable fast filtering during recall
+  • Project context links memories to codebases
+  • Use semantic search to find related memories
+`);
+    return;
+  }
+
+  // Parse content (first non-flag argument) and options
+  let content = null;
+  let tags = null;
+  let project = null;
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === '--tags' && i + 1 < args.length) {
+      tags = args[i + 1];
+      i += 2; // Skip flag and value
+    } else if (arg === '--project' && i + 1 < args.length) {
+      project = args[i + 1];
+      i += 2; // Skip flag and value
+    } else if (!arg.startsWith('--') && content === null) {
+      content = arg;
+      i++;
+    } else {
+      i++;
+    }
+  }
+
+  // Validate content
+  if (!content || content.trim().length === 0) {
+    console.log(`
+❌ ERROR: Memory content required
+
+Usage: memory-remember <content> [options]
+
+Example:
+  memory-remember "Important information here" --tags example
+
+Use --help for more information
+`);
+    return;
+  }
+
+  // Build Python command: add <content> [--project <path>] [--tags tag1,tag2]
+  const pythonArgs = ['add', content];
+
+  if (project) {
+    pythonArgs.push('--project', project);
+  }
+
+  if (tags) {
+    pythonArgs.push('--tags', tags);
+  }
+
+  try {
+    const { stdout, stderr } = await execFileAsync('python3', [memoryScript, ...pythonArgs]);
+
+    if (stderr) {
+      console.error('⚠️  Warning:', stderr);
+    }
+
+    console.log(stdout);
+    console.log('✅ Memory saved successfully\n');
+
+    // Show helpful next steps
+    console.log('Next steps:');
+    console.log('  • Use `memory-recall <query>` to search this memory');
+    console.log('  • Use `memory-list` to see recent memories');
+
+  } catch (error) {
+    console.error('❌ Error saving memory:', error.message);
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(error.stderr);
+  }
+}
+
+memoryRememberSkill();

package/hooks/memory-reset-skill.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * Memory Reset CLI Skill
+ * Provides /memory-reset command with safety warnings
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const readline = require('readline');
+
+const execFileAsync = promisify(execFile);
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+
+async function memoryResetSkill() {
+  const resetScript = path.join(process.env.HOME, '.claude-memory', 'memory-reset.py');
+  const args = process.argv.slice(2); // Get command line arguments
+
+  // Show help if no args
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                                                          ║
+║       SuperLocalMemory V2 - Reset Commands              ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+
+Usage: /memory-reset <command> [options]
+
+Commands:
+  status              Show current memory system status (SAFE)
+  soft                Clear all memories, keep V2 schema (⚠️  DESTRUCTIVE)
+  hard --confirm      Delete everything, reinitialize (🔴 NUCLEAR)
+  layer --layers X    Clear specific layers only (⚠️  SELECTIVE)
+
+Examples:
+  /memory-reset status
+  /memory-reset soft
+  /memory-reset hard --confirm
+  /memory-reset layer --layers graph patterns
+
+⚠️  WARNING: soft/hard/layer operations create automatic backups
+             but will delete data. Always check status first!
+
+Quick commands:
+  /memory-status      Alias for: /memory-reset status
+  /memory-soft-reset  Alias for: /memory-reset soft
+`);
+    rl.close();
+    return;
+  }
+
+  const command = args[0];
+
+  // STATUS command (safe, no warnings)
+  if (command === 'status') {
+    try {
+      const { stdout } = await execFileAsync('python', [resetScript, 'status']);
+      console.log(stdout);
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+    }
+    rl.close();
+    return;
+  }
+
+  // SOFT RESET command (destructive, show warning)
+  if (command === 'soft') {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                    ⚠️  WARNING ⚠️                        ║
+╚══════════════════════════════════════════════════════════╝
+
+SOFT RESET will:
+  ✓ Delete ALL memories from current profile
+  ✓ Clear graph data (nodes, edges, clusters)
+  ✓ Clear learned identity patterns
+  ✓ Clear tree structure
+  ✓ Create automatic backup before deletion
+  ✓ Keep V2 schema structure intact
+
+What it WON'T delete:
+  ✓ Python code (graph_engine.py, etc.)
+  ✓ Other profiles (if using profile system)
+  ✓ Documentation files
+
+Backup location: ~/.claude-memory/backups/pre-reset-[timestamp].db
+`);
+
+    const answer = await question('Proceed with soft reset? (yes/no): ');
+
+    if (answer.toLowerCase() === 'yes') {
+      try {
+        const { stdout } = await execFileAsync('python', [resetScript, 'soft']);
+        console.log(stdout);
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // HARD RESET command (nuclear, extra warnings)
+  if (command === 'hard') {
+    if (!args.includes('--confirm')) {
+      console.log(`
+❌ ERROR: Hard reset requires --confirm flag
+
+HARD RESET is DESTRUCTIVE and will:
+  🔴 Delete the ENTIRE database file
+  🔴 Remove ALL memories permanently
+  🔴 Remove ALL graph data permanently
+  🔴 Remove ALL learned patterns permanently
+
+This is the NUCLEAR option. Use only if:
+  - You want to completely start over
+  - You're sure you don't need any current data
+  - You've manually backed up anything important
+
+A backup will be created automatically, but this is irreversible
+within the system.
+
+To proceed, use:
+  /memory-reset hard --confirm
+`);
+      rl.close();
+      return;
+    }
+
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                  🔴 DANGER ZONE 🔴                       ║
+╚══════════════════════════════════════════════════════════╝
+
+HARD RESET will:
+  🔴 DELETE the entire database file (memory.db)
+  🔴 DESTROY all memories (cannot undo within system)
+  🔴 ERASE all graph relationships
+  🔴 REMOVE all learned patterns
+  🔴 Reinitialize fresh V2 schema
+
+What it KEEPS:
+  ✓ Python code
+  ✓ Virtual environment
+  ✓ Documentation
+  ✓ Backups (one will be created now)
+
+This is the MOST DESTRUCTIVE option.
+
+Backup location: ~/.claude-memory/backups/pre-reset-[timestamp].db
+`);
+
+    const answer = await question('Type "DELETE EVERYTHING" to confirm: ');
+
+    if (answer === 'DELETE EVERYTHING') {
+      try {
+        const { stdout } = await execFileAsync('python', [
+          resetScript,
+          'hard',
+          '--confirm'
+        ]);
+        console.log(stdout);
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+      console.log('(You must type exactly "DELETE EVERYTHING" to confirm)');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // LAYER RESET command (selective)
+  if (command === 'layer') {
+    const layersIndex = args.indexOf('--layers');
+
+    if (layersIndex === -1 || layersIndex === args.length - 1) {
+      console.log(`
+❌ ERROR: --layers flag required with layer names
+
+Usage: /memory-reset layer --layers <layer1> [layer2] [layer3]
+
+Available layers:
+  graph     - Clear graph nodes, edges, clusters (keeps memories)
+  patterns  - Clear learned identity patterns (keeps memories)
+  tree      - Clear hierarchical structure (keeps memories)
+  archive   - Clear compressed memory archives
+
+Examples:
+  /memory-reset layer --layers graph
+  /memory-reset layer --layers graph patterns
+  /memory-reset layer --layers graph patterns tree
+
+This is SELECTIVE - only specified layers are cleared.
+Memories remain intact unless you clear 'archive' layer.
+`);
+      rl.close();
+      return;
+    }
+
+    const layers = args.slice(layersIndex + 1);
+
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║              ⚠️  SELECTIVE LAYER RESET ⚠️                ║
+╚══════════════════════════════════════════════════════════╝
+
+Will clear these layers: ${layers.join(', ')}
+
+What this does:
+  ${layers.includes('graph') ? '✓ Clears graph nodes, edges, clusters' : ''}
+  ${layers.includes('patterns') ? '✓ Clears learned identity patterns' : ''}
+  ${layers.includes('tree') ? '✓ Clears hierarchical tree structure' : ''}
+  ${layers.includes('archive') ? '✓ Clears compressed memory archives' : ''}
+
+What it KEEPS:
+  ✓ Raw memories (unless clearing archive)
+  ✓ Unaffected layers
+  ✓ All backups
+
+You can rebuild cleared layers:
+  - Graph: python graph_engine.py build
+  - Patterns: python pattern_learner.py update
+  - Tree: python tree_manager.py build_tree
+
+Backup location: ~/.claude-memory/backups/pre-reset-[timestamp].db
+`);
+
+    const answer = await question('Proceed with layer reset? (yes/no): ');
+
+    if (answer.toLowerCase() === 'yes') {
+      try {
+        const { stdout } = await execFileAsync('python', [
+          resetScript,
+          'layer',
+          '--layers',
+          ...layers
+        ]);
+        console.log(stdout);
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // Unknown command
+  console.log(`
+❌ Unknown command: ${command}
+
+Valid commands: status, soft, hard, layer
+
+Use: /memory-reset --help for more information
+`);
+  rl.close();
+}
+
+memoryResetSkill();