@remixhq/core 0.1.7 → 0.1.9

package/dist/chunk-J3J4PBQ7.js

@@ -0,0 +1,710 @@
+import {
+  REMIX_ERROR_CODES
+} from "./chunk-GC2MOT3U.js";
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/infrastructure/repo/gitRepo.ts
+import fs from "fs/promises";
+import { createHash } from "crypto";
+import os from "os";
+import path from "path";
+import { execa } from "execa";
+var GIT_REMOTE_PROTOCOL_RE = /^(https?|ssh):\/\//i;
+var SCP_LIKE_GIT_REMOTE_RE = /^(?<user>[^@\s]+)@(?<host>[^:\s]+):(?<path>[^\\\s]+)$/;
+var CANONICAL_GIT_REMOTE_RE = /^(?<host>(?:localhost|[a-z0-9.-]+))\/(?<path>[^\\\s]+)$/i;
+async function runGit(args, cwd) {
+  const res = await execa("git", args, { cwd, stderr: "ignore" });
+  return String(res.stdout || "").trim();
+}
+async function runGitWithEnv(args, cwd, env) {
+  const res = await execa("git", args, { cwd, env, stderr: "ignore" });
+  return String(res.stdout || "").trim();
+}
+async function runGitRaw(args, cwd) {
+  const res = await execa("git", args, { cwd, stderr: "ignore", stripFinalNewline: false });
+  return String(res.stdout || "");
+}
+async function runGitRawWithEnv(args, cwd, env) {
+  const res = await execa("git", args, { cwd, env, stderr: "ignore", stripFinalNewline: false });
+  return String(res.stdout || "");
+}
+async function runGitDetailed(args, cwd) {
+  const res = await execa("git", args, { cwd, reject: false });
+  return {
+    exitCode: res.exitCode ?? 1,
+    stdout: String(res.stdout || ""),
+    stderr: String(res.stderr || "")
+  };
+}
+function cleanRepoPath(value) {
+  return value.trim().replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+}
+function normalizeGitRemote(remote) {
+  const raw = String(remote ?? "").trim();
+  if (!raw) return null;
+  const canonicalMatch = raw.match(CANONICAL_GIT_REMOTE_RE);
+  if (canonicalMatch?.groups?.host && canonicalMatch.groups.path) {
+    const repoPath = cleanRepoPath(canonicalMatch.groups.path);
+    if (!repoPath) return null;
+    return `${canonicalMatch.groups.host}/${repoPath}`.toLowerCase();
+  }
+  if (GIT_REMOTE_PROTOCOL_RE.test(raw)) {
+    try {
+      const url = new URL(raw);
+      const repoPath = cleanRepoPath(url.pathname);
+      if (!url.hostname || !repoPath) return null;
+      return `${url.hostname}/${repoPath}`.toLowerCase();
+    } catch {
+      return null;
+    }
+  }
+  const scpMatch = raw.match(SCP_LIKE_GIT_REMOTE_RE);
+  if (scpMatch?.groups?.host && scpMatch.groups.path) {
+    const repoPath = cleanRepoPath(scpMatch.groups.path);
+    if (!repoPath) return null;
+    return `${scpMatch.groups.host}/${repoPath}`.toLowerCase();
+  }
+  return null;
+}
+function sanitizeRefFragment(value) {
+  return value.trim().replace(/[^A-Za-z0-9._/-]+/g, "-").replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, "").replace(/^-+|-+$/g, "").slice(0, 120);
+}
+function normalizeRepoRelativePath(value) {
+  const normalized = path.posix.normalize(value.replace(/\\/g, "/").trim());
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+    throw new RemixError("Git returned an invalid repository-relative path.", {
+      exitCode: 1,
+      hint: `Path: ${value}`
+    });
+  }
+  return normalized;
+}
+function resolveRepoRelativePath(repoRoot, relativePath) {
+  return path.resolve(repoRoot, ...relativePath.split("/"));
+}
+function isWithinRepoRoot(repoRoot, targetPath) {
+  const relative = path.relative(repoRoot, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function resolveGitReportedPath(cwd, reportedPath) {
+  const value = reportedPath.trim();
+  if (!value) {
+    throw new RemixError("Git returned an empty internal path.", { exitCode: 1 });
+  }
+  return path.isAbsolute(value) ? value : path.resolve(cwd, value);
+}
+function parseGitNameStatusZ(stdout) {
+  const tokens = stdout.split("\0");
+  const entries = [];
+  for (let i = 0; i < tokens.length; i += 1) {
+    const rawToken = tokens[i];
+    if (!rawToken) continue;
+    let status = rawToken;
+    let inlinePath = null;
+    const tabIdx = rawToken.indexOf("	");
+    if (tabIdx >= 0) {
+      status = rawToken.slice(0, tabIdx);
+      inlinePath = rawToken.slice(tabIdx + 1) || null;
+    }
+    const kind = status[0]?.toUpperCase() ?? "";
+    if (kind === "R" || kind === "C") {
+      const oldPath = inlinePath ?? tokens[++i] ?? "";
+      const newPath = tokens[++i] ?? "";
+      if (!newPath) continue;
+      entries.push({
+        status,
+        path: normalizeRepoRelativePath(newPath),
+        oldPath: oldPath ? normalizeRepoRelativePath(oldPath) : null
+      });
+      continue;
+    }
+    const nextPath = inlinePath ?? tokens[++i] ?? "";
+    if (!nextPath) continue;
+    entries.push({
+      status,
+      path: normalizeRepoRelativePath(nextPath),
+      oldPath: null
+    });
+  }
+  return entries;
+}
+function buildStagePlan(entries) {
+  const updatePaths = /* @__PURE__ */ new Set();
+  const addPaths = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const kind = entry.status[0]?.toUpperCase() ?? "";
+    if (kind === "A" || kind === "C") {
+      addPaths.add(entry.path);
+      continue;
+    }
+    if (kind === "R") {
+      if (entry.oldPath) updatePaths.add(entry.oldPath);
+      addPaths.add(entry.path);
+      continue;
+    }
+    updatePaths.add(entry.path);
+  }
+  const expectedPaths = /* @__PURE__ */ new Set([...updatePaths, ...addPaths]);
+  return {
+    updatePaths: Array.from(updatePaths).sort(),
+    addPaths: Array.from(addPaths).sort(),
+    expectedPaths: Array.from(expectedPaths).sort()
+  };
+}
+function classifyGitApplyFailure(detail) {
+  const normalized = String(detail ?? "").toLowerCase();
+  if (normalized.includes("corrupt patch") || normalized.includes("patch with only garbage") || normalized.includes("unrecognized input") || normalized.includes("malformed patch") || normalized.includes("patch fragment without header")) {
+    return "malformed_patch";
+  }
+  if (normalized.includes("patch failed") || normalized.includes("does not apply") || normalized.includes("merge conflict") || normalized.includes("conflict")) {
+    return "apply_conflict";
+  }
+  return "unknown";
+}
+async function pruneEmptyParentDirectories(repoRoot, filePath) {
+  let current = path.dirname(filePath);
+  while (current !== repoRoot && isWithinRepoRoot(repoRoot, current)) {
+    const entries = await fs.readdir(current).catch(() => null);
+    if (!entries || entries.length > 0) return;
+    await fs.rmdir(current).catch(() => void 0);
+    current = path.dirname(current);
+  }
+}
+async function findGitRoot(startDir) {
+  try {
+    const root = await runGit(["rev-parse", "--show-toplevel"], startDir);
+    if (!root) throw new Error("empty");
+    return root;
+  } catch {
+    throw new RemixError("Not inside a git repository.", {
+      exitCode: 2,
+      hint: "Run this command from the root of the repository or one of its subdirectories."
+    });
+  }
+}
+async function getAbsoluteGitDir(cwd) {
+  try {
+    const gitDir = await runGit(["rev-parse", "--absolute-git-dir"], cwd);
+    return resolveGitReportedPath(cwd, gitDir);
+  } catch {
+    throw new RemixError("Failed to resolve the git directory.", {
+      exitCode: 1,
+      hint: "Ensure the current working directory is inside a valid git repository."
+    });
+  }
+}
+async function getGitCommonDir(cwd) {
+  try {
+    const commonDir = await runGit(["rev-parse", "--git-common-dir"], cwd);
+    return resolveGitReportedPath(cwd, commonDir);
+  } catch {
+    throw new RemixError("Failed to resolve the git common directory.", {
+      exitCode: 1,
+      hint: "Ensure the current working directory is inside a valid git repository."
+    });
+  }
+}
+async function getGitPath(cwd, relativePath) {
+  try {
+    const gitPath = await runGit(["rev-parse", "--git-path", relativePath], cwd);
+    return resolveGitReportedPath(cwd, gitPath);
+  } catch {
+    throw new RemixError("Failed to resolve a git-managed path.", {
+      exitCode: 1,
+      hint: `Path: ${relativePath}`
+    });
+  }
+}
+async function getCurrentBranch(cwd) {
+  try {
+    const branch = await runGit(["branch", "--show-current"], cwd);
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+async function checkoutLocalBranch(cwd, branchName) {
+  const normalized = sanitizeRefFragment(branchName);
+  if (!normalized) {
+    throw new RemixError("Preferred local branch name is invalid.", {
+      exitCode: 2,
+      hint: `Branch: ${branchName}`
+    });
+  }
+  const res = await runGitDetailed(["checkout", "-B", normalized], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to prepare the preferred local branch.", {
+      exitCode: 1,
+      hint: detail || `Git could not switch the checkout to ${normalized}.`
+    });
+  }
+  return normalized;
+}
+async function getRemoteOriginUrl(cwd) {
+  try {
+    const url = await runGit(["config", "--get", "remote.origin.url"], cwd);
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+async function getDefaultBranch(cwd) {
+  try {
+    const ref = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
+    if (!ref) return null;
+    const suffix = ref.replace(/^refs\/remotes\/origin\//, "").trim();
+    return suffix || null;
+  } catch {
+    return null;
+  }
+}
+async function listUntrackedFiles(cwd) {
+  try {
+    const out = await runGit(["ls-files", "--others", "--exclude-standard"], cwd);
+    return out.split("\n").map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getWorkingTreeDiff(cwd) {
+  const untracked = await listUntrackedFiles(cwd);
+  if (untracked.length > 0) {
+    throw new RemixError("Untracked files are not included in git diff mode.", {
+      exitCode: 2,
+      hint: "Provide `--diff-file`/`--diff-stdin`, or add the files to git before running `remix collab add`."
+    });
+  }
+  try {
+    return await runGitRaw(["diff", "--binary", "--no-ext-diff", "HEAD"], cwd);
+  } catch {
+    throw new RemixError("Failed to generate git diff.", { exitCode: 1 });
+  }
+}
+async function getWorkspaceDiff(cwd) {
+  const snapshot = await getWorkspaceSnapshot(cwd);
+  return {
+    diff: snapshot.diff,
+    includedUntrackedPaths: snapshot.includedUntrackedPaths
+  };
+}
+async function getWorkspaceSnapshot(cwd) {
+  const headCommitHash = await getHeadCommitHash(cwd);
+  if (!headCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  }
+  const includedUntrackedPaths = Array.from(new Set((await listUntrackedFiles(cwd)).map((entry) => normalizeRepoRelativePath(entry))));
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "remix-index-"));
+  const tempIndexPath = path.join(tempDir, "index");
+  const env = { ...process.env, GIT_INDEX_FILE: tempIndexPath };
+  try {
+    try {
+      await runGitWithEnv(["read-tree", "HEAD"], cwd, env);
+      await runGitWithEnv(["add", "-A", "--", "."], cwd, env);
+      const diff = await runGitRawWithEnv(["diff", "--binary", "--no-ext-diff", "--cached", "HEAD"], cwd, env);
+      const nameStatus = await runGitRawWithEnv(["diff", "--name-status", "--find-renames", "-z", "--cached", "HEAD"], cwd, env);
+      const pathEntries = parseGitNameStatusZ(nameStatus);
+      return {
+        diff,
+        diffSha256: sha256Hex(diff),
+        includedUntrackedPaths,
+        pathEntries,
+        stagePlan: buildStagePlan(pathEntries)
+      };
+    } catch {
+      throw new RemixError("Failed to generate workspace diff.", {
+        exitCode: 1,
+        hint: "Git could not snapshot the current workspace into an isolated index."
+      });
+    }
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function writeTempUnifiedDiffBackup(diff, prefix = "remix-add-backup") {
+  const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "remix-add-backup";
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), `${safePrefix}-`));
+  const backupPath = path.join(tmpDir, "submitted.diff");
+  await fs.writeFile(backupPath, diff, "utf8");
+  return { backupPath, diffSha256: sha256Hex(diff) };
+}
+async function validateUnifiedDiff(cwd, diff) {
+  const { backupPath } = await writeTempUnifiedDiffBackup(diff, "remix-validate-diff");
+  try {
+    const applyRes = await runGitDetailed(["apply", "--check", "--index", "--3way", backupPath], cwd);
+    if (applyRes.exitCode === 0) {
+      return { ok: true };
+    }
+    const detail = [applyRes.stderr.trim(), applyRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
+    return {
+      ok: false,
+      kind: classifyGitApplyFailure(detail),
+      detail
+    };
+  } finally {
+    await fs.rm(path.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function preserveWorkspaceChanges(cwd, prefix = "remix-add-preserve") {
+  const baseHeadCommitHash = await getHeadCommitHash(cwd);
+  if (!baseHeadCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD before preserving workspace changes.", { exitCode: 1 });
+  }
+  const snapshot = await getWorkspaceSnapshot(cwd);
+  const { backupPath, diffSha256 } = await writeTempUnifiedDiffBackup(snapshot.diff, prefix);
+  return {
+    baseHeadCommitHash,
+    preservedDiffPath: backupPath,
+    preservedDiffSha256: diffSha256,
+    includedUntrackedPaths: snapshot.includedUntrackedPaths,
+    stagePlan: snapshot.stagePlan
+  };
+}
+async function reapplyPreservedWorkspaceChanges(cwd, preserved, operation = "`remix collab add`") {
+  const patchFilePath = preserved.preservedDiffPath;
+  const tempPatchHash = await fs.readFile(patchFilePath, "utf8").then((content) => sha256Hex(content)).catch(() => null);
+  if (!tempPatchHash) {
+    return { status: "failed", detail: "Preserved diff artifact is missing." };
+  }
+  if (tempPatchHash !== preserved.preservedDiffSha256) {
+    return { status: "failed", detail: "Preserved diff artifact failed integrity verification." };
+  }
+  const applyRes = await runGitDetailed(["apply", "--index", "--3way", patchFilePath], cwd);
+  if (applyRes.exitCode !== 0) {
+    await runGitDetailed(["reset", "--hard", "HEAD"], cwd).catch(() => void 0);
+    await runGitDetailed(["clean", "-fd"], cwd).catch(() => void 0);
+    const detail = [applyRes.stderr.trim(), applyRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
+    return { status: "conflict", detail };
+  }
+  const unstageRes = await runGitDetailed(["reset", "--mixed", "HEAD", "--", "."], cwd);
+  if (unstageRes.exitCode !== 0) {
+    await runGitDetailed(["reset", "--hard", "HEAD"], cwd).catch(() => void 0);
+    await runGitDetailed(["clean", "-fd"], cwd).catch(() => void 0);
+    const detail = [unstageRes.stderr.trim(), unstageRes.stdout.trim()].filter(Boolean).join("\n\n") || null;
+    return {
+      status: "failed",
+      detail: detail || `Git could not restore the working tree state while running ${operation}.`
+    };
+  }
+  return { status: "clean" };
+}
+async function getHeadCommitHash(cwd) {
+  try {
+    const hash = await runGit(["rev-parse", "HEAD"], cwd);
+    return hash || null;
+  } catch {
+    return null;
+  }
+}
+async function createGitBundle(cwd, bundleName = "repository.bundle") {
+  const headCommitHash = await getHeadCommitHash(cwd);
+  if (!headCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD commit.", { exitCode: 1 });
+  }
+  const safeName = bundleName.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "remix-bundle-"));
+  const bundlePath = path.join(tmpDir, safeName);
+  const res = await runGitDetailed(["bundle", "create", bundlePath, "--all"], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to create repository bundle.", {
+      exitCode: 1,
+      hint: detail || "Git could not create the bundle artifact."
+    });
+  }
+  return { bundlePath, headCommitHash };
+}
+async function getWorktreeStatus(cwd) {
+  try {
+    const out = await runGit(["status", "--porcelain"], cwd);
+    const entries = out.split("\n").map((line) => line.trimEnd()).filter(Boolean);
+    return { isClean: entries.length === 0, entries };
+  } catch {
+    return { isClean: false, entries: [] };
+  }
+}
+async function captureRepoSnapshot(cwd, options) {
+  const [branch, headCommitHash, worktreeStatus] = await Promise.all([
+    getCurrentBranch(cwd),
+    getHeadCommitHash(cwd),
+    getWorktreeStatus(cwd)
+  ]);
+  const workspaceDiffSha256 = options?.includeWorkspaceDiffHash ? (await getWorkspaceSnapshot(cwd)).diffSha256 : null;
+  return {
+    branch,
+    headCommitHash,
+    statusEntries: worktreeStatus.entries,
+    statusSha256: sha256Hex(worktreeStatus.entries.join("\n")),
+    workspaceDiffSha256
+  };
+}
+async function assertRepoSnapshotUnchanged(cwd, snapshot, params) {
+  const current = await captureRepoSnapshot(cwd, {
+    includeWorkspaceDiffHash: snapshot.workspaceDiffSha256 !== null
+  });
+  const changes = [];
+  if (current.branch !== snapshot.branch) {
+    changes.push(`Branch changed: ${snapshot.branch ?? "(detached)"} -> ${current.branch ?? "(detached)"}`);
+  }
+  if (current.headCommitHash !== snapshot.headCommitHash) {
+    changes.push(`HEAD changed: ${snapshot.headCommitHash ?? "(missing)"} -> ${current.headCommitHash ?? "(missing)"}`);
+  }
+  if (current.statusSha256 !== snapshot.statusSha256) {
+    changes.push("Working tree status changed.");
+  }
+  if (snapshot.workspaceDiffSha256 !== null && current.workspaceDiffSha256 !== snapshot.workspaceDiffSha256) {
+    changes.push("Workspace diff changed.");
+  }
+  if (changes.length === 0) return;
+  const operation = params?.operation?.trim() || "this Remix operation";
+  const hint = [
+    `Operation: ${operation}`,
+    ...changes,
+    params?.recoveryHint?.trim() || "Review the local changes, then rerun the operation."
+  ].filter(Boolean).join("\n");
+  throw new RemixError("Repository state changed during the operation.", {
+    code: REMIX_ERROR_CODES.REPO_STATE_CHANGED_DURING_OPERATION,
+    exitCode: 2,
+    hint
+  });
+}
+async function ensureCleanWorktree(cwd, operation = "`remix collab sync`") {
+  const status = await getWorktreeStatus(cwd);
+  if (status.isClean) return;
+  const preview = status.entries.slice(0, 10).join("\n");
+  const suffix = status.entries.length > 10 ? `
+...and ${status.entries.length - 10} more` : "";
+  throw new RemixError(`Working tree must be clean before running ${operation}.`, {
+    exitCode: 2,
+    hint: `Commit, stash, or discard local changes first.
+
+${preview}${suffix}`
+  });
+}
+async function discardTrackedChanges(cwd, operation = "`remix collab add`") {
+  const res = await runGitDetailed(["reset", "--hard", "HEAD"], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError(`Failed to discard local tracked changes while running ${operation}.`, {
+      exitCode: 1,
+      hint: detail || "Git could not reset tracked changes back to HEAD."
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) {
+    throw new RemixError("Failed to resolve local HEAD after discarding tracked changes.", { exitCode: 1 });
+  }
+  return hash;
+}
+async function discardCapturedUntrackedChanges(repoRoot, capturedPaths) {
+  const normalizedCapturedPaths = Array.from(new Set(capturedPaths.map((entry) => normalizeRepoRelativePath(entry))));
+  if (normalizedCapturedPaths.length === 0) {
+    return { removedPaths: [] };
+  }
+  const currentUntracked = new Set((await listUntrackedFiles(repoRoot)).map((entry) => normalizeRepoRelativePath(entry)));
+  const removedPaths = [];
+  for (const relativePath of normalizedCapturedPaths) {
+    if (!currentUntracked.has(relativePath)) continue;
+    const absolutePath = resolveRepoRelativePath(repoRoot, relativePath);
+    if (!isWithinRepoRoot(repoRoot, absolutePath)) {
+      throw new RemixError("Refusing to delete a path outside the repository root.", {
+        exitCode: 1,
+        hint: `Path: ${relativePath}`
+      });
+    }
+    await fs.rm(absolutePath, { recursive: true, force: true }).catch((err) => {
+      throw new RemixError("Failed to remove a captured untracked path before syncing.", {
+        exitCode: 1,
+        hint: err instanceof Error ? `${relativePath}
+
+${err.message}` : relativePath
+      });
+    });
+    removedPaths.push(relativePath);
+    await pruneEmptyParentDirectories(repoRoot, absolutePath);
+  }
+  return { removedPaths };
+}
+async function requireCurrentBranch(cwd) {
+  const branch = await getCurrentBranch(cwd);
+  if (!branch) {
+    throw new RemixError("`remix collab sync` requires a checked out local branch.", {
+      exitCode: 2,
+      hint: "Checkout a branch before syncing."
+    });
+  }
+  return branch;
+}
+async function importGitBundle(cwd, bundlePath, bundleRef) {
+  const verifyRes = await runGitDetailed(["bundle", "verify", bundlePath], cwd);
+  if (verifyRes.exitCode !== 0) {
+    const detail = [verifyRes.stderr.trim(), verifyRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to verify sync bundle.", {
+      exitCode: 1,
+      hint: detail || "Git bundle verification failed."
+    });
+  }
+  const fetchRes = await runGitDetailed(["fetch", "--quiet", bundlePath, bundleRef], cwd);
+  if (fetchRes.exitCode !== 0) {
+    const detail = [fetchRes.stderr.trim(), fetchRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to import sync bundle.", {
+      exitCode: 1,
+      hint: detail || "Git could not fetch objects from the sync bundle."
+    });
+  }
+}
+async function cloneGitBundleToDirectory(bundlePath, targetDir) {
+  const parentDir = path.dirname(targetDir);
+  const cloneRes = await runGitDetailed(["clone", bundlePath, targetDir], parentDir);
+  if (cloneRes.exitCode !== 0) {
+    const detail = [cloneRes.stderr.trim(), cloneRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to create local remix checkout.", {
+      exitCode: 1,
+      hint: detail || "Git could not clone the remix repository bundle."
+    });
+  }
+  const remoteRemoveRes = await runGitDetailed(["remote", "remove", "origin"], targetDir);
+  if (remoteRemoveRes.exitCode !== 0) {
+    const detail = [remoteRemoveRes.stderr.trim(), remoteRemoveRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to finalize local remix checkout.", {
+      exitCode: 1,
+      hint: detail || "Git could not remove the temporary bundle origin."
+    });
+  }
+}
+async function ensureGitInfoExcludeEntries(cwd, entries) {
+  const excludePath = await getGitPath(cwd, "info/exclude");
+  await fs.mkdir(path.dirname(excludePath), { recursive: true });
+  let current = "";
+  try {
+    current = await fs.readFile(excludePath, "utf8");
+  } catch {
+  }
+  const lines = new Set(current.split("\n").map((line) => line.trim()).filter(Boolean));
+  let changed = false;
+  for (const entry of entries) {
+    const normalized = entry.trim();
+    if (!normalized || lines.has(normalized)) continue;
+    lines.add(normalized);
+    changed = true;
+  }
+  if (!changed) return;
+  await fs.writeFile(excludePath, `${Array.from(lines).join("\n")}
+`, "utf8");
+}
+async function ensureCommitExists(cwd, commitHash) {
+  const res = await runGitDetailed(["cat-file", "-e", `${commitHash}^{commit}`], cwd);
+  if (res.exitCode === 0) return;
+  throw new RemixError("Expected target commit is missing after bundle import.", {
+    exitCode: 1,
+    hint: `Commit ${commitHash} is not available in the local repository.`
+  });
+}
+async function fastForwardToCommit(cwd, commitHash) {
+  const res = await runGitDetailed(["merge", "--ff-only", commitHash], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to fast-forward local branch.", {
+      exitCode: 1,
+      hint: detail || "Git could not fast-forward to the target commit."
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) throw new RemixError("Failed to resolve local HEAD after fast-forward sync.", { exitCode: 1 });
+  return hash;
+}
+async function createBackupBranch(cwd, params) {
+  const sourceCommitHash = params?.sourceCommitHash?.trim() || await getHeadCommitHash(cwd);
+  if (!sourceCommitHash) {
+    throw new RemixError("Failed to resolve local HEAD before creating reconcile backup.", { exitCode: 1 });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const branchFragment = sanitizeRefFragment(params?.branchName?.trim() || "current-branch");
+  const prefix = sanitizeRefFragment(params?.prefix?.trim() || "remix/reconcile-backup");
+  const backupBranchName = `${prefix}/${branchFragment}-${timestamp}`;
+  const createRes = await runGitDetailed(["branch", backupBranchName, sourceCommitHash], cwd);
+  if (createRes.exitCode !== 0) {
+    const detail = [createRes.stderr.trim(), createRes.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError("Failed to create reconcile backup branch.", {
+      exitCode: 1,
+      hint: detail || "Git could not create the safety backup branch."
+    });
+  }
+  return { branchName: backupBranchName, commitHash: sourceCommitHash };
+}
+async function hardResetToCommit(cwd, commitHash, operation = "`remix collab reconcile`") {
+  const res = await runGitDetailed(["reset", "--hard", commitHash], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new RemixError(`Failed to move local branch while running ${operation}.`, {
+      exitCode: 1,
+      hint: detail || `Git could not reset the current branch to ${commitHash}.`
+    });
+  }
+  const hash = await getHeadCommitHash(cwd);
+  if (!hash) {
+    throw new RemixError("Failed to resolve local HEAD after resetting branch.", { exitCode: 1 });
+  }
+  return hash;
+}
+async function buildRepoFingerprint(params) {
+  const remote = normalizeGitRemote(params.remoteUrl);
+  const defaultBranch = params.defaultBranch?.trim().toLowerCase() || "";
+  const payload = remote ? { remote, defaultBranch } : { local: path.resolve(params.gitRoot).toLowerCase(), defaultBranch };
+  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function summarizeUnifiedDiff(diff) {
+  const lines = diff.split("\n");
+  let changedFilesCount = 0;
+  let insertions = 0;
+  let deletions = 0;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) changedFilesCount += 1;
+    if (line.startsWith("+") && !line.startsWith("+++")) insertions += 1;
+    if (line.startsWith("-") && !line.startsWith("---")) deletions += 1;
+  }
+  return { changedFilesCount, insertions, deletions };
+}
+
+export {
+  normalizeGitRemote,
+  findGitRoot,
+  getAbsoluteGitDir,
+  getGitCommonDir,
+  getGitPath,
+  getCurrentBranch,
+  checkoutLocalBranch,
+  getRemoteOriginUrl,
+  getDefaultBranch,
+  listUntrackedFiles,
+  getWorkingTreeDiff,
+  getWorkspaceDiff,
+  getWorkspaceSnapshot,
+  writeTempUnifiedDiffBackup,
+  validateUnifiedDiff,
+  preserveWorkspaceChanges,
+  reapplyPreservedWorkspaceChanges,
+  getHeadCommitHash,
+  createGitBundle,
+  getWorktreeStatus,
+  captureRepoSnapshot,
+  assertRepoSnapshotUnchanged,
+  ensureCleanWorktree,
+  discardTrackedChanges,
+  discardCapturedUntrackedChanges,
+  requireCurrentBranch,
+  importGitBundle,
+  cloneGitBundleToDirectory,
+  ensureGitInfoExcludeEntries,
+  ensureCommitExists,
+  fastForwardToCommit,
+  createBackupBranch,
+  hardResetToCommit,
+  buildRepoFingerprint,
+  summarizeUnifiedDiff
+};