@himamshus06/git-auto 1.1.0 → 1.2.0

package/README.md

@@ -7,7 +7,8 @@
 - **One-Command Workflow**: Stages all changes and commits them in one go.
 - **AI-Powered Messages**: Analyzes your `git diff` to generate a meaningful commit message.
 - **Conventional Commits**: Follows the [Conventional Commits](https://www.conventionalcommits.org/) specification (e.g., `feat:`, `fix:`, `chore:`).
-- **Customizable**: Override AI messages with your own or preview them before committing.
+- **Smart Diff Handling**: Uses a Map-Reduce approach to summarize large changes, ensuring no detail is lost regardless of diff size.
+- **Interactive Experience**: Preview and edit AI-generated messages before they are committed to your history.
 
 ## 📦 Installation
 
@@ -23,47 +24,83 @@ npm install
 ```
 
 ### 3. Install Globally
-To use the `git-auto` command anywhere on your system:
+To use the `git auto` command anywhere on your system:
 ```bash
 npm install -g @himamshus06/git-auto
 ```
 
+To make it work as a git alias (`git ac commit` instead of `git-auto commit`), run:
+```bash
+git config --global alias.ac "!git-auto"
+```
+
 ## ⚙️ Configuration
 
-The tool uses the Groq API for fast, free AI generation.
+`git-auto` is provider-agnostic and supports multiple AI backends, including local LLMs.
+
+1. Create a `.env` file in the root directory.
+2. Choose your preferred provider configuration:
+
+### Option A: Groq (Default - Fast & Free)
+Get a free API key from [Groq Cloud](https://console.groq.com/).
+```env
+AI_PROVIDER=groq
+AI_API_KEY=your_groq_api_key_here
+```
+
+### Option B: OpenAI
+```env
+AI_PROVIDER=openai
+AI_API_KEY=your_openai_api_key_here
+AI_BASE_URL=https://api.openai.com/v1
+AI_MODEL=gpt-4o
+```
+
+### Option C: Local LLMs (via Ollama)
+Install [Ollama](https://ollama.com/) and run a model (e.g., `ollama run llama3`).
+```env
+AI_PROVIDER=ollama
+AI_MODEL=llama3
+AI_BASE_URL=http://localhost:11434/v1
+```
 
-1. Get a free API key from [Groq Cloud](https://console.groq.com/).
-2. Create a `.env` file in the root directory:
-   ```env
-   GROQ_API_KEY=your_api_key_here
-   ```
+### Advanced Configuration
+| Variable | Description | Default |
+| :--- | :--- | :--- |
+| `AI_PROVIDER` | The AI backend to use (`groq`, `openai`, `ollama`, `local`) | `groq` |
+| `AI_API_KEY` | API key for cloud providers | (Required for cloud) |
+| `AI_BASE_URL` | API endpoint URL | `https://api.groq.com/openai/v1` |
+| `AI_MODEL` | The specific model ID to use | `qwen/qwen3.8-27b` |
 
 ## 🚀 Usage
 
 ### Basic Commit
 Stages all changes and commits with an AI-generated message:
 ```bash
-git-auto commit
+git auto commit
 ```
 
 ### Commit with Custom Message
 Override the AI and provide your own message:
 ```bash
-git-auto commit -m "feat: add amazing new feature"
+git auto commit -m "feat: add amazing new feature"
 ```
 
 ### Preview Message (Dry Run)
 See what the AI would generate without actually committing:
 ```bash
-git-auto commit --dry-run
+git auto commit --dry-run
 ```
 
 ## 🛠️ How it Works
 
 1. **Staging**: Runs `git add .` to stage all changes.
 2. **Diffing**: Extracts the staged changes using `git diff --cached`.
-3. **AI Generation**: Sends the diff to a Large Language Model (LLM) via Groq.
-4. **Committing**: Executes `git commit -m "generated_message"`.
+3. **AI Generation**: 
+    - **Map Phase**: For large diffs, it splits the changes into manageable chunks and generates a concise summary for each.
+    - **Reduce Phase**: It then aggregates these summaries into a single, professional commit message following Conventional Commits.
+4. **Interactive Review**: Presents the generated message for your approval or modification.
+5. **Committing**: Executes `git commit -m "final_message"`.
 
 ## 📜 License
 MIT

package/knowledge.md

@@ -0,0 +1,53 @@
+# Knowledge Base: git-auto AI Implementation
+
+This document serves as a technical reference for the AI architecture of `git-auto`, ensuring future maintainers can extend the provider system without breaking existing functionality.
+
+## Architecture: The Strategy Pattern
+
+The AI system is implemented using the **Strategy Pattern**. This decouples the high-level commit message generation logic from the low-level API communication details.
+
+### Component Breakdown
+
+#### 1. `AIProvider` (Abstract Base Class)
+- **Purpose**: Defines the contract for all AI providers.
+- **Key Method**: `generate(prompt, options)` - Must be implemented by all subclasses.
+
+#### 2. `OpenAICompatibleProvider` (Concrete Strategy)
+- **Purpose**: Handles any AI service that follows the OpenAI chat completion API specification.
+- **Scope**: Covers Groq, OpenAI, LM Studio, and Ollama's `/v1` endpoint.
+- **Implementation**: Uses the `openai` NPM package.
+
+#### 3. `getAIProvider()` (Factory)
+- **Purpose**: Instantiates the correct provider based on environment variables.
+- **Logic**: 
+    - Checks `AI_PROVIDER` to determine the strategy.
+    - Configures `baseURL` and `model` with sensible defaults based on the provider.
+    - Performs validation (e.g., ensures `AI_API_KEY` exists for cloud providers).
+
+#### 4. `generateCommitMessage` (Client Logic)
+- **Purpose**: Orchestrates the actual commit message generation.
+- **Workflow**:
+    - Retrieves a provider instance via `getAIProvider()`.
+    - Implements a **Map-Reduce** approach for large diffs:
+        - **Map**: Splits the diff into chunks ($\approx 8000$ characters) and generates 1-sentence summaries for each.
+        - **Reduce**: Combines these summaries into a final, professional commit message.
+
+## Configuration Mapping
+
+| Variable | Purpose | Default (Groq) | Default (Ollama) |
+| :--- | :--- | :--- | :--- |
+| `AI_PROVIDER` | Determines the strategy class | `groq` | `ollama` |
+| `AI_BASE_URL` | API endpoint | `https://api.groq.com/openai/v1` | `http://localhost:11434/v1` |
+| `AI_MODEL` | Model Identifier | `qwen/qwen3.8-27b` | `llama3` |
+
+## Future Extension Guide
+
+### How to add a non-OpenAI compatible provider
+If a new provider (e.g., Anthropic Claude) is added that does not use the OpenAI spec:
+1. Create a new class `ClaudeProvider` extending `AIProvider`.
+2. Implement the `generate()` method using the provider's specific SDK.
+3. Add the new provider type to the `getAIProvider()` factory switch statement.
+4. Update the `.env` documentation in `README.md`.
+
+### How to adjust token limits
+To handle larger diffs or more complex models, modify the `CHUNK_SIZE` constant in `generateCommitMessage`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@himamshus06/git-auto",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "",
   "main": "src/index.js",
   "bin": {

package/src/ai.js

@@ -1,55 +1,89 @@
 const OpenAI = require('openai');
 require('dotenv').config();
 
-const openai = new OpenAI({
-    apiKey: process.env.GROQ_API_KEY,
-    baseURL: "https://api.groq.com/openai/v1"
-});
+/**
+ * Base class for AI Providers.
+ * Defines the interface that all providers must implement.
+ */
+class AIProvider {
+    async generate(prompt, options = {}) {
+        throw new Error('Method generate() must be implemented');
+    }
+}
 
 /**
- * Generates a professional commit message based on the provided git diff.
- * For large diffs, it uses a map-reduce approach:
- * 1. Splits the diff into manageable chunks.
- * 2. Summarizes each chunk.
- * 3. Combines summaries into one final commit message.
- *
- * @param {string} diff - The git diff of staged changes.
- * @returns {Promise<string>} - The generated commit message.
- * @throws {Error} - If API key is missing or API call fails.
+ * Provider for any service that follows the OpenAI API specification.
+ * This covers Groq, OpenAI, LM Studio, and Ollama (/v1).
  */
-async function generateCommitMessage(diff) {
-    if (!process.env.GROQ_API_KEY) {
-        throw new Error('GROQ_API_KEY is missing from .env file.');
+class OpenAICompatibleProvider extends AIProvider {
+    constructor(config) {
+        super();
+        this.client = new OpenAI({
+            apiKey: config.apiKey || 'ollama',
+            baseURL: config.baseURL
+        });
+        this.model = config.model;
+    }
+
+    async generate(prompt, options = {}) {
+        const response = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: options.temperature ?? 0.2,
+            max_tokens: options.maxTokens ?? 100,
+        });
+        return response.choices[0].message.content.trim();
+    }
+}
+
+/**
+ * Factory to instantiate the appropriate AI provider based on configuration.
+ */
+function getAIProvider() {
+    const providerType = process.env.AI_PROVIDER || 'groq';
+    const apiKey = process.env.AI_API_KEY || process.env.GROQ_API_KEY;
+    const baseURL = process.env.AI_BASE_URL || (providerType === 'groq' ? 'https://api.groq.com/openai/v1' : 'http://localhost:11434/v1');
+    const model = process.env.AI_MODEL || (providerType === 'groq' ? 'qwen/qwen3.8-27b' : 'llama3');
+
+    // Validation for cloud providers
+    if (!apiKey && providerType !== 'ollama' && providerType !== 'local') {
+        throw new Error(`API key is missing for provider "${providerType}". Please set AI_API_KEY in your .env file.`);
+    }
+
+    switch (providerType.toLowerCase()) {
+        case 'openai':
+        case 'groq':
+        case 'ollama':
+        case 'local':
+            return new OpenAICompatibleProvider({ apiKey, baseURL, model });
+        default:
+            throw new Error(`Unsupported AI provider: ${providerType}`);
     }
+}
 
-    const CHUNK_SIZE = 8000; // Characters per chunk to stay under token limits
+/**
+ * Generates a professional commit message based on the provided git diff.
+ */
+async function generateCommitMessage(diff) {
+    const provider = getAIProvider();
+    const CHUNK_SIZE = 8000;
     const isLargeDiff = diff.length > CHUNK_SIZE;
 
     if (!isLargeDiff) {
-        return await getSingleCommitMessage(diff);
+        return await getSingleCommitMessage(provider, diff);
     }
 
     console.log(`Large diff detected (${diff.length} chars). Using chunked summary approach...`);
 
-    // 1. Map: Split diff into chunks and generate summaries for each
     const chunks = [];
     for (let i = 0; i < diff.length; i += CHUNK_SIZE) {
         chunks.push(diff.substring(i, i + CHUNK_SIZE));
     }
 
     const summaryPromises = chunks.map(async (chunk, index) => {
-        const prompt = `Analyze this portion (${index + 1}/${chunks.length}) of a git diff and provide a 1-sentence summary of the changes.
-Diff snippet:
-${chunk}`;
-
+        const prompt = `Analyze this portion (${index + 1}/${chunks.length}) of a git diff and provide a 1-sentence summary of the changes.\nDiff snippet:\n${chunk}`;
         try {
-            const response = await openai.chat.completions.create({
-                model: 'qwen/qwen3.8-27b',
-                messages: [{ role: 'user', content: prompt }],
-                temperature: 0.2,
-                max_tokens: 100,
-            });
-            return response.choices[0].message.content.trim();
+            return await provider.generate(prompt);
         } catch (e) {
             return `Error summarizing chunk ${index + 1}: ${e.message}`;
         }
@@ -58,7 +92,6 @@ ${chunk}`;
     const summaries = await Promise.all(summaryPromises);
     const combinedSummaries = summaries.join('\n');
 
-    // 2. Reduce: Combine all summaries into one final professional commit message
     const finalPrompt = `
 Based on the following summaries of changes across multiple files, write one professional, concise commit message.
 Follow the Conventional Commits specification (e.g., feat: ..., fix: ..., chore: ..., docs: ..., style: ..., refactor: ..., perf: ..., test: ...).
@@ -69,23 +102,16 @@ ${combinedSummaries}
     `.trim();
 
     try {
-        const response = await openai.chat.completions.create({
-            model: 'qwen/qwen3.8-27b',
-            messages: [{ role: 'user', content: finalPrompt }],
-            temperature: 0.2,
-            max_tokens: 100,
-        });
-
-        return response.choices[0].message.content.trim();
+        return await provider.generate(finalPrompt);
     } catch (error) {
         throw new Error(`Final reduction failed: ${error.message}`);
     }
 }
 
 /**
- * Helper to generate a commit message from a single diff (used for small changes).
+ * Helper to generate a commit message from a single diff.
  */
-async function getSingleCommitMessage(diff) {
+async function getSingleCommitMessage(provider, diff) {
     const prompt = `
 Analyze the following git diff and write a professional, concise commit message.
 Follow the Conventional Commits specification (e.g., feat: ..., fix: ..., chore: ..., docs: ..., style: ..., refactor: ..., perf: ..., test: ...).
@@ -96,14 +122,7 @@ ${diff}
     `.trim();
 
     try {
-        const response = await openai.chat.completions.create({
-            model: 'qwen/qwen3.8-27b',
-            messages: [{ role: 'user', content: prompt }],
-            temperature: 0.2,
-            max_tokens: 100,
-        });
-
-        return response.choices[0].message.content.trim();
+        return await provider.generate(prompt);
     } catch (error) {
         throw new Error(`AI generation failed: ${error.message}`);
     }

package/src/index.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 const { Command } = require('commander');
+const readline = require('node:readline/promises');
+const { stdin: input, stdout: output } = require('node:process');
 const git = require('./git');
 const ai = require('./ai');
 require('dotenv').config();
@@ -17,6 +19,7 @@ program
     .option('-m, --message <message>', 'override the AI-generated commit message')
     .option('--dry-run', 'preview the generated message without committing')
     .action(async (options) => {
+        const rl = readline.createInterface({ input, output });
         try {
             if (!(await git.isGitRepo())) {
                 console.error('Error: Current directory is not a git repository.');
@@ -29,6 +32,7 @@ program
             const diff = await git.getStagedDiff();
             if (!diff) {
                 console.log('No changes to commit.');
+                rl.close();
                 return;
             }
 
@@ -39,21 +43,39 @@ program
             } else {
                 console.log('Generating AI commit message...');
                 commitMessage = await ai.generateCommitMessage(diff);
-                console.log(`Generated message: ${commitMessage}`);
+                console.log(`\nGenerated message: ${commitMessage}\n`);
+
+                if (!options.dryRun) {
+                    const choice = await rl.question('(A)ccept, (E)dit, or (D)ecline? [a/e/d]: ');
+                    const action = choice.toLowerCase().trim();
+
+                    if (action === 'd') {
+                        console.log('Commit cancelled by user.');
+                        rl.close();
+                        return;
+                    } else if (action === 'e') {
+                        const newMessage = await rl.question('Enter new commit message: ');
+                        commitMessage = newMessage.trim() || commitMessage;
+                        console.log(`Updated message: ${commitMessage}`);
+                    } else {
+                        // Default to accept
+                    }
+                }
             }
 
             if (options.dryRun) {
                 console.log('Dry run enabled. Skipping commit.');
-                return;
+            } else {
+                console.log('Committing changes...');
+                await git.commit(commitMessage);
+                console.log('Successfully committed changes!');
             }
 
-            console.log('Committing changes...');
-            await git.commit(commitMessage);
-            console.log('Successfully committed changes!');
-
         } catch (error) {
             console.error(`Error: ${error.message}`);
             process.exit(1);
+        } finally {
+            rl.close();
         }
     });