@thankarezos/git-ai-commit 0.1.3 → 0.1.4

package/README.md

@@ -1,6 +1,6 @@
 # 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.
+Generate a git commit message from your staged diff using any AI CLI you already have on your machine (Claude Code, Antigravity 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"
@@ -44,7 +44,7 @@ First run launches an **interactive wizard** that asks you to pick a provider, e
 | `-a`, `--add` | Run `git add -A` before generating |
 | `-p "..."`, `--prompt "..."` | Append extra instructions to the AI prompt |
 | `-ap "..."`, `-pa "..."` | Combine `-a` and `-p` |
-| `--provider <name>`, `-P <name>` | One-off provider override. `<name>` matches a preset command (`claude`, `gemini`, `codex`, `opencode`, `llm`, `ollama`). |
+| `--provider <name>`, `-P <name>` | One-off provider override. `<name>` matches a preset command (`claude`, `agy`, `codex`, `opencode`, `llm`, `ollama`). |
 | `--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 |
@@ -100,7 +100,7 @@ Each field in your user config **replaces** the default if present. If you delet
 The wizard ships with presets for:
 
 - **Claude Code** — `claude -p "{prompt}"` (reads diff from stdin)
-- **Gemini CLI** — `gemini -p "{prompt}"`
+- **Antigravity CLI** — `agy -p "{prompt}"`
 - **Codex CLI** — `codex exec --skip-git-repo-check "{prompt}"`
 - **OpenCode** — `opencode run "{prompt}"`
 - **llm** (Simon Willison) — `llm "{prompt}"`
@@ -109,6 +109,20 @@ The wizard ships with presets for:
 
 You can edit `provider` in the config file at any time, or rerun `git aic --init`.
 
+### Windows note
+
+Most CLIs work the same on Windows. The exception is a CLI that renders its output to the console instead of stdout (like `agy`): to capture it, `git-aic` must spawn it with no console, which briefly flashes a console window. A provider can opt into this with a `windows` field carrying extra spawn options:
+
+```json
+"provider": {
+  "command": "agy",
+  "args": ["-p", "{prompt}"],
+  "windows": { "detached": true }
+}
+```
+
+CLIs that write to stdout (e.g. `claude`) don't need this and run without any window.
+
 ## Customizing the prompt
 
 The base prompt template, the `<commit_message>` tag, and the cleanup patterns live in `bin/prompts.json`. Edit that file to:

package/bin/git-aic.js

@@ -16,6 +16,7 @@ import { runInitWizard } from "./wizard.js";
 import { cleanCommitMessage } from "./clean.js";
 import { extractCommitMessage } from "./extract.js";
 import { runProvider } from "./run-provider.js";
+import { spawnCross } from "./spawn.js";
 import { applyUserOverrides, getConfiguration } from "./prompts.js";
 import { getConfigPath, loadConfig } from "./get-config-path.js";
 import { PROVIDER_PRESETS } from "./presets.js";
@@ -28,6 +29,9 @@ function fail(message, code = 1) {
 function run(command, args, options = {}) {
   return spawnSync(command, args, {
     encoding: "utf8",
+    // Suppress the transient console window Windows flashes for piped child
+    // processes (no effect on other platforms).
+    windowsHide: true,
     ...options,
   });
 }
@@ -41,6 +45,7 @@ function parseArgs(argv) {
   let runInit = false;
   let shouldAdd = false;
   let providerName = null;
+  let verbose = false;
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
@@ -105,6 +110,11 @@ function parseArgs(argv) {
       continue;
     }
 
+    if (arg === "-V" || arg === "--verbose") {
+      verbose = true;
+      continue;
+    }
+
     if (arg === "--init") {
       runInit = true;
       continue;
@@ -117,11 +127,12 @@ Usage:
   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 --provider gemini        # one-off provider override (also -P)
+  git aic --provider agy           # one-off provider override (also -P)
   git aic --provider               # list available providers
   git aic --no-commit
   git aic --config
   git aic -v, --version
+  git aic -V, --verbose           # print the prompt and raw provider output
   git aic --init
 
 Examples:
@@ -154,6 +165,7 @@ Environment:
     runInit,
     shouldAdd,
     providerName,
+    verbose,
   };
 }
 
@@ -181,6 +193,7 @@ function readStagedDiff() {
       {
         encoding: "utf8",
         maxBuffer: 50 * 1024 * 1024,
+        windowsHide: true,
       }
     );
   } catch (error) {
@@ -228,7 +241,11 @@ if (args.providerName) {
     const names = PROVIDER_PRESETS.map((p) => p.command).join(", ");
     fail(`Unknown provider: ${args.providerName}. Available: ${names}`);
   }
-  config.provider = { command: preset.command, args: preset.args };
+  config.provider = {
+    command: preset.command,
+    args: preset.args,
+    ...(preset.windows ? { windows: preset.windows } : {}),
+  };
 }
 
 if (args.printConfig) {
@@ -270,13 +287,25 @@ const prompt = buildPrompt(args.extraPrompt);
 
 console.log(`Using provider: ${config.provider.command}`);
 
+if (args.verbose) {
+  console.error("[verbose] ----- prompt -----");
+  console.error(prompt);
+  console.error("[verbose] ----- end prompt -----");
+}
+
 let raw;
 try {
-  raw = runProvider(config.provider, prompt, safeDiff);
+  raw = runProvider(config.provider, prompt, safeDiff, { verbose: args.verbose });
 } catch (error) {
   fail(error.message);
 }
 
+if (args.verbose) {
+  console.error("[verbose] ----- raw provider output -----");
+  console.error(raw);
+  console.error("[verbose] ----- end raw provider output -----");
+}
+
 const message = extractCommitMessage(raw);
 
 if (!message) {
@@ -291,8 +320,12 @@ 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], {
+const defaultEditor = process.platform === "win32" ? "notepad" : "nano";
+const editor = process.env.EDITOR || config.editor || defaultEditor;
+// Editor configs can carry flags (e.g. "code --wait"), so split the command
+// from its arguments before spawning.
+const [editorCommand, ...editorArgs] = editor.trim().split(/\s+/);
+const editorResult = spawnCross(editorCommand, [...editorArgs, file], {
   stdio: "inherit",
 });
 

package/bin/presets.js

@@ -5,9 +5,13 @@ export const PROVIDER_PRESETS = [
     args: ["-p", "{prompt}"]
   },
   {
-    name: "Gemini CLI",
-    command: "gemini",
-    args: ["-p", "{prompt}"]
+    name: "Antigravity CLI",
+    command: "agy",
+    args: ["-p", "{prompt}"],
+    // agy renders to the Windows console device instead of stdout, so it can
+    // only be captured when spawned with no console (detached). This pops a
+    // brief console window on Windows; CLIs that write to stdout don't need it.
+    windows: { detached: true }
   },
   {
     name: "Codex CLI",
@@ -31,4 +35,4 @@ export const PROVIDER_PRESETS = [
   }
 ];
 
-export const EDITOR_PRESETS = ["nano", "vim", "nvim", "code --wait", "micro", "hx"];
+export const EDITOR_PRESETS = ["nano", "vim", "nvim", "code --wait", "micro", "hx", "notepad"];

package/bin/run-provider.js

@@ -1,30 +1,58 @@
-import { spawnSync } from "node:child_process";
+import { spawnCross, isWindowsShim } from "./spawn.js";
 
-export function runProvider(provider, prompt, diff) {
+// Keep verbose output readable: show short args verbatim, summarise long ones
+// (like the full prompt) by byte size instead of dumping them.
+function previewArg(arg) {
+  return arg.length > 60 ? `<${Buffer.byteLength(arg)} bytes>` : arg;
+}
+
+export function runProvider(provider, prompt, diff, { verbose = false } = {}) {
   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;
+  let finalArgs;
+  let input;
+
+  if (isWindowsShim(provider.command) && !usesDiffPlaceholder) {
+    // Batch shims (e.g. claude.cmd) run through cmd.exe, which truncates a
+    // command-line argument at the first newline — so the multi-line prompt
+    // can't be passed inline. Send the prompt and diff via stdin and drop the
+    // inline {prompt}; CLIs like claude read the prompt from stdin when no
+    // inline prompt is given.
+    finalArgs = args.filter((arg) => arg.trim() !== "{prompt}");
+    input = `${prompt}\n\n${diff}`;
+  } else {
+    finalArgs = args.map((arg) =>
+      arg.replaceAll("{prompt}", prompt).replaceAll("{diff}", diff)
+    );
+    input = usesDiffPlaceholder ? undefined : diff;
+    if (!usesPromptPlaceholder) {
+      finalArgs.push(prompt);
+    }
+  }
 
-  if (!usesPromptPlaceholder) {
-    finalArgs.push(prompt);
+  if (verbose) {
+    const preview = finalArgs.map(previewArg).join(" ");
+    console.error(`[verbose] command: ${provider.command} ${preview}`);
+    console.error(
+      `[verbose] stdin: ${input ? `${Buffer.byteLength(input)} bytes` : "(none)"}`
+    );
   }
 
-  const result = spawnSync(provider.command, finalArgs, {
+  // Per-provider Windows spawn options (e.g. { detached: true } for agy).
+  // Applied only on Windows; ignored elsewhere.
+  const windowsOptions =
+    process.platform === "win32" ? provider.windows ?? {} : {};
+
+  const result = spawnCross(provider.command, finalArgs, {
     input,
     encoding: "utf8",
+    ...windowsOptions,
   });
 
   if (result.status !== 0) {

package/bin/spawn.js

@@ -0,0 +1,97 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, extname, isAbsolute, join } from "node:path";
+
+const isWindows = process.platform === "win32";
+
+// On Windows, a CLI on PATH may be a native executable (`agy.exe`) or a batch
+// shim that npm generates for global installs (`claude.cmd`). Native exes can
+// be spawned directly and accept multi-line arguments; batch shims must be run
+// through cmd.exe, which mangles multi-line arguments. We need to tell them
+// apart, so resolve the command to a real file and inspect its extension.
+function resolveWindowsCommand(command) {
+  if (isAbsolute(command) || command.includes("\\") || command.includes("/")) {
+    return { file: command, ext: extname(command).toLowerCase() };
+  }
+
+  const pathext = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+    .split(";")
+    .filter(Boolean);
+  const hasExt = extname(command) !== "";
+  const candidates = hasExt ? [command] : pathext.map((ext) => command + ext);
+  const dirs = (process.env.PATH || "").split(delimiter).filter(Boolean);
+
+  for (const dir of dirs) {
+    for (const candidate of candidates) {
+      const full = join(dir, candidate);
+      if (existsSync(full)) {
+        return { file: full, ext: extname(full).toLowerCase() };
+      }
+    }
+  }
+
+  // Not found on PATH — hand it back unchanged and let spawn surface the error.
+  return { file: command, ext: extname(command).toLowerCase() };
+}
+
+// Whether a command resolves to a batch/PowerShell shim on Windows (e.g. the
+// `claude.cmd` npm installs). Such shims run through cmd.exe, which truncates
+// arguments at the first newline — so callers must avoid passing multi-line
+// arguments to them. Always false off Windows.
+export function isWindowsShim(command) {
+  if (!isWindows) return false;
+  const { ext } = resolveWindowsCommand(command);
+  return ext === ".cmd" || ext === ".bat" || ext === ".ps1";
+}
+
+// Quoting for the cmd.exe shell path. With `shell: true` Node concatenates argv
+// verbatim instead of quoting it, so we wrap anything containing whitespace or
+// shell metacharacters ourselves.
+function quoteWinArg(arg) {
+  if (arg === "") return '""';
+  if (!/[\s"&|<>^()]/.test(arg)) return arg;
+  const escaped = arg
+    .replace(/(\\*)"/g, '$1$1\\"') // double backslashes before a quote, then escape the quote
+    .replace(/(\\*)$/, "$1$1"); // double trailing backslashes so they don't escape the closing quote
+  return `"${escaped}"`;
+}
+
+// Cross-platform spawnSync. Non-Windows spawns the command directly. On Windows
+// native executables are also spawned directly (preserving multi-line args),
+// while batch/PowerShell shims are routed through the shell so PATHEXT resolves
+// them.
+export function spawnCross(command, args = [], options = {}) {
+  if (!isWindows) {
+    return spawnSync(command, args, options);
+  }
+
+  const { file, ext } = resolveWindowsCommand(command);
+  const needsShell = ext === ".cmd" || ext === ".bat" || ext === ".ps1";
+  // Interactive spawns (the editor) inherit stdio and need a real, visible
+  // console; only capturing spawns get the window-suppression flags below.
+  // detached and windowsHide map to mutually exclusive console-creation flags
+  // (DETACHED_PROCESS vs CREATE_NO_WINDOW), so each path picks exactly one.
+  const capturing = options.stdio !== "inherit";
+
+  if (!needsShell) {
+    // Native exe. A caller can pass `detached: true` for a CLI that renders to
+    // the console device instead of stdout (e.g. agy): detached gives it no
+    // console so it falls back to stdout — at the cost of a brief console
+    // window. Everything else just gets a hidden console (no window).
+    const wantsDetached = capturing && options.detached === true;
+    const extra = capturing && !wantsDetached ? { windowsHide: true } : {};
+    return spawnSync(file, args, { ...extra, ...options });
+  }
+
+  // Batch/PowerShell shim — route through cmd.exe so PATHEXT resolves it.
+  // windowsHide (CREATE_NO_WINDOW) gives cmd.exe a hidden console: no popup,
+  // and shims like claude write to stdout normally so capture still works.
+  // detached would pop a cmd.exe window and shims never need it, so drop it.
+  const { detached, ...shimOptions } = options;
+  const extra = capturing ? { windowsHide: true } : {};
+  return spawnSync(file, args.map(quoteWinArg), {
+    ...extra,
+    ...shimOptions,
+    shell: true,
+  });
+}

package/bin/wizard.js

@@ -75,7 +75,11 @@ async function pickProvider(rl) {
 
     if (index >= 0 && index < PROVIDER_PRESETS.length) {
       const preset = PROVIDER_PRESETS[index];
-      return { command: preset.command, args: preset.args };
+      return {
+        command: preset.command,
+        args: preset.args,
+        ...(preset.windows ? { windows: preset.windows } : {}),
+      };
     }
 
     if (index === PROVIDER_PRESETS.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thankarezos/git-ai-commit",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Generate editable git commit messages using a configurable AI CLI",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
     "commit",
     "cli",
     "claude",
-    "gemini",
+    "antigravity",
     "conventional-commits"
   ],
   "license": "MIT"