@abhaydesu/git-pilot 1.3.1 → 2.0.1

package/src/commands/undo.js

@@ -1,35 +1,165 @@
 import chalk from "chalk";
-import { callApi, requireString } 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";
 
+/**
+ * Parses a standard Git reflog line (`<sha> HEAD@{<n>}: <action>: <detail>`)
+ * into `{ action, detail }`, or returns `null` if the line does not match.
+ * Prevents substring false-positives when commit messages or branch names
+ * contain words like "merge" or "rebase".
+ */
+export function parseReflogAction(line) {
+  if (typeof line !== "string" || !line.trim()) return null;
+  const match = /(?:^|\s)HEAD@\{\d+\}:\s*([^:]+):\s*(.*)$/.exec(line.trim());
+  if (!match) return null;
+  return {
+    action: match[1].trim(),
+    detail: match[2].trim(),
+  };
+}
+
+const ACTIVE_OPERATION_SUGGESTIONS = {
+  rebase: {
+    command: "git rebase --abort",
+    explanation: "This command cancels the active rebase operation and restores your branch.",
+    isDestructive: false,
+  },
+  merge: {
+    command: "git merge --abort",
+    explanation:
+      "This command attempts to abort the in-progress merge. " +
+      "Warning: if you had uncommitted changes before starting the merge (or edited conflicted files), some pre-merge changes may not be recoverable.",
+    isDestructive: true,
+    caution:
+      "\nCAUTION: `git merge --abort` discards in-progress merge conflict edits and cannot always recover uncommitted changes that existed before the merge started.",
+  },
+  "cherry-pick": {
+    command: "git cherry-pick --abort",
+    explanation: "This command cancels the active cherry-pick operation and restores your branch.",
+    isDestructive: false,
+  },
+  revert: {
+    command: "git revert --abort",
+    explanation: "This command cancels the active revert operation and restores your branch.",
+    isDestructive: false,
+  },
+};
+
+/**
+ * Determines a safe undo suggestion from repository state and the latest reflog entry.
+ * Always checks active Git operations (rebase, merge, cherry-pick, revert) first before
+ * inspecting historical reflog entries, and refuses to suggest destructive operations
+ * when the state is ambiguous.
+ */
+export function analyzeUndoState({
+  reflog,
+  repoStates = [],
+  rebaseInProgress = false,
+  origHeadExists = false,
+} = {}) {
+  const activeStates = Array.isArray(repoStates) ? [...repoStates] : [];
+  if (rebaseInProgress && !activeStates.includes("rebase")) {
+    activeStates.push("rebase");
+  }
+
+  // If multiple operations appear active simultaneously, state is ambiguous
+  if (activeStates.length > 1) {
+    return null;
+  }
+
+  if (activeStates.length === 1) {
+    const activeOp = activeStates[0];
+    return ACTIVE_OPERATION_SUGGESTIONS[activeOp] || null;
+  }
+
+  const firstLine =
+    String(reflog || "")
+      .split("\n")
+      .map((l) => l.trim())
+      .find(Boolean) || "";
+
+  const parsed = parseReflogAction(firstLine);
+  if (!parsed) return null;
+
+  const { action, detail } = parsed;
+
+  // Standard commit or amend (explicitly excluding `commit (initial)` which has no HEAD~1 parent)
+  if (action === "commit" || action === "commit (amend)") {
+    return {
+      command: "git reset --soft HEAD~1",
+      explanation: "This command undoes your last commit but keeps all your changes staged.",
+      isDestructive: false,
+    };
+  }
+
+  // Completed merge or fast-forward pull: require both an explicit merge/pull action
+  // AND a verified ORIG_HEAD reference before suggesting a destructive hard reset.
+  const isMergeAction =
+    action === "merge" ||
+    action.startsWith("merge ") ||
+    action === "pull" ||
+    action.startsWith("pull ");
+  const isCompletedMergeDetail = /^(Fast-forward|Merge made by\b)/i.test(detail);
+
+  if (isMergeAction && isCompletedMergeDetail && origHeadExists) {
+    return {
+      command: "git reset --hard ORIG_HEAD",
+      explanation: "This command resets your branch to ORIG_HEAD (the state before the merge).",
+      isDestructive: true,
+      caution:
+        "\nCAUTION: This command is destructive (`git reset --hard`) and will discard uncommitted changes.",
+    };
+  }
+
+  return null;
+}
+
 export async function undoCommand() {
   const spinner = spin("Analyzing your recent Git history...");
   try {
-    const reflog = await git.getReflog();
+    const [reflog, repoStates, origHeadExists] = await Promise.all([
+      git.getReflog(),
+      git.getGitRepoState(),
+      git.hasOrigHead(),
+    ]);
 
-    spinner.text = "Suggesting an undo command...";
-    const data = await callApi("pilot-undo", { reflog });
-    const command = data?.command ?? null;
+    const suggestion = analyzeUndoState({
+      reflog,
+      repoStates,
+      origHeadExists,
+    });
 
-    if (!command) {
-      spinner.warn("Couldn't determine a safe action to undo.");
+    if (!suggestion) {
+      spinner.warn("Couldn't determine a safe, unambiguous action to undo from recent Git state.");
       return;
     }
+
     spinner.succeed();
 
-    const args = parseGitCommand(requireString(data, "command"));
+    const { command, explanation, isDestructive, caution } = suggestion;
+    const args = parseGitCommand(command);
 
+    if (isDestructive) {
+      console.log(
+        chalk.red.bold(
+          caution ||
+            "\nCAUTION: This command is destructive (`git reset --hard`) and will discard uncommitted changes."
+        )
+      );
+    }
     showBlock("Suggested Undo Command", command);
-    console.log(chalk.yellow(String(data?.explanation ?? "")));
+    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."));
+    if (args.includes("--abort") && args[0] in ACTIVE_OPERATION_SUGGESTIONS) {
+      const currentStates = await git.getGitRepoState();
+      if (!currentStates.includes(args[0])) {
+        return console.log(chalk.yellow(`No ${args[0]} in progress — abort not necessary.`));
+      }
     }
 
     await runGit(args);

package/src/lib/config.js

@@ -0,0 +1,191 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import process from "node:process";
+
+export const CURRENT_CONFIG_VERSION = 2;
+export const CURRENT_NOTICE_VERSION = 1;
+export const DEFAULT_PROVIDER = "gemini";
+export const DEFAULT_MODEL = "gemini-3.5-flash-lite";
+const LEGACY_DEFAULT_MODEL = "gemini-2.5-flash";
+
+const SAFE_MODEL_REGEX = /^[a-zA-Z0-9._-]+$/;
+
+let customConfigDir = null;
+
+export function setConfigDir(dir) {
+  customConfigDir = dir;
+}
+
+export function getConfigDir() {
+  if (customConfigDir) return customConfigDir;
+  if (process.env.GIT_PILOT_CONFIG_DIR) return process.env.GIT_PILOT_CONFIG_DIR;
+
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "git-pilot");
+  }
+
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(xdgConfig, "git-pilot");
+}
+
+export function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+
+export function getDefaultConfig() {
+  return {
+    version: CURRENT_CONFIG_VERSION,
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL,
+    dataSharingNoticeAccepted: false,
+    dataSharingNoticeVersion: 0,
+    noticeAcceptedAt: null,
+  };
+}
+
+export function hasAcceptedCurrentNotice(cfg) {
+  const effective = cfg || loadConfig();
+  return (
+    effective?.dataSharingNoticeAccepted === true &&
+    effective?.dataSharingNoticeVersion === CURRENT_NOTICE_VERSION
+  );
+}
+
+export function recordNoticeAcceptance() {
+  return saveConfig({
+    dataSharingNoticeAccepted: true,
+    dataSharingNoticeVersion: CURRENT_NOTICE_VERSION,
+    noticeAcceptedAt: new Date().toISOString(),
+  });
+}
+
+export function validateConfig(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid configuration: root must be an object.");
+  }
+
+  if (typeof data.version !== "number") {
+    throw new Error("Invalid configuration: missing or invalid 'version'.");
+  }
+
+  if (data.provider !== "gemini") {
+    throw new Error(
+      `Unsupported provider: "${data.provider}". Only "gemini" is supported in this release.`
+    );
+  }
+
+  if (typeof data.model !== "string" || !SAFE_MODEL_REGEX.test(data.model)) {
+    throw new Error(
+      `Invalid model name "${data.model}". Model names can only contain alphanumeric characters, dots, underscores, and hyphens.`
+    );
+  }
+
+  return true;
+}
+
+export function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return getDefaultConfig();
+  }
+
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+
+    const migrated = { ...getDefaultConfig(), ...parsed };
+    if (migrated.version < CURRENT_CONFIG_VERSION) {
+      // The old built-in model is restricted for many new API projects. Migrate
+      // only the previous default; preserve any user-selected model identifier.
+      if (migrated.model === LEGACY_DEFAULT_MODEL) {
+        migrated.model = DEFAULT_MODEL;
+      }
+      migrated.version = CURRENT_CONFIG_VERSION;
+    }
+
+    validateConfig(migrated);
+    return migrated;
+  } catch (err) {
+    if (err.name === "SyntaxError") {
+      throw new Error(`Corrupted config file at ${configPath}: ${err.message}`, {
+        cause: err,
+      });
+    }
+    throw err;
+  }
+}
+
+export function saveConfig(patch = {}) {
+  const dir = getConfigDir();
+  const configPath = getConfigPath();
+
+  // Create directory with 0700 permissions on POSIX
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(dir, 0o700);
+    } catch {
+      // Ignored on filesystems that do not support POSIX chmod
+    }
+  }
+
+  let current = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      current = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (current.version < CURRENT_CONFIG_VERSION) {
+        if (current.model === LEGACY_DEFAULT_MODEL) current.model = DEFAULT_MODEL;
+        current.version = CURRENT_CONFIG_VERSION;
+      }
+    } catch {
+      // Fall back to default config if file is unreadable/corrupted
+    }
+  }
+
+  const updated = {
+    ...getDefaultConfig(),
+    ...current,
+    ...patch,
+    version: CURRENT_CONFIG_VERSION,
+  };
+
+  validateConfig(updated);
+
+  // Safe atomic write with 0600 permissions
+  const tempPath = path.join(dir, `.config.json.tmp.${process.pid}.${Date.now()}`);
+  const content = JSON.stringify(updated, null, 2) + "\n";
+
+  fs.writeFileSync(tempPath, content, { encoding: "utf8", mode: 0o600 });
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(tempPath, 0o600);
+    } catch {
+      // Ignored on filesystems that do not support POSIX chmod
+    }
+  }
+
+  fs.renameSync(tempPath, configPath);
+  return updated;
+}
+
+export function resetConfig() {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+}
+
+/** Redacts any key-like fields for printing or diagnostics */
+export function redactConfig(cfg) {
+  const copy = { ...cfg };
+  for (const k of Object.keys(copy)) {
+    if (/key|secret|token|password/i.test(k)) {
+      copy[k] = "[REDACTED]";
+    }
+  }
+  return copy;
+}