agentic-mermaid 0.1.1 → 0.2.0

package/src/browser.ts

@@ -1,29 +0,0 @@
-// ============================================================================
-// Browser entry point for Agentic Mermaid
-//
-// Exposes renderMermaid and renderMermaidAscii on window.__mermaid so they
-// can be called from inline <script> tags in samples.html.
-//
-// Bundled via `Bun.build({ target: 'browser' })` in scripts/site/editor.ts and website/build.ts.
-// ============================================================================
-
-import { renderMermaidSVGAsync } from './index.ts'
-import { verifyMermaid } from './agent/verify.ts'
-import { renderMermaidASCII, diagramColorsToAsciiTheme } from './ascii/index.ts'
-import { THEMES } from './theme.ts'
-import { knownStyles, getStyle } from './scene/style-registry.ts'
-import { getSeriesColor, CHART_ACCENT_FALLBACK } from './xychart/colors.ts'
-
-declare const window: unknown
-
-;(window as Record<string, unknown>).__mermaid = {
-  renderMermaidSVGAsync,
-  verifyMermaid,
-  renderMermaidASCII,
-  diagramColorsToAsciiTheme,
-  THEMES,
-  knownStyles,
-  getStyle,
-  getSeriesColor,
-  CHART_ACCENT_FALLBACK,
-}

package/src/class/layout.ts

@@ -1,240 +0,0 @@
-/**
- * Class diagram layout engine (ELK.js).
- *
- * Each class box has 3 compartments:
- *   1. Header (class name + optional annotation)
- *   2. Attributes section
- *   3. Methods section
- */
-
-import type { ElkNode, ElkExtendedEdge } from 'elkjs'
-import type { ClassDiagram, ClassNode, ClassMember, PositionedClassDiagram, PositionedClassNode, PositionedClassRelationship } from './types.ts'
-import type { RenderOptions, Point } from '../types.ts'
-import { applyTextTransform, estimateTextWidth, estimateMonoTextWidth, FONT_SIZES, FONT_WEIGHTS, STROKE_WIDTHS, resolveRenderStyle } from '../styles.ts'
-import type { RenderStyleDefaults } from '../styles.ts'
-import { measureMultilineText } from '../text-metrics.ts'
-import { elkLayoutSync } from '../elk-instance.ts'
-
-/** Layout constants for class diagrams */
-export const CLS = {
-  padding: 40,
-  boxPadX: 8,
-  headerBaseHeight: 32,
-  annotationHeight: 16,
-  memberRowHeight: 20,
-  sectionPadY: 8,
-  emptySectionHeight: 8,
-  minWidth: 120,
-  memberFontSize: 11,
-  memberFontWeight: 400,
-  nodeSpacing: 40,
-  layerSpacing: 60,
-} as const
-
-/** Shared by layout (sizing) and renderer (drawing) — keep it single-sourced. */
-export const CLASS_STYLE_DEFAULTS: RenderStyleDefaults = {
-  nodeLabelFontSize: FONT_SIZES.nodeLabel,
-  edgeLabelFontSize: FONT_SIZES.edgeLabel,
-  groupHeaderFontSize: FONT_SIZES.groupHeader,
-  nodeLabelFontWeight: 700, // class titles are drawn bold; measure them bold too
-  edgeLabelFontWeight: FONT_WEIGHTS.edgeLabel,
-  groupHeaderFontWeight: FONT_WEIGHTS.groupHeader,
-  nodePaddingX: CLS.boxPadX,
-  nodePaddingY: CLS.sectionPadY,
-  nodeCornerRadius: 0,
-  nodeLineWidth: STROKE_WIDTHS.outerBox,
-  edgeLineWidth: STROKE_WIDTHS.connector,
-  groupCornerRadius: 0,
-  groupPaddingX: CLS.boxPadX,
-  groupPaddingY: CLS.sectionPadY,
-  groupLineWidth: STROKE_WIDTHS.outerBox,
-}
-
-type ClassSizeMap = Map<string, { width: number; height: number; headerHeight: number; attrHeight: number; methodHeight: number }>
-
-/** Build ELK graph and size map from a class diagram. */
-function buildClassElkGraph(
-  diagram: ClassDiagram,
-  options: RenderOptions
-): { elkGraph: ElkNode; classSizes: ClassSizeMap } {
-  const style = resolveRenderStyle(options, CLASS_STYLE_DEFAULTS)
-  const classSizes: ClassSizeMap = new Map()
-
-  for (const cls of diagram.classes) {
-    const label = applyTextTransform(cls.label, style.nodeTextTransform)
-    const headerBaseHeight = Math.max(
-      CLS.headerBaseHeight,
-      measureMultilineText(label, style.nodeLabelFontSize, style.nodeLabelFontWeight).height + style.nodePaddingY * 2,
-    )
-    const headerHeight = cls.annotation
-      ? headerBaseHeight + CLS.annotationHeight
-      : headerBaseHeight
-
-    const attrHeight = cls.attributes.length > 0
-      ? cls.attributes.length * CLS.memberRowHeight + style.nodePaddingY
-      : CLS.emptySectionHeight
-
-    const methodHeight = cls.methods.length > 0
-      ? cls.methods.length * CLS.memberRowHeight + style.nodePaddingY
-      : CLS.emptySectionHeight
-
-    const headerTextW = estimateTextWidth(label, style.nodeLabelFontSize, style.nodeLabelFontWeight)
-    const maxAttrW = maxMemberWidth(cls.attributes)
-    const maxMethodW = maxMemberWidth(cls.methods)
-    const width = Math.max(CLS.minWidth, headerTextW + style.nodePaddingX * 2, maxAttrW + style.nodePaddingX * 2, maxMethodW + style.nodePaddingX * 2)
-    const height = headerHeight + attrHeight + methodHeight
-
-    classSizes.set(cls.id, { width, height, headerHeight, attrHeight, methodHeight })
-  }
-
-  const elkGraph: ElkNode = {
-    id: 'root',
-    layoutOptions: {
-      'elk.algorithm': 'layered',
-      'elk.direction': 'DOWN',
-      'elk.spacing.nodeNode': String(CLS.nodeSpacing),
-      'elk.layered.spacing.nodeNodeBetweenLayers': String(CLS.layerSpacing),
-      'elk.padding': `[top=${CLS.padding},left=${CLS.padding},bottom=${CLS.padding},right=${CLS.padding}]`,
-      'elk.edgeRouting': 'ORTHOGONAL',
-      'elk.edgeLabels.placement': 'CENTER',
-    },
-    children: [],
-    edges: [],
-  }
-
-  for (const cls of diagram.classes) {
-    const size = classSizes.get(cls.id)!
-    elkGraph.children!.push({ id: cls.id, width: size.width, height: size.height })
-  }
-
-  for (let i = 0; i < diagram.relationships.length; i++) {
-    const rel = diagram.relationships[i]!
-    const edge: ElkExtendedEdge = { id: `e${i}`, sources: [rel.from], targets: [rel.to] }
-    if (rel.label) {
-      const label = applyTextTransform(rel.label, style.edgeTextTransform)
-      const metrics = measureMultilineText(label, style.edgeLabelFontSize, style.edgeLabelFontWeight)
-      edge.labels = [{ text: label, width: metrics.width + 8, height: metrics.height + 6 }]
-    }
-    elkGraph.edges!.push(edge)
-  }
-
-  return { elkGraph, classSizes }
-}
-
-/** Extract positioned classes and relationships from ELK result. */
-function extractClassLayout(
-  result: ElkNode,
-  diagram: ClassDiagram,
-  classSizes: ClassSizeMap
-): PositionedClassDiagram {
-  const classLookup = new Map<string, ClassNode>()
-  for (const cls of diagram.classes) classLookup.set(cls.id, cls)
-
-  const positionedClasses: PositionedClassNode[] = []
-  for (const child of result.children ?? []) {
-    const cls = classLookup.get(child.id)
-    if (cls) {
-      const size = classSizes.get(cls.id)!
-      positionedClasses.push({
-        id: cls.id,
-        label: cls.label,
-        annotation: cls.annotation,
-        attributes: cls.attributes,
-        methods: cls.methods,
-        x: child.x ?? 0,
-        y: child.y ?? 0,
-        width: child.width ?? size.width,
-        height: child.height ?? size.height,
-        headerHeight: size.headerHeight,
-        attrHeight: size.attrHeight,
-        methodHeight: size.methodHeight,
-      })
-    }
-  }
-
-  const relationships: PositionedClassRelationship[] = []
-  for (let i = 0; i < (result.edges?.length ?? 0); i++) {
-    const elkEdge = result.edges![i]!
-    const rel = diagram.relationships[i]!
-
-    const points: Point[] = []
-    if (elkEdge.sections && elkEdge.sections.length > 0) {
-      const section = elkEdge.sections[0]!
-      points.push({ x: section.startPoint.x, y: section.startPoint.y })
-      if (section.bendPoints) {
-        for (const bp of section.bendPoints) {
-          points.push({ x: bp.x, y: bp.y })
-        }
-      }
-      points.push({ x: section.endPoint.x, y: section.endPoint.y })
-    }
-
-    let labelPosition: Point | undefined
-    if (elkEdge.labels && elkEdge.labels.length > 0) {
-      const label = elkEdge.labels[0]!
-      if (label.x != null && label.y != null) {
-        labelPosition = {
-          x: label.x + (label.width ?? 0) / 2,
-          y: label.y + (label.height ?? 0) / 2,
-        }
-      }
-    }
-
-    relationships.push({
-      from: rel.from,
-      to: rel.to,
-      type: rel.type,
-      markerAt: rel.markerAt,
-      label: rel.label,
-      fromCardinality: rel.fromCardinality,
-      toCardinality: rel.toCardinality,
-      points,
-      labelPosition,
-    })
-  }
-
-  return {
-    width: result.width ?? 600,
-    height: result.height ?? 400,
-    accessibilityTitle: diagram.accessibilityTitle,
-    accessibilityDescription: diagram.accessibilityDescription,
-    classes: positionedClasses,
-    relationships,
-  }
-}
-
-/**
- * Lay out a parsed class diagram using ELK.js.
- */
-export function layoutClassDiagram(
-  diagram: ClassDiagram,
-  options: RenderOptions = {}
-): PositionedClassDiagram {
-  if (diagram.classes.length === 0) {
-    return { width: 0, height: 0, accessibilityTitle: diagram.accessibilityTitle, accessibilityDescription: diagram.accessibilityDescription, classes: [], relationships: [] }
-  }
-
-  const { elkGraph, classSizes } = buildClassElkGraph(diagram, options)
-  const result = elkLayoutSync(elkGraph)
-  return extractClassLayout(result, diagram, classSizes)
-}
-
-/** Calculate the max width of a list of class members (uses mono metrics) */
-function maxMemberWidth(members: ClassMember[]): number {
-  if (members.length === 0) return 0
-  let maxW = 0
-  for (const m of members) {
-    const text = memberToString(m)
-    const w = estimateMonoTextWidth(text, CLS.memberFontSize)
-    if (w > maxW) maxW = w
-  }
-  return maxW
-}
-
-/** Convert a class member to its display string */
-export function memberToString(m: ClassMember): string {
-  const vis = m.visibility ? `${m.visibility} ` : ''
-  const name = m.isMethod ? `${m.name}(${m.params || ''})` : m.name
-  const type = m.type ? `: ${m.type}` : ''
-  return `${vis}${name}${type}`
-}

package/src/class/parser.ts

@@ -1,332 +0,0 @@
-import type { ClassDiagram, ClassNode, ClassRelationship, ClassMember, RelationshipType, ClassNamespace } from './types.ts'
-import { normalizeBrTags } from '../multiline-utils.ts'
-
-// ============================================================================
-// Class diagram parser
-//
-// Parses Mermaid classDiagram syntax into a ClassDiagram structure.
-//
-// Supported syntax:
-//   class Animal { +String name; +eat() void }
-//   class Shape { <<abstract>> }
-//   Animal <|-- Dog           (inheritance)
-//   Car *-- Engine            (composition)
-//   Car o-- Wheel             (aggregation)
-//   A --> B                   (association)
-//   A ..> B                   (dependency)
-//   A ..|> B                  (realization)
-//   A "1" --> "*" B : label   (with cardinality + label)
-//   Animal : +String name     (inline attribute)
-//   namespace MyNamespace { class A { } }
-// ============================================================================
-
-/**
- * Parse a Mermaid class diagram.
- * Expects the first line to be "classDiagram".
- */
-export function parseClassDiagram(lines: string[]): ClassDiagram {
-  const diagram: ClassDiagram = {
-    classes: [],
-    relationships: [],
-    namespaces: [],
-  }
-
-  // Track classes by ID for deduplication
-  const classMap = new Map<string, ClassNode>()
-  // Track namespace nesting
-  let currentNamespace: ClassNamespace | null = null
-  // Track class body parsing
-  let currentClass: ClassNode | null = null
-  let braceDepth = 0
-
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i]!
-
-    const accTitle = parseAccessibilityLine(line, 'accTitle')
-    if (accTitle !== undefined) {
-      diagram.accessibilityTitle = accTitle
-      continue
-    }
-
-    const accDescrStart = line.match(/^accDescr\s*:?\s*\{\s*(.*)$/i)
-    if (accDescrStart) {
-      const parsed = collectAccessibilityBlock(accDescrStart[1] ?? '', lines, i)
-      diagram.accessibilityDescription = normalizeBrTags(parsed.text)
-      i = parsed.nextIndex
-      continue
-    }
-
-    const accDescr = parseAccessibilityLine(line, 'accDescr')
-    if (accDescr !== undefined) {
-      diagram.accessibilityDescription = accDescr
-      continue
-    }
-
-    // --- Inside a class body block ---
-    if (currentClass && braceDepth > 0) {
-      if (line === '}') {
-        braceDepth--
-        if (braceDepth === 0) {
-          currentClass = null
-        }
-        continue
-      }
-
-      // Check for annotation like <<interface>>
-      const annotMatch = line.match(/^<<(\w+)>>$/)
-      if (annotMatch) {
-        currentClass.annotation = annotMatch[1]!
-        continue
-      }
-
-      // Parse member: visibility, name, type, optional parens for method
-      const member = parseMember(line)
-      if (member) {
-        if (member.isMethod) {
-          currentClass.methods.push(member.member)
-        } else {
-          currentClass.attributes.push(member.member)
-        }
-      }
-      continue
-    }
-
-    // --- Namespace block start ---
-    const nsMatch = line.match(/^namespace\s+(\S+)\s*\{$/)
-    if (nsMatch) {
-      currentNamespace = { name: nsMatch[1]!, classIds: [] }
-      continue
-    }
-
-    // --- Namespace end ---
-    if (line === '}' && currentNamespace) {
-      diagram.namespaces.push(currentNamespace)
-      currentNamespace = null
-      continue
-    }
-
-    // --- Class block start: `class ClassName {` or `class ClassName` ---
-    const classBlockMatch = line.match(/^class\s+(\S+?)(?:\s*~(\w+)~)?\s*\{$/)
-    if (classBlockMatch) {
-      const id = classBlockMatch[1]!
-      const generic = classBlockMatch[2]
-      const cls = ensureClass(classMap, id)
-      if (generic) {
-        cls.label = `${id}<${generic}>`
-      }
-      currentClass = cls
-      braceDepth = 1
-      if (currentNamespace) {
-        currentNamespace.classIds.push(id)
-      }
-      continue
-    }
-
-    // --- Standalone class declaration (no body): `class ClassName` ---
-    const classOnlyMatch = line.match(/^class\s+(\S+?)(?:\s*~(\w+)~)?\s*$/)
-    if (classOnlyMatch) {
-      const id = classOnlyMatch[1]!
-      const generic = classOnlyMatch[2]
-      const cls = ensureClass(classMap, id)
-      if (generic) {
-        cls.label = `${id}<${generic}>`
-      }
-      if (currentNamespace) {
-        currentNamespace.classIds.push(id)
-      }
-      continue
-    }
-
-    // --- Inline annotation: `class ClassName { <<interface>> }` (single line) ---
-    const inlineAnnotMatch = line.match(/^class\s+(\S+?)\s*\{\s*<<(\w+)>>\s*\}$/)
-    if (inlineAnnotMatch) {
-      const cls = ensureClass(classMap, inlineAnnotMatch[1]!)
-      cls.annotation = inlineAnnotMatch[2]!
-      continue
-    }
-
-    // --- Inline attribute: `ClassName : +String name` ---
-    const inlineAttrMatch = line.match(/^(\S+?)\s*:\s*(.+)$/)
-    if (inlineAttrMatch) {
-      // Make sure this isn't a relationship line (those have arrows)
-      const rest = inlineAttrMatch[2]!
-      if (!rest.match(/<\|--|--|\*--|o--|-->|\.\.>|\.\.\|>/)) {
-        const cls = ensureClass(classMap, inlineAttrMatch[1]!)
-        const member = parseMember(rest)
-        if (member) {
-          if (member.isMethod) {
-            cls.methods.push(member.member)
-          } else {
-            cls.attributes.push(member.member)
-          }
-        }
-        continue
-      }
-    }
-
-    // --- Relationship ---
-    // Pattern: [FROM] ["card"] ARROW ["card"] [TO] [: label]
-    // Arrows: <|--, *--, o--, -->, ..|>, ..>
-    // Can also be reversed: --o, --*, --|>
-    const rel = parseRelationship(line)
-    if (rel) {
-      // Ensure both classes exist
-      ensureClass(classMap, rel.from)
-      ensureClass(classMap, rel.to)
-      diagram.relationships.push(rel)
-      continue
-    }
-  }
-
-  diagram.classes = [...classMap.values()]
-  return diagram
-}
-
-function parseAccessibilityLine(line: string, directive: 'accTitle' | 'accDescr'): string | undefined {
-  const match = line.match(new RegExp(`^${directive}\\s*:?[ \\t]+(.+)$`, 'i'))
-  return match ? normalizeBrTags(match[1]!.trim()) : undefined
-}
-
-function collectAccessibilityBlock(initial: string, lines: string[], startIndex: number): { text: string; nextIndex: number } {
-  const initialEnd = initial.indexOf('}')
-  if (initialEnd !== -1) return { text: initial.slice(0, initialEnd).trim(), nextIndex: startIndex }
-  const parts = [initial.trim()].filter(Boolean)
-  for (let i = startIndex + 1; i < lines.length; i++) {
-    const line = lines[i]!
-    const end = line.indexOf('}')
-    if (end !== -1) {
-      const beforeBrace = line.slice(0, end).trim()
-      if (beforeBrace) parts.push(beforeBrace)
-      return { text: parts.join('\n'), nextIndex: i }
-    }
-    parts.push(line)
-  }
-  throw new Error('Class accDescr block is missing a closing "}"')
-}
-
-/** Ensure a class exists in the map, creating a default if needed */
-function ensureClass(classMap: Map<string, ClassNode>, id: string): ClassNode {
-  let cls = classMap.get(id)
-  if (!cls) {
-    cls = { id, label: id, attributes: [], methods: [] }
-    classMap.set(id, cls)
-  }
-  return cls
-}
-
-/** Parse a class member line (attribute or method) */
-function parseMember(line: string): { member: ClassMember; isMethod: boolean } | null {
-  const trimmed = line.trim().replace(/;$/, '')
-  if (!trimmed) return null
-
-  // Extract visibility prefix
-  let visibility: ClassMember['visibility'] = ''
-  let rest = trimmed
-  if (/^[+\-#~]/.test(rest)) {
-    visibility = rest[0] as ClassMember['visibility']
-    rest = rest.slice(1).trim()
-  }
-
-  // Check if it's a method (has parentheses)
-  const methodMatch = rest.match(/^(.+?)\(([^)]*)\)(?:\s*(.+))?$/)
-  if (methodMatch) {
-    const name = methodMatch[1]!.trim()
-    const params = methodMatch[2]?.trim() || undefined // Store the parameter string
-    const type = methodMatch[3]?.trim()
-    // Check for static ($) or abstract (*) markers
-    const isStatic = name.endsWith('$') || rest.includes('$')
-    const isAbstract = name.endsWith('*') || rest.includes('*')
-    return {
-      member: {
-        visibility,
-        name: name.replace(/[$*]$/, ''),
-        type: type || undefined,
-        isStatic,
-        isAbstract,
-        isMethod: true,
-        params,
-      },
-      isMethod: true,
-    }
-  }
-
-  // It's an attribute: [Type] name or name Type
-  // Common patterns: "String name", "+int age", "name"
-  const parts = rest.split(/\s+/)
-  let name: string
-  let type: string | undefined
-
-  if (parts.length >= 2) {
-    // "Type name" pattern
-    type = parts[0]
-    name = parts.slice(1).join(' ')
-  } else {
-    name = parts[0] ?? rest
-  }
-
-  const isStatic = name.endsWith('$')
-  const isAbstract = name.endsWith('*')
-
-  return {
-    member: {
-      visibility,
-      name: name.replace(/[$*]$/, ''),
-      type: type || undefined,
-      isStatic,
-      isAbstract,
-      isMethod: false,
-    },
-    isMethod: false,
-  }
-}
-
-/** Parse a relationship line into a ClassRelationship */
-function parseRelationship(line: string): ClassRelationship | null {
-  // Relationship regex — handles all arrow types with optional cardinality and labels
-  // Pattern: FROM ["card"] ARROW ["card"] TO [: label]
-  const match = line.match(
-    /^(\S+?)\s+(?:"([^"]*?)"\s+)?(<\|--|<\|\.\.|\*--|o--|-->|--\*|--o|--\|>|\.\.>|\.\.\|>|<--|<\.\.?|--)\s+(?:"([^"]*?)"\s+)?(\S+?)(?:\s*:\s*(.+))?$/
-  )
-  if (!match) return null
-
-  const from = match[1]!
-  const rawFromCardinality = match[2]
-  const fromCardinality = rawFromCardinality ? normalizeBrTags(rawFromCardinality) : undefined
-  const arrow = match[3]!.trim()
-  const rawToCardinality = match[4]
-  const toCardinality = rawToCardinality ? normalizeBrTags(rawToCardinality) : undefined
-  const to = match[5]!
-  const rawLabel = match[6]?.trim()
-  const label = rawLabel ? normalizeBrTags(rawLabel) : undefined
-
-  const parsed = parseArrow(arrow)
-  if (!parsed) return null
-
-  return { from, to, type: parsed.type, markerAt: parsed.markerAt, label, fromCardinality, toCardinality }
-}
-
-/**
- * Map arrow syntax to relationship type and marker placement side.
- * Prefix markers (`<|--`, `*--`, `o--`) place the UML shape at the 'from' end.
- * Suffix markers (`..|>`, `-->`, `..>`, `--*`, `--o`) place it at the 'to' end.
- */
-function parseArrow(arrow: string): { type: RelationshipType; markerAt: 'from' | 'to' } | null {
-  // Trim whitespace that might be captured by the regex
-  const a = arrow.trim()
-  switch (a) {
-    case '<|--': return { type: 'inheritance',  markerAt: 'from' }
-    case '--|>': return { type: 'inheritance',  markerAt: 'to' }
-    case '<|..': return { type: 'realization',  markerAt: 'from' }
-    case '..|>': return { type: 'realization',  markerAt: 'to' }
-    case '*--':  return { type: 'composition',  markerAt: 'from' }
-    case '--*':  return { type: 'composition',  markerAt: 'to' }
-    case 'o--':  return { type: 'aggregation',  markerAt: 'from' }
-    case '--o':  return { type: 'aggregation',  markerAt: 'to' }
-    case '-->':  return { type: 'association',  markerAt: 'to' }
-    case '<--':  return { type: 'association',  markerAt: 'from' }
-    case '..>':  return { type: 'dependency',   markerAt: 'to' }
-    case '<..':  return { type: 'dependency',   markerAt: 'from' }
-    case '--':   return { type: 'association',  markerAt: 'to' }
-    default:     return null
-  }
-}