heyquilt 0.3.138 → 0.3.141

package/src/clash.js

@@ -1,128 +0,0 @@
-// Commits from outside that a folder can't bring in (git couldn't read a file
-// they change: too large, or behind a filter such as Git LFS) are handed to ONE
-// member as a task on the board, instead of every folder behind on that branch
-// telling its AI. Files both sides changed never come here: Quilt combines them
-// itself (upstream.js combine). Each folder that reports the clash works out the same owner from
-// presence; only the owner's Quilt writes the task, under an id derived from
-// the branch and the upstream commit, so two that race write the same task.
-// Pure: Session (reviewClash) reads presence and the board and applies these.
-import crypto from 'node:crypto'
-import { MAX_FILES, MAX_TITLE } from './tasks.js'
-
-const HEX_ID = /^[0-9a-f]{16}$/
-const SHA = /^[0-9a-f]{7,64}$/
-
-/** The task id for a clash on `branch` with upstream commit `sha`: the same in every member's Quilt. */
-export function clashTaskId (branch, sha) {
-  return crypto.createHash('sha256').update(`quilt-clash\n${branch}\n${sha}`).digest('hex').slice(0, 16)
-}
-
-/** A clash record from the room's "clashes" map (branch -> record), or null for anything else. */
-export function readClash (value, branch) {
-  if (!value || typeof value !== 'object') return null
-  if (typeof value.task !== 'string' || !HEX_ID.test(value.task)) return null
-  if (typeof value.sha !== 'string' || !SHA.test(value.sha)) return null
-  if (typeof value.upstream !== 'string' || !value.upstream || value.upstream.length > 200) return null
-  const ts = Number.isFinite(value.ts) ? value.ts : 0
-  return { branch, task: value.task, sha: value.sha, upstream: value.upstream, ts }
-}
-
-/** Whether a member's presence shows a live AI session working through its app (persona.js). */
-export function hasAi (st) {
-  return !!st && Array.isArray(st.personas) && st.personas.some((p) => p && typeof p.name === 'string' && p.name)
-}
-
-/**
- * The members who may take this clash: their folder is on `branch` with `upstream` as its
- * upstream and reports clashing files (not a diverged branch: that history is the folder's own),
- * their Quilt hands clashes out (git.clash 1), and they may change the clashing files.
- * `states`: [[clientID, presence state]], this member's own included.
- * Each: { id, name, kind, ai, rank } (rank 0 an agent member, 1 a person with an AI session, 2 a person).
- */
-export function clashCandidates (states, { branch, upstream }) {
-  const out = []
-  for (const [id, st] of states) {
-    if (!st || typeof st.name !== 'string' || !st.name || !st.git || typeof st.git !== 'object') continue
-    const g = st.git
-    const u = g.upstream
-    if (g.clash !== 1 || g.branch !== branch || !u || u.name !== upstream) continue
-    // A folder whose fetch fails can't pull, so its AI couldn't merge.
-    if (!(u.conflicts > 0) || u.diverged || u.mayWrite !== true || u.fetchOk === false) continue
-    const agent = st.kind === 'agent'
-    const ai = !agent && hasAi(st)
-    out.push({ id, name: st.name, kind: agent ? 'agent' : 'human', ai, rank: agent ? 0 : ai ? 1 : 2 })
-  }
-  return out
-}
-
-/** The candidates in the order they take the clash: an agent member first, then a person with an AI, then anyone; the lowest client id among equals. */
-export function clashOrder (candidates) {
-  return [...candidates].sort((a, b) => a.rank - b.rank || a.id - b.id)
-}
-
-/** Who takes the clash (the first in clashOrder not in `except`), or null. */
-export function pickClashOwner (candidates, { except = [] } = {}) {
-  return clashOrder(candidates.filter((c) => !except.includes(c.name)))[0] || null
-}
-
-/**
- * The presence state of whoever `assignee` is (a member, or one of a member's AI sessions),
- * counted only when that member's folder is on `branch`; null when they are not here.
- */
-export function holderOf (states, assignee, branch) {
-  for (const [id, st] of states) {
-    if (!st || !st.git || st.git.branch !== branch) continue
-    if (st.name === assignee || (Array.isArray(st.personas) && st.personas.some((p) => p && p.name === assignee))) return { id, st, rank: st.kind === 'agent' ? 0 : hasAi(st) ? 1 : 2 }
-  }
-  return null
-}
-
-/** How a task's assignee is named in a notice and on the branch list: an agent by name, a person as "<name>'s AI". */
-export function ownerLabel ({ assignee, forAi }) {
-  return forAi ? `${assignee}'s AI` : assignee
-}
-
-const n = (k, w) => `${k} ${w}${k === 1 ? '' : 's'}`
-
-/** The task's title: "Bring 4 commits from origin/main into the session: src/a.js, src/b.js clash". */
-export function clashTitle ({ upstream, behind, conflicts = [] }) {
-  const head = `Bring ${n(behind, 'commit')} from ${upstream} into the session: `
-  const paths = conflicts.map((c) => c.path)
-  const tail = paths.length === 1 ? ' clashes' : ' clash'
-  const text = (shown) => {
-    const rest = paths.length - shown.length
-    return head + shown.join(', ') + (rest ? ` and ${rest} more` : '') + tail
-  }
-  let shown = []
-  for (const p of paths) {
-    const next = [...shown, p]
-    if (shown.length && text(next).length > MAX_TITLE) break
-    shown = next
-  }
-  return text(shown).slice(0, MAX_TITLE)
-}
-
-/** The files the task lists (the board keeps at most MAX_FILES). */
-export function clashFiles (conflicts = []) {
-  return [...new Set(conflicts.map((c) => c.path))].slice(0, MAX_FILES)
-}
-
-/** The task's description, as its first comment: each file and why. Nobody is asked to pull or merge. */
-export function clashBrief ({ branch, upstream, sha, behind, conflicts = [] }) {
-  const lines = [`${n(behind, 'commit')} on ${upstream} (up to ${sha.slice(0, 7)}) change files Quilt can't read here, so it brought nothing in yet:`]
-  for (const c of conflicts.slice(0, 30)) lines.push(`- ${c.path}: ${c.why}`)
-  if (conflicts.length > 30) lines.push(`- and ${conflicts.length - 30} more`)
-  lines.push('', `Files both sides changed are combined by Quilt on its own; nothing here needs merging by hand. Once a folder on \`${branch}\` that can read these files is at ${sha.slice(0, 7)} or later, every other folder follows it and Quilt closes this task by itself: no need to move it.`)
-  return lines.join('\n')
-}
-
-/** The notice for a member whose folder is behind but who is not merging: leave it to the owner. */
-export function leaveItNotice ({ label, upstream, task, facts }) {
-  return `${label} is bringing in the commits from ${upstream} (task ${task}); leave those files to them.${facts ? ` ${facts}` : ''}`
-}
-
-/** What a folder that reports the clash knows about it, without the advice to pull. */
-export function clashFacts ({ branch, upstream, behind, conflicts = [] }) {
-  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 bring them in.`
-}

package/src/commit-request.js

@@ -1,59 +0,0 @@
-// Commit requests (quilt_request_commit): an AI or a person asks for a commit, says what it
-// is for and which files changed, and the session owner (whose machine usually commits) is
-// told with a direct message. Shared by the folder's Session and the relay's hosted MCP so
-// both build the same request and the same message.
-import { isSafeRelPath } from './pathrules.js'
-
-export const MAX_COMMIT_MESSAGE = 500
-export const MAX_COMMIT_DESCRIPTION = 2000
-export const MAX_COMMIT_FILES = 100
-
-/** The changed files an agent listed: clean relative paths, no duplicates, at most MAX_COMMIT_FILES. */
-export function cleanCommitFiles (files) {
-  if (files == null) return []
-  if (!Array.isArray(files)) throw new Error('files must be a list of paths')
-  const out = []
-  for (const f of files) {
-    const rel = String(f == null ? '' : f).trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
-    if (!rel) continue
-    if (!isSafeRelPath(rel)) throw new Error(`not a path in the project: ${String(f).slice(0, 200)}`)
-    if (!out.includes(rel)) out.push(rel)
-  }
-  if (out.length > MAX_COMMIT_FILES) throw new Error(`list at most ${MAX_COMMIT_FILES} files`)
-  return out
-}
-
-/** The owner's name from a member list ({ name, role }), or ''. */
-export function ownerName (members) {
-  const o = (members || []).find((m) => m && m.role === 'owner' && m.name)
-  return o ? String(o.name) : ''
-}
-
-/** A new open request. Throws when there is nothing to say. */
-export function makeCommitRequest ({ id, by, message, description = '', files = [], branch = '', ts = Date.now() }) {
-  const msg = String(message || '').trim().slice(0, MAX_COMMIT_MESSAGE)
-  if (!msg) throw new Error('say what the commit is for')
-  const desc = String(description || '').trim().slice(0, MAX_COMMIT_DESCRIPTION)
-  const list = cleanCommitFiles(files)
-  return { id, by, message: msg, ...(desc ? { description: desc } : {}), ...(list.length ? { files: list } : {}), ...(branch ? { branch } : {}), ts, state: 'open' }
-}
-
-/** What the owner is told: who wants a commit, what for, which files, and how to settle it. */
-export function commitRequestText (r, { defaultBranch = 'main' } = {}) {
-  const branch = r.branch && r.branch !== defaultBranch ? ` on \`${r.branch}\`` : ''
-  const files = r.files && r.files.length
-    ? ` Files (${r.files.length}): ${r.files.slice(0, 20).join(', ')}${r.files.length > 20 ? `, and ${r.files.length - 20} more` : ''}.`
-    : ''
-  const desc = r.description ? ` ${r.description.replace(/\s+/g, ' ')}` : ''
-  return `📌 Commit requested${branch} (${r.id}): ${r.message.replace(/[.!?]+$/, '')}.${desc}${files} ` +
-    'Commit with git when it is a good moment (quilt_commit_status), then mark it done with quilt_commit_request_done.'
-}
-
-/** The chat message that tells the owner, or null when there is no owner to tell or the owner asked. */
-export function commitRequestMessage (r, { owner, id, defaultBranch, of = null }) {
-  if (!owner || owner === r.by) return null
-  return { id, by: r.by, to: owner, text: commitRequestText(r, { defaultBranch }), ts: r.ts, kind: 'commit', commit: r.id, ...(of ? { of } : {}) }
-}
-
-/** A message that tells the owner about a commit request: settled by committing, not by a reply. */
-export const commitRequestNote = (m) => !!m && m.kind === 'commit'

package/src/commit.js

@@ -1,213 +0,0 @@
-// Commit requests, committed in a person's folder with git: exactly the files a request names
-// (those that differ from HEAD), with its message, then pushed to the branch's upstream. This is
-// the way in when the relay can't commit for the asker (relay-commit.js: no GitHub token, a
-// repository not on GitHub, or the owner keeps agents from committing): a person commits it from
-// the app's commit panel (session.js: commitRequest).
-//
-// Committing touches no file: `git commit --only -- <paths>` moves the branch and the index
-// entries of those paths, and leaves everything else (other people's uncommitted work, files
-// someone staged by hand) as it was. Quilt never merges history: a push git refuses (the
-// remote moved on) is reported, not forced.
-//
-// The pure parts (who changed which uncommitted file, what a person should know before
-// committing a request, the commit message) are here too, so the app, the daemon and tests agree.
-import { execFile } from 'node:child_process'
-import { isSafeRelPath, globMatcher } from './pathrules.js'
-
-export const COMMIT_TIMEOUT_MS = 60 * 1000 // a pre-commit hook may run tests
-export const PUSH_TIMEOUT_MS = 90 * 1000
-export const MAX_REQUEST_FILES = 500
-export const MAX_MESSAGE = 500
-// How long a request is left alone after it is made: the asker's AI may still be saving its files.
-export const REQUEST_SETTLE_MS = 60 * 1000
-
-const NO_PROMPT = { GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_OPTIONAL_LOCKS: '0' }
-
-/** Runs git: { ok, out, err }. Never rejects. */
-function git (root, args, { timeout = 15000, env = {} } = {}) {
-  return new Promise((resolve) => {
-    let child
-    try {
-      child = execFile(process.env.QUILT_GIT || 'git', args, { cwd: root, timeout, maxBuffer: 64 * 1024 * 1024, env: { ...process.env, ...NO_PROMPT, ...env } },
-        (err, stdout, stderr) => resolve({ ok: !err, out: String(stdout || ''), err: String(stderr || (err && err.message) || '') }))
-    } catch (err) { return resolve({ ok: false, out: '', err: err.message }) }
-    child.stdin.end()
-  })
-}
-
-/** The paths a request may name: relative, inside the folder, no duplicates. */
-export function cleanFiles (files) {
-  const out = []
-  for (const f of Array.isArray(files) ? files : []) {
-    const p = String(f || '').trim().replace(/\\/g, '/').replace(/^\.\//, '')
-    if (!isSafeRelPath(p) || out.includes(p)) continue
-    out.push(p)
-    if (out.length >= MAX_REQUEST_FILES) break
-  }
-  return out
-}
-
-/**
- * Which of `files` differ from HEAD (changed, new or deleted, not ignored): Map path -> 'M' | 'A' | 'D'.
- * Null when git can't say.
- */
-export async function uncommitted (root, files = null) {
-  const args = ['-c', 'core.quotePath=false', 'status', '--porcelain=v1', '-z', '--no-renames', '--untracked-files=all']
-  if (files) {
-    if (!files.length) return new Map()
-    args.push('--', ...files.map((f) => `:(literal)${f}`))
-  }
-  const r = await git(root, args)
-  if (!r.ok) return null
-  const out = new Map()
-  for (const rec of r.out.split('\0')) {
-    if (rec.length < 4) continue
-    const xy = rec.slice(0, 2)
-    const rel = rec.slice(3)
-    if (xy === '!!') continue
-    out.set(rel, xy === '??' || xy.includes('A') ? 'A' : xy.includes('D') ? 'D' : 'M')
-  }
-  return out
-}
-
-/** When each path was last committed (ms), from the newest `depth` commits: Map path -> ts. */
-export async function lastCommitted (root, { depth = 2000 } = {}) {
-  const r = await git(root, ['-c', 'core.quotePath=false', 'log', `-n${depth}`, '--format=%x00%ct', '--name-only', 'HEAD'])
-  const out = new Map()
-  if (!r.ok) return out
-  let ts = 0
-  for (const line of r.out.split('\n')) {
-    if (line.startsWith('\0')) { ts = Number(line.slice(1)) * 1000 || 0; continue }
-    if (line && !out.has(line)) out.set(line, ts)
-  }
-  return out
-}
-
-/**
- * Commits the request's files that differ from HEAD, and pushes. Resolves
- * { hash, files, pushed, pushError, nothing } or throws with a plain reason (git refused, a hook failed).
- * `push` false only commits. `upstream` is { remote, name } (gitstate.upstreamOf); without one nothing is pushed.
- */
-export async function commitFiles (root, { files, message, push = true, upstream = null, branch = '' } = {}) {
-  const wanted = cleanFiles(files)
-  const changed = await uncommitted(root, wanted)
-  if (!changed) throw new Error('git could not read this folder')
-  const paths = wanted.filter((f) => changed.has(f))
-  if (!paths.length) return { hash: null, files: [], pushed: false, pushError: null, nothing: true }
-  const spec = paths.map((f) => `:(literal)${f}`)
-  // New files must be known to git before `commit --only` takes them; deletions are taken as they are.
-  const added = paths.filter((f) => changed.get(f) === 'A')
-  if (added.length) {
-    const a = await git(root, ['add', '--', ...added.map((f) => `:(literal)${f}`)])
-    if (!a.ok) throw new Error(`git add failed: ${firstLine(a.err)}`)
-  }
-  const c = await git(root, ['commit', '--only', '--no-edit', '-m', message, '--', ...spec], { timeout: COMMIT_TIMEOUT_MS })
-  if (!c.ok) {
-    // Leave nothing half-done: what was added for this commit goes back to untracked.
-    if (added.length) await git(root, ['reset', '-q', '--', ...added.map((f) => `:(literal)${f}`)])
-    throw new Error(`git commit failed: ${firstLine(c.err || c.out)}`)
-  }
-  const hash = (await git(root, ['rev-parse', 'HEAD'])).out.trim()
-  if (!push || !upstream || !upstream.remote || upstream.remote === '.') return { hash, files: paths, pushed: false, pushError: upstream ? null : 'this branch has no upstream to push to', nothing: false }
-  const target = String(upstream.name || '').startsWith(`${upstream.remote}/`) ? upstream.name.slice(upstream.remote.length + 1) : branch
-  const p = await git(root, ['-c', 'core.askPass=', 'push', '--quiet', upstream.remote, `HEAD:refs/heads/${target}`], {
-    timeout: PUSH_TIMEOUT_MS,
-    env: { GIT_ASKPASS: '', SSH_ASKPASS: '', GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || 'ssh -o BatchMode=yes' }
-  })
-  return { hash, files: paths, pushed: p.ok, pushError: p.ok ? null : pushProblem(p.err, upstream.remote, target), nothing: false }
-}
-
-const firstLine = (s) => String(s || '').split('\n').map((l) => l.replace(/^(fatal|error):\s*/i, '').trim()).find(Boolean)?.slice(0, 200) || 'unknown error'
-
-/** Why a push failed, in plain words (never a URL: it may carry credentials). */
-export function pushProblem (stderr, remote = 'origin', branch = '') {
-  const e = String(stderr || '').toLowerCase()
-  if (/non-fast-forward|fetch first|rejected/.test(e)) return `${remote}/${branch} has commits this folder doesn't have yet: the commit is made here and will be pushed after Quilt catches the branch up`
-  if (/could not read (username|password)|terminal prompts disabled|authentication failed|permission denied|repository not found|could not read from remote|access denied|returned error: 40[13]/.test(e)) return `git can't sign in to ${remote} from this folder to push`
-  if (/could not resolve host|failed to connect|unable to access|network is unreachable|timed out/.test(e)) return `can't reach ${remote} (no network?)`
-  return `git push failed: ${firstLine(stderr).replace(/[a-z]+:\/\/[^\s'"]*@/gi, '')}`
-}
-
-/** The commit message: what the request says, and who asked (and for which task). */
-export function commitMessage (r) {
-  const first = String(r.message || '').trim().split('\n')[0].slice(0, 120) || 'Changes from the Quilt session'
-  const rest = String(r.message || '').trim().split('\n').slice(1).join('\n').trim()
-  const by = r.by ? `Asked for by ${r.by} in Quilt${r.task ? ` (task ${r.task.id}: ${r.task.title})` : ''}.` : ''
-  return [first, rest, by].filter(Boolean).join('\n\n')
-}
-
-/**
- * Who made each uncommitted change, from the session's history: for each path in `dirty`, the
- * people whose own edits (not pulls from git) to it came after it was last committed.
- * Returns Map path -> [names], newest editor last. `history`: entries, oldest first.
- */
-export function editorsSince (dirty, history, committedAt = new Map()) {
-  const out = new Map()
-  for (const rel of dirty) out.set(rel, [])
-  for (const e of history || []) {
-    if (!e || !out.has(e.path) || e.pulled || !e.by) continue
-    if ((e.ts || 0) <= (committedAt.get(e.path) || 0)) continue
-    const list = out.get(e.path)
-    const i = list.indexOf(e.by)
-    if (i >= 0) list.splice(i, 1)
-    list.push(e.by)
-  }
-  return out
-}
-
-/**
- * Uncommitted work grouped by who made it: [{ by, files }], most files first. A file several
- * people changed is listed under each. Files no history entry explains go under ''.
- */
-export function uncommittedByPerson (editors) {
-  const groups = new Map()
-  for (const [rel, names] of editors) {
-    for (const n of names.length ? names : ['']) {
-      if (!groups.has(n)) groups.set(n, [])
-      groups.get(n).push(rel)
-    }
-  }
-  return [...groups].map(([by, files]) => ({ by, files: files.sort() })).sort((a, b) => b.files.length - a.files.length || a.by.localeCompare(b.by))
-}
-
-/**
- * What the person committing a request should know first, or '': a file with conflict markers,
- * one that also holds others' uncommitted changes (they would go in too), one someone else holds,
- * or an asker still at work.
- */
-export function requestWarning (r, { editors, claims = [], markers = new Set(), taskEditors = new Set(), busy = [], now = Date.now() } = {}) {
-  if (now - (r.ts || 0) < REQUEST_SETTLE_MS) return 'just asked'
-  if (busy.includes(r.by)) return `${r.by} is still working`
-  for (const [rel, names] of editors) {
-    if (markers.has(rel)) return `${rel} has conflict markers`
-    const others = names.filter((n) => n !== r.by && !taskEditors.has(n))
-    if (others.length) return `${rel} also has uncommitted changes by ${others.join(', ')}`
-    const held = claims.find((c) => c && c.by && c.by !== r.by && globMatcher(String(c.pattern || ''))(rel))
-    if (held) return `${held.by} holds ${rel}`
-  }
-  return ''
-}
-
-// ------------------------------------------------------------- words --
-// The same for the local and the hosted tools, and the HTTP routes' docs.
-
-export const REQUEST_COMMIT_DESCRIPTION = 'Ask a person to commit your finished work, when you can\'t get it into git yourself (the owner keeps agents from committing, nobody has connected GitHub, or the repository is not on GitHub). ' +
-  'A person with git on this branch commits exactly these files (those that differ from git) with your message, from their app, and you are told the commit. ' +
-  'Give the files you changed; without them, the task\'s changes (task) or every change of yours on record are asked for.'
-
-/** Open requests (with ids, files and what holds them up) and recent commits, as lines for an agent. */
-export function describeCommitRequests (c, { canCommit = false } = {}) {
-  const lines = []
-  const open = c.open || []
-  if (open.length) {
-    lines.push('Open commit requests:')
-    for (const r of open) {
-      const files = Array.isArray(r.files) && r.files.length ? ` (${r.files.length} file${r.files.length === 1 ? '' : 's'}: ${r.files.slice(0, 8).join(', ')}${r.files.length > 8 ? ', …' : ''})` : ''
-      lines.push(`- [${r.id}] ${r.by}${r.branch ? ` on \`${r.branch}\`` : ''}: ${r.message}${r.task ? ` (task ${r.task.id})` : ''}${files}${r.error ? `. Last try: ${r.error}` : ''}`)
-    }
-    lines.push(canCommit ? 'This folder has git: its app commits a request with its Commit button.' : 'A person with git on that branch commits them from their app; the asker is told the commit.')
-  } else lines.push('No open commit requests.')
-  const recent = (c.recent || []).filter((r) => r.hash)
-  if (recent.length) lines.push('Committed lately:', ...recent.map((r) => `- ${r.hash.slice(0, 7)} ${r.message} (${r.by}${r.pushed === false ? `; not pushed${r.pushError ? `: ${r.pushError}` : ''}` : ''})`))
-  return lines.join('\n')
-}

package/src/git-hook.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-// The hooks of the relay's git views (relay-githttp.js): git runs this for a push into a session's
-// view, with the ref updates on stdin. The relay decides (QUILT_HOOK_URL, a secret only this relay
-// process knows): before the refs move ("pre-receive") it checks the push and puts it on GitHub;
-// after ("post-receive") it sets the view's branches back to what GitHub has. What the relay says is
-// printed for the person or agent pushing ("remote: …").
-import http from 'node:http'
-import path from 'node:path'
-
-// git gives hooks some paths relative to the repository (GIT_DIR=.): the relay needs them whole.
-const whole = (p) => (p ? path.resolve(process.cwd(), p) : '')
-const wholeList = (l) => String(l || '').split(path.delimiter).filter(Boolean).map(whole).join(path.delimiter)
-
-const phase = process.argv[2] === 'post-receive' ? 'post' : 'pre'
-let input = ''
-process.stdin.setEncoding('utf8')
-process.stdin.on('data', (d) => { input += d })
-process.stdin.on('end', () => {
-  const url = process.env.QUILT_HOOK_URL
-  if (!url) { process.stderr.write('Quilt: this push did not come through the relay.\n'); process.exit(phase === 'pre' ? 1 : 0) }
-  const body = JSON.stringify({
-    phase,
-    room: process.env.QUILT_ROOM || '',
-    who: process.env.QUILT_WHO || '',
-    name: process.env.QUILT_WHO_NAME || '',
-    updates: input,
-    env: {
-      GIT_DIR: whole(process.env.GIT_DIR || '.'),
-      GIT_OBJECT_DIRECTORY: whole(process.env.GIT_OBJECT_DIRECTORY),
-      GIT_ALTERNATE_OBJECT_DIRECTORIES: wholeList(process.env.GIT_ALTERNATE_OBJECT_DIRECTORIES),
-      GIT_QUARANTINE_PATH: whole(process.env.GIT_QUARANTINE_PATH)
-    }
-  })
-  const req = http.request(url, { method: 'POST', headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), authorization: `Bearer ${process.env.QUILT_HOOK_TOKEN || ''}` }, timeout: 10 * 60 * 1000 }, (res) => {
-    let out = ''
-    res.setEncoding('utf8')
-    res.on('data', (d) => { out += d })
-    res.on('end', () => {
-      let r = null
-      try { r = JSON.parse(out) } catch {}
-      if (r && r.message) process.stderr.write(`${r.message}\n`)
-      process.exit(r && r.ok ? 0 : (phase === 'pre' ? 1 : 0))
-    })
-  })
-  req.on('error', (err) => { process.stderr.write(`Quilt: the relay did not answer (${err.message}).\n`); process.exit(phase === 'pre' ? 1 : 0) })
-  req.on('timeout', () => req.destroy(new Error('it took too long')))
-  req.end(body)
-})

package/src/gitignore.js

@@ -1,49 +0,0 @@
-// Quilt keeps a session's local state in .quilt/. In a git folder that is an
-// untracked folder, so `git stash -u` or `git clean -fd` would take it away. The
-// project's own .gitignore is where git is told to leave it alone: a line is
-// added there (and shared, like any edit of .gitignore). Nothing under .git is
-// ever touched.
-import fs from 'node:fs'
-import path from 'node:path'
-import { gitDir } from './gitstate.js'
-
-const IGNORES_QUILT = new Set(['.quilt', '.quilt/', '/.quilt', '/.quilt/'])
-export const QUILT_IGNORE_COMMENT = "# Quilt keeps this session's local state here"
-
-/**
- * Whether .gitignore's text already has a line ignoring .quilt. Trailing
- * spaces don't count (git drops them); leading ones are part of the pattern.
- */
-export function ignoresQuilt (text) {
-  return String(text).split(/\r?\n/).some((line) => IGNORES_QUILT.has(line.replace(/\s+$/, '')))
-}
-
-/**
- * In a git folder, makes sure .gitignore ignores .quilt/: appends a comment
- * and `.quilt/` when no line does (creating the file if need be, in its own
- * line endings). Returns { added: true }, { added: false } (nothing to do:
- * not a git folder, or already ignored), or { added: false, error } when
- * .gitignore couldn't be read or written.
- */
-export function ensureQuiltIgnored (root) {
-  if (!gitDir(root)) return { added: false }
-  const file = path.join(root, '.gitignore')
-  let text = ''
-  try {
-    const st = fs.lstatSync(file)
-    if (!st.isFile()) return { added: false, error: new Error('.gitignore is not a plain file') }
-    text = fs.readFileSync(file, 'utf8')
-  } catch (err) {
-    if (err.code !== 'ENOENT') return { added: false, error: err }
-  }
-  if (ignoresQuilt(text)) return { added: false }
-  const eol = text.includes('\r\n') ? '\r\n' : '\n'
-  const lead = text && !text.endsWith('\n') ? eol : ''
-  try {
-    // Appended, so the file's own bytes stay as they are; O_NOFOLLOW: never through a link put there meanwhile.
-    fs.writeFileSync(file, `${lead}${QUILT_IGNORE_COMMENT}${eol}.quilt/${eol}`, { flag: fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND | (fs.constants.O_NOFOLLOW || 0) })
-  } catch (err) {
-    return { added: false, error: err }
-  }
-  return { added: true }
-}