commit-writer 1.1.0

package/index.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { createInterface } from "readline";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { google } from "@ai-sdk/google";
+import { runSetup } from "./setup.js";
+
+const CONFIG_PATH = join(homedir(), ".config", "commit-writer", "config.json");
+
+const ENV_VAR_MAP = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+};
+
+function loadConfig() {
+  try {
+    const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    // Migrate legacy config (pre-1.1.0)
+    if (raw.openaiApiKey && !raw.provider) {
+      return {
+        provider: "openai",
+        model: "gpt-5-mini",
+        apiKey: raw.openaiApiKey,
+        diffMode: raw.diffMode || "staged",
+      };
+    }
+    return raw;
+  } catch {
+    return {};
+  }
+}
+
+let config = loadConfig();
+
+const SYSTEM_PROMPT = `You are a commit message generator. Given a git diff, write a concise conventional commit message.
+
+Rules:
+- Use conventional commit format: type(scope): description
+- Types: feat, fix, refactor, docs, style, test, chore, perf, ci, build
+- Keep the subject line under 72 characters
+- Optionally add a body with bullet points for complex changes
+- Do not include anything other than the commit message itself`;
+
+function getModel(config) {
+  const providers = { openai, anthropic, google };
+  const createModel = providers[config.provider];
+  if (!createModel) {
+    console.error(
+      `Error: Unknown provider "${config.provider}". Run \`commit-writer-setup\` to reconfigure.`
+    );
+    process.exit(1);
+  }
+  return createModel(config.model);
+}
+
+async function getDiff() {
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf-8").trim();
+  }
+
+  const diffCommands = {
+    staged: "git diff --staged",
+    unstaged: "git diff",
+    all: "git diff HEAD",
+  };
+  const diffMode = config.diffMode || "staged";
+  const command = diffCommands[diffMode] || diffCommands.staged;
+
+  try {
+    const diff = execSync(command, { encoding: "utf-8" }).trim();
+    return diff;
+  } catch {
+    console.error("Error: Not a git repository or git is not installed.");
+    process.exit(1);
+  }
+}
+
+async function generateCommitMessage(diff) {
+  const { text } = await generateText({
+    model: getModel(config),
+    system: SYSTEM_PROMPT,
+    prompt: `Generate a commit message for this diff:\n\n${diff}`,
+  });
+
+  return text.trim();
+}
+
+function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+async function main() {
+  // First run: no config or no provider set — run setup automatically
+  if (!config.provider && !existsSync(CONFIG_PATH)) {
+    await runSetup();
+    config = loadConfig();
+  }
+
+  if (!config.provider) {
+    console.error(
+      "Error: No provider configured. Run `commit-writer-setup` to set up."
+    );
+    process.exit(1);
+  }
+
+  // Set the env var the AI SDK reads from config
+  const envVar = ENV_VAR_MAP[config.provider];
+  if (!process.env[envVar] && config.apiKey) {
+    process.env[envVar] = config.apiKey;
+  }
+
+  if (!process.env[envVar]) {
+    console.error(
+      `Error: ${envVar} not set. Run \`commit-writer-setup\` or set the env var.`
+    );
+    process.exit(1);
+  }
+
+  const diff = await getDiff();
+
+  if (!diff) {
+    console.error("No diff found. Stage your changes with `git add` first.");
+    process.exit(1);
+  }
+
+  console.log("Generating commit message...\n");
+
+  const message = await generateCommitMessage(diff);
+
+  console.log("--- Suggested commit message ---");
+  console.log(message);
+  console.log("--------------------------------\n");
+
+  if (process.stdin.isTTY) {
+    const answer = await ask("Commit with this message? (y/n): ");
+    if (answer === "y" || answer === "yes") {
+      try {
+        execSync(`git commit -m ${JSON.stringify(message)}`, {
+          stdio: "inherit",
+        });
+      } catch {
+        console.error("Commit failed.");
+        process.exit(1);
+      }
+    } else {
+      console.log("Commit cancelled.");
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "commit-writer",
+  "version": "1.1.0",
+  "description": "Generate commit messages from git diffs using AI (OpenAI, Anthropic, Gemini)",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "commit-writer": "./index.js",
+    "commit-writer-setup": "./setup.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "index.js",
+    "setup.js"
+  ],
+  "keywords": [
+    "git",
+    "commit",
+    "ai",
+    "openai",
+    "anthropic",
+    "claude",
+    "gemini",
+    "conventional-commits"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1.0.0",
+    "@ai-sdk/google": "^1.0.0",
+    "@ai-sdk/openai": "^1.0.0",
+    "ai": "^4.0.0"
+  }
+}

package/setup.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+import { createInterface } from "readline";
+import { createReadStream } from "fs";
+import { mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CONFIG_DIR = join(homedir(), ".config", "commit-writer");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+const PROVIDERS = {
+  openai: { name: "OpenAI", envVar: "OPENAI_API_KEY" },
+  anthropic: { name: "Anthropic (Claude)", envVar: "ANTHROPIC_API_KEY" },
+  google: { name: "Google Gemini", envVar: "GOOGLE_GENERATIVE_AI_API_KEY" },
+};
+
+function loadExistingConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function getTTYInput() {
+  if (process.stdin.isTTY) {
+    return process.stdin;
+  }
+  try {
+    return createReadStream("/dev/tty", { encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+}
+
+function askQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+function askMasked(rl, input, question) {
+  return new Promise((resolve) => {
+    const output = rl.output;
+    output.write(question);
+
+    const originalWrite = output.write.bind(output);
+    let answer = "";
+
+    output.write = () => true;
+
+    const onData = (char) => {
+      const str = char.toString();
+      if (str === "\n" || str === "\r") {
+        output.write = originalWrite;
+        input.removeListener("data", onData);
+        if (input.setRawMode) input.setRawMode(false);
+        output.write("\n");
+        resolve(answer);
+      } else if (str === "\u007F" || str === "\b") {
+        if (answer.length > 0) {
+          answer = answer.slice(0, -1);
+        }
+      } else {
+        answer += str;
+        output.write = originalWrite;
+        output.write("*");
+        output.write = () => true;
+      }
+    };
+
+    if (input.setRawMode) input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
+
+async function fetchModels(provider, apiKey) {
+  let url, headers;
+
+  if (provider === "openai") {
+    url = "https://api.openai.com/v1/models";
+    headers = { Authorization: `Bearer ${apiKey}` };
+  } else if (provider === "anthropic") {
+    url = "https://api.anthropic.com/v1/models";
+    headers = { "x-api-key": apiKey, "anthropic-version": "2023-06-01" };
+  } else if (provider === "google") {
+    url = `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`;
+    headers = {};
+  }
+
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`API returned ${res.status}: ${body}`);
+  }
+  const json = await res.json();
+
+  if (provider === "openai") {
+    return json.data
+      .map((m) => m.id)
+      .filter((id) => /^(gpt|o[0-9]|chatgpt)/.test(id))
+      .sort();
+  } else if (provider === "anthropic") {
+    return json.data.map((m) => m.id).sort();
+  } else if (provider === "google") {
+    return json.models
+      .filter((m) =>
+        m.supportedGenerationMethods?.includes("generateContent")
+      )
+      .map((m) => m.name.replace("models/", ""))
+      .sort();
+  }
+}
+
+export async function runSetup() {
+  const input = getTTYInput();
+
+  if (!input) {
+    console.log("\nNo interactive terminal detected.");
+    console.log(
+      "Run `commit-writer-setup` to configure your API key and preferences.\n"
+    );
+    return;
+  }
+
+  const existing = loadExistingConfig();
+
+  console.log("\n🔧 commit-writer setup\n");
+
+  const rl = createInterface({ input, output: process.stdout });
+
+  // 1. Provider selection
+  console.log("Provider:");
+  console.log("  1) OpenAI");
+  console.log("  2) Anthropic (Claude)");
+  console.log("  3) Google Gemini\n");
+
+  const currentProvider = existing.provider || "openai";
+  const providerAnswer = await askQuestion(
+    rl,
+    `Choose provider [1/2/3] (current: ${currentProvider}): `
+  );
+
+  const providerMap = { "1": "openai", "2": "anthropic", "3": "google" };
+  const provider = providerMap[providerAnswer] || existing.provider || "openai";
+  const providerInfo = PROVIDERS[provider];
+
+  // 2. API key
+  const sameProvider = provider === existing.provider;
+  const keyHint =
+    sameProvider && existing.apiKey ? ` (press Enter to keep existing)` : "";
+  const apiKey = await askMasked(
+    rl,
+    input,
+    `\n${providerInfo.name} API key${keyHint}: `
+  );
+
+  const finalKey = apiKey || (sameProvider ? existing.apiKey : "") || "";
+  if (!finalKey) {
+    console.log(
+      `\n⚠️  No API key provided. You can set ${providerInfo.envVar} env var instead.`
+    );
+  }
+
+  // 3. Model selection (live-fetched)
+  let model = existing.model && sameProvider ? existing.model : "";
+
+  if (finalKey) {
+    console.log("\nFetching available models...");
+    try {
+      const models = await fetchModels(provider, finalKey);
+
+      if (models.length === 0) {
+        console.log("No models found.");
+      } else {
+        console.log(`\nAvailable models (${models.length}):`);
+        models.forEach((m, i) => {
+          console.log(`  ${i + 1}) ${m}`);
+        });
+        console.log();
+
+        const currentHint = model ? ` (current: ${model})` : "";
+        const modelAnswer = await askQuestion(
+          rl,
+          `Choose model [number]${currentHint}: `
+        );
+
+        const idx = parseInt(modelAnswer, 10) - 1;
+        if (idx >= 0 && idx < models.length) {
+          model = models[idx];
+        } else if (!modelAnswer && model) {
+          // keep existing
+        } else if (modelAnswer) {
+          // treat as manual model ID input
+          model = modelAnswer;
+        }
+      }
+    } catch (err) {
+      console.log(`\n⚠️  Could not fetch models: ${err.message}`);
+      const manualModel = await askQuestion(rl, "Enter model ID manually: ");
+      if (manualModel) model = manualModel;
+    }
+  }
+
+  if (!model) {
+    const manualModel = await askQuestion(rl, "\nEnter model ID: ");
+    model = manualModel || "";
+  }
+
+  // 4. Diff mode
+  console.log("\nDiff mode options:");
+  console.log("  1) staged   — git diff --staged (default)");
+  console.log("  2) unstaged — git diff");
+  console.log("  3) all      — git diff HEAD\n");
+
+  const currentMode = existing.diffMode || "staged";
+  const modeAnswer = await askQuestion(
+    rl,
+    `Choose diff mode [1/2/3] (current: ${currentMode}): `
+  );
+
+  const modeMap = { "1": "staged", "2": "unstaged", "3": "all" };
+  const diffMode = modeMap[modeAnswer] || existing.diffMode || "staged";
+
+  rl.close();
+  if (input !== process.stdin) input.destroy();
+
+  // Write config
+  const config = { provider, model, apiKey: finalKey, diffMode };
+
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+
+  console.log(`\n✅ Config saved to ${CONFIG_PATH}`);
+  console.log(`   Provider:  ${providerInfo.name}`);
+  console.log(`   Model:     ${model || "(not set)"}`);
+  console.log(`   Diff mode: ${diffMode}`);
+  console.log(
+    `   API key:   ${finalKey ? "***" + finalKey.slice(-4) : "(not set)"}\n`
+  );
+}
+
+// Run directly if called as a script (commit-writer-setup command)
+const isDirectRun =
+  process.argv[1] &&
+  (process.argv[1].endsWith("setup.js") ||
+    process.argv[1].endsWith("commit-writer-setup"));
+
+if (isDirectRun) {
+  runSetup().catch((err) => {
+    console.error("commit-writer setup error:", err.message);
+    process.exit(0);
+  });
+}