@remixhq/core 0.1.2

package/dist/chunk-NDA7EJJA.js

@@ -0,0 +1,286 @@
+import {
+  ComergeError
+} from "./chunk-ZBMOGUSJ.js";
+
+// src/api/client.ts
+async function readJsonSafe(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.toLowerCase().includes("application/json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function createApiClient(config, opts) {
+  const apiKey = (opts?.apiKey ?? "").trim();
+  const tokenProvider = opts?.tokenProvider;
+  const CLIENT_KEY_HEADER = "x-comerge-api-key";
+  async function request(path, init) {
+    if (!tokenProvider) {
+      throw new ComergeError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Comerge API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new ComergeError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const json = await readJsonSafe(res);
+    return json ?? null;
+  }
+  async function requestBinary(path, init) {
+    if (!tokenProvider) {
+      throw new ComergeError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Comerge API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "*/*",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new ComergeError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const contentDisposition = res.headers.get("content-disposition") ?? "";
+    const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      fileName: fileNameMatch?.[1] ?? null,
+      contentType: res.headers.get("content-type")
+    };
+  }
+  return {
+    getMe: () => request("/v1/me", { method: "GET" }),
+    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
+    getOrganization: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}`, { method: "GET" }),
+    listProjects: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.clientAppId) qs.set("clientAppId", params.clientAppId);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects${suffix}`, { method: "GET" });
+    },
+    getProject: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}`, { method: "GET" }),
+    resolveProjectBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
+    },
+    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
+    listClientApps: (params) => {
+      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
+      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
+    },
+    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
+    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    listApps: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.projectId) qs.set("projectId", params.projectId);
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.forked) qs.set("forked", params.forked);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps${suffix}`, { method: "GET" });
+    },
+    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
+    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
+    presignImportUploadFirstParty: (payload) => request("/v1/apps/import/upload/presign/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
+    downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
+    createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listCollabTurns: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.changeStepId) qs.set("changeStepId", params.changeStepId);
+      if (params?.threadId) qs.set("threadId", params.threadId);
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns${suffix}`, { method: "GET" });
+    },
+    getCollabTurn: (appId, collabTurnId) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/${encodeURIComponent(collabTurnId)}`, {
+      method: "GET"
+    }),
+    getAgentMemorySummary: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/summary`, { method: "GET" }),
+    listAgentMemoryTimeline: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params?.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/timeline${suffix}`, { method: "GET" });
+    },
+    searchAgentMemory: (appId, params) => {
+      const qs = new URLSearchParams();
+      qs.set("q", params.q);
+      if (params.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/search?${qs.toString()}`, { method: "GET" });
+    },
+    getChangeStep: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}`, { method: "GET" }),
+    getChangeStepDiff: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}/diff`, {
+      method: "GET"
+    }),
+    startChangeStepReplay: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getChangeStepReplay: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}`, {
+      method: "GET"
+    }),
+    getChangeStepReplayDiff: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}/diff`, {
+      method: "GET"
+    }),
+    listMergeRequests: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.sourceAppId) qs.set("sourceAppId", params.sourceAppId);
+      if (params?.targetAppId) qs.set("targetAppId", params.targetAppId);
+      if (Array.isArray(params?.status)) {
+        for (const status of params.status) qs.append("status", status);
+      } else if (typeof params?.status === "string") {
+        qs.set("status", params.status);
+      }
+      if (params?.kind) qs.set("kind", params.kind);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/merge-requests${suffix}`, { method: "GET" });
+    },
+    openMergeRequest: (sourceAppId) => request("/v1/merge-requests", { method: "POST", body: JSON.stringify({ sourceAppId }) }),
+    getMergeRequestReview: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}/review`, { method: "GET" }),
+    updateMergeRequest: (mrId, payload) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "PATCH", body: JSON.stringify(payload) }),
+    createOrganizationInvite: (orgId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createProjectInvite: (projectId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createAppInvite: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listOrganizationInvites: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations`, { method: "GET" }),
+    listProjectInvites: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, { method: "GET" }),
+    listAppInvites: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations`, { method: "GET" }),
+    resendOrganizationInvite: (orgId, inviteId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    resendProjectInvite: (projectId, inviteId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    resendAppInvite: (appId, inviteId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    revokeOrganizationInvite: (orgId, inviteId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    revokeProjectInvite: (projectId, inviteId) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    revokeAppInvite: (appId, inviteId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    syncUpstreamApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-upstream`, {
+      method: "POST",
+      body: JSON.stringify({})
+    }),
+    preflightAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/preflight`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    startAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/start`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getAppReconcile: (appId, reconcileId) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}`, { method: "GET" }),
+    downloadAppReconcileBundle: (appId, reconcileId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}/download.bundle`, {
+      method: "GET"
+    }),
+    syncLocalApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-local`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    initiateBundle: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles`, { method: "POST", body: JSON.stringify(payload) }),
+    getBundle: (appId, bundleId) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`, { method: "GET" }),
+    getBundleDownloadUrl: (appId, bundleId, options) => request(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/download?redirect=${options?.redirect ?? false}`,
+      { method: "GET" }
+    ),
+    getBundleAssetsDownloadUrl: (appId, bundleId, options) => {
+      const qs = new URLSearchParams({
+        redirect: String(options?.redirect ?? false),
+        kind: options?.kind ?? "metro-assets"
+      });
+      return request(
+        `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/assets/download?${qs.toString()}`,
+        { method: "GET" }
+      );
+    }
+  };
+}
+
+export {
+  createApiClient
+};

package/dist/chunk-NK2DA4X6.js

@@ -0,0 +1,357 @@
+import {
+  ComergeError
+} from "./chunk-K57ZFDGC.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 runGitRaw(args, cwd) {
+  const res = await execa("git", args, { cwd, 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);
+}
+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 ComergeError("Not inside a git repository.", {
+      exitCode: 2,
+      hint: "Run this command from the root of the repository or one of its subdirectories."
+    });
+  }
+}
+async function getCurrentBranch(cwd) {
+  try {
+    const branch = await runGit(["branch", "--show-current"], cwd);
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+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 ComergeError("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 `comerge collab add`."
+    });
+  }
+  try {
+    return await runGitRaw(["diff", "--binary", "--no-ext-diff", "HEAD"], cwd);
+  } catch {
+    throw new ComergeError("Failed to generate git diff.", { exitCode: 1 });
+  }
+}
+async function writeTempUnifiedDiffBackup(diff, prefix = "comerge-add-backup") {
+  const safePrefix = prefix.replace(/[^a-zA-Z0-9._-]+/g, "-") || "comerge-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 };
+}
+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 ComergeError("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(), "comerge-bundle-"));
+  const bundlePath = path.join(tmpDir, safeName);
+  const res = await runGitDetailed(["bundle", "create", bundlePath, "--all", "--tags"], cwd);
+  if (res.exitCode !== 0) {
+    const detail = [res.stderr.trim(), res.stdout.trim()].filter(Boolean).join("\n\n");
+    throw new ComergeError("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 ensureCleanWorktree(cwd, operation = "`comerge 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 ComergeError(`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 = "`comerge 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 ComergeError(`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 ComergeError("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 ComergeError("`comerge 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 ComergeError("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 ComergeError("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 ComergeError("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 ComergeError("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 = path.join(cwd, ".git", "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 ComergeError("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 ComergeError("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 ComergeError("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 ComergeError("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() || "comerge/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 ComergeError("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 = "`comerge 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 ComergeError(`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 ComergeError("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,
+  getCurrentBranch,
+  getRemoteOriginUrl,
+  getDefaultBranch,
+  listUntrackedFiles,
+  getWorkingTreeDiff,
+  writeTempUnifiedDiffBackup,
+  getHeadCommitHash,
+  createGitBundle,
+  ensureCleanWorktree,
+  discardTrackedChanges,
+  requireCurrentBranch,
+  importGitBundle,
+  cloneGitBundleToDirectory,
+  ensureGitInfoExcludeEntries,
+  ensureCommitExists,
+  fastForwardToCommit,
+  createBackupBranch,
+  hardResetToCommit,
+  buildRepoFingerprint,
+  summarizeUnifiedDiff
+};