git-message-ai-commit 1.0.0 → 2.0.0

package/README.md

@@ -11,9 +11,11 @@ A CLI tool that uses a local [Ollama](https://ollama.com/) instance to generate
 ## Installation
 
 ```bash
-npm install
-npm run build
-npm link
+# Global installation
+npm install -g git-message-ai-commit
+
+# Or run directly with npx
+npx git-message-ai-commit
 ```
 
 ## Usage
@@ -34,6 +36,48 @@ git-ai-commit
 
 - `-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`)
+- `--max-chars <n>`: Max diff characters sent (range: `500-200000`, default: `16000`)
 - `--type <type>`: Force a commit type (feat, fix, etc.)
+- `--scope <scope>`: Optional commit scope
 - `--dry-run`: Print message to stdout without committing
+- `--ci`: Non-interactive mode for CI/hooks
+- `--allow-invalid`: Override validation and allow invalid messages
+- `--timeout-ms <n>`: Ollama request timeout in milliseconds (range: `1000-300000`, default: `60000`)
+- `--retries <n>`: Retry count for transient Ollama failures (range: `0-5`, default: `2`)
+- `--output <text|json>`: Output format (default: `text`)
+- `--no-verify`: Pass `--no-verify` to `git commit`
+
+### Environment variables
+
+- `GIT_AI_MODEL`
+- `GIT_AI_HOST`
+- `GIT_AI_TIMEOUT_MS`
+- `GIT_AI_RETRIES`
+
+### CI usage
+
+Generate JSON output in non-interactive mode:
+
+```bash
+git-ai-commit --ci --dry-run --output json
+```
+
+### Exit codes
+
+- `0`: success
+- `1`: usage/configuration error
+- `2`: git context error (not a repo or no staged changes)
+- `3`: Ollama/model error
+- `4`: invalid AI output (blocked by default)
+- `5`: `git commit` failed
+- `6`: unexpected internal error
+
+## Tips
+
+### Set an alias
+
+You can set a shorter alias (e.g. `gmac`) in your shell config (`.zshrc`, `.bashrc`, etc.):
+
+```bash
+alias gmac="git-ai-commit"
+```

package/dist/cli.js

@@ -1,165 +1,130 @@
 #!/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(", ")}` };
+import { ExitCode } from "./exit-codes.js";
+import { parseBoundedInteger } from "./util.js";
+import { isAllowedType } from "./validation.js";
+import { runWorkflow } from "./workflow.js";
+const MIN_MAX_CHARS = 500;
+const MAX_MAX_CHARS = 200000;
+const MIN_TIMEOUT_MS = 1000;
+const MAX_TIMEOUT_MS = 300000;
+const MIN_RETRIES = 0;
+const MAX_RETRIES = 5;
+function readEnv(name, fallback) {
+    const value = process.env[name]?.trim();
+    return value && value.length > 0 ? value : fallback;
+}
+function parseOutput(value) {
+    if (value === "text" || value === "json")
+        return value;
+    throw new Error("--output must be one of: text, json.");
+}
+function parseType(value) {
+    if (!value)
+        return null;
+    const normalized = value.toLowerCase();
+    if (!isAllowedType(normalized)) {
+        throw new Error("Invalid --type. Must be one of: feat, fix, chore, refactor, docs, test, perf, build, ci.");
+    }
+    return normalized;
+}
+function buildOptions(raw) {
+    const model = raw.model.trim();
+    if (!model)
+        throw new Error("--model must be a non-empty string.");
+    const host = raw.host.trim();
+    if (!host)
+        throw new Error("--host must be a non-empty URL.");
+    return {
+        model,
+        host,
+        maxChars: parseBoundedInteger(raw.maxChars, "--max-chars", MIN_MAX_CHARS, MAX_MAX_CHARS),
+        type: parseType(raw.type),
+        scope: raw.scope?.trim() ? raw.scope.trim() : null,
+        dryRun: raw.dryRun,
+        noVerify: raw.noVerify,
+        ci: raw.ci,
+        allowInvalid: raw.allowInvalid,
+        timeoutMs: parseBoundedInteger(raw.timeoutMs, "--timeout-ms", MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
+        retries: parseBoundedInteger(raw.retries, "--retries", MIN_RETRIES, MAX_RETRIES),
+        output: parseOutput(raw.output.toLowerCase())
+    };
+}
+function printJson(result) {
+    if (result.ok) {
+        console.log(JSON.stringify({
+            status: "ok",
+            message: result.message,
+            source: result.source,
+            committed: result.committed
+        }));
+        return;
+    }
+    console.log(JSON.stringify({
+        status: "error",
+        code: result.code,
+        hint: result.hint ?? result.message
+    }));
+}
+function printText(result, options) {
+    if (result.ok) {
+        if (result.cancelled) {
+            console.log("Cancelled.");
+            return;
+        }
+        if (!result.committed) {
+            console.log(result.message);
+            return;
+        }
+        if (options.ci) {
+            console.log(result.message);
+        }
+        else {
+            console.log("Committed.");
+        }
+        return;
     }
-    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 };
+    console.error(result.message);
+    if (result.hint)
+        console.error(result.hint);
 }
 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("-m, --model <name>", "Ollama model name", readEnv("GIT_AI_MODEL", "llama3"))
+        .option("--host <url>", "Ollama host", readEnv("GIT_AI_HOST", "http://localhost:11434"))
+        .option("--max-chars <n>", `Max diff characters sent to model (${MIN_MAX_CHARS}-${MAX_MAX_CHARS})`, "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)
+        .option("--ci", "Non-interactive mode for CI usage", false)
+        .option("--allow-invalid", "Allow commit even if validation fails", false)
+        .option("--timeout-ms <n>", `Ollama request timeout in milliseconds (${MIN_TIMEOUT_MS}-${MAX_TIMEOUT_MS})`, readEnv("GIT_AI_TIMEOUT_MS", "60000"))
+        .option("--retries <n>", `Retry count for transient Ollama failures (${MIN_RETRIES}-${MAX_RETRIES})`, readEnv("GIT_AI_RETRIES", "2"))
+        .option("--output <format>", "Output format (text|json)", "text")
         .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);
+    let options;
+    try {
+        options = buildOptions(program.opts());
     }
-    // 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);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exit(ExitCode.UsageError);
     }
-    if (opts.type && !ALLOWED_TYPES.has(opts.type)) {
-        console.error(`Invalid --type. Must be one of: ${[...ALLOWED_TYPES].join(", ")}`);
-        process.exit(1);
+    const result = await runWorkflow(options);
+    if (options.output === "json") {
+        printJson(result);
     }
-    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);
+    else {
+        printText(result, options);
     }
+    process.exit(result.exitCode);
 }
-main().catch((err) => {
-    console.error(err instanceof Error ? err.stack : String(err));
-    process.exit(1);
+main().catch((error) => {
+    console.error(error instanceof Error ? error.stack : String(error));
+    process.exit(ExitCode.InternalError);
 });

package/dist/exit-codes.js

@@ -0,0 +1,19 @@
+export var ExitCode;
+(function (ExitCode) {
+    ExitCode[ExitCode["Success"] = 0] = "Success";
+    ExitCode[ExitCode["UsageError"] = 1] = "UsageError";
+    ExitCode[ExitCode["GitContextError"] = 2] = "GitContextError";
+    ExitCode[ExitCode["OllamaError"] = 3] = "OllamaError";
+    ExitCode[ExitCode["InvalidAiOutput"] = 4] = "InvalidAiOutput";
+    ExitCode[ExitCode["GitCommitError"] = 5] = "GitCommitError";
+    ExitCode[ExitCode["InternalError"] = 6] = "InternalError";
+})(ExitCode || (ExitCode = {}));
+export const EXIT_CODE_LABEL = {
+    [ExitCode.Success]: "SUCCESS",
+    [ExitCode.UsageError]: "USAGE_ERROR",
+    [ExitCode.GitContextError]: "GIT_CONTEXT_ERROR",
+    [ExitCode.OllamaError]: "OLLAMA_ERROR",
+    [ExitCode.InvalidAiOutput]: "INVALID_AI_OUTPUT",
+    [ExitCode.GitCommitError]: "GIT_COMMIT_ERROR",
+    [ExitCode.InternalError]: "INTERNAL_ERROR"
+};

package/dist/git.js

@@ -1,4 +1,12 @@
 import { execa } from "execa";
+function getExitCode(error) {
+    if (!error || typeof error !== "object")
+        return null;
+    if (!("exitCode" in error))
+        return null;
+    const value = error.exitCode;
+    return typeof value === "number" ? value : null;
+}
 export async function isGitRepo() {
     try {
         await execa("git", ["rev-parse", "--is-inside-work-tree"]);
@@ -14,10 +22,10 @@ export async function hasStagedChanges() {
         await execa("git", ["diff", "--staged", "--quiet"]);
         return false;
     }
-    catch (e) {
-        if (typeof e?.exitCode === "number" && e.exitCode === 1)
+    catch (error) {
+        if (getExitCode(error) === 1)
             return true;
-        throw e;
+        throw error;
     }
 }
 export async function getStagedDiff() {

package/dist/ollama.js

@@ -1,49 +1,165 @@
-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 class OllamaError extends Error {
+    code;
+    hint;
+    status;
+    retryable;
+    constructor(message, code, opts) {
+        super(message);
+        this.name = "OllamaError";
+        this.code = code;
+        this.hint = opts?.hint ?? null;
+        this.status = opts?.status ?? null;
+        this.retryable = opts?.retryable ?? false;
     }
 }
-export async function ollamaChat(opts) {
-    const url = `${opts.host.replace(/\/$/, "")}/api/chat`;
-    // Default 60s timeout for generation
+function toUrl(host, path) {
+    return `${host.replace(/\/$/, "")}${path}`;
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 60000);
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     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),
+        return await fetch(url, {
+            ...init,
             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).");
+    catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+            throw new OllamaError(`Ollama request timed out (${timeoutMs}ms).`, "TIMEOUT", {
+                hint: "Ensure Ollama is running and/or increase --timeout-ms.",
+                retryable: true
+            });
         }
-        throw e;
+        if (error instanceof TypeError) {
+            throw new OllamaError("Cannot reach Ollama.", "UNREACHABLE", {
+                hint: "Run `ollama serve` and verify --host points to the local Ollama endpoint.",
+                retryable: true
+            });
+        }
+        throw error;
     }
     finally {
         clearTimeout(timeoutId);
     }
 }
+export async function listLocalModels(host, timeoutMs = 2000) {
+    const url = toUrl(host, "/api/tags");
+    const res = await fetchWithTimeout(url, { method: "GET" }, timeoutMs);
+    if (!res.ok) {
+        throw new OllamaError(`Ollama returned HTTP ${res.status} while checking models.`, "HTTP_ERROR", {
+            status: res.status,
+            retryable: res.status >= 500,
+            hint: "Confirm Ollama is healthy and reachable on --host."
+        });
+    }
+    let data;
+    try {
+        data = await res.json();
+    }
+    catch {
+        throw new OllamaError("Failed to parse Ollama model list response.", "INVALID_RESPONSE", {
+            hint: "Update Ollama and retry. The /api/tags response was not valid JSON."
+        });
+    }
+    return (data.models ?? [])
+        .map((model) => model.name?.trim())
+        .filter((name) => Boolean(name));
+}
+function matchesModel(requested, available) {
+    const req = requested.toLowerCase();
+    const model = available.toLowerCase();
+    if (req === model)
+        return true;
+    if (!req.includes(":") && model.startsWith(`${req}:`))
+        return true;
+    return false;
+}
+export async function ensureLocalModel(host, model, timeoutMs) {
+    const availableModels = await listLocalModels(host, timeoutMs);
+    const found = availableModels.some((available) => matchesModel(model, available));
+    if (!found) {
+        throw new OllamaError(`Model "${model}" is not available in local Ollama.`, "MODEL_NOT_FOUND", {
+            hint: `Run \`ollama pull ${model}\` and try again.`
+        });
+    }
+}
+export async function checkOllamaConnection(host) {
+    try {
+        await listLocalModels(host, 2000);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shouldRetry(error) {
+    if (error.retryable)
+        return true;
+    return error.code === "HTTP_ERROR" && Boolean(error.status && error.status >= 500);
+}
+function normalizeOllamaError(error) {
+    if (error instanceof OllamaError)
+        return error;
+    if (error instanceof Error) {
+        return new OllamaError(error.message, "HTTP_ERROR");
+    }
+    return new OllamaError(String(error), "HTTP_ERROR");
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function ollamaChat(opts) {
+    const timeoutMs = opts.timeoutMs ?? 60000;
+    const retries = Math.max(0, Math.floor(opts.retries ?? 2));
+    const url = toUrl(opts.host, "/api/chat");
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            const body = {
+                model: opts.model,
+                messages: opts.messages,
+                stream: false
+            };
+            if (opts.json)
+                body.format = "json";
+            const res = await fetchWithTimeout(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(body)
+            }, timeoutMs);
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                if (res.status === 404 && text.toLowerCase().includes("model")) {
+                    throw new OllamaError(`Model "${opts.model}" is not available in local Ollama.`, "MODEL_NOT_FOUND", {
+                        status: res.status,
+                        hint: `Run \`ollama pull ${opts.model}\` and try again.`
+                    });
+                }
+                throw new OllamaError(`Ollama error ${res.status}: ${text}`, "HTTP_ERROR", {
+                    status: res.status,
+                    retryable: res.status >= 500,
+                    hint: "Check Ollama logs and confirm the local model can run."
+                });
+            }
+            const data = await res.json();
+            const content = data?.message?.content;
+            if (typeof content !== "string" || content.trim() === "") {
+                throw new OllamaError("Ollama returned an empty response.", "INVALID_RESPONSE", {
+                    hint: "Try a larger --timeout-ms, then retry generation."
+                });
+            }
+            return content;
+        }
+        catch (error) {
+            const normalized = normalizeOllamaError(error);
+            lastError = normalized;
+            if (attempt < retries && shouldRetry(normalized)) {
+                await sleep(150 * (attempt + 1));
+                continue;
+            }
+            throw normalized;
+        }
+    }
+    throw (lastError ?? new OllamaError("Unknown Ollama failure.", "HTTP_ERROR"));
+}

package/dist/prompt.js

@@ -1,8 +1,9 @@
 const SYSTEM = `You write excellent git commit messages.
 
 Rules:
-- Output valid JSON object: { "message": "commit message string" }
-- NO markdown, NO commentary. JUST JSON.
+- Output ONLY valid JSON object with exactly one key: { "message": "..." }
+- Do not include any keys other than "message".
+- NO markdown and NO commentary.
 - 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.
@@ -25,7 +26,7 @@ Input Data:
 ${opts.diff}
 --- END DIFF ---
 
-Output the commit message only. Do not repeat the task description.`;
+Return JSON only, exactly in this shape: { "message": "..." }.`;
     return [
         { role: "system", content: SYSTEM },
         { role: "user", content: user }

package/dist/util.js

@@ -1,10 +1,33 @@
+const DIFF_TRUNCATION_MARKER = "\n\n--- DIFF TRUNCATED ---\n\n";
 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)));
+    const source = diff ?? "";
+    const limit = Number.isFinite(maxChars) ? Math.max(0, Math.floor(maxChars)) : 0;
+    if (limit === 0)
+        return "";
+    if (source.length <= limit)
+        return source;
+    if (limit <= DIFF_TRUNCATION_MARKER.length + 20) {
+        return source.slice(0, limit);
+    }
+    const available = limit - DIFF_TRUNCATION_MARKER.length;
+    const headSize = Math.max(1, Math.floor(available * 0.7));
+    const tailSize = Math.max(1, available - headSize);
+    return `${source.slice(0, headSize)}${DIFF_TRUNCATION_MARKER}${source.slice(source.length - tailSize)}`;
+}
+export function parseBoundedInteger(value, name, min, max) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${name} must be a number.`);
+    }
+    if (parsed < min || parsed > max) {
+        throw new Error(`${name} must be between ${min} and ${max}.`);
+    }
+    return parsed;
+}
+export function normalizeErrorMessage(error, fallback) {
+    if (error instanceof Error && error.message.trim())
+        return error.message;
+    if (typeof error === "string" && error.trim())
+        return error;
+    return fallback;
 }

package/dist/validation.js

@@ -0,0 +1,203 @@
+export const ALLOWED_TYPES = ["feat", "fix", "chore", "refactor", "docs", "test", "perf", "build", "ci"];
+export const ALLOWED_TYPES_SET = new Set(ALLOWED_TYPES);
+const SUBJECT_REGEX = /^([a-z]+)(\([^)]+\))?!?:\s(.+)$/;
+export function isAllowedType(value) {
+    return ALLOWED_TYPES_SET.has(value);
+}
+export function normalizeMessage(input) {
+    const lines = (input ?? "")
+        .replace(/\r\n?/g, "\n")
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+$/g, ""));
+    while (lines.length > 0 && lines[0] === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.join("\n");
+}
+function stripWrappingCodeFence(input) {
+    const trimmed = (input ?? "").trim();
+    const match = trimmed.match(/^```(?:json|txt|text)?\s*([\s\S]*?)\s*```$/i);
+    return match ? match[1].trim() : trimmed;
+}
+function parseMessageFromJson(input) {
+    try {
+        const parsed = JSON.parse(input);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (!("message" in parsed))
+            return null;
+        const value = parsed.message;
+        return typeof value === "string" ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseMessageFromEmbeddedJson(input) {
+    const start = input.indexOf("{");
+    const end = input.lastIndexOf("}");
+    if (start < 0 || end <= start)
+        return null;
+    const block = input.slice(start, end + 1);
+    return parseMessageFromJson(block);
+}
+export function extractMessageFromModelOutput(raw) {
+    const noFence = stripWrappingCodeFence(raw ?? "");
+    const jsonMessage = parseMessageFromJson(noFence) ?? parseMessageFromEmbeddedJson(noFence);
+    const candidate = jsonMessage ?? noFence;
+    return normalizeMessage(stripWrappingCodeFence(candidate));
+}
+export function validateMessage(message) {
+    const normalized = normalizeMessage(message);
+    if (!normalized)
+        return { ok: false, reason: "Message is empty" };
+    if (normalized.includes("```"))
+        return { ok: false, reason: "No markdown/code fences" };
+    const subject = normalized.split("\n")[0].trim();
+    if (!subject)
+        return { ok: false, reason: "Subject line is empty" };
+    if (subject.length > 72)
+        return { ok: false, reason: "Subject line > 72 chars" };
+    if (subject.endsWith("."))
+        return { ok: false, reason: "Subject should not end with a period" };
+    const conventional = subject.match(SUBJECT_REGEX);
+    if (!conventional)
+        return { ok: false, reason: "Not Conventional Commits format" };
+    const type = conventional[1];
+    if (!isAllowedType(type)) {
+        return { ok: false, reason: `Type must be one of: ${ALLOWED_TYPES.join(", ")}` };
+    }
+    return { ok: true };
+}
+export function inferTypeFromDiff(diff) {
+    const filePattern = /^diff --git a\/(.+?) b\/(.+)$/gm;
+    const files = [];
+    for (const match of diff.matchAll(filePattern)) {
+        const file = match[2]?.trim();
+        if (file)
+            files.push(file.toLowerCase());
+    }
+    if (files.length === 0)
+        return null;
+    if (files.every(isDocumentationFile))
+        return "docs";
+    if (files.every(isTestFile))
+        return "test";
+    if (files.every(isCiFile))
+        return "ci";
+    if (files.every(isBuildFile))
+        return "build";
+    return null;
+}
+function normalizeScope(scope) {
+    if (!scope)
+        return null;
+    const compact = scope.trim().replace(/\s+/g, "-").replace(/[()]/g, "");
+    return compact || null;
+}
+function parseTypedSubject(subject) {
+    const typed = subject.match(/^([A-Za-z]+)(?:\(([^)]+)\))?!?:\s*(.+)$/);
+    if (!typed)
+        return null;
+    return {
+        type: typed[1].toLowerCase(),
+        scope: typed[2] ? typed[2].trim() : null,
+        description: typed[3].trim()
+    };
+}
+function parseLooseTypedSubject(subject) {
+    const loose = subject.match(/^([A-Za-z]+)\s*[-:]\s*(.+)$/);
+    if (!loose)
+        return null;
+    return {
+        type: loose[1].toLowerCase(),
+        description: loose[2].trim()
+    };
+}
+function normalizeDescription(description) {
+    const cleaned = description
+        .trim()
+        .replace(/\.$/, "")
+        .replace(/\s+/g, " ");
+    return cleaned || "update project files";
+}
+export function repairMessage(options) {
+    const original = normalizeMessage(stripWrappingCodeFence(options.message));
+    if (!original)
+        return { message: original, didRepair: false };
+    const lines = original.split("\n");
+    const originalSubject = lines[0].trim().replace(/^["'`]+|["'`]+$/g, "").trim();
+    const body = normalizeMessage(lines.slice(1).join("\n"));
+    const bodyBlock = body ? `\n\n${body}` : "";
+    const forcedType = options.forcedType;
+    const normalizedScope = normalizeScope(options.scope);
+    const inferredType = forcedType ?? inferTypeFromDiff(options.diff);
+    let selectedType = null;
+    let selectedScope = null;
+    let description = originalSubject;
+    const typed = parseTypedSubject(originalSubject);
+    if (typed) {
+        if (isAllowedType(typed.type))
+            selectedType = typed.type;
+        selectedScope = typed.scope;
+        description = typed.description;
+    }
+    else {
+        const loose = parseLooseTypedSubject(originalSubject);
+        if (loose && isAllowedType(loose.type)) {
+            selectedType = loose.type;
+            description = loose.description;
+        }
+    }
+    if (forcedType)
+        selectedType = forcedType;
+    if (!selectedType && inferredType)
+        selectedType = inferredType;
+    if (normalizedScope)
+        selectedScope = normalizedScope;
+    description = normalizeDescription(description);
+    let repairedSubject;
+    if (selectedType) {
+        const scopePart = selectedScope ? `(${selectedScope})` : "";
+        repairedSubject = `${selectedType}${scopePart}: ${description}`;
+    }
+    else {
+        repairedSubject = description;
+    }
+    const repaired = normalizeMessage(`${repairedSubject}${bodyBlock}`);
+    return {
+        message: repaired,
+        didRepair: repaired !== original
+    };
+}
+function isDocumentationFile(path) {
+    return path.startsWith("docs/")
+        || path.endsWith(".md")
+        || path.endsWith(".mdx")
+        || path.endsWith(".rst")
+        || path.includes("/docs/");
+}
+function isTestFile(path) {
+    return path.includes("/test/")
+        || path.includes("/tests/")
+        || path.includes("__tests__")
+        || path.endsWith(".spec.ts")
+        || path.endsWith(".test.ts")
+        || path.endsWith(".spec.js")
+        || path.endsWith(".test.js");
+}
+function isCiFile(path) {
+    return path.startsWith(".github/workflows/")
+        || path.startsWith(".gitlab-ci")
+        || path.startsWith(".circleci/")
+        || path.startsWith("azure-pipelines");
+}
+function isBuildFile(path) {
+    return path === "package-lock.json"
+        || path === "yarn.lock"
+        || path === "pnpm-lock.yaml"
+        || path === "package.json"
+        || path.endsWith("/dockerfile")
+        || path.endsWith("/docker-compose.yml");
+}

package/dist/workflow.js

@@ -0,0 +1,217 @@
+import prompts from "prompts";
+import { ExitCode, EXIT_CODE_LABEL } from "./exit-codes.js";
+import { getStagedDiff, gitCommit, hasStagedChanges, isGitRepo } from "./git.js";
+import { ensureLocalModel, ollamaChat, OllamaError } from "./ollama.js";
+import { buildMessages } from "./prompt.js";
+import { clampDiff, normalizeErrorMessage } from "./util.js";
+import { extractMessageFromModelOutput, normalizeMessage, repairMessage, validateMessage } from "./validation.js";
+class WorkflowError extends Error {
+    exitCode;
+    code;
+    hint;
+    constructor(exitCode, message, opts) {
+        super(message);
+        this.name = "WorkflowError";
+        this.exitCode = exitCode;
+        this.code = opts?.code ?? EXIT_CODE_LABEL[exitCode];
+        this.hint = opts?.hint ?? null;
+    }
+}
+async function generateCandidate(diff, opts) {
+    const messages = buildMessages({
+        diff,
+        forcedType: opts.type,
+        scope: opts.scope
+    });
+    const raw = (await ollamaChat({
+        host: opts.host,
+        model: opts.model,
+        messages,
+        json: true,
+        timeoutMs: opts.timeoutMs,
+        retries: opts.retries
+    })).trim();
+    const extracted = extractMessageFromModelOutput(raw);
+    const repaired = repairMessage({
+        message: extracted,
+        diff,
+        forcedType: opts.type,
+        scope: opts.scope
+    });
+    const candidate = normalizeMessage(repaired.message);
+    return {
+        message: candidate,
+        source: repaired.didRepair ? "repaired" : "model",
+        validation: validateMessage(candidate)
+    };
+}
+function ensureValid(candidate, allowInvalid) {
+    if (candidate.validation.ok || allowInvalid)
+        return;
+    throw new WorkflowError(ExitCode.InvalidAiOutput, `AI output failed validation: ${candidate.validation.reason}`, {
+        hint: "Regenerate/edit the message or pass --allow-invalid to override."
+    });
+}
+function toErrorResult(error) {
+    if (error instanceof WorkflowError) {
+        return {
+            ok: false,
+            exitCode: error.exitCode,
+            code: error.code,
+            message: error.message,
+            hint: error.hint
+        };
+    }
+    if (error instanceof OllamaError) {
+        return {
+            ok: false,
+            exitCode: ExitCode.OllamaError,
+            code: EXIT_CODE_LABEL[ExitCode.OllamaError],
+            message: error.message,
+            hint: error.hint
+        };
+    }
+    return {
+        ok: false,
+        exitCode: ExitCode.InternalError,
+        code: EXIT_CODE_LABEL[ExitCode.InternalError],
+        message: normalizeErrorMessage(error, "Unexpected internal error."),
+        hint: null
+    };
+}
+async function commitMessage(message, noVerify) {
+    try {
+        await gitCommit(message, { noVerify });
+    }
+    catch (error) {
+        throw new WorkflowError(ExitCode.GitCommitError, normalizeErrorMessage(error, "git commit failed."), { hint: "Resolve git hook or repository errors, then retry." });
+    }
+}
+async function runNonInteractive(diff, opts) {
+    const candidate = await generateCandidate(diff, opts);
+    ensureValid(candidate, opts.allowInvalid);
+    if (opts.dryRun) {
+        return {
+            ok: true,
+            exitCode: ExitCode.Success,
+            message: candidate.message,
+            source: candidate.source,
+            committed: false,
+            cancelled: false
+        };
+    }
+    await commitMessage(candidate.message, opts.noVerify);
+    return {
+        ok: true,
+        exitCode: ExitCode.Success,
+        message: candidate.message,
+        source: candidate.source,
+        committed: true,
+        cancelled: false
+    };
+}
+async function runInteractive(diff, opts) {
+    while (true) {
+        process.stdout.write("Generating commit message... ");
+        const candidate = await generateCandidate(diff, opts);
+        process.stdout.write("Done.\n");
+        if (!candidate.validation.ok) {
+            console.warn(`AI output validation failed: ${candidate.validation.reason}`);
+        }
+        console.log("\n--- Suggested commit message ---\n");
+        console.log(candidate.message);
+        console.log("\n-------------------------------\n");
+        const response = 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
+        });
+        const action = response.action;
+        if (!action || action === "cancel") {
+            return {
+                ok: true,
+                exitCode: ExitCode.Success,
+                message: candidate.message,
+                source: candidate.source,
+                committed: false,
+                cancelled: true
+            };
+        }
+        if (action === "regen")
+            continue;
+        if (action === "dry") {
+            return {
+                ok: true,
+                exitCode: ExitCode.Success,
+                message: candidate.message,
+                source: candidate.source,
+                committed: false,
+                cancelled: false
+            };
+        }
+        let finalMessage = candidate.message;
+        if (action === "edit") {
+            const edited = await prompts({
+                type: "text",
+                name: "message",
+                message: "Edit commit message",
+                initial: finalMessage
+            });
+            const editedMessage = edited.message;
+            if (!editedMessage) {
+                return {
+                    ok: true,
+                    exitCode: ExitCode.Success,
+                    message: candidate.message,
+                    source: candidate.source,
+                    committed: false,
+                    cancelled: true
+                };
+            }
+            finalMessage = normalizeMessage(editedMessage);
+        }
+        const validation = validateMessage(finalMessage);
+        if (!validation.ok && !opts.allowInvalid) {
+            console.error(`Cannot commit invalid message: ${validation.reason}`);
+            console.error("Use Edit/Regenerate, or rerun with --allow-invalid to override.");
+            continue;
+        }
+        await commitMessage(finalMessage, opts.noVerify);
+        return {
+            ok: true,
+            exitCode: ExitCode.Success,
+            message: finalMessage,
+            source: finalMessage === candidate.message ? candidate.source : "repaired",
+            committed: true,
+            cancelled: false
+        };
+    }
+}
+export async function runWorkflow(opts) {
+    try {
+        if (!(await isGitRepo())) {
+            throw new WorkflowError(ExitCode.GitContextError, "Not a git repository.");
+        }
+        if (!(await hasStagedChanges())) {
+            throw new WorkflowError(ExitCode.GitContextError, "No staged changes. Stage files first: git add <files>.");
+        }
+        await ensureLocalModel(opts.host, opts.model, Math.min(opts.timeoutMs, 10000));
+        const stagedDiff = await getStagedDiff();
+        const diff = clampDiff(stagedDiff, opts.maxChars);
+        if (opts.ci || opts.dryRun) {
+            return await runNonInteractive(diff, opts);
+        }
+        return await runInteractive(diff, opts);
+    }
+    catch (error) {
+        return toErrorResult(error);
+    }
+}

package/package.json

@@ -1,33 +1,46 @@
 {
   "name": "git-message-ai-commit",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "AI git commit messages using local Ollama",
-  "main": "index.js",
+  "main": "dist/cli.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest run --coverage",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:e2e": "vitest run tests/e2e",
     "build": "tsc",
     "dev": "tsx src/cli.ts",
-    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings 0",
+    "check": "npm run lint && npm run typecheck && npm run test",
     "prepare": "npm run build"
   },
   "keywords": [],
   "author": "Denis Tola",
   "license": "ISC",
   "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "dependencies": {
-    "-": "^0.0.1",
     "commander": "^14.0.2",
     "execa": "^9.6.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
+    "@vitest/coverage-v8": "^4.0.7",
     "@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"
+    "typescript-eslint": "^8.53.0",
+    "vitest": "^4.0.7"
   },
   "bin": {
     "git-ai-commit": "dist/cli.js"

package/eslint.config.mjs

@@ -1,14 +0,0 @@
-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: "^_" }]
-        }
-    }
-);