jettypod 4.1.2 → 4.1.4

package/lib/push-queue.js

@@ -1,417 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Get path to push queue file
- * @returns {string} Absolute path to push-queue.json
- */
-function getQueueFilePath() {
-  return path.join(process.cwd(), '.jettypod', 'push-queue.json');
-}
-
-/**
- * Ensure .jettypod directory exists
- */
-function ensureJettypodDir() {
-  const dir = path.join(process.cwd(), '.jettypod');
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-/**
- * Initialize empty queue file if it doesn't exist
- */
-function initializeQueueFile() {
-  const queuePath = getQueueFilePath();
-  if (!fs.existsSync(queuePath)) {
-    ensureJettypodDir();
-    fs.writeFileSync(queuePath, JSON.stringify({ queue: [] }, null, 2));
-  }
-}
-
-/**
- * Read queue from file
- * @returns {Object} Queue object with queue array
- */
-function readQueue() {
-  initializeQueueFile();
-  const queuePath = getQueueFilePath();
-  try {
-    const content = fs.readFileSync(queuePath, 'utf-8');
-    return JSON.parse(content);
-  } catch (err) {
-    // Handle corrupted JSON - reinitialize and continue
-    if (err instanceof SyntaxError) {
-      console.warn('⚠️  Push queue file corrupted - reinitializing with empty queue');
-      const emptyQueue = { queue: [] };
-      try {
-        fs.writeFileSync(queuePath, JSON.stringify(emptyQueue, null, 2));
-        return emptyQueue;
-      } catch (writeErr) {
-        throw new Error(`Cannot recover corrupted queue: ${writeErr.message}`);
-      }
-    }
-    throw new Error(`Failed to read push queue: ${err.message}`);
-  }
-}
-
-/**
- * Write queue to file
- * @param {Object} queueData - Queue object to write
- */
-function writeQueue(queueData) {
-  const queuePath = getQueueFilePath();
-  try {
-    fs.writeFileSync(queuePath, JSON.stringify(queueData, null, 2));
-  } catch (err) {
-    // Handle permission errors
-    if (err.code === 'EACCES' || err.code === 'EPERM') {
-      console.error('❌ Insufficient permissions to write push queue');
-      console.error(`   File: ${queuePath}`);
-      console.error('');
-      console.error('To fix permissions:');
-      console.error(`   chmod u+w ${path.dirname(queuePath)}`);
-      console.error(`   chmod u+w ${queuePath}`);
-      throw new Error('Insufficient permissions - see guidance above');
-    }
-
-    // Handle disk full errors
-    if (err.code === 'ENOSPC') {
-      console.error('❌ Disk full - cannot write push queue');
-      console.error('   Free up disk space and try again');
-      throw new Error('Disk full - cannot write queue file');
-    }
-
-    throw new Error(`Failed to write push queue: ${err.message}`);
-  }
-}
-
-/**
- * Get current queue
- * @returns {Array} Array of queue entries
- */
-function getQueue() {
-  const data = readQueue();
-
-  // Filter out invalid entries
-  const validEntries = [];
-  const invalidEntries = [];
-
-  for (const entry of data.queue) {
-    // Check if entry has required fields
-    if (!entry.instanceId || typeof entry.instanceId !== 'string' || entry.instanceId.trim() === '') {
-      invalidEntries.push(entry);
-      continue;
-    }
-
-    if (!entry.commitSha || typeof entry.commitSha !== 'string' || entry.commitSha.trim() === '') {
-      invalidEntries.push(entry);
-      continue;
-    }
-
-    validEntries.push(entry);
-  }
-
-  // Log warning about invalid entries
-  if (invalidEntries.length > 0) {
-    console.warn(`⚠️  Found ${invalidEntries.length} invalid queue entries - removing them`);
-    console.warn('   Invalid entries detected with missing instanceId or commitSha');
-
-    // Write back cleaned queue if we found invalid entries
-    data.queue = validEntries;
-    writeQueue(data);
-  }
-
-  return validEntries;
-}
-
-/**
- * Check if queue is empty
- * @returns {boolean} True if queue has no entries
- */
-function isEmpty() {
-  const queue = getQueue();
-  return queue.length === 0;
-}
-
-/**
- * Add instance to queue
- * @param {string} instanceId - Unique identifier for Claude instance
- * @param {string} commitSha - SHA of commit to push
- * @returns {number} Position in queue (1-indexed)
- */
-function addToQueue(instanceId, commitSha) {
-  // Validate instanceId
-  if (!instanceId || typeof instanceId !== 'string' || instanceId.trim() === '') {
-    console.error('❌ Invalid instance ID provided to queue');
-    console.error('   Instance ID must be a non-empty string');
-    throw new Error('Invalid instance ID - cannot add to queue');
-  }
-
-  // Validate commitSha
-  if (!commitSha || typeof commitSha !== 'string' || commitSha.trim() === '') {
-    console.error('❌ Invalid commit SHA provided to queue');
-    console.error('   Commit SHA must be a non-empty string');
-    console.error('');
-    console.error('To fix:');
-    console.error('   Ensure you have committed your changes before pushing');
-    console.error('   Run: git rev-parse HEAD');
-    throw new Error('Invalid commit SHA - cannot add to queue');
-  }
-
-  const data = readQueue();
-  const position = data.queue.length + 1;
-
-  const entry = {
-    instanceId,
-    commitSha,
-    position,
-    timestamp: Date.now(),
-    status: 'waiting'
-  };
-
-  data.queue.push(entry);
-  writeQueue(data);
-
-  return position;
-}
-
-/**
- * Validate queue integrity
- * @param {Array} queue - Queue entries to validate
- * @returns {Object} Validation result with isValid and issues array
- */
-function validateQueueIntegrity(queue) {
-  const issues = [];
-
-  // Check positions are sequential and match array indices
-  const positionSet = new Set();
-
-  queue.forEach((entry, index) => {
-    const expectedPosition = index + 1;
-
-    // Check if position matches index
-    if (entry.position !== expectedPosition) {
-      issues.push({
-        type: 'position_mismatch',
-        instanceId: entry.instanceId,
-        expected: expectedPosition,
-        actual: entry.position
-      });
-    }
-
-    // Check for duplicate positions
-    if (positionSet.has(entry.position)) {
-      issues.push({
-        type: 'duplicate_position',
-        position: entry.position,
-        instanceId: entry.instanceId
-      });
-    }
-    positionSet.add(entry.position);
-  });
-
-  // Check for gaps in positions (should be 1, 2, 3... without skips)
-  const positions = queue.map(e => e.position).sort((a, b) => a - b);
-  for (let i = 0; i < positions.length; i++) {
-    if (positions[i] !== i + 1) {
-      issues.push({
-        type: 'position_gap',
-        expected: i + 1,
-        found: positions[i]
-      });
-    }
-  }
-
-  return {
-    isValid: issues.length === 0,
-    issues
-  };
-}
-
-/**
- * Detect position changes between old and new queue states
- * @param {Array} oldQueue - Previous queue state
- * @param {Array} newQueue - New queue state
- * @returns {Array} List of position changes
- */
-function detectPositionChanges(oldQueue, newQueue) {
-  const changes = [];
-
-  // Build maps for quick lookup
-  const oldPositions = new Map();
-  oldQueue.forEach(entry => {
-    oldPositions.set(entry.instanceId, entry.position);
-  });
-
-  const newPositions = new Map();
-  newQueue.forEach(entry => {
-    newPositions.set(entry.instanceId, entry.position);
-  });
-
-  // Check each instance in new queue for position changes
-  newQueue.forEach(entry => {
-    const oldPosition = oldPositions.get(entry.instanceId);
-
-    if (oldPosition !== undefined && oldPosition !== entry.position) {
-      changes.push({
-        instanceId: entry.instanceId,
-        oldPosition,
-        newPosition: entry.position,
-        change: oldPosition - entry.position // Positive means moved up
-      });
-    }
-  });
-
-  return changes;
-}
-
-/**
- * Remove instance from queue
- * @param {string} instanceId - Instance to remove
- */
-function removeFromQueue(instanceId) {
-  const data = readQueue();
-
-  // Capture old queue state for position change detection
-  const oldQueue = [...data.queue];
-
-  // Remove entry
-  data.queue = data.queue.filter(entry => entry.instanceId !== instanceId);
-
-  // Recompute positions
-  data.queue.forEach((entry, index) => {
-    entry.position = index + 1;
-  });
-
-  // Detect position changes
-  const positionChanges = detectPositionChanges(oldQueue, data.queue);
-
-  // Log position changes
-  if (positionChanges.length > 0) {
-    console.log(`📊 Queue position changes after removing ${instanceId}:`);
-    positionChanges.forEach(change => {
-      console.log(`   • Instance ${change.instanceId}: position ${change.oldPosition} → ${change.newPosition} (moved up ${change.change} positions)`);
-    });
-  }
-
-  // Validate queue integrity
-  const validation = validateQueueIntegrity(data.queue);
-  if (!validation.isValid) {
-    console.error('⚠️  Queue integrity issues detected:');
-    validation.issues.forEach(issue => {
-      console.error(`   • ${issue.type}:`, issue);
-    });
-  }
-
-  writeQueue(data);
-}
-
-/**
- * Get position of instance in queue
- * @param {string} instanceId - Instance to check
- * @returns {number|null} Position (1-indexed) or null if not in queue
- */
-function getPosition(instanceId) {
-  const queue = getQueue();
-  const entry = queue.find(e => e.instanceId === instanceId);
-  return entry ? entry.position : null;
-}
-
-/**
- * Get number of entries ahead in queue
- * @param {string} instanceId - Instance to check
- * @returns {number} Number of entries ahead
- */
-function getEntriesAhead(instanceId) {
-  const position = getPosition(instanceId);
-  if (!position) return 0;
-  return position - 1;
-}
-
-/**
- * Clean up stale entries from queue
- * @param {number} timeoutMs - Timeout in milliseconds (default 1 hour)
- * @returns {number} Number of stale entries removed
- */
-function cleanupStaleEntries(timeoutMs = 3600000) {
-  const data = readQueue();
-  const now = Date.now();
-  const oldQueue = [...data.queue];
-
-  // Filter out stale entries
-  const staleEntries = [];
-  data.queue = data.queue.filter(entry => {
-    // Handle missing or invalid timestamps
-    if (!entry.timestamp || typeof entry.timestamp !== 'number') {
-      staleEntries.push(entry);
-      return false; // Remove entries with invalid timestamps
-    }
-
-    const age = now - entry.timestamp;
-
-    // Handle negative age (clock skew)
-    if (age < 0) {
-      console.warn(`⚠️  Entry ${entry.instanceId} has future timestamp - keeping but may indicate clock skew`);
-      return true;
-    }
-
-    if (age > timeoutMs) {
-      staleEntries.push(entry);
-      return false; // Remove stale entry
-    }
-    return true; // Keep fresh entry
-  });
-
-  // If entries were removed, recalculate positions and log
-  if (staleEntries.length > 0) {
-    // Recompute positions
-    data.queue.forEach((entry, index) => {
-      entry.position = index + 1;
-    });
-
-    // Detect position changes
-    const changes = detectPositionChanges(oldQueue, data.queue);
-
-    // Log stale entry removal
-    console.log(`🧹 Removed ${staleEntries.length} stale queue entries`);
-    staleEntries.forEach(entry => {
-      const waitTime = entry.timestamp ? Math.floor((now - entry.timestamp) / 60000) : 'unknown';
-      console.log(`   • Instance ${entry.instanceId} (waiting ${waitTime} minutes)`);
-    });
-
-    // Log position changes
-    if (changes.length > 0) {
-      console.log(`📊 Queue position changes after cleanup:`);
-      changes.forEach(change => {
-        console.log(`   • Instance ${change.instanceId}: position ${change.oldPosition} → ${change.newPosition} (moved up ${change.change} positions)`);
-      });
-    }
-
-    // Validate queue integrity
-    const validation = validateQueueIntegrity(data.queue);
-    if (!validation.isValid) {
-      console.error('⚠️  Queue integrity issues detected after cleanup:');
-      validation.issues.forEach(issue => {
-        console.error(`   • ${issue.type}:`, issue);
-      });
-    }
-
-    writeQueue(data);
-  }
-
-  return staleEntries.length;
-}
-
-module.exports = {
-  getQueue,
-  isEmpty,
-  addToQueue,
-  removeFromQueue,
-  getPosition,
-  getEntriesAhead,
-  validateQueueIntegrity,
-  detectPositionChanges,
-  cleanupStaleEntries
-};

package/lib/queue-processor.js

@@ -1,74 +0,0 @@
-const { getQueue, removeFromQueue, getPosition, getEntriesAhead } = require('./push-queue');
-const { rebaseOnMain, pushDirectlyToMain } = require('./git-coordinator');
-
-/**
- * Check if it's this instance's turn to push
- * @param {string} instanceId - Instance to check
- * @returns {boolean} True if at position 1
- */
-function isMyTurn(instanceId) {
-  const position = getPosition(instanceId);
-  return position === 1;
-}
-
-/**
- * Wait for turn by polling queue
- * @param {string} instanceId - Instance to wait for
- * @param {number} pollInterval - Milliseconds between checks (default: 5000)
- * @returns {Promise<void>} Resolves when it's this instance's turn
- */
-async function waitForTurn(instanceId, pollInterval = 5000) {
-  return new Promise((resolve) => {
-    const checkQueue = () => {
-      if (isMyTurn(instanceId)) {
-        resolve();
-      } else {
-        const entriesAhead = getEntriesAhead(instanceId);
-        console.log(`Waiting in queue (${entriesAhead} ahead)...`);
-        setTimeout(checkQueue, pollInterval);
-      }
-    };
-
-    checkQueue();
-  });
-}
-
-/**
- * Monitor current position in queue
- * @param {string} instanceId - Instance to monitor
- * @returns {number|null} Current position or null if not in queue
- */
-function monitorPosition(instanceId) {
-  return getPosition(instanceId);
-}
-
-/**
- * Process queue entry: wait for turn, rebase, push, remove entry
- * @param {string} instanceId - Instance processing queue
- * @returns {Promise<void>}
- */
-async function processQueue(instanceId) {
-  const initialPosition = getPosition(instanceId);
-  console.log(`Added to push queue (position ${initialPosition})`);
-
-  // Wait until it's our turn
-  await waitForTurn(instanceId);
-
-  // Now at position 1 - rebase and push
-  console.log('Your turn! Rebasing on main...');
-  rebaseOnMain();
-
-  console.log('Pushing to main...');
-  pushDirectlyToMain();
-
-  // Remove from queue
-  removeFromQueue(instanceId);
-  console.log('Push complete, removed from queue');
-}
-
-module.exports = {
-  isMyTurn,
-  waitForTurn,
-  monitorPosition,
-  processQueue
-};

package/lib/test-helpers.js

@@ -1,202 +0,0 @@
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-/**
- * Creates an isolated test directory for testing
- * @returns {Object} Test context with testDir and originalCwd
- * @throws {Error} If temporary directory cannot be created
- */
-function createTestEnvironment() {
-  // Get original cwd, handling case where current directory was deleted
-  let originalCwd;
-  try {
-    originalCwd = process.cwd();
-  } catch (err) {
-    // If current directory doesn't exist, use the project root
-    // This can happen when previous tests deleted their test directory
-    originalCwd = path.resolve(__dirname, '..');
-    try {
-      process.chdir(originalCwd);
-    } catch (chdirErr) {
-      throw new Error(`Failed to restore to valid directory: ${chdirErr.message}`);
-    }
-  }
-
-  let testDir;
-  try {
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jettypod-test-'));
-  } catch (err) {
-    throw new Error(`Failed to create test directory: ${err.message}`);
-  }
-
-  return {
-    originalCwd,
-    testDir,
-    cleanup: () => {
-      try {
-        process.chdir(originalCwd);
-      } catch (err) {
-        // Directory may have been deleted, try project root
-        try {
-          process.chdir(path.resolve(__dirname, '..'));
-        } catch (chdirErr) {
-          // Ignore if we can't change directories
-        }
-      }
-      if (fs.existsSync(testDir)) {
-        try {
-          fs.rmSync(testDir, { recursive: true, force: true });
-        } catch (err) {
-          console.warn(`Warning: Failed to cleanup test directory: ${err.message}`);
-        }
-      }
-    }
-  };
-}
-
-/**
- * Copies directory recursively, excluding test files
- * @param {string} src - Source directory
- * @param {string} dest - Destination directory
- * @throws {Error} If src doesn't exist, is not a directory, or copy fails
- */
-function copyDirRecursive(src, dest) {
-  if (!src || typeof src !== 'string') {
-    throw new Error('Source path must be a non-empty string');
-  }
-  if (!dest || typeof dest !== 'string') {
-    throw new Error('Destination path must be a non-empty string');
-  }
-
-  if (!fs.existsSync(src)) {
-    throw new Error(`Source directory does not exist: ${src}`);
-  }
-
-  const srcStat = fs.statSync(src);
-  if (!srcStat.isDirectory()) {
-    throw new Error(`Source is not a directory: ${src}`);
-  }
-
-  try {
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-
-    fs.readdirSync(src).forEach(item => {
-      const srcPath = path.join(src, item);
-      const destPath = path.join(dest, item);
-
-      if (fs.statSync(srcPath).isDirectory()) {
-        copyDirRecursive(srcPath, destPath);
-      } else {
-        // Skip test files when copying
-        if (!item.endsWith('.test.js')) {
-          fs.copyFileSync(srcPath, destPath);
-        }
-      }
-    });
-  } catch (err) {
-    throw new Error(`Failed to copy directory from ${src} to ${dest}: ${err.message}`);
-  }
-}
-
-/**
- * Runs a JettyPod command in test environment
- * @param {string} cmd - Command to run (e.g., 'jettypod init')
- * @param {Object} context - Test context with originalCwd
- * @returns {string} Command output
- * @throws {Error} If cmd is invalid or context is missing
- */
-function runCommand(cmd, context) {
-  if (!cmd || typeof cmd !== 'string') {
-    throw new Error('Command must be a non-empty string');
-  }
-  if (!context || typeof context !== 'object') {
-    throw new Error('Context must be an object');
-  }
-
-  try {
-    const productionJettypodPath = context.originalCwd ?
-      path.join(context.originalCwd, 'jettypod.js') :
-      path.join(process.cwd(), '..', '..', 'jettypod.js');
-
-    if (!fs.existsSync(productionJettypodPath)) {
-      throw new Error(`JettyPod script not found at: ${productionJettypodPath}`);
-    }
-
-    const fullCmd = cmd.replace(/^jettypod/, `node ${productionJettypodPath}`);
-    return execSync(fullCmd, {
-      encoding: 'utf-8',
-      stdio: 'pipe'
-    });
-  } catch (error) {
-    return error.stdout || error.message;
-  }
-}
-
-/**
- * Reads config.json from .jettypod directory
- * @returns {Object|null} Config object or null if not found
- * @throws {Error} If JSON is corrupted or file cannot be read
- */
-function readConfig() {
-  const configPath = '.jettypod/config.json';
-
-  if (!fs.existsSync(configPath)) {
-    return null;
-  }
-
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    return JSON.parse(content);
-  } catch (err) {
-    if (err instanceof SyntaxError) {
-      throw new Error(`Config file contains invalid JSON: ${err.message}`);
-    }
-    throw new Error(`Failed to read config file: ${err.message}`);
-  }
-}
-
-/**
- * Reads CLAUDE.md from current directory
- * @returns {string} CLAUDE.md content or empty string
- * @throws {Error} If file exists but cannot be read
- */
-function readClaude() {
-  if (!fs.existsSync('CLAUDE.md')) {
-    return '';
-  }
-
-  try {
-    return fs.readFileSync('CLAUDE.md', 'utf-8');
-  } catch (err) {
-    throw new Error(`Failed to read CLAUDE.md: ${err.message}`);
-  }
-}
-
-/**
- * Initializes tracking for created files/directories
- * @param {Object} context - Test context to initialize
- * @throws {Error} If context is invalid
- */
-function initializeTracking(context) {
-  if (!context || typeof context !== 'object') {
-    throw new Error('Context must be an object');
-  }
-
-  context.createdFiles = [];
-  context.createdDirs = [];
-  context.modifiedFiles = new Map();
-  context.createdTestDirs = [];
-}
-
-module.exports = {
-  createTestEnvironment,
-  copyDirRecursive,
-  runCommand,
-  readConfig,
-  readClaude,
-  initializeTracking
-};