spexcode 0.6.2 → 0.6.6

package/spec-dashboard/src/session.js

@@ -1,199 +0,0 @@
-// status→colour values are theme tokens (styles.css :root) so the palette stays single-sourced; var() resolves in inline styles.
-export const STATUS_COLOR = {
-  working: 'var(--green)', parked: 'var(--green)',
-  asking: 'var(--yellow)', review: 'var(--yellow)', done: 'var(--yellow)',
-  error: 'var(--red)',
-  idle: 'var(--muted)', starting: 'var(--muted)', queued: 'var(--muted)',
-  'close-pending': 'var(--muted)', offline: 'var(--muted)',
-  unknown: 'var(--yellow)',   // liveness probe FAILED (box overloaded) — death unproven, so warn, never read as dead
-  corrupt: 'var(--red)',      // the RECORD itself is unreadable — a broken thing to look at, not a dead agent
-  retired: 'var(--muted)',    // the work merged and its worktree is gone: terminal, only `close` remains
-}
-
-// compact one-line surfaces (the console's terminal-styled sidebar) render the status as a SINGLE glyph
-// instead of the word — STATUS_COLOR still paints it, and the exact word stays in the title/aria for hover +
-// a11y. One terminal-ish mark per lifecycle; same four-hue traffic-light meaning as the word it replaces.
-export const STATUS_GLYPH = {
-  working: '●', parked: '‖',
-  asking: '?', review: '◑', done: '✓',
-  error: '✕',
-  idle: '·', starting: '◌', queued: '⋯', 'close-pending': '⊘', offline: '○', unknown: '⁇',
-  corrupt: '⚠', retired: '⚑',
-}
-
-// the three triage zones the session list groups into — "whose turn is it?". `offline` = the process is
-// DEAD/dormant (can't act until relaunched) — checked FIRST, because a session whose process died while
-// asking/review/error keeps that pre-death lifecycle, yet it belongs at the bottom, not under Needs You.
-// `need` = the ball is with the HUMAN (asking / review / done / close-pending / error → answer, review,
-// close, fix); `run` = self-driving, the agent's turn (working / parked / starting / queued / idle — booting
-// counts as running, not dead). Closed sessions aren't on the board at all. Same partition drives every
-// session-list surface.
-// `corrupt` joins them: an unreadable record cannot resolve itself and no agent can act on it, so it is
-// squarely the human's — and it carries liveness `unknown` (never probed), so the offline check above does not
-// claim it first. `retired` is deliberately NOT here: its agent really is down, so it sorts with the offline
-// rows and its badge, not its zone, is what says the worktree is gone.
-const NEED_STATUS = new Set(['asking', 'review', 'done', 'close-pending', 'error', 'corrupt'])
-export const sessionZone = (s) => {
-  if (s?.liveness === 'offline' || s?.status === 'offline') return 'offline'
-  return NEED_STATUS.has(s?.status) ? 'need' : 'run'
-}
-export const ZONE_ORDER = ['need', 'run', 'offline']
-
-export const isArchived = (s) => !!s?.archived
-export const splitArchived = (sessions = []) => ({
-  live: sessions.filter((s) => !isArchived(s)),
-  archived: sessions.filter(isArchived),
-})
-// the ONE liveness join: resolve an id against the board sessions and return the
-// session only while it is ALIVE (listed and not offline) — the same alive/offline judgment the originator
-// chip renders (Thread.jsx). A non-session id ('human', a github
-// login) resolves to null, honestly.
-export const liveSession = (sessions, id) => {
-  const s = id ? (sessions || []).find((x) => x.id === id) : null
-  return s && sessionZone(s) !== 'offline' ? s : null
-}
-// the ONE source-session PRESENCE join ([[live-session-filter]] — the session:present|missing facet):
-// does the id still resolve to a session on the current board at ALL, any zone? Presence, not liveness —
-// the facet asks "is the source still around", never "is it online".
-export const sessionPresent = (sessions, id) => {
-  const s = id ? (sessions || []).find((x) => x.id === id) : null
-  return s || null
-}
-// order the working list by its active lifecycle zones; the archive shelf is a separate flat cold collection.
-// each zone the NEWEST session on top (descending effective time) — the fresh, recently-touched work you
-// actually reach for, not the oldest.
-const effOf = (s) => (s?.sortKey != null ? s.sortKey : (s?.created ?? 0))
-export const zoneSort = (sessions) => {
-  const rank = { need: 0, run: 1, offline: 2 }
-  return [...sessions].sort((a, b) => rank[sessionZone(a)] - rank[sessionZone(b)] || effOf(b) - effOf(a))
-}
-
-// the session's display strings are DERIVED SERVER-SIDE ([[session-label]]): the wire carries `label`
-// (stable handle) and `headline` (the live line a human reads), computed once in toSession; the bare parts
-// (rename `name`, prompt-truncation `title`) don't ride the wire at the top level, so a surface CANNOT
-// re-derive its own chain — these two accessors are the only doors, and the legacy chain below each exists
-// solely as the old-backend fallback, confined to THIS file. Reach for s.raw.name / s.raw.title only for an
-// explicitly raw consumer (the rename prefill).
-//
-// `sessionHandle` is the STABLE handle — its ONLY sanctioned uses are the avatar/hover TOOLTIP, mobile's
-// handle-line, and search MATCHING. On a current backend the wire always carries `label`, so this door
-// short-circuits there: what search matches IS the label (a rename name or the prompt truncation);
-// raw id/node/branch fragments are deliberately NOT promised searchable.
-// It is NEVER a visible one-line title: EVERY surface where a human reads "which session is this" (board
-// rows, the map window, Enter tabs, the console strip, the search palette, the @-mention dropdown, and the
-// node-menu overlay list) renders `sessionHeadline`. Naming the stable door `Handle`, not `Name`, is the
-// architectural guard: a dev wanting "the name to show" reaches for the headline by reflex and can no longer
-// grab the handle by mistake — the divergence that kept recurring ([[session-activity]]: one name everywhere).
-export const sessionHandle = (s) =>
-  s?.label || s?.name || s?.node || s?.title || s?.branch || s?.id
-
-export const sessionHeadline = (s) =>
-  s?.title || s?.headline || s?.name || s?.activity || s?.note || s?.promptPreview || s?.node || s?.raw?.title || s?.branch || s?.id
-
-// The visible session name is a single derived `title` on current backends. Keep the old
-// accessor as a compatibility alias while mixed-version clients roll forward.
-export const sessionTitle = sessionHeadline
-
-export function nestSessions(sessions) {
-  const present = new Set(sessions.map((s) => s?.id))
-  const childrenOf = new Map()
-  const roots = []
-  for (const s of sessions) {
-    const p = s?.parent && s.parent !== s.id && present.has(s.parent) ? s.parent : null
-    if (p) { const arr = childrenOf.get(p) || []; arr.push(s); childrenOf.set(p, arr) }
-    else roots.push(s)
-  }
-  return { roots, childrenOf }
-}
-
-// Present ancestors of one session, nearest first. This mirrors nestSessions' rule that a missing parent
-// makes its child a root, and bounds malformed cycles so an external jump can safely reveal the row.
-export function sessionAncestorIds(sessions, id) {
-  const byId = new Map(sessions.map((s) => [s?.id, s]))
-  const ids = []
-  const seen = new Set([id])
-  let cur = byId.get(id)
-  while (cur?.parent && !seen.has(cur.parent)) {
-    const parent = byId.get(cur.parent)
-    if (!parent) break
-    ids.push(parent.id)
-    seen.add(parent.id)
-    cur = parent
-  }
-  return ids
-}
-
-export function subtreeRollup(id, childrenOf) {
-  let need = false, run = false, count = 0
-  const walk = (pid, seen) => {
-    for (const c of childrenOf.get(pid) || []) {
-      if (seen.has(c.id)) continue
-      seen.add(c.id)
-      count++
-      if (NEED_STATUS.has(c.status)) need = true
-      else if (STATUS_COLOR[c.status] === STATUS_COLOR.working) run = true
-      walk(c.id, seen)
-    }
-  }
-  walk(id, new Set([id]))
-  return { color: need ? STATUS_COLOR.asking : run ? STATUS_COLOR.working : STATUS_COLOR.idle, count }
-}
-
-export function sessionForest(sessions, isExpanded, { zoneFolded = () => false, keepVisible = () => false } = {}) {
-  const { roots, childrenOf } = nestSessions(sessions)
-  const items = []
-  const emit = (s, depth, seen, guides) => {
-    const kids = childrenOf.get(s.id) || []
-    const expandable = kids.length > 0
-    const expanded = expandable && !!isExpanded(s.id)
-    const roll = expandable ? subtreeRollup(s.id, childrenOf) : null
-    items.push({ type: 'row', s, depth, expandable, expanded, rollup: roll?.color ?? null, kin: roll?.count ?? 0, guides })
-    if (expanded) {
-      const vis = zoneSort(kids).filter((c) => !seen.has(c.id))
-      vis.forEach((c, i) => { seen.add(c.id); emit(c, depth + 1, seen, [...guides, i < vis.length - 1]) })
-    }
-  }
-  // a folded subtree still counts everything it hides (the root and every descendant), so the disclosure's
-  // number is the whole history, not just its top-level rows.
-  const subtreeSize = (s, seen) => {
-    let n = 1
-    for (const c of childrenOf.get(s.id) || []) { if (seen.has(c.id)) continue; seen.add(c.id); n += subtreeSize(c, seen) }
-    return n
-  }
-  const seen = new Set()
-  let prevZone = null
-  let zoneItem = null
-  for (const r of zoneSort(roots)) {
-    if (seen.has(r.id)) continue
-    const z = sessionZone(r)
-    if (z !== prevZone) {
-      zoneItem = { type: 'zone', zone: z, count: 0, folded: !!zoneFolded(z) }
-      items.push(zoneItem)
-      prevZone = z
-    }
-    // the zone's count is its WHOLE population (every root and descendant), folded or not — the
-    // disclosure chip must not read 0 the moment the zone is open.
-    zoneItem.count += subtreeSize(r, new Set([...seen, r.id]))
-    if (zoneItem.folded) {
-      // still emit any row (at any depth) the surface pinned visible — flat, since its nesting context
-      // is folded away with the rest.
-      const pinned = []
-      const collect = (s, walked) => {
-        if (keepVisible(s) && !seen.has(s.id)) pinned.push(s)
-        for (const c of childrenOf.get(s.id) || []) { if (walked.has(c.id)) continue; walked.add(c.id); collect(c, walked) }
-      }
-      collect(r, new Set([r.id]))
-      for (const s of pinned) { seen.add(s.id); items.push({ type: 'row', s, depth: 0, expandable: false, expanded: false, rollup: null, kin: 0, guides: [] }) }
-      seen.add(r.id)
-      continue
-    }
-    seen.add(r.id)
-    emit(r, 0, seen, [])
-  }
-  return items
-}
-
-// The natural working-list order behind session lists: zones, newest-first roots, and recursive parent-before-
-// child disclosure as sessionForest. The archive shelf deliberately bypasses this and remains flat.
-export const sessionPresentationOrder = (sessions) =>
-  sessionForest(sessions, () => true).filter((item) => item.type === 'row').map((item) => item.s)

package/spec-eval/src/cache.ts

@@ -1,57 +0,0 @@
-import { createHash } from 'node:crypto'
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { gitCommonDir } from '../../spec-cli/src/layout.js'
-
-export const MISS_BLOB = 'miss original file'
-
-export function cacheDir(): string {
-  return join(gitCommonDir(), 'spexcode', 'evidence')
-}
-
-const BLOB_NAME = /^[0-9a-f]{64}$/
-
-export function putBlob(bytes: Buffer, dir = cacheDir()): string {
-  const sha = createHash('sha256').update(bytes).digest('hex')
-  mkdirSync(dir, { recursive: true })
-  const p = join(dir, sha)
-  if (!existsSync(p)) writeFileSync(p, bytes)
-  return sha
-}
-
-export function blobPath(sha: string, dir = cacheDir()): string {
-  return join(dir, sha)
-}
-
-export function hasBlob(sha: string | null, dir = cacheDir()): boolean {
-  return !!sha && existsSync(blobPath(sha, dir))
-}
-
-export function resolveBlob(sha: string | null, dir = cacheDir()): string {
-  if (!sha) return ''
-  return hasBlob(sha, dir) ? blobPath(sha, dir) : MISS_BLOB
-}
-
-export function listBlobs(dir = cacheDir()): string[] {
-  if (!existsSync(dir)) return []
-  return readdirSync(dir).filter((n) => BLOB_NAME.test(n)).sort()
-}
-
-export function gc(keep: Set<string>, dir = cacheDir()): string[] {
-  const removed: string[] = []
-  for (const name of listBlobs(dir)) {
-    if (keep.has(name)) continue
-    rmSync(blobPath(name, dir))
-    removed.push(name)
-  }
-  return removed
-}
-
-export function getBlob(sha: string | null, dir = cacheDir()): Buffer | null {
-  return hasBlob(sha, dir) ? readFileSync(blobPath(sha!, dir)) : null
-}
-
-export function isStrayBlob(path: string): boolean {
-  const base = path.slice(path.lastIndexOf('/') + 1)
-  return BLOB_NAME.test(base) || path.includes('spexcode/evidence/') || path.includes('/yatsu-blobs/') // dead-words-ok: archived cache dir name — a stray copy of the retired cache is still rejected
-}