@kud/ai-conventional-commit-cli 3.2.3 → 3.2.5

package/dist/index.cjs

@@ -0,0 +1,1200 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_clipanion = require("clipanion");
+
+// src/workflow/generate.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_ora = __toESM(require("ora"), 1);
+
+// src/git.ts
+var import_simple_git = require("simple-git");
+var import_node_crypto = __toESM(require("crypto"), 1);
+var git = (0, import_simple_git.simpleGit)();
+var ensureStagedChanges = async () => {
+  const status = await git.status();
+  return status.staged.length > 0;
+};
+var getStagedDiffRaw = async () => {
+  return git.diff(["--cached", "--unified=3", "--no-color"]);
+};
+var HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
+var parseDiffFromRaw = (raw) => {
+  if (!raw.trim()) return [];
+  const lines = raw.split("\n");
+  const files = [];
+  let currentFile = null;
+  for (const line of lines) {
+    if (line.startsWith("diff --git a/")) {
+      const pathMatch = line.match(/diff --git a\/(.+?) b\/(.+)$/);
+      if (pathMatch) {
+        const file = pathMatch[2];
+        currentFile = { file, hunks: [], additions: 0, deletions: 0 };
+        files.push(currentFile);
+      }
+      continue;
+    }
+    if (line.startsWith("diff --git")) continue;
+    if (line.startsWith("index ")) continue;
+    if (line.startsWith("--- ")) continue;
+    if (line.startsWith("+++ ")) continue;
+    if (line.startsWith("@@")) {
+      if (!currentFile) continue;
+      const m = line.match(HUNK_HEADER_RE);
+      if (!m) continue;
+      const from = parseInt(m[1], 10);
+      const fromLen = parseInt(m[2] || "1", 10);
+      const to = parseInt(m[3], 10);
+      const toLen = parseInt(m[4] || "1", 10);
+      const ctx = m[5]?.trim() || "";
+      currentFile.hunks.push({
+        file: currentFile.file,
+        header: line,
+        from,
+        to,
+        added: toLen,
+        removed: fromLen,
+        lines: [],
+        hash: "",
+        functionContext: ctx || void 0
+      });
+      continue;
+    }
+    if (currentFile && currentFile.hunks.length) {
+      const hunk = currentFile.hunks[currentFile.hunks.length - 1];
+      hunk.lines.push(line);
+      if (line.startsWith("+") && !line.startsWith("+++")) currentFile.additions++;
+      if (line.startsWith("-") && !line.startsWith("---")) currentFile.deletions++;
+    }
+  }
+  for (const f of files) {
+    for (const h of f.hunks) {
+      h.hash = import_node_crypto.default.createHash("sha1").update(f.file + h.header + h.lines.join("\n")).digest("hex").slice(0, 8);
+    }
+  }
+  return files;
+};
+var parseDiff = async () => {
+  const raw = await getStagedDiffRaw();
+  return parseDiffFromRaw(raw);
+};
+var getRecentCommitMessages = async (limit) => {
+  const log = await git.log({ maxCount: limit });
+  return log.all.map((e) => e.message);
+};
+var createCommit = async (title, body) => {
+  if (body) {
+    await git.commit([title, body].join("\n\n"));
+  } else {
+    await git.commit(title);
+  }
+};
+
+// src/style.ts
+var buildStyleProfile = (messages) => {
+  if (!messages.length) {
+    return {
+      tense: "imperative",
+      avgTitleLength: 50,
+      usesScopes: false,
+      gitmojiRatio: 0,
+      topPrefixes: [],
+      conventionalRatio: 0
+    };
+  }
+  const titles = messages.map((m) => m.split("\n")[0]);
+  const avgTitleLength = titles.reduce((a, c) => a + c.length, 0) / Math.max(1, titles.length);
+  const gitmojiCount = titles.filter((t) => /[\u{1F300}-\u{1FAFF}]/u.test(t)).length;
+  const usesScopesCount = titles.filter((t) => /^\w+\(.+\):/.test(t)).length;
+  const conventionalCount = titles.filter(
+    (t) => /^(feat|fix|chore|docs|refactor|test|ci|perf|style)(\(.+\))?: /.test(t)
+  ).length;
+  const prefixes = /* @__PURE__ */ new Map();
+  for (const t of titles) {
+    const m = t.match(/^(\w+)(\(.+\))?:/);
+    if (m) prefixes.set(m[1], (prefixes.get(m[1]) || 0) + 1);
+  }
+  const topPrefixes = [...prefixes.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([k]) => k);
+  return {
+    tense: "imperative",
+    avgTitleLength,
+    usesScopes: usesScopesCount / titles.length > 0.25,
+    gitmojiRatio: gitmojiCount / titles.length,
+    topPrefixes,
+    conventionalRatio: conventionalCount / titles.length
+  };
+};
+
+// src/prompt.ts
+var summarizeDiffForPrompt = (files, privacy) => {
+  if (privacy === "high") {
+    return files.map((f) => `file: ${f.file} (+${f.additions} -${f.deletions}) hunks:${f.hunks.length}`).join("\n");
+  }
+  if (privacy === "medium") {
+    return files.map(
+      (f) => `file: ${f.file}
+` + f.hunks.map(
+        (h) => `  hunk ${h.hash} context:${h.functionContext || ""} +${h.added} -${h.removed}`
+      ).join("\n")
+    ).join("\n");
+  }
+  return files.map(
+    (f) => `file: ${f.file}
+` + f.hunks.map(
+      (h) => `${h.header}
+${h.lines.slice(0, 40).join("\n")}${h.lines.length > 40 ? "\n[truncated]" : ""}`
+    ).join("\n")
+  ).join("\n");
+};
+var buildGenerationMessages = (opts) => {
+  const { files, style, config, mode, desiredCommits } = opts;
+  const diff = summarizeDiffForPrompt(files, config.privacy);
+  const TYPE_MAP = {
+    feat: "A new feature or capability added for the user",
+    fix: "A bug fix resolving incorrect behavior",
+    chore: "Internal change with no user-facing impact",
+    docs: "Documentation-only changes",
+    refactor: "Code change that neither fixes a bug nor adds a feature",
+    test: "Adding or improving tests only",
+    ci: "Changes to CI configuration or scripts",
+    perf: "Performance improvement",
+    style: "Formatting or stylistic change (no logic)",
+    build: "Build system or dependency changes",
+    revert: "Revert a previous commit",
+    merge: "Merge branches (rare; only if truly a merge commit)",
+    security: "Security-related change or hardening",
+    release: "Version bump or release meta change"
+  };
+  const specLines = [];
+  specLines.push(
+    "Purpose: Generate high-quality Conventional Commit messages for the provided git diff."
+  );
+  specLines.push("Locale: en");
+  specLines.push(
+    'Output JSON Schema: { "commits": [ { "title": string, "body": string, "score": 0-100, "reasons": string[] } ], "meta": { "splitRecommended": boolean } }'
+  );
+  specLines.push("Primary Output Field: commits[ ].title");
+  specLines.push("Title Format: <type>(<optional-scope>): <subject>");
+  specLines.push("Max Title Length: 72 characters (hard limit)");
+  specLines.push("Types (JSON mapping follows on next line)");
+  specLines.push("TypeMap: " + JSON.stringify(TYPE_MAP));
+  specLines.push("Scope Rules: optional; if present, lowercase kebab-case; omit when unclear.");
+  specLines.push(
+    "Subject Rules: imperative mood, present tense, no leading capital unless proper noun, no trailing period."
+  );
+  specLines.push("Length Rule: Entire title line (including type/scope) must be <= 72 chars.");
+  specLines.push(
+    "Emoji Rule: " + (config.gitmoji ? "OPTIONAL single leading gitmoji BEFORE the type only if confidently adds clarity; do not invent or stack; omit if unsure." : "Disallow all emojis and gitmoji codes; output must start directly with the type.")
+  );
+  specLines.push(
+    "Forbidden: breaking changes notation, exclamation mark after type unless truly semver-major (avoid unless diff clearly indicates)."
+  );
+  specLines.push("Fallback Type: use chore when no other type clearly fits.");
+  specLines.push("Consistency: prefer existing top prefixes: " + style.topPrefixes.join(", "));
+  specLines.push("Provide score (0-100) measuring clarity & specificity (higher is better).");
+  specLines.push(
+    "Provide reasons array citing concrete diff elements: filenames, functions, tests, metrics."
+  );
+  specLines.push("Return ONLY the JSON object. No surrounding text or markdown.");
+  specLines.push("Do not add fields not listed in schema.");
+  specLines.push("Never fabricate content not present or implied by the diff.");
+  specLines.push(
+    "If mode is split and multiple logical changes exist, set meta.splitRecommended=true."
+  );
+  return [
+    {
+      role: "system",
+      content: specLines.join("\n")
+    },
+    {
+      role: "user",
+      content: `Mode: ${mode}
+RequestedCommitCount: ${desiredCommits || (mode === "split" ? "2-6" : 1)}
+StyleFingerprint: ${JSON.stringify(style)}
+Diff:
+${diff}
+Generate commit candidates now.`
+    }
+  ];
+};
+var buildRefineMessages = (opts) => {
+  const { originalPlan, index, instructions, config } = opts;
+  const target = originalPlan.commits[index];
+  const spec = [];
+  spec.push("Purpose: Refine a single Conventional Commit message while preserving intent.");
+  spec.push("Locale: en");
+  spec.push("Input: one existing commit JSON object.");
+  spec.push(
+    'Output JSON Schema: { "commits": [ { "title": string, "body": string, "score": 0-100, "reasons": string[] } ] }'
+  );
+  spec.push("Title Format: <type>(<optional-scope>): <subject> (<=72 chars)");
+  spec.push("Subject: imperative, present tense, no trailing period.");
+  spec.push(
+    "Emoji Rule: " + (config.gitmoji ? "OPTIONAL single leading gitmoji BEFORE type if it adds clarity; omit if unsure." : "Disallow all emojis; start directly with the type.")
+  );
+  spec.push("Preserve semantic meaning; only improve clarity, scope, brevity, conformity.");
+  spec.push("If instructions request scope or emoji, incorporate only if justified by content.");
+  spec.push("Return ONLY JSON (commits array length=1).");
+  return [
+    { role: "system", content: spec.join("\n") },
+    {
+      role: "user",
+      content: `Current commit object:
+${JSON.stringify(target, null, 2)}
+Instructions:
+${instructions.join("\n") || "None"}
+Refine now.`
+    }
+  ];
+};
+
+// src/model/provider.ts
+var import_zod = require("zod");
+var import_execa = require("execa");
+var OpenCodeProvider = class {
+  constructor(model = "github-copilot/gpt-5") {
+    this.model = model;
+  }
+  name() {
+    return "opencode";
+  }
+  async chat(messages, _opts) {
+    const debug = process.env.AICC_DEBUG === "true";
+    const mockMode = process.env.AICC_DEBUG_PROVIDER === "mock";
+    const timeoutMs = parseInt(process.env.AICC_MODEL_TIMEOUT_MS || "45000", 10);
+    const eager = process.env.AICC_EAGER_PARSE !== "false";
+    const userAggregate = messages.map((m) => `${m.role.toUpperCase()}: ${m.content}`).join("\n\n");
+    const command = `Generate high-quality commit message candidates based on the staged git diff.`;
+    const fullPrompt = `${command}
+
+Context:
+${userAggregate}`;
+    if (mockMode) {
+      if (debug) console.error("[ai-cc][mock] Returning deterministic mock response");
+      return JSON.stringify({
+        commits: [
+          {
+            title: "chore: mock commit from provider",
+            body: "",
+            score: 80,
+            reasons: ["mock mode"]
+          }
+        ],
+        meta: { splitRecommended: false }
+      });
+    }
+    const start = Date.now();
+    return await new Promise((resolve3, reject) => {
+      let resolved = false;
+      let acc = "";
+      const includeLogs = process.env.AICC_PRINT_LOGS === "true";
+      const args = ["run", fullPrompt, "--model", this.model];
+      if (includeLogs) args.push("--print-logs");
+      const subprocess = (0, import_execa.execa)("opencode", args, {
+        timeout: timeoutMs,
+        input: ""
+        // immediately close stdin in case CLI waits for it
+      });
+      const finish = (value) => {
+        if (resolved) return;
+        resolved = true;
+        const elapsed = Date.now() - start;
+        if (debug) {
+          console.error(
+            `[ai-cc][provider] model=${this.model} elapsedMs=${elapsed} promptChars=${fullPrompt.length} bytesOut=${value.length}`
+          );
+        }
+        resolve3(value);
+      };
+      const tryEager = () => {
+        if (!eager) return;
+        const first = acc.indexOf("{");
+        const last = acc.lastIndexOf("}");
+        if (first !== -1 && last !== -1 && last > first) {
+          const candidate = acc.slice(first, last + 1).trim();
+          try {
+            JSON.parse(candidate);
+            if (debug) console.error("[ai-cc][provider] eager JSON detected, terminating process");
+            subprocess.kill("SIGTERM");
+            finish(candidate);
+          } catch {
+          }
+        }
+      };
+      subprocess.stdout?.on("data", (chunk) => {
+        const text = chunk.toString();
+        acc += text;
+        tryEager();
+      });
+      subprocess.stderr?.on("data", (chunk) => {
+        if (debug) console.error("[ai-cc][provider][stderr]", chunk.toString().trim());
+      });
+      subprocess.then(({ stdout }) => {
+        if (!resolved) finish(stdout);
+      }).catch((e) => {
+        if (resolved) return;
+        const elapsed = Date.now() - start;
+        if (e.timedOut) {
+          return reject(
+            new Error(`Model call timed out after ${timeoutMs}ms (elapsed=${elapsed}ms)`)
+          );
+        }
+        if (debug) console.error("[ai-cc][provider] failure", e.stderr || e.message);
+        reject(new Error(e.stderr || e.message || "opencode invocation failed"));
+      });
+    });
+  }
+};
+var CommitSchema = import_zod.z.object({
+  title: import_zod.z.string().min(5).max(150),
+  body: import_zod.z.string().optional().default(""),
+  score: import_zod.z.number().min(0).max(100),
+  reasons: import_zod.z.array(import_zod.z.string()).optional().default([])
+});
+var PlanSchema = import_zod.z.object({
+  commits: import_zod.z.array(CommitSchema).min(1),
+  meta: import_zod.z.object({
+    splitRecommended: import_zod.z.boolean().optional()
+  }).optional()
+});
+var extractJSON = (raw) => {
+  const trimmed = raw.trim();
+  let jsonText = null;
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    jsonText = trimmed;
+  } else {
+    const match = raw.match(/\{[\s\S]*\}$/m);
+    if (match) jsonText = match[0];
+  }
+  if (!jsonText) throw new Error("No JSON object detected.");
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (e) {
+    throw new Error("Invalid JSON parse");
+  }
+  return PlanSchema.parse(parsed);
+};
+
+// src/plugins.ts
+var import_node_path = require("path");
+async function loadPlugins(config, cwd = process.cwd()) {
+  const out = [];
+  for (const p of config.plugins || []) {
+    try {
+      const mod = await import((0, import_node_path.resolve)(cwd, p));
+      if (mod.default) out.push(mod.default);
+      else if (mod.plugin) out.push(mod.plugin);
+    } catch (e) {
+      if (config.verbose) {
+        console.error("[plugin]", p, "failed to load", e);
+      }
+    }
+  }
+  return out;
+}
+async function applyTransforms(candidates, plugins, ctx) {
+  let current = candidates;
+  for (const pl of plugins) {
+    if (pl.transformCandidates) {
+      current = await pl.transformCandidates(current, ctx);
+    }
+  }
+  return current;
+}
+async function runValidations(candidate, plugins, ctx) {
+  const errors = [];
+  for (const pl of plugins) {
+    if (pl.validateCandidate) {
+      const res = await pl.validateCandidate(candidate, ctx);
+      if (typeof res === "string") errors.push(res);
+      else if (Array.isArray(res)) errors.push(...res);
+    }
+  }
+  return errors;
+}
+
+// src/guardrails.ts
+var SECRET_PATTERNS = [
+  /AWS_[A-Z0-9_]+/i,
+  /BEGIN RSA PRIVATE KEY/,
+  /-----BEGIN PRIVATE KEY-----/,
+  /ssh-rsa AAAA/
+];
+var CONVENTIONAL_RE = /^(?:([\p{Emoji}\p{So}\p{Sk}]+)\s+(feat|fix|chore|docs|refactor|test|ci|perf|style|build|revert|merge|security|release)(\(.+\))?:\s|([\p{Emoji}\p{So}\p{Sk}]+):\s.*|([\p{Emoji}\p{So}\p{Sk}]+):\s*$|(feat|fix|chore|docs|refactor|test|ci|perf|style|build|revert|merge|security|release)(\(.+\))?:\s)/u;
+var sanitizeTitle = (title, allowEmoji) => {
+  let t = title.trim();
+  if (allowEmoji) {
+    const multi = t.match(/^((?:[\p{Emoji}\p{So}\p{Sk}]+)[\p{Emoji}\p{So}\p{Sk}\s]*)+/u);
+    if (multi) {
+      const first = Array.from(multi[0].trim())[0];
+      t = first + " " + t.slice(multi[0].length).trimStart();
+    }
+  } else {
+    t = t.replace(/^([\p{Emoji}\p{So}\p{Sk}\p{P}]+\s*)+/u, "").trimStart();
+  }
+  return t;
+};
+var normalizeConventionalTitle = (title) => {
+  let original = title.trim();
+  let leadingEmoji = "";
+  const emojiCluster = original.match(/^[\p{Emoji}\p{So}\p{Sk}]+/u);
+  if (emojiCluster) {
+    leadingEmoji = Array.from(emojiCluster[0])[0];
+  }
+  let t = original.replace(/^([\p{Emoji}\p{So}\p{Sk}\p{P}]+\s*)+/u, "").trim();
+  const m = t.match(/^(\w+)(\(.+\))?:\s+(.*)$/);
+  let result;
+  if (m) {
+    const type = m[1].toLowerCase();
+    const scope = m[2] || "";
+    let subject = m[3].trim();
+    subject = subject.replace(/\.$/, "");
+    subject = subject.charAt(0).toLowerCase() + subject.slice(1);
+    result = `${type}${scope}: ${subject}`;
+  } else if (!/^\w+\(.+\)?: /.test(t)) {
+    t = t.replace(/\.$/, "");
+    t = t.charAt(0).toLowerCase() + t.slice(1);
+    result = `chore: ${t}`;
+  } else {
+    result = t;
+  }
+  if (leadingEmoji) {
+    result = `${leadingEmoji} ${result}`;
+  }
+  return result.slice(0, 72);
+};
+var checkCandidate = (candidate) => {
+  const errs = [];
+  if (candidate.title.length > 72) errs.push("Title exceeds 72 chars.");
+  if (!CONVENTIONAL_RE.test(candidate.title)) {
+    errs.push("Not a valid conventional commit title.");
+  }
+  if (/^[A-Z]/.test(candidate.title)) {
+  }
+  const body = candidate.body || "";
+  for (const pat of SECRET_PATTERNS) {
+    if (pat.test(body)) {
+      errs.push("Potential secret detected.");
+      break;
+    }
+  }
+  return errs;
+};
+
+// src/title-format.ts
+var EMOJI_MAP = {
+  feat: "\u2728",
+  fix: "\u{1F41B}",
+  chore: "\u{1F9F9}",
+  docs: "\u{1F4DD}",
+  refactor: "\u267B\uFE0F",
+  test: "\u2705",
+  ci: "\u{1F916}",
+  perf: "\u26A1\uFE0F",
+  style: "\u{1F3A8}",
+  build: "\u{1F3D7}\uFE0F",
+  revert: "\u23EA",
+  merge: "\u{1F500}",
+  security: "\u{1F512}",
+  release: "\u{1F3F7}\uFE0F"
+};
+var MAX_LEN = 72;
+var EMOJI_TYPE_RE = /^([\p{Emoji}\p{So}\p{Sk}])\s+(\w+)(\(.+\))?:\s+(.*)$/u;
+var TYPE_RE = /^(\w+)(\(.+\))?:\s+(.*)$/;
+var formatCommitTitle = (raw, opts) => {
+  const { allowGitmoji, mode = "standard" } = opts;
+  let norm = normalizeConventionalTitle(sanitizeTitle(raw, allowGitmoji));
+  if (!allowGitmoji || mode !== "gitmoji" && mode !== "gitmoji-pure") {
+    return norm.slice(0, MAX_LEN);
+  }
+  if (mode === "gitmoji-pure") {
+    let m2 = norm.match(EMOJI_TYPE_RE);
+    if (m2) {
+      const emoji = m2[1];
+      const subject = m2[4];
+      norm = `${emoji}: ${subject}`;
+    } else if (m2 = norm.match(TYPE_RE)) {
+      const type = m2[1];
+      const subject = m2[3];
+      const em = EMOJI_MAP[type] || "\u{1F527}";
+      norm = `${em}: ${subject}`;
+    } else if (!/^([\p{Emoji}\p{So}\p{Sk}])+:/u.test(norm)) {
+      norm = `\u{1F527}: ${norm}`;
+    }
+    return norm.slice(0, MAX_LEN);
+  }
+  let m = norm.match(EMOJI_TYPE_RE);
+  if (m) {
+    return norm.slice(0, MAX_LEN);
+  }
+  if (m = norm.match(TYPE_RE)) {
+    const type = m[1];
+    const scope = m[2] || "";
+    const subject = m[3];
+    const em = EMOJI_MAP[type] || "\u{1F527}";
+    norm = `${em} ${type}${scope}: ${subject}`;
+  } else if (!/^([\p{Emoji}\p{So}\p{Sk}])+\s+\w+.*:/u.test(norm)) {
+    norm = `\u{1F527} chore: ${norm}`;
+  }
+  return norm.slice(0, MAX_LEN);
+};
+
+// src/workflow/generate.ts
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var import_inquirer = __toESM(require("inquirer"), 1);
+
+// src/workflow/panel.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function buildPanel(opts) {
+  const termWidth = process.stdout.columns || 80;
+  const contentLines = opts.lines && opts.lines.length ? opts.lines : [];
+  const maxContent = Math.max(
+    opts.title ? stripAnsi(opts.title).length : 0,
+    ...contentLines.map((l) => stripAnsi(l).length)
+  );
+  const innerWidth = Math.min(opts.width || maxContent, termWidth - 4);
+  const pad = (s) => {
+    const visible = stripAnsi(s).length;
+    const needed = innerWidth - visible;
+    return s + " ".repeat(Math.max(0, needed));
+  };
+  const top = "\u250C " + pad(opts.title ? import_chalk.default.bold(opts.title) : "") + " \u2510";
+  const body = contentLines.map((l) => "\u2502 " + pad(l) + " \u2502");
+  const bottom = "\u2514" + "\u2500".repeat(innerWidth + 2) + "\u2518";
+  return [top, ...body, bottom].join("\n");
+}
+function stripAnsi(str) {
+  return str.replace(/\u001B\[[0-9;]*m/g, "");
+}
+
+// src/workflow/generate.ts
+async function animateHeader() {
+  const text = "ai-conventional-commit";
+  if (!process.stdout.isTTY || process.env.AICC_NO_ANIMATION) {
+    console.log("\n\u250C  " + import_chalk2.default.bold(text));
+    return;
+  }
+  const palette = [
+    "#3a0d6d",
+    "#5a1ea3",
+    "#7a32d6",
+    "#9a4dff",
+    "#b267ff",
+    "#c37dff",
+    "#b267ff",
+    "#9a4dff",
+    "#7a32d6",
+    "#5a1ea3"
+  ];
+  process.stdout.write("\n");
+  for (const color of palette) {
+    const frame = import_chalk2.default.bold.hex(color)(text);
+    process.stdout.write("\r\u250C  " + frame);
+    await new Promise((r) => setTimeout(r, 60));
+  }
+  process.stdout.write("\n");
+}
+async function runGenerate(config) {
+  if (!await ensureStagedChanges()) {
+    console.log("No staged changes.");
+    return;
+  }
+  const files = await parseDiff();
+  if (!files.length) {
+    console.log("No diff content detected after staging. Aborting.");
+    return;
+  }
+  const fileLines = [
+    import_chalk2.default.dim(`Detected ${files.length} staged ${files.length === 1 ? "file" : "files"}:`),
+    ...files.map((f) => "\u2022 " + f.file)
+  ];
+  if (process.stdout.isTTY) {
+    await animateHeader();
+    console.log(
+      buildPanel({
+        title: "Files",
+        lines: fileLines
+      })
+    );
+  } else {
+    console.log("\nFiles:");
+    fileLines.forEach((l) => console.log("  " + l));
+  }
+  const spinner = (0, import_ora.default)({ text: " Starting", spinner: "dots" }).start();
+  function setPhase(label) {
+    spinner.text = " " + import_chalk2.default.bold(label);
+  }
+  async function runStep(label, fn) {
+    setPhase(label);
+    try {
+      return await fn();
+    } catch (e) {
+      spinner.fail(`\u25C7  ${label} failed: ${e.message}`);
+      throw e;
+    }
+  }
+  let style;
+  let plugins;
+  let messages;
+  let raw;
+  let plan;
+  let candidates = [];
+  const provider = new OpenCodeProvider(config.model);
+  style = await runStep("Profiling style", async () => {
+    const history = await getRecentCommitMessages(config.styleSamples);
+    return buildStyleProfile(history);
+  });
+  plugins = await runStep("Loading plugins", async () => loadPlugins(config));
+  messages = await runStep(
+    "Building prompt",
+    async () => buildGenerationMessages({ files, style, config, mode: "single" })
+  );
+  raw = await runStep(
+    "Calling model",
+    async () => provider.chat(messages, { maxTokens: config.maxTokens })
+  );
+  plan = await runStep("Parsing response", async () => extractJSON(raw));
+  candidates = await runStep(
+    "Analyzing changes",
+    async () => applyTransforms(plan.commits, plugins, { cwd: process.cwd(), env: process.env })
+  );
+  setPhase("Result found");
+  spinner.stopAndPersist({ symbol: "\u25C6", text: " " + import_chalk2.default.bold("Result found:") });
+  candidates = candidates.map((c) => ({
+    ...c,
+    title: formatCommitTitle(c.title, {
+      allowGitmoji: !!config.gitmoji,
+      mode: config.gitmojiMode || "standard"
+    })
+  }));
+  const chosen = candidates[0];
+  const resultLines = [import_chalk2.default.white(chosen.title)];
+  if (chosen.body) {
+    chosen.body.split("\n").forEach((line) => {
+      if (line.trim().length === 0) resultLines.push("");
+      else resultLines.push(import_chalk2.default.white(line));
+    });
+  }
+  if (process.stdout.isTTY) {
+    console.log(
+      buildPanel({
+        title: "Result",
+        lines: resultLines
+      })
+    );
+  } else {
+    console.log("\nResult:");
+    resultLines.forEach((l) => console.log("  " + l));
+  }
+  const pluginErrors = await runValidations(chosen, plugins, {
+    cwd: process.cwd(),
+    env: process.env
+  });
+  const guardErrors = checkCandidate(chosen);
+  const errors = [...pluginErrors, ...guardErrors];
+  if (errors.length) {
+    const errorLines = ["Validation issues:", ...errors.map((e) => import_chalk2.default.red("\u2022 " + e))];
+    if (process.stdout.isTTY) {
+      console.log(
+        buildPanel({
+          title: "Checks",
+          lines: errorLines
+        })
+      );
+    } else {
+      console.log("\nValidation issues:");
+      errorLines.slice(1).forEach((l) => console.log("  " + l));
+    }
+  }
+  const yn = await selectYesNo();
+  if (!yn) {
+    console.log("Aborted.");
+    return;
+  }
+  await createCommit(chosen.title, chosen.body);
+  saveSession({ plan, chosen, mode: "single" });
+  console.log(import_chalk2.default.green("Commit created."));
+}
+function saveSession(data) {
+  const dir = ".git/.aicc-cache";
+  if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs.writeFileSync)((0, import_node_path2.join)(dir, "last-session.json"), JSON.stringify(data, null, 2));
+}
+async function selectYesNo() {
+  const { choice } = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: " Use this commit message?",
+      choices: [
+        { name: "Yes", value: true },
+        { name: "No", value: false }
+      ],
+      default: 0
+    }
+  ]);
+  return choice;
+}
+
+// src/workflow/split.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+
+// src/cluster.ts
+var topLevel = (file) => file.split("/")[0] || file;
+var clusterHunks = (files) => {
+  const clusters = [];
+  const byDir = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    for (const h of f.hunks) {
+      const dir = topLevel(f.file);
+      if (!byDir.has(dir)) byDir.set(dir, []);
+      byDir.get(dir).push(h);
+    }
+  }
+  for (const [dir, hunks] of byDir.entries()) {
+    if (hunks.length <= 5) {
+      clusters.push({
+        id: `dir-${dir}`,
+        files: [...new Set(hunks.map((h) => h.file))],
+        hunkHashes: hunks.map((h) => h.hash),
+        rationale: `Changes grouped by directory ${dir}`
+      });
+    } else {
+      const perFile = /* @__PURE__ */ new Map();
+      for (const h of hunks) {
+        if (!perFile.has(h.file)) perFile.set(h.file, []);
+        perFile.get(h.file).push(h);
+      }
+      for (const [file, list] of perFile.entries()) {
+        clusters.push({
+          id: `file-${file}`,
+          files: [file],
+          hunkHashes: list.map((h) => h.hash),
+          rationale: `Large directory; grouped by file ${file}`
+        });
+      }
+    }
+  }
+  return clusters;
+};
+
+// src/workflow/split.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var import_inquirer2 = __toESM(require("inquirer"), 1);
+async function runSplit(config, desired) {
+  if (!await ensureStagedChanges()) {
+    console.log("No staged changes.");
+    return;
+  }
+  const files = await parseDiff();
+  if (!files.length) {
+    console.log("No diff content detected after staging. Aborting.");
+    return;
+  }
+  console.log("\u25C7  Clustering changes");
+  clusterHunks(files);
+  console.log("\u25C7  Profiling style");
+  const history = await getRecentCommitMessages(config.styleSamples);
+  const style = buildStyleProfile(history);
+  console.log("\u25C7  Loading plugins");
+  const plugins = await loadPlugins(config);
+  console.log("\u25C7  Building prompt");
+  const messages = buildGenerationMessages({
+    files,
+    style,
+    config,
+    mode: "split",
+    desiredCommits: desired
+  });
+  const provider = new OpenCodeProvider(config.model);
+  console.log("\u25C7  Calling model for split plan");
+  let raw;
+  try {
+    raw = await provider.chat(messages, { maxTokens: config.maxTokens });
+  } catch (e) {
+    console.log(e.message);
+    return;
+  }
+  console.log("\u25C7  Parsing response");
+  let plan;
+  try {
+    plan = extractJSON(raw);
+  } catch (e) {
+    console.log("JSON parse error: " + e.message);
+    return;
+  }
+  console.log("\u25C7  Plan received");
+  let candidates = await applyTransforms(plan.commits, plugins, {
+    cwd: process.cwd(),
+    env: process.env
+  });
+  candidates = candidates.map((c) => ({
+    ...c,
+    title: formatCommitTitle(c.title, {
+      allowGitmoji: !!config.gitmoji,
+      mode: config.gitmojiMode || "standard"
+    })
+  }));
+  console.log(import_chalk3.default.cyan("\nProposed commits:"));
+  candidates.forEach((c) => {
+    console.log(import_chalk3.default.yellow(`\u2022 ${c.title}`));
+    if (c.body) {
+      const indent = "   ";
+      c.body.split("\n").forEach((line) => {
+        if (line.trim().length === 0) console.log(indent);
+        else console.log(indent + import_chalk3.default.gray(line));
+      });
+    }
+  });
+  const { ok } = await import_inquirer2.default.prompt([
+    {
+      type: "list",
+      name: "ok",
+      message: "Apply these commit messages?",
+      choices: [
+        { name: "\u25CF Yes", value: true },
+        { name: "\u25CB No", value: false }
+      ],
+      default: 0
+    }
+  ]);
+  if (!ok) {
+    console.log("Aborted.");
+    return;
+  }
+  for (const candidate of candidates) {
+    const pluginErrors = await runValidations(candidate, plugins, {
+      cwd: process.cwd(),
+      env: process.env
+    });
+    const guardErrors = checkCandidate(candidate);
+    const errors = [...pluginErrors, ...guardErrors];
+    if (errors.length) {
+      console.log(import_chalk3.default.red("Skipping commit due to errors:"), candidate.title);
+      errors.forEach((e) => console.log(" -", e));
+      continue;
+    }
+    await createCommit(candidate.title, candidate.body);
+    console.log(import_chalk3.default.green("Committed: ") + candidate.title);
+  }
+  saveSession2({ plan, chosen: candidates, mode: "split" });
+}
+function saveSession2(data) {
+  const dir = ".git/.aicc-cache";
+  if (!(0, import_node_fs2.existsSync)(dir)) (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs2.writeFileSync)((0, import_node_path3.join)(dir, "last-session.json"), JSON.stringify(data, null, 2));
+}
+
+// src/workflow/refine.ts
+var import_chalk4 = __toESM(require("chalk"), 1);
+var import_ora2 = __toESM(require("ora"), 1);
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+
+// src/workflow/util.ts
+var import_node_readline = __toESM(require("readline"), 1);
+var prompt = async (question, defaultValue) => {
+  const rl = import_node_readline.default.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      if (!answer && defaultValue) return res(defaultValue);
+      res(answer);
+    });
+  });
+};
+
+// src/workflow/refine.ts
+function loadSession() {
+  const path = (0, import_node_path4.join)(".git/.aicc-cache", "last-session.json");
+  if (!(0, import_node_fs3.existsSync)(path)) return null;
+  try {
+    return JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function runRefine(config, options) {
+  const spinner = (0, import_ora2.default)("Loading last session").start();
+  const session = loadSession();
+  if (!session) {
+    spinner.fail("No previous session found.");
+    return;
+  }
+  spinner.succeed("Session loaded");
+  const plan = session.plan;
+  const index = options.index ?? 0;
+  if (!plan.commits[index]) {
+    console.log("Invalid index.");
+    return;
+  }
+  const instructions = [];
+  if (options.shorter) instructions.push("Make the title shorter but keep meaning.");
+  if (options.longer) instructions.push("Add more specificity to the title.");
+  if (options.scope) instructions.push(`Add or adjust scope to: ${options.scope}`);
+  if (options.emoji) instructions.push("Add a relevant emoji prefix.");
+  if (!instructions.length) {
+    const add = await prompt("No refinement flags given. Enter custom instruction: ");
+    if (add.trim()) instructions.push(add.trim());
+    else {
+      console.log("Nothing to refine.");
+      return;
+    }
+  }
+  const provider = new OpenCodeProvider(config.model);
+  const messages = buildRefineMessages({
+    originalPlan: plan,
+    index,
+    instructions,
+    config
+  });
+  const raw = await provider.chat(messages, { maxTokens: config.maxTokens });
+  let refined;
+  try {
+    refined = extractJSON(raw);
+  } catch (e) {
+    console.error("Failed to parse refine response:", e.message);
+    return;
+  }
+  {
+    refined.commits[0].title = formatCommitTitle(refined.commits[0].title, {
+      allowGitmoji: !!config.gitmoji || !!options.emoji,
+      mode: config.gitmojiMode || "standard"
+    });
+  }
+  console.log(import_chalk4.default.cyan("\nRefined candidate:"));
+  console.log(import_chalk4.default.yellow(refined.commits[0].title));
+  if (refined.commits[0].body) {
+    const indent = "   ";
+    refined.commits[0].body.split("\n").forEach((line) => {
+      if (line.trim().length === 0) console.log(indent);
+      else console.log(indent + import_chalk4.default.gray(line));
+    });
+  }
+  const accept = await prompt("Accept refined version? (Y/n) ", "y");
+  if (!/^n/i.test(accept)) {
+    plan.commits[index] = refined.commits[0];
+    console.log(import_chalk4.default.green("Refinement stored (not retro-committed)."));
+  } else {
+    console.log("Refinement discarded.");
+  }
+}
+
+// src/config.ts
+var import_cosmiconfig = require("cosmiconfig");
+var import_node_path5 = require("path");
+var import_node_fs4 = require("fs");
+var DEFAULTS = {
+  model: process.env.AICC_MODEL || "github-copilot/gpt-5",
+  privacy: process.env.AICC_PRIVACY || "low",
+  gitmoji: process.env.AICC_GITMOJI === "true",
+  gitmojiMode: "standard",
+  styleSamples: parseInt(process.env.AICC_STYLE_SAMPLES || "120", 10),
+  maxTokens: parseInt(process.env.AICC_MAX_TOKENS || "512", 10),
+  cacheDir: ".git/.aicc-cache",
+  plugins: [],
+  verbose: process.env.AICC_VERBOSE === "true"
+};
+async function loadConfig(cwd = process.cwd()) {
+  const explorer = (0, import_cosmiconfig.cosmiconfig)("aicc");
+  const result = await explorer.search(cwd);
+  const cfg = {
+    ...DEFAULTS,
+    ...result?.config || {}
+  };
+  cfg.plugins = (cfg.plugins || []).filter((p) => {
+    const abs = (0, import_node_path5.resolve)(cwd, p);
+    return (0, import_node_fs4.existsSync)(abs);
+  });
+  return cfg;
+}
+
+// src/index.ts
+var import_module = require("module");
+var import_meta = {};
+var require2 = (0, import_module.createRequire)(import_meta.url);
+var pkgVersion = "0.0.0";
+try {
+  const pkg = require2("../package.json");
+  pkgVersion = pkg.version || pkgVersion;
+} catch {
+}
+var GenerateCommand = class extends import_clipanion.Command {
+  static paths = [[`generate`], []];
+  static usage = import_clipanion.Command.Usage({
+    description: "Generate a conventional commit message for staged changes (aliases: run, commit).",
+    details: `Generates a single commit message using AI with style + guardrails.
+Add --gitmoji or --gitmoji-pure to enable emoji styles.`,
+    examples: [
+      ["Generate a commit with gitmoji style", "ai-conventional-commit generate --gitmoji"]
+    ]
+  });
+  gitmoji = import_clipanion.Option.Boolean("--gitmoji", false, {
+    description: "Gitmoji mode (vs --gitmoji-pure): emoji + type (emoji: subject)"
+  });
+  gitmojiPure = import_clipanion.Option.Boolean("--gitmoji-pure", false, {
+    description: "Pure gitmoji mode (vs --gitmoji): emoji only (emoji: subject)"
+  });
+  model = import_clipanion.Option.String("-m,--model", {
+    required: false,
+    description: "Model provider/name (e.g. github-copilot/gpt-5)"
+  });
+  async execute() {
+    const config = await loadConfig();
+    if (this.gitmoji || this.gitmojiPure) {
+      config.gitmoji = true;
+      config.gitmojiMode = this.gitmojiPure ? "gitmoji-pure" : "gitmoji";
+    }
+    if (this.model) config.model = this.model;
+    await runGenerate(config);
+  }
+};
+var SplitCommand = class extends import_clipanion.Command {
+  static paths = [[`split`]];
+  static usage = import_clipanion.Command.Usage({
+    description: "Propose multiple smaller conventional commits for current staged diff.",
+    details: `Analyzes staged changes, groups them logically and suggests multiple commit messages.
+Use --max to limit the number of proposals.`,
+    examples: [
+      [
+        "Split into at most 3 commits with gitmoji",
+        "ai-conventional-commit split --max 3 --gitmoji"
+      ]
+    ]
+  });
+  max = import_clipanion.Option.String("--max", { description: "Max proposed commits", required: false });
+  gitmoji = import_clipanion.Option.Boolean("--gitmoji", false, {
+    description: "Gitmoji mode (vs --gitmoji-pure): emoji + type"
+  });
+  gitmojiPure = import_clipanion.Option.Boolean("--gitmoji-pure", false, {
+    description: "Pure gitmoji mode (vs --gitmoji): emoji only"
+  });
+  model = import_clipanion.Option.String("-m,--model", {
+    required: false,
+    description: "Model provider/name override"
+  });
+  async execute() {
+    const config = await loadConfig();
+    if (this.gitmoji || this.gitmojiPure) {
+      config.gitmoji = true;
+      config.gitmojiMode = this.gitmojiPure ? "gitmoji-pure" : "gitmoji";
+    }
+    if (this.model) config.model = this.model;
+    await runSplit(config, this.max ? parseInt(this.max, 10) : void 0);
+  }
+};
+var RefineCommand = class extends import_clipanion.Command {
+  static paths = [[`refine`]];
+  static usage = import_clipanion.Command.Usage({
+    description: "Refine the last (or chosen) commit message with style rules.",
+    details: `Allows targeted improvements: shorter/longer length, inject scope, add emoji, or select a specific index when multiple commits were generated earlier.`,
+    examples: [
+      ["Shorten the last commit message", "ai-conventional-commit refine --shorter"],
+      ["Add a scope to the last commit", "ai-conventional-commit refine --scope ui"]
+    ]
+  });
+  shorter = import_clipanion.Option.Boolean("--shorter", false, { description: "Make message more concise" });
+  longer = import_clipanion.Option.Boolean("--longer", false, { description: "Expand message with detail" });
+  scope = import_clipanion.Option.String("--scope", { description: "Override/add scope (e.g. ui, api)" });
+  emoji = import_clipanion.Option.Boolean("--emoji", false, { description: "Add appropriate gitmoji (non-pure)" });
+  index = import_clipanion.Option.String("--index", {
+    description: "Select commit index if multiple were generated"
+  });
+  model = import_clipanion.Option.String("-m,--model", {
+    required: false,
+    description: "Model provider/name override"
+  });
+  async execute() {
+    const config = await loadConfig();
+    if (this.model) config.model = this.model;
+    await runRefine(config, {
+      shorter: this.shorter,
+      longer: this.longer,
+      scope: this.scope,
+      emoji: this.emoji,
+      index: this.index ? parseInt(this.index, 10) : void 0
+    });
+  }
+};
+var HelpCommand = class extends import_clipanion.Command {
+  static paths = [[`--help`], [`-h`]];
+  // capture explicit help
+  async execute() {
+    this.context.stdout.write(globalHelp() + "\n");
+  }
+};
+function globalHelp() {
+  return `ai-conventional-commit v${pkgVersion}
+
+Usage:
+  ai-conventional-commit [generate] [options]   Generate a commit (default)
+  ai-conventional-commit split [options]        Propose multiple commits
+  ai-conventional-commit refine [options]       Refine last or indexed commit
+
+Global Options:
+  -m, --model <provider/name>   Override model provider/name
+  --gitmoji                     Gitmoji mode (emoji + type)
+  --gitmoji-pure                Gitmoji pure mode (emoji only)
+  -h, --help                    Show this help
+  -V, --version                 Show version
+
+Refine Options:
+  --shorter / --longer          Adjust message length
+  --scope <scope>               Add or replace scope
+  --emoji                       Add suitable gitmoji
+  --index <n>                   Select commit index
+
+Examples:
+  ai-conventional-commit --gitmoji
+  ai-conventional-commit split --max 3
+  ai-conventional-commit refine --scope api --emoji
+`;
+}
+var VersionCommand = class extends import_clipanion.Command {
+  static paths = [[`--version`], [`-V`]];
+  async execute() {
+    this.context.stdout.write(`${pkgVersion}
+`);
+  }
+};
+var cli = new import_clipanion.Cli({
+  binaryLabel: "ai-conventional-commit",
+  binaryName: "ai-conventional-commit",
+  binaryVersion: pkgVersion
+});
+cli.register(GenerateCommand);
+cli.register(SplitCommand);
+cli.register(RefineCommand);
+cli.register(HelpCommand);
+cli.register(VersionCommand);
+cli.runExit(process.argv.slice(2), {
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr
+});