spexcode 0.5.6 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spexcode",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "type": "module",
   "description": "SpexCode — a spec-driven, self-developing dev tool. The `spex` CLI + spec server reads the .spec tree and its git history, and serves the dashboard.",
   "license": "MIT",

package/spec-cli/src/anchors.ts

@@ -505,15 +505,24 @@ export function windowEvents(idx: DriftIndex, sinceHash: string, path: string, n
 // through the current filename. Several selectors are OR'd and one commit still produces one hit row.
 // An historical image the designated extractor cannot parse is a conservative hit (`unparseable`).
 export type AnchorHit = { commit: string; selectors: string[]; unparseable?: string }
-export async function anchorHitCommits(root: string, win: DriftPathEvent[], symbols: string[], regs: Extractor[]): Promise<AnchorHit[]> {
-  const hits = new Map<string, { selectors: Set<string>; unparseable?: string }>()
+export type AnchorHitQuery = { win: DriftPathEvent[]; symbols: string[] }
+type AnchorRevision = { commit: string; path: string }
+const anchorRevisionKey = ({ commit, path }: AnchorRevision) => `${commit}\0${path}`
+
+// One lint can judge several selectors with overlapping windows. Their Git images and ordinary hunks are
+// immutable facts, so the batch owns them once and each query keeps its own selector verdict.
+export async function anchorHitQueries(root: string, queries: AnchorHitQuery[], regs: Extractor[]): Promise<AnchorHit[][]> {
+  if (!queries.length) return []
   const objectFormat = gitObjectFormat(root)
-  type Revision = { commit: string; path: string }
-  const revisionKey = ({ commit, path }: Revision) => `${commit}\0${path}`
-  const revisions = new Map<string, Revision>()
-  for (const event of win) {
+  const revisions = new Map<string, AnchorRevision>()
+  const ordinaryByPath = new Map<string, Set<string>>()
+  for (const { win } of queries) for (const event of win) {
     const refs = [{ commit: event.commit, path: event.historicalPath }, ...event.parents.map(({ commit, historicalPath }) => ({ commit, path: historicalPath }))]
-    for (const ref of refs) revisions.set(revisionKey(ref), ref)
+    for (const ref of refs) revisions.set(anchorRevisionKey(ref), ref)
+    if (event.parents.length > 1 || event.parents.some((parent) => parent.historicalPath !== event.historicalPath)) continue
+    const commits = ordinaryByPath.get(event.historicalPath) ?? new Set<string>()
+    commits.add(event.commit)
+    ordinaryByPath.set(event.historicalPath, commits)
   }
   const refs = [...revisions.values()]
   const oids = batchRevisionOids(root, refs.map(({ commit, path }) => `${commit}:${path}`))
@@ -524,44 +533,45 @@ export async function anchorHitCommits(root: string, win: DriftPathEvent[], symb
     const x = extractorFor(regs, extOf(ref.path))
     const ready = x?.ready()
     if (!x || ready !== true) {
-      units.set(revisionKey(ref), { unparseable: !x ? `no designated extractor for ${ref.path}` : String(ready) })
+      units.set(anchorRevisionKey(ref), { unparseable: !x ? `no designated extractor for ${ref.path}` : String(ready) })
       continue
     }
-    units.set(revisionKey(ref), await unitsAtFileRevision(ref.commit, ref.path, x, objectFormat, oid, oid ? blobs.get(oid) : undefined))
-  }
-  const byPath = new Map<string, string[]>()
-  for (const event of win) {
-    if (event.parents.length > 1 || event.parents.some((parent) => parent.historicalPath !== event.historicalPath)) continue
-    const commits = byPath.get(event.historicalPath) ?? []
-    commits.push(event.commit)
-    byPath.set(event.historicalPath, commits)
+    units.set(anchorRevisionKey(ref), await unitsAtFileRevision(ref.commit, ref.path, x, objectFormat, oid, oid ? blobs.get(oid) : undefined))
   }
   const ordinaryHunks = new Map<string, Map<string, HunkRanges>>()
-  for (const [path, commits] of byPath) ordinaryHunks.set(path, await hunksAtMany(root, commits, path))
+  for (const [path, commits] of ordinaryByPath) ordinaryHunks.set(path, await hunksAtMany(root, [...commits], path))
   const intersects = (ranges: DiffLineRange[], candidates: Unit[]) =>
     ranges.some(([start, end]) => candidates.some((unit) => start <= unit.end && unit.start <= end))
-  for (const event of win) {
-    const after = units.get(revisionKey({ commit: event.commit, path: event.historicalPath }))!
-    const before = event.parents.map(({ commit, historicalPath }) => units.get(revisionKey({ commit, path: historicalPath }))!)
-    const ranges = ordinaryHunks.get(event.historicalPath)?.get(event.commit)
-      ?? await hunksAt(root, event)
-    if (event.parents.length && ranges.before.length !== before.length)
-      throw new Error(`anchor diff for ${event.commit}:${event.historicalPath} has ${ranges.before.length} parent ranges for ${before.length} parents`)
-    const hit = hits.get(event.commit) ?? { selectors: new Set<string>() }
-    const broken = [after, ...before].find((image) => 'unparseable' in image)
-    if (broken && 'unparseable' in broken) {
-      for (const symbol of symbols) hit.selectors.add(symbol)
-      hit.unparseable = broken.unparseable
-    } else {
-      for (const symbol of symbols) {
-        const afterUnits = 'units' in after ? after.units.filter((unit) => unit.name === symbol) : []
-        const authoredAfter = intersects(ranges.after, afterUnits)
-        const authoredBefore = before.length > 0 && before.every((image, parent) =>
-          'units' in image && intersects(ranges.before[parent], image.units.filter((unit) => unit.name === symbol)))
-        if (authoredAfter || authoredBefore) hit.selectors.add(symbol)
+  const results: AnchorHit[][] = []
+  for (const { win, symbols } of queries) {
+    const hits = new Map<string, { selectors: Set<string>; unparseable?: string }>()
+    for (const event of win) {
+      const after = units.get(anchorRevisionKey({ commit: event.commit, path: event.historicalPath }))!
+      const before = event.parents.map(({ commit, historicalPath }) => units.get(anchorRevisionKey({ commit, path: historicalPath }))!)
+      const ranges = ordinaryHunks.get(event.historicalPath)?.get(event.commit)
+        ?? await hunksAt(root, event)
+      if (event.parents.length && ranges.before.length !== before.length)
+        throw new Error(`anchor diff for ${event.commit}:${event.historicalPath} has ${ranges.before.length} parent ranges for ${before.length} parents`)
+      const hit = hits.get(event.commit) ?? { selectors: new Set<string>() }
+      const broken = [after, ...before].find((image) => 'unparseable' in image)
+      if (broken && 'unparseable' in broken) {
+        for (const symbol of symbols) hit.selectors.add(symbol)
+        hit.unparseable = broken.unparseable
+      } else {
+        for (const symbol of symbols) {
+          const afterUnits = 'units' in after ? after.units.filter((unit) => unit.name === symbol) : []
+          const authoredAfter = intersects(ranges.after, afterUnits)
+          const authoredBefore = before.length > 0 && before.every((image, parent) =>
+            'units' in image && intersects(ranges.before[parent], image.units.filter((unit) => unit.name === symbol)))
+          if (authoredAfter || authoredBefore) hit.selectors.add(symbol)
+        }
       }
+      if (hit.selectors.size) hits.set(event.commit, hit)
     }
-    if (hit.selectors.size) hits.set(event.commit, hit)
+    results.push([...hits].map(([commit, hit]) => ({ commit, selectors: [...hit.selectors], ...(hit.unparseable ? { unparseable: hit.unparseable } : {}) })))
   }
-  return [...hits].map(([commit, hit]) => ({ commit, selectors: [...hit.selectors], ...(hit.unparseable ? { unparseable: hit.unparseable } : {}) }))
+  return results
+}
+export async function anchorHitCommits(root: string, win: DriftPathEvent[], symbols: string[], regs: Extractor[]): Promise<AnchorHit[]> {
+  return (await anchorHitQueries(root, [{ win, symbols }], regs))[0]
 }

package/spec-cli/src/cli.ts

@@ -50,7 +50,7 @@ function flushExit(code = 0): Promise<never> {
 }
 const has = (name: string) => process.argv.includes(`--${name}`)
 // bare positionals after argv index `from`, skipping flags and their values (selectors for ls/watch).
-const VALUE_FLAGS = new Set(['--status', '--as', '--interval', '--propose', '--note', '--node', '--prompt', '--prompt-file', '--timeout', '--reason', '--out', '--password', '--tls-cert', '--tls-key', '--harness', '--launcher', '--harness-session', '--port', '--api', '--api-port', '--host', '--preset', '--limit', '--session', '--depth', '--focus', '--keys', '--allow-stop', '--allow-resume', '--ttl-ms', '--wait-ms'])
+const VALUE_FLAGS = new Set(['--status', '--as', '--interval', '--propose', '--note', '--node', '--prompt', '--prompt-file', '--timeout', '--reason', '--out', '--password', '--tls-cert', '--tls-key', '--harness', '--launcher', '--harness-session', '--port', '--api', '--api-port', '--host', '--preset', '--limit', '--session', '--depth', '--focus', '--keys', '--allow-stop', '--allow-resume', '--ttl-ms', '--wait-ms', '--adapter', '--thread', '--tmux', '--worktree', '--branch'])
 function positionals(from: number): string[] {
   const out: string[] = []
   for (let i = from; i < process.argv.length; i++) {
@@ -873,6 +873,23 @@ if (cmd === 'serve') {
       const closed = await c.clientClose(full)
       if (!closed) { console.error(`spex session close: no such session ${full} (record remains; no close was committed)`); process.exit(1) }
       console.log(`closed ${full}`)
+    } else if (sub === 'quarantine') {
+      rejectUnknownFlags('spex session quarantine', 4, ['adapter', 'thread', 'tmux', 'worktree', 'branch', 'restore', 'api', 'port'])
+      if (!id) { console.error('usage: spex session quarantine <ID> --adapter <harness> [--thread <native-id>] --tmux <session-id> --worktree <absent-path> --branch <absent-branch>') ; process.exit(2) }
+      if (has('restore')) {
+        // Quarantine addresses an unreadable row which selector resolution intentionally excludes. Both the
+        // move and its reverse therefore take the literal exact id, with the backend proving record state.
+        const restored = await c.clientRestoreQuarantine(id)
+        console.log(`restored quarantined record ${restored.id} from ${restored.bundle}`)
+      } else {
+        const adapter = flag('adapter'), tmux = flag('tmux'), worktree = flag('worktree'), branch = flag('branch')
+        if (!adapter || !tmux || !worktree || !branch) {
+          console.error('usage: spex session quarantine <ID> --adapter <harness> [--thread <native-id>] --tmux <session-id> --worktree <absent-path> --branch <absent-branch>')
+          process.exit(2)
+        }
+        const quarantined = await c.clientQuarantine(id, { adapter, thread: flag('thread') ?? null, tmux, worktree, branch })
+        console.log(`quarantined ${quarantined.id} -> ${quarantined.bundle}`)
+      }
     } else if (sub === 'send') {
       const full = await resolveSelectorOrExit(id)
       if (has('keys')) {

package/spec-cli/src/client.ts

@@ -276,6 +276,27 @@ export async function clientClose(id: string): Promise<boolean> {
   return !!(await r.json().catch(() => ({ ok: false })))?.ok
 }
 
+export async function clientQuarantine(
+  id: string,
+  witness: { adapter: string; thread: string | null; tmux: string; worktree: string; branch: string },
+): Promise<{ id: string; bundle: string; sha256: string; observedAt: string }> {
+  await guarded('session quarantine')
+  const r = await apiFetch(`/api/sessions/${seg(id)}/quarantine`, post(witness))
+  if (!r.ok) throw new BackendError(`backend refused to quarantine ${id}: ${await r.text()}`, r.status)
+  const body = await r.json() as { ok?: boolean; id?: string; bundle?: string; sha256?: string; observedAt?: string }
+  if (!body.ok || !body.id || !body.bundle || !body.sha256 || !body.observedAt) throw new BackendError(`backend returned an invalid quarantine result for ${id}`, r.status)
+  return { id: body.id, bundle: body.bundle, sha256: body.sha256, observedAt: body.observedAt }
+}
+
+export async function clientRestoreQuarantine(id: string): Promise<{ id: string; bundle: string; sha256: string; observedAt: string }> {
+  await guarded('session quarantine')
+  const r = await apiFetch(`/api/sessions/${seg(id)}/quarantine/restore`, post({}))
+  if (!r.ok) throw new BackendError(`backend refused to restore ${id}: ${await r.text()}`, r.status)
+  const body = await r.json() as { ok?: boolean; id?: string; bundle?: string; sha256?: string; observedAt?: string }
+  if (!body.ok || !body.id || !body.bundle || !body.sha256 || !body.observedAt) throw new BackendError(`backend returned an invalid quarantine restore for ${id}`, r.status)
+  return { id: body.id, bundle: body.bundle, sha256: body.sha256, observedAt: body.observedAt }
+}
+
 // POST /api/sessions/:id/archive — cold-archive the session ([[archive]]). The legacy on=false spelling is a
 // signpost to the same resume transition; it never performs a record-only unarchive.
 export async function clientArchive(id: string, on = true): Promise<boolean> {