@howlil/ez-agents 3.4.1 → 3.5.0

package/ez-agents/bin/lib/fs-utils.cjs

@@ -1,153 +1,153 @@
-#!/usr/bin/env node
-
-/**
- * EZ FS Utils — Cross-platform file system utilities
- * 
- * Replaces Unix commands (find, grep, head, tail) with
- * cross-platform JavaScript implementations.
- * 
- * Usage:
- *   const { findFiles, grepContent, readLines } = require('./fs-utils.cjs');
- *   const files = await findFiles('./src', /\.js$/);
- */
-
-const fs = require('fs');
-const path = require('path');
-const Logger = require('./logger.cjs');
-const logger = new Logger();
-
-/**
- * Find files matching patterns (cross-platform find replacement)
- * @param {string} dir - Directory to search
- * @param {RegExp[]} patterns - File patterns to match
- * @param {Object} options - Search options
- * @returns {string[]} - Array of matching file paths
- */
-function findFiles(dir, patterns, options = {}) {
-  const { maxDepth = 5, exclude = ['node_modules', '.git', '.planning'] } = options;
-  const results = [];
-
-  function recurse(currentDir, depth) {
-    if (depth > maxDepth) return;
-    
-    let entries;
-    try {
-      entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    } catch (err) {
-      logger.warn('Cannot read directory', { dir: currentDir, error: err.message });
-      return;
-    }
-
-    for (const entry of entries) {
-      if (exclude.includes(entry.name)) continue;
-      
-      const fullPath = path.join(currentDir, entry.name);
-      
-      if (entry.isDirectory()) {
-        recurse(fullPath, depth + 1);
-      } else if (patterns.some(p => p.test(entry.name))) {
-        results.push(fullPath);
-      }
-    }
-  }
-
-  recurse(dir, 0);
-  return results;
-}
-
-/**
- * Search file content (cross-platform grep replacement)
- * @param {string} filePath - File to search
- * @param {RegExp} pattern - Pattern to match
- * @returns {Object[]} - Array of { line, lineNumber, match }
- */
-function grepContent(filePath, pattern) {
-  const results = [];
-  
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const lines = content.split('\n');
-    
-    lines.forEach((line, index) => {
-      if (pattern.test(line)) {
-        results.push({
-          line: line.trim(),
-          lineNumber: index + 1,
-          match: line.match(pattern)?.[0]
-        });
-      }
-    });
-  } catch (err) {
-    logger.warn('Cannot read file for grep', { filePath, error: err.message });
-  }
-  
-  return results;
-}
-
-/**
- * Read first N lines (cross-platform head replacement)
- * @param {string} filePath - File to read
- * @param {number} count - Number of lines
- * @returns {string[]} - Array of lines
- */
-function readFirstLines(filePath, count = 10) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return content.split('\n').slice(0, count);
-  } catch (err) {
-    logger.warn('Cannot read file', { filePath, error: err.message });
-    return [];
-  }
-}
-
-/**
- * Read last N lines (cross-platform tail replacement)
- * @param {string} filePath - File to read
- * @param {number} count - Number of lines
- * @returns {string[]} - Array of lines
- */
-function readLastLines(filePath, count = 10) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const lines = content.split('\n');
-    return lines.slice(-count);
-  } catch (err) {
-    logger.warn('Cannot read file', { filePath, error: err.message });
-    return [];
-  }
-}
-
-/**
- * Count lines in file (cross-platform wc -l replacement)
- * @param {string} filePath - File to count
- * @returns {number} - Line count
- */
-function countLines(filePath) {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return content.split('\n').length;
-  } catch (err) {
-    logger.warn('Cannot count lines', { filePath, error: err.message });
-    return 0;
-  }
-}
-
-/**
- * Ensure directory exists
- * @param {string} dirPath - Directory path
- */
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-    logger.debug('Directory created', { dir: dirPath });
-  }
-}
-
-module.exports = {
-  findFiles,
-  grepContent,
-  readFirstLines,
-  readLastLines,
-  countLines,
-  ensureDir
-};
+#!/usr/bin/env node
+
+/**
+ * EZ FS Utils — Cross-platform file system utilities
+ * 
+ * Replaces Unix commands (find, grep, head, tail) with
+ * cross-platform JavaScript implementations.
+ * 
+ * Usage:
+ *   const { findFiles, grepContent, readLines } = require('./fs-utils.cjs');
+ *   const files = await findFiles('./src', /\.js$/);
+ */
+
+const fs = require('fs');
+const path = require('path');
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+/**
+ * Find files matching patterns (cross-platform find replacement)
+ * @param {string} dir - Directory to search
+ * @param {RegExp[]} patterns - File patterns to match
+ * @param {Object} options - Search options
+ * @returns {string[]} - Array of matching file paths
+ */
+function findFiles(dir, patterns, options = {}) {
+  const { maxDepth = 5, exclude = ['node_modules', '.git', '.planning'] } = options;
+  const results = [];
+
+  function recurse(currentDir, depth) {
+    if (depth > maxDepth) return;
+    
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (err) {
+      logger.warn('Cannot read directory', { dir: currentDir, error: err.message });
+      return;
+    }
+
+    for (const entry of entries) {
+      if (exclude.includes(entry.name)) continue;
+      
+      const fullPath = path.join(currentDir, entry.name);
+      
+      if (entry.isDirectory()) {
+        recurse(fullPath, depth + 1);
+      } else if (patterns.some(p => p.test(entry.name))) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  recurse(dir, 0);
+  return results;
+}
+
+/**
+ * Search file content (cross-platform grep replacement)
+ * @param {string} filePath - File to search
+ * @param {RegExp} pattern - Pattern to match
+ * @returns {Object[]} - Array of { line, lineNumber, match }
+ */
+function grepContent(filePath, pattern) {
+  const results = [];
+  
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    
+    lines.forEach((line, index) => {
+      if (pattern.test(line)) {
+        results.push({
+          line: line.trim(),
+          lineNumber: index + 1,
+          match: line.match(pattern)?.[0]
+        });
+      }
+    });
+  } catch (err) {
+    logger.warn('Cannot read file for grep', { filePath, error: err.message });
+  }
+  
+  return results;
+}
+
+/**
+ * Read first N lines (cross-platform head replacement)
+ * @param {string} filePath - File to read
+ * @param {number} count - Number of lines
+ * @returns {string[]} - Array of lines
+ */
+function readFirstLines(filePath, count = 10) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content.split('\n').slice(0, count);
+  } catch (err) {
+    logger.warn('Cannot read file', { filePath, error: err.message });
+    return [];
+  }
+}
+
+/**
+ * Read last N lines (cross-platform tail replacement)
+ * @param {string} filePath - File to read
+ * @param {number} count - Number of lines
+ * @returns {string[]} - Array of lines
+ */
+function readLastLines(filePath, count = 10) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    return lines.slice(-count);
+  } catch (err) {
+    logger.warn('Cannot read file', { filePath, error: err.message });
+    return [];
+  }
+}
+
+/**
+ * Count lines in file (cross-platform wc -l replacement)
+ * @param {string} filePath - File to count
+ * @returns {number} - Line count
+ */
+function countLines(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return content.split('\n').length;
+  } catch (err) {
+    logger.warn('Cannot count lines', { filePath, error: err.message });
+    return 0;
+  }
+}
+
+/**
+ * Ensure directory exists
+ * @param {string} dirPath - Directory path
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+    logger.debug('Directory created', { dir: dirPath });
+  }
+}
+
+module.exports = {
+  findFiles,
+  grepContent,
+  readFirstLines,
+  readLastLines,
+  countLines,
+  ensureDir
+};

package/ez-agents/bin/lib/git-errors.cjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Git Workflow Error Classes
+ *
+ * Provides structured error handling for git operations
+ */
+
+class GitWorkflowError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'GitWorkflowError';
+    this.code = options.code || 'GIT_WORKFLOW_ERROR';
+    this.details = options.details || {};
+    this.timestamp = new Date().toISOString();
+    Error.captureStackTrace(this, GitWorkflowError);
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      timestamp: this.timestamp
+    };
+  }
+}
+
+class BranchExistsError extends GitWorkflowError {
+  constructor(branchName, options = {}) {
+    super(`Branch '${branchName}' already exists`, {
+      code: 'BRANCH_EXISTS',
+      details: { branchName, ...options.details }
+    });
+    this.name = 'BranchExistsError';
+    this.branchName = branchName;
+  }
+}
+
+class BranchNotFoundError extends GitWorkflowError {
+  constructor(branchName, options = {}) {
+    super(`Branch '${branchName}' does not exist`, {
+      code: 'BRANCH_NOT_FOUND',
+      details: { branchName, ...options.details }
+    });
+    this.name = 'BranchNotFoundError';
+    this.branchName = branchName;
+  }
+}
+
+class MergeConflictError extends GitWorkflowError {
+  constructor(sourceBranch, targetBranch, conflictingFiles = [], options = {}) {
+    super(`Merge conflict between '${sourceBranch}' and '${targetBranch}'`, {
+      code: 'MERGE_CONFLICT',
+      details: { sourceBranch, targetBranch, conflictingFiles, ...options.details }
+    });
+    this.name = 'MergeConflictError';
+    this.sourceBranch = sourceBranch;
+    this.targetBranch = targetBranch;
+    this.conflictingFiles = conflictingFiles;
+  }
+}
+
+class ValidationFailedError extends GitWorkflowError {
+  constructor(validationType, failures = [], options = {}) {
+    super(`${validationType} validation failed`, {
+      code: 'VALIDATION_FAILED',
+      details: { validationType, failures, ...options.details }
+    });
+    this.name = 'ValidationFailedError';
+    this.validationType = validationType;
+    this.failures = failures;
+  }
+}
+
+module.exports = {
+  GitWorkflowError,
+  BranchExistsError,
+  BranchNotFoundError,
+  MergeConflictError,
+  ValidationFailedError
+};

package/ez-agents/bin/lib/git-utils.cjs

@@ -20,6 +20,8 @@ const { promisify } = require('util');
 const execFileAsync = promisify(execFile);
 const Logger = require('./logger.cjs');
 const logger = new Logger();
+const { BranchExistsError, BranchNotFoundError } = require('./git-errors.cjs');
+const { MergeConflictError } = require('./git-errors.cjs');
 
 class GitUtils {
   constructor(cwd) {
@@ -137,6 +139,122 @@ class GitUtils {
     return name;
   }
 
+  /**
+   * Check if branch exists
+   */
+  async branchExists(branchName) {
+    try {
+      await this.exec(['rev-parse', '--verify', branchName]);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * List branches matching pattern
+   */
+  async listBranches(pattern = '*') {
+    const { stdout } = await this.exec(['branch', '--list', pattern]);
+    return stdout.split('\n')
+      .map(b => b.trim().replace(/^\*\s*/, '').replace(/^\+\s*/, ''))
+      .filter(b => b);
+  }
+
+  /**
+   * Delete branch
+   */
+  async deleteBranch(branchName, force = false) {
+    const exists = await this.branchExists(branchName);
+    if (!exists) {
+      throw new BranchNotFoundError(branchName);
+    }
+    const args = force ? ['branch', '-D', branchName] : ['branch', '-d', branchName];
+    await this.exec(args);
+    logger.info('Branch deleted', { branch: branchName, force });
+  }
+
+  /**
+   * Get branch point (merge base with HEAD)
+   */
+  async getBranchPoint(branchName) {
+    const { stdout } = await this.exec(['merge-base', 'HEAD', branchName]);
+    return stdout;
+  }
+
+  /**
+   * Check if merge would have conflicts
+   */
+  async hasConflicts(sourceBranch, targetBranch) {
+    try {
+      await this.exec(['merge-tree', targetBranch, sourceBranch]);
+      return false;
+    } catch (err) {
+      if (err.stdout?.includes('conflict')) {
+        return true;
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Merge with strategy (merge, squash, rebase)
+   */
+  async mergeWithStrategy(source, target, strategy = 'merge') {
+    const currentBranch = await this.getCurrentBranch();
+
+    try {
+      await this.checkout(target);
+
+      if (strategy === 'squash') {
+        await this.exec(['merge', '--squash', source]);
+        await this.exec(['commit', '-m', `Merge '${source}' into '${target}'`]);
+      } else if (strategy === 'rebase') {
+        await this.exec(['rebase', source]);
+      } else {
+        await this.exec(['merge', source, '--no-edit']);
+      }
+
+      logger.info('Merge completed', { source, target, strategy });
+      return { success: true, strategy };
+    } catch (err) {
+      if (err.message?.includes('conflict')) {
+        throw new MergeConflictError(source, target);
+      }
+      throw err;
+    } finally {
+      if (currentBranch !== target) {
+        await this.checkout(currentBranch);
+      }
+    }
+  }
+
+  /**
+   * Squash merge with custom commit message
+   */
+  async squashMerge(source, target, commitMessage) {
+    await this.checkout(target);
+    await this.exec(['merge', '--squash', source]);
+    await this.exec(['commit', '-m', commitMessage]);
+    logger.info('Squash merge completed', { source, target, message: commitMessage });
+  }
+
+  /**
+   * Abort merge
+   */
+  async abortMerge() {
+    await this.exec(['merge', '--abort']);
+    logger.info('Merge aborted');
+  }
+
+  /**
+   * Revert commit
+   */
+  async revertCommit(commitHash) {
+    await this.exec(['revert', commitHash, '--no-edit']);
+    logger.info('Commit reverted', { hash: commitHash });
+  }
+
   /**
    * Switch to branch
    */