spec-cat 0.1.0

package/.output/server/chunks/_/git.mjs

@@ -0,0 +1,707 @@
+import { execFileSync, execSync, exec } from 'child_process';
+import { promisify } from 'util';
+import { f as getProjectDir } from '../nitro/nitro.mjs';
+
+const execAsync = promisify(exec);
+function execGit(cwd, command) {
+  try {
+    const output = execSync(`git ${command}`, {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10,
+      // 10MB buffer
+      encoding: "utf-8"
+    });
+    return output.trim();
+  } catch (error) {
+    throw new Error(`Git command failed: ${error.message}`);
+  }
+}
+function execGitArgs(cwd, args) {
+  try {
+    const output = execFileSync("git", args, {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10,
+      encoding: "utf-8"
+    });
+    return output.trim();
+  } catch (error) {
+    throw new Error(`Git command failed: ${error.message}`);
+  }
+}
+async function execGitCommand(args, cwd = getProjectDir()) {
+  try {
+    const command = `git ${args.join(" ")}`;
+    const { stdout } = await execAsync(command, {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10
+      // 10MB buffer for large repositories
+    });
+    return stdout.trim();
+  } catch (error) {
+    throw new Error(`Git command failed: ${error.message}`);
+  }
+}
+async function isGitRepository(path = getProjectDir()) {
+  try {
+    await execGitCommand(["rev-parse", "--git-dir"], path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCommitHistory(options = {}) {
+  const {
+    limit = 50,
+    offset = 0,
+    branch,
+    author,
+    search,
+    since,
+    until,
+    cwd = getProjectDir()
+  } = options;
+  const args = ["log", "--pretty=format:%H|%h|%s|%B|%an|%ae|%ad|%cn|%ce|%cd|%P", "--date=iso"];
+  if (limit) args.push(`-${limit}`);
+  if (offset && offset > 0) args.push(`--skip=${offset}`);
+  if (branch) args.push(branch);
+  if (author) args.push(`--author=${author}`);
+  if (search) args.push(`--grep=${search}`);
+  if (since) args.push(`--since=${since}`);
+  if (until) args.push(`--until=${until}`);
+  const output = await execGitCommand(args, cwd);
+  if (!output) return [];
+  return output.split("\n").map((line) => {
+    const [
+      hash,
+      shortHash,
+      subject,
+      message,
+      authorName,
+      authorEmail,
+      authorDate,
+      committerName,
+      committerEmail,
+      committerDate,
+      parentHashes
+    ] = line.split("|");
+    const parents = parentHashes ? parentHashes.split(" ").filter(Boolean) : [];
+    return {
+      hash,
+      shortHash,
+      message: message || subject,
+      subject,
+      author: {
+        name: authorName,
+        email: authorEmail,
+        date: authorDate
+      },
+      committer: committerName !== authorName || committerEmail !== authorEmail ? {
+        name: committerName,
+        email: committerEmail,
+        date: committerDate
+      } : void 0,
+      date: authorDate,
+      parents,
+      branches: [],
+      // Will be populated separately
+      tags: []
+      // Will be populated separately
+    };
+  });
+}
+async function getCommitDetail(hash, cwd = getProjectDir()) {
+  const [commit] = await getCommitHistory({ limit: 1, cwd });
+  if (!commit || commit.hash !== hash) {
+    throw new Error(`Commit ${hash} not found`);
+  }
+  const fileChangesOutput = await execGitCommand([
+    "diff-tree",
+    "--no-commit-id",
+    "--name-status",
+    "-r",
+    hash
+  ], cwd);
+  const fileChanges = [];
+  if (fileChangesOutput) {
+    for (const line of fileChangesOutput.split("\n").filter(Boolean)) {
+      const [status, ...pathParts] = line.split("	");
+      const path = pathParts.join("	");
+      let oldPath;
+      let newPath = path;
+      if (status.startsWith("R") || status.startsWith("C")) {
+        const [from, to] = path.split("	");
+        oldPath = from;
+        newPath = to;
+      }
+      fileChanges.push({
+        path: newPath,
+        oldPath,
+        status: status.charAt(0),
+        additions: 0,
+        // Will be populated by diffstat
+        deletions: 0,
+        // Will be populated by diffstat
+        binary: false
+        // Will be detected by diffstat
+      });
+    }
+  }
+  const diffstatOutput = await execGitCommand([
+    "diff-tree",
+    "--no-commit-id",
+    "--numstat",
+    "-r",
+    hash
+  ], cwd);
+  const diffstatMap = /* @__PURE__ */ new Map();
+  if (diffstatOutput) {
+    for (const line of diffstatOutput.split("\n").filter(Boolean)) {
+      const [addStr, delStr, path] = line.split("	");
+      const additions = addStr === "-" ? 0 : parseInt(addStr, 10);
+      const deletions = delStr === "-" ? 0 : parseInt(delStr, 10);
+      const binary = addStr === "-" && delStr === "-";
+      diffstatMap.set(path, { additions, deletions, binary });
+    }
+  }
+  for (const fileChange of fileChanges) {
+    const stats2 = diffstatMap.get(fileChange.path);
+    if (stats2) {
+      fileChange.additions = stats2.additions;
+      fileChange.deletions = stats2.deletions;
+      fileChange.binary = stats2.binary;
+    }
+  }
+  const stats = {
+    additions: fileChanges.reduce((sum, f) => sum + f.additions, 0),
+    deletions: fileChanges.reduce((sum, f) => sum + f.deletions, 0),
+    filesChanged: fileChanges.length
+  };
+  return {
+    ...commit,
+    fileChanges,
+    stats
+  };
+}
+function generateBranchColor(branchName) {
+  const colors = [
+    "#3B82F6",
+    // blue
+    "#EF4444",
+    // red
+    "#10B981",
+    // green
+    "#F59E0B",
+    // amber
+    "#8B5CF6",
+    // violet
+    "#EC4899",
+    // pink
+    "#14B8A6",
+    // teal
+    "#F97316",
+    // orange
+    "#06B6D4",
+    // cyan
+    "#84CC16",
+    // lime
+    "#F43F5E",
+    // rose
+    "#A855F7"
+    // purple
+  ];
+  let hash = 0;
+  for (let i = 0; i < branchName.length; i++) {
+    const char = branchName.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return colors[Math.abs(hash) % colors.length];
+}
+async function getMergeBase(ref1, ref2, cwd = getProjectDir()) {
+  try {
+    const output = await execGitCommand(["merge-base", ref1, ref2], cwd);
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function isGitRepositorySync(cwd) {
+  try {
+    execGit(cwd, "rev-parse --git-dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getBranchesSync(cwd) {
+  try {
+    const output = execGit(cwd, "branch -a --format='%(refname:short)'");
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getTags(cwd) {
+  try {
+    const output = execGit(cwd, "tag --list");
+    return output.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getCommitCount(cwd) {
+  try {
+    const output = execGit(cwd, "rev-list --all --count");
+    return parseInt(output, 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+function parseGitLog(output, branches, tags) {
+  if (!output.trim()) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const [hash, shortHash, author, email, timestamp, message, parentHashes] = line.split("|");
+    const parents = parentHashes ? parentHashes.split(" ").filter(Boolean) : [];
+    return {
+      hash,
+      shortHash,
+      author,
+      email,
+      timestamp: parseInt(timestamp, 10),
+      message,
+      parents,
+      branches: [],
+      // Decorations added separately
+      tags: []
+    };
+  });
+}
+function getCommitDetailSync(cwd, hash) {
+  try {
+    const output = execGit(cwd, `show -s --format="%H|%h|%an|%ae|%at|%s|%b|%P" ${hash}`);
+    if (!output.trim()) return null;
+    const [commitHash, shortHash, author, email, timestamp, message, body, parentHashes] = output.split("|");
+    const parents = parentHashes ? parentHashes.trim().split(" ").filter(Boolean) : [];
+    return {
+      hash: commitHash,
+      shortHash,
+      author,
+      email,
+      timestamp: parseInt(timestamp, 10),
+      message,
+      body: body || "",
+      parents
+    };
+  } catch {
+    return null;
+  }
+}
+function getCommitFiles(cwd, hash) {
+  try {
+    const numstatOutput = execGit(cwd, `diff-tree --root --no-commit-id --numstat -r -M ${hash}`);
+    const statusOutput = execGit(cwd, `diff-tree --root --no-commit-id --name-status -r -M ${hash}`);
+    if (!numstatOutput.trim()) return [];
+    const statusMap = /* @__PURE__ */ new Map();
+    for (const line of statusOutput.split("\n").filter(Boolean)) {
+      const parts = line.split("	");
+      const statusCode = parts[0][0];
+      if (statusCode === "R" || statusCode === "C") {
+        statusMap.set(parts[2], { status: statusCode, oldPath: parts[1] });
+      } else {
+        statusMap.set(parts[1], { status: statusCode });
+      }
+    }
+    return numstatOutput.split("\n").filter(Boolean).map((line) => {
+      const parts = line.split("	");
+      const addStr = parts[0];
+      const delStr = parts[1];
+      const isBinary = addStr === "-" && delStr === "-";
+      const additions = isBinary ? 0 : parseInt(addStr, 10);
+      const deletions = isBinary ? 0 : parseInt(delStr, 10);
+      let filePath;
+      if (parts.length >= 4) {
+        filePath = parts[3];
+      } else {
+        filePath = parts[2];
+      }
+      const info = statusMap.get(filePath);
+      return {
+        path: filePath,
+        oldPath: info == null ? void 0 : info.oldPath,
+        status: (info == null ? void 0 : info.status) || "M",
+        additions,
+        deletions,
+        binary: isBinary
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function getCommitStats(cwd, hash) {
+  try {
+    const output = execGit(cwd, `diff-tree --root --no-commit-id --shortstat ${hash}`);
+    if (!output.trim()) return { filesChanged: 0, additions: 0, deletions: 0 };
+    const filesMatch = output.match(/(\d+) files? changed/);
+    const addMatch = output.match(/(\d+) insertions?\(\+\)/);
+    const delMatch = output.match(/(\d+) deletions?\(-\)/);
+    return {
+      filesChanged: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+      additions: addMatch ? parseInt(addMatch[1], 10) : 0,
+      deletions: delMatch ? parseInt(delMatch[1], 10) : 0
+    };
+  } catch {
+    return { filesChanged: 0, additions: 0, deletions: 0 };
+  }
+}
+function getHeadCommit(cwd) {
+  try {
+    return execGit(cwd, "rev-parse HEAD");
+  } catch {
+    return "";
+  }
+}
+function getBranchListHash(cwd) {
+  try {
+    const output = execGit(cwd, "for-each-ref --format='%(refname):%(objectname)' refs/heads refs/remotes");
+    let hash = 0;
+    for (let i = 0; i < output.length; i++) {
+      const char = output.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  } catch {
+    return "";
+  }
+}
+function getUncommittedFileCount(cwd) {
+  try {
+    const output = execGit(cwd, "status --porcelain");
+    if (!output.trim()) return 0;
+    return output.split("\n").filter(Boolean).length;
+  } catch {
+    return 0;
+  }
+}
+function getWorkingTreeHash(cwd) {
+  try {
+    const output = execGit(cwd, "status --porcelain");
+    return hashString(output);
+  } catch {
+    return "";
+  }
+}
+function getStashListHash(cwd) {
+  try {
+    const output = execGit(cwd, "stash list --pretty=format:%gd:%H");
+    return hashString(output);
+  } catch {
+    return "";
+  }
+}
+function hashString(value) {
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    const char = value.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16);
+}
+function renameBranch(cwd, oldName, newName) {
+  return execGitArgs(cwd, ["branch", "-m", oldName, newName]);
+}
+function mergeBranch(cwd, branch, options = {}) {
+  const args = ["merge"];
+  if (options.noCommit) args.push("--no-commit");
+  if (options.noFastForward) args.push("--no-ff");
+  if (options.squash) args.push("--squash");
+  args.push(branch);
+  return execGitArgs(cwd, args);
+}
+function rebaseBranch(cwd, onto) {
+  return execGitArgs(cwd, ["rebase", onto]);
+}
+function pushBranch(cwd, branch, options = {}) {
+  const args = ["push"];
+  if (options.force) args.push("--force");
+  if (options.forceWithLease) args.push("--force-with-lease");
+  args.push(options.remote || "origin");
+  args.push(branch);
+  return execGitArgs(cwd, args);
+}
+function pullBranch(cwd, options = {}) {
+  const args = ["pull"];
+  if (options.noFastForward) args.push("--no-ff");
+  if (options.squash) args.push("--squash");
+  if (options.remote) args.push(options.remote);
+  if (options.branch) args.push(options.branch);
+  return execGitArgs(cwd, args);
+}
+function fetchBranch(cwd, options = {}) {
+  const args = ["fetch"];
+  if (options.all) args.push("--all");
+  if (options.prune) args.push("--prune");
+  if (options.pruneTags) args.push("--prune-tags");
+  if (options.force) args.push("--force");
+  if (!options.all && options.remote) args.push(options.remote);
+  if (!options.all && options.branch) args.push(options.branch);
+  return execGitArgs(cwd, args);
+}
+function cherryPick(cwd, hash, options = {}) {
+  const args = ["cherry-pick"];
+  if (options.recordOrigin) args.push("-x");
+  if (options.noCommit) args.push("--no-commit");
+  args.push(hash);
+  return execGitArgs(cwd, args);
+}
+function revertCommit(cwd, hash) {
+  return execGitArgs(cwd, ["revert", "--no-edit", hash]);
+}
+function resetBranch(cwd, hash, mode) {
+  return execGitArgs(cwd, ["reset", `--${mode}`, hash]);
+}
+function cleanUntrackedFiles(cwd) {
+  return execGitArgs(cwd, ["clean", "-fd"]);
+}
+function getDiff(cwd, from, to) {
+  const nameStatusOutput = execGitArgs(cwd, ["diff", "--name-status", from, to]);
+  const numstatOutput = execGitArgs(cwd, ["diff", "--numstat", from, to]);
+  const files = [];
+  const numstatMap = /* @__PURE__ */ new Map();
+  if (numstatOutput.trim()) {
+    for (const line of numstatOutput.split("\n").filter(Boolean)) {
+      const [addStr, delStr, ...pathParts] = line.split("	");
+      const path = pathParts.join("	");
+      const additions = addStr === "-" ? 0 : parseInt(addStr, 10);
+      const deletions = delStr === "-" ? 0 : parseInt(delStr, 10);
+      const binary = addStr === "-" && delStr === "-";
+      numstatMap.set(path, { additions, deletions, binary });
+    }
+  }
+  if (nameStatusOutput.trim()) {
+    for (const line of nameStatusOutput.split("\n").filter(Boolean)) {
+      const [status, ...pathParts] = line.split("	");
+      let path = pathParts.join("	");
+      let oldPath;
+      if (status.startsWith("R") || status.startsWith("C")) {
+        const [from2, to2] = path.split("	");
+        oldPath = from2;
+        path = to2;
+      }
+      const stat = numstatMap.get(path) || { additions: 0, deletions: 0, binary: false };
+      files.push({
+        path,
+        oldPath,
+        status: status.charAt(0),
+        additions: stat.additions,
+        deletions: stat.deletions,
+        binary: stat.binary
+      });
+    }
+  }
+  const stats = {
+    filesChanged: files.length,
+    additions: files.reduce((sum, f) => sum + f.additions, 0),
+    deletions: files.reduce((sum, f) => sum + f.deletions, 0)
+  };
+  return { files, stats };
+}
+function getFileDiff(cwd, commitHash, filePath, parentHash) {
+  const MAX_LINES = 1e4;
+  let diffOutput;
+  try {
+    if (parentHash) {
+      diffOutput = execGitArgs(cwd, ["diff", `${parentHash}...${commitHash}`, "--", filePath]);
+    } else {
+      let parents;
+      try {
+        parents = execGitArgs(cwd, ["rev-parse", `${commitHash}^`]);
+      } catch {
+        parents = "";
+      }
+      if (parents) {
+        diffOutput = execGitArgs(cwd, ["diff", `${commitHash}^`, commitHash, "--", filePath]);
+      } else {
+        diffOutput = execGitArgs(cwd, ["diff", "--root", commitHash, "--", filePath]);
+      }
+    }
+  } catch {
+    diffOutput = "";
+  }
+  let status = "M";
+  let oldPath;
+  try {
+    const nameStatusArgs = parentHash ? ["diff", "--name-status", "-M", `${parentHash}...${commitHash}`, "--", filePath] : ["diff-tree", "--name-status", "-M", "-r", "--root", commitHash, "--", filePath];
+    const nameStatusOutput = execGitArgs(cwd, nameStatusArgs);
+    if (nameStatusOutput.trim()) {
+      const firstLine = nameStatusOutput.trim().split("\n")[0];
+      const [statusCode, ...pathParts] = firstLine.split("	");
+      status = statusCode.charAt(0);
+      if ((status === "R" || status === "C") && pathParts.length >= 2) {
+        oldPath = pathParts[0];
+      }
+    }
+  } catch {
+  }
+  const isBinary = diffOutput.includes("Binary files") || diffOutput.includes("GIT binary patch");
+  if (isBinary) {
+    return { filePath, oldPath, status, binary: true, lines: [], truncated: false };
+  }
+  const lines = [];
+  let truncated = false;
+  if (diffOutput.trim()) {
+    const diffLines = diffOutput.split("\n");
+    let oldLineNum = 0;
+    let newLineNum = 0;
+    for (const line of diffLines) {
+      if (lines.length >= MAX_LINES) {
+        truncated = true;
+        break;
+      }
+      if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++")) {
+        continue;
+      }
+      if (line.startsWith("@@")) {
+        const match = line.match(/@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+        if (match) {
+          oldLineNum = parseInt(match[1], 10);
+          newLineNum = parseInt(match[2], 10);
+        }
+        lines.push({ type: "header", content: line });
+        continue;
+      }
+      if (line.startsWith("+")) {
+        lines.push({ type: "add", content: line.substring(1), newLineNumber: newLineNum });
+        newLineNum++;
+      } else if (line.startsWith("-")) {
+        lines.push({ type: "delete", content: line.substring(1), oldLineNumber: oldLineNum });
+        oldLineNum++;
+      } else if (line.startsWith(" ") || line === "") {
+        const content = line.startsWith(" ") ? line.substring(1) : line;
+        lines.push({ type: "context", content, oldLineNumber: oldLineNum, newLineNumber: newLineNum });
+        oldLineNum++;
+        newLineNum++;
+      } else if (line.startsWith("\\")) {
+        continue;
+      }
+    }
+  }
+  return { filePath, oldPath, status, binary: false, lines, truncated };
+}
+function createTag(cwd, name, hash, options = {}) {
+  const args = ["tag"];
+  if (options.annotated && options.message) {
+    args.push("-a", name, "-m", options.message, hash);
+  } else {
+    args.push(name, hash);
+  }
+  return execGitArgs(cwd, args);
+}
+function deleteTag(cwd, name) {
+  return execGitArgs(cwd, ["tag", "-d", name]);
+}
+function deleteRemoteTag(cwd, name, remote = "origin") {
+  return execGitArgs(cwd, ["push", remote, "--delete", `refs/tags/${name}`]);
+}
+function pushTag(cwd, name, remote = "origin") {
+  return execGitArgs(cwd, ["push", remote, `refs/tags/${name}`]);
+}
+function getTagDetail(cwd, name) {
+  const hash = execGitArgs(cwd, ["rev-list", "-n", "1", `refs/tags/${name}`]);
+  try {
+    const tagType = execGitArgs(cwd, ["cat-file", "-t", `refs/tags/${name}`]);
+    if (tagType === "tag") {
+      const tagInfo = execGitArgs(cwd, ["tag", "-v", name]).replace(/^.*-----BEGIN PGP SIGNATURE-----[\s\S]*$/, "");
+      const taggerMatch = tagInfo.match(/Tagger:\s+(.+)\s+<(.+)>/);
+      const dateMatch = tagInfo.match(/Date:\s+(.+)/);
+      const messageParts = tagInfo.split("\n\n");
+      const message = messageParts.length > 1 ? messageParts.slice(1).join("\n\n").trim() : void 0;
+      return {
+        name,
+        hash,
+        isAnnotated: true,
+        tagger: taggerMatch ? { name: taggerMatch[1], email: taggerMatch[2], date: (dateMatch == null ? void 0 : dateMatch[1]) || "" } : void 0,
+        message
+      };
+    }
+  } catch {
+  }
+  return { name, hash, isAnnotated: false };
+}
+function listStashes(cwd) {
+  try {
+    const output = execGitArgs(cwd, ["stash", "list", "--format=%H|%gd|%gs|%ai"]);
+    if (!output.trim()) return [];
+    return output.split("\n").filter(Boolean).map((line) => {
+      const [hash, refName, message, date] = line.split("|");
+      const indexMatch = refName.match(/\{(\d+)\}/);
+      const index = indexMatch ? parseInt(indexMatch[1], 10) : 0;
+      const branchMatch = message.match(/(?:WIP on|On)\s+([^:]+):/);
+      const branchName = branchMatch ? branchMatch[1] : "";
+      return { hash, index, message, date, branchName };
+    });
+  } catch {
+    return [];
+  }
+}
+function createStash(cwd, options = {}) {
+  const args = ["stash", "push"];
+  if (options.includeUntracked) args.push("--include-untracked");
+  if (options.message) args.push("-m", options.message);
+  return execGitArgs(cwd, args);
+}
+function applyStash(cwd, index, reinstateIndex = false) {
+  const args = ["stash", "apply"];
+  if (reinstateIndex) args.push("--index");
+  args.push(`stash@{${index}}`);
+  return execGitArgs(cwd, args);
+}
+function popStash(cwd, index, reinstateIndex = false) {
+  const args = ["stash", "pop"];
+  if (reinstateIndex) args.push("--index");
+  args.push(`stash@{${index}}`);
+  return execGitArgs(cwd, args);
+}
+function dropStash(cwd, index) {
+  return execGitArgs(cwd, ["stash", "drop", `stash@{${index}}`]);
+}
+function stashBranch(cwd, branchName, index) {
+  return execGitArgs(cwd, ["stash", "branch", branchName, `stash@{${index}}`]);
+}
+function listRemotes(cwd) {
+  try {
+    const output = execGitArgs(cwd, ["remote", "-v"]);
+    if (!output.trim()) return [];
+    const remoteMap = /* @__PURE__ */ new Map();
+    for (const line of output.split("\n").filter(Boolean)) {
+      const [name, url, type] = line.split(/\s+/);
+      if (!remoteMap.has(name)) {
+        remoteMap.set(name, { fetchUrl: url, pushUrl: url });
+      }
+      const remote = remoteMap.get(name);
+      if (type === "(fetch)") remote.fetchUrl = url;
+      if (type === "(push)") remote.pushUrl = url;
+    }
+    return Array.from(remoteMap.entries()).map(([name, urls]) => ({
+      name,
+      fetchUrl: urls.fetchUrl,
+      pushUrl: urls.pushUrl
+    }));
+  } catch {
+    return [];
+  }
+}
+function addRemote(cwd, name, url) {
+  return execGitArgs(cwd, ["remote", "add", name, url]);
+}
+function editRemote(cwd, name, newUrl) {
+  return execGitArgs(cwd, ["remote", "set-url", name, newUrl]);
+}
+function deleteRemote(cwd, name) {
+  return execGitArgs(cwd, ["remote", "remove", name]);
+}
+
+export { listRemotes as A, resetBranch as B, revertCommit as C, getCommitDetailSync as D, getCommitFiles as E, getCommitStats as F, applyStash as G, stashBranch as H, dropStash as I, popStash as J, listStashes as K, createStash as L, getStashListHash as M, getWorkingTreeHash as N, getUncommittedFileCount as O, getBranchListHash as P, getHeadCommit as Q, pushTag as R, deleteTag as S, deleteRemoteTag as T, createTag as U, getTagDetail as V, isGitRepository as a, execGitCommand as b, execGit as c, cherryPick as d, execGitArgs as e, cleanUntrackedFiles as f, generateBranchColor as g, getCommitDetail as h, isGitRepositorySync as i, getDiff as j, fetchBranch as k, getFileDiff as l, getCommitHistory as m, getBranchesSync as n, getTags as o, getCommitCount as p, parseGitLog as q, renameBranch as r, getMergeBase as s, mergeBranch as t, pullBranch as u, pushBranch as v, rebaseBranch as w, deleteRemote as x, addRemote as y, editRemote as z };
+//# sourceMappingURL=git.mjs.map