@traisetech/autopilot 2.4.0 → 2.5.0

package/src/core/events.js

@@ -1,110 +1,110 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { getConfigDir } = require('../utils/paths');
-const logger = require('../utils/logger');
-
-const getQueuePath = () => path.join(getConfigDir(), 'events-queue.json');
-
-/**
- * Telemetry/Event System for Autopilot
- * Handles reliable event emission with local queuing
- */
-class EventSystem {
-  constructor() {
-    this.queue = [];
-    this.isFlushing = false;
-  }
-
-  async loadQueue() {
-    try {
-      const queuePath = getQueuePath();
-      if (await fs.pathExists(queuePath)) {
-        this.queue = await fs.readJson(queuePath);
-      }
-    } catch (error) {
-      logger.debug(`Failed to load event queue: ${error.message}`);
-    }
-  }
-
-  async saveQueue() {
-    try {
-      await fs.ensureDir(getConfigDir());
-      await fs.writeJson(getQueuePath(), this.queue, { spaces: 2 });
-    } catch (error) {
-      logger.error(`Failed to save event queue: ${error.message}`);
-    }
-  }
-
-  /**
-   * Queue an event for emission
-   * @param {object} event - Event payload
-   */
-  async emit(event) {
-    await this.loadQueue();
-    
-    // Add metadata
-    const enrichedEvent = {
-      ...event,
-      queuedAt: Date.now(),
-      retryCount: 0
-    };
-
-    this.queue.push(enrichedEvent);
-    await this.saveQueue();
-    
-    // Try to flush immediately
-    this.flush();
-  }
-
-  /**
-   * Attempt to send queued events to backend
-   */
-  async flush() {
-    if (this.isFlushing || this.queue.length === 0) return;
-    this.isFlushing = true;
-
-    try {
-      const remaining = [];
-      
-      for (const event of this.queue) {
-        try {
-          await this.sendToBackend(event);
-        } catch (error) {
-          // Keep in queue if failed
-          event.retryCount++;
-          remaining.push(event);
-        }
-      }
-
-      this.queue = remaining;
-      await this.saveQueue();
-    } finally {
-      this.isFlushing = false;
-    }
-  }
-
-  /**
-   * Mock backend transmission
-   * In production, this would POST to an API
-   */
-  async sendToBackend(event) {
-    const apiBase = process.env.AUTOPILOT_API_URL || 'https://autopilot-cli.vercel.app';
-    const url = `${apiBase}/api/events`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3000);
-    try {
-      const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(event),
-        signal: controller.signal
-      });
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      return true;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-}
-
-module.exports = new EventSystem();
+const fs = require('fs-extra');
+const path = require('path');
+const { getConfigDir } = require('../utils/paths');
+const logger = require('../utils/logger');
+
+const getQueuePath = () => path.join(getConfigDir(), 'events-queue.json');
+
+/**
+ * Telemetry/Event System for Autopilot
+ * Handles reliable event emission with local queuing
+ */
+class EventSystem {
+  constructor() {
+    this.queue = [];
+    this.isFlushing = false;
+  }
+
+  async loadQueue() {
+    try {
+      const queuePath = getQueuePath();
+      if (await fs.pathExists(queuePath)) {
+        this.queue = await fs.readJson(queuePath);
+      }
+    } catch (error) {
+      logger.debug(`Failed to load event queue: ${error.message}`);
+    }
+  }
+
+  async saveQueue() {
+    try {
+      await fs.ensureDir(getConfigDir());
+      await fs.writeJson(getQueuePath(), this.queue, { spaces: 2 });
+    } catch (error) {
+      logger.error(`Failed to save event queue: ${error.message}`);
+    }
+  }
+
+  /**
+   * Queue an event for emission
+   * @param {object} event - Event payload
+   */
+  async emit(event) {
+    await this.loadQueue();
+    
+    // Add metadata
+    const enrichedEvent = {
+      ...event,
+      queuedAt: Date.now(),
+      retryCount: 0
+    };
+
+    this.queue.push(enrichedEvent);
+    await this.saveQueue();
+    
+    // Try to flush immediately
+    this.flush();
+  }
+
+  /**
+   * Attempt to send queued events to backend
+   */
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) return;
+    this.isFlushing = true;
+
+    try {
+      const remaining = [];
+      
+      for (const event of this.queue) {
+        try {
+          await this.sendToBackend(event);
+        } catch (error) {
+          // Keep in queue if failed
+          event.retryCount++;
+          remaining.push(event);
+        }
+      }
+
+      this.queue = remaining;
+      await this.saveQueue();
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+
+  /**
+   * Mock backend transmission
+   * In production, this would POST to an API
+   */
+  async sendToBackend(event) {
+    const apiBase = process.env.AUTOPILOT_API_URL || 'https://autopilot-cli.vercel.app';
+    const url = `${apiBase}/api/events`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(event),
+        signal: controller.signal
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      return true;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+module.exports = new EventSystem();

package/src/core/focus.js

@@ -12,7 +12,8 @@ const CalendarIntegration = require('../integrations/calendar');
 class FocusEngine {
   constructor(repoPath, config) {
     this.repoPath = repoPath;
-    this.logFile = path.join(repoPath, 'autopilot.log');
+    this.logFile = path.join(repoPath, '.autopilot', 'focus.log');
+    fs.ensureDirSync(path.dirname(this.logFile));
     this.config = config?.focus || {
       activeThresholdSeconds: 120, // 2 mins between events counts as continuous active time
       sessionTimeoutSeconds: 1800, // 30 mins gap = new session

package/src/core/gemini.js

@@ -41,10 +41,10 @@ ${truncatedDiff}
 `;
 
   try {
-    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000);
-    const response = await fetch(url, {
+    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch(url, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -59,10 +59,10 @@ ${truncatedDiff}
           temperature: 0.2,
           maxOutputTokens: 256,
         }
-      }),
-      signal: controller.signal
+      }),
+      signal: controller.signal
     });
-    clearTimeout(timeout);
+    clearTimeout(timeout);
 
     if (!response.ok) {
       const errorData = await response.json().catch(() => ({}));
@@ -96,20 +96,20 @@ ${truncatedDiff}
  */
 async function validateApiKey(apiKey, model = DEFAULT_MODEL) {
   try {
-    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
-    // Simple test call with empty prompt
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 4000);
-    const response = await fetch(url, {
+    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
+    // Simple test call with empty prompt
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 4000);
+    const response = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         contents: [{ parts: [{ text: "Hi" }] }],
         generationConfig: { maxOutputTokens: 1 }
-      }),
-      signal: controller.signal
+      }),
+      signal: controller.signal
     });
-    clearTimeout(timeout);
+    clearTimeout(timeout);
     
     if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));

package/src/core/git.js

@@ -151,17 +151,44 @@ async function isRemoteAhead(root) {
  * Push changes to remote
  * @param {string} root - Repository root path
  * @param {string} [branch] - Branch to push (optional, defaults to current)
- * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string, conflict?: boolean}>} Result object
  */
 async function push(root, branch) {
   try {
     const targetBranch = branch || await getBranch(root);
     if (!targetBranch) throw new Error('Could not determine branch to push');
 
+    // 1. Fetch updates
+    await fetch(root);
+
+    // 2. Check if behind
+    const { stdout: behindCountStr } = await execa('git', ['rev-list', 'HEAD..origin/' + targetBranch, '--count'], { cwd: root }).catch(() => ({ stdout: '0' }));
+    const behindCount = parseInt(behindCountStr.trim(), 10);
+
+    if (behindCount > 0) {
+      // 3. Try rebase
+      try {
+        await execa('git', ['pull', '--rebase', 'origin', targetBranch], { cwd: root });
+      } catch (err) {
+        if (err.stdout?.includes('CONFLICT') || err.stderr?.includes('CONFLICT')) {
+          return { ok: false, stdout: '', stderr: 'Rebase conflict detected — manual intervention required', conflict: true };
+        }
+        throw err;
+      }
+    }
+
+    // 4. Push
     const { stdout, stderr } = await execa('git', ['push', 'origin', targetBranch], { cwd: root });
     return { ok: true, stdout, stderr };
   } catch (error) {
-    return { ok: false, stdout: '', stderr: error.message };
+    const stderr = error.stderr || error.message || '';
+    if (stderr.includes('CONFLICT')) {
+      return { ok: false, stdout: '', stderr: 'Rebase conflict detected — manual intervention required', conflict: true };
+    }
+    if (error.exitCode === 128 && stderr.includes('rejected')) {
+      return { ok: false, stdout: '', stderr: 'Push rejected: remote has diverged. Try manual rebase.', conflict: true };
+    }
+    return { ok: false, stdout: '', stderr };
   }
 }
 

package/src/core/history.js

@@ -1,69 +1,69 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { getAutopilotHome } = require('../utils/paths');
-const logger = require('../utils/logger');
-
-const HISTORY_FILE = 'history.json';
-
-class HistoryManager {
-  constructor(repoPath) {
-    this.repoPath = repoPath;
-    this.historyDir = path.join(repoPath, '.autopilot');
-    this.historyFile = path.join(this.historyDir, HISTORY_FILE);
-    this.init();
-  }
-
-  init() {
-    fs.ensureDirSync(this.historyDir);
-    if (!fs.existsSync(this.historyFile)) {
-      fs.writeJsonSync(this.historyFile, { commits: [] }, { spaces: 2 });
-    }
-  }
-
-  getHistory() {
-    try {
-      const data = fs.readJsonSync(this.historyFile);
-      return data.commits || [];
-    } catch (error) {
-      logger.error('Failed to read history:', error.message);
-      return [];
-    }
-  }
-
-  addCommit(commitData) {
-    try {
-      const history = this.getHistory();
-      history.unshift({
-        ...commitData,
-        timestamp: new Date().toISOString()
-      });
-      // Keep only last 100 commits
-      if (history.length > 100) history.length = 100;
-      
-      fs.writeJsonSync(this.historyFile, { commits: history }, { spaces: 2 });
-    } catch (error) {
-      logger.error('Failed to write history:', error.message);
-    }
-  }
-
-  getLastCommit() {
-    const history = this.getHistory();
-    return history[0];
-  }
-
-  removeLastCommit() {
-    try {
-      const history = this.getHistory();
-      if (history.length === 0) return null;
-      
-      const removed = history.shift();
-      fs.writeJsonSync(this.historyFile, { commits: history }, { spaces: 2 });
-      return removed;
-    } catch (error) {
-      logger.error('Failed to update history:', error.message);
-      return null;
-    }
-  }
-}
-
-module.exports = HistoryManager;
+const fs = require('fs-extra');
+const path = require('path');
+const { getAutopilotHome } = require('../utils/paths');
+const logger = require('../utils/logger');
+
+const HISTORY_FILE = 'history.json';
+
+class HistoryManager {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+    this.historyDir = path.join(repoPath, '.autopilot');
+    this.historyFile = path.join(this.historyDir, HISTORY_FILE);
+    this.init();
+  }
+
+  init() {
+    fs.ensureDirSync(this.historyDir);
+    if (!fs.existsSync(this.historyFile)) {
+      fs.writeJsonSync(this.historyFile, { commits: [] }, { spaces: 2 });
+    }
+  }
+
+  getHistory() {
+    try {
+      const data = fs.readJsonSync(this.historyFile);
+      return data.commits || [];
+    } catch (error) {
+      logger.error('Failed to read history:', error.message);
+      return [];
+    }
+  }
+
+  addCommit(commitData) {
+    try {
+      const history = this.getHistory();
+      history.unshift({
+        ...commitData,
+        timestamp: new Date().toISOString()
+      });
+      // Keep only last 100 commits
+      if (history.length > 100) history.length = 100;
+      
+      fs.writeJsonSync(this.historyFile, { commits: history }, { spaces: 2 });
+    } catch (error) {
+      logger.error('Failed to write history:', error.message);
+    }
+  }
+
+  getLastCommit() {
+    const history = this.getHistory();
+    return history[0];
+  }
+
+  removeLastCommit() {
+    try {
+      const history = this.getHistory();
+      if (history.length === 0) return null;
+      
+      const removed = history.shift();
+      fs.writeJsonSync(this.historyFile, { commits: history }, { spaces: 2 });
+      return removed;
+    } catch (error) {
+      logger.error('Failed to update history:', error.message);
+      return null;
+    }
+  }
+}
+
+module.exports = HistoryManager;

package/src/core/notifier.js

@@ -0,0 +1,61 @@
+/**
+ * System notifications for Autopilot events
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const notifier = require('node-notifier');
+const path = require('path');
+
+/**
+ * Send a desktop notification
+ * @param {string} event - The name/type of the event
+ * @param {object} data - The event data { message, branch, title, sound }
+ * @param {boolean} [enabled=true] - Whether notifications are enabled in config
+ */
+function notify(event, data, enabled = true) {
+  if (!enabled) return;
+
+  try {
+    let title = data.title || 'Autopilot';
+    let message = data.message || '';
+    let sound = data.sound || false;
+
+    switch (event) {
+      case 'push_success':
+        title = 'Autopilot';
+        message = `Pushed: ${data.commitMessage || 'latest changes'}`;
+        sound = false;
+        break;
+      case 'push_failed':
+        title = 'Autopilot';
+        message = 'Push failed — queued for retry';
+        sound = false;
+        break;
+      case 'conflict':
+        title = 'Autopilot — Action needed';
+        message = `Merge conflict in ${data.branch || 'current branch'} — paused`;
+        sound = true;
+        break;
+      case 'queue_cleared':
+        title = 'Autopilot';
+        message = 'All queued pushes succeeded';
+        sound = false;
+        break;
+    }
+
+    notifier.notify({
+      title,
+      message,
+      sound,
+      // Optional icon (use relative from src/core to some generic icon location if it exists)
+      // icon: path.join(__dirname, '../assets/icon.png')
+    });
+  } catch (error) {
+    // Never crash the watcher if notifications fail
+    // console.error('Notification failed:', error);
+  }
+}
+
+module.exports = {
+  notify
+};

package/src/core/retryQueue.js

@@ -0,0 +1,152 @@
+/**
+ * Network retry queue for failed pushes
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+
+class RetryQueue {
+  /**
+   * Initialize retry queue
+   * @param {string} root - Repository root path
+   * @param {Function} pushFn - Function to call for retry (expects root, branch)
+   */
+  constructor(root, pushFn) {
+    this.root = root;
+    this.queuePath = path.join(root, '.autopilot-queue.json');
+    this.pushFn = pushFn;
+    this.queue = [];
+    this.retryDelays = [30000, 60000, 120000, 300000, 600000]; // 30s, 60s, 2m, 5m, 10m
+    
+    this.load();
+    this.initRetries();
+  }
+
+  /**
+   * Load existing queue from file
+   */
+  load() {
+    try {
+      if (fs.existsSync(this.queuePath)) {
+        this.queue = fs.readJsonSync(this.queuePath);
+        // Reset timers/attempts if loaded from disk?
+        // Actually we should resume where it left off, but we'll re-init timers.
+      }
+    } catch (err) {
+      logger.error('Failed to load retry queue:', err.message);
+      this.queue = [];
+    }
+  }
+
+  /**
+   * Persist current queue to file
+   */
+  save() {
+    try {
+      fs.writeJsonSync(this.queuePath, this.queue, { spaces: 2 });
+    } catch (err) {
+      logger.error('Failed to save retry queue:', err.message);
+    }
+  }
+
+  /**
+   * Add a new push job to the queue
+   * @param {object} job - { commitHash, branch, timestamp, attempts, maxAttempts }
+   */
+  add(job) {
+    const newJob = {
+      ...job,
+      timestamp: Date.now(),
+      attempts: job.attempts || 0,
+      maxAttempts: job.maxAttempts || 5
+    };
+    
+    // Check if duplicate?
+    if (this.queue.some(j => j.commitHash === job.commitHash)) {
+       return;
+    }
+
+    this.queue.push(newJob);
+    this.save();
+    
+    // Start retry for this job
+    this.scheduleRetry(newJob);
+    logger.info(`Push queued — will retry later (Job: ${newJob.commitHash})`);
+  }
+
+  /**
+   * Cancel a pending job
+   * @param {string} commitHash 
+   */
+  cancel(commitHash) {
+    this.queue = this.queue.filter(j => j.commitHash !== commitHash);
+    this.save();
+  }
+
+  /**
+   * Schedule a retry for a specific job
+   * @param {object} job 
+   */
+  scheduleRetry(job) {
+    const delay = this.retryDelays[job.attempts] || 600000;
+    
+    setTimeout(async () => {
+      // Re-fetch job from queue to see if it hasn't been cancelled or already succeeded
+      const currentJob = this.queue.find(j => j.commitHash === job.commitHash);
+      if (!currentJob) return;
+
+      currentJob.attempts++;
+      logger.info(`Retrying queued push (Attempt ${currentJob.attempts}/${currentJob.maxAttempts}) for ${currentJob.commitHash}`);
+
+      try {
+        const result = await this.pushFn(this.root, currentJob.branch);
+        if (result.ok) {
+          logger.info(`Queued push succeeded on attempt ${currentJob.attempts} for ${currentJob.commitHash}`);
+          this.cancel(currentJob.commitHash);
+          if (this.queue.length === 0) {
+            // Emit queue cleared event
+          }
+        } else {
+          if (currentJob.attempts >= currentJob.maxAttempts) {
+            logger.error(`Max retry attempts exceeded for ${currentJob.commitHash}. Job removed from queue.`);
+            this.cancel(currentJob.commitHash);
+          } else {
+            this.save(); // Update attempt count on disk
+            this.scheduleRetry(currentJob); // Continue backoff
+          }
+        }
+      } catch (error) {
+        logger.error(`Retry error for ${currentJob.commitHash}: ${error.message}`);
+        this.scheduleRetry(currentJob);
+      }
+    }, delay);
+  }
+
+  /**
+   * Initialize retries for all pending jobs in the queue (e.g. after restart)
+   */
+  initRetries() {
+    if (this.queue.length > 0) {
+      logger.info(`Resuming ${this.queue.length} pending push jobs from queue...`);
+      this.queue.forEach(job => this.scheduleRetry(job));
+    }
+  }
+
+  /**
+   * Get public status of the queue
+   * @returns {Array}
+   */
+  getStatus() {
+    return this.queue.map(j => ({
+       commitHash: j.commitHash,
+       branch: j.branch,
+       attempts: j.attempts,
+       maxAttempts: j.maxAttempts,
+       queuedAt: new Date(j.timestamp).toISOString()
+    }));
+  }
+}
+
+module.exports = RetryQueue;