@diagrammo/dgmo 0.7.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diagrammo/dgmo",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "DGMO diagram markup language — parser, renderer, and color system",
   "license": "MIT",
   "type": "module",

package/src/c4/parser.ts

@@ -11,6 +11,7 @@ import {
   measureIndent,
   extractColor,
   parsePipeMetadata,
+  MULTIPLE_PIPE_WARNING,
   CHART_TYPE_RE,
   TITLE_RE,
   OPTION_RE,
@@ -411,7 +412,7 @@ export function parseC4(
         // Otherwise it's a deployment node (possibly with pipe metadata)
         const segments = trimmed.split('|').map((s) => s.trim());
         const nodeName = segments[0];
-        const metadata = parsePipeMetadata(segments, aliasMap);
+        const metadata = parsePipeMetadata(segments, aliasMap, () => pushError(lineNumber, MULTIPLE_PIPE_WARNING, 'warning'));
         const shape = inferC4Shape(nodeName, metadata.tech ?? metadata.technology);
 
         const dNode: C4DeploymentNode = {
@@ -598,7 +599,7 @@ export function parseC4(
         namePart = namePart.substring(0, isAMatch.index!).trim();
       }
 
-      const metadata = parsePipeMetadata(segments, aliasMap);
+      const metadata = parsePipeMetadata(segments, aliasMap, () => pushError(lineNumber, MULTIPLE_PIPE_WARNING, 'warning'));
 
       // Determine shape: explicit > inference
       const shape =

package/src/d3.ts

@@ -181,7 +181,7 @@ import { getSeriesColors } from './palettes';
 import { mix } from './palettes/color-utils';
 import type { DgmoError } from './diagnostics';
 import { makeDgmoError, formatDgmoError, suggest } from './diagnostics';
-import { collectIndentedValues, extractColor, parsePipeMetadata } from './utils/parsing';
+import { collectIndentedValues, extractColor, parsePipeMetadata, MULTIPLE_PIPE_WARNING } from './utils/parsing';
 import { matchTagBlockHeading, validateTagValues, resolveTagColor } from './utils/tag-groups';
 import type { TagGroup } from './utils/tag-groups';
 import {
@@ -545,9 +545,9 @@ export function parseVisualization(content: string, palette?: PaletteColors): Pa
         continue;
       }
 
-      // Timeline marker lines: marker YYYY: Label (color)
+      // Timeline marker lines: marker: YYYY Label (color)
       const markerMatch = line.match(
-        /^marker\s+(\d{4}(?:-\d{2})?(?:-\d{2})?)\s*:\s*(.+?)(?:\s*\(([^)]+)\))?\s*$/
+        /^marker:\s+(\d{4}(?:-\d{2})?(?:-\d{2})?)\s+(.+?)(?:\s*\(([^)]+)\))?\s*$/
       );
       if (markerMatch) {
         const colorAnnotation = markerMatch[3]?.trim() || null;
@@ -579,7 +579,7 @@ export function parseVisualization(content: string, palette?: PaletteColors): Pa
         const endDate = addDurationToDate(startDate, amount, unit);
         const segments = durationMatch[5].split('|');
         const metadata = segments.length > 1
-          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap)
+          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING))
           : {};
         result.timelineEvents.push({
           date: startDate,
@@ -600,7 +600,7 @@ export function parseVisualization(content: string, palette?: PaletteColors): Pa
       if (rangeMatch) {
         const segments = rangeMatch[4].split('|');
         const metadata = segments.length > 1
-          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap)
+          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING))
           : {};
         result.timelineEvents.push({
           date: rangeMatch[1],
@@ -621,7 +621,7 @@ export function parseVisualization(content: string, palette?: PaletteColors): Pa
       if (pointMatch) {
         const segments = pointMatch[2].split('|');
         const metadata = segments.length > 1
-          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap)
+          ? parsePipeMetadata(['', ...segments.slice(1)], timelineAliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING))
           : {};
         result.timelineEvents.push({
           date: pointMatch[1],
@@ -6095,10 +6095,8 @@ export async function renderForExport(
 
     const effectivePalette = await resolveExportPalette(theme, palette);
     const ganttParsed = parseGantt(content, effectivePalette);
-    if (ganttParsed.error) return '';
-
     const resolved = calculateSchedule(ganttParsed);
-    if (resolved.error || resolved.tasks.length === 0) return '';
+    if (resolved.tasks.length === 0) return '';
 
     const EXPORT_W = 1200;
     const EXPORT_H = 800;

package/src/er/parser.ts

@@ -1,7 +1,7 @@
 import { resolveColor } from '../colors';
 import type { PaletteColors } from '../palettes';
 import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
-import { measureIndent, extractColor, parsePipeMetadata } from '../utils/parsing';
+import { measureIndent, extractColor, parsePipeMetadata, MULTIPLE_PIPE_WARNING } from '../utils/parsing';
 import { matchTagBlockHeading, validateTagValues } from '../utils/tag-groups';
 import type { TagGroup } from '../utils/tag-groups';
 import type {
@@ -350,8 +350,10 @@ export function parseERDiagram(
       // Parse pipe metadata: TableName(color) | key: value, key2: value2
       const pipeStr = tableDecl[3]?.trim();
       if (pipeStr) {
-        // parsePipeMetadata skips index 0 (name segment), so prepend empty
-        const meta = parsePipeMetadata(['', pipeStr], aliasMap);
+        // Split on additional pipes (treated as commas) and warn if found
+        const pipeSegments = pipeStr.split('|');
+        const meta = parsePipeMetadata(['', ...pipeSegments], aliasMap,
+          () => result.diagnostics.push(makeDgmoError(lineNumber, MULTIPLE_PIPE_WARNING, 'warning')));
         Object.assign(table.metadata, meta);
       }
 

package/src/gantt/calculator.ts

@@ -119,11 +119,8 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
     for (const dep of task.dependencies) {
       const resolved = resolveTaskName(dep.targetName, allTasks);
       if (isResolverError(resolved)) {
-        if (resolved.kind === 'ambiguous') {
-          return fail(dep.lineNumber, `\`-> ${dep.targetName}\` — ${resolved.message}`);
-        } else {
-          return fail(dep.lineNumber, `\`-> ${dep.targetName}\` — ${resolved.message}`);
-        }
+        warn(dep.lineNumber, `\`-> ${dep.targetName}\` — ${resolved.message}`);
+        continue;
       }
 
       // The dependency means: target starts after source
@@ -146,15 +143,34 @@ export function calculateSchedule(parsed: ParsedGantt): ResolvedSchedule {
 
   // ── Topological sort with cycle detection ───────────────
 
-  const sortedIds = topologicalSort(taskMap);
+  let sortedIds = topologicalSort(taskMap);
   if (!sortedIds) {
-    // Find cycle for error message
+    // Find cycle, warn, and break it by removing one explicit dep edge
     const cycle = findCycle(taskMap);
     const cycleStr = cycle.map(id => taskMap.get(id)!.task.label).join(' → ');
-    return fail(
+    warn(
       taskMap.get(cycle[0])!.task.lineNumber,
-      `Circular dependency detected: ${cycleStr}`,
+      `Circular dependency detected: ${cycleStr}. The cycle-creating dependency was dropped.`,
     );
+
+    // Remove the last edge in the cycle to break it
+    // (prefer removing explicit -> deps over implicit sequential ones)
+    breakCycle(cycle, taskMap, depOffsetMap);
+
+    // Retry — if still cyclic after breaking, keep breaking until resolved
+    sortedIds = topologicalSort(taskMap);
+    let safety = 10;
+    while (!sortedIds && safety-- > 0) {
+      const nextCycle = findCycle(taskMap);
+      if (nextCycle.length === 0) break;
+      breakCycle(nextCycle, taskMap, depOffsetMap);
+      sortedIds = topologicalSort(taskMap);
+    }
+
+    if (!sortedIds) {
+      // Truly unresolvable — fall back to task insertion order
+      sortedIds = [...taskMap.keys()];
+    }
   }
 
   // ── Forward pass: resolve dates ─────────────────────────
@@ -521,6 +537,30 @@ function findCycle(taskMap: Map<string, TaskNode>): string[] {
   }
 }
 
+/**
+ * Break a cycle by removing the last edge. The cycle array is [A, B, ..., A]
+ * (starts and ends with the same node). We remove A's predecessor edge to
+ * the penultimate node, which breaks the cycle.
+ */
+function breakCycle(
+  cycle: string[],
+  taskMap: Map<string, TaskNode>,
+  depOffsetMap: Map<string, Offset>,
+): void {
+  if (cycle.length < 3) return; // need at least [A, B, A]
+  // Remove the edge from second-to-last → first (i.e. the edge that closes the cycle)
+  const fromId = cycle[cycle.length - 2];
+  const toId = cycle[0];
+  const toNode = taskMap.get(toId);
+  if (toNode) {
+    const idx = toNode.predecessors.indexOf(fromId);
+    if (idx !== -1) {
+      toNode.predecessors.splice(idx, 1);
+      depOffsetMap.delete(`${fromId}->${toId}`);
+    }
+  }
+}
+
 // ── Critical path ───────────────────────────────────────────
 
 function computeCriticalPath(
@@ -641,10 +681,10 @@ function buildResolvedGroups(
         if (!resolved?.startDate || !resolved?.endDate) continue;
         if (resolved.startDate.getTime() < minStart) minStart = resolved.startDate.getTime();
         if (resolved.endDate.getTime() > maxEnd) maxEnd = resolved.endDate.getTime();
+        const dur = resolved.endDate.getTime() - resolved.startDate.getTime();
+        totalDuration += dur;
         if (task.progress !== null) {
-          const dur = resolved.endDate.getTime() - resolved.startDate.getTime();
           totalProgress += task.progress * dur;
-          totalDuration += dur;
           hasProgress = true;
         }
       }

package/src/gantt/parser.ts

@@ -6,7 +6,7 @@ import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
 import type { DgmoError } from '../diagnostics';
 import type { TagGroup, TagEntry } from '../utils/tag-groups';
 import { matchTagBlockHeading } from '../utils/tag-groups';
-import { measureIndent, extractColor, parsePipeMetadata } from '../utils/parsing';
+import { measureIndent, extractColor, parsePipeMetadata, MULTIPLE_PIPE_WARNING } from '../utils/parsing';
 import { parseOffset } from '../utils/duration';
 import type { PaletteColors } from '../palettes';
 import { resolveColor } from '../colors';
@@ -51,8 +51,8 @@ const COMMENT_RE = /^\/\//;
 /** Era: `era YYYY[-MM[-DD]] -> YYYY[-MM[-DD]]: Label (color?)` */
 const ERA_RE = /^era\s+(\d{4}(?:-\d{2}(?:-\d{2})?)?)\s*->\s*(\d{4}(?:-\d{2}(?:-\d{2})?)?)\s*:\s*(.+)$/i;
 
-/** Marker: `marker YYYY[-MM[-DD]]: Label (color?)` */
-const MARKER_RE = /^marker\s+(\d{4}(?:-\d{2}(?:-\d{2})?)?)\s*:\s*(.+)$/i;
+/** Marker: `marker: YYYY[-MM[-DD]] Label (color?)` */
+const MARKER_RE = /^marker:\s+(\d{4}(?:-\d{2}(?:-\d{2})?)?)\s+(.+)$/i;
 
 /** Holiday date: `2024-01-15: Label` */
 const HOLIDAY_DATE_RE = /^(\d{4}-\d{2}-\d{2}):\s*(.+)$/;
@@ -123,6 +123,11 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     diagnostics.push(makeDgmoError(line, message, 'warning'));
   };
 
+  /** Red squiggly but parsing continues — line is wrong, rest of chart is fine */
+  const softError = (line: number, message: string): void => {
+    diagnostics.push(makeDgmoError(line, message, 'error'));
+  };
+
   // ── Alias map for pipe metadata ─────────────────────────
 
   const aliasMap = new Map<string, string>();
@@ -300,10 +305,10 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         let offset: Offset | undefined;
 
         if (depParts.length > 1) {
-          const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap);
+          const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING));
           if (meta.lag || meta.lead) {
             const key = meta.lag ? 'lag' : 'lead';
-            return fail(lineNumber, `Unknown keyword "${key}". Use "offset: ${meta[key]}" instead.`);
+            softError(lineNumber, `Unknown keyword "${key}". Use "offset: ${meta[key]}" instead.`);
           }
           if (meta.offset) {
             const raw = meta.offset;
@@ -470,7 +475,8 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     if (groupMatch) {
       // Validate nesting: group under a task is invalid
       if (blockStack.length > 0 && blockStack[blockStack.length - 1].containerType === 'task') {
-        return fail(lineNumber, `Cannot nest a group inside a task. Groups must be inside other groups or parallel blocks.`);
+        softError(lineNumber, `Cannot nest a group inside a task. Groups must be inside other groups or parallel blocks.`);
+        continue;
       }
 
       const afterBrackets = groupMatch[2].trim();
@@ -480,11 +486,12 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       let metadata: Record<string, string> = {};
       let color: string | null = null;
 
+      const pipeWarn = () => warn(lineNumber, MULTIPLE_PIPE_WARNING);
       if (segments.length > 0 && segments[0].trim()) {
         // Check if first segment after brackets is pipe metadata
-        metadata = parsePipeMetadata(['', ...segments], aliasMap);
+        metadata = parsePipeMetadata(['', ...segments], aliasMap, pipeWarn);
       } else if (segments.length > 1) {
-        metadata = parsePipeMetadata(['', ...segments.slice(1)], aliasMap);
+        metadata = parsePipeMetadata(['', ...segments.slice(1)], aliasMap, pipeWarn);
       }
 
       // Extract color from group name if present
@@ -522,7 +529,6 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       const labelRaw = timelineDurMatch[5];
 
       const task = makeTask(labelRaw, { amount, unit }, uncertain, lineNumber, startDate);
-      if (result.error) return result;
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
       lastTaskNode = taskNode as GanttNode & { kind: 'task' };
@@ -540,7 +546,6 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       const labelRaw = durMatch[4];
 
       const task = makeTask(labelRaw, { amount, unit }, uncertain, lineNumber);
-      if (result.error) return result;
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
       lastTaskNode = taskNode as GanttNode & { kind: 'task' };
@@ -559,7 +564,6 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
         lineNumber,
         explicitDateMatch[1],
       );
-      if (result.error) return result;
       // Explicit date tasks with no duration are milestones
       const taskNode: GanttNode = { kind: 'task', ...task };
       currentContainer().push(taskNode);
@@ -574,7 +578,8 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     if (depMatch) {
       // Dependency without a task context is an error
       if (!lastTaskNode) {
-        return fail(lineNumber, `Dependency "-> ${depMatch[1]}" must be indented under a task.`);
+        softError(lineNumber, `Dependency "-> ${depMatch[1]}" must be indented under a task.`);
+        continue;
       }
       // This happens when the dep is at the same indent as the task
       const depParts = depMatch[1].split('|');
@@ -582,7 +587,7 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       let offset: Offset | undefined;
 
       if (depParts.length > 1) {
-        const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap);
+        const meta = parsePipeMetadata(['', ...depParts.slice(1)], aliasMap, () => warn(lineNumber, MULTIPLE_PIPE_WARNING));
         if (meta.lag || meta.lead) {
           const key = meta.lag ? 'lag' : 'lead';
           warn(lineNumber, `"${key}" is deprecated — use "offset: ${meta[key]}" instead.${key === 'lead' ? ' Negate the value for lead behavior: "offset: -...".' : ''}`);
@@ -606,7 +611,8 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
 
     // ── Bare label = parse error ──────────────────────────
 
-    return fail(lineNumber, `Expected duration (e.g., "10d: Task"), group brackets (e.g., "[Group]"), or keyword. Got: "${line}"`);
+    softError(lineNumber, `Expected duration (e.g., "10d: Task"), group brackets (e.g., "[Group]"), or keyword. Got: "${line}"`);
+    continue;
   }
 
   // ── Finalize ────────────────────────────────────────────
@@ -640,12 +646,12 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
 
     // Check for reserved keyword
     if (label.toLowerCase() === 'parallel') {
-      fail(ln, `"parallel" is a reserved keyword and cannot be used as a task name.`);
+      softError(ln, `"parallel" is a reserved keyword and cannot be used as a task name.`);
     }
 
     // Parse pipe metadata
     const metadata = segments.length > 1
-      ? parsePipeMetadata(segments, aliasMap)
+      ? parsePipeMetadata(segments, aliasMap, () => warn(ln, MULTIPLE_PIPE_WARNING))
       : {};
 
     // Extract progress from metadata or shorthand
@@ -654,9 +660,9 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
       progress = parseFloat(metadata.progress);
       delete metadata.progress;
     }
-    // Check for progress shorthand: `| 80%`
-    for (let j = 1; j < segments.length; j++) {
-      const seg = segments[j].trim();
+    // Check for progress shorthand: `| 80%` or `| t:X, 80%`
+    for (const part of segments.slice(1).join(',').split(',')) {
+      const seg = part.trim();
       const progressMatch = seg.match(/^(\d+)%$/);
       if (progressMatch) {
         progress = parseInt(progressMatch[1], 10);
@@ -666,7 +672,7 @@ export function parseGantt(content: string, palette?: PaletteColors): ParsedGant
     // Reject lag/lead — use offset instead
     if (metadata.lag || metadata.lead) {
       const key = metadata.lag ? 'lag' : 'lead';
-      fail(ln, `Unknown keyword "${key}". Use "offset: ${metadata[key]}" instead.`);
+      softError(ln, `Unknown keyword "${key}". Use "offset: ${metadata[key]}" instead.`);
     }
 
     // Extract task-level offset from metadata