git-message-ai-commit 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# Git Message AI Commit
+
+A CLI tool that uses a local [Ollama](https://ollama.com/) instance to generate Conventional Commits messages from your staged changes.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) (v18+)
+- [Ollama](https://ollama.com/) running locally (default: `http://localhost:11434`)
+- `git`
+
+## Installation
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+## Usage
+
+Stage your changes:
+
+```bash
+git add .
+```
+
+Run the tool:
+
+```bash
+git-ai-commit
+```
+
+### Options
+
+- `-m, --model <name>`: Specify Ollama model (default: `llama3`)
+- `--host <url>`: Ollama host (default: `http://localhost:11434`)
+- `--max-chars <n>`: Max diff characters sent (default: `16000`)
+- `--type <type>`: Force a commit type (feat, fix, etc.)
+- `--dry-run`: Print message to stdout without committing

package/dist/cli.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import prompts from "prompts";
+import { isGitRepo, hasStagedChanges, getStagedDiff, gitCommit } from "./git.js";
+import { ollamaChat, checkOllamaConnection } from "./ollama.js";
+import { buildMessages } from "./prompt.js";
+import { clampDiff } from "./util.js";
+const ALLOWED_TYPES = new Set(["feat", "fix", "chore", "refactor", "docs", "test", "perf", "build", "ci"]);
+function validateMessage(msg) {
+    const s = (msg ?? "").trim();
+    if (!s)
+        return { ok: false, reason: "Message is empty" };
+    if (s.length > 72)
+        return { ok: false, reason: "Message is too long" };
+    if (s.includes("```"))
+        return { ok: false, reason: "No markdown/code fences" };
+    const firtstLine = s.split("\n")[0].trim();
+    const cc = /^([a-z]+)(\([^)]+\))?!?:\s.+$/;
+    if (!cc.test(firtstLine))
+        return { ok: false, reason: "Not Conventional Commits format" };
+    const type = firtstLine.match(/^([a-z]+)\b/)?.[1];
+    if (!type || !ALLOWED_TYPES.has(type)) {
+        return { ok: false, reason: `Type must be one of: ${[...ALLOWED_TYPES].join(", ")}` };
+    }
+    if (firtstLine.length > 72)
+        return { ok: false, reason: "Subject line > 72 chars" };
+    if (firtstLine.endsWith("."))
+        return { ok: false, reason: "Subject should not end with a period" };
+    return { ok: true };
+}
+async function main() {
+    // ... (keep program definition)
+    const program = new Command();
+    program
+        .name("git-ai-commit")
+        // ... (keep options)
+        .description("Generate a Conventional Commit message from staged changes using local Ollama")
+        .option("-m, --model <name>", "Ollama model name", "llama3")
+        .option("--host <url>", "Ollama host", "http://localhost:11434")
+        .option("--max-chars <n>", "Max diff characters sent to model", (v) => parseInt(v, 10), 16000)
+        .option("--type <type>", "Force commit type (feat|fix|chore|refactor|docs|test|perf|build|ci)")
+        .option("--scope <scope>", "Optional scope, e.g. api, infra")
+        .option("--dry-run", "Print message only, do not commit", false)
+        .option("--no-verify", "Pass --no-verify to git commit", false)
+        .parse(process.argv);
+    const opts = program.opts();
+    if (!(await isGitRepo())) {
+        console.error("Not a git repository.");
+        process.exit(1);
+    }
+    if (!(await hasStagedChanges())) {
+        console.error("No staged changes. Stage files first: git add <files>.");
+        process.exit(1);
+    }
+    // Check Ollama connection first
+    const isUp = await checkOllamaConnection(opts.host);
+    if (!isUp) {
+        console.error(`Cannot reach Ollama at ${opts.host}. Is it running?`);
+        console.error("Try running 'ollama list' or 'ollama serve' in another terminal.");
+        process.exit(1);
+    }
+    if (opts.type && !ALLOWED_TYPES.has(opts.type)) {
+        console.error(`Invalid --type. Must be one of: ${[...ALLOWED_TYPES].join(", ")}`);
+        process.exit(1);
+    }
+    const stagedDiff = await getStagedDiff();
+    const diff = clampDiff(stagedDiff, opts.maxChars);
+    while (true) {
+        const messages = buildMessages({
+            diff,
+            forcedType: opts.type ?? null,
+            scope: opts.scope ?? null
+        });
+        process.stdout.write("⏳ Generating commit message... ");
+        let suggestion = "";
+        try {
+            const raw = (await ollamaChat({
+                host: opts.host,
+                model: opts.model,
+                messages,
+                json: true
+            })).trim();
+            try {
+                const parsed = JSON.parse(raw);
+                suggestion = parsed.message ?? raw;
+            }
+            catch {
+                // Fallback if model ignored json mode (rare)
+                suggestion = raw;
+            }
+            // Auto-fix: remove trailing period
+            if (suggestion.endsWith(".")) {
+                suggestion = suggestion.slice(0, -1);
+            }
+            process.stdout.write("Done!\n");
+        }
+        catch (e) {
+            process.stdout.write("Failed.\n");
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exit(1);
+        }
+        const v = validateMessage(suggestion);
+        if (!v.ok)
+            console.warn(`AI output validation failed: ${v.reason}`);
+        console.log("\n--- Suggested commit message ---\n");
+        console.log(suggestion);
+        console.log("\n-------------------------------\n");
+        const { action } = await prompts({
+            type: "select",
+            name: "action",
+            message: "What next?",
+            choices: [
+                { title: "✅ Accept and commit", value: "accept" },
+                { title: "✏️  Edit", value: "edit" },
+                { title: "🔁 Regenerate", value: "regen" },
+                { title: "🧪 Dry-run (print only)", value: "dry" },
+                { title: "❌ Cancel", value: "cancel" }
+            ],
+            initial: 0
+        });
+        // ... (keep rest of loop)
+        if (!action || action === "cancel") {
+            console.log("Cancelled.");
+            process.exit(0);
+        }
+        if (action === "regen")
+            continue;
+        let finalMsg = suggestion;
+        if (action === "edit") {
+            const { msg } = await prompts({
+                type: "text",
+                name: "msg",
+                message: "Edit commit message",
+                initial: finalMsg
+            });
+            if (!msg) {
+                console.log("Cancelled.");
+                process.exit(0);
+            }
+            finalMsg = String(msg).trim();
+        }
+        if (action === "dry" || opts.dryRun) {
+            console.log(finalMsg);
+            process.exit(0);
+        }
+        const v2 = validateMessage(finalMsg);
+        if (!v2.ok) {
+            const { yes } = await prompts({
+                type: "confirm",
+                name: "yes",
+                message: `Still fails validation (${v2.reason}). Commit anyway?`,
+                initial: false
+            });
+            if (!yes)
+                continue;
+        }
+        await gitCommit(finalMsg, { noVerify: opts.noVerify });
+        console.log("Committed.");
+        process.exit(0);
+    }
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.stack : String(err));
+    process.exit(1);
+});

package/dist/git.js

@@ -0,0 +1,32 @@
+import { execa } from "execa";
+export async function isGitRepo() {
+    try {
+        await execa("git", ["rev-parse", "--is-inside-work-tree"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function hasStagedChanges() {
+    // exit code 0 => no diff, 1 => diff exists
+    try {
+        await execa("git", ["diff", "--staged", "--quiet"]);
+        return false;
+    }
+    catch (e) {
+        if (typeof e?.exitCode === "number" && e.exitCode === 1)
+            return true;
+        throw e;
+    }
+}
+export async function getStagedDiff() {
+    const { stdout } = await execa("git", ["diff", "--staged", "--"]);
+    return stdout ?? "";
+}
+export async function gitCommit(message, opts = {}) {
+    const args = ["commit", "-m", message];
+    if (opts.noVerify)
+        args.push("--no-verify");
+    await execa("git", args, { stdio: "inherit" });
+}

package/dist/ollama.js

@@ -0,0 +1,49 @@
+export async function checkOllamaConnection(host) {
+    try {
+        const url = `${host.replace(/\/$/, "")}/api/tags`; // "tags" endpoint is lightweight
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), 2000); // 2s timeout for check
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(id);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ollamaChat(opts) {
+    const url = `${opts.host.replace(/\/$/, "")}/api/chat`;
+    // Default 60s timeout for generation
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 60000);
+    try {
+        const body = {
+            model: opts.model,
+            messages: opts.messages,
+            stream: false
+        };
+        if (opts.json)
+            body.format = "json";
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Ollama error ${res.status}: ${text}`);
+        }
+        const data = await res.json();
+        return data?.message?.content ?? "";
+    }
+    catch (e) {
+        if (e.name === "AbortError") {
+            throw new Error("Ollama request timed out (60s).");
+        }
+        throw e;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

package/dist/prompt.js

@@ -0,0 +1,33 @@
+const SYSTEM = `You write excellent git commit messages.
+
+Rules:
+- Output valid JSON object: { "message": "commit message string" }
+- NO markdown, NO commentary. JUST JSON.
+- Use Conventional Commits: type(scope optional): subject
+- Allowed types: feat, fix, chore, refactor, docs, test, perf, build, ci
+- Subject line: <= 72 chars, imperative mood, present tense, NO trailing period.
+- If really useful, add a blank line and a short body explaining "what" and "why".
+- Never mention that you are an AI.
+- Keep it short and simple and dont be chatty.
+- Do not use "!" (breaking change) unless the diff contains significant breaking changes.`;
+export function buildMessages(opts) {
+    const constraints = [
+        opts.forcedType ? `Forced type: ${opts.forcedType}` : "Choose the best type from allowed list.",
+        opts.scope ? `Use scope: ${opts.scope}` : "Use a scope only if it helps; otherwise omit."
+    ].join("\n");
+    const user = `Task: Generate a specific and concise Conventional Commit message for the following git diff.
+
+Constraints:
+${constraints}
+
+Input Data:
+--- BEGIN DIFF ---
+${opts.diff}
+--- END DIFF ---
+
+Output the commit message only. Do not repeat the task description.`;
+    return [
+        { role: "system", content: SYSTEM },
+        { role: "user", content: user }
+    ];
+}

package/dist/util.js

@@ -0,0 +1,10 @@
+export function clampDiff(diff, maxChars) {
+    const s = diff ?? "";
+    if (s.length <= maxChars)
+        return s;
+    const head = Math.floor(maxChars * 0.7);
+    const tail = maxChars - head - 200;
+    return (s.slice(0, head) +
+        "\n\n--- DIFF TRUNCATED ---\n\n" +
+        s.slice(Math.max(0, s.length - tail)));
+}

package/eslint.config.mjs

@@ -0,0 +1,14 @@
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+    { ignores: ["**/dist/**", "dist/", "node_modules/"] },
+    js.configs.recommended,
+    ...tseslint.configs.recommended,
+    {
+        rules: {
+            "@typescript-eslint/no-explicit-any": "warn",
+            "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }]
+        }
+    }
+);

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "git-message-ai-commit",
+  "version": "1.0.0",
+  "description": "AI git commit messages using local Ollama",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "lint": "eslint .",
+    "prepare": "npm run build"
+  },
+  "keywords": [],
+  "author": "Denis Tola",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "-": "^0.0.1",
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.8",
+    "@types/prompts": "^2.4.9",
+    "eslint": "^9.39.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.0"
+  },
+  "bin": {
+    "git-ai-commit": "dist/cli.js"
+  }
+}