@howlil/ez-agents 3.1.0 → 3.4.1

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

@@ -4,7 +4,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const { safeExec, auditExec } = require('./safe-exec.cjs');
+const { defaultLogger: logger } = require('./logger.cjs');
 
 // ─── Path helpers ────────────────────────────────────────────────────────────
 
@@ -63,7 +64,8 @@ function error(message) {
 function safeReadFile(filePath) {
   try {
     return fs.readFileSync(filePath, 'utf-8');
-  } catch {
+  } catch (err) {
+    logger.warn('safeReadFile failed', { filePath, error: err.message });
     return null;
   }
 }
@@ -75,8 +77,8 @@ function loadConfig(cwd) {
     commit_docs: true,
     search_gitignored: false,
     branching_strategy: 'none',
-    phase_branch_template: 'gsd/phase-{phase}-{slug}',
-    milestone_branch_template: 'gsd/{milestone}-{slug}',
+    phase_branch_template: 'ez/phase-{phase}-{slug}',
+    milestone_branch_template: 'ez/{milestone}-{slug}',
     research: true,
     plan_checker: true,
     verifier: true,
@@ -94,7 +96,11 @@ function loadConfig(cwd) {
       const depthToGranularity = { quick: 'coarse', standard: 'standard', comprehensive: 'fine' };
       parsed.granularity = depthToGranularity[parsed.depth] || parsed.depth;
       delete parsed.depth;
-      try { fs.writeFileSync(configPath, JSON.stringify(parsed, null, 2), 'utf-8'); } catch {}
+      try {
+        fs.writeFileSync(configPath, JSON.stringify(parsed, null, 2), 'utf-8');
+      } catch (err) {
+        logger.warn('Failed to persist migrated config depth->granularity', { configPath, error: err.message });
+      }
     }
 
     const get = (key, nested) => {
@@ -127,42 +133,43 @@ function loadConfig(cwd) {
       brave_search: get('brave_search') ?? defaults.brave_search,
       model_overrides: parsed.model_overrides || null,
     };
-  } catch {
+  } catch (err) {
+    logger.warn('Failed to load config, using defaults', { configPath, error: err.message });
     return defaults;
   }
 }
 
 // ─── Git utilities ────────────────────────────────────────────────────────────
 
-function isGitIgnored(cwd, targetPath) {
+async function isGitIgnored(cwd, targetPath) {
   try {
     // --no-index checks .gitignore rules regardless of whether the file is tracked.
     // Without it, git check-ignore returns "not ignored" for tracked files even when
     // .gitignore explicitly lists them — a common source of confusion when .planning/
     // was committed before being added to .gitignore.
-    execSync('git check-ignore -q --no-index -- ' + targetPath.replace(/[^a-zA-Z0-9._\-/]/g, ''), {
+    const safePath = targetPath.replace(/[^a-zA-Z0-9._\-/]/g, '');
+    await auditExec('git', ['check-ignore', '-q', '--no-index', '--', safePath], {
       cwd,
-      stdio: 'pipe',
+      context: 'isGitIgnored',
+      timeout: 5000
     });
     return true;
-  } catch {
+  } catch (err) {
+    logger.warn('git check-ignore failed, assuming not ignored', { targetPath, error: err.message });
     return false;
   }
 }
 
-function execGit(cwd, args) {
+async function execGit(cwd, args) {
   try {
-    const escaped = args.map(a => {
-      if (/^[a-zA-Z0-9._\-/=:@]+$/.test(a)) return a;
-      return "'" + a.replace(/'/g, "'\\''") + "'";
-    });
-    const stdout = execSync('git ' + escaped.join(' '), {
+    const stdout = await auditExec('git', args, {
       cwd,
-      stdio: 'pipe',
-      encoding: 'utf-8',
+      context: 'execGit',
+      timeout: 30000
     });
     return { exitCode: 0, stdout: stdout.trim(), stderr: '' };
   } catch (err) {
+    logger.warn('execGit failed', { args, error: err.message });
     return {
       exitCode: err.status ?? 1,
       stdout: (err.stdout ?? '').toString().trim(),
@@ -254,7 +261,8 @@ function searchPhaseInDir(baseDir, relBase, normalized) {
       has_context: hasContext,
       has_verification: hasVerification,
     };
-  } catch {
+  } catch (err) {
+    logger.warn('Failed to search phase directory', { baseDir, normalized, error: err.message });
     return null;
   }
 }
@@ -291,7 +299,9 @@ function findPhaseInternal(cwd, phase) {
         return result;
       }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed while searching archived milestone phases', { milestonesDir, error: err.message });
+  }
 
   return null;
 }
@@ -326,7 +336,9 @@ function getArchivedPhaseDirs(cwd) {
         });
       }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to enumerate archived phase directories', { milestonesDir, error: err.message });
+  }
 
   return results;
 }
@@ -362,7 +374,8 @@ function getRoadmapPhaseInternal(cwd, phaseNum) {
       goal,
       section,
     };
-  } catch {
+  } catch (err) {
+    logger.warn('Failed to read roadmap phase metadata', { roadmapPath, phaseNum, error: err.message });
     return null;
   }
 }
@@ -391,7 +404,8 @@ function pathExistsInternal(cwd, targetPath) {
   try {
     fs.statSync(fullPath);
     return true;
-  } catch {
+  } catch (err) {
+    logger.warn('Path existence check failed', { fullPath, error: err.message });
     return false;
   }
 }
@@ -431,7 +445,8 @@ function getMilestoneInfo(cwd) {
       version: versionMatch ? versionMatch[0] : 'v1.0',
       name: 'milestone',
     };
-  } catch {
+  } catch (err) {
+    logger.warn('Failed to load milestone info, using fallback', { error: err.message });
     return { version: 'v1.0', name: 'milestone' };
   }
 }
@@ -450,7 +465,9 @@ function getMilestonePhaseFilter(cwd) {
     while ((m = phasePattern.exec(roadmap)) !== null) {
       milestonePhaseNums.add(m[1]);
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to parse milestone phases from roadmap', { error: err.message });
+  }
 
   if (milestonePhaseNums.size === 0) {
     const passAll = () => true;

package/ez-agents/bin/lib/file-lock.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD File Lock — File locking utility for concurrent write protection
+ * EZ File Lock — File locking utility for concurrent write protection
  * 
  * Uses proper-lockfile to prevent concurrent writes to planning files
  * Includes deadlock detection (30s timeout) and automatic lock cleanup
@@ -82,11 +82,11 @@ async function simpleLock(filePath, options = {}) {
         }
       }
       
-      // Try to create lock file
+      // Try to create lock file (using 'wx' flag to fail if it exists)
       fs.writeFileSync(lockPath, JSON.stringify({
         pid: process.pid,
         timestamp: Date.now()
-      }), 'utf-8');
+      }), { encoding: 'utf-8', flag: 'wx' });
       
       lockHolders.set(filePath, lockPath);
       

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD FS Utils — Cross-platform file system utilities
+ * EZ FS Utils — Cross-platform file system utilities
  * 
  * Replaces Unix commands (find, grep, head, tail) with
  * cross-platform JavaScript implementations.

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Git Utils — Safe git operations with atomic commits
+ * EZ Git Utils — Safe git operations with atomic commits
  * 
  * Provides:
  * - Atomic commits with validation

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * GSD Health Check — Health monitoring for GSD workflow
+ * EZ Health Check — Health monitoring for EZ workflow
  * 
- * Validates GSD environment and configuration
+ * Validates EZ environment and configuration
  * Used by workflows to detect failures and use fallback functions
  * 
  * Usage:
@@ -14,7 +14,6 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 
 class HealthCheck {
   /**

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Lib Index — Central export for all GSD libraries
+ * EZ Lib Index — Central export for all EZ libraries
  * 
  * Provides single import point for all utility modules.
  * 

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

@@ -4,8 +4,10 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 const { loadConfig, resolveModelInternal, findPhaseInternal, getRoadmapPhaseInternal, pathExistsInternal, generateSlugInternal, getMilestoneInfo, normalizePhaseName, toPosixPath, output, error } = require('./core.cjs');
+const { defaultLogger: logger } = require('./logger.cjs');
+const { findFiles } = require('./fs-utils.cjs');
+const { execWithTimeout } = require('./timeout-exec.cjs');
 
 function cmdInitExecutePhase(cwd, phase, raw) {
   if (!phase) {
@@ -153,31 +155,44 @@ function cmdInitPlanPhase(cwd, phase, raw) {
       if (uatFile) {
         result.uat_path = toPosixPath(path.join(phaseInfo.directory, uatFile));
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to inspect phase artifacts in cmdInitPlanPhase', { phaseDirFull, error: err.message });
+    }
   }
 
   output(result, raw);
 }
 
-function cmdInitNewProject(cwd, raw) {
+async function cmdInitNewProject(cwd, raw) {
   const config = loadConfig(cwd);
 
-  // Detect Brave Search API key availability
+  // Detect Brave Search API key availability (prefer ~/.ez)
   const homedir = require('os').homedir();
-  const braveKeyFile = path.join(homedir, '.gsd', 'brave_api_key');
-  const hasBraveSearch = !!(process.env.BRAVE_API_KEY || fs.existsSync(braveKeyFile));
+  const braveKeyCandidates = [
+    path.join(homedir, '.ez', 'brave_api_key'),
+  ];
+  const hasBraveSearch = !!(process.env.BRAVE_API_KEY || braveKeyCandidates.some(p => fs.existsSync(p)));
 
   // Detect existing code
   let hasCode = false;
   let hasPackageFile = false;
   try {
-    const files = execSync('find . -maxdepth 3 \\( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" \\) 2>/dev/null | grep -v node_modules | grep -v .git | head -5', {
-      cwd,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
+    const codeFiles = findFiles(cwd, [
+      /\.ts$/,
+      /\.js$/,
+      /\.py$/,
+      /\.go$/,
+      /\.rs$/,
+      /\.swift$/,
+      /\.java$/,
+    ], {
+      maxDepth: 3,
+      exclude: ['node_modules', '.git'],
     });
-    hasCode = files.trim().length > 0;
-  } catch {}
+    hasCode = codeFiles.length > 0;
+  } catch (err) {
+    logger.warn('Failed to detect existing source files in cmdInitNewProject', { cwd, error: err.message });
+  }
 
   hasPackageFile = pathExistsInternal(cwd, 'package.json') ||
                    pathExistsInternal(cwd, 'requirements.txt') ||
@@ -185,6 +200,18 @@ function cmdInitNewProject(cwd, raw) {
                    pathExistsInternal(cwd, 'go.mod') ||
                    pathExistsInternal(cwd, 'Package.swift');
 
+  let hasGit = pathExistsInternal(cwd, '.git');
+  try {
+    const gitProbe = await execWithTimeout('git', ['rev-parse', '--is-inside-work-tree'], { timeout: 5000, fallback: '' });
+    if (gitProbe === '') {
+      logger.info('Fallback activated during init new-project git probe', { command: 'git rev-parse --is-inside-work-tree' });
+    } else {
+      hasGit = gitProbe.trim() === 'true' || hasGit;
+    }
+  } catch (err) {
+    logger.warn('Init new-project git probe failed without fallback', { error: err.message });
+  }
+
   const result = {
     // Models
     researcher_model: resolveModelInternal(cwd, 'ez-project-researcher'),
@@ -206,7 +233,7 @@ function cmdInitNewProject(cwd, raw) {
     needs_codebase_map: (hasCode || hasPackageFile) && !pathExistsInternal(cwd, '.planning/codebase'),
 
     // Git state
-    has_git: pathExistsInternal(cwd, '.git'),
+    has_git: hasGit,
 
     // Enhanced search
     brave_search_available: hasBraveSearch,
@@ -307,7 +334,9 @@ function cmdInitResume(cwd, raw) {
   let interruptedAgentId = null;
   try {
     interruptedAgentId = fs.readFileSync(path.join(cwd, '.planning', 'current-agent-id.txt'), 'utf-8').trim();
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to read current-agent-id marker in cmdInitResume', { cwd, error: err.message });
+  }
 
   const result = {
     // File existence
@@ -436,7 +465,9 @@ function cmdInitPhaseOp(cwd, phase, raw) {
       if (uatFile) {
         result.uat_path = toPosixPath(path.join(phaseInfo.directory, uatFile));
       }
-    } catch {}
+    } catch (err) {
+      logger.warn('Failed to inspect phase artifacts in cmdInitPhaseOp', { phaseDirFull, error: err.message });
+    }
   }
 
   output(result, raw);
@@ -471,9 +502,13 @@ function cmdInitTodos(cwd, area, raw) {
           area: todoArea,
           path: '.planning/todos/pending/' + file,
         });
-      } catch {}
+      } catch (err) {
+        logger.warn('Failed to parse todo file in cmdInitTodos', { file, error: err.message });
+      }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to list pending todos in cmdInitTodos', { pendingDir, error: err.message });
+  }
 
   const result = {
     // Config
@@ -520,9 +555,13 @@ function cmdInitMilestoneOp(cwd, raw) {
         const phaseFiles = fs.readdirSync(path.join(phasesDir, dir));
         const hasSummary = phaseFiles.some(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
         if (hasSummary) completedPhases++;
-      } catch {}
+      } catch (err) {
+        logger.warn('Failed to inspect phase directory in cmdInitMilestoneOp', { dir, error: err.message });
+      }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to list phase directories in cmdInitMilestoneOp', { phasesDir, error: err.message });
+  }
 
   // Check archive
   const archiveDir = path.join(cwd, '.planning', 'archive');
@@ -531,7 +570,9 @@ function cmdInitMilestoneOp(cwd, raw) {
     archivedMilestones = fs.readdirSync(archiveDir, { withFileTypes: true })
       .filter(e => e.isDirectory())
       .map(e => e.name);
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to list archived milestones in cmdInitMilestoneOp', { archiveDir, error: err.message });
+  }
 
   const result = {
     // Config
@@ -570,7 +611,9 @@ function cmdInitMapCodebase(cwd, raw) {
   let existingMaps = [];
   try {
     existingMaps = fs.readdirSync(codebaseDir).filter(f => f.endsWith('.md'));
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to list codebase map files in cmdInitMapCodebase', { codebaseDir, error: err.message });
+  }
 
   const result = {
     // Models
@@ -646,7 +689,9 @@ function cmdInitProgress(cwd, raw) {
         nextPhase = phaseInfo;
       }
     }
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to analyze phase progress in cmdInitProgress', { phasesDir, error: err.message });
+  }
 
   // Check for paused work
   let pausedAt = null;
@@ -654,7 +699,9 @@ function cmdInitProgress(cwd, raw) {
     const state = fs.readFileSync(path.join(cwd, '.planning', 'STATE.md'), 'utf-8');
     const pauseMatch = state.match(/\*\*Paused At:\*\*\s*(.+)/);
     if (pauseMatch) pausedAt = pauseMatch[1].trim();
-  } catch {}
+  } catch (err) {
+    logger.warn('Failed to read paused state in cmdInitProgress', { cwd, error: err.message });
+  }
 
   const result = {
     // Models

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * GSD Logger — Centralized logging module for GSD workflow
+ * EZ Logger — Centralized logging module for EZ workflow
  * 
  * Provides structured logging with levels (ERROR, WARN, INFO, DEBUG)
  * Writes to .planning/logs/ez-{timestamp}.log
@@ -24,7 +24,6 @@ class Logger {
   constructor(logDir = '.planning/logs') {
     this.logDir = logDir;
     this.logFile = null;
-    this._ensureLogDir();
   }
 
   /**
@@ -42,6 +41,9 @@ class Logger {
    * @returns {string} - Path to log file
    */
   getLogFile() {
+    if (!this.logFile) {
+      this._ensureLogDir();
+    }
     return this.logFile;
   }
 
@@ -52,6 +54,11 @@ class Logger {
    * @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,
@@ -65,11 +72,11 @@ class Logger {
       
       // Always output ERROR level to console for visibility
       if (level === 'ERROR') {
-        console.error(`[GSD ${level}] ${message}`);
+        console.error(`[EZ ${level}] ${message}`);
       }
     } catch (err) {
       // Fallback: log to console if file write fails
-      console.error(`[GSD ${level}] ${message} (file write failed: ${err.message})`);
+      console.error(`[EZ ${level}] ${message} (file write failed: ${err.message})`);
     }
   }