@lizard-build/cli 4.0.73 → 4.0.75

package/src/commands/git-hosting.ts

@@ -71,12 +71,16 @@ export function checkoutStatus(): boolean {
   const c = wc.loadCheckout(root);
   const ch = wc.changesOf(c, wc.scanWorking(root, c));
   const unpushed = (c.pending?.commits ?? []).map((x) => ({ message: x.message.trim(), time: x.time, files: x.files.length }));
-  out({ repo: c.repo, branch: c.branch, commit: c.base, sparse: c.sparse, ...ch, unpushed }, () => {
+  out({ repo: c.repo, branch: c.branch, commit: c.base, sparse: c.sparse, ...ch, unpushed, conflicts: c.conflicts ?? [] }, () => {
     info(`${chalk.bold(c.repo)} on ${chalk.cyan(c.branch)} at ${c.base.slice(0, 12)}${c.sparse ? chalk.dim(` (sparse: ${c.sparse.join(", ")})`) : ""}`);
     if (unpushed.length) {
       info(`${chalk.yellow(`${unpushed.length} commit${unpushed.length === 1 ? "" : "s"} not pushed`)} ${chalk.dim("(lizard git push)")}`);
       for (const u of unpushed) info(`  ${chalk.dim("•")} ${u.message.split("\n")[0]}`);
     }
+    if (c.conflicts?.length) {
+      info(chalk.red(`${c.conflicts.length} conflict${c.conflicts.length === 1 ? "" : "s"} to fix`));
+      for (const x of c.conflicts) info(`  ${chalk.red("conflict")}  ${x.path}  ${chalk.dim(x.reason)}`);
+    }
     const n = ch.added.length + ch.modified.length + ch.deleted.length;
     if (!n) return info(chalk.dim("no changes"));
     for (const p of ch.modified) info(`  ${chalk.yellow("modified")}  ${p}`);
@@ -160,6 +164,23 @@ export function registerLizardGit(git: Command) {
     const extra = r.sync.updated.length + r.sync.removed.length;
     return `Pushed ${r.shas.length} commit${r.shas.length === 1 ? "" : "s"} to ${r.branch}: ${r.sha.slice(0, 12)}${r.uploaded ? chalk.dim(` (${r.uploaded} file(s) uploaded)`) : ""}${extra ? chalk.dim(` · ${extra} file(s) from others' commits updated`) : ""}`;
   };
+  // A sync's merges and conflicts, for people.
+  const showMerge = (s: wc.SyncResult) => {
+    for (const p of s.merged ?? []) info(`  ${chalk.green("merged")}    ${p}`);
+    for (const x of s.conflicts ?? []) info(`  ${chalk.red("conflict")}  ${x.path}  ${chalk.dim(x.reason)}`);
+  };
+  // Push, or after a conflict: what was merged and what to fix (exit status 1).
+  const reportPush = (r: wc.PushResult) => {
+    if (r.pushed) return done(r, pushed(r));
+    out(r, () => {
+      info(chalk.yellow(`Not pushed: ${r.branch} has commits that change the same places.`));
+      info(chalk.dim(`Your ${r.messages?.length ?? 0} commit(s) are changes in your files again, merged with ${r.branch}:`));
+      showMerge(r.sync);
+      const msg = (r.messages ?? []).map((m) => m.split("\n")[0]).join("; ");
+      info(`Fix the marked places, then: lizard git commit --push -m ${JSON.stringify(msg || "...")}`);
+    });
+    process.exitCode = 1;
+  };
 
   git
     .command("commit")
@@ -168,14 +189,12 @@ export function registerLizardGit(git: Command) {
     .requiredOption("-m, --message <text>", "Commit message")
     .option("-b, --branch <name>", "Commit to a new branch, starting at this checkout's commit (and switch to it)")
     .option("--push", "Push right after committing")
-    .action(async (paths: string[], opts: { message: string; branch?: string; push?: boolean }) => {
+    .option("--force", "Commit even with conflict markers left in a file")
+    .action(async (paths: string[], opts: { message: string; branch?: string; push?: boolean; force?: boolean }) => {
       const root = needCheckout();
       const c = wc.loadCheckout(root);
-      const r = wc.commitLocal(root, c, opts.message.endsWith("\n") ? opts.message : opts.message + "\n", paths, opts.branch);
-      if (opts.push) {
-        const p = await wc.push(root, c);
-        return done(p, pushed(p));
-      }
+      const r = wc.commitLocal(root, c, opts.message.endsWith("\n") ? opts.message : opts.message + "\n", paths, opts.branch, !!opts.force);
+      if (opts.push) return reportPush(await wc.push(root, c));
       done(r, `Committed ${r.files} file(s) on ${r.branch} ${chalk.dim(`(${r.pending} not pushed: lizard git push)`)}`);
     });
 
@@ -185,8 +204,7 @@ export function registerLizardGit(git: Command) {
     .action(async () => {
       const root = needCheckout();
       const c = wc.loadCheckout(root);
-      const r = await wc.push(root, c);
-      done(r, pushed(r));
+      reportPush(await wc.push(root, c));
     });
 
   git
@@ -207,8 +225,13 @@ export function registerLizardGit(git: Command) {
       const root = needCheckout();
       const c = wc.loadCheckout(root);
       const r = await wc.sync(root, c);
-      done(r, r.from === r.to ? `Already at ${c.branch}'s latest (${r.to.slice(0, 12)})` :
-        `${c.branch}: ${r.from.slice(0, 12)} -> ${r.to.slice(0, 12)} (${r.updated.length} updated, ${r.removed.length} removed)`);
+      out(r, () => {
+        info(r.from === r.to ? `Already at ${c.branch}'s latest (${r.to.slice(0, 12)})` :
+          `${c.branch}: ${r.from.slice(0, 12)} -> ${r.to.slice(0, 12)} (${r.updated.length} updated, ${r.removed.length} removed)`);
+        showMerge(r);
+        if (r.conflicts?.length) info(chalk.dim(`Fix the marked places, then commit and push them.`));
+      });
+      if (r.conflicts?.length) process.exitCode = 1;
     });
 
   git
@@ -281,14 +304,15 @@ export function registerLizardGit(git: Command) {
     .option("-d, --description <text>")
     .option("--readme", "Start with a README (otherwise empty)")
     .option("--default-branch <name>", "Default branch (main)")
+    .option("-w, --workspace <slug>", "Workspace whose members become its collaborators (default: your personal one)")
     .action(async (name: string, opts) => {
       const r = await lg.post<{ owner: string; name: string }>("/api/repos", {
-        name, private: !!opts.private, description: opts.description, readme: !!opts.readme, defaultBranch: opts.defaultBranch,
+        name, private: !!opts.private, description: opts.description, readme: !!opts.readme, defaultBranch: opts.defaultBranch, workspace: opts.workspace,
       });
       const full = `${r.owner}/${r.name}`;
       out({ ...r, url: `${gitURL()}/${full}` }, () => {
         success(`Created ${chalk.bold(full)}  ${link(`${gitURL()}/${full}`)}`);
-        info(chalk.dim(`  Check out: lizard git clone ${full}    then: lizard git commit -m "..."`));
+        info(chalk.dim(`  Check out: lizard git clone ${full}    then: lizard git commit -m "..." && lizard git push`));
       });
     });
   repoOpt(repo.command("view").description("A repository's details").argument("[repo]"))
@@ -297,22 +321,25 @@ export function registerLizardGit(git: Command) {
       const m = await lg.get<any>(repoPath(r));
       out(m, () => {
         info(`${chalk.bold(r)}  ${m.repo.private ? "private" : "public"}  ${chalk.dim(`you: ${m.role || "reader"}`)}`);
+        if (m.workspace) info(chalk.dim(`workspace: ${m.workspace.name} (${m.workspace.slug}): its members are collaborators`));
         if (m.repo.description) info(m.repo.description);
         if (m.forkOf) info(chalk.dim(`forked from ${m.forkOf}`));
         info(`default branch ${m.repo.defaultBranch} · ${m.branches} branches · ${m.tags} tags · ${m.openIssues} open issues · ${m.openPulls} open pull requests · ${m.repo.stars} stars`);
         info(`${link(`${gitURL()}/${r}`)}\ncheck out: lizard git clone ${r}`);
       });
     });
-  repoOpt(repo.command("edit").description("Change name, description, visibility or default branch").argument("[repo]"))
+  repoOpt(repo.command("edit").description("Change name, description, visibility, default branch or workspace").argument("[repo]"))
     .option("--name <name>")
     .option("-d, --description <text>")
     .option("--private").option("--public")
     .option("--default-branch <name>")
+    .option("-w, --workspace <slug>", "Attach to a workspace you're in: its members become collaborators (\"none\" detaches; owner only)")
     .action(async (arg: string | undefined, opts) => {
       const r = await resolveRepo(arg ?? opts.repo);
       await lg.patch(repoPath(r), {
         name: opts.name, description: opts.description, defaultBranch: opts.defaultBranch,
         private: opts.private ? true : opts.public ? false : undefined,
+        workspace: opts.workspace === undefined ? undefined : opts.workspace === "none" ? "" : opts.workspace,
       });
       done({ ok: true, repo: opts.name ? `${r.split("/")[0]}/${opts.name}` : r }, `Updated ${r}`);
     });
@@ -972,7 +999,7 @@ export function registerLizardGit(git: Command) {
       const r = await resolveRepo(opts.repo);
       const c = await lg.get<any>(`${repoPath(r)}/collaborators`);
       out(c, () => {
-        c.collaborators.length ? table(["LOGIN", "ROLE", "SINCE"], c.collaborators.map((x: any) => [x.login, x.role, ago(x.createdAt)])) : info("No collaborators.");
+        c.collaborators.length ? table(["LOGIN", "ROLE", "SINCE", "VIA"], c.collaborators.map((x: any) => [x.login, x.role, ago(x.createdAt), x.fromWorkspace ? "workspace" : ""])) : info("No collaborators.");
         if (c.invitations?.length) {
           info("\nInvited:");
           table(["ID", "LOGIN", "ROLE", "BY"], c.invitations.map((x: any) => [String(x.id), x.login, x.role, x.inviter]));

package/src/lib/checkout.ts

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { APIError } from "./api.js";
 import { gitURL, lg, repoPath, sendRaw } from "./lizard-git.js";
+import { hasConflictMarkers, merge3 } from "./merge3.js";
 
 /**
  * A Lizard Git working copy (after Scion: lizard.build/git keeps no repositories as files and
@@ -58,6 +59,12 @@ export interface Checkout {
   sparse: string[] | null; // folders (or files) checked out; null: everything
   files: Record<string, FileState>;
   pending?: Pending; // commits made here, not pushed
+  conflicts?: Conflict[]; // left by the last sync for a person to fix (cleared by a commit)
+}
+
+export interface Conflict {
+  path: string;
+  reason: string;
 }
 
 interface WireEntry {
@@ -402,12 +409,17 @@ export interface SyncResult {
   to: string;
   updated: string[];
   removed: string[];
+  merged?: string[]; // changed here and on the branch: merged line by line
+  conflicts?: Conflict[]; // changed here and on the branch the same lines: marked in the file
 }
 
+const isBinaryBuf = (b: Buffer) => b.subarray(0, 8000).includes(0);
+
 /**
- * Bring the files to the branch's tip (or another branch: switching). Local changes are kept;
- * if the tip changed the same files, nothing is touched and the conflict comes back: commit
- * first, and the server merges.
+ * Bring the files to the branch's tip (or another branch: switching). Local changes are kept.
+ * A file changed here and on the branch is merged here line by line, as the server merges:
+ * what both changed differently is written between conflict markers for a person to choose,
+ * and listed in the result (and in status until the next commit).
  */
 export async function sync(root: string, c: Checkout, toBranch?: string): Promise<SyncResult> {
   needNoPending(c);
@@ -432,11 +444,57 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
     const w = want.get(p);
     return !(l && w && l.h === w.h && l.m === w.m); // the same change on both sides is fine
   });
+  const clashSet = new Set(clash);
+  const merged: string[] = [];
+  const conflicts: Conflict[] = [];
   if (clash.length) {
-    throw new APIError(409, `${branch} changed files you changed too: ${clash.slice(0, 10).join(", ")}${clash.length > 10 ? ", ..." : ""}. Commit and push them (lizard git commit --push -m "..."): the server merges them line by line.`);
+    const need = new Set<string>();
+    for (const p of clash) {
+      if (c.files[p]) need.add(c.files[p].h);
+      const w = want.get(p);
+      if (w) need.add(w.h);
+    }
+    const got = await getBlobs(c.repo, [...need]);
+    for (const p of clash) {
+      const baseF = c.files[p];
+      const w = want.get(p);
+      const l = local.get(p);
+      if (!l && !w) {
+        delete c.files[p]; // deleted on both sides
+        continue;
+      }
+      if (!l) {
+        // Deleted here, changed on the branch: theirs comes back; deleting it again is one rm away.
+        c.files[p] = writeFile(root, p, got.get(w!.h)!, w!.m);
+        conflicts.push({ path: p, reason: `you deleted it, ${branch} changed it: their version is back (delete it again if you meant to)` });
+        continue;
+      }
+      if (!w) {
+        // Deleted on the branch, changed here: yours stays (it is new to the branch now).
+        delete c.files[p];
+        conflicts.push({ path: p, reason: `${branch} deleted it, you changed it: your version is kept` });
+        continue;
+      }
+      const full = safeJoin(root, p);
+      const ours = l.m === "120000" ? Buffer.from(readlinkSync(full)) : readFileSync(full);
+      const base = baseF ? got.get(baseF.h)! : Buffer.alloc(0);
+      const theirs = got.get(w.h)!;
+      c.files[p] = { h: w.h, m: w.m }; // the branch's version is what yours now differs from
+      if (l.m === "120000" || w.m === "120000" || isBinaryBuf(base) || isBinaryBuf(ours) || isBinaryBuf(theirs)) {
+        writeFileSync(full + ".theirs", theirs);
+        conflicts.push({ path: p, reason: `binary, changed on both sides: yours kept, theirs saved as ${p}.theirs` });
+        continue;
+      }
+      const r = merge3(base.toString("utf8"), ours.toString("utf8"), theirs.toString("utf8"), branch);
+      // Yours kept its mode unless only the branch changed it.
+      writeFile(root, p, Buffer.from(r.text, "utf8"), baseF && l.m === baseF.m ? w.m : l.m);
+      if (r.conflicts) conflicts.push({ path: p, reason: `${r.conflicts} place${r.conflicts === 1 ? "" : "s"} both changed: marked <<<<<<< yours / ======= / >>>>>>> ${branch}` });
+      else merged.push(p);
+    }
   }
   const blobs = await getBlobs(c.repo, toWrite.filter(([p]) => !dirty.has(p)).map(([, f]) => f.h));
   for (const [p, f] of toWrite) {
+    if (clashSet.has(p)) continue;
     if (dirty.has(p)) {
       c.files[p] = { ...local.get(p)!, h: f.h, m: f.m }; // already identical locally
       continue;
@@ -445,6 +503,7 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
     res.updated.push(p);
   }
   for (const p of toRemove) {
+    if (clashSet.has(p)) continue;
     if (!dirty.has(p)) removeFile(root, p);
     delete c.files[p];
     res.removed.push(p);
@@ -452,7 +511,10 @@ export async function sync(root: string, c: Checkout, toBranch?: string): Promis
   c.base = r.id;
   c.root = r.root;
   c.branch = branch;
+  if (conflicts.length) c.conflicts = [...(c.conflicts ?? []).filter((x) => !conflicts.some((y) => y.path === x.path)), ...conflicts];
   saveCheckout(root, c);
+  if (merged.length) res.merged = merged;
+  if (conflicts.length) res.conflicts = conflicts;
   return res;
 }
 
@@ -473,7 +535,7 @@ export interface LocalCommitResult {
 }
 
 /** Record a commit of the changed files (all, or those under paths) here; push sends it. */
-export function commitLocal(root: string, c: Checkout, message: string, paths: string[], newBranch?: string): LocalCommitResult {
+export function commitLocal(root: string, c: Checkout, message: string, paths: string[], newBranch?: string, force = false): LocalCommitResult {
   const local = scanWorking(root, c);
   const ch = changesOf(c, local);
   const pick = (p: string) => !paths.length || paths.some((x) => p === x || p.startsWith(x.replace(/\/+$/, "") + "/"));
@@ -481,6 +543,15 @@ export function commitLocal(root: string, c: Checkout, message: string, paths: s
   const deleted = ch.deleted.filter(pick);
   if (!changed.length && !deleted.length) throw new APIError(400, "nothing to commit: no changes");
   if (newBranch && c.pending?.commits.length) throw new APIError(409, "push the commits on this branch before starting another (lizard git push)");
+  if (!force) {
+    const marked = changed.filter((p) => {
+      const f = local.get(p)!;
+      if (f.m === "120000" || f.s > 8 << 20) return false;
+      const b = readFileSync(safeJoin(root, p));
+      return !isBinaryBuf(b) && hasConflictMarkers(b.toString("utf8"));
+    });
+    if (marked.length) throw new APIError(409, `conflict markers left in ${marked.join(", ")}: choose between yours and theirs there first (or commit --force)`);
+  }
   // Keep the contents as they are now: later edits don't change a commit.
   for (const p of changed) {
     const f = local.get(p)!;
@@ -506,6 +577,10 @@ export function commitLocal(root: string, c: Checkout, message: string, paths: s
   for (const p of changed) c.files[p] = { ...local.get(p)! };
   for (const p of deleted) delete c.files[p];
   if (newBranch) c.branch = newBranch;
+  if (c.conflicts) {
+    c.conflicts = c.conflicts.filter((x) => !changed.includes(x.path) && !deleted.includes(x.path));
+    if (!c.conflicts.length) delete c.conflicts;
+  }
   saveCheckout(root, c);
   return { branch: c.branch, files: changed.length + deleted.length, pending: c.pending.commits.length };
 }
@@ -527,11 +602,13 @@ export function uncommit(root: string, c: Checkout): number {
 }
 
 export interface PushResult {
+  pushed: boolean; // false: conflicts; the commits are changes in the files again, merged with the branch
   shas: string[];
   sha: string;
   branch: string;
   uploaded: number;
   sync: SyncResult;
+  messages?: string[]; // when not pushed: the commits' messages, to commit again
 }
 
 /** Send the commits not pushed: one branch move; then bring in others' commits if there were any. */
@@ -558,7 +635,19 @@ export async function push(root: string, c: Checkout): Promise<PushResult> {
   const body: Record<string, unknown> = { branch: c.branch, commits: pend.commits };
   if (pend.newBranch && pend.base) body.createFrom = pend.base;
   else if (pend.base) body.expect = pend.base;
-  const r = await lg.post<{ shas: string[]; sha: string; parent?: string; root?: string }>(`${repoPath(c.repo)}/push`, body);
+  let r: { shas: string[]; sha: string; parent?: string; root?: string };
+  try {
+    r = await lg.post<{ shas: string[]; sha: string; parent?: string; root?: string }>(`${repoPath(c.repo)}/push`, body);
+  } catch (e) {
+    const conflicts = e instanceof APIError && e.status === 409 ? (e.body as { conflicts?: string[] } | null)?.conflicts : undefined;
+    if (!conflicts?.length) throw e;
+    // Someone changed the same lines: bring their commits here and merge in the files, so the
+    // person sees exactly what to choose; then commit and push again.
+    const messages = pend.commits.map((x) => x.message.trim());
+    uncommit(root, c);
+    const s = await sync(root, c);
+    return { pushed: false, shas: [], sha: "", branch: c.branch, uploaded: missing.size, sync: s, messages };
+  }
   const from = pend.base;
   c.pending = undefined;
   rmSync(join(root, STATE_DIR, "objects"), { recursive: true, force: true });
@@ -567,11 +656,11 @@ export async function push(root: string, c: Checkout): Promise<PushResult> {
     c.base = r.sha;
     c.root = r.root;
     saveCheckout(root, c);
-    return { shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: { from, to: r.sha, updated: [], removed: [] } };
+    return { pushed: true, shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: { from, to: r.sha, updated: [], removed: [] } };
   }
   saveCheckout(root, c);
   const s = await sync(root, c);
-  return { shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: s };
+  return { pushed: true, shas: r.shas, sha: r.sha, branch: c.branch, uploaded: missing.size, sync: s };
 }
 
 export interface CommitResult {

package/src/lib/merge3.ts

@@ -0,0 +1,179 @@
+/**
+ * Three-way line merge, as Lizard Git's server merges (lizard-git-server internal/store/merge.go,
+ * merge3): the changes each side made to base are combined; changes to different lines (even
+ * neighbouring ones) merge, the same change on both sides is taken once, and only lines both
+ * sides changed differently conflict. Where the server refuses, this writes both versions
+ * between conflict markers, for a person to choose, as git does.
+ */
+
+export const MARK_OURS = "<<<<<<< yours";
+export const MARK_SEP = "=======";
+export const MARK_THEIRS = ">>>>>>>";
+
+/** Lines with their line endings kept (the last one may have none). */
+export function splitLines(s: string): string[] {
+  const out: string[] = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\n") {
+      out.push(s.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < s.length) out.push(s.slice(start));
+  return out;
+}
+
+interface Op {
+  k: " " | "-" | "+";
+  a: number; // index in base
+  b: number; // index in side
+}
+
+/** Myers' diff of two line lists. */
+export function diffLines(A: string[], B: string[]): Op[] {
+  const n = A.length;
+  const m = B.length;
+  const max = n + m;
+  const v: number[] = new Array(2 * max + 2).fill(0);
+  const trace: number[][] = [];
+  outer: for (let d = 0; d <= max; d++) {
+    trace.push(v.slice());
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || (k !== d && v[max + k - 1] < v[max + k + 1]) ? v[max + k + 1] : v[max + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && A[x] === B[y]) {
+        x++;
+        y++;
+      }
+      v[max + k] = x;
+      if (x >= n && y >= m) break outer;
+    }
+  }
+  const ops: Op[] = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const vd = trace[d];
+    const k = x - y;
+    const pk = k === -d || (k !== d && vd[max + k - 1] < vd[max + k + 1]) ? k + 1 : k - 1;
+    const px = vd[max + pk];
+    const py = px - pk;
+    while (x > px && y > py) ops.unshift({ k: " ", a: --x, b: --y });
+    if (d > 0) {
+      if (x === px) ops.unshift({ k: "+", a: x, b: --y });
+      else ops.unshift({ k: "-", a: --x, b: y });
+    }
+  }
+  return ops;
+}
+
+/** Base lines [start, end) replaced by lines. */
+interface Region {
+  start: number;
+  end: number;
+  lines: string[];
+}
+
+function changeRegions(base: string[], side: string[]): Region[] {
+  const out: Region[] = [];
+  let cur: Region | null = null;
+  for (const o of diffLines(base, side)) {
+    if (o.k === " ") {
+      if (cur) out.push(cur);
+      cur = null;
+      continue;
+    }
+    if (!cur) cur = { start: o.a, end: o.a, lines: [] };
+    if (o.k === "-") cur.end = o.a + 1;
+    else cur.lines.push(side[o.b]);
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+function overlaps(a: Region, b: Region): boolean {
+  // Touching insertions at the same point conflict too, as in git (and the server).
+  return (a.start < b.end && b.start < a.end) || a.start === b.start || (a.start === a.end && a.start === b.end) || (b.start === b.end && b.start === a.end);
+}
+
+function apply(base: string[], r: { start: number; end: number }, rs: Region[]): string {
+  let s = "";
+  let pos = r.start;
+  for (const x of rs) {
+    for (; pos < x.start; pos++) s += base[pos];
+    s += x.lines.join("");
+    pos = x.end;
+  }
+  for (; pos < r.end; pos++) s += base[pos];
+  return s;
+}
+
+const withEOL = (s: string) => (s === "" || s.endsWith("\n") ? s : s + "\n");
+
+export interface MergeResult {
+  text: string;
+  conflicts: number; // regions between markers
+}
+
+/** Merge ours and theirs over base; conflicting regions are written with markers. */
+export function merge3(base: string, ours: string, theirs: string, theirsLabel = "theirs"): MergeResult {
+  const b = splitLines(base);
+  const co = changeRegions(b, splitLines(ours));
+  const ct = changeRegions(b, splitLines(theirs));
+  let out = "";
+  let conflicts = 0;
+  let pos = 0;
+  let i = 0;
+  let j = 0;
+  while (i < co.length || j < ct.length) {
+    let r: { start: number; end: number };
+    const fromO: Region[] = [];
+    const fromT: Region[] = [];
+    if (j >= ct.length || (i < co.length && co[i].start <= ct[j].start)) {
+      r = { start: co[i].start, end: co[i].end };
+      fromO.push(co[i++]);
+    } else {
+      r = { start: ct[j].start, end: ct[j].end };
+      fromT.push(ct[j++]);
+    }
+    for (let grew = true; grew; ) {
+      grew = false;
+      while (i < co.length && overlaps(co[i], { ...r, lines: [] })) {
+        r = { start: Math.min(r.start, co[i].start), end: Math.max(r.end, co[i].end) };
+        fromO.push(co[i++]);
+        grew = true;
+      }
+      while (j < ct.length && overlaps(ct[j], { ...r, lines: [] })) {
+        r = { start: Math.min(r.start, ct[j].start), end: Math.max(r.end, ct[j].end) };
+        fromT.push(ct[j++]);
+        grew = true;
+      }
+    }
+    for (; pos < r.start; pos++) out += b[pos];
+    if (!fromT.length) out += apply(b, r, fromO);
+    else if (!fromO.length) out += apply(b, r, fromT);
+    else {
+      const mo = apply(b, r, fromO);
+      const mt = apply(b, r, fromT);
+      if (mo === mt) out += mo;
+      else {
+        conflicts++;
+        out += `${MARK_OURS}\n${withEOL(mo)}${MARK_SEP}\n${withEOL(mt)}${MARK_THEIRS} ${theirsLabel}\n`;
+      }
+    }
+    pos = r.end;
+  }
+  for (; pos < b.length; pos++) out += b[pos];
+  return { text: out, conflicts };
+}
+
+/** Whether text still holds conflict markers (a whole marker line from merge3). */
+export function hasConflictMarkers(text: string): boolean {
+  let ours = false;
+  for (const l of text.split("\n")) {
+    if (l === MARK_OURS) ours = true;
+    else if (ours && l.startsWith(MARK_THEIRS + " ")) return true;
+  }
+  return false;
+}

package/src/lib/updater.ts

@@ -5,7 +5,7 @@ import { join, dirname } from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
 
-export const CURRENT_VERSION = "4.0.73";
+export const CURRENT_VERSION = "4.0.75";
 const RELEASES_API = "https://api.github.com/repos/lizard-build/lizard-cli/releases/latest";
 const RELEASE_BASE = "https://github.com/lizard-build/lizard-cli/releases/latest/download";
 

package/test/unit/merge3.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { hasConflictMarkers, merge3 } from "../../src/lib/merge3.js";
+
+const L = (...xs: string[]) => xs.map((x) => x + "\n").join("");
+const ten = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`);
+
+describe("merge3 (as the server merges)", () => {
+  it("merges changes to different lines, even neighbouring ones", () => {
+    const base = L(...ten);
+    expect(merge3(base, L("LINE 1", ...ten.slice(1)), L(...ten.slice(0, 9), "LINE 10"))).toEqual({ text: L("LINE 1", ...ten.slice(1, 9), "LINE 10"), conflicts: 0 });
+    expect(merge3(base, L(...ten.slice(0, 4), "LINE 5", ...ten.slice(5)), L(...ten.slice(0, 5), "LINE 6", ...ten.slice(6))).text)
+      .toBe(L(...ten.slice(0, 4), "LINE 5", "LINE 6", ...ten.slice(6)));
+  });
+  it("takes the same change once", () => {
+    const x = L(...ten.slice(0, 4), "SAME", ...ten.slice(5));
+    expect(merge3(L(...ten), x, x)).toEqual({ text: x, conflicts: 0 });
+  });
+  it("marks lines both changed differently, and merges the rest", () => {
+    const base = L(...ten);
+    const r = merge3(base, L("TOP", ...ten.slice(1, 4), "OURS", ...ten.slice(5)), L(...ten.slice(0, 4), "THEIRS", ...ten.slice(5, 9), "BOTTOM"), "main");
+    expect(r.conflicts).toBe(1);
+    expect(r.text).toBe(L("TOP", ...ten.slice(1, 4), "<<<<<<< yours", "OURS", "=======", "THEIRS", ">>>>>>> main", ...ten.slice(5, 9), "BOTTOM"));
+    expect(hasConflictMarkers(r.text)).toBe(true);
+  });
+  it("both appending at the end conflicts (as in git)", () => {
+    const r = merge3(L("a"), L("a", "ours"), L("a", "theirs"));
+    expect(r.conflicts).toBe(1);
+  });
+  it("keeps CRLF and a missing final newline", () => {
+    expect(merge3("a\r\nb\r\nc\r\nd\r\n", "A\r\nb\r\nc\r\nd\r\n", "a\r\nb\r\nc\r\nD\r\n").text).toBe("A\r\nb\r\nc\r\nD\r\n");
+    expect(merge3("a\nb\nc\nd", "A\nb\nc\nd", "a\nb\nc\nD").text).toBe("A\nb\nc\nD");
+  });
+  it("a file both added differently: everything is one marked region", () => {
+    const r = merge3("", "ours\n", "theirs\n");
+    expect(r.text).toBe("<<<<<<< yours\nours\n=======\ntheirs\n>>>>>>> theirs\n");
+  });
+  it("marker detection needs whole marker lines", () => {
+    expect(hasConflictMarkers("x <<<<<<< yours\n")).toBe(false);
+    expect(hasConflictMarkers("a\n=======\nb\n")).toBe(false);
+  });
+});