npm - @frigopedro/committer - Versions diffs - 0.1.0 - Mend

@frigopedro/committer 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,114 @@
+# AI Git Committer
+I was tired of typing out commit messages, so I wrote this tool.
+I know bunch of other tools exist, but I had hard times with them.
+Its a personal tool, dont expect to be good because its not :/
+## Install
+```bash
+npm install -g .
+```
+Or for local development:
+```bash
+npm link
+```
+## Usage
+```bash
+committer
+```
+The tool reads your git diff, proposes a conventional commit message, then
+asks you to (y) commit, (n) abort, or (r) regenerate.
+Commit messages include a required body with a broader summary of the changes.
+On first run, committer creates a `.committer` config file in your home
+directory and walks the user through provider and model selection.
+Use `committer --init` to re-run onboarding and rewrite the config.
+### Options
+```bash
+committer --provider ollama --model llama3.1
+committer --provider openai --model gpt-4o-mini
+committer --staged
+committer --all
+committer --init
+```
+If you run `committer` with `--provider ollama` and no model specified, the
+CLI will list your local Ollama models and prompt you to pick one.
+### Environment variables
+- `AI_COMMIT_PROVIDER`: `claude`, `ollama`, or `openai`
+- `AI_COMMIT_MODEL`: override model name
+- `AI_COMMIT_MAX_DIFF_CHARS`: trim diff length
+- `ANTHROPIC_API_KEY` or `CLAUDE_API_KEY`: Claude API key
+- `OPENAI_API_KEY`: OpenAI API key
+- `AI_COMMIT_OLLAMA_HOST`: Ollama host (default `http://localhost:11434`)
+### .committer config
+The `.committer` file is a JSON config stored at `~/.committer`.
+Example:
+```json
+{
+  "version": 1,
+  "provider": "ollama",
+  "model": "llama3.1",
+  "diffMode": "auto",
+  "maxDiffChars": 12000
+}
+```
+### Commit format
+Commit messages are generated in the format:
+```
+<type>[optional scope]: <description>
+<body>
+```
+The body is always present and provides a multi-sentence summary of most
+changed files.
+## Claude setup
+Set your Claude API key before running:
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+```
+## ChatGPT setup
+Set your OpenAI API key before running:
+```bash
+export OPENAI_API_KEY=your_key_here
+```
+## Local Llama setup
+Install and run Ollama, then pull a model:
+```bash
+ollama pull llama3.1
+```
+Run the CLI with:
+```bash
+committer --provider ollama
+```

package/index.js ADDED Viewed

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { parseArgs } from "./src/args.js";
+import {
+    DEFAULT_CLAUDE_MODEL,
+    DEFAULT_MAX_DIFF_CHARS,
+    DEFAULT_OLLAMA_MODEL,
+    DEFAULT_OPENAI_MODEL,
+    DEFAULT_PROVIDER,
+    EXIT_USER_ABORT,
+} from "./src/constants.js";
+import { getConfigPath, readConfig } from "./src/config.js";
+import { ensureGitRepo, getDiff } from "./src/git.js";
+import { truncateDiff } from "./src/diff.js";
+import { generateCommitMessage } from "./src/ai.js";
+import { runOnboarding } from "./src/onboarding.js";
+import { selectOllamaModel } from "./src/ollama.js";
+import { writeLine } from "./src/ui.js";
+import { commitWithMessage } from "./src/commit.js";
+import { hasEmoji, validateCommitMessage } from "./src/validate.js";
+const PROVIDERS = ["claude", "ollama", "openai"];
+function normalizeProvider(provider) {
+    if (provider === "chatgpt") return "openai";
+    return provider;
+}
+function printHelp() {
+    const lines = [
+        "committer - generate conventional commit messages with AI",
+        "",
+        "Usage:",
+        "  committer [--provider claude|ollama|openai] [--model name] [--staged] [--all]",
+        "",
+        "Options:",
+        "  --provider            AI provider (default: claude)",
+        "  --model               Override model name",
+        "  --staged              Use staged diff only",
+        "  --all                 Combine staged + unstaged diff",
+        "  --max-diff-chars       Trim diff to this many chars (default: 12000)",
+        "  --init                Run onboarding and write ~/.committer",
+        "  --help                Show this help",
+        "",
+        "Environment:",
+        "  AI_COMMIT_PROVIDER    claude | ollama | openai",
+        "  AI_COMMIT_MODEL       model override",
+        "  AI_COMMIT_MAX_DIFF_CHARS   trim diff length",
+        "  ANTHROPIC_API_KEY     Claude API key",
+        "  CLAUDE_API_KEY        Claude API key (alias)",
+        "  OPENAI_API_KEY        OpenAI API key",
+        "  AI_COMMIT_OLLAMA_HOST Ollama host (default: http://localhost:11434)",
+    ];
+    writeLine(lines.join("\n"));
+}
+function resolveModel({ provider, modelFromArgs, storedConfig }) {
+    if (modelFromArgs) return modelFromArgs;
+    if (storedConfig?.provider === provider && storedConfig?.model) {
+        return storedConfig.model;
+    }
+    if (provider === "ollama") return DEFAULT_OLLAMA_MODEL;
+    if (provider === "openai") return DEFAULT_OPENAI_MODEL;
+    return DEFAULT_CLAUDE_MODEL;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.has("help")) {
+        printHelp();
+        process.exit(0);
+    }
+    let hasRepo = true;
+    try {
+        ensureGitRepo();
+    } catch (error) {
+        hasRepo = false;
+        if (!args.has("init")) {
+            writeLine(`❌ ${error.message}`);
+            process.exit(1);
+        }
+    }
+    const configPath = getConfigPath();
+    const ollamaHost = process.env.AI_COMMIT_OLLAMA_HOST || "http://localhost:11434";
+    const rl = createInterface({ input, output });
+    let storedConfig = null;
+    try {
+        storedConfig = await readConfig(configPath);
+    } catch (error) {
+        writeLine(`⚠️ ${error.message}`);
+    }
+    if (!storedConfig || args.has("init")) {
+        storedConfig = await runOnboarding({ rl, configPath, ollamaHost });
+        if (!hasRepo) {
+            rl.close();
+            process.exit(0);
+        }
+    }
+    const providerInput =
+        args.get("provider") ||
+        process.env.AI_COMMIT_PROVIDER ||
+        storedConfig?.provider ||
+        DEFAULT_PROVIDER;
+    const provider = normalizeProvider(providerInput);
+    if (!PROVIDERS.includes(provider)) {
+        writeLine("❌ Provider must be claude, openai, or ollama.");
+        process.exit(1);
+    }
+    const modelFromArgs = args.get("model") || process.env.AI_COMMIT_MODEL || null;
+    let model = resolveModel({
+        provider,
+        modelFromArgs,
+        storedConfig,
+    });
+    if (provider === "ollama" && !modelFromArgs) {
+        const configMatches = storedConfig?.provider === "ollama" && storedConfig?.model;
+        if (!configMatches) {
+            try {
+                model = await selectOllamaModel({ host: ollamaHost, rl });
+            } catch (error) {
+                writeLine(`⚠️ Ollama model selection failed: ${error.message}`);
+                writeLine(`↩️ Falling back to ${DEFAULT_OLLAMA_MODEL}.`);
+                model = DEFAULT_OLLAMA_MODEL;
+            }
+        }
+    }
+    let maxDiffChars = Number.parseInt(
+        args.get("max-diff-chars") ||
+        process.env.AI_COMMIT_MAX_DIFF_CHARS ||
+        storedConfig?.maxDiffChars ||
+        DEFAULT_MAX_DIFF_CHARS,
+        10
+    );
+    if (Number.isNaN(maxDiffChars) || maxDiffChars <= 0) {
+        maxDiffChars = DEFAULT_MAX_DIFF_CHARS;
+    }
+    const diffModeFromArgs = args.get("staged")
+        ? "staged"
+        : args.get("all")
+            ? "all"
+            : null;
+    const diffMode = diffModeFromArgs || storedConfig?.diffMode || "auto";
+    const diff = getDiff(diffMode);
+    if (!diff.trim()) {
+        writeLine("🟡 No changes detected in git diff.");
+        rl.close();
+        process.exit(0);
+    }
+    const { diff: trimmedDiff, truncated } = truncateDiff(diff, maxDiffChars);
+    let message = "";
+    try {
+        while (true) {
+            writeLine("⏳ Loading... generating commit message.");
+            message = await generateCommitMessage({
+                provider,
+                model,
+                diff: trimmedDiff,
+                truncated,
+                host: ollamaHost,
+            });
+            if (!message) {
+                writeLine("⚠️ AI response was invalid. Regenerating...");
+                continue;
+            }
+            if (hasEmoji(message)) {
+                writeLine("⚠️ Commit message contains emoji. Regenerating...");
+                continue;
+            }
+            console.log(message);
+            const validation = validateCommitMessage(message);
+            if (!validation.valid) {
+                writeLine(`⚠️ ${validation.reason} Regenerating...`);
+                continue;
+            }
+            writeLine(`\n✨ Suggested commit message:\n${message}\n`);
+            const answer = await rl.question(
+                "Use (y) to commit, (n) to abort, (r) to regenerate: "
+            );
+            const choice = answer.trim().toLowerCase();
+            if (choice === "y") {
+                writeLine("✅ Committing...");
+                const status = await commitWithMessage(message);
+                process.exit(status);
+            }
+            if (choice === "n") {
+                writeLine("🛑 Commit aborted.");
+                process.exit(EXIT_USER_ABORT);
+            }
+            if (choice === "r") {
+                writeLine("🔁 Regenerating commit message...");
+                continue;
+            }
+            writeLine("Please enter y, n, or r.");
+        }
+    } catch (error) {
+        writeLine(`❌ Error: ${error.message}`);
+        process.exit(1);
+    } finally {
+        rl.close();
+    }
+}
+main();

package/package.json ADDED Viewed

@@ -0,0 +1,28 @@
+{
+  "name": "@frigopedro/committer",
+  "version": "0.1.0",
+  "description": "Generate conventional commit messages using AI",
+  "type": "module",
+  "bin": {
+    "committer": "index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "keywords": [
+    "git",
+    "commit",
+    "conventional-commits",
+    "ai",
+    "cli"
+  ],
+  "files": [
+    "index.js",
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/ai.js ADDED Viewed

@@ -0,0 +1,27 @@
+import { buildPrompt, parseCommitMessage } from "./prompt.js";
+import { callClaude } from "./providers/claude.js";
+import { callOllama } from "./providers/ollama.js";
+import { callOpenAI } from "./providers/openai.js";
+export async function generateCommitMessage({
+  provider,
+  model,
+  diff,
+  truncated,
+  host,
+}) {
+  const system =
+    "You are a senior developer assistant that writes clear, conventional commit messages.";
+  const user = buildPrompt(diff, { truncated });
+  let raw = "";
+  if (provider === "ollama") {
+    raw = await callOllama({ system, user, model, host });
+  } else if (provider === "openai") {
+    raw = await callOpenAI({ system, user, model });
+  } else {
+    raw = await callClaude({ system, user, model });
+  }
+  return parseCommitMessage(raw);
+}

package/src/args.js ADDED Viewed

@@ -0,0 +1,16 @@
+export function parseArgs(argv) {
+  const args = new Map();
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith("--")) {
+      args.set(key, next);
+      i += 1;
+    } else {
+      args.set(key, true);
+    }
+  }
+  return args;
+}

package/src/commit.js ADDED Viewed

@@ -0,0 +1,19 @@
+import { spawnSync } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+export async function commitWithMessage(message) {
+  const filePath = join(tmpdir(), `committer-${randomUUID()}.txt`);
+  await fs.writeFile(filePath, `${message}\n`, "utf8");
+  try {
+    const result = spawnSync("git", ["commit", "-F", filePath], {
+      stdio: "inherit",
+    });
+    return result.status ?? 1;
+  } finally {
+    await fs.rm(filePath, { force: true });
+  }
+}

package/src/config.js ADDED Viewed

@@ -0,0 +1,24 @@
+import { promises as fs } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+export function getConfigPath() {
+  return resolve(homedir(), ".committer");
+}
+export async function readConfig(configPath) {
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new Error(`Could not read ${configPath}: ${error.message}`);
+  }
+}
+export async function writeConfig(configPath, config) {
+  const contents = `${JSON.stringify(config, null, 2)}\n`;
+  await fs.writeFile(configPath, contents, "utf8");
+}

package/src/constants.js ADDED Viewed

@@ -0,0 +1,22 @@
+export const COMMIT_TYPES = [
+  "feat",
+  "fix",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "revert",
+];
+export const DEFAULT_MAX_DIFF_CHARS = 12000;
+export const DEFAULT_CLAUDE_MODEL = "claude-3-5-sonnet-latest";
+export const DEFAULT_OLLAMA_MODEL = "llama3.1";
+export const DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
+export const DEFAULT_PROVIDER = "claude";
+export const EXIT_USER_ABORT = 2;
+export const CONFIG_VERSION = 1;

package/src/diff.js ADDED Viewed

@@ -0,0 +1,10 @@
+export function truncateDiff(diff, maxChars) {
+  if (diff.length <= maxChars) return { diff, truncated: false };
+  const keep = Math.floor(maxChars / 2);
+  const start = diff.slice(0, keep);
+  const end = diff.slice(diff.length - keep);
+  return {
+    diff: `${start}\n\n...diff truncated...\n\n${end}`,
+    truncated: true,
+  };
+}

package/src/git.js ADDED Viewed

@@ -0,0 +1,33 @@
+import { execSync } from "node:child_process";
+export function runGit(args) {
+  return execSync(`git ${args}`, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trimEnd();
+}
+export function ensureGitRepo() {
+  try {
+    runGit("rev-parse --show-toplevel");
+  } catch (error) {
+    throw new Error("Not inside a git repository.");
+  }
+}
+export function getRepoRoot() {
+  return runGit("rev-parse --show-toplevel");
+}
+export function getDiff(mode) {
+  const staged = runGit("diff --staged");
+  const unstaged = runGit("diff");
+  if (mode === "staged") return staged;
+  if (mode === "all") {
+    if (staged && unstaged) return `${staged}\n\n${unstaged}`;
+    return staged || unstaged;
+  }
+  return staged || unstaged;
+}

package/src/ollama.js ADDED Viewed

@@ -0,0 +1,41 @@
+import { fetchOllamaModels } from "./providers/ollama.js";
+import { writeLine } from "./ui.js";
+import { DEFAULT_OLLAMA_MODEL } from "./constants.js";
+export async function selectOllamaModel({ host, rl }) {
+  const models = await fetchOllamaModels(host);
+  if (!models.length) {
+    throw new Error(
+      "No Ollama models found. Run 'ollama pull <model>' first."
+    );
+  }
+  const defaultIndex = Math.max(
+    0,
+    models.findIndex((model) => model === DEFAULT_OLLAMA_MODEL)
+  );
+  writeLine("\n📦 Available Ollama models:");
+  models.forEach((model, index) => {
+    const marker = index === defaultIndex ? " (default)" : "";
+    writeLine(`${index + 1}) ${model}${marker}`);
+  });
+  const answer = await rl.question(`Select model [${defaultIndex + 1}]: `);
+  const trimmed = answer.trim();
+  if (!trimmed) {
+    return models[defaultIndex];
+  }
+  const asNumber = Number.parseInt(trimmed, 10);
+  if (!Number.isNaN(asNumber) && asNumber >= 1 && asNumber <= models.length) {
+    return models[asNumber - 1];
+  }
+  if (models.includes(trimmed)) {
+    return trimmed;
+  }
+  writeLine("Invalid selection. Using default model.");
+  return models[defaultIndex];
+}

package/src/onboarding.js ADDED Viewed

@@ -0,0 +1,70 @@
+import {
+  CONFIG_VERSION,
+  DEFAULT_CLAUDE_MODEL,
+  DEFAULT_OLLAMA_MODEL,
+  DEFAULT_OPENAI_MODEL,
+  DEFAULT_MAX_DIFF_CHARS,
+} from "./constants.js";
+import { promptNumber, promptSelect, writeLine } from "./ui.js";
+import { selectOllamaModel } from "./ollama.js";
+import { writeConfig } from "./config.js";
+export async function runOnboarding({ rl, configPath, ollamaHost }) {
+  writeLine("\n👋 Welcome to committer! Let's create a .committer config.");
+  const provider = await promptSelect({
+    rl,
+    question: "Choose your AI provider:",
+    defaultValue: "ollama",
+    options: [
+      { value: "ollama", label: "Ollama (local)" },
+      { value: "openai", label: "ChatGPT (OpenAI API key required)" },
+      { value: "claude", label: "Claude (API key required)" },
+    ],
+  });
+  let model = DEFAULT_CLAUDE_MODEL;
+  if (provider === "ollama") {
+    model = DEFAULT_OLLAMA_MODEL;
+    try {
+      model = await selectOllamaModel({ host: ollamaHost, rl });
+    } catch (error) {
+      writeLine(`⚠️ Ollama model selection failed: ${error.message}`);
+      writeLine(`↩️ Falling back to ${DEFAULT_OLLAMA_MODEL}.`);
+    }
+  }
+  if (provider === "openai") {
+    model = DEFAULT_OPENAI_MODEL;
+  }
+  const diffMode = await promptSelect({
+    rl,
+    question: "Which diff should committer use?",
+    defaultValue: "auto",
+    options: [
+      { value: "auto", label: "Auto (staged if any, else unstaged)" },
+      { value: "staged", label: "Staged only" },
+      { value: "all", label: "Staged + unstaged" },
+    ],
+  });
+  const maxDiffChars = await promptNumber({
+    rl,
+    question: "Max diff characters to send",
+    defaultValue: DEFAULT_MAX_DIFF_CHARS,
+    min: 500,
+  });
+  const config = {
+    version: CONFIG_VERSION,
+    provider,
+    model,
+    diffMode,
+    maxDiffChars,
+  };
+  await writeConfig(configPath, config);
+  writeLine(`✅ Saved config to ${configPath}.`);
+  return config;
+}

package/src/prompt.js ADDED Viewed

@@ -0,0 +1,106 @@
+import { COMMIT_TYPES } from "./constants.js";
+export function buildPrompt(diff, { truncated }) {
+    const types = COMMIT_TYPES.join(", ");
+    return [
+        "You are an expert software engineer writing a professional git commit message.",
+        "Analyze the diff and produce a precise, high-signal commit message.",
+        "",
+        "Return valid JSON only.",
+        "Do not wrap the response in markdown.",
+        "Do not include explanations, commentary, or extra keys.",
+        'Use exactly this schema: {"subject":"...","body":"..."}',
+        "",
+        "Rules for the subject:",
+        "1. Follow Conventional Commits.",
+        "2. Format: <type>(optional-scope)!: <description>",
+        `3. Allowed types: ${types}.`,
+        "4. Use ! only if the diff clearly introduces a breaking change.",
+        "5. Use imperative mood.",
+        "6. Use lower-case for the description.",
+        "7. Do not end the subject with a period.",
+        "8. Keep the subject concise, specific, and under 72 characters.",
+        "9. Prefer describing the main user-visible or architectural change.",
+        "10. Avoid vague subjects like 'update code', 'fix stuff', or 'changes'.",
+        "",
+        "Rules for the body:",
+        "1. Body is required.",
+        "2. Write 2 to 5 short sentences.",
+        "3. Summarize the intent and the most important changes.",
+        "4. Mention notable implementation details only when they help explain the change.",
+        "5. Cover the main files or areas affected, but do not list every file mechanically.",
+        "6. Focus on why and what changed more than line-level details.",
+        "7. Do not repeat the subject verbatim.",
+        "8. Do not include a footer, ticket number, or breaking-change footer.",
+        "9. Do not invent details not supported by the diff.",
+        "",
+        "Decision guidance:",
+        "- Use feat for new behavior or capability.",
+        "- Use fix for bug fixes or correctness issues.",
+        "- Use refactor for internal restructuring without behavior change.",
+        "- Use perf for performance improvements.",
+        "- Use docs for documentation-only changes.",
+        "- Use test for test-only changes.",
+        "- Use build for build system, dependencies, or packaging changes.",
+        "- Use ci for CI/CD changes.",
+        "- Use chore for maintenance tasks that do not fit other types.",
+        "- Use style for formatting-only changes with no logic change.",
+        "",
+        "Scoping guidance:",
+        "- Add a scope only when the affected area is clear and meaningful.",
+        "- Use a short scope such as api, auth, ui, cli, db, config, or parser.",
+        "- Omit the scope if there is no obvious single area.",
+        "",
+        "Diff interpretation guidance:",
+        "- Infer the primary purpose of the change from the overall diff, not isolated lines.",
+        "- Ignore unimportant noise such as formatting churn unless formatting is the main change.",
+        "- If multiple changes exist, prioritize the dominant one.",
+        truncated
+            ? "- The diff was truncated, so base the message on the visible changes only and avoid overclaiming."
+            : "",
+        "",
+        "Now analyze this diff and return only the JSON object.",
+        "",
+        "Diff:",
+        diff,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function cleanCommitMessage(message) {
+    let cleaned = message.trim();
+    cleaned = cleaned.replace(/^```[a-z]*\n?/i, "").replace(/```$/, "");
+    cleaned = cleaned.replace(/^commit message:\s*/i, "");
+    cleaned = cleaned.replace(/^"|"$/g, "");
+    cleaned = cleaned.replace(/^'|'$/g, "");
+    cleaned = cleaned.replace(/\r\n/g, "\n");
+    return cleaned.trim();
+}
+export function parseCommitMessage(raw) {
+    const cleaned = cleanCommitMessage(raw);
+    try {
+        const parsed = JSON.parse(cleaned);
+        const subject = parsed?.subject?.trim();
+        const body = parsed?.body?.trim();
+        if (!subject || !body) return "";
+        return `${subject}\n\n${body}`.trim();
+    } catch {
+        const start = cleaned.indexOf("{");
+        const end = cleaned.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            try {
+                const parsed = JSON.parse(cleaned.slice(start, end + 1));
+                const subject = parsed?.subject?.trim();
+                const body = parsed?.body?.trim();
+                if (!subject || !body) return "";
+                return `${subject}\n\n${body}`.trim();
+            } catch {
+                return "";
+            }
+        }
+        return "";
+    }
+}

package/src/providers/claude.js ADDED Viewed

@@ -0,0 +1,34 @@
+export async function callClaude({ system, user, model }) {
+  const apiKey =
+    process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY || "";
+  if (!apiKey) {
+    throw new Error(
+      "Missing ANTHROPIC_API_KEY or CLAUDE_API_KEY for Claude provider."
+    );
+  }
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 128,
+      temperature: 0.2,
+      system,
+      messages: [{ role: "user", content: user }],
+    }),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Claude API error: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  const content = data?.content?.[0]?.text ?? "";
+  return content;
+}

package/src/providers/ollama.js ADDED Viewed

@@ -0,0 +1,49 @@
+export async function callOllama({ system, user, model, host }) {
+  const response = await fetch(`${host}/api/chat`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model,
+      format: "json",
+      stream: false,
+      options: {
+        temperature: 0.2,
+        num_predict: 128,
+      },
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: user },
+      ],
+    }),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Ollama API error: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  return data?.message?.content ?? data?.response ?? "";
+}
+export async function fetchOllamaModels(host) {
+  const response = await fetch(`${host}/api/tags`, {
+    method: "GET",
+    headers: {
+      "content-type": "application/json",
+    },
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Ollama API error: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  const models = (data?.models || [])
+    .map((model) => model?.name)
+    .filter(Boolean);
+  return Array.from(new Set(models)).sort();
+}

package/src/providers/openai.js ADDED Viewed

@@ -0,0 +1,33 @@
+export async function callOpenAI({ system, user, model }) {
+  const apiKey = process.env.OPENAI_API_KEY || "";
+  if (!apiKey) {
+    throw new Error("Missing OPENAI_API_KEY for OpenAI provider.");
+  }
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      temperature: 0.2,
+      max_tokens: 128,
+      response_format: { type: "json_object" },
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: user },
+      ],
+    }),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI API error: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  const content = data?.choices?.[0]?.message?.content ?? "";
+  return content;
+}

package/src/ui.js ADDED Viewed

@@ -0,0 +1,43 @@
+import { stdout as output } from "node:process";
+export function writeLine(text) {
+  output.write(`${text}\n`);
+}
+export function write(text) {
+  output.write(text);
+}
+export async function promptSelect({ rl, question, options, defaultValue }) {
+  writeLine(`\n${question}`);
+  options.forEach((option, index) => {
+    const marker = option.value === defaultValue ? " (default)" : "";
+    writeLine(`${index + 1}) ${option.label}${marker}`);
+  });
+  const answer = await rl.question("Select option: ");
+  const trimmed = answer.trim();
+  if (!trimmed) return defaultValue;
+  const asNumber = Number.parseInt(trimmed, 10);
+  if (!Number.isNaN(asNumber) && asNumber >= 1 && asNumber <= options.length) {
+    return options[asNumber - 1].value;
+  }
+  const matched = options.find((option) => option.value === trimmed);
+  if (matched) return matched.value;
+  writeLine("Invalid selection. Using default.");
+  return defaultValue;
+}
+export async function promptNumber({ rl, question, defaultValue, min }) {
+  while (true) {
+    const answer = await rl.question(`${question} [${defaultValue}]: `);
+    const trimmed = answer.trim();
+    if (!trimmed) return defaultValue;
+    const value = Number.parseInt(trimmed, 10);
+    if (!Number.isNaN(value) && value >= min) return value;
+    writeLine(`Please enter a number >= ${min}.`);
+  }
+}

package/src/validate.js ADDED Viewed

@@ -0,0 +1,40 @@
+import { COMMIT_TYPES } from "./constants.js";
+const EMOJI_REGEX = /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}]/u;
+const SUBJECT_REGEX = new RegExp(
+    `^(${COMMIT_TYPES.join("|")})(\\([^)]+\\))?(!)?:\\s.+$`
+);
+export function hasEmoji(text) {
+    return EMOJI_REGEX.test(text);
+}
+export function validateCommitMessage(message) {
+    const normalized = message.trim().replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+        lines.pop();
+    }
+    const subject = lines[0]?.trim();
+    if (!subject) {
+        return { valid: false, reason: "Missing subject line." };
+    }
+    if (!SUBJECT_REGEX.test(subject.toLowerCase())) {
+        return {
+            valid: false,
+            reason: "Subject must follow conventional format like 'feat: add ...'.",
+        };
+    }
+    const bodyLines = lines.slice(2);
+    const bodyHasContent = bodyLines.some((line) => line.trim().length > 0);
+    if (!bodyHasContent) {
+        return { valid: false, reason: "Body is required." };
+    }
+    return { valid: true };
+}