memorylink 1.0.0

package/src/commands/change.ts

@@ -0,0 +1,298 @@
+/**
+ * MemoryLink - Change Command
+ * Log file changes to audit trail
+ * 
+ * v1.0 UPDATE: Now uses JSONL format with file locking and secret detection
+ */
+
+import * as fs from 'fs';
+import {
+  getFilePath,
+  isInitialized,
+  getTimestamp,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  findRoot,
+  generateId,
+  shortId,
+  appendJsonlEntry,
+  readJsonlEntries,
+  isJsonlFormat,
+  checkSecretsBeforeWrite,
+  filterByTag,
+  filterBySince,
+  normalizePathForStorage,
+  writeFileAtomic,
+} from '../utils.js';
+import type { 
+  GlobalOptions, 
+  ChangeEntry,
+  ChangeOptions,
+  ListOptions,
+} from '../types.js';
+import { checkMigrationRequired, showMigrationWarning } from './migrate.js';
+
+export async function changeCommand(
+  file: string,
+  reason: string,
+  options: ChangeOptions = {}
+): Promise<void> {
+  const { 
+    verbose, 
+    agent = 'user', 
+    action = 'edited', 
+    force = false,
+    justification,
+    reviewedBy,
+    tested,
+    impact,
+  } = options;
+
+  // Validate inputs - reject empty values and oversize payloads
+  if (!file || file.trim().length === 0) {
+    error('File path cannot be empty');
+    process.exit(1);
+  }
+  if (!reason || reason.trim().length === 0) {
+    error('Change reason cannot be empty');
+    process.exit(1);
+  }
+  if (reason.length > 4000) {
+    error('Change reason too large (max 4000 chars). Please shorten the content.');
+    process.exit(1);
+  }
+
+  log(`Logging change for: ${file}`, 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(reason, force)) {
+    process.exit(1);
+  }
+
+  const changesPath = getFilePath('CHANGES', root);
+
+  // Normalize file path for storage (forward slashes, Git-compatible)
+  const normalizedFile = normalizePathForStorage(file, root);
+
+  // Create JSONL entry with enhanced context
+  const entry: ChangeEntry = {
+    id: generateId(),
+    ts: getTimestamp(),
+    agent,
+    file: normalizedFile,
+    action,
+    reason,
+    status: 'ACTIVE',
+    forcedSecretCheck: force ? true : undefined,
+    // Enhanced context fields
+    ...(justification && { justification }),
+    ...(reviewedBy && { reviewedBy }),
+    ...(tested && { tested }),
+    ...(impact && { impact }),
+  };
+
+  // Append with file locking
+  try {
+    await appendJsonlEntry(changesPath, entry);
+    success(`Change logged (${shortId(entry.id)})`);
+    if (verbose) {
+      info(`Entry: ${JSON.stringify(entry)}`);
+    }
+  } catch (err) {
+    error(`Failed to log change: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+export async function listChangesCommand(
+  options: ListOptions & { file?: string } = {}
+): Promise<void> {
+  const { verbose, limit = 20, file, since, tag, json } = options;
+
+  log('Listing change entries', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const changesPath = getFilePath('CHANGES', root);
+
+  // Check format and suggest migration if needed
+  if (!isJsonlFormat(changesPath)) {
+    warn('Legacy format detected. Run: memorylink migrate');
+    console.log('');
+    // Fall back to legacy display
+    await listChangesLegacy(changesPath, limit, file);
+    return;
+  }
+
+  // Read JSONL entries
+  let entries = readJsonlEntries<ChangeEntry>(changesPath);
+
+  // Apply filters
+  if (file) {
+    entries = entries.filter(e => e.file.toLowerCase().includes(file.toLowerCase()));
+  }
+  if (tag) {
+    entries = filterByTag(entries, tag);
+  }
+  if (since) {
+    entries = filterBySince(entries, since);
+  }
+
+  if (entries.length === 0) {
+    info('No change entries found');
+    console.log('');
+    console.log('Log changes with: memorylink change <file> "reason"');
+    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(`Change log (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 agentStr = entry.agent !== 'user' ? `\x1b[36m(${entry.agent})\x1b[0m` : '';
+    const actionStr = entry.action !== 'edited' ? `\x1b[35m[${entry.action}]\x1b[0m ` : '';
+    const idStr = `\x1b[90m(${shortId(entry.id)})\x1b[0m`;
+    
+    console.log(`   \x1b[90m${shortDate}\x1b[0m ${actionStr}\x1b[33m${entry.file}\x1b[0m ${idStr}`);
+    console.log(`              ${entry.reason} ${agentStr}`);
+    
+    // Show enhanced context if available
+    if (entry.justification) {
+      console.log(`              \x1b[36mJustification:\x1b[0m ${entry.justification}`);
+    }
+    if (entry.reviewedBy) {
+      console.log(`              \x1b[36mReviewed by:\x1b[0m ${entry.reviewedBy}`);
+    }
+    if (entry.tested) {
+      console.log(`              \x1b[36mTested:\x1b[0m ${entry.tested}`);
+    }
+    if (entry.impact) {
+      console.log(`              \x1b[36mImpact:\x1b[0m ${entry.impact}`);
+    }
+  }
+
+  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 listChangesLegacy(
+  changesPath: string,
+  limit: number,
+  file?: string
+): Promise<void> {
+  let content: string;
+  try {
+    content = fs.readFileSync(changesPath, 'utf-8');
+  } catch (err) {
+    error(`Failed to read changes file: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+  let entries = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+
+  // Filter by file if specified
+  if (file) {
+    entries = entries.filter(entry => entry.toLowerCase().includes(file.toLowerCase()));
+  }
+
+  if (entries.length === 0) {
+    info('No change entries found');
+    console.log('');
+    console.log('Log changes with: memorylink change <file> "reason"');
+    return;
+  }
+
+  // Get last N entries
+  const displayEntries = entries.slice(-limit);
+
+  console.log('');
+  info(`Change log (showing ${displayEntries.length} of ${entries.length}):`);
+  console.log('');
+
+  for (const entry of displayEntries) {
+    // Parse legacy entry
+    const match = entry.match(/\[(.*?)\]\s*(.+?):\s*(.+?)(\s*\(.*\))?$/);
+    if (match) {
+      const [, timestamp, filePath, reason, agent] = 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 \x1b[33m${filePath}\x1b[0m`);
+      console.log(`              ${reason}\x1b[36m${agent || ''}\x1b[0m`);
+    } else {
+      console.log(`   ${entry}`);
+    }
+  }
+
+  console.log('');
+  
+  if (entries.length > limit) {
+    info(`Use --limit to see more entries`);
+  }
+}
+
+export async function clearChangesCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Clearing changes log', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const changesPath = getFilePath('CHANGES', root);
+  
+  // Clear to empty file (JSONL format - no header needed)
+  try {
+    writeFileAtomic(changesPath, '');
+    success('Changes log cleared');
+  } catch (err) {
+    error(`Failed to clear changes: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}

package/src/commands/checkpoint.ts

@@ -0,0 +1,390 @@
+/**
+ * MemoryLink - Checkpoint Command (v1.5)
+ * Create, list, and compare memory checkpoints
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  readJsonlEntries,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  getTimestamp,
+  ensureDir,
+} from '../utils.js';
+import { MEMORYLINK_DIR } from '../types.js';
+import type { GlobalOptions, MemoryEntry } from '../types.js';
+
+export interface CheckpointOptions extends GlobalOptions {
+  name?: string;
+  message?: string;
+}
+
+interface CheckpointMetadata {
+  id: string;
+  name: string;
+  message?: string;
+  timestamp: string;
+  recordCount: number;
+  branch?: string;
+  commit?: string;
+}
+
+/**
+ * Create a checkpoint
+ */
+export async function checkpointCreateCommand(
+  options: CheckpointOptions = {}
+): Promise<void> {
+  const { verbose, name, message } = options;
+
+  // TODO v1.6: Record telemetry event (command start)
+  // import { recordEvent, checkIsGitRepo, checkHasConfig } from '../telemetry.js';
+  // await recordEvent({
+  //   command: 'checkpoint',
+  //   result: 'success', // Will be updated to 'error' if command fails
+  //   flags: { create: true, name: name || null },
+  //   isGitRepo: checkIsGitRepo(),
+  //   hasConfig: checkHasConfig(),
+  // });
+
+  log('Creating checkpoint', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    // TODO v1.6: Record telemetry event (command error)
+    // await recordEvent({
+    //   command: 'checkpoint',
+    //   result: 'error',
+    //   exitCode: 1,
+    //   errorKind: 'NOT_INITIALIZED',
+    //   isGitRepo: checkIsGitRepo(),
+    //   hasConfig: checkHasConfig(),
+    // });
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Generate checkpoint name if not provided
+  const checkpointName = name || `checkpoint-${Date.now()}`;
+  
+  // Create checkpoints directory
+  const checkpointsDir = path.join(root, MEMORYLINK_DIR, 'checkpoints');
+  ensureDir(checkpointsDir);
+
+  // Read current memory entries
+  const memoryPath = getFilePath('MEMORY', root);
+  const entries = readJsonlEntries<MemoryEntry>(memoryPath);
+
+  // Get Git info if available
+  let branch: string | undefined;
+  let commit: string | undefined;
+  try {
+    const { execSync } = await import('child_process');
+    branch = execSync('git rev-parse --abbrev-ref HEAD', { 
+      cwd: root, 
+      encoding: 'utf-8' 
+    }).trim();
+    commit = execSync('git rev-parse HEAD', { 
+      cwd: root, 
+      encoding: 'utf-8' 
+    }).trim();
+  } catch {
+    // Git not available, continue without
+  }
+
+  // Create checkpoint metadata
+  const metadata: CheckpointMetadata = {
+    id: checkpointName,
+    name: checkpointName,
+    message,
+    timestamp: getTimestamp(),
+    recordCount: entries.length,
+    branch,
+    commit,
+  };
+
+  // Save checkpoint
+  const checkpointPath = path.join(checkpointsDir, `${checkpointName}.json`);
+  const checkpointData = {
+    metadata,
+    entries,
+  };
+
+  fs.writeFileSync(checkpointPath, JSON.stringify(checkpointData, null, 2));
+
+  success(`Checkpoint created: ${checkpointName}`);
+  info(`  Records: ${entries.length}`);
+  if (branch) {
+    info(`  Branch: ${branch}`);
+  }
+  if (commit) {
+    info(`  Commit: ${commit.substring(0, 8)}`);
+  }
+}
+
+/**
+ * List checkpoints
+ */
+export async function checkpointListCommand(
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log('Listing checkpoints', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const checkpointsDir = path.join(root, MEMORYLINK_DIR, 'checkpoints');
+  if (!fs.existsSync(checkpointsDir)) {
+    info('No checkpoints found');
+    return;
+  }
+
+  interface CheckpointInfo {
+    name: string;
+    timestamp: string;
+    recordCount: number;
+    branch?: string;
+    commit?: string;
+    message?: string;
+  }
+
+  const files: (CheckpointInfo | null)[] = fs.readdirSync(checkpointsDir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const filePath = path.join(checkpointsDir, f);
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(content) as { metadata: CheckpointMetadata };
+        return {
+          name: data.metadata.name,
+          timestamp: data.metadata.timestamp,
+          recordCount: data.metadata.recordCount,
+          branch: data.metadata.branch,
+          commit: data.metadata.commit,
+          message: data.metadata.message,
+        } as CheckpointInfo;
+      } catch {
+        return null;
+      }
+    });
+
+  const validFiles = files.filter((f): f is CheckpointInfo => f !== null)
+    .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+
+  if (validFiles.length === 0) {
+    info('No checkpoints found');
+    return;
+  }
+
+  console.log('');
+  console.log('\x1b[1m📸 Checkpoints\x1b[0m');
+  console.log('');
+
+  for (const checkpoint of validFiles) {
+    console.log(`  ${checkpoint.name}`);
+    console.log(`    Created: ${new Date(checkpoint.timestamp).toLocaleString()}`);
+    console.log(`    Records: ${checkpoint.recordCount}`);
+    if (checkpoint.branch) {
+      console.log(`    Branch: ${checkpoint.branch}`);
+    }
+    if (checkpoint.commit) {
+      console.log(`    Commit: ${checkpoint.commit.substring(0, 8)}`);
+    }
+    if (checkpoint.message) {
+      console.log(`    Message: ${checkpoint.message}`);
+    }
+    console.log('');
+  }
+}
+
+/**
+ * Compare two checkpoints
+ */
+export async function checkpointDiffCommand(
+  checkpoint1: string,
+  checkpoint2: string,
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log(`Comparing checkpoints: ${checkpoint1} vs ${checkpoint2}`, verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const checkpointsDir = path.join(root, MEMORYLINK_DIR, 'checkpoints');
+  
+  // Load checkpoints
+  const loadCheckpoint = (name: string) => {
+    const filePath = path.join(checkpointsDir, `${name}.json`);
+    if (!fs.existsSync(filePath)) {
+      error(`Checkpoint not found: ${name}`);
+      process.exit(1);
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  };
+
+  interface CheckpointData {
+    metadata: CheckpointMetadata;
+    entries: MemoryEntry[];
+  }
+
+  const cp1 = loadCheckpoint(checkpoint1) as CheckpointData;
+  const cp2 = loadCheckpoint(checkpoint2) as CheckpointData;
+
+  // Compare
+  const entries1 = new Map(cp1.entries.map((e: MemoryEntry) => [e.id, e]));
+  const entries2 = new Map(cp2.entries.map((e: MemoryEntry) => [e.id, e]));
+
+  const added: MemoryEntry[] = [];
+  const removed: MemoryEntry[] = [];
+  const modified: { old: MemoryEntry; new: MemoryEntry }[] = [];
+
+  // Find added and modified
+  for (const [id, entry2] of entries2) {
+    const entry1 = entries1.get(id);
+    if (!entry1) {
+      added.push(entry2);
+    } else if (JSON.stringify(entry1) !== JSON.stringify(entry2)) {
+      modified.push({ old: entry1, new: entry2 });
+    }
+  }
+
+  // Find removed
+  for (const [id, entry1] of entries1) {
+    if (!entries2.has(id)) {
+      removed.push(entry1);
+    }
+  }
+
+  // Display results
+  console.log('');
+  console.log('\x1b[1m📊 Checkpoint Comparison\x1b[0m');
+  console.log('');
+  console.log(`  ${checkpoint1}: ${cp1.metadata.recordCount} records`);
+  console.log(`  ${checkpoint2}: ${cp2.metadata.recordCount} records`);
+  console.log('');
+
+  if (added.length > 0) {
+    console.log(`  \x1b[32m+ Added: ${added.length}\x1b[0m`);
+    for (const entry of added.slice(0, 5)) {
+      console.log(`    - ${entry.id.substring(0, 8)}: ${entry.type}`);
+    }
+    if (added.length > 5) {
+      console.log(`    ... and ${added.length - 5} more`);
+    }
+  }
+
+  if (removed.length > 0) {
+    console.log(`  \x1b[31m- Removed: ${removed.length}\x1b[0m`);
+    for (const entry of removed.slice(0, 5)) {
+      console.log(`    - ${entry.id.substring(0, 8)}: ${entry.type}`);
+    }
+    if (removed.length > 5) {
+      console.log(`    ... and ${removed.length - 5} more`);
+    }
+  }
+
+  if (modified.length > 0) {
+    console.log(`  \x1b[33m~ Modified: ${modified.length}\x1b[0m`);
+    for (const { old, new: newEntry } of modified.slice(0, 5)) {
+      console.log(`    - ${old.id.substring(0, 8)}: ${old.type}`);
+    }
+    if (modified.length > 5) {
+      console.log(`    ... and ${modified.length - 5} more`);
+    }
+  }
+
+  if (added.length === 0 && removed.length === 0 && modified.length === 0) {
+    success('Checkpoints are identical');
+  }
+
+  console.log('');
+}
+
+/**
+ * Restore a checkpoint (with safety confirmation)
+ */
+export async function checkpointRestoreCommand(
+  checkpointName: string,
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log(`Restoring checkpoint: ${checkpointName}`, verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const checkpointsDir = path.join(root, MEMORYLINK_DIR, 'checkpoints');
+  const checkpointPath = path.join(checkpointsDir, `${checkpointName}.json`);
+
+  if (!fs.existsSync(checkpointPath)) {
+    error(`Checkpoint not found: ${checkpointName}`);
+    process.exit(1);
+  }
+
+  // Load checkpoint
+  const checkpointData = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8')) as {
+    metadata: CheckpointMetadata;
+    entries: MemoryEntry[];
+  };
+
+  // Create temp file with restored content
+  const tempPath = path.join(root, MEMORYLINK_DIR, 'memory.log.restore');
+  const memoryPath = getFilePath('MEMORY', root);
+
+  // Write checkpoint entries to temp file
+  const jsonl = checkpointData.entries
+    .map(e => JSON.stringify(e))
+    .join('\n') + '\n';
+  
+  fs.writeFileSync(tempPath, jsonl);
+
+  // Show preview
+  console.log('');
+  console.log('\x1b[1m📸 Checkpoint Restore Preview\x1b[0m');
+  console.log('');
+  console.log(`  Checkpoint: ${checkpointName}`);
+  console.log(`  Records: ${checkpointData.entries.length}`);
+  console.log(`  Created: ${new Date(checkpointData.metadata.timestamp).toLocaleString()}`);
+  if (checkpointData.metadata.branch) {
+    console.log(`  Branch: ${checkpointData.metadata.branch}`);
+  }
+  console.log('');
+  console.log(`  Current memory.log: ${fs.existsSync(memoryPath) ? fs.statSync(memoryPath).size + ' bytes' : 'does not exist'}`);
+  console.log(`  Restore candidate: ${tempPath}`);
+  console.log('');
+
+  warn('⚠️  This will overwrite your current memory.log');
+  warn('⚠️  Review the candidate file before confirming');
+  console.log('');
+  info('To restore:');
+  info(`  1. Review: ${tempPath}`);
+  info(`  2. If correct, run: mv ${tempPath} ${memoryPath}`);
+  info(`  3. If incorrect, run: rm ${tempPath}`);
+  console.log('');
+
+  success(`Restore candidate created at: ${tempPath}`);
+  info('Review the file and manually restore when ready');
+}
+