@heyquilt/seam 0.1.1 → 0.16.0

package/bin/seam.js

@@ -24,9 +24,14 @@ Docs: https://seam.heyquilt.com/docs
   seam square open "<title>" --quilt <q> [--dir <folder>]
   seam checkout <sq:id | revision> --quilt <q> [--dir <folder>] [-- paths]
   seam status | diff | commit -m "<message>"   in a block folder
+  seam restore <paths> | reset [rev] | clean [-f]   throw away uncommitted edits
+  seam live [sq] | live share | live clear   uncommitted work others read as sq:<id>:live
   seam merge [sq:id] [--into main]   seam rebase | revert <patch:n> | cherry-pick <rev>
   seam resolve <path>... --ours | --theirs | --base | --side n | --delete
   seam log [rev] [-n 20] [--oneline]  seam show <rev>  seam blame <path>[@rev]  seam cat | ls
+  seam key [add [--name n] | remove <key>]   seam commit --sign | sign [rev]   seam log --show-signature
+  seam line [new <name> [--from rev] | freeze | unfreeze]  Lines: main, release/<name>
+  seam tag [<name> [rev]]            seam release [<name> [rev] -m <notes>]  Read as tag:<name>
   seam events [--webhook <url>]      What happened to your squares
   seam export git <dir>              Back to git
   seam mcp                           The same commands as MCP tools, for your AI tool

package/lib/quilts/bisect-run.js

@@ -0,0 +1,31 @@
+// The check side of bisect (the server narrows, history.js): each commit the server names is
+// checked out into a fresh folder and the check command runs there. Exit 0 is good, 125 is skip,
+// 1 to 127 is bad, anything else (a signal, 128 and up) stops, as git bisect run does.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { checkout } from './block.js'
+
+const runIn = (cmd, cwd) => new Promise((resolve, reject) => {
+  const child = spawn(cmd, { cwd, shell: true, stdio: 'ignore' })
+  child.on('error', reject)
+  child.on('exit', (code, signal) => resolve(signal ? null : code))
+})
+
+export async function bisectRun (client, { quilt, bad, good, run, marks = {}, paths = [''], api, log = () => {} }) {
+  const m = { ...marks }
+  for (let i = 0; i < 200; i++) {
+    const r = await client.bisect(quilt, { bad, good, marks: m })
+    if (r.done) return { ...r, marks: m }
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'seam-bisect-'))
+    try {
+      await checkout(client, { quilt, rev: r.next.id, paths, dir, api })
+      const code = await runIn(run, dir)
+      if (code == null || code > 127) throw new Error(`The check stopped on ${r.next.short} (exit ${code ?? 'by a signal'}): bisect stopped.`)
+      m[r.next.id] = code === 0 ? 'good' : code === 125 ? 'skip' : 'bad'
+      log(`${r.next.short} ${m[r.next.id]}`)
+    } finally { fs.rmSync(dir, { recursive: true, force: true }) }
+  }
+  throw new Error('bisect took more than 200 steps')
+}

package/lib/quilts/block.js

@@ -35,29 +35,57 @@ export function saveBlock (dir, block) {
 
 const inBlock = (block, p) => block.paths.some((x) => under(p, x))
 
-function ignorer (dir) {
-  const ig = ignore().add(ALWAYS_IGNORED)
-  try { ig.add(fs.readFileSync(path.join(dir, '.gitignore'), 'utf8')) } catch {}
-  return ig
+/** The folders that hold committed files: they are walked even when a .gitignore names them. */
+function trackedDirs (block) {
+  const out = new Set()
+  for (const p of Object.keys(block.files)) for (let i = p.indexOf('/'); i > 0; i = p.indexOf('/', i + 1)) out.add(p.slice(0, i))
+  return out
+}
+
+/** Reads `rel`/.gitignore into the stack of rules in force there (deepest last). */
+function rulesIn (dir, rel, stack) {
+  try { return [...stack, { base: rel, ig: ignore().add(fs.readFileSync(path.join(dir, rel, '.gitignore'), 'utf8')) }] } catch { return stack }
+}
+
+/** As git decides: the deepest .gitignore with a rule for the path wins (a `!` rule re-includes). */
+function ignoredBy (stack, r, isDir) {
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const { base, ig } = stack[i]
+    const rel = base ? r.slice(base.length + 1) : r
+    const res = ig.test(isDir ? rel + '/' : rel)
+    if (res.ignored) return true
+    if (res.unignored) return false
+  }
+  return false
 }
 
-/** Every file under the block's paths on disk: Map path → { abs, stat }. */
+const ALWAYS = ignore().add(ALWAYS_IGNORED)
+
+/**
+ * Every file under the block's paths on disk: Map path → { abs, stat }. Every .gitignore on the
+ * way down is read, as git does; a committed file is never ignored.
+ */
 function scan (dir, block) {
-  const ig = ignorer(dir)
   const out = new Map()
-  const walk = (rel) => {
+  const dirs = trackedDirs(block)
+  const walk = (rel, stack) => {
     let names
     try { names = fs.readdirSync(path.join(dir, rel), { withFileTypes: true }) } catch { return }
     for (const d of names) {
       const r = rel ? `${rel}/${d.name}` : d.name
-      if (ig.ignores(d.isDirectory() ? r + '/' : r)) continue
-      if (d.isDirectory()) { if (block.paths.some((x) => under(r, x) || under(x, r))) walk(r); continue }
+      const n = r.normalize('NFC')
+      const isDir = d.isDirectory()
+      if (ALWAYS.ignores(isDir ? r + '/' : r)) continue
+      if (!(isDir ? dirs.has(n) : block.files[n]) && ignoredBy(stack, r, isDir)) continue
+      // A submodule's folder stands for its gitlink entry: what is inside belongs to the submodule.
+      if (isDir && block.files[n]?.mode === 'gitlink') { out.set(n, { abs: path.join(dir, r), gitlink: true }); continue }
+      if (isDir) { if (block.paths.some((x) => under(r, x) || under(x, r))) walk(r, rulesIn(dir, r, stack)); continue }
       if (!(d.isFile() || d.isSymbolicLink()) || !inBlock(block, r)) continue
       const abs = path.join(dir, r)
-      out.set(r.normalize('NFC'), { abs, stat: fs.lstatSync(abs) })
+      out.set(n, { abs, stat: fs.lstatSync(abs) })
     }
   }
-  walk('')
+  walk('', rulesIn(dir, '', []))
   return out
 }
 
@@ -75,8 +103,8 @@ export function localChanges (dir, block, { paths = [] } = {}) {
   const wanted = (p) => !only.length || only.some((x) => under(p, x))
   const files = scan(dir, block)
   const out = []
-  for (const [p, { abs, stat }] of files) {
-    if (!wanted(p)) continue
+  for (const [p, { abs, stat, gitlink }] of files) {
+    if (!wanted(p) || gitlink) continue
     const known = block.files[p]
     if (known && known.size === stat.size && known.mtimeMs === stat.mtimeMs) continue
     const { bytes, mode } = readFileEntry(abs, stat)
@@ -94,6 +122,8 @@ async function writeEntry (dir, e, content) {
   const abs = path.join(dir, ...e.path.split('/'))
   fs.mkdirSync(path.dirname(abs), { recursive: true })
   try { fs.rmSync(abs, { force: true }) } catch {}
+  // A git submodule is an empty folder, as git leaves one it has not cloned.
+  if (e.mode === 'gitlink') { fs.mkdirSync(abs, { recursive: true }); return { blob: e.blob, mode: 'gitlink', size: e.size, mtimeMs: 0 } }
   if (e.mode === 'symlink') fs.symlinkSync(content.toString('utf8'), abs)
   else fs.writeFileSync(abs, content, { mode: e.mode === 'exec' ? 0o755 : 0o644 })
   const st = fs.lstatSync(abs)
@@ -156,7 +186,11 @@ export async function syncTo (client, dir, block, to, { square } = {}) {
   for (const f of d.files) {
     if (local.has(f.path)) { kept.push(f.path); continue }
     const e = byPath.get(f.path)
-    if (!e) { fs.rmSync(path.join(dir, ...f.path.split('/')), { force: true }); delete block.files[f.path]; written++; continue }
+    if (!e) {
+      const abs = path.join(dir, ...f.path.split('/'))
+      if (block.files[f.path]?.mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true })
+      delete block.files[f.path]; written++; continue
+    }
     block.files[f.path] = await writeEntry(dir, e, await get(e))
     written++
   }
@@ -213,6 +247,25 @@ export async function commitFolder (client, dir, block, { message, paths = [] })
   return r
 }
 
+/** Amends the square's last commit with the folder's changes (paths: only these) and, if given, a new message. */
+export async function amendFolder (client, dir, block, { message, paths = [] }) {
+  if (!block.square) throw new Error('This folder is a read-only checkout of a line; there is no commit of yours to amend.')
+  const changes = localChanges(dir, block, { paths })
+  const blobs = changes.filter((c) => c.bytes).map((c) => ({ kind: 'blob', id: c.blob, bytes: c.bytes }))
+  if (blobs.length) await client.upload(block.quilt, blobs)
+  const list = changes.map((c) => c.status === 'deleted' ? { path: c.path, op: 'delete' } : { path: c.path, op: 'put', blob: c.blob, mode: c.mode || 'file' })
+  const r = await client.amend(block.quilt, block.square, { expect_head: block.head, ...(message ? { message } : {}), changes: list })
+  for (const c of changes) {
+    if (c.status === 'deleted') { delete block.files[c.path]; continue }
+    const st = fs.lstatSync(path.join(dir, ...c.path.split('/')))
+    block.files[c.path] = { blob: c.blob, mode: c.mode, size: st.size, mtimeMs: st.mtimeMs }
+  }
+  block.at = r.square.head
+  block.head = r.square.head
+  saveBlock(dir, block)
+  return r
+}
+
 /** The folder's changes as a unified diff against `at` (diff with no revision, in a block). */
 export async function localDiff (client, dir, block, { paths = [] } = {}) {
   const changes = localChanges(dir, block, { paths })
@@ -226,3 +279,69 @@ export async function localDiff (client, dir, block, { paths = [] } = {}) {
   }
   return { changes: changes.map(({ bytes, ...c }) => c), text: out.join('') }
 }
+
+const absOf = (dir, p) => path.join(dir, ...p.split('/'))
+const removeEntry = (dir, p, mode) => { const abs = absOf(dir, p); if (mode === 'gitlink') { try { fs.rmdirSync(abs) } catch {} } else fs.rmSync(abs, { force: true }) }
+
+/** Takes away the folders a removed file leaves empty, up to the block folder. */
+function pruneEmpty (dir, p) {
+  for (let d = path.dirname(absOf(dir, p)); d.startsWith(dir + path.sep); d = path.dirname(d)) {
+    try { if (fs.readdirSync(d).length) return; fs.rmdirSync(d) } catch { return }
+  }
+}
+
+/**
+ * restore: puts the named paths back as they were at the folder's last commit (`at`), throwing
+ * away their uncommitted edits and deletions. Files nobody committed are left (clean removes them).
+ */
+export async function restore (client, dir, block, { paths }) {
+  if (!paths?.length) throw new Error('Which files? seam restore <paths> (. for everything here)')
+  const changes = localChanges(dir, block, { paths }).filter((c) => c.status !== 'added')
+  const entries = changes.map((c) => ({ path: c.path, ...block.files[c.path] }))
+  const get = await contentsFor(client, block.quilt, `c:${block.at}`, entries)
+  for (const e of entries) block.files[e.path] = { ...await writeEntry(dir, e, await get(e)), ...(e.term ? { term: e.term } : {}) }
+  saveBlock(dir, block)
+  return { restored: entries.map((e) => e.path) }
+}
+
+/**
+ * reset: makes the folder's files those of `rev` (default: the folder's last commit, throwing
+ * away every uncommitted edit). The folder stays on its square or line: what differs from there
+ * shows as uncommitted changes, so a commit makes the square match `rev`. Files nobody committed
+ * stay unless `rev` has them.
+ */
+export async function reset (client, dir, block, { rev } = {}) {
+  if (!rev) {
+    const r = await restore(client, dir, block, { paths: [dir] })
+    return { rev: block.at, written: r.restored.length, removed: 0, changes: 0 }
+  }
+  const t = await client.tree(block.quilt, rev, block.paths)
+  const local = new Map(localChanges(dir, block).map((c) => [c.path, c]))
+  const want = new Map(t.entries.map((e) => [e.path, e]))
+  const toWrite = t.entries.filter((e) => {
+    const known = block.files[e.path]
+    return local.has(e.path) || !known || known.blob !== e.blob || known.mode !== e.mode || (e.term || null) !== (known.term || null)
+  })
+  const get = await contentsFor(client, block.quilt, rev, toWrite)
+  let removed = 0
+  for (const e of toWrite) {
+    const rec = await writeEntry(dir, e, await get(e))
+    const known = block.files[e.path]
+    // Same as the folder's commit: clean again. Otherwise the manifest keeps the commit's record,
+    // so the file shows as changed.
+    if (known && known.blob === e.blob && known.mode === e.mode) block.files[e.path] = rec
+  }
+  for (const [p, f] of Object.entries(block.files)) {
+    if (want.has(p) || !fs.existsSync(absOf(dir, p))) continue
+    removeEntry(dir, p, f.mode); pruneEmpty(dir, p); removed++
+  }
+  saveBlock(dir, block)
+  return { rev: t.commit, written: toWrite.length, removed, changes: localChanges(dir, block).length }
+}
+
+/** clean: removes the files under `paths` that nobody committed and no .gitignore names. */
+export function clean (dir, block, { paths = [], dryRun = false } = {}) {
+  const added = localChanges(dir, block, { paths }).filter((c) => c.status === 'added').map((c) => c.path)
+  if (!dryRun) for (const p of added) { removeEntry(dir, p, 'file'); pruneEmpty(dir, p) }
+  return { removed: added, dry_run: dryRun }
+}

package/lib/quilts/cli.js

@@ -4,16 +4,18 @@
 // --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, syncTo, localDiff, saveBlock } from './block.js'
-import { describeLog, describeShow, describeDiff, describeBlame, describeStatus, describeMerge, describeWrite, describeSquare, describeSquareStatus, describeEvents } from './describe.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 } 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'])
+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'])
 
-const VALUE_FLAGS = new Set(['-m', '--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'])
+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 = []
@@ -61,6 +63,43 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       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
@@ -75,7 +114,7 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     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'] })
+        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'])
@@ -130,20 +169,150 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       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.')
-      return print(r, describeWrite(r, 'Committed'))
+      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 '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 })
+      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'
@@ -206,13 +375,23 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
     }
     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 (or edit the file and commit it without the markers)')
+      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 })) })
+      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]')
@@ -236,12 +415,12 @@ export async function runSeamCommand (cmd, argv, { cwd = process.cwd(), token, o
       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 <new-quilt-slug>]')
+      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, `Imported ${r.commits} commits (${r.patches} patches on main) into ${r.slug} (${r.quilt}).${r.validated != null ? ` Validated ${r.validated} trees against git.` : ''}`)
+      return print(r, describeImport(r))
     }
     case 'export': {
       if (pos[0] !== 'git' || !pos[1]) throw new Error('seam export git <dir> [--line main] [--branch <name>]')

package/lib/quilts/client.js

@@ -45,6 +45,7 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     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`, {}),
@@ -54,6 +55,16 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     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)}`),
@@ -61,15 +72,37 @@ export function quiltClient ({ api, token, fetch: fetchImpl = globalThis.fetch,
     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),
+    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) => call('POST', `${Q(q)}/import/commits`, { items }),
+    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