commitor.js

#!/usr/bin/env node

/**
 * Commitor — Wizard-of-Oz prototype
 *
 * Reads your git diff, sends it to Gemini, and prints a proposed set of
 * logical, atomic commit groupings with conventional commit messages.
 *
 * This is a PROTOTYPE. It never runs `git add` or `git commit` for you —
 * it only prints suggestions so you can react to the output quality.
 *
 * Usage:
 *   export GEMINI_API_KEY=AIza...
 *   node commitor.js                 # analyzes unstaged + staged changes
 *   node commitor.js --staged        # only staged changes
 *   node commitor.js --file diff.txt # analyze a diff from a file instead of git
 */

const { execSync } = require("child_process");
const fs = require("fs");
const path = require("path");
const https = require("https");
const readline = require("readline");
const os = require("os");

const MODEL = "gemini-3.7-flash";
const CONFIG_DIR = path.join(os.homedir(), ".commitor");
const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");

let GEMINI_API_KEY = process.env.GEMINI_API_KEY || loadApiKey();

function loadApiKey() {
  try {
    if (fs.existsSync(CONFIG_FILE)) {
      const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
      return config.apiKey || null;
    }
  } catch (err) {
    // Silently ignore config read errors
  }
  return null;
}

function saveApiKey(apiKey) {
  try {
    if (!fs.existsSync(CONFIG_DIR)) {
      fs.mkdirSync(CONFIG_DIR, { recursive: true });
    }
    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ apiKey }, null, 2));
  } catch (err) {
    throw new Error(`Failed to save API key: ${err.message}`);
  }
}

function getGitDiff({ stagedOnly, filePath }) {
  if (filePath) {
    return fs.readFileSync(filePath, "utf8");
  }
  try {
    if (stagedOnly) {
      return execSync("git diff --staged", { maxBuffer: 1024 * 1024 * 20 }).toString();
    }
    // Combine staged + unstaged so the tool sees everything not yet committed
    const staged = execSync("git diff --staged", { maxBuffer: 1024 * 1024 * 20 }).toString();
    const unstaged = execSync("git diff", { maxBuffer: 1024 * 1024 * 20 }).toString();
    return staged + "\n" + unstaged;
  } catch (err) {
    console.error("Failed to read git diff. Are you inside a git repo?");
    console.error(err.message);
    process.exit(1);
  }
}

function parseFilesFromDiff(diffText) {
  // Extract file paths from diff header lines (e.g., "diff --git a/path b/path")
  const files = [];
  const lines = diffText.split("\n");
  for (const line of lines) {
    if (line.startsWith("diff --git")) {
      // Extract b/path from "diff --git a/path b/path"
      const match = line.match(/b\/(.+)$/);
      if (match) {
        files.push(match[1]);
      }
    }
  }
  return [...new Set(files)]; // Remove duplicates
}

function getFullFileContents(files) {
  // Try to read each file; skip if it doesn't exist or can't be read
  const contents = {};
  for (const file of files) {
    try {
      contents[file] = fs.readFileSync(file, "utf8");
    } catch (err) {
      // File doesn't exist (probably deleted) — skip it
    }
  }
  return contents;
}

function buildPrompt(diffText, fullFileContents = null, options = {}) {
  const isSquishedMode = options.squashMerge || false;
  let instruction = isSquishedMode
    ? "Group all distinct changes into EXACTLY ONE commit. Combine all concerns (unless truly incompatible) under a single message."
    : "Group the changed hunks/files into separate commits by concern. Prefer smaller, atomic, single-purpose commits over one giant commit.";

  let contentSection = "";
  if (fullFileContents && Object.keys(fullFileContents).length > 0) {
    contentSection = "\n\n## Full file contents (for context):\n\n";
    for (const [file, content] of Object.entries(fullFileContents)) {
      contentSection += `### File: ${file}\n\`\`\`\n${content}\n\`\`\`\n\n`;
    }
  }

  return `You are Commitor, a tool that groups a messy git diff into clean, logical, atomic commits.

Given the diff below, do the following:
1. Identify distinct logical concerns in the diff (e.g. a bug fix, a new feature, a refactor, a style/formatting change, unrelated tweaks).
2. ${instruction} If two changes are genuinely unrelated (e.g. an auth fix and a CSS tweak), they MUST be in separate commits, even if they touch the same file.
3. For each proposed commit, write a Conventional Commits style message (feat:, fix:, chore:, refactor:, style:, docs:, test:) with a short imperative summary line, and 1-2 bullet points describing what changed if useful.
4. Explicitly flag any case where unrelated changes appear bundled together in a way that could confuse a future reader.

Respond ONLY in this exact JSON format, no preamble, no markdown fences:

{
  "commits": [
    {
      "message": "fix: correct token refresh race condition",
      "files": ["src/auth/token.ts"],
      "reasoning": "One-sentence reasoning for why these changes belong together.",
      "bundling_warning": null
    }
  ],
  "summary": "One or two sentence overview of what this diff does as a whole."
}

If you detect unrelated changes that a naive tool might bundle together, set "bundling_warning" to a short string explaining the risk, otherwise set it to null.

## Diff:

\`\`\`diff
${diffText}
\`\`\`${contentSection}`;
}

function groupFilesLocally(diffText) {
  // Parse files from diff and group by top-level directory
  const files = parseFilesFromDiff(diffText);
  const groups = {};

  for (const file of files) {
    const topDir = file.split("/")[0];
    if (!groups[topDir]) {
      groups[topDir] = [];
    }
    groups[topDir].push(file);
  }

  // Generate commits for each group
  const commits = [];
  for (const [dir, fileList] of Object.entries(groups)) {
    commits.push({
      message: `chore: update ${fileList.length} file${fileList.length > 1 ? "s" : ""} in ${dir}`,
      files: fileList,
      reasoning: `Grouped ${fileList.length} file${fileList.length > 1 ? "s" : ""} from the ${dir}/ directory.`,
      bundling_warning: null,
    });
  }

  return {
    commits,
    summary: `Local grouping: ${commits.length} logical group${commits.length > 1 ? "s" : ""} by top-level directory.`,
  };
}

function callGemini(promptText) {
  return new Promise((resolve, reject) => {
    const body = JSON.stringify({
      contents: [{ role: "user", parts: [{ text: promptText }] }],
      generationConfig: {
        maxOutputTokens: 4000,
        temperature: 0.2,
      },
    });

    const options = {
      hostname: "generativelanguage.googleapis.com",
      path: `/v1beta/models/${MODEL}:generateContent`,
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-goog-api-key": GEMINI_API_KEY,
        "Content-Length": Buffer.byteLength(body),
      },
    };

    const req = https.request(options, (res) => {
      let data = "";
      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => {
        if (res.statusCode !== 200) {
          reject(new Error(`API error ${res.statusCode}: ${data}`));
          return;
        }
        try {
          const parsed = JSON.parse(data);
          const candidate = parsed.candidates && parsed.candidates[0];
          if (!candidate) {
            reject(new Error(`No candidates returned: ${data}`));
            return;
          }
          const text = candidate.content.parts.map((p) => p.text || "").join("\n");
          resolve(text);
        } catch (e) {
          reject(e);
        }
      });
    });

    req.on("error", reject);
    req.write(body);
    req.end();
  });
}

function extractJson(text) {
  // Strip markdown fences if the model added them anyway
  const cleaned = text.replace(/```json|```/g, "").trim();
  return JSON.parse(cleaned);
}

function printReport(result, diffStats) {
  const divider = "─".repeat(60);

  console.log("\n" + divider);
  console.log("  COMMITOR — Proposed Commit Grouping");
  console.log(divider);
  console.log(`\n${result.summary}\n`);
  console.log(`Detected ${result.commits.length} logical commit(s) from your diff.\n`);

  result.commits.forEach((commit, i) => {
    console.log(divider);
    console.log(`Commit ${i + 1}/${result.commits.length}`);
    console.log(divider);
    console.log(`  Message : ${commit.message}`);
    console.log(`  Files   : ${commit.files.join(", ")}`);
    console.log(`  Why     : ${commit.reasoning}`);
    if (commit.bundling_warning) {
      console.log(`  ⚠ Warning: ${commit.bundling_warning}`);
    }
    console.log("");
  });

  console.log(divider);
  console.log("This is a prototype — no git commands were run.");
  console.log("Review the groupings above and tell Commitor what's wrong or right.");
  console.log(divider + "\n");
}

function connectCommand() {
  // Prompt for API key
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  rl.question("Enter your Gemini API key: ", (apiKey) => {
    rl.close();

    if (!apiKey || !apiKey.trim()) {
      console.error("API key cannot be empty.");
      process.exit(1);
    }

    try {
      saveApiKey(apiKey.trim());
      console.log("\n✓ API key saved to ~/.commitor/config.json");
      console.log("You can now run 'commitor commit' in any git repository.");
    } catch (err) {
      console.error(`Failed to save API key: ${err.message}`);
      process.exit(1);
    }
  });
}

async function commitCommand(args) {
  // Parse commit-specific flags
  const stagedOnly = args.includes("--staged");
  const fileIdx = args.indexOf("--file");
  const filePath = fileIdx !== -1 ? args[fileIdx + 1] : null;
  const isFast = args.includes("--fast");
  const isNoAI = args.includes("--no-ai");
  const isSquashMerge = args.includes("--squash-merge");

  if (!isNoAI && !GEMINI_API_KEY) {
    console.error("Missing Gemini API key.");
    console.error("Run: commitor connect");
    console.error("(Or set GEMINI_API_KEY environment variable)");
    process.exit(1);
  }

  const diffText = getGitDiff({ stagedOnly, filePath });

  if (!diffText || !diffText.trim()) {
    console.log("No changes detected. Nothing to group.");
    process.exit(0);
  }

  // --no-ai mode: group files locally, no API call
  if (isNoAI) {
    console.log("Grouping files locally (no API call)...\n");
    const result = groupFilesLocally(diffText);
    printReport(result, diffText);
    return;
  }

  // Default mode (full context) or --fast mode
  let result;
  if (isFast) {
    console.log("Analyzing your diff with Gemini (fast mode, diff hunks only)...\n");
    const prompt = buildPrompt(diffText, null, { squashMerge: isSquashMerge });
    const raw = await callGemini(prompt);
    result = extractJson(raw);
  } else {
    console.log("Analyzing your diff with Gemini (full context mode, reading file contents)...\n");
    const files = parseFilesFromDiff(diffText);
    const fullContents = getFullFileContents(files);
    const prompt = buildPrompt(diffText, fullContents, { squashMerge: isSquashMerge });
    const raw = await callGemini(prompt);
    result = extractJson(raw);
  }

  printReport(result, diffText);
}

async function main() {
  const args = process.argv.slice(2);
  let subcommand = "commit"; // default subcommand

  // Check if first arg is a subcommand (doesn't start with --)
  if (args.length > 0 && !args[0].startsWith("--")) {
    subcommand = args[0];
    args.shift(); // remove subcommand from args
  }

  try {
    if (subcommand === "commit") {
      await commitCommand(args);
    } else if (subcommand === "connect") {
      connectCommand();
    } else {
      console.error(`Unknown subcommand: ${subcommand}`);
      console.error("Available subcommands: commit, connect");
      process.exit(1);
    }
  } catch (err) {
    console.error("Something went wrong:");
    console.error(err.message);
    process.exit(1);
  }
}

main();