hermes-git 0.2.3 → 0.2.5

package/README.md

@@ -469,25 +469,97 @@ Hermes is **terminal-native** and **explainable**:
 ### Copilot CLI Not Found
 
 ```bash
-Error: GitHub Copilot CLI not found
+❌ GitHub Copilot CLI is not installed
 ```
 
-**Solution:** Install from [github.com/github/copilot-cli](https://github.com/github/copilot-cli)
+**Problem:** Hermes requires the standalone Copilot CLI (not the deprecated `gh copilot` extension).
+
+**Solution:**
+
+```bash
+# Install via npm (recommended)
+npm install -g @github/copilot
+
+# Or via Homebrew (macOS/Linux)
+brew install github/gh/copilot-cli
+
+# Verify installation
+copilot --version
+```
+
+**Note:** The old `gh copilot` extension was deprecated on October 25, 2025. If you have it installed, you'll see a warning—install the new standalone CLI instead.
+
+---
 
 ### Authentication Required
 
 ```bash
-Error: authentication required
+❌ GitHub Copilot CLI is not authenticated
+```
+
+**Problem:** Copilot CLI needs GitHub authentication to work.
+
+**Solution (choose one):**
+
+**Option 1: OAuth (Recommended)**
+```bash
+# Start Copilot CLI interactively
+copilot
+
+# In the Copilot prompt, type:
+/login
+
+# Follow the browser OAuth flow
+```
+
+**Option 2: Personal Access Token**
+```bash
+# Create a token at: https://github.com/settings/tokens
+# Enable "Copilot Requests" permission under "Permissions"
+
+# Set the token in your environment
+export GH_TOKEN="your_token_here"
+
+# Add to your shell profile (~/.bashrc, ~/.zshrc) to persist:
+echo 'export GH_TOKEN="your_token_here"' >> ~/.bashrc
+```
+
+**Option 3: GitHub CLI Integration**
+```bash
+# If you already have gh CLI installed and authenticated
+gh auth login
+
+# Copilot CLI will automatically use those credentials
 ```
 
-**Solution:** Run `copilot login` and complete OAuth flow
+**Requirements:**
+- Active GitHub Copilot subscription ([subscribe here](https://github.com/features/copilot/plans))
+- If using organization Copilot, "Copilot CLI" must be enabled in org settings
+
+---
+
+### Subscription Issues
+
+```bash
+❌ GitHub Copilot subscription required
+```
+
+**Solution:**
+- Verify you have an active Copilot subscription at [github.com/settings/copilot](https://github.com/settings/copilot)
+- If using organization Copilot, check with your admin that "Copilot CLI" is enabled
+- Individual plans start at $10/month, or free for students/OSS maintainers
+
+---
 
 ### Slow Responses
 
 If AI responses are slow, try:
-- Use a faster model: `--model claude-sonnet-4.5` (default)
+- Use a faster model: `--model claude-sonnet-4.5` (default, fastest)
 - Check internet connection
 - Verify Copilot subscription is active
+- Try running `copilot` directly to test connection
+
+---
 
 ### Command Not Working
 
@@ -495,16 +567,33 @@ If AI responses are slow, try:
 # Check Hermes version
 hermes --version
 
-# Verify Copilot CLI
+# Verify Copilot CLI is installed and authenticated
 copilot --version
+copilot -p "test" --allow-all-tools -s
+
+# Check git is working
+git status
 
 # Test in a clean repo
 cd /tmp && git init test && cd test
+git config user.name "Test" && git config user.email "test@example.com"
 hermes plan "test"
 ```
 
 ---
 
+### Getting Help
+
+If you're still having issues:
+1. Check the [GitHub Copilot CLI documentation](https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-copilot-cli)
+2. Verify Copilot CLI works independently: `copilot -p "hello" -s`
+3. Open an issue at [github.com/simandebvu/hermes-cli/issues](https://github.com/simandebvu/hermes-cli/issues) with:
+   - Output of `hermes --version`
+   - Output of `copilot --version`
+   - The exact error message you're seeing
+
+---
+
 ## Contributing
 
 Contributions are welcome! Please see [DEVELOPMENT.md](DEVELOPMENT.md) for:

package/dist/index.js

@@ -21939,200 +21939,6 @@ var {
 // src/lib/copilot.ts
 import { exec } from "child_process";
 import { promisify } from "util";
-var execAsync = promisify(exec);
-async function getCopilotSuggestion(prompt, options = {}) {
-  try {
-    await checkCopilotCLI();
-    const {
-      model = "claude-sonnet-4.5",
-      allowAllTools = true,
-      silent = true
-    } = options;
-    const args = [
-      "-p",
-      `"${prompt.replace(/"/g, "\\\"")}"`,
-      "--model",
-      model
-    ];
-    if (allowAllTools) {
-      args.push("--allow-all-tools");
-    }
-    if (silent) {
-      args.push("-s");
-    }
-    const command = `copilot ${args.join(" ")}`;
-    const { stdout, stderr } = await execAsync(command, {
-      maxBuffer: 10 * 1024 * 1024,
-      timeout: 120000
-    });
-    if (stderr && !stdout) {
-      throw new Error(`Copilot CLI error: ${stderr}`);
-    }
-    return stdout.trim();
-  } catch (error) {
-    if (error.code === "ENOENT" || error.message.includes("not found")) {
-      throw new Error(`GitHub Copilot CLI not found. Install it from: https://github.com/github/copilot-cli
-` + "Then authenticate with: copilot login");
-    }
-    throw new Error(`Copilot CLI error: ${error.message}`);
-  }
-}
-async function checkCopilotCLI() {
-  try {
-    const { stdout } = await execAsync("copilot --version");
-    if (!stdout.includes("GitHub Copilot CLI")) {
-      throw new Error("Invalid Copilot CLI installation");
-    }
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`GitHub Copilot CLI is not installed.
-` + `Install from: https://github.com/github/copilot-cli
-` + "Or with npm: npm install -g @githubnext/github-copilot-cli");
-    }
-    throw error;
-  }
-}
-async function analyzeCopilotGitState(repoState, intent) {
-  const prompt = `
-You are a Git safety expert. Analyze this repository state and provide guidance.
-
-Repository State:
-${JSON.stringify(repoState, null, 2)}
-
-User Intent: "${intent}"
-
-Provide a clear, actionable analysis including:
-1. Current state summary (clean/dirty, branch position, conflicts, etc.)
-2. Recommended approach with reasoning
-3. Potential risks and safety considerations
-4. Step-by-step Git commands (if applicable)
-
-Be specific about WHY each step is safe and necessary.
-Format your response in clear sections.
-`;
-  return getCopilotSuggestion(prompt);
-}
-async function getCopilotGitPlan(repoState, intent, outputFormat = "json") {
-  const formatInstruction = outputFormat === "json" ? "Return your response as RAW JSON ONLY (no markdown code blocks, no backticks, just pure JSON) with fields: explanation, commands[], risks[], safetyNotes[]" : "Return your response as formatted text with clear sections";
-  const prompt = `
-You are a Git automation expert. Create a safe execution plan.
-
-Repository State:
-${JSON.stringify(repoState, null, 2)}
-
-User wants to: "${intent}"
-
-${formatInstruction}
-
-Ensure all Git commands are:
-- Safe (non-destructive when possible)
-- Ordered correctly
-- Include necessary error handling
-- Explain the purpose of each command
-`;
-  const response = await getCopilotSuggestion(prompt);
-  if (outputFormat === "json") {
-    return stripMarkdownCodeBlock(response);
-  }
-  return response;
-}
-function stripMarkdownCodeBlock(text) {
-  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-  if (codeBlockMatch) {
-    return codeBlockMatch[1].trim();
-  }
-  return text.trim();
-}
-
-// src/lib/git.ts
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-async function getRepoState() {
-  try {
-    const [
-      currentBranch,
-      status,
-      tracking,
-      rebaseStatus,
-      mergeStatus,
-      cherryPickStatus
-    ] = await Promise.all([
-      execAsync2("git rev-parse --abbrev-ref HEAD").then((r) => r.stdout.trim()),
-      execAsync2("git status --porcelain").then((r) => r.stdout.trim()),
-      execAsync2("git rev-parse --abbrev-ref @{upstream}").then((r) => r.stdout.trim()).catch(() => null),
-      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -d ${r.stdout.trim()}/rebase-merge`)).then(() => true).catch(() => false),
-      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -f ${r.stdout.trim()}/MERGE_HEAD`)).then(() => true).catch(() => false),
-      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -f ${r.stdout.trim()}/CHERRY_PICK_HEAD`)).then(() => true).catch(() => false)
-    ]);
-    const statusLines = status.split(`
-`).filter((line) => line);
-    const hasUncommittedChanges = statusLines.some((line) => line.startsWith(" M") || line.startsWith("M "));
-    const hasUntrackedFiles = statusLines.some((line) => line.startsWith("??"));
-    let ahead = 0;
-    let behind = 0;
-    if (tracking) {
-      const aheadBehind = await execAsync2(`git rev-list --left-right --count ${tracking}...HEAD`).then((r) => r.stdout.trim().split("\t")).catch(() => ["0", "0"]);
-      behind = parseInt(aheadBehind[0], 10);
-      ahead = parseInt(aheadBehind[1], 10);
-    }
-    return {
-      currentBranch,
-      isClean: statusLines.length === 0,
-      hasUncommittedChanges,
-      hasUntrackedFiles,
-      isInRebase: rebaseStatus,
-      isInMerge: mergeStatus,
-      isInCherryPick: cherryPickStatus,
-      remoteTracking: tracking || undefined,
-      ahead,
-      behind
-    };
-  } catch (error) {
-    throw new Error("Not a Git repository or Git is not installed");
-  }
-}
-async function isGitInstalled() {
-  try {
-    await execAsync2("git --version");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isGitRepository() {
-  try {
-    await execAsync2("git rev-parse --git-dir");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function hasCommits() {
-  try {
-    await execAsync2("git rev-parse HEAD");
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function executeGitCommand(command) {
-  try {
-    const { stdout, stderr } = await execAsync2(command);
-    return stdout || stderr;
-  } catch (error) {
-    throw new Error(`Git command failed: ${error.message}`);
-  }
-}
-async function getConflictedFiles() {
-  try {
-    const { stdout } = await execAsync2("git diff --name-only --diff-filter=U");
-    return stdout.trim().split(`
-`).filter((line) => line);
-  } catch {
-    return [];
-  }
-}
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -22623,6 +22429,309 @@ var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
+// src/lib/copilot.ts
+var execAsync = promisify(exec);
+async function getCopilotSuggestion(prompt, options = {}) {
+  try {
+    await checkCopilotCLI();
+    const {
+      model = "claude-sonnet-4.5",
+      allowAllTools = true,
+      silent = true
+    } = options;
+    const args = [
+      "-p",
+      `"${prompt.replace(/"/g, "\\\"")}"`,
+      "--model",
+      model
+    ];
+    if (allowAllTools) {
+      args.push("--allow-all-tools");
+    }
+    if (silent) {
+      args.push("-s");
+    }
+    const command = `copilot ${args.join(" ")}`;
+    const { stdout, stderr } = await execAsync(command, {
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 120000
+    });
+    if (stderr && !stdout) {
+      throw new Error(`Copilot CLI error: ${stderr}`);
+    }
+    return stdout.trim();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.message.includes("not found")) {
+      throw new CopilotNotInstalledError;
+    }
+    const errorMessage = (error.message || "").toLowerCase();
+    const stderr = (error.stderr || "").toLowerCase();
+    const combinedError = errorMessage + " " + stderr;
+    if (combinedError.includes("no authentication information") || combinedError.includes("authentication required") || combinedError.includes("not authenticated") || combinedError.includes("copilot_github_token") || combinedError.includes("gh_token") || combinedError.includes("github_token")) {
+      throw new CopilotNotAuthenticatedError(error.message);
+    }
+    if (combinedError.includes("subscription") || combinedError.includes("not authorized") || combinedError.includes("access denied")) {
+      throw new Error(source_default.red(`❌ GitHub Copilot subscription required
+
+`) + source_default.white(`Hermes requires an active GitHub Copilot subscription.
+`) + source_default.gray(`Subscribe at: https://github.com/features/copilot/plans
+
+`) + source_default.dim("Original error: " + error.message));
+    }
+    throw new Error(source_default.red(`❌ Copilot CLI error
+
+`) + source_default.white(error.message) + `
+
+` + source_default.dim("If this persists, try running: copilot --version"));
+  }
+}
+async function checkCopilotCLI() {
+  await checkForDeprecatedGhCopilot();
+  try {
+    const { stdout } = await execAsync("copilot --version", { timeout: 5000 });
+    if (!stdout.includes("GitHub Copilot CLI")) {
+      throw new Error("Invalid Copilot CLI installation");
+    }
+  } catch (error) {
+    if (error.code === "ENOENT" || error.message.includes("not found")) {
+      throw new CopilotNotInstalledError;
+    }
+    throw error;
+  }
+}
+async function checkForDeprecatedGhCopilot() {
+  try {
+    const { stdout } = await execAsync("gh copilot --version", { timeout: 5000 });
+    if (stdout) {
+      console.warn(source_default.yellow(`
+⚠️  Warning: You have the deprecated "gh copilot" extension installed.`));
+      console.warn(source_default.yellow("   The GitHub Copilot extension was deprecated on October 25, 2025."));
+      console.warn(source_default.yellow(`   Hermes requires the new standalone "copilot" CLI.
+`));
+    }
+  } catch {}
+}
+
+class CopilotNotInstalledError extends Error {
+  constructor() {
+    const message = [
+      "",
+      source_default.red("❌ GitHub Copilot CLI is not installed"),
+      "",
+      source_default.bold("Hermes requires the standalone Copilot CLI (not the deprecated gh copilot extension)."),
+      "",
+      source_default.cyan("\uD83D\uDCE6 Installation Options:"),
+      "",
+      source_default.white("  npm:       ") + source_default.gray("npm install -g @github/copilot"),
+      source_default.white("  Homebrew:  ") + source_default.gray("brew install github/gh/copilot-cli"),
+      source_default.white("  Manual:    ") + source_default.gray("https://github.com/github/copilot-cli/releases"),
+      "",
+      source_default.cyan("\uD83D\uDD10 After installation, authenticate with:"),
+      "",
+      source_default.white("  copilot") + source_default.gray(" (then run /login command)"),
+      "",
+      source_default.dim("\uD83D\uDCDA Learn more: https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli"),
+      ""
+    ].join(`
+`);
+    super(message);
+    this.name = "CopilotNotInstalledError";
+  }
+}
+
+class CopilotNotAuthenticatedError extends Error {
+  constructor(originalError) {
+    const ghAuthStatus = checkGhAuthenticationSync();
+    const message = [
+      "",
+      source_default.red("❌ GitHub Copilot CLI is not authenticated"),
+      "",
+      ghAuthStatus.isAuthenticated ? source_default.yellow("⚠️  Note: You have gh CLI authenticated, but Copilot CLI needs separate authentication.") : source_default.bold("Hermes needs access to GitHub Copilot to provide AI-powered Git guidance."),
+      "",
+      source_default.cyan("\uD83D\uDD10 Quick Fix:"),
+      "",
+      source_default.white("  Run: ") + source_default.bold.green("copilot"),
+      source_default.gray("  Then type: ") + source_default.bold("/login"),
+      source_default.gray("  Follow the OAuth flow in your browser"),
+      "",
+      source_default.cyan("\uD83D\uDD10 Alternative - Personal Access Token:"),
+      "",
+      source_default.gray("  1. Create token: https://github.com/settings/tokens/new"),
+      source_default.gray('  2. Enable "Copilot Requests" permission'),
+      source_default.gray("  3. Run: ") + source_default.white('export GH_TOKEN="your_token_here"'),
+      source_default.gray("  4. Add to ~/.bashrc or ~/.zshrc to persist"),
+      "",
+      source_default.cyan("\uD83D\uDCCB Requirements:"),
+      source_default.gray("  • Active GitHub Copilot subscription"),
+      source_default.gray('  • If using organization Copilot, "Copilot CLI" must be enabled in org settings'),
+      "",
+      source_default.dim("\uD83D\uDCDA Learn more: https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-copilot-cli"),
+      ""
+    ].join(`
+`);
+    super(message);
+    this.name = "CopilotNotAuthenticatedError";
+  }
+}
+function checkGhAuthenticationSync() {
+  try {
+    const { execSync } = __require("child_process");
+    const result = execSync("gh auth status 2>&1", {
+      encoding: "utf-8",
+      timeout: 2000
+    });
+    const isAuthenticated = result.includes("Logged in to github.com");
+    const usernameMatch = result.match(/Logged in to github\.com as (\S+)/);
+    return {
+      isAuthenticated,
+      username: usernameMatch?.[1]
+    };
+  } catch {
+    return { isAuthenticated: false };
+  }
+}
+async function analyzeCopilotGitState(repoState, intent) {
+  const prompt = `
+You are a Git safety expert. Analyze this repository state and provide guidance.
+
+Repository State:
+${JSON.stringify(repoState, null, 2)}
+
+User Intent: "${intent}"
+
+Provide a clear, actionable analysis including:
+1. Current state summary (clean/dirty, branch position, conflicts, etc.)
+2. Recommended approach with reasoning
+3. Potential risks and safety considerations
+4. Step-by-step Git commands (if applicable)
+
+Be specific about WHY each step is safe and necessary.
+Format your response in clear sections.
+`;
+  return getCopilotSuggestion(prompt);
+}
+async function getCopilotGitPlan(repoState, intent, outputFormat = "json") {
+  const formatInstruction = outputFormat === "json" ? "Return your response as RAW JSON ONLY (no markdown code blocks, no backticks, just pure JSON) with fields: explanation, commands[], risks[], safetyNotes[]" : "Return your response as formatted text with clear sections";
+  const prompt = `
+You are a Git automation expert. Create a safe execution plan.
+
+Repository State:
+${JSON.stringify(repoState, null, 2)}
+
+User wants to: "${intent}"
+
+${formatInstruction}
+
+Ensure all Git commands are:
+- Safe (non-destructive when possible)
+- Ordered correctly
+- Include necessary error handling
+- Explain the purpose of each command
+`;
+  const response = await getCopilotSuggestion(prompt);
+  if (outputFormat === "json") {
+    return stripMarkdownCodeBlock(response);
+  }
+  return response;
+}
+function stripMarkdownCodeBlock(text) {
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return text.trim();
+}
+
+// src/lib/git.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function getRepoState() {
+  try {
+    const [
+      currentBranch,
+      status,
+      tracking,
+      rebaseStatus,
+      mergeStatus,
+      cherryPickStatus
+    ] = await Promise.all([
+      execAsync2("git rev-parse --abbrev-ref HEAD").then((r) => r.stdout.trim()),
+      execAsync2("git status --porcelain").then((r) => r.stdout.trim()),
+      execAsync2("git rev-parse --abbrev-ref @{upstream}").then((r) => r.stdout.trim()).catch(() => null),
+      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -d ${r.stdout.trim()}/rebase-merge`)).then(() => true).catch(() => false),
+      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -f ${r.stdout.trim()}/MERGE_HEAD`)).then(() => true).catch(() => false),
+      execAsync2("git rev-parse --git-dir").then((r) => execAsync2(`test -f ${r.stdout.trim()}/CHERRY_PICK_HEAD`)).then(() => true).catch(() => false)
+    ]);
+    const statusLines = status.split(`
+`).filter((line) => line);
+    const hasUncommittedChanges = statusLines.some((line) => line.startsWith(" M") || line.startsWith("M "));
+    const hasUntrackedFiles = statusLines.some((line) => line.startsWith("??"));
+    let ahead = 0;
+    let behind = 0;
+    if (tracking) {
+      const aheadBehind = await execAsync2(`git rev-list --left-right --count ${tracking}...HEAD`).then((r) => r.stdout.trim().split("\t")).catch(() => ["0", "0"]);
+      behind = parseInt(aheadBehind[0], 10);
+      ahead = parseInt(aheadBehind[1], 10);
+    }
+    return {
+      currentBranch,
+      isClean: statusLines.length === 0,
+      hasUncommittedChanges,
+      hasUntrackedFiles,
+      isInRebase: rebaseStatus,
+      isInMerge: mergeStatus,
+      isInCherryPick: cherryPickStatus,
+      remoteTracking: tracking || undefined,
+      ahead,
+      behind
+    };
+  } catch (error) {
+    throw new Error("Not a Git repository or Git is not installed");
+  }
+}
+async function isGitInstalled() {
+  try {
+    await execAsync2("git --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isGitRepository() {
+  try {
+    await execAsync2("git rev-parse --git-dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasCommits() {
+  try {
+    await execAsync2("git rev-parse HEAD");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function executeGitCommand(command) {
+  try {
+    const { stdout, stderr } = await execAsync2(command);
+    return stdout || stderr;
+  } catch (error) {
+    throw new Error(`Git command failed: ${error.message}`);
+  }
+}
+async function getConflictedFiles() {
+  try {
+    const { stdout } = await execAsync2("git diff --name-only --diff-filter=U");
+    return stdout.trim().split(`
+`).filter((line) => line);
+  } catch {
+    return [];
+  }
+}
+
 // src/lib/display.ts
 function displayPlan(suggestion, repoState) {
   console.log(source_default.bold.cyan(`\uD83D\uDCCB Recommended Plan:
@@ -25809,9 +25918,81 @@ Project-specific:`);
   });
 }
 
+// src/lib/update-notifier.ts
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { homedir } from "os";
+import path2 from "path";
+var PACKAGE_NAME = "hermes-git";
+var CHECK_INTERVAL = 24 * 60 * 60 * 1000;
+var CACHE_DIR = path2.join(homedir(), ".hermes", "cache");
+var CACHE_FILE = path2.join(CACHE_DIR, "update-check.json");
+async function getLatestVersion() {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`);
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.version || null;
+  } catch {
+    return null;
+  }
+}
+async function readCache() {
+  try {
+    if (!existsSync4(CACHE_FILE))
+      return null;
+    const content = await readFile4(CACHE_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cache) {
+  try {
+    await mkdir3(CACHE_DIR, { recursive: true });
+    await writeFile4(CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {}
+}
+function isNewerVersion(current, latest) {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if (latestParts[i] > currentParts[i])
+      return true;
+    if (latestParts[i] < currentParts[i])
+      return false;
+  }
+  return false;
+}
+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();
+      await writeCache({
+        lastChecked: now,
+        latestVersion: latestVersion || undefined
+      });
+    }
+    if (latestVersion && isNewerVersion(currentVersion, latestVersion)) {
+      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(`└─────────────────────────────────────────────────────┘
+`));
+    }
+  } catch {}
+}
+
 // src/index.ts
 var program2 = new Command;
-program2.name("hermes").description("\uD83E\uDEBD Intent-driven Git, guided by AI").version("0.2.3");
+var CURRENT_VERSION = "0.2.4";
+program2.name("hermes").description("\uD83E\uDEBD Intent-driven Git, guided by AI").version(CURRENT_VERSION);
 initCommand(program2);
 planCommand(program2);
 startCommand(program2);
@@ -25821,4 +26002,5 @@ conflictCommand(program2);
 worktreeCommand(program2);
 statsCommand(program2);
 workflowCommand(program2);
+checkForUpdates(CURRENT_VERSION).catch(() => {});
 program2.parse();

package/package.json

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