hermes-git 0.3.2 → 0.3.6

package/README.md

@@ -334,7 +334,7 @@ If `HERMES_PROVIDER` is not set, Hermes auto-detects by using whichever key it f
 |----------|-------|-----------|
 | Anthropic | claude-sonnet-4-6 | [console.anthropic.com](https://console.anthropic.com/) |
 | OpenAI | gpt-4o | [platform.openai.com/api-keys](https://platform.openai.com/api-keys) |
-| Google | gemini-2.0-flash | [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey) |
+| Google | gemini-2.5-flash | [aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey) |
 
 ---
 

package/dist/index.js

@@ -34494,16 +34494,26 @@ async function makeOpenAIProvider(apiKey) {
 async function makeGeminiProvider(apiKey) {
   const { GoogleGenerativeAI: GoogleGenerativeAI2 } = await Promise.resolve().then(() => (init_dist(), exports_dist));
   const client = new GoogleGenerativeAI2(apiKey);
-  const genModel = client.getGenerativeModel({ model: "gemini-2.0-flash" });
+  const genModel = client.getGenerativeModel({ model: "gemini-2.5-flash" });
   return {
     name: "Gemini",
-    model: "gemini-2.0-flash",
+    model: "gemini-2.5-flash",
     async complete(prompt) {
-      const result = await genModel.generateContent(prompt);
-      const text = result.response.text();
-      if (!text)
-        throw new Error("Empty response from Gemini");
-      return text.trim();
+      try {
+        const result = await genModel.generateContent(prompt);
+        const text = result.response.text();
+        if (!text)
+          throw new Error("Empty response from Gemini");
+        return text.trim();
+      } catch (err) {
+        const msg = err?.message ?? "";
+        if (msg.includes("429") || msg.includes("Too Many Requests") || msg.includes("quota")) {
+          const retryMatch = msg.match(/retry in ([\d.]+)s/i);
+          const retryIn = retryMatch ? `${Math.ceil(parseFloat(retryMatch[1]))}s` : null;
+          throw new GeminiQuotaError(retryIn);
+        }
+        throw err;
+      }
     }
   };
 }
@@ -34548,6 +34558,25 @@ async function getProvider() {
   throw new NoProviderError;
 }
 
+class GeminiQuotaError extends Error {
+  constructor(retryIn) {
+    const lines = [
+      "",
+      source_default.red("❌ Gemini quota exceeded"),
+      "",
+      retryIn ? source_default.white(`  Per-minute limit hit. You could retry in ${source_default.bold(retryIn)}.`) : source_default.white("  Your free-tier daily quota is exhausted."),
+      "",
+      source_default.bold("  Options:"),
+      `  ${source_default.cyan("1.")} Enable billing at ${source_default.dim("https://aistudio.google.com/app/billing")}`,
+      `  ${source_default.cyan("2.")} Switch provider:  ${source_default.dim("hermes config set provider anthropic")}`,
+      `  ${source_default.cyan("3.")} Switch provider:  ${source_default.dim("hermes config set provider openai")}`,
+      ""
+    ];
+    super(lines.join(`
+`));
+  }
+}
+
 class MissingKeyError extends Error {
   constructor(provider) {
     const configs = {
@@ -37589,9 +37618,11 @@ function initCommand(program2) {
       await mkdir3(".hermes", { recursive: true });
       await writeFile4(".hermes/config.json", JSON.stringify(config, null, 2));
       await mkdir3(".hermes/backups", { recursive: true });
-      await appendToGitignore(`.hermes/backups/
-.hermes/stats.json
-`);
+      const added = await updateGitignore();
+      if (added.length > 0) {
+        console.log(`
+\uD83D\uDCDD Added to .gitignore: ${added.join(", ")}`);
+      }
       displaySuccess("Hermes initialized successfully!");
       console.log(`
 \uD83D\uDCC4 Configuration saved to .hermes/config.json`);
@@ -37734,23 +37765,38 @@ async function interactiveConfig(repoInfo) {
     }
   };
 }
-async function appendToGitignore(content) {
-  try {
-    const { appendFile } = await import("fs/promises");
-    const gitignorePath = ".gitignore";
-    if (existsSync4(gitignorePath)) {
-      const { readFile: readFile5 } = await import("fs/promises");
-      const existing = await readFile5(gitignorePath, "utf-8");
-      if (!existing.includes(".hermes/backups")) {
-        await appendFile(gitignorePath, `
+var GITIGNORE_ENTRIES = [
+  { pattern: ".env", comment: null },
+  { pattern: ".env.*", comment: null },
+  { pattern: "!.env.example", comment: null },
+  { pattern: ".hermes/backups/", comment: null },
+  { pattern: ".hermes/stats.json", comment: null }
+];
+async function updateGitignore() {
+  const { appendFile, readFile: rf } = await import("fs/promises");
+  const gitignorePath = ".gitignore";
+  let existing = "";
+  if (existsSync4(gitignorePath)) {
+    try {
+      existing = await rf(gitignorePath, "utf-8");
+    } catch {}
+  }
+  const existingLines = existing.split(`
+`).map((l) => l.trim());
+  const toAdd = GITIGNORE_ENTRIES.filter((e) => !existingLines.includes(e.pattern));
+  if (toAdd.length === 0)
+    return [];
+  const block = `
 # Hermes
-` + content);
-      }
-    } else {
-      await writeFile4(gitignorePath, `# Hermes
-` + content);
-    }
-  } catch {}
+` + toAdd.map((e) => e.pattern).join(`
+`) + `
+`;
+  if (existsSync4(gitignorePath)) {
+    await appendFile(gitignorePath, block);
+  } else {
+    await writeFile4(gitignorePath, block.trimStart());
+  }
+  return toAdd.map((e) => e.pattern);
 }
 
 // src/commands/stats.ts
@@ -38737,32 +38783,348 @@ function buildInstallCommand(pm) {
   }
 }
 
+// src/commands/commit.ts
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var execAsync6 = promisify6(exec6);
+async function getStagedFiles2() {
+  try {
+    const { stdout } = await execAsync6("git diff --cached --name-status");
+    return stdout.trim().split(`
+`).filter(Boolean).map((line) => {
+      const [status, ...rest] = line.split("\t");
+      return { status: status.trim(), path: rest.join("\t").trim() };
+    });
+  } catch {
+    return [];
+  }
+}
+async function getUnstagedFiles() {
+  try {
+    const { stdout } = await execAsync6("git status --porcelain");
+    return stdout.trim().split(`
+`).filter(Boolean).map((line) => {
+      const status = line.slice(0, 2).trim();
+      const path5 = line.slice(3).trim();
+      return { status, path: path5 };
+    }).filter(({ status }) => status === "??" || status[0] === " " || status.length === 1);
+  } catch {
+    return [];
+  }
+}
+async function getRecentBranchCommits(n = 5) {
+  try {
+    const { stdout } = await execAsync6(`git log --oneline -${n} --no-merges 2>/dev/null`);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+function statusLabel(s) {
+  const map = {
+    M: source_default.yellow("modified "),
+    A: source_default.green("new file "),
+    D: source_default.red("deleted  "),
+    R: source_default.blue("renamed  "),
+    C: source_default.blue("copied   "),
+    "??": source_default.dim("untracked"),
+    " M": source_default.yellow("modified "),
+    " D": source_default.red("deleted  ")
+  };
+  return map[s] ?? source_default.dim(s.padEnd(9));
+}
+function divider() {
+  console.log(source_default.dim("  " + "─".repeat(54)));
+}
+async function analyzeChanges(branch, stagedDiff, stagedStat, recentCommits) {
+  const prompt2 = `You are an expert Git historian. Analyze these staged changes and produce a structured commit analysis.
+
+Branch: ${branch}
+Recent commits on this branch:
+${recentCommits || "(none — first commit)"}
+
+Staged diff summary:
+${stagedStat}
+
+Full staged diff (truncated to 12000 chars):
+${stagedDiff.slice(0, 12000)}
+
+Return RAW JSON ONLY — no markdown, no code fences, just the JSON object:
+{
+  "summary": "2-3 sentences: what was changed and the likely intent behind it",
+  "concerns": ["array of concerns — mixed unrelated changes, debug/temp code, large binary, TODO left in, test missing, etc. Empty array if none."],
+  "message": "conventional commit: type(scope): subject (max 72 chars). Be specific.",
+  "body": "optional multi-line body explaining WHY (not WHAT). Empty string if the subject is self-explanatory.",
+  "alternatives": ["two alternative commit messages if the intent is ambiguous"]
+}
+
+Rules for message:
+- type: feat | fix | refactor | docs | test | chore | style | perf | build | ci
+- scope: the primary module/component affected (omit if changes are cross-cutting)
+- subject: imperative mood, no period, lowercase after colon
+- be specific — "add OAuth login" not "add feature"`;
+  const raw = await getAISuggestion(prompt2);
+  const cleaned = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    return {
+      summary: "Could not parse analysis.",
+      concerns: [],
+      message: cleaned.split(`
+`)[0].slice(0, 72),
+      body: "",
+      alternatives: []
+    };
+  }
+}
+function commitCommand(program2) {
+  program2.command("commit").description("Analyze staged changes with AI and craft a commit message").option("-a, --all", "Stage all tracked changes before analysis").option("--no-body", "Omit the commit body even if one is suggested").action(async (options) => {
+    const start = Date.now();
+    try {
+      const repoState = await getRepoState();
+      if (options.all) {
+        displayStep("git add -u");
+        await execAsync6("git add -u");
+      }
+      const staged = await getStagedFiles2();
+      if (staged.length === 0) {
+        console.log(source_default.yellow(`
+  Nothing staged to commit.`));
+        console.log(source_default.dim("  Use `git add <file>` or run `hermes commit --all` to stage tracked changes.\n"));
+        process.exit(0);
+      }
+      const unstaged = await getUnstagedFiles();
+      const recentCommits = await getRecentBranchCommits(5);
+      console.log();
+      console.log(source_default.bold(`  Staged (${staged.length} file${staged.length === 1 ? "" : "s"}):`));
+      for (const f of staged) {
+        console.log(`    ${statusLabel(f.status)} ${source_default.white(f.path)}`);
+      }
+      const relevantUnstaged = unstaged.filter((u) => !staged.some((s) => s.path === u.path));
+      if (relevantUnstaged.length > 0) {
+        console.log();
+        console.log(source_default.dim(`  Not staged (${relevantUnstaged.length}):`));
+        for (const f of relevantUnstaged.slice(0, 8)) {
+          console.log(`    ${statusLabel(f.status)} ${source_default.dim(f.path)}`);
+        }
+        if (relevantUnstaged.length > 8) {
+          console.log(source_default.dim(`    ...and ${relevantUnstaged.length - 8} more`));
+        }
+      }
+      const { name, model } = await getActiveProvider();
+      console.log();
+      console.log(`  Analyzing... ${source_default.dim(`[${name} / ${model}]`)}`);
+      const [stagedDiff, stagedStat] = await Promise.all([
+        execAsync6("git diff --cached").then((r) => r.stdout),
+        execAsync6("git diff --cached --stat").then((r) => r.stdout)
+      ]);
+      const analysis = await analyzeChanges(repoState.currentBranch, stagedDiff, stagedStat, recentCommits);
+      console.log();
+      divider();
+      console.log();
+      console.log("  " + source_default.bold("Understanding"));
+      console.log();
+      const words = analysis.summary.split(" ");
+      let line = "  ";
+      for (const w of words) {
+        if (line.length + w.length > 62) {
+          console.log(source_default.white(line));
+          line = "  " + w + " ";
+        } else {
+          line += w + " ";
+        }
+      }
+      if (line.trim())
+        console.log(source_default.white(line));
+      if (analysis.concerns.length > 0) {
+        console.log();
+        for (const c of analysis.concerns) {
+          console.log(`  ${source_default.yellow("⚠")}  ${source_default.yellow(c)}`);
+        }
+      }
+      console.log();
+      divider();
+      console.log();
+      const hasBody = options.body !== false && analysis.body.trim().length > 0;
+      console.log("  " + source_default.bold("Proposed commit"));
+      console.log();
+      console.log("  " + source_default.cyan.bold(analysis.message));
+      if (hasBody) {
+        console.log();
+        analysis.body.split(`
+`).forEach((l) => {
+          console.log("  " + source_default.dim(l));
+        });
+      }
+      console.log();
+      let finalMessage = analysis.message;
+      let finalBody = hasBody ? analysis.body : "";
+      let committed = false;
+      while (!committed) {
+        const choices = [
+          { name: "Commit", value: "commit" },
+          { name: "Edit message", value: "edit" }
+        ];
+        if (analysis.alternatives?.length > 0) {
+          choices.push({ name: "See alternative messages", value: "alts" });
+        }
+        if (relevantUnstaged.length > 0) {
+          choices.push({ name: "Stage more files first", value: "stage" });
+        }
+        choices.push({ name: "Cancel", value: "cancel" });
+        const { action } = await esm_default12.prompt([
+          {
+            type: "list",
+            name: "action",
+            message: "What would you like to do?",
+            choices
+          }
+        ]);
+        if (action === "cancel") {
+          console.log(source_default.dim(`
+  Cancelled. Changes remain staged.
+`));
+          await recordCommand("commit", [], Date.now() - start, false);
+          return;
+        }
+        if (action === "alts") {
+          console.log();
+          analysis.alternatives.forEach((alt, i) => {
+            console.log(`  ${source_default.dim(`${i + 1}.`)} ${source_default.cyan(alt)}`);
+          });
+          console.log();
+          const { pick } = await esm_default12.prompt([
+            {
+              type: "list",
+              name: "pick",
+              message: "Use an alternative?",
+              choices: [
+                ...analysis.alternatives.map((a, i) => ({ name: a, value: `${i}` })),
+                { name: "Keep original", value: "keep" }
+              ]
+            }
+          ]);
+          if (pick !== "keep") {
+            finalMessage = analysis.alternatives[parseInt(pick, 10)];
+            finalBody = "";
+            console.log();
+            console.log("  " + source_default.cyan.bold(finalMessage));
+            console.log();
+          }
+          continue;
+        }
+        if (action === "edit") {
+          const { edited } = await esm_default12.prompt([
+            {
+              type: "input",
+              name: "edited",
+              message: "Commit message:",
+              default: finalMessage
+            }
+          ]);
+          finalMessage = edited.trim();
+          finalBody = "";
+          console.log();
+          continue;
+        }
+        if (action === "stage") {
+          const { files } = await esm_default12.prompt([
+            {
+              type: "checkbox",
+              name: "files",
+              message: "Select files to stage:",
+              choices: relevantUnstaged.map((f) => ({
+                name: `${statusLabel(f.status)} ${f.path}`,
+                value: f.path
+              }))
+            }
+          ]);
+          if (files.length > 0) {
+            for (const f of files) {
+              const cmd = `git add ${JSON.stringify(f)}`;
+              displayStep(cmd);
+              await execAsync6(cmd);
+            }
+            console.log(source_default.dim(`
+  Staged ${files.length} file(s). Re-running analysis...
+`));
+            const [newDiff, newStat] = await Promise.all([
+              execAsync6("git diff --cached").then((r) => r.stdout),
+              execAsync6("git diff --cached --stat").then((r) => r.stdout)
+            ]);
+            const newAnalysis = await analyzeChanges(repoState.currentBranch, newDiff, newStat, recentCommits);
+            analysis.summary = newAnalysis.summary;
+            analysis.concerns = newAnalysis.concerns;
+            analysis.message = newAnalysis.message;
+            analysis.body = newAnalysis.body;
+            analysis.alternatives = newAnalysis.alternatives;
+            finalMessage = newAnalysis.message;
+            finalBody = options.body !== false && newAnalysis.body.trim().length > 0 ? newAnalysis.body : "";
+            console.log("  " + source_default.bold("Updated proposal"));
+            console.log();
+            console.log("  " + source_default.cyan.bold(finalMessage));
+            if (finalBody) {
+              console.log();
+              finalBody.split(`
+`).forEach((l) => console.log("  " + source_default.dim(l)));
+            }
+            if (newAnalysis.concerns.length > 0) {
+              console.log();
+              newAnalysis.concerns.forEach((c) => {
+                console.log(`  ${source_default.yellow("⚠")}  ${source_default.yellow(c)}`);
+              });
+            }
+            console.log();
+          }
+          continue;
+        }
+        if (action === "commit") {
+          const fullMessage = finalBody ? `${finalMessage}
+
+${finalBody}` : finalMessage;
+          displayStep(`git commit -m "${finalMessage}"${finalBody ? " (with body)" : ""}`);
+          await execAsync6(`git commit -m ${JSON.stringify(fullMessage)}`);
+          displaySuccess("Committed!");
+          const { stdout: hash } = await execAsync6("git rev-parse --short HEAD");
+          console.log(source_default.dim(`  ${hash.trim()} ${finalMessage}
+`));
+          await recordCommand("commit", [], Date.now() - start, true);
+          committed = true;
+        }
+      }
+    } catch (error3) {
+      console.error("❌ Error:", error3 instanceof Error ? error3.message : error3);
+      await recordCommand("commit", [], Date.now() - start, false);
+      process.exit(1);
+    }
+  });
+}
+
 // src/lib/update-notifier.ts
 import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir2 } from "os";
 import path5 from "path";
 var PACKAGE_NAME2 = "hermes-git";
-var CHECK_INTERVAL = 24 * 60 * 60 * 1000;
+var CHECK_INTERVAL = 12 * 60 * 60 * 1000;
 var CACHE_DIR = path5.join(homedir2(), ".hermes", "cache");
 var CACHE_FILE = path5.join(CACHE_DIR, "update-check.json");
-async function getLatestVersion() {
+async function fetchDistTags() {
   try {
-    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME2}/latest`);
-    if (!response.ok)
-      return null;
-    const data = await response.json();
-    return data.version || null;
+    const res = await fetch(`https://registry.npmjs.org/-/package/${PACKAGE_NAME2}/dist-tags`, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok)
+      return {};
+    return await res.json();
   } catch {
-    return null;
+    return {};
   }
 }
 async function readCache() {
   try {
     if (!existsSync6(CACHE_FILE))
       return null;
-    const content = await readFile6(CACHE_FILE, "utf-8");
-    return JSON.parse(content);
+    return JSON.parse(await readFile6(CACHE_FILE, "utf-8"));
   } catch {
     return null;
   }
@@ -38773,36 +39135,66 @@ async function writeCache(cache) {
     await writeFile6(CACHE_FILE, JSON.stringify(cache, null, 2));
   } catch {}
 }
-function isNewerVersion(current, latest) {
-  const currentParts = current.split(".").map(Number);
-  const latestParts = latest.split(".").map(Number);
+function compareVersions2(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
   for (let i = 0;i < 3; i++) {
-    if (latestParts[i] > currentParts[i])
-      return true;
-    if (latestParts[i] < currentParts[i])
-      return false;
+    if (pa[i] > pb[i])
+      return 1;
+    if (pa[i] < pb[i])
+      return -1;
   }
-  return false;
+  return 0;
+}
+async function enforceMinimumVersion(currentVersion) {
+  try {
+    const cache = await readCache();
+    const now = Date.now();
+    const stale = !cache || now - cache.lastChecked > CHECK_INTERVAL;
+    let minimumVersion = cache?.minimumVersion ?? null;
+    let latestVersion = cache?.latestVersion ?? null;
+    if (stale) {
+      const tags = await fetchDistTags();
+      latestVersion = tags.latest ?? latestVersion;
+      minimumVersion = tags.minimum ?? null;
+      await writeCache({ lastChecked: now, latestVersion: latestVersion ?? undefined, minimumVersion: minimumVersion ?? undefined });
+    }
+    if (minimumVersion && compareVersions2(currentVersion, minimumVersion) < 0) {
+      console.error("");
+      console.error(source_default.red.bold("  ✖ This version of hermes is no longer supported."));
+      console.error("");
+      console.error(`  You have ${source_default.dim(currentVersion)}, minimum required is ${source_default.red.bold(minimumVersion)}.`);
+      console.error("");
+      console.error("  Update now:");
+      console.error(`    ${source_default.cyan("npm install -g hermes-git@latest")}`);
+      console.error(`    ${source_default.dim("or:  hermes update")}`);
+      console.error("");
+      process.exit(1);
+    }
+  } catch {}
 }
 async function checkForUpdates(currentVersion) {
   try {
     const cache = await readCache();
     const now = Date.now();
-    const shouldCheck = !cache || now - cache.lastChecked > CHECK_INTERVAL;
-    let latestVersion = cache?.latestVersion || null;
-    if (shouldCheck) {
-      latestVersion = await getLatestVersion();
+    const stale = !cache || now - cache.lastChecked > CHECK_INTERVAL;
+    let latestVersion = cache?.latestVersion ?? null;
+    if (stale) {
+      const tags = await fetchDistTags();
+      latestVersion = tags.latest ?? null;
       await writeCache({
         lastChecked: now,
-        latestVersion: latestVersion || undefined
+        latestVersion: latestVersion ?? undefined,
+        minimumVersion: cache?.minimumVersion
       });
     }
-    if (latestVersion && isNewerVersion(currentVersion, latestVersion)) {
+    if (latestVersion && compareVersions2(latestVersion, currentVersion) > 0) {
+      const gap = " ".repeat(Math.max(0, 17 - currentVersion.length - latestVersion.length));
       console.log(source_default.yellow(`
-┌─────────────────────────────────────────────────────┐`));
-      console.log(source_default.yellow("│") + "  " + source_default.bold("Update available!") + " " + source_default.dim(currentVersion) + " → " + source_default.green.bold(latestVersion) + "       " + source_default.yellow("│"));
-      console.log(source_default.yellow("│") + "  Run: " + source_default.cyan("npm install -g hermes-git@latest") + "  " + source_default.yellow("│"));
-      console.log(source_default.yellow(`└─────────────────────────────────────────────────────┘
+┌──────────────────────────────────────────────────────┐`));
+      console.log(source_default.yellow("│") + `  ${source_default.bold("Update available!")} ${source_default.dim(currentVersion)} → ${source_default.green.bold(latestVersion)}${gap}` + source_default.yellow("│"));
+      console.log(source_default.yellow("│") + `  Run: ${source_default.cyan("hermes update")}` + " ".repeat(36) + source_default.yellow("│"));
+      console.log(source_default.yellow(`└──────────────────────────────────────────────────────┘
 `));
     }
   } catch {}
@@ -38889,7 +39281,7 @@ function printWorkflows() {
 
 // src/index.ts
 var program2 = new Command;
-var CURRENT_VERSION = "0.3.2";
+var CURRENT_VERSION = "0.3.6";
 program2.name("hermes").description("Intent-driven Git, guided by AI").version(CURRENT_VERSION).action(() => {
   printBanner(CURRENT_VERSION);
   printWorkflows();
@@ -38907,5 +39299,5 @@ workflowCommand(program2);
 configCommand(program2);
 guardCommand(program2);
 updateCommand(program2, CURRENT_VERSION);
-checkForUpdates(CURRENT_VERSION).catch(() => {});
-program2.parse();
+commitCommand(program2);
+enforceMinimumVersion(CURRENT_VERSION).then(() => program2.parseAsync()).then(() => checkForUpdates(CURRENT_VERSION)).catch(() => {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-git",
-  "version": "0.3.2",
+  "version": "0.3.6",
   "description": "Intent-driven Git, guided by AI. Turn natural language into safe, explainable Git operations.",
   "type": "module",
   "main": "./dist/index.js",