heyquilt 0.0.1 → 0.3.106

package/src/relay-ci.js

@@ -0,0 +1,111 @@
+// CI on GitHub becomes work on the board: checks failing on a branch the session follows open one task,
+// "CI failing on <branch>", for the member whose commit it is (when they are in the session); a newer commit
+// failing too is noted on it; checks passing again move it to Done. One task per branch (its id comes from the
+// branch), so a run reported twice never adds a second.
+import crypto from 'node:crypto'
+import { readTasks, addTask, updateTask } from './tasks.js'
+import { addComment } from './task-comments.js'
+import { githubWriter } from './github-commit.js'
+import { credentialsFor } from './relay-commit.js'
+import { upstreamsOf, parseRepo } from './relay-upstream.js'
+import { memberForAuthor, everyone } from './relay-clash.js'
+import { runGit } from './relay-git.js'
+import { RELAY_BY } from './branches.js'
+
+const ORIGIN = 'relay-publish'
+// What GitHub calls a check suite that failed (check_suite.conclusion).
+const FAILED = new Set(['failure', 'timed_out', 'action_required', 'startup_failure'])
+
+/** The task id for CI on `branch` of this session: the same every time. */
+export const ciTaskId = (room, branch) => crypto.createHash('sha256').update(`ci\0${room.name}\0${branch}`).digest('hex').slice(0, 16)
+
+/** Who made commit `sha` (from the relay's mirror): the member it maps to, or ''. */
+async function authorOf (room, rec, sha) {
+  if (!room.mirrors) return ''
+  try {
+    const repo = parseRepo(`https://${rec.repo}`)
+    const dir = (await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })).dir
+    const r = await runGit(dir, ['log', '-1', '--format=%an%x1f%ae', sha])
+    if (!r.ok) return ''
+    const [name, email] = r.out.trim().split('\x1f')
+    // By their noreply address, else by name: a member on record, or one connected now.
+    const online = room.names ? [...room.names.values()] : []
+    return memberForAuthor(room, { name, email }) || everyone(room).find((m) => m.name === name)?.name || online.find((n) => n === name) || ''
+  } catch { return '' }
+}
+
+/**
+ * A check suite on `repo` finished at commit `sha` of `branch` with `conclusion`. When the session follows that
+ * branch: failing opens (or reopens, or notes) its CI task; passing moves an open one to Done. Returns what it did
+ * ('opened', 'noted', 'closed') or null. Never throws.
+ */
+export function noteCiResult (room, result, opts = {}) {
+  // One at a time per branch, in the order GitHub's results arrive: a failure takes longer to note (GitHub is asked
+  // which checks failed), and a pass right after it must not be noted first.
+  if (!room.ciQueue) room.ciQueue = new Map()
+  const k = String(result && result.branch)
+  const next = (room.ciQueue.get(k) || Promise.resolve()).then(() => noteCiResultNow(room, result, opts))
+  room.ciQueue.set(k, next.catch(() => null))
+  return next
+}
+
+/** Whether commit `older` is an ancestor of `newer` in the relay's mirror of `rec`'s repository (false when it can't say). */
+async function before (room, rec, older, newer) {
+  try {
+    const repo = parseRepo(`https://${rec.repo}`)
+    const dir = (await room.mirrors.ensure(repo, { url: room.gitRemoteUrl(repo) })).dir
+    return (await runGit(dir, ['merge-base', '--is-ancestor', older, newer])).ok
+  } catch { return false }
+}
+
+async function noteCiResultNow (room, { repo, sha, branch, conclusion }, { fetch = globalThis.fetch, log = () => {} } = {}) {
+  try {
+    const want = String(repo).toLowerCase().replace(/^github\.com\//, '')
+    const rec = Object.values(upstreamsOf(room)).find((r) => r && r.repo && r.ref === branch && String(r.repo).toLowerCase().replace(/^github\.com\//, '') === want)
+    if (!rec || !/^[0-9a-f]{40}$/.test(sha || '')) return null
+    const failed = FAILED.has(String(conclusion))
+    if (!failed && conclusion !== 'success') return null
+    // A failure on an older commit than one that passed since (GitHub's results can come out of order) is old news.
+    if (!room.ciPassed) room.ciPassed = new Map()
+    const passed = room.ciPassed.get(branch)
+    if (!failed) room.ciPassed.set(branch, sha)
+    else if (passed && passed !== sha && room.mirrors && await before(room, rec, sha, passed)) return null
+    const map = room.doc.getMap('tasks')
+    const id = ciTaskId(room, branch)
+    const task = readTasks(map).find((t) => t.id === id)
+    const open = task && !task.archived && task.column !== 'done'
+    const comment = (text) => addComment(room.doc, room.doc.getMap('taskComments'), readTasks(map), { taskId: id, by: RELAY_BY, text }, ORIGIN)
+    if (!failed) {
+      if (!open) return null
+      comment(`CI passes again on ${branch} at ${sha.slice(0, 7)}.`)
+      updateTask(room.doc, map, { id, column: 'done' }, ORIGIN)
+      return 'closed'
+    }
+    // Which checks failed, when GitHub says (a failing suite is enough to act on).
+    let names = []
+    try {
+      const r = parseRepo(`https://${rec.repo}`)
+      const c = await githubWriter({ fetch, token: await credentialsFor(room, r), owner: r.owner, name: r.name }).checks(sha)
+      names = c.failing || []
+    } catch (err) { log(`[${room.name}] ${branch}: could not read which checks failed on ${sha.slice(0, 7)}: ${err.message}`) }
+    const what = names.length ? names.slice(0, 5).join(', ') : 'checks'
+    // The relay shut down while GitHub was asked: the room notes it when it is back (server.js runCi).
+    if (room.destroyed) return null
+    const url = `https://${rec.repo}/commit/${sha}`
+    if (open) {
+      comment(`Still failing at ${sha.slice(0, 7)}: ${what}. ${url}`)
+      return 'noted'
+    }
+    const who = await authorOf(room, rec, sha)
+    if (room.destroyed) return null
+    const title = `CI failing on ${branch}: ${what}`
+    if (task) updateTask(room.doc, map, { id, title, column: 'todo', archived: false, ...(who ? { assignee: who } : {}) }, ORIGIN)
+    else addTask(room.doc, map, { id, title, by: RELAY_BY, assignee: who, column: 'todo' }, ORIGIN)
+    comment(`GitHub's checks failed on ${branch} at ${sha.slice(0, 7)}: ${what}. ${url}${who ? ` The commit is ${who}'s.` : ''}`)
+    log(`[${room.name}] ${branch}: CI failing at ${sha.slice(0, 7)} (${what}): task ${id}${who ? ` for ${who}` : ''}`)
+    return 'opened'
+  } catch (err) {
+    log(`[${room.name}] ${branch}: could not note CI on ${String(sha).slice(0, 7)}: ${err.message}`)
+    return null
+  }
+}

package/src/relay-clash.js

@@ -0,0 +1,214 @@
+// Automatic merges on the relay (docs/superpowers/specs/2026-10-18-automatic-merges.md). Where
+// GitHub's commits and the session's work changed the same file, the relay combines them itself
+// (upstream.js combine: lines only one side changed are kept, lines both changed go to the newer
+// edit, an edit beats a deletion, a binary is the newer version) and the file lands at once: nobody
+// is asked to merge, no task, nothing held. What lost is kept (the file's history; the session's
+// version as a blob in the mirror, kept by its keep refs for RESOLVED_KEEP_MS) and whoever wrote it
+// is told: a direct message from the relay to the member whose lines lost, or a line in the
+// activity log for GitHub's. GitHub's checks failing on a commit that carried a merge tell both
+// parties; the file is never held for it.
+//
+// quilt_clash stays registered for a release (older guides call it) and answers that there is
+// nothing to do. Quilt never runs an AI itself.
+import { syncStateOf, runGit } from './relay-git.js'
+import { upstreamsOf, RELAY_ORIGIN } from './relay-upstream.js'
+import { readTasks, updateTask } from './tasks.js'
+import { RELAY_BY } from './branches.js'
+import { slug } from './github-commit.js'
+import { updateMerge } from './merges.js'
+
+export const RESOLVED_KEEP_MS = 30 * 24 * 60 * 60 * 1000
+/** quilt_clash's actions, still accepted (each answers that Quilt merges on its own). */
+export const CLASH_ACTIONS = ['propose', 'accept', 'keep_session', 'keep_github', 'keep_offline', 'revert', 'status']
+/** The most replaced lines a notice lists. */
+export const LOST_LINES_SHOWN = 12
+export const NOTHING_TO_MERGE = 'Quilt merges on its own now: where GitHub\'s commits and the session changed the same lines, the newer edit is kept, the other lines stay in the file\'s history (quilt_history), and whoever wrote them is told. Nothing to do.'
+
+const clip = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s)
+
+/** Everyone in the session: its members and its owner (who may not be in the members list): [{ id, name, kind, github? }]. */
+export function everyone (room) {
+  const out = Object.entries(room.meta.members || {}).filter(([, m]) => m && m.name).map(([id, m]) => ({ id, ...m }))
+  if (room.meta.ownerName && !out.some((m) => m.name === room.meta.ownerName)) out.push({ id: room.meta.ownerSub || '', name: room.meta.ownerName, kind: 'human', ...(room.meta.ownerGithub ? { github: room.meta.ownerGithub } : {}) })
+  return out
+}
+
+/** A git author as a member: by the agents' or people's noreply address, or the GitHub account a person linked. */
+export function memberForAuthor (room, { name = '', email = '' }) {
+  const e = String(email || '').toLowerCase()
+  const members = everyone(room)
+  let m
+  if ((m = /^([a-z0-9-]+)@agents\.noreply\.heyquilt\.com$/.exec(e))) return members.find((x) => x.kind === 'agent' && slug(x.name, 40) === m[1])?.name || null
+  if ((m = /^([a-z0-9-]+)@people\.noreply\.heyquilt\.com$/.exec(e))) return members.find((x) => x.kind !== 'agent' && slug(x.name, 40) === m[1])?.name || null
+  if ((m = /^(?:\d+\+)?([a-z0-9-]+)@users\.noreply\.github\.com$/.exec(e))) return members.find((x) => x.github && String(x.github.login).toLowerCase() === m[1])?.name || null
+  return null
+}
+
+/** The commits between `base` and `head` that changed `rel`, newest first: [{ sha, name, email, ts, subject }] (ts: commit time). */
+export async function upstreamCommits (dir, base, head, rel) {
+  const r = await runGit(dir, ['log', '--format=%H%x1f%an%x1f%ae%x1f%ct%x1f%s', `${base}..${head}`, '--', rel])
+  if (!r.ok) return []
+  return r.out.split('\n').filter(Boolean).map((l) => { const [sha, name, email, ct, subject] = l.split('\x1f'); return { sha, name, email, ts: Number(ct) * 1000, subject } })
+}
+
+/** Stores `buf` (a Buffer or text) as a blob in the mirror: its sha, or null. */
+export async function storeBlob (dir, buf) {
+  const r = await runGit(dir, ['hash-object', '-w', '--stdin'], { input: Buffer.isBuffer(buf) ? buf : Buffer.from(String(buf), 'utf8') })
+  return r.ok ? r.out.trim() : null
+}
+
+const dm = (room, to, text, kind = 'nudge') => { if (to && room.postChat) room.postChat({ by: RELAY_BY, to, kind, text }) }
+const activity = (room, entry) => {
+  if (!room.activity || !room.doc) return
+  room.doc.transact(() => {
+    room.activity.push([entry])
+    if (room.activity.length > 300) room.activity.delete(0, room.activity.length - 300)
+  }, RELAY_ORIGIN)
+}
+
+/** The replaced lines of `lost` (mergeAuto's), as a list for a notice: at most LOST_LINES_SHOWN. */
+export function lostLines (lost) {
+  const all = lost.flatMap((l) => l.lines)
+  const shown = all.slice(0, LOST_LINES_SHOWN).map((l) => `- ${clip(l, 200)}`)
+  if (all.length > shown.length) shown.push(`- and ${all.length - shown.length} more`)
+  return shown.join('\n')
+}
+
+/**
+ * The relay just combined `path` on branch `key` itself (upstream.js combine): whoever's lines lost
+ * is told, once. `lost`: combine's; `session`: { name, ts } the member who last changed it in the
+ * session; `github`: { name, member?, sha } the newest commit of GitHub's that changed it; `upstream`
+ * the upstream's name (origin/main). The session's lines lost: a direct message to that member, with
+ * the lines; GitHub's: a line in the activity log. `keptIn`: where the losing lines are kept. A notice, never a task.
+ */
+export function tellAutoMerge (room, key, { path: rel, lost = [], session = null, github = null, upstream = 'GitHub', head = '', deleted = null, keptIn = 'the file\'s history (quilt_history)', now = Date.now() }) {
+  const at = head ? ` ${head.slice(0, 7)}` : ''
+  const ghName = github ? (github.member || github.name || upstream) : upstream
+  if (deleted === 'theirs') activity(room, { by: RELAY_BY, path: rel, kind: 'merged', detail: `${upstream}${at} deleted it, but the session changed it: it stays`, branch: key, ts: now })
+  if (deleted === 'ours' && session && session.name) dm(room, session.name, `${rel} on ${key}: it was deleted in the session, but ${ghName} changed it on GitHub (${upstream}${at}), so it is back with that change. Delete it again if it should go.`)
+  const ours = lost.filter((l) => l.side === 'ours')
+  const theirs = lost.filter((l) => l.side === 'theirs')
+  if (ours.length && session && session.name) {
+    const binary = ours.some((l) => l.binary)
+    dm(room, session.name, binary
+      ? `Quilt merged ${upstream}${at} into ${key}: you and ${ghName} both changed ${rel}, a binary file, and ${ghName}'s newer version stays. Yours is kept in ${keptIn}.`
+      : `Quilt merged ${upstream}${at} into ${rel} on ${key}: where you and ${ghName} both changed the same lines, ${ghName}'s newer edit stays. The lines of yours it replaced are in ${keptIn}:\n${lostLines(ours)}`)
+  }
+  if (theirs.length) {
+    const n = theirs.reduce((k, l) => k + (l.binary ? 1 : l.lines.length), 0)
+    activity(room, { by: RELAY_BY, path: rel, kind: 'merged', detail: theirs.some((l) => l.binary) ? `kept the session's newer version over ${upstream}${at}'s` : `kept the session's newer lines over ${n} line${n === 1 ? '' : 's'} of ${upstream}${at}`, branch: key, ts: now })
+  }
+}
+
+/** A held entry from an older relay (a clash, failing checks): its task Done and its merge record closed, as Quilt merged it itself. */
+export function closeOldClash (room, key, h, { how = 'merged by Quilt', now = Date.now() } = {}) {
+  if (h.task) {
+    try {
+      const t = readTasks(room.tasks || room.doc.getMap('tasks')).find((x) => x.id === h.task)
+      if (t && t.column !== 'done') updateTask(room.doc, room.tasks || room.doc.getMap('tasks'), { id: h.task, column: 'done', verified: `${h.path}: ${how}. Quilt merges on its own now.` }, RELAY_ORIGIN)
+    } catch {}
+  }
+  if (h.mergeId) { try { const e = room.branchDoc(key); updateMerge(e.doc, e.doc.getMap('merges'), h.mergeId, { state: 'done', how: 'mine', resolvedBy: 'Quilt' }, RELAY_ORIGIN) } catch {} }
+  noteResolved(room, key, { path: h.path, kind: h.kind || 'upstream', base: h.base || null, theirs: h.theirs || null, oursBlob: h.oursBlob || null, otherBlob: h.otherBlob || null, baseBlob: h.baseBlob || null, how, at: now })
+}
+
+/** Keeps a merge's versions on record (state.resolved) for RESOLVED_KEEP_MS, so the mirror keeps their objects (relay-sync.js keptObjects). */
+export function noteResolved (room, key, entry) {
+  const state = syncStateOf(room, key)
+  if (!Array.isArray(state.resolved)) state.resolved = []
+  const now = entry.at || Date.now()
+  state.resolved.push({ ...entry, at: now })
+  state.resolved = state.resolved.filter((r) => now - r.at < RESOLVED_KEEP_MS).slice(-100)
+}
+
+/**
+ * quilt_clash, kept for older guides: every action answers that Quilt merges on its own and there
+ * is nothing to do. Resolves { ok: true, text }; never throws.
+ */
+export async function clashAction (room, { key = '', action = '' } = {}) {
+  if (action === 'status') return { ok: true, text: `No clashes${key ? ` on ${key}` : ''}. ${NOTHING_TO_MERGE}` }
+  return { ok: true, text: NOTHING_TO_MERGE }
+}
+
+export const CLASH_DESCRIPTION = 'No longer needed: Quilt merges on its own. Where GitHub\'s commits and the session changed the same lines, the newer edit is kept, the other lines stay in the file\'s history, and whoever wrote them is told. Every action answers that there is nothing to do.'
+export const clashSchema = (z) => ({
+  action: z.enum(CLASH_ACTIONS).describe('Any: there is nothing to do'),
+  path: z.string().max(1024).optional().describe('Ignored'),
+  content: z.string().max(1024 * 1024).optional().describe('Ignored'),
+  checks: z.object({ result: z.enum(['passed', 'failed', 'none']), command: z.string().max(300).optional() }).optional().describe('Ignored'),
+  force: z.boolean().optional().describe('Ignored')
+})
+
+/**
+ * A merged file (combined on the way in) is on record until it is pushed: then the commit it went
+ * in is, with both parties, so failing checks on that commit can tell them (noteMergeChecks).
+ */
+export function noteMerged (room, key, rel, parties, { now = Date.now() } = {}) {
+  const state = syncStateOf(room, key)
+  if (!state.merged || typeof state.merged !== 'object') state.merged = {}
+  state.merged[rel] = { parties, at: now }
+}
+
+/** Called by the outbound push: the merged files that went in `sha`. */
+export function notePushedMerges (room, key, sha, changed) {
+  const state = syncStateOf(room, key)
+  if (!state.merged) return
+  const files = changed.filter((rel) => state.merged[rel])
+  if (!files.length) return
+  if (!state.mergeCommits || typeof state.mergeCommits !== 'object') state.mergeCommits = {}
+  state.mergeCommits[sha] = { files, parties: files.map((rel) => state.merged[rel].parties), at: Date.now() }
+  for (const rel of files) delete state.merged[rel]
+  const keys = Object.keys(state.mergeCommits)
+  for (const k of keys.slice(0, Math.max(0, keys.length - 20))) delete state.mergeCommits[k]
+}
+
+/** The failing check runs' annotations on `sha` (REST metadata): [{ path, line }], or [] when GitHub doesn't say. */
+async function failingLines (room, key, sha) {
+  const rec = upstreamsOf(room)[key]
+  try {
+    const [owner, name] = String(rec.repo).replace(/^github\.com\//, '').split('/')
+    const token = await room.gitToken({ owner, name, slug: rec.repo })
+    const f = room.githubFetch || globalThis.fetch
+    const headers = { 'user-agent': 'quilt-relay', 'x-github-api-version': '2022-11-28', accept: 'application/vnd.github+json', ...(token ? { authorization: `Bearer ${token}` } : {}) }
+    const runs = await (await f(`https://api.github.com/repos/${owner}/${name}/commits/${sha}/check-runs?per_page=50`, { headers })).json()
+    const out = []
+    for (const r of (runs && runs.check_runs) || []) {
+      if (r.conclusion !== 'failure' || !r.id) continue
+      const ann = await (await f(`https://api.github.com/repos/${owner}/${name}/check-runs/${r.id}/annotations?per_page=50`, { headers })).json()
+      for (const a of Array.isArray(ann) ? ann : []) if (a && a.path) out.push({ path: a.path, line: a.start_line || 0, message: String(a.message || '').slice(0, 200) })
+    }
+    return out
+  } catch { return [] }
+}
+
+/**
+ * GitHub's checks on `sha` (a check_suite) finished. Failing on a commit that carried merged files:
+ * both parties of those merges are told, once, with the failing lines GitHub names. Nothing is held:
+ * the file keeps syncing, and a fix goes like any edit. Files an older relay held for failing checks
+ * are let go of. Returns what changed: [{ path, told: [names] }, { path, released: true }].
+ */
+export async function noteMergeChecks (room, key, { sha, conclusion }, { now = Date.now() } = {}) {
+  const state = syncStateOf(room, key)
+  const out = []
+  for (const h of state.held.filter((x) => x.why === 'checks')) {
+    state.held = state.held.filter((x) => x !== h)
+    closeOldClash(room, key, h, { how: 'let go of: a file is no longer held for failing checks', now })
+    if (room.outbound) room.outbound.note(key, h.path)
+    out.push({ path: h.path, released: true })
+  }
+  if (conclusion !== 'failure' && conclusion !== 'timed_out') return out
+  const mc = state.mergeCommits && state.mergeCommits[sha]
+  if (!mc || mc.told) return out
+  mc.told = now
+  const lines = await failingLines(room, key, sha)
+  const named = mc.files.filter((rel) => lines.some((l) => l.path === rel))
+  const files = named.length ? named : mc.files
+  for (const rel of files) {
+    const parties = mc.parties[mc.files.indexOf(rel)] || {}
+    const names = [...new Set([parties.session && parties.session.name, parties.github && (parties.github.member || null)].filter(Boolean))]
+    const where = lines.filter((l) => l.path === rel).slice(0, 5).map((l) => `\n- ${rel}:${l.line} ${l.message}`).join('')
+    for (const n of names) dm(room, n, `GitHub's checks failed on ${sha.slice(0, 7)}, which carried Quilt's merge of ${rel} on ${key} (your edit and ${names.find((x) => x !== n) || 'one from GitHub'}'s). It is not held: a fix goes in like any edit.${where}`)
+    out.push({ path: rel, told: names })
+  }
+  return out
+}