@abhaydesu/git-pilot 1.3.1 → 2.0.0

package/src/commands/commit.js

@@ -1,50 +1,233 @@
-import { callApi, fitsInRequest, requireString } from "../lib/api.js";
-import * as git from "../lib/git.js";
+import chalk from "chalk";
+import process from "node:process";
+import * as defaultGit from "../lib/git.js";
+import { GeminiProvider, fitsInGeminiRequest, boundSummary } from "../lib/provider.js";
+import { scanDiffForSecrets } from "../lib/scanner.js";
+import { sanitizeTerminalText } from "../lib/sanitizer.js";
+import { commitPrompt } from "../lib/prompts.js";
+import { ensureProviderReady } from "./setup.js";
 import {
   spin,
-  showBlock,
-  chooseAcceptEditAbort,
+  showPanel,
+  chooseCommitAction,
   editText,
   success,
   aborted,
+  warn,
   handleError,
 } from "../lib/ui.js";
 
-const OVERSIZED_PREFIX =
+export 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...");
+/**
+ * Builds the commit prompt, falling back to a byte-bounded file summary if the
+ * full diff exceeds character or UTF-8 JSON request byte limits.
+ */
+export async function buildBoundedCommitPrompt({ intent, diff, getSummary }) {
+  const fullPrompt = commitPrompt({ intent, diff });
+  if (fitsInGeminiRequest(fullPrompt, diff)) {
+    return fullPrompt;
+  }
+
+  const rawSummary = await getSummary();
+  const safeSummary = boundSummary(rawSummary);
+  return commitPrompt({
+    intent,
+    diff: OVERSIZED_PREFIX + safeSummary,
+  });
+}
+
+export async function commitCommand(intent, options = {}, deps = {}) {
+  const git = deps.git || defaultGit;
+  const createProvider = deps.createProvider || ((opts) => new GeminiProvider(opts));
+  const chooseAction = deps.chooseAction || chooseCommitAction;
+  const editMessage = deps.editMessage || editText;
+  const ensureReady = deps.ensureReady || ensureProviderReady;
+
+  let activeSpinner;
   try {
+    // Pre-flight 1: Check Git repository
+    if (!(await git.isInsideGitRepo())) {
+      console.error(
+        chalk.red(
+          "Fatal: Not inside a Git repository. Please run git-pilot inside a Git repository."
+        )
+      );
+      process.exit(1);
+    }
+
+    // Pre-flight 2: Check active Git states (rebase, merge, etc.)
+    const states = await git.getGitRepoState();
+    if (states.length > 0) {
+      warn(
+        `Notice: Git operation in progress (${states.join(", ")}). Your commit will apply to this operation.`
+      );
+    }
+
+    // Pre-flight 3: Check staged changes
+    const stagedFiles = await git.getStagedFiles();
+    if (stagedFiles.length === 0) {
+      console.log(chalk.yellow("\nNo staged changes found."));
+      console.log(
+        chalk.dim("Stage the changes you want to commit using: ") + chalk.cyan("git add <files>")
+      );
+      console.log("\nAvailable Git Pilot commands:");
+      console.log(
+        `  ${chalk.bold("git pilot run <query>")}     Translate natural language into a Git command`
+      );
+      console.log(`  ${chalk.bold("git pilot undo")}            Undo your last major Git action`);
+      console.log(`  ${chalk.bold("git pilot branch <name>")}    Create a conventional branch`);
+      console.log(
+        `  ${chalk.bold("git pilot setup")}            Configure your AI provider and key`
+      );
+      console.log(
+        `  ${chalk.bold("git pilot auth status")}      Inspect active credential status\n`
+      );
+      return;
+    }
+
+    // Pre-flight 4: Read staged diff & best-effort local secret scan BEFORE setup/network
     const diff = await git.getStagedDiff();
-    if (!diff) {
-      spinner.warn("No staged changes found. Please stage your files with `git add`.");
+    const scanResult = scanDiffForSecrets(diff);
+    if (!scanResult.clean) {
+      console.error(
+        chalk.bgRed.black.bold("\n SECURITY ALERT: Refusing to send diff to AI provider \n")
+      );
+      console.error(
+        chalk.red(
+          "Potential high-confidence secrets or credentials were detected in your staged changes:\n"
+        )
+      );
+      for (const finding of scanResult.findings) {
+        console.error(
+          `  ${chalk.bold.red(finding.rule)} at line ${finding.line}: ${chalk.yellow(finding.preview)}`
+        );
+      }
+      console.error(
+        chalk.dim(
+          "\nPlease unstage or remove sensitive material before generating commit messages."
+        )
+      );
+      process.exit(1);
+    }
+
+    // Non-interactive check (unless --dry-run is explicitly requested)
+    if (!process.stdout.isTTY && !options.dryRun && !deps.allowNonTty) {
+      console.error(
+        chalk.red(
+          "Error: Interactive commit flow requires a TTY terminal. Use --dry-run to output only the generated message."
+        )
+      );
+      process.exit(1);
+    }
+
+    // Pre-flight 5: Ensure API key and versioned data-sharing consent
+    const ready = await ensureReady({
+      dataDescription: "staged git diff and commit intent",
+      nonInteractive: Boolean(options.dryRun),
+      acceptNotice: Boolean(options.acceptNotice),
+    });
+    if (!ready) {
       return;
     }
+    const { config, keyInfo } = ready;
+
+    // Best-effort snapshot of staged index identity before generation
+    const initialSnapshot = await git.getStagedTreeHash();
+
+    const provider = createProvider({
+      apiKey: keyInfo.key,
+      model: config.model,
+    });
+
+    activeSpinner = spin(
+      `Analyzing ${stagedFiles.length} staged file${stagedFiles.length === 1 ? "" : "s"} with ${config.provider}...`
+    );
 
-    let payload = { intent, diff };
-    if (!fitsInRequest(payload, diff)) {
-      payload = { intent, diff: OVERSIZED_PREFIX + (await git.getStagedSummary()) };
+    const prompt = await buildBoundedCommitPrompt({
+      intent,
+      diff,
+      getSummary: () => git.getStagedSummary(),
+    });
+    let currentMessage = sanitizeTerminalText(await provider.generate(prompt));
+
+    if (options.dryRun) {
+      activeSpinner.stop();
+      process.stdout.write(`${currentMessage}\n`);
+      return;
     }
 
-    spinner.text = "Generating commit message...";
-    const message = requireString(await callApi("pilot-commit", payload), "message");
-    spinner.succeed();
+    activeSpinner.succeed();
+
+    // Interactive review loop
+    while (true) {
+      showPanel({
+        title: "Proposed Commit Message",
+        details: [
+          `Provider: ${config.provider} (${config.model})`,
+          `Staged files: ${stagedFiles.length} (${stagedFiles.slice(0, 3).join(", ")}${stagedFiles.length > 3 ? "..." : ""})`,
+          intent ? `User intent: "${intent}"` : "User intent: (none)",
+        ],
+        content: currentMessage,
+      });
 
-    showBlock("Suggested Message", message);
+      const action = await chooseAction();
 
-    const choice = await chooseAcceptEditAbort();
-    if (choice === "abort") return aborted("Commit aborted by user.");
+      if (action === "abort") {
+        return aborted("Commit cancelled by user. No changes were committed.");
+      }
 
-    const finalMessage =
-      choice === "edit"
-        ? await editText("Edit the commit message: ", message, "Commit message cannot be empty.")
-        : message;
+      if (action === "edit") {
+        currentMessage = await editMessage(
+          "Edit the commit message: ",
+          currentMessage,
+          "Commit message cannot be empty."
+        );
+        continue;
+      }
 
-    await git.commit(finalMessage);
-    success("Commit successful!");
-  } catch (error) {
-    handleError(error, spinner);
+      if (action === "regenerate") {
+        activeSpinner = spin("Regenerating commit message with Gemini...");
+        const regenPrompt = await buildBoundedCommitPrompt({
+          intent,
+          diff,
+          getSummary: () => git.getStagedSummary(),
+        });
+        currentMessage = sanitizeTerminalText(await provider.generate(regenPrompt));
+        activeSpinner.succeed("New message generated.");
+        continue;
+      }
+
+      if (action === "accept") {
+        if (deps.beforeSnapshotRecheck) {
+          await deps.beforeSnapshotRecheck();
+        }
+        // Best-effort re-check of index snapshot immediately before invoking `git commit`
+        const postSnapshot = await git.getStagedTreeHash();
+        if (postSnapshot !== initialSnapshot) {
+          console.error(
+            chalk.red(
+              "\nError: Staged changes have changed since this commit message was generated."
+            )
+          );
+          console.error(
+            chalk.yellow(
+              "Please run `git pilot` again to generate a message for the updated index."
+            )
+          );
+          process.exit(1);
+        }
+
+        activeSpinner = spin("Creating Git commit...");
+        await git.commit(currentMessage);
+        activeSpinner.succeed("Commit created successfully!");
+        success(`Committed with message: "${currentMessage.split("\n")[0]}"`);
+        return;
+      }
+    }
+  } catch (err) {
+    handleError(err, activeSpinner);
   }
 }

package/src/commands/run.js

@@ -1,21 +1,50 @@
 import chalk from "chalk";
-import { callApi, requireString } from "../lib/api.js";
+import { GeminiProvider, stripFences } from "../lib/provider.js";
 import { parseGitCommand, runGit } from "../lib/exec.js";
+import { runPrompt, runRetryPrompt } from "../lib/prompts.js";
+import { ensureProviderReady } from "./setup.js";
 import { spin, showBlock, confirm, success, aborted, handleError } from "../lib/ui.js";
 
+const ERROR_PREFIX = "Error:";
+
 export async function runCommand(request) {
-  const spinner = spin("Fetching the right command...");
+  let spinner;
   try {
-    const command = requireString(await callApi("pilot-run", { request }), "command");
+    const ready = await ensureProviderReady({
+      dataDescription: "natural-language Git command request",
+    });
+    if (!ready) return;
+    const { config, keyInfo } = ready;
+
+    spinner = spin("Translating your request into a Git command...");
+    const provider = new GeminiProvider({
+      apiKey: keyInfo.key,
+      model: config.model,
+    });
 
-    if (command.startsWith("Error:")) {
+    let command = stripFences(await provider.generate(runPrompt({ request })));
+    if (command.startsWith(ERROR_PREFIX)) {
       spinner.fail(command);
       process.exit(1);
     }
-    spinner.succeed();
 
-    // Validate before showing anything the user might be tempted to confirm.
-    const args = parseGitCommand(command);
+    // Try parsing; if not safe, retry once with the model
+    let args;
+    try {
+      args = parseGitCommand(command);
+    } catch {
+      const [, verb = command] = command.split(/\s+/);
+      command = stripFences(
+        await provider.generate(runRetryPrompt({ request, previous: command, verb }))
+      );
+      if (command.startsWith(ERROR_PREFIX)) {
+        spinner.fail(command);
+        process.exit(1);
+      }
+      args = parseGitCommand(command);
+    }
+
+    spinner.succeed();
 
     console.log(
       chalk.yellow.bold("\nWARNING: The suggested command will be executed on your repository.")

package/src/commands/setup.js

@@ -0,0 +1,208 @@
+import chalk from "chalk";
+import {
+  loadConfig,
+  hasAcceptedCurrentNotice,
+  recordNoticeAcceptance,
+  CURRENT_NOTICE_VERSION,
+} from "../lib/config.js";
+import {
+  getApiKey,
+  getEnvApiKey,
+  getStoredApiKey,
+  setApiKey,
+  maskApiKey,
+} from "../lib/credentials.js";
+import { GeminiProvider, OFFICIAL_GEMINI_HOSTNAME } from "../lib/provider.js";
+import {
+  spin,
+  confirm,
+  promptMaskedPassword,
+  success,
+  warn,
+  aborted,
+  handleError,
+} from "../lib/ui.js";
+
+export function printPrivacyNotice({
+  dataDescription = "staged diff and optional intent",
+  model = loadConfig().model,
+} = {}) {
+  console.error(
+    chalk.bold.cyan(`\n✈  Git Pilot Data-Sharing & Privacy Notice (v${CURRENT_NOTICE_VERSION})`)
+  );
+  console.error(
+    chalk.dim("────────────────────────────────────────────────────────────────────────")
+  );
+  console.error(chalk.yellow(" • Provider: ") + `Google Gemini (${OFFICIAL_GEMINI_HOSTNAME})`);
+  console.error(chalk.yellow(" • Model:    ") + model);
+  console.error(chalk.yellow(" • Sent:     ") + dataDescription);
+  console.error(chalk.dim("              Unstaged and untracked files are not sent."));
+  console.error(
+    chalk.yellow(" • API key:  ") + "Stored in your OS credential manager; sent directly to Google."
+  );
+  console.error(
+    chalk.yellow(" • Screening:") +
+      " Common secrets are checked locally, but this check is not exhaustive."
+  );
+  console.error(
+    chalk.dim("────────────────────────────────────────────────────────────────────────\n")
+  );
+}
+
+export async function runGuidedSetup({ isFirstRun = false } = {}) {
+  let spinner;
+  try {
+    const config = loadConfig();
+    printPrivacyNotice({ model: config.model });
+
+    const envKey = getEnvApiKey("gemini");
+    const storedKey = await getStoredApiKey("gemini");
+
+    if (envKey) {
+      warn(
+        `${envKey.envVarName} is currently set in your environment (${maskApiKey(envKey.key)}). ` +
+          `Setup will save your key to the OS credential manager, but ${envKey.envVarName} will continue to shadow the stored key until you unset it in your shell.`
+      );
+    }
+
+    if (storedKey && !isFirstRun) {
+      warn(
+        `An API key is already stored in the OS credential manager (${maskApiKey(storedKey.key)}).`
+      );
+      const proceed = await confirm("Do you want to replace the stored key?", false);
+      if (!proceed) {
+        console.log("Setup cancelled.");
+        return;
+      }
+    }
+
+    const agree = await confirm("Do you acknowledge this data flow and wish to proceed?", false);
+    if (!agree) {
+      console.log("Setup aborted. No changes were made.");
+      return;
+    }
+
+    console.error(chalk.dim("\nGet a Gemini API key at: https://aistudio.google.com/app/apikey\n"));
+
+    const key = await promptMaskedPassword("Enter your Gemini API key:");
+    if (!key) {
+      warn("Setup aborted: API key cannot be empty.");
+      return;
+    }
+
+    spinner = spin("Validating API key with Google Gemini...");
+    const provider = new GeminiProvider({ apiKey: key, model: config.model });
+    await provider.validateKey();
+    spinner.succeed("API key successfully validated!");
+
+    await setApiKey("gemini", key);
+    recordNoticeAcceptance();
+
+    console.log();
+    success(`Setup complete! Stored in OS credential manager as ${maskApiKey(key)}.`);
+    if (envKey) {
+      warn(
+        `Reminder: ${envKey.envVarName} is still set in your environment and will take precedence until unset.`
+      );
+    }
+    console.log(
+      chalk.cyan(
+        "\nTry it out: stage changes with `git add` and run " +
+          chalk.bold("`git pilot`") +
+          " to generate a commit message.\n"
+      )
+    );
+  } catch (err) {
+    const reportedError =
+      err?.code === "MODEL_NOT_FOUND"
+        ? new Error(
+            `${err.message}\nSetup did not save the entered key. Any previously stored key is unchanged.`,
+            { cause: err }
+          )
+        : err;
+    handleError(reportedError, spinner);
+  }
+}
+
+/**
+ * Ensures both a valid API key and a versioned data-sharing notice acknowledgement
+ * are present before any provider request is made—including when GEMINI_API_KEY is supplied via env.
+ * In non-interactive or `--dry-run` mode, never prompts interactively; fails early with setup steps
+ * unless explicit automation consent (`--accept-notice` or `GIT_PILOT_ACCEPT_NOTICE=1`) is provided.
+ */
+export async function ensureProviderReady({
+  dataDescription = "staged git diff and commit intent",
+  nonInteractive = false,
+  acceptNotice = false,
+} = {}) {
+  const isNonInteractive = Boolean(nonInteractive || !process.stdin.isTTY || !process.stdout.isTTY);
+  const hasExplicitConsent = Boolean(
+    acceptNotice ||
+    process.env.GIT_PILOT_ACCEPT_NOTICE === "1" ||
+    process.env.GIT_PILOT_ACCEPT_NOTICE === "true"
+  );
+
+  let config = loadConfig();
+  let keyInfo = await getApiKey(config.provider);
+
+  if (!keyInfo) {
+    if (isNonInteractive) {
+      console.error(
+        chalk.red(
+          "Error: No Gemini API key configured for non-interactive execution.\n" +
+            "To configure Git Pilot:\n" +
+            "  1. Run `git pilot setup` in an interactive terminal, OR\n" +
+            "  2. Set `GEMINI_API_KEY` in your environment and pass `--accept-notice` (or set `GIT_PILOT_ACCEPT_NOTICE=1`)."
+        )
+      );
+      process.exit(1);
+    }
+
+    console.error(chalk.yellow("\nNo API key found. Starting one-time guided setup...\n"));
+    await runGuidedSetup({ isFirstRun: true });
+    config = loadConfig();
+    keyInfo = await getApiKey(config.provider);
+    if (!keyInfo) {
+      console.error(chalk.red("Setup was not completed. Aborting."));
+      return null;
+    }
+  }
+
+  if (!hasAcceptedCurrentNotice(config)) {
+    if (hasExplicitConsent) {
+      config = recordNoticeAcceptance();
+      return { config, keyInfo };
+    }
+
+    if (isNonInteractive) {
+      printPrivacyNotice({ dataDescription, model: config.model });
+      console.error(
+        chalk.red(
+          "Error: Data-sharing notice has not been acknowledged yet (fresh configuration).\n" +
+            "To proceed in non-interactive or `--dry-run` mode:\n" +
+            "  1. Run `git pilot setup` once in an interactive terminal to review and accept the notice, OR\n" +
+            "  2. Pass `--accept-notice` (or set `GIT_PILOT_ACCEPT_NOTICE=1`) to explicitly acknowledge sending " +
+            `${dataDescription} to Google Gemini (${OFFICIAL_GEMINI_HOSTNAME}).`
+        )
+      );
+      process.exit(1);
+    }
+
+    printPrivacyNotice({ dataDescription, model: config.model });
+    const agreed = await confirm(
+      `Acknowledge sending ${dataDescription} to Google Gemini (${OFFICIAL_GEMINI_HOSTNAME})?`,
+      false
+    );
+    if (!agreed) {
+      aborted("Data-sharing notice was not accepted. No request was sent.");
+      return null;
+    }
+    config = recordNoticeAcceptance();
+  }
+
+  return { config, keyInfo };
+}
+
+export async function setupCommand() {
+  await runGuidedSetup({ isFirstRun: false });
+}