@thankarezos/git-ai-commit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thankarezos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# git-aic
+
+Generate a git commit message from your staged diff using any AI CLI you already have on your machine (Claude Code, Gemini CLI, Codex, `llm`, Ollama, or a custom command). The message opens in your editor — save to commit, quit without saving to abort.
+
+```
+$ git aic -ap "mention the migration"
+# (AI runs against your staged diff, message opens in nano)
+# Save -> commit. Quit without saving -> abort.
+```
+
+## Install
+
+Until this is published to npm, install from source:
+
+```sh
+git clone https://github.com/<you>/git-ai-commit.git
+cd git-ai-commit
+npm link        # symlinks `git-aic` onto your PATH
+```
+
+> If `npm link` fails with `EACCES`, set a user-owned npm prefix:
+> ```sh
+> npm config set prefix ~/.npm-global
+> mkdir -p ~/.npm-global
+> # add to ~/.bashrc or ~/.zshrc:
+> export PATH="$HOME/.npm-global/bin:$PATH"
+> ```
+
+Requires **Node 18+**. Because the binary is named `git-aic`, git resolves `git aic` automatically.
+
+## Quick start
+
+```sh
+git add <files>
+git aic                          # generate, edit, commit
+git aic -a                       # stage everything first (git add -A)
+git aic -p "be terse"            # add hints to the prompt
+git aic -ap "be terse"           # combine -a and -p
+git aic --no-commit              # generate + edit only, don't commit
+```
+
+First run launches an **interactive wizard** that asks you to pick a provider, editor, and behavior flags, and writes the result to `~/.config/git-aic/config.json`. You can re-run it any time with `git aic --init`.
+
+## Flags
+
+| Flag | Meaning |
+|---|---|
+| `-a`, `--add` | Run `git add -A` before generating |
+| `-p "..."`, `--prompt "..."` | Append extra instructions to the AI prompt |
+| `-ap "..."`, `-pa "..."` | Combine `-a` and `-p` |
+| `--no-commit` | Generate and edit, but skip the `git commit` |
+| `--commit` | Force commit (overrides `commit: false` in config) |
+| `--require-edit` | Refuse to commit if the saved message is byte-identical to what the AI produced |
+| `--no-require-edit` | Allow committing the AI message unchanged |
+| `--init` | Run the interactive setup wizard |
+| `--config` | Print the active config path and contents |
+| `-h` | Show usage. (`--help` is intercepted by git, so use `-h`.) |
+
+## How it decides to commit
+
+After the AI generates a message, the file opens in your editor:
+
+- **Save** (`Ctrl+X` → `Y` in nano, `:wq` in vim) → commits.
+- **Quit without saving** (`Ctrl+X` → `N`, `:q!`) → aborts with `File not saved. Aborted.`
+- With `requireEdit: true`, the saved content must additionally differ from the AI's output, otherwise it aborts with `No edit detected. Aborted.`
+
+## Configuration
+
+Stored at `~/.config/git-aic/config.json` (override with `GIT_AIC_CONFIG=/path/to/config.json`):
+
+```json
+{
+  "provider": {
+    "command": "claude",
+    "args": ["-p", "{prompt}"]
+  },
+  "editor": "nano",
+  "commit": true,
+  "requireEdit": false
+}
+```
+
+- **`provider.command`** — the binary to invoke.
+- **`provider.args`** — argv passed to that binary. `{prompt}` and `{diff}` are placeholders. If neither `{prompt}` nor `{diff}` appear in the args, the prompt is appended as the last arg and the diff is piped on stdin.
+- **`editor`** — the editor command (overridden by `$EDITOR` if set).
+- **`commit`** — whether to actually `git commit` after editing.
+- **`requireEdit`** — require the saved message to differ from the AI output.
+
+### Overriding prompts and cleanup patterns
+
+The wizard (`git aic --init`) writes the full defaults into your config so you can see and edit everything in one place. Any of these fields can be removed, changed, or extended:
+
+- **`prompt`** — array of lines sent to the AI. Include `{extraPrompt}` somewhere if you want `-p "..."` to keep working.
+- **`commitMessageTag`** — the XML tag the AI is told to wrap the message in.
+- **`removeLinesMatching`** — case-insensitive regex strings; matching lines are stripped from the AI's output.
+- **`stopLinesMatching`** — case-insensitive regex strings; lines from the first match onward are dropped (used to cut off AI rambling).
+
+Each field in your user config **replaces** the default if present. If you delete a field entirely, the built-in default from `bin/prompts.json` is used instead.
+
+## Providers
+
+The wizard ships with presets for:
+
+- **Claude Code** — `claude -p "{prompt}"` (reads diff from stdin)
+- **Gemini CLI** — `gemini -p "{prompt}"`
+- **Codex CLI** — `codex exec --skip-git-repo-check "{prompt}"`
+- **llm** (Simon Willison) — `llm "{prompt}"`
+- **Ollama** — `ollama run llama3 "{prompt}"`
+- **Custom** — type your own `command` and `args`
+
+You can edit `provider` in the config file at any time, or rerun `git aic --init`.
+
+## Customizing the prompt
+
+The base prompt template, the `<commit_message>` tag, and the cleanup patterns live in `bin/prompts.json`. Edit that file to:
+
+- Change tone, rules, or allowed Conventional Commit types in `prompt`.
+- Add line patterns to `removeLinesMatching` to strip more AI boilerplate.
+- Add line patterns to `stopLinesMatching` to cut off output when the AI starts rambling.
+
+Patterns are case-insensitive JS regex strings.
+
+## Tests
+
+```sh
+npm test
+```
+
+Uses Node's built-in test runner (no external dependencies). Tests cover `cleanCommitMessage`, `extractCommitMessage`, and the config merge logic.
+
+## License
+
+MIT

package/bin/clean.js

@@ -0,0 +1,21 @@
+import { getConfiguration } from "./prompts.js";
+
+export function cleanCommitMessage(text) {
+  const cfg = getConfiguration();
+  const remove = (cfg.removeLinesMatching ?? []).map(
+    (source) => new RegExp(source, "i")
+  );
+  const stop = (cfg.stopLinesMatching ?? []).map(
+    (source) => new RegExp(source, "i")
+  );
+
+  const result = [];
+
+  for (const line of text.split("\n")) {
+    if (stop.some((re) => re.test(line))) break;
+    if (remove.some((re) => re.test(line))) continue;
+    result.push(line);
+  }
+
+  return result.join("\n").trim();
+}

package/bin/extract.js

@@ -0,0 +1,26 @@
+import { getConfiguration } from "./prompts.js";
+import { cleanCommitMessage } from "./clean.js";
+
+export function extractCommitMessage(raw) {
+  const cfg = getConfiguration();
+  const tagRegex = new RegExp(
+    `<${cfg.commitMessageTag}>\\s*([\\s\\S]*?)\\s*<\\/${cfg.commitMessageTag}>`,
+    "i"
+  );
+  const tagMatch = raw.match(tagRegex);
+
+  if (tagMatch?.[1]) {
+    return cleanCommitMessage(tagMatch[1]);
+  }
+
+  const lines = raw.split("\n");
+  const startIndex = lines.findIndex((line) =>
+    /^[a-z]+(\([^)]+\))?!?: /.test(line.trim())
+  );
+
+  if (startIndex === -1) {
+    return "";
+  }
+
+  return cleanCommitMessage(lines.slice(startIndex).join("\n"));
+}

package/bin/get-config-path.js

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function getConfigPath() {
+  return (
+    process.env.GIT_AIC_CONFIG ||
+    join(homedir(), ".config", "git-aic", "config.json")
+  );
+}
+
+export function loadConfig() {
+  const path = getConfigPath();
+
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Failed to read config: ${path}\n${error.message}`);
+  }
+}

package/bin/git-aic.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import crypto from "node:crypto";
+import { runInitWizard } from "./wizard.js";
+import { cleanCommitMessage } from "./clean.js";
+import { extractCommitMessage } from "./extract.js";
+import { runProvider } from "./run-provider.js";
+import { applyUserOverrides, getConfiguration } from "./prompts.js";
+import { getConfigPath, loadConfig } from "./get-config-path.js";
+
+function fail(message, code = 1) {
+  console.error(message);
+  process.exit(code);
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    ...options,
+  });
+}
+
+function parseArgs(argv) {
+  let extraPrompt = "";
+  let shouldCommit = null;
+  let requireEdit = null;
+  let printConfig = false;
+  let runInit = false;
+  let shouldAdd = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === "-ap" || arg === "-pa") {
+      shouldAdd = true;
+      extraPrompt = argv.slice(i + 1).join(" ");
+      break;
+    }
+
+    if (arg === "-p" || arg === "--prompt") {
+      extraPrompt = argv.slice(i + 1).join(" ");
+      break;
+    }
+
+    if (arg === "-a" || arg === "--add") {
+      shouldAdd = true;
+      continue;
+    }
+
+    if (arg === "--no-commit") {
+      shouldCommit = false;
+      continue;
+    }
+
+    if (arg === "--commit") {
+      shouldCommit = true;
+      continue;
+    }
+
+    if (arg === "--require-edit") {
+      requireEdit = true;
+      continue;
+    }
+
+    if (arg === "--no-require-edit") {
+      requireEdit = false;
+      continue;
+    }
+
+    if (arg === "--config") {
+      printConfig = true;
+      continue;
+    }
+
+    if (arg === "--init") {
+      runInit = true;
+      continue;
+    }
+
+    if (arg === "-h") {
+      console.log(`
+Usage:
+  git aic
+  git aic -a                    # stage all changes first (git add -A)
+  git aic -p "extra prompt"
+  git aic -ap "extra prompt"    # combine -a and -p
+  git aic --no-commit
+  git aic --config
+  git aic --init
+
+Examples:
+  git aic
+  git aic -a
+  git aic -p "prefer docs(specs), mention Asset Management API"
+  git aic -ap "mention Asset Management API"
+  git aic --no-commit -p "only generate the message"
+  git aic --init                # interactive config wizard
+
+Config:
+  ~/.config/git-aic/config.json
+
+Environment:
+  GIT_AIC_CONFIG=/path/to/config.json
+`);
+      process.exit(0);
+    }
+
+    extraPrompt += `${arg} `;
+  }
+
+  return {
+    extraPrompt: extraPrompt.trim(),
+    shouldCommit,
+    requireEdit,
+    printConfig,
+    runInit,
+    shouldAdd,
+  };
+}
+
+function sha256(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function buildPrompt(extraPrompt) {
+  const cfg = getConfiguration();
+  const { extraPrompt: token, extraPromptFallback } = cfg.placeholders;
+  return cfg.prompt.join("\n").replaceAll(token, extraPrompt || extraPromptFallback);
+}
+
+
+const args = parseArgs(process.argv.slice(2));
+const configPath = getConfigPath();
+
+if (args.runInit) {
+  await runInitWizard(configPath);
+  process.exit(0);
+}
+
+if (!existsSync(configPath)) {
+  console.log(`No config found at ${configPath}`);
+  console.log("Launching first-time setup...");
+  await runInitWizard(configPath);
+}
+
+let config;
+try {
+  config = loadConfig();
+} catch (error) {
+  fail(error.message);
+}
+
+applyUserOverrides(config);
+
+if (args.printConfig) {
+  console.log(getConfigPath());
+  console.log(JSON.stringify(config, null, 2));
+  process.exit(0);
+}
+
+const shouldCommit = args.shouldCommit ?? config.commit ?? true;
+const requireEdit = args.requireEdit ?? config.requireEdit ?? false;
+
+const insideRepo = run("git", ["rev-parse", "--is-inside-work-tree"]);
+
+if (insideRepo.status !== 0) {
+  fail("Not inside a git repository.");
+}
+
+if (args.shouldAdd) {
+  const addResult = run("git", ["add", "-A"]);
+  if (addResult.status !== 0) {
+    fail(addResult.stderr || "git add -A failed.");
+  }
+}
+
+const hasStagedChanges = run("git", ["diff", "--cached", "--quiet"]);
+
+if (hasStagedChanges.status === 0) {
+  fail("No staged changes found. Use: git add <files>");
+}
+
+const diff = run("git", ["diff", "--cached"]);
+
+if (diff.status !== 0) {
+  fail(diff.stderr || "Failed to read staged diff.");
+}
+
+const prompt = buildPrompt(args.extraPrompt);
+
+let raw;
+try {
+  raw = runProvider(config.provider, prompt, diff.stdout);
+} catch (error) {
+  fail(error.message);
+}
+
+const message = extractCommitMessage(raw);
+
+if (!message) {
+  fail("AI provider returned no valid commit message. Aborted.");
+}
+
+const dir = mkdtempSync(join(tmpdir(), "git-aic-"));
+const file = join(dir, "COMMIT_EDITMSG");
+
+writeFileSync(file, `${message.trim()}\n`);
+
+const before = sha256(readFileSync(file, "utf8"));
+const mtimeBefore = statSync(file).mtimeMs;
+
+const editor = process.env.EDITOR || config.editor || "nano";
+const editorResult = spawnSync(editor, [file], {
+  stdio: "inherit",
+});
+
+if (editorResult.status !== 0) {
+  rmSync(dir, { recursive: true, force: true });
+  fail("Editor exited with an error. Aborted.");
+}
+
+const mtimeAfter = statSync(file).mtimeMs;
+
+if (mtimeAfter === mtimeBefore) {
+  rmSync(dir, { recursive: true, force: true });
+  fail("File not saved. Aborted.");
+}
+
+const edited = readFileSync(file, "utf8");
+const after = sha256(edited);
+
+if (requireEdit && before === after) {
+  rmSync(dir, { recursive: true, force: true });
+  fail("No edit detected. Aborted.");
+}
+
+const finalMessage = cleanCommitMessage(edited);
+
+if (!finalMessage.trim()) {
+  rmSync(dir, { recursive: true, force: true });
+  fail("Commit message is empty. Aborted.");
+}
+
+writeFileSync(file, `${finalMessage.trim()}\n`);
+
+console.log();
+console.log("Final commit message:");
+console.log("---------------------");
+console.log(finalMessage.trim());
+console.log("---------------------");
+console.log();
+
+if (!shouldCommit) {
+  rmSync(dir, { recursive: true, force: true });
+  process.exit(0);
+}
+
+const commit = spawnSync("git", ["commit", "-F", file], {
+  stdio: "inherit",
+});
+
+rmSync(dir, { recursive: true, force: true });
+
+process.exit(commit.status ?? 1);

package/bin/presets.js

@@ -0,0 +1,29 @@
+export const PROVIDER_PRESETS = [
+  {
+    name: "Claude Code",
+    command: "claude",
+    args: ["-p", "{prompt}"]
+  },
+  {
+    name: "Gemini CLI",
+    command: "gemini",
+    args: ["-p", "{prompt}"]
+  },
+  {
+    name: "Codex CLI",
+    command: "codex",
+    args: ["exec", "--skip-git-repo-check", "{prompt}"]
+  },
+  {
+    name: "llm (Simon Willison)",
+    command: "llm",
+    args: ["{prompt}"]
+  },
+  {
+    name: "Ollama (llama3)",
+    command: "ollama",
+    args: ["run", "llama3", "{prompt}"]
+  }
+];
+
+export const EDITOR_PRESETS = ["nano", "vim", "nvim", "code --wait", "micro", "hx"];

package/bin/prompts.js

@@ -0,0 +1,32 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+export const defaults = JSON.parse(
+  readFileSync(join(here, "prompts.json"), "utf8")
+);
+
+let merged = defaults;
+
+export function mergeConfig(base, userConfig = {}) {
+  return {
+    ...base,
+    prompt: userConfig.prompt ?? base.prompt,
+    commitMessageTag: userConfig.commitMessageTag ?? base.commitMessageTag,
+    placeholders: base.placeholders,
+    removeLinesMatching:
+      userConfig.removeLinesMatching ?? base.removeLinesMatching,
+    stopLinesMatching:
+      userConfig.stopLinesMatching ?? base.stopLinesMatching,
+  };
+}
+
+export function applyUserOverrides(userConfig = {}) {
+  merged = mergeConfig(defaults, userConfig);
+}
+
+export function getConfiguration() {
+  return merged;
+}

package/bin/prompts.json

@@ -0,0 +1,44 @@
+{
+  "prompt": [
+    "Generate a git commit message for the staged diff.",
+    "",
+    "Return the commit message ONLY inside these tags:",
+    "",
+    "<commit_message>",
+    "type(scope): summary",
+    "",
+    "optional body",
+    "</commit_message>",
+    "",
+    "Rules:",
+    "- Use Conventional Commits.",
+    "- Allowed types: feat, fix, docs, style, refactor, test, chore, build, ci, perf.",
+    "- Keep the first line under 72 characters.",
+    "- Body is optional.",
+    "- Do NOT include markdown.",
+    "- Do NOT include backticks.",
+    "- Do NOT include explanations.",
+    "- Do NOT include Co-Authored-By.",
+    "- Do NOT include Signed-off-by.",
+    "- Do NOT include AI attribution.",
+    "",
+    "Extra user instructions:",
+    "{extraPrompt}"
+  ],
+  "commitMessageTag": "commit_message",
+  "placeholders": {
+    "extraPrompt": "{extraPrompt}",
+    "extraPromptFallback": "None"
+  },
+  "removeLinesMatching": [
+    "^```",
+    "^Here.*commit message",
+    "^Co-Authored-By:",
+    "^Signed-off-by:",
+    "Claude",
+    "Anthropic"
+  ],
+  "stopLinesMatching": [
+    "^Wait.*rules"
+  ]
+}

package/bin/run-provider.js

@@ -0,0 +1,35 @@
+import { spawnSync } from "node:child_process";
+
+export function runProvider(provider, prompt, diff) {
+  if (!provider?.command) {
+    throw new Error("Config error: provider.command is required.");
+  }
+
+  const args = provider.args ?? [];
+
+  const finalArgs = args.map((arg) =>
+    arg
+      .replaceAll("{prompt}", prompt)
+      .replaceAll("{diff}", diff)
+  );
+
+  const usesPromptPlaceholder = args.some((arg) => arg.includes("{prompt}"));
+  const usesDiffPlaceholder = args.some((arg) => arg.includes("{diff}"));
+
+  const input = usesDiffPlaceholder ? undefined : diff;
+
+  if (!usesPromptPlaceholder) {
+    finalArgs.push(prompt);
+  }
+
+  const result = spawnSync(provider.command, finalArgs, {
+    input,
+    encoding: "utf8",
+  });
+
+  if (result.status !== 0) {
+    throw new Error(result.stderr || `${provider.command} failed.`);
+  }
+
+  return result.stdout;
+}

package/bin/wizard.js

@@ -0,0 +1,136 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import { PROVIDER_PRESETS, EDITOR_PRESETS } from "./presets.js";
+import { defaults } from "./prompts.js";
+
+export async function runInitWizard(path) {
+  const rl = createInterface({ input, output });
+
+  console.log();
+  console.log("git-aic config wizard");
+  console.log("=====================");
+  console.log(`Target: ${path}`);
+
+  if (existsSync(path)) {
+    const answer = (await rl.question("Config already exists. Overwrite? [y/N]: "))
+      .trim()
+      .toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      rl.close();
+      process.exit(0);
+    }
+  }
+
+  const provider = await pickProvider(rl);
+  const editor = await pickEditor(rl);
+
+  console.log();
+  const commitAnswer = (
+    await rl.question("Auto-commit after editing the message? [Y/n]: ")
+  ).trim().toLowerCase();
+  const commit = commitAnswer !== "n" && commitAnswer !== "no";
+
+  const requireEditAnswer = (
+    await rl.question("Require the message to be edited before commit? [y/N]: ")
+  ).trim().toLowerCase();
+  const requireEdit = requireEditAnswer === "y" || requireEditAnswer === "yes";
+
+  rl.close();
+
+  const config = {
+    provider,
+    editor,
+    commit,
+    requireEdit,
+    prompt: defaults.prompt,
+    commitMessageTag: defaults.commitMessageTag,
+    removeLinesMatching: defaults.removeLinesMatching,
+    stopLinesMatching: defaults.stopLinesMatching,
+  };
+
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n");
+
+  console.log();
+  console.log(`Wrote: ${path}`);
+  console.log(JSON.stringify(config, null, 2));
+}
+
+async function pickProvider(rl) {
+  console.log();
+  console.log("Choose a provider:");
+  PROVIDER_PRESETS.forEach((preset, index) => {
+    const argsPreview = preset.args.join(" ");
+    console.log(`  ${index + 1}) ${preset.name}  (${preset.command} ${argsPreview})`);
+  });
+  console.log(`  ${PROVIDER_PRESETS.length + 1}) Custom`);
+
+  while (true) {
+    const choice = (await rl.question(`Provider [1-${PROVIDER_PRESETS.length + 1}]: `)).trim();
+    const index = Number.parseInt(choice, 10) - 1;
+
+    if (index >= 0 && index < PROVIDER_PRESETS.length) {
+      const preset = PROVIDER_PRESETS[index];
+      return { command: preset.command, args: preset.args };
+    }
+
+    if (index === PROVIDER_PRESETS.length) {
+      const command = (await rl.question("Command (e.g. claude): ")).trim();
+
+      if (!command) {
+        console.log("Command cannot be empty.");
+        continue;
+      }
+
+      const argsRaw = (
+        await rl.question('Args (space-separated, use {prompt} and {diff} as placeholders) [-p "{prompt}"]: ')
+      ).trim();
+      const args = argsRaw ? argsRaw.split(/\s+/) : ["-p", "{prompt}"];
+      return { command, args };
+    }
+
+    console.log("Invalid choice.");
+  }
+}
+
+async function pickEditor(rl) {
+  console.log();
+  console.log("Choose an editor:");
+  EDITOR_PRESETS.forEach((preset, index) => {
+    console.log(`  ${index + 1}) ${preset}`);
+  });
+  console.log(`  ${EDITOR_PRESETS.length + 1}) Custom`);
+
+  while (true) {
+    const choice = (
+      await rl.question(`Editor [1-${EDITOR_PRESETS.length + 1}, default 1]: `)
+    ).trim();
+
+    if (choice === "") {
+      return EDITOR_PRESETS[0];
+    }
+
+    const index = Number.parseInt(choice, 10) - 1;
+
+    if (index >= 0 && index < EDITOR_PRESETS.length) {
+      return EDITOR_PRESETS[index];
+    }
+
+    if (index === EDITOR_PRESETS.length) {
+      const custom = (await rl.question("Editor command: ")).trim();
+
+      if (!custom) {
+        console.log("Editor cannot be empty.");
+        continue;
+      }
+
+      return custom;
+    }
+
+    console.log("Invalid choice.");
+  }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@thankarezos/git-ai-commit",
+  "version": "0.1.0",
+  "description": "Generate editable git commit messages using a configurable AI CLI",
+  "type": "module",
+  "bin": {
+    "git-aic": "bin/git-aic.js"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thankarezos/git-ai-commit.git"
+  },
+  "homepage": "https://github.com/thankarezos/git-ai-commit#readme",
+  "bugs": {
+    "url": "https://github.com/thankarezos/git-ai-commit/issues"
+  },
+  "author": "thankarezos <thankarezos@gmail.com>",
+  "keywords": [
+    "git",
+    "ai",
+    "commit",
+    "cli",
+    "claude",
+    "gemini",
+    "conventional-commits"
+  ],
+  "license": "MIT"
+}