@our2ndbrain/cli 1.1.3

package/src/lib/diff.js

@@ -0,0 +1,222 @@
+/**
+ * 2ndBrain CLI - Diff Operations
+ *
+ * Provides file comparison and diff generation utilities.
+ */
+
+const fs = require('fs-extra');
+const { diffLines, diffWords } = require('diff');
+
+/**
+ * Binary file extensions that should be detected and skipped
+ */
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp',
+  '.pdf', '.zip', '.tar', '.gz', '.rar', '.7z',
+  '.mp3', '.mp4', '.avi', '.mov', '.wav',
+  '.ttf', '.otf', '.woff', '.woff2', '.eot',
+  '.psd', '.ai', '.sketch',
+]);
+
+/**
+ * Large file threshold in bytes (100KB)
+ */
+const LARGE_FILE_THRESHOLD = 100 * 1024;
+
+/**
+ * Check if a file is likely binary based on its extension
+ * @param {string} filePath - File path
+ * @returns {boolean} True if file is likely binary
+ */
+function isBinaryFile(filePath) {
+  const ext = filePath.toLowerCase().split('.').pop();
+  return BINARY_EXTENSIONS.has(`.${ext}`);
+}
+
+/**
+ * Check if a file is too large for diff display
+ * @param {string} filePath - File path
+ * @returns {Promise<boolean>} True if file exceeds threshold
+ */
+async function isLargeFile(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.size > LARGE_FILE_THRESHOLD;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compare two file contents for equality
+ * @param {string} content1 - First content
+ * @param {string} content2 - Second content
+ * @returns {boolean} True if contents are equal
+ */
+function areContentsEqual(content1, content2) {
+  if (content1 === content2) return true;
+
+  // Normalize line endings for comparison
+  const normalize = (str) => str.replace(/\r\n/g, '\n');
+  return normalize(content1) === normalize(content2);
+}
+
+/**
+ * Read file content safely
+ * @param {string} filePath - File path
+ * @returns {Promise<string|null>} File content or null if error
+ */
+async function readFileContent(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Compare source and destination files
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @returns {Promise<{equal: boolean, error?: string, binary?: boolean, large?: boolean}>}
+ */
+async function compareFiles(src, dest) {
+  // Check for binary file
+  if (isBinaryFile(src) || isBinaryFile(dest)) {
+    return { equal: false, binary: true };
+  }
+
+  // Check for large file
+  if (await isLargeFile(src) || await isLargeFile(dest)) {
+    return { equal: false, large: true };
+  }
+
+  try {
+    const [srcContent, destContent] = await Promise.all([
+      readFileContent(src),
+      readFileContent(dest),
+    ]);
+
+    // If destination doesn't exist, files are not equal
+    if (destContent === null) {
+      return { equal: false };
+    }
+
+    // If source doesn't exist, that's an error
+    if (srcContent === null) {
+      return { equal: false, error: 'source file not found' };
+    }
+
+    return { equal: areContentsEqual(srcContent, destContent) };
+  } catch (err) {
+    return { equal: false, error: err.message };
+  }
+}
+
+/**
+ * Generate a unified diff between two contents
+ * @param {string} oldContent - Old content
+ * @param {string} newContent - New content
+ * @param {string} oldPath - Old file path (for display)
+ * @param {string} newPath - New file path (for display)
+ * @returns {string} Unified diff string
+ */
+function generateDiff(oldContent, newContent, oldPath = 'old', newPath = 'new') {
+  const changes = diffLines(oldContent, newContent);
+
+  if (changes.length === 0) {
+    return 'No differences found.';
+  }
+
+  let diffText = '';
+  let oldLineNum = 1;
+  let newLineNum = 1;
+
+  // Count changes
+  const addedLines = changes.filter(c => c.added).reduce((sum, c) => sum + c.count, 0);
+  const removedLines = changes.filter(c => c.removed).reduce((sum, c) => sum + c.count, 0);
+
+  diffText += `--- ${oldPath}\n`;
+  diffText += `+++ ${newPath}\n`;
+  diffText += `@@ -1 +${addedLines > 0 || removedLines === 0 ? '' : ''},${removedLines > 0 ? '?' : '1'} `;
+  diffText += `+1 ${removedLines > 0 || addedLines === 0 ? '' : ''},${addedLines > 0 ? '?' : '1'} @@\n`;
+
+  for (const change of changes) {
+    const lines = change.value.split('\n');
+    // Remove trailing empty line from split
+    if (lines[lines.length - 1] === '') {
+      lines.pop();
+    }
+
+    for (const line of lines) {
+      if (change.added) {
+        diffText += `+${line}\n`;
+        newLineNum++;
+      } else if (change.removed) {
+        diffText += `-${line}\n`;
+        oldLineNum++;
+      } else {
+        diffText += ` ${line}\n`;
+        oldLineNum++;
+        newLineNum++;
+      }
+    }
+  }
+
+  return diffText;
+}
+
+/**
+ * Format diff text with colors for terminal display
+ * @param {string} diffText - Raw diff text
+ * @param {Object} chalk - Chalk module for colors
+ * @returns {string} Formatted diff with ANSI colors
+ */
+function formatDiffForTerminal(diffText, chalk) {
+  const lines = diffText.split('\n');
+  const formatted = lines.map(line => {
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      return chalk.green(line);
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      return chalk.red(line);
+    } else if (line.startsWith('@@')) {
+      return chalk.cyan(line);
+    } else if (line.startsWith('---')) {
+      return chalk.yellow(line);
+    } else if (line.startsWith('+++')) {
+      return chalk.yellow(line);
+    }
+    return line;
+  });
+
+  return formatted.join('\n');
+}
+
+/**
+ * Generate a summary of changes between two contents
+ * @param {string} oldContent - Old content
+ * @param {string} newContent - New content
+ * @returns {{added: number, removed: number, changed: boolean}}
+ */
+function summarizeChanges(oldContent, newContent) {
+  const changes = diffLines(oldContent, newContent);
+  const added = changes.filter(c => c.added).reduce((sum, c) => sum + c.count, 0);
+  const removed = changes.filter(c => c.removed).reduce((sum, c) => sum + c.count, 0);
+
+  return {
+    added,
+    removed,
+    changed: added > 0 || removed > 0,
+  };
+}
+
+module.exports = {
+  areContentsEqual,
+  compareFiles,
+  generateDiff,
+  formatDiffForTerminal,
+  summarizeChanges,
+  isBinaryFile,
+  isLargeFile,
+  LARGE_FILE_THRESHOLD,
+};

package/src/lib/files.js

@@ -0,0 +1,340 @@
+/**
+ * 2ndBrain CLI - File Operations
+ *
+ * Provides file copy, remove, and directory operations.
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { compareFiles, summarizeChanges, isBinaryFile, isLargeFile } = require('./diff');
+
+/**
+ * Copy a file from source to destination
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @returns {Promise<void>}
+ */
+async function copyFile(src, dest) {
+  await fs.ensureDir(path.dirname(dest));
+  await fs.copy(src, dest);
+}
+
+/**
+ * Copy multiple files from template to target
+ * @param {string[]} files - Array of relative file paths
+ * @param {string} templateRoot - Template root directory
+ * @param {string} targetRoot - Target root directory
+ * @param {Function} [onFile] - Callback for each file (relativePath, action)
+ * @returns {Promise<{copied: string[], skipped: string[], errors: string[]}>}
+ */
+async function copyFiles(files, templateRoot, targetRoot, onFile) {
+  const result = { copied: [], skipped: [], errors: [] };
+
+  for (const file of files) {
+    const src = path.join(templateRoot, file);
+    const dest = path.join(targetRoot, file);
+
+    try {
+      // Check if source exists
+      if (!await fs.pathExists(src)) {
+        result.skipped.push(file);
+        if (onFile) onFile(file, 'skip', 'source not found');
+        continue;
+      }
+
+      await copyFile(src, dest);
+      result.copied.push(file);
+      if (onFile) onFile(file, 'copy');
+    } catch (err) {
+      result.errors.push(`${file}: ${err.message}`);
+      if (onFile) onFile(file, 'error', err.message);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Remove a file if it exists
+ * @param {string} filePath - File path to remove
+ * @returns {Promise<boolean>} True if removed, false if not found
+ */
+async function removeFile(filePath) {
+  if (await fs.pathExists(filePath)) {
+    await fs.remove(filePath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Remove multiple files from target directory
+ * @param {string[]} files - Array of relative file paths
+ * @param {string} targetRoot - Target root directory
+ * @param {Function} [onFile] - Callback for each file (relativePath, action)
+ * @returns {Promise<{removed: string[], skipped: string[], errors: string[]}>}
+ */
+async function removeFiles(files, targetRoot, onFile) {
+  const result = { removed: [], skipped: [], errors: [] };
+
+  for (const file of files) {
+    const filePath = path.join(targetRoot, file);
+
+    try {
+      if (await removeFile(filePath)) {
+        result.removed.push(file);
+        if (onFile) onFile(file, 'remove');
+      } else {
+        result.skipped.push(file);
+        if (onFile) onFile(file, 'skip', 'not found');
+      }
+    } catch (err) {
+      result.errors.push(`${file}: ${err.message}`);
+      if (onFile) onFile(file, 'error', err.message);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Ensure directories exist
+ * @param {string[]} dirs - Array of relative directory paths
+ * @param {string} targetRoot - Target root directory
+ * @returns {Promise<void>}
+ */
+async function ensureDirs(dirs, targetRoot) {
+  for (const dir of dirs) {
+    await fs.ensureDir(path.join(targetRoot, dir));
+  }
+}
+
+/**
+ * Remove empty directories (bottom-up)
+ * @param {string[]} dirs - Array of relative directory paths
+ * @param {string} targetRoot - Target root directory
+ * @param {Function} [onDir] - Callback for each directory (relativePath, action)
+ * @returns {Promise<string[]>} Array of removed directories
+ */
+async function removeEmptyDirs(dirs, targetRoot, onDir) {
+  const removed = [];
+
+  // Sort by depth (deepest first)
+  const sortedDirs = [...dirs].sort((a, b) => {
+    return b.split('/').length - a.split('/').length;
+  });
+
+  for (const dir of sortedDirs) {
+    const dirPath = path.join(targetRoot, dir);
+
+    try {
+      if (await fs.pathExists(dirPath)) {
+        const contents = await fs.readdir(dirPath);
+        if (contents.length === 0) {
+          await fs.remove(dirPath);
+          removed.push(dir);
+          if (onDir) onDir(dir, 'remove');
+        } else {
+          if (onDir) onDir(dir, 'skip', 'not empty');
+        }
+      }
+    } catch (err) {
+      // Ignore errors for directory removal
+    }
+  }
+
+  // Also try to remove parent directories if empty
+  const parentDirs = new Set();
+  for (const dir of removed) {
+    const parent = path.dirname(dir);
+    if (parent !== '.') {
+      parentDirs.add(parent);
+    }
+  }
+
+  for (const parent of parentDirs) {
+    const parentPath = path.join(targetRoot, parent);
+    try {
+      if (await fs.pathExists(parentPath)) {
+        const contents = await fs.readdir(parentPath);
+        if (contents.length === 0) {
+          await fs.remove(parentPath);
+          removed.push(parent);
+          if (onDir) onDir(parent, 'remove');
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  return removed;
+}
+
+/**
+ * Create a file with content
+ * @param {string} filePath - File path
+ * @param {string} content - File content
+ * @returns {Promise<void>}
+ */
+async function createFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf8');
+}
+
+/**
+ * Check if directory is empty or doesn't exist
+ * @param {string} dirPath - Directory path
+ * @returns {Promise<boolean>}
+ */
+async function isDirEmpty(dirPath) {
+  if (!await fs.pathExists(dirPath)) {
+    return true;
+  }
+  const contents = await fs.readdir(dirPath);
+  return contents.length === 0;
+}
+
+/**
+ * Compare source and destination files
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @returns {Promise<{equal: boolean, exists: boolean, error?: string, binary?: boolean, large?: boolean}>}
+ */
+async function compareFilesWrapper(src, dest) {
+  const destExists = await fs.pathExists(dest);
+
+  if (!destExists) {
+    return { equal: false, exists: false };
+  }
+
+  const result = await compareFiles(src, dest);
+  return { ...result, exists: true };
+}
+
+/**
+ * Copy a single file with comparison
+ * @param {string} src - Source file path
+ * @param {string} dest - Destination file path
+ * @param {Object} options - Copy options
+ * @param {boolean} [options.force] - Force copy even if equal
+ * @returns {Promise<{copied: boolean, unchanged: boolean, error?: string, change?: any}>}
+ */
+async function copyFileWithCompare(src, dest, options = {}) {
+  try {
+    // Check if source exists
+    if (!await fs.pathExists(src)) {
+      return { copied: false, unchanged: false, error: 'source not found' };
+    }
+
+    // Compare files if destination exists
+    const comparison = await compareFilesWrapper(src, dest);
+
+    if (comparison.exists && comparison.equal && !options.force) {
+      return { copied: false, unchanged: true };
+    }
+
+    // Perform the copy
+    await fs.ensureDir(path.dirname(dest));
+    await fs.copy(src, dest);
+
+    // Generate change summary
+    let change = null;
+    if (!comparison.equal) {
+      if (comparison.binary) {
+        change = { binary: true };
+      } else if (comparison.large) {
+        change = { large: true };
+      } else {
+        try {
+          const [srcContent, destContent] = await Promise.all([
+            fs.readFile(src, 'utf8'),
+            comparison.exists ? fs.readFile(dest, 'utf8') : '',
+          ]);
+          const summary = summarizeChanges(destContent, srcContent);
+          change = { added: summary.added, removed: summary.removed };
+        } catch {
+          // If we can't read as text, mark as binary
+          change = { binary: true };
+        }
+      }
+    }
+
+    return { copied: true, unchanged: false, change };
+  } catch (err) {
+    return { copied: false, unchanged: false, error: err.message };
+  }
+}
+
+/**
+ * Copy multiple files with smart comparison
+ * @param {string[]} files - Array of relative file paths
+ * @param {string} templateRoot - Template root directory
+ * @param {string} targetRoot - Target root directory
+ * @param {Object} options - Copy options
+ * @param {boolean} [options.force] - Force copy even if equal
+ * @param {boolean} [options.dryRun] - Dry run mode
+ * @param {Function} [onFile] - Callback for each file (relativePath, action, detail)
+ * @returns {Promise<{copied: string[], skipped: string[], unchanged: string[], errors: string[], changes: Array}>}
+ */
+async function copyFilesSmart(files, templateRoot, targetRoot, options = {}, onFile) {
+  const result = {
+    copied: [],
+    skipped: [],
+    unchanged: [],
+    errors: [],
+    changes: [],
+  };
+
+  for (const file of files) {
+    const src = path.join(templateRoot, file);
+    const dest = path.join(targetRoot, file);
+
+    try {
+      const fileResult = await copyFileWithCompare(src, dest, options);
+
+      if (fileResult.error) {
+        result.errors.push(`${file}: ${fileResult.error}`);
+        if (onFile) onFile(file, 'error', fileResult.error);
+        continue;
+      }
+
+      if (fileResult.unchanged) {
+        result.unchanged.push(file);
+        if (onFile) onFile(file, 'unchanged');
+        continue;
+      }
+
+      if (options.dryRun) {
+        result.skipped.push(file);
+        if (onFile) onFile(file, 'dryrun', fileResult.change);
+        continue;
+      }
+
+      result.copied.push(file);
+      if (fileResult.change) {
+        result.changes.push({ file, ...fileResult.change });
+      }
+      if (onFile) onFile(file, 'copy', fileResult.change);
+    } catch (err) {
+      result.errors.push(`${file}: ${err.message}`);
+      if (onFile) onFile(file, 'error', err.message);
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  copyFile,
+  copyFiles,
+  removeFile,
+  removeFiles,
+  ensureDirs,
+  removeEmptyDirs,
+  createFile,
+  isDirEmpty,
+  compareFilesWrapper,
+  copyFileWithCompare,
+  copyFilesSmart,
+};