@sabinm677/ccommit 0.1.0 → 0.2.1

package/README.md

@@ -1,11 +1,12 @@
 # ccommit
 
-Generate Conventional Commit messages from staged Git changes using Claude Code CLI, OpenCode CLI, or Codex CLI.
+Generate Conventional Commit messages from staged Git changes using Claude Code CLI, OpenCode CLI, Codex CLI, Kilo Code CLI, Qwen Code CLI, or Gemini CLI.
 
 ## Requirements
-- Bun 1.0+
+- Node 18+ or Bun 1.0+
 - Git 2.0+
-- Claude Code CLI, OpenCode CLI, or Codex CLI configured and available on `PATH`
+- One supported provider CLI configured and available on `PATH` (`claude`, `opencode`, `codex`, `kilo`, `qwen`, or `gemini`)
+- Native support for Windows, macOS, and Linux
 
 ## Usage
 ```bash
@@ -31,6 +32,8 @@ ln -sf "$(pwd)/bin/ccommit" ~/.local/bin/ccommit
 
 If needed, add `~/.local/bin` to your `PATH`.
 
+## Behavior
+
 Default mode:
 - Generates a commit message from staged changes
 - Shows the message
@@ -44,33 +47,61 @@ ccommit --show
 ccommit -s
 ```
 
-Choose provider explicitly:
+Override generated first line:
+```bash
+ccommit -m "ABC-1: Some message"
+ccommit --message "ABC-1: Some message"
+```
+
+Choose provider for one run:
 ```bash
-bin/ccommit -p opencode
 ccommit --provider opencode
-ccommit -p opencode
 ccommit -p codex
-ccommit --yes
+ccommit -p kilo
+ccommit -p qwen
+ccommit -p gemini
+```
+
+Persist a default provider:
+```bash
+ccommit --set-provider codex
+ccommit -sp opencode
+ccommit --set-provider=opencode
 ```
 
 ## Options
 - `-s`, `--show`: Generate and print message only. Do not prompt or create commit.
 - `-y`, `--yes`: Create commit without interactive confirmation.
-- `-p`, `--provider <claude|opencode|codex>`: Select AI provider for this run.
+- `-m`, `--message <text>`: Replace the first line of the generated commit message. Remaining lines are preserved.
+- `-p`, `--provider <claude|opencode|codex|kilo|qwen|gemini>`: Select AI provider for this run.
+- `-sp`, `--set-provider <claude|opencode|codex|kilo|qwen|gemini>`: Persist default provider to config and exit.
 - `-h`, `--help`: Show usage help.
 - `-v`, `--version`: Show CLI version.
 - `--verbose`: Print debug details to stderr, including provider failure diagnostics.
 
-ccommit prints the selected provider in the header (including `--show`/`-s` mode):
+## Commit Format
+ccommit enforces Conventional Commits with a required multi-line message:
+- Header format: `<type>[optional scope][optional !]: <description>`
+- At least one non-empty body line is required
+- `BREAKING CHANGE:` footer is supported
+
+Example output:
+```text
+feat(parser): improve prompt normalization
+
+Improve normalization to keep body content stable across providers.
+```
+
+ccommit prints the selected provider in the header (including `--show` mode):
 ```text
-Generated commit message (provider):
 Generated commit message (claude):
-Generated commit message (opencode):
-Generated commit message (codex):
 ```
 
 ## Config
-Optional config file: `~/.config/ccommit/config.json`
+Optional config file locations:
+- Windows: `%APPDATA%\\ccommit\\config.json`
+- macOS/Linux: `$XDG_CONFIG_HOME/ccommit/config.json` or `~/.config/ccommit/config.json`
+- Override on any OS: `CCOMMIT_CONFIG_PATH=/custom/path/config.json`
 
 ```json
 {
@@ -78,13 +109,17 @@ Optional config file: `~/.config/ccommit/config.json`
   "providers": {
     "claude": { "command": "claude", "args": ["-p"] },
     "opencode": { "command": "opencode", "args": ["run"] },
-    "codex": { "command": "codex", "args": ["exec"] }
+    "codex": { "command": "codex", "args": ["exec"] },
+    "kilo": { "command": "kilo", "args": ["run"] },
+    "qwen": { "command": "qwen", "args": ["run"] },
+    "gemini": { "command": "gemini", "args": ["-p"] }
   }
 }
 ```
 
 Precedence for provider/command settings: `CLI > env > config > defaults`.
 Default provider: `claude`.
+`--set-provider` updates the config file and can run outside a Git repository.
 
 ## Exit Codes
 - `0`: success
@@ -96,6 +131,21 @@ Run tests:
 bun test
 ```
 
+Build standalone executables:
+```bash
+bun run build:bin
+# or only current platform/arch
+bun run build:bin:current
+```
+
+Build outputs are written to `dist/`:
+- `ccommit-darwin-x64`
+- `ccommit-darwin-arm64`
+- `ccommit-linux-x64`
+- `ccommit-linux-arm64`
+- `ccommit-windows-x64.exe`
+- `ccommit-windows-arm64.exe`
+
 Node compatibility:
 - `ccommit` is Bun-first, but basic CLI invocation with Node remains supported (for example `node bin/ccommit --version`).
 
@@ -106,8 +156,11 @@ For local testing without provider API calls:
 - `CCOMMIT_MOCK_ERROR=NETWORK` to force network error.
 
 Provider env overrides:
-- `CCOMMIT_PROVIDER=claude|opencode|codex`
+- `CCOMMIT_PROVIDER=claude|opencode|codex|kilo|qwen|gemini`
 - `CCOMMIT_CLAUDE_CMD`, `CCOMMIT_CLAUDE_ARGS`
 - `CCOMMIT_OPENCODE_CMD`, `CCOMMIT_OPENCODE_ARGS`
 - `CCOMMIT_CODEX_CMD`, `CCOMMIT_CODEX_ARGS`
+- `CCOMMIT_KILO_CMD`, `CCOMMIT_KILO_ARGS`
+- `CCOMMIT_QWEN_CMD`, `CCOMMIT_QWEN_ARGS`
+- `CCOMMIT_GEMINI_CMD`, `CCOMMIT_GEMINI_ARGS`
 - `CCOMMIT_PROVIDER_TIMEOUT_MS` (optional, default `60000`)

package/bin/ccommit

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { run } from "../src/main.js";
 
 await run(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabinm677/ccommit",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "AI-powered Git commit message generator with Conventional Commits output.",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,9 @@
     "ccommit": "./bin/ccommit"
   },
   "scripts": {
-    "test": "bun test"
+    "test": "bun test",
+    "build:bin": "node scripts/build-binaries.mjs",
+    "build:bin:current": "node scripts/build-binaries.mjs --current"
   },
   "engines": {
     "bun": ">=1.0.0",

package/src/ai/generate.js

@@ -82,6 +82,20 @@ function writeVerboseFailure(options, details) {
   );
 }
 
+export function getProviderSpawnOptions(
+  timeout,
+  { platform = process.platform } = {},
+) {
+  const isWindows = platform === "win32";
+  return {
+    encoding: "utf8",
+    maxBuffer: 10 * 1024 * 1024,
+    timeout,
+    shell: isWindows,
+    windowsHide: isWindows,
+  };
+}
+
 export function generateCommitMessage(prompt, options = {}, config = {}) {
   const provider = resolveProvider(options, config);
   const errors = getProviderErrors();
@@ -103,11 +117,11 @@ export function generateCommitMessage(prompt, options = {}, config = {}) {
   const timeout = resolveProviderTimeoutMs();
   let result;
   try {
-    result = spawnSync(command, [...args, prompt], {
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024,
-      timeout,
-    });
+    result = spawnSync(
+      command,
+      [...args, prompt],
+      getProviderSpawnOptions(timeout),
+    );
   } catch (error) {
     writeVerboseFailure(options, {
       provider,

package/src/ai/prompt-builder.js

@@ -51,7 +51,7 @@ Rules:
 - Allowed types: ${COMMIT_TYPES.join(", ")}.
 - Format header exactly: <type>[optional scope][optional !]: <description>
 - Description must be concise and imperative.
-- Prefer a single-line commit message. Add body/footer only if essential.
+- Use a multi-line commit message with a meaningful body.
 - Do not claim changes that are not present in the staged diff.
 - Do not use markdown bullets in the commit body.
 - ${typeGuidance}

package/src/ai/provider-resolution.js

@@ -33,7 +33,13 @@ export function resolveCommand(provider, config = {}) {
       ? { command: "claude", args: ["-p"] }
       : provider === "opencode"
         ? { command: "opencode", args: ["run"] }
-        : { command: "codex", args: ["exec"] };
+        : provider === "codex"
+          ? { command: "codex", args: ["exec"] }
+          : provider === "kilo"
+            ? { command: "kilo", args: ["run"] }
+            : provider === "qwen"
+              ? { command: "qwen", args: ["run"] }
+              : { command: "gemini", args: ["-p"] };
 
   if (provider === "claude") {
     if (process.env.CCOMMIT_CLAUDE_CMD || process.env.CCOMMIT_CLAUDE_ARGS) {
@@ -58,6 +64,29 @@ export function resolveCommand(provider, config = {}) {
         args: splitArgs(process.env.CCOMMIT_CODEX_ARGS || defaults.args.join(" ")),
       };
     }
+  } else if (provider === "kilo") {
+    if (process.env.CCOMMIT_KILO_CMD || process.env.CCOMMIT_KILO_ARGS) {
+      return {
+        command: process.env.CCOMMIT_KILO_CMD || defaults.command,
+        args: splitArgs(process.env.CCOMMIT_KILO_ARGS || defaults.args.join(" ")),
+      };
+    }
+  } else if (provider === "qwen") {
+    if (process.env.CCOMMIT_QWEN_CMD || process.env.CCOMMIT_QWEN_ARGS) {
+      return {
+        command: process.env.CCOMMIT_QWEN_CMD || defaults.command,
+        args: splitArgs(process.env.CCOMMIT_QWEN_ARGS || defaults.args.join(" ")),
+      };
+    }
+  } else if (provider === "gemini") {
+    if (process.env.CCOMMIT_GEMINI_CMD || process.env.CCOMMIT_GEMINI_ARGS) {
+      return {
+        command: process.env.CCOMMIT_GEMINI_CMD || defaults.command,
+        args: splitArgs(
+          process.env.CCOMMIT_GEMINI_ARGS || defaults.args.join(" "),
+        ),
+      };
+    }
   }
 
   const providerConfig = config.providers?.[provider];

package/src/ai/providers.js

@@ -1,4 +1,11 @@
-export const AI_PROVIDERS = ["claude", "opencode", "codex"];
+export const AI_PROVIDERS = [
+  "claude",
+  "opencode",
+  "codex",
+  "kilo",
+  "qwen",
+  "gemini",
+];
 
 export function isValidProvider(provider) {
   return AI_PROVIDERS.includes(provider);

package/src/ai/response-parser.js

@@ -6,9 +6,18 @@ function stripCodeFence(text) {
   return text;
 }
 
+function stripCommitTrailers(text) {
+  return text
+    .split("\n")
+    .filter((line) => !/^co-authored-by:\s*/i.test(line.trim()))
+    .join("\n")
+    .trim();
+}
+
 export function parseCommitMessage(rawOutput) {
   let text = stripCodeFence(rawOutput).trim();
   text = text.replace(/^commit message:\s*/i, "").trim();
   text = text.replace(/^message:\s*/i, "").trim();
+  text = stripCommitTrailers(text);
   return text;
 }

package/src/cli/args.js

@@ -10,6 +10,8 @@ export function parseArgs(args) {
     version: false,
     verbose: false,
     provider: undefined,
+    setDefaultProvider: undefined,
+    message: undefined,
   };
 
   for (let index = 0; index < args.length; index += 1) {
@@ -34,6 +36,25 @@ export function parseArgs(args) {
       options.verbose = true;
       continue;
     }
+    if (arg === "--message" || arg === "-m") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("-") || !value.trim()) {
+        throw new AppError("Missing value for --message/-m.");
+      }
+      options.message = value.trim();
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--message=") || arg.startsWith("-m=")) {
+      const value = arg.startsWith("--message=")
+        ? arg.slice("--message=".length)
+        : arg.slice("-m=".length);
+      if (!value.trim()) {
+        throw new AppError("Missing value for --message/-m.");
+      }
+      options.message = value.trim();
+      continue;
+    }
     if (arg === "--provider" || arg === "-p") {
       const value = args[index + 1];
       if (!value || value.startsWith("-")) {
@@ -56,9 +77,37 @@ export function parseArgs(args) {
       options.provider = value;
       continue;
     }
+    if (arg === "--set-provider" || arg === "-sp") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new AppError("Missing value for --set-provider/-sp.");
+      }
+      if (!isValidProvider(value)) {
+        throw new AppError(ERROR_MESSAGES.INVALID_PROVIDER);
+      }
+      options.setDefaultProvider = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--set-provider=") || arg.startsWith("-sp=")) {
+      const value = arg.startsWith("--set-provider=")
+        ? arg.slice("--set-provider=".length)
+        : arg.slice("-sp=".length);
+      if (!isValidProvider(value)) {
+        throw new AppError(ERROR_MESSAGES.INVALID_PROVIDER);
+      }
+      options.setDefaultProvider = value;
+      continue;
+    }
     throw new AppError(`Unknown option: ${arg}`);
   }
 
+  if (options.provider && options.setDefaultProvider) {
+    throw new AppError(
+      "Cannot use --provider/-p together with --set-provider/-sp.",
+    );
+  }
+
   return options;
 }
 
@@ -70,7 +119,9 @@ Generate a Conventional Commit message from staged Git changes.
 Options:
   -s, --show      Show generated message only (do not commit)
   -y, --yes      Create commit without interactive confirmation
-  -p, --provider  AI provider: claude | opencode | codex
+  -m, --message   Override first line of generated message
+  -p, --provider  AI provider: claude | opencode | codex | kilo | qwen | gemini
+  -sp, --set-provider  Persist default provider: claude | opencode | codex | kilo | qwen | gemini
   -h, --help      Show help
   -v, --version   Show version
       --verbose   Print debug information to stderr

package/src/cli/compiled-entry.mjs

@@ -0,0 +1,6 @@
+import { run } from "../main.js";
+
+await run(process.argv.slice(2), {
+  version: process.env.CCOMMIT_VERSION,
+});
+process.exit(process.exitCode ?? 0);

package/src/commit/normalizer.js

@@ -12,10 +12,23 @@ function sanitizeDescription(raw) {
   return cleaned.charAt(0).toLowerCase() + cleaned.slice(1);
 }
 
+function toBodyLine(description) {
+  const sentence = sanitizeDescription(description);
+  return `${sentence.charAt(0).toUpperCase()}${sentence.slice(1)}.`;
+}
+
+function withBody(header, rest) {
+  if (rest.some((line) => line.trim().length > 0)) {
+    return [header, ...rest].join("\n").trim();
+  }
+  const description = header.split(":").slice(1).join(":").trim();
+  return `${header}\n\n${toBodyLine(description)}`;
+}
+
 export function normalizeCommitMessage(message) {
   const normalized = message.trim();
   if (!normalized) {
-    return "chore: update project files";
+    return "chore: update project files\n\nUpdate project files.";
   }
 
   const [header, ...rest] = normalized.split("\n");
@@ -25,12 +38,16 @@ export function normalizeCommitMessage(message) {
   );
 
   if (matchedType) {
-    return [cleanedHeader, ...rest].join("\n").trim();
+    return withBody(cleanedHeader, rest);
   }
 
   if (/^[a-z]+(\([^)]+\))?!?:/i.test(cleanedHeader)) {
-    return `chore: ${sanitizeDescription(cleanedHeader.split(":").slice(1).join(":"))}`;
+    const normalizedHeader = `chore: ${sanitizeDescription(
+      cleanedHeader.split(":").slice(1).join(":"),
+    )}`;
+    return withBody(normalizedHeader, rest);
   }
 
-  return `chore: ${sanitizeDescription(cleanedHeader)}`;
+  const normalizedHeader = `chore: ${sanitizeDescription(cleanedHeader)}`;
+  return withBody(normalizedHeader, rest);
 }

package/src/commit/validator.js

@@ -12,11 +12,15 @@ export function isValidCommitMessage(message) {
     return false;
   }
 
-  const [header] = normalized.split("\n");
+  const [header, ...rest] = normalized.split("\n");
   if (!HEADER_REGEX.test(header.trim())) {
     return false;
   }
 
+  if (!rest.some((line) => line.trim().length > 0)) {
+    return false;
+  }
+
   return true;
 }
 

package/src/config/loader.js

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { AppError } from "../errors/app-error.js";
 import { ERROR_MESSAGES } from "../errors/messages.js";
 import { isValidProvider } from "../ai/providers.js";
@@ -11,15 +11,69 @@ const defaultConfig = Object.freeze({
     claude: { command: undefined, args: undefined },
     opencode: { command: undefined, args: undefined },
     codex: { command: undefined, args: undefined },
+    kilo: { command: undefined, args: undefined },
+    qwen: { command: undefined, args: undefined },
+    gemini: { command: undefined, args: undefined },
   },
 });
 
+export function getLegacyConfigPath(homeDir = homedir()) {
+  return join(homeDir, ".config", "ccommit", "config.json");
+}
+
+export function getPrimaryConfigPath({
+  env = process.env,
+  platform = process.platform,
+  homeDir = homedir(),
+  cwd = process.cwd(),
+} = {}) {
+  const overridePath = env.CCOMMIT_CONFIG_PATH?.trim();
+  if (overridePath) {
+    return resolve(cwd, overridePath);
+  }
+
+  if (platform === "win32") {
+    const appData = env.APPDATA?.trim();
+    if (appData) {
+      return join(appData, "ccommit", "config.json");
+    }
+    return getLegacyConfigPath(homeDir);
+  }
+
+  const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
+  if (xdgConfigHome) {
+    return join(xdgConfigHome, "ccommit", "config.json");
+  }
+
+  return getLegacyConfigPath(homeDir);
+}
+
+export function getReadableConfigPath({
+  exists = existsSync,
+  env = process.env,
+  platform = process.platform,
+  homeDir = homedir(),
+  cwd = process.cwd(),
+} = {}) {
+  const primaryPath = getPrimaryConfigPath({ env, platform, homeDir, cwd });
+  if (exists(primaryPath)) {
+    return primaryPath;
+  }
+
+  const legacyPath = getLegacyConfigPath(homeDir);
+  if (legacyPath !== primaryPath && exists(legacyPath)) {
+    return legacyPath;
+  }
+
+  return primaryPath;
+}
+
 export function getConfigPath() {
-  return join(homedir(), ".config", "ccommit", "config.json");
+  return getPrimaryConfigPath();
 }
 
 export function loadConfig() {
-  const configPath = getConfigPath();
+  const configPath = getReadableConfigPath();
   if (!existsSync(configPath)) {
     return structuredClone(defaultConfig);
   }
@@ -34,6 +88,30 @@ export function loadConfig() {
   return normalizeConfig(raw);
 }
 
+export function setDefaultProvider(provider) {
+  const normalizedProvider = provider?.trim();
+  if (!normalizedProvider || !isValidProvider(normalizedProvider)) {
+    throw new AppError(ERROR_MESSAGES.INVALID_PROVIDER);
+  }
+
+  const configPath = getConfigPath();
+  const readablePath = getReadableConfigPath();
+  let raw = {};
+
+  if (existsSync(readablePath)) {
+    try {
+      raw = JSON.parse(readFileSync(readablePath, "utf8"));
+    } catch {
+      throw new AppError(ERROR_MESSAGES.INVALID_CONFIG_JSON);
+    }
+    normalizeConfig(raw);
+  }
+
+  raw.provider = normalizedProvider;
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf8");
+}
+
 function normalizeConfig(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     throw new AppError(ERROR_MESSAGES.INVALID_CONFIG);
@@ -59,7 +137,14 @@ function normalizeConfig(raw) {
     normalized.provider = provider.trim();
   }
 
-  for (const providerName of ["claude", "opencode", "codex"]) {
+  for (const providerName of [
+    "claude",
+    "opencode",
+    "codex",
+    "kilo",
+    "qwen",
+    "gemini",
+  ]) {
     const value = providers?.[providerName];
     if (value === undefined) {
       continue;

package/src/errors/messages.js

@@ -18,7 +18,7 @@ export const ERROR_MESSAGES = {
   INVALID_GENERATED_MESSAGE:
     "Generated commit message is invalid. Please retry or commit manually.",
   INVALID_PROVIDER:
-    "Invalid provider. Supported providers: claude, opencode, codex.",
+    "Invalid provider. Supported providers: claude, opencode, codex, kilo, qwen, gemini.",
   INVALID_CONFIG:
     "Invalid config file at ~/.config/ccommit/config.json.",
   INVALID_CONFIG_JSON:

package/src/main.js

@@ -16,16 +16,32 @@ import { resolveProvider } from "./ai/provider-resolution.js";
 import { parseCommitMessage } from "./ai/response-parser.js";
 import { isValidCommitMessage } from "./commit/validator.js";
 import { normalizeCommitMessage } from "./commit/normalizer.js";
-import { loadConfig } from "./config/loader.js";
+import { getConfigPath, loadConfig, setDefaultProvider } from "./config/loader.js";
+
+export function resolveVersion(runtime = {}) {
+  if (runtime.version) {
+    return runtime.version;
+  }
+
+  if (process.env.CCOMMIT_VERSION) {
+    return process.env.CCOMMIT_VERSION;
+  }
 
-function getVersion() {
   const currentFile = fileURLToPath(import.meta.url);
   const root = join(dirname(currentFile), "..");
   const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
   return pkg.version;
 }
 
-export async function run(args = []) {
+function replaceHeader(message, header) {
+  const [_, ...rest] = message.split("\n");
+  if (rest.length === 0) {
+    return header;
+  }
+  return [header, ...rest].join("\n");
+}
+
+export async function run(args = [], runtime = {}) {
   try {
     const options = parseArgs(args);
 
@@ -36,7 +52,16 @@ export async function run(args = []) {
     }
 
     if (options.version) {
-      writeStdout(`${getVersion()}\n`);
+      writeStdout(`${resolveVersion(runtime)}\n`);
+      process.exitCode = EXIT_CODES.SUCCESS;
+      return;
+    }
+
+    if (options.setDefaultProvider) {
+      setDefaultProvider(options.setDefaultProvider);
+      writeStdout(
+        `Default provider saved to ${getConfigPath()} as ${options.setDefaultProvider}.\n`,
+      );
       process.exitCode = EXIT_CODES.SUCCESS;
       return;
     }
@@ -60,6 +85,10 @@ export async function run(args = []) {
       throw new AppError(ERROR_MESSAGES.INVALID_GENERATED_MESSAGE);
     }
 
+    if (options.message) {
+      commitMessage = replaceHeader(commitMessage, options.message);
+    }
+
     if (options.show) {
       writeStdout(
         `Generated commit message (${provider}):\n\n${commitMessage.trim()}\n`,