@diagrammo/dgmo 0.2.27 → 0.3.0

package/src/er/parser.ts

@@ -1,6 +1,7 @@
 import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import { measureIndent } from '../utils/parsing';
 import type {
   ParsedERDiagram,
   ERTable,
@@ -13,16 +14,6 @@ import type {
 // Helpers
 // ============================================================
 
-function measureIndent(line: string): number {
-  let indent = 0;
-  for (const ch of line) {
-    if (ch === ' ') indent++;
-    else if (ch === '\t') indent += 4;
-    else break;
-  }
-  return indent;
-}
-
 function tableId(name: string): string {
   return name.toLowerCase().trim();
 }
@@ -50,42 +41,39 @@ const CONSTRAINT_MAP: Record<string, ERConstraint> = {
 // Cardinality parsing
 // ============================================================
 
-// Cardinality keyword map
-const CARD_WORD: Record<string, ERCardinality> = {
-  one: '1',
-  many: '*',
-  '1': '1',
-  '*': '*',
-  '?': '?',
-  zero: '?',
-};
-
 /**
- * Parse a cardinality side token (e.g. "1", "*", "?", "one", "many", "zero").
+ * Parse a cardinality side token (symbolic only: "1", "*", "?").
  */
 function parseCardSide(token: string): ERCardinality | null {
-  return CARD_WORD[token.toLowerCase()] ?? null;
+  if (token === '1' || token === '*' || token === '?') return token;
+  return null;
 }
 
 /**
- * Try to parse a relationship line with cardinality.
+ * Try to parse a relationship line with symbolic cardinality.
  *
- * Supported forms:
+ * Supported form:
  *   tableName 1--* tableName : label
  *   tableName 1-* tableName : label
- *   tableName one-to-many tableName : label
- *   tableName one to many tableName : label
- *   tableName 1 to many tableName : label
  *   tableName ?--1 tableName : label
  */
 const REL_SYMBOLIC_RE =
   /^([a-zA-Z_]\w*)\s+([1*?])\s*-{1,2}\s*([1*?])\s+([a-zA-Z_]\w*)(?:\s*:\s*(.+))?$/;
 
+/** Detects keyword cardinality forms to emit helpful error */
 const REL_KEYWORD_RE =
-  /^([a-zA-Z_]\w*)\s+(one|many|zero|1|\*|\?)[- ]to[- ](one|many|zero|1|\*|\?)\s+([a-zA-Z_]\w*)(?:\s*:\s*(.+))?$/i;
+  /^([a-zA-Z_]\w*)\s+(one|many|zero)[- ]to[- ](one|many|zero)\s+([a-zA-Z_]\w*)(?:\s*:\s*(.+))?$/i;
+
+const KEYWORD_TO_SYMBOL: Record<string, string> = {
+  one: '1',
+  many: '*',
+  zero: '?',
+};
 
 function parseRelationship(
-  trimmed: string
+  trimmed: string,
+  lineNumber: number,
+  pushError: (line: number, message: string) => void,
 ): {
   source: string;
   target: string;
@@ -109,20 +97,16 @@ function parseRelationship(
     }
   }
 
-  // Keyword / natural: one-to-many, one to many, 1 to many, etc.
+  // Keyword / natural: produce helpful error with symbolic suggestion
   const kw = trimmed.match(REL_KEYWORD_RE);
   if (kw) {
-    const fromCard = parseCardSide(kw[2]);
-    const toCard = parseCardSide(kw[3]);
-    if (fromCard && toCard) {
-      return {
-        source: kw[1],
-        target: kw[4],
-        from: fromCard,
-        to: toCard,
-        label: kw[5]?.trim(),
-      };
-    }
+    const fromSym = KEYWORD_TO_SYMBOL[kw[2].toLowerCase()] ?? kw[2];
+    const toSym = KEYWORD_TO_SYMBOL[kw[3].toLowerCase()] ?? kw[3];
+    pushError(
+      lineNumber,
+      `Use symbolic cardinality (1--*, ?--1, *--*) instead of "${kw[2]}-to-${kw[3]}". Example: ${kw[1]} ${fromSym}--${toSym} ${kw[4]}`,
+    );
+    return null;
   }
 
   return null;
@@ -157,6 +141,7 @@ export function parseERDiagram(
     tables: [],
     relationships: [],
     diagnostics: [],
+    error: null,
   };
 
   const fail = (line: number, message: string): ParsedERDiagram => {
@@ -166,6 +151,12 @@ export function parseERDiagram(
     return result;
   };
 
+  const pushError = (line: number, message: string): void => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+
   const tableMap = new Map<string, ERTable>();
   let currentTable: ERTable | null = null;
   let contentStarted = false;
@@ -257,7 +248,7 @@ export function parseERDiagram(
     contentStarted = true;
 
     // Try relationship
-    const rel = parseRelationship(trimmed);
+    const rel = parseRelationship(trimmed, lineNumber, pushError);
     if (rel) {
       getOrCreateTable(rel.source, lineNumber);
       getOrCreateTable(rel.target, lineNumber);
@@ -347,7 +338,7 @@ export function looksLikeERDiagram(content: string): boolean {
         hasTableDecl = true;
       }
       // Check for relationship patterns
-      if (REL_SYMBOLIC_RE.test(trimmed) || REL_KEYWORD_RE.test(trimmed)) {
+      if (REL_SYMBOLIC_RE.test(trimmed)) {
         hasRelationship = true;
       }
     }

package/src/er/types.ts

@@ -39,5 +39,5 @@ export interface ParsedERDiagram {
   tables: ERTable[];
   relationships: ERRelationship[];
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }

package/src/graph/flowchart-parser.ts

@@ -1,6 +1,7 @@
 import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import { measureIndent, extractColor } from '../utils/parsing';
 import type {
   ParsedGraph,
   GraphNode,
@@ -14,16 +15,6 @@ import type {
 // Helpers
 // ============================================================
 
-function measureIndent(line: string): number {
-  let indent = 0;
-  for (const ch of line) {
-    if (ch === ' ') indent++;
-    else if (ch === '\t') indent += 4;
-    else break;
-  }
-  return indent;
-}
-
 function nodeId(shape: GraphShape, label: string): string {
   return `${shape}:${label.toLowerCase().trim()}`;
 }
@@ -35,21 +26,6 @@ interface NodeRef {
   color?: string;
 }
 
-const COLOR_SUFFIX_RE = /\(([^)]+)\)\s*$/;
-
-function extractColor(
-  label: string,
-  palette?: PaletteColors
-): { label: string; color?: string } {
-  const m = label.match(COLOR_SUFFIX_RE);
-  if (!m) return { label };
-  const colorName = m[1].trim();
-  return {
-    label: label.substring(0, m.index!).trim(),
-    color: resolveColor(colorName, palette),
-  };
-}
-
 /**
  * Try to parse a node reference from a text fragment.
  * Order matters: subroutine & document before process.
@@ -239,6 +215,7 @@ export function parseFlowchart(
     edges: [],
     options: {},
     diagnostics: [],
+    error: null,
   };
 
   const fail = (line: number, message: string): ParsedGraph => {

package/src/graph/types.ts

@@ -45,5 +45,5 @@ export interface ParsedGraph {
   groups?: GraphGroup[];
   options: Record<string, string>;
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }

package/src/index.ts

@@ -126,6 +126,11 @@ export type {
   GraphDirection,
 } from './graph/types';
 
+export type { TagGroup, TagEntry } from './utils/tag-groups';
+
+export { parseInlineMarkdown, truncateBareUrl } from './utils/inline-markdown';
+export type { InlineSpan } from './utils/inline-markdown';
+
 export { parseOrg } from './org/parser';
 export type {
   ParsedOrg,

package/src/initiative-status/parser.ts

@@ -29,14 +29,14 @@ export function looksLikeInitiativeStatus(content: string): boolean {
   let hasIndentedArrow = false;
   for (const line of lines) {
     const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    if (!trimmed || trimmed.startsWith('//')) continue;
     if (trimmed.match(/^chart\s*:/i)) continue;
     if (trimmed.match(/^title\s*:/i)) continue;
     if (trimmed.includes('->')) hasArrow = true;
     if (/\|\s*(done|wip|todo|na)\s*$/i.test(trimmed)) hasStatus = true;
     // Indented arrow is a strong signal — only initiative-status uses this
     const isIndented = line.length > 0 && line !== trimmed && /^\s/.test(line);
-    if (isIndented && trimmed.startsWith('->')) hasIndentedArrow = true;
+    if (isIndented && (trimmed.startsWith('->') || /^-[^>].*->/.test(trimmed))) hasIndentedArrow = true;
     if (hasArrow && hasStatus) return true;
   }
   return hasIndentedArrow;
@@ -68,7 +68,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     groups: [],
     options: {},
     diagnostics: [],
-    error: undefined,
+    error: null,
   };
 
   const lines = content.split('\n');
@@ -82,7 +82,7 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     const trimmed = raw.trim();
 
     // Skip blanks and comments
-    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    if (!trimmed || trimmed.startsWith('//')) continue;
 
     // chart: header
     const chartMatch = trimmed.match(/^chart\s*:\s*(.+)/i);
@@ -123,11 +123,11 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       currentGroup = null;
     }
 
-    // Edge: contains `->`
+    // Edge: contains `->` or labeled form `-label->`
     if (trimmed.includes('->')) {
       let edgeText = trimmed;
-      // Indented `-> Target` shorthand — prepend the last node label as source
-      if (trimmed.startsWith('->')) {
+      // Indented `-> Target` or `-label-> Target` shorthand
+      if (trimmed.startsWith('->') || /^-[^>].*->/.test(trimmed)) {
         if (!lastNodeLabel) {
           result.diagnostics.push(
             makeDgmoError(lineNum, 'Indented edge has no preceding node to use as source', 'warning')
@@ -222,6 +222,35 @@ function parseEdgeLine(
   // or:     <source> -> <target> | <status>
   // or:     <source> -> <target>: <label>
   // or:     <source> -> <target>
+  // or:     <source> -<label>-> <target> [| <status>]
+
+  // Check for labeled arrow form: SOURCE -LABEL-> TARGET [| status]
+  const labeledMatch = trimmed.match(/^(\S+)\s+-(.+)->\s+(.+)$/);
+  if (labeledMatch) {
+    const source = labeledMatch[1];
+    const label = labeledMatch[2].trim();
+    let targetRest = labeledMatch[3].trim();
+
+    if (label) {
+      // Extract status from end (after last |)
+      let status: InitiativeStatus = 'na';
+      const lastPipe = targetRest.lastIndexOf('|');
+      if (lastPipe >= 0) {
+        const statusRaw = targetRest.slice(lastPipe + 1).trim();
+        status = parseStatus(statusRaw, lineNum, diagnostics);
+        targetRest = targetRest.slice(0, lastPipe).trim();
+      }
+
+      const target = targetRest.trim();
+      if (!target) {
+        diagnostics.push(makeDgmoError(lineNum, 'Edge is missing target'));
+        return null;
+      }
+
+      return { source, target, label, status, lineNumber: lineNum };
+    }
+    // Empty label — fall through to plain arrow parsing
+  }
 
   const arrowIdx = trimmed.indexOf('->');
   if (arrowIdx < 0) return null;

package/src/initiative-status/types.ts

@@ -39,5 +39,5 @@ export interface ParsedInitiativeStatus {
   groups: ISGroup[];
   options: Record<string, string>;
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }

package/src/kanban/parser.ts

@@ -1,7 +1,14 @@
-import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import type { DgmoError } from '../diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import { matchTagBlockHeading } from '../utils/tag-groups';
+import {
+  measureIndent,
+  extractColor,
+  CHART_TYPE_RE,
+  TITLE_RE,
+  OPTION_RE,
+} from '../utils/parsing';
 import type {
   ParsedKanban,
   KanbanColumn,
@@ -14,40 +21,7 @@ import type {
 // Regex patterns
 // ============================================================
 
-const CHART_TYPE_RE = /^chart\s*:\s*(.+)/i;
-const TITLE_RE = /^title\s*:\s*(.+)/i;
-const OPTION_RE = /^([a-z][a-z0-9-]*)\s*:\s*(.+)$/i;
-const GROUP_HEADING_RE =
-  /^##\s+(.+?)(?:\s+alias\s+(\w+))?(?:\s*\(([^)]+)\))?\s*$/;
 const COLUMN_RE = /^==\s+(.+?)\s*(?:\[wip:\s*(\d+)\])?\s*==$/;
-const COLOR_SUFFIX_RE = /\(([^)]+)\)\s*$/;
-
-// ============================================================
-// Helpers
-// ============================================================
-
-function measureIndent(line: string): number {
-  let indent = 0;
-  for (const ch of line) {
-    if (ch === ' ') indent++;
-    else if (ch === '\t') indent += 4;
-    else break;
-  }
-  return indent;
-}
-
-function extractColor(
-  label: string,
-  palette?: PaletteColors
-): { label: string; color?: string } {
-  const m = label.match(COLOR_SUFFIX_RE);
-  if (!m) return { label };
-  const colorName = m[1].trim();
-  return {
-    label: label.substring(0, m.index!).trim(),
-    color: resolveColor(colorName, palette),
-  };
-}
 
 // ============================================================
 // Parser
@@ -63,6 +37,7 @@ export function parseKanban(
     tagGroups: [],
     options: {},
     diagnostics: [],
+    error: null,
   };
 
   const fail = (line: number, message: string): ParsedKanban => {
@@ -146,10 +121,32 @@ export function parseKanban(
       }
     }
 
+    // Tag group heading — `tag: Name` (new) or `## Name` (deprecated)
+    // Must be checked BEFORE OPTION_RE to prevent `tag: Rank` being swallowed as option
+    if (!contentStarted) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        if (tagBlockMatch.deprecated) {
+          warn(lineNumber, `'## ${tagBlockMatch.name}' is deprecated for tag groups — use 'tag: ${tagBlockMatch.name}' instead`);
+        }
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          alias: tagBlockMatch.alias,
+          entries: [],
+          lineNumber,
+        };
+        if (tagBlockMatch.alias) {
+          aliasMap.set(tagBlockMatch.alias.toLowerCase(), tagBlockMatch.name.toLowerCase());
+        }
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+
     // Generic header options (key: value before content/tag groups)
     if (!contentStarted && !currentTagGroup && measureIndent(line) === 0) {
       const optMatch = trimmed.match(OPTION_RE);
-      if (optMatch && !trimmed.startsWith('##') && !COLUMN_RE.test(trimmed)) {
+      if (optMatch && !COLUMN_RE.test(trimmed)) {
         const key = optMatch[1].trim().toLowerCase();
         if (key !== 'chart' && key !== 'title') {
           result.options[key] = optMatch[2].trim();
@@ -158,24 +155,6 @@ export function parseKanban(
       }
     }
 
-    // ## Tag group heading
-    const groupMatch = trimmed.match(GROUP_HEADING_RE);
-    if (groupMatch && !contentStarted) {
-      const groupName = groupMatch[1].trim();
-      const alias = groupMatch[2] || undefined;
-      currentTagGroup = {
-        name: groupName,
-        alias,
-        entries: [],
-        lineNumber,
-      };
-      if (alias) {
-        aliasMap.set(alias.toLowerCase(), groupName.toLowerCase());
-      }
-      result.tagGroups.push(currentTagGroup);
-      continue;
-    }
-
     // Tag group entries (indented Value(color) [default] under ## heading)
     if (currentTagGroup && !contentStarted) {
       const indent = measureIndent(line);

package/src/kanban/renderer.ts

@@ -5,6 +5,7 @@
 import * as d3Selection from 'd3-selection';
 import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
+import { renderInlineText } from '../utils/inline-markdown';
 import type { ParsedKanban, KanbanColumn, KanbanCard, KanbanTagGroup } from './types';
 import { parseKanban } from './parser';
 import { isArchiveColumn } from './mutations';
@@ -498,14 +499,14 @@ export function renderKanban(
         .attr('stroke', cardStroke)
         .attr('stroke-width', CARD_STROKE_WIDTH);
 
-      // Card title
-      cg.append('text')
+      // Card title (inline markdown)
+      const titleEl = cg.append('text')
         .attr('x', cx + CARD_PADDING_X)
         .attr('y', cy + CARD_PADDING_Y + CARD_TITLE_FONT_SIZE)
         .attr('font-size', CARD_TITLE_FONT_SIZE)
         .attr('font-weight', '500')
-        .attr('fill', palette.text)
-        .text(card.title);
+        .attr('fill', palette.text);
+      renderInlineText(titleEl, card.title, palette, CARD_TITLE_FONT_SIZE);
 
       // Separator + metadata
       if (hasMeta) {
@@ -542,14 +543,14 @@ export function renderKanban(
           metaY += CARD_META_LINE_HEIGHT;
         }
 
-        // Detail lines
+        // Detail lines (inline markdown)
         for (const detail of card.details) {
-          cg.append('text')
+          const detailEl = cg.append('text')
             .attr('x', cx + CARD_PADDING_X)
             .attr('y', metaY)
             .attr('font-size', CARD_META_FONT_SIZE)
-            .attr('fill', palette.textMuted)
-            .text(detail);
+            .attr('fill', palette.textMuted);
+          renderInlineText(detailEl, detail, palette, CARD_META_FONT_SIZE);
 
           metaY += CARD_META_LINE_HEIGHT;
         }

package/src/kanban/types.ts

@@ -1,18 +1,10 @@
 import type { DgmoError } from '../diagnostics';
+import type { TagGroup, TagEntry } from '../utils/tag-groups';
 
-export interface KanbanTagEntry {
-  value: string;
-  color: string;
-  lineNumber: number;
-}
-
-export interface KanbanTagGroup {
-  name: string;
-  alias?: string;
-  entries: KanbanTagEntry[];
-  defaultValue?: string;
-  lineNumber: number;
-}
+/** @deprecated Use `TagEntry` from `utils/tag-groups` */
+export type KanbanTagEntry = TagEntry;
+/** @deprecated Use `TagGroup` from `utils/tag-groups` */
+export type KanbanTagGroup = TagGroup;
 
 export interface KanbanCard {
   id: string;
@@ -41,5 +33,5 @@ export interface ParsedKanban {
   tagGroups: KanbanTagGroup[];
   options: Record<string, string>;
   diagnostics: DgmoError[];
-  error?: string;
+  error: string | null;
 }