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

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

@@ -0,0 +1,129 @@
+/**
+ * The capture protocol's inline tags, tidied for the person reading the chat.
+ *
+ * Display only: the `AssistantMessage` render hook rewrites what the row
+ * draws, never the stored reply, so the daemon still harvests every tag from
+ * the transcript. Deterministic — the same text and mode draw the same row.
+ *
+ *   margin (default) — references become marginal marks (◎ cited, ✓ held,
+ *                      ✗ refuted, ⇢ linked); a flag reads as a sentence
+ *                      (⚑ …); asides (constraint, tried, failed, cause) go
+ *                      italic; graph metadata (domain, package, …) is shelved
+ *                      out of sight; an errata-* answer block folds to a line.
+ *   quiet            — every tag gone; a flag keeps its words, unmarked,
+ *                      because it is often the only place a problem is said.
+ *   raw              — drawn as written.
+ *
+ * Tags inside code (fences, inline spans) are prose ABOUT the protocol and
+ * are never touched; neither is a GitHub admonition (`> [!NOTE]`).
+ */
+
+export type TagMode = 'margin' | 'quiet' | 'raw'
+export const TAG_MODES: readonly TagMode[] = ['margin', 'quiet', 'raw']
+
+/** Every verb the grammar teaches (agent-signals.ts TAG_EXAMPLE); src/claude-mods-tags.test.ts holds them in step. */
+const VERBS = 'fix|confirm|refute|cause|aids|instance|pattern|builds-on|supersedes|alternative|constraint|tried|failed|domain|package|component'
+
+const HANDLE = String.raw`\[[^\]\s]{1,120}\]`
+const HANDLES = String.raw`${HANDLE}(?:\s*,\s*${HANDLE})*`
+const THREAD = String.raw`(?:#[a-z][\w-]{0,63})?`
+/** A tag body: text with at most one level of nested parentheses, one line. */
+const BODY = String.raw`(?:[^()\n]|\([^()\n]*\))`
+
+/** `([h])`, `([a], [b])` — leaning on a shown prior. */
+const CITE = new RegExp(String.raw`\(\s*${HANDLES}\s*\)`, 'g')
+/** Verdicts and links that name priors and say nothing else. */
+const REF_VERB = new RegExp(
+  String.raw`\(\s*(fix|confirm|cause|aids|instance|pattern|builds-on|supersedes|alternative)\s*:\s*${THREAD}\s*${HANDLES}\s*\)`,
+  'gi',
+)
+/** `(refute:[h] why)`, `(cause:[h] mechanism)` — a judgment on a prior, with its reason. */
+const REASONED = new RegExp(String.raw`\(\s*(refute|cause)\s*:\s*${HANDLES}\s*(${BODY}+?)\s*\)`, 'gi')
+/** Free-text asides the reader may want: why a choice, what was tried, why it broke. */
+const ASIDE = new RegExp(String.raw`\(\s*(constraint|tried|failed|cause|fix)\s*:\s*${THREAD}\s*(${BODY}{2,}?)\s*\)`, 'gi')
+/** Classification for the graph, not the reader. */
+const LABEL = /\(\s*(?:domain|package|component|pattern)\s*:\s*[^()\n]{2,}?\s*\)/gi
+/** `[!one line @ path:42]`, `[?vuln: …]`, `[!#slug …]` — a problem the agent states. */
+const FLAG = /\[([!?])(?:#[a-z][\w-]{0,63}\s+)?\s*((?:\[[^[\]\n]*\]|[^\]\n])+?)\s*(?:@\s*([^\s\]]+?)(?::(\d+))?\s*)?\]/g
+const ADMONITION = /^(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION)$/
+
+const ERRATA_FENCE = /^```errata-([a-z-]+)[^\n]*\n([\s\S]*?)^```[ \t]*$\n?/gm
+
+const MARK = { cite: '◎', held: '✓', refute: '✗', link: '⇢', flag: '⚑', suspect: '⚐' } as const
+
+/** Where a tag was taken out: the seam `mend` closes, so spacing the agent wrote stays as written. */
+const GONE = '\u0001'
+
+/** Code (fences and inline spans) as opaque slots: tags inside are protocol prose, not tags. */
+function shelveCode(text: string): { text: string; code: string[] } {
+  const code: string[] = []
+  const slot = (m: string) => `\u0000${code.push(m) - 1}\u0000`
+  const fenced = text.replace(/^(```|~~~)(?!errata-)[^\n]*\n[\s\S]*?^\1[ \t]*$/gm, slot)
+  return { text: fenced.replace(/`[^`\n]+`/g, slot), code }
+}
+
+function unshelveCode(text: string, code: string[]): string {
+  return text.replace(/\u0000(\d+)\u0000/g, (_, i: string) => code[Number(i)]!)
+}
+
+function refMark(verb: string): string {
+  const v = verb.toLowerCase()
+  if (v === 'confirm' || v === 'fix') return MARK.held
+  return v === 'cause' ? MARK.cite : MARK.link
+}
+
+/** One errata-* answer block → a single quiet line, or nothing. */
+function answerBlock(kind: string, body: string, mode: TagMode): string {
+  if (mode === 'quiet') return GONE
+  if (kind === 'intent') {
+    const intent = /^\s*intent:\s*(.+)$/m.exec(body)?.[1]?.trim()
+    return intent ? `*✎ ${intent}*\n` : GONE
+  }
+  return `*✎ errata ${kind} noted*\n`
+}
+
+/** Closes the seams removals left — a line or bullet with nothing left, a space before punctuation — and only those. */
+function mend(text: string): string {
+  return text
+    .split('\n')
+    .filter(line => !/^[ \t]*(?:(?:[-*+]|\d+\.)[ \t]*)?(?:\u0001[ \t]*)+$/.test(line))
+    .join('\n')
+    .replace(/[ \t]*(?:\u0001[ \t]*)+(?=[.,;:!?)]|$)/gm, '')
+    .replace(/^([ \t]*(?:[-*+>] |\d+\. )?)(?:\u0001[ \t]*)+/gm, '$1')
+    .replace(/[ \t]*(?:\u0001[ \t]*)+/g, ' ')
+}
+
+export function tidyTags(input: string, mode: TagMode = 'margin'): string {
+  if (mode === 'raw' || !input) return input
+  const shelved = shelveCode(input)
+  const isQuiet = mode === 'quiet'
+  let text = shelved.text
+
+  text = text.replace(ERRATA_FENCE, (_, kind: string, body: string) => answerBlock(kind, body, mode))
+  text = text.replace(REASONED, (_, verb: string, why: string) => {
+    if (isQuiet) return GONE
+    return `${verb.toLowerCase() === 'refute' ? MARK.refute : MARK.cite} *${why}*`
+  })
+  text = text.replace(REF_VERB, (_, verb: string) => (isQuiet ? GONE : refMark(verb)))
+  text = text.replace(CITE, () => (isQuiet ? GONE : MARK.cite))
+  text = text.replace(ASIDE, (_, verb: string, body: string) => {
+    if (isQuiet) return GONE
+    const v = verb.toLowerCase()
+    return v === 'constraint' ? `*(${body})*` : `*${v === 'fix' ? 'fixed' : v}: ${body}*`
+  })
+  text = text.replace(LABEL, GONE)
+  text = text.replace(FLAG, (whole: string, bang: string, body: string, path?: string, line?: string) => {
+    if (ADMONITION.test(body)) return whole
+    const said = body.replace(/\s+(?:<-|←)\s+/g, ' ← ')
+    const where = path ? ` (${path}${line ? `:${line}` : ''})` : ''
+    return isQuiet ? `${said}${where}` : `${bang === '?' ? MARK.suspect : MARK.flag} ${said}${where}`
+  })
+  return unshelveCode(mend(text), shelved.code)
+}
+
+const TAGGED = new RegExp(String.raw`\[[!?]|\(\s*\[|\(\s*(?:${VERBS})\s*:|${'`'}{3}errata-`, 'i')
+
+/** Whether a reply holds anything `tidyTags` could change: the render hook passes other rows through untouched. */
+export function hasTags(text: string): boolean {
+  return TAGGED.test(text)
+}

package/resources/claude-mods/errata-minimap/types/index.d.ts

@@ -4,6 +4,9 @@ export type BurstOrigin = 'agent' | 'daemon-file' | 'daemon-prompt'
 /** Which membrane a prior lives in: this machine only, or the project / team / org membrane, or the public Errata Network. */
 export type Scope = 'machine' | 'project' | 'team' | 'org' | 'public'
 
+/** A cloud community as the walker tools report it: tonight's partition number (compare within one answer only) and its theme when labelled. */
+export type CloudCommunity = { id: number; label: string | null }
+
 export type BurstNode = {
   id: string
   label: string
@@ -11,11 +14,14 @@ export type BurstNode = {
   /** Burst relevance; daemon-delivered nodes get a rank-derived stand-in. */
   score: number
   hops: number
-  /** The node the walk reached this one from, and by which edge. */
+  /** The node the walk reached this one from, and by which edge; `forward` ⇒ parent —edge→ node. */
   parent?: string
   edge?: string
+  forward?: boolean
   /** Absent when no client-visible signal says. */
   scope?: Scope
+  /** Only cloud-merged hits carry one. */
+  community?: CloudCommunity
 }
 
 /** One neighborhood that entered the agent's context. */
@@ -23,8 +29,7 @@ export type Burst = {
   origin: BurstOrigin
   seed: { id: string; label: string; name: string }
   nodes: BurstNode[]
-  /** Real edges among the delivered nodes, found after the fact. */
-  extra: [string, string][]
+  /** The seed's real name has been looked up (a burst names it by id). */
   isEnriched: boolean
   at: number
 }
@@ -35,25 +40,52 @@ export type MapNode = {
   name: string
   isSeed: boolean
   score: number
-  /** Rings out from the seed (0 for the seed): the order the reveal grows in. */
+  /** Steps out from the seed (0 for the seed). */
   hops: number
   scope?: Scope
-  x: number
-  y: number
+  /** Index of the node the walk reached this one from; -1 for the seed. */
+  parent: number
+  edge?: string
+  forward?: boolean
+  community?: CloudCommunity
 }
 
+/** A burst catalogued: its nodes in walk order, ready to bind into chains (hooks/chains.ts). */
 export type MapGraph = {
   title: string
   /** The seed's node type (File, Function, Prompt, ...). */
   seedLabel?: string
   origin?: BurstOrigin
   nodes: MapNode[]
-  /** Index pairs into `nodes`; `true` = an edge of the walk, `false` = a cross edge. */
-  edges: [number, number, boolean][]
   at: number
   note?: string
 }
 
+/** A node at the far end of an edge, as `errata_neighbors` names it. */
+export type FarNode = { id: string; label: string; name: string; community?: string }
+
+/**
+ * What `errata_neighbors` says about one chain's node: the edges that bind a
+ * chain (causes, fixes, the problems a lone cause/fix belongs to) and the ones
+ * that place it (tech anchors, patterns, the file it is anchored at, its
+ * community in the local partition).
+ */
+export type ChainFacts = {
+  id: string
+  label: string
+  name: string
+  /** `community_<id>` in the local partition; null = unplaced. */
+  community: string | null
+  causes: FarNode[]
+  fixes: FarNode[]
+  /** Problems this node causes or fixes (a lone cause/fix's chain). */
+  problems: FarNode[]
+  /** Tech anchors in edge order: Package (DEPENDS_ON), Tool/Component (CONCERNS), Language (OCCURS_IN). */
+  techs: FarNode[]
+  patterns: FarNode[]
+  anchors: string[]
+}
+
 /** One judgment the agent made on a prior in its reply: cited, confirmed, resolved or refuted. */
 export type Verdict = {
   id: string
@@ -69,6 +101,8 @@ declare module 'claude-code' {
       burst: Burst | null
       graph: MapGraph
       verdicts: Verdict[]
+      /** `errata_neighbors` answers by node id, for the chains on the shelves; missing = not asked yet, null = asked, not found. */
+      facts: Record<string, ChainFacts | null>
     }
   }
 }

package/resources/context-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "errata-context",
-  "version": "2.0.21",
+  "version": "2.0.22-dev.4020",
   "description": "A minimal 3D view of loaded Errata priors and recent graph bursts.",
   "author": {
     "name": "inErrata"

package/resources/context-plugin/SHA256SUMS

@@ -1,4 +1,4 @@
-56d81c847556db679faed369632a1f32e234c0ef41ff3b4475efc1af77983a21  .codex-plugin/plugin.json
+cefcb61c20b7e27f11cb65c4ab1bf3352957edd54c21cd575122b54dfd7f6581  .codex-plugin/plugin.json
 a7bebae9fb01c838d6c75fc784129e28be571233fa66ff5ee8039b574f35ccf7  assets/icon.png
 fc38b64e4df1e0b72c35764bef6c4c05430d97c9009ad0ecc8a9e75b4deab232  configure-local.mjs
 73dc6028b3b070257c7c31f252d11e55a9e096f4aed0f187f10cb21716e1e6d7  dist/client.js