@howlil/ez-agents 3.5.0 → 4.0.0

package/ez-agents/bin/lib/lockfile-validator.cjs

@@ -1,227 +1,227 @@
-#!/usr/bin/env node
-
-/**
- * Lockfile Validator — Validate package manager lockfiles
- *
- * Validates lockfile integrity for npm, yarn, and pnpm:
- * - npm: package-lock.json (JSON format with lockfileVersion)
- * - yarn: yarn.lock (YAML-like format with metadata header)
- * - pnpm: pnpm-lock.yaml (YAML format with lockfileVersion)
- *
- * Usage:
- *   const LockfileValidator = require('./lockfile-validator.cjs');
- *   const validator = new LockfileValidator(cwd);
- *   const result = validator.validate('npm');
- *   // Returns: { valid, reason, lockfileVersion?, packageCount? }
- */
-
-const fs = require('fs');
-const path = require('path');
-const Logger = require('./logger.cjs');
-
-/**
- * Lockfile Validator class
- * Validates lockfile integrity for different package managers
- */
-class LockfileValidator {
-  /**
-   * Create a LockfileValidator instance
-   * @param {string} cwd - Working directory (default: process.cwd())
-   */
-  constructor(cwd = process.cwd()) {
-    this.cwd = cwd;
-    this.logger = new Logger();
-  }
-
-  /**
-   * Validate lockfile for a specific package manager
-   * @param {string} manager - Package manager name ('npm', 'yarn', or 'pnpm')
-   * @returns {Object} Validation result
-   *   - {boolean} valid - Whether lockfile is valid
-   *   - {string} reason - Reason code if invalid
-   *   - {string} message - Human-readable message if invalid
-   *   - {number} lockfileVersion - Lockfile version (if valid)
-   *   - {number} packageCount - Number of packages (if valid)
-   */
-  validate(manager) {
-    const lockfilePath = this.getLockfilePath(manager);
-
-    this.logger.debug('Validating lockfile', {
-      manager,
-      lockfilePath,
-      cwd: this.cwd
-    });
-
-    // Check file existence
-    if (!fs.existsSync(lockfilePath)) {
-      this.logger.debug('Lockfile not found', { lockfilePath });
-      return {
-        valid: false,
-        reason: 'lockfile_missing',
-        message: `No ${path.basename(lockfilePath)} found`
-      };
-    }
-
-    try {
-      const content = fs.readFileSync(lockfilePath, 'utf-8');
-
-      switch (manager) {
-        case 'npm':
-          return this.validateNpmLockfile(content);
-        case 'yarn':
-          return this.validateYarnLockfile(content);
-        case 'pnpm':
-          return this.validatePnpmLockfile(content);
-        default:
-          return {
-            valid: false,
-            reason: 'unknown_manager',
-            message: `Unknown package manager: ${manager}`
-          };
-      }
-    } catch (err) {
-      this.logger.error('Lockfile read error', {
-        manager,
-        lockfilePath,
-        error: err.message
-      });
-      return {
-        valid: false,
-        reason: 'read_error',
-        message: err.message
-      };
-    }
-  }
-
-  /**
-   * Validate npm lockfile (package-lock.json)
-   * @param {string} content - Lockfile content
-   * @returns {Object} Validation result
-   */
-  validateNpmLockfile(content) {
-    try {
-      const lockfile = JSON.parse(content);
-
-      // Check required fields
-      if (!lockfile.lockfileVersion) {
-        return {
-          valid: false,
-          reason: 'invalid_format',
-          message: 'Missing lockfileVersion field'
-        };
-      }
-
-      if (!lockfile.packages && !lockfile.dependencies) {
-        return {
-          valid: false,
-          reason: 'empty_lockfile',
-          message: 'Lockfile has no dependencies'
-        };
-      }
-
-      const packageCount = Object.keys(lockfile.packages || lockfile.dependencies || {}).length;
-
-      this.logger.debug('npm lockfile valid', {
-        lockfileVersion: lockfile.lockfileVersion,
-        packageCount
-      });
-
-      return {
-        valid: true,
-        lockfileVersion: lockfile.lockfileVersion,
-        packageCount
-      };
-    } catch (err) {
-      this.logger.debug('npm lockfile invalid JSON', { error: err.message });
-      return {
-        valid: false,
-        reason: 'invalid_json',
-        message: `Invalid JSON: ${err.message}`
-      };
-    }
-  }
-
-  /**
-   * Validate yarn lockfile (yarn.lock)
-   * @param {string} content - Lockfile content
-   * @returns {Object} Validation result
-   */
-  validateYarnLockfile(content) {
-    // Yarn lockfile is YAML-like format
-    // Check for basic structure: __metadata__ (Yarn 2+) or "# yarn lockfile v" (Yarn 1)
-    const hasYarn2Metadata = content.includes('__metadata:');
-    const hasYarn1Header = content.match(/^# yarn lockfile v/i);
-
-    if (!hasYarn2Metadata && !hasYarn1Header) {
-      this.logger.debug('yarn lockfile invalid format');
-      return {
-        valid: false,
-        reason: 'invalid_format',
-        message: 'Invalid yarn.lock format'
-      };
-    }
-
-    // Count dependency entries (lines starting with package name pattern)
-    const entryCount = (content.match(/^"?[^@\s]+@/gm) || []).length;
-
-    this.logger.debug('yarn lockfile valid', {
-      version: hasYarn2Metadata ? '2+' : '1',
-      entryCount
-    });
-
-    return {
-      valid: true,
-      entryCount
-    };
-  }
-
-  /**
-   * Validate pnpm lockfile (pnpm-lock.yaml)
-   * @param {string} content - Lockfile content
-   * @returns {Object} Validation result
-   */
-  validatePnpmLockfile(content) {
-    // Check for lockfileVersion
-    const versionMatch = content.match(/^lockfileVersion:\s*(\d+)/m);
-    if (!versionMatch) {
-      this.logger.debug('pnpm lockfile missing lockfileVersion');
-      return {
-        valid: false,
-        reason: 'invalid_format',
-        message: 'Missing lockfileVersion in pnpm-lock.yaml'
-      };
-    }
-
-    const lockfileVersion = parseInt(versionMatch[1], 10);
-
-    // Count dependency entries (lines starting with "  /" which are package specs)
-    const entryCount = (content.match(/^  \/[^:]+:/gm) || []).length;
-
-    this.logger.debug('pnpm lockfile valid', {
-      lockfileVersion,
-      entryCount
-    });
-
-    return {
-      valid: true,
-      lockfileVersion,
-      entryCount
-    };
-  }
-
-  /**
-   * Get the lockfile path for a specific package manager
-   * @param {string} manager - Package manager name
-   * @returns {string} Full path to lockfile
-   */
-  getLockfilePath(manager) {
-    const lockfiles = {
-      'npm': 'package-lock.json',
-      'yarn': 'yarn.lock',
-      'pnpm': 'pnpm-lock.yaml'
-    };
-    return path.join(this.cwd, lockfiles[manager] || 'package-lock.json');
-  }
-}
-
-module.exports = LockfileValidator;
+#!/usr/bin/env node
+
+/**
+ * Lockfile Validator — Validate package manager lockfiles
+ *
+ * Validates lockfile integrity for npm, yarn, and pnpm:
+ * - npm: package-lock.json (JSON format with lockfileVersion)
+ * - yarn: yarn.lock (YAML-like format with metadata header)
+ * - pnpm: pnpm-lock.yaml (YAML format with lockfileVersion)
+ *
+ * Usage:
+ *   const LockfileValidator = require('./lockfile-validator.cjs');
+ *   const validator = new LockfileValidator(cwd);
+ *   const result = validator.validate('npm');
+ *   // Returns: { valid, reason, lockfileVersion?, packageCount? }
+ */
+
+const fs = require('fs');
+const path = require('path');
+const Logger = require('./logger.cjs');
+
+/**
+ * Lockfile Validator class
+ * Validates lockfile integrity for different package managers
+ */
+class LockfileValidator {
+  /**
+   * Create a LockfileValidator instance
+   * @param {string} cwd - Working directory (default: process.cwd())
+   */
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+    this.logger = new Logger();
+  }
+
+  /**
+   * Validate lockfile for a specific package manager
+   * @param {string} manager - Package manager name ('npm', 'yarn', or 'pnpm')
+   * @returns {Object} Validation result
+   *   - {boolean} valid - Whether lockfile is valid
+   *   - {string} reason - Reason code if invalid
+   *   - {string} message - Human-readable message if invalid
+   *   - {number} lockfileVersion - Lockfile version (if valid)
+   *   - {number} packageCount - Number of packages (if valid)
+   */
+  validate(manager) {
+    const lockfilePath = this.getLockfilePath(manager);
+
+    this.logger.debug('Validating lockfile', {
+      manager,
+      lockfilePath,
+      cwd: this.cwd
+    });
+
+    // Check file existence
+    if (!fs.existsSync(lockfilePath)) {
+      this.logger.debug('Lockfile not found', { lockfilePath });
+      return {
+        valid: false,
+        reason: 'lockfile_missing',
+        message: `No ${path.basename(lockfilePath)} found`
+      };
+    }
+
+    try {
+      const content = fs.readFileSync(lockfilePath, 'utf-8');
+
+      switch (manager) {
+        case 'npm':
+          return this.validateNpmLockfile(content);
+        case 'yarn':
+          return this.validateYarnLockfile(content);
+        case 'pnpm':
+          return this.validatePnpmLockfile(content);
+        default:
+          return {
+            valid: false,
+            reason: 'unknown_manager',
+            message: `Unknown package manager: ${manager}`
+          };
+      }
+    } catch (err) {
+      this.logger.error('Lockfile read error', {
+        manager,
+        lockfilePath,
+        error: err.message
+      });
+      return {
+        valid: false,
+        reason: 'read_error',
+        message: err.message
+      };
+    }
+  }
+
+  /**
+   * Validate npm lockfile (package-lock.json)
+   * @param {string} content - Lockfile content
+   * @returns {Object} Validation result
+   */
+  validateNpmLockfile(content) {
+    try {
+      const lockfile = JSON.parse(content);
+
+      // Check required fields
+      if (!lockfile.lockfileVersion) {
+        return {
+          valid: false,
+          reason: 'invalid_format',
+          message: 'Missing lockfileVersion field'
+        };
+      }
+
+      if (!lockfile.packages && !lockfile.dependencies) {
+        return {
+          valid: false,
+          reason: 'empty_lockfile',
+          message: 'Lockfile has no dependencies'
+        };
+      }
+
+      const packageCount = Object.keys(lockfile.packages || lockfile.dependencies || {}).length;
+
+      this.logger.debug('npm lockfile valid', {
+        lockfileVersion: lockfile.lockfileVersion,
+        packageCount
+      });
+
+      return {
+        valid: true,
+        lockfileVersion: lockfile.lockfileVersion,
+        packageCount
+      };
+    } catch (err) {
+      this.logger.debug('npm lockfile invalid JSON', { error: err.message });
+      return {
+        valid: false,
+        reason: 'invalid_json',
+        message: `Invalid JSON: ${err.message}`
+      };
+    }
+  }
+
+  /**
+   * Validate yarn lockfile (yarn.lock)
+   * @param {string} content - Lockfile content
+   * @returns {Object} Validation result
+   */
+  validateYarnLockfile(content) {
+    // Yarn lockfile is YAML-like format
+    // Check for basic structure: __metadata__ (Yarn 2+) or "# yarn lockfile v" (Yarn 1)
+    const hasYarn2Metadata = content.includes('__metadata:');
+    const hasYarn1Header = content.match(/^# yarn lockfile v/i);
+
+    if (!hasYarn2Metadata && !hasYarn1Header) {
+      this.logger.debug('yarn lockfile invalid format');
+      return {
+        valid: false,
+        reason: 'invalid_format',
+        message: 'Invalid yarn.lock format'
+      };
+    }
+
+    // Count dependency entries (lines starting with package name pattern)
+    const entryCount = (content.match(/^"?[^@\s]+@/gm) || []).length;
+
+    this.logger.debug('yarn lockfile valid', {
+      version: hasYarn2Metadata ? '2+' : '1',
+      entryCount
+    });
+
+    return {
+      valid: true,
+      entryCount
+    };
+  }
+
+  /**
+   * Validate pnpm lockfile (pnpm-lock.yaml)
+   * @param {string} content - Lockfile content
+   * @returns {Object} Validation result
+   */
+  validatePnpmLockfile(content) {
+    // Check for lockfileVersion
+    const versionMatch = content.match(/^lockfileVersion:\s*(\d+)/m);
+    if (!versionMatch) {
+      this.logger.debug('pnpm lockfile missing lockfileVersion');
+      return {
+        valid: false,
+        reason: 'invalid_format',
+        message: 'Missing lockfileVersion in pnpm-lock.yaml'
+      };
+    }
+
+    const lockfileVersion = parseInt(versionMatch[1], 10);
+
+    // Count dependency entries (lines starting with "  /" which are package specs)
+    const entryCount = (content.match(/^  \/[^:]+:/gm) || []).length;
+
+    this.logger.debug('pnpm lockfile valid', {
+      lockfileVersion,
+      entryCount
+    });
+
+    return {
+      valid: true,
+      lockfileVersion,
+      entryCount
+    };
+  }
+
+  /**
+   * Get the lockfile path for a specific package manager
+   * @param {string} manager - Package manager name
+   * @returns {string} Full path to lockfile
+   */
+  getLockfilePath(manager) {
+    const lockfiles = {
+      'npm': 'package-lock.json',
+      'yarn': 'yarn.lock',
+      'pnpm': 'pnpm-lock.yaml'
+    };
+    return path.join(this.cwd, lockfiles[manager] || 'package-lock.json');
+  }
+}
+
+module.exports = LockfileValidator;

package/ez-agents/bin/lib/log-rotation.cjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+/**
+ * Log Rotation Utility
+ * 
+ * Automatically deletes EZ Agents logs older than 7 days to prevent git spam.
+ * Run this weekly or add to CI/CD cleanup job.
+ * 
+ * Usage: node ez-agents/bin/lib/log-rotation.cjs [--dry-run]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LOGS_DIR = path.join(process.cwd(), '.planning', 'logs');
+const MAX_AGE_DAYS = 7;
+const DRY_RUN = process.argv.includes('--dry-run');
+
+function rotateLogs() {
+  if (!fs.existsSync(LOGS_DIR)) {
+    console.log('Logs directory not found:', LOGS_DIR);
+    return;
+  }
+
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - MAX_AGE_DAYS);
+
+  const files = fs.readdirSync(LOGS_DIR);
+  const logFiles = files.filter(f => f.endsWith('.log'));
+  
+  let deleted = 0;
+  let kept = 0;
+  let totalSize = 0;
+
+  logFiles.forEach(file => {
+    const filePath = path.join(LOGS_DIR, file);
+    const stats = fs.statSync(filePath);
+    
+    if (stats.mtime < cutoff) {
+      if (DRY_RUN) {
+        console.log(`[DRY-RUN] Would delete: ${file} (${formatBytes(stats.size)})`);
+      } else {
+        fs.unlinkSync(filePath);
+        console.log(`Deleted: ${file}`);
+      }
+      deleted++;
+      totalSize += stats.size;
+    } else {
+      kept++;
+    }
+  });
+
+  console.log(`\n${DRY_RUN ? '[DRY-RUN] ' : ''}Log Rotation Complete`);
+  console.log(`  Deleted: ${deleted} files (${formatBytes(totalSize)})`);
+  console.log(`  Kept: ${kept} files (last ${MAX_AGE_DAYS} days)`);
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+// Run if called directly
+if (require.main === module) {
+  rotateLogs();
+}
+
+module.exports = { rotateLogs };

package/ez-agents/bin/lib/logger.cjs

@@ -2,63 +2,32 @@
 
 /**
  * EZ Logger — Centralized logging module for EZ workflow
- * 
+ *
  * Provides structured logging with levels (ERROR, WARN, INFO, DEBUG)
- * Writes to .planning/logs/ez-{timestamp}.log
+ * Logs to console only (no file logging)
  * Replaces silent catch {} blocks with proper error logging
- * 
+ *
  * Usage:
  *   const Logger = require('./logger.cjs');
  *   const logger = new Logger();
  *   logger.error('Something failed', { context: 'details' });
  */
 
-const fs = require('fs');
-const path = require('path');
-
 class Logger {
   /**
    * Create a Logger instance
-   * @param {string} logDir - Directory for log files (default: .planning/logs)
-   */
-  constructor(logDir = '.planning/logs') {
-    this.logDir = logDir;
-    this.logFile = null;
-  }
-
-  /**
-   * Ensure log directory exists and initialize log file
-   */
-  _ensureLogDir() {
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-    this.logFile = path.join(this.logDir, `ez-${Date.now()}.log`);
-  }
-
-  /**
-   * Get current log file path
-   * @returns {string} - Path to log file
    */
-  getLogFile() {
-    if (!this.logFile) {
-      this._ensureLogDir();
-    }
-    return this.logFile;
+  constructor() {
+    // No file logging - console only
   }
 
   /**
-   * Write a log entry
+   * Write a log entry to console
    * @param {string} level - Log level (ERROR, WARN, INFO, DEBUG)
    * @param {string} message - Log message
    * @param {Object} context - Additional context data
    */
   log(level, message, context = {}) {
-    // Ensure log directory exists before first write
-    if (!this.logFile) {
-      this._ensureLogDir();
-    }
-    
     const entry = {
       timestamp: new Date().toISOString(),
       level,
@@ -67,16 +36,14 @@ class Logger {
       pid: process.pid
     };
 
-    try {
-      fs.appendFileSync(this.logFile, JSON.stringify(entry) + '\n');
-      
-      // Always output ERROR level to console for visibility
-      if (level === 'ERROR') {
-        console.error(`[EZ ${level}] ${message}`);
-      }
-    } catch (err) {
-      // Fallback: log to console if file write fails
-      console.error(`[EZ ${level}] ${message} (file write failed: ${err.message})`);
+    // Always output to console
+    if (level === 'ERROR') {
+      console.error(`[EZ ${level}] ${message}`);
+    } else if (level === 'WARN') {
+      console.warn(`[EZ ${level}] ${message}`);
+    } else if (process.env.DEBUG === 'ez-agents') {
+      // Only output INFO/DEBUG in debug mode
+      console.log(`[EZ ${level}] ${message}`);
     }
   }
 
@@ -115,6 +82,14 @@ class Logger {
   debug(msg, ctx) {
     this.log('DEBUG', msg, ctx);
   }
+
+  /**
+   * Get log file path (returns null - no file logging)
+   * @returns {null} - Always null
+   */
+  getLogFile() {
+    return null;
+  }
 }
 
 // Singleton instance for default usage