@traisetech/autopilot 2.4.0 → 2.5.0

package/src/commands/status.js

@@ -1,56 +1,90 @@
 /**
- * Command: status
- * Checks the status of the Autopilot watcher
+ * Autopilot status command
+ * Built by Praise Masunga (PraiseTechzw)
  */
 
 const fs = require('fs-extra');
 const path = require('path');
-const process = require('process');
-const logger = require('../utils/logger');
-const { getRunningPid } = require('../utils/process');
+// const { formatDistanceToNow } = require('date-fns'); // Removed unused dependency
+const git = require('../core/git');
+const safety = require('../core/safety');
 
-const status = async () => {
-  const repoPath = process.cwd();
+async function status() {
+  const root = process.cwd();
+  const statePath = path.join(root, '.autopilot-state.json');
+  const queuePath = path.join(root, '.autopilot-queue.json');
 
-  try {
-    const pid = await getRunningPid(repoPath);
+  console.log('\n  Autopilot status');
+  console.log('  ─────────────────────────────');
 
-    logger.section('Autopilot Status');
+  if (!fs.existsSync(statePath)) {
+    console.error('Status: Not Running');
+    console.log('  ─────────────────────────────');
+    return;
+  }
 
+  try {
+    const state = fs.readJsonSync(statePath);
+    const pid = state.pid;
+    let alive = false;
+    
     if (pid) {
-      logger.success(`Status: Running`);
-      logger.info(`PID: ${pid}`);
-    } else {
-      logger.warn('Status: Not Running');
-    }
-
-    // Show recent logs if available
-    const logPath = path.join(repoPath, 'autopilot.log');
-    if (await fs.pathExists(logPath)) {
-      logger.section('Recent Logs');
       try {
-        const logs = await fs.readFile(logPath, 'utf-8');
-        const lines = logs.trim().split('\n');
-        const lastLines = lines.slice(-5); // Show last 5 lines
-        
-        if (lastLines.length > 0) {
-          lastLines.forEach(line => console.log(line));
-        } else {
-          console.log('(Log file is empty)');
-        }
-        
-        logger.info(`\nFull log: ${logPath}`);
-      } catch (error) {
-        logger.error(`Could not read log file: ${error.message}`);
+        process.kill(pid, 0);
+        alive = true;
+      } catch (e) {
+        alive = false;
       }
-    } else {
-      logger.info('No log file found.');
     }
 
-  } catch (error) {
-    logger.error(`Error checking status: ${error.message}`);
-    process.exit(1);
+    const branch = state.branch || await git.getBranch(root) || 'unknown';
+    // Check if protected
+    // Read config to get protected branches
+    const configPath = path.join(root, '.autopilotrc.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      config = fs.readJsonSync(configPath);
+    }
+    const isProtected = safety.isProtectedBranch(branch, config);
+
+    const relativeTime = (ts) => {
+      if (!ts) return 'never';
+      const diff = Date.now() - ts;
+      const mins = Math.floor(diff / 60000);
+      if (mins < 1) return 'just now';
+      if (mins < 60) return `${mins} min ago`;
+      const hours = Math.floor(mins / 60);
+      if (hours < 24) return `${hours}h ago`;
+      return `${Math.floor(hours / 24)} days ago`;
+    };
+
+    const uptime = () => {
+      if (!state.startedAt) return 'unknown';
+      const diff = Date.now() - state.startedAt;
+      const hours = Math.floor(diff / 3600000);
+      const mins = Math.floor((diff % 3600000) / 60000);
+      return `${hours}h ${mins}m`;
+    };
+
+    let queueLength = 0;
+    if (fs.existsSync(queuePath)) {
+      const queue = fs.readJsonSync(queuePath);
+      queueLength = queue.length;
+    }
+
+    console.log(`  State:          ${alive ? (state.status || 'watching') : 'stopped'}`);
+    console.log(`  Branch:         ${branch}${isProtected ? ' (PROTECTED — push blocked)' : ''}`);
+    console.log(`  Last commit:    ${state.lastCommitHash ? state.lastCommitHash.substring(0, 7) : 'none'} — "${state.lastCommitMessage || 'none'}" (${relativeTime(state.lastCommitAt)})`);
+    console.log(`  Last push:      ${state.lastPushHash ? state.lastPushHash.substring(0, 7) : 'none'} — ${state.lastPushStatus || 'none'} (${relativeTime(state.lastPushAt)})`);
+    console.log(`  Pending queue:  ${queueLength} jobs waiting to push`);
+    console.log(`  Conflicts:      ${state.conflicts || 'none detected'}`);
+    console.log(`  Watching:       ${state.watchPath || root}`);
+    console.log(`  Uptime:         ${uptime()}`);
+  } catch (err) {
+    console.log(`  Error:          Could not read state: ${err.message}`);
   }
-};
+
+  console.log('  ─────────────────────────────');
+}
 
 module.exports = status;

package/src/commands/stop.js

@@ -1,50 +1,58 @@
-/**
- * Command: stop
- * Stops the running Autopilot instance
- */
-
-const process = require('process');
-const logger = require('../utils/logger');
-const { getRunningPid, removePid } = require('../utils/process');
-
-const stop = async () => {
-  const repoPath = process.cwd();
-
-  try {
-    const pid = await getRunningPid(repoPath);
-
-    if (!pid) {
-      logger.info('Autopilot is not running.');
-      // Clean up stale PID file just in case
-      await removePid(repoPath);
-      return;
-    }
-
-    logger.info(`Stopping Autopilot (PID: ${pid})...`);
-
-    try {
-      // Send SIGTERM to the process
-      process.kill(pid, 'SIGTERM');
-      
-      logger.success('Autopilot stopped successfully.');
-      
-      // Cleanup PID file
-      await removePid(repoPath);
-      
-    } catch (error) {
-      if (error.code === 'ESRCH') {
-        logger.warn('Process not found (stale PID file). Cleaning up...');
-        await removePid(repoPath);
-        logger.success('Cleaned up stale lock file.');
-      } else {
-        logger.error(`Failed to stop process: ${error.message}`);
-      }
-    }
-
-  } catch (error) {
-    logger.error(`Error stopping autopilot: ${error.message}`);
-    process.exit(1);
-  }
-};
-
-module.exports = stop;
+/**
+ * Command: stop
+ * Stops the running Autopilot instance
+ */
+
+const fs = require('fs');
+const path = require('path');
+const process = require('process');
+const logger = require('../utils/logger');
+const { getRunningPid, removePid } = require('../utils/process');
+
+const stop = async () => {
+  const repoPath = process.cwd();
+
+  try {
+    const pid = await getRunningPid(repoPath);
+
+    if (!pid) {
+      logger.info('Autopilot is not running.');
+      // Clean up stale PID file just in case
+      await removePid(repoPath);
+      return;
+    }
+
+    logger.info(`Stopping Autopilot (PID: ${pid})...`);
+
+    try {
+      // Send SIGTERM to the process
+      process.kill(pid, 'SIGTERM');
+      
+      logger.success('Autopilot stopped successfully.');
+      
+      // Cleanup files
+      await removePid(repoPath);
+      
+      const statePath = path.join(repoPath, '.autopilot-state.json');
+      const logPath = path.join(repoPath, '.autopilot.log');
+      
+      if (fs.existsSync(statePath)) fs.unlinkSync(statePath);
+      if (fs.existsSync(logPath)) fs.unlinkSync(logPath);
+      
+    } catch (error) {
+      if (error.code === 'ESRCH') {
+        logger.warn('Process not found (stale PID file). Cleaning up...');
+        await removePid(repoPath);
+        logger.success('Cleaned up stale lock file.');
+      } else {
+        logger.error(`Failed to stop process: ${error.message}`);
+      }
+    }
+
+  } catch (error) {
+    logger.error(`Error stopping autopilot: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = stop;

package/src/commands/undo.js

@@ -1,84 +1,84 @@
-const logger = require('../utils/logger');
-const HistoryManager = require('../core/history');
-const git = require('../core/git');
-
-async function undoCommand(options) {
-  const root = process.cwd();
-  const historyManager = new HistoryManager(root);
-  const count = options.count ? parseInt(options.count, 10) : 1;
-
-  if (isNaN(count) || count < 1) {
-    logger.error('Invalid count. Must be a positive integer.');
-    return;
-  }
-
-  logger.info(`Attempting to undo last ${count > 1 ? count + ' commits' : 'commit'}...`);
-
-  // Check for dirty working directory
-  const hasChanges = await git.hasChanges(root);
-  if (hasChanges) {
-    logger.warn('Working directory is dirty. Undo might be unsafe.');
-    // In a real interactive CLI, we might ask for confirmation here.
-    // For now, we proceed with caution or abort if strictly required.
-    // We'll assume soft reset is safe for unpushed, revert for pushed.
-  }
-
-  let undoneCount = 0;
-
-  for (let i = 0; i < count; i++) {
-    const lastCommit = historyManager.getLastCommit();
-
-    if (!lastCommit) {
-      logger.warn('No more Autopilot commits found in history.');
-      break;
-    }
-
-    // Verify commit exists in git
-    const exists = await git.commitExists(root, lastCommit.hash);
-    if (!exists) {
-      logger.warn(`Commit ${lastCommit.hash} not found in git history. Removing from Autopilot history.`);
-      historyManager.removeLastCommit();
-      continue;
-    }
-
-    // Check if pushed (simplified: if remote branch contains it)
-    // For simplicity in this phase, we'll try soft reset first if it's HEAD
-    // If it's not HEAD (e.g. manual commits happened on top), we must revert.
-    
-    const headHash = await git.getLatestCommitHash(root);
-    
-    if (headHash === lastCommit.hash) {
-      // It's the latest commit, we can try soft reset
-      logger.info(`Resetting (soft) ${lastCommit.hash} (${lastCommit.message})...`);
-      const result = await git.resetSoft(root, 'HEAD~1');
-      if (result.ok) {
-        historyManager.removeLastCommit();
-        undoneCount++;
-        logger.success(`Undid ${lastCommit.hash}`);
-      } else {
-        logger.error(`Failed to reset ${lastCommit.hash}: ${result.stderr}`);
-        break; // Stop on error
-      }
-    } else {
-      // It's buried, or pushed (safer to revert in mixed scenarios)
-      logger.info(`Reverting ${lastCommit.hash} (${lastCommit.message})...`);
-      const result = await git.revert(root, lastCommit.hash);
-      if (result.ok) {
-        historyManager.removeLastCommit();
-        undoneCount++;
-        logger.success(`Reverted ${lastCommit.hash}`);
-      } else {
-        logger.error(`Failed to revert ${lastCommit.hash}: ${result.stderr}`);
-        break; // Stop on error
-      }
-    }
-  }
-
-  if (undoneCount > 0) {
-    logger.success(`Successfully undid ${undoneCount} commit(s).`);
-  } else {
-    logger.info('No commits were undone.');
-  }
-}
-
-module.exports = undoCommand;
+const logger = require('../utils/logger');
+const HistoryManager = require('../core/history');
+const git = require('../core/git');
+
+async function undoCommand(options) {
+  const root = process.cwd();
+  const historyManager = new HistoryManager(root);
+  const count = options.count ? parseInt(options.count, 10) : 1;
+
+  if (isNaN(count) || count < 1) {
+    logger.error('Invalid count. Must be a positive integer.');
+    return;
+  }
+
+  logger.info(`Attempting to undo last ${count > 1 ? count + ' commits' : 'commit'}...`);
+
+  // Check for dirty working directory
+  const hasChanges = await git.hasChanges(root);
+  if (hasChanges) {
+    logger.warn('Working directory is dirty. Undo might be unsafe.');
+    // In a real interactive CLI, we might ask for confirmation here.
+    // For now, we proceed with caution or abort if strictly required.
+    // We'll assume soft reset is safe for unpushed, revert for pushed.
+  }
+
+  let undoneCount = 0;
+
+  for (let i = 0; i < count; i++) {
+    const lastCommit = historyManager.getLastCommit();
+
+    if (!lastCommit) {
+      logger.warn('No more Autopilot commits found in history.');
+      break;
+    }
+
+    // Verify commit exists in git
+    const exists = await git.commitExists(root, lastCommit.hash);
+    if (!exists) {
+      logger.warn(`Commit ${lastCommit.hash} not found in git history. Removing from Autopilot history.`);
+      historyManager.removeLastCommit();
+      continue;
+    }
+
+    // Check if pushed (simplified: if remote branch contains it)
+    // For simplicity in this phase, we'll try soft reset first if it's HEAD
+    // If it's not HEAD (e.g. manual commits happened on top), we must revert.
+    
+    const headHash = await git.getLatestCommitHash(root);
+    
+    if (headHash === lastCommit.hash) {
+      // It's the latest commit, we can try soft reset
+      logger.info(`Resetting (soft) ${lastCommit.hash} (${lastCommit.message})...`);
+      const result = await git.resetSoft(root, 'HEAD~1');
+      if (result.ok) {
+        historyManager.removeLastCommit();
+        undoneCount++;
+        logger.success(`Undid ${lastCommit.hash}`);
+      } else {
+        logger.error(`Failed to reset ${lastCommit.hash}: ${result.stderr}`);
+        break; // Stop on error
+      }
+    } else {
+      // It's buried, or pushed (safer to revert in mixed scenarios)
+      logger.info(`Reverting ${lastCommit.hash} (${lastCommit.message})...`);
+      const result = await git.revert(root, lastCommit.hash);
+      if (result.ok) {
+        historyManager.removeLastCommit();
+        undoneCount++;
+        logger.success(`Reverted ${lastCommit.hash}`);
+      } else {
+        logger.error(`Failed to revert ${lastCommit.hash}: ${result.stderr}`);
+        break; // Stop on error
+      }
+    }
+  }
+
+  if (undoneCount > 0) {
+    logger.success(`Successfully undid ${undoneCount} commit(s).`);
+  } else {
+    logger.info('No commits were undone.');
+  }
+}
+
+module.exports = undoCommand;

package/src/config/defaults.js

@@ -4,29 +4,34 @@
  */
 
 const DEFAULT_CONFIG = {
-  debounceSeconds: 20,
+  watchPath: '.',
+  debounceMs: 20000,
+  aiProvider: 'grok',
+  aiApiKey: '',
+  ai: {
+    enabled: true,
+    provider: 'grok',
+    apiKey: '',
+    grokApiKey: '',
+    interactive: true,
+    model: 'grok-beta'
+  },
+  protectedBranches: ['main', 'master', 'production', 'prod', 'release'],
+  allowPushToProtected: false,
+  notificationsEnabled: true,
+  maxRetryAttempts: 5,
+  ignorePaths: ['.git', 'node_modules', '.autopilot/', '.autopilot-state.json', '.autopilot.log', '.autopilot-queue.json'],
+  
+  // Legacy/Internal
   minSecondsBetweenCommits: 180,
   autoPush: true,
-  blockedBranches: ['main', 'master'],
   requireChecks: false,
   checks: [],
-  commitMessageMode: 'ai', // Default to AI for zero-config
-  ai: {
-    enabled: true, // Enabled by default
-    provider: 'grok', // Grok is the default for our system keys
-    apiKey: '', 
-    grokApiKey: '',
-    model: 'grok-beta',
-    grokModel: 'grok-beta',
-    interactive: true // Prompt user to review AI messages by default
-  },
-
-  // Phase 1: Team Mode
+  commitMessageMode: 'ai',
   teamMode: false,
   pullBeforePush: true,
   conflictStrategy: 'abort',
   maxUnpushedCommits: 5,
-  // Phase 1: Pre-commit checks
   preCommitChecks: {
     secrets: true,
     fileSize: true,
@@ -44,8 +49,10 @@ const DEFAULT_IGNORE_PATTERNS = [
   '.env.*',
   'coverage/',
   '*.log',
-  'autopilot.log',
+  '.autopilot.log',
   '.autopilot.pid',
+  '.autopilot-state.json',
+  '.autopilot/',
   '.DS_Store',
   '.git/',
   '.idea/',

package/src/config/ignore.js

@@ -54,9 +54,9 @@ const createIgnoreFile = async (repoPath, patterns = []) => {
  * @returns {function} Filter function (path => boolean)
  */
 const createIgnoredFilter = (repoPath, userPatterns = []) => {
-  const normalizedRepoPath = normalizePath(repoPath);
+  const normalizedRepoPath = normalizePath(repoPath).toLowerCase();
 
-  // Critical ignores that are ALWAYS enforced
+  // Critical ignores that are ALWAYS enforced (lowercase for comparison)
   const criticalPrefixes = [
     '.git',
     'node_modules',
@@ -71,7 +71,7 @@ const createIgnoredFilter = (repoPath, userPatterns = []) => {
   const criticalFiles = [
     'autopilot.log',
     '.autopilot.pid',
-    '.DS_Store'
+    '.ds_store'
   ];
 
   const criticalExtensions = [
@@ -79,18 +79,18 @@ const createIgnoredFilter = (repoPath, userPatterns = []) => {
   ];
 
   return (absolutePath) => {
-    // 1. Get relative path safely using path.relative
-    // This handles Windows casing and separators correctly
-    const relativeRaw = path.relative(repoPath, absolutePath);
+    // 1. Normalize and lowercase for consistent matching
+    const normalizedTarget = normalizePath(absolutePath).toLowerCase();
     
-    // If outside repo, ignore (or handle differently? Chokidar usually stays inside)
-    if (relativeRaw.startsWith('..') || path.isAbsolute(relativeRaw)) {
-        return false;
+    // 2. Determine relative path
+    let relativePath;
+    if (normalizedTarget.startsWith(normalizedRepoPath)) {
+        relativePath = normalizedTarget.slice(normalizedRepoPath.length).replace(/^\/+/, '');
+    } else {
+        // Fallback to path.relative if startsWith fails for some reason
+        relativePath = normalizePath(path.relative(repoPath, absolutePath)).toLowerCase();
     }
 
-    // Normalize to forward slashes for matching
-    const relativePath = normalizePath(relativeRaw);
-
     // Handle root path case
     if (!relativePath || relativePath === '.') return false;
 
@@ -111,30 +111,13 @@ const createIgnoredFilter = (repoPath, userPatterns = []) => {
       if (filename.endsWith(ext)) return true;
     }
 
-    // 4. Check user patterns (simple glob-like)
-    // TODO: Use micromatch if more complex patterns needed, but for now simple matching
-    // Note: chokidar handles globs in its 'ignored' option if passed as array, 
-    // but here we are providing a function.
-    
-    // We can rely on chokidar's glob handling if we pass array, but we are returning a function.
-    // If we want to support user globs in this function, we'd need micromatch.
-    // However, Chokidar accepts an array of strings/globs/functions.
-    // We should probably rely on Chokidar for user patterns if possible, 
-    // BUT the requirement says "Apply ignore rules in TWO places: a) chokidar ignored function b) internal ignore matcher".
-    // So we must handle it here too.
-    
-    // Simple implementation for user patterns:
+    // 4. Check user patterns
     for (const pattern of userPatterns) {
-      // Remove leading slash for matching relative path
-      const cleanPattern = pattern.replace(/^\/+/, '');
+      const cleanPattern = pattern.toLowerCase().replace(/^\/+/, '');
       
-      // Exact match
       if (relativePath === cleanPattern) return true;
-      
-      // Directory match
       if (relativePath.startsWith(cleanPattern + '/')) return true;
       
-      // Extension match (*.log)
       if (cleanPattern.startsWith('*.')) {
         const ext = cleanPattern.slice(1);
         if (filename.endsWith(ext)) return true;