@remixhq/core 0.1.14 → 0.1.16

package/dist/chunk-VA6WXRWB.js

@@ -1,636 +0,0 @@
-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 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()
-  };
-}
-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 setRemoteOriginUrl(cwd, remoteUrl) {
-  const normalized = String(remoteUrl ?? "").trim();
-  if (!normalized) return;
-  const existing = await runGitDetailed(["remote", "get-url", "origin"], cwd);
-  if (existing.exitCode === 0) {
-    const setUrl = await runGitDetailed(["remote", "set-url", "origin", normalized], cwd);
-    if (setUrl.exitCode !== 0) {
-      const detail = [setUrl.stderr.trim(), setUrl.stdout.trim()].filter(Boolean).join("\n\n");
-      throw new RemixError("Failed to update the local git origin remote.", {
-        exitCode: 1,
-        hint: detail || normalized
-      });
-    }
-    return;
-  }
-  const addRemote = await runGitDetailed(["remote", "add", "origin", normalized], cwd);
-  if (addRemote.exitCode !== 0) {
-    const detail = [addRemote.stderr.trim(), addRemote.stdout.trim()].filter(Boolean).join("\n\n");
-    throw new RemixError("Failed to write the local git origin remote.", {
-      exitCode: 1,
-      hint: detail || normalized
-    });
-  }
-}
-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 applyUnifiedDiffToWorktree(cwd, diff, operation = "`remix collab pull`") {
-  const normalizedDiff = String(diff ?? "");
-  if (!normalizedDiff.trim()) {
-    throw new RemixError("Diff is empty.", { exitCode: 2, hint: `${operation} requires a non-empty diff.` });
-  }
-  const { backupPath, diffSha256 } = await writeTempUnifiedDiffBackup(normalizedDiff, "remix-apply-diff");
-  try {
-    const applyRes = await runGitDetailed(["apply", "--binary", "--whitespace=nowarn", backupPath], cwd);
-    if (applyRes.exitCode !== 0) {
-      const detail = [applyRes.stderr.trim(), applyRes.stdout.trim()].filter(Boolean).join("\n\n");
-      throw new RemixError("Failed to apply unified diff to the local working tree.", {
-        exitCode: 1,
-        hint: detail || `${operation} could not apply the server diff to the current working tree.`
-      });
-    }
-    return { diffSha256 };
-  } finally {
-    await fs.rm(path.dirname(backupPath), { recursive: true, force: true }).catch(() => void 0);
-  }
-}
-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 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,
-  setRemoteOriginUrl,
-  getDefaultBranch,
-  listUntrackedFiles,
-  getWorkingTreeDiff,
-  getWorkspaceDiff,
-  writeTempUnifiedDiffBackup,
-  applyUnifiedDiffToWorktree,
-  getHeadCommitHash,
-  createGitBundle,
-  getWorktreeStatus,
-  captureRepoSnapshot,
-  assertRepoSnapshotUnchanged,
-  ensureCleanWorktree,
-  discardTrackedChanges,
-  requireCurrentBranch,
-  importGitBundle,
-  cloneGitBundleToDirectory,
-  ensureGitInfoExcludeEntries,
-  ensureCommitExists,
-  fastForwardToCommit,
-  createBackupBranch,
-  hardResetToCommit,
-  buildRepoFingerprint,
-  summarizeUnifiedDiff
-};