@inerrata-corporation/errata 2.0.21 → 2.0.22-dev.4049

package/resources/claude-mods/errata-minimap/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "errata-minimap",
-  "version": "0.1.0",
+  "version": "0.4.1",
   "author": { "name": "inErrata", "url": "https://inerrata.ai" },
-  "description": "Side pane: an errata graph minimap of the latest burst neighborhood that entered the agent's context.",
+  "description": "The errata library: the causal chains of the latest burst that entered the agent's context, in bookcases by technology with a catalog card — and errata's inline tags, tidied in the chat.",
   "types": "./types/index.d.ts"
 }

package/resources/claude-mods/errata-minimap/hooks/bookcase.ts

@@ -0,0 +1,450 @@
+import type { Book, Bookcase, Catalog, Part, Shelf } from './chains'
+import { bookHolding, callNumber, placeOf } from './chains'
+import type { JudgmentKind } from './minimap'
+
+/**
+ * The burst as a library, after the splash's Arched Library (SPL-library):
+ * BOOKCASES by technology, SHELVES by community, and every BOOK one causal
+ * chain standing upright — its spine banded top to bottom in the chain's own
+ * order, cause (gilt) over problem (oxblood) over fix (green). An upright
+ * spine cannot carry a title anyone could read, so the spines are a wordless
+ * glance — how many chains, how complete (a full chain stands tallest and
+ * thickest, a lone problem is a thin pamphlet), where they cluster — and the
+ * CATALOG CARD under the cases reads the book in focus in full.
+ *
+ * Two rooms, one token set, as on the site: the READING ROOM (parchment
+ * bindings, for a light terminal) and THE STACKS (the library after hours,
+ * for a dark one). Colours are lifted from apps/splash/src/network/network.css.
+ */
+export type Room = 'reading' | 'stacks'
+
+export type Binding = 'problem' | 'cause' | 'fix' | 'claim' | 'pattern' | 'code'
+
+export type Palette = {
+  binding: Record<Binding, number>
+  /** Lettering on a wooden plate. */
+  clothInk: number
+  /** A book being burst off flashes gilt. */
+  gilt: number
+  /** The bookmark in the book the card reads: not gilt, which is the cause's own binding at night. */
+  ribbon: number
+  wood: number
+  /** The catalog card: its stock, its ink, and the ink of a part completed from the graph (not in context). */
+  card: number
+  cardInk: number
+  cardFaint: number
+  verdict: Record<JudgmentKind, number>
+}
+
+export const PALETTE: Record<Room, Palette> = {
+  reading: {
+    binding: { problem: 0x7a2e24, cause: 0x8a6a1f, fix: 0x2a4e3c, claim: 0x5c3a50, pattern: 0x3e5a73, code: 0x8a6e52 },
+    clothInk: 0xf7f2e8,
+    gilt: 0xc9a24a,
+    ribbon: 0x2b2620,
+    wood: 0x8a6e52,
+    card: 0xefe6d2,
+    cardInk: 0x2b2620,
+    cardFaint: 0x8c8170,
+    verdict: { cite: 0x3e5a73, confirm: 0x2a4e3c, fix: 0x2a4e3c, refute: 0x7a2e24 },
+  },
+  stacks: {
+    binding: { problem: 0xe08a74, cause: 0xe2c376, fix: 0xa7d0b0, claim: 0xcba3bf, pattern: 0x9dbcd8, code: 0xbba98c },
+    clothInk: 0xf7f2e8,
+    gilt: 0xe2c376,
+    ribbon: 0xf7f2e8,
+    wood: 0x6b543d,
+    card: 0x1f3a2d,
+    cardInk: 0xf7f2e8,
+    cardFaint: 0x93a89a,
+    verdict: { cite: 0x9dbcd8, confirm: 0xa7d0b0, fix: 0xa7d0b0, refute: 0xe08a74 },
+  },
+}
+
+const BINDING_OF: Record<string, Binding> = {
+  Problem: 'problem',
+  Vulnerability: 'problem',
+  AntiPattern: 'problem',
+  RootCause: 'cause',
+  Constraint: 'cause',
+  Solution: 'fix',
+  Technique: 'fix',
+  Claim: 'claim',
+  Pattern: 'pattern',
+}
+
+export function bindingOf(label: string): Binding {
+  return BINDING_OF[label] ?? 'code'
+}
+
+/** What the legend calls each binding. */
+export const BINDING_NAME: Record<Binding, string> = {
+  problem: 'problem',
+  cause: 'cause',
+  fix: 'fix',
+  claim: 'claim',
+  pattern: 'pattern',
+  code: 'code',
+}
+
+/** The mark a part carries on the catalog card, and the status line's tally glyph. */
+export const BINDING_GLYPH: Record<Binding, string> = {
+  problem: '◆',
+  cause: '▲',
+  fix: '●',
+  claim: '◇',
+  pattern: '✦',
+  code: '§',
+}
+
+export type LibraryFrame = { grow: number; type: number }
+
+export type LibraryOptions = {
+  room?: Room
+  /** How far the reveal has run: books rise onto their shelves (`grow`), then the card inks in (`type`). */
+  frame?: LibraryFrame
+  /** The node whose book the card reads (a verdict's, the seed's); default: the seed's book, else the strongest. */
+  focus?: string
+  /** A node the agent is bursting off: its book flashes gilt. */
+  highlight?: string
+  isPulseOn?: boolean
+  /** Priors the agent just judged: their stamp flashes. */
+  marks?: Record<string, JudgmentKind>
+  isMarkOn?: boolean
+  /** Every recent verdict, stamped on the plank under its book like a date-due card. */
+  stamps?: Record<string, JudgmentKind>
+}
+
+/** Who gets the card's lines first when the chain will not fit: the problem, then its fix, then its cause. */
+const PRIORITY = { problem: 0, fix: 1, cause: 2 } as const
+const STAMP: Record<JudgmentKind, string> = { cite: '◎', confirm: '✓', fix: '✓', refute: '✗' }
+const VERB: Record<JudgmentKind, string> = { cite: 'cited', confirm: 'confirmed', fix: 'resolved', refute: 'refuted' }
+const DEFAULT = 0x01000000
+const SPACE = 0x20
+
+/** Book rows above each plank: a full chain stands 3.5 rows; the half-row above it holds the bookmark. */
+const TALL_SHELF = 4
+const SHORT_SHELF = 3
+/** Cells a shelf keeps after its books for its plate. */
+const PLATE = 17
+/** Rows the catalog card never gives up: header, two lines of chain, footer. */
+const MIN_CARD = 4
+const MAX_CARD = 8
+
+/** The focus book: an asked node's, else the seed's, else the strongest. */
+export function focusBook(catalog: Catalog, focus?: string): Book | undefined {
+  return bookHolding(catalog, focus) ?? catalog.books.find(b => b.isSeed) ?? catalog.books[0]
+}
+
+/** Thin (one part) or thick (a chain of two or three). */
+const widthOf = (b: Book) => (partsOf(b).length > 1 ? 2 : 1)
+
+function partsOf(b: Book): [('cause' | 'problem' | 'fix'), Part][] {
+  return (['cause', 'problem', 'fix'] as const).flatMap(r => (b[r] ? [[r, b[r]] as [typeof r, Part]] : []))
+}
+
+type Placed = { bookcase: Bookcase; x: number; y: number; width: number; shelves: { shelf: Shelf; books: Book[]; hidden: number }[]; hidden: number }
+
+/**
+ * Cases packed left to right, wrapping into another tier when the pane is
+ * narrow; each case as wide as its fullest shelf (books overflow into a `+n`
+ * on the plank), as tall as the rows allow (lower shelves give way first).
+ */
+function placeCases(catalog: Catalog, columns: number, rows: number, zone: number): Placed[] {
+  const placed: Placed[] = []
+  let x = 0
+  let y = 0
+  let tierHeight = 0
+  for (const bookcase of catalog.cases) {
+    const fullest = Math.max(...bookcase.shelves.map(s => s.books.reduce((w, b) => w + widthOf(b), 0)))
+    // Room after the fullest shelf for its plate (" 1 loose volumes "), and on the cornice for the tech.
+    const width = Math.min(columns, Math.max(bookcase.tech.length + 6, fullest + 4 + PLATE))
+    if (x > 0 && x + width > columns) {
+      x = 0
+      y += tierHeight
+      tierHeight = 0
+    }
+    const room = Math.floor((rows - y - 1) / (zone + 1))
+    if (room < 1) break
+    const kept = bookcase.shelves.slice(0, room)
+    const shelves = kept.map(shelf => {
+      const books: Book[] = []
+      let used = 0
+      for (const b of shelf.books) {
+        if (used + widthOf(b) > width - 4) break
+        books.push(b)
+        used += widthOf(b)
+      }
+      return { shelf, books, hidden: shelf.books.length - books.length }
+    })
+    const hidden = bookcase.shelves.slice(room).reduce((n, s) => n + s.books.length, 0)
+    placed.push({ bookcase, x, y, width, shelves, hidden })
+    tierHeight = Math.max(tierHeight, 1 + shelves.length * (zone + 1))
+    x += width + 1
+  }
+  return placed
+}
+
+/** The library's geometry: the card it keeps, the shelf height, where every case stands. */
+function layoutLibrary(catalog: Catalog, columns: number, rows: number, focusId?: string) {
+  const focus = focusBook(catalog, focusId)
+  // The card asks for its chain in full (header, every wrapped line, footer); the cases get the rest, at least a third.
+  const need = focus ? 2 + partsOf(focus).reduce((n, [, part]) => n + wrap(part.name, columns - 5).length, 0) : 0
+  const card = Math.max(MIN_CARD, Math.min(need, Math.max(MAX_CARD, Math.round(rows * 0.6)), rows - Math.ceil(rows / 3)))
+  const zone = rows - card >= 1 + TALL_SHELF + 1 ? TALL_SHELF : SHORT_SHELF
+  return { focus, need, card, zone, placed: placeCases(catalog, columns, rows - card, zone) }
+}
+
+/** Where a drawn book stands, in cells from the library's top-left: its spine's whole zone above the plank. */
+export type BookSpot = { book: Book; x: number; top: number; width: number; height: number }
+
+/**
+ * Every drawn book's spot, from the same layout `rasterizeLibrary` draws: the
+ * hover and click targets laid over the spines, so they can never disagree
+ * with the picture about where a book is.
+ */
+export function librarySpots(catalog: Catalog, columns: number, rows: number, focusId?: string): BookSpot[] {
+  const { zone, placed } = layoutLibrary(catalog, columns, rows, focusId)
+  const spots: BookSpot[] = []
+  for (const c of placed) {
+    c.shelves.forEach(({ books }, si) => {
+      const plank = c.y + 1 + si * (zone + 1) + zone
+      let x = c.x + 2
+      for (const book of books) {
+        spots.push({ book, x, top: plank - zone, width: widthOf(book), height: zone })
+        x += widthOf(book)
+      }
+    })
+  }
+  return spots
+}
+
+/** Every book drawn, in reading order: the order the reveal raises them. */
+function drawnBooks(placed: Placed[]): Book[] {
+  return placed.flatMap(p => p.shelves.flatMap(s => s.books))
+}
+
+/** Rows the cases take. */
+function casesHeight(placed: Placed[], zone: number): number {
+  return placed.reduce((h, p) => Math.max(h, p.y + 1 + p.shelves.length * (zone + 1)), 0)
+}
+
+function shade(color: number, by: number): number {
+  const ch = (s: number) => Math.round(((color >> s) & 0xff) * (1 - by))
+  return (ch(16) << 16) | (ch(8) << 8) | ch(0)
+}
+
+/**
+ * The library as Raster cells (`[codePoint, fg, bg]` u32 triplets, row-major,
+ * base64). Every frame of the reveal draws a prefix of the finished picture,
+ * so nothing jumps as it fills: cases first, then each book rises onto its
+ * shelf in reading order, then the card inks in.
+ */
+export function rasterizeLibrary(catalog: Catalog, columns: number, rows: number, options: LibraryOptions = {}): string {
+  const { room = 'stacks', frame = { grow: 1, type: 1 }, highlight, isPulseOn = true, marks = {}, isMarkOn = true, stamps = {} } = options
+  const p = PALETTE[room]
+  const words = new Uint32Array(columns * rows * 3)
+  for (let i = 0; i < columns * rows; i++) words.set([SPACE, DEFAULT, DEFAULT], i * 3)
+  const put = (x: number, y: number, ch: string | number, fg: number, bg = DEFAULT) => {
+    if (x >= 0 && y >= 0 && x < columns && y < rows) words.set([typeof ch === 'number' ? ch : ch.codePointAt(0)!, fg, bg], (y * columns + x) * 3)
+  }
+  const write = (x: number, y: number, text: string, fg: number, bg = DEFAULT) => {
+    let k = 0
+    for (const ch of text) put(x + k++, y, ch, fg, bg)
+    return x + k
+  }
+
+  const { focus, need, card, zone, placed } = layoutLibrary(catalog, columns, rows, options.focus)
+  const order = drawnBooks(placed)
+  const pulled = bookHolding(catalog, highlight)
+  const scores = catalog.books.map(b => b.score).sort((a, b) => a - b)
+  const medianScore = scores[Math.floor(scores.length / 2)] ?? 0
+  const verdictOf = (b: Book) => {
+    for (const id of b.memberIds) if (marks[id]) return { kind: marks[id]!, isFresh: true }
+    for (const id of b.memberIds) if (stamps[id]) return { kind: stamps[id]!, isFresh: false }
+    return undefined
+  }
+
+  for (const c of placed) {
+    // The cornice, its plate naming the technology.
+    for (let x = c.x; x < c.x + c.width; x++) put(x, c.y, '▄', p.wood)
+    const plate = ` ${fit(c.bookcase.tech, c.width - 4)} `
+    write(c.x + 1, c.y, plate, p.clothInk, p.wood)
+    if (c.hidden > 0) write(c.x + c.width - String(c.hidden).length - 3, c.y, ` +${c.hidden}`, p.clothInk, p.wood)
+    c.shelves.forEach(({ shelf, books, hidden }, si) => {
+      const plank = c.y + 1 + si * (zone + 1) + zone
+      for (let y = plank - zone; y < plank; y++) {
+        put(c.x, y, '▕', p.wood)
+        put(c.x + c.width - 1, y, '▏', p.wood)
+      }
+      for (let x = c.x; x < c.x + c.width; x++) put(x, plank, '▀', p.wood)
+      let x = c.x + 2
+      for (const book of books) {
+        const shown = Math.max(0, Math.min(1, frame.grow * order.length - order.indexOf(book)))
+        drawBook(book, x, plank, shown)
+        const verdict = verdictOf(book)
+        if (verdict && shown >= 1) {
+          const color = p.verdict[verdict.kind]
+          const isFlashing = verdict.isFresh && isMarkOn
+          put(x, plank, STAMP[verdict.kind], isFlashing ? p.clothInk : color, isFlashing ? color : DEFAULT)
+        }
+        x += widthOf(book)
+      }
+      // The shelf's plate, after its books: its number and the name its community earns (chains.ts shelfName).
+      const tail = hidden > 0 ? ` +${hidden}` : ''
+      const room = c.x + c.width - 1 - (x + 1)
+      const label = ` ${shelf.number} ${fit(shelf.name, room - 4 - tail.length)}${tail} `
+      if (room >= 6) write(x + 1, plank, label.slice(0, room), p.clothInk, p.wood)
+    })
+  }
+
+  function drawBook(book: Book, x: number, plank: number, shown: number): void {
+    const parts = partsOf(book)
+    const full = 2 * zone - 1
+    // Height in half-rows: a full chain stands tallest, each missing part a half-row shorter; the weaker half of the shelf a half-row lower still.
+    const height = Math.max(3, full - (3 - parts.length) - (book.score < medianScore ? 1 : 0))
+    const risen = Math.round(height * shown)
+    const side = Math.max(1, Math.round(height / 4))
+    // Bands bottom → top: fix, problem, cause; the problem takes what the ends leave.
+    const bands: number[] = []
+    for (const [role, part] of [...parts].reverse()) {
+      const span = parts.length === 1 ? height : role === 'problem' ? height - side * (parts.length - 1) : side
+      const color = book === pulled && isPulseOn ? p.gilt : p.binding[bindingOf(part.label)]
+      for (let k = 0; k < span; k++) bands.push(color)
+    }
+    const width = widthOf(book)
+    for (let col = 0; col < width; col++) {
+      const colorAt = (h: number): number | undefined => {
+        if (h < risen) return col === 0 ? bands[h] : shade(bands[h]!, 0.38)
+        if (h === risen && book === focus && col === 0 && shown >= 1) return p.ribbon
+        return undefined
+      }
+      for (let r = 0; r < zone; r++) {
+        const lower = colorAt(2 * r)
+        const upper = colorAt(2 * r + 1)
+        const y = plank - 1 - r
+        if (width === 1) {
+          // A pamphlet: the left half of the cell, so neighbours never merge into one block.
+          if (lower !== undefined && upper !== undefined) put(x, y, upper === lower ? '▌' : '▀', upper, upper === lower ? DEFAULT : lower)
+          else if (lower !== undefined) put(x, y, '▖', lower)
+          else if (upper !== undefined) put(x, y, '▘', upper)
+        } else if (lower !== undefined && upper !== undefined) put(x + col, y, '▀', upper, lower)
+        else if (lower !== undefined) put(x + col, y, '▄', lower)
+        else if (upper !== undefined) put(x + col, y, '▀', upper)
+      }
+    }
+  }
+  if (focus) drawCard(focus, casesHeight(placed, zone))
+
+  function drawCard(book: Book, top: number): void {
+    const height = Math.min(rows - top, Math.max(card, need))
+    if (height < 3) return
+    for (let y = top; y < top + height; y++) for (let x = 0; x < columns; x++) put(x, y, SPACE, p.cardInk, p.card)
+    const inked = (text: string) => [...text].slice(0, Math.ceil([...text].length * frame.type)).join('')
+    const place = placeOf(catalog, book)
+    // Header: the call number in the catalog card's red, the case, the shelf.
+    const call = callNumber(catalog, book)
+    let x = write(1, top, inked(call), p.binding.problem, p.card)
+    x = write(x, top, inked(`  ${place?.bookcase.tech ?? ''}`), p.cardInk, p.card)
+    const shelfText = place ? `shelf ${place.shelf.number} · ${place.shelf.name}` : ''
+    const room = columns - x - 3
+    if (room >= 10) {
+      const s = fit(shelfText, room)
+      write(columns - 1 - s.length, top, inked(s), p.cardFaint, p.card)
+    }
+    // Body: the chain in its order, each part wrapped; the problem gets spare lines first.
+    const parts = partsOf(book)
+    const body = height - 2
+    const textWidth = columns - 5
+    const wrapped = parts.map(([, part]) => wrap(part.name, textWidth))
+    const lines = parts.map(() => 0)
+    const byNeed = [...parts.keys()].sort((a, b) => PRIORITY[parts[a]![0]] - PRIORITY[parts[b]![0]])
+    let spare = body
+    while (spare > 0 && byNeed.some(i => lines[i]! < wrapped[i]!.length)) {
+      for (const i of byNeed) {
+        if (spare > 0 && lines[i]! < wrapped[i]!.length) {
+          lines[i]!++
+          spare--
+        }
+      }
+    }
+    let y = top + 1
+    parts.forEach(([, part], i) => {
+      const color = p.binding[bindingOf(part.label)]
+      const ink = part.isDelivered ? p.cardInk : p.cardFaint
+      const text = wrapped[i]!.slice(0, lines[i])
+      if (lines[i]! < wrapped[i]!.length && text.length > 0) text[text.length - 1] = clip(text[text.length - 1]!, textWidth)
+      text.forEach((line, k) => {
+        if (k === 0) put(2, y, BINDING_GLYPH[bindingOf(part.label)], color, p.card)
+        write(4, y, inked(line), ink, p.card)
+        y++
+      })
+    })
+    // Footer: where the chain is anchored, what else it holds, and the agent's verdict.
+    const footY = top + height - 1
+    const verdict = verdictOf(book)
+    const stamp = verdict ? ` ${STAMP[verdict.kind]} ${VERB[verdict.kind]} ` : ''
+    const more = [book.moreCauses > 0 ? `+${book.moreCauses} cause${book.moreCauses > 1 ? 's' : ''}` : '', book.moreFixes > 0 ? `+${book.moreFixes} fix${book.moreFixes > 1 ? 'es' : ''}` : '']
+      .filter(Boolean)
+      .join(' ')
+    const facts = [book.anchor ? `@ ${book.anchor}` : '', more, book.isCatalogued ? '' : 'cataloguing…'].filter(Boolean).join(' · ')
+    write(2, footY, inked(fit(facts, columns - 4 - stamp.length)), p.cardFaint, p.card)
+    if (verdict) {
+      const color = p.verdict[verdict.kind]
+      const isFlashing = verdict.isFresh && isMarkOn
+      write(columns - 1 - stamp.length, footY, stamp, isFlashing ? p.card : color, isFlashing ? color : p.card)
+    }
+  }
+
+  return new Uint8Array(words.buffer).toBase64()
+}
+
+/** One run of width-1 printable characters (a wide one would shift every cell after it). */
+function flat(text: string): string {
+  return text
+    .replace(/[–—]/g, '-')
+    .replace(/×/g, 'x')
+    .replace(/→/g, '->')
+    .replace(/…/g, '...')
+    .replace(/[‘’]/g, "'")
+    .replace(/[“”]/g, '"')
+    .replace(/[^\x20-\x7e\s·]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function clip(text: string, max: number): string {
+  if (max <= 1) return ''
+  return text.length < max ? `${text}~` : `${text.slice(0, max - 1)}~`
+}
+
+/** A title that fits `max` cells, the tail clipped with `~`. */
+export function fitTitle(name: string, max: number): string {
+  const f = flat(name)
+  if (max <= 1) return ''
+  return f.length <= max ? f : `${f.slice(0, max - 1)}~`
+}
+const fit = fitTitle
+
+/** Word-wrapped lines of at most `width` cells; a word longer than a line is broken. */
+export function wrap(text: string, width: number): string[] {
+  const lines: string[] = []
+  let line = ''
+  for (let word of flat(text).split(' ')) {
+    while (word.length > width) {
+      if (line) lines.push(line)
+      lines.push(word.slice(0, width))
+      word = word.slice(width)
+      line = ''
+    }
+    if (!word) continue
+    if (!line) line = word
+    else if (line.length + 1 + word.length <= width) line += ` ${word}`
+    else {
+      lines.push(line)
+      line = word
+    }
+  }
+  if (line) lines.push(line)
+  return lines
+}