@yassimba/pi-loom-mermaid 0.2.0

package/src/loom-mermaid/diagrams/gitgraph.ts

@@ -0,0 +1,230 @@
+/**
+ * `gitGraph`: commit lanes, drawn the way `git log --graph` draws them —
+ * newest commit on top, one column per branch, connector rows where history
+ * splits. Lenient: an unreadable statement is dropped and recorded in
+ * `warnings`.
+ *
+ * Connector rows go through the canvas direction bits, so a merge reaching
+ * across an active lane crosses it with a `┼` instead of erasing it.
+ */
+
+import { Canvas, D, drawText, U } from '../canvas.ts'
+import { MAX_EDGES } from '../graph.ts'
+import { cleanLabel, fitLabel, type Limits } from '../labels.ts'
+import type { Diagram } from '../registry.ts'
+import { headerKind, statementsOf, words } from '../statements.ts'
+import { stringWidth } from '../width.ts'
+
+interface GitCommit {
+  lane: number
+  id: string
+  tag: string | null
+  /** Lane this commit merged in, if it is a merge commit. */
+  mergeFrom: number | null
+}
+
+export const gitgraph: Diagram = {
+  kind: 'gitgraph',
+  headers: ['gitgraph', 'gitgraph:'],
+  render(src, limits) {
+    const model = parseGitGraph(src, limits)
+    if (model === null) return null
+    const { branches, commits, forkAt, warnings } = model
+    const laneCount = branches.length
+
+    // The newest commit of each lane wears the branch name.
+    const headOf = new Map<number, number>()
+    commits.forEach((c, i) => {
+      headOf.set(c.lane, i)
+    })
+
+    /** Rows, top-down: commit rows interleaved with connector rows.
+     * `open` hangs a merged lane off its merge commit, `close` returns a
+     * forked lane to its parent at its fork point. Lanes never used (a
+     * branch with no commits that nothing merged) simply never open. */
+    type GitRow =
+      | { kind: 'commit'; at: number }
+      | { kind: 'open' | 'close'; parent: number; lane: number }
+    const rows: GitRow[] = []
+    const used = branches.map(
+      (_, lane) => commits.some((c) => c.lane === lane || c.mergeFrom === lane) || lane === 0,
+    )
+    for (let i = commits.length - 1; i >= 0; i--) {
+      const c = commits[i]
+      rows.push({ kind: 'commit', at: i })
+      if (c.mergeFrom !== null) {
+        rows.push({ kind: 'open', parent: c.lane, lane: c.mergeFrom })
+      }
+      // Close outer lanes first so an inner close still sees them as columns.
+      for (let lane = branches.length - 1; lane > 0; lane--) {
+        if (forkAt[lane] === i - 1 && used[lane]) {
+          rows.push({ kind: 'close', parent: commits[i - 1].lane, lane })
+        }
+      }
+    }
+
+    const laneX = (lane: number): number => lane * 2
+    const graphW = laneCount * 2
+    const labels = rows.map((row) => {
+      if (row.kind !== 'commit') return null
+      const c = commits[row.at]
+      const parts: [string, 'text' | 'edgeLabel'][] = c.id === '' ? [] : [[c.id, 'text']]
+      if (headOf.get(c.lane) === row.at) parts.push([`(${branches[c.lane]})`, 'edgeLabel'])
+      if (c.tag !== null) parts.push([`[${c.tag}]`, 'edgeLabel'])
+      if (c.mergeFrom !== null) parts.push([`⇐ ${branches[c.mergeFrom]}`, 'edgeLabel'])
+      return parts
+    })
+    const width =
+      graphW +
+      Math.max(
+        1,
+        ...labels.map((parts) =>
+          parts === null ? 0 : parts.reduce((w, [t]) => w + stringWidth(t) + 1, 0) - 1,
+        ),
+      )
+    const canvas = new Canvas(width, rows.length)
+
+    // Walk top-down with the set of lanes currently drawn as columns: a lane
+    // joins at its newest own commit or its `open` connector, and leaves at
+    // its `close`. Everything in the set draws `│` through every other row.
+    const live = new Set<number>()
+    rows.forEach((row, y) => {
+      if (row.kind === 'commit') {
+        const c = commits[row.at]
+        live.add(c.lane)
+        for (const lane of live) {
+          if (lane !== c.lane) canvas.addBits(laneX(lane), y, U | D)
+        }
+        canvas.set(laneX(c.lane), y, '●', 'edge')
+        let x = graphW
+        for (const [text, role] of labels[y] ?? []) {
+          drawText(canvas, text, x, y, role)
+          x += stringWidth(text) + 1
+        }
+        return
+      }
+      // The parent keeps its column, the child lane hooks on toward it, and
+      // unrelated live lanes cross the horizontal run as `┼` via the bit merge.
+      const { parent, lane } = row
+      const rejoins = row.kind === 'open' && live.has(lane)
+      if (row.kind === 'open') live.add(lane)
+      for (const l of live) {
+        if (l !== parent && l !== lane) canvas.addBits(laneX(l), y, U | D)
+      }
+      // An open hangs off the merge commit directly above; a close bends down
+      // into the fork commit below, continuing up only if the parent already
+      // had a column here.
+      if (row.kind === 'open') canvas.addBits(laneX(parent), y, U | D)
+      else canvas.addBits(laneX(parent), y, D | (live.has(parent) ? U : 0))
+      live.add(parent)
+      canvas.segH(y, laneX(parent), laneX(lane))
+      canvas.addBits(laneX(lane), y, (row.kind === 'open' ? D : U) | (rejoins ? U : 0))
+      if (row.kind === 'close') live.delete(lane)
+    })
+
+    canvas.finalizeMask()
+    return { canvas, warnings, classDefs: {} }
+  },
+}
+
+function parseGitGraph(
+  src: string,
+  limits: Limits,
+): {
+  branches: string[]
+  commits: GitCommit[]
+  forkAt: (number | null)[]
+  warnings: string[]
+} | null {
+  const statements = statementsOf(src)
+  const kind = headerKind(statements)
+  if (kind === null || !gitgraph.headers.includes(kind)) return null
+
+  const branches = ['main']
+  const forkAt: (number | null)[] = [null]
+  const commits: GitCommit[] = []
+  const warnings: string[] = []
+  /** Newest commit index per lane — the fork point for branches cut from it. */
+  const heads: (number | null)[] = [null]
+  let cur = 0
+  let auto = 0
+  let truncated = false
+
+  for (const st of statements.slice(1)) {
+    if (commits.length >= MAX_EDGES) {
+      truncated = true
+      break
+    }
+    const first = words(st)[0]?.toLowerCase() ?? ''
+    const rest = st.slice(words(st)[0]?.length ?? 0).trim()
+    if (first === 'commit') {
+      const attrs = commitAttrs(rest, limits.label)
+      heads[cur] = commits.length
+      commits.push({ lane: cur, id: attrs.id ?? `c${auto++}`, tag: attrs.tag, mergeFrom: null })
+    } else if (first === 'branch') {
+      const { name } = nameToken(rest)
+      // The fork point is the current branch's head, not the newest commit.
+      const fork = heads[cur] ?? forkAt[cur]
+      if (name === undefined || branches.includes(name) || fork === null) {
+        warnings.push(`dropped, unreadable statement: "${st}"`)
+        continue
+      }
+      branches.push(name)
+      forkAt.push(fork)
+      heads.push(null)
+      cur = branches.length - 1
+    } else if (first === 'checkout' || first === 'switch') {
+      const lane = branches.indexOf(nameToken(rest).name ?? '')
+      if (lane === -1) {
+        warnings.push(`dropped, unreadable statement: "${st}"`)
+        continue
+      }
+      cur = lane
+    } else if (first === 'merge') {
+      const { name, after } = nameToken(rest)
+      const lane = branches.indexOf(name ?? '')
+      if (lane === -1 || lane === cur) {
+        warnings.push(`dropped, unreadable statement: "${st}"`)
+        continue
+      }
+      // An unnamed merge shows no id — the `⇐ branch` marker already says
+      // what it is, and an invented id would collide with authored ones.
+      const attrs = commitAttrs(after, limits.label)
+      heads[cur] = commits.length
+      commits.push({ lane: cur, id: attrs.id ?? '', tag: attrs.tag, mergeFrom: lane })
+    } else if (first === 'cherry-pick') {
+      const attrs = commitAttrs(rest, limits.label)
+      heads[cur] = commits.length
+      commits.push({
+        lane: cur,
+        id: attrs.id === null ? `c${auto++}` : `⟲ ${attrs.id}`,
+        tag: attrs.tag,
+        mergeFrom: null,
+      })
+    } else {
+      warnings.push(`dropped, unreadable statement: "${st}"`)
+    }
+  }
+  if (truncated) warnings.push(`diagram truncated: commit cap (${MAX_EDGES}) reached`)
+
+  return commits.length === 0 ? null : { branches, commits, forkAt, warnings }
+}
+
+/** First branch-name token; quotes let a name carry spaces or keywords. */
+function nameToken(rest: string): { name: string | undefined; after: string } {
+  if (rest.startsWith('"')) {
+    const close = rest.indexOf('"', 1)
+    if (close !== -1) return { name: rest.slice(1, close), after: rest.slice(close + 1) }
+  }
+  const w = words(rest)[0]
+  return { name: w, after: w === undefined ? rest : rest.slice(w.length) }
+}
+
+/** `id: "x" tag: "v1" …` key/value pairs trailing a commit or merge. */
+function commitAttrs(rest: string, max: number): { id: string | null; tag: string | null } {
+  const out = { id: null as string | null, tag: null as string | null }
+  for (const m of rest.matchAll(/(id|tag)\s*:\s*"([^"]*)"/gi)) {
+    out[m[1].toLowerCase() as 'id' | 'tag'] = fitLabel(cleanLabel(m[2]), max)
+  }
+  return out
+}

package/src/loom-mermaid/diagrams/mindmap.ts

@@ -0,0 +1,107 @@
+/**
+ * `mindmap`: an indentation tree, drawn the way every TUI draws trees
+ * (`├──`/`└──` guides). Parses raw lines rather than statements — the
+ * indentation IS the grammar, and `statementsOf` trims it away.
+ */
+
+import { Canvas, drawText } from '../canvas.ts'
+import { MAX_NODES } from '../graph.ts'
+import { cleanLabel, fitLabel, type Limits, srcLines } from '../labels.ts'
+import type { Diagram } from '../registry.ts'
+import { frontmatterEnd } from '../statements.ts'
+import { stringWidth } from '../width.ts'
+
+interface MindNode {
+  text: string
+  children: MindNode[]
+}
+
+export const mindmap: Diagram = {
+  kind: 'mindmap',
+  headers: ['mindmap'],
+  render(src, limits) {
+    const parsed = parseMindmap(src, limits)
+    if (parsed === null) return null
+    const { roots, warnings } = parsed
+
+    /** [prefix, text] per row; prefixes carry the `│ ├ └` guides. */
+    const rows: [string, string][] = []
+    const walk = (node: MindNode, prefix: string, childPrefix: string): void => {
+      rows.push([prefix, node.text])
+      node.children.forEach((child, i) => {
+        const last = i === node.children.length - 1
+        walk(child, childPrefix + (last ? '└── ' : '├── '), childPrefix + (last ? '    ' : '│   '))
+      })
+    }
+    for (const root of roots) walk(root, '', '')
+
+    const width = Math.max(...rows.map(([p, t]) => stringWidth(p) + stringWidth(t)))
+    const canvas = new Canvas(width, rows.length)
+    rows.forEach(([prefix, text], y) => {
+      drawText(canvas, prefix, 0, y, 'edge')
+      drawText(canvas, text, stringWidth(prefix), y, 'text')
+    })
+    return { canvas, warnings, classDefs: {} }
+  },
+}
+
+function parseMindmap(src: string, limits: Limits): { roots: MindNode[]; warnings: string[] } | null {
+  const lines = srcLines(src).slice(frontmatterEnd(srcLines(src)))
+  const headerAt = lines.findIndex((l) => l.trim() !== '')
+  if (headerAt === -1 || lines[headerAt].trim().toLowerCase() !== 'mindmap') return null
+
+  const roots: MindNode[] = []
+  const warnings: string[] = []
+  /** Ancestors of the next node: the node at each indent level seen so far. */
+  const stack: { indent: number; node: MindNode }[] = []
+  let count = 0
+  let truncated = false
+
+  for (const raw of lines.slice(headerAt + 1)) {
+    const noComment = raw.split('%%')[0]
+    if (noComment.trim() === '') continue
+    const indent = noComment.length - noComment.trimStart().length
+    const body = noComment.trim()
+    // Decoration lines attach to the previous node and draw nothing.
+    if (body.startsWith('::icon') || body.startsWith(':::')) continue
+    const text = nodeText(body)
+    if (text === '') {
+      warnings.push(`dropped, unreadable statement: "${body}"`)
+      continue
+    }
+    if (count >= MAX_NODES) {
+      truncated = true
+      break
+    }
+    count++
+    const node: MindNode = { text: fitLabel(text, limits.wrap), children: [] }
+    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) stack.pop()
+    if (stack.length === 0) roots.push(node)
+    else stack[stack.length - 1].node.children.push(node)
+    stack.push({ indent, node })
+  }
+  if (truncated) warnings.push(`diagram truncated: node cap (${MAX_NODES}) reached`)
+
+  return roots.length === 0 ? null : { roots, warnings }
+}
+
+/** Shape brackets around a mindmap node all mean "text" in a terminal. */
+const SHAPES: [string, string][] = [
+  ['((', '))'],
+  ['))', '(('],
+  ['(-', '-)'],
+  ['{{', '}}'],
+  ['[', ']'],
+  ['(', ')'],
+]
+
+function nodeText(body: string): string {
+  // `id((text))` — an optional id may precede the bracket.
+  for (const [open, close] of SHAPES) {
+    const at = body.indexOf(open)
+    if (at !== -1 && body.endsWith(close) && body.length > at + open.length + close.length - 1) {
+      return cleanLabel(body.slice(at + open.length, body.length - close.length))
+    }
+  }
+  return cleanLabel(body)
+}

package/src/loom-mermaid/diagrams/pie.ts

@@ -0,0 +1,121 @@
+/**
+ * `pie`: proportions as a labelled bar list. A terminal has no circle worth
+ * drawing; bars carry the same information in less space and align with how
+ * every TUI shows usage. Lenient: an unreadable statement is dropped and
+ * recorded in `warnings`.
+ */
+
+import { Canvas, drawText } from '../canvas.ts'
+import { MAX_NODES } from '../graph.ts'
+import { cleanLabel, fitLabel } from '../labels.ts'
+import type { Diagram } from '../registry.ts'
+import { headerKind, nonEmpty, quoteMask, statementsOf, words } from '../statements.ts'
+import { stringWidth } from '../width.ts'
+
+/** Columns of the full-scale bar; eighth blocks refine below one cell. */
+const BAR_W = 20
+const EIGHTHS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']
+
+export const pie: Diagram = {
+  kind: 'pie',
+  headers: ['pie'],
+  render(src) {
+    const parsed = parsePie(src)
+    if (parsed === null) return null
+    const { title, slices, showData, warnings } = parsed
+
+    const labelW = Math.max(...slices.map((s) => stringWidth(s.label)))
+    const total = slices.reduce((sum, s) => sum + s.value, 0)
+    const rows = slices.map((s) => {
+      const share = total === 0 ? 0 : s.value / total
+      const pct = `${Math.round(share * 100)}%`.padStart(4)
+      const data = showData ? `  (${s.value})` : ''
+      return { ...s, share, suffix: pct + data }
+    })
+
+    const barX = labelW + 2
+    const suffixX = barX + BAR_W + 1
+    const width = suffixX + Math.max(...rows.map((r) => stringWidth(r.suffix)))
+    const top = title === null ? 0 : 1
+    const canvas = new Canvas(width, top + rows.length)
+
+    if (title !== null) {
+      drawText(canvas, title, Math.max(0, Math.floor((width - stringWidth(title)) / 2)), 0, 'title')
+    }
+    rows.forEach((r, i) => {
+      const y = top + i
+      drawText(canvas, r.label, 0, y, 'text')
+      const eighths = Math.round(r.share * BAR_W * 8)
+      let bar = '█'.repeat(Math.floor(eighths / 8)) + EIGHTHS[eighths % 8]
+      // A nonzero slice always shows at least a sliver.
+      if (bar === '' && r.value > 0) bar = '▏'
+      drawText(canvas, bar, barX, y, 'edge')
+      // The unfilled remainder is a track, so every bar shows its full scale.
+      drawText(canvas, '░'.repeat(BAR_W - stringWidth(bar)), barX + stringWidth(bar), y, 'border')
+      drawText(canvas, r.suffix, suffixX, y, 'edgeLabel')
+    })
+    return { canvas, warnings, classDefs: {} }
+  },
+}
+
+interface PieSlice {
+  label: string
+  value: number
+}
+
+function parsePie(src: string): {
+  title: string | null
+  slices: PieSlice[]
+  showData: boolean
+  warnings: string[]
+} | null {
+  const statements = statementsOf(src)
+  if (headerKind(statements) !== 'pie') return null
+
+  // The header line may carry `showData` and an inline `title ...`.
+  const head = words(statements[0])
+  const showData = head.some((w) => w.toLowerCase() === 'showdata')
+  const inlineTitle = head.findIndex((w) => w.toLowerCase() === 'title')
+  let title = inlineTitle === -1 ? null : nonEmpty(head.slice(inlineTitle + 1).join(' '))
+
+  const slices: PieSlice[] = []
+  const warnings: string[] = []
+  let truncated = false
+  for (const st of statements.slice(1)) {
+    const first = words(st)[0]?.toLowerCase()
+    if (first === 'title') {
+      title = nonEmpty(st.slice(st.toLowerCase().indexOf('title') + 5).trim())
+      continue
+    }
+    const slice = parseSlice(st)
+    if (slice === null) {
+      warnings.push(`dropped, unreadable statement: "${st}"`)
+      continue
+    }
+    if (slices.length >= MAX_NODES) {
+      truncated = true
+      break
+    }
+    slices.push(slice)
+  }
+  if (truncated) warnings.push(`diagram truncated: slice cap (${MAX_NODES}) reached`)
+
+  return slices.length === 0 ? null : { title, slices, showData, warnings }
+}
+
+/** `"Label" : 42.5` — the label may be unquoted as long as it has no colon. */
+function parseSlice(st: string): PieSlice | null {
+  const chars = [...st]
+  const quoted = quoteMask(chars)
+  const colon = chars.findIndex((c, i) => c === ':' && !quoted[i])
+  if (colon === -1) return null
+  const label = fitLabel(cleanLabel(chars.slice(0, colon).join('')), 24)
+  const value = Number(
+    chars
+      .slice(colon + 1)
+      .join('')
+      .trim(),
+  )
+  if (label === '' || !Number.isFinite(value) || value < 0) return null
+  return { label, value }
+}