heyquilt 0.3.138 → 0.3.140

package/src/relay-prune.js

@@ -1,29 +1,13 @@
-// Branches leave a session by themselves, so it never fills up with finished or forgotten work
-// (each branch is a whole copy of the project in the relay's memory and disk). Two rules:
-//   - Merged: a branch whose work is in another branch the session tracks leaves the session, and
-//     its branch on GitHub is deleted. Merged means its pull request merged (relay-ask.js
-//     mergedBranches, from GitHub's webhook, or mergedByPull asking GitHub for one the webhook never
-//     told), or, for a merge made without a pull request, that all its commits are in its base
-//     branch (mergedByAncestry, looked at after the base moves).
-//   - Inactive: a branch nobody edited, committed to or was on for INACTIVE_MS leaves the session,
-//     whoever made it. It stays on GitHub.
-// Never the default branch or main, nor a branch someone is on, holds a file on, or a hosted agent
-// chose (while it was worked on this week). Work the session has that isn't on GitHub is never lost: a merged branch with edits after
-// its last commit stays, and an inactive one is kept in the relay's archive (on disk, out of the
+// Branches leave a session by themselves, so it never fills up with forgotten work (each branch is
+// a whole copy of the project in the relay's memory and disk): a branch nobody edited or was on for
+// INACTIVE_MS leaves the session, whoever made it. Never the default branch or main, nor a branch
+// someone is on, holds a file on, or a hosted agent chose (while it was worked on this week), nor a
+// square's live document. An inactive branch is kept in the relay's archive (on disk, out of the
 // session) for ARCHIVE_KEEP_MS before it goes. A branch comes back whenever someone checks it out.
-import { upstreamsOf, githubReader } from './relay-upstream.js'
-import { appCredentials } from './relay-github.js'
-import { githubWriter } from './github-commit.js'
-import { parseRepo } from './relay-upstream.js'
-import { RELAY_BY } from './branches.js'
+import { RELAY_NAME as RELAY_BY } from './ui/chat.js'
 
 export const INACTIVE_MS = 7 * 24 * 60 * 60 * 1000
 export const ARCHIVE_KEEP_MS = 30 * 24 * 60 * 60 * 1000
-export const ANCESTRY_EVERY_MS = 5 * 60 * 1000
-// A branch's pull requests are looked up this often (pull requests merged before the relay heard of them).
-export const PULLS_EVERY_MS = 60 * 60 * 1000
-// A session edit this long after a branch's last commit is work that isn't in git.
-const AFTER_COMMIT_MS = 60 * 1000
 const TRUNKS = new Set(['main', 'master'])
 
 /** Who is on which branch now: connected folders, claims, and hosted agents' choices of a branch worked on this week (chosenBranches). */
@@ -63,129 +47,6 @@ export function inactiveBranches (room, now = Date.now(), inactiveMs = INACTIVE_
     .map(([k]) => k)
 }
 
-/**
- * Whether everything the session has on branch `key` is on GitHub: it follows a GitHub branch at a
- * known commit, nothing is waiting to go there, and nobody edited it after that commit (`committedAt`).
- */
-export function savedOnGithub (room, key, committedAt = 0) {
-  const rec = upstreamsOf(room)[key]
-  if (!rec || !rec.repo || !rec.sha) return false
-  const pending = room.meta.sync && room.meta.sync[key] && room.meta.sync[key].pending
-  if (pending && Object.keys(pending).length) return false
-  const b = room.meta.branches[key]
-  return !(b && b.changed && committedAt && b.changed > committedAt + AFTER_COMMIT_MS)
-}
-
-/**
- * Merges made without a pull request: for each session branch following GitHub, whether all its
- * commits are in its base (the branch it started from), the default branch, or main. GitHub is asked
- * only when one of the two commits moved since it was last asked. Marks them merged (the way a pull
- * request's merge is recorded) and returns their keys.
- */
-export async function mergedByAncestry (room, { reader, now = Date.now(), patchesIn = null } = {}) {
-  const ups = upstreamsOf(room)
-  const marked = []
-  for (const [key, b] of Object.entries(room.meta.branches)) {
-    const rec = ups[key]
-    if (!rec || !rec.sha || !rec.repo || (rec.merged && rec.merged.at) || key === room.defaultKey || TRUNKS.has(key)) continue
-    const bases = new Set([b && b.base, room.defaultKey, ...TRUNKS].filter((x) => x && x !== key && room.meta.branches[x]))
-    for (const base of bases) {
-      const brec = ups[base]
-      if (!brec || !brec.sha || brec.repo !== rec.repo || brec.sha === rec.sha && !b.changed) continue
-      const asked = `${brec.sha}:${rec.sha}`
-      rec.ancestry = rec.ancestry || {}
-      if (rec.ancestry[base] === asked) continue
-      const gh = await reader(rec.repo)
-      if (!gh) break
-      let cmp
-      try { cmp = await gh.compare(brec.sha, rec.sha) } catch { continue } // looked at again next time
-      rec.ancestry[base] = asked
-      // Diverged, but every commit of the branch is already in the base as the same change (cherry-picked, or
-      // rebased in without a pull request): `patchesIn(base, head)` asks the relay's git mirror (git cherry).
-      const samePatches = cmp && cmp.status === 'diverged' && patchesIn ? await patchesIn(rec.repo, brec.sha, rec.sha).catch(() => false) : false
-      if (!cmp || (cmp.status !== 'behind' && cmp.status !== 'identical' && !samePatches)) continue
-      // Edited in the session after its last commit: that work isn't in git, so it isn't merged.
-      if (b && b.changed) {
-        let at = 0
-        try { at = await gh.committedAt(rec.sha) } catch { continue }
-        if (b.changed > at + AFTER_COMMIT_MS) continue
-      }
-      // Every commit of the branch is in its base: merged, as far as git can tell. A branch never
-      // committed to (identical to where it started) has nothing of its own either way.
-      rec.merged = { at: now, into: brec.ref || base, number: null, sha: brec.sha, via: 'commits' }
-      marked.push(key)
-      break
-    }
-  }
-  if (marked.length && room.saveMeta) room.saveMeta()
-  return marked
-}
-
-/**
- * Pull requests merged before the relay recorded merges, or whose webhook never came: for each
- * session branch with no merge recorded, asks the session's repository (at most every
- * PULLS_EVERY_MS a branch) for a merged pull request from it into a branch the session has, made
- * after the branch came into the session (an older one is another branch of the same name). Marks
- * them merged as the webhook would and returns their keys.
- */
-export async function mergedByPull (room, { reader, now = Date.now(), lookedAt = new Map(), log = () => {} } = {}) {
-  const ups = upstreamsOf(room)
-  const repo = (ups[room.defaultKey] && ups[room.defaultKey].repo) || (ups.main && ups.main.repo)
-  if (!repo) return []
-  const marked = []
-  let gh
-  for (const [key, b] of Object.entries(room.meta.branches)) {
-    const rec = ups[key]
-    if ((rec && rec.merged && rec.merged.at) || key === room.defaultKey || TRUNKS.has(key) || key.startsWith('@')) continue
-    if (rec && rec.repo && rec.repo !== repo) continue
-    if (now - (lookedAt.get(key) || 0) < PULLS_EVERY_MS) continue
-    if (gh === undefined) gh = await reader(repo)
-    if (!gh) return marked
-    const ref = (rec && rec.ref) || key
-    let pull
-    try { pull = await gh.mergedPull(ref) } catch (err) { log(`[${room.name}] could not look up ${ref}'s pull requests: ${err.message}`); return marked } // looked at again next time
-    lookedAt.set(key, now)
-    if (!pull || !pull.base || !(pull.mergedAt > 0) || pull.base === ref) continue
-    const into = room.resolveKey ? room.resolveKey(pull.base) : pull.base
-    if (!room.meta.branches[into] || into === key) continue
-    if (b && b.at && b.at > pull.mergedAt) continue
-    const merged = { at: pull.mergedAt, into: pull.base, number: pull.number, sha: pull.sha, via: 'pull' }
-    if (rec) rec.merged = merged
-    else ups[key] = { merged: { ...merged, repo, ref } } // not followed on GitHub: only the merge, and where its branch was
-    marked.push(key)
-  }
-  if (marked.length && room.saveMeta) room.saveMeta()
-  return marked
-}
-
-/** Whether every commit of `head` not in `base` is in `base` as the same change (`git cherry` in mirror `dir`; both commits there). */
-export async function samePatches (dir, base, head) {
-  const { runGit } = await import('./relay-git.js')
-  const out = await runGit(dir, ['cherry', base, head])
-  if (!out.ok) return false
-  const lines = out.out.split('\n').filter(Boolean)
-  return lines.length > 0 && lines.every((l) => l.startsWith('-'))
-}
-
-/** Deletes merged branch `ref` on GitHub, unless it is a trunk or still has an open pull request. Never throws. */
-export async function deleteOnGithub (room, repoStr, ref, { fetch, log = () => {} } = {}) {
-  if (!ref || TRUNKS.has(ref)) return false
-  const repo = parseRepo(`https://${repoStr}`)
-  if (!repo || !repo.github) return false
-  try {
-    const { token } = await appCredentials(room, `${repo.owner}/${repo.name}`, { access: 'write', fresh: false })
-    if (!token) return false
-    const res = await fetch(`https://api.github.com/repos/${repo.owner}/${repo.name}/pulls?state=open&head=${encodeURIComponent(`${repo.owner}:${ref}`)}`, { headers: { authorization: `Bearer ${token}`, accept: 'application/vnd.github+json', 'user-agent': 'quilt-relay', 'x-github-api-version': '2022-11-28' } })
-    const open = res.ok ? await res.json() : null
-    if (!Array.isArray(open) || open.length) return false // can't tell, or a pull request is still open: leave it
-    await githubWriter({ fetch, token, owner: repo.owner, name: repo.name }).deleteBranch(ref)
-    return true
-  } catch (err) {
-    log(`[${room.name}] could not delete ${ref} on GitHub: ${err.message}`)
-    return false
-  }
-}
-
 /** One chat line for what left the session, so nobody is surprised. */
 export function pruneNotice ({ merged = [], inactive = [], archived = [] }) {
   const parts = []

package/src/relay-turn-sync.js

@@ -24,7 +24,7 @@ import { applyTextDiff } from './textdiff.js'
 import { isSafeRelPath, LARGE_FILE_BYTES } from './pathrules.js'
 import { openMerge, updateMerge, readMerges, cleanName, MAX_RECORD_TEXT } from './merges.js'
 import { unionMatcher } from './merge3.js'
-import { RELAY_BY, isRelay } from './branches.js'
+import { RELAY_NAME as RELAY_BY, isRelay } from './ui/chat.js'
 import { decide, planSync, nextCheckpoint, mergeTexts, behind, sessionEntry, SKIP } from './turn-sync-plan.js'
 
 export const SLOT = /^[A-Za-z0-9_-]{8,64}$/