jettypod 4.1.2 → 4.1.4

package/lib/unit-test-generator.js

@@ -0,0 +1,232 @@
+/**
+ * Unit test generator
+ * Automatically scaffolds and generates Jest unit tests
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Scaffold empty unit test file with describe blocks
+ * @param {string} jsFilePath - Path to JS file to create tests for
+ * @returns {string} Path to created test file
+ */
+function scaffoldUnitTestFile(jsFilePath) {
+  const testFilePath = getTestFilePath(jsFilePath);
+
+  // Don't overwrite existing test files
+  if (fs.existsSync(testFilePath)) {
+    return testFilePath;
+  }
+
+  const fileName = path.basename(jsFilePath);
+  const moduleName = path.basename(jsFilePath, '.js');
+
+  const template = `/**
+ * Unit tests for ${fileName}
+ * Auto-generated by JettyPod unit-test-generator
+ */
+
+describe('${moduleName}', () => {
+  // TODO: Add test cases
+
+  it('should be implemented', () => {
+    expect(true).toBe(true);
+  });
+});
+`;
+
+  // Ensure test directory exists
+  const testDir = path.dirname(testFilePath);
+  if (!fs.existsSync(testDir)) {
+    fs.mkdirSync(testDir, { recursive: true });
+  }
+
+  fs.writeFileSync(testFilePath, template, 'utf8');
+  return testFilePath;
+}
+
+/**
+ * Generate tests for functions in a JS file
+ * @param {string} jsFilePath - Path to JS file
+ * @returns {string} Generated test code
+ */
+function generateTestsForFunctions(jsFilePath) {
+  const functions = extractFunctions(jsFilePath);
+
+  if (functions.length === 0) {
+    return null;
+  }
+
+  const fileName = path.basename(jsFilePath);
+  const moduleName = path.basename(jsFilePath, '.js');
+  const relativePath = path.relative(path.join(process.cwd(), 'test'), jsFilePath);
+
+  let testCode = `/**
+ * Unit tests for ${fileName}
+ * Auto-generated by JettyPod unit-test-generator
+ */
+
+const ${moduleName} = require('${relativePath.replace(/\\/g, '/')}');
+
+describe('${moduleName}', () => {
+`;
+
+  for (const func of functions) {
+    testCode += `
+  describe('${func.name}()', () => {
+    it('should handle happy path', () => {
+      // TODO: Implement happy path test
+      expect(${moduleName}.${func.name}).toBeDefined();
+    });
+
+    it('should handle error cases', () => {
+      // TODO: Implement error case tests
+    });
+
+    it('should handle edge cases', () => {
+      // TODO: Implement edge case tests
+    });
+  });
+`;
+  }
+
+  testCode += `});
+`;
+
+  return testCode;
+}
+
+/**
+ * Extract function names from JS file using regex
+ * @param {string} jsFilePath - Path to JS file
+ * @returns {Array<{name: string, line: number}>} Function info
+ */
+function extractFunctions(jsFilePath) {
+  if (!fs.existsSync(jsFilePath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(jsFilePath, 'utf8');
+  const lines = content.split('\n');
+  const functions = [];
+
+  // Match function declarations and expressions
+  const patterns = [
+    /function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/,  // function name()
+    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*function/,  // const name = function
+    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*\(/,  // const name = ()
+    /async\s+function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/,  // async function name()
+  ];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        functions.push({ name: match[1], line: i + 1 });
+        break;
+      }
+    }
+  }
+
+  return functions;
+}
+
+/**
+ * Get test file path for a JS file
+ * @param {string} jsFilePath - Path to JS file
+ * @returns {string} Path to test file
+ */
+function getTestFilePath(jsFilePath) {
+  const parsed = path.parse(jsFilePath);
+  return path.join('test', parsed.dir, `${parsed.name}.test.js`);
+}
+
+/**
+ * Check if test file exists for a JS file
+ * @param {string} jsFilePath - Path to JS file
+ * @returns {string|null} Path to test file or null
+ */
+function getExistingTestFile(jsFilePath) {
+  const testPath = getTestFilePath(jsFilePath);
+  return fs.existsSync(testPath) ? testPath : null;
+}
+
+/**
+ * Generate or update unit tests for new functions after GREEN
+ * @param {string} jsFilePath - Path to JS file
+ * @returns {{created: boolean, testFile: string, functionsAdded: number}} Result
+ */
+function generateTestsAfterGreen(jsFilePath) {
+  const testFilePath = getTestFilePath(jsFilePath);
+  const functions = extractFunctions(jsFilePath);
+
+  if (functions.length === 0) {
+    return { created: false, testFile: null, functionsAdded: 0 };
+  }
+
+  // If test file doesn't exist, generate full test file
+  if (!fs.existsSync(testFilePath)) {
+    const testCode = generateTestsForFunctions(jsFilePath);
+    const testDir = path.dirname(testFilePath);
+
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir, { recursive: true });
+    }
+
+    fs.writeFileSync(testFilePath, testCode, 'utf8');
+    return { created: true, testFile: testFilePath, functionsAdded: functions.length };
+  }
+
+  // Test file exists - check which functions need tests
+  const existingTests = fs.readFileSync(testFilePath, 'utf8');
+  const missingFunctions = functions.filter(func => {
+    const testPattern = new RegExp(`describe\\(['"\`]${func.name}\\(\\)['"\`]`);
+    return !testPattern.test(existingTests);
+  });
+
+  if (missingFunctions.length === 0) {
+    return { created: false, testFile: testFilePath, functionsAdded: 0 };
+  }
+
+  // Add tests for missing functions (append before closing brace)
+  const moduleName = path.basename(jsFilePath, '.js');
+  let additions = '';
+
+  for (const func of missingFunctions) {
+    additions += `
+  describe('${func.name}()', () => {
+    it('should handle happy path', () => {
+      // TODO: Implement happy path test
+      expect(${moduleName}.${func.name}).toBeDefined();
+    });
+
+    it('should handle error cases', () => {
+      // TODO: Implement error case tests
+    });
+
+    it('should handle edge cases', () => {
+      // TODO: Implement edge case tests
+    });
+  });
+`;
+  }
+
+  // Insert before final closing brace
+  const updatedTests = existingTests.replace(/}\);[\s]*$/, `${additions}});
+`);
+
+  fs.writeFileSync(testFilePath, updatedTests, 'utf8');
+  return { created: false, testFile: testFilePath, functionsAdded: missingFunctions.length };
+}
+
+module.exports = {
+  scaffoldUnitTestFile,
+  generateTestsForFunctions,
+  generateTestsAfterGreen,
+  extractFunctions,
+  getTestFilePath,
+  getExistingTestFile
+};

package/lib/verification-command-generator.js

@@ -0,0 +1,66 @@
+const fs = require('fs');
+
+/**
+ * Generate verification commands from scenario file and line number
+ * @param {string} scenarioFile - Path to the feature file
+ * @param {number} scenarioLine - Line number where the scenario starts
+ * @returns {{command: string, scenarioName: string}} Verification command and scenario name
+ */
+function generateVerificationCommands(scenarioFile, scenarioLine) {
+  // Handle missing scenario file
+  if (!fs.existsSync(scenarioFile)) {
+    console.warn(`⚠️  Scenario file not found: ${scenarioFile}`);
+    return {
+      command: '',
+      scenarioName: ''
+    };
+  }
+
+  // Validate scenarioLine is a positive number
+  if (!scenarioLine || scenarioLine < 1) {
+    console.warn(`⚠️  Invalid scenario line number: ${scenarioLine}`);
+    scenarioLine = 1;
+  }
+
+  let content;
+  try {
+    // Read the scenario file to extract scenario name
+    content = fs.readFileSync(scenarioFile, 'utf8');
+  } catch (err) {
+    console.warn(`⚠️  Cannot read scenario file ${scenarioFile}: ${err.message}`);
+    return {
+      command: '',
+      scenarioName: ''
+    };
+  }
+
+  const lines = content.split('\n');
+
+  // Handle line number beyond file length
+  if (scenarioLine > lines.length) {
+    console.warn(`⚠️  Line number ${scenarioLine} exceeds file length (${lines.length} lines). Using line 1 as fallback.`);
+    scenarioLine = 1;
+  }
+
+  // Generate the test command with line number
+  const command = `npm run test:bdd -- ${scenarioFile}:${scenarioLine}`;
+
+  // Find the scenario name at the given line
+  let scenarioName = '';
+  for (let i = scenarioLine - 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith('Scenario:')) {
+      scenarioName = line.replace('Scenario:', '').trim();
+      break;
+    }
+  }
+
+  return {
+    command,
+    scenarioName
+  };
+}
+
+module.exports = {
+  generateVerificationCommands
+};

package/lib/worktree-diagnostics.js

@@ -0,0 +1,413 @@
+/**
+ * Worktree Diagnostics - Health Check and Issue Detection
+ *
+ * This module provides comprehensive diagnostic capabilities for worktree health
+ * and integrity. It detects issues, provides actionable recommendations, and
+ * generates diagnostic reports.
+ *
+ * Diagnostic categories:
+ * 1. Database integrity (orphaned entries, missing references)
+ * 2. Git state (orphaned worktrees, stale branches)
+ * 3. Filesystem state (missing directories, permission issues)
+ * 4. Configuration issues (missing .jettypod symlinks, incorrect permissions)
+ */
+
+const worktreeReconciler = require('./worktree-reconciler');
+const worktreeManager = require('./worktree-manager');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Issue severity levels
+ */
+const SEVERITY = {
+  CRITICAL: 'critical',  // Prevents work from starting
+  HIGH: 'high',          // May cause data loss or corruption
+  MEDIUM: 'medium',      // May cause confusion or workflow issues
+  LOW: 'low',            // Minor issues that don't affect functionality
+  INFO: 'info'           // Informational, not an issue
+};
+
+/**
+ * Run comprehensive diagnostics on worktree state
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} repoPath - Path to main git repository
+ * @param {Object} options - Diagnostic options
+ * @param {string[]} options.checks - Specific checks to run (defaults to all)
+ * @param {string} options.minSeverity - Minimum severity to report (defaults to 'info')
+ * @returns {Promise<Object>} Diagnostic report with issues, recommendations, and summary
+ */
+async function runDiagnostics(db, repoPath, options = {}) {
+  const checks = options.checks || ['all'];
+  const minSeverity = options.minSeverity || 'info';
+
+  const report = {
+    timestamp: new Date().toISOString(),
+    repoPath: repoPath,
+    summary: {
+      totalIssues: 0,
+      critical: 0,
+      high: 0,
+      medium: 0,
+      low: 0,
+      info: 0
+    },
+    issues: [],
+    recommendations: [],
+    health: 'unknown'  // 'healthy', 'warning', 'critical'
+  };
+
+  // Run reconciliation to detect state issues
+  if (checks.includes('all') || checks.includes('state')) {
+    try {
+      const reconcileResults = await worktreeReconciler.reconcileState(db, repoPath, { cleanup: false });
+
+      // Orphaned worktrees
+      if (reconcileResults.orphanedWorktrees.length > 0) {
+        report.issues.push({
+          severity: SEVERITY.MEDIUM,
+          category: 'state',
+          type: 'orphaned_worktrees',
+          count: reconcileResults.orphanedWorktrees.length,
+          message: `Found ${reconcileResults.orphanedWorktrees.length} orphaned worktree(s) in git but not in database`,
+          details: reconcileResults.orphanedWorktrees,
+          recommendation: 'Run reconciliation with cleanup=true to remove orphaned worktrees'
+        });
+      }
+
+      // Orphaned branches
+      if (reconcileResults.orphanedBranches.length > 0) {
+        report.issues.push({
+          severity: SEVERITY.LOW,
+          category: 'state',
+          type: 'orphaned_branches',
+          count: reconcileResults.orphanedBranches.length,
+          message: `Found ${reconcileResults.orphanedBranches.length} orphaned branch(es) with no worktree`,
+          details: reconcileResults.orphanedBranches,
+          recommendation: 'Run reconciliation with cleanup=true to delete empty branches'
+        });
+      }
+
+      // Stale database entries
+      if (reconcileResults.staleDbEntries.length > 0) {
+        report.issues.push({
+          severity: SEVERITY.HIGH,
+          category: 'state',
+          type: 'stale_db_entries',
+          count: reconcileResults.staleDbEntries.length,
+          message: `Found ${reconcileResults.staleDbEntries.length} database entries with missing filesystem directories`,
+          details: reconcileResults.staleDbEntries,
+          recommendation: 'Run reconciliation with cleanup=true to mark as corrupted'
+        });
+      }
+
+      // Git-filesystem mismatches
+      if (reconcileResults.gitFilesystemMismatches.length > 0) {
+        report.issues.push({
+          severity: SEVERITY.CRITICAL,
+          category: 'state',
+          type: 'git_filesystem_mismatch',
+          count: reconcileResults.gitFilesystemMismatches.length,
+          message: `Found ${reconcileResults.gitFilesystemMismatches.length} directories that exist but git doesn't track`,
+          details: reconcileResults.gitFilesystemMismatches,
+          recommendation: 'Run reconciliation with cleanup=true to re-register with git'
+        });
+      }
+
+    } catch (err) {
+      report.issues.push({
+        severity: SEVERITY.CRITICAL,
+        category: 'state',
+        type: 'reconciliation_error',
+        message: `Failed to run state reconciliation: ${err.message}`,
+        details: { error: err.message, stack: err.stack },
+        recommendation: 'Check git repository integrity and database connection'
+      });
+    }
+  }
+
+  // Check database integrity
+  if (checks.includes('all') || checks.includes('database')) {
+    try {
+      const dbIssues = await checkDatabaseIntegrity(db);
+      report.issues.push(...dbIssues);
+    } catch (err) {
+      report.issues.push({
+        severity: SEVERITY.CRITICAL,
+        category: 'database',
+        type: 'database_check_error',
+        message: `Failed to check database integrity: ${err.message}`,
+        details: { error: err.message, stack: err.stack },
+        recommendation: 'Check database file permissions and integrity'
+      });
+    }
+  }
+
+  // Check filesystem health
+  if (checks.includes('all') || checks.includes('filesystem')) {
+    try {
+      const fsIssues = await checkFilesystemHealth(db, repoPath);
+      report.issues.push(...fsIssues);
+    } catch (err) {
+      report.issues.push({
+        severity: SEVERITY.HIGH,
+        category: 'filesystem',
+        type: 'filesystem_check_error',
+        message: `Failed to check filesystem health: ${err.message}`,
+        details: { error: err.message, stack: err.stack },
+        recommendation: 'Check filesystem permissions and disk space'
+      });
+    }
+  }
+
+  // Filter by minimum severity
+  report.issues = filterBySeverity(report.issues, minSeverity);
+
+  // Calculate summary
+  for (const issue of report.issues) {
+    report.summary.totalIssues++;
+    report.summary[issue.severity]++;
+  }
+
+  // Determine overall health
+  if (report.summary.critical > 0) {
+    report.health = 'critical';
+  } else if (report.summary.high > 0 || report.summary.medium > 0) {
+    report.health = 'warning';
+  } else {
+    report.health = 'healthy';
+  }
+
+  // Generate recommendations
+  report.recommendations = generateRecommendations(report);
+
+  return report;
+}
+
+/**
+ * Check database integrity
+ */
+async function checkDatabaseIntegrity(db) {
+  const issues = [];
+
+  // Check for corrupted worktrees
+  const corruptedCount = await new Promise((resolve, reject) => {
+    db.get('SELECT COUNT(*) as count FROM worktrees WHERE status = ?', ['corrupted'], (err, row) => {
+      if (err) reject(err);
+      else resolve(row.count);
+    });
+  });
+
+  if (corruptedCount > 0) {
+    issues.push({
+      severity: SEVERITY.INFO,
+      category: 'database',
+      type: 'corrupted_worktrees',
+      count: corruptedCount,
+      message: `Found ${corruptedCount} corrupted worktree(s) in database`,
+      details: { count: corruptedCount },
+      recommendation: 'These worktrees can be safely cleaned up or ignored'
+    });
+  }
+
+  // Check for worktrees with missing work items
+  const orphanedWorktrees = await new Promise((resolve, reject) => {
+    db.all(`
+      SELECT w.* FROM worktrees w
+      LEFT JOIN work_items wi ON w.work_item_id = wi.id
+      WHERE wi.id IS NULL
+    `, (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows);
+    });
+  });
+
+  if (orphanedWorktrees.length > 0) {
+    issues.push({
+      severity: SEVERITY.HIGH,
+      category: 'database',
+      type: 'orphaned_worktree_entries',
+      count: orphanedWorktrees.length,
+      message: `Found ${orphanedWorktrees.length} worktree(s) with missing work items`,
+      details: orphanedWorktrees,
+      recommendation: 'Mark these worktrees as corrupted'
+    });
+  }
+
+  return issues;
+}
+
+/**
+ * Check filesystem health
+ */
+async function checkFilesystemHealth(db, repoPath) {
+  const issues = [];
+
+  // Get all active worktrees
+  const activeWorktrees = await new Promise((resolve, reject) => {
+    db.all('SELECT * FROM worktrees WHERE status = ?', ['active'], (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows || []);
+    });
+  });
+
+  // Check each worktree directory
+  for (const worktree of activeWorktrees) {
+    const worktreePath = worktree.worktree_path;
+
+    // Check if directory exists
+    if (!fs.existsSync(worktreePath)) {
+      issues.push({
+        severity: SEVERITY.CRITICAL,
+        category: 'filesystem',
+        type: 'missing_worktree_directory',
+        message: `Active worktree directory missing: ${worktreePath}`,
+        details: { worktree },
+        recommendation: 'Mark worktree as corrupted and recreate if needed'
+      });
+      continue;
+    }
+
+    // Check .jettypod symlink
+    const jettypodLink = path.join(worktreePath, '.jettypod');
+    if (!fs.existsSync(jettypodLink)) {
+      issues.push({
+        severity: SEVERITY.MEDIUM,
+        category: 'filesystem',
+        type: 'missing_jettypod_symlink',
+        message: `.jettypod symlink missing in worktree: ${worktreePath}`,
+        details: { worktree, expectedLink: jettypodLink },
+        recommendation: 'Recreate symlink to .jettypod directory'
+      });
+    }
+
+    // Check directory permissions
+    try {
+      fs.accessSync(worktreePath, fs.constants.R_OK | fs.constants.W_OK);
+    } catch (err) {
+      issues.push({
+        severity: SEVERITY.CRITICAL,
+        category: 'filesystem',
+        type: 'permission_issue',
+        message: `Cannot read/write worktree directory: ${worktreePath}`,
+        details: { worktree, error: err.message },
+        recommendation: 'Fix directory permissions or mark worktree as corrupted'
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Filter issues by minimum severity
+ */
+function filterBySeverity(issues, minSeverity) {
+  const severityOrder = ['info', 'low', 'medium', 'high', 'critical'];
+  const minIndex = severityOrder.indexOf(minSeverity);
+
+  return issues.filter(issue => {
+    const issueIndex = severityOrder.indexOf(issue.severity);
+    return issueIndex >= minIndex;
+  });
+}
+
+/**
+ * Generate actionable recommendations based on issues
+ */
+function generateRecommendations(report) {
+  const recommendations = [];
+
+  if (report.summary.critical > 0) {
+    recommendations.push({
+      priority: 'urgent',
+      action: 'Run worktree reconciliation with cleanup enabled',
+      reason: 'Critical issues detected that may prevent work from starting'
+    });
+  }
+
+  if (report.summary.high > 0) {
+    recommendations.push({
+      priority: 'high',
+      action: 'Review and fix database integrity issues',
+      reason: 'High-severity issues may cause data loss or corruption'
+    });
+  }
+
+  if (report.issues.some(i => i.type === 'missing_jettypod_symlink')) {
+    recommendations.push({
+      priority: 'medium',
+      action: 'Recreate .jettypod symlinks in affected worktrees',
+      reason: 'Missing symlinks may cause configuration and database issues'
+    });
+  }
+
+  if (report.issues.some(i => i.type === 'corrupted_worktrees')) {
+    recommendations.push({
+      priority: 'low',
+      action: 'Clean up corrupted worktree entries from database',
+      reason: 'Keeping database clean improves query performance'
+    });
+  }
+
+  if (recommendations.length === 0) {
+    recommendations.push({
+      priority: 'none',
+      action: 'No action required',
+      reason: 'All worktree systems are healthy'
+    });
+  }
+
+  return recommendations;
+}
+
+/**
+ * Quick health check (lightweight version of full diagnostics)
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} repoPath - Path to main git repository
+ * @returns {Promise<Object>} Health status object
+ */
+async function quickHealthCheck(db, repoPath) {
+  const health = {
+    status: 'unknown',  // 'healthy', 'degraded', 'critical'
+    message: '',
+    issueCount: 0
+  };
+
+  try {
+    // Just check for critical issues
+    const report = await runDiagnostics(db, repoPath, {
+      checks: ['state'],
+      minSeverity: 'high'
+    });
+
+    health.issueCount = report.summary.totalIssues;
+
+    if (report.summary.critical > 0) {
+      health.status = 'critical';
+      health.message = `Found ${report.summary.critical} critical issue(s)`;
+    } else if (report.summary.high > 0) {
+      health.status = 'degraded';
+      health.message = `Found ${report.summary.high} high-severity issue(s)`;
+    } else {
+      health.status = 'healthy';
+      health.message = 'All systems operational';
+    }
+
+  } catch (err) {
+    health.status = 'critical';
+    health.message = `Health check failed: ${err.message}`;
+    health.error = err.message;
+  }
+
+  return health;
+}
+
+module.exports = {
+  runDiagnostics,
+  quickHealthCheck,
+  SEVERITY
+};