@vavasilva/git-commit-ai 0.2.3 → 0.3.1

package/dist/index.js

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
+import {
+  addFiles,
+  commit,
+  commitAmend,
+  filterDiffByPatterns,
+  getFileDiff,
+  getLastCommitDiff,
+  getStagedDiff,
+  getStagedFiles,
+  push,
+  resetStaged
+} from "./chunk-5MPJCPJ4.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -12,53 +24,210 @@ import { homedir } from "os";
 import { join, dirname } from "path";
 import { parse as parseToml } from "smol-toml";
 var DEFAULT_CONFIG = {
+  backend: "ollama",
   model: "llama3.1:8b",
   ollama_url: "http://localhost:11434",
+  openai_base_url: "https://api.openai.com/v1",
   temperature: 0.7,
-  retry_temperatures: [0.5, 0.3, 0.2]
+  retry_temperatures: [0.5, 0.3, 0.2],
+  ignore_patterns: []
+};
+var VALID_BACKENDS = ["ollama", "openai", "anthropic", "groq", "llamacpp"];
+var LOCAL_CONFIG_NAMES = [".gitcommitai", ".gitcommitai.toml"];
+var VALID_CONFIG_KEYS = [
+  "backend",
+  "model",
+  "ollama_url",
+  "openai_base_url",
+  "temperature",
+  "default_scope",
+  "default_type",
+  "default_language"
+];
+var CONFIG_ALIASES = {
+  lang: "default_language",
+  scope: "default_scope",
+  type: "default_type",
+  url: "ollama_url",
+  temp: "temperature"
 };
 function getConfigPath() {
   return join(homedir(), ".config", "git-commit-ai", "config.toml");
 }
-function loadConfig() {
-  const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
+function getLocalConfigPath() {
+  for (const name of LOCAL_CONFIG_NAMES) {
+    if (existsSync(name)) {
+      return name;
+    }
   }
+  return null;
+}
+function parseConfigFile(path) {
   try {
-    const content = readFileSync(configPath, "utf-8");
-    const data = parseToml(content);
-    return {
-      model: data.model ?? DEFAULT_CONFIG.model,
-      ollama_url: data.ollama_url ?? DEFAULT_CONFIG.ollama_url,
-      temperature: data.temperature ?? DEFAULT_CONFIG.temperature,
-      retry_temperatures: data.retry_temperatures ?? DEFAULT_CONFIG.retry_temperatures
-    };
+    const content = readFileSync(path, "utf-8");
+    return parseToml(content);
   } catch {
-    return { ...DEFAULT_CONFIG };
+    return null;
   }
 }
+function mergeConfigs(base, override) {
+  return {
+    backend: VALID_BACKENDS.includes(override.backend) ? override.backend : base.backend,
+    model: override.model ?? base.model,
+    ollama_url: override.ollama_url ?? base.ollama_url,
+    openai_base_url: override.openai_base_url ?? base.openai_base_url,
+    temperature: override.temperature ?? base.temperature,
+    retry_temperatures: override.retry_temperatures ?? base.retry_temperatures,
+    ignore_patterns: override.ignore_patterns ?? base.ignore_patterns,
+    default_scope: override.default_scope ?? base.default_scope,
+    default_type: override.default_type ?? base.default_type,
+    default_language: override.default_language ?? base.default_language
+  };
+}
+function loadConfig() {
+  let config = { ...DEFAULT_CONFIG };
+  const globalPath = getConfigPath();
+  if (existsSync(globalPath)) {
+    const globalData = parseConfigFile(globalPath);
+    if (globalData) {
+      config = mergeConfigs(config, globalData);
+    }
+  }
+  const localPath = getLocalConfigPath();
+  if (localPath) {
+    const localData = parseConfigFile(localPath);
+    if (localData) {
+      config = mergeConfigs(config, localData);
+    }
+  }
+  return config;
+}
 function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = dirname(configPath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  const content = `# git-commit-ai configuration
+  let content = `# git-commit-ai configuration
+# Backend: ollama, llamacpp, openai, anthropic, groq
+backend = "${config.backend}"
 model = "${config.model}"
 ollama_url = "${config.ollama_url}"
+# OpenAI Base URL - change this to use OpenAI-compatible APIs like llama.cpp
+# Example: http://localhost:8080/v1 for llama-server
+openai_base_url = "${config.openai_base_url}"
 temperature = ${config.temperature}
 retry_temperatures = [${config.retry_temperatures.join(", ")}]
 `;
+  if (config.default_language) {
+    content += `default_language = "${config.default_language}"
+`;
+  }
+  if (config.default_scope) {
+    content += `default_scope = "${config.default_scope}"
+`;
+  }
+  if (config.default_type) {
+    content += `default_type = "${config.default_type}"
+`;
+  }
+  if (config.ignore_patterns && config.ignore_patterns.length > 0) {
+    content += `ignore_patterns = [${config.ignore_patterns.map((p) => `"${p}"`).join(", ")}]
+`;
+  }
   writeFileSync(configPath, content, "utf-8");
 }
 function showConfig(config) {
-  return `Configuration:
+  const localPath = getLocalConfigPath();
+  let output = `Configuration:
+  Backend: ${config.backend}
   Model: ${config.model}
   Ollama URL: ${config.ollama_url}
+  OpenAI Base URL: ${config.openai_base_url}
   Temperature: ${config.temperature}
-  Retry temperatures: [${config.retry_temperatures.join(", ")}]
-  Config file: ${getConfigPath()}`;
+  Retry temperatures: [${config.retry_temperatures.join(", ")}]`;
+  if (config.ignore_patterns && config.ignore_patterns.length > 0) {
+    output += `
+  Ignore patterns: [${config.ignore_patterns.join(", ")}]`;
+  }
+  if (config.default_scope) {
+    output += `
+  Default scope: ${config.default_scope}`;
+  }
+  if (config.default_type) {
+    output += `
+  Default type: ${config.default_type}`;
+  }
+  if (config.default_language) {
+    output += `
+  Default language: ${config.default_language}`;
+  }
+  output += `
+  Global config: ${getConfigPath()}`;
+  if (localPath) {
+    output += `
+  Local config: ${localPath}`;
+  }
+  return output;
+}
+function updateConfig(key, value) {
+  const resolvedKey = CONFIG_ALIASES[key] || key;
+  if (!VALID_CONFIG_KEYS.includes(resolvedKey)) {
+    const aliasHelp = Object.entries(CONFIG_ALIASES).map(([alias, full]) => `${alias} \u2192 ${full}`).join(", ");
+    return {
+      success: false,
+      message: `Invalid config key: "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}. Aliases: ${aliasHelp}`
+    };
+  }
+  const configKey = resolvedKey;
+  if (configKey === "backend" && !VALID_BACKENDS.includes(value)) {
+    return {
+      success: false,
+      message: `Invalid backend: "${value}". Valid backends: ${VALID_BACKENDS.join(", ")}`
+    };
+  }
+  if (configKey === "temperature") {
+    const temp = parseFloat(value);
+    if (isNaN(temp) || temp < 0 || temp > 1) {
+      return {
+        success: false,
+        message: `Invalid temperature: "${value}". Must be a number between 0 and 1.`
+      };
+    }
+  }
+  const config = loadConfig();
+  switch (configKey) {
+    case "backend":
+      config.backend = value;
+      break;
+    case "model":
+      config.model = value;
+      break;
+    case "ollama_url":
+      config.ollama_url = value;
+      break;
+    case "openai_base_url":
+      config.openai_base_url = value;
+      break;
+    case "temperature":
+      config.temperature = parseFloat(value);
+      break;
+    case "default_scope":
+      config.default_scope = value;
+      break;
+    case "default_type":
+      config.default_type = value;
+      break;
+    case "default_language":
+      config.default_language = value;
+      break;
+  }
+  saveConfig(config);
+  const keyDisplay = key !== configKey ? `${key} (${configKey})` : configKey;
+  return {
+    success: true,
+    message: `Config updated: ${keyDisplay} = "${value}"`
+  };
 }
 
 // src/backends/ollama.ts
@@ -120,89 +289,265 @@ var OllamaBackend = class {
   }
 };
 
-// src/git.ts
-import { execSync } from "child_process";
-var GitError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GitError";
+// src/backends/openai.ts
+var OPENAI_DEFAULT_URL = "https://api.openai.com/v1";
+var OpenAIBackend = class _OpenAIBackend {
+  model;
+  apiKey;
+  baseUrl;
+  isLocalServer;
+  constructor(model = "gpt-4o-mini", apiKey, baseUrl) {
+    this.model = model;
+    this.baseUrl = baseUrl ?? process.env.OPENAI_BASE_URL ?? OPENAI_DEFAULT_URL;
+    this.isLocalServer = this.baseUrl.includes("localhost") || this.baseUrl.includes("127.0.0.1");
+    this.apiKey = apiKey ?? process.env.OPENAI_API_KEY ?? (this.isLocalServer ? "no-key-required" : "");
+  }
+  async generate(prompt, temperature = 0.7) {
+    if (!this.apiKey && !this.isLocalServer) {
+      throw new Error("OPENAI_API_KEY environment variable is not set");
+    }
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ],
+        temperature,
+        max_tokens: 256
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content ?? "";
+  }
+  async isAvailable() {
+    if (!this.apiKey && !this.isLocalServer) {
+      return false;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const headers = {};
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if OpenAI API key is configured or if a custom base URL is set
+   */
+  static hasApiKey() {
+    return !!process.env.OPENAI_API_KEY;
+  }
+  /**
+   * Check if a custom base URL is configured (for llama.cpp, etc.)
+   */
+  static hasCustomBaseUrl() {
+    return !!process.env.OPENAI_BASE_URL;
+  }
+  /**
+   * Check if this backend can potentially work (has API key or custom URL)
+   */
+  static isConfigured() {
+    return _OpenAIBackend.hasApiKey() || _OpenAIBackend.hasCustomBaseUrl();
   }
 };
-function runGit(...args) {
-  try {
-    const result = execSync(["git", ...args].join(" "), {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+
+// src/backends/anthropic.ts
+var AnthropicBackend = class {
+  model;
+  apiKey;
+  baseUrl;
+  constructor(model = "claude-3-haiku-20240307", apiKey, baseUrl = "https://api.anthropic.com") {
+    this.model = model;
+    this.apiKey = apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+    this.baseUrl = baseUrl;
+  }
+  async generate(prompt, temperature = 0.7) {
+    if (!this.apiKey) {
+      throw new Error("ANTHROPIC_API_KEY environment variable is not set");
+    }
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 256,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ],
+        temperature
+      })
     });
-    return result.trim();
-  } catch (error) {
-    const err = error;
-    const message = err.stderr?.trim() || err.message;
-    throw new GitError(`Git command failed: ${message}`);
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const textBlock = data.content?.find((block) => block.type === "text");
+    return textBlock?.text ?? "";
   }
-}
-function runGitSafe(...args) {
-  try {
-    return runGit(...args);
-  } catch {
-    return "";
+  async isAvailable() {
+    return !!this.apiKey;
   }
-}
-function getStagedDiff() {
-  const diff = runGitSafe("diff", "--cached");
-  const stats = runGitSafe("diff", "--cached", "--stat");
-  const filesOutput = runGitSafe("diff", "--cached", "--name-only");
-  const files = filesOutput.split("\n").filter((f) => f);
-  return {
-    diff,
-    stats,
-    files,
-    isEmpty: !diff.trim()
-  };
-}
-function getFileDiff(filePath) {
-  const diff = runGitSafe("diff", "--cached", "--", filePath);
-  const stats = runGitSafe("diff", "--cached", "--stat", "--", filePath);
-  const files = diff ? [filePath] : [];
-  return {
-    diff,
-    stats,
-    files,
-    isEmpty: !diff.trim()
-  };
-}
-function addFiles(...paths) {
-  if (paths.length === 0) {
-    paths = ["."];
+  static hasApiKey() {
+    return !!process.env.ANTHROPIC_API_KEY;
   }
-  try {
-    runGit("add", ...paths);
-    return true;
-  } catch (error) {
-    const err = error;
-    if (err.message.includes("ignored by one of your .gitignore") || err.message.includes("pathspec") && err.message.includes("did not match")) {
+};
+
+// src/backends/groq.ts
+var GroqBackend = class {
+  model;
+  apiKey;
+  baseUrl;
+  constructor(model = "llama-3.1-8b-instant", apiKey, baseUrl = "https://api.groq.com/openai/v1") {
+    this.model = model;
+    this.apiKey = apiKey ?? process.env.GROQ_API_KEY ?? "";
+    this.baseUrl = baseUrl;
+  }
+  async generate(prompt, temperature = 0.7) {
+    if (!this.apiKey) {
+      throw new Error("GROQ_API_KEY environment variable is not set");
+    }
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          {
+            role: "user",
+            content: prompt
+          }
+        ],
+        temperature,
+        max_tokens: 256
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Groq API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return data.choices?.[0]?.message?.content ?? "";
+  }
+  async isAvailable() {
+    if (!this.apiKey) {
+      return false;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
       return false;
     }
-    throw error;
+  }
+  static hasApiKey() {
+    return !!process.env.GROQ_API_KEY;
+  }
+};
+
+// src/backends/index.ts
+var LLAMACPP_DEFAULT_URL = "http://localhost:8080/v1";
+var DEFAULT_MODELS = {
+  ollama: "llama3.1:8b",
+  openai: "gpt-4o-mini",
+  anthropic: "claude-3-haiku-20240307",
+  groq: "llama-3.1-8b-instant",
+  llamacpp: "gpt-4o-mini"
+  // Model alias used by llama-server (--alias flag)
+};
+function createBackend(config) {
+  const model = config.model || DEFAULT_MODELS[config.backend];
+  switch (config.backend) {
+    case "openai":
+      return new OpenAIBackend(model, void 0, config.openai_base_url);
+    case "llamacpp":
+      return new OpenAIBackend(model, void 0, LLAMACPP_DEFAULT_URL);
+    case "anthropic":
+      return new AnthropicBackend(model);
+    case "groq":
+      return new GroqBackend(model);
+    case "ollama":
+    default:
+      return new OllamaBackend(model, config.ollama_url);
   }
 }
-function commit(message) {
-  runGit("commit", "-m", `"${message.replace(/"/g, '\\"')}"`);
-  return runGit("rev-parse", "HEAD");
-}
-function push() {
-  const branch = getCurrentBranch();
-  runGit("push", "origin", branch);
-}
-function getCurrentBranch() {
-  return runGit("rev-parse", "--abbrev-ref", "HEAD");
-}
-function getStagedFiles() {
-  const output = runGitSafe("diff", "--cached", "--name-only");
-  return output.split("\n").filter((f) => f);
+async function detectBackend() {
+  const ollama = new OllamaBackend();
+  if (await ollama.isAvailable()) {
+    return "ollama";
+  }
+  const llamacpp = new OpenAIBackend(DEFAULT_MODELS.llamacpp, void 0, LLAMACPP_DEFAULT_URL);
+  if (await llamacpp.isAvailable()) {
+    return "llamacpp";
+  }
+  if (OpenAIBackend.hasCustomBaseUrl()) {
+    const localOpenai = new OpenAIBackend();
+    if (await localOpenai.isAvailable()) {
+      return "openai";
+    }
+  }
+  if (GroqBackend.hasApiKey()) {
+    return "groq";
+  }
+  if (OpenAIBackend.hasApiKey()) {
+    return "openai";
+  }
+  if (AnthropicBackend.hasApiKey()) {
+    return "anthropic";
+  }
+  return "ollama";
 }
-function resetStaged() {
-  runGitSafe("reset", "HEAD");
+function getAvailableBackends() {
+  const available = ["ollama", "llamacpp"];
+  if (OpenAIBackend.isConfigured()) {
+    available.push("openai");
+  }
+  if (AnthropicBackend.hasApiKey()) {
+    available.push("anthropic");
+  }
+  if (GroqBackend.hasApiKey()) {
+    available.push("groq");
+  }
+  return available;
 }
 
 // src/prompts.ts
@@ -252,6 +597,8 @@ EXAMPLES based on diff content:
 IMPORTANT: Base your message ONLY on the actual changes shown in the diff below.
 Do NOT use the examples above if they don't match the diff content.
 
+{constraints}
+
 {context}
 
 DIFF TO ANALYZE:
@@ -260,6 +607,45 @@ DIFF TO ANALYZE:
 \`\`\`
 
 Reply with ONLY the commit message, nothing else. No quotes, no explanation.`;
+var VALID_TYPES = ["feat", "fix", "docs", "style", "refactor", "test", "chore", "build", "ci", "perf", "revert"];
+function isValidType(type) {
+  return VALID_TYPES.includes(type.toLowerCase());
+}
+function getValidTypes() {
+  return [...VALID_TYPES];
+}
+function buildConstraintsText(constraints) {
+  const parts = [];
+  if (constraints.type) {
+    parts.push(`CONSTRAINT: You MUST use "${constraints.type}" as the commit type.`);
+  }
+  if (constraints.scope) {
+    parts.push(`CONSTRAINT: You MUST use "(${constraints.scope})" as the scope in the commit message.`);
+  }
+  if (constraints.breaking) {
+    parts.push(`CONSTRAINT: This is a BREAKING CHANGE. You MUST use "!" after the type/scope (e.g., "feat!:" or "feat(api)!:").`);
+  }
+  if (constraints.language) {
+    const langMap = {
+      en: "English",
+      pt: "Portuguese",
+      es: "Spanish",
+      fr: "French",
+      de: "German",
+      it: "Italian",
+      ja: "Japanese",
+      zh: "Chinese",
+      ko: "Korean",
+      ru: "Russian"
+    };
+    const langName = langMap[constraints.language.toLowerCase()] || constraints.language;
+    parts.push(`CONSTRAINT: Write the commit message subject in ${langName}.`);
+  }
+  if (constraints.context) {
+    parts.push(`ADDITIONAL CONTEXT: ${constraints.context}`);
+  }
+  return parts.join("\n");
+}
 var KARMA_PATTERN = /^(feat|fix|docs|style|refactor|test|chore|build|ci|perf|revert)(\([^)]+\))?:\s*.+/;
 var ACTION_TO_TYPE = {
   add: "feat",
@@ -297,9 +683,10 @@ function truncateDiff(diff, maxChars = MAX_DIFF_CHARS) {
   }
   return truncated + "\n\n[... diff truncated for brevity ...]";
 }
-function buildPrompt(diff, context) {
+function buildPrompt(diff, context, constraints) {
   const truncatedDiff = truncateDiff(diff);
-  return KARMA_PROMPT.replace("{diff}", truncatedDiff).replace("{context}", context);
+  const constraintsText = constraints ? buildConstraintsText(constraints) : "";
+  return KARMA_PROMPT.replace("{diff}", truncatedDiff).replace("{context}", context).replace("{constraints}", constraintsText);
 }
 function buildSummarizePrompt(diff, context) {
   const truncatedDiff = truncateDiff(diff);
@@ -335,9 +722,30 @@ function fixMessage(message) {
   }
   return `chore: ${cleaned.toLowerCase()}`;
 }
+function addIssueReference(message, issue) {
+  const issueRef = issue.startsWith("#") ? issue : `#${issue}`;
+  return `${message}
+
+Refs: ${issueRef}`;
+}
+function addCoAuthors(message, coAuthors) {
+  if (coAuthors.length === 0) {
+    return message;
+  }
+  const trailers = coAuthors.map((author) => `Co-authored-by: ${author}`).join("\n");
+  return `${message}
+
+${trailers}`;
+}
+function ensureBreakingMarker(message) {
+  if (message.includes("!:")) {
+    return message;
+  }
+  return message.replace(/:/, "!:");
+}
 
 // src/hook.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync2, chmodSync, mkdirSync as mkdirSync2 } from "fs";
 import { join as join2, dirname as dirname2 } from "path";
 var HOOK_SCRIPT = `#!/bin/sh
@@ -380,7 +788,7 @@ exit 0
 var HOOK_NAME = "prepare-commit-msg";
 function getGitDir() {
   try {
-    const result = execSync2("git rev-parse --git-dir", {
+    const result = execSync("git rev-parse --git-dir", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -497,6 +905,32 @@ function debugValidation(message, isValid, fixed) {
 }
 
 // src/cli.ts
+function buildDiffContext(diffResult) {
+  const parts = [];
+  if (diffResult.filesAdded.length > 0) {
+    parts.push(`Files added:
+${diffResult.filesAdded.slice(0, 5).join("\n")}`);
+    if (diffResult.filesAdded.length > 5) {
+      parts.push(`  ... and ${diffResult.filesAdded.length - 5} more added`);
+    }
+  }
+  if (diffResult.filesDeleted.length > 0) {
+    parts.push(`Files deleted:
+${diffResult.filesDeleted.slice(0, 5).join("\n")}`);
+    if (diffResult.filesDeleted.length > 5) {
+      parts.push(`  ... and ${diffResult.filesDeleted.length - 5} more deleted`);
+    }
+  }
+  if (diffResult.filesModified.length > 0) {
+    parts.push(`Files modified:
+${diffResult.filesModified.slice(0, 5).join("\n")}`);
+    if (diffResult.filesModified.length > 5) {
+      parts.push(`  ... and ${diffResult.filesModified.length - 5} more modified`);
+    }
+  }
+  parts.push(`Stats: ${diffResult.stats}`);
+  return parts.join("\n");
+}
 async function promptUser(question, choices) {
   const rl = createInterface({
     input: process.stdin,
@@ -527,15 +961,18 @@ async function promptEdit(currentMessage) {
     });
   });
 }
-async function generateMessage(backend, diffContent, context, temperatures) {
-  const prompt = buildPrompt(diffContent, context);
+async function generateMessage(backend, diffContent, context, temperatures, constraints) {
+  const prompt = buildPrompt(diffContent, context, constraints);
   debugPrompt(prompt);
   for (const temp of temperatures) {
     debug(`Trying temperature: ${temp}`);
     try {
       const rawMessage = await backend.generate(prompt, temp);
       debugResponse(rawMessage);
-      const message = cleanMessage(rawMessage);
+      let message = cleanMessage(rawMessage);
+      if (constraints?.breaking) {
+        message = ensureBreakingMarker(message);
+      }
       const isValid = validateMessage(message);
       debugValidation(message, isValid);
       if (isValid) {
@@ -544,7 +981,7 @@ async function generateMessage(backend, diffContent, context, temperatures) {
       const fixed = fixMessage(message);
       if (validateMessage(fixed)) {
         debugValidation(fixed, true, fixed);
-        return fixed;
+        return constraints?.breaking ? ensureBreakingMarker(fixed) : fixed;
       }
     } catch (e) {
       const error = e;
@@ -570,13 +1007,13 @@ async function promptAction(message) {
     ["c", "e", "r", "a"]
   );
 }
-async function runCommitFlow(backend, cfg, diffContent, context, skipConfirm) {
+async function runCommitFlow(backend, cfg, diffContent, context, skipConfirm, constraints) {
   const temperatures = [cfg.temperature, ...cfg.retry_temperatures];
   const spinner = ora("Generating commit message...").start();
   while (true) {
     let message;
     try {
-      message = await generateMessage(backend, diffContent, context, temperatures);
+      message = await generateMessage(backend, diffContent, context, temperatures, constraints);
     } finally {
       spinner.stop();
     }
@@ -602,25 +1039,58 @@ async function runCommitFlow(backend, cfg, diffContent, context, skipConfirm) {
     }
   }
 }
-async function handleSingleCommit(backend, cfg, skipConfirm) {
-  const diffResult = getStagedDiff();
-  if (diffResult.isEmpty) {
-    console.log(chalk2.yellow("No changes to commit."));
-    process.exit(0);
+async function handleSingleCommit(backend, cfg, options) {
+  let diffResult;
+  if (options.amend) {
+    diffResult = getLastCommitDiff();
+    if (diffResult.isEmpty) {
+      console.log(chalk2.yellow("No previous commit to amend."));
+      process.exit(1);
+    }
+    console.log(chalk2.dim("Amending last commit..."));
+  } else {
+    diffResult = getStagedDiff();
+    if (diffResult.isEmpty) {
+      console.log(chalk2.yellow("No changes to commit."));
+      process.exit(0);
+    }
   }
-  debugDiff(diffResult.diff, diffResult.files);
-  const context = `Files changed:
-${diffResult.files.slice(0, 5).join("\n")}
-Stats: ${diffResult.stats}`;
-  const message = await runCommitFlow(backend, cfg, diffResult.diff, context, skipConfirm);
+  let diff = diffResult.diff;
+  if (cfg.ignore_patterns && cfg.ignore_patterns.length > 0) {
+    diff = filterDiffByPatterns(diff, cfg.ignore_patterns);
+    if (!diff.trim()) {
+      console.log(chalk2.yellow("All changes are ignored by ignore_patterns."));
+      process.exit(0);
+    }
+  }
+  debugDiff(diff, diffResult.files);
+  const context = buildDiffContext(diffResult);
+  let message = await runCommitFlow(backend, cfg, diff, context, options.skipConfirm, options.constraints);
   if (message === null) {
     console.log(chalk2.yellow("Aborted."));
     process.exit(0);
   }
+  if (options.issue) {
+    message = addIssueReference(message, options.issue);
+  }
+  if (options.coAuthors && options.coAuthors.length > 0) {
+    message = addCoAuthors(message, options.coAuthors);
+  }
+  if (options.dryRun) {
+    console.log(chalk2.cyan("Dry run - message not committed:"));
+    console.log(message);
+    return;
+  }
   try {
-    commit(message);
-    debug(`Commit successful: ${message}`);
-    console.log(chalk2.green("\u2713 Committed:"), message);
+    if (options.amend) {
+      commitAmend(message);
+      debug(`Amend successful: ${message}`);
+      console.log(chalk2.green("\u2713 Amended:"), message.split("\n")[0]);
+    } else {
+      commit(message);
+      debug(`Commit successful: ${message}`);
+      console.log(chalk2.green("\u2713 Committed:"), message.split("\n")[0]);
+    }
   } catch (e) {
     const error = e;
     debug(`Commit failed: ${error.message}`);
@@ -628,7 +1098,7 @@ Stats: ${diffResult.stats}`;
     process.exit(1);
   }
 }
-async function handleIndividualCommits(backend, cfg, skipConfirm) {
+async function handleIndividualCommits(backend, cfg, options) {
   const stagedFiles = getStagedFiles();
   if (stagedFiles.length === 0) {
     console.log(chalk2.yellow("No staged files to commit."));
@@ -638,6 +1108,13 @@ async function handleIndividualCommits(backend, cfg, skipConfirm) {
   console.log(chalk2.dim(`Found ${stagedFiles.length} files to commit individually.`));
   resetStaged();
   for (const filePath of stagedFiles) {
+    if (cfg.ignore_patterns && cfg.ignore_patterns.length > 0) {
+      const { shouldIgnoreFile } = await import("./git-F4ZHBA3B.js");
+      if (shouldIgnoreFile(filePath, cfg.ignore_patterns)) {
+        console.log(chalk2.dim(`Skipping ignored file: ${filePath}`));
+        continue;
+      }
+    }
     const added = addFiles(filePath);
     if (!added) {
       continue;
@@ -648,16 +1125,26 @@ async function handleIndividualCommits(backend, cfg, skipConfirm) {
     }
     console.log(chalk2.bold(`
 Processing: ${filePath}`));
-    const context = `File: ${filePath}
-Stats: ${diffResult.stats}`;
-    const message = await runCommitFlow(backend, cfg, diffResult.diff, context, skipConfirm);
+    const context = buildDiffContext(diffResult);
+    let message = await runCommitFlow(backend, cfg, diffResult.diff, context, options.skipConfirm, options.constraints);
     if (message === null) {
       console.log(chalk2.yellow(`Skipped: ${filePath}`));
       continue;
     }
+    if (options.issue) {
+      message = addIssueReference(message, options.issue);
+    }
+    if (options.coAuthors && options.coAuthors.length > 0) {
+      message = addCoAuthors(message, options.coAuthors);
+    }
+    if (options.dryRun) {
+      console.log(chalk2.cyan(`Dry run - ${filePath}:`));
+      console.log(message);
+      continue;
+    }
     try {
       commit(message);
-      console.log(chalk2.green("\u2713 Committed:"), message);
+      console.log(chalk2.green("\u2713 Committed:"), message.split("\n")[0]);
     } catch (e) {
       const error = e;
       console.log(chalk2.red(`Error committing ${filePath}: ${error.message}`));
@@ -666,46 +1153,124 @@ Stats: ${diffResult.stats}`;
 }
 function createProgram() {
   const program2 = new Command();
-  program2.name("git-commit-ai").description("Generate commit messages using local LLMs").version("0.2.0").option("-p, --push", "Push after commit").option("-y, --yes", "Skip confirmation").option("-i, --individual", "Commit files individually").option("-d, --debug", "Enable debug output").option("--hook-mode", "Called by git hook (outputs message only)").action(async (options) => {
+  program2.name("git-commit-ai").description("Generate commit messages using LLMs (Ollama, OpenAI, Anthropic, Groq, llama.cpp)").version("0.3.0").option("-p, --push", "Push after commit").option("-y, --yes", "Skip confirmation").option("-i, --individual", "Commit files individually").option("-d, --debug", "Enable debug output").option("--dry-run", "Show generated message without committing").option("-b, --backend <backend>", "Backend to use (ollama, openai, anthropic, groq, llamacpp)").option("-m, --model <model>", "Override model from config").option("-t, --temperature <temp>", "Override temperature (0.0-1.0)", parseFloat).option("--hook-mode", "Called by git hook (outputs message only)").option("--amend", "Regenerate and amend the last commit message").option("-s, --scope <scope>", "Force a specific scope (e.g., auth, api)").option("--type <type>", `Force commit type (${getValidTypes().join(", ")})`).option("-c, --context <text>", "Provide additional context for message generation").option("-l, --lang <code>", "Language for commit message (en, pt, es, fr, de, etc.)").option("--issue <ref>", "Reference an issue (e.g., 123 or #123)").option("--breaking", "Mark as breaking change (adds ! to type)").option("--co-author <author>", "Add co-author (can be used multiple times)", (val, prev) => prev.concat([val]), []).action(async (options) => {
     if (options.debug) {
       enableDebug();
       debug("Debug mode enabled");
     }
     const cfg = loadConfig();
+    if (options.type && !isValidType(options.type)) {
+      console.log(chalk2.red(`Error: Invalid commit type "${options.type}"`));
+      console.log(chalk2.dim(`Valid types: ${getValidTypes().join(", ")}`));
+      process.exit(1);
+    }
+    if (options.backend) {
+      const validBackends = ["ollama", "openai", "anthropic", "groq", "llamacpp"];
+      if (validBackends.includes(options.backend)) {
+        cfg.backend = options.backend;
+        if (!options.model && cfg.model === "llama3.1:8b") {
+          cfg.model = DEFAULT_MODELS[cfg.backend];
+        }
+        debug(`Backend overridden to: ${cfg.backend}`);
+      } else {
+        console.log(chalk2.red(`Error: Invalid backend "${options.backend}"`));
+        console.log(chalk2.dim(`Valid backends: ${validBackends.join(", ")}`));
+        process.exit(1);
+      }
+    }
+    if (options.model) {
+      cfg.model = options.model;
+      debug(`Model overridden to: ${cfg.model}`);
+    }
+    if (options.temperature !== void 0 && !isNaN(options.temperature)) {
+      cfg.temperature = options.temperature;
+      debug(`Temperature overridden to: ${cfg.temperature}`);
+    }
     debugConfig(cfg);
-    const backend = new OllamaBackend(cfg.model, cfg.ollama_url);
+    if (!options.backend && cfg.backend === "ollama") {
+      const detected = await detectBackend();
+      if (detected !== "ollama") {
+        cfg.backend = detected;
+        cfg.model = DEFAULT_MODELS[detected];
+        debug(`Auto-detected backend: ${detected}`);
+      }
+    }
+    const backend = createBackend(cfg);
+    debug(`Using backend: ${cfg.backend} with model: ${cfg.model}`);
     const available = await backend.isAvailable();
     if (!available) {
       if (options.hookMode) {
         process.exit(1);
       }
-      console.log(chalk2.red("Error: Ollama is not running."));
-      console.log(chalk2.dim("Start it with: brew services start ollama"));
+      if (cfg.backend === "ollama") {
+        console.log(chalk2.red("Error: Ollama is not running."));
+        console.log(chalk2.dim("Start it with: brew services start ollama"));
+      } else if (cfg.backend === "llamacpp") {
+        console.log(chalk2.red("Error: llama.cpp server is not running."));
+        console.log(chalk2.dim("Start it with: llama-server -m model.gguf --port 8080"));
+      } else {
+        console.log(chalk2.red(`Error: ${cfg.backend} backend is not available.`));
+        const envVar = {
+          openai: "OPENAI_API_KEY",
+          anthropic: "ANTHROPIC_API_KEY",
+          groq: "GROQ_API_KEY"
+        }[cfg.backend];
+        if (envVar) {
+          console.log(chalk2.dim(`Set ${envVar} environment variable.`));
+        }
+      }
+      const availableBackends = getAvailableBackends();
+      if (availableBackends.length > 1) {
+        console.log(chalk2.dim(`Available backends: ${availableBackends.join(", ")}`));
+      }
       process.exit(1);
     }
+    const constraints = {
+      type: options.type || cfg.default_type,
+      scope: options.scope || cfg.default_scope,
+      language: options.lang || cfg.default_language,
+      breaking: options.breaking,
+      context: options.context
+    };
     if (options.hookMode) {
       const diffResult = getStagedDiff();
       if (diffResult.isEmpty) {
         process.exit(1);
       }
-      const context = `Files changed:
-${diffResult.files.slice(0, 5).join("\n")}
-Stats: ${diffResult.stats}`;
+      let diff = diffResult.diff;
+      if (cfg.ignore_patterns && cfg.ignore_patterns.length > 0) {
+        diff = filterDiffByPatterns(diff, cfg.ignore_patterns);
+      }
+      const context = buildDiffContext(diffResult);
       const temperatures = [cfg.temperature, ...cfg.retry_temperatures];
-      const message = await generateMessage(backend, diffResult.diff, context, temperatures);
+      const message = await generateMessage(backend, diff, context, temperatures, constraints);
       if (message) {
         console.log(message);
         process.exit(0);
       }
       process.exit(1);
     }
-    addFiles(".");
+    const commitOptions = {
+      skipConfirm: options.yes,
+      dryRun: options.dryRun,
+      amend: options.amend,
+      constraints,
+      issue: options.issue,
+      coAuthors: options.coAuthor
+    };
+    if (!options.amend) {
+      addFiles(".");
+    }
     if (options.individual) {
-      await handleIndividualCommits(backend, cfg, options.yes);
+      if (options.amend) {
+        console.log(chalk2.red("Error: --amend cannot be used with --individual"));
+        process.exit(1);
+      }
+      await handleIndividualCommits(backend, cfg, commitOptions);
     } else {
-      await handleSingleCommit(backend, cfg, options.yes);
+      await handleSingleCommit(backend, cfg, commitOptions);
     }
-    if (options.push) {
+    if (options.push && !options.dryRun && !options.amend) {
       try {
         push();
         console.log(chalk2.green("\u2713 Changes pushed to remote."));
@@ -716,7 +1281,41 @@ Stats: ${diffResult.stats}`;
       }
     }
   });
-  program2.command("config").description("Show or edit configuration").option("-e, --edit", "Create/edit configuration file").action((options) => {
+  program2.command("config").description("Show or edit configuration").option("-e, --edit", "Create/edit configuration file").option("-s, --set <key=value>", "Set a config value (e.g., --set backend=llamacpp)").option("-l, --list-keys", "List all valid config keys").action((options) => {
+    if (options.listKeys) {
+      console.log(chalk2.bold("Valid config keys:"));
+      for (const key of VALID_CONFIG_KEYS) {
+        const alias = Object.entries(CONFIG_ALIASES).find(([, v]) => v === key)?.[0];
+        if (alias) {
+          console.log(`  ${key} ${chalk2.dim(`(alias: ${alias})`)}`);
+        } else {
+          console.log(`  ${key}`);
+        }
+      }
+      console.log();
+      console.log(chalk2.bold("Short aliases:"));
+      for (const [alias, fullKey] of Object.entries(CONFIG_ALIASES)) {
+        console.log(`  ${alias} \u2192 ${fullKey}`);
+      }
+      return;
+    }
+    if (options.set) {
+      const match = options.set.match(/^([^=]+)=(.*)$/);
+      if (!match) {
+        console.log(chalk2.red("Error: Invalid format. Use: --set key=value"));
+        console.log(chalk2.dim("Example: git-commit-ai config --set backend=llamacpp"));
+        process.exit(1);
+      }
+      const [, key, value] = match;
+      const result = updateConfig(key, value);
+      if (result.success) {
+        console.log(chalk2.green(`\u2713 ${result.message}`));
+      } else {
+        console.log(chalk2.red(`Error: ${result.message}`));
+        process.exit(1);
+      }
+      return;
+    }
     const cfg = loadConfig();
     if (options.edit) {
       console.log(chalk2.dim("Creating default config file..."));
@@ -727,16 +1326,34 @@ Stats: ${diffResult.stats}`;
       console.log(showConfig(cfg));
     }
   });
-  program2.command("summarize").description("Summarize staged changes in plain English").option("--diff", "Also show the raw diff").option("-d, --debug", "Enable debug output").action(async (options) => {
+  program2.command("summarize").description("Summarize staged changes in plain English").option("--diff", "Also show the raw diff").option("-b, --backend <backend>", "Backend to use (ollama, openai, anthropic, groq, llamacpp)").option("-d, --debug", "Enable debug output").action(async (options) => {
     if (options.debug) {
       enableDebug();
     }
     const cfg = loadConfig();
-    const backend = new OllamaBackend(cfg.model, cfg.ollama_url);
+    if (options.backend) {
+      const validBackends = ["ollama", "openai", "anthropic", "groq", "llamacpp"];
+      if (validBackends.includes(options.backend)) {
+        cfg.backend = options.backend;
+        cfg.model = DEFAULT_MODELS[cfg.backend];
+      }
+    }
+    if (cfg.backend === "ollama") {
+      const detected = await detectBackend();
+      if (detected !== "ollama") {
+        cfg.backend = detected;
+        cfg.model = DEFAULT_MODELS[detected];
+      }
+    }
+    const backend = createBackend(cfg);
     const available = await backend.isAvailable();
     if (!available) {
-      console.log(chalk2.red("Error: Ollama is not running."));
-      console.log(chalk2.dim("Start it with: brew services start ollama"));
+      if (cfg.backend === "ollama") {
+        console.log(chalk2.red("Error: Ollama is not running."));
+        console.log(chalk2.dim("Start it with: brew services start ollama"));
+      } else {
+        console.log(chalk2.red(`Error: ${cfg.backend} backend is not available.`));
+      }
       process.exit(1);
     }
     const diffResult = getStagedDiff();
@@ -754,8 +1371,7 @@ Files to summarize: ${diffResult.files.length}`));
     if (diffResult.files.length > 10) {
       console.log(`  ... and ${diffResult.files.length - 10} more`);
     }
-    const context = `Files changed: ${diffResult.files.slice(0, 5).join(", ")}
-Stats: ${diffResult.stats}`;
+    const context = buildDiffContext(diffResult);
     const prompt = buildSummarizePrompt(diffResult.diff, context);
     debugPrompt(prompt);
     const spinner = ora("Generating summary...").start();