@howlil/ez-agents 3.4.2 → 4.0.0

package/ez-agents/bin/lib/health-check.cjs

@@ -1,162 +1,162 @@
-#!/usr/bin/env node
-
-/**
- * EZ Health Check — Health monitoring for EZ workflow
- * 
- * Validates EZ environment and configuration
- * Used by workflows to detect failures and use fallback functions
- * 
- * Usage:
- *   const HealthCheck = require('./health-check.cjs');
- *   const health = new HealthCheck();
- *   const result = health.runAll();
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class HealthCheck {
-  /**
-   * Create a HealthCheck instance
-   */
-  constructor() {
-    this.issues = [];
-    this.warnings = [];
-  }
-
-  /**
-   * Check Node.js version (must be >= 16)
-   * @returns {boolean} - True if version is acceptable
-   */
-  checkNodeVersion() {
-    try {
-      const version = process.version;
-      const major = parseInt(version.slice(1).split('.')[0]);
-      if (major < 16) {
-        this.issues.push(`Node.js version ${version} is below required 16.x`);
-        return false;
-      }
-      return true;
-    } catch (err) {
-      this.issues.push('Cannot determine Node.js version');
-      return false;
-    }
-  }
-
-  /**
-   * Check if .planning directory exists
-   * @returns {boolean} - True if exists
-   */
-  checkPlanningDirectory() {
-    const planningDir = '.planning';
-    if (!fs.existsSync(planningDir)) {
-      this.warnings.push('.planning directory does not exist');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Check if config.json exists and is valid JSON
-   * @returns {boolean} - True if exists and valid
-   */
-  checkConfigFile() {
-    const configPath = '.planning/config.json';
-    if (!fs.existsSync(configPath)) {
-      this.warnings.push('config.json not found');
-      return false;
-    }
-    try {
-      JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-      return true;
-    } catch (err) {
-      this.issues.push('config.json is invalid JSON');
-      return false;
-    }
-  }
-
-  /**
-   * Check if STATE.md exists
-   * @returns {boolean} - True if exists
-   */
-  checkStateFile() {
-    const statePath = '.planning/STATE.md';
-    if (!fs.existsSync(statePath)) {
-      this.warnings.push('STATE.md not found');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Check if ROADMAP.md exists
-   * @returns {boolean} - True if exists
-   */
-  checkRoadmapFile() {
-    const roadmapPath = '.planning/ROADMAP.md';
-    if (!fs.existsSync(roadmapPath)) {
-      this.warnings.push('ROADMAP.md not found');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Check if PROJECT.md exists
-   * @returns {boolean} - True if exists
-   */
-  checkProjectFile() {
-    const projectPath = '.planning/PROJECT.md';
-    if (!fs.existsSync(projectPath)) {
-      this.warnings.push('PROJECT.md not found');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Check if REQUIREMENTS.md exists
-   * @returns {boolean} - True if exists
-   */
-  checkRequirementsFile() {
-    const reqPath = '.planning/REQUIREMENTS.md';
-    if (!fs.existsSync(reqPath)) {
-      this.warnings.push('REQUIREMENTS.md not found');
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Run all health checks
-   * @returns {Object} - Health status object
-   */
-  runAll() {
-    const results = {
-      status: 'healthy',
-      timestamp: new Date().toISOString(),
-      node_version: process.version,
-      checks: {
-        node_version: this.checkNodeVersion(),
-        planning_dir: this.checkPlanningDirectory(),
-        config_file: this.checkConfigFile(),
-        state_file: this.checkStateFile(),
-        roadmap_file: this.checkRoadmapFile(),
-        project_file: this.checkProjectFile(),
-        requirements_file: this.checkRequirementsFile()
-      },
-      issues: this.issues,
-      warnings: this.warnings
-    };
-
-    if (this.issues.length > 0) {
-      results.status = 'unhealthy';
-    } else if (this.warnings.length > 0) {
-      results.status = 'degraded';
-    }
-
-    return results;
-  }
-}
-
-module.exports = HealthCheck;
+#!/usr/bin/env node
+
+/**
+ * EZ Health Check — Health monitoring for EZ workflow
+ * 
+ * Validates EZ environment and configuration
+ * Used by workflows to detect failures and use fallback functions
+ * 
+ * Usage:
+ *   const HealthCheck = require('./health-check.cjs');
+ *   const health = new HealthCheck();
+ *   const result = health.runAll();
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class HealthCheck {
+  /**
+   * Create a HealthCheck instance
+   */
+  constructor() {
+    this.issues = [];
+    this.warnings = [];
+  }
+
+  /**
+   * Check Node.js version (must be >= 16)
+   * @returns {boolean} - True if version is acceptable
+   */
+  checkNodeVersion() {
+    try {
+      const version = process.version;
+      const major = parseInt(version.slice(1).split('.')[0]);
+      if (major < 16) {
+        this.issues.push(`Node.js version ${version} is below required 16.x`);
+        return false;
+      }
+      return true;
+    } catch (err) {
+      this.issues.push('Cannot determine Node.js version');
+      return false;
+    }
+  }
+
+  /**
+   * Check if .planning directory exists
+   * @returns {boolean} - True if exists
+   */
+  checkPlanningDirectory() {
+    const planningDir = '.planning';
+    if (!fs.existsSync(planningDir)) {
+      this.warnings.push('.planning directory does not exist');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Check if config.json exists and is valid JSON
+   * @returns {boolean} - True if exists and valid
+   */
+  checkConfigFile() {
+    const configPath = '.planning/config.json';
+    if (!fs.existsSync(configPath)) {
+      this.warnings.push('config.json not found');
+      return false;
+    }
+    try {
+      JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return true;
+    } catch (err) {
+      this.issues.push('config.json is invalid JSON');
+      return false;
+    }
+  }
+
+  /**
+   * Check if STATE.md exists
+   * @returns {boolean} - True if exists
+   */
+  checkStateFile() {
+    const statePath = '.planning/STATE.md';
+    if (!fs.existsSync(statePath)) {
+      this.warnings.push('STATE.md not found');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Check if ROADMAP.md exists
+   * @returns {boolean} - True if exists
+   */
+  checkRoadmapFile() {
+    const roadmapPath = '.planning/ROADMAP.md';
+    if (!fs.existsSync(roadmapPath)) {
+      this.warnings.push('ROADMAP.md not found');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Check if PROJECT.md exists
+   * @returns {boolean} - True if exists
+   */
+  checkProjectFile() {
+    const projectPath = '.planning/PROJECT.md';
+    if (!fs.existsSync(projectPath)) {
+      this.warnings.push('PROJECT.md not found');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Check if REQUIREMENTS.md exists
+   * @returns {boolean} - True if exists
+   */
+  checkRequirementsFile() {
+    const reqPath = '.planning/REQUIREMENTS.md';
+    if (!fs.existsSync(reqPath)) {
+      this.warnings.push('REQUIREMENTS.md not found');
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Run all health checks
+   * @returns {Object} - Health status object
+   */
+  runAll() {
+    const results = {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      node_version: process.version,
+      checks: {
+        node_version: this.checkNodeVersion(),
+        planning_dir: this.checkPlanningDirectory(),
+        config_file: this.checkConfigFile(),
+        state_file: this.checkStateFile(),
+        roadmap_file: this.checkRoadmapFile(),
+        project_file: this.checkProjectFile(),
+        requirements_file: this.checkRequirementsFile()
+      },
+      issues: this.issues,
+      warnings: this.warnings
+    };
+
+    if (this.issues.length > 0) {
+      results.status = 'unhealthy';
+    } else if (this.warnings.length > 0) {
+      results.status = 'degraded';
+    }
+
+    return results;
+  }
+}
+
+module.exports = HealthCheck;

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,22 @@ 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');
+
 module.exports = {
   // Core
   Logger,
@@ -64,6 +82,8 @@ module.exports = {
   
   // Git
   GitUtils,
+  GitWorkflowEngine,
+  GitErrors,
   
   // Reliability
   ...retry,
@@ -82,9 +102,25 @@ 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,
+
   // Version info
-  version: '2.0.0',
+  version: '3.0.0',
   
   /**
    * Get health status of all modules
@@ -101,6 +137,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/init.cjs

@@ -215,7 +215,6 @@ async function cmdInitNewProject(cwd, raw) {
   const result = {
     // Models
     researcher_model: resolveModelInternal(cwd, 'ez-project-researcher'),
-    synthesizer_model: resolveModelInternal(cwd, 'ez-research-synthesizer'),
     roadmapper_model: resolveModelInternal(cwd, 'ez-roadmapper'),
 
     // Config
@@ -252,7 +251,6 @@ function cmdInitNewMilestone(cwd, raw) {
   const result = {
     // Models
     researcher_model: resolveModelInternal(cwd, 'ez-project-researcher'),
-    synthesizer_model: resolveModelInternal(cwd, 'ez-research-synthesizer'),
     roadmapper_model: resolveModelInternal(cwd, 'ez-roadmapper'),
 
     // Config

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;