@traisetech/autopilot 0.1.8 → 2.0.0

package/src/commands/preset.js

@@ -0,0 +1,121 @@
+/**
+ * Workflow Presets Command
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+const { getConfigPath } = require('../utils/paths');
+const { DEFAULT_CONFIG } = require('../config/defaults');
+
+const PRESETS = {
+  'safe-team': {
+    description: 'Safe configuration for team collaboration',
+    config: {
+      teamMode: true,
+      pullBeforePush: true,
+      conflictStrategy: 'abort',
+      preventSecrets: true,
+      commitMessageMode: 'smart',
+      debounceSeconds: 30,
+      minSecondsBetweenCommits: 300
+    }
+  },
+  'solo-speed': {
+    description: 'Fast-paced configuration for solo developers',
+    config: {
+      teamMode: false,
+      pullBeforePush: false,
+      commitMessageMode: 'simple',
+      debounceSeconds: 5,
+      minSecondsBetweenCommits: 60,
+      autoPush: true
+    }
+  },
+  'strict-ci': {
+    description: 'Strict configuration ensuring quality checks pass',
+    config: {
+      requireChecks: true,
+      checks: ['npm test', 'npm run lint'],
+      preventSecrets: true,
+      preCommitChecks: {
+        secrets: true,
+        fileSize: true,
+        lint: true,
+        test: true
+      }
+    }
+  }
+};
+
+async function listPresets() {
+  logger.section('📋 Available Workflow Presets');
+  
+  Object.entries(PRESETS).forEach(([name, preset]) => {
+    console.log(`\n  ${logger.colors.cyan(name)}`);
+    console.log(`    ${preset.description}`);
+  });
+  console.log('');
+}
+
+async function applyPreset(name) {
+  if (!name) {
+    logger.error('Please specify a preset name.');
+    await listPresets();
+    return;
+  }
+
+  const preset = PRESETS[name];
+  if (!preset) {
+    logger.error(`Preset '${name}' not found.`);
+    await listPresets();
+    return;
+  }
+
+  const repoPath = process.cwd();
+  const configPath = getConfigPath(repoPath);
+
+  try {
+    // Read existing config or use defaults
+    let currentConfig = DEFAULT_CONFIG;
+    if (await fs.pathExists(configPath)) {
+      currentConfig = await fs.readJson(configPath);
+    }
+
+    // Merge preset config
+    const newConfig = {
+      ...currentConfig,
+      ...preset.config
+    };
+
+    await fs.writeJson(configPath, newConfig, { spaces: 2 });
+    logger.success(`Applied preset '${name}' successfully!`);
+    logger.info(`Updated .autopilotrc.json with ${Object.keys(preset.config).length} settings.`);
+
+  } catch (error) {
+    logger.error(`Failed to apply preset: ${error.message}`);
+  }
+}
+
+async function presetCommand(command, name) {
+  switch (command) {
+    case 'list':
+      await listPresets();
+      break;
+    case 'apply':
+      await applyPreset(name);
+      break;
+    default:
+      // If first arg is a known preset name, treat it as apply
+      if (PRESETS[command]) {
+        await applyPreset(command);
+      } else {
+        logger.error(`Unknown command or preset: ${command}`);
+        console.log('Usage: autopilot preset [list|apply] <name>');
+        console.log('       autopilot preset <name>');
+      }
+  }
+}
+
+module.exports = presetCommand;

package/src/commands/resume.js

@@ -0,0 +1,17 @@
+const logger = require('../utils/logger');
+const StateManager = require('../core/state');
+
+function resumeCommand() {
+  const root = process.cwd();
+  const stateManager = new StateManager(root);
+
+  if (!stateManager.isPaused()) {
+    logger.warn('Autopilot is already running.');
+    return;
+  }
+
+  stateManager.resume();
+  logger.success('Autopilot resumed.');
+}
+
+module.exports = resumeCommand;

package/src/commands/undo.js

@@ -0,0 +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;

package/src/config/defaults.js

@@ -13,9 +13,21 @@ const DEFAULT_CONFIG = {
   commitMessageMode: 'smart', // smart | simple | ai
   ai: {
     enabled: false,
-    apiKey: '',
-    model: 'gemini-pro',
-    interactive: false
+    apiKey: '', // Store in env var or secure config
+    model: 'gemini-2.5-flash',
+    interactive: true
+  },
+  // Phase 1: Team Mode
+  teamMode: false,
+  pullBeforePush: true,
+  conflictStrategy: 'abort',
+  maxUnpushedCommits: 5,
+  // Phase 1: Pre-commit checks
+  preCommitChecks: {
+    secrets: true,
+    fileSize: true,
+    lint: false,
+    test: null
   }
 };
 

package/src/core/commit.js

@@ -6,6 +6,7 @@
 const path = require('path');
 const logger = require('../utils/logger');
 const { generateAICommitMessage } = require('./gemini');
+const HistoryManager = require('./history');
 
 /**
  * Generate a conventional commit message based on diff analysis
@@ -15,20 +16,44 @@ const { generateAICommitMessage } = require('./gemini');
  * @returns {Promise<string>} Conventional commit message
  */
 async function generateCommitMessage(files, diffContent, config = {}) {
+  let message = '';
   if (!files || files.length === 0) {
-    return 'chore: update changes';
-  }
-
-  // AI Mode
-  if (config.commitMessageMode === 'ai' && config.ai?.enabled && config.ai?.apiKey) {
+    message = 'chore: update changes';
+  } else if (config.commitMessageMode === 'ai' && config.ai?.enabled && config.ai?.apiKey) {
+    // AI Mode
     try {
       logger.info('Generating AI commit message...');
-      return await generateAICommitMessage(diffContent, config.ai.apiKey);
+      message = await generateAICommitMessage(diffContent, config.ai.apiKey);
     } catch (error) {
       logger.warn('AI generation failed, falling back to smart generation.');
+      message = generateSmartCommitMessage(files, diffContent);
     }
+  } else {
+    // Smart Mode (Default)
+    message = generateSmartCommitMessage(files, diffContent);
+  }
+
+  // Prepend [autopilot] tag for traceability (Phase 1 req)
+  const finalMessage = `[autopilot] ${message}`;
+  
+  // Record history
+  try {
+    const root = process.cwd();
+    const historyManager = new HistoryManager(root);
+    // We don't have the hash yet, but we will update it or store it after commit
+    // Actually, we should probably return just the message here and let the caller (watcher) handle history.
+    // However, the prompt says "Tag all commits with [autopilot] prefix".
+  } catch (err) {
+    // ignore history errors here
   }
 
+  return finalMessage;
+}
+
+/**
+ * Smart generation logic extracted
+ */
+function generateSmartCommitMessage(files, diffContent) {
   // 1. Parse Diff for deep analysis
   const diffAnalysis = parseDiff(diffContent);
   

package/src/core/gemini.js

@@ -5,15 +5,17 @@
 
 const logger = require('../utils/logger');
 
-const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
+const BASE_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/';
+const DEFAULT_MODEL = 'gemini-2.5-flash';
 
 /**
  * Generate a commit message using Gemini API
  * @param {string} diff - The git diff content
  * @param {string} apiKey - Google Gemini API Key
+ * @param {string} [model] - Gemini Model ID (default: gemini-2.5-flash)
  * @returns {Promise<string>} Generated commit message
  */
-async function generateAICommitMessage(diff, apiKey) {
+async function generateAICommitMessage(diff, apiKey, model = DEFAULT_MODEL) {
   if (!diff || !diff.trim()) {
     return 'chore: update changes';
   }
@@ -39,7 +41,8 @@ ${truncatedDiff}
 `;
 
   try {
-    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
+    const response = await fetch(url, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -84,12 +87,14 @@ ${truncatedDiff}
 /**
  * Validate Gemini API Key
  * @param {string} apiKey 
- * @returns {Promise<boolean>}
+ * @param {string} [model] - Gemini Model ID (default: gemini-2.5-flash)
+ * @returns {Promise<{valid: boolean, error?: string}>}
  */
-async function validateApiKey(apiKey) {
+async function validateApiKey(apiKey, model = DEFAULT_MODEL) {
   try {
+    const url = `${BASE_API_URL}${model}:generateContent?key=${apiKey}`;
     // Simple test call with empty prompt
-    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+    const response = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -97,9 +102,16 @@ async function validateApiKey(apiKey) {
         generationConfig: { maxOutputTokens: 1 }
       })
     });
-    return response.ok;
+    
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const errorMessage = errorData.error?.message || response.statusText;
+        return { valid: false, error: errorMessage };
+    }
+
+    return { valid: true };
   } catch (e) {
-    return false;
+    return { valid: false, error: e.message };
   }
 }
 

package/src/core/git.js

@@ -104,6 +104,21 @@ async function fetch(root) {
   }
 }
 
+/**
+ * Run a generic git command
+ * @param {string} root - Repository root path
+ * @param {string[]} args - Git arguments
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function runGit(root, args) {
+  try {
+    const { stdout, stderr } = await execa('git', args, { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
 /**
  * Check if remote is ahead/behind
  * @param {string} root - Repository root path
@@ -167,6 +182,65 @@ async function getDiff(root, staged = true) {
   }
 }
 
+/**
+ * Revert a specific commit
+ * @param {string} root - Repository root path
+ * @param {string} hash - Commit hash
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function revert(root, hash) {
+  try {
+    const { stdout, stderr } = await execa('git', ['revert', '--no-edit', hash], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Reset to a specific commit (soft reset)
+ * @param {string} root - Repository root path
+ * @param {string} target - Target commitish (e.g. HEAD~1)
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function resetSoft(root, target) {
+  try {
+    const { stdout, stderr } = await execa('git', ['reset', '--soft', target], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Check if a commit exists
+ * @param {string} root - Repository root path
+ * @param {string} hash - Commit hash
+ * @returns {Promise<boolean>} True if exists
+ */
+async function commitExists(root, hash) {
+  try {
+    await execa('git', ['cat-file', '-e', `${hash}^{commit}`], { cwd: root });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get the latest commit hash
+ * @param {string} root - Repository root path
+ * @returns {Promise<string|null>} Commit hash or null
+ */
+async function getLatestCommitHash(root) {
+  try {
+    const { stdout } = await execa('git', ['rev-parse', 'HEAD'], { cwd: root });
+    return stdout.trim();
+  } catch (error) {
+    return null;
+  }
+}
+
 module.exports = {
   getBranch,
   hasChanges,
@@ -174,7 +248,12 @@ module.exports = {
   addAll,
   commit,
   fetch,
+  runGit,
   isRemoteAhead,
   push,
-  getDiff
+  getDiff,
+  revert,
+  resetSoft,
+  commitExists,
+  getLatestCommitHash
 };

package/src/core/history.js

@@ -0,0 +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;