@abhaydesu/git-pilot 1.0.3 → 1.2.0

package/README.md

@@ -1,22 +1,28 @@
+<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.
+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
+## 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
-* **Natural Language to Git Command:** Translate plain English requests like "squash the last 3 commits" into the precise Git command (`git rebase -i HEAD~3`).
-* **AI-Powered Commit Messages:** Analyzes your staged changes (`git diff`) and generates a perfect commit message following the Conventional Commits specification.
-
-* **Interactive & Safe:** Always asks for your confirmation before executing any command, ensuring you're always in control.
+## 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
+## Installation
 Make sure you have Node.js (v18+) and Git installed. Then, run the following command to install Git Pilot globally:
 
 ```bash
@@ -25,28 +31,51 @@ npm install -g @abhaydesu/git-pilot
 
 ### ◾ Usage
 
-#### **Running a Git Command**
-Run the run command with the task you want to perform in quotes.
+#### *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 run "create a new branch called feature/auth" 
+git pilot commit "add new user profile page"
 ```
-The tool will suggest the correct Git command and ask for confirmation before executing it.
 
+##### 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.
 
-#### **Generating a Commit Message**
-Stage your files (git add .).
+```Bash
+
+git pilot commit
+```
+After running, you can accept, edit, or abort the suggested commit.
 
-Run the commit command with your intent in quotes.
+
+#### *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 commit "add new user profile page"
+git pilot run "cherry-pick the last commit from the main branch" 
 ```
-The tool will suggest a message and ask for confirmation before committing.
 
+#### *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.

package/index.js

@@ -1,28 +1,30 @@
-#!/usr/bin/env node
+#!/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_COMMIT_URL = "http://git-pilot-api.vercel.app/api/commit-message";
-const API_COMMAND_URL ="http://git-pilot-api.vercel.app/api/git-command"
-
+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);
+    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.");
@@ -31,60 +33,172 @@ program
   .command("commit")
   .description("Generate an AI-powered commit message.")
   .argument(
-    "<string>",
-    'The user\'s intent for the commit (e.g., "add a new feature")'
+    "[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 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`.");
+      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...';
+      spinner.text = "Generating commit message...";
 
-      const response = await axios.post(API_COMMIT_URL,
-        { intent, diff},
+      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: "Commit with this message?",
-          default: true,
+          message: "Execute this command?",
+          default: false,
         },
       ]);
 
       if (confirm) {
-        await execa("git", ["commit", "-m", suggestedMessage]);
-        console.log(chalk.bgGreen.black("Commit successful!"));
+        await execaCommand(suggestedCommand, { stdio: "inherit" });
+        console.log(chalk.bgGreen.black("Command executed successfully!"));
       } else {
-        console.log(chalk.red("Commit aborted by user."));
+        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}`
-                )
-            );
+      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 occured: ", error.message)
+          chalk.red(`An unexpected error occurred: ${error.message}`)
         );
       }
 
@@ -92,62 +206,163 @@ program
     }
   });
 
-
 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) => {
+  .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 spinner = ora('Fetching the right command...').start();
+      const { stdout: reflog } = await execa("git", ["reflog", "-n", "15"]);
 
-        const response = await axios.post(
-            API_COMMAND_URL, 
-            { request },
-            { timeout: 30000 }
-        );
-        const suggestedCommand = response.data.command;
+      spinner.text = "Suggesting an undo command...";
 
-        if (suggestedCommand.startsWith('Error:')) {
-            spinner.fail(suggestedCommand);
-            process.exit(1);
-        }
+      const response = await axios.post(API_UNDO_URL, { reflog });
+      const { command, explanation } = response.data;
 
-        spinner.succeed();
+      if (!command) {
+        spinner.warn("Couldn't determine a safe action to undo.");
+        process.exit(0);
+      }
 
-        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'));
+      spinner.succeed();
 
-        console.log(chalk.green('\n------ Suggested Command ------'));
-        console.log(chalk.cyan(suggestedCommand));
-        console.log(chalk.green('-------------------------------\n'));
+      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 command?',
-                default: false,
-            },
-        ]);
+      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');
 
-        if (confirm) {
-            await execaCommand(suggestedCommand, {stdio: 'inherit'});
-            console.log(chalk.bgGreen.black('Command executed successfully!'));
-        } else {
-            console.log(chalk.red('Execution aborted by user.'));
+            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) {
-        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}`));
-        }
+      spinner.fail();
 
-  process.exit(1);
-}
-  })
+      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);
+program.parse(process.argv);

package/package.json

@@ -1,26 +1,26 @@
-{
-  "name": "@abhaydesu/git-pilot",
-  "version": "1.0.3",
-  "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.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"
+  }
+}