@traisetech/autopilot 0.1.6 → 0.1.8

package/src/core/gemini.js

@@ -0,0 +1,109 @@
+/**
+ * Google Gemini AI Integration for Autopilot
+ * Generates commit messages using the Gemini Pro model
+ */
+
+const logger = require('../utils/logger');
+
+const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
+
+/**
+ * Generate a commit message using Gemini API
+ * @param {string} diff - The git diff content
+ * @param {string} apiKey - Google Gemini API Key
+ * @returns {Promise<string>} Generated commit message
+ */
+async function generateAICommitMessage(diff, apiKey) {
+  if (!diff || !diff.trim()) {
+    return 'chore: update changes';
+  }
+
+  // Truncate diff if it's too large (Gemini has token limits, though high)
+  // A safe limit might be around 30k chars for now to be safe and fast
+  const truncatedDiff = diff.length > 30000 ? diff.slice(0, 30000) + '\n...(truncated)' : diff;
+
+  const prompt = `
+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.
+
+Diff:
+${truncatedDiff}
+`;
+
+  try {
+    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        contents: [{
+          parts: [{
+            text: prompt
+          }]
+        }],
+        generationConfig: {
+          temperature: 0.2,
+          maxOutputTokens: 256,
+        }
+      })
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Gemini API Error: ${response.status} ${response.statusText} - ${JSON.stringify(errorData)}`);
+    }
+
+    const data = await response.json();
+    
+    if (!data.candidates || data.candidates.length === 0 || !data.candidates[0].content) {
+      throw new Error('No response content from Gemini');
+    }
+
+    let message = data.candidates[0].content.parts[0].text.trim();
+    
+    // Cleanup markdown if present (e.g. ```git commit ... ```)
+    message = message.replace(/^```[a-z]*\n?/, '').replace(/\n?```$/, '').trim();
+
+    return message;
+
+  } catch (error) {
+    logger.error(`AI Generation failed: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Validate Gemini API Key
+ * @param {string} apiKey 
+ * @returns {Promise<boolean>}
+ */
+async function validateApiKey(apiKey) {
+  try {
+    // Simple test call with empty prompt
+    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: "Hi" }] }],
+        generationConfig: { maxOutputTokens: 1 }
+      })
+    });
+    return response.ok;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  generateAICommitMessage,
+  validateApiKey
+};

package/src/core/git.js

@@ -1,154 +1,180 @@
-/**
- * Git helper module - Clean, testable Git operations
- * Built by Praise Masunga (PraiseTechzw)
- */
-
-const { execa } = require('execa');
-
-/**
- * Get current branch name
- * @param {string} root - Repository root path
- * @returns {Promise<string|null>} Branch name or null on error
- */
-async function getBranch(root) {
-  try {
-    const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root });
-    return stdout.trim();
-  } catch (error) {
-    return null;
-  }
-}
-
-/**
- * Check if repository has uncommitted changes
- * @param {string} root - Repository root path
- * @returns {Promise<boolean>} True if there are changes
- */
-async function hasChanges(root) {
-  try {
-    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
-    return stdout.trim().length > 0;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Get porcelain status - parsed list of changed files
- * @param {string} root - Repository root path
- * @returns {Promise<{ok: boolean, files: string[], raw: string}>} Status object
- */
-async function getPorcelainStatus(root) {
-  try {
-    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
-    const raw = stdout.trim();
-    
-    if (!raw) {
-      return { ok: true, files: [], raw: '' };
-    }
-
-    const files = raw
-      .split(/\r?\n/)
-      .map(line => line.slice(3).trim()); // Remove status prefix (XY + space)
-
-    return { ok: true, files, raw };
-  } catch (error) {
-    return { ok: false, files: [], raw: error.message };
-  }
-}
-
-/**
- * Stage all changes (git add -A)
- * @param {string} root - Repository root path
- * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
- */
-async function addAll(root) {
-  try {
-    const { stdout, stderr } = await execa('git', ['add', '-A'], { cwd: root });
-    return { ok: true, stdout, stderr };
-  } catch (error) {
-    return { ok: false, stdout: '', stderr: error.message };
-  }
-}
-
-/**
- * Commit staged changes
- * @param {string} root - Repository root path
- * @param {string} message - Commit message
- * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
- */
-async function commit(root, message) {
-  try {
-    const { stdout, stderr } = await execa('git', ['commit', '-m', message], { cwd: root });
-    return { ok: true, stdout, stderr };
-  } catch (error) {
-    return { ok: false, stdout: '', stderr: error.message };
-  }
-}
-
-/**
- * Fetch updates from remote
- * @param {string} root - Repository root path
- * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
- */
-async function fetch(root) {
-  try {
-    const { stdout, stderr } = await execa('git', ['fetch'], { 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
- * @returns {Promise<{ok: boolean, ahead: boolean, behind: boolean, raw: string}>} Status object
- */
-async function isRemoteAhead(root) {
-  try {
-    const branch = await getBranch(root);
-    if (!branch) return { ok: false, ahead: false, behind: false, raw: 'No branch' };
-
-    // Ensure we have latest info
-    await fetch(root);
-
-    const { stdout } = await execa('git', ['rev-list', '--left-right', '--count', `${branch}...origin/${branch}`], { cwd: root });
-    const [aheadCount, behindCount] = stdout.trim().split(/\s+/).map(Number);
-    
-    return {
-      ok: true,
-      ahead: aheadCount > 0,
-      behind: behindCount > 0,
-      raw: stdout.trim()
-    };
-  } catch (error) {
-    return { ok: false, ahead: false, behind: false, raw: error.message };
-  }
-}
-
-/**
- * Push changes to remote
- * @param {string} root - Repository root path
- * @param {string} branch - Branch to push
- * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
- */
-async function push(root, branch) {
-  try {
-    const { stdout, stderr } = await execa('git', ['push', 'origin', branch], { cwd: root });
-    return { ok: true, stdout, stderr };
-  } catch (error) {
-    return { ok: false, stdout: '', stderr: error.message };
-  }
-}
-
-module.exports = {
-  getBranch,
-  hasChanges,
-  getPorcelainStatus,
-  addAll,
-  commit,
-  fetch,
-  isRemoteAhead,
-  push,
-};
+/**
+ * Git helper module - Clean, testable Git operations
+ * Built by Praise Masunga (PraiseTechzw)
+ */
+
+const execa = require('execa');
+
+/**
+ * Get current branch name
+ * @param {string} root - Repository root path
+ * @returns {Promise<string|null>} Branch name or null on error
+ */
+async function getBranch(root) {
+  try {
+    const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root });
+    return stdout.trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if repository has uncommitted changes
+ * @param {string} root - Repository root path
+ * @returns {Promise<boolean>} True if there are changes
+ */
+async function hasChanges(root) {
+  try {
+    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
+    return stdout.trim().length > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get porcelain status - parsed list of changed files
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, files: string[], raw: string}>} Status object
+ */
+async function getPorcelainStatus(root) {
+  try {
+    const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: root });
+    const raw = stdout.trim();
+    
+    if (!raw) {
+      return { ok: true, files: [], raw: '' };
+    }
+
+    const files = raw
+      .split(/\r?\n/)
+      .map(line => {
+        const status = line.slice(0, 2).trim();
+        const file = line.slice(3).trim();
+        return { status, file };
+      });
+
+    return { ok: true, files, raw };
+  } catch (error) {
+    return { ok: false, files: [], raw: error.message };
+  }
+}
+
+/**
+ * Stage all changes (git add -A)
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function addAll(root) {
+  try {
+    const { stdout, stderr } = await execa('git', ['add', '-A'], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Commit staged changes
+ * @param {string} root - Repository root path
+ * @param {string} message - Commit message
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function commit(root, message) {
+  try {
+    const { stdout, stderr } = await execa('git', ['commit', '-m', message], { cwd: root });
+    return { ok: true, stdout, stderr };
+  } catch (error) {
+    return { ok: false, stdout: '', stderr: error.message };
+  }
+}
+
+/**
+ * Fetch updates from remote
+ * @param {string} root - Repository root path
+ * @returns {Promise<{ok: boolean, stdout: string, stderr: string}>} Result object
+ */
+async function fetch(root) {
+  try {
+    const { stdout, stderr } = await execa('git', ['fetch'], { 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
+ * @returns {Promise<{ok: boolean, ahead: boolean, behind: boolean, raw: string}>} Status object
+ */
+async function isRemoteAhead(root) {
+  try {
+    const branch = await getBranch(root);
+    if (!branch) return { ok: false, ahead: false, behind: false, raw: 'No branch' };
+
+    // Ensure we have latest info
+    await fetch(root);
+
+    const { stdout } = await execa('git', ['rev-list', '--left-right', '--count', `${branch}...origin/${branch}`], { cwd: root });
+    const [aheadCount, behindCount] = stdout.trim().split(/\s+/).map(Number);
+    
+    return {
+      ok: true,
+      ahead: aheadCount > 0,
+      behind: behindCount > 0,
+      raw: stdout.trim()
+    };
+  } catch (error) {
+    return { ok: false, ahead: false, behind: false, raw: error.message };
+  }
+}
+
+/**
+ * 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
+ */
+async function push(root, branch) {
+  try {
+    const targetBranch = branch || await getBranch(root);
+    if (!targetBranch) throw new Error('Could not determine branch to 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 };
+  }
+}
+
+/**
+ * Get diff of changes
+ * @param {string} root - Repository root path
+ * @param {boolean} staged - Whether to get staged diff (default: true)
+ * @returns {Promise<string>} Diff content
+ */
+async function getDiff(root, staged = true) {
+  try {
+    const args = ['diff'];
+    if (staged) args.push('--cached');
+    args.push('-U3');
+    const { stdout } = await execa('git', args, { cwd: root });
+    return stdout || '';
+  } catch (error) {
+    return '';
+  }
+}
+
+module.exports = {
+  getBranch,
+  hasChanges,
+  getPorcelainStatus,
+  addAll,
+  commit,
+  fetch,
+  isRemoteAhead,
+  push,
+  getDiff
+};