@howlil/ez-agents 3.4.2 → 4.0.0

package/ez-agents/bin/lib/dependency-graph.cjs

@@ -0,0 +1,319 @@
+/**
+ * Dependency Graph — Automated dependency analysis using madge
+ * 
+ * Provides:
+ * - build(rootPath, entryPoint): Creates dependency graph using madge for JS/TS files
+ * - detectCircular(): Returns array of circular dependency paths
+ * - getNodes(), getEdges(), getOrphanFiles(), getLeafFiles(): Graph accessors
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+class DependencyGraph {
+  constructor(rootPath, options = {}) {
+    this.rootPath = rootPath;
+    this.options = {
+      entry: options.entry || null,
+      detectCircular: options.detectCircular !== false,
+      includeNpm: options.includeNpm || false,
+      tsConfig: options.tsConfig || 'tsconfig.json',
+      fileExtensions: options.fileExtensions || ['.ts', '.tsx', '.js', '.jsx'],
+      ...options
+    };
+    this.nodes = [];
+    this.edges = {};
+    this.circular = [];
+    this.orphan = [];
+    this.leafs = [];
+    this.graph = null;
+  }
+
+  /**
+   * Build dependency graph from root path
+   * @param {string} rootPath - Root directory to analyze
+   * @param {string} entryPoint - Optional entry point file
+   * @returns {Promise<object>} Graph object with nodes, edges, circular, orphan, leafs
+   */
+  async build(rootPath = this.rootPath, entryPoint = this.options.entry) {
+    try {
+      const madge = require('madge');
+
+      const config = {
+        entry: entryPoint || undefined,
+        detectCircular: this.options.detectCircular,
+        includeNpm: this.options.includeNpm,
+        tsConfig: path.join(rootPath, this.options.tsConfig),
+        fileExtensions: this.options.fileExtensions,
+        extensions: this.options.fileExtensions.map(ext => ext.replace('.', ''))
+      };
+
+      // Find source files
+      const srcDir = path.join(rootPath, 'src');
+      const appDir = path.join(rootPath, 'app');
+      const libDir = path.join(rootPath, 'lib');
+
+      let searchPath = rootPath;
+      if (fs.existsSync(srcDir)) {
+        searchPath = srcDir;
+      } else if (fs.existsSync(appDir)) {
+        searchPath = appDir;
+      } else if (fs.existsSync(libDir)) {
+        searchPath = libDir;
+      }
+
+      // Build glob pattern
+      const patterns = this.options.fileExtensions
+        .flatMap(ext => [
+          path.join(searchPath, `**/*${ext}`),
+          path.join(rootPath, `bin/**/*${ext}`),
+          path.join(rootPath, 'commands/**/*${ext}')
+        ]);
+
+      // Filter to existing paths
+      const existingPatterns = patterns.filter(p => {
+        // Simple check - madge will handle the actual globbing
+        return true;
+      });
+
+      // Use madge to analyze dependencies
+      const depGraph = await madge(existingPatterns.length > 0 ? existingPatterns : searchPath, {
+        ...config,
+        tsConfig: fs.existsSync(config.tsConfig) ? config.tsConfig : undefined
+      });
+
+      this.nodes = depGraph.nodes();
+      this.edges = depGraph.dependencies();
+      this.circular = this.options.detectCircular ? depGraph.circular() : [];
+      this.orphan = depGraph.orphan();
+      this.leafs = depGraph.leafs();
+      this.graph = depGraph;
+
+      return {
+        nodes: this.nodes,
+        edges: this.edges,
+        circular: this.circular,
+        orphan: this.orphan,
+        leafs: this.leafs
+      };
+    } catch (err) {
+      // If madge fails, create a basic graph from file system
+      console.warn(`Warning: Madge analysis failed (${err.message}), using fallback file-based analysis`);
+      return this._buildFallback(rootPath);
+    }
+  }
+
+  /**
+   * Detect circular dependencies
+   * @returns {Array} Array of circular dependency paths
+   */
+  detectCircular() {
+    return this.circular;
+  }
+
+  /**
+   * Get all nodes (files) in the graph
+   * @returns {Array} Array of file paths
+   */
+  getNodes() {
+    return this.nodes;
+  }
+
+  /**
+   * Get all edges (import relationships) in the graph
+   * @returns {object} Object mapping file paths to their dependencies
+   */
+  getEdges() {
+    return this.edges;
+  }
+
+  /**
+   * Get orphan files (files with no imports/exports)
+   * @returns {Array} Array of orphan file paths
+   */
+  getOrphanFiles() {
+    return this.orphan;
+  }
+
+  /**
+   * Get leaf files (files not imported by others)
+   * @returns {Array} Array of leaf file paths
+   */
+  getLeafFiles() {
+    return this.leafs;
+  }
+
+  /**
+   * Get dependency count for a file
+   * @param {string} filePath - File path
+   * @returns {number} Number of dependencies
+   */
+  getDependencyCount(filePath) {
+    return this.edges[filePath] ? this.edges[filePath].length : 0;
+  }
+
+  /**
+   * Get dependent count (how many files depend on this file)
+   * @param {string} filePath - File path
+   * @returns {number} Number of files that depend on this file
+   */
+  getDependentCount(filePath) {
+    let count = 0;
+    for (const deps of Object.values(this.edges)) {
+      if (deps.includes(filePath)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Get most depended upon files (hubs)
+   * @param {number} limit - Maximum number of results
+   * @returns {Array} Array of {file, count} objects
+   */
+  getHubFiles(limit = 10) {
+    const counts = {};
+    for (const deps of Object.values(this.edges)) {
+      for (const dep of deps) {
+        counts[dep] = (counts[dep] || 0) + 1;
+      }
+    }
+
+    return Object.entries(counts)
+      .map(([file, count]) => ({ file, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, limit);
+  }
+
+  /**
+   * Get most dependent files (files with many dependencies)
+   * @param {number} limit - Maximum number of results
+   * @returns {Array} Array of {file, count} objects
+   */
+  getMostDependentFiles(limit = 10) {
+    return Object.entries(this.edges)
+      .map(([file, deps]) => ({ file, count: deps.length }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, limit);
+  }
+
+  /**
+   * Fallback graph builder when madge fails
+   * @private
+   */
+  _buildFallback(rootPath) {
+    const result = {
+      nodes: [],
+      edges: {},
+      circular: [],
+      orphan: [],
+      leafs: []
+    };
+
+    try {
+      // Simple file-based analysis
+      const files = this._getAllSourceFiles(rootPath);
+      result.nodes = files;
+
+      // Create basic edges from import statements
+      for (const file of files) {
+        const imports = this._extractImports(file);
+        result.edges[file] = imports.filter(imp => files.includes(imp));
+      }
+
+      // Find orphans (no imports and not imported)
+      const importedFiles = new Set();
+      for (const deps of Object.values(result.edges)) {
+        for (const dep of deps) {
+          importedFiles.add(dep);
+        }
+      }
+
+      result.orphan = files.filter(file => {
+        const hasImports = result.edges[file] && result.edges[file].length > 0;
+        const isImported = importedFiles.has(file);
+        return !hasImports && !isImported;
+      });
+
+      // Find leafs (not imported by others)
+      result.leafs = files.filter(file => !importedFiles.has(file));
+
+      this.nodes = result.nodes;
+      this.edges = result.edges;
+      this.orphan = result.orphan;
+      this.leafs = result.leafs;
+
+      return result;
+    } catch (err) {
+      console.warn(`Warning: Fallback graph building failed: ${err.message}`);
+      return result;
+    }
+  }
+
+  /**
+   * Get all source files in directory
+   * @private
+   */
+  _getAllSourceFiles(dir, files = []) {
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && !['node_modules', '.git', 'dist', 'build'].includes(entry.name)) {
+          this._getAllSourceFiles(fullPath, files);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          if (this.options.fileExtensions.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (err) {
+      // Ignore errors
+    }
+    return files;
+  }
+
+  /**
+   * Extract imports from a file
+   * @private
+   */
+  _extractImports(filePath) {
+    const imports = [];
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const importRegex = /(?:import|require)\s*[\s\S]*?['"]([^'"]+)['"]/g;
+      let match;
+
+      while ((match = importRegex.exec(content)) !== null) {
+        const importPath = match[1];
+        // Only include relative imports
+        if (importPath.startsWith('.')) {
+          const resolved = path.resolve(path.dirname(filePath), importPath);
+          // Try to find the actual file
+          for (const ext of this.options.fileExtensions) {
+            const withExt = resolved + ext;
+            if (fs.existsSync(withExt)) {
+              imports.push(withExt);
+              break;
+            }
+          }
+          // Also check index files
+          for (const ext of this.options.fileExtensions) {
+            const indexPath = path.join(resolved, `index${ext}`);
+            if (fs.existsSync(indexPath)) {
+              imports.push(indexPath);
+              break;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      // Ignore errors
+    }
+    return imports;
+  }
+}
+
+module.exports = { DependencyGraph };

package/ez-agents/bin/lib/deploy/deploy-audit-log.cjs

@@ -0,0 +1,76 @@
+/**
+ * Deploy Audit Log — Writes deploy audit logs
+ * Logs to temp directory (console-only fallback)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class DeployAuditLog {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+    // Use temp directory instead of .planning/logs
+    this.logsDir = path.join(process.env.TEMP || process.env.TMPDIR || '/tmp', 'ez-agents-deploy');
+    // Ensure temp dir exists
+    if (!fs.existsSync(this.logsDir)) {
+      fs.mkdirSync(this.logsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Write deploy audit log
+   * @param {Object} deployDetails - Deploy details to log
+   * @returns {string} Path to written log
+   */
+  writeAuditLog(deployDetails) {
+    // Ensure logs directory exists
+    if (!fs.existsSync(this.logsDir)) {
+      fs.mkdirSync(this.logsDir, { recursive: true });
+    }
+
+    const timestamp = Date.now();
+    const filename = `deploy-${timestamp}.json`;
+    const logPath = path.join(this.logsDir, filename);
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      ...deployDetails
+    };
+
+    fs.writeFileSync(logPath, JSON.stringify(logEntry, null, 2), 'utf8');
+    return logPath;
+  }
+
+  /**
+   * Read deploy audit log
+   * @param {string} filename - Log filename
+   * @returns {Object} Log entry
+   */
+  readAuditLog(filename) {
+    const logPath = path.join(this.logsDir, filename);
+    if (!fs.existsSync(logPath)) return null;
+    return JSON.parse(fs.readFileSync(logPath, 'utf8'));
+  }
+
+  /**
+   * List all deploy audit logs
+   * @returns {Array} Array of log filenames
+   */
+  listAuditLogs() {
+    if (!fs.existsSync(this.logsDir)) return [];
+    return fs.readdirSync(this.logsDir).filter(f => f.startsWith('deploy-') && f.endsWith('.json'));
+  }
+}
+
+/**
+ * Write deploy audit log
+ * @param {Object} deployDetails - Deploy details
+ * @param {string} cwd - Working directory
+ * @returns {string} Path to written log
+ */
+function writeAuditLog(deployDetails, cwd) {
+  const logger = new DeployAuditLog(cwd);
+  return logger.writeAuditLog(deployDetails);
+}
+
+module.exports = { DeployAuditLog, writeAuditLog };

package/ez-agents/bin/lib/deploy/deploy-detector.cjs

@@ -0,0 +1,69 @@
+/**
+ * Deploy Detector — Detects target deployment environment
+ * Checks config files (vercel.json, fly.toml, Procfile) and git remotes
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+class DeployDetector {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+  }
+
+  /**
+   * Detect deployment environment from config files and git remotes
+   * @returns {Object} Detection result { platform, confidence, source }
+   */
+  detect() {
+    // Check for platform config files (high confidence)
+    const configChecks = [
+      { file: 'vercel.json', platform: 'vercel', confidence: 'high' },
+      { file: 'fly.toml', platform: 'fly.io', confidence: 'high' },
+      { file: 'Procfile', platform: 'heroku', confidence: 'high' },
+      { file: 'railway.json', platform: 'railway', confidence: 'high' }
+    ];
+
+    for (const check of configChecks) {
+      if (fs.existsSync(path.join(this.cwd, check.file))) {
+        return {
+          platform: check.platform,
+          confidence: check.confidence,
+          source: check.file
+        };
+      }
+    }
+
+    // Fallback: check git remotes (medium confidence)
+    try {
+      const remotes = execSync('git remote -v', { cwd: this.cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+      
+      if (remotes.includes('vercel.com')) {
+        return { platform: 'vercel', confidence: 'medium', source: 'git-remote' };
+      }
+      if (remotes.includes('fly.dev')) {
+        return { platform: 'fly.io', confidence: 'medium', source: 'git-remote' };
+      }
+      if (remotes.includes('heroku.com')) {
+        return { platform: 'heroku', confidence: 'medium', source: 'git-remote' };
+      }
+    } catch (e) {
+      // No git or no remotes
+    }
+
+    return { platform: 'unknown', confidence: 'none', source: 'none' };
+  }
+}
+
+/**
+ * Detect deployment environment
+ * @param {string} cwd - Working directory
+ * @returns {Object} Detection result
+ */
+function detect(cwd) {
+  const detector = new DeployDetector(cwd);
+  return detector.detect();
+}
+
+module.exports = { DeployDetector, detect };

package/ez-agents/bin/lib/deploy/deploy-env-manager.cjs

@@ -0,0 +1,109 @@
+/**
+ * Deploy Env Manager — Multi-environment deploy config
+ * Manages dev/staging/prod environment configurations
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class DeployEnvManager {
+  constructor(cwd) {
+    this.cwd = cwd || process.cwd();
+    this.configPath = path.join(this.cwd, '.planning', 'deploy-config.json');
+  }
+
+  /**
+   * Get environment configuration
+   * @param {string} env - Environment name (dev, staging, prod)
+   * @returns {Object} Environment config
+   */
+  getEnvConfig(env) {
+    const config = this.loadConfig();
+    const defaultConfig = {
+      env: 'dev',
+      platform: 'vercel',
+      url: null,
+      requiredVars: []
+    };
+
+    return config.environments?.[env] || { ...defaultConfig, env };
+  }
+
+  /**
+   * Set environment configuration
+   * @param {string} env - Environment name
+   * @param {Object} config - Configuration to set
+   */
+  setEnv(env, config) {
+    const current = this.loadConfig();
+    if (!current.environments) current.environments = {};
+    current.environments[env] = { ...current.environments[env], ...config };
+    this.saveConfig(current);
+  }
+
+  /**
+   * List all configured environments
+   * @returns {Array} Array of environment names
+   */
+  listEnvs() {
+    const config = this.loadConfig();
+    return Object.keys(config.environments || {});
+  }
+
+  /**
+   * Validate environment has required variables
+   * @param {string} env - Environment name
+   * @returns {Object} Validation result { valid, missing }
+   */
+  validateEnv(env) {
+    const config = this.getEnvConfig(env);
+    const missing = [];
+
+    for (const envVar of config.requiredVars || []) {
+      if (!process.env[envVar]) {
+        missing.push(envVar);
+      }
+    }
+
+    return {
+      valid: missing.length === 0,
+      missing
+    };
+  }
+
+  /**
+   * Load config from file
+   * @returns {Object} Config
+   */
+  loadConfig() {
+    if (!fs.existsSync(this.configPath)) {
+      return { environments: {} };
+    }
+    return JSON.parse(fs.readFileSync(this.configPath, 'utf8'));
+  }
+
+  /**
+   * Save config to file
+   * @param {Object} config - Config to save
+   */
+  saveConfig(config) {
+    const dir = path.dirname(this.configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf8');
+  }
+}
+
+/**
+ * Get environment configuration
+ * @param {string} env - Environment name
+ * @param {string} cwd - Working directory
+ * @returns {Object} Environment config
+ */
+function getEnvConfig(env, cwd) {
+  const manager = new DeployEnvManager(cwd);
+  return manager.getEnvConfig(env);
+}
+
+module.exports = { DeployEnvManager, getEnvConfig };

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

@@ -0,0 +1,88 @@
+/**
+ * Deploy Health Check — Verifies deployment success
+ * Checks deployment URL for healthy response
+ */
+
+const https = require('https');
+const http = require('http');
+
+class DeployHealthCheck {
+  constructor(timeout = 10000) {
+    this.timeout = timeout;
+  }
+
+  /**
+   * Check health of deployment URL
+   * @param {string} url - Deployment URL to check
+   * @param {Array} endpoints - Additional endpoints to check
+   * @returns {Object} Health result { healthy, status, message }
+   */
+  async checkHealth(url, endpoints = []) {
+    const allEndpoints = [url, ...endpoints];
+    const results = [];
+
+    for (const endpoint of allEndpoints) {
+      try {
+        const result = await this.checkEndpoint(endpoint);
+        results.push(result);
+      } catch (e) {
+        results.push({
+          url: endpoint,
+          healthy: false,
+          status: 'error',
+          message: e.message
+        });
+      }
+    }
+
+    const allHealthy = results.every(r => r.healthy);
+    return {
+      healthy: allHealthy,
+      results,
+      message: allHealthy ? 'All endpoints healthy' : 'Some endpoints unhealthy'
+    };
+  }
+
+  /**
+   * Check single endpoint
+   * @param {string} url - URL to check
+   * @returns {Object} Health result
+   */
+  async checkEndpoint(url) {
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith('https') ? https : http;
+      
+      const req = protocol.get(url, { timeout: this.timeout }, (res) => {
+        if (res.statusCode === 200) {
+          resolve({ url, healthy: true, status: res.statusCode, message: 'OK' });
+        } else if (res.statusCode >= 500) {
+          resolve({ url, healthy: false, status: res.statusCode, message: 'Server Error' });
+        } else {
+          resolve({ url, healthy: true, status: res.statusCode, message: 'OK (non-200)' });
+        }
+      });
+
+      req.on('error', (e) => {
+        resolve({ url, healthy: false, status: 'error', message: e.message });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ url, healthy: false, status: 'timeout', message: 'Request timed out' });
+      });
+    });
+  }
+}
+
+/**
+ * Check health of deployment URL
+ * @param {string} url - Deployment URL
+ * @param {Array} endpoints - Additional endpoints
+ * @returns {Object} Health result
+ */
+async function checkHealth(url, endpoints = []) {
+  const checker = new DeployHealthCheck();
+  return checker.checkHealth(url, endpoints);
+}
+
+module.exports = { DeployHealthCheck, checkHealth };