jettypod 4.1.2 → 4.1.4

package/lib/git-hook-helpers.js

@@ -0,0 +1,174 @@
+/**
+ * Git hook helpers for context-aware testing
+ *
+ * Provides utilities for detecting work context and running appropriate tests
+ * based on the current workflow phase (speed/stable/production mode).
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Detect current work context from CLAUDE.md
+ *
+ * @returns {{mode: string, feature_id: number, feature_title: string, scenario_file: string} | null}
+ */
+function detectWorkContext() {
+  try {
+    const projectRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
+    const claudeMdPath = path.join(projectRoot, 'CLAUDE.md');
+
+    if (!fs.existsSync(claudeMdPath)) {
+      return null;
+    }
+
+    const claudeMd = fs.readFileSync(claudeMdPath, 'utf8');
+
+    // Extract current work from <current_work> tag
+    const currentWorkMatch = claudeMd.match(/<current_work>([\s\S]*?)<\/current_work>/);
+    if (!currentWorkMatch) {
+      return null;
+    }
+
+    const currentWorkBlock = currentWorkMatch[1];
+
+    // Parse work item ID from "Working on: [#123] Title (type)"
+    const workingOnMatch = currentWorkBlock.match(/Working on:\s*\[#(\d+)\]/);
+    if (!workingOnMatch) {
+      return null;
+    }
+
+    const workItemId = parseInt(workingOnMatch[1], 10);
+
+    // Get work item details from database
+    const { getDb } = require('./database');
+    const db = getDb();
+
+    return new Promise((resolve, reject) => {
+      db.get(`
+        SELECT
+          w.id,
+          w.title,
+          w.mode,
+          w.parent_id,
+          f.title as feature_title,
+          f.scenario_file
+        FROM work_items w
+        LEFT JOIN work_items f ON w.parent_id = f.id
+        WHERE w.id = ?
+      `, [workItemId], (err, row) => {
+        db.close();
+
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        if (!row) {
+          resolve(null);
+          return;
+        }
+
+        // Determine mode (use work item's mode, or parent feature's mode if chore)
+        const mode = row.mode || 'speed';
+
+        resolve({
+          mode,
+          feature_id: row.parent_id || row.id,
+          feature_title: row.feature_title || row.title,
+          scenario_file: row.scenario_file
+        });
+      });
+    });
+  } catch (err) {
+    console.error('Error detecting work context:', err.message);
+    return null;
+  }
+}
+
+/**
+ * Run context-aware tests based on workflow phase
+ *
+ * @param {{mode: string, feature_id: number, feature_title: string, scenario_file: string}} context
+ * @returns {{success: boolean, error?: string}}
+ */
+function runContextualTests(context) {
+  try {
+    const {
+      runBddTestWithTimeout,
+      runBddScenarioWithTimeout,
+      getFirstScenarioLine
+    } = require('../.claude/skills/speed-mode/test-runner');
+
+    if (!context.scenario_file) {
+      return { success: true }; // No scenario file, skip tests
+    }
+
+    const projectRoot = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim();
+    const scenarioPath = path.join(projectRoot, context.scenario_file);
+
+    if (!fs.existsSync(scenarioPath)) {
+      return { success: true }; // Scenario file doesn't exist yet, skip tests
+    }
+
+    let result;
+
+    switch (context.mode) {
+      case 'speed':
+        // Speed mode: Quick smoke test (happy path scenario only)
+        console.log('Speed mode: Running happy path scenario...');
+        const happyPathLine = getFirstScenarioLine(context.scenario_file);
+        if (!happyPathLine) {
+          return { success: true }; // No scenarios yet
+        }
+        result = runBddScenarioWithTimeout(context.scenario_file, happyPathLine, 30000); // 30s timeout
+        break;
+
+      case 'stable':
+        // Stable mode: Feature-specific tests (all scenarios in current feature)
+        console.log('Stable mode: Running all feature scenarios...');
+        result = runBddTestWithTimeout(context.scenario_file, 60000); // 60s timeout
+        break;
+
+      case 'production':
+        // Production mode: Comprehensive tests (entire suite)
+        console.log('Production mode: Running full test suite...');
+        result = runBddTestWithTimeout(context.scenario_file, 120000); // 120s timeout
+        break;
+
+      default:
+        // Unknown mode, skip tests
+        return { success: true };
+    }
+
+    // Check if tests timed out
+    if (result.timedOut) {
+      return {
+        success: false,
+        error: 'Tests timed out. Check for infinite loops or hanging processes.'
+      };
+    }
+
+    // Check if tests passed
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        error: `Tests failed with exit code ${result.exitCode}.\n\n${result.stderr || result.stdout}`
+      };
+    }
+
+    return { success: true };
+
+  } catch (err) {
+    return {
+      success: false,
+      error: `Test execution error: ${err.message}`
+    };
+  }
+}
+
+module.exports = {
+  detectWorkContext,
+  runContextualTests
+};

package/lib/git-root.js

@@ -0,0 +1,90 @@
+/**
+ * Git Root Detection - SAFE VERSION
+ *
+ * Calculates the REAL git root directory ONCE at startup, before any
+ * worktree operations. This prevents catastrophic bugs where process.cwd()
+ * returns a worktree path instead of the main repo.
+ *
+ * CRITICAL: This module MUST be required at the top of jettypod.js BEFORE
+ * any worktree operations.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+let cachedGitRoot = null;
+
+/**
+ * Get the REAL git root directory (main repository, not worktree)
+ *
+ * This function:
+ * 1. Uses --git-common-dir to find the shared .git directory
+ * 2. Verifies it's actually the main repo (not a worktree)
+ * 3. Caches the result to prevent re-calculation
+ *
+ * @returns {string} Absolute path to git root
+ * @throws {Error} If not in a git repository or can't determine root
+ */
+function getGitRoot() {
+  if (cachedGitRoot) {
+    return cachedGitRoot;
+  }
+
+  try {
+    // Step 1: Get the common git directory (shared across worktrees)
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: process.cwd(),
+      encoding: 'utf8'
+    }).trim();
+
+    // Step 2: Resolve to absolute path
+    const absoluteGitDir = path.isAbsolute(gitCommonDir)
+      ? gitCommonDir
+      : path.resolve(process.cwd(), gitCommonDir);
+
+    // Step 3: Get the directory containing .git
+    const gitRoot = path.dirname(absoluteGitDir);
+
+    // Step 4: SAFETY VERIFICATION - ensure this is the MAIN repository
+    // Check 1: .jettypod directory must exist
+    const jettypodPath = path.join(gitRoot, '.jettypod');
+    if (!fs.existsSync(jettypodPath)) {
+      throw new Error(`SAFETY: .jettypod not found in ${gitRoot} - may be a worktree`);
+    }
+
+    // Check 2: Verify with git that this is the top-level directory
+    const gitTopLevel = execSync('git rev-parse --show-toplevel', {
+      cwd: gitRoot,
+      encoding: 'utf8'
+    }).trim();
+
+    if (gitTopLevel !== gitRoot) {
+      throw new Error(`SAFETY: Calculated git root ${gitRoot} does not match git top-level ${gitTopLevel}`);
+    }
+
+    // Check 3: Ensure we're not in a worktree subdirectory
+    if (gitRoot.includes('.jettypod-work')) {
+      throw new Error(`SAFETY: Calculated git root contains .jettypod-work - this is a worktree, not main repo`);
+    }
+
+    // Success - cache and return
+    cachedGitRoot = gitRoot;
+    return cachedGitRoot;
+
+  } catch (err) {
+    throw new Error(`Failed to determine git root: ${err.message}`);
+  }
+}
+
+/**
+ * Reset the cached git root (for testing only)
+ */
+function resetCache() {
+  cachedGitRoot = null;
+}
+
+module.exports = {
+  getGitRoot,
+  resetCache
+};

package/lib/infrastructure-chore-generator.js

@@ -0,0 +1,45 @@
+// Infrastructure chore generator - creates chores from infrastructure-scoped standards
+const { getDb } = require('./database');
+
+/**
+ * Generate chores from infrastructure-scoped standards
+ * @param {number} epicId - ID of the parent epic
+ * @param {Array} standards - Array of all production standards
+ * @returns {Array<number>} Array of created chore IDs
+ */
+function generateInfrastructureChores(epicId, standards) {
+  const db = getDb();
+  const infraStandards = standards.filter(s => s.scope === 'infrastructure');
+
+  // Handle empty infrastructure standards - emit warning
+  if (infraStandards.length === 0) {
+    console.log('Warning: No infrastructure standards found');
+    return [];
+  }
+
+  const choreIds = [];
+
+  for (const standard of infraStandards) {
+    const description = [
+      `**Acceptance Criteria:**`,
+      standard.acceptance,
+      ``,
+      `**Reasoning:**`,
+      standard.reasoning,
+      ``,
+      `**Implementation Pattern:**`,
+      standard.pattern
+    ].join('\n');
+
+    const result = db.prepare(`
+      INSERT INTO work (type, title, description, status, parent_id)
+      VALUES (?, ?, ?, ?, ?)
+    `).run('chore', standard.id, description, 'backlog', epicId);
+
+    choreIds.push(result.lastInsertRowid);
+  }
+
+  return choreIds;
+}
+
+module.exports = { generateInfrastructureChores };

package/lib/install-hooks.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Find the actual git directory (handles worktrees)
+ */
+function findGitDir() {
+  try {
+    const gitDir = execSync('git rev-parse --git-dir', { encoding: 'utf8' }).trim();
+    return path.resolve(gitDir);
+  } catch (err) {
+    throw new Error('Not in a git repository');
+  }
+}
+
+/**
+ * Install git hooks from hooks/ directory to .git/hooks/
+ */
+function installHooks() {
+  const hooksDir = path.join(__dirname, '..', 'hooks');
+  const gitDir = findGitDir();
+  const gitHooksDir = path.join(gitDir, 'hooks');
+
+  // Ensure .git/hooks exists
+  if (!fs.existsSync(gitHooksDir)) {
+    fs.mkdirSync(gitHooksDir, { recursive: true });
+  }
+
+  // Copy all hooks
+  const hookFiles = fs.readdirSync(hooksDir);
+
+  hookFiles.forEach(hookFile => {
+    const sourcePath = path.join(hooksDir, hookFile);
+    const destPath = path.join(gitHooksDir, hookFile);
+
+    // Copy the hook
+    fs.copyFileSync(sourcePath, destPath);
+
+    // Make it executable
+    fs.chmodSync(destPath, '755');
+
+    console.log(`✓ Installed ${hookFile}`);
+  });
+}
+
+module.exports = { installHooks };
+
+// Run if called directly
+if (require.main === module) {
+  installHooks();
+}

package/lib/jettypod-backup.js

@@ -0,0 +1,238 @@
+/**
+ * JettyPod Backup Manager
+ *
+ * Automatic backups of .jettypod directory before any destructive operation.
+ * This is a critical safety measure to prevent catastrophic data loss.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Create a backup of the .jettypod directory
+ *
+ * @param {string} gitRoot - Absolute path to git repository root
+ * @param {string} reason - Human-readable reason for backup (e.g., "cleanup-worktree-1234")
+ * @returns {Promise<Object>} Result with success status and backup path
+ */
+async function createBackup(gitRoot, reason = 'unknown') {
+  const jettypodPath = path.join(gitRoot, '.jettypod');
+
+  // Verify .jettypod exists
+  if (!fs.existsSync(jettypodPath)) {
+    return {
+      success: false,
+      error: '.jettypod directory does not exist',
+      backupPath: null
+    };
+  }
+
+  // Create backup directory if it doesn't exist
+  const backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
+  if (!fs.existsSync(backupBaseDir)) {
+    fs.mkdirSync(backupBaseDir, { recursive: true });
+  }
+
+  // Generate timestamped backup name
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const sanitizedReason = reason.replace(/[^a-zA-Z0-9-]/g, '-');
+  const backupName = `jettypod-${timestamp}-${sanitizedReason}`;
+  const backupPath = path.join(backupBaseDir, backupName);
+
+  try {
+    // Copy entire .jettypod directory
+    execSync(`cp -R "${jettypodPath}" "${backupPath}"`, {
+      stdio: 'pipe'
+    });
+
+    // Verify backup was created
+    if (!fs.existsSync(backupPath)) {
+      throw new Error('Backup directory was not created');
+    }
+
+    // Clean up old backups (keep last 10)
+    await cleanupOldBackups(backupBaseDir, 10);
+
+    return {
+      success: true,
+      backupPath: backupPath,
+      timestamp: timestamp
+    };
+
+  } catch (err) {
+    return {
+      success: false,
+      error: err.message,
+      backupPath: null
+    };
+  }
+}
+
+/**
+ * Clean up old backups, keeping only the N most recent
+ *
+ * @param {string} backupDir - Directory containing backups
+ * @param {number} keepCount - Number of backups to keep
+ */
+async function cleanupOldBackups(backupDir, keepCount = 10) {
+  try {
+    const backups = fs.readdirSync(backupDir)
+      .filter(name => name.startsWith('jettypod-'))
+      .map(name => ({
+        name: name,
+        path: path.join(backupDir, name),
+        mtime: fs.statSync(path.join(backupDir, name)).mtime
+      }))
+      .sort((a, b) => b.mtime - a.mtime); // Sort newest first
+
+    // Delete old backups
+    const toDelete = backups.slice(keepCount);
+    for (const backup of toDelete) {
+      fs.rmSync(backup.path, { recursive: true, force: true });
+    }
+  } catch (err) {
+    // Non-fatal - just log warning
+    console.warn(`Warning: Could not cleanup old backups: ${err.message}`);
+  }
+}
+
+/**
+ * List available backups
+ *
+ * @param {string} gitRoot - Absolute path to git repository root
+ * @returns {Array} List of backup objects with name, path, timestamp
+ */
+function listBackups(gitRoot) {
+  const backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
+
+  if (!fs.existsSync(backupBaseDir)) {
+    return [];
+  }
+
+  try {
+    return fs.readdirSync(backupBaseDir)
+      .filter(name => name.startsWith('jettypod-'))
+      .map(name => {
+        const backupPath = path.join(backupBaseDir, name);
+        const stat = fs.statSync(backupPath);
+        return {
+          name: name,
+          path: backupPath,
+          created: stat.mtime,
+          size: getDirectorySize(backupPath)
+        };
+      })
+      .sort((a, b) => b.created - a.created); // Sort newest first
+  } catch (err) {
+    console.error(`Error listing backups: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Restore from a backup
+ *
+ * @param {string} gitRoot - Absolute path to git repository root
+ * @param {string} backupName - Name of backup to restore (or 'latest')
+ * @returns {Promise<Object>} Result with success status
+ */
+async function restoreBackup(gitRoot, backupName = 'latest') {
+  const backupBaseDir = path.join(gitRoot, '.git', 'jettypod-backups');
+
+  if (!fs.existsSync(backupBaseDir)) {
+    return {
+      success: false,
+      error: 'No backups directory found'
+    };
+  }
+
+  let backupPath;
+
+  if (backupName === 'latest') {
+    const backups = listBackups(gitRoot);
+    if (backups.length === 0) {
+      return {
+        success: false,
+        error: 'No backups available'
+      };
+    }
+    backupPath = backups[0].path;
+    backupName = backups[0].name;
+  } else {
+    backupPath = path.join(backupBaseDir, backupName);
+    if (!fs.existsSync(backupPath)) {
+      return {
+        success: false,
+        error: `Backup not found: ${backupName}`
+      };
+    }
+  }
+
+  const jettypodPath = path.join(gitRoot, '.jettypod');
+
+  try {
+    // Create backup of current .jettypod before restoring
+    if (fs.existsSync(jettypodPath)) {
+      const preRestoreBackup = await createBackup(gitRoot, 'pre-restore');
+      if (!preRestoreBackup.success) {
+        console.warn(`Warning: Could not backup current .jettypod: ${preRestoreBackup.error}`);
+      }
+    }
+
+    // Remove current .jettypod
+    if (fs.existsSync(jettypodPath)) {
+      fs.rmSync(jettypodPath, { recursive: true, force: true });
+    }
+
+    // Copy backup to .jettypod
+    execSync(`cp -R "${backupPath}" "${jettypodPath}"`, {
+      stdio: 'pipe'
+    });
+
+    // Verify restore
+    if (!fs.existsSync(jettypodPath)) {
+      throw new Error('Restore failed - .jettypod directory was not created');
+    }
+
+    return {
+      success: true,
+      restoredFrom: backupName
+    };
+
+  } catch (err) {
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+
+/**
+ * Get total size of a directory
+ */
+function getDirectorySize(dirPath) {
+  let totalSize = 0;
+
+  function traverse(currentPath) {
+    const stats = fs.statSync(currentPath);
+
+    if (stats.isFile()) {
+      totalSize += stats.size;
+    } else if (stats.isDirectory()) {
+      const files = fs.readdirSync(currentPath);
+      for (const file of files) {
+        traverse(path.join(currentPath, file));
+      }
+    }
+  }
+
+  traverse(dirPath);
+  return totalSize;
+}
+
+module.exports = {
+  createBackup,
+  listBackups,
+  restoreBackup
+};