ghostcommit 1.0.0

package/dist/index.js

@@ -0,0 +1,2580 @@
+// src/cli.ts
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+import chalk7 from "chalk";
+import { Command } from "commander";
+
+// src/commands/amend.ts
+import chalk2 from "chalk";
+
+// src/providers/anthropic.ts
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+var AnthropicProvider = class {
+  name = "anthropic";
+  model;
+  apiKey;
+  constructor(model) {
+    this.model = model || DEFAULT_MODEL;
+    this.apiKey = process.env.ANTHROPIC_API_KEY || "";
+  }
+  async isAvailable() {
+    return !!this.apiKey;
+  }
+  getTokenBudget() {
+    return 18e4;
+  }
+  async generate(prompt, systemPrompt) {
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const client = new Anthropic({ apiKey: this.apiKey });
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: 1024,
+      system: systemPrompt,
+      messages: [{ role: "user", content: prompt }]
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    return textBlock && "text" in textBlock ? textBlock.text.trim() : "";
+  }
+  async *generateStream(prompt, systemPrompt) {
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const client = new Anthropic({ apiKey: this.apiKey });
+    const stream = client.messages.stream({
+      model: this.model,
+      max_tokens: 1024,
+      system: systemPrompt,
+      messages: [{ role: "user", content: prompt }]
+    });
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield event.delta.text;
+      }
+    }
+  }
+};
+
+// src/providers/gemini.ts
+var DEFAULT_MODEL2 = "gemini-2.0-flash";
+var GeminiProvider = class {
+  name = "gemini";
+  model;
+  apiKey;
+  constructor(model) {
+    this.model = model || DEFAULT_MODEL2;
+    this.apiKey = process.env.GEMINI_API_KEY || "";
+  }
+  async isAvailable() {
+    return !!this.apiKey;
+  }
+  getTokenBudget() {
+    return 9e5;
+  }
+  async generate(prompt, systemPrompt) {
+    const { GoogleGenerativeAI } = await import("@google/generative-ai");
+    const client = new GoogleGenerativeAI(this.apiKey);
+    const model = client.getGenerativeModel({
+      model: this.model,
+      systemInstruction: systemPrompt
+    });
+    const result = await model.generateContent(prompt);
+    return result.response.text().trim();
+  }
+  async *generateStream(prompt, systemPrompt) {
+    const { GoogleGenerativeAI } = await import("@google/generative-ai");
+    const client = new GoogleGenerativeAI(this.apiKey);
+    const model = client.getGenerativeModel({
+      model: this.model,
+      systemInstruction: systemPrompt
+    });
+    const result = await model.generateContentStream(prompt);
+    for await (const chunk of result.stream) {
+      const text = chunk.text();
+      if (text) yield text;
+    }
+  }
+};
+
+// src/providers/groq.ts
+var DEFAULT_MODEL3 = "llama-3.3-70b-versatile";
+var GROQ_TOKEN_BUDGETS = {
+  "llama-3.3-70b-versatile": 1e4,
+  // 12k TPM, leave headroom
+  "llama-3.1-8b-instant": 5e3
+  // 6k TPM limit
+};
+var GROQ_DEFAULT_BUDGET = 6e3;
+var GroqProvider = class {
+  name = "groq";
+  model;
+  apiKey;
+  constructor(model) {
+    this.model = model || DEFAULT_MODEL3;
+    this.apiKey = process.env.GROQ_API_KEY || "";
+  }
+  async isAvailable() {
+    return !!this.apiKey;
+  }
+  getTokenBudget() {
+    return GROQ_TOKEN_BUDGETS[this.model] ?? GROQ_DEFAULT_BUDGET;
+  }
+  async generate(prompt, systemPrompt) {
+    const { default: Groq } = await import("groq-sdk");
+    const client = new Groq({ apiKey: this.apiKey });
+    const response = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ]
+    });
+    return response.choices[0]?.message?.content?.trim() || "";
+  }
+  async *generateStream(prompt, systemPrompt) {
+    const { default: Groq } = await import("groq-sdk");
+    const client = new Groq({ apiKey: this.apiKey });
+    const stream = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ],
+      stream: true
+    });
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) yield content;
+    }
+  }
+};
+
+// src/providers/ollama.ts
+var DEFAULT_MODEL4 = "qwen2.5-coder:0.5b";
+var DEFAULT_HOST = "http://localhost:11434";
+var OllamaProvider = class {
+  name = "ollama";
+  model;
+  host;
+  ensuredModel = false;
+  constructor(model, host) {
+    this.model = model || DEFAULT_MODEL4;
+    this.host = host || process.env.OLLAMA_HOST || DEFAULT_HOST;
+  }
+  async isAvailable() {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 2e3);
+      const response = await fetch(`${this.host}/api/tags`, {
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  getTokenBudget() {
+    return 4e3;
+  }
+  /** Check if a specific model is already pulled locally. */
+  async hasModel(model) {
+    try {
+      const response = await fetch(`${this.host}/api/tags`);
+      if (!response.ok) return false;
+      const data = await response.json();
+      const target = model || this.model;
+      return data.models.some(
+        (m) => m.name === target || m.name === `${target}:latest`
+      );
+    } catch {
+      return false;
+    }
+  }
+  /** Auto-pull the model if not present. Shows progress to the user. */
+  async ensureModel() {
+    if (this.ensuredModel) return;
+    this.ensuredModel = true;
+    if (await this.hasModel()) return;
+    process.stderr.write(
+      `Downloading model "${this.model}" (first run only)...
+`
+    );
+    const response = await fetch(`${this.host}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: this.model, stream: true })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `Failed to pull model "${this.model}": ${text}
+Run manually: ollama pull ${this.model}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("No response body from Ollama pull");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let lastPercent = -1;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const data = JSON.parse(line);
+            if (data.total && data.completed) {
+              const percent = Math.round(data.completed / data.total * 100);
+              if (percent !== lastPercent && percent % 10 === 0) {
+                process.stderr.write(`  ${percent}%
+`);
+                lastPercent = percent;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    process.stderr.write(`Model "${this.model}" ready.
+`);
+  }
+  async generate(prompt, systemPrompt) {
+    await this.ensureModel();
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: prompt }
+    ];
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 9e4);
+    const response = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        stream: false
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Ollama error (${response.status}): ${text}`);
+    }
+    const data = await response.json();
+    return data.message.content.trim();
+  }
+  async *generateStream(prompt, systemPrompt) {
+    await this.ensureModel();
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: prompt }
+    ];
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 9e4);
+    const response = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        messages,
+        stream: true
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Ollama error (${response.status}): ${text}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body from Ollama");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const data = JSON.parse(line);
+            if (data.message?.content) {
+              yield data.message.content;
+            }
+          } catch {
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          const data = JSON.parse(buffer);
+          if (data.message?.content) {
+            yield data.message.content;
+          }
+        } catch {
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/providers/openai.ts
+var DEFAULT_MODEL5 = "gpt-4o-mini";
+var OpenAIProvider = class {
+  name = "openai";
+  model;
+  apiKey;
+  constructor(model) {
+    this.model = model || DEFAULT_MODEL5;
+    this.apiKey = process.env.OPENAI_API_KEY || "";
+  }
+  async isAvailable() {
+    return !!this.apiKey;
+  }
+  getTokenBudget() {
+    return 12e4;
+  }
+  async generate(prompt, systemPrompt) {
+    const { default: OpenAI } = await import("openai");
+    const client = new OpenAI({ apiKey: this.apiKey });
+    const response = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ]
+    });
+    return response.choices[0]?.message?.content?.trim() || "";
+  }
+  async *generateStream(prompt, systemPrompt) {
+    const { default: OpenAI } = await import("openai");
+    const client = new OpenAI({ apiKey: this.apiKey });
+    const stream = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: prompt }
+      ],
+      stream: true
+    });
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) yield content;
+    }
+  }
+};
+
+// src/ai.ts
+function createProvider(providerName, model) {
+  switch (providerName) {
+    case "ollama":
+      return new OllamaProvider(model);
+    case "groq":
+      return new GroqProvider(model);
+    case "openai":
+      return new OpenAIProvider(model);
+    case "anthropic":
+      return new AnthropicProvider(model);
+    case "gemini":
+      return new GeminiProvider(model);
+    default:
+      throw new Error(
+        `Unknown provider "${providerName}". Available: ollama, groq, openai, anthropic, gemini`
+      );
+  }
+}
+async function resolveProvider(configuredProvider, model) {
+  if (configuredProvider) {
+    const provider = createProvider(configuredProvider, model);
+    const available = await provider.isAvailable();
+    if (!available) {
+      throw new Error(
+        `Provider "${configuredProvider}" is not available. ` + getProviderHelp(configuredProvider)
+      );
+    }
+    return provider;
+  }
+  const groq = new GroqProvider(model);
+  if (await groq.isAvailable()) {
+    return groq;
+  }
+  const ollama = new OllamaProvider(model);
+  if (await ollama.isAvailable()) {
+    return ollama;
+  }
+  throw new Error(
+    "No AI provider available.\n\nghostcommit needs an AI provider to generate commit messages.\n\nOptions (in order of recommendation):\n  1. Install Ollama (free, local, private): https://ollama.ai\n     The model downloads automatically on first run.\n\n  2. Set GROQ_API_KEY for free cloud inference:\n     https://console.groq.com/keys\n\n  3. Set GEMINI_API_KEY for free Google Gemini:\n     https://aistudio.google.com/apikey\n\n  4. Set OPENAI_API_KEY or ANTHROPIC_API_KEY for paid providers"
+  );
+}
+function getProviderHelp(provider) {
+  switch (provider) {
+    case "ollama":
+      return "Make sure Ollama is running (ollama serve). The model downloads automatically.";
+    case "groq":
+      return "Set GROQ_API_KEY environment variable. Get a free key at https://console.groq.com/keys";
+    case "openai":
+      return "Set OPENAI_API_KEY environment variable.";
+    case "anthropic":
+      return "Set ANTHROPIC_API_KEY environment variable.";
+    case "gemini":
+      return "Set GEMINI_API_KEY environment variable. Get a free key at https://aistudio.google.com/apikey";
+    default:
+      return "";
+  }
+}
+var TOKEN_LIMIT_PATTERNS = [
+  /413/,
+  /rate.?limit/i,
+  /context.?length.?exceeded/i,
+  /too.?large/i,
+  /too.?many.?tokens/i,
+  /token.?limit/i,
+  /maximum.?context/i,
+  /request.?too.?large/i
+];
+function isTokenLimitError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return TOKEN_LIMIT_PATTERNS.some((pattern) => pattern.test(message));
+}
+async function generateCommitMessage(provider, userPrompt, systemPrompt, stream = true) {
+  if (stream && process.stdout.isTTY) {
+    let result = "";
+    for await (const chunk of provider.generateStream(
+      userPrompt,
+      systemPrompt
+    )) {
+      result += chunk;
+      process.stdout.write(chunk);
+    }
+    process.stdout.write("\n");
+    return result.trim();
+  }
+  return provider.generate(userPrompt, systemPrompt);
+}
+
+// src/config.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/changelog/categorizer.ts
+var ALL_CATEGORIES = [
+  "Features",
+  "Bug Fixes",
+  "Performance",
+  "Breaking Changes",
+  "Documentation",
+  "Refactoring",
+  "Tests",
+  "CI/CD",
+  "Chore"
+];
+var TYPE_TO_CATEGORY = {
+  feat: "Features",
+  fix: "Bug Fixes",
+  perf: "Performance",
+  docs: "Documentation",
+  refactor: "Refactoring",
+  test: "Tests",
+  build: "CI/CD",
+  ci: "CI/CD",
+  chore: "Chore",
+  style: "Chore",
+  revert: "Chore"
+};
+var CATEGORIZER_SYSTEM_PROMPT = `You are a changelog categorizer. Given a commit message, categorize it into exactly ONE of these categories:
+- Features (new functionality)
+- Bug Fixes (bug fixes)
+- Performance (performance improvements)
+- Breaking Changes (backward-incompatible changes)
+- Documentation (docs changes)
+- Refactoring (code restructuring without behavior change)
+- Tests (test additions or changes)
+- CI/CD (CI/CD and build changes)
+- Chore (maintenance, deps, etc.)
+
+Respond with ONLY a JSON object (no markdown, no code fences):
+{"category": "...", "summary": "..."}
+
+The summary should be a concise, human-readable description of the change (imperative mood, no period).`;
+function categorizeByType(commit) {
+  if (!commit.type) return null;
+  if (commit.breaking) {
+    return {
+      commit,
+      category: "Breaking Changes",
+      summary: commit.description
+    };
+  }
+  const category = TYPE_TO_CATEGORY[commit.type];
+  return category ? { commit, category, summary: commit.description } : null;
+}
+async function categorizeWithAI(commit, provider) {
+  try {
+    const response = await provider.generate(
+      `Commit message: "${commit.message}"`,
+      CATEGORIZER_SYSTEM_PROMPT
+    );
+    const cleaned = response.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const validCategory = ALL_CATEGORIES.find(
+      (c) => c.toLowerCase() === parsed.category.toLowerCase()
+    );
+    return {
+      commit,
+      category: validCategory ?? "Chore",
+      summary: parsed.summary || commit.description
+    };
+  } catch {
+    return { commit, category: "Chore", summary: commit.description };
+  }
+}
+function categorizeFallback(commit) {
+  return {
+    commit,
+    category: commit.breaking ? "Breaking Changes" : "Chore",
+    summary: commit.description
+  };
+}
+function matchesAnyPattern(message, patterns) {
+  return patterns.some((pattern) => new RegExp(pattern).test(message));
+}
+async function categorizeCommits(commits, options = {}) {
+  const { provider, excludePatterns = [] } = options;
+  const filtered = excludePatterns.length > 0 ? commits.filter((c) => !matchesAnyPattern(c.message, excludePatterns)) : commits;
+  const regexResults = filtered.map(categorizeByType);
+  const needsAI = filtered.filter((_, i) => regexResults[i] === null);
+  const aiResults = /* @__PURE__ */ new Map();
+  for (const commit of needsAI) {
+    aiResults.set(
+      commit,
+      provider ? await categorizeWithAI(commit, provider) : categorizeFallback(commit)
+    );
+  }
+  return filtered.map(
+    (commit, i) => regexResults[i] ?? aiResults.get(commit) ?? categorizeFallback(commit)
+  );
+}
+function groupByCategory(categorized) {
+  return categorized.reduce((grouped, item) => {
+    const existing = grouped.get(item.category) ?? [];
+    grouped.set(item.category, [...existing, item]);
+    return grouped;
+  }, /* @__PURE__ */ new Map());
+}
+
+// src/config.ts
+function createDefaults() {
+  return {
+    provider: void 0,
+    model: void 0,
+    language: "en",
+    learnStyle: true,
+    learnStyleCommits: 50,
+    ignorePaths: [],
+    branchPrefix: true,
+    branchPattern: "[A-Z]+-\\d+",
+    tokenBudget: void 0,
+    changelog: {
+      format: "markdown",
+      output: "CHANGELOG.md",
+      categories: [...ALL_CATEGORIES],
+      exclude: []
+    },
+    release: {
+      draft: true
+    }
+  };
+}
+async function readYamlFile(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const parsed = parseYaml(content);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function loadConfig(projectRoot, cliFlags) {
+  let config = createDefaults();
+  const globalConfig = await readYamlFile(join(homedir(), ".ghostcommit.yml"));
+  if (globalConfig) {
+    config = mergeConfig(config, globalConfig);
+  }
+  if (projectRoot) {
+    const projectConfig = await readYamlFile(
+      join(projectRoot, ".ghostcommit.yml")
+    );
+    if (projectConfig) {
+      config = mergeConfig(config, projectConfig);
+    }
+  }
+  if (cliFlags) {
+    config = applyCLIFlags(config, cliFlags);
+  }
+  return config;
+}
+function applyCLIFlags(base, flags) {
+  return {
+    ...base,
+    ...flags.provider !== void 0 && { provider: flags.provider },
+    ...flags.model !== void 0 && { model: flags.model },
+    ...flags.noStyle && { learnStyle: false }
+  };
+}
+function mergeChangelog(base, overrides) {
+  return {
+    format: overrides.format ?? base.format,
+    output: overrides.output ?? base.output,
+    categories: overrides.categories ?? base.categories,
+    exclude: overrides.exclude !== void 0 ? [...base.exclude, ...overrides.exclude] : [...base.exclude]
+  };
+}
+function mergeRelease(base, overrides) {
+  return {
+    draft: overrides.draft ?? base.draft
+  };
+}
+function mergeConfig(base, overrides) {
+  return {
+    provider: overrides.provider ?? base.provider,
+    model: overrides.model ?? base.model,
+    language: overrides.language ?? base.language,
+    learnStyle: overrides.learnStyle ?? base.learnStyle,
+    learnStyleCommits: overrides.learnStyleCommits ?? base.learnStyleCommits,
+    ignorePaths: overrides.ignorePaths !== void 0 ? [...base.ignorePaths, ...overrides.ignorePaths] : [...base.ignorePaths],
+    branchPrefix: overrides.branchPrefix ?? base.branchPrefix,
+    branchPattern: overrides.branchPattern ?? base.branchPattern,
+    tokenBudget: overrides.tokenBudget ?? base.tokenBudget,
+    changelog: overrides.changelog ? mergeChangelog(
+      base.changelog,
+      overrides.changelog
+    ) : { ...base.changelog, exclude: [...base.changelog.exclude] },
+    release: overrides.release ? mergeRelease(base.release, overrides.release) : { ...base.release }
+  };
+}
+
+// src/utils.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function exec(command, args, cwd) {
+  try {
+    const result = await execFileAsync(command, args, {
+      cwd,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB for large diffs
+    });
+    return { stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    const err = error;
+    throw new Error(err.stderr?.trim() || err.message);
+  }
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  return lines.slice(0, maxLines).join("\n") + `
+... (truncated ${lines.length - maxLines} more lines)`;
+}
+function extractTicketFromBranch(branchName, pattern) {
+  const regex = new RegExp(pattern || "[A-Z]+-\\d+");
+  const match = branchName.match(regex);
+  return match ? match[0] : null;
+}
+
+// src/diff-processor.ts
+var DEFAULT_IGNORE_PATTERNS = [
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Gemfile.lock",
+  "Cargo.lock",
+  "poetry.lock",
+  "composer.lock",
+  "go.sum"
+];
+var DEFAULT_IGNORE_GLOBS = [
+  "*.generated.*",
+  "*.min.js",
+  "*.min.css",
+  "*.map"
+];
+var DEFAULT_IGNORE_DIRS = [
+  "dist/",
+  "build/",
+  ".next/",
+  "__pycache__/"
+];
+var SOURCE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".java",
+  ".go",
+  ".rs",
+  ".rb",
+  ".c",
+  ".cpp",
+  ".h",
+  ".cs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".vue",
+  ".svelte"
+];
+var DEFAULT_TOKEN_LIMIT = 2e3;
+var DEFAULT_MAX_LINES_PER_FILE = 60;
+function getMaxLinesPerFile(tokenBudget) {
+  if (tokenBudget > 1e4) return 200;
+  if (tokenBudget > 4e3) return 100;
+  return DEFAULT_MAX_LINES_PER_FILE;
+}
+function shouldIgnoreFile(filePath, extraIgnorePaths = []) {
+  const fileName = filePath.split("/").pop() || "";
+  if (DEFAULT_IGNORE_PATTERNS.includes(fileName)) return true;
+  for (const dir of DEFAULT_IGNORE_DIRS) {
+    if (filePath.startsWith(dir) || filePath.includes(`/${dir}`)) return true;
+  }
+  for (const pattern of DEFAULT_IGNORE_GLOBS) {
+    if (matchSimpleGlob(fileName, pattern)) return true;
+  }
+  for (const pattern of extraIgnorePaths) {
+    if (pattern.endsWith("/")) {
+      if (filePath.startsWith(pattern) || filePath.includes(`/${pattern}`))
+        return true;
+    } else if (pattern.includes("*")) {
+      if (matchSimpleGlob(fileName, pattern)) return true;
+    } else if (filePath === pattern || fileName === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+var globCache = /* @__PURE__ */ new Map();
+function matchSimpleGlob(fileName, pattern) {
+  let regex = globCache.get(pattern);
+  if (!regex) {
+    regex = new RegExp(
+      `^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`
+    );
+    globCache.set(pattern, regex);
+  }
+  return regex.test(fileName);
+}
+function isSourceFile(filePath) {
+  return SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+function countDiffChanges(diff) {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+    else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+  }
+  return { additions, deletions };
+}
+function parseDiffIntoChunks(rawDiff, stagedFiles) {
+  const chunks = [];
+  const fileDiffs = rawDiff.split(/^diff --git /m).filter(Boolean);
+  for (const fileDiff of fileDiffs) {
+    const headerMatch = fileDiff.match(/^a\/(.+?) b\/(.+)/m);
+    if (!headerMatch) continue;
+    const oldPath = headerMatch[1];
+    const newPath = headerMatch[2];
+    const stagedFile = stagedFiles.find(
+      (f) => f.path === newPath || f.oldPath === oldPath
+    );
+    const { additions, deletions } = countDiffChanges(fileDiff);
+    chunks.push({
+      path: newPath,
+      status: stagedFile?.status || "M",
+      oldPath: stagedFile?.oldPath,
+      diff: `diff --git ${fileDiff}`,
+      additions,
+      deletions
+    });
+  }
+  return chunks;
+}
+function processDiff(rawDiff, stagedFiles, extraIgnorePaths = [], tokenBudget = DEFAULT_TOKEN_LIMIT) {
+  if (!rawDiff.trim()) {
+    return {
+      chunks: [],
+      summary: "No changes",
+      totalAdditions: 0,
+      totalDeletions: 0,
+      wasFiltered: false,
+      wasTruncated: false
+    };
+  }
+  let chunks = parseDiffIntoChunks(rawDiff, stagedFiles);
+  const totalChunksBefore = chunks.length;
+  chunks = chunks.filter(
+    (chunk) => !shouldIgnoreFile(chunk.path, extraIgnorePaths)
+  );
+  const wasFiltered = chunks.length < totalChunksBefore;
+  const totalAdditions = chunks.reduce((sum, c) => sum + c.additions, 0);
+  const totalDeletions = chunks.reduce((sum, c) => sum + c.deletions, 0);
+  const fullDiff = chunks.map((c) => c.diff).join("\n");
+  const totalTokens = estimateTokens(fullDiff);
+  const maxLines = getMaxLinesPerFile(tokenBudget);
+  let wasTruncated = false;
+  if (totalTokens > tokenBudget) {
+    wasTruncated = true;
+    chunks.sort((a, b) => {
+      const aIsSource = isSourceFile(a.path) ? 0 : 1;
+      const bIsSource = isSourceFile(b.path) ? 0 : 1;
+      if (aIsSource !== bIsSource) return aIsSource - bIsSource;
+      return a.diff.length - b.diff.length;
+    });
+    for (const chunk of chunks) {
+      const lines = chunk.diff.split("\n");
+      if (lines.length > maxLines) {
+        chunk.diff = truncateLines(chunk.diff, maxLines);
+      }
+    }
+    const truncatedDiff = chunks.map((c) => c.diff).join("\n");
+    if (estimateTokens(truncatedDiff) > tokenBudget) {
+      const sourceChunks = chunks.filter((c) => isSourceFile(c.path));
+      const otherChunks = chunks.filter((c) => !isSourceFile(c.path));
+      if (sourceChunks.length > 0) {
+        chunks = sourceChunks;
+        for (const chunk of chunks) {
+          chunk.diff = truncateLines(chunk.diff, maxLines);
+        }
+      }
+      if (otherChunks.length > 0) {
+        const otherSummary = otherChunks.map(
+          (c) => `  ${c.status === "R" ? `${c.oldPath} \u2192 ` : ""}${c.path} (+${c.additions} -${c.deletions})`
+        ).join("\n");
+        chunks.push({
+          path: "(other files summary)",
+          status: "S",
+          diff: `Other files:
+${otherSummary}`,
+          additions: otherChunks.reduce((s, c) => s + c.additions, 0),
+          deletions: otherChunks.reduce((s, c) => s + c.deletions, 0)
+        });
+      }
+    }
+  }
+  const summaryParts = chunks.filter((c) => c.status !== "S").map((c) => {
+    const prefix = c.status === "A" ? "new: " : c.status === "D" ? "deleted: " : c.status === "R" ? `renamed: ${c.oldPath} \u2192 ` : "";
+    return `${prefix}${c.path} (+${c.additions} -${c.deletions})`;
+  });
+  const summary = `${chunks.filter((c) => c.status !== "S").length} files changed, +${totalAdditions} -${totalDeletions}
+${summaryParts.join("\n")}`;
+  return {
+    chunks,
+    summary,
+    totalAdditions,
+    totalDeletions,
+    wasFiltered,
+    wasTruncated
+  };
+}
+function isInitialCommit(chunks) {
+  const realChunks = chunks.filter((c) => c.status !== "S");
+  return realChunks.length > 5 && realChunks.every((c) => c.status === "A");
+}
+function formatDiffForPrompt(processed) {
+  if (processed.chunks.length === 0) return "No changes staged.";
+  const parts = [];
+  parts.push(`Files: ${processed.summary}`);
+  if (processed.wasFiltered) {
+    parts.push("(Some auto-generated/lock files were excluded)");
+  }
+  if (processed.wasTruncated) {
+    parts.push("(Large diff was truncated to fit context window)");
+  }
+  if (isInitialCommit(processed.chunks)) {
+    parts.push("(Initial commit \u2014 full diff omitted, use file list above)");
+    return parts.join("\n\n");
+  }
+  parts.push("---");
+  for (const chunk of processed.chunks) {
+    parts.push(chunk.diff);
+  }
+  return parts.join("\n\n");
+}
+
+// src/git.ts
+async function isGitRepo() {
+  try {
+    await exec("git", ["rev-parse", "--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getStagedDiff(excludePaths = []) {
+  const args = ["diff", "--staged"];
+  for (const p of excludePaths) {
+    args.push(`:(exclude)${p}`);
+  }
+  const { stdout } = await exec("git", args);
+  return stdout;
+}
+async function getStagedFiles() {
+  const { stdout } = await exec("git", ["diff", "--staged", "--name-status"]);
+  if (!stdout.trim()) return [];
+  return stdout.trim().split("\n").map((line) => {
+    const parts = line.split("	");
+    const statusCode = parts[0];
+    if (statusCode.startsWith("R")) {
+      return {
+        status: "R",
+        path: parts[2],
+        oldPath: parts[1]
+      };
+    }
+    return {
+      status: statusCode,
+      path: parts[1]
+    };
+  });
+}
+async function getRecentCommits(n = 50) {
+  try {
+    const { stdout } = await exec("git", [
+      "log",
+      `-${n}`,
+      "--format=%H%x00%s%x00%an%x00%aI%x00%b%x1e"
+    ]);
+    if (!stdout.trim()) return [];
+    return stdout.split("").map((record) => record.trim()).filter(Boolean).map((record) => {
+      const [hash, message, author, date, ...bodyParts] = record.split("\0");
+      const body = bodyParts.join("\0").trim();
+      return { hash, message, author, date, body: body || void 0 };
+    });
+  } catch {
+    return [];
+  }
+}
+async function getBranchName() {
+  try {
+    const { stdout } = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+    return stdout.trim();
+  } catch {
+    return "HEAD";
+  }
+}
+async function createCommit(message) {
+  await exec("git", ["commit", "-m", message]);
+}
+async function getDiffStats() {
+  const { stdout } = await exec("git", ["diff", "--staged", "--shortstat"]);
+  const text = stdout.trim();
+  if (!text) {
+    return { filesChanged: 0, insertions: 0, deletions: 0 };
+  }
+  const filesMatch = text.match(/(\d+) file/);
+  const insertionsMatch = text.match(/(\d+) insertion/);
+  const deletionsMatch = text.match(/(\d+) deletion/);
+  return {
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+    deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0
+  };
+}
+async function getGitRootDir() {
+  const { stdout } = await exec("git", ["rev-parse", "--show-toplevel"]);
+  return stdout.trim();
+}
+async function getCommitsBetween(from, to = "HEAD") {
+  try {
+    const { stdout } = await exec("git", [
+      "log",
+      `${from}..${to}`,
+      "--format=%H%x00%s%x00%an%x00%aI"
+    ]);
+    if (!stdout.trim()) return [];
+    return stdout.trim().split("\n").map((line) => {
+      const [hash, message, author, date] = line.split("\0");
+      return { hash, message, author, date };
+    });
+  } catch {
+    throw new Error(
+      `Could not get commits between "${from}" and "${to}".
+Make sure both refs exist (tags, branches, or commit SHAs).`
+    );
+  }
+}
+async function getTags() {
+  try {
+    const { stdout } = await exec("git", [
+      "tag",
+      "--sort=-creatordate",
+      "--format=%(refname:short)%00%(objectname:short)%00%(creatordate:iso-strict)"
+    ]);
+    if (!stdout.trim()) return [];
+    return stdout.trim().split("\n").map((line) => {
+      const [name, hash, date] = line.split("\0");
+      return { name, hash, date };
+    });
+  } catch {
+    return [];
+  }
+}
+async function getLatestTag() {
+  try {
+    const { stdout } = await exec("git", ["describe", "--tags", "--abbrev=0"]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function getGitHooksDir() {
+  const { stdout } = await exec("git", ["rev-parse", "--git-path", "hooks"]);
+  return stdout.trim();
+}
+async function getLastCommitMessage() {
+  const { stdout } = await exec("git", ["log", "-1", "--format=%B"]);
+  return stdout.trim();
+}
+async function getLastCommitDiff(excludePaths = []) {
+  const args = ["diff", "HEAD~1", "HEAD"];
+  for (const p of excludePaths) {
+    args.push(`:(exclude)${p}`);
+  }
+  const { stdout } = await exec("git", args);
+  return stdout;
+}
+async function getLastCommitDiffStats() {
+  const { stdout } = await exec("git", [
+    "diff",
+    "HEAD~1",
+    "HEAD",
+    "--shortstat"
+  ]);
+  const text = stdout.trim();
+  if (!text) {
+    return { filesChanged: 0, insertions: 0, deletions: 0 };
+  }
+  const filesMatch = text.match(/(\d+) file/);
+  const insertionsMatch = text.match(/(\d+) insertion/);
+  const deletionsMatch = text.match(/(\d+) deletion/);
+  return {
+    filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+    insertions: insertionsMatch ? parseInt(insertionsMatch[1], 10) : 0,
+    deletions: deletionsMatch ? parseInt(deletionsMatch[1], 10) : 0
+  };
+}
+async function getLastCommitFiles() {
+  const { stdout } = await exec("git", [
+    "diff",
+    "HEAD~1",
+    "HEAD",
+    "--name-status"
+  ]);
+  if (!stdout.trim()) return [];
+  return stdout.trim().split("\n").map((line) => {
+    const parts = line.split("	");
+    const statusCode = parts[0];
+    if (statusCode.startsWith("R")) {
+      return {
+        status: "R",
+        path: parts[2],
+        oldPath: parts[1]
+      };
+    }
+    return {
+      status: statusCode,
+      path: parts[1]
+    };
+  });
+}
+async function amendCommit(message) {
+  await exec("git", ["commit", "--amend", "-m", message]);
+}
+
+// src/interactive.ts
+import { spawn } from "child_process";
+import { readFile as readFile2, unlink, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import chalk from "chalk";
+function promptSingleKey(options) {
+  return new Promise((resolve) => {
+    const line = chalk.dim("\u2500".repeat(40));
+    const labels = options.map((o) => o.color(o.label)).join("  ");
+    process.stdout.write(`
+${line}
+${labels}? `);
+    const keyMap = new Map(options.map((o) => [o.key.toLowerCase(), o.value]));
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    const onData = (data) => {
+      const key = data.toString().toLowerCase();
+      if (key === "c" || key === "" || key === "\x1B") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve("cancel");
+        return;
+      }
+      const value = keyMap.get(key);
+      if (value !== void 0) {
+        cleanup();
+        process.stdout.write(`${key}
+`);
+        resolve(value);
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(wasRaw ?? false);
+      }
+      stdin.pause();
+    };
+    stdin.on("data", onData);
+  });
+}
+async function promptAction() {
+  return promptSingleKey([
+    {
+      key: "a",
+      label: "[A]ccept",
+      color: chalk.green,
+      value: "accept"
+    },
+    { key: "e", label: "[E]dit", color: chalk.blue, value: "edit" },
+    {
+      key: "r",
+      label: "[R]egenerate",
+      color: chalk.yellow,
+      value: "regenerate"
+    },
+    { key: "c", label: "[C]ancel", color: chalk.red, value: "cancel" }
+  ]);
+}
+async function editMessage(message) {
+  const editorCmd = process.env.VISUAL || process.env.EDITOR || "vi";
+  const tmpFile = join2(tmpdir(), `ghostcommit-${Date.now()}.txt`);
+  try {
+    await writeFile(tmpFile, message, "utf-8");
+    const parts = editorCmd.split(/\s+/);
+    const bin = parts[0];
+    const args = [...parts.slice(1), tmpFile];
+    await new Promise((resolve, reject) => {
+      const child = spawn(bin, args, { stdio: "inherit" });
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Editor exited with code ${code}`));
+      });
+      child.on("error", reject);
+    });
+    const edited = await readFile2(tmpFile, "utf-8");
+    const trimmed = edited.trim();
+    if (!trimmed || trimmed === message.trim()) {
+      return null;
+    }
+    return trimmed;
+  } catch {
+    return null;
+  } finally {
+    try {
+      await unlink(tmpFile);
+    } catch {
+    }
+  }
+}
+function displayCommitMessage(message) {
+  console.log("");
+  const lines = message.split("\n");
+  console.log(chalk.bold.white(lines[0]));
+  if (lines.length > 1) {
+    for (const line of lines.slice(1)) {
+      console.log(chalk.gray(line));
+    }
+  }
+}
+function displayHeader(filesChanged, insertions, deletions) {
+  console.log(chalk.bold("\n\u{1F47B} ghostcommit\n"));
+  console.log(
+    chalk.dim(
+      `Analyzing ${filesChanged} file${filesChanged !== 1 ? "s" : ""} (+${insertions} -${deletions})...
+`
+    )
+  );
+}
+
+// src/prompt.ts
+var BASE_SYSTEM_PROMPT = `You are ghostcommit, an AI that writes git commit messages.
+
+RULES:
+- Follow Conventional Commits: <type>(<scope>): <description>
+- Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+- Imperative mood, lowercase subject, no period at end, max 72 chars for subject line
+- Focus on WHY, not just WHAT changed
+- If changes are significant, add a body after a blank line explaining the reasoning
+- Output ONLY the commit message, nothing else (no markdown, no quotes, no explanation)`;
+var LANGUAGE_NAMES = {
+  en: "English",
+  it: "Italian",
+  es: "Spanish",
+  fr: "French",
+  de: "German",
+  pt: "Portuguese",
+  ja: "Japanese",
+  ko: "Korean",
+  zh: "Chinese",
+  ru: "Russian"
+};
+function buildSystemPrompt(options) {
+  const parts = [BASE_SYSTEM_PROMPT];
+  if (options.language && options.language !== "en") {
+    const name = LANGUAGE_NAMES[options.language] || options.language;
+    parts.push("");
+    parts.push(`LANGUAGE: Write the commit message in ${name}.`);
+  }
+  if (options.styleContext) {
+    parts.push("");
+    parts.push(options.styleContext);
+  }
+  return parts.join("\n");
+}
+function buildUserPrompt(options) {
+  const parts = [];
+  if (options.branchName && options.branchName !== "HEAD") {
+    const ticket = extractTicketFromBranch(
+      options.branchName,
+      options.branchPattern
+    );
+    parts.push(`BRANCH: ${options.branchName}`);
+    if (ticket) {
+      parts.push(`\u2192 Include "${ticket}" reference if appropriate.`);
+    }
+    parts.push("");
+  }
+  if (options.userContext) {
+    parts.push("DEVELOPER CONTEXT (from --context flag):");
+    parts.push(options.userContext);
+    parts.push(
+      "\u2192 The developer provided this extra context about their changes. Use it to understand intent."
+    );
+    parts.push("");
+  }
+  parts.push("DIFF:");
+  parts.push(options.diff);
+  return parts.join("\n");
+}
+function estimatePromptOverhead(options) {
+  const systemPrompt = buildSystemPrompt({
+    styleContext: options.styleContext,
+    language: options.language
+  });
+  const userPrompt = buildUserPrompt({
+    diff: "",
+    branchName: options.branchName,
+    branchPattern: options.branchPattern,
+    userContext: options.userContext
+  });
+  return estimateTokens(systemPrompt) + estimateTokens(userPrompt);
+}
+
+// src/style-learner.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+var EMOJI_REGEX = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|:\w+:/u;
+var COMMON_ENGLISH_WORDS = [
+  "add",
+  "fix",
+  "update",
+  "remove",
+  "change",
+  "implement",
+  "create",
+  "delete",
+  "move",
+  "rename",
+  "refactor",
+  "improve",
+  "support",
+  "handle",
+  "use",
+  "set",
+  "merge",
+  "release",
+  "bump",
+  "init"
+];
+var COMMON_ITALIAN_WORDS = [
+  "aggiungi",
+  "aggiorna",
+  "correggi",
+  "rimuovi",
+  "modifica",
+  "implementa",
+  "crea",
+  "elimina",
+  "sposta",
+  "rinomina",
+  "migliora",
+  "gestisci",
+  "usa",
+  "imposta"
+];
+function analyzeCommits(commits) {
+  if (commits.length === 0) {
+    return {
+      usesConventionalCommits: false,
+      conventionalCommitRatio: 0,
+      usesScope: false,
+      commonScopes: [],
+      language: "unknown",
+      averageSubjectLength: 0,
+      usesBody: false,
+      bodyRatio: 0,
+      usesEmoji: false,
+      emojiRatio: 0,
+      usesLowercase: true,
+      ticketPattern: null,
+      commitCount: 0
+    };
+  }
+  let conventionalCount = 0;
+  let scopeCount = 0;
+  let emojiCount = 0;
+  let lowercaseCount = 0;
+  let bodyCount = 0;
+  let totalLength = 0;
+  const scopes = {};
+  let englishScore = 0;
+  let italianScore = 0;
+  const ticketPatterns = {};
+  for (const commit of commits) {
+    const msg = commit.message;
+    totalLength += msg.length;
+    if (commit.body) {
+      bodyCount++;
+    }
+    const ccMatch = msg.match(
+      /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(([^)]+)\))?(!)?:/
+    );
+    if (ccMatch) {
+      conventionalCount++;
+      if (ccMatch[3]) {
+        scopeCount++;
+        const scope = ccMatch[3];
+        scopes[scope] = (scopes[scope] || 0) + 1;
+      }
+    }
+    if (EMOJI_REGEX.test(msg)) {
+      emojiCount++;
+    }
+    const subjectMatch = msg.match(/^(?:\w+(?:\([^)]*\))?:\s*)(.*)/);
+    const subject = subjectMatch ? subjectMatch[1] : msg;
+    if (subject && subject[0] === subject[0].toLowerCase()) {
+      lowercaseCount++;
+    }
+    const words = msg.toLowerCase().split(/\s+/);
+    for (const word of words) {
+      if (COMMON_ENGLISH_WORDS.includes(word)) englishScore++;
+      if (COMMON_ITALIAN_WORDS.includes(word)) italianScore++;
+    }
+    const ticketMatch = msg.match(/([A-Z]+-\d+)|#(\d+)|(?:refs?\s+#?\d+)/i);
+    if (ticketMatch) {
+      const pattern = ticketMatch[0].replace(/\d+/g, "N");
+      ticketPatterns[pattern] = (ticketPatterns[pattern] || 0) + 1;
+    }
+  }
+  const n = commits.length;
+  const conventionalRatio = conventionalCount / n;
+  const scopeRatio = scopeCount / n;
+  const commonScopes = Object.entries(scopes).filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 8).map(([scope]) => scope);
+  let language = "unknown";
+  if (englishScore > 0 || italianScore > 0) {
+    if (englishScore > italianScore * 2) language = "english";
+    else if (italianScore > englishScore * 2) language = "italian";
+    else if (englishScore > 0 && italianScore > 0) language = "mixed";
+    else language = englishScore > 0 ? "english" : "italian";
+  }
+  const topTicketPattern = Object.entries(ticketPatterns).sort((a, b) => b[1] - a[1]).find(([, count]) => count >= 3);
+  return {
+    usesConventionalCommits: conventionalRatio > 0.5,
+    conventionalCommitRatio: conventionalRatio,
+    usesScope: scopeRatio > 0.3,
+    commonScopes,
+    language,
+    averageSubjectLength: Math.round(totalLength / n),
+    usesBody: bodyCount / n > 0.2,
+    bodyRatio: bodyCount / n,
+    usesEmoji: emojiCount / n > 0.2,
+    emojiRatio: emojiCount / n,
+    usesLowercase: lowercaseCount / n > 0.7,
+    ticketPattern: topTicketPattern ? topTicketPattern[0] : null,
+    commitCount: n
+  };
+}
+function buildStyleContext(analysis) {
+  if (analysis.commitCount === 0) return "";
+  const lines = ["STYLE GUIDE (from repo history):"];
+  if (analysis.usesConventionalCommits) {
+    if (analysis.usesScope) {
+      lines.push("- Format: conventional commits with scope");
+    } else {
+      lines.push("- Format: conventional commits (no scope)");
+    }
+  } else {
+    lines.push("- Format: freeform (no conventional commits pattern)");
+  }
+  if (analysis.commonScopes.length > 0) {
+    lines.push(`- Common scopes: ${analysis.commonScopes.join(", ")}`);
+  }
+  if (analysis.language !== "unknown") {
+    const languageMap = {
+      english: "English",
+      italian: "Italian",
+      mixed: "Mixed (English/Italian)"
+    };
+    lines.push(`- Language: ${languageMap[analysis.language]}`);
+  }
+  lines.push(
+    `- Average subject length: ${analysis.averageSubjectLength} chars`
+  );
+  if (analysis.bodyRatio > 0) {
+    lines.push(
+      `- Body: used in ${Math.round(analysis.bodyRatio * 100)}% of commits`
+    );
+  }
+  if (analysis.usesEmoji) {
+    lines.push("- Uses emoji/gitmoji in commit messages");
+  }
+  if (analysis.usesLowercase) {
+    lines.push("- Subject starts with lowercase");
+  }
+  if (analysis.ticketPattern) {
+    lines.push(`- Pattern: ticket reference "${analysis.ticketPattern}"`);
+  }
+  return lines.join("\n");
+}
+async function loadCache(cacheFile) {
+  try {
+    const content = await readFile3(cacheFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveCache(cacheFile, data) {
+  await writeFile2(cacheFile, JSON.stringify(data, null, 2));
+}
+async function learnStyle(n = 50) {
+  let gitRoot;
+  try {
+    gitRoot = await getGitRootDir();
+  } catch {
+    return { styleContext: "", analysis: analyzeCommits([]) };
+  }
+  const cacheFile = join3(gitRoot, ".ghostcommit-cache.json");
+  const commits = await getRecentCommits(n);
+  if (commits.length === 0) {
+    return { styleContext: "", analysis: analyzeCommits([]) };
+  }
+  const cache = await loadCache(cacheFile);
+  if (cache && cache.lastCommitHash === commits[0].hash && cache.commitCount === commits.length) {
+    return { styleContext: cache.styleContext, analysis: cache.analysis };
+  }
+  const analysis = analyzeCommits(commits);
+  const styleContext = buildStyleContext(analysis);
+  try {
+    await saveCache(cacheFile, {
+      styleContext,
+      analysis,
+      lastCommitHash: commits[0].hash,
+      commitCount: commits.length,
+      timestamp: Date.now()
+    });
+  } catch {
+  }
+  return { styleContext, analysis };
+}
+
+// src/commands/amend.ts
+async function runAmend(options) {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  let currentMessage;
+  try {
+    currentMessage = await getLastCommitMessage();
+  } catch {
+    throw new Error(
+      "No commits found. Make a commit first before using amend."
+    );
+  }
+  if (!currentMessage) {
+    throw new Error(
+      "No commits found. Make a commit first before using amend."
+    );
+  }
+  let projectRoot;
+  try {
+    projectRoot = await getGitRootDir();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  const cliFlags = {
+    provider: options.provider,
+    model: options.model,
+    context: options.context,
+    yes: options.yes,
+    dryRun: options.dryRun,
+    noStyle: options.style === false
+  };
+  const config = await loadConfig(projectRoot, cliFlags);
+  console.log(chalk2.bold("\n\u{1F47B} ghostcommit amend\n"));
+  console.log(chalk2.dim("Current message:"));
+  console.log(chalk2.yellow(currentMessage));
+  console.log("");
+  const stats = await getLastCommitDiffStats();
+  console.log(
+    chalk2.dim(
+      `Analyzing ${stats.filesChanged} file${stats.filesChanged !== 1 ? "s" : ""} (+${stats.insertions} -${stats.deletions})...
+`
+    )
+  );
+  const gitExcludes = [
+    ...DEFAULT_IGNORE_PATTERNS,
+    ...DEFAULT_IGNORE_DIRS,
+    ...config.ignorePaths
+  ];
+  const rawDiff = await getLastCommitDiff(gitExcludes);
+  const lastCommitFiles = await getLastCommitFiles();
+  let styleContext = "";
+  if (config.learnStyle) {
+    const style = await learnStyle(config.learnStyleCommits);
+    styleContext = style.styleContext;
+  }
+  const branchName = config.branchPrefix ? await getBranchName() : void 0;
+  const provider = await resolveProvider(config.provider, config.model);
+  console.log(chalk2.dim(`Using ${provider.name}...
+`));
+  const providerBudget = config.tokenBudget ?? provider.getTokenBudget();
+  const promptOverhead = estimatePromptOverhead({
+    styleContext,
+    language: config.language,
+    branchName,
+    branchPattern: config.branchPattern,
+    userContext: options.context
+  });
+  const RESPONSE_RESERVE = 500;
+  let done = false;
+  while (!done) {
+    let message;
+    const MAX_RETRIES = 3;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const diffBudget = Math.max(
+        500,
+        Math.floor(
+          (providerBudget - promptOverhead - RESPONSE_RESERVE) / 2 ** attempt
+        )
+      );
+      if (attempt > 0) {
+        console.log(
+          chalk2.yellow(
+            `Retrying with compressed diff (budget: ${diffBudget} tokens)...
+`
+          )
+        );
+      }
+      const processed = processDiff(
+        rawDiff,
+        lastCommitFiles,
+        config.ignorePaths,
+        diffBudget
+      );
+      const formattedDiff = formatDiffForPrompt(processed);
+      const systemPrompt = buildSystemPrompt({
+        styleContext,
+        language: config.language
+      });
+      const userPrompt = buildUserPrompt({
+        diff: formattedDiff,
+        styleContext,
+        branchName,
+        branchPattern: config.branchPattern,
+        userContext: options.context
+      });
+      try {
+        message = await generateCommitMessage(
+          provider,
+          userPrompt,
+          systemPrompt,
+          !options.yes
+        );
+        break;
+      } catch (error) {
+        if (isTokenLimitError(error) && attempt < MAX_RETRIES - 1) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (!message) {
+      throw new Error("AI returned an empty commit message. Try again.");
+    }
+    if (options.dryRun) {
+      if (!process.stdout.isTTY || options.yes) {
+        displayCommitMessage(message);
+      }
+      done = true;
+      continue;
+    }
+    if (options.yes) {
+      console.log(chalk2.dim(message));
+      await amendCommit(message);
+      console.log(chalk2.green("\nCommit amended."));
+      done = true;
+      continue;
+    }
+    if (!process.stdout.isTTY) {
+      await amendCommit(message);
+      done = true;
+      continue;
+    }
+    const action = await promptAction();
+    switch (action) {
+      case "accept":
+        await amendCommit(message);
+        console.log(chalk2.green("\nCommit amended."));
+        done = true;
+        break;
+      case "edit": {
+        const edited = await editMessage(message);
+        if (edited) {
+          await amendCommit(edited);
+          console.log(chalk2.green("\nCommit amended."));
+        } else {
+          console.log(chalk2.yellow("No changes made. Amend cancelled."));
+          process.exit(2);
+        }
+        done = true;
+        break;
+      }
+      case "regenerate":
+        console.log(chalk2.dim("\nRegenerating...\n"));
+        break;
+      case "cancel":
+        console.log(chalk2.yellow("\nAmend cancelled."));
+        process.exit(2);
+    }
+  }
+}
+
+// src/commands/commit.ts
+import chalk3 from "chalk";
+async function runCommit(options) {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  const stagedFiles = await getStagedFiles();
+  if (stagedFiles.length === 0) {
+    throw new Error(
+      "No staged changes. Stage your changes first:\n  git add <files>"
+    );
+  }
+  let projectRoot;
+  try {
+    projectRoot = await getGitRootDir();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  const cliFlags = {
+    provider: options.provider,
+    model: options.model,
+    context: options.context,
+    yes: options.yes,
+    dryRun: options.dryRun,
+    noStyle: options.style === false
+  };
+  const config = await loadConfig(projectRoot, cliFlags);
+  const stats = await getDiffStats();
+  displayHeader(stats.filesChanged, stats.insertions, stats.deletions);
+  const gitExcludes = [
+    ...DEFAULT_IGNORE_PATTERNS,
+    ...DEFAULT_IGNORE_DIRS,
+    ...config.ignorePaths
+  ];
+  const rawDiff = await getStagedDiff(gitExcludes);
+  let styleContext = "";
+  if (config.learnStyle) {
+    const style = await learnStyle(config.learnStyleCommits);
+    styleContext = style.styleContext;
+  }
+  const branchName = config.branchPrefix ? await getBranchName() : void 0;
+  const provider = await resolveProvider(config.provider, config.model);
+  console.log(chalk3.dim(`Using ${provider.name}...
+`));
+  const providerBudget = config.tokenBudget ?? provider.getTokenBudget();
+  const promptOverhead = estimatePromptOverhead({
+    styleContext,
+    language: config.language,
+    branchName,
+    branchPattern: config.branchPattern,
+    userContext: options.context
+  });
+  const RESPONSE_RESERVE = 500;
+  let done = false;
+  while (!done) {
+    let message;
+    const MAX_RETRIES = 3;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const diffBudget = Math.max(
+        500,
+        Math.floor(
+          (providerBudget - promptOverhead - RESPONSE_RESERVE) / 2 ** attempt
+        )
+      );
+      if (attempt > 0) {
+        console.log(
+          chalk3.yellow(
+            `Retrying with compressed diff (budget: ${diffBudget} tokens)...
+`
+          )
+        );
+      }
+      const processed = processDiff(
+        rawDiff,
+        stagedFiles,
+        config.ignorePaths,
+        diffBudget
+      );
+      const formattedDiff = formatDiffForPrompt(processed);
+      const systemPrompt = buildSystemPrompt({
+        styleContext,
+        language: config.language
+      });
+      const userPrompt = buildUserPrompt({
+        diff: formattedDiff,
+        styleContext,
+        branchName,
+        branchPattern: config.branchPattern,
+        userContext: options.context
+      });
+      try {
+        message = await generateCommitMessage(
+          provider,
+          userPrompt,
+          systemPrompt,
+          !options.yes
+          // stream only in interactive mode
+        );
+        break;
+      } catch (error) {
+        if (isTokenLimitError(error) && attempt < MAX_RETRIES - 1) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (!message) {
+      throw new Error("AI returned an empty commit message. Try again.");
+    }
+    if (options.dryRun) {
+      if (!process.stdout.isTTY || options.yes) {
+        displayCommitMessage(message);
+      }
+      done = true;
+      continue;
+    }
+    if (options.yes) {
+      console.log(chalk3.dim(message));
+      await createCommit(message);
+      console.log(chalk3.green("\nCommit created."));
+      done = true;
+      continue;
+    }
+    if (!process.stdout.isTTY) {
+      await createCommit(message);
+      done = true;
+      continue;
+    }
+    const action = await promptAction();
+    switch (action) {
+      case "accept":
+        await createCommit(message);
+        console.log(chalk3.green("\nCommit created."));
+        done = true;
+        break;
+      case "edit": {
+        const edited = await editMessage(message);
+        if (edited) {
+          await createCommit(edited);
+          console.log(chalk3.green("\nCommit created."));
+        } else {
+          console.log(chalk3.yellow("No changes made. Commit cancelled."));
+          process.exit(2);
+        }
+        done = true;
+        break;
+      }
+      case "regenerate":
+        console.log(chalk3.dim("\nRegenerating...\n"));
+        break;
+      case "cancel":
+        console.log(chalk3.yellow("\nCommit cancelled."));
+        process.exit(2);
+    }
+  }
+}
+
+// src/commands/hook.ts
+import { chmod, readFile as readFile4, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+import chalk4 from "chalk";
+var HOOK_MARKER = "# ghostcommit-hook";
+var HOOK_SCRIPT = `#!/bin/sh
+${HOOK_MARKER} \u2014 auto-generated, do not edit
+ghostcommit hook run "$1" "$2" 2>/dev/null || true
+`;
+async function runHookInstall() {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  const hooksDir = await getGitHooksDir();
+  const hookPath = join4(hooksDir, "prepare-commit-msg");
+  await writeFile3(hookPath, HOOK_SCRIPT, "utf-8");
+  await chmod(hookPath, 493);
+  console.log(chalk4.green("Installed prepare-commit-msg hook."));
+  console.log(
+    chalk4.dim(
+      "ghostcommit will auto-generate messages when you run git commit."
+    )
+  );
+}
+async function runHookUninstall() {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  const hooksDir = await getGitHooksDir();
+  const hookPath = join4(hooksDir, "prepare-commit-msg");
+  let content;
+  try {
+    content = await readFile4(hookPath, "utf-8");
+  } catch {
+    throw new Error("No prepare-commit-msg hook found.");
+  }
+  if (!content.includes(HOOK_MARKER)) {
+    throw new Error(
+      "The prepare-commit-msg hook was not created by ghostcommit. Refusing to remove it."
+    );
+  }
+  await unlink2(hookPath);
+  console.log(chalk4.green("Removed prepare-commit-msg hook."));
+}
+async function runHookRun(msgFile, source) {
+  if (source === "message" || source === "merge" || source === "squash") {
+    return;
+  }
+  const stagedFiles = await getStagedFiles();
+  if (stagedFiles.length === 0) {
+    return;
+  }
+  let projectRoot;
+  try {
+    projectRoot = await getGitRootDir();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  const cliFlags = {};
+  const config = await loadConfig(projectRoot, cliFlags);
+  const gitExcludes = [
+    ...DEFAULT_IGNORE_PATTERNS,
+    ...DEFAULT_IGNORE_DIRS,
+    ...config.ignorePaths
+  ];
+  const rawDiff = await getStagedDiff(gitExcludes);
+  let styleContext = "";
+  if (config.learnStyle) {
+    const style = await learnStyle(config.learnStyleCommits);
+    styleContext = style.styleContext;
+  }
+  const branchName = config.branchPrefix ? await getBranchName() : void 0;
+  const provider = await resolveProvider(config.provider, config.model);
+  const providerBudget = config.tokenBudget ?? provider.getTokenBudget();
+  const promptOverhead = estimatePromptOverhead({
+    styleContext,
+    language: config.language,
+    branchName,
+    branchPattern: config.branchPattern
+  });
+  const RESPONSE_RESERVE = 500;
+  const MAX_RETRIES = 3;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    const diffBudget = Math.max(
+      500,
+      Math.floor(
+        (providerBudget - promptOverhead - RESPONSE_RESERVE) / 2 ** attempt
+      )
+    );
+    const processed = processDiff(
+      rawDiff,
+      stagedFiles,
+      config.ignorePaths,
+      diffBudget
+    );
+    const formattedDiff = formatDiffForPrompt(processed);
+    const systemPrompt = buildSystemPrompt({
+      styleContext,
+      language: config.language
+    });
+    const userPrompt = buildUserPrompt({
+      diff: formattedDiff,
+      styleContext,
+      branchName,
+      branchPattern: config.branchPattern
+    });
+    try {
+      const message = await generateCommitMessage(
+        provider,
+        userPrompt,
+        systemPrompt,
+        false
+        // no streaming in hook mode
+      );
+      if (message) {
+        await writeFile3(msgFile, message, "utf-8");
+      }
+      return;
+    } catch (error) {
+      if (isTokenLimitError(error) && attempt < MAX_RETRIES - 1) {
+        continue;
+      }
+      return;
+    }
+  }
+}
+
+// src/commands/log.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import chalk5 from "chalk";
+
+// src/changelog/formatter.ts
+function formatPRRef(prNumber) {
+  if (prNumber == null) return "";
+  return ` (#${prNumber})`;
+}
+function formatCommitLine(item) {
+  return `- ${item.summary}${formatPRRef(item.commit.prNumber)}`;
+}
+function formatMarkdown(categorized, options) {
+  const version = options.version || "Unreleased";
+  const date = options.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const categoryOrder = options.categories || ALL_CATEGORIES;
+  const grouped = groupByCategory(categorized);
+  const lines = [];
+  lines.push(`## [${version}] - ${date}`);
+  lines.push("");
+  for (const category of categoryOrder) {
+    const items = grouped.get(category);
+    if (!items || items.length === 0) continue;
+    lines.push(`### ${category}`);
+    for (const item of items) {
+      lines.push(formatCommitLine(item));
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatJSON(categorized, options) {
+  const version = options.version || "Unreleased";
+  const date = options.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const grouped = groupByCategory(categorized);
+  const categories = {};
+  for (const [category, items] of grouped) {
+    categories[category] = items.map((item) => ({
+      summary: item.summary,
+      hash: item.commit.hash,
+      author: item.commit.author,
+      prNumber: item.commit.prNumber,
+      breaking: item.commit.breaking
+    }));
+  }
+  const output = { version, date, categories };
+  return `${JSON.stringify(output, null, 2)}
+`;
+}
+function formatPlain(categorized, options) {
+  const version = options.version || "Unreleased";
+  const date = options.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const categoryOrder = options.categories || ALL_CATEGORIES;
+  const grouped = groupByCategory(categorized);
+  const lines = [];
+  lines.push(`${version} (${date})`);
+  lines.push("=".repeat(lines[0].length));
+  lines.push("");
+  for (const category of categoryOrder) {
+    const items = grouped.get(category);
+    if (!items || items.length === 0) continue;
+    lines.push(`${category}:`);
+    for (const item of items) {
+      const prRef = item.commit.prNumber ? ` (#${item.commit.prNumber})` : "";
+      lines.push(`  * ${item.summary}${prRef}`);
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatChangelog(categorized, options) {
+  switch (options.format) {
+    case "markdown":
+      return formatMarkdown(categorized, options);
+    case "json":
+      return formatJSON(categorized, options);
+    case "plain":
+      return formatPlain(categorized, options);
+    default:
+      return formatMarkdown(categorized, options);
+  }
+}
+
+// src/changelog/parser.ts
+var CONVENTIONAL_COMMIT_RE = /^(?<type>feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(?:\((?<scope>[^)]+)\))?(?<breaking>!)?:\s+(?<description>.+)$/;
+var PR_NUMBER_RE = /\(#(\d+)\)\s*$/;
+function parseCommit(commit) {
+  const { hash, message, author, date } = commit;
+  const prMatch = message.match(PR_NUMBER_RE);
+  const prNumber = prMatch ? parseInt(prMatch[1], 10) : void 0;
+  const ccMatch = message.match(CONVENTIONAL_COMMIT_RE);
+  if (ccMatch?.groups) {
+    const { type, scope, breaking, description } = ccMatch.groups;
+    return {
+      hash,
+      date,
+      author,
+      message,
+      type,
+      scope,
+      description,
+      breaking: !!breaking,
+      prNumber
+    };
+  }
+  const isBreaking = message.toUpperCase().includes("BREAKING CHANGE") || message.toUpperCase().includes("BREAKING:");
+  return {
+    hash,
+    date,
+    author,
+    message,
+    description: message,
+    breaking: isBreaking,
+    prNumber
+  };
+}
+function parseCommits(commits) {
+  return commits.map(parseCommit);
+}
+
+// src/commands/log.ts
+async function promptLogAction(outputFile) {
+  return promptSingleKey([
+    {
+      key: "a",
+      label: "[A]ccept",
+      color: chalk5.green,
+      value: "accept"
+    },
+    {
+      key: "w",
+      label: `[W]rite to ${outputFile}`,
+      color: chalk5.blue,
+      value: "write"
+    },
+    { key: "e", label: "[E]dit", color: chalk5.yellow, value: "edit" },
+    { key: "c", label: "[C]ancel", color: chalk5.red, value: "cancel" }
+  ]);
+}
+async function runLog(options) {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  const fromRef = options.from || await getLatestTag();
+  if (!fromRef) {
+    throw new Error(
+      "No tags found and no --from specified.\nCreate a tag first (git tag v0.1.0) or specify --from <ref>."
+    );
+  }
+  const toRef = options.to || "HEAD";
+  console.log(chalk5.bold("\n\u{1F47B} ghostcommit log\n"));
+  console.log(chalk5.dim(`Generating changelog for ${fromRef}...${toRef}`));
+  const commits = await getCommitsBetween(fromRef, toRef);
+  if (commits.length === 0) {
+    console.log(chalk5.yellow("No commits found in the specified range."));
+    return;
+  }
+  console.log(chalk5.dim(`Analyzing ${commits.length} commits...
+`));
+  const parsed = parseCommits(commits);
+  let projectRoot;
+  try {
+    projectRoot = await getGitRootDir();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  const config = await loadConfig(projectRoot, {
+    provider: options.provider,
+    model: options.model
+  });
+  const needsAI = parsed.some((c) => !c.type);
+  let provider;
+  if (needsAI) {
+    try {
+      provider = await resolveProvider(config.provider, config.model);
+      console.log(
+        chalk5.dim(
+          `Some commits need AI categorization, using ${provider.name}...`
+        )
+      );
+    } catch {
+      console.log(
+        chalk5.dim(
+          "No AI provider available. Non-conventional commits will be categorized as Chore."
+        )
+      );
+    }
+  }
+  const categorized = await categorizeCommits(parsed, {
+    provider,
+    excludePatterns: config.changelog.exclude
+  });
+  const format = options.format || config.changelog.format;
+  const outputFile = options.output || config.changelog.output;
+  const changelog = formatChangelog(categorized, {
+    format,
+    version: toRef === "HEAD" ? void 0 : toRef,
+    categories: config.changelog.categories
+  });
+  console.log(changelog);
+  if (options.dryRun) {
+    return;
+  }
+  if (!process.stdout.isTTY) {
+    return;
+  }
+  const action = await promptLogAction(outputFile);
+  switch (action) {
+    case "accept":
+      console.log(chalk5.green("Changelog generated."));
+      break;
+    case "write":
+      await writeFile4(outputFile, changelog, "utf-8");
+      console.log(chalk5.green(`
+Changelog written to ${outputFile}`));
+      break;
+    case "edit": {
+      const edited = await editMessage(changelog);
+      if (edited) {
+        await writeFile4(outputFile, edited, "utf-8");
+        console.log(chalk5.green(`
+Edited changelog written to ${outputFile}`));
+      } else {
+        console.log(chalk5.yellow("No changes made."));
+      }
+      break;
+    }
+    case "cancel":
+      console.log(chalk5.yellow("\nCancelled."));
+      process.exit(2);
+  }
+}
+
+// src/commands/release.ts
+import chalk6 from "chalk";
+
+// src/github.ts
+import { Octokit } from "@octokit/rest";
+function getOctokit() {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GITHUB_TOKEN environment variable is required for GitHub operations.\nCreate a token at https://github.com/settings/tokens"
+    );
+  }
+  return new Octokit({ auth: token });
+}
+async function getRepoInfo() {
+  const { stdout } = await exec("git", ["remote", "get-url", "origin"]);
+  const url = stdout.trim();
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = url.match(
+    /https?:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/
+  );
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  throw new Error(
+    `Could not parse GitHub remote URL: ${url}
+Expected a github.com remote.`
+  );
+}
+async function createRelease(options) {
+  const octokit = getOctokit();
+  const response = await octokit.repos.createRelease({
+    owner: options.owner,
+    repo: options.repo,
+    tag_name: options.tag,
+    name: options.title,
+    body: options.body,
+    draft: options.draft ?? false
+  });
+  return response.data.html_url;
+}
+function isGitHubTokenAvailable() {
+  return !!process.env.GITHUB_TOKEN;
+}
+
+// src/commands/release.ts
+async function promptReleaseAction() {
+  return promptSingleKey([
+    {
+      key: "p",
+      label: "[P]ublish release",
+      color: chalk6.green,
+      value: "publish"
+    },
+    { key: "c", label: "[C]ancel", color: chalk6.red, value: "cancel" }
+  ]);
+}
+async function runRelease(options) {
+  if (!await isGitRepo()) {
+    throw new Error(
+      "Not a git repository. Run this command from inside a git repo."
+    );
+  }
+  if (!isGitHubTokenAvailable()) {
+    throw new Error(
+      "GITHUB_TOKEN environment variable is required for creating releases.\nCreate a token at https://github.com/settings/tokens"
+    );
+  }
+  const targetTag = options.tag || await getLatestTag();
+  if (!targetTag) {
+    throw new Error(
+      "No tags found and no --tag specified.\nCreate a tag first (git tag v1.0.0) or specify --tag <tag>."
+    );
+  }
+  const tags = await getTags();
+  const tagIndex = tags.findIndex((t) => t.name === targetTag);
+  const previousTag = tagIndex >= 0 && tags.length > tagIndex + 1 ? tags[tagIndex + 1].name : null;
+  if (!previousTag) {
+    throw new Error(
+      `No previous tag found before ${targetTag}. Need at least two tags for a release.
+Specify the range manually with: ghostcommit log --from <ref> --to <ref>`
+    );
+  }
+  console.log(chalk6.bold("\n\u{1F47B} ghostcommit release\n"));
+  console.log(
+    chalk6.dim(
+      `Creating release for ${targetTag} (${previousTag}...${targetTag})`
+    )
+  );
+  const commits = await getCommitsBetween(previousTag, targetTag);
+  if (commits.length === 0) {
+    console.log(chalk6.yellow("No commits found in the specified range."));
+    return;
+  }
+  console.log(chalk6.dim(`Analyzing ${commits.length} commits...
+`));
+  const parsed = parseCommits(commits);
+  let projectRoot;
+  try {
+    projectRoot = await getGitRootDir();
+  } catch {
+    projectRoot = process.cwd();
+  }
+  const config = await loadConfig(projectRoot, {
+    provider: options.provider,
+    model: options.model
+  });
+  const needsAI = parsed.some((c) => !c.type);
+  let provider;
+  if (needsAI) {
+    try {
+      provider = await resolveProvider(config.provider, config.model);
+    } catch {
+    }
+  }
+  const categorized = await categorizeCommits(parsed, {
+    provider,
+    excludePatterns: config.changelog.exclude
+  });
+  const body = formatChangelog(categorized, {
+    format: "markdown",
+    version: targetTag,
+    categories: config.changelog.categories
+  });
+  console.log(body);
+  const isDraft = options.draft ?? config.release.draft;
+  const draftLabel = isDraft ? " (draft)" : "";
+  console.log(chalk6.dim(`Release: ${targetTag}${draftLabel}`));
+  if (process.stdout.isTTY) {
+    const action = await promptReleaseAction();
+    if (action === "cancel") {
+      console.log(chalk6.yellow("\nRelease cancelled."));
+      process.exit(2);
+    }
+  }
+  const { owner, repo } = await getRepoInfo();
+  console.log(chalk6.dim("\nCreating GitHub release..."));
+  const releaseUrl = await createRelease({
+    owner,
+    repo,
+    tag: targetTag,
+    title: targetTag,
+    body,
+    draft: isDraft
+  });
+  console.log(chalk6.green(`
+Release created: ${releaseUrl}`));
+}
+
+// src/cli.ts
+async function getVersion() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    for (const base of [__dirname, join5(__dirname, "..")]) {
+      try {
+        const pkg = JSON.parse(
+          await readFile5(join5(base, "package.json"), "utf-8")
+        );
+        return pkg.version || "0.0.0";
+      } catch {
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function wrapAction(fn) {
+  return async (opts) => {
+    try {
+      await fn(opts);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(chalk7.red(`Error: ${msg}`));
+      process.exit(1);
+    }
+  };
+}
+function createCLI() {
+  const program = new Command();
+  program.name("ghostcommit").description("Your commits, ghostwritten by AI").option("-c, --context <text>", "extra context to guide the AI").option(
+    "-p, --provider <name>",
+    "AI provider (groq, ollama, gemini, openai, anthropic)"
+  ).option("-m, --model <name>", "model to use").option("-y, --yes", "auto-accept without interactive prompt").option("--dry-run", "show message without committing").option("--no-style", "disable style learning from repo history").action(
+    wrapAction(async (options) => {
+      await runCommit(options);
+    })
+  );
+  program.command("log").description("generate a changelog from commit history").option("--from <ref>", "start ref (default: latest tag)").option("--to <ref>", "end ref (default: HEAD)").option("-o, --output <file>", "output file path").option("-f, --format <format>", "output format: markdown, json, plain").option("--dry-run", "preview changelog without writing").option(
+    "-p, --provider <name>",
+    "AI provider for categorizing non-conventional commits"
+  ).option("-m, --model <name>", "model to use").action(
+    wrapAction(async (options) => {
+      await runLog(options);
+    })
+  );
+  program.command("release").description("create a GitHub Release with generated changelog").option(
+    "-t, --tag <tag>",
+    "tag to create release for (default: latest tag)"
+  ).option("--draft", "create as draft release").option(
+    "-p, --provider <name>",
+    "AI provider for categorizing non-conventional commits"
+  ).option("-m, --model <name>", "model to use").action(
+    wrapAction(async (options) => {
+      await runRelease(options);
+    })
+  );
+  program.command("amend").description("regenerate the last commit message with AI").option("-c, --context <text>", "extra context to guide the AI").option(
+    "-p, --provider <name>",
+    "AI provider (groq, ollama, gemini, openai, anthropic)"
+  ).option("-m, --model <name>", "model to use").option("-y, --yes", "auto-accept without interactive prompt").option("--dry-run", "show message without amending").option("--no-style", "disable style learning from repo history").action(
+    wrapAction(async (options) => {
+      await runAmend(options);
+    })
+  );
+  const hookCmd = program.command("hook").description("manage git hook for auto-generating commit messages");
+  hookCmd.command("install").description("install the prepare-commit-msg git hook").action(
+    wrapAction(async () => {
+      await runHookInstall();
+    })
+  );
+  hookCmd.command("uninstall").description("remove the prepare-commit-msg git hook").action(
+    wrapAction(async () => {
+      await runHookUninstall();
+    })
+  );
+  hookCmd.command("run").description("(internal) called by the git hook").argument("<msgFile>", "commit message file path").argument("[source]", "commit source (message, merge, squash, etc.)").action(async (msgFile, source) => {
+    try {
+      await runHookRun(msgFile, source);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(chalk7.red(`Error: ${msg}`));
+      process.exit(1);
+    }
+  });
+  program.command("init").description("create a .ghostcommit.yml config file").action(
+    wrapAction(async () => {
+      await initConfig();
+    })
+  );
+  return program;
+}
+async function initConfig() {
+  const template = `# ghostcommit configuration
+# See https://github.com/Alessandro-Mac7/ghostcommit for docs
+
+# AI provider (auto-detects: groq \u2192 ollama if not set)
+# Available: groq, ollama, gemini, openai, anthropic
+# provider: groq
+
+# Model override (uses provider default if not set)
+# model: llama-3.3-70b-versatile
+
+# Language for commit messages (en, it, etc.)
+# language: en
+
+# Learn commit style from repo history
+learnStyle: true
+learnStyleCommits: 50
+
+# Additional paths to ignore in diff analysis
+ignorePaths: []
+  # - "*.generated.ts"
+  # - "migrations/"
+
+# Extract ticket references from branch names
+branchPrefix: true
+branchPattern: "[A-Z]+-\\\\d+"
+
+# === Changelog settings ===
+changelog:
+  format: markdown           # markdown, json, plain
+  output: CHANGELOG.md       # default output file
+  categories:
+    - Features
+    - Bug Fixes
+    - Performance
+    - Breaking Changes
+    - Documentation
+  exclude:                   # patterns to exclude
+    - "^chore:"
+    - "^ci:"
+    - "^Merge"
+
+# === Release settings ===
+release:
+  draft: true                # create as draft by default
+`;
+  await writeFile5(".ghostcommit.yml", template, "utf-8");
+  console.log(chalk7.green("Created .ghostcommit.yml"));
+  console.log(
+    chalk7.dim("Edit this file to customize ghostcommit for your project.")
+  );
+}
+async function main() {
+  const program = createCLI();
+  const version = await getVersion();
+  program.version(version, "-v, --version");
+  await program.parseAsync();
+}
+
+// src/env.ts
+import { readFileSync } from "fs";
+import { join as join6 } from "path";
+async function loadEnv() {
+  const dirs = [];
+  try {
+    dirs.push(await getGitRootDir());
+  } catch {
+  }
+  const cwd = process.cwd();
+  if (!dirs.includes(cwd)) {
+    dirs.push(cwd);
+  }
+  const fileNames = [".env.local", ".env"];
+  for (const dir of dirs) {
+    for (const fileName of fileNames) {
+      tryLoadFile(join6(dir, fileName));
+    }
+  }
+}
+function tryLoadFile(filePath) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+
+// src/index.ts
+loadEnv().then(() => main()).catch((error) => {
+  const msg = error instanceof Error ? error.message : String(error);
+  console.error(`ghostcommit: ${msg}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map