@diagrammo/dgmo 0.2.21 → 0.2.23

package/src/initiative-status/layout.ts

@@ -0,0 +1,217 @@
+// ============================================================
+// Initiative Status Diagram — Layout (dagre-based)
+// ============================================================
+
+import dagre from '@dagrejs/dagre';
+import type { ParsedInitiativeStatus, ISEdge, InitiativeStatus } from './types';
+
+export interface ISLayoutNode {
+  label: string;
+  status: import('./types').InitiativeStatus;
+  shape: import('../sequence/parser').ParticipantType;
+  lineNumber: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface ISLayoutEdge {
+  source: string;
+  target: string;
+  label?: string;
+  status: import('./types').InitiativeStatus;
+  lineNumber: number;
+  points: { x: number; y: number }[];
+}
+
+export interface ISLayoutGroup {
+  label: string;
+  status: InitiativeStatus;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  lineNumber: number;
+}
+
+export interface ISLayoutResult {
+  nodes: ISLayoutNode[];
+  edges: ISLayoutEdge[];
+  groups: ISLayoutGroup[];
+  width: number;
+  height: number;
+}
+
+// Roll up child statuses: worst (least-progressed) wins
+// Priority: todo > wip > done > na > null
+const STATUS_PRIORITY: Record<string, number> = { todo: 3, wip: 2, done: 1, na: 0 };
+
+function rollUpStatus(members: ISLayoutNode[]): InitiativeStatus {
+  let worst: InitiativeStatus = null;
+  let worstPri = -1;
+  for (const m of members) {
+    const pri = m.status ? (STATUS_PRIORITY[m.status] ?? -1) : -1;
+    if (pri > worstPri) {
+      worstPri = pri;
+      worst = m.status;
+    }
+  }
+  return worst;
+}
+
+// Golden ratio fixed-size nodes — all boxes are identical dimensions
+const PHI = 1.618;
+const NODE_HEIGHT = 60;
+const NODE_WIDTH = Math.round(NODE_HEIGHT * PHI); // ~97
+const GROUP_PADDING = 20;
+
+export function layoutInitiativeStatus(parsed: ParsedInitiativeStatus): ISLayoutResult {
+  if (parsed.nodes.length === 0) {
+    return { nodes: [], edges: [], groups: [], width: 0, height: 0 };
+  }
+
+  const hasGroups = parsed.groups.length > 0;
+  const g = new dagre.graphlib.Graph({ multigraph: true, compound: hasGroups });
+  g.setGraph({
+    rankdir: 'LR',
+    nodesep: 80,
+    ranksep: 160,
+    edgesep: 40,
+  });
+  g.setDefaultEdgeLabel(() => ({}));
+
+  // Add group parent nodes
+  for (const group of parsed.groups) {
+    const groupId = `__group_${group.label}`;
+    g.setNode(groupId, { label: group.label, clusterLabelPos: 'top' });
+  }
+
+  // Add nodes — all same size (golden ratio)
+  for (const node of parsed.nodes) {
+    g.setNode(node.label, { label: node.label, width: NODE_WIDTH, height: NODE_HEIGHT });
+  }
+
+  // Assign children to group parents
+  for (const group of parsed.groups) {
+    const groupId = `__group_${group.label}`;
+    for (const nodeLabel of group.nodeLabels) {
+      if (g.hasNode(nodeLabel)) {
+        g.setParent(nodeLabel, groupId);
+      }
+    }
+  }
+
+  // Add edges — use multigraph names to allow duplicates between same pair
+  for (let i = 0; i < parsed.edges.length; i++) {
+    const edge = parsed.edges[i];
+    g.setEdge(edge.source, edge.target, { label: edge.label ?? '' }, `e${i}`);
+  }
+
+  // Compute layout
+  dagre.layout(g);
+
+  // Extract positioned nodes — dagre owns within-rank ordering
+  // (crossing minimization). We don't reorder post-layout because
+  // that would desync edge waypoints from node positions.
+  const layoutNodes: ISLayoutNode[] = parsed.nodes.map((node) => {
+    const pos = g.node(node.label);
+    return {
+      label: node.label,
+      status: node.status,
+      shape: node.shape,
+      lineNumber: node.lineNumber,
+      x: pos.x,
+      y: pos.y,
+      width: pos.width,
+      height: pos.height,
+    };
+  });
+
+  // Extract edge waypoints
+  const layoutEdges: ISLayoutEdge[] = parsed.edges.map((edge, i) => {
+    const edgeData = g.edge(edge.source, edge.target, `e${i}`);
+    return {
+      source: edge.source,
+      target: edge.target,
+      label: edge.label,
+      status: edge.status,
+      lineNumber: edge.lineNumber,
+      points: edgeData?.points ?? [],
+    };
+  });
+
+  // Compute group bounding boxes from member positions
+  const layoutGroups: ISLayoutGroup[] = [];
+  if (parsed.groups.length > 0) {
+    const nodeMap = new Map(layoutNodes.map((n) => [n.label, n]));
+    for (const group of parsed.groups) {
+      const members = group.nodeLabels
+        .map((label) => nodeMap.get(label))
+        .filter((n): n is ISLayoutNode => n !== undefined);
+
+      if (members.length === 0) continue;
+
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+
+      for (const member of members) {
+        const left = member.x - member.width / 2;
+        const right = member.x + member.width / 2;
+        const top = member.y - member.height / 2;
+        const bottom = member.y + member.height / 2;
+        if (left < minX) minX = left;
+        if (right > maxX) maxX = right;
+        if (top < minY) minY = top;
+        if (bottom > maxY) maxY = bottom;
+      }
+
+      layoutGroups.push({
+        label: group.label,
+        status: rollUpStatus(members),
+        x: minX - GROUP_PADDING,
+        y: minY - GROUP_PADDING,
+        width: maxX - minX + GROUP_PADDING * 2,
+        height: maxY - minY + GROUP_PADDING * 2,
+        lineNumber: group.lineNumber,
+      });
+    }
+  }
+
+  // Compute total dimensions
+  let totalWidth = 0;
+  let totalHeight = 0;
+  for (const node of layoutNodes) {
+    const right = node.x + node.width / 2;
+    const bottom = node.y + node.height / 2;
+    if (right > totalWidth) totalWidth = right;
+    if (bottom > totalHeight) totalHeight = bottom;
+  }
+  // Also consider group bounds
+  for (const group of layoutGroups) {
+    const right = group.x + group.width;
+    const bottom = group.y + group.height;
+    if (right > totalWidth) totalWidth = right;
+    if (bottom > totalHeight) totalHeight = bottom;
+  }
+  // Also consider edge control points
+  for (const edge of layoutEdges) {
+    for (const pt of edge.points) {
+      if (pt.x > totalWidth) totalWidth = pt.x;
+      if (pt.y > totalHeight) totalHeight = pt.y;
+    }
+  }
+  // Add margin
+  totalWidth += 40;
+  totalHeight += 40;
+
+  return {
+    nodes: layoutNodes,
+    edges: layoutEdges,
+    groups: layoutGroups,
+    width: totalWidth,
+    height: totalHeight,
+  };
+}

package/src/initiative-status/parser.ts

@@ -0,0 +1,246 @@
+// ============================================================
+// Initiative Status Diagram — Parser
+// ============================================================
+
+import { makeDgmoError, formatDgmoError, suggest } from '../diagnostics';
+import type { DgmoError } from '../diagnostics';
+import type {
+  ParsedInitiativeStatus,
+  ISNode,
+  ISEdge,
+  ISGroup,
+  InitiativeStatus,
+} from './types';
+import { VALID_STATUSES } from './types';
+import { inferParticipantType } from '../sequence/participant-inference';
+
+// ============================================================
+// Heuristic — does this content look like an initiative-status diagram?
+// ============================================================
+
+/**
+ * Returns true if the content looks like an initiative-status diagram.
+ * Detects `->` arrows combined with `| done/wip/todo/na` status markers.
+ */
+export function looksLikeInitiativeStatus(content: string): boolean {
+  const lines = content.split('\n');
+  let hasArrow = false;
+  let hasStatus = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || 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;
+    if (hasArrow && hasStatus) return true;
+  }
+  return false;
+}
+
+// ============================================================
+// Parser
+// ============================================================
+
+function parseStatus(raw: string, line: number, diagnostics: DgmoError[]): InitiativeStatus {
+  const trimmed = raw.trim().toLowerCase();
+  if (!trimmed) return null;
+  if (VALID_STATUSES.includes(trimmed)) return trimmed as InitiativeStatus;
+
+  // Unknown status — emit warning with suggestion
+  const hint = suggest(trimmed, VALID_STATUSES);
+  const msg = `Unknown status "${raw.trim()}"${hint ? `. ${hint}` : ''}`;
+  diagnostics.push(makeDgmoError(line, msg, 'warning'));
+  return null;
+}
+
+export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
+  const result: ParsedInitiativeStatus = {
+    type: 'initiative-status',
+    title: null,
+    titleLineNumber: null,
+    nodes: [],
+    edges: [],
+    groups: [],
+    options: {},
+    diagnostics: [],
+    error: undefined,
+  };
+
+  const lines = content.split('\n');
+  const nodeLabels = new Set<string>();
+  let currentGroup: ISGroup | null = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const lineNum = i + 1; // 1-based
+    const raw = lines[i];
+    const trimmed = raw.trim();
+
+    // Skip blanks and comments
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+
+    // chart: header
+    const chartMatch = trimmed.match(/^chart\s*:\s*(.+)/i);
+    if (chartMatch) {
+      const chartType = chartMatch[1].trim().toLowerCase();
+      if (chartType !== 'initiative-status') {
+        const diag = makeDgmoError(lineNum, `Expected chart type "initiative-status", got "${chartType}"`);
+        result.diagnostics.push(diag);
+        result.error = formatDgmoError(diag);
+        return result;
+      }
+      continue;
+    }
+
+    // title: header
+    const titleMatch = trimmed.match(/^title\s*:\s*(.+)/i);
+    if (titleMatch) {
+      result.title = titleMatch[1].trim();
+      result.titleLineNumber = lineNum;
+      continue;
+    }
+
+    // Group header: [Group Name]
+    const groupMatch = trimmed.match(/^\[(.+)\]\s*$/);
+    if (groupMatch) {
+      // Close previous group
+      if (currentGroup) {
+        result.groups.push(currentGroup);
+      }
+      currentGroup = { label: groupMatch[1], nodeLabels: [], lineNumber: lineNum };
+      continue;
+    }
+
+    // Non-indented line closes the current group
+    const isIndented = raw.length > 0 && raw !== trimmed && /^\s/.test(raw);
+    if (!isIndented && currentGroup) {
+      result.groups.push(currentGroup);
+      currentGroup = null;
+    }
+
+    // Edge: contains `->`
+    if (trimmed.includes('->')) {
+      const edge = parseEdgeLine(trimmed, lineNum, result.diagnostics);
+      if (edge) result.edges.push(edge);
+      continue;
+    }
+
+    // Node: everything else
+    const node = parseNodeLine(trimmed, lineNum, result.diagnostics);
+    if (node) {
+      if (nodeLabels.has(node.label)) {
+        result.diagnostics.push(
+          makeDgmoError(lineNum, `Duplicate node "${node.label}"`, 'warning')
+        );
+      } else {
+        nodeLabels.add(node.label);
+      }
+      result.nodes.push(node);
+      // Add to current group if indented
+      if (currentGroup && isIndented) {
+        currentGroup.nodeLabels.push(node.label);
+      }
+    }
+  }
+
+  // Close any trailing group
+  if (currentGroup) {
+    result.groups.push(currentGroup);
+  }
+
+  // Validate edges reference declared nodes
+  for (const edge of result.edges) {
+    if (!nodeLabels.has(edge.source)) {
+      result.diagnostics.push(
+        makeDgmoError(edge.lineNumber, `Edge source "${edge.source}" is not a declared node`, 'warning')
+      );
+      // Auto-create an implicit node
+      if (!result.nodes.some((n) => n.label === edge.source)) {
+        result.nodes.push({ label: edge.source, status: null, shape: inferParticipantType(edge.source), lineNumber: edge.lineNumber });
+        nodeLabels.add(edge.source);
+      }
+    }
+    if (!nodeLabels.has(edge.target)) {
+      result.diagnostics.push(
+        makeDgmoError(edge.lineNumber, `Edge target "${edge.target}" is not a declared node`, 'warning')
+      );
+      if (!result.nodes.some((n) => n.label === edge.target)) {
+        result.nodes.push({ label: edge.target, status: null, shape: inferParticipantType(edge.target), lineNumber: edge.lineNumber });
+        nodeLabels.add(edge.target);
+      }
+    }
+  }
+
+  return result;
+}
+
+// ============================================================
+// Line parsers
+// ============================================================
+
+function parseNodeLine(
+  trimmed: string,
+  lineNum: number,
+  diagnostics: DgmoError[]
+): ISNode | null {
+  // Format: <label> | <status>
+  // or just: <label>
+  const pipeIdx = trimmed.lastIndexOf('|');
+  if (pipeIdx >= 0) {
+    const label = trimmed.slice(0, pipeIdx).trim();
+    const statusRaw = trimmed.slice(pipeIdx + 1).trim();
+    if (!label) return null;
+    const status = parseStatus(statusRaw, lineNum, diagnostics);
+    return { label, status, shape: inferParticipantType(label), lineNumber: lineNum };
+  }
+  return { label: trimmed, status: null, shape: inferParticipantType(trimmed), lineNumber: lineNum };
+}
+
+function parseEdgeLine(
+  trimmed: string,
+  lineNum: number,
+  diagnostics: DgmoError[]
+): ISEdge | null {
+  // Format: <source> -> <target>: <label> | <status>
+  // or:     <source> -> <target> | <status>
+  // or:     <source> -> <target>: <label>
+  // or:     <source> -> <target>
+
+  const arrowIdx = trimmed.indexOf('->');
+  if (arrowIdx < 0) return null;
+
+  const source = trimmed.slice(0, arrowIdx).trim();
+  let rest = trimmed.slice(arrowIdx + 2).trim();
+
+  if (!source || !rest) {
+    diagnostics.push(makeDgmoError(lineNum, 'Edge is missing source or target'));
+    return null;
+  }
+
+  // Extract status from end (after last |)
+  let status: InitiativeStatus = null;
+  const lastPipe = rest.lastIndexOf('|');
+  if (lastPipe >= 0) {
+    const statusRaw = rest.slice(lastPipe + 1).trim();
+    status = parseStatus(statusRaw, lineNum, diagnostics);
+    rest = rest.slice(0, lastPipe).trim();
+  }
+
+  // Extract target and optional label (target: label)
+  let target: string;
+  let label: string | undefined;
+  const colonIdx = rest.indexOf(':');
+  if (colonIdx >= 0) {
+    target = rest.slice(0, colonIdx).trim();
+    label = rest.slice(colonIdx + 1).trim() || undefined;
+  } else {
+    target = rest.trim();
+  }
+
+  if (!target) {
+    diagnostics.push(makeDgmoError(lineNum, 'Edge is missing target'));
+    return null;
+  }
+
+  return { source, target, label, status, lineNumber: lineNum };
+}