memorylink 1.0.0

package/src/commands/learn.ts

@@ -0,0 +1,328 @@
+/**
+ * MemoryLink - Learn Command
+ * Track successful and failed solutions
+ * 
+ * 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,
+  parseTags,
+  generateId,
+  shortId,
+  appendJsonlEntry,
+  readJsonlEntries,
+  isJsonlFormat,
+  checkSecretsBeforeWrite,
+  filterByTag,
+  filterBySince,
+  filterByStatus,
+} from '../utils.js';
+import type { 
+  GlobalOptions, 
+  LearningStatus,
+  LearningEntry,
+  LearnOptions,
+  ListOptions,
+} from '../types.js';
+import { checkMigrationRequired, showMigrationWarning } from './migrate.js';
+import { scoreLearningEntry, formatQualityScore, getQualityLevel } from '../utils/quality.js';
+
+export async function learnCommand(
+  problem: string,
+  solution: string,
+  options: LearnOptions
+): Promise<void> {
+  const { verbose, status, tags: tagString, reason, force = false } = options;
+
+  // Validate inputs - reject empty problem/solution
+  if (!problem || problem.trim().length === 0) {
+    error('Problem description cannot be empty');
+    process.exit(1);
+  }
+  if (!solution || solution.trim().length === 0) {
+    error('Solution description cannot be empty');
+    process.exit(1);
+  }
+
+  log(`Adding learning: ${problem} -> ${solution} (${status})`, 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);
+  }
+
+  // Validate status
+  if (status !== 'SUCCESS' && status !== 'FAILED') {
+    error('Status must be SUCCESS or FAILED');
+    process.exit(1);
+  }
+
+  // Secret detection at write time (check both problem and solution)
+  const contentToCheck = `${problem} ${solution} ${reason || ''}`;
+  if (!checkSecretsBeforeWrite(contentToCheck, force)) {
+    process.exit(1);
+  }
+
+  const learningsPath = getFilePath('LEARNINGS', root);
+  const tags = parseTags(tagString);
+
+  // Create JSONL entry
+  const entry: LearningEntry = {
+    id: generateId(),
+    ts: getTimestamp(),
+    agent: 'user',
+    problem,
+    solution,
+    outcome: status,
+    reason,
+    tags,
+    status: 'ACTIVE',
+    forcedSecretCheck: force ? true : undefined,
+  };
+
+  // Quality validation (Week 5)
+  const qualityScore = scoreLearningEntry(entry);
+  const qualityLevel = getQualityLevel(qualityScore.score);
+  
+  if (qualityScore.score < 60) {
+    warn(`⚠️  Low quality learning (score: ${qualityScore.score}/100)`);
+    console.log('');
+    console.log(formatQualityScore(qualityScore));
+    console.log('');
+    
+    // Ask user if they want to proceed (non-interactive: just warn)
+    warn('Learning 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(learningsPath, entry);
+    
+    if (status === 'SUCCESS') {
+      success(`Learning added - SUCCESS (${shortId(entry.id)})`);
+    } else {
+      warn(`Learning added - FAILED (${shortId(entry.id)})`);
+    }
+    
+    if (verbose) {
+      info(`Entry: ${JSON.stringify(entry)}`);
+    }
+  } catch (err) {
+    error(`Failed to add learning: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}
+
+export async function listLearningsCommand(
+  options: ListOptions & { status?: LearningStatus } = {}
+): Promise<void> {
+  const { verbose, limit = 20, tag, since, status, json } = options;
+
+  log('Listing learnings', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const learningsPath = getFilePath('LEARNINGS', root);
+
+  // Check format and suggest migration if needed
+  if (!isJsonlFormat(learningsPath)) {
+    warn('Legacy format detected. Run: memorylink migrate');
+    console.log('');
+    // Fall back to legacy display
+    await listLearningsLegacy(learningsPath, limit, status, tag);
+    return;
+  }
+
+  // Read JSONL entries
+  let entries = readJsonlEntries<LearningEntry>(learningsPath);
+
+  // Apply filters
+  if (tag) {
+    entries = filterByTag(entries, tag);
+  }
+  if (since) {
+    entries = filterBySince(entries, since);
+  }
+  if (status) {
+    // Filter by outcome (SUCCESS/FAILED)
+    entries = entries.filter(e => e.outcome === status);
+  }
+  
+  // Only show ACTIVE entries by default
+  entries = entries.filter(e => e.status === 'ACTIVE');
+
+  if (entries.length === 0) {
+    info('No learnings found');
+    console.log('');
+    console.log('Add learnings with: memorylink learn "problem" "solution" --status SUCCESS');
+    return;
+  }
+
+  // Count successes and failures
+  const successCount = entries.filter(e => e.outcome === 'SUCCESS').length;
+  const failedCount = entries.filter(e => e.outcome === 'FAILED').length;
+
+  // 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(`Learnings (${successCount} ✓ success, ${failedCount} ✗ failed):`);
+  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 isSuccess = entry.outcome === 'SUCCESS';
+    const statusColor = isSuccess ? '\x1b[32m' : '\x1b[31m';
+    const statusIcon = isSuccess ? '✓' : '✗';
+    const tagsStr = entry.tags?.length ? `\x1b[36m[${entry.tags.join(', ')}]\x1b[0m` : '';
+    const idStr = `\x1b[90m(${shortId(entry.id)})\x1b[0m`;
+    
+    console.log(`   \x1b[90m${shortDate}\x1b[0m ${statusColor}${statusIcon}\x1b[0m ${entry.problem}`);
+    console.log(`              → ${entry.solution} ${tagsStr} ${idStr}`);
+    if (entry.reason) {
+      console.log(`              \x1b[90m(${entry.reason})\x1b[0m`);
+    }
+  }
+
+  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 listLearningsLegacy(
+  learningsPath: string,
+  limit: number,
+  status?: LearningStatus,
+  tag?: string
+): Promise<void> {
+  const content = fs.readFileSync(learningsPath, 'utf-8');
+  let entries = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
+
+  // Filter by status if specified
+  if (status) {
+    entries = entries.filter(entry => entry.includes(`[${status}]`) || entry.includes(`${status}]`));
+  }
+
+  // Filter by tag if specified
+  if (tag) {
+    entries = entries.filter(entry => entry.toLowerCase().includes(`[${tag.toLowerCase()}`));
+  }
+
+  if (entries.length === 0) {
+    info('No learnings found');
+    console.log('');
+    console.log('Add learnings with: memorylink learn "problem" "solution" --status SUCCESS');
+    return;
+  }
+
+  // Count successes and failures
+  const successCount = entries.filter(e => e.includes('SUCCESS')).length;
+  const failedCount = entries.filter(e => e.includes('FAILED')).length;
+
+  // Get last N entries
+  const displayEntries = entries.slice(-limit);
+
+  console.log('');
+  info(`Learnings (${successCount} ✓ success, ${failedCount} ✗ failed):`);
+  console.log('');
+
+  for (const entry of displayEntries) {
+    // Parse legacy entry
+    const match = entry.match(/\[(.*?)\]\s*\[(.*?)\]\s*(.+?)\s*->\s*(.+?)(\s*\[.*\])?$/);
+    if (match) {
+      const [, timestamp, statusPart, problem, solution, tags] = match;
+      const date = new Date(timestamp);
+      const shortDate = date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+      
+      const isSuccess = statusPart.includes('SUCCESS');
+      const statusColor = isSuccess ? '\x1b[32m' : '\x1b[31m';
+      const statusIcon = isSuccess ? '✓' : '✗';
+      
+      console.log(`   \x1b[90m${shortDate}\x1b[0m ${statusColor}${statusIcon}\x1b[0m ${problem}`);
+      console.log(`              → ${solution}\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 clearLearningsCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  log('Clearing learnings log', verbose);
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const learningsPath = getFilePath('LEARNINGS', root);
+  
+  // Clear to empty file (JSONL format - no header needed)
+  try {
+    fs.writeFileSync(learningsPath, '');
+    success('Learnings log cleared');
+  } catch (err) {
+    error(`Failed to clear learnings: ${err instanceof Error ? err.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}

package/src/commands/lock.ts

@@ -0,0 +1,345 @@
+/**
+ * MemoryLink - Lock Command (v1.5)
+ * Agent locking to prevent multi-agent conflicts
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  findRoot,
+  isInitialized,
+  getFilePath,
+  success,
+  error,
+  warn,
+  info,
+  log,
+  getTimestamp,
+  readConfig,
+} from '../utils.js';
+import { MEMORYLINK_DIR } from '../types.js';
+import type { GlobalOptions } from '../types.js';
+
+export interface LockOptions extends GlobalOptions {
+  agent?: string;
+  files?: string;
+  timeout?: number;  // Timeout in minutes (default: 30)
+}
+
+interface LockData {
+  agentId: string;
+  files?: string[];
+  timestamp: string;
+  expiresAt: string;
+  branch?: string;
+  commit?: string;
+}
+
+const DEFAULT_TIMEOUT_MINUTES = 30;
+
+/**
+ * Acquire a lock
+ */
+export async function lockAcquireCommand(
+  options: LockOptions = {}
+): Promise<void> {
+  // TODO v1.6: Record telemetry event (command start)
+  // import { recordEvent, checkIsGitRepo, checkHasConfig, getErrorKind } from '../telemetry.js';
+  // await recordEvent({
+  //   command: 'lock',
+  //   result: 'success', // Will be updated to 'error' if command fails
+  //   flags: { acquire: true, timeout: options.timeout },
+  //   isGitRepo: checkIsGitRepo(),
+  //   hasConfig: checkHasConfig(),
+  // });
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    // TODO v1.6: Record telemetry event (command error)
+    // await recordEvent({
+    //   command: 'lock',
+    //   result: 'error',
+    //   exitCode: 1,
+    //   errorKind: 'NOT_INITIALIZED',
+    //   isGitRepo: checkIsGitRepo(),
+    //   hasConfig: checkHasConfig(),
+    // });
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Get timeout from config or use default (v1.5 Phase 2 enhancement)
+  const config = readConfig(root);
+  const configTimeout = config?.lockTimeoutMinutes;
+  const defaultTimeout = configTimeout || DEFAULT_TIMEOUT_MINUTES;
+
+  const { verbose, agent, files, timeout = defaultTimeout } = options;
+
+  log('Acquiring lock', verbose);
+
+  const lockPath = path.join(root, MEMORYLINK_DIR, '.lock');
+
+  // Check for existing lock
+  if (fs.existsSync(lockPath)) {
+    try {
+      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8')) as LockData;
+      const expiresAt = new Date(lockData.expiresAt);
+      const now = new Date();
+
+      if (now < expiresAt) {
+        // Lock is still valid
+        error(`Lock already held by agent: ${lockData.agentId}`);
+        info(`  Expires at: ${expiresAt.toLocaleString()}`);
+        if (lockData.files && lockData.files.length > 0) {
+          info(`  Files: ${lockData.files.join(', ')}`);
+        }
+        process.exit(1);
+      } else {
+        // Lock expired, remove it
+        warn('Existing lock expired, removing...');
+        fs.unlinkSync(lockPath);
+      }
+    } catch {
+      // Invalid lock file, remove it
+      warn('Invalid lock file, removing...');
+      fs.unlinkSync(lockPath);
+    }
+  }
+
+  // Generate agent ID if not provided
+  const agentId = agent || `agent-${Date.now()}`;
+
+  // Parse files if provided
+  const fileList = files ? files.split(',').map(f => f.trim()) : undefined;
+
+  // 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 lock
+  const now = new Date();
+  const expiresAt = new Date(now.getTime() + timeout * 60 * 1000);
+
+  const lockData: LockData = {
+    agentId,
+    files: fileList,
+    timestamp: getTimestamp(),
+    expiresAt: expiresAt.toISOString(),
+    branch,
+    commit,
+  };
+
+  fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2));
+
+  success(`Lock acquired by: ${agentId}`);
+  info(`  Expires at: ${expiresAt.toLocaleString()}`);
+  if (fileList && fileList.length > 0) {
+    info(`  Files: ${fileList.join(', ')}`);
+  }
+  if (branch) {
+    info(`  Branch: ${branch}`);
+  }
+}
+
+/**
+ * Release a lock
+ */
+export async function lockReleaseCommand(
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log('Releasing lock', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const lockPath = path.join(root, MEMORYLINK_DIR, '.lock');
+
+  if (!fs.existsSync(lockPath)) {
+    warn('No lock found');
+    return;
+  }
+
+  fs.unlinkSync(lockPath);
+  success('Lock released');
+}
+
+/**
+ * Show lock status
+ */
+export async function lockStatusCommand(
+  options: GlobalOptions = {}
+): Promise<void> {
+  const { verbose } = options;
+
+  log('Checking lock status', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const lockPath = path.join(root, MEMORYLINK_DIR, '.lock');
+
+  if (!fs.existsSync(lockPath)) {
+    info('No lock active');
+    return;
+  }
+
+  try {
+    const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8')) as LockData;
+    const expiresAt = new Date(lockData.expiresAt);
+    const now = new Date();
+    const isExpired = now >= expiresAt;
+
+    console.log('');
+    console.log('\x1b[1m🔒 Lock Status\x1b[0m');
+    console.log('');
+
+    if (isExpired) {
+      warn('Lock expired (but not released)');
+      console.log(`  Expired at: ${expiresAt.toLocaleString()}`);
+    } else {
+      const remaining = Math.round((expiresAt.getTime() - now.getTime()) / 1000 / 60);
+      success('Lock active');
+      console.log(`  Agent: ${lockData.agentId}`);
+      console.log(`  Expires in: ${remaining} minutes`);
+      console.log(`  Expires at: ${expiresAt.toLocaleString()}`);
+    }
+
+    if (lockData.files && lockData.files.length > 0) {
+      console.log(`  Files: ${lockData.files.join(', ')}`);
+    }
+    if (lockData.branch) {
+      console.log(`  Branch: ${lockData.branch}`);
+    }
+    if (lockData.commit) {
+      console.log(`  Commit: ${lockData.commit.substring(0, 8)}`);
+    }
+
+    console.log('');
+  } catch (err) {
+    error(`Invalid lock file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Renew a lock (extend timeout)
+ */
+export async function lockRenewCommand(
+  options: LockOptions = {}
+): Promise<void> {
+  const { verbose, timeout = DEFAULT_TIMEOUT_MINUTES } = options;
+
+  log('Renewing lock', verbose);
+
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    error('MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  const lockPath = path.join(root, MEMORYLINK_DIR, '.lock');
+
+  if (!fs.existsSync(lockPath)) {
+    error('No lock found to renew');
+    process.exit(1);
+  }
+
+  // Load existing lock
+  let lockData: LockData;
+  try {
+    lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8')) as LockData;
+    const expiresAt = new Date(lockData.expiresAt);
+    const now = new Date();
+
+    if (now >= expiresAt) {
+      error('Lock has expired. Acquire a new lock instead.');
+      process.exit(1);
+    }
+  } catch (err) {
+    error(`Invalid lock file: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+
+  // Extend expiry time
+  const now = new Date();
+  const newExpiresAt = new Date(now.getTime() + timeout * 60 * 1000);
+
+  lockData.expiresAt = newExpiresAt.toISOString();
+  lockData.timestamp = getTimestamp();
+
+  fs.writeFileSync(lockPath, JSON.stringify(lockData, null, 2));
+
+  // Log renewal to observability
+  try {
+    const { logBuddyCheckRun } = await import('../utils/observability.js');
+    logBuddyCheckRun({
+      status: 'GREEN',
+      summary: `Lock renewed by ${lockData.agentId}`,
+      issues: [],
+      timestamp: new Date().toISOString(),
+      runType: 'preflight',
+      agentId: lockData.agentId,
+    }, root);
+  } catch {
+    // Observability logging is optional
+  }
+
+  success(`Lock renewed by: ${lockData.agentId}`);
+  info(`  New expiry: ${newExpiresAt.toLocaleString()}`);
+  info(`  Extended by: ${timeout} minutes`);
+}
+
+/**
+ * Check if lock exists and is valid (for preflight integration)
+ */
+export function checkLock(root: string): { locked: boolean; agentId?: string; expiresAt?: Date } {
+  const lockPath = path.join(root, MEMORYLINK_DIR, '.lock');
+
+  if (!fs.existsSync(lockPath)) {
+    return { locked: false };
+  }
+
+  try {
+    const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf-8')) as LockData;
+    const expiresAt = new Date(lockData.expiresAt);
+    const now = new Date();
+
+    if (now >= expiresAt) {
+      // Expired, remove it
+      fs.unlinkSync(lockPath);
+      return { locked: false };
+    }
+
+    return {
+      locked: true,
+      agentId: lockData.agentId,
+      expiresAt,
+    };
+  } catch {
+    // Invalid lock file, remove it
+    fs.unlinkSync(lockPath);
+    return { locked: false };
+  }
+}
+