@kud/ai-conventional-commit-cli 0.12.12 → 0.13.1

package/README.md

@@ -221,10 +221,31 @@ Resolves via cosmiconfig (JSON/YAML/etc). Example:
   "style": "gitmoji",
   "styleSamples": 120,
   "plugins": ["./src/sample-plugin/example-plugin.ts"],
-  "maxTokens": 512
+  "maxTokens": 512,
+  "maxFileLines": 1000,
+  "skipFilePatterns": [
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/*.d.ts",
+    "**/dist/**"
+  ]
 }
 ```
 
+### Configuration Options
+
+- **`maxFileLines`** (default: 1000): Skip file content in AI prompt if diff line count exceeds this threshold (per file). Files are still committed - the AI just sees the filename and stats instead of full content. Helps avoid token overflow from extremely large files.
+
+- **`skipFilePatterns`** (default: see below): Glob patterns for files whose content should be skipped in the AI prompt but still committed. Useful for generated files, lock files, and build artifacts.
+
+  **Default patterns:**
+  - Lock files: `**/package-lock.json`, `**/yarn.lock`, `**/pnpm-lock.yaml`, `**/bun.lockb`, `**/composer.lock`, `**/Gemfile.lock`, `**/Cargo.lock`, `**/poetry.lock`
+  - TypeScript declarations: `**/*.d.ts`
+  - Build output: `**/dist/**`, `**/build/**`, `**/.next/**`, `**/out/**`, `**/coverage/**`
+  - Minified files: `**/*.min.js`, `**/*.min.css`, `**/*.map`
+
+  To override, provide your own array in config. To disable entirely, set to `[]`.
+
 Environment overrides (prefix `AICC_`):
 
 ### Configuration Precedence
@@ -253,7 +274,9 @@ ai-conventional-commit models --interactive --save # pick + persist globally
 ai-conventional-commit models --current     # show active model + source
 ```
 
-`MODEL`, `PRIVACY`, `STYLE`, `STYLE_SAMPLES`, `MAX_TOKENS`, `VERBOSE`, `MODEL_TIMEOUT_MS`, `DEBUG`, `PRINT_LOGS`, `DEBUG_PROVIDER=mock`.
+`MODEL`, `PRIVACY`, `STYLE`, `STYLE_SAMPLES`, `MAX_TOKENS`, `MAX_FILE_LINES`, `VERBOSE`, `MODEL_TIMEOUT_MS`, `DEBUG`, `PRINT_LOGS`, `DEBUG_PROVIDER=mock`.
+
+**Note:** `skipFilePatterns` cannot be set via environment variable - use config file or accept defaults.
 
 ## Refinement Workflow
 

package/dist/chunk-HJR5M6U7.js

@@ -0,0 +1,120 @@
+// src/config.ts
+import { cosmiconfig } from "cosmiconfig";
+import { resolve, dirname, join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+var DEFAULTS = {
+  model: process.env.AICC_MODEL || "github-copilot/gpt-4.1",
+  privacy: process.env.AICC_PRIVACY || "low",
+  style: process.env.AICC_STYLE || "standard",
+  styleSamples: parseInt(process.env.AICC_STYLE_SAMPLES || "120", 10),
+  maxTokens: parseInt(process.env.AICC_MAX_TOKENS || "512", 10),
+  maxFileLines: parseInt(process.env.AICC_MAX_FILE_LINES || "1000", 10),
+  skipFilePatterns: [
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/bun.lockb",
+    "**/composer.lock",
+    "**/Gemfile.lock",
+    "**/Cargo.lock",
+    "**/poetry.lock",
+    "**/*.d.ts",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/out/**",
+    "**/coverage/**",
+    "**/*.min.js",
+    "**/*.min.css",
+    "**/*.map"
+  ],
+  cacheDir: ".git/.aicc-cache",
+  plugins: [],
+  verbose: process.env.AICC_VERBOSE === "true"
+};
+function getGlobalConfigPath() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return resolve(base, "ai-conventional-commit-cli", "aicc.json");
+}
+function saveGlobalConfig(partial) {
+  const filePath = getGlobalConfigPath();
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let existing = {};
+  if (existsSync(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync(filePath, "utf8")) || {};
+    } catch (e) {
+      if (process.env.AICC_VERBOSE === "true") {
+        console.error("[ai-cc] Failed to parse existing global config, overwriting.");
+      }
+    }
+  }
+  const merged = { ...existing, ...partial };
+  writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  return filePath;
+}
+async function loadConfig(cwd = process.cwd()) {
+  return (await loadConfigDetailed(cwd)).config;
+}
+async function loadConfigDetailed(cwd = process.cwd()) {
+  let globalCfg = {};
+  const globalPath = getGlobalConfigPath();
+  if (existsSync(globalPath)) {
+    try {
+      globalCfg = JSON.parse(readFileSync(globalPath, "utf8")) || {};
+    } catch (e) {
+      if (process.env.AICC_VERBOSE === "true") {
+        console.error("[ai-cc] Failed to parse global config, ignoring.");
+      }
+    }
+  }
+  const explorer = cosmiconfig("aicc");
+  const result = await explorer.search(cwd);
+  const projectCfg = result?.config || {};
+  const envCfg = {};
+  if (process.env.AICC_MODEL) envCfg.model = process.env.AICC_MODEL;
+  if (process.env.AICC_PRIVACY) envCfg.privacy = process.env.AICC_PRIVACY;
+  if (process.env.AICC_STYLE) envCfg.style = process.env.AICC_STYLE;
+  if (process.env.AICC_STYLE_SAMPLES)
+    envCfg.styleSamples = parseInt(process.env.AICC_STYLE_SAMPLES, 10);
+  if (process.env.AICC_MAX_TOKENS) envCfg.maxTokens = parseInt(process.env.AICC_MAX_TOKENS, 10);
+  if (process.env.AICC_MAX_FILE_LINES)
+    envCfg.maxFileLines = parseInt(process.env.AICC_MAX_FILE_LINES, 10);
+  if (process.env.AICC_VERBOSE) envCfg.verbose = process.env.AICC_VERBOSE === "true";
+  const merged = {
+    ...DEFAULTS,
+    ...globalCfg,
+    ...projectCfg,
+    ...envCfg
+  };
+  merged.plugins = (merged.plugins || []).filter((p) => {
+    const abs = resolve(cwd, p);
+    return existsSync(abs);
+  });
+  if (!merged.skipFilePatterns) {
+    merged.skipFilePatterns = DEFAULTS.skipFilePatterns;
+  }
+  const sources = Object.keys(merged).reduce((acc, key) => {
+    const k = key;
+    let src = "default";
+    if (k in globalCfg) src = "global";
+    if (k in projectCfg) src = "project";
+    if (k in envCfg) src = "env";
+    acc[k] = src;
+    return acc;
+  }, {});
+  const withMeta = Object.assign(merged, { _sources: sources });
+  return {
+    config: withMeta,
+    raw: { defaults: DEFAULTS, global: globalCfg, project: projectCfg, env: envCfg }
+  };
+}
+
+export {
+  getGlobalConfigPath,
+  saveGlobalConfig,
+  loadConfig,
+  loadConfigDetailed
+};

package/dist/chunk-WW3N76NL.js

@@ -0,0 +1,586 @@
+// src/prompt.ts
+var matchesPattern = (filePath, pattern) => {
+  const regexPattern = pattern.replace(/\*\*/g, "\xA7DOUBLESTAR\xA7").replace(/\*/g, "[^/]*").replace(/§DOUBLESTAR§/g, ".*").replace(/\./g, "\\.").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filePath);
+};
+var summarizeDiffForPrompt = (files, privacy, maxFileLines, skipFilePatterns) => {
+  const getTotalLines = (f) => {
+    return f.hunks.reduce((sum, h) => sum + h.lines.length, 0);
+  };
+  const shouldSkipFile = (filePath) => {
+    return skipFilePatterns.some((pattern) => matchesPattern(filePath, pattern));
+  };
+  if (privacy === "high") {
+    return files.map((f) => {
+      const totalLines = getTotalLines(f);
+      const patternSkipped = shouldSkipFile(f.file);
+      const sizeSkipped = totalLines > maxFileLines;
+      const skipped = patternSkipped || sizeSkipped;
+      const reason = patternSkipped ? "generated/lock file" : "large file";
+      return `file: ${f.file} (+${f.additions} -${f.deletions}) hunks:${f.hunks.length}${skipped ? ` [${reason}, content skipped]` : ""}`;
+    }).join("\n");
+  }
+  if (privacy === "medium") {
+    return files.map((f) => {
+      const totalLines = getTotalLines(f);
+      const patternSkipped = shouldSkipFile(f.file);
+      const sizeSkipped = totalLines > maxFileLines;
+      if (patternSkipped || sizeSkipped) {
+        const reason = patternSkipped ? "generated/lock file" : "large file";
+        return `file: ${f.file} (+${f.additions} -${f.deletions}) hunks:${f.hunks.length} [${reason}, content skipped]`;
+      }
+      return `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) => {
+    const totalLines = getTotalLines(f);
+    const patternSkipped = shouldSkipFile(f.file);
+    const sizeSkipped = totalLines > maxFileLines;
+    if (patternSkipped || sizeSkipped) {
+      const reason = patternSkipped ? "generated/lock file" : "large file";
+      return `file: ${f.file} (+${f.additions} -${f.deletions}) hunks:${f.hunks.length} [${reason}, content skipped]`;
+    }
+    return `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,
+    config.maxFileLines,
+    config.skipFilePatterns
+  );
+  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[], "files"?: string[] } ], "meta": { "splitRecommended": boolean } }'
+  );
+  specLines.push("Primary Output Field: commits[ ].title");
+  specLines.push("Title Format (REQUIRED): <type>(<scope>): <subject>");
+  specLines.push(
+    "Title Length Guidance: Aim for <=50 chars ideal; absolute max 72 (do not exceed)."
+  );
+  specLines.push("Types (JSON mapping follows on next line)");
+  specLines.push("TypeMap: " + JSON.stringify(TYPE_MAP));
+  specLines.push(
+    "Scope Rules: ALWAYS include a concise lowercase kebab-case scope (derive from dominant directory, package, or feature); never omit."
+  );
+  specLines.push(
+    "Subject Rules: imperative mood, present tense, no leading capital unless proper noun, no trailing period."
+  );
+  specLines.push(
+    "Length Rule: Keep titles concise; prefer 50 or fewer chars; MUST be <=72 including type/scope."
+  );
+  specLines.push(
+    "Emoji Rule: " + (config.style === "gitmoji" || config.style === "gitmoji-pure" ? "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(
+    'When mode is split, WHERE POSSIBLE add a "files" array per commit listing the most relevant changed file paths (1-6, minimize overlap across commits).'
+  );
+  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 (REQUIRED): <type>(<scope>): <subject> (<=72 chars)");
+  spec.push("Subject: imperative, present tense, no trailing period.");
+  spec.push(
+    "Emoji Rule: " + (config.style === "gitmoji" || config.style === "gitmoji-pure" ? "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; ensure a scope is present (infer one if missing); only improve clarity, 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
+import { z } from "zod";
+import { execa } from "execa";
+var OpenCodeProvider = class {
+  constructor(model = "github-copilot/gpt-4.1") {
+    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 || "120000", 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((resolve, 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 = 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}`
+          );
+        }
+        resolve(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 = z.object({
+  title: z.string().min(5).max(150),
+  body: z.string().optional().default(""),
+  score: z.number().min(0).max(100),
+  reasons: z.array(z.string()).optional().default([]),
+  files: z.array(z.string()).optional().default([])
+});
+var PlanSchema = z.object({
+  commits: z.array(CommitSchema).min(1),
+  meta: z.object({
+    splitRecommended: 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/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;
+};
+var checkCandidate = (candidate) => {
+  const errs = [];
+  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 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;
+  }
+  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;
+  }
+  let m = norm.match(EMOJI_TYPE_RE);
+  if (m) {
+    return norm;
+  }
+  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;
+};
+
+// src/workflow/ui.ts
+import chalk from "chalk";
+function animateHeaderBase(text = "ai-conventional-commit", modelSegment) {
+  const mainText = text;
+  const modelSeg = modelSegment ? ` (using ${modelSegment})` : "";
+  if (!process.stdout.isTTY || process.env.AICC_NO_ANIMATION) {
+    if (modelSeg) console.log("\n\u250C " + chalk.bold(mainText) + chalk.dim(modelSeg));
+    else console.log("\n\u250C " + chalk.bold(mainText));
+    return Promise.resolve();
+  }
+  const palette = [
+    "#3a0d6d",
+    "#5a1ea3",
+    "#7a32d6",
+    "#9a4dff",
+    "#b267ff",
+    "#c37dff",
+    "#b267ff",
+    "#9a4dff",
+    "#7a32d6",
+    "#5a1ea3"
+  ];
+  process.stdout.write("\n");
+  return palette.reduce(async (p, color) => {
+    await p;
+    const frame = chalk.bold.hex(color)(mainText);
+    if (modelSeg) process.stdout.write("\r\u250C " + frame + chalk.dim(modelSeg));
+    else process.stdout.write("\r\u250C " + frame);
+    await new Promise((r) => setTimeout(r, 60));
+  }, Promise.resolve()).then(() => process.stdout.write("\n"));
+}
+function borderLine(content) {
+  if (!content) console.log("\u2502");
+  else console.log("\u2502 " + content);
+}
+function sectionTitle(label) {
+  console.log("\u2299 " + chalk.bold(label));
+}
+function abortMessage() {
+  console.log("\u2514 \u{1F645}\u200D\u2640\uFE0F No commit created.");
+  console.log();
+}
+function finalSuccess(opts) {
+  const elapsedMs = Date.now() - opts.startedAt;
+  const seconds = elapsedMs / 1e3;
+  const dur = seconds >= 0.1 ? seconds.toFixed(1) + "s" : elapsedMs + "ms";
+  const plural = opts.count !== 1;
+  if (plural) console.log(`\u2514 \u2728 ${opts.count} commits created in ${dur}.`);
+  else console.log(`\u2514 \u2728 commit created in ${dur}.`);
+  console.log();
+}
+function createPhasedSpinner(oraLib) {
+  const useAnim = process.stdout.isTTY && !process.env.AICC_NO_ANIMATION && !process.env.AICC_NO_SPINNER_ANIM;
+  const palette = [
+    "#3a0d6d",
+    "#5a1ea3",
+    "#7a32d6",
+    "#9a4dff",
+    "#b267ff",
+    "#c37dff",
+    "#b267ff",
+    "#9a4dff",
+    "#7a32d6",
+    "#5a1ea3"
+  ];
+  let label = "Starting";
+  let i = 0;
+  const spinner = oraLib({ text: chalk.bold(label), spinner: "dots" }).start();
+  let interval = null;
+  function frame() {
+    if (!useAnim) return;
+    spinner.text = chalk.bold.hex(palette[i])(label);
+    i = (i + 1) % palette.length;
+  }
+  if (useAnim) {
+    frame();
+    interval = setInterval(frame, 80);
+  }
+  function setLabel(next) {
+    label = next;
+    if (useAnim) {
+      i = 0;
+      frame();
+    } else {
+      spinner.text = chalk.bold(label);
+    }
+  }
+  function stopAnim() {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+  }
+  return {
+    spinner,
+    async step(l, fn) {
+      setLabel(l);
+      try {
+        return await fn();
+      } catch (e) {
+        stopAnim();
+        const msg = `${l} failed: ${e?.message || e}`.replace(/^\s+/, "");
+        spinner.fail(msg);
+        throw e;
+      }
+    },
+    phase(l) {
+      setLabel(l);
+    },
+    stop() {
+      stopAnim();
+      spinner.stop();
+    }
+  };
+}
+function renderCommitBlock(opts) {
+  const dim = (s) => chalk.dim(s);
+  const white = (s) => chalk.white(s);
+  const msgColor = opts.messageLabelColor || dim;
+  const descColor = opts.descriptionLabelColor || dim;
+  const titleColor = opts.titleColor || white;
+  const bodyFirst = opts.bodyFirstLineColor || white;
+  const bodyRest = opts.bodyLineColor || white;
+  if (opts.fancy) {
+    const heading = opts.heading ? chalk.hex("#9a4dff").bold(opts.heading) : void 0;
+    if (heading) borderLine(heading);
+    borderLine(msgColor("Title:") + " " + titleColor(`${opts.indexPrefix || ""}${opts.title}`));
+  } else {
+    if (opts.heading) borderLine(chalk.bold(opts.heading));
+    if (!opts.hideMessageLabel)
+      borderLine(msgColor("Message:") + " " + titleColor(`${opts.indexPrefix || ""}${opts.title}`));
+    else
+      borderLine(msgColor("Title:") + " " + titleColor(`${opts.indexPrefix || ""}${opts.title}`));
+  }
+  borderLine();
+  if (opts.body) {
+    const lines = opts.body.split("\n");
+    lines.forEach((line, i) => {
+      if (line.trim().length === 0) borderLine();
+      else if (i === 0) {
+        borderLine(descColor("Description:"));
+        borderLine(bodyFirst(line));
+      } else borderLine(bodyRest(line));
+    });
+  }
+}
+
+export {
+  buildGenerationMessages,
+  buildRefineMessages,
+  OpenCodeProvider,
+  extractJSON,
+  checkCandidate,
+  formatCommitTitle,
+  animateHeaderBase,
+  borderLine,
+  sectionTitle,
+  abortMessage,
+  finalSuccess,
+  createPhasedSpinner,
+  renderCommitBlock
+};

package/dist/config-C3S4LWLD.js

@@ -0,0 +1,12 @@
+import {
+  getGlobalConfigPath,
+  loadConfig,
+  loadConfigDetailed,
+  saveGlobalConfig
+} from "./chunk-HJR5M6U7.js";
+export {
+  getGlobalConfigPath,
+  loadConfig,
+  loadConfigDetailed,
+  saveGlobalConfig
+};

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   loadConfig
-} from "./chunk-DCGUX6KW.js";
+} from "./chunk-HJR5M6U7.js";
 import {
   OpenCodeProvider,
   abortMessage,
@@ -16,7 +16,7 @@ import {
   formatCommitTitle,
   renderCommitBlock,
   sectionTitle
-} from "./chunk-H4W6AMGZ.js";
+} from "./chunk-WW3N76NL.js";
 
 // src/index.ts
 import { Cli, Command, Option } from "clipanion";
@@ -34,7 +34,7 @@ var ensureStagedChanges = async () => {
   return status.staged.length > 0;
 };
 var getStagedDiffRaw = async () => {
-  return git.diff(["--cached", "--unified=3", "--no-color"]);
+  return git.diff(["--cached", "--unified=3", "--no-color", "-M"]);
 };
 var HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
 var parseDiffFromRaw = (raw) => {
@@ -54,6 +54,9 @@ var parseDiffFromRaw = (raw) => {
     }
     if (line.startsWith("diff --git")) continue;
     if (line.startsWith("index ")) continue;
+    if (line.startsWith("similarity index ")) continue;
+    if (line.startsWith("rename from ")) continue;
+    if (line.startsWith("rename to ")) continue;
     if (/^deleted file mode /.test(line)) {
       if (currentFile) currentFile.deleted = true;
       continue;
@@ -854,7 +857,7 @@ var ModelsCommand = class extends Command {
   });
   async execute() {
     if (this.current) {
-      const { loadConfigDetailed } = await import("./config-Q7AKJSO4.js");
+      const { loadConfigDetailed } = await import("./config-C3S4LWLD.js");
       const { config } = await loadConfigDetailed();
       this.context.stdout.write(`${config.model} (source: ${config._sources.model})
 `);
@@ -898,7 +901,7 @@ var ModelsCommand = class extends Command {
       this.context.stdout.write(model + "\n");
       if (this.save) {
         try {
-          const { saveGlobalConfig } = await import("./config-Q7AKJSO4.js");
+          const { saveGlobalConfig } = await import("./config-C3S4LWLD.js");
           const path = saveGlobalConfig({ model });
           this.context.stdout.write(`Saved as default model in ${path}
 `);
@@ -933,7 +936,7 @@ var ConfigShowCommand = class extends Command {
   });
   json = Option.Boolean("--json", false, { description: "Output JSON including _sources" });
   async execute() {
-    const { loadConfigDetailed } = await import("./config-Q7AKJSO4.js");
+    const { loadConfigDetailed } = await import("./config-C3S4LWLD.js");
     const { config, raw } = await loadConfigDetailed();
     if (this.json) {
       this.context.stdout.write(JSON.stringify({ config, raw }, null, 2) + "\n");
@@ -958,7 +961,7 @@ var ConfigGetCommand = class extends Command {
   key = Option.String();
   withSource = Option.Boolean("--with-source", false, { description: "Append source label" });
   async execute() {
-    const { loadConfigDetailed } = await import("./config-Q7AKJSO4.js");
+    const { loadConfigDetailed } = await import("./config-C3S4LWLD.js");
     const { config } = await loadConfigDetailed();
     const key = this.key;
     if (!(key in config)) {
@@ -1006,7 +1009,7 @@ var ConfigSetCommand = class extends Command {
       } catch {
       }
     }
-    const { saveGlobalConfig } = await import("./config-Q7AKJSO4.js");
+    const { saveGlobalConfig } = await import("./config-C3S4LWLD.js");
     const path = saveGlobalConfig({ [this.key]: parsed });
     this.context.stdout.write(`Saved ${this.key} to ${path}
 `);
@@ -1027,7 +1030,7 @@ var RewordCommand = class extends Command {
   style = Option.String("--style", { required: false, description: "Title style override" });
   model = Option.String("-m,--model", { required: false, description: "Model override" });
   async execute() {
-    const { runReword } = await import("./reword-IN2D2J4H.js");
+    const { runReword } = await import("./reword-Q7MES34W.js");
     const config = await loadConfig();
     if (this.style) config.style = this.style;
     if (this.model) config.model = this.model;

package/dist/reword-Q7MES34W.js

@@ -0,0 +1,212 @@
+import {
+  OpenCodeProvider,
+  abortMessage,
+  animateHeaderBase,
+  borderLine,
+  buildRefineMessages,
+  createPhasedSpinner,
+  extractJSON,
+  finalSuccess,
+  formatCommitTitle,
+  renderCommitBlock,
+  sectionTitle
+} from "./chunk-WW3N76NL.js";
+
+// src/workflow/reword.ts
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { simpleGit } from "simple-git";
+var git = simpleGit();
+async function getCommitMessage(hash) {
+  try {
+    const raw = await git.show([`${hash}`, "--quiet", "--format=%P%n%B"]);
+    const lines = raw.split("\n");
+    const parentsLine = lines.shift() || "";
+    const parents = parentsLine.trim().length ? parentsLine.trim().split(/\s+/) : [];
+    const message = lines.join("\n").trim();
+    if (!message) return null;
+    const [first, ...rest] = message.split("\n");
+    const body = rest.join("\n").trim() || void 0;
+    return { title: first, body, parents };
+  } catch {
+    return null;
+  }
+}
+async function isAncestor(ancestor, head) {
+  try {
+    const mb = (await git.raw(["merge-base", ancestor, head])).trim();
+    const anc = (await git.revparse([ancestor])).trim();
+    return mb === anc;
+  } catch {
+    return false;
+  }
+}
+async function runReword(config, hash) {
+  const startedAt = Date.now();
+  const commit = await getCommitMessage(hash);
+  if (!commit) {
+    console.log(`Commit not found: ${hash}`);
+    return;
+  }
+  if (commit.parents.length > 1) {
+    console.log("Refusing to reword a merge commit (multiple parents).");
+    return;
+  }
+  if (process.stdout.isTTY) {
+    await animateHeaderBase("ai-conventional-commit", config.model);
+    borderLine();
+  }
+  sectionTitle("Original commit");
+  borderLine(chalk.yellow(commit.title));
+  if (commit.body) {
+    commit.body.split("\n").forEach((l) => l.trim().length ? borderLine(l) : borderLine());
+  }
+  borderLine();
+  const instructions = [
+    "Improve clarity & conformity to Conventional Commits while preserving meaning."
+  ];
+  const syntheticPlan = {
+    commits: [
+      {
+        title: commit.title,
+        body: commit.body,
+        score: 0,
+        reasons: []
+      }
+    ]
+  };
+  const provider = new OpenCodeProvider(config.model);
+  const phased = createPhasedSpinner(ora);
+  let refined = null;
+  try {
+    phased.phase("Preparing prompt");
+    const messages = buildRefineMessages({
+      originalPlan: syntheticPlan,
+      index: 0,
+      instructions,
+      config
+    });
+    phased.phase("Calling model");
+    const raw = await provider.chat(messages, { maxTokens: config.maxTokens });
+    phased.phase("Parsing response");
+    refined = await extractJSON(raw);
+  } catch (e) {
+    phased.spinner.fail("Reword failed: " + (e?.message || e));
+    return;
+  }
+  phased.stop();
+  if (!refined || !refined.commits.length) {
+    console.log("No refined commit produced.");
+    return;
+  }
+  const candidate = refined.commits[0];
+  candidate.title = formatCommitTitle(candidate.title, {
+    allowGitmoji: config.style === "gitmoji" || config.style === "gitmoji-pure",
+    mode: config.style
+  });
+  sectionTitle("Proposed commit");
+  renderCommitBlock({
+    title: chalk.yellow(candidate.title),
+    body: candidate.body,
+    hideMessageLabel: true
+  });
+  borderLine();
+  const resolvedHash = (await git.revparse([hash])).trim();
+  const headHash = (await git.revparse(["HEAD"])).trim();
+  const isHead = headHash === resolvedHash || headHash.startsWith(resolvedHash);
+  const { ok } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "ok",
+      message: isHead ? "Amend HEAD with this message?" : "Apply rewrite (history will change)?",
+      choices: [
+        { name: "Yes", value: true },
+        { name: "No", value: false }
+      ],
+      default: 0
+    }
+  ]);
+  if (!ok) {
+    borderLine();
+    abortMessage();
+    return;
+  }
+  const full = candidate.body ? `${candidate.title}
+
+${candidate.body}` : candidate.title;
+  if (isHead) {
+    try {
+      await git.commit(full, { "--amend": null });
+    } catch (e) {
+      borderLine("Failed to amend HEAD: " + (e?.message || e));
+      borderLine();
+      abortMessage();
+      return;
+    }
+    borderLine();
+    finalSuccess({ count: 1, startedAt });
+    return;
+  }
+  const ancestorOk = await isAncestor(resolvedHash, headHash);
+  if (!ancestorOk) {
+    borderLine("Selected commit is not an ancestor of HEAD.");
+    borderLine("Cannot safely rewrite automatically.");
+    borderLine();
+    abortMessage();
+    return;
+  }
+  let mergesRange = "";
+  try {
+    mergesRange = (await git.raw(["rev-list", "--merges", `${resolvedHash}..HEAD`])).trim();
+  } catch {
+  }
+  if (mergesRange) {
+    sectionTitle("Unsafe automatic rewrite");
+    borderLine("Merge commits detected between target and HEAD.");
+    borderLine("Falling back to manual instructions (preserving previous behavior).");
+    borderLine();
+    sectionTitle("Apply manually");
+    borderLine(`1. git rebase -i ${resolvedHash}~1 --reword`);
+    borderLine("2. Mark the line as reword if needed.");
+    borderLine("3. Replace the message with:");
+    borderLine();
+    borderLine(candidate.title);
+    if (candidate.body) candidate.body.split("\n").forEach((l) => borderLine(l || void 0));
+    borderLine();
+    abortMessage();
+    return;
+  }
+  try {
+    const tree = (await git.raw(["show", "-s", "--format=%T", resolvedHash])).trim();
+    const parent = commit.parents[0];
+    const args = ["commit-tree", tree];
+    if (parent) args.push("-p", parent);
+    args.push("-m", full);
+    const newHash = (await git.raw(args)).trim();
+    const currentBranch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    const rebaseTarget = currentBranch === "HEAD" ? "HEAD" : currentBranch;
+    await git.raw(["rebase", "--onto", newHash, resolvedHash, rebaseTarget]);
+    const afterBranch = (await git.revparse(["--abbrev-ref", "HEAD"])).trim();
+    if (afterBranch === "HEAD" && rebaseTarget !== "HEAD") {
+      try {
+        await git.checkout([rebaseTarget]);
+      } catch {
+      }
+    }
+    sectionTitle("Updated commit");
+    borderLine(`Rewrote ${resolvedHash.slice(0, 7)} \u2192 ${newHash.slice(0, 7)}`);
+    renderCommitBlock({ title: candidate.title, body: candidate.body, hideMessageLabel: true });
+    borderLine();
+    finalSuccess({ count: 1, startedAt });
+  } catch (e) {
+    borderLine("Automatic rewrite failed: " + (e?.message || e));
+    borderLine("If a rebase is in progress, resolve conflicts then run: git rebase --continue");
+    borderLine("Or abort with: git rebase --abort");
+    borderLine();
+    abortMessage();
+  }
+}
+export {
+  runReword
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kud/ai-conventional-commit-cli",
-  "version": "0.12.12",
+  "version": "0.13.1",
   "type": "module",
   "description": "Opinionated, style-aware AI assistant for crafting and splitting git commits (opencode-based, provider-agnostic).",
   "bin": {