@abhaydesu/git-pilot 1.3.1 → 2.0.1

package/README.md

@@ -2,120 +2,131 @@
   <img width="40" height="40" alt="logo" src="./public/logo.png" />
 </div>
 
-# Git Pilot 
+# 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.
+A local-first, AI-powered Git assistant that lives in your command line. Never write a commit message from scratch or look up a complex Git 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.
+
+- **Frictionless Commit Fast Path:** Simply run `git pilot` (or `git pilot commit`) with staged changes. It analyzes your staged diff and suggests a conventional commit message.
+- **Bare Intent & Context Support:** Add optional intent without ceremony: `git pilot add auth throttling` or `git pilot -m "fix login bug"` (unquoted multi-word `-m add auth throttling` is also supported).
+- **Scriptable Dry-Run Mode:** `git pilot --dry-run` sends spinners and warnings to `stderr` and writes only the generated commit message to `stdout`.
+- **Personal Key & Local Execution:** Connects directly to Google Gemini (`https://generativelanguage.googleapis.com`) using your personal API key. Git Pilot's hosted servers are never in the request path.
+- **OS Credential Manager Storage:** Your API key is stored locally in your operating system's native credential store (macOS Keychain, Windows Credential Manager, Linux Secret Service) without exposing secrets in process arguments.
+- **Best-Effort Pre-flight Secret Screening:** Staged diffs are screened locally for common high-confidence credential patterns (such as private keys, AWS access keys, GitHub tokens, Slack tokens, and Google API keys) before transmission.
+- **Best-Effort Index Modification Detection:** Checks your staged Git index tree hash (`git write-tree`) before generation and immediately before invoking `git commit` to detect concurrent staging changes.
+- **Natural Language to Git Commands:** Translate plain English requests like "squash the last 3 commits" into precise Git commands with `git pilot run <query>`.
+- **Safe Undo:** `git pilot undo` parses the structured action field of your latest reflog entry and checks live repository state before suggesting an undo command.
+- **Intelligent Branching:** Describe your goal, and `git pilot branch` generates a clean, conventional branch name.
+- **Safe Subprocess Execution:** Commands are validated against an allowlist and executed via `execa` using direct `argv` arrays (never through a shell). Provider API keys are stripped from the environment of all Git subprocesses and hooks, and diff collection disables external diff and textconv helpers (`--no-ext-diff --no-textconv`).
 
 ## Installation
-Make sure you have Node.js (v20+) and Git installed. Then, run the following command to install Git Pilot globally:
+
+Requires Node.js (v20+) and Git. Install Git Pilot globally via npm:
 
 ```bash
 npm install -g @abhaydesu/git-pilot
 ```
 
-### ◾ Usage
+## First-Run Setup
 
-#### *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.
+On your first `git pilot` run with staged changes, Git Pilot starts guided setup if it does not find an API key. You can also start it directly:
 
-##### With an Intent
-Provide a brief description of your changes, and the AI will use it to write the commit message.
+```bash
+git pilot setup
+```
 
-```Bash
+Setup shows the provider, selected model, and the data sent before asking for consent. Enter your Gemini API key at the masked prompt. Git Pilot validates the key and model with Google before saving the key to your OS credential manager; if validation fails, the key is not saved. The CLI currently defaults to `gemini-3.5-flash-lite`.
 
-git pilot commit "add new user profile page"
+Get a Gemini API key at [Google AI Studio](https://aistudio.google.com/app/apikey). Model availability depends on your Google project. Google currently limits access to Gemini 2.5 models for many new projects; if setup reports that a model is unavailable, check model access in Google AI Studio or set `model` in your Git Pilot config to a model available to your key, then run `git pilot setup` again. Config is stored at `~/.config/git-pilot/config.json` on macOS/Linux, or `%APPDATA%\git-pilot\config.json` on Windows. The previous built-in model is migrated automatically when an older config is loaded.
+
+To inspect or remove your stored credentials at any time:
+
+```bash
+git pilot auth status
+git pilot auth remove
 ```
 
-##### 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.
+## Usage
 
-```Bash
+### Generating a Commit Message (Fast Path)
 
-git pilot commit
-```
-After running, you can accept, edit, or abort the suggested commit.
+Stage your changes (`git add <files>`), then run `git pilot`:
 
+```bash
+# Analyze staged diff automatically
+git pilot
 
-#### *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.
+# Provide intent as bare words (no `commit` subcommand needed)
+git pilot add user profile page
 
-```Bash
+# Or use -m / --message-context
+git pilot -m "add user profile page"
 
-git pilot run "cherry-pick the last commit from the main branch" 
+# Output only the message to stdout without committing
+git pilot --dry-run
 ```
 
-#### *Creating a New Branch*
-Describe the purpose of your new branch, and let the AI generate a conventional name.
+After generation, an interactive menu (defaulting to **Abort** so pressing Enter accidentally never creates an unintended commit) allows you to:
 
-```Bash
+1. **Accept and commit:** Commits the staged changes using `git commit -m`.
+2. **Edit in $EDITOR:** Opens your configured editor to modify the message.
+3. **Regenerate message:** Asks Gemini for another suggestion.
+4. **Abort:** Cancels without modifying your Git repository.
 
-git pilot branch "create a new feature for the auth system"
-```
+Google receives each staged diff and intent sent for generation directly from the CLI. Calls use your Gemini API quota and follow your Google AI plan's limits and pricing. See Google's [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing).
 
-#### *Undoing a Mistake*
+### Running a Git Command
 
-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 run "cherry-pick the last commit from main"
+```
 
-```Bash
+### Creating a Conventional Branch
 
-git pilot undo 
+```bash
+git pilot branch "create a new feature for the auth system"
 ```
 
-Check the installed version with `git pilot --version`, or see all commands with `git pilot --help`.
+### Undoing a Mistake
 
-### ◾ Configuration
+```bash
+git pilot undo
+```
 
-| 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"`. |
+## Privacy & Security Model
 
-`GIT_PILOT_API_URL` must use `https` (plain `http` is accepted only for `localhost`), because your staged diffs are sent to that server.
+- **Credential Storage & Transport:** The API key is stored locally in your operating system credential manager (macOS Keychain, Windows Credential Manager, Linux Secret Service). When making an AI request, your key is transmitted directly over TLS to Google's official Gemini endpoint (`https://generativelanguage.googleapis.com`) in the `x-goog-api-key` header; Git Pilot's hosted servers never receive your API key or repository diffs in personal-key mode.
+- **Data Sent to Provider:** Only the staged diff (or a bounded file-status summary for diffs exceeding 800,000 characters or 1 MB UTF-8 JSON size) and optional user intent are transmitted when generating commit messages. Untracked and unstaged files are never read or sent. Before the first provider request, Git Pilot requires acknowledging a versioned data-sharing notice regardless of whether the key is stored in the OS credential manager or supplied via `GEMINI_API_KEY`. Provider data retention and model training terms are governed by Google's [Gemini API Terms of Service](https://ai.google.dev/terms).
+- **Best-Effort Secret Screening:** Before sending any diff, Git Pilot screens staged changes for common high-confidence credential patterns. This heuristic screening is a best-effort safeguard and **cannot guarantee that a diff is free of all secrets or proprietary data**—always review staged changes before running `git pilot`.
+- **Git Subprocess & Hook Isolation:** Git Pilot strips `GEMINI_API_KEY` and other provider secret variables from the environment of every Git subprocess (including `git commit` hooks) and passes `--no-ext-diff --no-textconv` whenever collecting diffs.
+- **Index Modification Check:** Git Pilot records `git write-tree` before calling the provider and re-checks it immediately before invoking `git commit`. This provides best-effort detection if files were staged or unstaged while reviewing the proposal.
 
-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.
+## Configuration & Environment Variables
 
-### ◾ Privacy and Security
+| Variable         | Description                                                                                                                                                                                                                                                      |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GEMINI_API_KEY` | Optional ephemeral override for CI/headless environments. Takes precedence over (and shadows) the OS credential store without persisting to disk. `git pilot auth status` and `git pilot auth remove` distinguish between environment and OS-stored credentials. |
+| `NO_COLOR`       | Disables ANSI color codes in terminal output (complies with [no-color.org](https://no-color.org)).                                                                                                                                                               |
 
-* `git pilot commit` sends your **staged diff** (and intent) to the Git Pilot API, which forwards it to Google's Gemini API. `run` sends your request text, `undo` your last 15 reflog lines, and `branch` your description. **Don't stage secrets or code you can't share** when using `commit`.
-* Suggested commands are validated locally before you are even asked to confirm: only `git` with a known subcommand (`add`, `commit`, `push`, ...), no shell operators, no leading global options (`git -c ...`), and no options that run other programs (`--upload-pack`, `--exec`, ...).
-* Commands run without a shell, and only after you confirm.
-* To report a vulnerability, please open a private security advisory on the GitHub repository rather than a public issue.
+Non-secret configuration is saved in your platform's standard configuration directory (`~/.config/git-pilot/config.json` on POSIX systems with restrictive `0600` permissions).
 
-### ◾ Development
+## 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`
+npm test            # Run unit tests
+npm run test:e2e    # Run end-to-end PTY tests (requires expect)
+npm run lint        # Run ESLint
+npm run format      # Format with Prettier
 ```
 
-| 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
 
-### ◾ License
-This project is licensed under the MIT License.
+MIT License.

package/bin/git-pilot.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
-import { buildProgram } from "../src/cli.js";
+import { buildProgram, normalizeArgs } from "../src/cli.js";
+import { handleError } from "../src/lib/ui.js";
 
-await buildProgram().parseAsync(process.argv);
+try {
+  const normalized = normalizeArgs(process.argv);
+  await buildProgram().parseAsync(normalized);
+} catch (err) {
+  handleError(err);
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@abhaydesu/git-pilot",
-  "version": "1.3.1",
+  "version": "2.0.1",
   "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": "node scripts/run-tests.js",
     "test:e2e": "bash test/e2e/run.sh",
     "lint": "eslint .",
     "format": "prettier --write ."
@@ -31,7 +31,7 @@
     "execa": "^9.6.0",
     "inquirer": "^12.11.1",
     "ora": "^9.4.1",
-    "shell-quote": "^1.10.0"
+    "shell-quote": "^1.12.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/src/cli.js

@@ -4,37 +4,133 @@ import { commitCommand } from "./commands/commit.js";
 import { runCommand } from "./commands/run.js";
 import { undoCommand } from "./commands/undo.js";
 import { branchCommand } from "./commands/branch.js";
+import { setupCommand } from "./commands/setup.js";
+import { authStatusCommand, authRemoveCommand } from "./commands/auth.js";
 
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 
-export function buildProgram() {
+const SUBCOMMANDS = new Set(["commit", "run", "undo", "branch", "setup", "auth", "help"]);
+
+const GLOBAL_FLAGS = new Set(["-h", "--help", "-V", "--version"]);
+const COMMIT_FLAGS = new Set(["-m", "--message-context", "--dry-run", "--accept-notice"]);
+
+function isKnownCommitFlag(arg) {
+  return COMMIT_FLAGS.has(arg) || arg.startsWith("--message-context=") || arg.startsWith("-m=");
+}
+
+/**
+ * Combines `-m/--message-context` and any remaining positional intent words
+ * so multi-word unquoted `-m add login throttling` never drops words.
+ */
+export function extractCommitIntent(intentParts, options = {}) {
+  const parts = [];
+  if (typeof options.messageContext === "string" && options.messageContext.trim()) {
+    parts.push(options.messageContext.trim());
+  }
+
+  if (Array.isArray(intentParts)) {
+    for (const part of intentParts) {
+      if (typeof part === "string" && part.trim()) {
+        parts.push(part.trim());
+      }
+    }
+  } else if (typeof intentParts === "string" && intentParts.trim()) {
+    parts.push(intentParts.trim());
+  }
+
+  return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+/**
+ * Normalizes CLI argv so bare `git pilot`, `git pilot add login throttling`,
+ * or `git pilot -m add login throttling` dispatches directly to `commit`.
+ * Unknown flags (e.g. `--unknown`) are left untouched so Commander reports an error.
+ */
+export function normalizeArgs(argv) {
+  const [nodeBin, script, ...rest] = argv;
+  if (!rest || rest.length === 0) {
+    return [nodeBin, script, "commit"];
+  }
+
+  const firstArg = rest[0];
+  if (GLOBAL_FLAGS.has(firstArg) || SUBCOMMANDS.has(firstArg)) {
+    return argv;
+  }
+
+  // If the first argument is an unknown flag, let Commander reject it with help
+  if (firstArg.startsWith("-") && !isKnownCommitFlag(firstArg)) {
+    return argv;
+  }
+
+  // Preserve individual tokens so flags like -m and --dry-run are parsed by `commit`
+  // and all remaining positional tokens are joined by extractCommitIntent.
+  return [nodeBin, script, "commit", ...rest];
+}
+
+export function buildProgram({
+  handlers = {
+    commit: commitCommand,
+    setup: setupCommand,
+    authStatus: authStatusCommand,
+    authRemove: authRemoveCommand,
+    run: runCommand,
+    undo: undoCommand,
+    branch: branchCommand,
+  },
+} = {}) {
   const program = new Command()
     .name("git-pilot")
-    .description("An AI-powered Git assistant in your command line.")
+    .description("A local-first AI 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);
+    .description("Generate an AI-powered commit message from staged changes.")
+    .argument("[intent...]", 'Optional intent for the commit (e.g., "add a new feature")')
+    .option("-m, --message-context <context>", "Provide context for the commit message")
+    .option("--dry-run", "Output only the generated message to stdout without committing")
+    .option(
+      "--accept-notice",
+      "Explicitly acknowledge sending staged diffs to Google Gemini for non-interactive runs"
+    )
+    .action(async (intentParts, options) => {
+      const intent = extractCommitIntent(intentParts, options);
+      await handlers.commit(intent, options);
+    });
+
+  program
+    .command("setup")
+    .description("Guided interactive setup for your Google Gemini API key.")
+    .action(handlers.setup);
+
+  const auth = program.command("auth").description("Inspect or manage stored AI credentials.");
+
+  auth
+    .command("status")
+    .description("Check credential storage and API key status.")
+    .action(handlers.authStatus);
+
+  auth
+    .command("remove")
+    .description("Remove stored API key from the local OS credential manager.")
+    .action(handlers.authRemove);
 
   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);
+    .action(handlers.run);
 
   program
     .command("undo")
-    .description("Suggests a command to undo your last major Git action")
-    .action(undoCommand);
+    .description("Suggests a command to undo your last major Git action.")
+    .action(handlers.undo);
 
   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);
+    .action(handlers.branch);
 
   return program;
 }

package/src/commands/auth.js

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import { loadConfig, hasAcceptedCurrentNotice } from "../lib/config.js";
+import {
+  getEnvApiKey,
+  getStoredApiKey,
+  deleteApiKey,
+  maskApiKey,
+  getCredentialBackend,
+} from "../lib/credentials.js";
+import { confirm, success, warn, handleError } from "../lib/ui.js";
+
+function getStoreDisplayName(platform) {
+  if (platform === "darwin") return "macOS Keychain";
+  if (platform === "linux") return "Linux Secret Service";
+  if (platform === "win32") return "Windows Credential Manager";
+  return "Custom / In-Memory Store";
+}
+
+export async function authStatusCommand() {
+  try {
+    const config = loadConfig();
+    const backend = getCredentialBackend();
+    const backendStatus = await backend.isAvailable();
+    const envKey = getEnvApiKey(config.provider);
+    let storedKey = null;
+    if (backendStatus.available) {
+      storedKey = await getStoredApiKey(config.provider);
+    }
+
+    console.log(chalk.bold.cyan("\nGit Pilot Authentication Status"));
+    console.log(
+      chalk.dim("────────────────────────────────────────────────────────────────────────")
+    );
+
+    console.log(`Provider:         ${chalk.green(config.provider)}`);
+    console.log(`Model:            ${chalk.green(config.model)}`);
+
+    const storeName = getStoreDisplayName(backend.platform);
+    console.log(
+      `Credential Store: ${
+        backendStatus.available
+          ? chalk.green(storeName)
+          : chalk.red(`${storeName} (Unavailable: ${backendStatus.reason || "error"})`)
+      }`
+    );
+
+    if (storedKey) {
+      console.log(
+        `Stored Key (OS):  ${chalk.cyan(maskApiKey(storedKey.key))} (${chalk.green("present in OS Credential Manager")})`
+      );
+    } else {
+      console.log(`Stored Key (OS):  ${chalk.dim("None")}`);
+    }
+
+    if (envKey) {
+      const shadowNote = storedKey ? " — active, shadows stored OS credential" : " — active";
+      console.log(
+        `Env Override:     ${chalk.cyan(maskApiKey(envKey.key))} (${chalk.yellow(`${envKey.envVarName}${shadowNote}`)})`
+      );
+    } else {
+      console.log(`Env Override:     ${chalk.dim("Not set")}`);
+    }
+
+    const effectiveKey = envKey || storedKey;
+    if (effectiveKey) {
+      const activeSource =
+        effectiveKey.source === "env"
+          ? `Environment (${envKey.envVarName})`
+          : "OS Credential Manager";
+      console.log(
+        `Effective Key:    ${chalk.cyan(maskApiKey(effectiveKey.key))} (${chalk.green(activeSource)})`
+      );
+    } else {
+      console.log(`Effective Key:    ${chalk.red("Not configured")}`);
+      console.log(chalk.dim("\nRun `git pilot setup` to configure your API key."));
+    }
+
+    console.log(
+      `Privacy Notice:   ${
+        hasAcceptedCurrentNotice(config)
+          ? chalk.green(
+              `Accepted v${config.dataSharingNoticeVersion} (${config.noticeAcceptedAt || "yes"})`
+            )
+          : chalk.yellow("Pending acknowledgement")
+      }`
+    );
+    console.log(
+      chalk.dim("────────────────────────────────────────────────────────────────────────\n")
+    );
+  } catch (err) {
+    handleError(err);
+  }
+}
+
+export async function authRemoveCommand() {
+  try {
+    const config = loadConfig();
+    const envKey = getEnvApiKey(config.provider);
+    const storedKey = await getStoredApiKey(config.provider);
+
+    if (!storedKey) {
+      if (envKey) {
+        warn(
+          `No API key is stored in the OS credential manager. The active key is provided via the ${envKey.envVarName} environment variable — unset it in your shell profile to remove it.`
+        );
+      } else {
+        warn("No stored API key was found in the OS credential manager.");
+      }
+      return;
+    }
+
+    const ok = await confirm(
+      `Are you sure you want to remove the stored ${config.provider} API key (${maskApiKey(storedKey.key)}) from the OS credential manager?`,
+      false
+    );
+    if (!ok) {
+      console.log("Removal cancelled.");
+      return;
+    }
+
+    await deleteApiKey(config.provider);
+    success("API key removed successfully from the OS credential manager.");
+
+    if (envKey) {
+      warn(
+        `Note: ${envKey.envVarName} is still set in your environment (${maskApiKey(envKey.key)}) and will continue to be used until unset.`
+      );
+    }
+  } catch (err) {
+    handleError(err);
+  }
+}

package/src/commands/branch.js

@@ -1,6 +1,8 @@
 import chalk from "chalk";
-import { callApi, requireString } from "../lib/api.js";
+import { GeminiProvider, stripFences } from "../lib/provider.js";
 import * as git from "../lib/git.js";
+import { branchPrompt } from "../lib/prompts.js";
+import { ensureProviderReady } from "./setup.js";
 import {
   spin,
   showBlock,
@@ -12,29 +14,42 @@ import {
 } from "../lib/ui.js";
 
 export async function branchCommand(description) {
-  const spinner = spin("Generating a conventional branch name...");
+  let spinner;
   try {
-    const branchName = requireString(await callApi("pilot-branch", { description }), "branchName");
+    const ready = await ensureProviderReady({
+      dataDescription: "branch description",
+    });
+    if (!ready) return;
+    const { config, keyInfo } = ready;
+
+    spinner = spin("Generating a conventional branch name...");
+    const provider = new GeminiProvider({
+      apiKey: keyInfo.key,
+      model: config.model,
+    });
+
+    const prompt = branchPrompt({ description });
+    const rawBranchName = stripFences(await provider.generate(prompt));
     spinner.succeed();
 
-    showBlock("Suggested Branch Name", branchName);
+    showBlock("Suggested Branch Name", rawBranchName);
 
     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;
+        ? await editText("Edit the branch name:", rawBranchName, "Branch name cannot be empty")
+        : rawBranchName;
 
     const safeName = git.slugifyBranchName(chosen);
     if (!safeName) {
-      console.log(chalk.red("Resulting branch name is empty or invalid. Aborting."));
+      console.error(chalk.red("Resulting branch name is empty or invalid. Aborting."));
       process.exit(1);
     }
 
     await git.createBranch(safeName);
-    success(`✔ Switched to new branch '${safeName}'`);
+    success(`Switched to new branch '${safeName}'`);
   } catch (error) {
     handleError(error, spinner);
   }