diffprism 0.34.0 → 0.35.0

package/dist/chunk-QGWYCEJN.js

@@ -0,0 +1,448 @@
+// packages/git/src/local.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+function getGitDiff(ref, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    execSync("git --version", { cwd, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "git is not available. Please install git and make sure it is on your PATH."
+    );
+  }
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      `The directory "${cwd}" is not inside a git repository.`
+    );
+  }
+  let command;
+  let includeUntracked = false;
+  switch (ref) {
+    case "staged":
+      command = "git diff --staged --no-color";
+      break;
+    case "unstaged":
+      command = "git diff --no-color";
+      includeUntracked = true;
+      break;
+    case "all":
+      command = "git diff HEAD --no-color";
+      includeUntracked = true;
+      break;
+    default:
+      command = `git diff --no-color ${ref}`;
+      break;
+  }
+  let output;
+  try {
+    output = execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+      // 50 MB
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`git diff failed: ${message}`);
+  }
+  if (includeUntracked) {
+    output += getUntrackedDiffs(cwd);
+  }
+  return output;
+}
+function getCurrentBranch(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function listBranches(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    const output = execSync(
+      "git branch -a --format='%(refname:short)' --sort=-committerdate",
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!output) return { local: [], remote: [] };
+    const local = [];
+    const remote = [];
+    for (const line of output.split("\n")) {
+      const name = line.trim();
+      if (!name) continue;
+      if (name.endsWith("/HEAD")) continue;
+      if (name.includes("/")) {
+        remote.push(name);
+      } else {
+        local.push(name);
+      }
+    }
+    return { local, remote };
+  } catch {
+    return { local: [], remote: [] };
+  }
+}
+function listCommits(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const limit = options?.limit ?? 50;
+  try {
+    const output = execSync(
+      `git log --format='%H<<>>%h<<>>%s<<>>%an<<>>%aI' -n ${limit}`,
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!output) return [];
+    const commits = [];
+    for (const line of output.split("\n")) {
+      const parts = line.split("<<>>");
+      if (parts.length < 5) continue;
+      commits.push({
+        hash: parts[0],
+        shortHash: parts[1],
+        subject: parts[2],
+        author: parts[3],
+        date: parts[4]
+      });
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function detectWorktree(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    const gitDir = execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const resolvedGitDir = path.resolve(cwd, gitDir);
+    const resolvedCommonDir = path.resolve(cwd, gitCommonDir);
+    const isWorktree = resolvedGitDir !== resolvedCommonDir;
+    if (!isWorktree) {
+      return { isWorktree: false };
+    }
+    const worktreePath = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const mainWorktreePath = path.dirname(resolvedCommonDir);
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return {
+      isWorktree: true,
+      worktreePath,
+      mainWorktreePath,
+      branch: branch === "HEAD" ? void 0 : branch
+    };
+  } catch {
+    return { isWorktree: false };
+  }
+}
+function getUntrackedDiffs(cwd) {
+  let untrackedList;
+  try {
+    untrackedList = execSync(
+      "git ls-files --others --exclude-standard",
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+  } catch {
+    return "";
+  }
+  if (!untrackedList) return "";
+  const files = untrackedList.split("\n");
+  let result = "";
+  for (const file of files) {
+    const absPath = path.resolve(cwd, file);
+    let content;
+    try {
+      content = readFileSync(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    const hasTrailingNewline = content.length > 0 && content[content.length - 1] === "\n";
+    const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+    result += `diff --git a/${file} b/${file}
+`;
+    result += "new file mode 100644\n";
+    result += "--- /dev/null\n";
+    result += `+++ b/${file}
+`;
+    result += `@@ -0,0 +1,${contentLines.length} @@
+`;
+    for (const line of contentLines) {
+      result += `+${line}
+`;
+    }
+    if (!hasTrailingNewline) {
+      result += "\\n";
+    }
+  }
+  return result;
+}
+
+// packages/git/src/parser.ts
+import path2 from "path";
+var EXTENSION_MAP = {
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  java: "java",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  hpp: "cpp",
+  cc: "cpp",
+  cs: "csharp",
+  md: "markdown",
+  json: "json",
+  yaml: "yaml",
+  yml: "yaml",
+  html: "html",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell"
+};
+var FILENAME_MAP = {
+  Dockerfile: "dockerfile",
+  Makefile: "makefile"
+};
+function detectLanguage(filePath) {
+  const basename = path2.basename(filePath);
+  if (FILENAME_MAP[basename]) {
+    return FILENAME_MAP[basename];
+  }
+  const ext = basename.includes(".") ? basename.slice(basename.lastIndexOf(".") + 1) : "";
+  return EXTENSION_MAP[ext] ?? "text";
+}
+function stripPrefix(raw) {
+  if (raw === "/dev/null") return raw;
+  return raw.replace(/^[ab]\//, "");
+}
+function parseDiff(rawDiff, baseRef, headRef) {
+  if (!rawDiff.trim()) {
+    return { baseRef, headRef, files: [] };
+  }
+  const files = [];
+  const lines = rawDiff.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith("diff --git ")) {
+      i++;
+      continue;
+    }
+    let oldPath;
+    let newPath;
+    let status = "modified";
+    let binary = false;
+    let renameFrom;
+    let renameTo;
+    const diffLine = lines[i];
+    const gitPathMatch = diffLine.match(/^diff --git a\/(.*) b\/(.*)$/);
+    if (gitPathMatch) {
+      oldPath = gitPathMatch[1];
+      newPath = gitPathMatch[2];
+    }
+    i++;
+    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
+      const line = lines[i];
+      if (line.startsWith("--- ")) {
+        const raw = line.slice(4);
+        oldPath = stripPrefix(raw);
+        if (raw === "/dev/null") {
+          status = "added";
+        }
+      } else if (line.startsWith("+++ ")) {
+        const raw = line.slice(4);
+        newPath = stripPrefix(raw);
+        if (raw === "/dev/null") {
+          status = "deleted";
+        }
+      } else if (line.startsWith("rename from ")) {
+        renameFrom = line.slice("rename from ".length);
+        status = "renamed";
+      } else if (line.startsWith("rename to ")) {
+        renameTo = line.slice("rename to ".length);
+        status = "renamed";
+      } else if (line.startsWith("new file mode")) {
+        status = "added";
+      } else if (line.startsWith("deleted file mode")) {
+        status = "deleted";
+      } else if (line.startsWith("Binary files") || line === "GIT binary patch") {
+        binary = true;
+        if (line.includes("/dev/null") && line.includes(" and b/")) {
+          status = "added";
+        } else if (line.includes("a/") && line.includes("/dev/null")) {
+          status = "deleted";
+        }
+      }
+      if (line.startsWith("@@ ")) {
+        break;
+      }
+      i++;
+    }
+    const filePath = status === "deleted" ? oldPath ?? newPath ?? "unknown" : newPath ?? oldPath ?? "unknown";
+    const fileOldPath = status === "renamed" ? renameFrom ?? oldPath : oldPath;
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
+      const line = lines[i];
+      if (line.startsWith("@@ ")) {
+        const hunkMatch = line.match(
+          /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+        );
+        if (!hunkMatch) {
+          i++;
+          continue;
+        }
+        const oldStart = parseInt(hunkMatch[1], 10);
+        const oldLines = hunkMatch[2] !== void 0 ? parseInt(hunkMatch[2], 10) : 1;
+        const newStart = parseInt(hunkMatch[3], 10);
+        const newLines = hunkMatch[4] !== void 0 ? parseInt(hunkMatch[4], 10) : 1;
+        const changes = [];
+        let oldLineNum = oldStart;
+        let newLineNum = newStart;
+        i++;
+        while (i < lines.length) {
+          const changeLine = lines[i];
+          if (changeLine.startsWith("@@ ") || changeLine.startsWith("diff --git ")) {
+            break;
+          }
+          if (changeLine.startsWith("\")) {
+            i++;
+            continue;
+          }
+          if (changeLine.startsWith("+")) {
+            changes.push({
+              type: "add",
+              lineNumber: newLineNum,
+              content: changeLine.slice(1)
+            });
+            newLineNum++;
+            additions++;
+          } else if (changeLine.startsWith("-")) {
+            changes.push({
+              type: "delete",
+              lineNumber: oldLineNum,
+              content: changeLine.slice(1)
+            });
+            oldLineNum++;
+            deletions++;
+          } else {
+            changes.push({
+              type: "context",
+              lineNumber: newLineNum,
+              content: changeLine.length > 0 ? changeLine.slice(1) : ""
+            });
+            oldLineNum++;
+            newLineNum++;
+          }
+          i++;
+        }
+        hunks.push({ oldStart, oldLines, newStart, newLines, changes });
+      } else {
+        i++;
+      }
+    }
+    const diffFile = {
+      path: filePath,
+      status,
+      hunks,
+      language: detectLanguage(filePath),
+      binary,
+      additions,
+      deletions
+    };
+    if (status === "renamed" && fileOldPath) {
+      diffFile.oldPath = fileOldPath;
+    }
+    files.push(diffFile);
+  }
+  return { baseRef, headRef, files };
+}
+
+// packages/git/src/index.ts
+function getDiff(ref, options) {
+  if (ref === "working-copy") {
+    return getWorkingCopyDiff(options);
+  }
+  const rawDiff = getGitDiff(ref, options);
+  let baseRef;
+  let headRef;
+  if (ref === "staged") {
+    baseRef = "HEAD";
+    headRef = "staged";
+  } else if (ref === "unstaged") {
+    baseRef = "staged";
+    headRef = "working tree";
+  } else if (ref.includes("..")) {
+    const [base, head] = ref.split("..");
+    baseRef = base;
+    headRef = head;
+  } else {
+    baseRef = ref;
+    headRef = "HEAD";
+  }
+  const diffSet = parseDiff(rawDiff, baseRef, headRef);
+  return { diffSet, rawDiff };
+}
+function getWorkingCopyDiff(options) {
+  const stagedRaw = getGitDiff("staged", options);
+  const unstagedRaw = getGitDiff("unstaged", options);
+  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
+  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
+  const stagedFiles = stagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "staged"
+  }));
+  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "unstaged"
+  }));
+  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
+  return {
+    diffSet: {
+      baseRef: "HEAD",
+      headRef: "working tree",
+      files: [...stagedFiles, ...unstagedFiles]
+    },
+    rawDiff
+  };
+}
+
+export {
+  getGitDiff,
+  getCurrentBranch,
+  listBranches,
+  listCommits,
+  detectWorktree,
+  parseDiff,
+  getDiff
+};