memorylink 1.0.0

package/src/commands/context.ts

@@ -0,0 +1,618 @@
+/**
+ * MemoryLink - Get Context Command
+ * Retrieve filtered, relevant context for AI
+ * 
+ * v1.0 UPDATE: Now handles JSONL format
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getFilePath,
+  isInitialized,
+  success,
+  error,
+  info,
+  log,
+  findRoot,
+  readLines,
+  isJsonlFormat,
+  filterBySince,
+} from '../utils.js';
+import { loadGraph } from '../utils/code-structure.js';
+import type { 
+  GlobalOptions, 
+  GetContextOptions,
+  MemoryEntry,
+  LearningEntry,
+  ChangeEntry,
+} from '../types.js';
+
+/**
+ * Get smart filtering weights from config (v1.5 Phase 2 enhancement)
+ */
+function getSmartWeights(root: string): {
+  trust: { high: number; medium: number; low: number };
+  status: { verified: number; draft: number; default: number };
+  recency: { day1: number; day7: number; day30: number; day90: number; older: number };
+  file: { exact: number; partial: number; directory: number };
+  task: { max: number };
+  threshold: number;
+} {
+  const { readConfig } = require('../utils.js');
+  const config = readConfig(root);
+  
+  // Default weights
+  const defaults = {
+    trust: { high: 30, medium: 15, low: 5 },
+    status: { verified: 20, draft: 5, default: 10 },
+    recency: { day1: 25, day7: 20, day30: 15, day90: 10, older: 5 },
+    file: { exact: 15, partial: 10, directory: 5 },
+    task: { max: 10 },
+    threshold: 10,
+  };
+
+  if (!config?.smart?.weights) {
+    return defaults;
+  }
+
+  const weights = config.smart.weights;
+  return {
+    trust: { ...defaults.trust, ...weights.trust },
+    status: { ...defaults.status, ...weights.status },
+    recency: { ...defaults.recency, ...weights.recency },
+    file: { ...defaults.file, ...weights.file },
+    task: { max: weights.task?.max || defaults.task.max },
+    threshold: config.smart.threshold ?? defaults.threshold,
+  };
+}
+
+/**
+ * Score a memory entry for smart filtering (v1.5)
+ */
+function scoreMemoryEntry(
+  entry: MemoryEntry,
+  targetFile?: string,
+  taskDescription?: string,
+  now: Date = new Date(),
+  weights?: {
+    trust: { high: number; medium: number; low: number };
+    status: { verified: number; draft: number; default: number };
+    recency: { day1: number; day7: number; day30: number; day90: number; older: number };
+    file: { exact: number; partial: number; directory: number };
+    task: { max: number };
+  }
+): number {
+  let score = 0;
+
+  // Default weights if not provided
+  const defaultWeights = {
+    trust: { high: 30, medium: 15, low: 5 },
+    status: { verified: 20, draft: 5, default: 10 },
+    recency: { day1: 25, day7: 20, day30: 15, day90: 10, older: 5 },
+    file: { exact: 15, partial: 10, directory: 5 },
+    task: { max: 10 },
+  };
+
+  const w = weights || defaultWeights;
+
+  // Trust level
+  score += w.trust[entry.trustLevel || 'medium'];
+
+  // Status
+  if (entry.memoryStatus === 'VERIFIED') {
+    score += w.status.verified;
+  } else if (entry.memoryStatus === 'DRAFT') {
+    score += w.status.draft;
+  } else {
+    score += w.status.default;
+  }
+
+  // Recency
+  const entryTime = new Date(entry.ts).getTime();
+  const ageDays = (now.getTime() - entryTime) / (1000 * 60 * 60 * 24);
+  if (ageDays < 1) score += w.recency.day1;
+  else if (ageDays < 7) score += w.recency.day7;
+  else if (ageDays < 30) score += w.recency.day30;
+  else if (ageDays < 90) score += w.recency.day90;
+  else score += w.recency.older;
+
+  // File relevance
+  if (targetFile && entry.file) {
+    if (entry.file === targetFile) {
+      score += w.file.exact;
+    } else if (entry.file.includes(targetFile) || targetFile.includes(entry.file)) {
+      score += w.file.partial;
+    } else if (entry.file.includes(path.dirname(targetFile)) || path.dirname(targetFile).includes(entry.file)) {
+      score += w.file.directory;
+    }
+  }
+
+  // Task relevance
+  if (taskDescription) {
+    const taskLower = taskDescription.toLowerCase();
+    const details = (entry.details || '').toLowerCase();
+    const code = (entry.code || '').toLowerCase();
+    const context = (entry.context || '').toLowerCase();
+    
+    // Simple keyword matching
+    const taskWords = taskDescription.toLowerCase().split(/\s+/);
+    let matches = 0;
+    for (const word of taskWords) {
+      if (word.length > 3 && (details.includes(word) || code.includes(word) || context.includes(word))) {
+        matches++;
+      }
+    }
+    score += Math.min(matches * 2, w.task.max);
+  }
+
+  // Penalty for stale entries (v1.4)
+  if (entry.location?.commit) {
+    // If file changed since commit, reduce score
+    // This is a simple heuristic - in real implementation, would check Git
+    score -= 5; // Small penalty for entries with commit references (may be stale)
+  }
+
+  return score;
+}
+
+export async function getContextCommand(
+  tagOrFile?: string,
+  options: GetContextOptions = {}
+): Promise<void> {
+  const { verbose, limit = 50, since, format = 'default', tag, smart = false, task, scope } = options;
+
+  log(`Getting context${tagOrFile ? ` for: ${tagOrFile}` : ''}`, verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Get all logs
+  const memoryPath = getFilePath('MEMORY', root);
+  const changesPath = getFilePath('CHANGES', root);
+  const learningsPath = getFilePath('LEARNINGS', root);
+  const protectedPath = getFilePath('PROTECTED', root);
+
+  // Get protected files (plain text format)
+  const protectedEntries = readLines(protectedPath).filter(l => !l.startsWith('#'));
+
+  // Get entries with streaming and capped buffers to avoid large-memory operations
+  const searchTerm = (tag || tagOrFile || '').toLowerCase();
+  const rules: MemoryEntry[] = [];
+  const nonRuleMemories: MemoryEntry[] = [];
+  const learningsEntries: LearningEntry[] = [];
+  const changesEntries: ChangeEntry[] = [];
+
+  const pushCapped = <T>(arr: T[], item: T, cap: number) => {
+    arr.push(item);
+    if (arr.length > cap) {
+      arr.shift();
+    }
+  };
+
+  // Stream memory entries
+  if (isJsonlFormat(memoryPath)) {
+    const { streamJsonlEntries } = await import('../utils/streaming.js');
+    for await (const entry of streamJsonlEntries<MemoryEntry>(memoryPath, {})) {
+      if (entry.status && entry.status !== 'ACTIVE') continue;
+      if (since && !filterBySince([entry], since).length) continue;
+      // v1.5 Phase 2: Filter by project scope
+      if (scope && entry.projectScope && entry.projectScope !== scope) continue;
+      if (searchTerm) {
+        const details = typeof entry.details === 'string' ? entry.details.toLowerCase() : '';
+        const hit =
+          details.includes(searchTerm) ||
+          entry.tags?.some(t => t.toLowerCase().includes(searchTerm));
+        if (!hit) continue;
+      }
+      if (entry.type === 'rule' || entry.type === 'preference') {
+        rules.push(entry);
+      } else {
+        // v1.5: Smart filtering - score and rank entries
+        if (smart) {
+          // Collect all entries first for ranking
+          nonRuleMemories.push(entry);
+        } else {
+          pushCapped(nonRuleMemories, entry, limit);
+        }
+      }
+    }
+  }
+
+  // Stream learnings
+  if (isJsonlFormat(learningsPath)) {
+    const { streamJsonlEntries } = await import('../utils/streaming.js');
+    for await (const entry of streamJsonlEntries<LearningEntry>(learningsPath, {})) {
+      if (entry.status && entry.status !== 'ACTIVE') continue;
+      if (since && !filterBySince([entry], since).length) continue;
+      if (searchTerm) {
+        const hit =
+          entry.problem.toLowerCase().includes(searchTerm) ||
+          entry.solution.toLowerCase().includes(searchTerm) ||
+          entry.tags?.some(t => t.toLowerCase().includes(searchTerm));
+        if (!hit) continue;
+      }
+      pushCapped(learningsEntries, entry, limit);
+    }
+  }
+
+  // v1.5: Smart filtering - rank and filter entries
+  if (smart && nonRuleMemories.length > 0) {
+    const now = new Date();
+    
+    // Get weights from config (v1.5 Phase 2 enhancement)
+    const weights = getSmartWeights(root!);
+    const threshold = weights.threshold;
+    
+    // Score all entries
+    const scored = nonRuleMemories.map(entry => ({
+      entry,
+      score: scoreMemoryEntry(entry, tagOrFile, task, now, weights),
+    }));
+    
+    // Sort by score (highest first)
+    scored.sort((a, b) => b.score - a.score);
+    
+    // Filter out low-scoring entries
+    const filtered = scored
+      .filter(item => {
+        // Exclude entries below threshold
+        if (item.score < threshold) return false;
+        return true;
+      })
+      .slice(0, limit)
+      .map(item => item.entry);
+    
+    // Replace with ranked entries
+    nonRuleMemories.length = 0;
+    nonRuleMemories.push(...filtered);
+    
+    if (verbose) {
+      log(`Smart filtering: ${scored.length} entries scored, ${filtered.length} selected (threshold: ${threshold})`, verbose);
+      // v1.5 Priority 2: Enhanced verbose score breakdown
+      if (scored.length > 0) {
+        const topScores = scored.slice(0, 5);
+        for (const item of topScores) {
+          const entry = item.entry;
+          const entryTime = new Date(entry.ts).getTime();
+          const ageDays = (now.getTime() - entryTime) / (1000 * 60 * 60 * 24);
+          
+          // Calculate individual components for breakdown
+          const trustScore = weights.trust[entry.trustLevel || 'medium'];
+          const statusScore = entry.memoryStatus === 'VERIFIED' 
+            ? weights.status.verified 
+            : entry.memoryStatus === 'DRAFT' 
+            ? weights.status.draft 
+            : weights.status.default;
+          const recencyScore = ageDays < 1 ? weights.recency.day1
+            : ageDays < 7 ? weights.recency.day7
+            : ageDays < 30 ? weights.recency.day30
+            : ageDays < 90 ? weights.recency.day90
+            : weights.recency.older;
+          
+          let fileScore = 0;
+          if (tagOrFile && entry.file) {
+            if (entry.file === tagOrFile) {
+              fileScore = weights.file.exact;
+            } else if (entry.file.includes(tagOrFile) || tagOrFile.includes(entry.file)) {
+              fileScore = weights.file.partial;
+            } else if (entry.file.includes(path.dirname(tagOrFile)) || path.dirname(tagOrFile).includes(entry.file)) {
+              fileScore = weights.file.directory;
+            }
+          }
+          
+          let taskScore = 0;
+          if (task) {
+            const taskWords = task.toLowerCase().split(/\s+/);
+            const details = (entry.details || '').toLowerCase();
+            const code = (entry.code || '').toLowerCase();
+            const context = (entry.context || '').toLowerCase();
+            let matches = 0;
+            for (const word of taskWords) {
+              if (word.length > 3 && (details.includes(word) || code.includes(word) || context.includes(word))) {
+                matches++;
+              }
+            }
+            taskScore = Math.min(matches * 2, weights.task.max);
+          }
+          
+          // Log detailed breakdown
+          log(`  ${entry.id.substring(0, 8)}: total=${item.score} [trust:${trustScore}, status:${statusScore}, recency:${recencyScore}, file:${fileScore}, task:${taskScore}]`, verbose);
+        }
+      }
+    }
+  }
+
+  // Stream changes
+  if (isJsonlFormat(changesPath)) {
+    const { streamJsonlEntries } = await import('../utils/streaming.js');
+    for await (const entry of streamJsonlEntries<ChangeEntry>(changesPath, {})) {
+      if (since && !filterBySince([entry], since).length) continue;
+      if (searchTerm) {
+        const file = typeof entry.file === 'string' ? entry.file.toLowerCase() : '';
+        const reason = typeof entry.reason === 'string' ? entry.reason.toLowerCase() : '';
+        const hit =
+          file.includes(searchTerm) ||
+          reason.includes(searchTerm);
+        if (!hit) continue;
+      }
+      pushCapped(changesEntries, entry, limit);
+    }
+  }
+
+  // Build context output
+  console.log('');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('                    MEMORYLINK CONTEXT');
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('');
+
+  // RULES SECTION FIRST (Critical - must be seen first) - Claude's Stronger Formatting
+  if (rules.length > 0) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('🚨🚨🚨 CRITICAL PROJECT RULES - MUST FOLLOW STRICTLY 🚨🚨🚨');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    console.log('⚠️  WARNING: The rules below are ACTIVE and MUST be followed.');
+    console.log('⚠️  These rules override default AI behavior.');
+    console.log('⚠️  Failure to follow these rules is an error.');
+    console.log('');
+    
+    // Separate preferences from rules (preferences are more behavioral)
+    const preferences = rules.filter(r => r.type === 'preference');
+    const strictRules = rules.filter(r => r.type === 'rule');
+    
+    if (preferences.length > 0) {
+      console.log('📋 USER PREFERENCES (HIGHEST PRIORITY - OVERRIDE ALL DEFAULTS):');
+      console.log('─────────────────────────────────────────────────────────────');
+      for (const pref of preferences) {
+        const tagsStr = pref.tags?.length ? ` [${pref.tags.join(', ')}]` : '';
+        console.log(`   🔴 CRITICAL: ${pref.details}${tagsStr}`);
+      }
+      console.log('');
+      console.log('   ⚠️  IMPORTANT: These preferences are ACTIVE and visible in every AI session.');
+      console.log('   ⚠️  The AI MUST follow these preferences unless there is a safety override.');
+      console.log('   ⚠️  If the AI asks for confirmation when a preference says to proceed,');
+      console.log('   ⚠️  remind the AI: "You have a preference to proceed automatically."');
+      console.log('');
+    }
+    
+    if (strictRules.length > 0) {
+      console.log('📜 TECHNICAL RULES (MUST FOLLOW - NO EXCEPTIONS):');
+      console.log('─────────────────────────────────────────────────────────────');
+      for (const rule of strictRules) {
+        const tagsStr = rule.tags?.length ? ` [${rule.tags.join(', ')}]` : '';
+        console.log(`   🔴 REQUIRED: ${rule.details}${tagsStr}`);
+      }
+      console.log('');
+    }
+    
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('🚨 FINAL REMINDER: The above rules OVERRIDE default behavior.');
+    console.log('🚨 These rules are ACTIVE and MUST be followed.');
+    console.log('🚨 If you see a preference to "proceed automatically", DO NOT ask for confirmation.');
+    console.log('🚨 Failure to follow these rules is an error.');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+  }
+
+  // Protected files section
+  if (protectedEntries.length > 0) {
+    console.log('🛡️  PROTECTED FILES (DO NOT MODIFY):');
+    console.log('───────────────────────────────────────');
+    for (const entry of protectedEntries) {
+      const filePath = entry.split('#')[0].trim();
+      console.log(`   • ${filePath}`);
+    }
+    console.log('');
+  }
+
+  // Memory section (non-rules)
+  if (nonRuleMemories.length > 0) {
+    console.log('📝 SHARED MEMORY:');
+    console.log('───────────────────────────────────────');
+    for (const entry of nonRuleMemories) {
+      if (entry.type === 'code_snippet') {
+        // Format code snippets specially
+        const langStr = entry.language ? ` (${entry.language})` : '';
+        const fileStr = entry.file ? ` from ${entry.file}` : '';
+        const linesStr = entry.lines ? ` lines ${entry.lines}` : '';
+        const tagsStr = entry.tags?.length ? ` [${entry.tags.join(', ')}]` : '';
+        console.log(`   💻 [code_snippet] ${entry.details}${langStr}${fileStr}${linesStr}${tagsStr}`);
+        if (entry.code) {
+          // Show first few lines of code
+          const codeLines = entry.code.split('\n');
+          const preview = codeLines.slice(0, 3).join('\n');
+          const more = codeLines.length > 3 ? `\n   ... (${codeLines.length - 3} more lines)` : '';
+          console.log(`   ┌─ Code ──────────────────────────────────────────────`);
+          codeLines.slice(0, 5).forEach(line => {
+            console.log(`   │ ${line.substring(0, 60)}${line.length > 60 ? '...' : ''}`);
+          });
+          if (codeLines.length > 5) {
+            console.log(`   │ ... (${codeLines.length - 5} more lines)`);
+          }
+          console.log(`   └──────────────────────────────────────────────────────`);
+        }
+        if (entry.context) {
+          console.log(`   Context: ${entry.context}`);
+        }
+        console.log('');
+      } else {
+        const typeStr = entry.type !== 'note' ? `[${entry.type}] ` : '';
+        const tagsStr = entry.tags?.length ? ` [${entry.tags.join(', ')}]` : '';
+        console.log(`   • ${typeStr}${entry.details}${tagsStr}`);
+      }
+    }
+    console.log('');
+  }
+
+  // Learnings section (SUCCESS first, then FAILED)
+  const successLearnings = learningsEntries.filter(e => e.outcome === 'SUCCESS');
+  const failedLearnings = learningsEntries.filter(e => e.outcome === 'FAILED');
+
+  if (successLearnings.length > 0) {
+    console.log('✅ SUCCESSFUL SOLUTIONS:');
+    console.log('───────────────────────────────────────');
+    for (const entry of successLearnings) {
+      console.log(`   Problem:  ${entry.problem}`);
+      console.log(`   Solution: ${entry.solution}`);
+      if (entry.reason) {
+        console.log(`   Why:      ${entry.reason}`);
+      }
+      console.log('');
+    }
+  }
+
+  if (failedLearnings.length > 0) {
+    console.log('❌ FAILED SOLUTIONS (DO NOT REPEAT):');
+    console.log('───────────────────────────────────────');
+    for (const entry of failedLearnings) {
+      console.log(`   Problem:  ${entry.problem}`);
+      console.log(`   Failed:   ${entry.solution}`);
+      if (entry.reason) {
+        console.log(`   Why:      ${entry.reason}`);
+      }
+      console.log('');
+    }
+  }
+
+  // Recent changes section (last 10)
+  if (changesEntries.length > 0) {
+    console.log('📋 RECENT CHANGES:');
+    console.log('───────────────────────────────────────');
+    const recentChanges = changesEntries.slice(-10);
+    for (const entry of recentChanges) {
+      const date = new Date(entry.ts);
+      const shortDate = date.toLocaleDateString();
+      const agentStr = entry.agent !== 'user' ? ` (${entry.agent})` : '';
+      console.log(`   ${shortDate} | ${entry.file}: ${entry.reason}${agentStr}`);
+    }
+    console.log('');
+  }
+
+  // Code structure section (v1.2) - if tagOrFile looks like a file path
+  if (tagOrFile && (tagOrFile.includes('/') || tagOrFile.includes('\\') || tagOrFile.endsWith('.ts') || tagOrFile.endsWith('.js') || tagOrFile.endsWith('.tsx') || tagOrFile.endsWith('.jsx'))) {
+    const graphFile = path.join(root!, '.memorylink', 'code-graph.json');
+    const graph = loadGraph(graphFile);
+    
+    if (graph) {
+      const normalizedFile = path.relative(root!, path.resolve(root!, tagOrFile)).replace(/\\/g, '/');
+      const node = graph.files.get(normalizedFile);
+      const dependents = graph.dependents.get(normalizedFile) || [];
+      const dependencies = graph.dependencies.get(normalizedFile) || [];
+      
+      if (node || dependents.length > 0 || dependencies.length > 0) {
+        console.log('🔗 CODE STRUCTURE:');
+        console.log('───────────────────────────────────────');
+        console.log(`   File: ${normalizedFile}`);
+        
+        if (node) {
+          console.log(`   Complexity: ${node.complexity} (${node.complexity < 20 ? 'LOW' : node.complexity < 50 ? 'MEDIUM' : 'HIGH'})`);
+          console.log(`   Lines: ${node.lines}`);
+          if (node.functions.length > 0) {
+            console.log(`   Functions: ${node.functions.join(', ')}`);
+          }
+          if (node.classes.length > 0) {
+            console.log(`   Classes: ${node.classes.join(', ')}`);
+          }
+        }
+        
+        if (dependencies.length > 0) {
+          console.log(`   Depends on: ${dependencies.slice(0, 5).join(', ')}${dependencies.length > 5 ? ` (+${dependencies.length - 5} more)` : ''}`);
+        }
+        
+        if (dependents.length > 0) {
+          console.log(`   Imported by: ${dependents.length} file(s)`);
+          if (dependents.length > 5) {
+            console.log(`   ⚠️  HIGH RISK: ${dependents.length} files depend on this`);
+          }
+          if (dependents.length <= 5 && dependents.length > 0) {
+            console.log(`   Files: ${dependents.slice(0, 5).join(', ')}`);
+          }
+        }
+        
+        console.log('');
+      }
+    }
+  }
+
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('');
+
+  // Stats
+  info(`Context: ${rules.length} rule(s), ${nonRuleMemories.length} memories, ${learningsEntries.length} learnings, ${changesEntries.length} changes`);
+  if (tagOrFile) {
+    info(`Filtered by: "${tagOrFile}"`);
+  }
+  console.log('');
+}
+
+export async function exportContextCommand(
+  outputFile?: string,
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log('Exporting context', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Get all logs
+  const memoryPath = getFilePath('MEMORY', root);
+  const changesPath = getFilePath('CHANGES', root);
+  const learningsPath = getFilePath('LEARNINGS', root);
+  const protectedPath = getFilePath('PROTECTED', root);
+
+  let memoryContent: string;
+  let changesContent: string;
+  let learningsContent: string;
+  let protectedContent: string;
+
+  try {
+    memoryContent = fs.existsSync(memoryPath) ? fs.readFileSync(memoryPath, 'utf-8') : '';
+    changesContent = fs.existsSync(changesPath) ? fs.readFileSync(changesPath, 'utf-8') : '';
+    learningsContent = fs.existsSync(learningsPath) ? fs.readFileSync(learningsPath, 'utf-8') : '';
+    protectedContent = fs.existsSync(protectedPath) ? fs.readFileSync(protectedPath, 'utf-8') : '';
+  } catch (err) {
+    error(`Failed to read log files: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+
+  const exportContent = `# MemoryLink Export
+# Generated: ${new Date().toISOString()}
+
+## Protected Files
+${protectedContent}
+
+## Memory Log
+${memoryContent}
+
+## Learnings Log
+${learningsContent}
+
+## Changes Log
+${changesContent}
+`;
+
+  if (outputFile) {
+    try {
+      fs.writeFileSync(outputFile, exportContent);
+      success(`Exported to: ${outputFile}`);
+    } catch (err) {
+      error(`Failed to write export file: ${err instanceof Error ? err.message : 'Unknown error'}`);
+      process.exit(1);
+    }
+  } else {
+    console.log(exportContent);
+  }
+}