memorylink 1.0.0

package/src/commands/memory.ts

@@ -0,0 +1,415 @@
+/**
+ * MemoryLink - Memory Command
+ * Add entries to shared memory log
+ * 
+ * v1.0 UPDATE: Now uses JSONL format with file locking and secret detection
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getFilePath,
+  isInitialized,
+  getTimestamp,
+  success,
+  error,
+  info,
+  warn,
+  log,
+  findRoot,
+  parseTags,
+  generateId,
+  shortId,
+  appendJsonlEntry,
+  readJsonlEntries,
+  isJsonlFormat,
+  checkSecretsBeforeWrite,
+  filterByTag,
+  filterBySince,
+  filterByStatus,
+  writeFileAtomic,
+} from '../utils.js';
+import { syncRulesCommand } from './sync-rules.js';
+import type { 
+  GlobalOptions, 
+  MemoryEntry, 
+  MemoryType,
+  MemoryOptions,
+  ListOptions,
+} from '../types.js';
+import { checkMigrationRequired, showMigrationWarning } from './migrate.js';
+import { scoreMemoryEntry, formatQualityScore, getQualityLevel } from '../utils/quality.js';
+
+export async function memoryCommand(
+  message: string,
+  options: MemoryOptions = {}
+): Promise<void> {
+  const { verbose, tags: tagString, type = 'note', force = false, scope } = options;
+
+  // Validate scope if provided (v1.5 Phase 2 enhancement)
+  if (scope) {
+    const { validateScope } = await import('../utils.js');
+    const validation = validateScope(scope);
+    if (!validation.valid) {
+      error(`Invalid scope: ${validation.error}`);
+      process.exit(1);
+    }
+  }
+
+  // Validate input - reject empty messages
+  if (!message || message.trim().length === 0) {
+    error('Memory message cannot be empty');
+    process.exit(1);
+  }
+  if (message.length > 4000) {
+    error('Memory message too large (max 4000 chars). Please shorten the content.');
+    process.exit(1);
+  }
+
+  log(`Adding memory: ${message}`, verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Check if migration is required
+  if (checkMigrationRequired(root)) {
+    showMigrationWarning();
+    process.exit(1);
+  }
+
+  // Secret detection at write time
+  if (!checkSecretsBeforeWrite(message, force)) {
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  let tags = parseTags(tagString);
+
+  // Auto-suggest tags if none provided
+  if (tags.length === 0 && !verbose) {
+    const { suggestTags } = await import('../utils/tag-suggestions.js');
+    const existingEntries = readJsonlEntries<MemoryEntry>(memoryPath);
+    const allExistingTags = existingEntries
+      .flatMap(e => e.tags || [])
+      .filter(Boolean);
+    
+    const suggested = suggestTags(message, allExistingTags);
+    if (suggested.length > 0) {
+      info(`💡 Suggested tags: ${suggested.join(', ')}`);
+      info(`   Add them with: memorylink memory "${message}" --tags ${suggested.join(',')}`);
+    }
+  }
+
+  // Auto-suggest team patterns (v1.3 integration)
+  try {
+    const { patternsSuggestCommand } = await import('./patterns.js');
+    const patternsPath = path.join(root, '.memorylink', 'team-patterns.json');
+    if (fs.existsSync(patternsPath)) {
+      // Check if message matches any pattern context
+      const patternsData = JSON.parse(fs.readFileSync(patternsPath, 'utf-8'));
+      if (patternsData.patterns && patternsData.patterns.length > 0) {
+        // Simple keyword matching for pattern suggestions
+        const messageLower = message.toLowerCase();
+        const relevantPatterns = patternsData.patterns.filter((p: any) => {
+          const patternLower = (p.pattern_name || '').toLowerCase();
+          const categoryLower = (p.category || '').toLowerCase();
+          return messageLower.includes(patternLower) || 
+                 messageLower.includes(categoryLower) ||
+                 patternLower.includes(messageLower.split(' ')[0]);
+        });
+        
+        if (relevantPatterns.length > 0 && !verbose) {
+          const topPattern = relevantPatterns[0];
+          if (topPattern.adoption_rate && topPattern.adoption_rate > 0.7) {
+            info(`💡 Team pattern detected: "${topPattern.pattern_name}" (${Math.round(topPattern.adoption_rate * 100)}% adoption)`);
+            if (topPattern.team_preference) {
+              info(`   Team preference: ${topPattern.team_preference}`);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // Pattern suggestions are optional, don't fail if unavailable
+  }
+
+  // Create JSONL entry
+  const entry: MemoryEntry = {
+    id: generateId(),
+    ts: getTimestamp(),
+    agent: 'user',
+    type: type as MemoryType,
+    details: message,
+    tags,
+    status: 'ACTIVE',
+    forcedSecretCheck: force && checkSecretsBeforeWrite(message, true) ? true : undefined,
+    // v1.5 Phase 2: Add project scope if provided
+    ...(scope && { projectScope: scope }),
+  };
+
+  // Quality validation (Week 5)
+  const qualityScore = scoreMemoryEntry(entry);
+  const qualityLevel = getQualityLevel(qualityScore.score);
+  
+  if (qualityScore.score < 60) {
+    warn(`⚠️  Low quality memory (score: ${qualityScore.score}/100)`);
+    console.log('');
+    console.log(formatQualityScore(qualityScore));
+    console.log('');
+    
+    // Ask user if they want to proceed (non-interactive: just warn)
+    warn('Memory will be saved, but consider improving it for better searchability.');
+    console.log('');
+  } else if (qualityScore.score < 80 && !verbose) {
+    // Show suggestions for good but not excellent entries
+    info(`Quality score: ${qualityScore.score}/100 (${qualityLevel})`);
+    if (qualityScore.suggestions.length > 0) {
+      info('💡 Suggestions:');
+      qualityScore.suggestions.forEach(suggestion => {
+        info(`   ${suggestion}`);
+      });
+      console.log('');
+    }
+  }
+
+  // Append with file locking
+  try {
+    await appendJsonlEntry(memoryPath, entry);
+    success(`Memory added (${shortId(entry.id)})`);
+    if (verbose) {
+      info(`Entry: ${JSON.stringify(entry)}`);
+    }
+
+    // AUTO-SYNC RULES: If this is a rule or preference, automatically sync rules
+    // This removes the manual step and completes the "Hello World" loop (Gemini's Phase 2)
+    if (type === 'rule' || type === 'preference') {
+      if (verbose) {
+        info('Auto-syncing rules (rule/preference detected)...');
+      }
+      try {
+        // Call sync-rules silently (don't show success message again)
+        await syncRulesCommand({ verbose: false });
+        if (verbose) {
+          info('Rules automatically synced to .memorylink/rules.md');
+        }
+      } catch (err: any) {
+        // Don't fail the memory command if sync fails
+        warn(`Memory saved, but rules sync failed: ${err.message}`);
+        warn('Run `memorylink sync-rules` manually to update rules.md');
+      }
+    }
+  } catch (err) {
+    error(`Failed to add memory: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+export async function listMemoryCommand(
+  options: ListOptions = {}
+): Promise<void> {
+  const { verbose, limit = 20, tag, since, status, json } = options;
+
+  log('Listing memory entries', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+
+  // Check format and suggest migration if needed
+  if (!isJsonlFormat(memoryPath)) {
+    warn('Legacy format detected. Run: memorylink migrate');
+    console.log('');
+    // Fall back to legacy display for now
+    await listMemoryLegacy(memoryPath, limit, tag);
+    return;
+  }
+
+  // Read JSONL entries
+  let entries = readJsonlEntries<MemoryEntry>(memoryPath);
+
+  // Apply filters
+  if (tag) {
+    entries = filterByTag(entries, tag);
+  }
+  if (since) {
+    entries = filterBySince(entries, since);
+  }
+  if (status) {
+    entries = filterByStatus(entries, status);
+  } else {
+    // Default: show only ACTIVE entries
+    entries = entries.filter(e => e.status === 'ACTIVE');
+  }
+
+  if (entries.length === 0) {
+    info('No memory entries found');
+    console.log('');
+    console.log('Add memory with: memorylink memory "Your context here"');
+    return;
+  }
+
+  // Sort by timestamp (newest last)
+  entries.sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
+
+  // Get last N entries
+  const displayEntries = entries.slice(-limit);
+
+  // JSON output
+  if (json) {
+    console.log(JSON.stringify(displayEntries, null, 2));
+    return;
+  }
+
+  // Human-readable output
+  console.log('');
+  info(`Memory entries (showing ${displayEntries.length} of ${entries.length}):`);
+  console.log('');
+
+  for (const entry of displayEntries) {
+    const date = new Date(entry.ts);
+    const shortDate = date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    const tagsStr = entry.tags?.length ? ` \x1b[36m[${entry.tags.join(', ')}]\x1b[0m` : '';
+    const typeStr = entry.type !== 'note' ? `\x1b[33m[${entry.type}]\x1b[0m ` : '';
+    const idStr = `\x1b[90m(${shortId(entry.id)})\x1b[0m`;
+    
+    console.log(`   \x1b[90m${shortDate}\x1b[0m ${typeStr}${entry.details}${tagsStr} ${idStr}`);
+  }
+
+  console.log('');
+  
+  if (entries.length > limit) {
+    info(`Showing ${limit} of ${entries.length}. Use --limit to see more.`);
+  }
+}
+
+/**
+ * Legacy format display (for pre-migration compatibility)
+ */
+async function listMemoryLegacy(
+  memoryPath: string, 
+  limit: number, 
+  tag?: string
+): Promise<void> {
+  let content: string;
+  try {
+    content = fs.readFileSync(memoryPath, 'utf-8');
+  } catch (err) {
+    error(`Failed to read memory file: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+  let entries = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+
+  // Filter by tag if specified
+  if (tag) {
+    entries = entries.filter(entry => entry.toLowerCase().includes(`[${tag.toLowerCase()}`));
+  }
+
+  if (entries.length === 0) {
+    info('No memory entries found');
+    console.log('');
+    console.log('Add memory with: memorylink memory "Your context here"');
+    return;
+  }
+
+  // Get last N entries
+  const displayEntries = entries.slice(-limit);
+
+  console.log('');
+  info(`Memory entries (showing ${displayEntries.length} of ${entries.length}):`);
+  console.log('');
+
+  for (const entry of displayEntries) {
+    // Parse legacy entry
+    const match = entry.match(/\[(.*?)\]\s*(.+?)(\s*\[.*\])?$/);
+    if (match) {
+      const [, timestamp, message, tags] = match;
+      const date = new Date(timestamp);
+      const shortDate = date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+      
+      console.log(`   \x1b[90m${shortDate}\x1b[0m ${message}\x1b[36m${tags || ''}\x1b[0m`);
+    } else {
+      console.log(`   ${entry}`);
+    }
+  }
+
+  console.log('');
+  
+  if (entries.length > limit) {
+    info(`Use --limit to see more entries`);
+  }
+}
+
+export async function clearMemoryCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Clearing memory log', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  
+  // Clear to empty file (JSONL format - no header needed)
+  try {
+    writeFileAtomic(memoryPath, '');
+    success('Memory log cleared');
+  } catch (err) {
+    error(`Failed to clear memory: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Update an existing memory entry's status
+ */
+export async function updateMemoryStatus(
+  id: string,
+  newStatus: 'ACTIVE' | 'DEPRECATED' | 'DELETED',
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log(`Updating memory ${id} to ${newStatus}`, verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const memoryPath = getFilePath('MEMORY', root);
+  const entries = readJsonlEntries<MemoryEntry>(memoryPath);
+  
+  const entryIndex = entries.findIndex(e => e.id === id || e.id.startsWith(id));
+  
+  if (entryIndex === -1) {
+    error(`Memory entry not found: ${id}`);
+    process.exit(1);
+  }
+
+  // Update status
+  entries[entryIndex].status = newStatus;
+
+  // Rewrite file with error handling
+  try {
+    const jsonl = entries.map(e => JSON.stringify(e)).join('\n') + '\n';
+    writeFileAtomic(memoryPath, jsonl);
+    success(`Memory ${shortId(entries[entryIndex].id)} marked as ${newStatus}`);
+  } catch (err) {
+    error(`Failed to update memory: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}