heyquilt 0.3.121 → 0.3.138

package/src/quilts/conflict-format.js

@@ -1,190 +0,0 @@
-// 07's default conflict materialisation, `diff` (Jujutsu's style): inside each marker block one
-// side as a snapshot (`+++++++`), then each other side as a diff from its base (`%%%%%%%`). With
-// two sides (diff3), more sides on one base (an N-way merge, `nway`) or on different bases (each
-// side's change laid onto the first side, `ontoFirst`) only the clashing regions are marked and the
-// rest of the file is merged text; a deleted side is an empty side labelled "(deleted by <who>)". Also the `git` format (diff3 markers with the `|||||||` base section, two sides
-// only). Every block's first line carries the term's tag, so a
-// file committed with these markers is still conflicted (service.js, block.js).
-import { diff3Merge } from 'node-diff3'
-import { hunks, splitLines } from './textdiff.js'
-
-/** `old` → `now` as `-`/`+`/` ` lines (every line of both, in order). */
-export function lineDiff (old, now) {
-  const out = []
-  let i = 0
-  let j = 0
-  for (const h of hunks(old, now)) {
-    while (i < h.a[0]) { out.push(' ' + old[i++]); j++ }
-    for (let k = 0; k < h.a[1]; k++) out.push('-' + old[i++])
-    for (let k = 0; k < h.b[1]; k++) out.push('+' + now[j++])
-  }
-  while (i < old.length) { out.push(' ' + old[i++]); j++ }
-  return out
-}
-
-/**
- * The term as `diff` markers. `sides` are [{ text, label, by }] (adds, text null for a delete);
- * `bases` the removes' texts (bases[i] is the base of sides[i + 1]). `tag` is
- * `quilt-conflict <hash>`, `kind` the term kind.
- */
-export function diffMarkers ({ sides, bases, tag, kind }) {
-  const L = (t) => splitLines(t || '')
-  // Ruling (2026-10-24): a side that deleted the file, or the region, is an empty side labelled so.
-  const name = (s, lines, base) => s.text == null || (!lines.length && base && base.length) ? `${s.label} (deleted by ${s.by || 'someone'})` : s.label
-  const block = (snap, others) => [
-    `<<<<<<< ${tag} ${kind}`,
-    `+++++++ ${name(snap.side, snap.lines, snap.base)}`, ...snap.lines,
-    ...others.flatMap((o) => [`%%%%%%% ${name(o.side, o.lines, o.base)} (diff from base)`, ...lineDiff(o.base, o.lines)]),
-    `>>>>>>> ${tag}`
-  ]
-  const whole = () => block({ side: sides[0], lines: L(sides[0].text), base: L(bases[0]) },
-    sides.slice(1).map((s, i) => ({ side: s, base: L(bases[i]), lines: L(s.text) })))
-  if (sides.length < 2) return whole().join('\n') + '\n'
-  const out = []
-  let marked = false
-  if (sides.length === 2) {
-    for (const r of diff3Merge(L(sides[0].text), L(bases[0]), L(sides[1].text), { excludeFalseConflicts: true })) {
-      if (r.ok) { out.push(...r.ok); continue }
-      const c = r.conflict
-      marked = true
-      out.push(...block({ side: sides[0], lines: c.a, base: c.o }, [{ side: sides[1], base: c.o, lines: c.b }]))
-    }
-  } else {
-    const regions = bases.some((b) => (b || '') !== (bases[0] || '')) ? ontoFirst(L(sides[0].text), sides.slice(1).map((s, i) => ({ base: L(bases[i]), lines: L(s.text) }))) : null
-    if (regions) {
-      for (const r of regions) {
-        if (r.ok) { out.push(...r.ok); continue }
-        marked = true
-        out.push(...block({ side: sides[0], lines: r.snap }, sides.slice(1).map((s, i) => ({ side: s, base: r.others[i].base, lines: r.others[i].lines }))))
-      }
-    } else for (const r of nway(L(bases[0]), sides.map((s) => L(s.text)))) {
-      if (r.ok) { out.push(...r.ok); continue }
-      marked = true
-      out.push(...block({ side: sides[0], lines: r.sides[0], base: r.base }, sides.slice(1).map((s, i) => ({ side: s, base: r.base, lines: r.sides[i + 1] }))))
-    }
-  }
-  return (marked ? out : whole()).join('\n') + '\n'
-}
-
-/**
- * An N-way line merge of `sides` (arrays of lines) that all start from `base`: regions
- * `{ ok: lines }` where at most one distinct change touches the base lines, and
- * `{ base, sides }` where two sides changed the same (or touching) base lines differently.
- */
-export function nway (base, sides) {
-  const all = []
-  sides.forEach((lines, s) => { for (const h of hunks(base, lines)) all.push({ s, a0: h.a[0], a1: h.a[0] + h.a[1], d: h.b[1] - h.a[1] }) })
-  all.sort((x, y) => x.a0 - y.a0 || x.a1 - y.a1)
-  const groups = []
-  for (const h of all) {
-    const g = groups[groups.length - 1]
-    if (g && h.a0 <= g.hi) { g.hi = Math.max(g.hi, h.a1); g.hunks.push(h) } else groups.push({ lo: h.a0, hi: h.a1, hunks: [h] })
-  }
-  const shift = new Array(sides.length).fill(0) // each side's line offset before the current group
-  const out = []
-  let at = 0
-  const ok = (lines) => { if (lines.length) out.push({ ok: lines }) }
-  for (const g of groups) {
-    ok(base.slice(at, g.lo))
-    const changed = new Set(g.hunks.map((h) => h.s))
-    const slice = sides.map((lines, s) => {
-      const d = g.hunks.filter((h) => h.s === s).reduce((n, h) => n + h.d, 0)
-      const part = lines.slice(g.lo + shift[s], g.hi + shift[s] + d)
-      shift[s] += d
-      return part
-    })
-    const versions = new Set([...changed].map((s) => slice[s].join('\n') + '\u0000' + slice[s].length))
-    if (versions.size === 1) ok(slice[[...changed][0]])
-    else out.push({ base: base.slice(g.lo, g.hi), sides: slice })
-    at = g.hi
-  }
-  ok(base.slice(at))
-  return out
-}
-
-/** Maps line positions of `a` to `b` through their hunks; inside a changed run (or on an insertion), `lo` snaps to its start and `hi` to its end. */
-function mapper (a, b) {
-  const hs = hunks(a, b)
-  const at = (p, end) => {
-    let off = 0
-    for (const h of hs) {
-      const [a0, an] = h.a
-      if (end && p === a0 && an === 0) return h.b[0] + h.b[1] // an end on an insertion takes it in
-      if (p <= a0) return p + off
-      if (p < a0 + an) return end ? h.b[0] + h.b[1] : h.b[0]
-      off += h.b[1] - an
-    }
-    return p + off
-  }
-  return { hunks: hs, lo: (p) => at(p, false), hi: (p) => at(p, true) }
-}
-
-/**
- * Sides on different bases, each laid onto the first side (the snapshot): a side's change lands
- * where its base lines sit in the first side. Regions `{ ok: lines }` where at most one change
- * lands and it does not touch lines the first side changed from that base, and `{ snap, others }`
- * (each other side's base and text over the region) where they clash.
- */
-export function ontoFirst (first, others) {
-  const regions = []
-  others.forEach((o, i) => {
-    const toFirst = mapper(o.base, first)
-    const toSide = mapper(o.base, o.lines)
-    for (const h of toSide.hunks) {
-      let x0 = h.a[0]; let x1 = h.a[0] + h.a[1]; let clash = false
-      for (let grew = true; grew;) {
-        grew = false
-        for (const c of toFirst.hunks) {
-          const c0 = c.a[0]; const c1 = c.a[0] + c.a[1]
-          if (c0 > x1 || x0 > c1) continue
-          clash = true
-          if (c0 < x0 || c1 > x1) { x0 = Math.min(x0, c0); x1 = Math.max(x1, c1); grew = true }
-        }
-      }
-      regions.push({ i, lo: toFirst.lo(x0), hi: toFirst.hi(x1), clash, text: o.lines.slice(toSide.lo(x0), toSide.hi(x1)) })
-    }
-  })
-  regions.sort((x, y) => x.lo - y.lo || x.hi - y.hi)
-  const groups = []
-  for (const r of regions) {
-    const g = groups[groups.length - 1]
-    if (g && r.lo <= g.hi) { g.hi = Math.max(g.hi, r.hi); g.rs.push(r) } else groups.push({ lo: r.lo, hi: r.hi, rs: [r] })
-  }
-  const out = []
-  let at = 0
-  const ok = (lines) => { if (lines.length) out.push({ ok: lines }) }
-  for (const g of groups) {
-    ok(first.slice(at, g.lo))
-    const same = g.rs.every((r) => !r.clash && r.lo === g.lo && r.hi === g.hi && r.text.join('\n') === g.rs[0].text.join('\n') && r.text.length === g.rs[0].text.length)
-    if (same) ok(g.rs[0].text)
-    else {
-      out.push({
-        snap: first.slice(g.lo, g.hi),
-        others: others.map((o) => {
-          const back = mapper(first, o.base)
-          const fwd = mapper(o.base, o.lines)
-          const [b0, b1] = [back.lo(g.lo), back.hi(g.hi)]
-          return { base: o.base.slice(b0, b1), lines: o.lines.slice(fwd.lo(b0), fwd.hi(b1)) }
-        })
-      })
-    }
-    at = g.hi
-  }
-  ok(first.slice(at))
-  return out
-}
-
-/** The term as git's diff3 markers (07's `git` format): two sides, with the `|||||||` base. */
-export function gitMarkers ({ ours, base, theirs, tag }) {
-  const L = (t) => splitLines(t || '')
-  const name = (s, lines, o) => s.text == null || (!lines.length && o.length) ? `${s.label} (deleted by ${s.by || 'someone'})` : s.label
-  const block = (a, o, b) => [`<<<<<<< ${name(ours, a, o)} ${tag}`, ...a, `||||||| base ${tag}`, ...o, '=======', ...b, `>>>>>>> ${name(theirs, b, o)} ${tag}`]
-  const out = []
-  let marked = false
-  for (const r of diff3Merge(L(ours.text), L(base), L(theirs.text), { excludeFalseConflicts: true })) {
-    if (r.ok) { out.push(...r.ok); continue }
-    marked = true
-    out.push(...block(r.conflict.a, r.conflict.o, r.conflict.b))
-  }
-  return (marked ? out : block(L(ours.text), L(base), L(theirs.text))).join('\n') + '\n'
-}

package/src/quilts/describe.js

@@ -1,266 +0,0 @@
-// The server's records as plain English (plans/quilt-source-control/12, "Every write returns the
-// server's view"): one rendering for the CLI and both MCPs, so every tool says the same thing.
-
-const when = (ms) => (ms ? new Date(ms).toISOString().replace('T', ' ').slice(0, 16) + ' UTC' : '')
-const first = (m) => String(m || '').split('\n')[0]
-const patchName = (p) => (p ? `patch ${p.line}:${p.patch_no}` : '')
-
-export function describeSquare (s) {
-  const bits = [`${s.short} "${s.title}"`, s.state]
-  if (s.state === 'merged' && s.merged) bits.push(`as ${patchName(s.merged)}`)
-  if (s.state === 'open') {
-    bits.push(s.head ? `head ${s.head.slice(0, 12)}` : 'no commits yet')
-    if (s.on) bits.push(`stacked on ${s.on}`)
-    if (s.behind_by) bits.push(`${s.behind_by} patch${s.behind_by === 1 ? '' : 'es'} behind ${s.line}`)
-    if (s.conflicted_paths) bits.push(`${s.conflicted_paths} conflicted path${s.conflicted_paths === 1 ? '' : 's'}`)
-  }
-  bits.push(`held by ${s.holder}`)
-  return bits.join(' · ')
-}
-
-export function describeLog (r, { oneline = false } = {}) {
-  if (!r.commits.length) return 'No commits.'
-  const lines = r.commits.map((c) => oneline
-    ? `${c.short} ${c.patch ? `[${c.patch.line}:${c.patch.patch_no}] ` : ''}${first(c.message)}${r.follow && c.path && c.path !== r.follow ? `  (${c.path})` : ''}${c.signature ? `  (signature: ${c.signature.status})` : ''}`
-    : [`commit ${c.id}${c.patch ? ` (${patchName(c.patch)})` : ''}`, `Square: ${c.square}`, ...(r.follow && c.path && c.path !== r.follow ? [`Path:   ${c.path}`] : []), `Author: ${c.author.name} <${c.author.member_id}>${c.author.tool ? ` via ${c.author.tool}` : ''}`, ...(c.signature ? [describeSignature(c.signature)] : []), `Date:   ${when(c.authored_at)}`, '', ...String(c.message || '').split('\n').map((l) => `    ${l}`), ''].join('\n'))
-  if (r.more) lines.push(oneline ? '…' : '(more: seam log -n <count>)')
-  return lines.join('\n')
-}
-
-export function describeDiff (d, { format = 'unified' } = {}) {
-  if (!d.files.length) return 'No differences.'
-  if (format === 'names') return d.files.map((f) => `${f.status[0].toUpperCase()}\t${f.path}`).join('\n')
-  if (format === 'stat') {
-    const w = Math.max(...d.files.map((f) => f.path.length))
-    return [...d.files.map((f) => ` ${f.path.padEnd(w)} | ${f.binary ? 'Bin' : `${(f.add || 0) + (f.del || 0)} ${'+'.repeat(Math.min(f.add || 0, 40))}${'-'.repeat(Math.min(f.del || 0, 40))}`}`), ` ${d.files.length} file${d.files.length === 1 ? '' : 's'} changed, ${d.add || 0} insertions(+), ${d.del || 0} deletions(-)`].join('\n')
-  }
-  return d.files.map((f) => f.binary ? `Binary file ${f.path} ${f.status}\n` : f.patch || `${f.path} ${f.status}\n`).join('')
-}
-
-export function describeShow (r, { format = 'unified' } = {}) {
-  const c = r.commit
-  const head = [`commit ${c.id}${c.patch ? ` (${patchName(c.patch)})` : ''}`]
-  if (c.parents.length > 1) head.push(`Merge: ${c.parents.map((p) => p.slice(0, 12)).join(' ')}`)
-  head.push(`Square: ${c.square}${r.square ? ` "${r.square.title}" (${r.square.state})` : ''}`)
-  head.push(`Author: ${c.author.name} <${c.author.member_id}>${c.author.tool ? ` via ${c.author.tool}` : ''}`)
-  head.push(`Date:   ${when(c.authored_at)}`)
-  if (c.predecessor) head.push(`Rewrites: ${c.predecessor.slice(0, 12)}`)
-  if (c.conflicted) head.push(`Conflicted paths in this commit: ${c.conflicted}`)
-  head.push('', ...String(c.message || '').split('\n').map((l) => `    ${l}`), '')
-  return head.join('\n') + (r.diff ? '\n' + describeDiff(r.diff, { format }) : '')
-}
-
-export function describeBlame (r) {
-  const w = Math.max(...r.lines.map((l) => (l.author || '').length), 4)
-  return r.lines.map((l) => `${(l.short || '?').slice(0, 10)} ${l.patch ? `${l.patch.line}:${l.patch.patch_no}`.padEnd(9) : (l.square || '').padEnd(9)} (${(l.author || '?').padEnd(w)} ${when(l.at).slice(0, 10)} ${String(l.line).padStart(4)}) ${l.text}`).join('\n')
-}
-
-/** A square with 06's status fields: what merged under it and what would conflict on merge. */
-export function describeSquareStatus (s, { prefix = '' } = {}) {
-  const lines = [prefix + describeSquare(s)]
-  if (s.folded_into) lines.push(`Folded into ${s.folded_into}.`)
-  const under = s.merged_under_you || []
-  if (under.length) {
-    lines.push(`Merged under you (patches since your base that changed your files)${s.merged_under_you_more ? ', newest 50' : ''}:`)
-    for (const p of under) lines.push(`  patch ${p.patch_no} by ${p.author}: ${p.message} (${p.paths.join(', ')})`)
-  }
-  const wc = s.would_conflict || []
-  if (wc.length) lines.push(`Would conflict if merged now: ${wc.map((w) => `${w.path}${w.patch_no ? ` (with patch ${w.patch_no} by ${w.author})` : ''}`).join(', ')}. Rebase (seam rebase) to settle it in your square first.`)
-  else if (under.length) lines.push('Would merge cleanly now.')
-  return lines.join('\n')
-}
-
-export function describeStatus (st) {
-  const lines = []
-  if (st.square) lines.push(describeSquareStatus(st.square, { prefix: 'On square ' }))
-  else lines.push(`A read-only checkout of ${st.at ? st.at.slice(0, 12) : 'an empty line'}`)
-  lines.push(`Block: ${st.paths.map((p) => p || '/').join(', ')} at ${st.at ? st.at.slice(0, 12) : '(empty)'}`)
-  if (st.stale) lines.push('The square moved on since this folder last looked: run seam checkout ' + st.square.short + ' after committing.')
-  if (st.conflicted.length) lines.push(`Conflicted (edit and commit without the markers, or seam resolve --ours|--theirs): ${st.conflicted.join(', ')}`)
-  if (!st.changes.length) lines.push('Nothing changed since the last commit.')
-  else lines.push('Changes not yet committed:', ...st.changes.map((c) => `  ${c.status.padEnd(9)} ${c.path}`))
-  return lines.join('\n')
-}
-
-export function describeWrite (r, verb = 'Done') {
-  const c = r.result
-  const bits = [`${verb}${c && c.id ? ` ${c.short}` : ''}${c && c.message ? ` "${first(c.message)}"` : ''}`]
-  if (r.square) bits.push(`square ${describeSquare(r.square)}`)
-  if (r.conflicted) bits.push(`${r.conflicted} conflicted path${r.conflicted === 1 ? '' : 's'}: ${(r.terms || []).map((t) => `${t.path} (${t.kind})`).join(', ')}`)
-  const reused = (r.combined || []).filter((c) => c.how === 'reuse')
-  if (reused.length) bits.push(`Settled the way it was settled before: ${reused.map((c) => `${c.path} (by ${c.by})`).join(', ')}`)
-  return bits.join('\n')
-}
-
-export function describeMerge (r) {
-  if (r.dry_run) return r.ok ? `Would merge as patch ${r.would_merge.line}:${r.would_merge.patch_no}${r.would_merge.fast ? ' (no file touched on both sides)' : ''}.` : `Would be refused: ${r.refused.detail}.`
-  if (r.ok) {
-    const lines = [`Merged as ${patchName(r.merged)} (${r.merged.commit.slice(0, 12)})${r.retries ? ` after ${r.retries} lost race${r.retries === 1 ? '' : 's'}` : ''}.`]
-    const combined = (r.combined || []).filter((c) => c.how !== 'lines' || true)
-    if (combined.length) lines.push(`Combined with changes already on ${r.merged.line}: ${combined.map((c) => c.how === 'reuse' ? `${c.path} (settled as ${c.by} settled it before)` : `${c.path} (${c.how})`).join(', ')}.`)
-    for (const k of r.restacked || []) lines.push(k.error ? `${k.square} is stacked on it and could not be moved (${k.error}): its holder rebases it.` : `Moved ${k.square}, stacked on it, onto ${r.merged.line}${k.conflicted ? ` with ${k.conflicted} conflicted path${k.conflicted === 1 ? '' : 's'}` : ''}.`)
-    return lines.join('\n')
-  }
-  const lines = [`Not merged: ${r.refused ? r.refused.detail : r.error}.`]
-  if (r.terms && r.terms.length) {
-    lines.push('Conflicts, now kept in the square:')
-    for (const t of r.terms) lines.push(`  ${t.path} (${t.kind})${t.sides ? `: ${t.sides.map((s) => s.by).join(' vs ')}` : ''}${t.suggestion ? ' (a word-level merge is offered: seam resolve --suggestion, or choose suggestion)' : ''}`)
-    lines.push('Edit those files and commit them without the markers (or seam resolve <path> --ours|--theirs), then merge again.')
-  }
-  return lines.join('\n')
-}
-
-/** Events as one line each (12's inbox line: kind, who, square, paths, patch, would_conflict). */
-export function describeEvents (r) {
-  if (!r.events.length) return `No new events (cursor ${r.after}).`
-  const line = (e) => {
-    const p = e.payload || {}
-    if (e.kind === 'patch.merged') return `#${e.event_seq} patch.merged: patch ${e.patch_no} by ${e.by.member_id} "${first(p.message || '')}" changed ${e.paths.join(', ')} in your square ${e.square_short}${p.would_conflict ? `; would conflict in ${p.would_conflict_paths.join(', ')}` : '; merges cleanly'}`
-    if (e.kind === 'conflict.added') return `#${e.event_seq} conflict.added: ${p.path} (${p.kind}) in ${e.square_short}${p.caused_by && p.caused_by.patch_no ? `, against patch ${p.caused_by.patch_no}` : ''}; settle it and merge again`
-    if (e.kind === 'square.handoff') return `#${e.event_seq} square.handoff: ${e.square_short} from ${p.from} to ${p.to}${p.note ? `: ${p.note}` : ''}`
-    return `#${e.event_seq} ${e.kind}`
-  }
-  return [...r.events.map(line), `(next: after=${r.after})`].join('\n')
-}
-
-/** One tag per line: name, commit, patch, and "release" when it is one. */
-export const describeTag = (x) => `${x.name}  ${x.short}${x.patch ? ` ${x.patch.line}:${x.patch.patch_no}` : ''}${x.release ? '  release' : ''}`
-/** A release and its notes, indented under it. */
-export const describeRelease = (x) => `${x.name}  ${x.short}${x.patch ? ` ${x.patch.line}:${x.patch.patch_no}` : ''}  ${String(x.at && new Date(x.at).toISOString()).slice(0, 10)} ${x.by}` +
-  (x.notes ? '\n' + x.notes.split('\n').map((l) => `  ${l}`).join('\n') : '')
-
-/** A git import's answer, the same words from the CLI and seam_import_git. */
-export function describeImport (r) {
-  const said = [`${r.again ? 'Added' : 'Imported'} ${r.commits} commits (${r.patches} patches) into ${r.slug}.`]
-  for (const l of r.lines) said.push(`  ${l.name}${l.name !== l.git ? ` (git ${l.git})` : ''}: ${l.added} new patches`)
-  if (r.tags) said.push(`  tags: ${r.tags}`)
-  for (const x of r.report) said.push(`  left out: ${x.ref || x.path || x.sha.slice(0, 12)}: ${x.note}`)
-  if (r.validated != null) said.push(`Validated ${r.validated} trees against git.`)
-  return said.join('\n')
-}
-
-export function describeRestore (r) {
-  return r.restored.length ? `Restored ${r.restored.length} file(s) to the last commit: ${r.restored.join(', ')}` : 'Nothing to restore: those files have no uncommitted edits.'
-}
-
-export function describeReset (r, block) {
-  const n = r.written + r.removed
-  const where = block.square ? 'the square' : block.line
-  return `Reset ${n} file(s) to ${String(r.rev).slice(0, 12)}.` + (r.changes ? `\n${r.changes} change(s) from ${where} show as uncommitted (seam status); commit them to keep them, or seam reset to go back.` : '')
-}
-
-export function describeClean (r, again) {
-  if (!r.removed.length) return 'Nothing to clean.'
-  if (r.dry_run) return r.removed.map((p) => `Would remove ${p}`).join('\n') + `\n${again}`
-  return `Removed ${r.removed.length} file(s): ${r.removed.join(', ')}`
-}
-
-export function describeLive (r) {
-  if (!r.changes.length) return `No uncommitted work shared for ${r.square}: ${r.square}:live is its head.`
-  return [`Uncommitted work in ${r.square}${r.by ? ` (shared by ${r.by})` : ''}, read as ${r.square}:live:`, ...r.changes.map((c) => `  ${c.status.padEnd(9)} ${c.path}`)].join('\n')
-}
-
-export function describeLiveSet (r) {
-  return r.changes.length ? `Shared ${r.changes.length} uncommitted change(s) of ${r.square}: read them as ${r.square}:live.` : `Cleared the live work of ${r.square}.`
-}
-
-const at = (c) => `${c.short || String(c.id || c.commit).slice(0, 12)}${c.patch ? ` (${c.patch.line}:${c.patch.patch_no})` : ''}`
-
-export function describeMergeBase (r) {
-  return r.commit ? `${r.commit}${r.patch ? ` (${r.patch.line}:${r.patch.patch_no})` : ''}` : 'No common history.'
-}
-
-export function describeGrep (r, { filesOnly = false } = {}) {
-  if (!r.matches.length) return 'No matches.'
-  const lines = filesOnly ? r.files : r.matches.map((m) => `${m.quilt ? m.quilt + ':' : ''}${m.path}:${m.line}:${m.text}`)
-  if (r.more) lines.push('… (more: raise the limit, or narrow by paths)')
-  if (r.skipped) lines.push(`(${r.skipped} large file(s) not searched)`)
-  return lines.join('\n')
-}
-
-export function describeBisect (r) {
-  if (r.done) {
-    const said = [`First bad: ${at(r.first_bad)} ${first(r.first_bad.message)}`]
-    if (r.maybe) said.push(`Or one of the skipped commits before it: ${r.maybe.map(at).join(', ')}`)
-    return said.join('\n')
-  }
-  return `Test ${at(r.next)} ${first(r.next.message)}: ${r.remaining} commit(s) left, about ${r.steps} step(s). Mark it good, bad or skip and ask again.`
-}
-
-/** A list of claims, one per line. */
-export function describeClaims (claims) {
-  if (!claims.length) return 'No claims.'
-  return claims.map((c) => `${c.pattern}  ${c.square} (${c.line})  ${c.holder}${c.note ? `: ${c.note}` : ''}`).join('\n')
-}
-
-export function describeCheck (r) {
-  const lines = [`${r.line}: merge window ${r.window} an hour${r.red.length ? ` (red: ${r.red.join(', ')})` : ''}.`]
-  const v = r.revert
-  if (v && v.reverted) lines.push(`Reverted patch ${r.line}:${v.patch_no} as patch ${r.line}:${v.revert_patch_no}.${v.fix_square ? ` The change is again in square ${v.fix_square.short}, held by ${v.fix_square.holder}: fix it there, commit, merge.` : ''}`)
-  else if (v) lines.push(`Did not revert patch ${r.line}:${v.patch_no}: ${(v.refused && (v.refused.detail || v.refused.code)) || 'refused'}.${v.square ? ` The revert waits in square ${v.square.short}.` : ''}`)
-  return lines.join('\n')
-}
-
-/** Remembered resolutions, one per line. */
-export function describeResolutions (rows) {
-  if (!rows.length) return 'No remembered resolutions.'
-  return rows.map((r) => `${r.short}  ${r.path}  ${r.answer === 'delete' ? 'deleted' : `kept ${r.blob.slice(0, 12)}`} (${r.how}, ${r.by})`).join('\n')
-}
-
-/** Where a square stands in review: approvals against what its line needs. */
-function describeStanding (r) {
-  const parts = [`${r.have} of ${r.need} approval${r.need === 1 ? '' : 's'}${r.approved_by.length ? ` (${r.approved_by.join(', ')})` : ''}`]
-  if (r.changes_requested_by.length) parts.push(`changes asked for by ${r.changes_requested_by.join(', ')}`)
-  for (const c of r.checks || []) if (c.required || c.status !== 'missing') parts.push(`check ${c.name} ${c.status}`)
-  parts.push(r.ready ? 'ready to merge' : 'not ready to merge')
-  return parts.join('; ')
-}
-
-/** A square's reviews, oldest first, then where it stands. */
-export function describeReviews (r) {
-  const rows = r.reviews.map((x) => {
-    const what = { approve: 'approved', request_changes: 'asked for changes', dismiss: 'dismissed their verdict', comment: 'commented' }[x.kind]
-    const where = x.path ? ` on ${x.path}${x.line ? `:${x.line}` : ''}` : ''
-    return `${x.author} ${what}${where}${x.outdated ? ' (an earlier commit)' : ''}${x.body ? `: ${x.body}` : ''}`
-  })
-  return `${r.square} on ${r.line}: ${describeStanding(r)}${rows.length ? '\n' + rows.join('\n') : '\nNo reviews yet.'}`
-}
-
-/** One review just given. */
-export function describeReviewed (r) {
-  const x = r.review
-  const what = { approve: 'Approved', request_changes: 'Asked for changes on', dismiss: 'Dismissed your verdict on', comment: 'Commented on' }[x.kind]
-  return `${what} ${x.square}${x.path ? ` at ${x.path}${x.line ? `:${x.line}` : ''}` : ''}. ${describeStanding(r)}.`
-}
-
-/** What a line needs to take a merge. */
-export function describePolicy (p) {
-  const parts = []
-  if (p.approvals) parts.push(`${p.approvals} approval${p.approvals === 1 ? '' : 's'} of a square's latest commit from someone other than its holder`)
-  if (p.checks?.length) parts.push(`check${p.checks.length === 1 ? '' : 's'} ${p.checks.join(', ')} green on it`)
-  return parts.length ? `${p.line} needs ${parts.join(' and ')} to take a merge.` : `${p.line} takes merges without approvals or checks.`
-}
-
-/** A check reported on a square. */
-export function describeSquareCheck (r) {
-  const req = r.checks.filter((c) => c.required)
-  const left = req.filter((c) => c.status !== 'green').map((c) => `${c.name} ${c.status}`)
-  return `${r.check} is ${r.status} on ${r.square} (${r.head.slice(0, 12)}).${req.length ? (left.length ? ` Its line still needs: ${left.join(', ')}.` : ' Every check its line requires is green.') : ''}`
-}
-
-const SIGNATURE_WORDS = { good: 'Good signature', bad: 'BAD signature', removed_key: 'Signature by a removed key', none: 'No signature' }
-export function describeSignature (s) {
-  return `Signed: ${SIGNATURE_WORDS[s.status] || s.status}${s.key ? ` from ${s.signer} (${s.key})` : ''}`
-}
-
-export function describeKeys (r) {
-  if (!r.keys.length) return `${r.member} has no signing keys.`
-  return r.keys.map((k) => `${k.key}${k.name ? `  ${k.name}` : ''}${k.removed_at ? `  (removed ${when(k.removed_at)})` : `  added ${when(k.added_at)}`}`).join('\n')
-}
-
-export function describeTokens (r) {
-  if (!r.tokens.length) return `${r.quilt} has no tokens. Make one with seam token new <name> [--level read|write].`
-  return r.tokens.map((t) => `${t.id}  ${t.name}  ${t.level}${t.revoked_at ? `  (revoked ${when(t.revoked_at)})` : `  made ${when(t.created_at)} by ${t.created_by}`}`).join('\n')
-}
-
-export const describeNewToken = (t) => `Made token ${t.name} (${t.level} on ${t.quilt}, id ${t.id}). Its secret, shown only this once:\n\n  ${t.token}\n\nSet it as SEAM_TOKEN (or send it as Authorization: Bearer <token>).`

package/src/quilts/dogfood.js

@@ -1,82 +0,0 @@
-// The dogfood round trip (week 4, item 2): a git repository's full history into a new quilt on
-// whatever API the client points at, every imported commit's tree checked against git, then
-// `main` exported back to git and checked: one exported commit per first-parent commit, each
-// with git's tree and its `Quilt-Git-Sha` trailer naming that commit, and a second export from
-// scratch giving the same tip (the export is deterministic).
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { execFileSync } from 'node:child_process'
-import { importGit } from './import-git.js'
-import { exportGit } from './export-git.js'
-
-const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { maxBuffer: 1 << 30, env: { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' } }).toString()
-
-/** `git rev-list` with one format line per commit: [[sha, field], ...]. */
-function revs (dir, args, format) {
-  const out = git(dir, ['rev-list', `--format=${format}`, ...args]).split('\n')
-  const rows = []
-  for (let i = 0; i < out.length; i++) {
-    if (!out[i].startsWith('commit ')) continue
-    rows.push([out[i].slice(7), out[i + 1] || ''])
-  }
-  return rows
-}
-
-/**
- * Runs the round trip. `repo` is any git repository on this machine, `rev` the commit whose
- * history is imported (HEAD by default), `slug` the new quilt. Returns a report; throws on the
- * first mismatch.
- */
-export async function dogfood (client, { repo, rev = 'HEAD', slug, work, keep = false, batch = 200, log = () => {} }) {
-  const sha = git(repo, ['rev-parse', '--verify', `${rev}^{commit}`]).trim()
-  const dir = work || fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-dogfood-'))
-  const src = path.join(dir, 'src')
-  const times = {}
-  try {
-    // A bare-ish copy whose HEAD is `rev`, so the import walks exactly that history.
-    git(os.tmpdir(), ['clone', '-q', '--shared', '--no-checkout', repo, src])
-    git(src, ['update-ref', '--no-deref', 'HEAD', sha])
-
-    let t = Date.now()
-    log(`Importing ${sha.slice(0, 12)} of ${repo} into ${slug}…`)
-    const imp = await importGit(client, { repo: src, slug, batch, validate: 'all', log, onlyHead: true, fresh: true })
-    times.import_ms = Date.now() - t
-    log(`Imported ${imp.commits} commits (${imp.patches} patches); every commit's tree equals git's (${imp.validated}).`)
-
-    t = Date.now()
-    const out = path.join(dir, 'export.git')
-    const exp = await exportGit(client, { q: imp.quilt, dir: out, log })
-    times.export_ms = Date.now() - t
-
-    const want = revs(src, ['--first-parent', '--reverse', sha], '%T')
-    const got = revs(out, ['--reverse', 'refs/heads/main'], '%T')
-    if (got.length !== want.length) throw new Error(`export: main has ${got.length} commits, git's first-parent history ${want.length}`)
-    const trailers = revs(out, ['--reverse', 'refs/heads/main'], '%(trailers:key=Quilt-Git-Sha,valueonly,separator=)')
-    for (let i = 0; i < want.length; i++) {
-      if (got[i][1] !== want[i][1]) throw new Error(`export: commit ${i + 1} (git ${want[i][0].slice(0, 12)}) has tree ${got[i][1].slice(0, 12)}, git's is ${want[i][1].slice(0, 12)}`)
-      if (trailers[i][1].trim() !== want[i][0]) throw new Error(`export: commit ${i + 1} names git ${trailers[i][1].trim() || 'nothing'} in Quilt-Git-Sha, expected ${want[i][0]}`)
-    }
-    log(`Exported ${exp.exported} patches; every tree and Quilt-Git-Sha matches git's first-parent history.`)
-
-    const again = await exportGit(client, { q: imp.quilt, dir: path.join(dir, 'again.git'), page: 97 })
-    if (again.sha !== exp.sha) throw new Error(`export is not deterministic: ${exp.sha} then ${again.sha}`)
-    log(`Exported again from scratch: same tip ${exp.sha.slice(0, 12)}.`)
-
-    return {
-      quilt: imp.quilt,
-      slug: imp.slug,
-      rev: sha,
-      commits: imp.commits,
-      patches: imp.patches,
-      validated: imp.validated,
-      exported: exp.exported,
-      export_sha: exp.sha,
-      left_out: imp.report,
-      ...times,
-      ...(keep ? { work: dir } : {})
-    }
-  } finally {
-    if (!keep && !work) fs.rmSync(dir, { recursive: true, force: true })
-  }
-}

package/src/quilts/errors.js

@@ -1,8 +0,0 @@
-// What both the server and the seam client need without loading the server (service.js).
-export class QuiltError extends Error {
-  /** `code` is the wire name (04/07/12): head_moved, tip_moved, conflict, not_found, ... */
-  constructor (status, code, message, extra = {}) { super(message); this.status = status; this.code = code; this.extra = extra }
-}
-
-/** A square's short handle: sq: + the last 8 hex of its uuid (02). */
-export const squareShort = (id) => `sq:${String(id).replace(/-/g, '').slice(-8)}`