git-auto-ai-himamshu 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# Git-Auto 🚀
+
+`git-auto` is a lightweight CLI tool that automates the process of staging changes and generating professional, AI-powered commit messages. No more guessing what to write in your commit messages—let AI handle it!
+
+## ✨ Features
+
+- **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.
+
+## 📦 Installation
+
+### 1. Clone the Repository
+```bash
+git clone https://github.com/your-username/git-auto.git
+cd git-auto
+```
+
+### 2. Install Dependencies
+```bash
+npm install
+```
+
+### 3. Link Globally
+To use the `git-auto` command anywhere on your system:
+```bash
+npm link
+```
+
+## ⚙️ Configuration
+
+The tool uses the Groq API for fast, free AI generation.
+
+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
+   ```
+
+## 🚀 Usage
+
+### Basic Commit
+Stages all changes and commits with an AI-generated message:
+```bash
+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"
+```
+
+### Preview Message (Dry Run)
+See what the AI would generate without actually committing:
+```bash
+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"`.
+
+## 📜 License
+MIT

package/initial.txt

@@ -0,0 +1,2 @@
+initial file
+update

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "git-auto-ai-himamshu",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "bin": {
+    "git-auto": "src/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^15.0.0",
+    "dotenv": "^18.0.4",
+    "openai": "^7.23.0",
+    "simple-git": "^4.0.1"
+  }
+}

package/src/ai.js

@@ -0,0 +1,45 @@
+const OpenAI = require('openai');
+require('dotenv').config();
+
+const openai = new OpenAI({
+    apiKey: process.env.GROQ_API_KEY,
+    baseURL: "https://api.groq.com/openai/v1"
+});
+
+/**
+ * Generates a professional commit message based on the provided git diff.
+ * @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.
+ */
+async function generateCommitMessage(diff) {
+    if (!process.env.GROQ_API_KEY) {
+        throw new Error('GROQ_API_KEY is missing from .env file.');
+    }
+
+    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: ...).
+Only return the commit message string itself, without any quotes or explanation.
+
+Diff:
+${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();
+    } catch (error) {
+        throw new Error(`AI generation failed: ${error.message}`);
+    }
+}
+
+module.exports = {
+    generateCommitMessage
+};

package/src/git.js

@@ -0,0 +1,47 @@
+const { simpleGit } = require('simple-git');
+const git = simpleGit();
+
+/**
+ * Checks if the current directory is a git repository.
+ * @returns {Promise<boolean>}
+ */
+async function isGitRepo() {
+    try {
+        await git.revparse(['--is-inside-work-tree']);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * Stages all changes in the repository.
+ * @returns {Promise<void>}
+ */
+async function stageAll() {
+    await git.add('.');
+}
+
+/**
+ * Retrieves the diff of currently staged changes.
+ * @returns {Promise<string>}
+ */
+async function getStagedDiff() {
+    return await git.diff(['--cached']);
+}
+
+/**
+ * Commits the staged changes with the given message.
+ * @param {string} message - The commit message to use.
+ * @returns {Promise<void>}
+ */
+async function commit(message) {
+    await git.commit(message);
+}
+
+module.exports = {
+    isGitRepo,
+    stageAll,
+    getStagedDiff,
+    commit
+};

package/src/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+const { Command } = require('commander');
+const git = require('./git');
+const ai = require('./ai');
+require('dotenv').config();
+
+const program = new Command();
+
+program
+    .name('git-auto')
+    .description('AI-powered git commit tool')
+    .version('1.0.0');
+
+program
+    .command('commit')
+    .description('Automatically stage and commit changes with an AI-generated message')
+    .option('-m, --message <message>', 'override the AI-generated commit message')
+    .option('--dry-run', 'preview the generated message without committing')
+    .action(async (options) => {
+        try {
+            if (!(await git.isGitRepo())) {
+                console.error('Error: Current directory is not a git repository.');
+                process.exit(1);
+            }
+
+            console.log('Staging changes...');
+            await git.stageAll();
+
+            const diff = await git.getStagedDiff();
+            if (!diff) {
+                console.log('No changes to commit.');
+                return;
+            }
+
+            let commitMessage;
+            if (options.message) {
+                commitMessage = options.message;
+                console.log(`Using custom message: ${commitMessage}`);
+            } else {
+                console.log('Generating AI commit message...');
+                commitMessage = await ai.generateCommitMessage(diff);
+                console.log(`Generated message: ${commitMessage}`);
+            }
+
+            if (options.dryRun) {
+                console.log('Dry run enabled. Skipping commit.');
+                return;
+            }
+
+            console.log('Committing changes...');
+            await git.commit(commitMessage);
+            console.log('Successfully committed changes!');
+
+        } catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
+program.parse(process.argv);