@traisetech/autopilot 2.0.0 → 2.1.0

package/src/config/loader.js

@@ -2,27 +2,52 @@ const fs = require('fs-extra');
 const path = require('path');
 const logger = require('../utils/logger');
 const { DEFAULT_CONFIG } = require('./defaults');
-const { getConfigPath } = require('../utils/paths');
+const { getConfigPath, getConfigDir, ensureConfigDir } = require('../utils/paths');
+
+const getGlobalConfigPath = () => path.join(getConfigDir(), 'config.json');
 
 const loadConfig = async (repoPath) => {
+  let config = { ...DEFAULT_CONFIG };
+
+  // 1. Load Global Config
+  try {
+    const globalPath = getGlobalConfigPath();
+    if (await fs.pathExists(globalPath)) {
+      const globalConfig = await fs.readJson(globalPath);
+      config = { ...config, ...globalConfig };
+      logger.debug(`Loaded global config from ${globalPath}`);
+    }
+  } catch (error) {
+    logger.warn(`Error loading global config: ${error.message}`);
+  }
+
+  // 2. Load Local Config (Overrides Global)
   const configPath = getConfigPath(repoPath);
   try {
     if (await fs.pathExists(configPath)) {
-      const config = await fs.readJson(configPath);
-      logger.debug(`Loaded config from ${configPath}`);
-      return { ...DEFAULT_CONFIG, ...config };
+      const localConfig = await fs.readJson(configPath);
+      config = { ...config, ...localConfig };
+      logger.debug(`Loaded local config from ${configPath}`);
     }
   } catch (error) {
-    logger.warn(`Error loading config: ${error.message}`);
+    logger.warn(`Error loading local config: ${error.message}`);
   }
-  return { ...DEFAULT_CONFIG };
+
+  return config;
 };
 
-const saveConfig = async (repoPath, config) => {
-  const configPath = getConfigPath(repoPath);
+const saveConfig = async (repoPath, config, isGlobal = false) => {
   try {
-    await fs.writeJson(configPath, config, { spaces: 2 });
-    logger.success(`Config saved to ${configPath}`);
+    let targetPath;
+    if (isGlobal) {
+      await ensureConfigDir();
+      targetPath = getGlobalConfigPath();
+    } else {
+      targetPath = getConfigPath(repoPath);
+    }
+
+    await fs.writeJson(targetPath, config, { spaces: 2 });
+    logger.success(`Config saved to ${targetPath}`);
   } catch (error) {
     logger.error(`Failed to save config: ${error.message}`);
   }
@@ -44,4 +69,5 @@ module.exports = {
   loadConfig,
   saveConfig,
   createDefaultConfig,
+  getGlobalConfigPath
 };

package/src/core/commit.js

@@ -5,7 +5,8 @@
 
 const path = require('path');
 const logger = require('../utils/logger');
-const { generateAICommitMessage } = require('./gemini');
+const gemini = require('./gemini');
+const grok = require('./grok');
 const HistoryManager = require('./history');
 
 /**
@@ -19,13 +20,22 @@ async function generateCommitMessage(files, diffContent, config = {}) {
   let message = '';
   if (!files || files.length === 0) {
     message = 'chore: update changes';
-  } else if (config.commitMessageMode === 'ai' && config.ai?.enabled && config.ai?.apiKey) {
+  } else if (config.commitMessageMode === 'ai' && config.ai?.enabled) {
     // AI Mode
     try {
-      logger.info('Generating AI commit message...');
-      message = await generateAICommitMessage(diffContent, config.ai.apiKey);
+      const provider = config.ai.provider || 'gemini';
+      logger.info(`Generating AI commit message using ${provider}...`);
+      
+      if (provider === 'grok') {
+        if (!config.ai.grokApiKey) throw new Error('Grok API Key not configured');
+        message = await grok.generateGrokCommitMessage(diffContent, config.ai.grokApiKey, config.ai.grokModel);
+      } else {
+        // Default to Gemini
+        if (!config.ai.apiKey) throw new Error('Gemini API Key not configured');
+        message = await gemini.generateAICommitMessage(diffContent, config.ai.apiKey, config.ai.model);
+      }
     } catch (error) {
-      logger.warn('AI generation failed, falling back to smart generation.');
+      logger.warn(`AI generation failed (${error.message}), falling back to smart generation.`);
       message = generateSmartCommitMessage(files, diffContent);
     }
   } else {
@@ -340,7 +350,32 @@ function generateBody(analysis, files) {
   return bullets;
 }
 
+async function addTrailers(message) {
+  const { getIdentity } = require('../utils/identity');
+  const { generateSignature } = require('../utils/crypto');
+  const { version } = require('../../package.json');
+
+  const identity = await getIdentity();
+  const timestamp = Date.now().toString();
+  
+  // Content to sign: message|timestamp|version|userId
+  // This ensures integrity of the whole commit data
+  const contentToSign = `${message}|${timestamp}|${version}|${identity.id}`;
+  const signature = generateSignature(contentToSign, identity.id);
+
+  const trailers = [
+    '',
+    'Autopilot-Commit: true',
+    `Autopilot-Version: ${version}`,
+    `Autopilot-User: ${identity.id}`,
+    `Autopilot-Signature: ${signature}`
+  ];
+
+  return message + trailers.join('\n');
+}
+
 module.exports = {
   generateCommitMessage,
-  parseDiff
+  parseDiff,
+  addTrailers
 };

package/src/core/events.js

@@ -0,0 +1,105 @@
+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) {
+    // Simulate network delay
+    // await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // For now, we just log that we would have sent it
+    // logger.debug(`[Telemetry] Event emitted: ${event.type}`);
+    
+    // In a real implementation:
+    // const response = await fetch('https://api.autopilot.com/events', { ... });
+    // if (!response.ok) throw new Error('Network error');
+    
+    return true; 
+  }
+}
+
+module.exports = new EventSystem();

package/src/core/git.js

@@ -241,6 +241,42 @@ async function getLatestCommitHash(root) {
   }
 }
 
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Check if repository is in a merge/rebase/cherry-pick state
+ * @param {string} root - Repository root path
+ * @returns {Promise<boolean>} True if operation in progress
+ */
+async function isMergeInProgress(root) {
+  try {
+    const gitDir = path.join(root, '.git');
+    const files = [
+      'MERGE_HEAD',
+      'REBASE_HEAD',
+      'CHERRY_PICK_HEAD',
+      'REVERT_HEAD',
+      'BISECT_LOG'
+    ];
+    
+    // Check if .git/rebase-merge or .git/rebase-apply exists (directory check)
+    if (await fs.pathExists(path.join(gitDir, 'rebase-merge')) || 
+        await fs.pathExists(path.join(gitDir, 'rebase-apply'))) {
+      return true;
+    }
+
+    for (const file of files) {
+      if (await fs.pathExists(path.join(gitDir, file))) {
+        return true;
+      }
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+
 module.exports = {
   getBranch,
   hasChanges,
@@ -255,5 +291,6 @@ module.exports = {
   revert,
   resetSoft,
   commitExists,
-  getLatestCommitHash
+  getLatestCommitHash,
+  isMergeInProgress
 };

package/src/core/grok.js

@@ -0,0 +1,109 @@
+/**
+ * xAI Grok Integration for Autopilot
+ * Generates commit messages using the Grok API
+ */
+
+const logger = require('../utils/logger');
+
+const BASE_API_URL = 'https://api.x.ai/v1/chat/completions';
+const DEFAULT_MODEL = 'grok-beta'; // or current stable model
+
+/**
+ * Generate a commit message using Grok API
+ * @param {string} diff - The git diff content
+ * @param {string} apiKey - xAI API Key
+ * @param {string} [model] - Grok Model ID
+ * @returns {Promise<string>} Generated commit message
+ */
+async function generateGrokCommitMessage(diff, apiKey, model = DEFAULT_MODEL) {
+  if (!diff || !diff.trim()) {
+    return 'chore: update changes';
+  }
+
+  // Truncate diff to avoid token limits (safe limit)
+  const truncatedDiff = diff.length > 30000 ? diff.slice(0, 30000) + '\n...(truncated)' : diff;
+
+  const systemPrompt = `You are an expert software engineer.
+Generate a concise, standardized commit message following the Conventional Commits specification based on the provided git diff.
+
+Rules:
+1. Format: <type>(<scope>): <subject>
+2. Keep the subject line under 72 characters.
+3. If there are multiple changes, use a bulleted body.
+4. Detect breaking changes and add "BREAKING CHANGE:" footer if necessary.
+5. Use types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.
+6. Return ONLY the commit message, no explanations or markdown code blocks.`;
+
+  try {
+    const response = await fetch(BASE_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: `Diff:\n${truncatedDiff}` }
+        ],
+        temperature: 0.2,
+        stream: false
+      })
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Grok API Error: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+
+    const data = await response.json();
+    
+    if (!data.choices || data.choices.length === 0 || !data.choices[0].message) {
+      throw new Error('No response content from Grok');
+    }
+
+    let message = data.choices[0].message.content.trim();
+    
+    // Cleanup markdown if present
+    message = message.replace(/^```[a-z]*\n?/, '').replace(/\n?```$/, '').trim();
+
+    return message;
+
+  } catch (error) {
+    logger.error(`Grok Generation failed: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Validate Grok API Key
+ * @param {string} apiKey 
+ * @returns {Promise<{valid: boolean, error?: string}>}
+ */
+async function validateGrokApiKey(apiKey) {
+  try {
+    const response = await fetch(BASE_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: DEFAULT_MODEL,
+        messages: [{ role: 'user', content: 'test' }],
+        max_tokens: 1
+      })
+    });
+
+    if (response.ok) return { valid: true };
+    return { valid: false, error: `Status: ${response.status}` };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+}
+
+module.exports = {
+  generateGrokCommitMessage,
+  validateGrokApiKey
+};

package/src/core/safety.js

@@ -56,6 +56,12 @@ const validateBeforeCommit = async (repoPath, config) => {
     return { ok: true, errors: [] };
   }
 
+  // 0. Merge/Rebase Safety Check (Hard Guarantee)
+  const isMerge = await git.isMergeInProgress(repoPath);
+  if (isMerge) {
+    return { ok: false, errors: ['Repository is in a merge/rebase state. Autopilot paused for safety.'] };
+  }
+
   try {
     // Get staged files
     const statusObj = await git.getPorcelainStatus(repoPath);

package/src/core/watcher.js

@@ -10,7 +10,10 @@ const readline = require('readline');
 const logger = require('../utils/logger');
 const git = require('./git');
 const FocusEngine = require('./focus');
-const { generateCommitMessage } = require('./commit');
+const { generateCommitMessage, addTrailers } = require('./commit');
+const eventSystem = require('./events');
+const { getIdentity } = require('../utils/identity');
+const { version } = require('../../package.json');
 const { savePid, removePid, registerProcessHandlers } = require('../utils/process');
 const { loadConfig } = require('../config/loader');
 const { readIgnoreFile, createIgnoredFilter, normalizePath } = require('../config/ignore');
@@ -356,6 +359,9 @@ class Watcher {
         message = approval.message;
       }
 
+      // Add Trust/Attribution Trailers
+      message = await addTrailers(message);
+
       const commitResult = await git.commit(this.repoPath, message);
       
       if (commitResult.ok) {
@@ -388,9 +394,31 @@ class Watcher {
         logger.info('Pushing to remote...');
         const pushResult = await git.push(this.repoPath);
         if (!pushResult.ok) {
-             logger.warn(`Push failed (will retry next time): ${pushResult.stderr}`);
+             logger.warn(`Push failed: ${pushResult.stderr}`);
+             
+             // Safety: Pause on critical push failures (Auth, Permissions, or Persistent errors)
+             // This aligns with "Failure Behavior: If a push fails -> pause watcher"
+             logger.error('Push failed! Pausing Autopilot to prevent issues.');
+             this.stateManager.pause(`Push failed: ${pushResult.stderr.split('\n')[0]}`);
+             logger.info('Run "autopilot resume" to restart after fixing the issue.');
         } else {
              logger.success('Push complete');
+             
+             // Emit Event for Leaderboard/Telemetry
+             try {
+               const identity = await getIdentity();
+               const latestHash = await git.getLatestCommitHash(this.repoPath);
+               
+               await eventSystem.emit({
+                 type: 'push_success',
+                 userId: identity.id,
+                 commitHash: latestHash,
+                 timestamp: Date.now(),
+                 version: version
+               });
+             } catch (err) {
+               logger.debug(`Failed to emit push event: ${err.message}`);
+             }
         }
       }
 

package/src/utils/crypto.js

@@ -0,0 +1,18 @@
+const crypto = require('crypto');
+
+/**
+ * Generate HMAC signature for commit verification
+ * @param {string} content - Content to sign (message + timestamp + version)
+ * @param {string} secret - Secret key (using anonymous ID as salt for now)
+ * @returns {string} HMAC SHA256 signature
+ */
+function generateSignature(content, secret) {
+  return crypto
+    .createHmac('sha256', secret)
+    .update(content)
+    .digest('hex');
+}
+
+module.exports = {
+  generateSignature
+};

package/src/utils/identity.js

@@ -0,0 +1,41 @@
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+const { getConfigDir } = require('./paths');
+const logger = require('./logger');
+
+const getIdentityPath = () => path.join(getConfigDir(), 'identity.json');
+
+/**
+ * Get or create the anonymous user identity
+ * @returns {Promise<{id: string, created: number}>} Identity object
+ */
+async function getIdentity() {
+  try {
+    const identityPath = getIdentityPath();
+    
+    if (await fs.pathExists(identityPath)) {
+      return await fs.readJson(identityPath);
+    }
+
+    // Create new identity
+    const identity = {
+      id: crypto.randomUUID(),
+      created: Date.now()
+    };
+
+    await fs.ensureDir(getConfigDir());
+    await fs.writeJson(identityPath, identity, { spaces: 2 });
+    logger.debug(`Created new anonymous identity: ${identity.id}`);
+    
+    return identity;
+  } catch (error) {
+    logger.error(`Failed to manage identity: ${error.message}`);
+    // Fallback to memory-only ID if filesystem fails
+    return { id: crypto.randomUUID(), created: Date.now() };
+  }
+}
+
+module.exports = {
+  getIdentity
+};

package/src/utils/paths.js

@@ -39,6 +39,9 @@ const getGitPath = (repoPath) => {
  * @returns {string} Config directory path
  */
 const getConfigDir = () => {
+  if (process.env.AUTOPILOT_CONFIG_DIR) {
+    return process.env.AUTOPILOT_CONFIG_DIR;
+  }
   return path.join(os.homedir(), '.autopilot');
 };