superlocalmemory 2.3.0

package/docs/WINDOWS-POST-INSTALL.txt

@@ -0,0 +1,45 @@
+SuperLocalMemory V2.1.0 - Installation Complete!
+================================================
+
+Installation successful!
+
+Location: %USERPROFILE%\.claude-memory\
+CLI Command: slm
+
+Quick Start:
+------------
+1. Open a NEW Command Prompt or PowerShell window
+   (Required for PATH changes to take effect)
+
+2. Verify installation:
+   > slm status
+
+3. Store your first memory:
+   > slm remember "React is my preferred framework" --tags frontend
+
+4. Search memories:
+   > slm recall "React"
+
+5. Launch dashboard (optional):
+   > powershell -ExecutionPolicy Bypass -File start-dashboard.ps1
+
+Integrated IDEs:
+----------------
+SuperLocalMemory is now available in:
+✓ Claude Desktop (restart to see @SuperLocalMemory)
+✓ Cursor (restart IDE)
+✓ Windsurf (restart IDE)
+✓ Continue.dev (use /slm-* skills)
+✓ Cody (use custom commands)
+✓ And 6+ more tools (11+ IDEs supported total)
+
+Troubleshooting:
+----------------
+• 'slm' not found: Open NEW terminal window
+• Python errors: Ensure Python 3.8+ is installed
+• Permission errors: Run PowerShell as Administrator
+
+Documentation: https://github.com/varun369/SuperLocalMemoryV2/wiki
+Support: https://github.com/varun369/SuperLocalMemoryV2/issues
+
+Copyright (c) 2026 Varun Pratap Bhardwaj

package/docs/example_graph_usage.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - example_graph_usage.py
+
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Solution Architect & Original Creator
+
+Licensed under MIT License (see LICENSE file)
+Repository: https://github.com/varun369/SuperLocalMemoryV2
+
+ATTRIBUTION REQUIRED: This notice must be preserved in all copies.
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from graph_engine import GraphEngine
+
+
+def example_build_graph():
+    """Example: Build complete knowledge graph."""
+    print("=" * 60)
+    print("Example 1: Build Knowledge Graph")
+    print("=" * 60)
+
+    engine = GraphEngine()
+
+    # Build graph with default similarity threshold (0.3)
+    stats = engine.build_graph(min_similarity=0.3)
+
+    print(f"Graph built successfully!")
+    print(f"  - Nodes: {stats['nodes']}")
+    print(f"  - Edges: {stats['edges']}")
+    print(f"  - Clusters: {stats['clusters']}")
+    print(f"  - Time: {stats['time_seconds']}s")
+    print()
+
+
+def example_find_related():
+    """Example: Find related memories."""
+    print("=" * 60)
+    print("Example 2: Find Related Memories")
+    print("=" * 60)
+
+    engine = GraphEngine()
+
+    # Find memories related to memory #1
+    memory_id = 1
+    related = engine.get_related(memory_id, max_hops=2)
+
+    print(f"Memories related to #{memory_id}:")
+    for idx, mem in enumerate(related[:5], 1):  # Top 5
+        print(f"\n{idx}. Memory #{mem['id']} ({mem['hops']}-hop)")
+        print(f"   Relationship: {mem['relationship']}")
+        print(f"   Weight: {mem['weight']:.3f}")
+        print(f"   Importance: {mem['importance']}")
+        if mem['shared_entities']:
+            print(f"   Shared entities: {', '.join(mem['shared_entities'][:3])}")
+    print()
+
+
+def example_query_clusters():
+    """Example: Query memory clusters."""
+    print("=" * 60)
+    print("Example 3: Query Clusters")
+    print("=" * 60)
+
+    engine = GraphEngine()
+
+    # Get statistics
+    stats = engine.get_stats()
+
+    print(f"Total clusters: {stats['clusters']}")
+    print("\nTop clusters:")
+
+    for cluster in stats['top_clusters'][:5]:
+        print(f"\n  - {cluster['name']}")
+        print(f"    Members: {cluster['members']}")
+        print(f"    Avg Importance: {cluster['avg_importance']}")
+
+        # Get cluster members
+        cluster_id = stats['top_clusters'].index(cluster) + 1
+        members = engine.get_cluster_members(cluster_id)
+
+        print(f"    Sample memories: {[m['id'] for m in members[:3]]}")
+    print()
+
+
+def example_incremental_add():
+    """Example: Add memory to existing graph."""
+    print("=" * 60)
+    print("Example 4: Incremental Add")
+    print("=" * 60)
+
+    engine = GraphEngine()
+
+    # Simulate adding a new memory (would normally be created first)
+    memory_id = 5  # Existing memory
+
+    print(f"Adding memory #{memory_id} to graph...")
+    success = engine.add_memory_incremental(memory_id)
+
+    if success:
+        print(f"Memory #{memory_id} added successfully!")
+
+        # Find what it connected to
+        related = engine.get_related(memory_id, max_hops=1)
+        print(f"Connected to {len(related)} existing memories")
+    else:
+        print("Failed to add memory")
+    print()
+
+
+def example_extract_entities():
+    """Example: Extract entities from a memory."""
+    print("=" * 60)
+    print("Example 5: Entity Extraction")
+    print("=" * 60)
+
+    engine = GraphEngine()
+
+    memory_id = 1
+    entities = engine.extract_entities(memory_id)
+
+    print(f"Entities extracted from memory #{memory_id}:")
+    for idx, entity in enumerate(entities[:10], 1):
+        print(f"  {idx}. {entity}")
+    print()
+
+
+if __name__ == '__main__':
+    print("\n" + "=" * 60)
+    print("GraphEngine Usage Examples")
+    print("=" * 60 + "\n")
+
+    # Run all examples
+    example_build_graph()
+    example_find_related()
+    example_query_clusters()
+    example_extract_entities()
+    example_incremental_add()
+
+    print("=" * 60)
+    print("All examples completed!")
+    print("=" * 60)

package/hooks/memory-list-skill.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * Memory List CLI Skill
+ * List recent memories with sorting and filtering
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+
+const execFileAsync = promisify(execFile);
+
+async function memoryListSkill() {
+  const memoryScript = path.join(process.env.HOME, '.claude-memory', 'memory_store_v2.py');
+  const args = process.argv.slice(2);
+
+  // Show help if --help
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║                                                          ║
+║     SuperLocalMemory V2 - List Recent Memories           ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+
+Display recent memories with optional sorting and limits.
+Quick overview of what's stored in your memory database.
+
+Usage: memory-list [options]
+
+Options:
+  --limit <n>            Number of memories to show (default: 20)
+  --sort <field>         Sort by: recent, accessed, importance
+                         • recent: Latest created first (default)
+                         • accessed: Most recently accessed
+                         • importance: Highest importance first
+
+Examples:
+  memory-list
+
+  memory-list --limit 50
+
+  memory-list --sort importance
+
+  memory-list --limit 10 --sort accessed
+
+Output Format:
+  • ID, Content (truncated), Tags, Importance
+  • Creation timestamp
+  • Access count and last accessed time
+
+Notes:
+  • Default shows last 20 memories
+  • Content is truncated to 100 chars for readability
+  • Use ID with memory-recall to see full content
+  • Sort by 'accessed' to find frequently used memories
+`);
+    return;
+  }
+
+  // Parse options
+  let limit = 20;
+  let sortBy = 'recent';
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--limit' && i + 1 < args.length) {
+      const parsedLimit = parseInt(args[i + 1]);
+      if (parsedLimit > 0 && parsedLimit <= 1000) {
+        limit = parsedLimit;
+      } else {
+        console.error('❌ ERROR: Limit must be between 1-1000');
+        return;
+      }
+      i++;
+    } else if (arg === '--sort' && i + 1 < args.length) {
+      const validSorts = ['recent', 'accessed', 'importance'];
+      if (validSorts.includes(args[i + 1])) {
+        sortBy = args[i + 1];
+      } else {
+        console.error(`❌ ERROR: Sort must be one of: ${validSorts.join(', ')}`);
+        return;
+      }
+      i++;
+    }
+  }
+
+  // Build Python command based on sort type
+  // Note: V1 store only supports 'recent' and 'list' commands without sort flags
+  let pythonArgs = [];
+
+  if (sortBy === 'recent' || sortBy === 'accessed') {
+    pythonArgs = ['recent', limit.toString()];
+  } else {
+    // Default to list for importance or other sorts
+    pythonArgs = ['list', limit.toString()];
+  }
+
+  try {
+    const { stdout, stderr } = await execFileAsync('python3', [memoryScript, ...pythonArgs]);
+
+    if (stderr) {
+      console.error('⚠️  Warning:', stderr);
+    }
+
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║     Recent Memories (${sortBy} | limit: ${limit})
+╚══════════════════════════════════════════════════════════╝
+`);
+
+    console.log(stdout);
+
+    // Show helpful next steps
+    console.log(`
+Next steps:
+  • Use \`memory-recall <query>\` to search memories
+  • Use \`memory-remember <content>\` to add new memories
+  • Use \`memory-list --sort <field>\` to change sort order
+`);
+
+  } catch (error) {
+    console.error('❌ Error listing memories:', error.message);
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(error.stderr);
+  }
+}
+
+memoryListSkill();

package/hooks/memory-profile-skill.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/**
+ * Memory Profile CLI Skill
+ * Provides memory-profile commands for managing multiple memory contexts
+ */
+
+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 memoryProfileSkill() {
+  const profileScript = path.join(process.env.HOME, '.claude-memory', 'memory-profiles.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 - Profile Management            ║
+║                                                          ║
+╚══════════════════════════════════════════════════════════╝
+
+Profiles let you maintain separate memory databases for different contexts:
+  • Work vs Personal projects
+  • Different clients or teams
+  • Different AI personalities
+  • Experimentation vs Production
+
+Each profile has isolated: memories, graph, patterns, archives
+
+Usage: memory-profile <command> [options]
+
+Commands:
+  list                List all profiles and show active one
+  current             Show current active profile
+  create <name>       Create a new empty profile
+  switch <name>       Switch to a different profile (requires restart)
+  delete <name>       Delete a profile (with confirmation)
+
+Examples:
+  memory-profile list
+  memory-profile current
+  memory-profile create work
+  memory-profile switch work
+  memory-profile delete old-project
+
+Notes:
+  • Default profile is always available
+  • Switching profiles requires restarting Claude CLI
+  • Deleting a profile is permanent (but creates backup)
+`);
+    rl.close();
+    return;
+  }
+
+  const command = args[0];
+
+  // LIST command
+  if (command === 'list') {
+    try {
+      const { stdout } = await execFileAsync('python', [profileScript, 'list']);
+      console.log(stdout);
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+    }
+    rl.close();
+    return;
+  }
+
+  // CURRENT command
+  if (command === 'current') {
+    try {
+      const { stdout } = await execFileAsync('python', [profileScript, 'current']);
+      console.log(stdout);
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+    }
+    rl.close();
+    return;
+  }
+
+  // CREATE command
+  if (command === 'create') {
+    if (args.length < 2) {
+      console.log(`
+❌ ERROR: Profile name required
+
+Usage: memory-profile create <name> [options]
+
+Options:
+  --description "text"    Profile description
+  --from-current          Copy current profile's data to new profile
+
+Examples:
+  memory-profile create work
+  memory-profile create work --description "Work projects"
+  memory-profile create personal --from-current
+`);
+      rl.close();
+      return;
+    }
+
+    const profileName = args[1];
+    const pythonArgs = ['create', profileName];
+
+    // Check for --description flag
+    const descIndex = args.indexOf('--description');
+    if (descIndex !== -1 && descIndex + 1 < args.length) {
+      pythonArgs.push('--description', args[descIndex + 1]);
+    }
+
+    // Check for --from-current flag
+    if (args.includes('--from-current')) {
+      pythonArgs.push('--from-current');
+    }
+
+    try {
+      const { stdout } = await execFileAsync('python', [profileScript, ...pythonArgs]);
+      console.log(stdout);
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      if (error.stdout) console.log(error.stdout);
+    }
+    rl.close();
+    return;
+  }
+
+  // SWITCH command
+  if (command === 'switch') {
+    if (args.length < 2) {
+      console.log(`
+❌ ERROR: Profile name required
+
+Usage: memory-profile switch <name>
+
+Example:
+  memory-profile switch work
+
+After switching, restart Claude CLI for changes to take effect.
+`);
+      rl.close();
+      return;
+    }
+
+    const profileName = args[1];
+
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║              Profile Switch Confirmation                 ║
+╚══════════════════════════════════════════════════════════╝
+
+This will:
+  ✓ Save current profile state
+  ✓ Load profile "${profileName}"
+  ✓ Update active profile marker
+
+After switching, you MUST restart Claude CLI for the new profile
+to take effect.
+
+Current memories will be preserved in the old profile.
+`);
+
+    const answer = await question('Proceed with profile switch? (yes/no): ');
+
+    if (answer.toLowerCase() === 'yes') {
+      try {
+        const { stdout } = await execFileAsync('python', [
+          profileScript,
+          'switch',
+          profileName
+        ]);
+        console.log(stdout);
+        console.log(`
+⚠️  IMPORTANT: Restart Claude CLI now for profile switch to complete.
+
+The new profile will not be active until you restart.
+`);
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+        if (error.stdout) console.log(error.stdout);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // DELETE command
+  if (command === 'delete') {
+    if (args.length < 2) {
+      console.log(`
+❌ ERROR: Profile name required
+
+Usage: memory-profile delete <name>
+
+Example:
+  memory-profile delete old-project
+
+Cannot delete:
+  • The "default" profile
+  • The currently active profile
+`);
+      rl.close();
+      return;
+    }
+
+    const profileName = args[1];
+
+    // Prevent deleting default
+    if (profileName === 'default') {
+      console.log(`
+❌ ERROR: Cannot delete the default profile
+
+The default profile is protected and cannot be deleted.
+`);
+      rl.close();
+      return;
+    }
+
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║              ⚠️  DELETE PROFILE WARNING ⚠️               ║
+╚══════════════════════════════════════════════════════════╝
+
+This will PERMANENTLY delete profile: "${profileName}"
+
+What will be deleted:
+  🔴 All memories in this profile
+  🔴 Graph data (nodes, edges, clusters)
+  🔴 Learned patterns
+  🔴 Compressed archives
+
+A backup will be created before deletion.
+
+`);
+
+    const answer = await question(`Type the profile name "${profileName}" to confirm: `);
+
+    if (answer === profileName) {
+      try {
+        const { stdout } = await execFileAsync('python', [
+          profileScript,
+          'delete',
+          profileName
+        ]);
+        console.log(stdout);
+      } catch (error) {
+        console.error('❌ Error:', error.message);
+        if (error.stdout) console.log(error.stdout);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+      console.log(`(You must type exactly "${profileName}" to confirm)`);
+    }
+
+    rl.close();
+    return;
+  }
+
+  // Unknown command
+  console.log(`
+❌ Unknown command: ${command}
+
+Valid commands: list, current, create, switch, delete
+
+Use: memory-profile --help for more information
+`);
+  rl.close();
+}
+
+memoryProfileSkill();