@heyquilt/seam 0.1.1 → 0.17.0

package/lib/quilts/describe.js

@@ -10,6 +10,7 @@ export function describeSquare (s) {
   if (s.state === 'merged' && s.merged) bits.push(`as ${patchName(s.merged)}`)
   if (s.state === 'open') {
     bits.push(s.head ? `head ${s.head.slice(0, 12)}` : 'no commits yet')
+    if (s.on) bits.push(`stacked on ${s.on}`)
     if (s.behind_by) bits.push(`${s.behind_by} patch${s.behind_by === 1 ? '' : 'es'} behind ${s.line}`)
     if (s.conflicted_paths) bits.push(`${s.conflicted_paths} conflicted path${s.conflicted_paths === 1 ? '' : 's'}`)
   }
@@ -20,8 +21,8 @@ export function describeSquare (s) {
 export function describeLog (r, { oneline = false } = {}) {
   if (!r.commits.length) return 'No commits.'
   const lines = r.commits.map((c) => oneline
-    ? `${c.short} ${c.patch ? `[${c.patch.line}:${c.patch.patch_no}] ` : ''}${first(c.message)}`
-    : [`commit ${c.id}${c.patch ? ` (${patchName(c.patch)})` : ''}`, `Square: ${c.square}`, `Author: ${c.author.name} <${c.author.member_id}>${c.author.tool ? ` via ${c.author.tool}` : ''}`, `Date:   ${when(c.authored_at)}`, '', ...String(c.message || '').split('\n').map((l) => `    ${l}`), ''].join('\n'))
+    ? `${c.short} ${c.patch ? `[${c.patch.line}:${c.patch.patch_no}] ` : ''}${first(c.message)}${r.follow && c.path && c.path !== r.follow ? `  (${c.path})` : ''}${c.signature ? `  (signature: ${c.signature.status})` : ''}`
+    : [`commit ${c.id}${c.patch ? ` (${patchName(c.patch)})` : ''}`, `Square: ${c.square}`, ...(r.follow && c.path && c.path !== r.follow ? [`Path:   ${c.path}`] : []), `Author: ${c.author.name} <${c.author.member_id}>${c.author.tool ? ` via ${c.author.tool}` : ''}`, ...(c.signature ? [describeSignature(c.signature)] : []), `Date:   ${when(c.authored_at)}`, '', ...String(c.message || '').split('\n').map((l) => `    ${l}`), ''].join('\n'))
   if (r.more) lines.push(oneline ? '…' : '(more: seam log -n <count>)')
   return lines.join('\n')
 }
@@ -86,6 +87,8 @@ export function describeWrite (r, verb = 'Done') {
   const bits = [`${verb}${c && c.id ? ` ${c.short}` : ''}${c && c.message ? ` "${first(c.message)}"` : ''}`]
   if (r.square) bits.push(`square ${describeSquare(r.square)}`)
   if (r.conflicted) bits.push(`${r.conflicted} conflicted path${r.conflicted === 1 ? '' : 's'}: ${(r.terms || []).map((t) => `${t.path} (${t.kind})`).join(', ')}`)
+  const reused = (r.combined || []).filter((c) => c.how === 'reuse')
+  if (reused.length) bits.push(`Settled the way it was settled before: ${reused.map((c) => `${c.path} (by ${c.by})`).join(', ')}`)
   return bits.join('\n')
 }
 
@@ -94,7 +97,8 @@ export function describeMerge (r) {
   if (r.ok) {
     const lines = [`Merged as ${patchName(r.merged)} (${r.merged.commit.slice(0, 12)})${r.retries ? ` after ${r.retries} lost race${r.retries === 1 ? '' : 's'}` : ''}.`]
     const combined = (r.combined || []).filter((c) => c.how !== 'lines' || true)
-    if (combined.length) lines.push(`Combined with changes already on ${r.merged.line}: ${combined.map((c) => `${c.path} (${c.how})`).join(', ')}.`)
+    if (combined.length) lines.push(`Combined with changes already on ${r.merged.line}: ${combined.map((c) => c.how === 'reuse' ? `${c.path} (settled as ${c.by} settled it before)` : `${c.path} (${c.how})`).join(', ')}.`)
+    for (const k of r.restacked || []) lines.push(k.error ? `${k.square} is stacked on it and could not be moved (${k.error}): its holder rebases it.` : `Moved ${k.square}, stacked on it, onto ${r.merged.line}${k.conflicted ? ` with ${k.conflicted} conflicted path${k.conflicted === 1 ? '' : 's'}` : ''}.`)
     return lines.join('\n')
   }
   const lines = [`Not merged: ${r.refused ? r.refused.detail : r.error}.`]
@@ -118,3 +122,145 @@ export function describeEvents (r) {
   }
   return [...r.events.map(line), `(next: after=${r.after})`].join('\n')
 }
+
+/** One tag per line: name, commit, patch, and "release" when it is one. */
+export const describeTag = (x) => `${x.name}  ${x.short}${x.patch ? ` ${x.patch.line}:${x.patch.patch_no}` : ''}${x.release ? '  release' : ''}`
+/** A release and its notes, indented under it. */
+export const describeRelease = (x) => `${x.name}  ${x.short}${x.patch ? ` ${x.patch.line}:${x.patch.patch_no}` : ''}  ${String(x.at && new Date(x.at).toISOString()).slice(0, 10)} ${x.by}` +
+  (x.notes ? '\n' + x.notes.split('\n').map((l) => `  ${l}`).join('\n') : '')
+
+/** A git import's answer, the same words from the CLI and seam_import_git. */
+export function describeImport (r) {
+  const said = [`${r.again ? 'Added' : 'Imported'} ${r.commits} commits (${r.patches} patches) into ${r.slug}.`]
+  for (const l of r.lines) said.push(`  ${l.name}${l.name !== l.git ? ` (git ${l.git})` : ''}: ${l.added} new patches`)
+  if (r.tags) said.push(`  tags: ${r.tags}`)
+  for (const x of r.report) said.push(`  left out: ${x.ref || x.path || x.sha.slice(0, 12)}: ${x.note}`)
+  if (r.validated != null) said.push(`Validated ${r.validated} trees against git.`)
+  return said.join('\n')
+}
+
+export function describeRestore (r) {
+  return r.restored.length ? `Restored ${r.restored.length} file(s) to the last commit: ${r.restored.join(', ')}` : 'Nothing to restore: those files have no uncommitted edits.'
+}
+
+export function describeReset (r, block) {
+  const n = r.written + r.removed
+  const where = block.square ? 'the square' : block.line
+  return `Reset ${n} file(s) to ${String(r.rev).slice(0, 12)}.` + (r.changes ? `\n${r.changes} change(s) from ${where} show as uncommitted (seam status); commit them to keep them, or seam reset to go back.` : '')
+}
+
+export function describeClean (r, again) {
+  if (!r.removed.length) return 'Nothing to clean.'
+  if (r.dry_run) return r.removed.map((p) => `Would remove ${p}`).join('\n') + `\n${again}`
+  return `Removed ${r.removed.length} file(s): ${r.removed.join(', ')}`
+}
+
+export function describeLive (r) {
+  if (!r.changes.length) return `No uncommitted work shared for ${r.square}: ${r.square}:live is its head.`
+  return [`Uncommitted work in ${r.square}${r.by ? ` (shared by ${r.by})` : ''}, read as ${r.square}:live:`, ...r.changes.map((c) => `  ${c.status.padEnd(9)} ${c.path}`)].join('\n')
+}
+
+export function describeLiveSet (r) {
+  return r.changes.length ? `Shared ${r.changes.length} uncommitted change(s) of ${r.square}: read them as ${r.square}:live.` : `Cleared the live work of ${r.square}.`
+}
+
+const at = (c) => `${c.short || String(c.id || c.commit).slice(0, 12)}${c.patch ? ` (${c.patch.line}:${c.patch.patch_no})` : ''}`
+
+export function describeMergeBase (r) {
+  return r.commit ? `${r.commit}${r.patch ? ` (${r.patch.line}:${r.patch.patch_no})` : ''}` : 'No common history.'
+}
+
+export function describeGrep (r, { filesOnly = false } = {}) {
+  if (!r.matches.length) return 'No matches.'
+  const lines = filesOnly ? r.files : r.matches.map((m) => `${m.quilt ? m.quilt + ':' : ''}${m.path}:${m.line}:${m.text}`)
+  if (r.more) lines.push('… (more: raise the limit, or narrow by paths)')
+  if (r.skipped) lines.push(`(${r.skipped} large file(s) not searched)`)
+  return lines.join('\n')
+}
+
+export function describeBisect (r) {
+  if (r.done) {
+    const said = [`First bad: ${at(r.first_bad)} ${first(r.first_bad.message)}`]
+    if (r.maybe) said.push(`Or one of the skipped commits before it: ${r.maybe.map(at).join(', ')}`)
+    return said.join('\n')
+  }
+  return `Test ${at(r.next)} ${first(r.next.message)}: ${r.remaining} commit(s) left, about ${r.steps} step(s). Mark it good, bad or skip and ask again.`
+}
+
+/** A list of claims, one per line. */
+export function describeClaims (claims) {
+  if (!claims.length) return 'No claims.'
+  return claims.map((c) => `${c.pattern}  ${c.square} (${c.line})  ${c.holder}${c.note ? `: ${c.note}` : ''}`).join('\n')
+}
+
+export function describeCheck (r) {
+  const lines = [`${r.line}: merge window ${r.window} an hour${r.red.length ? ` (red: ${r.red.join(', ')})` : ''}.`]
+  const v = r.revert
+  if (v && v.reverted) lines.push(`Reverted patch ${r.line}:${v.patch_no} as patch ${r.line}:${v.revert_patch_no}.${v.fix_square ? ` The change is again in square ${v.fix_square.short}, held by ${v.fix_square.holder}: fix it there, commit, merge.` : ''}`)
+  else if (v) lines.push(`Did not revert patch ${r.line}:${v.patch_no}: ${(v.refused && (v.refused.detail || v.refused.code)) || 'refused'}.${v.square ? ` The revert waits in square ${v.square.short}.` : ''}`)
+  return lines.join('\n')
+}
+
+/** Remembered resolutions, one per line. */
+export function describeResolutions (rows) {
+  if (!rows.length) return 'No remembered resolutions.'
+  return rows.map((r) => `${r.short}  ${r.path}  ${r.answer === 'delete' ? 'deleted' : `kept ${r.blob.slice(0, 12)}`} (${r.how}, ${r.by})`).join('\n')
+}
+
+/** Where a square stands in review: approvals against what its line needs. */
+function describeStanding (r) {
+  const parts = [`${r.have} of ${r.need} approval${r.need === 1 ? '' : 's'}${r.approved_by.length ? ` (${r.approved_by.join(', ')})` : ''}`]
+  if (r.changes_requested_by.length) parts.push(`changes asked for by ${r.changes_requested_by.join(', ')}`)
+  for (const c of r.checks || []) if (c.required || c.status !== 'missing') parts.push(`check ${c.name} ${c.status}`)
+  parts.push(r.ready ? 'ready to merge' : 'not ready to merge')
+  return parts.join('; ')
+}
+
+/** A square's reviews, oldest first, then where it stands. */
+export function describeReviews (r) {
+  const rows = r.reviews.map((x) => {
+    const what = { approve: 'approved', request_changes: 'asked for changes', dismiss: 'dismissed their verdict', comment: 'commented' }[x.kind]
+    const where = x.path ? ` on ${x.path}${x.line ? `:${x.line}` : ''}` : ''
+    return `${x.author} ${what}${where}${x.outdated ? ' (an earlier commit)' : ''}${x.body ? `: ${x.body}` : ''}`
+  })
+  return `${r.square} on ${r.line}: ${describeStanding(r)}${rows.length ? '\n' + rows.join('\n') : '\nNo reviews yet.'}`
+}
+
+/** One review just given. */
+export function describeReviewed (r) {
+  const x = r.review
+  const what = { approve: 'Approved', request_changes: 'Asked for changes on', dismiss: 'Dismissed your verdict on', comment: 'Commented on' }[x.kind]
+  return `${what} ${x.square}${x.path ? ` at ${x.path}${x.line ? `:${x.line}` : ''}` : ''}. ${describeStanding(r)}.`
+}
+
+/** What a line needs to take a merge. */
+export function describePolicy (p) {
+  const parts = []
+  if (p.approvals) parts.push(`${p.approvals} approval${p.approvals === 1 ? '' : 's'} of a square's latest commit from someone other than its holder`)
+  if (p.checks?.length) parts.push(`check${p.checks.length === 1 ? '' : 's'} ${p.checks.join(', ')} green on it`)
+  return parts.length ? `${p.line} needs ${parts.join(' and ')} to take a merge.` : `${p.line} takes merges without approvals or checks.`
+}
+
+/** A check reported on a square. */
+export function describeSquareCheck (r) {
+  const req = r.checks.filter((c) => c.required)
+  const left = req.filter((c) => c.status !== 'green').map((c) => `${c.name} ${c.status}`)
+  return `${r.check} is ${r.status} on ${r.square} (${r.head.slice(0, 12)}).${req.length ? (left.length ? ` Its line still needs: ${left.join(', ')}.` : ' Every check its line requires is green.') : ''}`
+}
+
+const SIGNATURE_WORDS = { good: 'Good signature', bad: 'BAD signature', removed_key: 'Signature by a removed key', none: 'No signature' }
+export function describeSignature (s) {
+  return `Signed: ${SIGNATURE_WORDS[s.status] || s.status}${s.key ? ` from ${s.signer} (${s.key})` : ''}`
+}
+
+export function describeKeys (r) {
+  if (!r.keys.length) return `${r.member} has no signing keys.`
+  return r.keys.map((k) => `${k.key}${k.name ? `  ${k.name}` : ''}${k.removed_at ? `  (removed ${when(k.removed_at)})` : `  added ${when(k.added_at)}`}`).join('\n')
+}
+
+export function describeTokens (r) {
+  if (!r.tokens.length) return `${r.quilt} has no tokens. Make one with seam token new <name> [--level read|write].`
+  return r.tokens.map((t) => `${t.id}  ${t.name}  ${t.level}${t.revoked_at ? `  (revoked ${when(t.revoked_at)})` : `  made ${when(t.created_at)} by ${t.created_by}`}`).join('\n')
+}
+
+export const describeNewToken = (t) => `Made token ${t.name} (${t.level} on ${t.quilt}, id ${t.id}). Its secret, shown only this once:\n\n  ${t.token}\n\nSet it as SEAM_TOKEN (or send it as Authorization: Bearer <token>).`

package/lib/quilts/errors.js

@@ -0,0 +1,8 @@
+// What both the server and the seam client need without loading the server (service.js).
+export class QuiltError extends Error {
+  /** `code` is the wire name (04/07/12): head_moved, tip_moved, conflict, not_found, ... */
+  constructor (status, code, message, extra = {}) { super(message); this.status = status; this.code = code; this.extra = extra }
+}
+
+/** A square's short handle: sq: + the last 8 hex of its uuid (02). */
+export const squareShort = (id) => `sq:${String(id).replace(/-/g, '').slice(-8)}`

package/lib/quilts/export-git.js

@@ -9,7 +9,7 @@ import { spawn, execFileSync } from 'node:child_process'
 import fs from 'node:fs'
 import path from 'node:path'
 
-const MODES = { file: '100644', exec: '100755', symlink: '120000' }
+const MODES = { file: '100644', exec: '100755', symlink: '120000', gitlink: '160000' }
 const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_CONFIG_NOSYSTEM: '1' }
 
 const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { env: GIT_ENV, maxBuffer: 256 * 1024 * 1024 }).toString().trim()
@@ -90,6 +90,9 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
     let mark = 0
     const blobMark = new Map()
     for (const [id, bytes] of blobs) {
+      // A gitlink's content is the submodule commit it pins; git writes no blob for it.
+      if (r.patches.some((p) => p.changes.some((c) => c.blob === id && c.mode === 'gitlink'))) blobMark.set(id, bytes.toString('utf8').trim())
+      if (blobMark.has(id)) continue
       blobMark.set(id, ++mark)
       await send(`blob\nmark :${mark}\ndata ${bytes.length}\n`); await send(bytes); await send('\n')
     }
@@ -104,6 +107,7 @@ export async function exportGit (client, { q, dir, line = 'main', branch, page =
       first = false
       for (const c of p.changes) {
         if (c.op === 'delete') s += `D ${fiPath(c.path)}\n`
+        else if (c.mode === 'gitlink') s += `M 160000 ${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
         else s += `M ${MODES[c.mode || 'file'] || MODES.file} :${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
       }
       await send(s + '\n')

package/lib/quilts/hash.js

@@ -17,7 +17,7 @@ export const KINDS = ['commit', 'blob', 'tree', 'chunk', 'pack', 'term', 'manife
 
 /** The id of `bytes` as an object of `kind`: BLAKE3 derive-key mode, 32 bytes, as hex. */
 // Not object kinds: keys made with their own contexts so they can never equal an object id.
-const KEY_KINDS = ['idempotency']
+const KEY_KINDS = ['idempotency', 'resolution']
 
 /** A key (not an object id) in its own context, e.g. 'idempotency' → "quilt idempotency v1". */
 export function keyOf (kind, bytes) {

package/lib/quilts/import-git.js

@@ -1,14 +1,16 @@
 // The local driver of a git import (plans/quilt-source-control/14): walks a repository on this
 // machine with `git cat-file --batch`, hashes blobs with BLAKE3, uploads the missing ones in
 // packs with the commit records, and sends the commits in order. Every commit on HEAD's
-// first-parent chain becomes a patch on main with a square of its own; a merge commit's side
-// commits become the commits of the merge's square (14, "Which square owns each commit").
+// first-parent chain becomes a patch on main with a square of its own, and every other branch's
+// on a line of its name; a merge commit's side commits become the commits of the merge's square
+// (14, "Which square owns each commit"). Tags come too, submodules stay gitlink entries, LFS
+// pointer files stay the pointer files they are, and a second import adds only new commits.
 import { spawn, execFileSync } from 'node:child_process'
 import { cleanCommit, commitId, commitBytes, blobId } from './records.js'
 import { uuidv7 } from './ids.js'
 
 const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' }
-const MODES = { 100644: 'file', 100755: 'exec', 120000: 'symlink', 100664: 'file' }
+const MODES = { 100644: 'file', 100755: 'exec', 120000: 'symlink', 100664: 'file', 160000: 'gitlink' }
 
 /** A long-lived `git cat-file --batch`: get(sha) → { type, bytes }. */
 function catFile (repo) {
@@ -78,56 +80,106 @@ const agentEmail = /@agents\.noreply\.heyquilt\.com$/i
 const member = (who) => ({ member_id: `stub:${String(who.email || who.name).toLowerCase()}`, kind: agentEmail.test(who.email || '') ? 'agent' : 'person', name: who.name || who.email })
 
 /**
- * Imports the history of HEAD in `repo` into a new quilt `slug`. Returns { quilt, slug,
- * commits, patches, report, validated? }.
+ * The branches to import: [{ name, sha }], HEAD's branch first as main. Local branches, then
+ * remote-tracking ones (origin/dev → dev) no local branch has, so a fresh clone brings them all.
  */
-export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0 }) {
+function branches (repo, head) {
+  let current = null
+  try { current = git(repo, ['symbolic-ref', '-q', '--short', 'HEAD']).toString().trim() || null } catch {}
+  const out = [{ name: 'main', sha: head, git: current || 'HEAD' }]
+  const seen = new Set([current, 'HEAD'])
+  const rows = git(repo, ['for-each-ref', '--format=%(refname)%00%(objectname)%00%(objecttype)', 'refs/heads', 'refs/remotes']).toString().split('\n').filter(Boolean).map((l) => l.split('\0'))
+  for (const local of [true, false]) {
+    for (const [ref, sha, type] of rows) {
+      if (type !== 'commit' || ref.startsWith('refs/heads/') !== local) continue
+      const name = local ? ref.slice(11) : ref.split('/').slice(3).join('/')
+      if (!name || name === 'HEAD' || seen.has(name)) continue
+      seen.add(name)
+      out.push({ name, sha, git: local ? name : ref.slice(13) })
+    }
+  }
+  return out
+}
+
+/** Every tag: [{ name, sha }] with sha the commit it names (an annotated tag peeled). */
+function gitTags (repo) {
+  return git(repo, ['for-each-ref', '--format=%(refname:strip=2)%00%(objectname)%00%(*objectname)%00%(objecttype)%00%(*objecttype)', 'refs/tags']).toString().split('\n').filter(Boolean).map((l) => {
+    const [name, sha, peeled, type, ptype] = l.split('\0')
+    return { name, sha: peeled || sha, type: ptype || type }
+  })
+}
+
+/**
+ * Imports a git repository into the quilt `slug`: HEAD's branch as main, every other branch as a
+ * line of its own name, and every tag. Into a new quilt, or again into a quilt an import made,
+ * where only the commits it does not have yet are added. Returns { quilt, slug, commits,
+ * patches, lines, tags, report, validated? }.
+ */
+export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false }) {
   const head = git(repo, ['rev-parse', 'HEAD']).toString().trim()
-  const all = git(repo, ['rev-list', head]).toString().split('\n').filter(Boolean)
+  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head)
+  const all = git(repo, ['rev-list', ...new Set(refs.map((r) => r.sha))]).toString().split('\n').filter(Boolean)
   const cat = catFile(repo)
   const report = []
   try {
     // Parents and fields of every commit, read once.
     const info = new Map()
     for (const sha of all) info.set(sha, parseCommit((await cat.get(sha)).bytes))
-    // HEAD's first-parent chain, root first.
-    const chain = []
-    for (let s = head; s; s = info.get(s).parents[0]) chain.push(s)
-    chain.reverse()
-    if (limit) chain.length = Math.min(chain.length, limit)
-
-    const quilt = await client.createQuilt({ slug, name: slug, import: true })
-    log(`Importing ${chain.length} patches (${all.length} commits in all) into ${quilt.slug}…`)
+
+    // A quilt an import made takes the new commits; otherwise a new quilt.
+    let quilt = null
+    try { quilt = await client.quilt(slug) } catch (err) { if (err.status !== 404) throw err }
+    if (quilt && fresh) throw new Error(`there is already a quilt ${slug}`)
+    const again = !!quilt
+    if (!quilt) quilt = await client.createQuilt({ slug, name: slug, import: true })
     const ids = new Map() // git sha → quilt commit id
+    if (again) {
+      for (let i = 0; i < all.length; i += 5000) {
+        const { known } = await client.importKnown(quilt.id, all.slice(i, i + 5000))
+        for (const [sha, id] of Object.entries(known)) ids.set(sha, id)
+      }
+    }
+    const lineTips = new Map((again ? await client.lines(quilt.id) : [{ name: 'main', tip: null }]).map((l) => [l.name, l.tip]))
+    log(again ? `Adding to ${quilt.slug}: ${all.length - ids.size} new commits of ${all.length}…` : `Importing ${all.length} commits on ${refs.length} branches into ${quilt.slug}…`)
+
     const blobs = new Map() // git blob sha → { id, size }
-    const assigned = new Set()
+    const assigned = new Set(ids.keys())
     const items = []
+    const newLines = []
+    const written = [] // the git shas of the patches this import writes
     let pending = []
     let commits = 0; let patches = 0
+    const lines = []
 
     const flush = async () => {
-      if (!items.length) return
-      await client.upload(quilt.id, pending)
-      const r = await client.importCommits(quilt.id, items.splice(0))
+      if (!items.length && !newLines.length) return
+      if (pending.length) await client.upload(quilt.id, pending)
+      const r = await client.importCommits(quilt.id, items.splice(0), newLines.splice(0))
       pending = []
       commits += r.commits; patches += r.patches
       log(`  ${patches} patches, ${commits} commits`)
     }
 
-    const emit = async (sha, square, kind) => {
+    const blobOf = async (sha, gitMode) => {
+      let b = blobs.get(sha)
+      if (!b) {
+        // A submodule has no blob in git: its entry's content is the commit sha it pins.
+        const bytes = gitMode === '160000' ? Buffer.from(sha) : (await cat.get(sha)).bytes
+        b = { id: blobId(bytes), size: bytes.length }
+        blobs.set(sha, b)
+        pending.push({ kind: 'blob', id: b.id, bytes })
+      }
+      return b
+    }
+
+    const emit = async (sha, square, kind, line) => {
       const g = info.get(sha)
       const changes = []
       for (const ch of diffTree(repo, g.parents[0] || null, sha)) {
         if (ch.delete) { changes.push({ path: ch.path, op: 'delete' }); continue }
         const mode = MODES[ch.gitMode]
-        if (!mode) { report.push({ kind: ch.gitMode === '160000' ? 'submodule' : 'mode', sha, path: ch.path, note: `git mode ${ch.gitMode} left out` }); continue }
-        let b = blobs.get(ch.sha)
-        if (!b) {
-          const { bytes } = await cat.get(ch.sha)
-          b = { id: blobId(bytes), size: bytes.length }
-          blobs.set(ch.sha, b)
-          pending.push({ kind: 'blob', id: b.id, bytes })
-        }
+        if (!mode) { report.push({ kind: 'mode', sha, path: ch.path, note: `git mode ${ch.gitMode} left out` }); continue }
+        const b = await blobOf(ch.sha, ch.gitMode)
         changes.push({ path: ch.path, op: 'put', blob: b.id, mode, size: b.size })
       }
       const c = cleanCommit({
@@ -138,56 +190,102 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
       const id = commitId(c)
       ids.set(sha, id)
       pending.push({ kind: 'commit', id, bytes: commitBytes(c) })
-      items.push({ id, commit: c, kind, square, git_sha: sha, payload: { committer: g.committer || null, author_email: g.author?.email || '' } })
+      if (kind === 'patch') written.push(sha)
+      items.push({ id, commit: c, kind, line, square, git_sha: sha, payload: { committer: g.committer || null, author_email: g.author?.email || '' } })
       if (items.length >= batch) await flush()
     }
 
-    for (const sha of chain) {
-      const g = info.get(sha)
-      const title = String(g.message).split('\n')[0].slice(0, 200)
-      const square = { id: uuidv7(g.author?.at || Date.now()), title, base: g.parents[0] ? ids.get(g.parents[0]) || null : null, holder: member(g.author || {}).member_id }
-      if (g.parents.length > 1) {
-        // Side commits: reachable from parents 2..n and not yet in any square, parents first.
-        const side = []
-        const seen = new Set()
-        const visit = (s) => {
-          if (!s || seen.has(s) || assigned.has(s) || !info.has(s)) return
-          seen.add(s)
-          for (const p of info.get(s).parents) visit(p)
-          side.push(s)
-        }
-        for (const p of g.parents.slice(1)) visit(p)
-        if (side.length) {
-          const m = title.match(/^Merge (?:pull request #\d+ from |branch ')([^' ]+)/)
-          if (m) square.title = m[1]
-          for (const s of side) { assigned.add(s); await emit(s, square, 'side') }
+    // One branch: its first-parent commits not yet imported become patches on its line.
+    const importBranch = async (ref) => {
+      const chain = []
+      let s = ref.sha
+      for (; s && !ids.has(s); s = info.get(s).parents[0]) chain.push(s)
+      const base = s ? ids.get(s) : null
+      chain.reverse()
+      if (limit && ref.name === 'main') chain.length = Math.min(chain.length, limit)
+      if (!lineTips.has(ref.name)) {
+        if (!base) { report.push({ kind: 'branch', ref: ref.git, note: 'shares no history with the other branches; left out' }); return }
+        if (!LINE_NAME.test(ref.name) || /\.\.|\/\/|\/$/.test(ref.name)) { report.push({ kind: 'branch', ref: ref.git, note: 'its name cannot be a line; left out' }); return }
+        await flush() // the line's first commit is imported before the line names it
+        newLines.push({ name: ref.name, tip: base })
+        lineTips.set(ref.name, base)
+      } else if ((lineTips.get(ref.name) || null) !== base) {
+        // The line moved on in the quilt (merges since the import), or git rewrote the branch.
+        if (chain.length) report.push({ kind: 'branch', ref: ref.git, note: `line ${ref.name} no longer follows git's branch; its ${chain.length} new commits were left out` })
+        return
+      }
+      for (const sha of chain) {
+        const g = info.get(sha)
+        const title = String(g.message).split('\n')[0].slice(0, 200)
+        const square = { id: uuidv7(g.author?.at || Date.now()), title, base: g.parents[0] ? ids.get(g.parents[0]) || null : null, holder: member(g.author || {}).member_id }
+        if (g.parents.length > 1) {
+          // Side commits: reachable from parents 2..n and not yet in any square, parents first.
+          const side = []
+          const seen = new Set()
+          const visit = (x) => {
+            if (!x || seen.has(x) || assigned.has(x) || !info.has(x)) return
+            seen.add(x)
+            for (const p of info.get(x).parents) visit(p)
+            side.push(x)
+          }
+          for (const p of g.parents.slice(1)) visit(p)
+          if (side.length) {
+            const m = title.match(/^Merge (?:pull request #\d+ from |branch ')([^' ]+)/)
+            if (m) square.title = m[1]
+            for (const x of side) { assigned.add(x); await emit(x, square, 'side', ref.name) }
+          }
         }
+        assigned.add(sha)
+        await emit(sha, square, 'patch', ref.name)
       }
-      assigned.add(sha)
-      await emit(sha, square, 'patch')
+      lineTips.set(ref.name, chain.length ? ids.get(chain[chain.length - 1]) : base)
+      lines.push({ name: ref.name, git: ref.git, added: chain.length })
     }
+
+    for (const ref of refs) await importBranch(ref)
     await flush()
 
+    // Tags, on the commits they name. A tag is never moved: one the quilt has on another commit is reported.
+    const have = again ? new Map((await client.tags(quilt.id)).map((t) => [t.name, t.commit])) : new Map()
+    let tagged = 0
+    for (const t of onlyHead ? [] : gitTags(repo)) {
+      const id = t.type === 'commit' ? ids.get(t.sha) : null
+      if (!id) { report.push({ kind: 'tag', ref: t.name, note: 'names no imported commit; left out' }); continue }
+      if (have.has(t.name)) { if (have.get(t.name) !== id) report.push({ kind: 'tag', ref: t.name, note: 'the quilt has this tag on another commit; left as it is' }); continue }
+      try { await client.createTag(quilt.id, { name: t.name, rev: `c:${id}` }); tagged++ } catch (err) { report.push({ kind: 'tag', ref: t.name, note: err.message }) }
+    }
+
     let validated
     if (validate) {
       validated = 0
-      // validate: 'all' checks every imported commit (side commits of merges too), else the patches.
-      for (const sha of validate === 'all' ? [...ids.keys()] : chain) {
+      // validate: 'all' checks every commit the quilt has from git (side commits of merges too),
+      // else the patches this import wrote.
+      const check = validate === 'all' ? [...ids.keys()] : written
+      for (const sha of check) {
         const want = new Map()
         for (const row of git(repo, ['ls-tree', '-r', '-z', sha]).toString('utf8').split('\0').filter(Boolean)) {
           const [meta, path] = row.split('\t')
           const [mode, type, osha] = meta.split(' ')
-          if (type !== 'blob' || !MODES[mode]) continue
-          want.set(path, { mode: MODES[mode], blob: blobs.get(osha)?.id })
+          if ((type !== 'blob' && type !== 'commit') || !MODES[mode]) continue
+          want.set(path, { mode: MODES[mode], osha, gitMode: mode })
         }
         const t = await client.tree(quilt.id, `c:${ids.get(sha)}`)
-        const bad = t.entries.length !== want.size || t.entries.some((e) => { const w = want.get(e.path); return !w || w.mode !== e.mode || w.blob !== e.blob })
+        let bad = t.entries.length !== want.size
+        for (const e of t.entries) {
+          const w = want.get(e.path)
+          if (bad || !w || w.mode !== e.mode) { bad = true; break }
+          // Blobs from an earlier import were not read this time: hash them now.
+          const id = blobs.get(w.osha)?.id || blobId(w.gitMode === '160000' ? Buffer.from(w.osha) : (await cat.get(w.osha)).bytes)
+          if (id !== e.blob) { bad = true; break }
+        }
         if (bad) throw new Error(`validation: the tree of git ${sha.slice(0, 12)} does not match quilt commit ${ids.get(sha).slice(0, 12)}`)
         validated++
       }
     }
-    return { quilt: quilt.id, slug: quilt.slug, commits, patches, report, ...(validate ? { validated } : {}), tip: ids.get(chain[chain.length - 1]) }
+    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
   } finally {
     cat.close()
   }
 }
+
+const LINE_NAME = /^[A-Za-z0-9._-][A-Za-z0-9._/-]{0,99}$/

package/lib/quilts/records.js

@@ -5,7 +5,8 @@
 import { encode, decode } from './cbor.js'
 import { idOf, isId, idBytes } from './hash.js'
 
-export const MODES = ['file', 'exec', 'symlink', 'quilt']
+// gitlink: a git submodule, kept as git has it: its blob is the submodule commit's sha as text.
+export const MODES = ['file', 'exec', 'symlink', 'quilt', 'gitlink']
 export const TERM_KINDS = ['content', 'order', 'edit_vs_delete', 'name', 'mode', 'square_divergence']
 export const MAX_FILES_PER_COMMIT = 20000
 export const MAX_MESSAGE = 64 * 1024