memorylink 1.0.0

package/src/commands/auto-log.ts

@@ -0,0 +1,531 @@
+/**
+ * MemoryLink - Auto-Logging Command
+ * Automatically log file changes to changes.log via Git hooks
+ * 
+ * Reduces manual logging friction - ensures all changes are tracked automatically
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import {
+  isInitialized,
+  findRoot,
+  getFilePath,
+  getTimestamp,
+  generateId,
+  appendJsonlEntry,
+  readJsonlEntries,
+  checkSecretsBeforeWrite,
+  normalizePathForStorage,
+} from '../utils.js';
+import { isFileProtected } from './protect.js';
+import { detectCommitPattern, formatSuggestion } from '../utils/commit-patterns.js';
+import type { GlobalOptions, ChangeEntry } from '../types.js';
+
+interface AutoLogOptions extends GlobalOptions {
+  commit?: string;
+  message?: string;
+  files?: string;
+}
+
+const POST_COMMIT_HOOK = `#!/bin/sh
+# MemoryLink Auto-Logging Hook
+# Automatically logs changes to changes.log after each commit
+
+# Find the project root
+ROOT=$(git rev-parse --show-toplevel)
+MEMORYLINK_DIR="$ROOT/.memorylink"
+
+# Check if MemoryLink is initialized
+if [ ! -d "$MEMORYLINK_DIR" ]; then
+  exit 0
+fi
+
+# Get commit info
+COMMIT_HASH=$(git rev-parse HEAD)
+COMMIT_MSG=$(git log -1 --pretty=%B)
+
+# Get changed files (handle root commit)
+CHANGED_FILES=""
+if git rev-parse HEAD^ >/dev/null 2>&1; then
+  # Not a root commit - compare to parent
+  CHANGED_FILES=$(git diff-tree --no-commit-id --name-only -r HEAD^ HEAD)
+else
+  # Root commit - get all files in commit
+  CHANGED_FILES=$(git ls-tree -r --name-only HEAD)
+fi
+
+# Run memorylink auto-log (if available)
+# Try multiple paths to find memorylink
+MEMORYLINK_CMD=""
+if command -v memorylink >/dev/null 2>&1; then
+  MEMORYLINK_CMD="memorylink"
+elif [ -f "$ROOT/node_modules/.bin/memorylink" ]; then
+  MEMORYLINK_CMD="$ROOT/node_modules/.bin/memorylink"
+elif [ -f "$ROOT/../node_modules/.bin/memorylink" ]; then
+  MEMORYLINK_CMD="$ROOT/../node_modules/.bin/memorylink"
+elif [ -f "$ROOT/dist/cli.js" ]; then
+  # Use node to run the built CLI directly
+  cd "$ROOT"
+  node dist/cli.js auto-log commit "$COMMIT_HASH" "$COMMIT_MSG" "$CHANGED_FILES" 2>/dev/null || true
+  exit 0
+fi
+
+if [ -n "$MEMORYLINK_CMD" ]; then
+  cd "$ROOT"
+  "$MEMORYLINK_CMD" auto-log commit "$COMMIT_HASH" "$COMMIT_MSG" "$CHANGED_FILES" 2>/dev/null || true
+fi
+
+# Auto-update code structure map if source files changed (v1.2)
+if echo "$CHANGED_FILES" | grep -qE "\.(js|ts|jsx|tsx)$"; then
+  if [ -n "$MEMORYLINK_CMD" ]; then
+    cd "$ROOT"
+    "$MEMORYLINK_CMD" graph build --silent 2>/dev/null || true
+  elif [ -f "$ROOT/dist/cli.js" ]; then
+    cd "$ROOT"
+    node dist/cli.js graph build --silent 2>/dev/null || true
+  fi
+fi
+
+exit 0
+`;
+
+/**
+ * Check if post-commit hook is installed
+ */
+function checkHookInstalled(root: string): boolean {
+  const gitDir = path.join(root, '.git');
+  const hooksDir = path.join(gitDir, 'hooks');
+  const postCommitPath = path.join(hooksDir, 'post-commit');
+
+  if (!fs.existsSync(postCommitPath)) {
+    return false;
+  }
+
+  const content = fs.readFileSync(postCommitPath, 'utf-8');
+  return content.includes('MemoryLink Auto-Logging Hook');
+}
+
+/**
+ * Install post-commit hook
+ */
+function installHook(root: string, verbose: boolean = false): void {
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    throw new Error('Git is not initialized. Run: git init');
+  }
+
+  const hooksDir = path.join(gitDir, 'hooks');
+  const postCommitPath = path.join(hooksDir, 'post-commit');
+
+  // Ensure hooks directory exists
+  if (!fs.existsSync(hooksDir)) {
+    fs.mkdirSync(hooksDir, { recursive: true });
+  }
+
+  // Check for existing hook
+  if (fs.existsSync(postCommitPath)) {
+    const existingContent = fs.readFileSync(postCommitPath, 'utf-8');
+    
+    if (existingContent.includes('MemoryLink Auto-Logging Hook')) {
+      if (verbose) {
+        console.log('MemoryLink auto-logging hook is already installed');
+      }
+      return;
+    }
+
+    // Append to existing hook
+    const updatedContent = existingContent + '\n\n' + POST_COMMIT_HOOK.replace('#!/bin/sh\n', '');
+    fs.writeFileSync(postCommitPath, updatedContent);
+    fs.chmodSync(postCommitPath, '755');
+    
+    if (verbose) {
+      console.log('MemoryLink auto-logging hook added to existing post-commit hook');
+    }
+  } else {
+    // Create new hook
+    fs.writeFileSync(postCommitPath, POST_COMMIT_HOOK);
+    fs.chmodSync(postCommitPath, '755');
+    
+    if (verbose) {
+      console.log('Git post-commit hook installed');
+    }
+  }
+}
+
+/**
+ * Uninstall post-commit hook
+ */
+function uninstallHook(root: string, verbose: boolean = false): void {
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    throw new Error('Git is not initialized');
+  }
+
+  const postCommitPath = path.join(gitDir, 'hooks', 'post-commit');
+
+  if (!fs.existsSync(postCommitPath)) {
+    if (verbose) {
+      console.log('No post-commit hook found');
+    }
+    return;
+  }
+
+  const content = fs.readFileSync(postCommitPath, 'utf-8');
+
+  if (!content.includes('MemoryLink Auto-Logging Hook')) {
+    if (verbose) {
+      console.log('MemoryLink auto-logging hook is not installed');
+    }
+    return;
+  }
+
+  // Remove MemoryLink section
+  const lines = content.split('\n');
+  const newLines: string[] = [];
+  let inMemoryLinkSection = false;
+
+  for (const line of lines) {
+    if (line.includes('MemoryLink Auto-Logging Hook')) {
+      inMemoryLinkSection = true;
+      continue;
+    }
+    if (inMemoryLinkSection && line === 'exit 0' && lines[lines.indexOf(line) - 1]?.trim() === '') {
+      inMemoryLinkSection = false;
+      continue;
+    }
+    if (!inMemoryLinkSection) {
+      newLines.push(line);
+    }
+  }
+
+  const newContent = newLines.join('\n').trim();
+
+  if (newContent === '' || newContent === '#!/bin/sh') {
+    // Remove the hook file entirely
+    fs.unlinkSync(postCommitPath);
+    if (verbose) {
+      console.log('Git post-commit hook removed');
+    }
+  } else {
+    fs.writeFileSync(postCommitPath, newContent);
+    if (verbose) {
+      console.log('MemoryLink hook removed from post-commit');
+    }
+  }
+}
+
+/**
+ * Process commit and log changes
+ */
+async function processCommit(
+  root: string,
+  commitHash: string,
+  commitMessage: string,
+  changedFiles: string,
+  verbose: boolean = false
+): Promise<void> {
+  if (!isInitialized(root)) {
+    if (verbose) {
+      console.log('MemoryLink not initialized, skipping auto-log');
+    }
+    return;
+  }
+
+  // Parse changed files
+  let files: string[] = [];
+  
+  if (changedFiles && changedFiles.trim().length > 0) {
+    files = changedFiles.trim().split('\n').filter(f => f.trim().length > 0);
+  } else {
+    // If no files provided, get them from Git
+    try {
+      const parentCommit = execSync(`git rev-parse HEAD^`, {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+      
+      const diffOutput = execSync(`git diff-tree --no-commit-id --name-only -r ${parentCommit} ${commitHash}`, {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+      
+      files = diffOutput.split('\n').filter(f => f.trim().length > 0);
+    } catch {
+      // Root commit or no parent - get all files in commit
+      try {
+        const treeFiles = execSync(`git ls-tree -r --name-only ${commitHash}`, {
+          cwd: root,
+          stdio: 'pipe',
+          encoding: 'utf-8'
+        }).trim();
+        
+        files = treeFiles.split('\n').filter(f => f.trim().length > 0);
+      } catch (err) {
+        if (verbose) {
+          console.log(`Could not get changed files: ${err}`);
+        }
+        return;
+      }
+    }
+  }
+  
+  if (files.length === 0) {
+    if (verbose) {
+      console.log('No files changed in commit, skipping auto-log');
+    }
+    return;
+  }
+
+  const changesPath = getFilePath('CHANGES', root);
+
+  // Log each changed file
+  for (const file of files) {
+    // Skip .memorylink/ files themselves (avoid recursion)
+    if (file.startsWith('.memorylink/')) {
+      continue;
+    }
+
+    // Skip protected files (they're already tracked by pre-commit hook)
+    if (isFileProtected(file, root)) {
+      if (verbose) {
+        console.log(`Skipping protected file: ${file}`);
+      }
+      continue;
+    }
+
+    // Determine action (created, edited, deleted)
+    let action: 'created' | 'edited' | 'deleted' = 'edited';
+    try {
+      const status = execSync(`git diff-tree --no-commit-id --name-status -r ${commitHash}`, {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+      
+      const fileStatus = status.split('\n').find(line => line.includes(file));
+      if (fileStatus) {
+        const statusCode = fileStatus.split('\t')[0];
+        if (statusCode === 'A' || statusCode.startsWith('A')) {
+          action = 'created';
+        } else if (statusCode === 'D' || statusCode.startsWith('D')) {
+          action = 'deleted';
+        } else {
+          action = 'edited';
+        }
+      }
+    } catch {
+      // Default to edited if we can't determine
+      action = 'edited';
+    }
+
+    // Normalize file path for storage (forward slashes, Git-compatible)
+    const normalizedFile = normalizePathForStorage(file, root);
+
+    // Create change entry
+    const entry: ChangeEntry = {
+      id: generateId(),
+      ts: getTimestamp(),
+      agent: 'git',
+      file: normalizedFile,
+      action: action,
+      reason: commitMessage || `Auto-logged from commit ${commitHash.substring(0, 8)}`,
+      status: 'ACTIVE',
+    };
+
+    // Check for secrets before writing
+    const reasonWithSecret = commitMessage + ' ' + file;
+    if (!checkSecretsBeforeWrite(reasonWithSecret, false)) {
+      if (verbose) {
+        console.log(`Skipping ${file} - secret detected in commit message`);
+      }
+      continue;
+    }
+
+    // Append to changes.log
+    try {
+      await appendJsonlEntry(changesPath, entry);
+      if (verbose) {
+        console.log(`Logged: ${file} (${action})`);
+      }
+    } catch (err) {
+      // Don't fail the commit if logging fails
+      if (verbose) {
+        console.error(`Failed to log ${file}: ${err}`);
+      }
+    }
+  }
+
+  if (verbose) {
+    console.log(`Auto-logged ${files.length} file(s) from commit ${commitHash.substring(0, 8)}`);
+  }
+
+  // Week 6: Detect commit patterns and suggest logging (v1.3)
+  const pattern = detectCommitPattern(commitMessage);
+  if (pattern) {
+    const suggestionsPath = path.join(root, '.memorylink', 'suggestions.log');
+    const suggestion = formatSuggestion(pattern, commitHash, commitMessage);
+    const suggestionEntry = {
+      timestamp: new Date().toISOString(),
+      commit: commitHash,
+      message: commitMessage,
+      suggestion: suggestion,
+      pattern: pattern.type,
+    };
+    
+    try {
+      // Append suggestion to suggestions.log (JSONL format)
+      const suggestionLine = JSON.stringify(suggestionEntry) + '\n';
+      fs.appendFileSync(suggestionsPath, suggestionLine);
+      
+      if (verbose) {
+        console.log('');
+        console.log(suggestion);
+      }
+    } catch {
+      // Don't fail if suggestions file can't be written
+    }
+  }
+}
+
+
+/**
+ * Install auto-logging hook
+ */
+export async function autoLogInstallCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  // Check initialization
+  const root = findRoot();
+  if (!root || !isInitialized(root)) {
+    console.error('\x1b[31m✗\x1b[0m MemoryLink is not initialized. Run: memorylink init');
+    process.exit(1);
+  }
+
+  // Check if Git is initialized
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    console.error('\x1b[31m✗\x1b[0m Git is not initialized. Run: git init');
+    process.exit(1);
+  }
+
+  try {
+    installHook(root, verbose);
+    console.log('\x1b[32m✓\x1b[0m Auto-logging hook installed');
+    console.log('');
+    console.log('  Changes will now be automatically logged to changes.log after each commit.');
+    console.log('  To test: Make a commit and check changes.log');
+  } catch (err: any) {
+    console.error(`\x1b[31m✗\x1b[0m Failed to install hook: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Uninstall auto-logging hook
+ */
+export async function autoLogUninstallCommand(options: GlobalOptions = {}): Promise<void> {
+  const { verbose } = options;
+
+  const root = findRoot();
+  if (!root) {
+    console.error('\x1b[31m✗\x1b[0m Not in a MemoryLink project');
+    process.exit(1);
+  }
+
+  try {
+    uninstallHook(root, verbose);
+    console.log('\x1b[32m✓\x1b[0m Auto-logging hook uninstalled');
+  } catch (err: any) {
+    console.error(`\x1b[31m✗\x1b[0m Failed to uninstall hook: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Check auto-logging hook status
+ */
+export async function autoLogStatusCommand(options: GlobalOptions = {}): Promise<void> {
+  const root = findRoot();
+  if (!root) {
+    console.log('Not in a MemoryLink project');
+    return;
+  }
+
+  const gitDir = path.join(root, '.git');
+  if (!fs.existsSync(gitDir)) {
+    console.log('Not a Git repository');
+    return;
+  }
+
+  const isInstalled = checkHookInstalled(root);
+  
+  console.log('');
+  console.log('Auto-Logging Hook Status:');
+  console.log('');
+  console.log(`  Status: ${isInstalled ? '\x1b[32mInstalled\x1b[0m' : '\x1b[33mNot installed\x1b[0m'}`);
+  console.log('');
+  
+  if (!isInstalled) {
+    console.log('  Install with: memorylink auto-log install');
+  } else {
+    console.log('  Changes are automatically logged after each commit.');
+    console.log('  Uninstall with: memorylink auto-log uninstall');
+  }
+  console.log('');
+}
+
+/**
+ * Process commit (called from hook)
+ */
+export async function autoLogCommitCommand(options: AutoLogOptions = {}): Promise<void> {
+  const { verbose, commit, message, files } = options;
+
+  if (!commit || !files) {
+    // Called from hook - get commit info from Git
+    const root = findRoot();
+    if (!root) {
+      return; // Silently fail if not in a project
+    }
+
+    try {
+      const commitHash = execSync('git rev-parse HEAD', {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+
+      const commitMessage = execSync('git log -1 --pretty=%B', {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+
+      const changedFiles = execSync('git diff-tree --no-commit-id --name-only -r HEAD', {
+        cwd: root,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+
+      await processCommit(root, commitHash, commitMessage, changedFiles, verbose);
+    } catch (err) {
+      // Silently fail - don't block commits
+      if (verbose) {
+        console.error(`Auto-log failed: ${err}`);
+      }
+    }
+  } else {
+    // Called with explicit parameters
+    const root = findRoot();
+    if (!root) {
+      console.error('\x1b[31m✗\x1b[0m Not in a MemoryLink project');
+      process.exit(1);
+    }
+
+    await processCommit(root, commit, message || '', files, verbose);
+  }
+}
+