heyquilt 0.3.121 → 0.3.138

package/src/quilts/cli.js

@@ -1,449 +0,0 @@
-// `seam <verb>`, Quilt source control's own command (the @heyquilt/seam package, seam/): git's
-// command names and flags (plans/quilt-source-control/12), answered by the server. Inside a block
-// folder (.seam/block.json) the quilt and square come from the folder; elsewhere name them with
-// --quilt and --square. It is not part of the Quilt app's `quilt` command.
-import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
-import { quiltClient } from './client.js'
-import { findBlock, checkout, status as blockStatus, commitFolder, amendFolder, syncTo, localDiff, saveBlock, restore, reset, clean, localChanges } from './block.js'
-import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents, describeTag, describeRelease, describeImport, describeRestore, describeReset, describeClean, describeLive, describeClaims, describeResolutions, describeLiveSet, describeMergeBase, describeGrep, describeBisect, describeCheck, describeReviews, describeReviewed, describeSquareCheck, describePolicy, describeKeys, describeTokens, describeNewToken } from './describe.js'
-import { signWithLocalKey, localKey, makeLocalKey, signingKeyFile } from './signing.js'
-
-export const API_URL = 'https://api.heyquilt.com'
-
-/** The verbs `seam` answers. */
-export const SEAM_VERBS = new Set(['quilts', 'square', 'checkout', 'status', 'commit', 'log', 'show', 'diff', 'merge', 'rebase', 'revert', 'cherry-pick', 'blame', 'resolve', 'cat', 'ls', 'import', 'export', 'events', 'tag', 'release', 'line', 'restore', 'reset', 'clean', 'live', 'bisect', 'grep', 'describe', 'merge-base', 'claim', 'unclaim', 'check', 'resolutions', 'review', 'sign', 'key', 'token'])
-
-const VALUE_FLAGS = new Set(['-m', '--quilts', '--message', '-n', '--max-count', '--into', '--onto', '--on-conflict', '--quilt', '--square', '--dir', '--line', '--task', '--level', '--title', '--slug', '--format', '--expect-tip', '--side', '--file', '--batch', '--to', '--note', '--after', '--kinds', '--webhook', '--secret', '--branch', '--from', '-S', '--run', '--marks', '--patch', '--on', '--path', '--checks', '--name', '--public-key'])
-
-export function parse (argv) {
-  const pos = []; const flags = {}; const paths = []
-  let rest = false
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i]
-    if (rest) { paths.push(a); continue }
-    if (a === '--') { rest = true; continue }
-    const eq = a.match(/^(--[\w-]+)=(.*)$/)
-    if (eq) { flags[eq[1]] = eq[2]; continue }
-    if (VALUE_FLAGS.has(a)) { flags[a] = argv[++i]; continue }
-    if (/^-n\d+$/.test(a)) { flags['-n'] = a.slice(2); continue }
-    if (a.startsWith('-') && a.length > 1) { flags[a] = true; continue }
-    pos.push(a)
-  }
-  return { pos, flags, paths }
-}
-
-/** The client for a block (or none): SEAM_API_URL / SEAM_TOKEN first, else the block's server and `token` (seam's own sign-in). */
-export function connect (block, token) {
-  const api = process.env.SEAM_API_URL || block?.api || API_URL
-  const key = process.env.SEAM_TOKEN || token
-  if (!key) throw new Error('Not signed in: run seam login, or set SEAM_TOKEN to an agent key.')
-  return { client: quiltClient({ api, token: key }), api }
-}
-
-/** Runs one verb; returns the text to print (or JSON with --json). `token` is the signed-in person's, when there is one. */
-export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, out = (s) => process.stdout.write(s.endsWith('\n') ? s : s + '\n') } = {}) {
-  const { pos, flags, paths } = parse(argv)
-  const found = findBlock(cwd)
-  const block = found?.block
-  const { client, api } = connect(block, token)
-  const quilt = flags['--quilt'] || block?.quilt
-  const needQuilt = () => { if (!quilt) throw new Error('Name the quilt with --quilt <slug or id> (or run this inside a block folder).'); return quilt }
-  const needSquare = () => { const s = flags['--square'] || block?.square; if (!s) throw new Error('No square here: run this in a block folder, or pass --square sq:<id>.'); return s }
-  const json = !!flags['--json']
-  const print = (data, text) => out(json ? JSON.stringify(data, null, 2) : text)
-  const message = flags['-m'] || flags['--message']
-
-  switch (cmd) {
-    case 'quilts': {
-      if (pos[0] === 'new') { const q = await client.createQuilt({ slug: pos[1], name: flags['--title'] }); return print(q, `Made quilt ${q.slug} (${q.id}).`) }
-      if (pos[0] === 'add') { const r = await client.addMember(needQuilt(), { member_id: pos[1], level: flags['--level'] || 'write' }); return print(r, `${r.member_id}: ${r.level || 'removed'}`) }
-      if (pos[0] === 'show') { const q = await client.quilt(pos[1] || needQuilt()); return print(q, `${q.slug} (${q.id})\n${q.lines.map((l) => `  ${l.name}: ${l.patch_count} patches, tip ${l.tip ? l.tip.slice(0, 12) : '(empty)'}`).join('\n')}`) }
-      const list = await client.quilts()
-      return print(list, list.length ? list.map((q) => `${q.slug}  ${q.id}  (${q.level})`).join('\n') : 'No quilts yet.')
-    }
-    case 'line': {
-      // seam line [list] | new release/<name> [--from <rev>] | freeze <line> | unfreeze <line>
-      const sub = pos[0] || 'list'
-      const describeLine = (l) => `${l.name}: ${l.patch_count} patches, tip ${l.tip ? l.tip.slice(0, 12) : '(empty)'}${l.frozen ? ', frozen' : ''}`
-      if (sub === 'list') { const ls = await client.lines(needQuilt()); return print(ls, ls.map(describeLine).join('\n')) }
-      if (sub === 'new') {
-        if (!pos[1]) throw new Error('Name the line: seam line new release/<name> [--from <rev>]')
-        const l = await client.newLine(needQuilt(), { name: pos[1], from: flags['--from'] })
-        return print(l, `Made line ${describeLine(l)}.\nOpen a square on it with: seam square open "<title>" --line ${l.name}`)
-      }
-      if (sub === 'freeze' || sub === 'unfreeze') {
-        if (!pos[1]) throw new Error(`Which line? seam line ${sub} <line>`)
-        const l = await (sub === 'freeze' ? client.freezeLine : client.unfreezeLine)(needQuilt(), pos[1])
-        return print(l, sub === 'freeze' ? `${l.name} is frozen: merges into it are refused until seam line unfreeze ${l.name}.` : `${l.name} takes merges again.`)
-      }
-      if (sub === 'require') {
-        if (!pos[1]) throw new Error('Which line? seam line require <line> [<approvals>] [--checks ci,lint]')
-        const checks = flags['--checks'] === undefined ? undefined : String(flags['--checks']).split(',').map((c) => c.trim()).filter(Boolean)
-        if (pos[2] === undefined && checks === undefined) { const p = await client.linePolicy(needQuilt(), pos[1]); return print(p, describePolicy(p)) }
-        const p = await client.setLinePolicy(needQuilt(), pos[1], { ...(pos[2] !== undefined ? { approvals: Number(pos[2]) } : {}), ...(checks ? { checks } : {}) })
-        return print(p, describePolicy(p))
-      }
-      throw new Error('seam line [list] | new release/<name> [--from <rev>] | freeze <line> | unfreeze <line> | require <line> [<approvals>] [--checks ci,lint]')
-    }
-    case 'tag':
-    case 'release': {
-      // seam tag [<name> [rev]] | seam release [<name> [rev] -m <notes>]: no name lists them.
-      const where = (x) => `${x.short}${x.patch ? ` (${x.patch.line}:${x.patch.patch_no})` : ''}`
-      if (!pos[0]) {
-        if (cmd === 'tag') { const ts = await client.tags(needQuilt()); return print(ts, ts.length ? ts.map(describeTag).join('\n') : 'No tags yet.') }
-        const rs = await client.releases(needQuilt())
-        return print(rs, rs.length ? rs.map(describeRelease).join('\n') : 'No releases yet.')
-      }
-      if (cmd === 'tag') { const x = await client.createTag(needQuilt(), { name: pos[0], rev: pos[1] }); return print(x, `Tagged ${x.name} at ${where(x)}. Read it as tag:${x.name}.`) }
-      const x = await client.createRelease(needQuilt(), { name: pos[0], rev: pos[1], notes: flags['-m'] ?? flags['--message'] ?? '' })
-      return print(x, `Released ${x.name} at ${where(x)}. Read it as tag:${x.name}.`)
-    }
-    case 'events': {
-      // seam events [--after n] [--kinds a,b] | --webhook <url> [--secret s] [--kinds a,b] | --webhook off
-      const kinds = flags['--kinds'] ? String(flags['--kinds']).split(',') : undefined
-      if (flags['--webhook']) {
-        const off = flags['--webhook'] === 'off'
-        const r = await client.subscribe(needQuilt(), off ? { url: null } : { url: flags['--webhook'], secret: flags['--secret'], events: kinds })
-        return print(r, off ? 'Webhook removed.' : `Events (${r.events.join(', ')}) now POST to ${r.url}${r.secret ? `\nSigning secret (shown once): ${r.secret}` : ''}`)
-      }
-      const r = await client.events(needQuilt(), { after: flags['--after'], kinds })
-      return print(r, describeEvents(r))
-    }
-    case 'square': {
-      const sub = pos[0] || 'list'
-      if (sub === 'open') {
-        const sq = await client.openSquare(needQuilt(), { title: pos.slice(1).join(' ') || flags['--title'] || 'untitled', line: flags['--line'], task_id: flags['--task'], ...(flags['--on'] ? { on: flags['--on'] } : {}) })
-        let text = describeSquare(sq)
-        if (flags['--dir']) {
-          const dir = path.resolve(cwd, flags['--dir'])
-          await checkout(client, { quilt: needQuilt(), square: sq.id, paths, dir, api })
-          text += `\nChecked out into ${dir}.`
-        }
-        return print(sq, text)
-      }
-      // seam square handoff [sq] --to <member> [--note text] | abandon [sq] | reopen [sq]
-      if (sub === 'handoff') { const sq = await client.handoff(needQuilt(), pos[1] || needSquare(), { to: flags['--to'], note: flags['--note'] }); return print(sq, `Handed ${sq.short || sq.id} to ${sq.holder}.`) }
-      if (sub === 'abandon') { const sq = await client.abandon(needQuilt(), pos[1] || needSquare()); return print(sq, `Abandoned ${sq.short || sq.id}; seam square reopen brings it back.`) }
-      if (sub === 'reopen') { const sq = await client.reopen(needQuilt(), pos[1] || needSquare()); return print(sq, `Reopened ${sq.short || sq.id}; you hold it.`) }
-      // seam square fold [sq] --into sq:<id> | split [sq] <paths,...> <paths,...> [--title t]
-      if (sub === 'fold') {
-        if (!flags['--into']) throw new Error('Fold into which square? seam square fold [sq:from] --into sq:<id>')
-        const r = await client.fold(needQuilt(), pos[1] || needSquare(), { into: flags['--into'], message })
-        return print(r, describeWrite(r, `Folded ${r.folded.short} into ${r.square.short}:`))
-      }
-      if (sub === 'split') {
-        const own = pos[1] && pos[1].startsWith('sq:')
-        const groups = pos.slice(own ? 2 : 1).map((g) => g.split(',').filter(Boolean))
-        if (!groups.length) throw new Error('Split by which paths? seam square split [sq] docs,README.md src (one group per new square)')
-        const r = await client.split(needQuilt(), own ? pos[1] : needSquare(), { by: 'paths', groups, ...(flags['--title'] ? { titles: [flags['--title']] } : {}) })
-        const text = [`Kept in ${r.square.short}: ${r.kept.join(', ') || '(nothing)'}`, ...r.squares.map((q) => `New ${describeSquare(q)}: ${q.paths.join(', ')}`)].join('\n')
-        if (found && block.square === r.square.id) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); return print(r, `${text}\n${st.written} file(s) updated in the folder.`) }
-        return print(r, text)
-      }
-      if (sub === 'show') { const sq = await client.square(needQuilt(), pos[1] || needSquare()); return print(sq, describeSquareStatus(sq)) }
-      const list = await client.squares(needQuilt(), { state: flags['--all'] ? undefined : (flags['--state'] || 'open'), mine: !!flags['--mine'] })
-      return print(list, list.length ? list.map(describeSquare).join('\n') : 'No open squares.')
-    }
-    case 'checkout': {
-      const target = pos[0]
-      if (!target) throw new Error('seam checkout <sq:id | revision> [--dir folder] [-- paths]')
-      const isSquare = target.startsWith('sq:') && !/:(base|live)$|~\d+$/.test(target)
-      if (found && !flags['--dir']) {
-        // Switch this block to another square or revision: only from a clean folder.
-        const st = await blockStatus(client, found.dir, block)
-        if (st.changes.length) throw new Error(`This folder has ${st.changes.length} uncommitted change(s); commit them first.`)
-        const sq = isSquare ? await client.square(block.quilt, target) : null
-        const to = sq ? (sq.head || sq.base) : (await client.show(block.quilt, target, { format: 'none' })).commit.id
-        const r = await syncTo(client, found.dir, block, to, { square: sq })
-        if (!sq) { block.square = null; block.square_short = null; block.head = null; saveBlock(found.dir, block) }
-        return print(r, `Switched to ${sq ? `${sq.short} "${sq.title}"` : target} (${r.written} file(s) written).`)
-      }
-      const dir = path.resolve(cwd, flags['--dir'] || (isSquare ? target.replace(':', '-') : 'seam-checkout'))
-      const r = await checkout(client, { quilt: needQuilt(), ...(isSquare ? { square: target } : { rev: target }), paths, dir, api })
-      return print({ dir, files: r.files, block: { ...r.block, files: undefined } }, `Checked out ${r.files} file(s) of ${isSquare ? target : target} under ${r.block.paths.map((p) => p || '/').join(', ')} into ${dir}.`)
-    }
-    case 'status': {
-      if (!found) throw new Error('Not in a block folder (no .seam/block.json here or above).')
-      const st = await blockStatus(client, found.dir, block)
-      return print(st, describeStatus(st))
-    }
-    case 'review': {
-      // seam review [sq] (the reviews and where the square stands)
-      // seam review approve|request-changes|comment|dismiss [sq] [-m <text>] [--path <file> [--line <n>]]
-      const VERDICT = { approve: 'approve', 'request-changes': 'request_changes', comment: 'comment', dismiss: 'dismiss' }
-      const kind = VERDICT[pos[0]]
-      const sq = (kind ? pos[1] : pos[0]) || needSquare()
-      if (!kind) { const r = await client.reviews(needQuilt(), sq); return print(r, describeReviews(r)) }
-      const r = await client.review(needQuilt(), sq, { kind, body: message || '', ...(flags['--path'] ? { path: flags['--path'] } : {}), ...(flags['--line'] ? { line: Number(flags['--line']) } : {}) })
-      return print(r, describeReviewed(r))
-    }
-    case 'claim': {
-      // seam claim (lists the quilt's claims) | seam claim <pattern>... [--note <why>] (claims them for your square)
-      if (!pos.length) { const cs = await client.claims(needQuilt(), flags['--square']); return print(cs, describeClaims(cs)) }
-      const sq = needSquare()
-      const made = []
-      for (const p of pos) made.push(await client.claim(needQuilt(), sq, { pattern: p, note: flags['--note'] || message }))
-      return print(made, made.map((c) => `Claimed ${c.pattern} for ${c.square}: writes to it from other squares on ${c.line} are refused until the square merges or you run seam unclaim ${c.pattern}.`).join('\n'))
-    }
-    case 'check': {
-      // seam check <name> red|green|flaky [--line main] [--patch n] | seam check <name> green|red --square <sq>
-      const [name, status] = pos
-      if (!name || !['red', 'green', 'flaky'].includes(status)) throw new Error('seam check <name> red|green|flaky [--line <line>] [--patch <n>]')
-      if (flags['--square']) {
-        // seam check <name> green|red --square <sq>: a result for a square's latest commit (a line may require it before a merge)
-        const r = await client.reportSquareCheck(needQuilt(), flags['--square'], { check: name, status })
-        return print(r, describeSquareCheck(r))
-      }
-      const r = await client.reportCheck(needQuilt(), flags['--line'] || 'main', { check: name, status, ...(flags['--patch'] != null ? { patch: Number(flags['--patch']) } : {}) })
-      return print(r, describeCheck(r))
-    }
-    case 'unclaim': {
-      // seam unclaim <pattern|claim id>...
-      if (!pos.length) throw new Error('Which claim? seam unclaim <pattern>')
-      const sq = needSquare()
-      const out = []
-      for (const p of pos) out.push(await client.unclaim(needQuilt(), sq, p))
-      return print(out, out.map((r) => `Let go of ${r.released.pattern}.`).join('\n'))
-    }
-    case 'live': {
-      // seam live [sq] | live share (a block folder's uncommitted edits) | live clear
-      const sub = pos[0]
-      if (sub === 'share' || sub === 'clear') {
-        const sqRef = flags['--square'] || block?.square
-        if (!sqRef) throw new Error(`seam live ${sub} works in a block folder on a square (or pass --square sq:<id>).`)
-        if (sub === 'share' && !found) throw new Error('seam live share sends a block folder\'s uncommitted edits: run it in a folder made by seam checkout.')
-        const changes = sub === 'clear' ? [] : localChanges(found.dir, block).map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', content: c.bytes.toString('base64'), mode: c.mode })
-        const r = await client.setLive(needQuilt(), sqRef, { changes })
-        return print(r, describeLiveSet(r))
-      }
-      const r = await client.live(needQuilt(), sub || needSquare())
-      return print(r, describeLive(r))
-    }
-    case 'restore':
-    case 'reset':
-    case 'clean': {
-      if (!found) throw new Error(`seam ${cmd} works on a block folder; run it in a folder made by seam checkout.`)
-      const files = [...(cmd === 'reset' ? pos.slice(1) : pos), ...paths].map((p) => path.resolve(cwd, p))
-      if (cmd === 'restore') { const r = await restore(client, found.dir, block, { paths: files }); return print(r, describeRestore(r)) }
-      if (cmd === 'reset') { const r = await reset(client, found.dir, block, { rev: pos[0] }); return print(r, describeReset(r, block)) }
-      const r = clean(found.dir, block, { paths: files.length ? files : [cwd], dryRun: !flags['-f'] && !flags['--force'] })
-      return print(r, describeClean(r, 'Run it again as seam clean -f to remove them.'))
-    }
-    case 'commit': {
-      if (!found) {
-        throw new Error('seam commit seals a block folder\'s changes; run it in a folder made by seam checkout.')
-      }
-      // --sign: signs the new commit with this computer's key (seam key add).
-      const signed = async (r) => {
-        if (!flags['--sign'] || !r?.result?.id) return ''
-        const s = await signWithLocalKey(client, needQuilt(), r.result.id)
-        r.signature = s.signature
-        return `\nSigned with ${s.signature.key}.`
-      }
-      if (flags['--amend']) {
-        const r = await amendFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)) })
-        const s = await signed(r)
-        return print(r, describeWrite(r, `Amended ${r.amended.slice(0, 12)} as`) + s)
-      }
-      if (!message) throw new Error('Say what changed: seam commit -m "message" [paths...]')
-      const r = await commitFolder(client, found.dir, block, { message, paths: [...pos, ...paths].map((p) => path.resolve(cwd, p)) })
-      if (r.nothing) return print(r, 'Nothing to commit.')
-      const s = await signed(r)
-      return print(r, describeWrite(r, 'Committed') + s)
-    }
-    case 'sign': {
-      // seam sign [rev]: signs a commit you made (default: your square's head, or main's tip).
-      const r = await signWithLocalKey(client, needQuilt(), pos[0] || (block?.square ? block.square_short : block?.line) || 'main')
-      return print(r, `Signed ${r.short} with ${r.signature.key}.`)
-    }
-    case 'token': {
-      // seam token [list] | new <name> [--level read|write] | revoke <id or name>
-      const sub = pos[0] || 'list'
-      if (sub === 'list') { const r = await client.tokens(needQuilt()); return print(r, describeTokens(r)) }
-      if (sub === 'new') {
-        if (!pos[1]) throw new Error('seam token new <name> [--level read|write]')
-        const r = await client.createToken(needQuilt(), { name: pos[1], level: flags['--level'] || 'read' })
-        return print(r, describeNewToken(r))
-      }
-      if (sub === 'revoke') {
-        if (!pos[1]) throw new Error('seam token revoke <id or name>')
-        const r = await client.revokeToken(needQuilt(), pos[1])
-        return print(r, `Revoked token ${r.name} (${r.id}): it no longer reaches the quilt.`)
-      }
-      throw new Error('seam token [list] | new <name> [--level read|write] | revoke <id or name>')
-    }
-    case 'key': {
-      // seam key [list [member]] | add [--name <n>] [--public-key <file>] | remove <key>
-      const sub = pos[0] || 'list'
-      if (sub === 'list') { const r = await client.signingKeys({ member: pos[1] }); return print(r, describeKeys(r)) }
-      if (sub === 'remove') {
-        if (!pos[1]) throw new Error('seam key remove <key>')
-        const r = await client.removeKey(pos[1])
-        return print(r, `Removed ${r.key}: commits it signed now show "Signature by a removed key".`)
-      }
-      if (sub !== 'add') throw new Error('seam key [list [member]] | add [--name <name>] [--public-key <file>] | remove <key>')
-      let pub = flags['--public-key'] ? fs.readFileSync(path.resolve(cwd, flags['--public-key']), 'utf8') : null
-      let made = false
-      if (!pub) { const k = localKey(); if (k) pub = k.public_key; else { pub = makeLocalKey(); made = true } }
-      const r = await client.addKey({ public_key: pub, name: flags['--name'] || os.hostname() })
-      return print(r, `${made ? `Made a signing key at ${signingKeyFile()} and added` : 'Added'} ${r.key}. Sign with seam commit --sign or seam sign <rev>.`)
-    }
-    case 'log': {
-      const rev = pos[0] || (block?.square ? block.square_short : block?.line) || 'main'
-      const r = await client.log(needQuilt(), { rev, paths, limit: flags['-n'] || flags['--max-count'] || 20, follow: flags['--follow'] ? true : undefined, show_signature: flags['--show-signature'] ? true : undefined, search: typeof flags['-S'] === 'string' ? flags['-S'] : undefined })
-      return print(r, describeLog(r, { oneline: !!flags['--oneline'] }))
-    }
-    case 'describe': {
-      const r = await client.describe(needQuilt(), pos[0] || (block?.square ? block.square_short : block?.line) || 'main')
-      return print(r, r.describe)
-    }
-    case 'merge-base': {
-      if (pos.length !== 2) throw new Error('seam merge-base <revision> <revision>')
-      const r = await client.mergeBase(needQuilt(), pos[0], pos[1])
-      return print(r, describeMergeBase(r))
-    }
-    case 'grep': {
-      // seam grep <pattern> [revision] [-- paths]: -i ignores case, -F takes the pattern as plain text, -l lists files.
-      if (!pos[0]) throw new Error('seam grep <pattern> [revision] [-i] [-F] [-l] [--all] [-- paths]')
-      if (flags['--all']) {
-        // --all: every quilt you can read (or --quilts a,b), at the revision (default main).
-        const r = await client.search({ pattern: pos[0], rev: pos[1] || 'main', quilts: flags['--quilts'] ? String(flags['--quilts']).split(',') : undefined, paths, ignore_case: flags['-i'] ? 1 : undefined, fixed: flags['-F'] ? 1 : undefined, limit: flags['--max-count'] })
-        return print(r, describeGrep(r, { filesOnly: !!flags['-l'] }))
-      }
-      const rev = pos[1] || (block?.square ? block.square_short : block?.line) || 'main'
-      const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
-      const r = await client.grep(needQuilt(), { pattern: pos[0], rev, paths: paths.map(rel), ignore_case: flags['-i'] ? 1 : undefined, fixed: flags['-F'] ? 1 : undefined, limit: flags['--max-count'] })
-      return print(r, describeGrep(r, { filesOnly: !!flags['-l'] }))
-    }
-    case 'bisect': {
-      // seam bisect <bad> <good> --run "<check>": exit 0 good, 125 skip, else bad. Without --run, one step (--marks id:good,id:bad).
-      if (pos.length !== 2) throw new Error('seam bisect <bad> <good> --run "<check command>" (or --marks <commit>:good,<commit>:bad for one step)')
-      const marks = Object.fromEntries(String(flags['--marks'] || '').split(',').filter(Boolean).map((x) => x.split(':')))
-      if (typeof flags['--run'] === 'string') {
-        const { bisectRun } = await import('./bisect-run.js')
-        const r = await bisectRun(client, { quilt: needQuilt(), bad: pos[0], good: pos[1], run: flags['--run'], marks, api, log: (s) => { if (!json) out(s) } })
-        return print(r, describeBisect(r))
-      }
-      const r = await client.bisect(needQuilt(), { bad: pos[0], good: pos[1], marks })
-      return print(r, describeBisect(r) + (r.done ? '' : `\nThen: seam bisect ${pos[0]} ${pos[1]} --marks ${[...Object.entries(marks).map(([k, v]) => `${k}:${v}`), `${r.next.short}:<good|bad|skip>`].join(',')}`))
-    }
-    case 'show': {
-      const rev = pos[0] || (block?.square ? block.square_short : 'main')
-      const format = flags['--stat'] ? 'stat' : flags['--name-only'] || flags['--name-status'] ? 'names' : 'unified'
-      const r = await client.show(needQuilt(), rev, { format, paths })
-      return print(r, describeShow(r, { format }))
-    }
-    case 'diff': {
-      const format = flags['--stat'] ? 'stat' : flags['--name-only'] || flags['--name-status'] ? 'names' : 'unified'
-      if (!pos.length && found) {
-        const d = await localDiff(client, found.dir, block, { paths: paths.map((p) => path.resolve(cwd, p)) })
-        return print(d, format === 'unified' ? (d.text || '') : d.changes.map((c) => `${c.status[0].toUpperCase()}\t${c.path}`).join('\n'))
-      }
-      const [from, to] = pos.length === 1 && pos[0].includes('..') ? pos[0].split('..') : pos.length === 1 ? [pos[0], block?.square ? block.square_short : 'main'] : pos
-      const r = await client.diff(needQuilt(), { from, to, paths, format })
-      return print(r, describeDiff(r, { format }))
-    }
-    case 'merge': {
-      let into = flags['--into'] || (pos.length ? null : (block?.line || 'main'))
-      // git merge <other>: in a block on a square, merges that square (or revision) into this one.
-      if (!into && block?.square) into = block.square_short || block.square
-      if (!into) throw new Error('Merge into what? seam merge sq:<id> --into main (a line) or --into sq:<id> (a square)')
-      if (/^sq:/.test(into)) {
-        const target = into
-        const from = pos[0] || needSquare()
-        const mine = found && (target === block.square_short || target === block.square)
-        const r = await client.mergeSquare(needQuilt(), target, { from, ...(mine ? { expect_head: block.head } : {}), message })
-        let text = r.noop ? `Already up to date: ${from} is in ${target}.` : describeWrite(r, `Merged ${from} into ${target}:`)
-        if (mine && !r.noop) { const st = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${st.written} file(s) updated in the folder.` }
-        return print(r, text)
-      }
-      const sqId = pos[0] && pos[0].startsWith('sq:') ? pos[0] : needSquare()
-      const r = await client.merge(needQuilt(), into, { square: sqId, ...(found && sqId === block.square ? { expect_head: block.head } : {}), message, dry_run: !!flags['--dry-run'], on_conflict: flags['--on-conflict'], expect_tip: flags['--expect-tip'] })
-      let text = describeMerge(r)
-      // The refused merge left the square rebased onto the tip with its conflicts: bring the folder there.
-      if (found && sqId === block.square && !r.ok && r.head && r.head !== block.head) {
-        const s = await syncTo(client, found.dir, block, r.head, { square: r.square })
-        text += `\nThe folder now holds the rebased files (${s.written} written)${s.kept.length ? `; kept your own version of ${s.kept.join(', ')}` : ''}.`
-      }
-      return print(r, text)
-    }
-    case 'rebase': {
-      const r = await client.rebase(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), onto: flags['--onto'] })
-      let text = r.noop ? 'Already on the tip.' : describeWrite(r, 'Rebased')
-      if (found && !r.noop) { const s = await syncTo(client, found.dir, block, r.square.head || r.square.base, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
-      return print(r, text)
-    }
-    case 'cherry-pick': {
-      if (!pos[0]) throw new Error('seam cherry-pick <revision>')
-      const r = await client.cherryPick(needQuilt(), needSquare(), { from: pos[0], ...(found ? { expect_head: block.head } : {}) })
-      let text = describeWrite(r, 'Picked')
-      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
-      return print(r, text)
-    }
-    case 'revert': {
-      if (!pos[0]) throw new Error('seam revert <patch:n | revision>')
-      const r = await client.revert(needQuilt(), { rev: pos[0], line: flags['--line'] })
-      let text = describeWrite(r, 'Reverted in a new square') + `\nMerge it with: seam merge ${r.square.short} --into ${r.square.line}`
-      if (flags['--dir']) { const dir = path.resolve(cwd, flags['--dir']); await checkout(client, { quilt: needQuilt(), square: r.square.id, dir, api }); text += `\nChecked out into ${dir}.` }
-      return print(r, text)
-    }
-    case 'resolve': {
-      const choose = flags['--ours'] ? 'ours' : flags['--theirs'] ? 'theirs' : flags['--base'] ? 'base' : flags['--delete'] ? 'delete' : flags['--suggestion'] ? 'suggestion' : flags['--side'] != null ? Number(flags['--side']) : null
-      if (choose === null || !pos.length) throw new Error('seam resolve <path>... --ours | --theirs | --base | --suggestion | --side n | --delete [--no-remember] (or edit the file and commit it without the markers)')
-      const rel = (p) => found ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
-      const r = await client.resolve(needQuilt(), needSquare(), { ...(found ? { expect_head: block.head } : {}), entries: pos.map((p) => ({ path: rel(p), choose })), ...(flags['--no-remember'] ? { remember: false } : {}) })
-      let text = describeWrite(r, 'Resolved')
-      if (found) { const s = await syncTo(client, found.dir, block, r.square.head, { square: r.square }); text += `\n${s.written} file(s) updated in the folder.` }
-      return print(r, text)
-    }
-    case 'resolutions': {
-      // seam resolutions [path] (the remembered answers) | seam resolutions forget <key>
-      if (pos[0] === 'forget') {
-        if (!pos[1]) throw new Error('Which one? seam resolutions forget <key>')
-        const r = await client.forgetResolution(needQuilt(), pos[1])
-        return print(r, `Forgot ${r.forgotten.short} (${r.forgotten.path}): that conflict will be asked about again.`)
-      }
-      const rows = await client.resolutions(needQuilt(), pos[0])
-      return print(rows, describeResolutions(rows))
-    }
-    case 'blame': {
-      const arg = pos[0]
-      if (!arg) throw new Error('seam blame <path>[@revision]')
-      const at = arg.lastIndexOf('@')
-      const [p, rev] = at > 0 ? [arg.slice(0, at), arg.slice(at + 1)] : [arg, pos[1] || (block?.square ? block.square_short : 'main')]
-      const rel = found && at < 0 ? path.relative(found.dir, path.resolve(cwd, p)).split(path.sep).join('/') : p
-      const r = await client.blame(needQuilt(), rev, rel)
-      return print(r, describeBlame(r))
-    }
-    case 'cat': {
-      const arg = pos[0] || ''
-      const at = arg.lastIndexOf('@')
-      const [p, rev] = at > 0 ? [arg.slice(0, at), arg.slice(at + 1)] : [arg, 'main']
-      const r = await client.cat(needQuilt(), rev, p, { format: flags['--format'] || 'diff' })
-      if (json) return print(r, '')
-      process.stdout.write(Buffer.from(r.content, 'base64'))
-      return
-    }
-    case 'ls': {
-      const r = await client.tree(needQuilt(), pos[0] || 'main', pos.slice(1).concat(paths))
-      return print(r, r.entries.map((e) => `${e.mode}\t${e.blob ? e.blob.slice(0, 12) : e.term.slice(0, 12)}\t${e.path}`).join('\n'))
-    }
-    case 'import': {
-      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam import git <path> [--into <quilt-slug>] [--validate]')
-      const { importGit } = await import('./import-git.js')
-      const repo = path.resolve(cwd, pos[1])
-      if (!fs.existsSync(path.join(repo, '.git')) && !fs.existsSync(path.join(repo, 'HEAD'))) throw new Error(`${repo} is not a git repository`)
-      const r = await importGit(client, { repo, slug: flags['--into'] || path.basename(repo).toLowerCase().replace(/[^a-z0-9-]/g, '-'), log: (s) => { if (!json) out(s) }, validate: !!flags['--validate'], batch: Number(flags['--batch']) || 100 })
-      return print(r, describeImport(r))
-    }
-    case 'export': {
-      if (pos[0] !== 'git' || !pos[1]) throw new Error('seam export git <dir> [--line main] [--branch <name>]')
-      const { exportGit } = await import('./export-git.js')
-      const r = await exportGit(client, { q: needQuilt(), dir: path.resolve(cwd, pos[1]), line: flags['--line'] || 'main', branch: flags['--branch'] || undefined, log: (s) => { if (!json) out(s) } })
-      return print(r, r.exported ? `Exported ${r.exported} patches to ${r.branch} in ${pos[1]}: ${r.branch} is ${r.sha} (patch ${r.patch_no}).` : `Nothing new: ${r.branch} is ${r.sha || 'empty'} (patch ${r.patch_no}).`)
-    }
-  }
-  throw new Error(`unknown seam command ${cmd}`)
-}

package/src/quilts/client.js

@@ -1,128 +0,0 @@
-// The quilt API from a client (the CLI, the local MCP, the importer): one function per route.
-// A refusal throws an Error with the server's `code`, `status` and fields (head, terms, ...).
-import { buildPack } from './pack.js'
-
-const enc = encodeURIComponent
-const qs = (o) => {
-  const p = Object.entries(o).filter(([, v]) => v !== undefined && v !== null && v !== '' && !(Array.isArray(v) && !v.length))
-  return p.length ? '?' + p.map(([k, v]) => `${k}=${enc(Array.isArray(v) ? v.join(',') : v)}`).join('&') : ''
-}
-const pathPart = (p) => String(p).split('/').map(enc).join('/')
-
-export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch, timeoutMs = 120_000 }) {
-  const base = String(api || '').replace(/\/+$/, '')
-  if (!base) throw new Error('No quilt server: set QUILT_API (or sign in with `quilt login`).')
-  const auth = token ? (token.startsWith('QuiltPass ') ? token : `Bearer ${token}`) : null
-
-  async function call (method, route, body, { raw = false } = {}) {
-    let res
-    try {
-      res = await fetchImpl(base + route, {
-        method,
-        headers: { ...(auth ? { authorization: auth } : {}), ...(body !== undefined ? { 'content-type': raw ? 'application/octet-stream' : 'application/json' } : {}) },
-        body: body === undefined ? undefined : raw ? body : JSON.stringify(body),
-        signal: AbortSignal.timeout(timeoutMs)
-      })
-    } catch (err) {
-      throw new Error(`Couldn't reach the quilt server at ${base} (${err?.cause?.code || err?.name || 'no answer'}).`)
-    }
-    const data = await res.json().catch(() => null)
-    if (!res.ok && !(data && data.refused)) {
-      const { error, ...extra } = data || {}
-      throw Object.assign(new Error(error || `The quilt server answered ${res.status}.`), { status: res.status, ...extra })
-    }
-    return data
-  }
-
-  const Q = (q) => `/v1/quilts/${enc(q)}`
-  return {
-    call,
-    quilts: async () => (await call('GET', '/v1/quilts')).quilts,
-    createQuilt: (b) => call('POST', '/v1/quilts', b),
-    quilt: (q) => call('GET', Q(q)),
-    addMember: (q, b) => call('POST', `${Q(q)}/members`, b),
-    squares: async (q, f = {}) => (await call('GET', `${Q(q)}/squares${qs({ state: f.state, mine: f.mine ? 1 : undefined, task: f.task })}`)).squares,
-    openSquare: (q, b) => call('POST', `${Q(q)}/squares`, b),
-    square: (q, s) => call('GET', `${Q(q)}/squares/${enc(s)}`),
-    commit: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/commit`, b),
-    amend: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/amend`, b),
-    handoff: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/handoff`, b),
-    abandon: (q, s, b = {}) => call('POST', `${Q(q)}/squares/${enc(s)}/abandon`, b),
-    reopen: (q, s) => call('POST', `${Q(q)}/squares/${enc(s)}/reopen`, {}),
-    mergeSquare: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/merge`, b),
-    fold: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/fold`, b),
-    split: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/split`, b),
-    rebase: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/rebase`, b),
-    cherryPick: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/cherry-pick`, b),
-    resolve: (q, s, b) => call('POST', `${Q(q)}/squares/${enc(s)}/resolve`, b),
-    lines: async (q) => (await call('GET', `${Q(q)}/lines`)).lines,
-    newLine: (q, b) => call('POST', `${Q(q)}/lines`, b),
-    reportCheck: (q, line, b) => call('POST', `${Q(q)}/lines/${enc(line)}/checks`, b),
-    freezeLine: (q, line) => call('POST', `${Q(q)}/lines/${enc(line)}/freeze`, {}),
-    unfreezeLine: (q, line) => call('POST', `${Q(q)}/lines/${enc(line)}/unfreeze`, {}),
-    tags: async (q) => (await call('GET', `${Q(q)}/tags`)).tags,
-    tag: (q, name) => call('GET', `${Q(q)}/tags/${name.split('/').map(enc).join('/')}`),
-    createTag: (q, b) => call('POST', `${Q(q)}/tags`, b),
-    releases: async (q) => (await call('GET', `${Q(q)}/releases`)).releases,
-    createRelease: (q, b) => call('POST', `${Q(q)}/releases`, b),
-    merge: (q, line, b) => call('POST', `${Q(q)}/lines/${enc(line)}/merge`, b),
-    revert: (q, b) => call('POST', `${Q(q)}/revert`, b),
-    events: (q, o = {}) => call('GET', `${Q(q)}/events${qs(o)}`),
-    subscribe: (q, b) => call('POST', `${Q(q)}/webhook`, b),
-    show: (q, rev, o = {}) => call('GET', `${Q(q)}/show/${enc(rev)}${qs(o)}`),
-    exportPatches: (q, o = {}) => call('GET', `${Q(q)}/export/git${qs(o)}`),
-    log: (q, o = {}) => call('GET', `${Q(q)}/log${qs(o)}`),
-    sign: (q, rev, b) => call('POST', `${Q(q)}/commits/${enc(rev)}/signatures`, b),
-    tokens: (q) => call('GET', `${Q(q)}/tokens`),
-    createToken: (q, b) => call('POST', `${Q(q)}/tokens`, b),
-    revokeToken: (q, id) => call('DELETE', `${Q(q)}/tokens/${enc(id)}`),
-    signingKeys: (o = {}) => call('GET', `/v1/signing-keys${qs(o)}`),
-    addKey: (b) => call('POST', '/v1/signing-keys', b),
-    removeKey: (key) => call('DELETE', `/v1/signing-keys/${enc(key)}`),
-    describe: (q, rev) => call('GET', `${Q(q)}/describe${qs({ rev })}`),
-    mergeBase: (q, a, b) => call('GET', `${Q(q)}/merge-base${qs({ a, b })}`),
-    grep: (q, o = {}) => call('GET', `${Q(q)}/grep${qs(o)}`),
-    search: (o = {}) => call('GET', `/v1/search${qs(o)}`),
-    bisect: (q, b) => call('POST', `${Q(q)}/bisect`, b),
-    linePatches: (q, line = 'main', o = {}) => call('GET', `${Q(q)}/lines/${encodeURIComponent(line)}/patches${qs(o)}`),
-    diff: (q, o = {}) => call('GET', `${Q(q)}/diff${qs(o)}`),
-    resolutions: async (q, p) => (await call('GET', `${Q(q)}/resolutions${p ? `?path=${enc(p)}` : ''}`)).resolutions,
-    forgetResolution: (q, key) => call('DELETE', `${Q(q)}/resolutions/${enc(key)}`),
-    reviews: (q, sq) => call('GET', `${Q(q)}/squares/${enc(sq)}/reviews`),
-    review: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/reviews`, b),
-    reportSquareCheck: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/checks`, b),
-    linePolicy: (q, line) => call('GET', `${Q(q)}/lines/${enc(line)}/policy`),
-    setLinePolicy: (q, line, b) => call('PUT', `${Q(q)}/lines/${enc(line)}/policy`, b),
-    claims: async (q, square) => (await call('GET', `${Q(q)}/claims${square ? `?square=${enc(square)}` : ''}`)).claims,
-    claim: (q, sq, b) => call('POST', `${Q(q)}/squares/${enc(sq)}/claims`, b),
-    unclaim: (q, sq, which) => call('DELETE', `${Q(q)}/squares/${enc(sq)}/claims/${enc(which)}`),
-    live: (q, sq) => call('GET', `${Q(q)}/squares/${enc(sq)}/live`),
-    setLive: (q, sq, body) => call('PUT', `${Q(q)}/squares/${enc(sq)}/live`, body),
-    tree: (q, rev, paths) => call('GET', `${Q(q)}/tree/${enc(rev || 'main')}${qs({ paths })}`),
-    cat: (q, rev, path, o = {}) => call('GET', `${Q(q)}/blob/${enc(rev || 'main')}/${pathPart(path)}${qs(o)}`),
-    blame: (q, rev, path) => call('GET', `${Q(q)}/blame/${enc(rev || 'main')}/${pathPart(path)}`),
-    have: (q, ids) => call('POST', `${Q(q)}/have`, { ids }),
-    blobs: (q, ids) => call('POST', `${Q(q)}/blobs`, { ids }),
-    uploadPack: (q, bytes) => call('POST', `${Q(q)}/packs`, bytes, { raw: true }),
-    importCommits: (q, items, lines = []) => call('POST', `${Q(q)}/import/commits`, { items, ...(lines.length ? { lines } : {}) }),
-    importKnown: (q, shas) => call('POST', `${Q(q)}/import/known`, { shas }),
-
-    /**
-     * Uploads objects the server does not have yet ([{ kind, id, bytes }]), in packs of at most
-     * ~48 MiB, after asking `have` (04: want-only, one pack per commit for a typical commit).
-     */
-    async upload (q, objs) {
-      const missing = new Set()
-      for (let i = 0; i < objs.length; i += 10000) for (const id of (await call('POST', `${Q(q)}/have`, { ids: objs.slice(i, i + 10000).map((o) => o.id) })).missing) missing.add(id)
-      const todo = objs.filter((o) => missing.has(o.id))
-      let batch = []; let size = 0; let packs = 0
-      const flush = async () => { if (!batch.length) return; await call('POST', `${Q(q)}/packs`, buildPack(batch).bytes, { raw: true }); packs++; batch = []; size = 0 }
-      for (const o of todo) {
-        if (size + o.bytes.length > 48 * 1024 * 1024) await flush()
-        batch.push(o); size += o.bytes.length
-      }
-      await flush()
-      return { uploaded: todo.length, packs }
-    }
-  }
-}