@abhaydesu/git-pilot 1.0.2 → 1.1.0

package/README.md

@@ -1,55 +1,104 @@
-# Git Pilot 
+<div align="center" display="inline">
+  <img width="30" height="30" alt="logo" src="./public/logo-pilot.png" />
+</div>
 
-[![NPM Version](https://img.shields.io/npm/v/@abhaydesu/git-pilot)](https://www.npmjs.com/package/@abhaydesu/git-pilot)
+# Git Pilot API
 
-An AI-powered assistant that lives in your command line to streamline your Git workflow.
+This is the backend API server that powers the <a href="https://www.npmjs.com/package/@abhaydesu/git-pilot">`git-pilot`</a> CLI tool. It handles the secure communication with AI models to generate Git commands, commit messages, undo actions, and branch names.
 
+## ◼️ Purpose
 
-## ◼️ 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.
+The primary role of this API is to act as a secure intermediary between the <a href="https://github.com/abhaydesu/git-pilot-cli">`git-pilot-cli` </a> and the AI service (Google Gemini). This architecture ensures that the AI API keys are never exposed on a user's local machine.
 
-**Git Pilot** solves this by acting as your intelligent copilot, translating your natural language intent into the exact commands and messages you need.
+## ◼️ Technology Stack
 
-## ◼️ 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.
+* **Runtime:** Node.js
+* **Framework:** Express.js
+* **AI Service:** Google Gemini API
+* **Deployment:** Vercel
 
-* **Interactive & Safe:** Always asks for your confirmation before executing any command, ensuring you're always in control.
+## ◼️ API Endpoints
 
-## ◼️ Installation
-Make sure you have Node.js (v18+) and Git installed. Then, run the following command to install Git Pilot globally:
+The API exposes the following endpoints:
 
-```bash
-npm install -g @abhaydesu/git-pilot
-```
+### 1. Generate Commit Message
 
-### ◾ Usage
+* **Route:** `POST /api/pilot-commit`
+* **Description:** Analyzes a Git diff and a user's intent to generate a conventional commit message.
+* **Request Body (JSON):**
 
-#### **Running a Git Command**
-Run the run command with the task you want to perform in quotes.
+  ```json
+  {
+    "intent": "string",
+    "diff": "string"
+  }
+  ```
+* **Success Response (200 - JSON):**
 
-```Bash
+  ```json
+  {
+    "message": "string"
+  }
+  ```
 
-git pilot run "create a new branch called feature/auth" 
-```
-The tool will suggest the correct Git command and ask for confirmation before executing it.
+### 2. Generate Git Command
 
+* **Route:** `POST /api/pilot-run`
+* **Description:** Translates a user's natural language request into an executable, safe Git command.
+* **Request Body (JSON):**
 
-#### **Generating a Commit Message**
-Stage your files (git add .).
+  ```json
+  {
+    "request": "string"
+  }
+  ```
+* **Success Response (200 - JSON):**
 
-Run the commit command with your intent in quotes.
+  ```json
+  {
+    "command": "string"
+  }
+  ```
 
-```Bash
+### 3. Undo Last Action
 
-git pilot commit "add new user profile page"
-```
-The tool will suggest a message and ask for confirmation before committing.
+* **Route:** `POST /api/pilot-undo`
+* **Description:** Suggests a safe Git command to undo the most recent significant action (merge, rebase, commit).
+* **Request Body (JSON):**
 
+  ```json
+  {
+    "reflog": "string"
+  }
+  ```
+* **Success Response (200 - JSON):**
 
+  ```json
+  {
+    "command": "string",
+    "explanation": "string"
+  }
+  ```
 
-### ◾ 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.
+### 4. Generate Branch Name
 
-### ◾ License
-This project is licensed under the MIT License.
+* **Route:** `POST /api/pilot-branch`
+* **Description:** Converts a natural language description into a conventional, kebab-case Git branch name.
+* **Request Body (JSON):**
+
+  ```json
+  {
+    "description": "string"
+  }
+  ```
+* **Success Response (200 - JSON):**
+
+  ```json
+  {
+    "branchName": "string"
+  }
+  ```
+
+### ◾ Deployment
+
+This API is designed for and deployed on Vercel.

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.");
@@ -35,56 +37,155 @@ program
     '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);
     }
 
     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 },
         { 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 +193,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();
 
-        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 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) {
-        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();
+
+      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);
+    }
+  });
 
-  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,25 +1,26 @@
-{
-  "name": "@abhaydesu/git-pilot",
-  "version": "1.0.2",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "bin": {
-    "git-pilot": "./index.js"
-  },
-  "type": "module",
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "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.1.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"
+  }
+}