@vedanshsharma/commit-gen 1.0.0

package/README.md

@@ -0,0 +1,80 @@
+# 🚀 Commit Message Generator (commitgen)
+
+A lightning-fast, offline-first CLI tool that reads your staged git diffs and automatically generates professional Conventional Commits using locally running LLMs (via Ollama).
+
+*(Replace this text with a Demo GIF once recorded)*
+
+## ✨ Why this tool?
+
+- **100% Offline & Private:** Uses local LLMs. Your source code never leaves your machine.
+- **Zero API Costs:** No OpenAI/Anthropic API keys needed.
+- **Professional History:** Strictly adheres to the [Conventional Commits](https://www.conventionalcommits.org/) specification.
+- **Lightning Fast:** Generates and commits in seconds without disrupting your terminal flow.
+
+## 🛠 Prerequisites
+
+1. **Node.js** (v18+ recommended for native `fetch`).
+2. **Ollama** - You must have [Ollama](https://ollama.com/) installed and running locally.
+3. **LLM Model** - Download your preferred model (default is `mistral`):
+   ```bash
+   ollama pull mistral
+   ```
+
+## 📦 Installation
+
+To install this tool globally on your machine so you can use it in any repository:
+
+```bash
+# Clone the repository
+git clone https://github.com/VSDeadShot/commit-gen.git
+cd commit-gen
+
+# Install dependencies and link globally
+npm install
+npm link
+```
+
+## 🚀 Usage
+
+Whenever you have changes ready to commit:
+
+1. Stage your files as usual:
+   ```bash
+   git add <files>
+   ```
+
+2. Run the CLI:
+   ```bash
+   commitgen
+   ```
+
+3. The AI-generated commit message will be presented in a styled box. You can then:
+   - **Accept and Commit** instantly
+   - **Regenerate** if you want a different variation
+   - **Edit Manually** to tweak the generated message inline
+   - **Cancel** to abort without committing
+
+### Command Options
+
+- **Change Model**: Specify a different Ollama model (defaults to `mistral`).
+  ```bash
+  commitgen --model llama3.2
+  ```
+
+- **Dry Run**: Generate and preview the message without actually running `git commit`.
+  ```bash
+  commitgen --dry-run
+  ```
+
+- **Gemini Fallback**: Use the Gemini API instead of local Ollama (requires the `GEMINI_API_KEY` environment variable).
+  ```bash
+  commitgen --gemini
+  ```
+
+## 🏗 Tech Stack
+
+- **JavaScript / Node.js ES Modules**
+- **Commander.js** - CLI command orchestration
+- **Inquirer.js (Classic)** - Interactive prompts
+- **Chalk** - Premium terminal styling
+- **Native Node Fetch & Child_Process** - Zero bloat system integration

package/bin/commitgen.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../src/index.js';
+
+run();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vedanshsharma/commit-gen",
+  "version": "1.0.0",
+  "description": "CLI to generate Conventional Commits using local LLMs or Gemini",
+  "bin": {
+    "commitgen": "bin/commitgen.js"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VSDeadShot/commit-gen.git"
+  },
+  "keywords": [
+    "git",
+    "commit",
+    "cli",
+    "ai",
+    "ollama",
+    "conventional-commits"
+  ],
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "bugs": {
+    "url": "https://github.com/VSDeadShot/commit-gen/issues"
+  },
+  "homepage": "https://github.com/VSDeadShot/commit-gen#readme",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "clipboardy": "^5.3.1",
+    "commander": "^15.0.0",
+    "inquirer": "^14.0.2"
+  }
+}

package/src/config.js

@@ -0,0 +1,39 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.commitgen');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG = {
+    model: 'mistral'
+};
+
+/**
+ * Reads the configuration file or returns defaults if it doesn't exist.
+ */
+export async function getConfig() {
+    try {
+        const data = await fs.readFile(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+    } catch (error) {
+        // If file doesn't exist or is invalid, return defaults
+        return DEFAULT_CONFIG;
+    }
+}
+
+/**
+ * Updates the configuration file with new values.
+ */
+export async function setConfig(newConfig) {
+    try {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        
+        const currentConfig = await getConfig();
+        const mergedConfig = { ...currentConfig, ...newConfig };
+        
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(mergedConfig, null, 2));
+    } catch (error) {
+        throw new Error('Failed to save configuration: ' + error.message);
+    }
+}

package/src/gemini.js

@@ -0,0 +1,40 @@
+/**
+ * Sends the prompt to the Gemini API and returns the generated commit message.
+ * @param {string} prompt The full prompt containing the diff and instructions
+ * @returns {Promise<string>} The generated commit message
+ */
+export async function generateCommitMessageGemini(prompt) {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        throw new Error('GEMINI_API_KEY environment variable is not set.');
+    }
+
+    try {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                contents: [{
+                    parts: [{ text: prompt }]
+                }]
+            }),
+        });
+
+        if (!response.ok) {
+            const errBody = await response.text();
+            throw new Error(`Gemini API returned status ${response.status}: ${errBody}`);
+        }
+
+        const data = await response.json();
+        
+        if (!data.candidates || data.candidates.length === 0) {
+            throw new Error('Gemini API returned no candidates.');
+        }
+
+        return data.candidates[0].content.parts[0].text.trim();
+    } catch (error) {
+        throw new Error('Failed to generate commit message via Gemini: ' + error.message);
+    }
+}

package/src/git.js

@@ -0,0 +1,44 @@
+import { execFile } from 'child_process';
+import util from 'util';
+
+const execFilePromise = util.promisify(execFile);
+
+/**
+ * Checks if the current working directory is inside a git repository.
+ * @returns {Promise<boolean>}
+ */
+export async function isGitRepo() {
+    try {
+        await execFilePromise('git', ['rev-parse', '--is-inside-work-tree']);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * Gets the currently staged git diff.
+ * @returns {Promise<string>} The diff output
+ */
+export async function getStagedDiff() {
+    try {
+        const { stdout } = await execFilePromise('git', ['diff', '--staged']);
+        return stdout.trim();
+    } catch (error) {
+        throw new Error('Failed to get staged diff: ' + error.message);
+    }
+}
+
+/**
+ * Commits the staged changes with the provided message.
+ * @param {string} message The commit message
+ * @returns {Promise<string>} stdout from git commit
+ */
+export async function commitChanges(message) {
+    try {
+        const { stdout } = await execFilePromise('git', ['commit', '-m', message]);
+        return stdout.trim();
+    } catch (error) {
+        throw new Error('Failed to commit changes: ' + error.message);
+    }
+}

package/src/index.js

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { isGitRepo, getStagedDiff, commitChanges } from './git.js';
+import { buildPrompt } from './prompt.js';
+import { generateCommitMessage } from './ollama.js';
+import { generateCommitMessageGemini } from './gemini.js';
+import { displayMessage, promptUserAction, promptManualEdit, promptConfigMenu } from './ui.js';
+import { getConfig, setConfig } from './config.js';
+
+const program = new Command();
+
+program
+    .name('commitgen')
+    .description('CLI to generate Conventional Commits using local LLMs')
+    .version('1.0.0');
+
+program.command('config')
+    .description('Configure default settings')
+    .action(async () => {
+        try {
+            const config = await getConfig();
+            console.log(chalk.magenta.bold('\n⚙️  Commitgen Configuration\n'));
+            const answers = await promptConfigMenu(config.model);
+            await setConfig(answers);
+            console.log(chalk.green.bold('\n✅ Configuration saved successfully to ~/.commitgen/config.json!\n'));
+        } catch (error) {
+            console.log('\n' + chalk.red.bold('❌ Error: ') + error.message);
+            process.exit(1);
+        }
+    });
+
+program
+    .option('-m, --model <name>', 'Ollama model to use')
+    .option('--dry-run', "show generated message but don't commit")
+    .option('--gemini', "use Gemini API instead of local Ollama")
+    .action(async (options) => {
+        try {
+            const config = await getConfig();
+            const selectedModel = options.model || config.model;
+
+            // 1. Verify we are in a git repository
+            const isRepo = await isGitRepo();
+            if (!isRepo) {
+                console.log(chalk.red.bold('❌ Error:') + ' You are not inside a git repository.');
+                process.exit(1);
+            }
+
+            // 2. Get staged changes
+            const diff = await getStagedDiff();
+            if (!diff) {
+                console.log(chalk.yellow('⚠️  No staged changes found.'));
+                console.log(chalk.gray('Run `git add <files>` and try again.'));
+                process.exit(0);
+            }
+
+            // 3. Main interactive loop
+            while (true) {
+                console.log(chalk.gray('\nAnalyzing staged diff and generating message...'));
+                
+                const prompt = buildPrompt(diff);
+                
+                let message;
+                if (options.gemini) {
+                    if (!process.env.GEMINI_API_KEY) {
+                        console.log(chalk.red.bold('\n❌ Error: ') + 'GEMINI_API_KEY environment variable is missing.');
+                        console.log(chalk.gray('Set it using: $env:GEMINI_API_KEY="your_key" (PowerShell) or export GEMINI_API_KEY="your_key" (Mac/Linux)\n'));
+                        process.exit(1);
+                    }
+                    message = await generateCommitMessageGemini(prompt);
+                } else {
+                    message = await generateCommitMessage(prompt, selectedModel);
+                }
+                
+                displayMessage(message);
+                
+                if (options.dryRun) {
+                    console.log(chalk.gray('Dry run complete. No changes were committed.\n'));
+                    process.exit(0);
+                }
+                
+                const action = await promptUserAction();
+                
+                if (action === 'accept') {
+                    await commitChanges(message);
+                    console.log(chalk.green.bold('\n✅ Successfully committed!'));
+                    break;
+                } else if (action === 'regenerate') {
+                    // Just continue the loop to regenerate
+                    continue;
+                } else if (action === 'edit') {
+                    const edited = await promptManualEdit(message);
+                    if (edited && edited.trim() !== '') {
+                        await commitChanges(edited.trim());
+                        console.log(chalk.green.bold('\n✅ Successfully committed with your edits!'));
+                    } else {
+                        console.log(chalk.red('\n❌ Commit aborted: Message cannot be empty.'));
+                    }
+                    break;
+                } else if (action === 'cancel') {
+                    console.log(chalk.gray('\nProcess cancelled. No changes committed.'));
+                    break;
+                }
+            }
+        } catch (error) {
+            console.log('\n' + chalk.red.bold('❌ Error: ') + error.message);
+            process.exit(1);
+        }
+    });
+
+export function run() {
+    program.parse(process.argv);
+}

package/src/ollama.js

@@ -0,0 +1,34 @@
+/**
+ * Sends the prompt to the local Ollama instance and returns the generated commit message.
+ * @param {string} prompt The full prompt containing the diff and instructions
+ * @param {string} model The Ollama model to use (default: 'mistral')
+ * @returns {Promise<string>} The generated commit message
+ */
+export async function generateCommitMessage(prompt, model = 'mistral') {
+    try {
+        const response = await fetch('http://localhost:11434/api/generate', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: model,
+                prompt: prompt,
+                stream: false, // We want the full response at once
+            }),
+        });
+
+        if (!response.ok) {
+            throw new Error(`Ollama API returned status ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+        return data.response.trim();
+    } catch (error) {
+        // Handle connection refused specifically to give a friendly error
+        if (error.code === 'ECONNREFUSED' || (error.cause && error.cause.code === 'ECONNREFUSED')) {
+            throw new Error('Could not connect to Ollama. Please make sure Ollama is running locally on port 11434.');
+        }
+        throw new Error('Failed to generate commit message: ' + error.message);
+    }
+}

package/src/prompt.js

@@ -0,0 +1,36 @@
+const SYSTEM_PROMPT = `You are a git commit message generator. You follow the Conventional Commits 
+specification exactly. Analyze the provided git diff and generate ONE commit 
+message. Rules:
+- Format: type(scope): description
+- Type must be one of: feat, fix, refactor, docs, style, test, chore
+- Scope is the main file or module changed (optional but preferred)
+- Description is lowercase, present tense, under 72 characters, no period
+- Return ONLY the commit message, nothing else, no explanation, no markdown
+- Do NOT wrap the output in a code block.`;
+
+/**
+ * Cleans and truncates the diff to ensure it fits within the context window.
+ * @param {string} diff The raw git diff
+ * @param {number} maxLength The maximum allowed length for the diff (default 3500)
+ * @returns {string} The processed diff
+ */
+export function truncateDiff(diff, maxLength = 3500) {
+    if (!diff) return '';
+    
+    if (diff.length <= maxLength) {
+        return diff;
+    }
+
+    return diff.substring(0, maxLength) + '\n\n... [DIFF TRUNCATED]';
+}
+
+/**
+ * Builds the final prompt to be sent to the LLM.
+ * @param {string} rawDiff The raw git diff from the staged files
+ * @returns {string} The complete prompt
+ */
+export function buildPrompt(rawDiff) {
+    const diff = truncateDiff(rawDiff);
+    
+    return `${SYSTEM_PROMPT}\n\nHere is the git diff:\n\`\`\`diff\n${diff}\n\`\`\`\n\nGenerate the commit message now:`;
+}

package/src/ui.js

@@ -0,0 +1,70 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+/**
+ * Displays the generated commit message with a premium, clean aesthetic.
+ * @param {string} message The commit message to display
+ */
+export function displayMessage(message) {
+    console.log('\n' + chalk.magenta.bold('✨ Generated Commit Message ✨'));
+    console.log(chalk.gray('─────────────────────────────────────────────'));
+    console.log(chalk.cyanBright.bold(message));
+    console.log(chalk.gray('─────────────────────────────────────────────\n'));
+}
+
+/**
+ * Prompts the user for their next action using a styled list.
+ * @returns {Promise<string>} The selected action ('accept', 'regenerate', 'edit', 'cancel')
+ */
+export async function promptUserAction() {
+    const { action } = await inquirer.prompt([
+        {
+            type: 'select',
+            name: 'action',
+            message: chalk.white.bold('What would you like to do?'),
+            choices: [
+                { name: chalk.green('🚀 Accept and Commit'), value: 'accept' },
+                { name: chalk.yellow('🔄 Regenerate Message'), value: 'regenerate' },
+                { name: chalk.blue('✏️  Edit Manually'), value: 'edit' },
+                { name: chalk.red('❌ Cancel Process'), value: 'cancel' }
+            ],
+            prefix: chalk.magenta('❯') // Overrides the standard '?' prefix
+        }
+    ]);
+    return action;
+}
+
+/**
+ * Prompts the user to edit the message manually inline.
+ * @param {string} currentMessage The default message to pre-fill
+ * @returns {Promise<string>} The edited message
+ */
+export async function promptManualEdit(currentMessage) {
+    const { editedMessage } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'editedMessage',
+            message: chalk.white.bold('Edit your commit message:'),
+            default: currentMessage,
+            prefix: chalk.magenta('❯')
+        }
+    ]);
+    return editedMessage;
+}
+
+/**
+ * Prompts the user to configure their default settings.
+ * @param {string} currentModel The current default model
+ * @returns {Promise<{model: string}>} The new config answers
+ */
+export async function promptConfigMenu(currentModel) {
+    return await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'model',
+            message: chalk.white.bold('Enter your preferred default Ollama model:'),
+            default: currentModel,
+            prefix: chalk.magenta('❯')
+        }
+    ]);
+}