@abhaydesu/git-pilot 1.2.0 → 1.3.0

package/README.md

@@ -1,84 +1,112 @@
-<div align="center" display="inline">
-  <img width="40" height="40" alt="logo" src="./public/logo-dark-new.png" />
-</div>
-
-# Git Pilot 
-
-[![NPM Version](https://img.shields.io/npm/v/@abhaydesu/git-pilot)](https://www.npmjs.com/package/@abhaydesu/git-pilot)
-
-An AI-powered assistant that lives in your command line to streamline your Git workflow. Never write a commit message or look up a command again.
-
----
-
-## The Problem
-Remembering complex commands like interactive rebase can be a pain. Writing well-formatted commit messages is a chore. Git is powerful, but its interface can sometimes get in the way of a fast workflow.
-
-**Git Pilot** solves this by acting as your intelligent copilot, translating your natural language intent into the exact commands and messages you need.
-
-## Features
-* **AI-Powered Commit Messages:** Analyzes your staged changes (`git diff`) and generates a perfect commit message following the Conventional Commits specification. Just run `git pilot commit <your_intent>`
-* **Natural Language to Git Command:** Translate plain English requests like "squash the last 3 commits" into the precise Git command. One simple `git pilot run <your_request>`
-* **Magic Undo:** Made a mistake? `git pilot undo` analyzes your recent history and suggests the exact command to reverse your last action.
-* **Intelligent Branching:** Describe your goal, and `git pilot branch` will create a clean, conventional branch name for you.
-* **Interactive & Safe:** Always asks for your confirmation before executing any command. You can also **edit** any AI suggestion to get it just right.
-
-## Installation
-Make sure you have Node.js (v18+) and Git installed. Then, run the following command to install Git Pilot globally:
-
-```bash
-npm install -g @abhaydesu/git-pilot
-```
-
-### ◾ Usage
-
-#### *Generating a Commit Message*
-Stage your files (git add .), then run git pilot commit. This command analyzes your staged changes and generates a conventional commit message.
-
-##### With an Intent
-Provide a brief description of your changes, and the AI will use it to write the commit message.
-
-```Bash
-
-git pilot commit "add new user profile page"
-```
-
-##### Without an Intent
-If you don't provide an intent, the AI will analyze the diff of your staged files and generate a message automatically.
-
-```Bash
-
-git pilot commit
-```
-After running, you can accept, edit, or abort the suggested commit.
-
-
-#### *Running a Git Command*
-Run the run command with the task you want to perform. The tool will suggest a command and ask for confirmation.
-
-```Bash
-
-git pilot run "cherry-pick the last commit from the main branch" 
-```
-
-#### *Creating a New Branch*
-Describe the purpose of your new branch, and let the AI generate a conventional name.
-
-```Bash
-
-git pilot branch "create a new feature for the auth system"
-```
-
-#### *Undoing a Mistake*
-
-If you've made a mistake (like a bad commit or merge), this command will analyze your history and suggest the safest way to undo it.
-
-```Bash
-
-git pilot undo 
-```
-
-### ◾ How It Works
-Git Pilot is a CLI tool that communicates with a secure backend API. This API uses Google's Gemini models to understand your intent and analyze code, keeping your API keys safe and off your local machine.
-
-### ◾ License
+<div align="center" display="inline">
+  <img width="40" height="40" alt="logo" src="./public/logo.png" />
+</div>
+
+# Git Pilot 
+
+[![NPM Version](https://img.shields.io/npm/v/@abhaydesu/git-pilot)](https://www.npmjs.com/package/@abhaydesu/git-pilot)
+
+An AI-powered assistant that lives in your command line to streamline your Git workflow. Never write a commit message or look up a command again.
+
+---
+
+## The Problem
+Remembering complex commands like interactive rebase can be a pain. Writing well-formatted commit messages is a chore. Git is powerful, but its interface can sometimes get in the way of a fast workflow.
+
+**Git Pilot** solves this by acting as your intelligent copilot, translating your natural language intent into the exact commands and messages you need.
+
+## Features
+* **AI-Powered Commit Messages:** Analyzes your staged changes (`git diff`) and generates a perfect commit message following the Conventional Commits specification. Just run `git pilot commit <your_intent>`
+* **Natural Language to Git Command:** Translate plain English requests like "squash the last 3 commits" into the precise Git command. One simple `git pilot run <your_request>`
+* **Magic Undo:** Made a mistake? `git pilot undo` analyzes your recent history and suggests the exact command to reverse your last action.
+* **Intelligent Branching:** Describe your goal, and `git pilot branch` will create a clean, conventional branch name for you.
+* **Interactive & Safe:** Always asks for your confirmation before executing any command. You can also **edit** any AI suggestion to get it just right. Suggested commands must be plain `git ...` commands and are never run through a shell, so chained commands (`;`, `&&`, `|`, `$(...)`) and non-git programs are refused.
+
+## Installation
+Make sure you have Node.js (v20+) and Git installed. Then, run the following command to install Git Pilot globally:
+
+```bash
+npm install -g @abhaydesu/git-pilot
+```
+
+### ◾ Usage
+
+#### *Generating a Commit Message*
+Stage your files (git add .), then run git pilot commit. This command analyzes your staged changes and generates a conventional commit message.
+
+##### With an Intent
+Provide a brief description of your changes, and the AI will use it to write the commit message.
+
+```Bash
+
+git pilot commit "add new user profile page"
+```
+
+##### Without an Intent
+If you don't provide an intent, the AI will analyze the diff of your staged files and generate a message automatically.
+
+```Bash
+
+git pilot commit
+```
+After running, you can accept, edit, or abort the suggested commit.
+
+
+#### *Running a Git Command*
+Run the run command with the task you want to perform. The tool will suggest a command and ask for confirmation.
+
+```Bash
+
+git pilot run "cherry-pick the last commit from the main branch" 
+```
+
+#### *Creating a New Branch*
+Describe the purpose of your new branch, and let the AI generate a conventional name.
+
+```Bash
+
+git pilot branch "create a new feature for the auth system"
+```
+
+#### *Undoing a Mistake*
+
+If you've made a mistake (like a bad commit or merge), this command will analyze your history and suggest the safest way to undo it.
+
+```Bash
+
+git pilot undo 
+```
+
+Check the installed version with `git pilot --version`, or see all commands with `git pilot --help`.
+
+### ◾ Configuration
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `GIT_PILOT_API_URL` | `https://git-pilot-api.vercel.app` | Base URL of the backend API. Set it to use a self-hosted or local instance, e.g. `GIT_PILOT_API_URL=http://localhost:3000 git pilot run "show status"`. |
+
+Very large staged diffs (over ~800,000 characters) are not sent in full. Git Pilot sends the list of changed files instead and uses your intent to write the message.
+
+### ◾ Development
+
+```bash
+git clone https://github.com/abhaydesu/git-pilot-cli.git
+cd git-pilot-cli
+npm install
+node bin/git-pilot.js --help   # or `npm link` to get a global `git-pilot`
+```
+
+| Script | What it does |
+| --- | --- |
+| `npm test` | Unit tests (`node --test`) |
+| `npm run test:e2e` | Runs the real CLI in a PTY against a fake API and a scratch repo (needs `expect`; skipped if missing) |
+| `npm run lint` | ESLint |
+| `npm run format` | Prettier |
+
+Code layout: `bin/` (entry point), `src/commands/` (one file per command), `src/lib/` (`api`, `git`, `exec`, `ui`).
+
+### ◾ How It Works
+Git Pilot is a CLI tool that communicates with a secure backend API. This API uses Google's Gemini models to understand your intent and analyze code, keeping your API keys safe and off your local machine.
+
+### ◾ License
 This project is licensed under the MIT License.

package/bin/git-pilot.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { buildProgram } from "../src/cli.js";
+
+await buildProgram().parseAsync(process.argv);

package/package.json

@@ -1,26 +1,55 @@
-{
-  "name": "@abhaydesu/git-pilot",
-  "version": "1.2.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "bin": {
-    "git-pilot": "./index.js"
-  },
-  "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "preferGlobal": true,
-  "dependencies": {
-    "axios": "^1.12.2",
-    "chalk": "^5.6.2",
-    "commander": "^14.0.1",
-    "dotenv": "^17.2.2",
-    "execa": "^9.6.0",
-    "inquirer": "^12.9.6",
-    "ora": "^9.0.0"
-  }
-}
+{
+  "name": "@abhaydesu/git-pilot",
+  "version": "1.3.0",
+  "description": "AI-powered Git assistant: commit messages, natural-language git commands, undo suggestions and branch names.",
+  "main": "src/cli.js",
+  "scripts": {
+    "test": "node --test \"test/*.test.js\"",
+    "test:e2e": "bash test/e2e/run.sh",
+    "lint": "eslint .",
+    "format": "prettier --write ."
+  },
+  "bin": {
+    "git-pilot": "bin/git-pilot.js"
+  },
+  "type": "module",
+  "keywords": [
+    "git",
+    "cli",
+    "ai",
+    "gemini",
+    "commit",
+    "conventional-commits"
+  ],
+  "author": "",
+  "license": "MIT",
+  "preferGlobal": true,
+  "dependencies": {
+    "axios": "^1.12.2",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1",
+    "execa": "^9.6.0",
+    "inquirer": "^12.11.1",
+    "ora": "^9.4.1",
+    "shell-quote": "^1.10.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.11.0",
+    "globals": "^17.12.0",
+    "prettier": "^3.9.9"
+  },
+  "files": [
+    "bin",
+    "src",
+    "public",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abhaydesu/git-pilot-cli.git"
+  }
+}

package/src/cli.js

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { commitCommand } from "./commands/commit.js";
+import { runCommand } from "./commands/run.js";
+import { undoCommand } from "./commands/undo.js";
+import { branchCommand } from "./commands/branch.js";
+
+const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+
+export function buildProgram() {
+  const program = new Command()
+    .name("git-pilot")
+    .description("An AI-powered Git assistant in your command line.")
+    .version(version);
+
+  program
+    .command("commit")
+    .description("Generate an AI-powered commit message.")
+    .argument("[intent]", 'Optional: The user\'s intent for the commit (e.g., "add a new feature")')
+    .action(commitCommand);
+
+  program
+    .command("run")
+    .description("Translate natural language into a Git command.")
+    .argument("<string>", 'The task you want to perform (e.g. "squash the last 3 commits")')
+    .action(runCommand);
+
+  program
+    .command("undo")
+    .description("Suggests a command to undo your last major Git action")
+    .action(undoCommand);
+
+  program
+    .command("branch")
+    .description("Generates a conventional branch name from a description and creates the branch.")
+    .argument("<string>", 'A description of the branch\'s purpose (e.g., "fix login bug")')
+    .action(branchCommand);
+
+  return program;
+}

package/src/commands/branch.js

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { callApi } from "../lib/api.js";
+import * as git from "../lib/git.js";
+import {
+  spin,
+  showBlock,
+  chooseAcceptEditAbort,
+  editText,
+  success,
+  aborted,
+  handleError,
+} from "../lib/ui.js";
+
+export async function branchCommand(description) {
+  const spinner = spin("Generating a conventional branch name...");
+  try {
+    const { branchName } = await callApi("pilot-branch", { description });
+    spinner.succeed();
+
+    showBlock("Suggested Branch Name", branchName);
+
+    const choice = await chooseAcceptEditAbort();
+    if (choice === "abort") return aborted("Branch creation aborted by user.");
+
+    const chosen =
+      choice === "edit"
+        ? await editText("Edit the branch name:", branchName, "Branch name cannot be empty")
+        : branchName;
+
+    const safeName = git.slugifyBranchName(chosen);
+    if (!safeName) {
+      console.log(chalk.red("Resulting branch name is empty or invalid. Aborting."));
+      process.exit(1);
+    }
+
+    await git.createBranch(safeName);
+    success(`✔ Switched to new branch '${safeName}'`);
+  } catch (error) {
+    handleError(error, spinner);
+  }
+}

package/src/commands/commit.js

@@ -0,0 +1,48 @@
+import { callApi, MAX_DIFF_CHARS } from "../lib/api.js";
+import * as git from "../lib/git.js";
+import {
+  spin,
+  showBlock,
+  chooseAcceptEditAbort,
+  editText,
+  success,
+  aborted,
+  handleError,
+} from "../lib/ui.js";
+
+const OVERSIZED_PREFIX =
+  "The staged changes are too large to display the full diff. " +
+  "Please generate a commit message based on the user's intent and this summary of changed files:\n\n";
+
+export async function commitCommand(intent) {
+  const spinner = spin("Analyzing your staged changes...");
+  try {
+    const diff = await git.getStagedDiff();
+    if (!diff) {
+      spinner.warn("No staged changes found. Please stage your files with `git add`.");
+      return;
+    }
+
+    const diffToSend =
+      diff.length > MAX_DIFF_CHARS ? OVERSIZED_PREFIX + (await git.getStagedSummary()) : diff;
+
+    spinner.text = "Generating commit message...";
+    const { message } = await callApi("pilot-commit", { intent, diff: diffToSend });
+    spinner.succeed();
+
+    showBlock("Suggested Message", message);
+
+    const choice = await chooseAcceptEditAbort();
+    if (choice === "abort") return aborted("Commit aborted by user.");
+
+    const finalMessage =
+      choice === "edit"
+        ? await editText("Edit the commit message: ", message, "Commit message cannot be empty.")
+        : message;
+
+    await git.commit(finalMessage);
+    success("Commit successful!");
+  } catch (error) {
+    handleError(error, spinner);
+  }
+}

package/src/commands/run.js

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { callApi } from "../lib/api.js";
+import { parseGitCommand, runGit } from "../lib/exec.js";
+import { spin, showBlock, confirm, success, aborted, handleError } from "../lib/ui.js";
+
+export async function runCommand(request) {
+  const spinner = spin("Fetching the right command...");
+  try {
+    const { command } = await callApi("pilot-run", { request });
+
+    if (command.startsWith("Error:")) {
+      spinner.fail(command);
+      process.exit(1);
+    }
+    spinner.succeed();
+
+    // Validate before showing anything the user might be tempted to confirm.
+    const args = parseGitCommand(command);
+
+    console.log(
+      chalk.yellow.bold("\nWARNING: The suggested command will be executed on your repository.")
+    );
+    console.log(chalk.yellow("Always review commands carefully before confirming."));
+    showBlock("Suggested Command", command);
+
+    if (!(await confirm("Execute this command?"))) {
+      return aborted("Execution aborted by user.");
+    }
+
+    await runGit(args);
+    success("Command executed successfully!");
+  } catch (error) {
+    handleError(error, spinner);
+  }
+}

package/src/commands/undo.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import { callApi } from "../lib/api.js";
+import { parseGitCommand, runGit } from "../lib/exec.js";
+import * as git from "../lib/git.js";
+import { spin, showBlock, confirm, success, aborted, handleError } from "../lib/ui.js";
+
+export async function undoCommand() {
+  const spinner = spin("Analyzing your recent Git history...");
+  try {
+    const reflog = await git.getReflog();
+
+    spinner.text = "Suggesting an undo command...";
+    const { command, explanation } = await callApi("pilot-undo", { reflog });
+
+    if (!command) {
+      spinner.warn("Couldn't determine a safe action to undo.");
+      return;
+    }
+    spinner.succeed();
+
+    const args = parseGitCommand(command);
+
+    showBlock("Suggested Undo Command", command);
+    console.log(chalk.yellow(explanation));
+
+    if (!(await confirm("Execute this undo command?"))) {
+      return aborted("Execution aborted by user.");
+    }
+
+    if (args[0] === "rebase" && args.includes("--abort") && !(await git.isRebaseInProgress())) {
+      return console.log(chalk.yellow("No rebase in progress — abort not necessary."));
+    }
+
+    await runGit(args);
+    success("Action successfully undone!");
+  } catch (error) {
+    handleError(error, spinner);
+  }
+}

package/src/lib/api.js

@@ -0,0 +1,26 @@
+import axios from "axios";
+
+export const DEFAULT_API_URL = "https://git-pilot-api.vercel.app";
+
+// The API rejects request bodies over 1 MB; keep the diff safely below that.
+export const MAX_DIFF_CHARS = 800_000;
+
+export const apiBaseUrl = () =>
+  (process.env.GIT_PILOT_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+
+/** POSTs `body` to `/api/<endpoint>` and returns the parsed response data. */
+export async function callApi(endpoint, body) {
+  const { data } = await axios.post(`${apiBaseUrl()}/api/${endpoint}`, body, {
+    timeout: 30_000,
+  });
+  return data;
+}
+
+/** Human-readable message for an axios/network/other error. */
+export function describeError(error) {
+  if (error.response) {
+    const detail = error.response.data?.error || "No message";
+    return `API Error: ${error.response.status} - ${detail}`;
+  }
+  return `An unexpected error occurred: ${error.message}`;
+}

package/src/lib/exec.js

@@ -0,0 +1,34 @@
+import { parse } from "shell-quote";
+import { execa } from "execa";
+
+export class UnsafeCommandError extends Error {}
+
+/**
+ * Turns a suggested command string into an argv array for `git`, or throws.
+ * Only plain `git <args...>` is accepted: quoting is honored, but shell
+ * operators (;, &&, |, >, $(...)), comments and non-git binaries are rejected.
+ * Nothing is ever run through a shell.
+ */
+export function parseGitCommand(command) {
+  // Keep `$VAR` literal instead of letting shell-quote expand it to "".
+  const tokens = parse(command, (key) => `$${key}`).map((token) =>
+    // Globs (`git add *.js`) are valid pathspecs that git expands itself.
+    typeof token === "object" && token.op === "glob" ? token.pattern : token
+  );
+
+  if (tokens.length === 0) {
+    throw new UnsafeCommandError("The suggested command is empty.");
+  }
+  if (tokens.some((token) => typeof token !== "string")) {
+    throw new UnsafeCommandError(
+      "The suggested command contains shell operators, which are not allowed."
+    );
+  }
+  if (tokens[0] !== "git" || tokens.length < 2) {
+    throw new UnsafeCommandError("Only git commands can be executed.");
+  }
+  return tokens.slice(1);
+}
+
+/** Runs `git <args>` with the terminal attached. */
+export const runGit = (args) => execa("git", args, { stdio: "inherit" });

package/src/lib/git.js

@@ -0,0 +1,36 @@
+import { execa } from "execa";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const git = async (args) => (await execa("git", args)).stdout;
+
+export const getStagedDiff = () => git(["diff", "--staged"]);
+export const getStagedSummary = () => git(["diff", "--staged", "--name-status"]);
+export const getReflog = () => git(["reflog", "-n", "15"]);
+export const commit = (message) => git(["commit", "-m", message]);
+export const createBranch = (name) => git(["switch", "-c", name]);
+
+const exists = (p) =>
+  fs.access(p).then(
+    () => true,
+    () => false
+  );
+
+export async function isRebaseInProgress() {
+  const gitDir = path.resolve(await git(["rev-parse", "--git-dir"]));
+  return (
+    (await exists(path.join(gitDir, "rebase-apply"))) ||
+    (await exists(path.join(gitDir, "rebase-merge")))
+  );
+}
+
+/** Lowercase, hyphenated, git-safe branch name; "" if nothing usable is left. */
+export const slugifyBranchName = (name) =>
+  name
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9._\-/]/g, "")
+    .replace(/\/{2,}/g, "/")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 250);

package/src/lib/ui.js

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import { describeError } from "./api.js";
+import { UnsafeCommandError } from "./exec.js";
+
+// ora 9.x divides by stream.columns; a PTY that reports 0 columns makes its
+// redraw loop spin forever. Give it a sane fallback.
+if (!process.stderr.columns) process.stderr.columns = 80;
+
+// discardStdin is off so the spinner never swallows the input inquirer needs next.
+export const spin = (text) => ora({ text, discardStdin: false }).start();
+
+export function showBlock(title, body) {
+  const bar = "-".repeat(title.length + 14);
+  console.log(chalk.green(`\n------ ${title} ------`));
+  console.log(chalk.cyan(body));
+  console.log(chalk.green(`${bar}\n`));
+}
+
+export async function confirm(message) {
+  const { ok } = await inquirer.prompt([{ type: "confirm", name: "ok", message, default: false }]);
+  return ok;
+}
+
+/** Accept / Edit / Abort menu; returns "accept" | "edit" | "abort". */
+export async function chooseAcceptEditAbort() {
+  const { choice } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "What would you like to do?",
+      choices: [
+        { name: "Accept", value: "accept" },
+        { name: "Edit", value: "edit" },
+        { name: "Abort", value: "abort" },
+      ],
+    },
+  ]);
+  return choice;
+}
+
+/** Opens $EDITOR on `initial`; returns the trimmed result. */
+export async function editText(message, initial, emptyMessage) {
+  const { text } = await inquirer.prompt([
+    {
+      type: "editor",
+      name: "text",
+      message,
+      default: initial,
+      validate: (input) => (input.trim().length > 0 ? true : emptyMessage),
+    },
+  ]);
+  return text.trim();
+}
+
+export const success = (text) => console.log(chalk.bgGreen.black(text));
+export const aborted = (text) => console.log(chalk.red(text));
+
+/** Prints an error, stops the spinner if it is running, and exits non-zero. */
+export function handleError(error, spinner) {
+  if (spinner?.isSpinning) spinner.fail();
+
+  if (error?.name === "ExitPromptError") {
+    console.error(chalk.red("\nCancelled."));
+    process.exit(130);
+  }
+  if (error instanceof UnsafeCommandError) {
+    console.error(chalk.red(`Refusing to run: ${error.message}`));
+  } else {
+    console.error(chalk.red(describeError(error)));
+  }
+  process.exit(1);
+}

package/index.js

@@ -1,368 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from "commander";
-import { execa, execaCommand } from "execa";
-import axios from "axios";
-import inquirer from "inquirer";
-import chalk from "chalk";
-import ora from "ora";
-
-const API_BRANCH_URL = "https://git-pilot-api.vercel.app/api/pilot-branch";
-const API_COMMIT_URL = "https://git-pilot-api.vercel.app/api/pilot-commit";
-const API_COMMAND_URL = "https://git-pilot-api.vercel.app/api/pilot-run";
-const API_UNDO_URL = "https://git-pilot-api.vercel.app/api/pilot-undo";
-
-const getStagedDiff = async () => {
-  try {
-    const { stdout } = await execa("git", ["diff", "--staged"]);
-    return stdout;
-  } catch (error) {
-    console.error(
-      chalk.red("Error getting git diff:"),
-      error?.message || error
-    );
-    process.exit(1);
-  }
-};
-
-program
-  .name("git-pilot")
-  .description("An AI-powered Git assistant in your command line.");
-
-program
-  .command("commit")
-  .description("Generate an AI-powered commit message.")
-  .argument(
-    "[intent]",
-    'Optional: The user\'s intent for the commit (e.g., "add a new feature")'
-  )
-  .action(async (intent) => {
-    const spinner = ora("Analyzing your staged changes...").start();
-
-    const diff = await getStagedDiff();
-
-    if (!diff) {
-      spinner.warn(
-        "No staged changes found. Please stage your files with `git add`."
-      );
-      process.exit(0);
-    }
-
-    const MAX_PAYLOAD_SIZE = 4 * 1024 * 1024; 
-    const diffSize = Buffer.byteLength(diff, 'utf8');
-    let diffToSend = diff;
-
-    if (diffSize > MAX_PAYLOAD_SIZE) {
-      
-      const { stdout: diffSummary } = await execa("git", ["diff", "--staged", "--name-status"]);
-      
-      diffToSend = "The staged changes are too large to display the full diff. " +
-                   "Please generate a commit message based on the user's intent and this summary of changed files:\n\n" +
-                   diffSummary;
-    }
-
-    try {
-      spinner.text = "Generating commit message...";
-
-      const response = await axios.post(
-        API_COMMIT_URL,
-        { intent, diff: diffToSend },
-        { timeout: 30000 }
-      );
-
-      const suggestedMessage = response.data.message;
-
-      spinner.succeed();
-
-      console.log(chalk.green("\n--- Suggested Message ---"));
-      console.log(chalk.cyan(suggestedMessage));
-      console.log(chalk.green("-------------------------\n"));
-
-      const { choice } = await inquirer.prompt([
-        {
-          type: "list",
-          name: "choice",
-          message: "What would you like to do?",
-          choices: [
-            { name: "Accept", value: "accept" },
-            { name: "Edit", value: "edit" },
-            { name: "Abort", value: "abort" },
-          ],
-        },
-      ]);
-
-      if (choice === 'abort') {
-        console.log(chalk.red('Commit aborted by user.'));
-        process.exit(0);
-      }
-
-      if (choice == "edit") {
-        const { editedMessage } = await inquirer.prompt([
-          {
-            type: "editor",
-            name: "editedMessage",
-            message: "Edit the commit message: ",
-            default: suggestedMessage,
-            validate: (input) =>
-              input.length > 0 ? true : "Commit message cannot be empty.",
-          },
-        ]);
-
-        await execa("git", ["commit", "-m", editedMessage]);
-        console.log(chalk.bgGreen.black("Commit successful!"));
-      }
-
-      if (choice === "accept") {
-        await execa("git", ["commit", "-m", suggestedMessage]);
-        console.log(chalk.bgGreen.black("Commit successful!"));
-      }
-
-    } catch (error) {
-      if (error.response) {
-        console.error(
-          chalk.red(
-            `API Error: ${error.response.status} - ${error.response.data.error}`
-          )
-        );
-      } else {
-        console.error(
-          chalk.red("An unexpected error occurred: ", error.message)
-        );
-      }
-
-      process.exit(1);
-    }
-  });
-
-program
-  .command("run")
-  .description("Translate natural language into a Git command.")
-  .argument(
-    "<string>",
-    'The task you want to perform (e.g. "squash the last 3 commits")'
-  )
-  .action(async (request) => {
-    try {
-      const spinner = ora("Fetching the right command...").start();
-
-      const response = await axios.post(
-        API_COMMAND_URL,
-        { request },
-        { timeout: 30000 }
-      );
-      const suggestedCommand = response.data.command;
-
-      if (suggestedCommand.startsWith("Error:")) {
-        spinner.fail(suggestedCommand);
-        process.exit(1);
-      }
-
-      spinner.succeed();
-
-      console.log(
-        chalk.yellow.bold(
-          "\nWARNING: The suggested command will be executed in your shell."
-        )
-      );
-      console.log(
-        chalk.yellow("Always review commands carefully before confirming.\n")
-      );
-
-      console.log(chalk.green("\n------ Suggested Command ------"));
-      console.log(chalk.cyan(suggestedCommand));
-      console.log(chalk.green("-------------------------------\n"));
-
-      const { confirm } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "confirm",
-          message: "Execute this command?",
-          default: false,
-        },
-      ]);
-
-      if (confirm) {
-        await execaCommand(suggestedCommand, { stdio: "inherit" });
-        console.log(chalk.bgGreen.black("Command executed successfully!"));
-      } else {
-        console.log(chalk.red("Execution aborted by user."));
-      }
-    } catch (error) {
-      if (error.response) {
-        console.error(
-          chalk.red(
-            `API Error: ${error.response.status} - ${
-              error.response.data.error || "No message"
-            }`
-          )
-        );
-      } else {
-        console.error(
-          chalk.red(`An unexpected error occurred: ${error.message}`)
-        );
-      }
-
-      process.exit(1);
-    }
-  });
-
-program
-  .command("undo")
-  .description("Suggests a command to undo your last major Git action")
-  .action(async () => {
-    const spinner = ora("Analyzing your recent Git history...").start();
-
-    try {
-      const { stdout: reflog } = await execa("git", ["reflog", "-n", "15"]);
-
-      spinner.text = "Suggesting an undo command...";
-
-      const response = await axios.post(API_UNDO_URL, { reflog });
-      const { command, explanation } = response.data;
-
-      if (!command) {
-        spinner.warn("Couldn't determine a safe action to undo.");
-        process.exit(0);
-      }
-
-      spinner.succeed();
-
-      console.log(chalk.green("\n--- Suggested Undo Command ---"));
-      console.log(chalk.cyan(command));
-      console.log(chalk.green("------------------------------\n"));
-      console.log(chalk.yellow(explanation));
-
-      const { confirm } = await inquirer.prompt([
-        {
-          type: "confirm",
-          name: "confirm",
-          message: "Execute this undo command?",
-          default: false,
-        },
-      ]);
-
-      if (confirm) {
-        if (command.startsWith('git rebase --abort')) {
-          try {
-            const { stdout: gitDirRaw } = await execa('git', ['rev-parse', '--git-dir']);
-            const gitDir = gitDirRaw.trim();
-
-            const fs = await import('fs/promises');
-
-            const rebaseApply = `${gitDir}/rebase-apply`;
-            const rebaseMerge = `${gitDir}/rebase-merge`;
-
-            const hasRebaseApply = await fs.access(rebaseApply).then(() => true).catch(() => false);
-            const hasRebaseMerge = await fs.access(rebaseMerge).then(() => true).catch(() => false);
-
-            if (!hasRebaseApply && !hasRebaseMerge) {
-              console.log(chalk.yellow('No rebase in progress — abort not necessary.'));
-              process.exit(0);
-            }
-          } catch (e) {
-          }
-        }
-
-        await execaCommand(command, { stdio: "inherit" });        
-        console.log(chalk.bgGreen.black("Action successfully undone!"));
-      } else {
-        console.log(chalk.red("Execution aborted by user."));
-      }
-    } catch (error) {
-      spinner.fail();
-
-      if (error.response) {
-        console.error(chalk.red(`API Error: ${error.response.status} - ${error.response.data.error || 'No message'}`));
-      } else {
-        console.error(chalk.red(`An unexpected error occurred: ${error.message}`));
-      }
-
-      process.exit(1);
-    }
-  });
-
-  program
-  .command('branch')
-  .description('Generates a conventional branch name from a description and creates the branch.')
-  .argument('<string>', 'A description of the branch\'s purpose (e.g., "fix login bug")')
-  .action(async (description) => {
-    const spinner = ora('Generating a conventional branch name...').start();
-    try {
-      const response = await axios.post(API_BRANCH_URL, { description });
-      const { branchName } = response.data;
-
-      spinner.succeed();
-
-      console.log(chalk.green('\n--- Suggested Branch Name ---'));
-      console.log(chalk.cyan(branchName));
-      console.log(chalk.green('-----------------------------\n'));
-
-      const { choice } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'choice',
-          message: 'What would you like to do?',
-          choices: [
-            { name: 'Accept', value: 'accept' },
-            { name: 'Edit', value: 'edit' },
-            { name: 'Abort', value: 'abort' },
-          ],
-        },
-      ]);
-
-      if (choice === 'abort') {
-        console.log(chalk.red('Branch creation aborted by user.'));
-        process.exit(0);
-      }
-
-      let finalBranchName = branchName;
-
-      if (choice === 'edit') {
-        const editResp = await inquirer.prompt({
-          type: 'editor',
-          name: 'editedBranchName',
-          message: 'Edit the branch name:',
-          default: branchName,
-          validate: value => (value && value.trim().length > 0) ? true : 'Branch name cannot be empty'
-        }, {
-              onCancel: () => {
-                console.log(chalk.red('\nEdit cancelled.'));
-                process.exit(0);
-                }
-        });
-
-        finalBranchName = editResp.editedBranchName;
-      }
-
-      const slugifyBranchName = (name) =>
-        name
-          .toLowerCase()
-          .trim()
-          .replace(/\s+/g, '-')             
-          .replace(/[^a-z0-9._\-\/]/g, '') 
-          .replace(/\/{2,}/g, '/')        
-          .replace(/^-+|-+$/g, '')        
-          .slice(0, 250);
-
-      const safeBranchName = slugifyBranchName(finalBranchName || '');
-
-      if (!safeBranchName) {
-        console.log(chalk.red('Resulting branch name is empty or invalid. Aborting.'));
-        process.exit(1);
-      }
-
-      await execa('git', ['switch', '-c', safeBranchName]);
-      console.log(chalk.bgGreen.black(`✔ Switched to new branch '${safeBranchName}'`));
-
-    } catch (error) {
-      spinner.fail();
-      if (error.response) {
-        console.error(chalk.red(`API Error: ${error.response.status} - ${error.response.data.error || 'No message'}`));
-      } else {
-        console.error(chalk.red(`An unexpected error occurred: ${error.message}`));
-      }
-      process.exit(1);
-    }
-  });
-
-program.parse(process.argv);