heyquilt 0.3.138 → 0.3.140

package/src/sync-words.js

@@ -1,42 +0,0 @@
-// Where each branch stands with GitHub (relay-sync.js syncStatus), in words for agents: the
-// quilt_sync_status tool, hosted (relay-mcp.js) and in a folder (mcp.js), from the branch list.
-
-const short = (sha) => (typeof sha === 'string' && sha ? sha.slice(0, 7) : '')
-const plural = (n, w) => `${n} ${w}${n === 1 ? '' : 's'}`
-
-/** One line for branch entry `b` ({ key, relay: { repo, sync, ... } }), or null when it doesn't follow GitHub. */
-export function syncLine (b) {
-  const r = b && b.relay
-  const s = r && r.sync
-  if (!s) return null
-  const repo = String(r.repo || '').replace(/^github\.com\//, '')
-  const at = s.revision ? ` at ${short(s.revision)}` : ''
-  const head = `${b.key}${repo ? ` (${repo})` : ''}`
-  switch (s.state) {
-    case 'synced': return `${head}: in step with GitHub${at}; nothing uncommitted.`
-    case 'github-pending': return `${head}: has GitHub's latest${at}; ${plural(s.pending || 0, 'file')} changed in the session and not committed (quilt_git_commit commits yours).`
-    case 'conflict-held': return `${head}: ${s.why || `${plural(s.held || 0, 'file')} waiting to be merged`}${at}; Quilt merges ${s.held === 1 ? 'it' : 'them'} on its own, nothing to do.` // from a relay before 0.3.99
-    case 'pr-pending': return `${head}: ${r.leased ? 'another session holds this branch' : 'protected on GitHub'}, so commits go through ${s.pr && s.pr.number ? `pull request #${s.pr.number}${s.pr.url ? ` (${s.pr.url})` : ''}` : 'a pull request (opened with the next commit)'}${at}.`
-    case 'offline': return `${head}: GitHub unreachable${s.since ? ` since ${new Date(s.since).toISOString().slice(11, 16)} UTC` : ''}; the session keeps working, and commits asked for go when it answers.`
-    case 'permission-held': return `${head}: ${s.why || 'GitHub refused the relay'}.`
-    default: return `${head}: not syncing with GitHub (${s.why || 'paused'}).`
-  }
-}
-
-/** The files of a branch that are GitHub's version, not edited in the session since: one line, or ''. */
-export function fromGithubLine (s) {
-  const files = s && Array.isArray(s.fromGithubFiles) ? s.fromGithubFiles : []
-  if (!files.length) return ''
-  const more = (s.fromGithub || files.length) - files.length
-  return `  From GitHub, not edited here since: ${files.map((f) => `${f.path} (${short(f.sha)}${f.by ? ` by ${f.by}` : ''})`).join(', ')}${more > 0 ? `, and ${more} more` : ''}.`
-}
-
-/** Every branch that follows GitHub, the caller's first: one line each. */
-export function syncStatusText (list, { mine = '' } = {}) {
-  const rows = (Array.isArray(list) ? list : []).filter((b) => b && b.relay && b.relay.sync)
-  if (!rows.length) return 'No branch of this session syncs with GitHub (none follows a GitHub repository, or the relay has no git sync).'
-  rows.sort((a, b) => (a.key === mine ? -1 : b.key === mine ? 1 : 0))
-  return rows.map((b) => [syncLine(b), fromGithubLine(b.relay.sync)].filter(Boolean).join('\n')).filter(Boolean).join('\n')
-}
-
-export const SYNC_STATUS_DESCRIPTION = 'Where each branch of the session stands with GitHub: in step (with the commit it is at), files changed and not committed, files held for a merge, commits going through a pull request (a protected branch, or another session holds it), GitHub unreachable, or sync paused and why. Pushes and merges on GitHub come in by themselves, and the files that are GitHub\'s version, not edited here since, are listed with the commit that brought them; nothing goes to GitHub until someone commits.'

package/src/upstream.js

@@ -1,192 +0,0 @@
-// Catching a folder's branch up with commits it doesn't have yet (pushed from
-// a worktree, merged on GitHub, moved by another worktree), without anyone
-// running git pull. Quilt never merges git history: the branch only ever moves
-// forward to a commit it is behind. What it merges is the session's
-// uncommitted work into those commits' files, file by file, the way
-// `git pull --autostash` would, except that where both changed the same lines
-// Quilt combines them itself (combine, merge3.js mergeAuto): nobody is asked to
-// merge (docs/superpowers/specs/2026-10-18-automatic-merges.md). Only a file git
-// can't read holds a catch-up up.
-//
-// planCatchUp is pure: session.js reads git and the disk, asks for a plan,
-// and applies it (bringIn there).
-import crypto from 'node:crypto'
-import { mergeAuto } from './merge3.js'
-
-const isText = (k) => typeof k === 'string' && !k.startsWith('bin:')
-
-/**
- * A file's content id as Quilt records what it published (`published` in the room document):
- * the sha1 of its bytes. A key here is text or "bin:<sha1>" (the sha1 of the bytes already).
- */
-export const contentId = (k) => typeof k !== 'string' ? null : k.startsWith('bin:') ? k.slice(4) : crypto.createHash('sha1').update(Buffer.from(k, 'utf8')).digest('hex')
-
-/**
- * Whether `key` is a version of `rel` the session itself published to GitHub (a commit the relay
- * made from the session's copy, on any branch). `published`: Map path -> [content ids], or null.
- */
-export const wasPublished = (published, rel, key) => {
-  if (!published || key === null || key === undefined) return false
-  const ids = published.get(rel)
-  return !!ids && ids.includes(contentId(key))
-}
-
-/** What the session published (relay commits), read from the room document: Map path -> [content ids]. */
-export function publishedOf (doc) {
-  const out = new Map()
-  try { doc.getMap('published').forEach((v, k) => { if (Array.isArray(v)) out.set(k, v.filter((x) => typeof x === 'string')) }) } catch {}
-  return out
-}
-
-/** Records that these files' contents (path -> bytes, null for deleted) were published; the last 20 per path are kept. */
-export function notePublished (doc, files, origin) {
-  const entries = []
-  for (const [rel, buf] of files) if (buf) entries.push([rel, crypto.createHash('sha1').update(buf).digest('hex')])
-  notePublishedIds(doc, entries, origin)
-}
-
-/** The same, by content id (sha1 of the bytes): [[path, id]], as a folder reports what it pushed. */
-export function notePublishedIds (doc, entries, origin) {
-  const map = doc.getMap('published')
-  doc.transact(() => {
-    for (const [rel, id] of entries) {
-      if (typeof rel !== 'string' || !/^[0-9a-f]{40}$/.test(id || '')) continue
-      const was = Array.isArray(map.get(rel)) ? map.get(rel) : []
-      if (was.includes(id)) continue
-      map.set(rel, [...was, id].slice(-20))
-    }
-  }, origin)
-}
-
-/**
- * Two versions of a file that both moved on from `base`, combined the way Quilt does it on its own
- * (keys as planCatchUp's: text, "bin:<sha1>", null when absent): lines only one side changed are
- * kept, lines both changed go to the newer side (`oursNewer`), an edit beats a deletion, and a binary
- * file (or one both created, differently) is the newer version. Returns { key, lost, how }: `lost` as mergeAuto's ({ side, lines, kept,
- * at }; a binary that lost has `binary: true` and no lines); `how` 'lines', 'kept-edit' or 'newer'.
- */
-export function combine (base, ours, theirs, { oursNewer = true, union = false } = {}) {
-  if (ours === theirs || theirs === base) return { key: ours, lost: [], how: 'lines' }
-  if (ours === base) return { key: theirs, lost: [], how: 'lines' }
-  // Deleted on one side, edited on the other: the edit stays (a deletion is cheap to redo; lost work is not).
-  if (ours === null) return { key: theirs, lost: [], how: 'kept-edit', deleted: 'ours' }
-  if (theirs === null) return { key: ours, lost: [], how: 'kept-edit', deleted: 'theirs' }
-  if (base === null && isText(ours) && isText(theirs) && !union) {
-    // Created on both sides, differently: nothing to measure either from, so the newer file, and the other's lines it lacks are what lost.
-    const [won, lose] = oursNewer ? [ours, theirs] : [theirs, ours]
-    const left = new Map()
-    for (const l of won.split('\n')) left.set(l, (left.get(l) || 0) + 1)
-    const gone = lose.split('\n').filter((l) => { const n = left.get(l); if (n) { left.set(l, n - 1); return false } return l !== '' })
-    return { key: won, lost: gone.length ? [{ side: oursNewer ? 'theirs' : 'ours', lines: gone, kept: [], at: 0 }] : [], how: 'newer' }
-  }
-  if ((base === null || isText(base)) && isText(ours) && isText(theirs)) {
-    const r = mergeAuto(base ?? '', ours, theirs, { oursNewer, union })
-    return { key: r.text, lost: r.lost, how: 'lines' }
-  }
-  // A binary file (or one that became one): the newer version.
-  return { key: oursNewer ? ours : theirs, lost: [{ side: oursNewer ? 'theirs' : 'ours', lines: [], kept: [], at: 0, binary: true }], how: 'newer' }
-}
-
-/**
- * How the folder at commit `from` (its files on disk: the commit plus the
- * session's uncommitted work) becomes the folder at `to` with that work kept.
- *
- * - changes: Map path -> git status letter (A, M, D, T...) between the commits.
- * - base / theirs: Map path -> the file at `from` / at `to` (text, "bin:<sha1>",
- *   null when absent, undefined when git couldn't read it).
- * - disk(rel): the file in the folder now (same keys).
- * - moved: candidates for a file the session moved: Map path -> its text, for
- *   files on disk that `from` didn't have (new or moved here).
- * - emptied: folders the session emptied (had files at `from`, none on disk now).
- *
- * - oursNewer(rel): whether the session's (the folder's) edit of rel is newer than
- *   the commits' (it keeps the lines both changed); union(rel): a merge=union file.
- *
- * Every file both sides changed is combined (combine): nothing clashes. Returns
- * { writes: Map path -> key (null: delete), moves: [{ from, to }], conflicts:
- * [{ path, why }] (only files git couldn't read), strays: [path], merged: [{ path,
- * how, lost, oursNewer, deleted? }] (the files both changed, for the history and
- * the notice to whoever's lines lost) }. With conflicts, writes is empty: a
- * catch-up is all or nothing.
- */
-export function planCatchUp ({ changes, base, theirs, disk, moved = new Map(), emptied = new Set(), published = null, oursNewer = () => true, union = () => false }) {
-  const writes = new Map()
-  const conflicts = []
-  const moves = []
-  const strays = []
-  const merged = []
-  const taken = new Set()
-  for (const rel of changes.keys()) {
-    const b = base.get(rel)
-    const t = theirs.get(rel)
-    const o = disk(rel)
-    if (b === undefined || t === undefined || o === undefined) {
-      conflicts.push({ path: rel, why: 'git could not read it (too large, or behind a filter such as Git LFS)' })
-      continue
-    }
-    if (o === b) { // untouched here: the commits' version
-      if (t !== o) writes.set(rel, t)
-      if (b === null && t !== null && emptied.has(dirOf(rel))) strays.push(rel)
-      continue
-    }
-    if (o === t || t === b) continue // the session already has it, or the commits didn't change it
-    // The commits bring a version of this file the session itself published (an agent committed it
-    // to a branch, and the branch was merged, squashed or rebased in): the session's copy is that
-    // version or newer, so it stays as it is. Matched by content, so every merge strategy counts.
-    if (o !== null && wasPublished(published, rel, t)) continue
-    const newer = !!oursNewer(rel)
-    if (o === null && isText(b) && isText(t)) {
-      // Gone here, changed there: the session may have moved it. Followed by content, as git
-      // follows a rename, into the moved copy, which takes the commits' change.
-      const to = findMove(rel, b, moved, taken)
-      if (to) {
-        const r = mergeAuto(b, moved.get(to), t, { oursNewer: newer, union: !!union(to) })
-        taken.add(to)
-        moves.push({ from: rel, to })
-        if (r.text !== moved.get(to)) writes.set(to, r.text)
-        if (r.lost.length) merged.push({ path: to, how: 'lines', lost: r.lost, oursNewer: newer })
-        continue
-      }
-    }
-    // Both changed it: Quilt combines them (an edit beats a deletion; the newer edit keeps the lines both changed).
-    const r = combine(b, o, t, { oursNewer: newer, union: !!union(rel) })
-    if (r.key !== o) writes.set(rel, r.key)
-    merged.push({ path: rel, how: r.how, lost: r.lost, oursNewer: newer, ...(r.deleted ? { deleted: r.deleted } : {}) })
-  }
-  if (conflicts.length) return { writes: new Map(), moves: [], conflicts, strays: [], merged: [] }
-  return { writes, moves, conflicts, strays, merged }
-}
-
-const dirOf = (rel) => rel.includes('/') ? rel.slice(0, rel.lastIndexOf('/')) : ''
-const nameOf = (rel) => rel.slice(rel.lastIndexOf('/') + 1)
-
-/** The moved copy of a file: same name, and at least half its lines the same. */
-function findMove (rel, text, moved, taken) {
-  let best = null
-  let score = 0.5
-  for (const [to, t] of moved) {
-    if (taken.has(to) || nameOf(to) !== nameOf(rel) || !isText(t)) continue
-    const s = similarity(text, t)
-    if (s >= score) { best = to; score = s }
-  }
-  return best
-}
-
-/** Share of lines in common (multiset), against the longer file. */
-export function similarity (a, b) {
-  const count = new Map()
-  const la = a.split('\n')
-  const lb = b.split('\n')
-  for (const l of la) count.set(l, (count.get(l) || 0) + 1)
-  let same = 0
-  for (const l of lb) { const n = count.get(l); if (n) { same++; count.set(l, n - 1) } }
-  return same / Math.max(la.length, lb.length, 1)
-}
-
-/** One line for the AI and the log about why a catch-up waits. Nobody is told to pull or merge: Quilt combines what it can read. */
-export function catchUpAdvice ({ branch, upstream, behind, conflicts = [], diverged, ahead }) {
-  const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-  if (diverged) return `${branch} and ${upstream} have both moved on (${n(ahead, 'commit')} here, ${n(behind, 'commit')} there). Quilt never rewrites git history in this folder: the session's files take in ${upstream}'s changes, combined with yours, and your commits go to GitHub through the session.`
-  const list = conflicts.slice(0, 4).map((c) => `${c.path} (${c.why})`).join('; ') + (conflicts.length > 4 ? `; and ${conflicts.length - 4} more` : '')
-  return `${branch} is ${n(behind, 'commit')} behind ${upstream}, and Quilt can't read ${list} to combine ${conflicts.length === 1 ? 'it' : 'them'} with the session's work, so it brought nothing in yet. A folder on ${branch} that can read ${conflicts.length === 1 ? 'it' : 'them'} brings the commits in; nothing to merge by hand.`
-}