@howlil/ez-agents 3.4.2 → 3.5.0

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

@@ -29,6 +29,8 @@ const auditExec = require('./audit-exec.cjs');
 
 // Git
 const GitUtils = require('./git-utils.cjs');
+const GitWorkflowEngine = require('./git-workflow-engine.cjs');
+const GitErrors = require('./git-errors.cjs');
 
 // Reliability
 const retry = require('./retry.cjs');
@@ -48,6 +50,25 @@ const modelProvider = require('./model-provider.cjs');
 // Adapters
 const assistantAdapter = require('./assistant-adapter.cjs');
 
+// Package Manager
+const PackageManagerService = require('./package-manager-service.cjs');
+const PackageManagerDetector = require('./package-manager-detector.cjs');
+const PackageManagerExecutor = require('./package-manager-executor.cjs');
+const LockfileValidator = require('./lockfile-validator.cjs');
+
+// BDD & Requirements (Phase 30)
+const bddValidator = require('./bdd-validator.cjs');
+
+// Discussion Synthesis (Phase 31)
+const discussionSynthesizer = require('./discussion-synthesizer.cjs');
+
+// Tier Management & Release Validation (Phase 32-33)
+const TierManager = require('./tier-manager.cjs');
+const ReleaseValidator = require('./release-validator.cjs');
+
+// Metrics (Phase 34)
+const MetricsTracker = require('./metrics-tracker.cjs');
+
 module.exports = {
   // Core
   Logger,
@@ -64,6 +85,8 @@ module.exports = {
   
   // Git
   GitUtils,
+  GitWorkflowEngine,
+  GitErrors,
   
   // Reliability
   ...retry,
@@ -82,9 +105,28 @@ module.exports = {
   
   // Adapters
   ...assistantAdapter,
-  
+
+  // Package Manager
+  PackageManagerService,
+  PackageManagerDetector,
+  PackageManagerExecutor,
+  LockfileValidator,
+
+  // BDD & Requirements (Phase 30)
+  ...bddValidator,
+
+  // Discussion Synthesis (Phase 31)
+  ...discussionSynthesizer,
+
+  // Tier Management & Release (Phase 32-33)
+  TierManager,
+  ReleaseValidator,
+
+  // Metrics (Phase 34)
+  MetricsTracker,
+
   // Version info
-  version: '2.0.0',
+  version: '3.0.0',
   
   /**
    * Get health status of all modules
@@ -101,6 +143,8 @@ module.exports = {
         safePath: 'ok',
         auth: auth.isKeychainAvailable() ? 'keychain' : 'fallback',
         gitUtils: 'ok',
+      gitWorkflowEngine: 'ok',
+      gitErrors: 'ok',
         retry: 'ok',
         circuitBreaker: 'ok',
         fileLock: 'ok',

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

@@ -0,0 +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;

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

@@ -1,154 +1,124 @@
-#!/usr/bin/env node
-
-/**
- * EZ Logger — Centralized logging module for EZ workflow
- *
- * Provides structured logging with levels (ERROR, WARN, INFO, DEBUG)
- * Writes to .planning/logs/{category}/ez-{YYYY-MM-DD}.log
- * - One file per day per category (reduces file waste)
- * - Categories: error, warn, info, debug
- * 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.logFiles = {
-      error: null,
-      warn: null,
-      info: null,
-      debug: null
-    };
-    this.currentDate = null;
-  }
-
-  /**
-   * Get current date string in YYYY-MM-DD format
-   * @returns {string} - Date string
-   */
-  _getDateStr() {
-    return new Date().toISOString().split('T')[0];
-  }
-
-  /**
-   * Ensure log directory exists
-   */
-  _ensureLogDir() {
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Get log file path for a specific category
-   * Creates new file when date changes (daily rotation)
-   * @param {string} category - Log category (error, warn, info, debug)
-   * @returns {string} - Path to log file
-   */
-  _getLogFile(category) {
-    const dateStr = this._getDateStr();
-    
-    // Rotate log file if date changed
-    if (this.currentDate !== dateStr) {
-      this.currentDate = dateStr;
-      this.logFiles = { error: null, warn: null, info: null, debug: null };
-    }
-
-    if (!this.logFiles[category]) {
-      this._ensureLogDir();
-      // Create category subdirectory
-      const categoryDir = path.join(this.logDir, category);
-      if (!fs.existsSync(categoryDir)) {
-        fs.mkdirSync(categoryDir, { recursive: true });
-      }
-      this.logFiles[category] = path.join(categoryDir, `ez-${dateStr}.log`);
-    }
-
-    return this.logFiles[category];
-  }
-
-  /**
-   * Write a log entry
-   * @param {string} level - Log level (ERROR, WARN, INFO, DEBUG)
-   * @param {string} message - Log message
-   * @param {Object} context - Additional context data
-   */
-  log(level, message, context = {}) {
-    const category = level.toLowerCase();
-    const logFile = this._getLogFile(category);
-
-    const entry = {
-      timestamp: new Date().toISOString(),
-      level,
-      message,
-      context,
-      pid: process.pid
-    };
-
-    try {
-      fs.appendFileSync(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})`);
-    }
-  }
-
-  /**
-   * Log an ERROR level message
-   * @param {string} msg - Error message
-   * @param {Object} ctx - Additional context
-   */
-  error(msg, ctx) {
-    this.log('ERROR', msg, ctx);
-  }
-
-  /**
-   * Log a WARN level message
-   * @param {string} msg - Warning message
-   * @param {Object} ctx - Additional context
-   */
-  warn(msg, ctx) {
-    this.log('WARN', msg, ctx);
-  }
-
-  /**
-   * Log an INFO level message
-   * @param {string} msg - Info message
-   * @param {Object} ctx - Additional context
-   */
-  info(msg, ctx) {
-    this.log('INFO', msg, ctx);
-  }
-
-  /**
-   * Log a DEBUG level message
-   * @param {string} msg - Debug message
-   * @param {Object} ctx - Additional context
-   */
-  debug(msg, ctx) {
-    this.log('DEBUG', msg, ctx);
-  }
-}
-
-// Singleton instance for default usage
-const defaultLogger = new Logger();
-
-module.exports = Logger;
-module.exports.defaultLogger = defaultLogger;
+#!/usr/bin/env node
+
+/**
+ * EZ Logger — Centralized logging module for EZ workflow
+ * 
+ * Provides structured logging with levels (ERROR, WARN, INFO, DEBUG)
+ * Writes to .planning/logs/ez-{timestamp}.log
+ * 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;
+  }
+
+  /**
+   * Write a log entry
+   * @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,
+      message,
+      context,
+      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})`);
+    }
+  }
+
+  /**
+   * Log an ERROR level message
+   * @param {string} msg - Error message
+   * @param {Object} ctx - Additional context
+   */
+  error(msg, ctx) {
+    this.log('ERROR', msg, ctx);
+  }
+
+  /**
+   * Log a WARN level message
+   * @param {string} msg - Warning message
+   * @param {Object} ctx - Additional context
+   */
+  warn(msg, ctx) {
+    this.log('WARN', msg, ctx);
+  }
+
+  /**
+   * Log an INFO level message
+   * @param {string} msg - Info message
+   * @param {Object} ctx - Additional context
+   */
+  info(msg, ctx) {
+    this.log('INFO', msg, ctx);
+  }
+
+  /**
+   * Log a DEBUG level message
+   * @param {string} msg - Debug message
+   * @param {Object} ctx - Additional context
+   */
+  debug(msg, ctx) {
+    this.log('DEBUG', msg, ctx);
+  }
+}
+
+// Singleton instance for default usage
+const defaultLogger = new Logger();
+
+module.exports = Logger;
+module.exports.defaultLogger = defaultLogger;