memorylink 1.0.0

package/src/commands/configure.ts

@@ -0,0 +1,297 @@
+/**
+ * Configure Command
+ * 
+ * Interactive setup to configure MemoryLink for the user's workflow
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { getMemoryLinkDir } from '../utils.js';
+import { FILES, MEMORYLINK_VERSION } from '../types.js';
+
+interface ConfigureOptions {
+  verbose?: boolean;
+}
+
+interface MemoryLinkConfig {
+  version: string;
+  initialized: string;
+  aiTools: string[];
+  protectPatterns: string[];
+  watchIgnore: string[];
+  autoProtect: boolean;
+  defaultTags: string[];
+}
+
+// Common AI tools
+const AI_TOOLS = [
+  { id: 'cursor', name: 'Cursor AI', description: 'VS Code-based AI editor' },
+  { id: 'copilot', name: 'GitHub Copilot', description: 'VS Code / JetBrains extension' },
+  { id: 'claude', name: 'Claude', description: 'Anthropic AI assistant' },
+  { id: 'chatgpt', name: 'ChatGPT', description: 'OpenAI chat interface' },
+  { id: 'windsurf', name: 'Windsurf', description: 'AI-powered IDE' },
+  { id: 'gemini', name: 'Gemini', description: 'Google AI assistant' },
+  { id: 'other', name: 'Other', description: 'Other AI tools' },
+];
+
+// Common protection patterns by project type
+const PROTECTION_PRESETS: Record<string, string[]> = {
+  node: ['.env', '.env.local', '.env.production', 'package-lock.json'],
+  react: ['.env', '.env.local', 'public/index.html'],
+  python: ['.env', 'requirements.txt', 'poetry.lock'],
+  general: ['.env', '*.key', '*.pem', 'secrets/**'],
+};
+
+// Common ignore patterns
+const IGNORE_PRESETS = [
+  'node_modules/**',
+  'dist/**',
+  'build/**',
+  '.git/**',
+  '*.log',
+  'coverage/**',
+];
+
+/**
+ * Create a readline interface for prompts
+ */
+function createPrompt(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Ask a question and get answer
+ */
+function ask(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Display welcome message
+ */
+function showWelcome(): void {
+  console.log('\n\x1b[36m╔══════════════════════════════════════════════════════════╗');
+  console.log('║                                                          ║');
+  console.log('║   🧠 MemoryLink Configuration Wizard                     ║');
+  console.log('║                                                          ║');
+  console.log('║   Let\'s set up MemoryLink for your workflow!             ║');
+  console.log('║                                                          ║');
+  console.log('╚══════════════════════════════════════════════════════════╝\x1b[0m\n');
+}
+
+/**
+ * Main configure command
+ */
+export async function configureCommand(options: ConfigureOptions = {}): Promise<void> {
+  const mlDir = getMemoryLinkDir();
+  const configPath = path.join(mlDir, 'config.json');
+  
+  // Check if initialized
+  if (!fs.existsSync(mlDir)) {
+    console.log('\x1b[33m⚠️  MemoryLink not initialized!\x1b[0m');
+    console.log('   Run: memorylink init\n');
+    return;
+  }
+  
+  showWelcome();
+  
+  const rl = createPrompt();
+  
+  try {
+    // Load existing config
+    let config: MemoryLinkConfig = {
+      version: MEMORYLINK_VERSION,
+      initialized: new Date().toISOString(),
+      aiTools: [],
+      protectPatterns: [],
+      watchIgnore: IGNORE_PRESETS,
+      autoProtect: false,
+      defaultTags: [],
+    };
+    
+    if (fs.existsSync(configPath)) {
+      const existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      config = { ...config, ...existing };
+    }
+    
+    // Step 1: AI Tools
+    console.log('\x1b[1m📌 Step 1: Which AI tools do you use?\x1b[0m\n');
+    console.log('Available options:');
+    AI_TOOLS.forEach((tool, i) => {
+      console.log(`  ${i + 1}) ${tool.name} - ${tool.description}`);
+    });
+    console.log('\nEnter numbers separated by commas (e.g., 1,2,3)');
+    console.log('Or press Enter to skip\n');
+    
+    const toolsAnswer = await ask(rl, '> ');
+    
+    if (toolsAnswer) {
+      const selected = toolsAnswer.split(',').map(n => parseInt(n.trim()) - 1);
+      config.aiTools = selected
+        .filter(i => i >= 0 && i < AI_TOOLS.length)
+        .map(i => AI_TOOLS[i].id);
+      
+      if (config.aiTools.length > 0) {
+        console.log(`\n✅ Selected: ${config.aiTools.join(', ')}\n`);
+      }
+    }
+    
+    // Step 2: Project Type
+    console.log('\x1b[1m📌 Step 2: What type of project is this?\x1b[0m\n');
+    console.log('  1) Node.js / TypeScript');
+    console.log('  2) React / Next.js');
+    console.log('  3) Python');
+    console.log('  4) General / Other');
+    console.log('\nThis helps us suggest files to protect.\n');
+    
+    const projectAnswer = await ask(rl, '> ');
+    
+    let projectType = 'general';
+    switch (projectAnswer) {
+      case '1': projectType = 'node'; break;
+      case '2': projectType = 'react'; break;
+      case '3': projectType = 'python'; break;
+      default: projectType = 'general';
+    }
+    
+    // Step 3: Auto-protect common files?
+    const presetPatterns = PROTECTION_PRESETS[projectType];
+    console.log(`\n\x1b[1m📌 Step 3: Auto-protect common sensitive files?\x1b[0m\n`);
+    console.log('Suggested patterns for your project:');
+    presetPatterns.forEach(p => console.log(`  - ${p}`));
+    console.log('\nAdd these to protected.txt? (y/n)\n');
+    
+    const autoProtectAnswer = await ask(rl, '> ');
+    
+    if (autoProtectAnswer.toLowerCase() === 'y') {
+      config.protectPatterns = presetPatterns;
+      config.autoProtect = true;
+      
+      // Actually add to protected.txt
+      const protectedPath = path.join(mlDir, FILES.PROTECTED);
+      const existing = fs.existsSync(protectedPath) 
+        ? fs.readFileSync(protectedPath, 'utf-8').split('\n').filter(l => l.trim())
+        : [];
+      
+      const newPatterns = presetPatterns.filter(p => !existing.includes(p));
+      if (newPatterns.length > 0) {
+        const updated = [...existing, ...newPatterns].join('\n') + '\n';
+        fs.writeFileSync(protectedPath, updated);
+        console.log(`\n✅ Added ${newPatterns.length} protection patterns\n`);
+      } else {
+        console.log('\n✅ Patterns already in protected.txt\n');
+      }
+    }
+    
+    // Step 4: Default tags
+    console.log('\x1b[1m📌 Step 4: Default tags for memories (optional)\x1b[0m\n');
+    console.log('Enter comma-separated tags to add to all memories.');
+    console.log('Example: myproject,backend,api');
+    console.log('Or press Enter to skip\n');
+    
+    const tagsAnswer = await ask(rl, '> ');
+    
+    if (tagsAnswer) {
+      config.defaultTags = tagsAnswer.split(',').map(t => t.trim()).filter(t => t);
+      console.log(`\n✅ Default tags: ${config.defaultTags.join(', ')}\n`);
+    }
+    
+    // Step 5: Install Git hook?
+    console.log('\x1b[1m📌 Step 5: Install Git pre-commit hook?\x1b[0m\n');
+    console.log('This will block commits that modify protected files.');
+    console.log('Highly recommended for team projects. (y/n)\n');
+    
+    const hookAnswer = await ask(rl, '> ');
+    
+    if (hookAnswer.toLowerCase() === 'y') {
+      try {
+        const { execSync } = await import('child_process');
+        execSync('memorylink hooks install', { stdio: 'inherit' });
+      } catch {
+        console.log('\n⚠️  Could not install hook. Run manually: memorylink hooks install\n');
+      }
+    }
+    
+    // Save config
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    
+    // Summary
+    console.log('\n\x1b[36m╔══════════════════════════════════════════════════════════╗');
+    console.log('║                                                          ║');
+    console.log('║   ✅ MemoryLink Configuration Complete!                  ║');
+    console.log('║                                                          ║');
+    console.log('╚══════════════════════════════════════════════════════════╝\x1b[0m\n');
+    
+    console.log('\x1b[1mYour setup:\x1b[0m');
+    console.log(`  AI Tools:      ${config.aiTools.length > 0 ? config.aiTools.join(', ') : 'Not specified'}`);
+    console.log(`  Project Type:  ${projectType}`);
+    console.log(`  Auto-protect:  ${config.autoProtect ? 'Yes' : 'No'}`);
+    console.log(`  Default Tags:  ${config.defaultTags.length > 0 ? config.defaultTags.join(', ') : 'None'}`);
+    
+    console.log('\n\x1b[1mNext steps:\x1b[0m');
+    console.log('  1. memorylink protect <file>     # Add more protected files');
+    console.log('  2. memorylink memory "context"   # Add project context');
+    console.log('  3. memorylink watch              # Start file watcher');
+    console.log('  4. memorylink status             # Check current state');
+    console.log('');
+    
+  } finally {
+    rl.close();
+  }
+}
+
+/**
+ * Quick config (non-interactive) - sets defaults
+ */
+export async function quickConfigureCommand(options: ConfigureOptions & {
+  aiTools?: string;
+  projectType?: string;
+}): Promise<void> {
+  const mlDir = getMemoryLinkDir();
+  const configPath = path.join(mlDir, 'config.json');
+  
+  if (!fs.existsSync(mlDir)) {
+    console.log('\x1b[33m⚠️  MemoryLink not initialized!\x1b[0m');
+    console.log('   Run: memorylink init\n');
+    return;
+  }
+  
+  // Quick config with defaults
+  const config: MemoryLinkConfig = {
+    version: MEMORYLINK_VERSION,
+    initialized: new Date().toISOString(),
+    aiTools: options.aiTools ? options.aiTools.split(',') : ['cursor', 'copilot'],
+    protectPatterns: PROTECTION_PRESETS.general,
+    watchIgnore: IGNORE_PRESETS,
+    autoProtect: true,
+    defaultTags: [],
+  };
+  
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  
+  // Add default protection patterns
+  const protectedPath = path.join(mlDir, FILES.PROTECTED);
+  const existing = fs.existsSync(protectedPath) 
+    ? fs.readFileSync(protectedPath, 'utf-8').split('\n').filter(l => l.trim())
+    : [];
+  
+  const newPatterns = config.protectPatterns.filter(p => !existing.includes(p));
+  if (newPatterns.length > 0) {
+    const updated = [...existing, ...newPatterns].join('\n') + '\n';
+    fs.writeFileSync(protectedPath, updated);
+  }
+  
+  console.log('\x1b[32m✓\x1b[0m Quick configuration applied');
+  console.log(`  Protected: ${config.protectPatterns.join(', ')}`);
+  console.log(`  AI Tools:  ${config.aiTools.join(', ')}`);
+  console.log('\nRun \x1b[36mmemorylink configure\x1b[0m for full setup wizard.\n');
+}
+

package/src/commands/consolidate.ts

@@ -0,0 +1,263 @@
+/**
+ * MemoryLink - Consolidate Command
+ * Merge duplicate or similar memory entries
+ * 
+ * AGENT NEED: Clean, deduplicated memory for better context
+ * USER NEED: Prevent memory bloat from duplicate entries
+ */
+
+import * as fs from 'fs';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  readJsonlEntries,
+  appendJsonlEntry,
+} from '../utils.js';
+import type { GlobalOptions, MemoryEntry, BaseEntry } from '../types.js';
+
+interface ConsolidateOptions extends GlobalOptions {
+  threshold?: number;     // Similarity threshold (0-1, default 0.8)
+  dryRun?: boolean;       // Show what would be consolidated without actually doing it
+  autoMerge?: boolean;    // Automatically merge without confirmation
+}
+
+/**
+ * Calculate similarity between two strings using Levenshtein distance
+ * Returns a score between 0 (completely different) and 1 (identical)
+ */
+function calculateSimilarity(str1: string, str2: string): number {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+
+  if (longer.length === 0) {
+    return 1.0;
+  }
+
+  // Simple word-based similarity (Jaccard similarity)
+  const words1 = new Set(str1.toLowerCase().split(/\s+/));
+  const words2 = new Set(str2.toLowerCase().split(/\s+/));
+
+  const intersection = new Set([...words1].filter(x => words2.has(x)));
+  const union = new Set([...words1, ...words2]);
+
+  const jaccard = intersection.size / union.size;
+
+  // Also check if one contains the other (substring match)
+  const longerLower = longer.toLowerCase();
+  const shorterLower = shorter.toLowerCase();
+  const contains = longerLower.includes(shorterLower) ? 0.3 : 0;
+
+  return Math.max(jaccard, contains);
+}
+
+/**
+ * Find similar entries in a list
+ */
+function findSimilarEntries<T extends BaseEntry>(
+  entries: T[],
+  threshold: number
+): Array<{ entry1: T; entry2: T; similarity: number }> {
+  const similar: Array<{ entry1: T; entry2: T; similarity: number }> = [];
+  const processed = new Set<string>();
+
+  for (let i = 0; i < entries.length; i++) {
+    if (processed.has(entries[i].id)) {
+      continue;
+    }
+
+    for (let j = i + 1; j < entries.length; j++) {
+      if (processed.has(entries[j].id)) {
+        continue;
+      }
+
+      // Compare details (for MemoryEntry) or problem/solution (for LearningEntry)
+      let text1 = '';
+      let text2 = '';
+
+      if ('details' in entries[i] && 'details' in entries[j]) {
+        text1 = (entries[i] as any).details || '';
+        text2 = (entries[j] as any).details || '';
+      } else if ('problem' in entries[i] && 'problem' in entries[j]) {
+        text1 = `${(entries[i] as any).problem} ${(entries[i] as any).solution || ''}`;
+        text2 = `${(entries[j] as any).problem} ${(entries[j] as any).solution || ''}`;
+      } else {
+        continue;
+      }
+
+      const similarity = calculateSimilarity(text1, text2);
+
+      if (similarity >= threshold) {
+        similar.push({
+          entry1: entries[i],
+          entry2: entries[j],
+          similarity,
+        });
+        processed.add(entries[i].id);
+        processed.add(entries[j].id);
+      }
+    }
+  }
+
+  return similar;
+}
+
+/**
+ * Merge two entries into one
+ */
+function mergeEntries<T extends BaseEntry>(
+  entry1: T,
+  entry2: T
+): T {
+  // Keep the newer entry as base
+  const date1 = new Date(entry1.ts);
+  const date2 = new Date(entry2.ts);
+  const base = date1 > date2 ? entry1 : entry2;
+  const other = date1 > date2 ? entry2 : entry1;
+
+  // Merge tags
+  const tags1 = base.tags || [];
+  const tags2 = other.tags || [];
+  const mergedTags = Array.from(new Set([...tags1, ...tags2]));
+
+  // Merge details (for MemoryEntry)
+  let mergedDetails = '';
+  if ('details' in base && 'details' in other) {
+    const details1 = (base as any).details || '';
+    const details2 = (other as any).details || '';
+    // Keep the longer/more detailed one, or combine if similar length
+    if (details1.length > details2.length) {
+      mergedDetails = details1;
+    } else if (details2.length > details1.length) {
+      mergedDetails = details2;
+    } else {
+      mergedDetails = details1; // Prefer base
+    }
+  }
+
+  // Create merged entry
+  const merged: T = {
+    ...base,
+    tags: mergedTags.length > 0 ? mergedTags : undefined,
+    replacesId: other.id, // Track what was replaced
+  } as T;
+
+  if (mergedDetails) {
+    (merged as any).details = mergedDetails;
+  }
+
+  return merged;
+}
+
+/**
+ * Consolidate duplicate/similar entries
+ */
+export async function consolidateCommand(
+  options: ConsolidateOptions = {}
+): Promise<void> {
+  const { verbose, threshold = 0.8, dryRun = false, autoMerge = false } = options;
+
+  log('Starting consolidation process...', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  console.log('');
+  if (dryRun) {
+    info('🔍 Consolidation Dry Run (no changes will be made)');
+  } else {
+    info('🔗 Consolidating Similar Entries');
+  }
+  console.log('');
+  info(`Similarity threshold: ${(threshold * 100).toFixed(0)}%`);
+  console.log('');
+
+  const memoryPath = getFilePath('MEMORY', root);
+  if (!fs.existsSync(memoryPath)) {
+    warn('Memory log not found - nothing to consolidate');
+    return;
+  }
+
+  // Read all entries
+  const entries = readJsonlEntries<MemoryEntry>(memoryPath);
+  const activeEntries = entries.filter(e => e.status === 'ACTIVE');
+
+  if (activeEntries.length < 2) {
+    info('Not enough entries to consolidate (need at least 2)');
+    return;
+  }
+
+  // Find similar entries
+  const similar = findSimilarEntries(activeEntries, threshold);
+
+  if (similar.length === 0) {
+    success('✅ No similar entries found (all entries are unique)');
+    console.log('');
+    return;
+  }
+
+  // Display what would be consolidated
+  console.log(`Found ${similar.length} pair(s) of similar entries:\n`);
+
+  for (let i = 0; i < similar.length; i++) {
+    const { entry1, entry2, similarity } = similar[i];
+    const mem1 = entry1 as MemoryEntry;
+    const mem2 = entry2 as MemoryEntry;
+
+    console.log(`\n${i + 1}. Similarity: ${(similarity * 100).toFixed(0)}%`);
+    console.log(`   Entry 1 (${entry1.ts.split('T')[0]}): ${mem1.details.substring(0, 60)}...`);
+    console.log(`   Entry 2 (${entry2.ts.split('T')[0]}): ${mem2.details.substring(0, 60)}...`);
+    console.log(`   Tags: [${(entry1.tags || []).join(', ')}] + [${(entry2.tags || []).join(', ')}]`);
+  }
+
+  console.log('');
+
+  if (dryRun) {
+    info(`📋 Would consolidate ${similar.length} pair(s) into ${similar.length} merged entry/entries`);
+    info('   Run without --dry-run to actually consolidate');
+    console.log('');
+    return;
+  }
+
+  // Actually consolidate
+  const toKeep: MemoryEntry[] = [];
+  const toRemove = new Set<string>();
+
+  for (const { entry1, entry2 } of similar) {
+    const merged = mergeEntries(entry1, entry2) as MemoryEntry;
+    toKeep.push(merged);
+    toRemove.add(entry1.id);
+    toRemove.add(entry2.id);
+  }
+
+  // Keep all non-consolidated entries
+  for (const entry of activeEntries) {
+    if (!toRemove.has(entry.id)) {
+      toKeep.push(entry);
+    }
+  }
+
+  // Also keep DEPRECATED/DELETED entries (don't touch them)
+  const inactiveEntries = entries.filter(e => e.status !== 'ACTIVE');
+  const allEntries = [...toKeep, ...inactiveEntries];
+
+  // Write back
+  fs.writeFileSync(memoryPath, '');
+  for (const entry of allEntries) {
+    await appendJsonlEntry(memoryPath, entry);
+  }
+
+  success(`✅ Consolidated ${similar.length} pair(s) of similar entries`);
+  info(`   Kept: ${toKeep.length} entries`);
+  info(`   Removed: ${toRemove.size} duplicate entries`);
+  console.log('');
+}
+