jettypod 4.1.2 → 4.1.4

package/lib/process-manager.js

@@ -0,0 +1,140 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execPromise = promisify(exec);
+
+/**
+ * Find all processes with open file handles in the specified directory
+ * @param {string} dirPath - Directory path to search for processes
+ * @returns {Promise<Array<{pid: number, name: string}>>} Array of process info
+ */
+async function findProcessesInDirectory(dirPath) {
+  const processes = [];
+
+  try {
+    // Use lsof to find processes with file handles in the directory
+    // -t returns PIDs only, +D searches directory recursively
+    // 2>/dev/null suppresses errors, || true ensures command doesn't fail
+    const lsofCmd = `lsof +D "${dirPath}" -t 2>/dev/null || true`;
+    const { stdout } = await execPromise(lsofCmd);
+
+    const pids = stdout.trim().split('\n').filter(pid => pid);
+
+    // Get process names for each PID
+    for (const pid of pids) {
+      if (!pid) continue;
+
+      try {
+        const psCmd = `ps -p ${pid} -o comm= 2>/dev/null || echo "unknown"`;
+        const { stdout: name } = await execPromise(psCmd);
+
+        processes.push({
+          pid: parseInt(pid, 10),
+          name: name.trim()
+        });
+      } catch (err) {
+        // Process may have exited, skip it
+        continue;
+      }
+    }
+  } catch (err) {
+    // lsof command failed - log details and continue gracefully
+    console.warn('⚠️  Warning: Failed to detect processes in directory');
+    console.warn(`   Directory: ${dirPath}`);
+
+    // Provide actionable error details
+    if (err.code === 'ENOENT') {
+      console.warn('   Reason: lsof command not found');
+      console.warn('   Solution: Install lsof (brew install lsof on macOS, apt-get install lsof on Linux)');
+    } else if (err.code === 'EACCES') {
+      console.warn('   Reason: Permission denied');
+      console.warn('   Solution: Run with appropriate permissions or check directory permissions');
+    } else if (err.killed) {
+      console.warn('   Reason: Command timed out');
+      console.warn('   Solution: Directory may have too many files or processes');
+    } else {
+      console.warn(`   Reason: ${err.message}`);
+    }
+
+    console.warn('   Continuing cleanup without process termination...');
+  }
+
+  return processes;
+}
+
+/**
+ * Terminate a process gracefully with SIGTERM, falling back to SIGKILL if needed
+ * @param {number} pid - Process ID to terminate
+ * @param {number} timeout - Maximum milliseconds to wait for graceful termination (default: 2000)
+ * @returns {Promise<{pid: number, name: string, method: string}>} Termination result
+ */
+async function terminateProcessGracefully(pid, timeout = 2000) {
+  let name = 'unknown';
+
+  // Get process name
+  try {
+    const { stdout } = await execPromise(`ps -p ${pid} -o comm= 2>/dev/null || echo "unknown"`);
+    name = stdout.trim();
+  } catch (err) {
+    // Process may have exited, name stays "unknown"
+  }
+
+  // Try graceful termination with SIGTERM
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (err) {
+    // Handle termination errors
+    if (err.code === 'EPERM') {
+      console.warn(`⚠️  Warning: Permission denied when terminating process ${pid} (${name})`);
+      console.warn('   Reason: Insufficient permissions to terminate this process');
+      console.warn('   Solution: Run with elevated permissions (sudo) or check process ownership');
+      return { pid, name, method: 'permission-denied' };
+    } else if (err.code === 'ESRCH') {
+      // Process already dead or not found - this is fine
+      return { pid, name, method: 'already-terminated' };
+    } else {
+      console.warn(`⚠️  Warning: Failed to terminate process ${pid} (${name}): ${err.message}`);
+      return { pid, name, method: 'failed' };
+    }
+  }
+
+  // Wait for process to exit gracefully
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      // Check if process still exists (kill with signal 0)
+      process.kill(pid, 0);
+
+      // Still alive, wait a bit longer
+      await new Promise(resolve => setTimeout(resolve, 100));
+    } catch (err) {
+      // Process is dead
+      return { pid, name, method: 'graceful' };
+    }
+  }
+
+  // Timeout reached, force kill with SIGKILL
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch (err) {
+    // Handle force kill errors
+    if (err.code === 'EPERM') {
+      console.warn(`⚠️  Warning: Permission denied when force-killing process ${pid} (${name})`);
+      console.warn('   Reason: Insufficient permissions to force-kill this process');
+      console.warn('   Solution: Run with elevated permissions (sudo) or check process ownership');
+      return { pid, name, method: 'permission-denied' };
+    } else if (err.code === 'ESRCH') {
+      // Process exited during timeout - this is fine
+      return { pid, name, method: 'graceful' };
+    } else {
+      console.warn(`⚠️  Warning: Failed to force-kill process ${pid} (${name}): ${err.message}`);
+      return { pid, name, method: 'failed' };
+    }
+  }
+
+  return { pid, name, method: 'force-killed' };
+}
+
+module.exports = {
+  findProcessesInDirectory,
+  terminateProcessGracefully
+};

package/lib/production-standards-reader.js

@@ -11,7 +11,7 @@ async function readStandards() {
 
   // Check file exists
   if (!fs.existsSync(standardsPath)) {
-    throw new Error('Production standards file not found. Run external-transition first.');
+    throw new Error('Production standards not found');
   }
 
   // Read file with specific error handling
@@ -98,7 +98,18 @@ function validateStandardsFormat(standards) {
     }
 
     if (!standard.acceptance) {
-      throw new Error(`Standard ${standard.id} missing required field: acceptance`);
+      throw new Error(`Invalid standard format: missing acceptance field`);
+    }
+
+    // Validate infrastructure-scoped standards have all required fields
+    if (standard.scope === 'infrastructure') {
+      if (!standard.reasoning) {
+        throw new Error(`Invalid standard format: missing reasoning field`);
+      }
+
+      if (!standard.pattern) {
+        throw new Error(`Invalid standard format: missing pattern field`);
+      }
     }
   }
 }

package/lib/production-standards-writer.js

@@ -0,0 +1,85 @@
+// Production standards writer - saves production standards to file
+const fs = require('fs');
+const path = require('path');
+const { validateStandardsFormat } = require('./production-standards-reader');
+
+/**
+ * Save production standards to file
+ * @param {Object} standards - Production standards object to save
+ * @returns {void}
+ */
+function saveStandards(standards) {
+  const standardsPath = path.join(process.cwd(), '.jettypod', 'production-standards.json');
+
+  // Validate standards format before saving
+  try {
+    validateStandardsFormat(standards);
+  } catch (validationErr) {
+    throw new Error(
+      `Invalid production standards format:\n` +
+      `  ${validationErr.message}\n` +
+      `  File: ${standardsPath}`
+    );
+  }
+
+  // Ensure .jettypod directory exists
+  ensureJettypodDir();
+
+  // Write JSON with pretty formatting
+  try {
+    fs.writeFileSync(standardsPath, JSON.stringify(standards, null, 2), 'utf8');
+  } catch (writeErr) {
+    // Provide specific error messages based on error code
+    let errorMessage = `Failed to save production standards to ${standardsPath}:\n`;
+
+    if (writeErr.code === 'EACCES') {
+      errorMessage += `  Permission denied. Check file permissions:\n`;
+      errorMessage += `    chmod 644 ${standardsPath}`;
+    } else if (writeErr.code === 'ENOSPC') {
+      errorMessage += `  No space left on device. Free up disk space and try again.`;
+    } else if (writeErr.code === 'EROFS') {
+      errorMessage += `  File system is read-only. Check mount permissions.`;
+    } else {
+      errorMessage += `  ${writeErr.message}`;
+    }
+
+    throw new Error(errorMessage);
+  }
+}
+
+/**
+ * Ensure .jettypod directory exists
+ * @returns {void}
+ */
+function ensureJettypodDir() {
+  const jettypodDir = path.join(process.cwd(), '.jettypod');
+
+  if (!fs.existsSync(jettypodDir)) {
+    try {
+      fs.mkdirSync(jettypodDir, { recursive: true });
+    } catch (mkdirErr) {
+      // Provide specific error messages based on error code
+      let errorMessage = `Failed to create .jettypod directory at ${jettypodDir}:\n`;
+
+      if (mkdirErr.code === 'EACCES') {
+        errorMessage += `  Permission denied. Check parent directory permissions:\n`;
+        errorMessage += `    chmod 755 ${path.dirname(jettypodDir)}`;
+      } else if (mkdirErr.code === 'ENOSPC') {
+        errorMessage += `  No space left on device. Free up disk space and try again.`;
+      } else if (mkdirErr.code === 'EROFS') {
+        errorMessage += `  File system is read-only. Check mount permissions.`;
+      } else if (mkdirErr.code === 'EEXIST') {
+        errorMessage += `  Path exists but is not a directory. Remove the file:\n`;
+        errorMessage += `    rm ${jettypodDir}`;
+      } else {
+        errorMessage += `  ${mkdirErr.message}`;
+      }
+
+      throw new Error(errorMessage);
+    }
+  }
+}
+
+module.exports = {
+  saveStandards
+};

package/lib/skills/feature-planning/dry-run-validator.js

@@ -0,0 +1,135 @@
+const { execSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Validates BDD infrastructure by running cucumber dry-run
+ * @param {string} featureFilePath - Absolute path to .feature file
+ * @returns {Promise<{success: boolean, errors: Array, warnings: Array}>}
+ */
+async function validateBddInfrastructure(featureFilePath) {
+  const result = {
+    success: false,
+    errors: [],
+    warnings: []
+  };
+
+  try {
+    // Run cucumber-js with --dry-run flag
+    const output = execSync(
+      `npx cucumber-js --dry-run "${featureFilePath}"`,
+      {
+        cwd: path.dirname(path.dirname(path.dirname(featureFilePath))),
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe'
+      }
+    );
+
+    // If we get here, dry-run passed
+    result.success = true;
+
+    // Check for warnings in output (like deprecation notices)
+    if (output.includes('deprecated') || output.includes('warning')) {
+      result.warnings.push({
+        type: 'deprecation',
+        message: output.match(/warning.*/gi)?.[0] || 'Deprecation warning found'
+      });
+    }
+
+  } catch (error) {
+    // Dry-run failed - parse the error output
+    const errorOutput = error.stderr || error.stdout || error.message;
+
+    result.success = false;
+    result.errors = parseValidationErrors(errorOutput, featureFilePath);
+  }
+
+  return result;
+}
+
+/**
+ * Parses cucumber dry-run error output to extract specific issues
+ * @param {string} errorOutput - stderr/stdout from cucumber-js
+ * @param {string} featureFilePath - Path to feature file for context
+ * @returns {Array<{type: string, message: string, details: object}>}
+ */
+function parseValidationErrors(errorOutput, featureFilePath) {
+  const errors = [];
+
+  // Check for undefined steps
+  const undefinedStepsMatch = errorOutput.match(/Undefined\. Implement with the following snippet:([\s\S]*?)(?=\n\n|\nScenario:|\nFeature:|$)/g);
+  if (undefinedStepsMatch) {
+    undefinedStepsMatch.forEach(match => {
+      const stepText = match.match(/(?:Given|When|Then|And|But)\('(.+?)'/)?.[1];
+      if (stepText) {
+        errors.push({
+          type: 'undefined_step',
+          message: `Undefined step: "${stepText}"`,
+          details: {
+            stepText,
+            file: featureFilePath,
+            suggestedImplementation: match
+          }
+        });
+      }
+    });
+  }
+
+  // Check for syntax errors
+  const syntaxErrorMatch = errorOutput.match(/Parse error[^\n]*\n[^\n]*/);
+  if (syntaxErrorMatch) {
+    errors.push({
+      type: 'syntax_error',
+      message: syntaxErrorMatch[0],
+      details: {
+        file: featureFilePath
+      }
+    });
+  }
+
+  // Check for duplicate step definitions
+  const duplicateMatch = errorOutput.match(/Multiple step definitions match:([\s\S]*?)(?=\n\n|$)/g);
+  if (duplicateMatch) {
+    duplicateMatch.forEach(match => {
+      const stepFiles = match.match(/features\/[^\s]+\.js:\d+/g) || [];
+      errors.push({
+        type: 'duplicate_step',
+        message: 'Multiple step definitions match the same pattern',
+        details: {
+          files: stepFiles,
+          fullMessage: match
+        }
+      });
+    });
+  }
+
+  // Check for missing cucumber installation
+  if (errorOutput.includes('cucumber-js: command not found') ||
+      errorOutput.includes('Cannot find module')) {
+    errors.push({
+      type: 'missing_dependency',
+      message: 'Cucumber is not installed or not found',
+      details: {
+        suggestion: 'Run: npm install --save-dev @cucumber/cucumber'
+      }
+    });
+  }
+
+  // If no specific errors found but validation failed, add generic error
+  if (errors.length === 0) {
+    errors.push({
+      type: 'unknown',
+      message: 'Validation failed with unknown error',
+      details: {
+        output: errorOutput.substring(0, 500)
+      }
+    });
+  }
+
+  return errors;
+}
+
+module.exports = {
+  validateBddInfrastructure,
+  parseValidationErrors
+};

package/lib/skills/feature-planning/validation-formatter.js

@@ -0,0 +1,160 @@
+/**
+ * Formats dry-run validation results with colors and actionable guidance
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Formats validation result for display
+ * @param {object} result - Result from validateBddInfrastructure()
+ * @param {string} featurePath - Path to feature file being validated
+ * @returns {string} Formatted output
+ */
+function formatValidationResult(result, featurePath) {
+  const lines = [];
+
+  // Always show the validation header first
+  lines.push(chalk.cyan('🧪 Validating BDD infrastructure...'));
+  lines.push('');
+
+  if (result.success) {
+    lines.push(chalk.green('✅ BDD infrastructure validated'));
+    lines.push(chalk.green('✅ Step definitions match scenario steps'));
+
+    if (result.warnings && result.warnings.length > 0) {
+      lines.push('');
+      lines.push(chalk.yellow('⚠️  Warnings:'));
+      result.warnings.forEach(warning => {
+        lines.push(chalk.yellow(`  • ${warning.message}`));
+      });
+    }
+  } else {
+    lines.push(chalk.red('❌ BDD infrastructure validation failed'));
+    lines.push('');
+
+    // Check error types to provide specific messaging
+    const hasUndefinedSteps = result.errors.some(e => e.type === 'undefined_step');
+    const hasSyntaxErrors = result.errors.some(e => e.type === 'syntax_error');
+
+    if (hasUndefinedSteps) {
+      lines.push(chalk.red('❌ Undefined steps detected:'));
+      lines.push('');
+    }
+
+    if (result.errors && result.errors.length > 0) {
+      result.errors.forEach(error => {
+        const formatted = formatError(error, featurePath);
+        lines.push(formatted);
+        lines.push('');
+      });
+
+      // Provide specific guidance based on error types
+      if (hasUndefinedSteps) {
+        lines.push(chalk.yellow('⚠️  Fix step definitions before proceeding'));
+      } else if (hasSyntaxErrors) {
+        lines.push(chalk.yellow('⚠️  Fix the feature file before proceeding'));
+      } else {
+        lines.push(chalk.yellow('⚠️  Fix the issues above before proceeding to implementation.'));
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Formats a single validation error with guidance
+ * @param {object} error - Error object from parseValidationErrors()
+ * @param {string} featurePath - Path to feature file
+ * @returns {string} Formatted error message
+ */
+function formatError(error, featurePath) {
+  const lines = [];
+
+  switch (error.type) {
+    case 'undefined_step':
+      lines.push(chalk.red(`  Undefined step: ${chalk.bold(error.details.stepText)}`));
+      lines.push(chalk.gray(`  File: ${error.details.file}`));
+      lines.push('');
+      lines.push(chalk.cyan('  💡 Add this step definition:'));
+      lines.push(chalk.gray(indent(extractStepDefinition(error.details.suggestedImplementation), 5)));
+      break;
+
+    case 'syntax_error':
+      lines.push(chalk.red(`  Syntax error in feature file`));
+      lines.push(chalk.gray(`  ${error.message}`));
+      lines.push('');
+      lines.push(chalk.cyan('  💡 Check your Gherkin syntax:'));
+      lines.push(chalk.gray('     • Ensure proper indentation'));
+      lines.push(chalk.gray('     • Verify Feature/Scenario keywords are correctly placed'));
+      lines.push(chalk.gray('     • Check for missing colons after keywords'));
+      break;
+
+    case 'duplicate_step':
+      lines.push(chalk.red(`  Duplicate step definitions detected`));
+      lines.push(chalk.gray(`  ${error.message}`));
+      if (error.details.files && error.details.files.length > 0) {
+        lines.push('');
+        lines.push(chalk.cyan('  💡 Found in these files:'));
+        error.details.files.forEach(file => {
+          lines.push(chalk.gray(`     • ${file}`));
+        });
+        lines.push('');
+        lines.push(chalk.gray('     Remove or rename one of the duplicate definitions'));
+      }
+      break;
+
+    case 'missing_dependency':
+      lines.push(chalk.red(`  Missing dependency: Cucumber`));
+      lines.push(chalk.gray(`  ${error.message}`));
+      lines.push('');
+      lines.push(chalk.cyan('  💡 Install Cucumber:'));
+      lines.push(chalk.gray(`     ${error.details.suggestion}`));
+      break;
+
+    case 'unknown':
+    default:
+      lines.push(chalk.red(`  Validation failed: ${error.message}`));
+      if (error.details && error.details.output) {
+        lines.push('');
+        lines.push(chalk.gray('  Error output:'));
+        lines.push(chalk.gray(indent(error.details.output, 5)));
+      }
+      break;
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Extracts step definition code from cucumber suggestion
+ * @param {string} suggestion - Cucumber's suggested implementation
+ * @returns {string} Clean step definition code
+ */
+function extractStepDefinition(suggestion) {
+  // Extract the step definition code (everything after "Implement with the following snippet:")
+  const match = suggestion.match(/(?:Given|When|Then|And|But)\([^)]+\)[^{]*\{[^}]*\}/);
+  if (match) {
+    return match[0];
+  }
+
+  // Fallback: return first few lines of the suggestion
+  const lines = suggestion.split('\n').slice(1, 4);
+  return lines.join('\n');
+}
+
+/**
+ * Indents text by a given number of spaces
+ * @param {string} text - Text to indent
+ * @param {number} spaces - Number of spaces to indent
+ * @returns {string} Indented text
+ */
+function indent(text, spaces) {
+  const prefix = ' '.repeat(spaces);
+  return text.split('\n').map(line => prefix + line).join('\n');
+}
+
+module.exports = {
+  formatValidationResult,
+  formatError
+};