heyquilt 0.3.121 → 0.3.138

package/src/ui/seam-model.js

@@ -0,0 +1,251 @@
+// The app in a session that moved into Seam (layout 3, Seam's plans/quilt-source-control/16): what the
+// source control button, its panel and Session settings show there. Each folder follows its branch's
+// square (session-follow.js), and work lands by committing the square and merging it onto main, in
+// Seam; git is set aside in the folder and GitHub only receives Seam's export of main. So nothing here
+// offers git, branches, pushes or pull requests. Pure: no DOM (test/unit/ui-seam-model.test.js).
+
+import { forceAheadWords } from './force-words.js'
+
+const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+
+/** Whether the session's files are in Seam's squares now (the relay says layout 3): status.quilt from Session.quiltLink. */
+export const inSeam = (st) => !!(st && st.quilt && st.quilt.layout === 3)
+
+/** The quilt's name as people read it. */
+const quiltName = (st) => (st.quilt && (st.quilt.slug || st.quilt.id)) || 'the quilt'
+
+/** The square this folder follows, as Seam names it (`sq:` and the end of its id), or ''. */
+export const squareName = (st) => (st && st.square && st.square.short ? `sq:${st.square.short}` : '')
+
+/**
+ * The source control button at layout 3: { label, title, aria } for the square this folder follows, or
+ * why it follows none yet. `label` '' leaves the button with its icon and count only.
+ */
+export function seamChip (st) {
+  const name = squareName(st)
+  const s = st.square
+  const label = name
+  const title = st.moving ? movingCard(st).text
+    : st.squareless ? squarelessWords(st).text
+    : st.readOnly && !(s && !s.opening && !s.problem)
+    ? `Your edits here are not reaching anyone: ${st.readOnly.why}`
+    : !s ? `This session's code is committed and merged in Seam (${quiltName(st)}), and this folder is not following a square yet.`
+      : s.problem ? `This folder's work belongs in square ${name}, but it can't follow it yet: ${s.problem}`
+        : s.opening ? `This folder is starting to follow square ${name}.`
+          : [`This folder's work is live in square ${name} of ${quiltName(st)}. Click to commit it or merge it onto main.`, ...catchUpWords(s)].join(' ')
+  // The number is the square's work not committed yet (everyone's on it): what a commit takes.
+  const count = s && s.work ? s.work.count : 0
+  const countLine = count ? `${files(count)} not committed in this square.` : ''
+  return { label, title, aria: `Source control: ${name ? `square ${name}` : 'Seam'}${count ? `, ${files(count)} not committed` : ''}`, count, countLine }
+}
+
+const files = (n) => `${n} file${n === 1 ? '' : 's'}`
+const patches = (n) => `${n} newer patch${n === 1 ? '' : 'es'}`
+const listed = (list) => list.length > 4 ? `${list.slice(0, 4).join(', ')} and ${list.length - 4} more` : list.join(', ')
+
+/**
+ * Main brought into the square (session-follow.js status: `behind`, `conflicted`, `brought`), in plain
+ * words: how far behind main it is, when main's newer patches last came in, and what conflicts with main.
+ * The app's square card and panel show these, and quilt_status says them. [] with nothing to say.
+ */
+export function catchUpWords (s) {
+  if (!s) return []
+  const out = []
+  const b = s.brought
+  const old = Array.isArray(s.outdated) ? s.outdated : []
+  if (s.behind && old.length) out.push(`Main has ${patches(s.behind)} this square doesn't have yet. ${s.behind === 1 ? 'It comes' : 'They come'} in once ${listed(old)} ${old.length === 1 ? 'updates' : 'update'} Quilt: the version on ${old.length === 1 ? 'that folder' : 'those folders'} can't follow a square whose base moves.`)
+  else if (s.behind) out.push(`Main has ${patches(s.behind)} this square doesn't have yet: Quilt brings ${s.behind === 1 ? 'it' : 'them'} in by itself.`)
+  if (b && b.at) {
+    const at = new Date(b.at).toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
+    const combined = b.combined || []
+    out.push(`Main's ${b.patches ? patches(b.patches) : 'newer patches'} came in at ${at}${b.by ? ` (brought in by ${b.by})` : ''}${combined.length ? `, combined with this square's work in ${listed(combined)}` : ''}.`)
+    const stale = Array.isArray(b.stale) ? b.stale : []
+    if (stale.length) out.push(`${files(stale.length)} in this square ${stale.length === 1 ? 'was an older copy' : 'were older copies'} of main's, not anyone's edit: main's ${stale.length === 1 ? 'version stands' : 'versions stand'} (${listed(stale)}).`)
+  }
+  const n = s.conflicted ?? (b && b.conflicts ? b.conflicts.length : 0)
+  if (n) {
+    const named = b && b.conflicts && b.conflicts.length ? ` (${listed(b.conflicts)})` : ''
+    out.push(`${files(n)} ${n === 1 ? 'conflicts' : 'conflict'} with main and ${n === 1 ? 'is' : 'are'} marked in this folder${named}: settle ${n === 1 ? 'it' : 'them'}, commit, and merge again.`)
+  }
+  return out
+}
+
+/**
+ * The square card above the main area: { title, text }, only when something needs the person (a
+ * conflict with main, edits reaching nobody, a move under way), else null. The app's words, not
+ * quilt_status's: a person commits and merges from the square button, not with a command.
+ */
+export function squareCard (st) {
+  // The owner is moving the session (into Seam, or back): said first, with what to expect, on git or in Seam alike.
+  if (st.moving) return movingCard(st)
+  const s = st.square
+  const following = s && !s.opening && !s.problem
+  // The relay's own words name a tool: a person gets plain ones, and the button in the square panel.
+  if (st.squareless) return { ...squarelessWords(st), open: true }
+  if (st.readOnly && !following) return { title: 'Your edits here are not reaching anyone', text: st.readOnly.why }
+  if (!s) return null
+  if (s.problem || s.opening) return { title: s.problem ? 'Not following its square yet' : 'Starting to follow its square', text: s.line }
+  // Following its square with nothing to settle: the square button at the top says it, so no card (Daniel, 2026-11-01).
+  if (!(s.conflicted ?? (s.brought && s.brought.conflicts ? s.brought.conflicts.length : 0))) return null
+  return { title: 'Main conflicts with this square', text: catchUpWords(s).join(' ') }
+}
+
+/**
+ * The source control panel's top at layout 3, in place of the branch list: the square, its line, and
+ * the two things a person does with it, Commit (the square's live work, with a message) and Merge onto
+ * main (Seam merges once its checks pass; the folder carries on in a new square). `busy`: 'commit' or
+ * 'merge' while that one runs. A viewer, or a folder not following its square yet, gets the line only.
+ */
+export function squarePanelHtml (st, { busy = '' } = {}) {
+  const s = st.square
+  const name = squareName(st)
+  const following = s && !s.opening && !s.problem
+  const viewer = !!(st.access && st.access.role === 'viewer')
+  const head = `<div class="br-here sq-here"><div class="br-title">${name ? `Square <b>${esc(name)}</b> of ${esc(quiltName(st))}` : `Code committed and merged in Seam: <b>${esc(quiltName(st))}</b>`}</div>`
+  // While the session moves, nothing is committed or merged from here: the move is what it waits for.
+  if (st.moving) return `${head}<div class="br-sub warn">${esc(movingCard(st).text)}</div></div>`
+  if (st.squareless) {
+    const w = squarelessWords(st)
+    return `${head}<div class="br-sub warn">${esc(w.text)}</div>${viewer ? '' : `<div class="sq-acts">${openSquareButton(st, busy)}</div>`}</div>`
+  }
+  if (!following) {
+    const why = st.readOnly ? st.readOnly.why : s ? s.line : 'This folder is not following a square yet: Quilt opens it by itself once the session says which.'
+    return `${head}<div class="br-sub${st.readOnly || (s && s.problem) ? ' warn' : ''}">${esc(why)}</div></div>`
+  }
+  const sub = '<div class="br-sub">Every edit here is live for everyone on this square. Commit it to keep a version; merge it to put it on main (GitHub gets main from Seam by itself).</div>'
+  const caught = catchUpWords(s)
+  const work = (caught.length ? `<div class="br-sub${s.conflicted ? ' warn' : ''}">${esc(caught.join(' '))}</div>` : '') + workHtml(s.work)
+  if (viewer) return `${head}${sub}${work}</div>`
+  return `${head}${sub}${work}
+    <form class="cp-commit" data-square-commit><input class="input" name="message" placeholder="What this commit is" aria-label="Commit message" maxlength="2000" required autocomplete="off"${busy ? ' disabled' : ''}><button type="submit" class="btn sm primary"${busy ? ' disabled' : ''}>${busy === 'commit' ? 'Committing…' : 'Commit'}</button></form>
+    <div class="sq-acts"><button type="button" class="btn sm" data-square-merge${busy ? ' disabled' : ''} title="Commits what is not committed yet, then merges ${esc(name)} onto main once its checks pass">${busy === 'merge' ? 'Merging…' : 'Merge onto main'}</button></div>
+  </div>`
+}
+
+/** While the owner moves the session (status `moving`, the relay's): { title, text }, what to expect in plain words. */
+export function movingCard (st) {
+  const m = st.moving || {}
+  return { title: m.kind === 'back' ? 'Moving the code back to git' : 'Moving the code into Seam', text: m.line || (m.kind === 'back' ? 'The session\'s code is moving back from Seam to its git branches. Keep Quilt open: it can take a few minutes, and your edits are kept.' : 'The session\'s code is moving into Seam, where it will be committed and merged; the session stays in Quilt. Keep Quilt open: it can take a few minutes, and your edits are kept.') }
+}
+
+/**
+ * A folder whose branch has no square in the quilt (made after the move into Seam, or main with nothing
+ * to adopt): its edits reach nobody until a square is opened for it. { title, text } in plain words.
+ */
+export function squarelessWords (st) {
+  const b = (st.squareless && st.squareless.branch) || 'this branch'
+  return { title: `${b} has no square yet`, text: `Your folder is on ${b}, which has no square in Seam, so your edits here reach nobody. Open a square for it: your files stay as they are, they become its work, and everyone on ${b} follows it.` }
+}
+
+/** The button that opens a square for the folder's branch (squareTool open_square). */
+export function openSquareButton (st, busy = '') {
+  const b = (st.squareless && st.squareless.branch) || 'this branch'
+  return `<button type="button" class="btn sm primary" data-square-open${busy ? ' disabled' : ''}>${busy === 'open' ? 'Opening…' : `Open a square for ${esc(b)}`}</button>`
+}
+
+/** What the square holds not committed yet (everyone's on it), folded: what Commit takes. */
+function workHtml (work) {
+  if (!work) return ''
+  if (!work.count) return '<div class="br-sub">Nothing here is waiting to be committed.</div>'
+  const word = { added: 'new', deleted: 'deleted', modified: '' }
+  const more = work.count - work.files.length
+  return `<details class="sq-work"><summary>${files(work.count)} not committed yet</summary><ul class="commit-files">${work.files.map((f) => `<li><code title="${esc(f.path)}">${esc(f.path)}</code>${word[f.status] ? ` <span class="hint">${word[f.status]}</span>` : ''}</li>`).join('')}${more > 0 ? `<li class="hint">and ${more} more</li>` : ''}</ul></details>`
+}
+
+/**
+ * The words on the owner's "Make this a quilt" card (16 flag 9), while the session's code is on git.
+ * `quilt`: the status's quilt link ({ slug, shadow }), `remote`: the session has a git remote.
+ */
+export function makeQuiltWords ({ quilt = null, remote = false, moving = false, force = null, importing = null, shadow = null } = {}) {
+  const w = makeQuiltWordsNow({ quilt, remote, moving, importing, shadow })
+  // The forced date (16 flag 9): live sync stopped here, or when it comes (force-date.js).
+  if (force && force.stopped) return { ...w, note: force.stopped.why || '' }
+  const ahead = force && force.at ? forceAheadWords({ at: Date.parse(force.at), remote: !!force.remote }) : null
+  return ahead ? { ...w, note: ahead } : w
+}
+
+function makeQuiltWordsNow ({ quilt, remote, moving, importing, shadow }) {
+  if (moving) return { text: 'The session\'s code is moving into Seam now. Keep Quilt open: your edits are kept.', button: 'Moving into Seam…', disabled: true }
+  // A session with a git remote, step by step (quilt-remote.js): Seam importing it, then linked and ready for the cut-over.
+  if (shadow || (quilt && quilt.shadow)) return { text: `Seam follows this session's git remote in the quilt ${(shadow || quilt).slug || ''}. When the team is ready: the repository's GitHub owner lets only Seam push to main (the steps show when you click), then move the session in. Its branches become squares, its uncommitted work a square of its own, and GitHub keeps getting main from Seam.`, button: 'Move into Seam now' }
+  if (importing) return { text: `Seam is importing ${importing.repo} into the quilt ${importing.slug} and follows it. Git stays as it is meanwhile: remote, clones and CI. Check again once it has caught up.`, button: 'Check the import' }
+  if (quilt && !quilt.shadow) return { text: `This session is the quilt ${quilt.slug} already, but its files are still on its branches. Finish the move to put them in its squares.`, button: 'Finish the move' }
+  if (remote) return { text: 'This session has a git remote, so it becomes a quilt with its git history: Seam imports the remote and follows it, then the session moves in when the import is ready. Your git remote, clones and CI keep working.', button: 'Make this a quilt' }
+  return { text: 'Move this session\'s code into Seam: main as it is now becomes the quilt\'s first commit, each branch a square, and everyone\'s folder follows its square live. Nothing is lost: the session can go back to its branches.', button: 'Make this a quilt' }
+}
+
+/**
+ * Session settings' Source control at layout 3, for everyone in it: where the code's history is, in
+ * place of the git and GitHub settings, which are put away while the session is in Seam (the relay
+ * keeps them for a move back: quilt session migrate --back).
+ */
+export function seamSettingsHtml (st) {
+  return `<div class="pm-section"><div class="pm-title">Seam</div><div class="pm-card git-card">
+    <div class="git-head"><h4>This session's source control</h4><span class="pill">Seam</span></div>
+    <p class="git-line ok"><b>${esc(quiltName(st))}.</b> This session's code is committed and merged in Seam; the session itself is Quilt. Everyone's folder follows its branch's square: people and their AIs commit there and merge onto main, and GitHub gets main from Seam by itself.</p>
+    <span class="hint">Git and GitHub settings are put away while the session's code is in Seam. If its owner moves it back to its branches (quilt session migrate --back), they come back as they were.</span>
+  </div></div>`
+}
+
+/**
+ * The left sidebar in Seam, in place of boxes (there are none: every edit is live in its square): each
+ * square with whose folders are on it, and, for yours, how many files it holds not committed yet.
+ * `st.squares` is branch -> square name; people are you (`st.square`) and `st.peers` by their branch.
+ */
+export function squaresSideHtml (st) {
+  const squares = st.squares || {}
+  const branchOf = Object.fromEntries(Object.entries(squares).map(([b, sq]) => [sq, b]))
+  const groups = new Map()
+  const add = (sq, who) => { if (!sq) return; if (!groups.has(sq)) groups.set(sq, []); if (!groups.get(sq).includes(who)) groups.get(sq).push(who) }
+  const mine = squareName(st)
+  add(mine, 'you')
+  for (const p of st.peers || []) if (p && p.name && p.branch && squares[p.branch] && !(p.persona && p.of === (st.me && st.me.name))) add(squares[p.branch], p.mine ? 'your AI' : p.name)
+  const n = st.square && st.square.work ? st.square.work.count : 0
+  const rows = [...groups].map(([sq, who]) => `<li class="sq-side-row${sq === mine ? ' on' : ''}"><div><b>${esc(sq)}</b>${branchOf[sq] ? ` <span class="hint">${esc(branchOf[sq])}</span>` : ''}</div><div class="hint">${esc(who.join(', '))}${sq === mine ? ` · ${n ? `${files(n)} not committed` : 'all committed'}` : ''}</div></li>`).join('')
+  // The pane's own title says Squares already (session.js, as it says Boxes outside Seam): no second heading.
+  return rows ? `<ul class="sq-side">${rows}</ul>` : ''
+}
+
+/** The sidebar's line under it in Seam. */
+export const SEAM_SIDE_HINT = 'In Seam nothing waits in boxes: everyone on a square sees every edit as it is made. Commit and merge your square from the square button at the top.'
+
+/**
+ * What the square panel's Commit or Merge onto main did, for a person: from the Seam tool's own record
+ * (`structuredContent`), never its tool text (ids, `held by person:…`, CLI hints). `text` is the tool's
+ * text, read only for what has no record: nothing to commit, the folder carrying on in a new square.
+ */
+export function seamResultWords (tool, { structuredContent: rec = null, text = '' } = {}) {
+  const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`
+  const names = (list) => list.length > 4 ? `${list.slice(0, 4).join(', ')} and ${list.length - 4} more` : list.join(', ')
+  const careful = (rec && rec.warnings || []).map((w) => w.kind === 'markers_in_file' ? `${w.path} still has conflict markers in it.` : `${w.path} looks like it holds a secret: check it before you merge.`)
+  if (tool === 'seam_commit') {
+    if (/^Nothing to commit/.test(text)) return 'Nothing to commit: everything in this square is committed already.'
+    const c = rec && rec.result
+    if (!c) return text
+    const n = Array.isArray(c.changes) ? c.changes.length : 0
+    return [`Committed "${String(c.message || '').split('\n')[0]}"${n ? `: ${plural(n, 'file')}` : ''}.`, ...careful].join(' ')
+  }
+  if (tool === 'seam_merge') {
+    if (!rec) return text
+    const moved = /carries on in a new square/.test(text) ? 'Your folder carries on in a new square on main\'s new version: keep working as before.' : ''
+    if (rec.ok && rec.merged) {
+      const m = rec.merged
+      const combined = (rec.combined || []).map((c) => c.path)
+      return [`Merged onto ${m.line || 'main'} as patch ${m.patch_no}${m.subject ? ` "${m.subject}"` : ''}.`, combined.length ? `Combined with changes already on ${m.line || 'main'} in ${names(combined)}.` : '', ...careful, moved].filter(Boolean).join(' ')
+    }
+    const terms = (rec.terms || []).map((t) => t.path)
+    const why = rec.refused ? rec.refused.detail : rec.error || 'Seam refused'
+    return [`Not merged: ${why}.`, terms.length ? `${plural(terms.length, 'file')} ${terms.length === 1 ? 'conflicts' : 'conflict'} with main and ${terms.length === 1 ? 'is' : 'are'} marked in your folder (${names(terms)}): settle ${terms.length === 1 ? 'it' : 'them'}, commit, and merge again.` : ''].filter(Boolean).join(' ')
+  }
+  return text
+}
+
+/**
+ * The words for a session that stopped by itself (the relay sent this app away, its owner ended it, ...):
+ * `session` the app's record of it (for its name), `why` what Quilt was told.
+ */
+export function stoppedWords (session, why) {
+  const st = session && session.status
+  const name = (st && st.sessionName) || (session && session.dir ? String(session.dir).split(/[\\/]/).filter(Boolean).pop() : '') || 'The session'
+  return `${name} stopped: ${String(why || '').replace(/^Relay refused connection: /, '')}`
+}