@traisetech/autopilot 0.1.8 → 2.0.1

package/src/core/safety.js

@@ -1,38 +1,204 @@
-const logger = require('../utils/logger');
-
-const validateConfig = (config) => {
-  const errors = [];
-
-  if (!config) {
-    errors.push('Configuration is missing');
-    return errors;
-  }
-
-  if (config.commitMessage && typeof config.commitMessage !== 'string') {
-    errors.push('commitMessage must be a string');
-  }
-
-  if (config.autoPush && typeof config.autoPush !== 'boolean') {
-    errors.push('autoPush must be a boolean');
-  }
-
-  if (config.ignore && !Array.isArray(config.ignore)) {
-    errors.push('ignore must be an array');
-  }
-
-  return errors;
-};
-
-const validateBeforeCommit = async (repoPath) => {
-  const errors = [];
-
-  // Add safety checks before committing
-  // For example, check for large files, sensitive files, etc.
-
-  return errors;
-};
-
-module.exports = {
-  validateConfig,
-  validateBeforeCommit,
-};
+const fs = require('fs-extra');
+const path = require('path');
+const execa = require('execa');
+const logger = require('../utils/logger');
+const git = require('./git');
+
+// Regex patterns for common secrets
+const SECRET_PATTERNS = [
+  { name: 'AWS Access Key', regex: /(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}/ },
+  { name: 'AWS Secret Key', regex: /(?<![A-Za-z0-9/+=])[A-Za-z0-9/+=]{40}(?![A-Za-z0-9/+=])/ },
+  { name: 'GitHub Token', regex: /(gh[pousr]_[a-zA-Z0-9]{36,255})/ },
+  { name: 'Stripe Secret Key', regex: /(sk_live_[0-9a-zA-Z]{24})/ },
+  { name: 'Google API Key', regex: /AIza[0-9A-Za-z\\-_]{35}/ },
+  { name: 'Bearer Token', regex: /Bearer [a-zA-Z0-9\-\._~\+\/]+=*/ },
+  { name: 'Generic Private Key', regex: /-----BEGIN PRIVATE KEY-----/ }
+];
+
+const MAX_FILE_SIZE_MB = 50;
+
+/**
+ * Validate configuration
+ */
+const validateConfig = (config) => {
+  const errors = [];
+
+  if (!config) {
+    errors.push('Configuration is missing');
+    return errors;
+  }
+
+  if (config.commitMessage && typeof config.commitMessage !== 'string') {
+    errors.push('commitMessage must be a string');
+  }
+
+  if (config.autoPush && typeof config.autoPush !== 'boolean') {
+    errors.push('autoPush must be a boolean');
+  }
+
+  if (config.ignore && !Array.isArray(config.ignore)) {
+    errors.push('ignore must be an array');
+  }
+
+  return errors;
+};
+
+/**
+ * Run pre-commit checks on staged files
+ * @param {string} repoPath
+ * @param {object} config
+ * @returns {Promise<{ok: boolean, errors: string[]}>}
+ */
+const validateBeforeCommit = async (repoPath, config) => {
+  const errors = [];
+  
+  if (!config.preCommitChecks) {
+    return { ok: true, errors: [] };
+  }
+
+  try {
+    // Get staged files
+    const statusObj = await git.getPorcelainStatus(repoPath);
+    // Filter only modified/added files (ignore deleted)
+    const stagedFiles = statusObj.files.filter(f => f.status !== 'D' && f.status !== ' D');
+    
+    // 1. File Size Check
+    if (config.preCommitChecks.fileSize) {
+      for (const file of stagedFiles) {
+        try {
+          const filePath = path.join(repoPath, file.file);
+          if (fs.existsSync(filePath)) {
+            const stats = await fs.stat(filePath);
+            const sizeMb = stats.size / (1024 * 1024);
+            if (sizeMb > MAX_FILE_SIZE_MB) {
+              errors.push(`File ${file.file} is too large (${sizeMb.toFixed(2)}MB > ${MAX_FILE_SIZE_MB}MB)`);
+            }
+          }
+        } catch (err) {
+          // Ignore missing files
+        }
+      }
+    }
+
+    // 2. Secret Detection
+    if (config.preCommitChecks.secrets) {
+      for (const file of stagedFiles) {
+        try {
+          const filePath = path.join(repoPath, file.file);
+          if (fs.existsSync(filePath)) {
+            // Read first 1MB only for performance
+            // Use stream or buffer
+            const buffer = Buffer.alloc(1024 * 1024);
+            const fd = await fs.open(filePath, 'r');
+            const { bytesRead } = await fs.read(fd, buffer, 0, buffer.length, 0);
+            await fs.close(fd);
+            
+            const content = buffer.toString('utf8', 0, bytesRead);
+            
+            for (const pattern of SECRET_PATTERNS) {
+              if (pattern.regex.test(content)) {
+                errors.push(`Possible ${pattern.name} detected in ${file.file}`);
+              }
+            }
+          }
+        } catch (err) {
+           logger.debug(`Could not read ${file.file} for secret scan: ${err.message}`);
+        }
+      }
+    }
+
+    // 3. Linting
+    if (config.preCommitChecks.lint && config.preCommitChecks.lint !== false) {
+      logger.info('Running lint check...');
+      try {
+        await execa.command('npm run lint', { cwd: repoPath });
+      } catch (err) {
+        errors.push(`Lint check failed: ${err.shortMessage || err.message}`);
+      }
+    }
+
+    // 4. Tests
+    if (config.preCommitChecks.test) {
+      logger.info('Running tests...');
+      try {
+        await execa.command(config.preCommitChecks.test, { cwd: repoPath });
+      } catch (err) {
+        errors.push(`Test check failed: ${err.shortMessage || err.message}`);
+      }
+    }
+
+  } catch (error) {
+    logger.error(`Validation error: ${error.message}`);
+    // If validation crashes, safe to fail open? No, fail closed for safety.
+    errors.push(`Validation crashed: ${error.message}`);
+  }
+
+  return { ok: errors.length === 0, errors };
+};
+
+/**
+ * Handle Team Mode Checks (Pull-Before-Push)
+ * @param {string} repoPath 
+ * @param {object} config 
+ * @returns {Promise<{ok: boolean, action: 'continue'|'pull'|'abort'}>}
+ */
+const checkTeamStatus = async (repoPath, config) => {
+  if (!config.teamMode) {
+    return { ok: true, action: 'continue' };
+  }
+
+  logger.debug('Running Team Mode checks...');
+
+  // Check unpushed commits limit
+  try {
+    const branch = await git.getBranch(repoPath);
+    if (!branch) return { ok: false, action: 'abort' }; // No branch?
+
+    const { stdout: unpushedCount } = await execa('git', ['rev-list', '--count', `origin/${branch}..HEAD`], { cwd: repoPath }).catch(() => ({ stdout: '0' }));
+    
+    if (Number(unpushedCount) > (config.maxUnpushedCommits || 5)) {
+      logger.warn(`Too many unpushed commits (${unpushedCount}). Pushing required.`);
+      // We might force a push here or just warn
+    }
+
+    // Fetch to see if we are behind
+    await git.fetch(repoPath);
+    const remoteStatus = await git.isRemoteAhead(repoPath);
+    
+    if (remoteStatus.behind) {
+      if (config.pullBeforePush) {
+        logger.info('Remote is ahead. Pulling changes...');
+        // Try pull --rebase
+        try {
+          await execa('git', ['pull', '--rebase'], { cwd: repoPath });
+          return { ok: true, action: 'continue' };
+        } catch (err) {
+          logger.error('Pull failed (conflict detected).');
+          return { ok: false, action: 'abort' };
+        }
+      } else {
+        return { ok: false, action: 'abort' };
+      }
+    }
+
+    // Detect potential conflicts without pulling (git diff --check)
+    // Actually git diff --check is for whitespace, not merge conflicts.
+    // To check for merge conflicts before pulling is hard without actually merging.
+    // But since we did fetch, we can dry-run a merge?
+    // For now, relies on pull --rebase failure above.
+
+  } catch (err) {
+    logger.warn(`Team check failed: ${err.message}`);
+    // If we can't check, maybe safe to continue locally? 
+    // But "conflictStrategy": "abort" suggests we should stop.
+    if (config.conflictStrategy === 'abort') return { ok: false, action: 'abort' };
+  }
+
+  return { ok: true, action: 'continue' };
+};
+
+module.exports = {
+  validateConfig,
+  validateBeforeCommit,
+  checkTeamStatus
+};

package/src/core/state.js

@@ -0,0 +1,71 @@
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+const { getAutopilotHome } = require('../utils/paths');
+
+const STATE_FILE = 'state.json';
+
+class StateManager {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+    this.stateDir = path.join(repoPath, '.autopilot');
+    this.stateFile = path.join(this.stateDir, STATE_FILE);
+    this.init();
+  }
+
+  init() {
+    fs.ensureDirSync(this.stateDir);
+    if (!fs.existsSync(this.stateFile)) {
+      this.reset();
+    }
+  }
+
+  getState() {
+    if (!fs.existsSync(this.stateFile)) {
+      return { status: 'running' };
+    }
+    try {
+      return fs.readJsonSync(this.stateFile);
+    } catch (error) {
+      logger.error('Failed to read state:', error.message);
+      return { status: 'running' }; // Default
+    }
+  }
+
+  setState(newState) {
+    try {
+      const currentState = this.getState();
+      const updatedState = { ...currentState, ...newState };
+      fs.writeJsonSync(this.stateFile, updatedState, { spaces: 2 });
+    } catch (error) {
+      logger.error('Failed to write state:', error.message);
+    }
+  }
+
+  reset() {
+    this.setState({
+      status: 'running', // running | paused
+      reason: null,
+      pausedAt: null
+    });
+  }
+
+  pause(reason) {
+    this.setState({
+      status: 'paused',
+      reason: reason || 'User paused',
+      pausedAt: new Date().toISOString()
+    });
+  }
+
+  resume() {
+    this.reset();
+  }
+
+  isPaused() {
+    const state = this.getState();
+    return state.status === 'paused';
+  }
+}
+
+module.exports = StateManager;

package/src/core/watcher.js

@@ -14,6 +14,9 @@ const { generateCommitMessage } = require('./commit');
 const { savePid, removePid, registerProcessHandlers } = require('../utils/process');
 const { loadConfig } = require('../config/loader');
 const { readIgnoreFile, createIgnoredFilter, normalizePath } = require('../config/ignore');
+const HistoryManager = require('./history');
+const StateManager = require('./state');
+const { validateBeforeCommit, checkTeamStatus } = require('./safety');
 
 class Watcher {
   constructor(repoPath) {
@@ -30,6 +33,8 @@ class Watcher {
     this.ignorePatterns = [];
     this.ignoredFilter = null;
     this.focusEngine = new FocusEngine(repoPath);
+    this.historyManager = new HistoryManager(repoPath);
+    this.stateManager = new StateManager(repoPath);
   }
 
   logVerbose(message) {
@@ -269,6 +274,13 @@ class Watcher {
     try {
       logger.debug('Checking git status...');
 
+      // 0. Pause Check
+      if (this.stateManager.isPaused()) {
+        const state = this.stateManager.getState();
+        logger.debug(`Skipping processing: Autopilot is paused (${state.reason})`);
+        return;
+      }
+
       // 1. Min interval check
       const now = Date.now();
       const minInterval = (this.config?.minSecondsBetweenCommits || 30) * 1000;
@@ -293,15 +305,24 @@ class Watcher {
         return;
       }
 
-      // 4. Safety: Remote check (fetch -> behind?)
-      logger.debug('Checking remote status...');
-      const remoteStatus = await git.isRemoteAhead(this.repoPath);
-      if (remoteStatus.behind) {
-        logger.warn('Skip commit: Local branch is behind remote. Please pull changes.');
+      // 4. Safety: Team Mode & Remote check
+      logger.debug('Checking team/remote status...');
+      const teamStatus = await checkTeamStatus(this.repoPath, this.config);
+      if (!teamStatus.ok) {
+        logger.warn('Skip commit: Team check failed (Remote ahead or conflict).');
+        return;
+      }
+
+      // 5. Safety: Pre-commit checks (Validation)
+      logger.debug('Running pre-commit validation...');
+      const validation = await validateBeforeCommit(this.repoPath, this.config);
+      if (!validation.ok) {
+        logger.warn('Skip commit: Pre-commit validation failed:');
+        validation.errors.forEach(e => logger.error(`- ${e}`));
         return;
       }
 
-      // 5. Safety: Custom checks
+      // 6. Safety: Custom checks (Legacy)
       if (this.config?.requireChecks) {
         const checksPassed = await this.runChecks();
         if (!checksPassed) {
@@ -310,7 +331,7 @@ class Watcher {
         }
       }
 
-      // 6. Commit
+      // 7. Commit
       logger.info('Committing changes...');
       
       // Add all changes
@@ -335,10 +356,32 @@ class Watcher {
         message = approval.message;
       }
 
-      await git.commit(this.repoPath, message);
-      this.lastCommitAt = Date.now();
-      this.focusEngine.onCommit();
-      logger.success('Commit complete');
+      const commitResult = await git.commit(this.repoPath, message);
+      
+      if (commitResult.ok) {
+        this.lastCommitAt = Date.now();
+        this.focusEngine.onCommit();
+        
+        // Phase 1: Record History
+        try {
+          // We need the hash of the commit we just made
+          const hash = await git.getLatestCommitHash(this.repoPath);
+          if (hash) {
+            this.historyManager.addCommit({
+              hash,
+              message,
+              files: changedFiles.map(f => f.file)
+            });
+          }
+        } catch (err) {
+          logger.error(`Failed to record history: ${err.message}`);
+        }
+        
+        logger.success('Commit complete');
+      } else {
+        logger.error(`Commit failed: ${commitResult.stderr}`);
+        return;
+      }
 
       // 7. Auto-push
       if (this.config?.autoPush) {

package/src/index.js

@@ -3,7 +3,13 @@ const { initRepo } = require('./commands/init');
 const { startWatcher } = require('./commands/start');
 const { stopWatcher } = require('./commands/stop');
 const { statusWatcher } = require('./commands/status');
+const undoCommand = require('./commands/undo');
 const { doctor } = require('./commands/doctor');
+const { insights } = require('./commands/insights');
+const pauseCommand = require('./commands/pause');
+const resumeCommand = require('./commands/resume');
+const runDashboard = require('./commands/dashboard');
+const { leaderboard } = require('./commands/leaderboard');
 const pkg = require('../package.json');
 
 function run() {
@@ -14,6 +20,12 @@ function run() {
     .description('Git automation with safety rails')
     .version(pkg.version, '-v, --version', 'Show version');
 
+  program
+    .command('leaderboard')
+    .description('View or sync with the global leaderboard')
+    .option('--sync', 'Sync your local stats to the leaderboard')
+    .action(leaderboard);
+
   program
     .command('init')
     .description('Initialize autopilot configuration in repository')
@@ -34,6 +46,27 @@ function run() {
     .description('Show autopilot watcher status')
     .action(statusWatcher);
 
+  program
+    .command('undo')
+    .description('Undo the last Autopilot commit')
+    .option('-c, --count <n>', 'Number of commits to undo', '1')
+    .action(undoCommand);
+
+  program
+    .command('pause [reason]')
+    .description('Pause Autopilot watcher')
+    .action(pauseCommand);
+
+  program
+    .command('resume')
+    .description('Resume Autopilot watcher')
+    .action(resumeCommand);
+
+  program
+    .command('dashboard')
+    .description('View real-time Autopilot dashboard')
+    .action(runDashboard);
+
   program
     .command('doctor')
     .description('Diagnose and validate autopilot setup')
@@ -43,6 +76,7 @@ function run() {
     .command('insights')
     .description('View productivity insights and focus analytics')
     .option('-f, --format <type>', 'Output format (json, text)', 'text')
+    .option('-e, --export <type>', 'Export insights (csv)')
     .action(insights);
 
   program

package/src/utils/logger.js

@@ -4,6 +4,15 @@
  */
 
 const logger = {
+  colors: {
+    cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+    green: (text) => `\x1b[32m${text}\x1b[0m`,
+    yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+    red: (text) => `\x1b[31m${text}\x1b[0m`,
+    blue: (text) => `\x1b[34m${text}\x1b[0m`,
+    bold: (text) => `\x1b[1m${text}\x1b[0m`
+  },
+
   /**
    * Log informational message
    * @param {string} message - Message to log