@oh-my-pi/pi-utils 16.0.6 → 16.0.8

package/src/vendor/mermaid-ascii/class/parser.ts

@@ -0,0 +1,290 @@
+import type { ClassDiagram, ClassNode, ClassRelationship, ClassMember, RelationshipType, ClassNamespace } from './types'
+import { normalizeBrTags } from '../multiline-utils'
+
+// ============================================================================
+// 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]!
+
+    // --- 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
+}
+
+/** 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
+  }
+}

package/src/vendor/mermaid-ascii/class/types.ts

@@ -0,0 +1,121 @@
+// ============================================================================
+// Class diagram types
+//
+// Models the parsed and positioned representations of a Mermaid class diagram.
+// Class diagrams show UML class relationships, inheritance, composition, etc.
+// ============================================================================
+
+/** Parsed class diagram — logical structure from mermaid text */
+export interface ClassDiagram {
+  /** All class definitions */
+  classes: ClassNode[]
+  /** Relationships between classes */
+  relationships: ClassRelationship[]
+  /** Optional namespace groupings */
+  namespaces: ClassNamespace[]
+}
+
+export interface ClassNode {
+  id: string
+  label: string
+  /** Annotation like <<interface>>, <<abstract>>, <<service>>, <<enumeration>> */
+  annotation?: string
+  /** Class attributes (fields/properties) */
+  attributes: ClassMember[]
+  /** Class methods (functions) */
+  methods: ClassMember[]
+}
+
+export interface ClassMember {
+  /** Visibility: + public, - private, # protected, ~ package */
+  visibility: '+' | '-' | '#' | '~' | ''
+  /** Member name */
+  name: string
+  /** Type annotation (e.g., "String", "int", "void") */
+  type?: string
+  /** Whether the member is static (underlined in UML) */
+  isStatic?: boolean
+  /** Whether the member is abstract (italic in UML) */
+  isAbstract?: boolean
+  /** Whether the member is a method (renders with parentheses) */
+  isMethod?: boolean
+  /** Method parameters (e.g., "data", "key, val") — only for methods */
+  params?: string
+}
+
+/** Relationship types following UML conventions */
+export type RelationshipType =
+  | 'inheritance'   // A <|-- B   (solid line, hollow triangle)
+  | 'composition'   // A *-- B    (solid line, filled diamond)
+  | 'aggregation'   // A o-- B    (solid line, hollow diamond)
+  | 'association'   // A --> B    (solid line, open arrow)
+  | 'dependency'    // A ..> B    (dashed line, open arrow)
+  | 'realization'   // A ..|> B   (dashed line, hollow triangle)
+
+export interface ClassRelationship {
+  from: string
+  to: string
+  type: RelationshipType
+  /**
+   * Which end of the relationship line has the UML marker (triangle, diamond, arrow).
+   * Determined by the arrow syntax direction:
+   *   - Prefix markers like `<|--`, `*--`, `o--` → 'from' (marker on left/from side)
+   *   - Suffix markers like `..|>`, `-->`, `..>`, `--*`, `--o` → 'to' (marker on right/to side)
+   */
+  markerAt: 'from' | 'to'
+  /** Label on the relationship line */
+  label?: string
+  /** Cardinality at the "from" end (e.g., "1", "*", "0..1") */
+  fromCardinality?: string
+  /** Cardinality at the "to" end */
+  toCardinality?: string
+}
+
+export interface ClassNamespace {
+  name: string
+  classIds: string[]
+}
+
+// ============================================================================
+// Positioned class diagram — ready for SVG rendering
+// ============================================================================
+
+export interface PositionedClassDiagram {
+  width: number
+  height: number
+  classes: PositionedClassNode[]
+  relationships: PositionedClassRelationship[]
+}
+
+export interface PositionedClassNode {
+  id: string
+  label: string
+  annotation?: string
+  attributes: ClassMember[]
+  methods: ClassMember[]
+  x: number
+  y: number
+  width: number
+  height: number
+  /** Height of the header section (name + annotation) */
+  headerHeight: number
+  /** Height of the attributes section */
+  attrHeight: number
+  /** Height of the methods section */
+  methodHeight: number
+}
+
+export interface PositionedClassRelationship {
+  from: string
+  to: string
+  type: RelationshipType
+  /** Which end of the line has the UML marker — propagated from ClassRelationship */
+  markerAt: 'from' | 'to'
+  label?: string
+  fromCardinality?: string
+  toCardinality?: string
+  /** Path points from source to target */
+  points: Array<{ x: number; y: number }>
+  /** Dagre-computed label center position (avoids overlaps between nearby edges) */
+  labelPosition?: { x: number; y: number }
+}

package/src/vendor/mermaid-ascii/er/parser.ts

@@ -0,0 +1,181 @@
+import type { ErDiagram, ErEntity, ErAttribute, ErRelationship, Cardinality } from './types'
+import { normalizeBrTags } from '../multiline-utils'
+
+// ============================================================================
+// ER diagram parser
+//
+// Parses Mermaid erDiagram syntax into an ErDiagram structure.
+//
+// Supported syntax:
+//   CUSTOMER ||--o{ ORDER : places
+//   CUSTOMER {
+//     string name PK
+//     int age
+//     string email UK "user email"
+//   }
+//
+// Cardinality notation:
+//   ||  exactly one
+//   o|  zero or one (also |o)
+//   }|  one or more (also |{)
+//   o{  zero or more (also {o)
+//
+// Line style:
+//   --  identifying (solid line)
+//   ..  non-identifying (dashed line)
+// ============================================================================
+
+/**
+ * Parse a Mermaid ER diagram.
+ * Expects the first line to be "erDiagram".
+ */
+export function parseErDiagram(lines: string[]): ErDiagram {
+  const diagram: ErDiagram = {
+    entities: [],
+    relationships: [],
+  }
+
+  // Track entities by ID for deduplication
+  const entityMap = new Map<string, ErEntity>()
+  // Track entity body parsing
+  let currentEntity: ErEntity | null = null
+
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]!
+
+    // --- Inside entity body ---
+    if (currentEntity) {
+      if (line === '}') {
+        currentEntity = null
+        continue
+      }
+
+      // Attribute line: type name [PK|FK|UK] ["comment"]
+      const attr = parseAttribute(line)
+      if (attr) {
+        currentEntity.attributes.push(attr)
+      }
+      continue
+    }
+
+    // --- Entity block start: `ENTITY_NAME {` ---
+    const entityBlockMatch = line.match(/^(\S+)\s*\{$/)
+    if (entityBlockMatch) {
+      const id = entityBlockMatch[1]!
+      const entity = ensureEntity(entityMap, id)
+      currentEntity = entity
+      continue
+    }
+
+    // --- Relationship: `ENTITY1 cardinality1--cardinality2 ENTITY2 : label` ---
+    const rel = parseRelationshipLine(line)
+    if (rel) {
+      // Ensure both entities exist
+      ensureEntity(entityMap, rel.entity1)
+      ensureEntity(entityMap, rel.entity2)
+      diagram.relationships.push(rel)
+      continue
+    }
+  }
+
+  diagram.entities = [...entityMap.values()]
+  return diagram
+}
+
+/** Ensure an entity exists in the map */
+function ensureEntity(entityMap: Map<string, ErEntity>, id: string): ErEntity {
+  let entity = entityMap.get(id)
+  if (!entity) {
+    entity = { id, label: id, attributes: [] }
+    entityMap.set(id, entity)
+  }
+  return entity
+}
+
+/** Parse an attribute line inside an entity block */
+function parseAttribute(line: string): ErAttribute | null {
+  // Format: type name [PK|FK|UK [...]] ["comment"]
+  const match = line.match(/^(\S+)\s+(\S+)(?:\s+(.+))?$/)
+  if (!match) return null
+
+  const type = match[1]!
+  const name = match[2]!
+  const rest = match[3]?.trim() ?? ''
+
+  // Extract key constraints (PK, FK, UK) and optional comment
+  const keys: ErAttribute['keys'] = []
+  let comment: string | undefined
+
+  // Extract quoted comment first (supports <br> tags)
+  const commentMatch = rest.match(/"([^"]*)"/)
+  if (commentMatch) {
+    comment = normalizeBrTags(commentMatch[1]!)
+  }
+
+  // Extract key constraints
+  const restWithoutComment = rest.replace(/"[^"]*"/, '').trim()
+  for (const part of restWithoutComment.split(/\s+/)) {
+    const upper = part.toUpperCase()
+    if (upper === 'PK' || upper === 'FK' || upper === 'UK') {
+      keys.push(upper as 'PK' | 'FK' | 'UK')
+    }
+  }
+
+  return { type, name, keys, comment }
+}
+
+/**
+ * Parse a relationship line.
+ *
+ * Cardinality symbols on each side of the line style:
+ *   Left side (entity1):  ||  |o  o|  }|  |{  o{  {o
+ *   Line:                 --  (identifying) or  ..  (non-identifying)
+ *   Right side (entity2): ||  o|  |o  |{  }|  {o  o{
+ *
+ * Full pattern example: CUSTOMER ||--o{ ORDER : places
+ */
+function parseRelationshipLine(line: string): ErRelationship | null {
+  // Match: ENTITY1 <cardinality_and_line> ENTITY2 : label
+  const match = line.match(/^(\S+)\s+([|o}{]+(?:--|\.\.)[|o}{]+)\s+(\S+)\s*:\s*(.+)$/)
+  if (!match) return null
+
+  const entity1 = match[1]!
+  const cardinalityStr = match[2]!
+  const entity2 = match[3]!
+  // Strip surrounding quotes if present, then normalize br tags
+  const rawLabel = match[4]!.trim().replace(/^["']|["']$/g, '')
+  const label = normalizeBrTags(rawLabel)
+
+  // Split the cardinality string into left side, line style, right side
+  const lineMatch = cardinalityStr.match(/^([|o}{]+)(--|\.\.?)([|o}{]+)$/)
+  if (!lineMatch) return null
+
+  const leftStr = lineMatch[1]!
+  const lineStyle = lineMatch[2]!
+  const rightStr = lineMatch[3]!
+
+  const cardinality1 = parseCardinality(leftStr)
+  const cardinality2 = parseCardinality(rightStr)
+  const identifying = lineStyle === '--'
+
+  if (!cardinality1 || !cardinality2) return null
+
+  return { entity1, entity2, cardinality1, cardinality2, label, identifying }
+}
+
+/** Parse a cardinality notation string into a Cardinality type */
+function parseCardinality(str: string): Cardinality | null {
+  // Normalize: sort the characters to handle both orders (e.g., |o and o|)
+  const sorted = str.split('').sort().join('')
+
+  // Exact one: || → sorted "||"
+  if (sorted === '||') return 'one'
+  // Zero or one: o| or |o → sorted "o|" (o=111 < |=124 in char codes)
+  if (sorted === 'o|') return 'zero-one'
+  // One or more: }| or |{ → sorted "|}" or "{|"
+  if (sorted === '|}' || sorted === '{|') return 'many'
+  // Zero or more: o{ or {o → sorted "{o" or "o{"
+  if (sorted === '{o' || sorted === 'o{') return 'zero-many'
+
+  return null
+}

package/src/vendor/mermaid-ascii/er/types.ts

@@ -0,0 +1,91 @@
+// ============================================================================
+// ER diagram types
+//
+// Models the parsed and positioned representations of a Mermaid ER diagram.
+// ER diagrams show database entities, their attributes, and relationships.
+// ============================================================================
+
+/** Parsed ER diagram — logical structure from mermaid text */
+export interface ErDiagram {
+  /** All entity definitions */
+  entities: ErEntity[]
+  /** Relationships between entities */
+  relationships: ErRelationship[]
+}
+
+export interface ErEntity {
+  id: string
+  /** Display name (same as id unless aliased) */
+  label: string
+  /** Entity attributes (columns) */
+  attributes: ErAttribute[]
+}
+
+export interface ErAttribute {
+  /** Data type (string, int, varchar, etc.) */
+  type: string
+  /** Attribute name */
+  name: string
+  /** Key constraints: PK, FK, UK */
+  keys: Array<'PK' | 'FK' | 'UK'>
+  /** Optional comment */
+  comment?: string
+}
+
+/**
+ * Cardinality notation (crow's foot):
+ *   'one'       ||  exactly one
+ *   'zero-one'  |o  zero or one
+ *   'many'      }|  one or more
+ *   'zero-many' o{  zero or more
+ */
+export type Cardinality = 'one' | 'zero-one' | 'many' | 'zero-many'
+
+export interface ErRelationship {
+  entity1: string
+  entity2: string
+  /** Cardinality at entity1's end */
+  cardinality1: Cardinality
+  /** Cardinality at entity2's end */
+  cardinality2: Cardinality
+  /** Relationship verb/label (e.g., "places", "contains") */
+  label: string
+  /** Whether the relationship is identifying (solid line) or non-identifying (dashed) */
+  identifying: boolean
+}
+
+// ============================================================================
+// Positioned ER diagram — ready for SVG rendering
+// ============================================================================
+
+export interface PositionedErDiagram {
+  width: number
+  height: number
+  entities: PositionedErEntity[]
+  relationships: PositionedErRelationship[]
+}
+
+export interface PositionedErEntity {
+  id: string
+  label: string
+  attributes: ErAttribute[]
+  x: number
+  y: number
+  width: number
+  height: number
+  /** Height of the header row */
+  headerHeight: number
+  /** Height per attribute row */
+  rowHeight: number
+}
+
+export interface PositionedErRelationship {
+  entity1: string
+  entity2: string
+  cardinality1: Cardinality
+  cardinality2: Cardinality
+  label: string
+  identifying: boolean
+  /** Path points from entity1 to entity2 */
+  points: Array<{ x: number; y: number }>
+}

package/src/vendor/mermaid-ascii/index.ts

@@ -0,0 +1,14 @@
+// ============================================================================
+// Mermaid → ASCII renderer (vendored)
+//
+// First-party copy of the ASCII rendering pipeline from `beautiful-mermaid`
+// (MIT, Copyright (c) 2026 Craft Docs — see ./NOTICE). The SVG pipeline and
+// its `elkjs` graph-layout dependency are omitted; the ASCII renderers use
+// their own grid layout + A* edge routing and need no external deps. Terminal
+// display-width math is delegated to `Bun.stringWidth` (see ./text-metrics).
+//
+// Public surface: renderMermaidASCII + AsciiRenderOptions (incl. the
+// `direction` override) and the theme/color-mode types.
+// ============================================================================
+
+export * from './ascii/index'