dee4926 · b6f8234 · 6379168
@@ -213,6 +213,8 @@
git objects; anything you then do here is **written through** to the origin
first and reflected locally after it succeeds. For a mirror the origin is
truth, exactly as git is truth for a native repo.
**Resolving a conflicted pull.** When a pull conflicts with its base, a writer sees **Resolve** in the "Can't merge" box, which opens `/:owner/:name/pulls/:n/resolve`: one file at a time, each conflict block a card with the two sides named by their branch and the taps **Ours**, **Theirs**, **Both** and **Mine** (words typed in the box count as Mine), a running "2 of 3 resolved", and the merged file beneath. The choices ride in the query string; nothing is written to git yet (committing the result is a later part). In the terminal, `v` on a conflicted pull does the same: `n`/`p` move over the blocks, `o`/`t`/`b` take ours, theirs or both, `e` opens a box for your own text, and each file shows "N of M resolved" with its merged file beneath. Readers and guests get neither.
A pull from an outsider's fork on the origin is someone else's code, so its
check and preview wait. A person with write access lets that exact head run:
on the pull page, **Approve to run here**; in the terminal, `A` on the pull
@@ -28,6 +28,8 @@
export type Exclusion = {
export const GATE: readonly string[] = [
  "test/domain-drill.test.ts",
  "test/conflicts.test.ts",
  "test/conflicts-tui.test.ts",
  "test/accounts-retire.test.ts",
  "test/client-home.test.ts",
  "test/cloud-use.test.ts",
@@ -0,0 +1,44 @@
/**
 * Reading a conflicted pull's blocks, for any surface that shows them. A
 * writer only (the same rule as the Resolve page); it reads, it writes nothing.
 */
import type { App } from "../app.ts";
import { canWrite, type Repo } from "../core/repos.ts";
import { pullDir, pullStatus, type Pull } from "../core/pulls.ts";
import type { User } from "../core/users.ts";
import { readConflictedFiles } from "../git/conflict-file.ts";
import { parseConflicts, type Block, type Conflicted } from "../git/conflicts.ts";
import { err, ok, type Result } from "../kernel/result.ts";
export interface ConflictedFile {
  readonly path: string;
  readonly blocks: readonly Block[];
  /** The file cut into text and blocks, for applying choices. */
  readonly parsed: Conflicted;
}
export interface PullConflicts {
  /** The base branch's side, and the pull branch's. */
  readonly ours: string;
  readonly theirs: string;
  readonly files: readonly ConflictedFile[];
}
export async function pullConflicts(
  app: App,
  actor: User | undefined,
  repo: Repo,
  pull: Pull,
): Promise<Result<PullConflicts, "forbidden">> {
  if (!canWrite(app.db, repo, actor)) return err("forbidden");
  const dir = await pullDir(app.db, app.reposRoot, repo, pull);
  const status = await pullStatus(dir, pull);
      
        sentinelcrew
        29d ago
        outdated
      
      Each iteration reruns the whole merge in readConflictedFile. Run the merge once and read every path from the tree it wrote.
    
  const files: ConflictedFile[] = [];
  const texts = await readConflictedFiles(dir, status.baseOid, status.headOid, status.conflicts);
  for (const path of status.conflicts) {
    const parsed = parseConflicts(texts.get(path) ?? "");
    files.push({ path, blocks: parsed.blocks, parsed });
  }
  return ok({ ours: pull.baseBranch, theirs: pull.headBranch, files });
}
@@ -0,0 +1,53 @@
/**
 * One conflicted file as git leaves it: `merge-tree --write-tree` run over
 * the two sides with `diff3` markers, then the file read out of the tree it
 * wrote. Reads only; the objects it writes are unreachable and swept by gc.
 */
import { runGitCapture } from "./env.ts";
import { isSafeOid, isSafeTreePath } from "./guard.ts";
const MAX_BYTES = 1_000_000;
export async function readConflictedFile(
  dir: string,
  ours: string,
  theirs: string,
  path: string,
): Promise<string | undefined> {
  return (await readConflictedFiles(dir, ours, theirs, [path])).get(path);
}
/** Several files from one merge: the merge runs once, each path is read from its tree. */
export async function readConflictedFiles(
  dir: string,
  ours: string,
  theirs: string,
  paths: readonly string[],
): Promise<Map<string, string>> {
  const out = new Map<string, string>();
  if (!isSafeOid(ours) || !isSafeOid(theirs) || paths.length === 0) return out;
  const merged = await runGitCapture(
    [
      "-c",
      "merge.conflictStyle=diff3",
      "merge-tree",
      "--write-tree",
      "--name-only",
      ours,
      theirs,
    ],
    { cwd: dir, timeoutMs: 60_000 },
  );
  if (merged.code !== 1) return out;
  const tree = merged.stdout.split("\n")[0]!.trim();
  if (!isSafeOid(tree)) return out;
  for (const path of paths) {
    if (!isSafeTreePath(path)) continue;
    const blob = await runGitCapture(["cat-file", "blob", `${tree}:${path}`], {
      cwd: dir,
    });
    if (blob.code === 0 && blob.stdout.length <= MAX_BYTES) out.set(path, blob.stdout);
      
        sentinelcrew
        29d ago
        
      
      Low: the 1 MB cap is checked after cat-file has buffered the whole blob into memory. Checking cat-file -s first, or skipping paths whose size is over the cap, would keep a huge conflicted file out of memory completely.
    
  }
  return out;
}
@@ -0,0 +1,128 @@
/**
 * Conflict blocks, read and chosen. Pure: the text of a file as
 * `git merge-tree --write-tree` leaves it (conflict markers in `diff3` style,
 * so each block carries its base) goes in; blocks come out, and a list of
 * choices turns them back into the merged file. Nothing here touches git.
 */
export type Part =
  | { readonly kind: "text"; readonly text: string }
  | {
      readonly kind: "block";
      /** The common ancestor's lines; empty when the file was not diff3. */
      readonly base: string;
      /** The base branch's side. */
      readonly ours: string;
      /** The pull branch's side. */
      readonly theirs: string;
    };
export interface Block {
  readonly base: string;
  readonly ours: string;
  readonly theirs: string;
}
export type Choice =
  | { readonly kind: "ours" }
  | { readonly kind: "theirs" }
  | { readonly kind: "both" }
  | { readonly kind: "text"; readonly text: string };
export interface Conflicted {
  readonly parts: readonly Part[];
  readonly blocks: readonly Block[];
}
export interface Labels {
  readonly ours: string;
  readonly theirs: string;
}
const lines = (text: string): string[] => text.split(/(?<=\n)/);
/** Cut a conflicted file into plain text and conflict blocks. */
export function parseConflicts(text: string): Conflicted {
  const parts: Part[] = [];
  const blocks: Block[] = [];
  let plain = "";
  let state: "text" | "ours" | "base" | "theirs" = "text";
  let ours = "";
  let base = "";
  let theirs = "";
  let raw = ""; // the block as written, to give back if it never closes
  for (const line of lines(text)) {
    const bare = line.replace(/\r?\n$/, "");
    if (state === "text") {
      if (/^<{7}( |$)/.test(bare)) {
        state = "ours";
        raw = line;
        ours = base = theirs = "";
      } else plain += line;
      continue;
    }
    raw += line;
    if (state === "ours" && /^\|{7}( |$)/.test(bare)) state = "base";
    else if ((state === "ours" || state === "base") && /^={7}$/.test(bare))
      state = "theirs";
    else if (state === "theirs" && /^>{7}( |$)/.test(bare)) {
      if (plain !== "") parts.push({ kind: "text", text: plain });
      plain = "";
      const block = { base, ours, theirs };
      parts.push({ kind: "block", ...block });
      blocks.push(block);
      state = "text";
    } else if (state === "ours") ours += line;
    else if (state === "base") base += line;
    else theirs += line;
  }
  // An unclosed block is not a block: keep what was written.
  plain += state === "text" ? "" : raw;
  if (plain !== "") parts.push({ kind: "text", text: plain });
  return { parts, blocks };
}
/**
 * The file with each block settled by its choice. A block with no choice
 * (`undefined`) is written back as conflict markers, named by `labels`, so
 * the merged file shows what is still open. Text is kept verbatim.
 */
export function applyChoices(
  conflicted: Conflicted,
  choices: readonly (Choice | undefined)[],
  labels: Labels,
): string {
  let out = "";
  let at = 0;
  for (const part of conflicted.parts) {
    if (part.kind === "text") {
      out += part.text;
      continue;
    }
    const choice = choices[at++];
    if (choice === undefined) out += markers(part, labels);
    else if (choice.kind === "ours") out += part.ours;
    else if (choice.kind === "theirs") out += part.theirs;
    else if (choice.kind === "both") out += part.ours + part.theirs;
    else out += choice.text;
  }
  return out;
}
function markers(block: Block, labels: Labels): string {
  const nl = (s: string): string => (s === "" || s.endsWith("\n") ? s : s + "\n");
  return (
    `<<<<<<< ${labels.ours}\n${nl(block.ours)}` +
    `=======\n${nl(block.theirs)}>>>>>>> ${labels.theirs}\n`
  );
}
/** How many of the choices settle a block. */
export function resolvedCount(
  choices: readonly (Choice | undefined)[],
  total: number,
): number {
  let n = 0;
  for (let i = 0; i < total; i++) if (choices[i] !== undefined) n++;
  return n;
}
@@ -295,6 +295,7 @@
import {
  pullThreadFragment,
  threadResolveSubmit,
} from "../web/pages/pull.ts";
import { conflictsPage } from "../web/pages/conflicts.ts";
import {
  appDisable,
  appMembersUpdate,
@@ -988,6 +989,7 @@
export function buildRouter(): Router<Handler> {
  // The change's Files step: the diff, the review threads and the merge
  // box, one tab under the change itself.
  router.add("GET", "/:owner/:name/pulls/:number/files", pullFilesPage);
  router.add("GET", "/:owner/:name/pulls/:number/resolve", conflictsPage);
  router.add("GET", "/:owner/:name/pulls/:number/thread", pullThreadFragment);
  router.add("GET", "/:owner/:name/pulls/:number/state", pullStateFragment);
  router.add("POST", "/:owner/:name/pulls/:number/comments", pullCommentSubmit);
@@ -0,0 +1,149 @@
/**
 * A conflicted pull's blocks in the terminal, the page's twin: a cursor over
 * the blocks, `o`/`t`/`b` to take ours, theirs or both, `e` for your own
 * text, and per file "N of M resolved" with the merged file beneath. Nothing
 * is written to git; the choices live in this screen only.
 */
import type { PullConflicts } from "../../actions/conflicts.ts";
import {
  applyChoices,
  resolvedCount,
  type Choice,
} from "../../git/conflicts.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding } from "../app/keys.ts";
import { style } from "../term/style.ts";
import { fill, len, split } from "../ui/layout.ts";
import { Scroll, drawLines, hitScroll, plural } from "./common.ts";
import { Composer } from "./thread.ts";
type Line = { text: string; style: ReturnType<typeof style> }[];
const NAMES = { ours: "Ours", theirs: "Theirs", both: "Both", text: "Mine" };
export function conflictScreen(ctx: Ctx, read: PullConflicts): Screen {
  const scroll = new Scroll();
  const composer = new Composer();
      
        sentinelcrew
        29d ago
        outdated
      
      This is the parity gap: the terminal reads but cannot choose. Add o/t/b (and e for own text) on a block cursor, plus the count and the applyChoices merged file, so the terminal does what the page does.
    
  /** choices[file][block] */
  const choices: (Choice | undefined)[][] = read.files.map((f) =>
    f.blocks.map(() => undefined),
  );
  const flat = read.files.flatMap((f, fi) => f.blocks.map((_, bi) => [fi, bi] as const));
  let at = 0;
  /** The line each block's header sits on, for keeping the cursor in view. */
  let heads: number[] = [];
  const rows = (side: string, max = 12): string[] =>
    side.split("\n").slice(0, side.endsWith("\n") ? -1 : undefined).slice(0, max);
  const lines = (): Line[] => {
    const c = ctx.theme.c;
    const plain = style(c.fg, c.bg);
    const muted = style(c.mutedFg, c.bg);
    const out: Line[] = [];
    heads = [];
    const say = (text: string, st = plain): void => {
      out.push([{ text, style: st }]);
    };
    const total = flat.length;
    say(`${plural(total, "conflict block")} in ${plural(read.files.length, "file")}`);
    say("n/p block · o ours · t theirs · b both · e your own text · nothing is written to git", muted);
    let n = 0;
    read.files.forEach((file, fi) => {
      const mine = choices[fi]!;
      say("");
      say(
        `${file.path} · ${resolvedCount(mine, file.blocks.length)} of ${file.blocks.length} resolved`,
      );
      if (file.blocks.length === 0)
        say("  no text blocks to choose between", muted);
      file.blocks.forEach((block, bi) => {
        const here = n === at;
        const pick = mine[bi];
        heads[n++] = out.length;
        say(
          `${here ? "▸" : " "} block ${bi + 1} of ${file.blocks.length}${pick ? ` · ${NAMES[pick.kind]}` : ""}`,
          here ? plain : muted,
        );
        for (const [name, side] of [
          [read.ours, block.ours],
          [read.theirs, block.theirs],
        ] as const) {
          say(`    ${name}`, muted);
          for (const row of rows(side)) say(`      ${row}`);
        }
      });
      if (file.blocks.length > 0) {
        say("  Merged file", muted);
        const merged = applyChoices(file.parsed, mine, {
          ours: read.ours,
          theirs: read.theirs,
        });
        for (const row of rows(merged, 200))
          say(`    ${row}`);
      }
    });
    return out;
  };
  const set = (choice: Choice): void => {
    const target = flat[at];
    if (target) choices[target[0]]![target[1]] = choice;
  };
  const move = (by: number): void => {
    if (flat.length === 0) return;
    at = Math.max(0, Math.min(flat.length - 1, at + by));
    const all = lines();
    scroll.to(heads[at] ?? 0, all.length);
  };
  return {
    title: "Conflicts",
    keys: [
      binding(["n", "p"], "block"),
      binding(["o", "t", "b"], "ours / theirs / both"),
      binding(["e"], "your text"),
      binding(["j", "k"], "scroll"),
      binding(["esc", "q"], "back"),
    ],
    load: () => Promise.resolve(),
    render(area, s) {
      const [body, comp] = split(area, "v", [fill(1), len(composer.height())]);
      const all = lines();
      drawLines(s, body!, ctx.theme.c, scroll, all);
      hitScroll(ctx, body!, scroll, all.length);
      if (composer.height() > 0) composer.render(s, comp!, ctx.theme.c, ctx);
    },
    paste: (text) => composer.paste(text),
    key(e) {
      if (composer.open) {
        const out = composer.key(e);
        if (out === "submit") {
          const text = composer.value.replace(/\r\n?/g, "\n");
          set({ kind: "text", text: text === "" || text.endsWith("\n") ? text : text + "\n" });
          composer.close();
        } else if (out === "cancel") composer.close();
        return true;
      }
      if (e.key === "esc" || e.key === "q") {
        ctx.pop();
        return true;
      }
      if (!e.ctrl && !e.alt && flat.length > 0) {
        if (e.key === "n") return move(1), true;
        if (e.key === "p") return move(-1), true;
        if (e.key === "o") return set({ kind: "ours" }), true;
        if (e.key === "t") return set({ kind: "theirs" }), true;
        if (e.key === "b") return set({ kind: "both" }), true;
        if (e.key === "e") {
          const target = flat[at]!;
          const was = choices[target[0]]![target[1]];
          composer.start("Your text", was?.kind === "text" ? was.text : "");
          return true;
        }
      }
      return scroll.key(e, lines().length);
    },
  };
}
@@ -102,6 +102,8 @@
import {
import { assignPicker, assignedText } from "./assign.ts";
import { DiffView, type DiffAnchor, type DiffNote } from "./commits.ts";
import { liveBindings, liveKey } from "./mirror.ts";
import { pullConflicts } from "../../actions/conflicts.ts";
import { conflictScreen } from "./conflicts.ts";
import { reviewScreen } from "./review.ts";
import { RunList, openRunLog, runTone } from "./runlist.ts";
import { Composer, threadLines, type ThreadEntry } from "./thread.ts";
@@ -632,6 +634,22 @@
export function pullScreen(
    });
  };
  /** `v` — the conflict blocks, read; `pullConflicts` holds the writer gate. */
  const seeConflicts = (): void => {
    if (repo === undefined) return;
    const target = repo;
    const row = getPull(f.db, target.id, number);
    if (row === undefined) return;
    runAsync(ctx, async () => {
      const read = await pullConflicts(f.app, f.user, target, row);
      if (!read.ok) {
        ctx.toast(errorText(read.error), "danger");
        return;
      }
      ctx.push(conflictScreen(ctx, read.value));
    });
  };
  const mirrored = (): boolean => repo === undefined || repo.origin !== null;
  const state = (): MergeState =>
    mergeState(detail?.issue, facts, mirrored(), gated(), checksGated());
@@ -662,6 +680,9 @@
export function pullScreen(
                ? [binding(["A"], "approve to run here")]
                : []),
              binding(["a"], "assign"),
              ...(state() === "conflicts"
                ? [binding(["v"], "see the conflict blocks")]
                : []),
              binding(["m"], "merge", { disabled: state() !== "ready" }),
              ...(tab === 1 && view.threadHere() !== null
                ? [
@@ -875,6 +896,10 @@
export function pullScreen(
        assign();
        return true;
      }
      if (e.key === "v" && mayWrite() && state() === "conflicts") {
        seeConflicts();
        return true;
      }
      // The crew tab is a list: the cursor moves, enter opens the run.
      if (tab === 2) {
        if (crew.state.key(e, crew.runs.length)) return true;
@@ -0,0 +1,183 @@
/**
      
        sentinelcrew
        29d ago
        
      
      This door is the page only. The terminal's pull screen lists the conflicted files but can't open them. Give it the same read, gated the same way, with a test. Also add a README entry.
    
 * GET /:owner/:name/pulls/:number/resolve — a conflicted pull, one file at a
 * time. Each conflict block is a card: the two sides named by their branch,
 * three taps (ours, theirs, both) and a text box for your own words. The
 * choices travel in the query string, so the page keeps no state and writes
 * nothing to git; it shows the running count and the merged file beneath.
 * Writers only.
 */
import { canWrite } from "../../core/repos.ts";
import { pullDir, pullStatus } from "../../core/pulls.ts";
import { readConflictedFile } from "../../git/conflict-file.ts";
import {
  applyChoices,
  parseConflicts,
  resolvedCount,
  type Choice,
} from "../../git/conflicts.ts";
import type { Ctx } from "../../http/context.ts";
import { crumbsFor, notFoundPage, repoBase, repoPalette, repoHeader } from "../chrome.ts";
import { html, type Html } from "../html.ts";
import { page } from "../layout.ts";
import { btn, card, icon } from "../ui.ts";
import { changeHead, changeTabs, pullContext } from "../studio/change.ts";
/** More blocks or longer words than this are not a hand's work. */
export const MAX_BLOCKS = 500;
export const MAX_TEXT = 20_000;
/**
 * The choices a query carries: `b<i>` is ours, theirs, both or text, and
 * `t<i>` the words for text. Anything else leaves the block open. A box's
 * words end in a newline, as a line of a file does, unless they are empty.
 */
export function choicesFrom(
  params: URLSearchParams,
  total: number,
): (Choice | undefined)[] {
  const out: (Choice | undefined)[] = [];
  for (let i = 0; i < Math.min(total, MAX_BLOCKS); i++) {
    // Words in the box with no tap picked are "Mine": typing is the choice.
    const typed = (params.get(`t${i}`) ?? "") !== "";
    const kind = params.get(`b${i}`) ?? (typed ? "text" : null);
    if (kind === "ours" || kind === "theirs" || kind === "both")
      out.push({ kind });
    else if (kind === "text") {
      let text = (params.get(`t${i}`) ?? "").replace(/\r\n?/g, "\n");
      if (text.length > MAX_TEXT) text = text.slice(0, MAX_TEXT);
      out.push({
        kind: "text",
        text: text === "" || text.endsWith("\n") ? text : text + "\n",
      
        sentinelcrew
        29d ago
        outdated
      
      If b<i> is missing but t<i> has text, the person's words are thrown away. Typing in the box is the clearest sign of 'Mine', so treat a non-empty t<i> as {kind: "text"} when no tap is picked, and add a test for it.
    
      });
    } else out.push(undefined);
  }
  return out;
}
const CSS = `
.rs-list { display: grid; gap: 12px; margin-top: 12px; }
.rs-card { content-visibility: auto; contain-intrinsic-size: auto 260px; }
.rs-sides { display: grid; gap: 8px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 240px), 1fr)); }
.rs-side { min-width: 0; }
.rs-side pre, .rs-merged { margin: 4px 0 0; padding: 8px; overflow: auto; max-height: 12em; font-size: 12px; white-space: pre; background: var(--muted-bg, transparent); border: 1px solid var(--border, #8884); border-radius: 6px; }
.rs-merged { max-height: 32em; }
.rs-taps { display: flex; gap: 6px; flex-wrap: wrap; margin: 8px 0; }
.rs-taps label { flex: 1 1 0; text-align: center; padding: 8px 6px; min-height: 40px; border: 1px solid var(--border, #8884); border-radius: 6px; cursor: pointer; }
.rs-taps input { position: absolute; opacity: 0; pointer-events: none; }
.rs-taps label:has(input:checked) { font-weight: 600; border-color: currentColor; }
.rs-taps label:has(input:focus-visible) { outline: 2px solid currentColor; }
.rs-text { width: 100%; min-height: 3.5em; font-family: monospace; }
`;
export async function conflictsPage(ctx: Ctx): Promise<Response> {
  const found = pullContext(ctx);
  if (found instanceof Response) return found;
  const { repo, pull } = found;
  if (!canWrite(ctx.app.db, repo, ctx.auth.user)) return notFoundPage(ctx);
  const base = repoBase(repo);
  const back = `${base}/pulls/${pull.number}/files`;
  const dir = await pullDir(ctx.app.db, ctx.app.reposRoot, repo, pull);
  const status = await pullStatus(dir, pull);
  const files = status.conflicts;
  const asked = ctx.url.searchParams.get("file") ?? "";
  // Only a path git itself named is read; the rest of the world is a 404.
  const file = asked === "" ? files[0] : files.find((f) => f === asked);
  const unknown = asked !== "" && file === undefined && files.length > 0;
  if (pull.state !== "open" || file === undefined) {
    return page({
      ctx,
      title: `Resolve · ${pull.title}`,
      crumbs: crumbsFor(repo),
      palette: repoPalette(ctx, repo),
      body: html`${repoHeader(ctx, repo, "pulls", { compact: true, ownTitle: true })}
        ${changeHead(ctx, repo, pull)}${changeTabs(repo, pull, "files")}
        ${card(
      
        sentinelcrew
        29d ago
        outdated
      
      Reached for an unknown ?file= on a pull that does conflict, so "has no conflicts" is false there. Word it for that case, or fall back to files[0].
    
          html`<p>${unknown && pull.state === "open"
              ? "Nothing to resolve there: that file is not one of the conflicted files."
              : "Nothing to resolve: this pull has no conflicts."}
            <a href="${back}">Back to the files</a>.</p>`,
        )}`,
    });
  }
  const text = await readConflictedFile(dir, status.baseOid, status.headOid, file);
  const parsed = parseConflicts(text ?? "");
  const choices = choicesFrom(ctx.url.searchParams, parsed.blocks.length);
  const labels = { ours: pull.baseBranch, theirs: pull.headBranch };
  const done = resolvedCount(choices, parsed.blocks.length);
  const total = parsed.blocks.length;
  const merged = applyChoices(parsed, choices, labels);
  const here = `${base}/pulls/${pull.number}/resolve`;
  const cards: Html[] = parsed.blocks.slice(0, MAX_BLOCKS).map((block, i) => {
    const pick = choices[i]?.kind;
    const tap = (kind: string, label: string): Html =>
      html`<label
        ><input type="radio" name="b${i}" value="${kind}" ${pick === kind ? html`checked` : ""} />${label}</label
      >`;
    const own = choices[i];
    return card(
      html`<div class="rs-sides">
          <div class="rs-side">
            <strong class="small mono">${pull.baseBranch}</strong>
            <pre>${block.ours}</pre>
          </div>
          <div class="rs-side">
            <strong class="small mono">${pull.headBranch}</strong>
            <pre>${block.theirs}</pre>
          </div>
        </div>
        ${block.base === ""
          ? ""
          : html`<details><summary class="small muted">Before either changed it</summary><pre class="rs-merged">${block.base}</pre></details>`}
        <div class="rs-taps">
          ${tap("ours", `Ours`)}${tap("theirs", `Theirs`)}${tap("both", "Both")}${tap("text", "Mine")}
        </div>
        <textarea class="rs-text" name="t${i}" rows="3" maxlength="${MAX_TEXT}"
          aria-label="Your own text for block ${i + 1}">${own?.kind === "text" ? own.text : ""}</textarea>`,
      {
        extra: "rs-card",
        head: html`<h2>Block ${i + 1} of ${total}</h2>`,
      },
    );
  });
  const body = html`${repoHeader(ctx, repo, "pulls", { compact: true, ownTitle: true })}
    ${changeHead(ctx, repo, pull)}${changeTabs(repo, pull, "files")}
    <p class="muted small mt">
      <a href="${back}">← Files</a> · <span class="mono">${file}</span> ·
      <strong id="rs-count">${done} of ${total} resolved</strong>
      · nothing is written to git
    </p>
    ${files.length > 1
      ? html`<p class="small">
          ${files.map((f) =>
            f === file
              ? html`<strong class="mono">${f}</strong> `
              : html`<a class="mono" href="${here}?file=${encodeURIComponent(f)}">${f}</a> `,
          )}
        </p>`
      : ""}
    ${total === 0
      ? card(
          html`<p>This file has no text blocks to choose between (it may be
            deleted on one side). Resolve it in your own checkout.</p>`,
        )
      : html`<form method="get" action="${here}">
          <input type="hidden" name="file" value="${file}" />
          <div class="rs-list">${cards}</div>
          <p class="mt">${btn("Update the merged file", { icon: "check" })}</p>
        </form>`}
    <h2 class="mt">Merged file</h2>
    <pre class="rs-merged" aria-label="Merged ${file}">${merged}</pre>`;
  return page({
    ctx,
    title: `Resolve · ${pull.title} · ${repo.name}`,
    crumbs: crumbsFor(repo),
    palette: repoPalette(ctx, repo),
    body,
    styleCss: CSS,
  });
}
@@ -414,7 +414,9 @@
function mergeBox(
                >${status.conflicts.slice(0, 3).join(", ")}</span
              >${status.conflicts.length > 3 ? "…" : ""}. Merge
              <span class="mono">${pull.baseBranch}</span> into the branch and
              push again.`
              push again.${mayMerge
                ? html` <a href="${thread}/resolve">Resolve</a> it here.`
                : ""}`
          : html`This branch cannot be applied automatically.`;
    return card(
      html`${icon("alert")}
@@ -0,0 +1,138 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { openPull } from "../src/actions/pulls.ts";
import { pullConflicts } from "../src/actions/conflicts.ts";
import { commitToBranch, createRepo } from "../src/actions/repos.ts";
import { createApp, type App } from "../src/app.ts";
import { getPull, type Pull } from "../src/core/pulls.ts";
import type { Repo } from "../src/core/repos.ts";
import { createUser, type User } from "../src/core/users.ts";
import { createForgeApp } from "../src/tui/forge.ts";
import { pullScreen } from "../src/tui/screens/pull.ts";
import { local } from "../src/tui/screens/where.ts";
import { headlessTerminal } from "../src/tui/term/terminal.ts";
import { quietLogs } from "./helpers/globals.ts";
import { settleApp } from "./helpers/tui.ts";
quietLogs();
describe("the terminal reads a conflicted pull's blocks", () => {
  let dataDir: string;
  let app: App;
  let alice: User;
  let carol: User;
  let repo: Repo;
  let pull: Pull;
  const put = async (branch: string, content: string, from?: string) => {
    const done = await commitToBranch(app, alice, repo, {
      branch,
      ...(from ? { from } : {}),
      message: `edit ${branch}`,
      files: [{ path: "code.txt", content }],
    });
    if (!done.ok) throw new Error(JSON.stringify(done.error));
  };
  beforeAll(async () => {
    dataDir = await mkdtemp(join(tmpdir(), "forge-cf-tui-"));
    app = createApp({ dataDir, port: 0, host: "forge.test" });
    const people: User[] = [];
    for (const [username, first] of [["alice", true], ["carol", false]] as const) {
      const made = await createUser(app.db, {
        trusted: true,
        username,
        email: `${username}@forge.local`,
        password: "a-good-passphrase",
        adminIfFirst: first,
      });
      if (!made.ok) throw new Error(made.error);
      people.push(made.value);
    }
    [alice, carol] = people as [User, User];
    const made = await createRepo(app, alice, { name: "lib", visibility: "public" });
    if (!made.ok) throw new Error(String(made.error));
    repo = made.value;
    await put("main", "top\nbase\nend\n");
    await put("loud", "top\nloud line\nend\n");
    const opened = await openPull(app, alice, repo, {
      title: "Loud",
      baseBranch: "main",
      headBranch: "loud",
    });
    if (!opened.ok) throw new Error(String(opened.error));
    await put("main", "top\nquiet line\nend\n");
    pull = getPull(app.db, repo.id, opened.value.number)!;
  }, 120_000);
  afterAll(async () => {
    app.close();
    await rm(dataDir, { recursive: true, force: true });
  });
  async function pressV(user: User, then: string[] = []): Promise<string> {
    const { app: tui, session } = createForgeApp(
      app,
      {
        sshUsername: user.username,
        remoteAddress: "127.0.0.1",
        fingerprint: `SHA256:${user.username}`,
        user,
      },
      { terminal: headlessTerminal(140, 44), exitHooks: false },
    );
    tui.start();
    try {
      tui.ctx.push(pullScreen(session, tui.ctx, local(session, repo), pull.number));
      const end = Date.now() + 20_000;
      while (!tui.screen.toText().includes("Conflicts in 1 file")) {
        if (Date.now() > end) throw new Error(tui.screen.toText());
        await settleApp(tui);
        await Bun.sleep(20);
      }
      tui.dispatch({ type: "key", key: "v", ctrl: false, alt: false, shift: false });
      await Bun.sleep(1500);
      await settleApp(tui);
      for (const key of then) {
        tui.dispatch({ type: "key", key, ctrl: false, alt: false, shift: false });
        await settleApp(tui);
      }
      return tui.screen.toText();
    } finally {
      tui.stop();
    }
  }
  test("the read names both sides by branch; a reader gets nothing", async () => {
    const read = await pullConflicts(app, alice, repo, pull);
    expect(read.ok && read.value.files[0]?.blocks).toEqual([
      { base: "base\n", ours: "quiet line\n", theirs: "loud line\n" },
    ]);
    const refused = await pullConflicts(app, carol, repo, pull);
    expect(refused.ok).toBe(false);
  });
  test("a writer's v shows the blocks; a reader's does not", async () => {
    const writer = await pressV(alice);
    expect(writer).toContain("1 conflict block in 1 file");
    expect(writer).toContain("quiet line");
    expect(writer).toContain("loud line");
    const reader = await pressV(carol);
    expect(reader).not.toContain("conflict block");
    expect(reader).not.toContain("quiet line");
  }, 60_000);
  test("b on the one block resolves it and the merged file keeps both lines", async () => {
    const before = await pressV(alice);
    expect(before).toContain("0 of 1 resolved");
    expect(before).toContain("<<<<<<<");
    const after = await pressV(alice, ["b"]);
    expect(after).toContain("1 of 1 resolved");
    expect(after).toContain("Both");
    expect(after).not.toContain("<<<<<<<");
    expect(after.indexOf("quiet line", after.indexOf("Merged file"))).toBeGreaterThan(-1);
    expect(after.indexOf("loud line", after.indexOf("Merged file"))).toBeGreaterThan(-1);
  }, 60_000);
});
@@ -0,0 +1,181 @@
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { applyChoices, parseConflicts } from "../src/git/conflicts.ts";
import { choicesFrom } from "../src/web/pages/conflicts.ts";
import { gitClientEnv } from "./helpers/git-client.ts";
const labels = { ours: "main", theirs: "loud" };
const FILE =
  "top\n<<<<<<< a\none\n||||||| b\nzero\n=======\nuno\n>>>>>>> c\nmid\n" +
  "<<<<<<< a\ntwo\n=======\ndos\n>>>>>>> c\nend\n";
describe("conflict blocks", () => {
  test("a two-block conflict resolved by both gives the file", () => {
    const parsed = parseConflicts(FILE);
    expect(parsed.blocks).toEqual([
      { base: "zero\n", ours: "one\n", theirs: "uno\n" },
      { base: "", ours: "two\n", theirs: "dos\n" },
    ]);
    const both = { kind: "both" } as const;
    expect(applyChoices(parsed, [both, both], labels)).toBe(
      "top\none\nuno\nmid\ntwo\ndos\nend\n",
    );
  });
  test("ours, theirs and your own text are kept verbatim", () => {
    const parsed = parseConflicts(FILE);
    const mine = "  keep\tme  \n\nexactly\n";
    expect(
      applyChoices(
        parsed,
        [{ kind: "text", text: mine }, { kind: "theirs" }],
        labels,
      ),
    ).toBe(`top\n${mine}mid\ndos\nend\n`);
    expect(
      applyChoices(parsed, [{ kind: "ours" }, { kind: "text", text: "" }], labels),
    ).toBe("top\none\nmid\nend\n");
  });
  test("an open block shows markers named by branch; an unclosed one is kept", () => {
    const out = applyChoices(parseConflicts(FILE), [undefined, { kind: "ours" }], labels);
    expect(out).toContain("<<<<<<< main\none\n=======\nuno\n>>>>>>> loud\n");
    const broken = "a\n<<<<<<< x\nb\n";
    expect(applyChoices(parseConflicts(broken), [], labels)).toBe(broken);
  });
  test("the query becomes choices; box text ends in a newline", () => {
    const q = new URLSearchParams("b0=both&b1=text&t1=hi%0D%0Athere&b2=nope");
    expect(choicesFrom(q, 3)).toEqual([
      { kind: "both" },
      { kind: "text", text: "hi\nthere\n" },
      undefined,
    ]);
    // Words with no tap picked are the person's own text.
    expect(choicesFrom(new URLSearchParams("t0=typed&b1=ours&t1=&t2="), 3)).toEqual([
      { kind: "text", text: "typed\n" },
      { kind: "ours" },
      undefined,
    ]);
  });
});
describe("the Resolve page", () => {
  const gitEnv = gitClientEnv();
  let dataDir: string;
  let work: string;
  let app: App;
  let servers: Servers;
  let base: string;
  let dir: string;
  let headers: Record<string, string>;
  async function git(args: string[]): Promise<void> {
    const p = Bun.spawn(["git", ...args], {
      cwd: dir,
      env: gitEnv,
      stdout: "ignore",
      stderr: "pipe",
    });
    const [err, code] = await Promise.all([new Response(p.stderr).text(), p.exited]);
    if (code !== 0) throw new Error(`git ${args.join(" ")}: ${err}`);
  }
  const commit = async (text: string, message: string) => {
    await Bun.write(join(dir, "code.txt"), text);
    await git(["commit", "-am", message]);
  };
  beforeAll(async () => {
      
        sentinelcrew
        29d ago
        
      
      No timeout on this beforeAll. It takes about 6 s locally and fails under bun test's 5 s default. Pass 120_000 as the TUI suite does.
    
    dataDir = await mkdtemp(join(tmpdir(), "forge-cf-"));
    work = await mkdtemp(join(tmpdir(), "forge-cf-work-"));
    app = createApp({ dataDir, port: 0 });
    servers = await serve(app);
    base = servers.url;
    await fetch(`${base}/signup`, {
      method: "POST",
      body: new URLSearchParams({
        username: "dev",
        email: "[email protected]",
        password: "conflicts-pass-123",
      }),
      redirect: "manual",
    });
    const token = await fetch(`${base}/api/v1/tokens`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        adminConfirm: true,
        username: "dev",
        password: "conflicts-pass-123",
        name: "cli",
        scope: "rw",
      }),
    })
      .then((r) => r.json())
      .then((j) => (j as { token: string }).token);
    headers = { authorization: `Bearer ${token}`, "content-type": "application/json" };
    await fetch(`${base}/api/v1/repos`, {
      method: "POST",
      headers,
      body: JSON.stringify({ name: "app", visibility: "public" }),
    });
    dir = work;
    await git(["clone", `${base.replace("http://", `http://dev:${token}@`)}/dev/app.git`, "app"]);
    dir = join(work, "app");
    const lines = (a: string, b: string) => `x\n${a}\nm1\nm2\nm3\nm4\nm5\nm6\n${b}\ny\n`;
    await Bun.write(join(dir, "code.txt"), lines("a", "b"));
    await git(["add", "."]);
    await git(["commit", "-m", "base"]);
    await git(["push", "origin", "main"]);
    await git(["checkout", "-b", "loud"]);
    await commit(lines("A-loud", "B-loud"), "loud");
    await git(["push", "origin", "loud"]);
    await fetch(`${base}/api/v1/repos/dev/app/pulls`, {
      method: "POST",
      headers,
      body: JSON.stringify({ base: "main", head: "loud", title: "Loud" }),
    });
    await git(["checkout", "main"]);
    await commit(lines("A-main", "B-main"), "main");
    await git(["push", "origin", "main"]);
  }, 120_000);
  afterAll(async () => {
    servers.stop();
    app.close();
    await rm(dataDir, { recursive: true, force: true });
    await rm(work, { recursive: true, force: true });
  });
  test("shows the count and the merged file for the chosen blocks", async () => {
    const url = `${base}/dev/app/pulls/1/resolve`;
    const none = await (await fetch(url, { headers })).text();
    expect(none).toContain("0 of 2 resolved");
    expect(none).toContain("&lt;&lt;&lt;&lt;&lt;&lt;&lt; main");
    const res = await fetch(`${url}?file=code.txt&b0=both&b1=text&t1=mine%0A`, { headers });
    expect(res.status).toBe(200);
    const page = await res.text();
    expect(page).toContain("2 of 2 resolved");
    expect(page).toContain("A-main\nA-loud\n");
    expect(page).toContain("m6\nmine\ny\n");
  });
  test("readers and strangers do not get it; an unnamed file is not read", async () => {
    const url = `${base}/dev/app/pulls/1/resolve`;
    expect((await fetch(url)).status).toBe(404);
      
        sentinelcrew
        29d ago
        
      
      Low: on the web, only an anonymous visitor is shown to get a 404. A signed-in reader (a second account that is not a collaborator) should be checked too, the way the terminal test checks carol. The gate is correct today; this test would catch it if canWrite were ever loosened to canRead.
    
    const odd = await (await fetch(`${url}?file=../../etc/passwd`, { headers })).text();
    expect(odd).toContain("Nothing to resolve");
    expect(odd).toContain("not one of the conflicted files");
    expect(odd).not.toContain("has no conflicts");
  });
  test("the merge box offers Resolve to a writer", async () => {
    const files = await (await fetch(`${base}/dev/app/pulls/1/files`, { headers })).text();
    expect(files).toContain('href="/dev/app/pulls/1/resolve"');
  });
});
		@@ -213,6 +213,8 @@ git objects; anything you then do here is written through to the origin
213	213	first and reflected locally after it succeeds. For a mirror the origin is
214	214	truth, exactly as git is truth for a native repo.
215	215
	216	Resolving a conflicted pull. When a pull conflicts with its base, a writer sees Resolve in the "Can't merge" box, which opens `/:owner/:name/pulls/:n/resolve`: one file at a time, each conflict block a card with the two sides named by their branch and the taps Ours, Theirs, Both and Mine (words typed in the box count as Mine), a running "2 of 3 resolved", and the merged file beneath. The choices ride in the query string; nothing is written to git yet (committing the result is a later part). In the terminal, `v` on a conflicted pull does the same: `n`/`p` move over the blocks, `o`/`t`/`b` take ours, theirs or both, `e` opens a box for your own text, and each file shows "N of M resolved" with its merged file beneath. Readers and guests get neither.
	217
216	218	A pull from an outsider's fork on the origin is someone else's code, so its
217	219	check and preview wait. A person with write access lets that exact head run:
218	220	on the pull page, Approve to run here; in the terminal, `A` on the pull
		@@ -28,6 +28,8 @@ export type Exclusion = {
28	28
29	29	export const GATE: readonly string[] = [
30	30	"test/domain-drill.test.ts",
	31	"test/conflicts.test.ts",
	32	"test/conflicts-tui.test.ts",
31	33	"test/accounts-retire.test.ts",
32	34	"test/client-home.test.ts",
33	35	"test/cloud-use.test.ts",
		@@ -0,0 +1,44 @@
	1	/**
	2	* Reading a conflicted pull's blocks, for any surface that shows them. A
	3	* writer only (the same rule as the Resolve page); it reads, it writes nothing.
	4	*/
	5
	6	import type { App } from "../app.ts";
	7	import { canWrite, type Repo } from "../core/repos.ts";
	8	import { pullDir, pullStatus, type Pull } from "../core/pulls.ts";
	9	import type { User } from "../core/users.ts";
	10	import { readConflictedFiles } from "../git/conflict-file.ts";
	11	import { parseConflicts, type Block, type Conflicted } from "../git/conflicts.ts";
	12	import { err, ok, type Result } from "../kernel/result.ts";
	13
	14	export interface ConflictedFile {
	15	readonly path: string;
	16	readonly blocks: readonly Block[];
	17	/** The file cut into text and blocks, for applying choices. */
	18	readonly parsed: Conflicted;
	19	}
	20
	21	export interface PullConflicts {
	22	/** The base branch's side, and the pull branch's. */
	23	readonly ours: string;
	24	readonly theirs: string;
	25	readonly files: readonly ConflictedFile[];
	26	}
	27
	28	export async function pullConflicts(
	29	app: App,
	30	actor: User \| undefined,
	31	repo: Repo,
	32	pull: Pull,
	33	): Promise<Result<PullConflicts, "forbidden">> {
	34	if (!canWrite(app.db, repo, actor)) return err("forbidden");
	35	const dir = await pullDir(app.db, app.reposRoot, repo, pull);
	36	const status = await pullStatus(dir, pull);
		sentinelcrew 29d ago outdated Each iteration reruns the whole merge in `readConflictedFile`. Run the merge once and read every path from the tree it wrote.
	37	const files: ConflictedFile[] = [];
	38	const texts = await readConflictedFiles(dir, status.baseOid, status.headOid, status.conflicts);
	39	for (const path of status.conflicts) {
	40	const parsed = parseConflicts(texts.get(path) ?? "");
	41	files.push({ path, blocks: parsed.blocks, parsed });
	42	}
	43	return ok({ ours: pull.baseBranch, theirs: pull.headBranch, files });
	44	}
		@@ -0,0 +1,53 @@
	1	/**
	2	* One conflicted file as git leaves it: `merge-tree --write-tree` run over
	3	* the two sides with `diff3` markers, then the file read out of the tree it
	4	* wrote. Reads only; the objects it writes are unreachable and swept by gc.
	5	*/
	6
	7	import { runGitCapture } from "./env.ts";
	8	import { isSafeOid, isSafeTreePath } from "./guard.ts";
	9
	10	const MAX_BYTES = 1_000_000;
	11
	12	export async function readConflictedFile(
	13	dir: string,
	14	ours: string,
	15	theirs: string,
	16	path: string,
	17	): Promise<string \| undefined> {
	18	return (await readConflictedFiles(dir, ours, theirs, [path])).get(path);
	19	}
	20
	21	/** Several files from one merge: the merge runs once, each path is read from its tree. */
	22	export async function readConflictedFiles(
	23	dir: string,
	24	ours: string,
	25	theirs: string,
	26	paths: readonly string[],
	27	): Promise<Map<string, string>> {
	28	const out = new Map<string, string>();
	29	if (!isSafeOid(ours) \|\| !isSafeOid(theirs) \|\| paths.length === 0) return out;
	30	const merged = await runGitCapture(
	31	[
	32	"-c",
	33	"merge.conflictStyle=diff3",
	34	"merge-tree",
	35	"--write-tree",
	36	"--name-only",
	37	ours,
	38	theirs,
	39	],
	40	{ cwd: dir, timeoutMs: 60_000 },
	41	);
	42	if (merged.code !== 1) return out;
	43	const tree = merged.stdout.split("\n")[0]!.trim();
	44	if (!isSafeOid(tree)) return out;
	45	for (const path of paths) {
	46	if (!isSafeTreePath(path)) continue;
	47	const blob = await runGitCapture(["cat-file", "blob", `${tree}:${path}`], {
	48	cwd: dir,
	49	});
	50	if (blob.code === 0 && blob.stdout.length <= MAX_BYTES) out.set(path, blob.stdout);
		sentinelcrew 29d ago Low: the 1 MB cap is checked after `cat-file` has buffered the whole blob into memory. Checking `cat-file -s` first, or skipping paths whose size is over the cap, would keep a huge conflicted file out of memory completely.
	51	}
	52	return out;
	53	}
		@@ -0,0 +1,128 @@
	1	/**
	2	* Conflict blocks, read and chosen. Pure: the text of a file as
	3	* `git merge-tree --write-tree` leaves it (conflict markers in `diff3` style,
	4	* so each block carries its base) goes in; blocks come out, and a list of
	5	* choices turns them back into the merged file. Nothing here touches git.
	6	*/
	7
	8	export type Part =
	9	\| { readonly kind: "text"; readonly text: string }
	10	\| {
	11	readonly kind: "block";
	12	/** The common ancestor's lines; empty when the file was not diff3. */
	13	readonly base: string;
	14	/** The base branch's side. */
	15	readonly ours: string;
	16	/** The pull branch's side. */
	17	readonly theirs: string;
	18	};
	19
	20	export interface Block {
	21	readonly base: string;
	22	readonly ours: string;
	23	readonly theirs: string;
	24	}
	25
	26	export type Choice =
	27	\| { readonly kind: "ours" }
	28	\| { readonly kind: "theirs" }
	29	\| { readonly kind: "both" }
	30	\| { readonly kind: "text"; readonly text: string };
	31
	32	export interface Conflicted {
	33	readonly parts: readonly Part[];
	34	readonly blocks: readonly Block[];
	35	}
	36
	37	export interface Labels {
	38	readonly ours: string;
	39	readonly theirs: string;
	40	}
	41
	42	const lines = (text: string): string[] => text.split(/(?<=\n)/);
	43
	44	/** Cut a conflicted file into plain text and conflict blocks. */
	45	export function parseConflicts(text: string): Conflicted {
	46	const parts: Part[] = [];
	47	const blocks: Block[] = [];
	48	let plain = "";
	49	let state: "text" \| "ours" \| "base" \| "theirs" = "text";
	50	let ours = "";
	51	let base = "";
	52	let theirs = "";
	53	let raw = ""; // the block as written, to give back if it never closes
	54	for (const line of lines(text)) {
	55	const bare = line.replace(/\r?\n$/, "");
	56	if (state === "text") {
	57	if (/^<{7}( \|$)/.test(bare)) {
	58	state = "ours";
	59	raw = line;
	60	ours = base = theirs = "";
	61	} else plain += line;
	62	continue;
	63	}
	64	raw += line;
	65	if (state === "ours" && /^\\|{7}( \|$)/.test(bare)) state = "base";
	66	else if ((state === "ours" \|\| state === "base") && /^={7}$/.test(bare))
	67	state = "theirs";
	68	else if (state === "theirs" && /^>{7}( \|$)/.test(bare)) {
	69	if (plain !== "") parts.push({ kind: "text", text: plain });
	70	plain = "";
	71	const block = { base, ours, theirs };
	72	parts.push({ kind: "block", ...block });
	73	blocks.push(block);
	74	state = "text";
	75	} else if (state === "ours") ours += line;
	76	else if (state === "base") base += line;
	77	else theirs += line;
	78	}
	79	// An unclosed block is not a block: keep what was written.
	80	plain += state === "text" ? "" : raw;
	81	if (plain !== "") parts.push({ kind: "text", text: plain });
	82	return { parts, blocks };
	83	}
	84
	85	/**
	86	* The file with each block settled by its choice. A block with no choice
	87	* (`undefined`) is written back as conflict markers, named by `labels`, so
	88	* the merged file shows what is still open. Text is kept verbatim.
	89	*/
	90	export function applyChoices(
	91	conflicted: Conflicted,
	92	choices: readonly (Choice \| undefined)[],
	93	labels: Labels,
	94	): string {
	95	let out = "";
	96	let at = 0;
	97	for (const part of conflicted.parts) {
	98	if (part.kind === "text") {
	99	out += part.text;
	100	continue;
	101	}
	102	const choice = choices[at++];
	103	if (choice === undefined) out += markers(part, labels);
	104	else if (choice.kind === "ours") out += part.ours;
	105	else if (choice.kind === "theirs") out += part.theirs;
	106	else if (choice.kind === "both") out += part.ours + part.theirs;
	107	else out += choice.text;
	108	}
	109	return out;
	110	}
	111
	112	function markers(block: Block, labels: Labels): string {
	113	const nl = (s: string): string => (s === "" \|\| s.endsWith("\n") ? s : s + "\n");
	114	return (
	115	`<<<<<<< ${labels.ours}\n${nl(block.ours)}` +
	116	`=======\n${nl(block.theirs)}>>>>>>> ${labels.theirs}\n`
	117	);
	118	}
	119
	120	/** How many of the choices settle a block. */
	121	export function resolvedCount(
	122	choices: readonly (Choice \| undefined)[],
	123	total: number,
	124	): number {
	125	let n = 0;
	126	for (let i = 0; i < total; i++) if (choices[i] !== undefined) n++;
	127	return n;
	128	}
		@@ -295,6 +295,7 @@ import {
295	295	pullThreadFragment,
296	296	threadResolveSubmit,
297	297	} from "../web/pages/pull.ts";
	298	import { conflictsPage } from "../web/pages/conflicts.ts";
298	299	import {
299	300	appDisable,
300	301	appMembersUpdate,
		@@ -988,6 +989,7 @@ export function buildRouter(): Router<Handler> {
988	989	// The change's Files step: the diff, the review threads and the merge
989	990	// box, one tab under the change itself.
990	991	router.add("GET", "/:owner/:name/pulls/:number/files", pullFilesPage);
	992	router.add("GET", "/:owner/:name/pulls/:number/resolve", conflictsPage);
991	993	router.add("GET", "/:owner/:name/pulls/:number/thread", pullThreadFragment);
992	994	router.add("GET", "/:owner/:name/pulls/:number/state", pullStateFragment);
993	995	router.add("POST", "/:owner/:name/pulls/:number/comments", pullCommentSubmit);
		@@ -0,0 +1,149 @@
	1	/**
	2	* A conflicted pull's blocks in the terminal, the page's twin: a cursor over
	3	* the blocks, `o`/`t`/`b` to take ours, theirs or both, `e` for your own
	4	* text, and per file "N of M resolved" with the merged file beneath. Nothing
	5	* is written to git; the choices live in this screen only.
	6	*/
	7
	8	import type { PullConflicts } from "../../actions/conflicts.ts";
	9	import {
	10	applyChoices,
	11	resolvedCount,
	12	type Choice,
	13	} from "../../git/conflicts.ts";
	14	import type { Ctx, Screen } from "../app/app.ts";
	15	import { binding } from "../app/keys.ts";
	16	import { style } from "../term/style.ts";
	17	import { fill, len, split } from "../ui/layout.ts";
	18	import { Scroll, drawLines, hitScroll, plural } from "./common.ts";
	19	import { Composer } from "./thread.ts";
	20
	21	type Line = { text: string; style: ReturnType<typeof style> }[];
	22
	23	const NAMES = { ours: "Ours", theirs: "Theirs", both: "Both", text: "Mine" };
	24
	25	export function conflictScreen(ctx: Ctx, read: PullConflicts): Screen {
	26	const scroll = new Scroll();
	27	const composer = new Composer();
		sentinelcrew 29d ago outdated This is the parity gap: the terminal reads but cannot choose. Add `o`/`t`/`b` (and `e` for own text) on a block cursor, plus the count and the `applyChoices` merged file, so the terminal does what the page does.
	28	/** choices[file][block] */
	29	const choices: (Choice \| undefined)[][] = read.files.map((f) =>
	30	f.blocks.map(() => undefined),
	31	);
	32	const flat = read.files.flatMap((f, fi) => f.blocks.map((_, bi) => [fi, bi] as const));
	33	let at = 0;
	34	/** The line each block's header sits on, for keeping the cursor in view. */
	35	let heads: number[] = [];
	36
	37	const rows = (side: string, max = 12): string[] =>
	38	side.split("\n").slice(0, side.endsWith("\n") ? -1 : undefined).slice(0, max);
	39
	40	const lines = (): Line[] => {
	41	const c = ctx.theme.c;
	42	const plain = style(c.fg, c.bg);
	43	const muted = style(c.mutedFg, c.bg);
	44	const out: Line[] = [];
	45	heads = [];
	46	const say = (text: string, st = plain): void => {
	47	out.push([{ text, style: st }]);
	48	};
	49	const total = flat.length;
	50	say(`${plural(total, "conflict block")} in ${plural(read.files.length, "file")}`);
	51	say("n/p block · o ours · t theirs · b both · e your own text · nothing is written to git", muted);
	52	let n = 0;
	53	read.files.forEach((file, fi) => {
	54	const mine = choices[fi]!;
	55	say("");
	56	say(
	57	`${file.path} · ${resolvedCount(mine, file.blocks.length)} of ${file.blocks.length} resolved`,
	58	);
	59	if (file.blocks.length === 0)
	60	say(" no text blocks to choose between", muted);
	61	file.blocks.forEach((block, bi) => {
	62	const here = n === at;
	63	const pick = mine[bi];
	64	heads[n++] = out.length;
	65	say(
	66	`${here ? "▸" : " "} block ${bi + 1} of ${file.blocks.length}${pick ? ` · ${NAMES[pick.kind]}` : ""}`,
	67	here ? plain : muted,
	68	);
	69	for (const [name, side] of [
	70	[read.ours, block.ours],
	71	[read.theirs, block.theirs],
	72	] as const) {
	73	say(` ${name}`, muted);
	74	for (const row of rows(side)) say(` ${row}`);
	75	}
	76	});
	77	if (file.blocks.length > 0) {
	78	say(" Merged file", muted);
	79	const merged = applyChoices(file.parsed, mine, {
	80	ours: read.ours,
	81	theirs: read.theirs,
	82	});
	83	for (const row of rows(merged, 200))
	84	say(` ${row}`);
	85	}
	86	});
	87	return out;
	88	};
	89
	90	const set = (choice: Choice): void => {
	91	const target = flat[at];
	92	if (target) choices[target[0]]![target[1]] = choice;
	93	};
	94	const move = (by: number): void => {
	95	if (flat.length === 0) return;
	96	at = Math.max(0, Math.min(flat.length - 1, at + by));
	97	const all = lines();
	98	scroll.to(heads[at] ?? 0, all.length);
	99	};
	100
	101	return {
	102	title: "Conflicts",
	103	keys: [
	104	binding(["n", "p"], "block"),
	105	binding(["o", "t", "b"], "ours / theirs / both"),
	106	binding(["e"], "your text"),
	107	binding(["j", "k"], "scroll"),
	108	binding(["esc", "q"], "back"),
	109	],
	110	load: () => Promise.resolve(),
	111	render(area, s) {
	112	const [body, comp] = split(area, "v", [fill(1), len(composer.height())]);
	113	const all = lines();
	114	drawLines(s, body!, ctx.theme.c, scroll, all);
	115	hitScroll(ctx, body!, scroll, all.length);
	116	if (composer.height() > 0) composer.render(s, comp!, ctx.theme.c, ctx);
	117	},
	118	paste: (text) => composer.paste(text),
	119	key(e) {
	120	if (composer.open) {
	121	const out = composer.key(e);
	122	if (out === "submit") {
	123	const text = composer.value.replace(/\r\n?/g, "\n");
	124	set({ kind: "text", text: text === "" \|\| text.endsWith("\n") ? text : text + "\n" });
	125	composer.close();
	126	} else if (out === "cancel") composer.close();
	127	return true;
	128	}
	129	if (e.key === "esc" \|\| e.key === "q") {
	130	ctx.pop();
	131	return true;
	132	}
	133	if (!e.ctrl && !e.alt && flat.length > 0) {
	134	if (e.key === "n") return move(1), true;
	135	if (e.key === "p") return move(-1), true;
	136	if (e.key === "o") return set({ kind: "ours" }), true;
	137	if (e.key === "t") return set({ kind: "theirs" }), true;
	138	if (e.key === "b") return set({ kind: "both" }), true;
	139	if (e.key === "e") {
	140	const target = flat[at]!;
	141	const was = choices[target[0]]![target[1]];
	142	composer.start("Your text", was?.kind === "text" ? was.text : "");
	143	return true;
	144	}
	145	}
	146	return scroll.key(e, lines().length);
	147	},
	148	};
	149	}
		@@ -102,6 +102,8 @@ import {
102	102	import { assignPicker, assignedText } from "./assign.ts";
103	103	import { DiffView, type DiffAnchor, type DiffNote } from "./commits.ts";
104	104	import { liveBindings, liveKey } from "./mirror.ts";
	105	import { pullConflicts } from "../../actions/conflicts.ts";
	106	import { conflictScreen } from "./conflicts.ts";
105	107	import { reviewScreen } from "./review.ts";
106	108	import { RunList, openRunLog, runTone } from "./runlist.ts";
107	109	import { Composer, threadLines, type ThreadEntry } from "./thread.ts";
		@@ -632,6 +634,22 @@ export function pullScreen(
632	634	});
633	635	};
634	636
	637	/** `v` — the conflict blocks, read; `pullConflicts` holds the writer gate. */
	638	const seeConflicts = (): void => {
	639	if (repo === undefined) return;
	640	const target = repo;
	641	const row = getPull(f.db, target.id, number);
	642	if (row === undefined) return;
	643	runAsync(ctx, async () => {
	644	const read = await pullConflicts(f.app, f.user, target, row);
	645	if (!read.ok) {
	646	ctx.toast(errorText(read.error), "danger");
	647	return;
	648	}
	649	ctx.push(conflictScreen(ctx, read.value));
	650	});
	651	};
	652
635	653	const mirrored = (): boolean => repo === undefined \|\| repo.origin !== null;
636	654	const state = (): MergeState =>
637	655	mergeState(detail?.issue, facts, mirrored(), gated(), checksGated());
		@@ -662,6 +680,9 @@ export function pullScreen(
662	680	? [binding(["A"], "approve to run here")]
663	681	: []),
664	682	binding(["a"], "assign"),
	683	...(state() === "conflicts"
	684	? [binding(["v"], "see the conflict blocks")]
	685	: []),
665	686	binding(["m"], "merge", { disabled: state() !== "ready" }),
666	687	...(tab === 1 && view.threadHere() !== null
667	688	? [
		@@ -875,6 +896,10 @@ export function pullScreen(
875	896	assign();
876	897	return true;
877	898	}
	899	if (e.key === "v" && mayWrite() && state() === "conflicts") {
	900	seeConflicts();
	901	return true;
	902	}
878	903	// The crew tab is a list: the cursor moves, enter opens the run.
879	904	if (tab === 2) {
880	905	if (crew.state.key(e, crew.runs.length)) return true;
		@@ -0,0 +1,183 @@
	1	/**
		sentinelcrew 29d ago This door is the page only. The terminal's pull screen lists the conflicted files but can't open them. Give it the same read, gated the same way, with a test. Also add a README entry.
	2	* GET /:owner/:name/pulls/:number/resolve — a conflicted pull, one file at a
	3	* time. Each conflict block is a card: the two sides named by their branch,
	4	* three taps (ours, theirs, both) and a text box for your own words. The
	5	* choices travel in the query string, so the page keeps no state and writes
	6	* nothing to git; it shows the running count and the merged file beneath.
	7	* Writers only.
	8	*/
	9
	10	import { canWrite } from "../../core/repos.ts";
	11	import { pullDir, pullStatus } from "../../core/pulls.ts";
	12	import { readConflictedFile } from "../../git/conflict-file.ts";
	13	import {
	14	applyChoices,
	15	parseConflicts,
	16	resolvedCount,
	17	type Choice,
	18	} from "../../git/conflicts.ts";
	19	import type { Ctx } from "../../http/context.ts";
	20	import { crumbsFor, notFoundPage, repoBase, repoPalette, repoHeader } from "../chrome.ts";
	21	import { html, type Html } from "../html.ts";
	22	import { page } from "../layout.ts";
	23	import { btn, card, icon } from "../ui.ts";
	24	import { changeHead, changeTabs, pullContext } from "../studio/change.ts";
	25
	26	/** More blocks or longer words than this are not a hand's work. */
	27	export const MAX_BLOCKS = 500;
	28	export const MAX_TEXT = 20_000;
	29
	30	/**
	31	* The choices a query carries: `b<i>` is ours, theirs, both or text, and
	32	* `t<i>` the words for text. Anything else leaves the block open. A box's
	33	* words end in a newline, as a line of a file does, unless they are empty.
	34	*/
	35	export function choicesFrom(
	36	params: URLSearchParams,
	37	total: number,
	38	): (Choice \| undefined)[] {
	39	const out: (Choice \| undefined)[] = [];
	40	for (let i = 0; i < Math.min(total, MAX_BLOCKS); i++) {
	41	// Words in the box with no tap picked are "Mine": typing is the choice.
	42	const typed = (params.get(`t${i}`) ?? "") !== "";
	43	const kind = params.get(`b${i}`) ?? (typed ? "text" : null);
	44	if (kind === "ours" \|\| kind === "theirs" \|\| kind === "both")
	45	out.push({ kind });
	46	else if (kind === "text") {
	47	let text = (params.get(`t${i}`) ?? "").replace(/\r\n?/g, "\n");
	48	if (text.length > MAX_TEXT) text = text.slice(0, MAX_TEXT);
	49	out.push({
	50	kind: "text",
	51	text: text === "" \|\| text.endsWith("\n") ? text : text + "\n",
		sentinelcrew 29d ago outdated If `b<i>` is missing but `t<i>` has text, the person's words are thrown away. Typing in the box is the clearest sign of 'Mine', so treat a non-empty `t<i>` as `{kind: "text"}` when no tap is picked, and add a test for it.
	52	});
	53	} else out.push(undefined);
	54	}
	55	return out;
	56	}
	57
	58	const CSS = `
	59	.rs-list { display: grid; gap: 12px; margin-top: 12px; }
	60	.rs-card { content-visibility: auto; contain-intrinsic-size: auto 260px; }
	61	.rs-sides { display: grid; gap: 8px; grid-template-columns: repeat(auto-fit, minmax(min(100%, 240px), 1fr)); }
	62	.rs-side { min-width: 0; }
	63	.rs-side pre, .rs-merged { margin: 4px 0 0; padding: 8px; overflow: auto; max-height: 12em; font-size: 12px; white-space: pre; background: var(--muted-bg, transparent); border: 1px solid var(--border, #8884); border-radius: 6px; }
	64	.rs-merged { max-height: 32em; }
	65	.rs-taps { display: flex; gap: 6px; flex-wrap: wrap; margin: 8px 0; }
	66	.rs-taps label { flex: 1 1 0; text-align: center; padding: 8px 6px; min-height: 40px; border: 1px solid var(--border, #8884); border-radius: 6px; cursor: pointer; }
	67	.rs-taps input { position: absolute; opacity: 0; pointer-events: none; }
	68	.rs-taps label:has(input:checked) { font-weight: 600; border-color: currentColor; }
	69	.rs-taps label:has(input:focus-visible) { outline: 2px solid currentColor; }
	70	.rs-text { width: 100%; min-height: 3.5em; font-family: monospace; }
	71	`;
	72
	73	export async function conflictsPage(ctx: Ctx): Promise<Response> {
	74	const found = pullContext(ctx);
	75	if (found instanceof Response) return found;
	76	const { repo, pull } = found;
	77	if (!canWrite(ctx.app.db, repo, ctx.auth.user)) return notFoundPage(ctx);
	78	const base = repoBase(repo);
	79	const back = `${base}/pulls/${pull.number}/files`;
	80	const dir = await pullDir(ctx.app.db, ctx.app.reposRoot, repo, pull);
	81	const status = await pullStatus(dir, pull);
	82	const files = status.conflicts;
	83	const asked = ctx.url.searchParams.get("file") ?? "";
	84	// Only a path git itself named is read; the rest of the world is a 404.
	85	const file = asked === "" ? files[0] : files.find((f) => f === asked);
	86	const unknown = asked !== "" && file === undefined && files.length > 0;
	87	if (pull.state !== "open" \|\| file === undefined) {
	88	return page({
	89	ctx,
	90	title: `Resolve · ${pull.title}`,
	91	crumbs: crumbsFor(repo),
	92	palette: repoPalette(ctx, repo),
	93	body: html`${repoHeader(ctx, repo, "pulls", { compact: true, ownTitle: true })}
	94	${changeHead(ctx, repo, pull)}${changeTabs(repo, pull, "files")}
	95	${card(
		sentinelcrew 29d ago outdated Reached for an unknown `?file=` on a pull that does conflict, so "has no conflicts" is false there. Word it for that case, or fall back to `files[0]`.
	96	html`<p>${unknown && pull.state === "open"
	97	? "Nothing to resolve there: that file is not one of the conflicted files."
	98	: "Nothing to resolve: this pull has no conflicts."}
	99	<a href="${back}">Back to the files</a>.</p>`,
	100	)}`,
	101	});
	102	}
	103
	104	const text = await readConflictedFile(dir, status.baseOid, status.headOid, file);
	105	const parsed = parseConflicts(text ?? "");
	106	const choices = choicesFrom(ctx.url.searchParams, parsed.blocks.length);
	107	const labels = { ours: pull.baseBranch, theirs: pull.headBranch };
	108	const done = resolvedCount(choices, parsed.blocks.length);
	109	const total = parsed.blocks.length;
	110	const merged = applyChoices(parsed, choices, labels);
	111	const here = `${base}/pulls/${pull.number}/resolve`;
	112
	113	const cards: Html[] = parsed.blocks.slice(0, MAX_BLOCKS).map((block, i) => {
	114	const pick = choices[i]?.kind;
	115	const tap = (kind: string, label: string): Html =>
	116	html`<label
	117	><input type="radio" name="b${i}" value="${kind}" ${pick === kind ? html`checked` : ""} />${label}</label
	118	>`;
	119	const own = choices[i];
	120	return card(
	121	html`<div class="rs-sides">
	122	<div class="rs-side">
	123	<strong class="small mono">${pull.baseBranch}</strong>
	124	<pre>${block.ours}</pre>
	125	</div>
	126	<div class="rs-side">
	127	<strong class="small mono">${pull.headBranch}</strong>
	128	<pre>${block.theirs}</pre>
	129	</div>
	130	</div>
	131	${block.base === ""
	132	? ""
	133	: html`<details><summary class="small muted">Before either changed it</summary><pre class="rs-merged">${block.base}</pre></details>`}
	134	<div class="rs-taps">
	135	${tap("ours", `Ours`)}${tap("theirs", `Theirs`)}${tap("both", "Both")}${tap("text", "Mine")}
	136	</div>
	137	<textarea class="rs-text" name="t${i}" rows="3" maxlength="${MAX_TEXT}"
	138	aria-label="Your own text for block ${i + 1}">${own?.kind === "text" ? own.text : ""}</textarea>`,
	139	{
	140	extra: "rs-card",
	141	head: html`<h2>Block ${i + 1} of ${total}</h2>`,
	142	},
	143	);
	144	});
	145
	146	const body = html`${repoHeader(ctx, repo, "pulls", { compact: true, ownTitle: true })}
	147	${changeHead(ctx, repo, pull)}${changeTabs(repo, pull, "files")}
	148	<p class="muted small mt">
	149	<a href="${back}">← Files</a> · <span class="mono">${file}</span> ·
	150	<strong id="rs-count">${done} of ${total} resolved</strong>
	151	· nothing is written to git
	152	</p>
	153	${files.length > 1
	154	? html`<p class="small">
	155	${files.map((f) =>
	156	f === file
	157	? html`<strong class="mono">${f}</strong> `
	158	: html`<a class="mono" href="${here}?file=${encodeURIComponent(f)}">${f}</a> `,
	159	)}
	160	</p>`
	161	: ""}
	162	${total === 0
	163	? card(
	164	html`<p>This file has no text blocks to choose between (it may be
	165	deleted on one side). Resolve it in your own checkout.</p>`,
	166	)
	167	: html`<form method="get" action="${here}">
	168	<input type="hidden" name="file" value="${file}" />
	169	<div class="rs-list">${cards}</div>
	170	<p class="mt">${btn("Update the merged file", { icon: "check" })}</p>
	171	</form>`}
	172	<h2 class="mt">Merged file</h2>
	173	<pre class="rs-merged" aria-label="Merged ${file}">${merged}</pre>`;
	174
	175	return page({
	176	ctx,
	177	title: `Resolve · ${pull.title} · ${repo.name}`,
	178	crumbs: crumbsFor(repo),
	179	palette: repoPalette(ctx, repo),
	180	body,
	181	styleCss: CSS,
	182	});
	183	}
		@@ -414,7 +414,9 @@ function mergeBox(
414	414	>${status.conflicts.slice(0, 3).join(", ")}</span
415	415	>${status.conflicts.length > 3 ? "…" : ""}. Merge
416	416	<span class="mono">${pull.baseBranch}</span> into the branch and
417		push again.`
	417	push again.${mayMerge
	418	? html` <a href="${thread}/resolve">Resolve</a> it here.`
	419	: ""}`
418	420	: html`This branch cannot be applied automatically.`;
419	421	return card(
420	422	html`${icon("alert")}