memorylink 1.0.0

package/src/commands/migrate.ts

@@ -0,0 +1,540 @@
+/**
+ * MemoryLink - Migrate Command
+ * Migrate legacy text format logs to JSONL format
+ * 
+ * v1.0 UPDATE: Required for users upgrading from pre-1.0 versions
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  isJsonlFormat,
+  readLines,
+  readJsonlEntries,
+  parseLegacyMemoryLine,
+  parseLegacyLearningLine,
+  parseLegacyChangeLine,
+  success,
+  error,
+  warn,
+  info,
+  log,
+} from '../utils.js';
+import type { 
+  GlobalOptions, 
+  MemoryEntry, 
+  LearningEntry, 
+  ChangeEntry,
+  Sensitivity,
+  TrustLevel,
+  MemoryStatus,
+  SourceType,
+  Provenance,
+} from '../types.js';
+
+export interface MigrateOptions extends GlobalOptions {
+  backup?: boolean;
+  dryRun?: boolean;
+  to?: string;  // Target version: "1.0" or "1.4"
+}
+
+export async function migrateCommand(options: MigrateOptions = {}): Promise<void> {
+  const { verbose, backup = true, dryRun = false, to = '1.0' } = options;
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Handle v1.4 migration
+  if (to === '1.4') {
+    await migrateToV14(root, { verbose, backup, dryRun });
+    return;
+  }
+
+  // Legacy v0.x → v1.0 migration
+  log('Starting migration to JSONL format', verbose);
+
+  console.log('');
+  console.log('\x1b[1m🔄 MemoryLink Migration (v0.x → v1.0)\x1b[0m');
+  console.log('');
+
+  if (dryRun) {
+    info('Dry run mode - no changes will be made');
+    console.log('');
+  }
+
+  const results = {
+    memory: { migrated: 0, skipped: 0, errors: 0 },
+    learnings: { migrated: 0, skipped: 0, errors: 0 },
+    changes: { migrated: 0, skipped: 0, errors: 0 },
+  };
+
+  // Migrate memory.log
+  const memoryPath = getFilePath('MEMORY', root);
+  if (fs.existsSync(memoryPath)) {
+    if (isJsonlFormat(memoryPath)) {
+      info('memory.log: Already in JSONL format ✓');
+      results.memory.skipped = 1;
+    } else {
+      const migrated = await migrateMemoryLog(memoryPath, backup, dryRun, verbose);
+      results.memory = migrated;
+    }
+  }
+
+  // Migrate learnings.log
+  const learningsPath = getFilePath('LEARNINGS', root);
+  if (fs.existsSync(learningsPath)) {
+    if (isJsonlFormat(learningsPath)) {
+      info('learnings.log: Already in JSONL format ✓');
+      results.learnings.skipped = 1;
+    } else {
+      const migrated = await migrateLearningsLog(learningsPath, backup, dryRun, verbose);
+      results.learnings = migrated;
+    }
+  }
+
+  // Migrate changes.log
+  const changesPath = getFilePath('CHANGES', root);
+  if (fs.existsSync(changesPath)) {
+    if (isJsonlFormat(changesPath)) {
+      info('changes.log: Already in JSONL format ✓');
+      results.changes.skipped = 1;
+    } else {
+      const migrated = await migrateChangesLog(changesPath, backup, dryRun, verbose);
+      results.changes = migrated;
+    }
+  }
+
+  // Summary
+  console.log('');
+  console.log('\x1b[1m📊 Migration Summary\x1b[0m');
+  console.log('');
+  
+  const totalMigrated = results.memory.migrated + results.learnings.migrated + results.changes.migrated;
+  const totalErrors = results.memory.errors + results.learnings.errors + results.changes.errors;
+
+  console.log(`   memory.log:    ${formatResult(results.memory)}`);
+  console.log(`   learnings.log: ${formatResult(results.learnings)}`);
+  console.log(`   changes.log:   ${formatResult(results.changes)}`);
+  console.log('');
+
+  if (totalErrors > 0) {
+    warn(`Migration completed with ${totalErrors} errors`);
+    console.log('   Check the .backup files to recover original data');
+  } else if (totalMigrated > 0) {
+    success(`Migration completed! ${totalMigrated} entries converted to JSONL`);
+    if (backup && !dryRun) {
+      info('Backup files created with .backup extension');
+    }
+  } else {
+    success('All logs already in JSONL format - nothing to migrate');
+  }
+  
+  console.log('');
+}
+
+function formatResult(result: { migrated: number; skipped: number; errors: number }): string {
+  if (result.skipped > 0) {
+    return '\x1b[90m(already JSONL)\x1b[0m';
+  }
+  if (result.errors > 0) {
+    return `\x1b[32m${result.migrated} migrated\x1b[0m, \x1b[31m${result.errors} errors\x1b[0m`;
+  }
+  if (result.migrated > 0) {
+    return `\x1b[32m${result.migrated} entries migrated ✓\x1b[0m`;
+  }
+  return '\x1b[90m(empty)\x1b[0m';
+}
+
+async function migrateMemoryLog(
+  filePath: string, 
+  backup: boolean, 
+  dryRun: boolean,
+  verbose?: boolean
+): Promise<{ migrated: number; skipped: number; errors: number }> {
+  log(`Migrating memory.log`, verbose);
+  
+  const lines = readLines(filePath);
+  const entries: MemoryEntry[] = [];
+  let errors = 0;
+
+  for (const line of lines) {
+    // Skip comments
+    if (line.startsWith('#')) continue;
+
+    const entry = parseLegacyMemoryLine(line);
+    if (entry) {
+      entries.push(entry);
+    } else {
+      errors++;
+      warn(`Could not parse line: ${line.substring(0, 50)}...`);
+    }
+  }
+
+  if (dryRun) {
+    info(`memory.log: Would migrate ${entries.length} entries`);
+    return { migrated: entries.length, skipped: 0, errors };
+  }
+
+  // Create backup
+  if (backup) {
+    fs.copyFileSync(filePath, filePath + '.backup');
+  }
+
+  // Write JSONL
+  const jsonl = entries.map(e => JSON.stringify(e)).join('\n') + (entries.length > 0 ? '\n' : '');
+  fs.writeFileSync(filePath, jsonl);
+
+  success(`memory.log: Migrated ${entries.length} entries`);
+  return { migrated: entries.length, skipped: 0, errors };
+}
+
+async function migrateLearningsLog(
+  filePath: string, 
+  backup: boolean, 
+  dryRun: boolean,
+  verbose?: boolean
+): Promise<{ migrated: number; skipped: number; errors: number }> {
+  log(`Migrating learnings.log`, verbose);
+  
+  const lines = readLines(filePath);
+  const entries: LearningEntry[] = [];
+  let errors = 0;
+
+  for (const line of lines) {
+    // Skip comments
+    if (line.startsWith('#')) continue;
+
+    const entry = parseLegacyLearningLine(line);
+    if (entry) {
+      entries.push(entry);
+    } else {
+      errors++;
+      warn(`Could not parse line: ${line.substring(0, 50)}...`);
+    }
+  }
+
+  if (dryRun) {
+    info(`learnings.log: Would migrate ${entries.length} entries`);
+    return { migrated: entries.length, skipped: 0, errors };
+  }
+
+  // Create backup
+  if (backup) {
+    fs.copyFileSync(filePath, filePath + '.backup');
+  }
+
+  // Write JSONL
+  const jsonl = entries.map(e => JSON.stringify(e)).join('\n') + (entries.length > 0 ? '\n' : '');
+  fs.writeFileSync(filePath, jsonl);
+
+  success(`learnings.log: Migrated ${entries.length} entries`);
+  return { migrated: entries.length, skipped: 0, errors };
+}
+
+async function migrateChangesLog(
+  filePath: string, 
+  backup: boolean, 
+  dryRun: boolean,
+  verbose?: boolean
+): Promise<{ migrated: number; skipped: number; errors: number }> {
+  log(`Migrating changes.log`, verbose);
+  
+  const lines = readLines(filePath);
+  const entries: ChangeEntry[] = [];
+  let errors = 0;
+
+  for (const line of lines) {
+    // Skip comments
+    if (line.startsWith('#')) continue;
+
+    const entry = parseLegacyChangeLine(line);
+    if (entry) {
+      entries.push(entry);
+    } else {
+      errors++;
+      warn(`Could not parse line: ${line.substring(0, 50)}...`);
+    }
+  }
+
+  if (dryRun) {
+    info(`changes.log: Would migrate ${entries.length} entries`);
+    return { migrated: entries.length, skipped: 0, errors };
+  }
+
+  // Create backup
+  if (backup) {
+    fs.copyFileSync(filePath, filePath + '.backup');
+  }
+
+  // Write JSONL
+  const jsonl = entries.map(e => JSON.stringify(e)).join('\n') + (entries.length > 0 ? '\n' : '');
+  fs.writeFileSync(filePath, jsonl);
+
+  success(`changes.log: Migrated ${entries.length} entries`);
+  return { migrated: entries.length, skipped: 0, errors };
+}
+
+/**
+ * Check if migration is needed and warn user
+ */
+export function checkMigrationRequired(root?: string): boolean {
+  const projectRoot = root || findRoot();
+  if (!projectRoot) return false;
+
+  const logFiles = ['MEMORY', 'LEARNINGS', 'CHANGES'] as const;
+  
+  for (const fileKey of logFiles) {
+    const filePath = getFilePath(fileKey, projectRoot);
+    if (fs.existsSync(filePath) && !isJsonlFormat(filePath)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Show migration required warning
+ */
+export function showMigrationWarning(): void {
+  console.error('');
+  console.error('\x1b[31m\x1b[1m⚠️  MIGRATION REQUIRED\x1b[0m');
+  console.error('');
+  console.error('Your MemoryLink logs are in the legacy text format.');
+  console.error('v1.0 requires JSONL format for improved reliability.');
+  console.error('');
+  console.error('\x1b[33mTo migrate, run:\x1b[0m');
+  console.error('  memorylink migrate');
+  console.error('');
+  console.error('\x1b[90mTo preview changes without modifying files:\x1b[0m');
+  console.error('  memorylink migrate --dry-run');
+  console.error('');
+}
+
+/**
+ * Migrate v1.3 records to v1.4 format
+ * Adds schemaVersion, trustLevel, sensitivity, status, sourceType, provenance
+ */
+async function migrateToV14(
+  root: string,
+  options: { verbose?: boolean; backup?: boolean; dryRun?: boolean }
+): Promise<void> {
+  const { verbose, backup = true, dryRun = false } = options;
+
+  log('Starting migration to v1.4 schema', verbose);
+
+  console.log('');
+  console.log('\x1b[1m🔄 MemoryLink Migration (v1.3 → v1.4)\x1b[0m');
+  console.log('');
+
+  if (dryRun) {
+    info('Dry run mode - no changes will be made');
+    console.log('');
+  }
+
+  const results = {
+    memory: { migrated: 0, skipped: 0, errors: 0 },
+    learnings: { migrated: 0, skipped: 0, errors: 0 },
+    changes: { migrated: 0, skipped: 0, errors: 0 },
+  };
+
+  // Migrate memory.log
+  const memoryPath = getFilePath('MEMORY', root);
+  if (fs.existsSync(memoryPath)) {
+    if (!isJsonlFormat(memoryPath)) {
+      error('memory.log is not in JSONL format. Run: memorylink migrate (to v1.0 first)');
+      results.memory.errors = 1;
+    } else {
+      const migrated = await migrateMemoryToV14(memoryPath, root, backup, dryRun, verbose);
+      results.memory = migrated;
+    }
+  }
+
+  // Learnings and changes don't need v1.4 migration (they use same schema)
+  // But we'll mark them as checked
+  const learningsPath = getFilePath('LEARNINGS', root);
+  if (fs.existsSync(learningsPath)) {
+    info('learnings.log: No v1.4 migration needed (schema unchanged) ✓');
+    results.learnings.skipped = 1;
+  }
+
+  const changesPath = getFilePath('CHANGES', root);
+  if (fs.existsSync(changesPath)) {
+    info('changes.log: No v1.4 migration needed (schema unchanged) ✓');
+    results.changes.skipped = 1;
+  }
+
+  // Summary
+  console.log('');
+  console.log('\x1b[1m📊 Migration Summary\x1b[0m');
+  console.log('');
+
+  const totalMigrated = results.memory.migrated;
+  const totalErrors = results.memory.errors;
+
+  console.log(`   memory.log:    ${formatResult(results.memory)}`);
+  console.log(`   learnings.log: ${formatResult(results.learnings)}`);
+  console.log(`   changes.log:   ${formatResult(results.changes)}`);
+  console.log('');
+
+  if (totalErrors > 0) {
+    warn(`Migration completed with ${totalErrors} errors`);
+    if (backup && !dryRun) {
+      console.log('   Check the .backup files to recover original data');
+    }
+  } else if (totalMigrated > 0) {
+    success(`Migration completed! ${totalMigrated} memory entries upgraded to v1.4`);
+    if (backup && !dryRun) {
+      info('Backup files created with .backup extension');
+    }
+  } else {
+    success('All records already in v1.4 format - nothing to migrate');
+  }
+
+  console.log('');
+}
+
+/**
+ * Read raw JSONL entries without normalization (for migration)
+ */
+function readRawJsonlEntries<T>(filePath: string): T[] {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n').filter(line => line.trim() !== '');
+  const entries: T[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Skip comments
+    if (line.startsWith('#')) {
+      continue;
+    }
+
+    try {
+      const entry = JSON.parse(line) as T;
+      entries.push(entry);
+    } catch (err) {
+      // Skip invalid JSON lines
+      warn(`Line ${i + 1}: Invalid JSON, skipping`);
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Migrate memory.log from v1.3 to v1.4
+ */
+async function migrateMemoryToV14(
+  filePath: string,
+  root: string,
+  backup: boolean,
+  dryRun: boolean,
+  verbose?: boolean
+): Promise<{ migrated: number; skipped: number; errors: number }> {
+  log(`Migrating memory.log to v1.4`, verbose);
+
+  // Read raw entries (without normalization)
+  const entries = readRawJsonlEntries<MemoryEntry>(filePath);
+  const migratedEntries: MemoryEntry[] = [];
+  let skipped = 0;
+  let errors = 0;
+
+  for (const entry of entries) {
+    try {
+      // Check if already v1.4 (check schemaVersion field directly)
+      if (entry.schemaVersion === '1.4.0') {
+        skipped++;
+        migratedEntries.push(entry); // Keep as-is
+        continue;
+      }
+
+      // Normalize to v1.4
+      const normalized = normalizeMemoryEntryToV14(entry, root);
+      migratedEntries.push(normalized);
+    } catch (err) {
+      errors++;
+      warn(`Error migrating entry ${entry.id}: ${err instanceof Error ? err.message : String(err)}`);
+      // Keep original entry on error
+      migratedEntries.push(entry);
+    }
+  }
+
+  if (dryRun) {
+    const toMigrate = entries.length - skipped;
+    info(`memory.log: Would migrate ${toMigrate} entries to v1.4`);
+    return { migrated: toMigrate, skipped, errors };
+  }
+
+  // Create backup
+  if (backup) {
+    const backupPath = filePath + '.backup';
+    fs.copyFileSync(filePath, backupPath);
+    log(`Backup created: ${backupPath}`, verbose);
+  }
+
+  // Write migrated entries
+  const jsonl = migratedEntries.map(e => JSON.stringify(e)).join('\n') + (migratedEntries.length > 0 ? '\n' : '');
+  fs.writeFileSync(filePath, jsonl);
+
+  const migrated = entries.length - skipped;
+  success(`memory.log: Migrated ${migrated} entries to v1.4`);
+  return { migrated, skipped, errors };
+}
+
+/**
+ * Normalize v1.3 MemoryEntry to v1.4 format
+ */
+function normalizeMemoryEntryToV14(entry: MemoryEntry, root: string): MemoryEntry {
+  // If already v1.4, return as-is
+  if (entry.schemaVersion === '1.4.0') {
+    return entry;
+  }
+
+  // Determine source type from agent field
+  const sourceType: SourceType =
+    entry.agent === 'user' || !entry.agent || entry.agent === 'migrated'
+      ? 'human'
+      : ['cursor', 'claude', 'chatgpt', 'copilot', 'windsurf'].includes(entry.agent.toLowerCase())
+      ? 'agent'
+      : 'code';
+
+  // Determine memory status: VERIFIED for human, DRAFT for agent
+  const memoryStatus: MemoryStatus = sourceType === 'human' ? 'VERIFIED' : 'DRAFT';
+
+  // Build provenance from existing fields
+  const provenance: Provenance = {
+    createdAt: entry.ts,
+    createdBy: entry.agent || 'unknown',
+    tool: entry.agent || undefined,
+    kind: sourceType === 'human' ? 'user' : 'app',
+  };
+
+  // Get project path (relative to root)
+  const projectPath = root || process.cwd();
+
+  // Add v1.4 fields with defaults
+  return {
+    ...entry,
+    schemaVersion: '1.4.0',
+    recordVersion: 1,
+    projectPath,
+    sensitivity: 'internal' as Sensitivity,
+    trustLevel: 'medium' as TrustLevel,
+    memoryStatus,
+    sourceType,
+    provenance,
+  };
+}
+

package/src/commands/patterns.ts

@@ -0,0 +1,158 @@
+/**
+ * MemoryLink - Team Pattern Detection Commands
+ * Detect and suggest team coding patterns
+ * 
+ * v1.3: Team Pattern Detection feature
+ */
+
+import * as path from 'path';
+import {
+  detectTeamPatterns,
+  suggestPatterns,
+  saveTeamPatterns,
+  loadTeamPatterns,
+  type TeamPatternsReport,
+  type TeamPattern,
+} from '../utils/team-patterns.js';
+import { findRoot, colorize } from '../utils.js';
+
+export interface GlobalOptions {
+  verbose?: boolean;
+}
+
+/**
+ * Detect team patterns from learnings
+ */
+export async function patternsDetectCommand(options: GlobalOptions = {}): Promise<void> {
+  const rootDir = findRoot();
+  if (!rootDir) {
+    console.error(colorize('❌ Not in a MemoryLink project. Run: memorylink init', 'red'));
+    process.exit(1);
+  }
+  
+  console.log(colorize('📊 Detecting team patterns from learnings...', 'cyan'));
+  
+  const report = detectTeamPatterns(rootDir);
+  
+  // Save report
+  saveTeamPatterns(report, rootDir);
+  
+  // Display results
+  displayPatternsReport(report);
+  
+  console.log(colorize('\n✅ Patterns saved to .memorylink/team-patterns.json', 'green'));
+}
+
+/**
+ * Suggest patterns for a context
+ */
+export async function patternsSuggestCommand(
+  context: string,
+  options: GlobalOptions = {}
+): Promise<void> {
+  const rootDir = findRoot();
+  if (!rootDir) {
+    console.error(colorize('❌ Not in a MemoryLink project. Run: memorylink init', 'red'));
+    process.exit(1);
+  }
+  
+  console.log(colorize(`💡 Suggesting patterns for: "${context}"`, 'cyan'));
+  console.log('');
+  
+  const suggestions = suggestPatterns(context, rootDir);
+  
+  if (suggestions.length === 0) {
+    console.log(colorize('No matching patterns found. Your team may not have encountered this problem yet.', 'yellow'));
+    console.log(colorize('Consider logging a learning after solving this problem.', 'yellow'));
+    return;
+  }
+  
+  console.log(colorize('📋 Suggested Team Patterns:', 'cyan'));
+  console.log('');
+  
+  for (let i = 0; i < suggestions.length; i++) {
+    const pattern = suggestions[i];
+    console.log(colorize(`${i + 1}. ${pattern.pattern_name}`, 'bold'));
+    console.log(`   Category: ${pattern.category}`);
+    console.log(`   Description: ${pattern.description}`);
+    console.log(`   Adoption: ${Math.round(pattern.adoption_rate * 100)}% of team`);
+    console.log(`   Success Rate: ${Math.round(pattern.success_rate * 100)}%`);
+    
+    if (pattern.code_example) {
+      console.log(`   Example: ${pattern.code_example.substring(0, 60)}...`);
+    }
+    
+    if (pattern.exceptions.length > 0) {
+      console.log(colorize(`   ⚠️  Exceptions: ${pattern.exceptions.map(e => e.name).join(', ')} use different approach`, 'yellow'));
+    }
+    
+    console.log('');
+  }
+}
+
+/**
+ * Display patterns report
+ */
+function displayPatternsReport(report: TeamPatternsReport): void {
+  console.log('');
+  console.log(colorize('═══════════════════════════════════════════════════════════════', 'cyan'));
+  console.log(colorize('                    TEAM PATTERNS REPORT', 'cyan'));
+  console.log(colorize('═══════════════════════════════════════════════════════════════', 'cyan'));
+  console.log('');
+  
+  console.log(`Detected: ${new Date(report.detectedAt).toLocaleString()}`);
+  console.log(`Team Consensus: ${Math.round(report.teamConsensus * 100)}%`);
+  console.log('');
+  
+  // Problem Patterns
+  if (report.problemPatterns.length > 0) {
+    console.log(colorize('📋 Problem-Solution Patterns:', 'cyan'));
+    console.log('');
+    
+    for (const pattern of report.problemPatterns.slice(0, 10)) {
+      console.log(colorize(`  • ${pattern.pattern_name}`, 'bold'));
+      console.log(`    Category: ${pattern.category}`);
+      console.log(`    Adoption: ${Math.round(pattern.adoption_rate * 100)}% (${pattern.adopted_by.length} team members)`);
+      console.log(`    Success Rate: ${Math.round(pattern.success_rate * 100)}%`);
+      console.log(`    Evidence: ${pattern.evidence.length} learnings`);
+      
+      if (pattern.exceptions.length > 0) {
+        console.log(colorize(`    ⚠️  Exceptions: ${pattern.exceptions.map(e => `${e.name} (${e.preferred_alternative})`).join(', ')}`, 'yellow'));
+      }
+      
+      console.log('');
+    }
+    
+    if (report.problemPatterns.length > 10) {
+      console.log(colorize(`  ... and ${report.problemPatterns.length - 10} more patterns`, 'gray'));
+      console.log('');
+    }
+  }
+  
+  // Style Patterns
+  if (report.stylePatterns.length > 0) {
+    console.log(colorize('🎨 Coding Style Patterns:', 'cyan'));
+    console.log('');
+    
+    for (const pattern of report.stylePatterns) {
+      console.log(colorize(`  • ${pattern.pattern_name}`, 'bold'));
+      console.log(`    Adoption: ${Math.round(pattern.adoption_rate * 100)}%`);
+      console.log(`    Success Rate: ${Math.round(pattern.success_rate * 100)}%`);
+      console.log('');
+    }
+  }
+  
+  // Recommendations
+  if (report.recommendations.length > 0) {
+    console.log(colorize('💡 Recommendations:', 'yellow'));
+    console.log('');
+    for (const rec of report.recommendations) {
+      console.log(`  ${rec}`);
+    }
+    console.log('');
+  }
+  
+  console.log(colorize('═══════════════════════════════════════════════════════════════', 'cyan'));
+  console.log('');
+}
+