@hienlh/ppm 0.19.12 → 0.20.0

package/packages/ext-git-graph/src/file-history-parser.ts

@@ -0,0 +1,89 @@
+/**
+ * Parser for the combined `git log --follow --name-status` output used by the
+ * file history panel.
+ *
+ * One git invocation carries both the commit metadata and the per-commit file
+ * status. Records are separated by \x1e and metadata fields by \x1f — control
+ * characters rather than `|` or tabs, because a commit subject may legitimately
+ * contain either, and a rename record already uses tabs as its own separator.
+ */
+
+export const RECORD_SEP = "\x1e";
+export const FIELD_SEP = "\x1f";
+
+/** `--format` value that produces the records this module parses. */
+export const FILE_HISTORY_FORMAT =
+  `${RECORD_SEP}%H${FIELD_SEP}%P${FIELD_SEP}%an${FIELD_SEP}%ae${FIELD_SEP}%at${FIELD_SEP}%s`;
+
+export interface FileHistoryEntry {
+  hash: string;
+  parents: string[];
+  author: string;
+  authorEmail: string;
+  authorDate: number;
+  subject: string;
+  /** Status of the tracked file at this commit: A/M/D/R/C. */
+  status: string;
+  /** Path the file had at this commit — after a rename this is the new path. */
+  path: string;
+  /** Previous path, present only on a rename or copy. */
+  oldPath?: string;
+}
+
+export function parseFileHistory(stdout: string): FileHistoryEntry[] {
+  const entries: FileHistoryEntry[] = [];
+
+  for (const record of stdout.split(RECORD_SEP)) {
+    if (!record.trim()) continue;
+    const lines = record.split("\n");
+    const fields = (lines[0] ?? "").split(FIELD_SEP);
+    if (fields.length < 6) continue;
+
+    const parents = fields[1] ?? "";
+    const entry: FileHistoryEntry = {
+      hash: fields[0] ?? "",
+      parents: parents ? parents.split(" ").filter(Boolean) : [],
+      author: fields[2] ?? "",
+      authorEmail: fields[3] ?? "",
+      authorDate: Number(fields[4]) || 0,
+      subject: fields[5] ?? "",
+      status: "M",
+      path: "",
+    };
+
+    // First name-status line wins: with --follow git reports the one tracked
+    // path per commit, and a merge commit may report none at all.
+    for (const line of lines.slice(1)) {
+      if (!line.trim()) continue;
+      const parts = line.split("\t");
+      const code = parts[0];
+      const first = parts[1];
+      if (!code || !first) continue;
+      const letter = code[0] ?? "M";
+      entry.status = letter;
+      const second = parts[2];
+      if ((letter === "R" || letter === "C") && second) {
+        entry.oldPath = first;
+        entry.path = second;
+      } else {
+        entry.path = first;
+      }
+      break;
+    }
+
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
+/**
+ * Build the `-L<start>,<end>:<file>` argument for line history.
+ * Callers must have validated the numbers and the path already; this only fixes
+ * the ordering so an inverted selection still produces a valid range.
+ */
+export function buildLineRangeArg(start: number, end: number, filePath: string): string {
+  const lo = Math.min(start, end);
+  const hi = Math.max(start, end);
+  return `-L${lo},${hi}:${filePath}`;
+}

package/packages/ext-git-graph/src/file-history-view.ts

@@ -0,0 +1,386 @@
+/**
+ * File history panel — the timeline of one file, with rename tracking, plus
+ * line history for a chosen range.
+ *
+ * Whole-file mode uses `--follow` so the history survives renames; line mode
+ * uses `-L<start>,<end>:<file>`, which follows the lines themselves. The two are
+ * mutually exclusive in git (`-L` refuses `--follow`), hence the mode switch.
+ */
+import type { ExtensionContext } from "@ppm/vscode-compat";
+import type { VscodeApi } from "./git-exec.ts";
+import { assertSafeFilePaths, assertValidHash, assertValidLineNumber, spawnGit } from "./git-exec.ts";
+import { openPanel } from "./panel-registry.ts";
+import { registerViewCommand } from "./register-view-command.ts";
+import { navigateToPanel, takePendingTarget } from "./panel-nav.ts";
+import { resolveProjectName } from "./ppm-api.ts";
+import { FILE_HISTORY_FORMAT, buildLineRangeArg, parseFileHistory } from "./file-history-parser.ts";
+import { FILE_PICKER_CSS, FILE_PICKER_HTML, FILE_PICKER_JS, shellHtml } from "./webview-shell.ts";
+
+const VIEW_TYPE = "git-graph.fileHistory";
+const PAGE_SIZE = 150;
+
+export interface FileHistoryTarget {
+  filePath: string;
+  lineStart?: number;
+  lineEnd?: number;
+}
+
+export function registerFileHistoryView(context: ExtensionContext, vscode: VscodeApi): void {
+  registerViewCommand({
+    context,
+    vscode,
+    command: VIEW_TYPE,
+    label: "File History",
+    open: (projectPath, args) => {
+      const filePath = typeof args[1] === "string" ? args[1] : undefined;
+      openFileHistoryView(vscode, context, projectPath, filePath ? { filePath } : undefined);
+    },
+  });
+}
+
+export function openFileHistoryView(
+  vscode: VscodeApi,
+  context: ExtensionContext,
+  projectPath: string,
+  target?: FileHistoryTarget,
+): void {
+  const dirName = projectPath.split(/[\\/]/).filter(Boolean).pop() || "History";
+  const initialTarget = target ?? takePendingTarget<FileHistoryTarget>(VIEW_TYPE, projectPath);
+  let fileList: string[] | null = null;
+
+  const panel = openPanel({
+    vscode,
+    viewType: VIEW_TYPE,
+    title: `History: ${dirName}`,
+    projectPath,
+    html: getFileHistoryHtml(),
+    onMessage: async (raw) => {
+      const msg = raw as Record<string, any>;
+      try {
+        switch (msg.command) {
+          case "ready":
+            await panel.webview.postMessage({ command: "init", data: { target: initialTarget ?? null } });
+            if (initialTarget?.filePath) {
+              await loadHistory(initialTarget.filePath, {
+                lineStart: initialTarget.lineStart,
+                lineEnd: initialTarget.lineEnd,
+              });
+            }
+            break;
+
+          case "requestFiles": {
+            if (!fileList) {
+              const res = await spawnGit(vscode, ["ls-files", "-z"], projectPath, 60_000);
+              fileList = res.stdout.split("\0").filter(Boolean);
+            }
+            const query = String(msg.query || "").toLowerCase();
+            const matches = (query
+              ? fileList.filter((f) => f.toLowerCase().includes(query))
+              : fileList
+            ).slice(0, 300);
+            await panel.webview.postMessage({
+              command: "loadFiles",
+              data: { files: matches, total: fileList.length },
+            });
+            break;
+          }
+
+          case "requestHistory":
+            await loadHistory(String(msg.filePath || ""), {
+              lineStart: msg.lineStart,
+              lineEnd: msg.lineEnd,
+              skip: msg.skip,
+              append: Boolean(msg.append),
+            });
+            break;
+
+          case "openDiff": {
+            const filePath = String(msg.filePath || "");
+            assertSafeFilePaths([filePath], projectPath);
+            const hash = assertValidHash(msg.hash);
+            const fileName = filePath.split(/[\\/]/).pop() || filePath;
+            const projectName = await resolveProjectName(projectPath);
+            const parent = await spawnGit(vscode, ["rev-parse", `${hash}^`], projectPath);
+            await vscode.window.openTab("git-diff", `${fileName} (${hash.slice(0, 7)})`, projectName, {
+              projectName,
+              filePath,
+              ...(parent.exitCode === 0 ? { ref1: parent.stdout.trim() } : {}),
+              ref2: hash,
+            });
+            break;
+          }
+
+          case "openBlame": {
+            const filePath = String(msg.filePath || "");
+            assertSafeFilePaths([filePath], projectPath);
+            const fileName = filePath.split(/[\\/]/).pop() || filePath;
+            await navigateToPanel({
+              vscode,
+              context,
+              viewType: "git-graph.blame",
+              title: `Blame: ${fileName}`,
+              projectPath,
+              target: { filePath, rev: msg.hash ? assertValidHash(msg.hash) : undefined },
+            });
+            break;
+          }
+        }
+      } catch (e) {
+        await panel.webview.postMessage({
+          command: "error",
+          message: e instanceof Error ? e.message : String(e),
+        });
+      }
+    },
+  });
+
+  async function loadHistory(
+    filePath: string,
+    opts: { lineStart?: unknown; lineEnd?: unknown; skip?: unknown; append?: boolean },
+  ): Promise<void> {
+    if (!filePath) return;
+    assertSafeFilePaths([filePath], projectPath);
+
+    const hasRange = opts.lineStart != null && opts.lineEnd != null;
+    const skip = Number(opts.skip) > 0 ? Number(opts.skip) : 0;
+
+    const args = ["log", `--format=${FILE_HISTORY_FORMAT}`, `--max-count=${PAGE_SIZE}`];
+    if (skip > 0) args.push(`--skip=${skip}`);
+
+    let lineStart: number | undefined;
+    let lineEnd: number | undefined;
+    if (hasRange) {
+      lineStart = assertValidLineNumber(opts.lineStart, "lineStart");
+      lineEnd = assertValidLineNumber(opts.lineEnd, "lineEnd");
+      // `-s` suppresses the patch that -L emits by default; we only want commits.
+      args.push("-s", buildLineRangeArg(lineStart, lineEnd, filePath));
+    } else {
+      args.push("--follow", "--name-status", "--", filePath);
+    }
+
+    if (!opts.append) await panel.webview.postMessage({ command: "loading" });
+    const res = await spawnGit(vscode, args, projectPath, 60_000);
+    if (res.exitCode !== 0) {
+      const detail = res.stderr.trim() || `git log exited with ${res.exitCode}`;
+      await panel.webview.postMessage({ command: "error", message: detail });
+      return;
+    }
+
+    const entries = parseFileHistory(res.stdout);
+    await panel.webview.postMessage({
+      command: "loadHistory",
+      data: {
+        filePath,
+        lineStart: lineStart ?? null,
+        lineEnd: lineEnd ?? null,
+        entries,
+        skip,
+        append: Boolean(opts.append),
+        hasMore: entries.length === PAGE_SIZE,
+      },
+    });
+  }
+}
+
+function getFileHistoryHtml(): string {
+  return shellHtml({
+    toolbar: `
+      <div class="toolbar-left">
+        <button id="btn-pick" title="Choose a file">Open file…</button>
+        <span class="toolbar-title" id="file-label">No file</span>
+      </div>
+      <div class="toolbar-right">
+        <label class="range-label"><input type="checkbox" id="chk-lines" /> Lines</label>
+        <input type="text" id="line-start" class="line-input hidden" placeholder="from" inputmode="numeric" />
+        <input type="text" id="line-end" class="line-input hidden" placeholder="to" inputmode="numeric" />
+        <button id="btn-apply-lines" class="hidden">Apply</button>
+        <button id="btn-blame" title="Blame this file" disabled>Blame</button>
+        <button id="btn-refresh" disabled>Reload</button>
+      </div>`,
+    body: `${FILE_PICKER_HTML}
+      <div id="list" class="scroll"></div>`,
+    css: `${FILE_PICKER_CSS}
+.range-label { display: flex; align-items: center; gap: 4px; font-size: 11px; color: var(--subtext); white-space: nowrap; }
+.line-input { width: 58px; }
+
+.fh-row { display: flex; align-items: flex-start; gap: 8px; padding: 6px 10px; border-bottom: 1px solid var(--border); cursor: pointer; }
+.fh-row:hover { background: var(--surface-hover); }
+.fh-main { flex: 1; min-width: 0; }
+.fh-subject { font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.fh-meta { color: var(--subtext); font-size: 10px; margin-top: 2px; display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
+.fh-hash { font-family: ui-monospace, monospace; }
+.fh-status { font-size: 9px; font-weight: 700; padding: 1px 4px; border-radius: 3px; border: 1px solid var(--border2); }
+.fh-status.A { color: var(--green); border-color: var(--green); }
+.fh-status.M { color: var(--blue); border-color: var(--blue); }
+.fh-status.D { color: var(--red); border-color: var(--red); }
+.fh-status.R, .fh-status.C { color: var(--purple); border-color: var(--purple); }
+.fh-rename { color: var(--purple); font-size: 10px; }
+.fh-actions { display: flex; gap: 4px; flex-shrink: 0; }
+.fh-more { padding: 10px; text-align: center; }
+.fh-end { padding: 10px; text-align: center; color: var(--subtext); font-size: 10px; }`,
+    script: `
+const state = { filePath: null, lineStart: null, lineEnd: null, entries: [], hasMore: false, loading: false };
+
+const el = {
+  list: document.getElementById('list'),
+  fileLabel: document.getElementById('file-label'),
+  chkLines: document.getElementById('chk-lines'),
+  lineStart: document.getElementById('line-start'),
+  lineEnd: document.getElementById('line-end'),
+  btnApplyLines: document.getElementById('btn-apply-lines'),
+  btnBlame: document.getElementById('btn-blame'),
+  btnRefresh: document.getElementById('btn-refresh'),
+};
+
+/* --- File picker (shared) --- */
+${FILE_PICKER_JS}
+
+function onFileChosen(filePath) {
+  state.lineStart = null;
+  state.lineEnd = null;
+  el.chkLines.checked = false;
+  syncLineInputs();
+  request(filePath, false);
+}
+
+document.getElementById('btn-pick').addEventListener('click', () => {
+  if (isFilePickerOpen()) closeFilePicker(); else openFilePicker();
+});
+
+function syncLineInputs() {
+  const on = el.chkLines.checked;
+  for (const node of [el.lineStart, el.lineEnd, el.btnApplyLines]) node.classList.toggle('hidden', !on);
+}
+
+el.chkLines.addEventListener('change', () => {
+  syncLineInputs();
+  if (!el.chkLines.checked && state.filePath) {
+    state.lineStart = null;
+    state.lineEnd = null;
+    request(state.filePath, false);
+  }
+});
+
+el.btnApplyLines.addEventListener('click', () => {
+  if (!state.filePath) return;
+  const a = parseInt(el.lineStart.value, 10);
+  const b = parseInt(el.lineEnd.value, 10);
+  if (!Number.isInteger(a) || !Number.isInteger(b) || a < 1 || b < 1) {
+    showError('Enter two line numbers of 1 or more.');
+    return;
+  }
+  state.lineStart = a;
+  state.lineEnd = b;
+  request(state.filePath, false);
+});
+
+function request(filePath, append) {
+  if (state.loading) return;
+  state.loading = true;
+  vscode.postMessage({
+    command: 'requestHistory',
+    filePath,
+    append,
+    skip: append ? state.entries.length : 0,
+    lineStart: state.lineStart ?? undefined,
+    lineEnd: state.lineEnd ?? undefined,
+  });
+}
+
+el.btnRefresh.addEventListener('click', () => { if (state.filePath) request(state.filePath, false); });
+el.btnBlame.addEventListener('click', () => {
+  if (state.filePath) vscode.postMessage({ command: 'openBlame', filePath: state.filePath });
+});
+
+function render() {
+  if (!state.filePath) {
+    el.list.innerHTML = '<div class="empty">Choose a file to see every commit that touched it.</div>';
+    return;
+  }
+  if (!state.entries.length) {
+    el.list.innerHTML = '<div class="empty">No commits found for this file' + (state.lineStart ? ' in lines ' + state.lineStart + '–' + state.lineEnd : '') + '.</div>';
+    return;
+  }
+  let html = '';
+  for (const e of state.entries) {
+    html += '<div class="fh-row" data-hash="' + escHtml(e.hash) + '" data-path="' + escHtml(e.path || state.filePath) + '">'
+      + '<div class="fh-main">'
+        + '<div class="fh-subject">' + escHtml(e.subject) + '</div>'
+        + '<div class="fh-meta">'
+          + avatarHtml(e.author, e.authorEmail)
+          + '<span>' + escHtml(e.author) + '</span>'
+          + '<span>' + escHtml(relTime(e.authorDate)) + '</span>'
+          + '<span class="fh-hash">' + escHtml(e.hash.slice(0, 7)) + '</span>'
+          + (e.status ? '<span class="fh-status ' + escHtml(e.status) + '">' + escHtml(e.status) + '</span>' : '')
+          + (e.oldPath ? '<span class="fh-rename">renamed from ' + escHtml(e.oldPath) + '</span>' : '')
+        + '</div>'
+      + '</div>'
+      + '<div class="fh-actions">'
+        + '<button data-act="blame" title="Blame at this commit">Blame</button>'
+      + '</div>'
+    + '</div>';
+  }
+  html += state.hasMore
+    ? '<div class="fh-more"><button id="btn-more">Load more</button></div>'
+    : '<div class="fh-end">End of history</div>';
+  el.list.innerHTML = html;
+  const more = document.getElementById('btn-more');
+  if (more) more.addEventListener('click', () => request(state.filePath, true));
+}
+
+el.list.addEventListener('click', (e) => {
+  const row = e.target.closest('.fh-row');
+  if (!row) return;
+  const act = e.target.closest('button[data-act]');
+  if (act && act.dataset.act === 'blame') {
+    vscode.postMessage({ command: 'openBlame', filePath: row.dataset.path, hash: row.dataset.hash });
+    return;
+  }
+  vscode.postMessage({ command: 'openDiff', filePath: row.dataset.path, hash: row.dataset.hash });
+});
+
+window.addEventListener('message', (event) => {
+  const msg = event.data || {};
+  switch (msg.command) {
+    case 'init':
+      if (!msg.data.target) { render(); openFilePicker(); }
+      break;
+    case 'loading':
+      clearError();
+      el.list.innerHTML = '<div class="empty"><span class="spinner"></span></div>';
+      break;
+    case 'loadFiles':
+      applyFileList(msg.data);
+      break;
+    case 'loadHistory':
+      clearError();
+      state.loading = false;
+      state.filePath = msg.data.filePath;
+      state.lineStart = msg.data.lineStart;
+      state.lineEnd = msg.data.lineEnd;
+      state.entries = msg.data.append ? state.entries.concat(msg.data.entries) : msg.data.entries;
+      state.hasMore = msg.data.hasMore;
+      el.fileLabel.textContent = state.filePath + (state.lineStart ? ' :' + state.lineStart + '–' + state.lineEnd : '');
+      el.btnBlame.disabled = false;
+      el.btnRefresh.disabled = false;
+      if (state.lineStart) {
+        el.chkLines.checked = true;
+        el.lineStart.value = state.lineStart;
+        el.lineEnd.value = state.lineEnd;
+        syncLineInputs();
+      }
+      render();
+      break;
+    case 'error':
+      state.loading = false;
+      showError(msg.message);
+      if (!state.entries.length) el.list.innerHTML = '<div class="empty">' + escHtml(msg.message) + '</div>';
+      break;
+  }
+});
+
+render();
+vscode.postMessage({ command: 'ready' });
+`,
+  });
+}

package/packages/ext-git-graph/src/git-exec.ts

@@ -0,0 +1,122 @@
+/**
+ * Shared git execution + argument validation.
+ *
+ * Every git argument that originates in a webview passes through one of the
+ * assert* guards here before it reaches `spawn`. The guards reject leading
+ * dashes (option injection), control characters, and paths that escape the
+ * project root.
+ */
+import * as nodePath from "node:path";
+import type { SpawnResult } from "@ppm/vscode-compat/src/process.ts";
+
+export interface VscodeApi {
+  commands: {
+    registerCommand(command: string, callback: (...args: unknown[]) => unknown): { dispose(): void };
+  };
+  window: {
+    showErrorMessage(message: string, ...items: string[]): Promise<string | undefined>;
+    showInformationMessage(message: string, ...items: string[]): Promise<string | undefined>;
+    showQuickPick?(items: unknown[], options?: unknown): Promise<unknown>;
+    openTab(tabType: string, title: string, projectId: string | null, metadata?: Record<string, unknown>): Promise<void>;
+    switchProject(projectName: string): Promise<void>;
+    createWebviewPanel(viewType: string, title: string, showOptions: unknown, options?: { projectPath?: string }): {
+      webview: {
+        html: string;
+        onDidReceiveMessage: (listener: (msg: unknown) => void) => { dispose(): void };
+        postMessage(message: unknown): Promise<boolean>;
+      };
+      onDidDispose: (listener: () => void) => { dispose(): void };
+      dispose(): void;
+    };
+  };
+  process: {
+    spawn(cmd: string, args: string[], cwd: string, options?: { timeout?: number; env?: Record<string, string> }): Promise<SpawnResult>;
+  };
+  workspace: {
+    fs: {
+      readFile(uri: { fsPath: string }): Promise<Uint8Array>;
+      stat(uri: { fsPath: string }): Promise<{ type: number; size: number; mtime: number }>;
+    };
+  };
+  Uri: { file(path: string): { fsPath: string } };
+  ViewColumn: { Active: number };
+}
+
+export type ExtWebviewPanel = ReturnType<VscodeApi["window"]["createWebviewPanel"]>;
+
+/** Spawn git and return result */
+export async function spawnGit(
+  vscode: VscodeApi,
+  args: string[],
+  cwd: string,
+  timeout = 30_000,
+  extraEnv?: Record<string, string>,
+): Promise<SpawnResult> {
+  return vscode.process.spawn("git", args, cwd, {
+    timeout,
+    env: { GIT_TERMINAL_PROMPT: "0", ...extraEnv },
+  });
+}
+
+export function assertValidHash(value: unknown): string {
+  const s = String(value || "");
+  if (s === "HEAD") return s;
+  if (!/^[0-9a-f]{4,40}$/i.test(s)) throw new Error(`Invalid commit hash: "${s}"`);
+  return s;
+}
+
+export function assertValidRef(value: unknown, label: string): string {
+  const s = String(value || "");
+  if (!s || /[\x00-\x1f\x7f~^:?*[\]\\]/.test(s) || s.startsWith("-") || s.includes("..")) {
+    throw new Error(`Invalid git ref for ${label}: "${s}"`);
+  }
+  return s;
+}
+
+export function assertValidRemote(value: unknown): string {
+  const s = String(value || "");
+  if (!s || /[\x00-\x1f\x7f]/.test(s) || s.startsWith("-")) {
+    throw new Error(`Invalid remote name: "${s}"`);
+  }
+  return s;
+}
+
+/**
+ * The part of `node:path` the guard below needs. It is a parameter because the
+ * separator decides whether the guard accepts a path or rejects it, so a test
+ * running on one platform says nothing about the other.
+ */
+type PathApi = Pick<typeof nodePath, "resolve" | "relative" | "isAbsolute" | "sep">;
+
+/** Validate file paths are relative and don't escape the project root */
+export function assertSafeFilePaths(
+  files: string[],
+  projectPath: string,
+  path: PathApi = nodePath,
+): void {
+  for (const f of files) {
+    if (!f || f.startsWith("-") || path.isAbsolute(f) || /[\x00-\x1f\x7f]/.test(f)) {
+      throw new Error(`Invalid file path: "${f}"`);
+    }
+    // Containment is asked of `relative`, not of a string prefix. Comparing a
+    // resolved path against `normalize(projectPath) + "/"` rejected *every*
+    // path on Windows, where `resolve` answers with backslashes and the root
+    // built with a forward slash therefore never matched — the whole extension
+    // was unusable there, with a message blaming the file.
+    const rel = path.relative(projectPath, path.resolve(projectPath, f));
+    if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+      throw new Error(`File path escapes project root: "${f}"`);
+    }
+  }
+}
+
+/**
+ * A positive 1-based line number, for `git blame -L` / `git log -L`.
+ * Anything non-integer would otherwise be interpolated straight into an
+ * argument that git parses as a range expression.
+ */
+export function assertValidLineNumber(value: unknown, label: string): number {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1) throw new Error(`Invalid line number for ${label}: "${String(value)}"`);
+  return n;
+}

package/packages/ext-git-graph/src/git-state.ts

@@ -0,0 +1,81 @@
+/**
+ * Detection of an in-progress merge / rebase / cherry-pick.
+ *
+ * These states are only visible as marker files inside GIT_DIR, and git has no
+ * command that reports them in a machine-readable, locale-independent way. They
+ * are read through `workspace.fs` rather than by spawning `test` and `cat`:
+ * `process:spawn` only permits git, node, bun, npx and sqlite3, so shelling out
+ * to coreutils throws — and the caller's catch turned that into "no uncommitted
+ * data at all" for exactly the conflicted repositories that needed it.
+ */
+import type { MergeState } from "./types.ts";
+import type { VscodeApi } from "./git-exec.ts";
+import { spawnGit } from "./git-exec.ts";
+
+async function exists(vscode: VscodeApi, path: string): Promise<boolean> {
+  try {
+    await vscode.workspace.fs.stat(vscode.Uri.file(path));
+    return true;
+  } catch {
+    // Missing, or outside the paths the host will read (a linked worktree's
+    // GIT_DIR can live under the main repository). Either way: not detected.
+    return false;
+  }
+}
+
+async function readText(vscode: VscodeApi, path: string): Promise<string> {
+  try {
+    const bytes = await vscode.workspace.fs.readFile(vscode.Uri.file(path));
+    return new TextDecoder().decode(bytes).trim();
+  } catch {
+    return "";
+  }
+}
+
+/** Absolute GIT_DIR for the repository at `projectPath`, or null. */
+export async function resolveGitDir(vscode: VscodeApi, projectPath: string): Promise<string | null> {
+  const res = await spawnGit(vscode, ["rev-parse", "--git-dir"], projectPath, 2000);
+  if (res.exitCode !== 0) return null;
+  const gitDir = res.stdout.trim();
+  if (!gitDir) return null;
+  // `--git-dir` is relative when the cwd is the repository root.
+  return /^([a-zA-Z]:[\\/]|[\\/])/.test(gitDir) ? gitDir : `${projectPath}/${gitDir}`;
+}
+
+export async function detectMergeState(
+  vscode: VscodeApi,
+  projectPath: string,
+): Promise<MergeState | undefined> {
+  const gitDir = await resolveGitDir(vscode, projectPath);
+  if (!gitDir) return undefined;
+
+  // Interactive rebase
+  const rebaseMergeDir = `${gitDir}/rebase-merge`;
+  if (await exists(vscode, rebaseMergeDir)) {
+    const [current, total, message] = await Promise.all([
+      readText(vscode, `${rebaseMergeDir}/msgnum`),
+      readText(vscode, `${rebaseMergeDir}/end`),
+      readText(vscode, `${rebaseMergeDir}/message`),
+    ]);
+    return {
+      type: "rebase",
+      progress: current && total ? `${current}/${total}` : undefined,
+      message: message.split("\n")[0] || undefined,
+    };
+  }
+
+  // Non-interactive rebase / git am
+  if (await exists(vscode, `${gitDir}/rebase-apply`)) {
+    return { type: "rebase" };
+  }
+
+  if (await exists(vscode, `${gitDir}/MERGE_HEAD`)) {
+    return { type: "merge" };
+  }
+
+  if (await exists(vscode, `${gitDir}/CHERRY_PICK_HEAD`)) {
+    return { type: "cherry-pick" };
+  }
+
+  return undefined;
+}