@diagrammo/dgmo 0.6.2 → 0.7.0

package/src/gantt/resolver.ts

@@ -0,0 +1,144 @@
+// ============================================================
+// Gantt Dot-Notation Task Resolver
+// ============================================================
+//
+// Resolves `-> TargetName` dependency references to actual tasks.
+// Implements greedy right-to-left dot splitting for disambiguation.
+
+import type { GanttTask, GanttNode } from './types';
+
+export interface ResolverMatch {
+  task: GanttTask;
+}
+
+export interface ResolverError {
+  kind: 'not_found' | 'ambiguous';
+  message: string;
+}
+
+export type ResolverResult = ResolverMatch | ResolverError;
+
+export function isResolverError(r: ResolverResult): r is ResolverError {
+  return 'kind' in r;
+}
+
+/**
+ * Collect all tasks from a tree of GanttNodes, annotating each with its
+ * fully qualified group path (e.g., ["Backend", "API"]).
+ */
+export function collectTasks(nodes: GanttNode[]): GanttTask[] {
+  const tasks: GanttTask[] = [];
+  function walk(children: GanttNode[]) {
+    for (const node of children) {
+      if (node.kind === 'task') {
+        tasks.push(node);
+      } else if (node.kind === 'group' || node.kind === 'parallel') {
+        walk(node.children);
+      }
+    }
+  }
+  walk(nodes);
+  return tasks;
+}
+
+/**
+ * Resolve a dependency target name to a task.
+ *
+ * Resolution strategy (greedy right-to-left):
+ * 1. Try the full string as an exact task label match
+ * 2. If no match, split at the last dot → group prefix + task label
+ * 3. Recurse for deeper paths
+ *
+ * Returns a match or an error with helpful suggestions.
+ */
+export function resolveTaskName(
+  name: string,
+  allTasks: GanttTask[],
+): ResolverResult {
+  const trimmed = name.trim();
+
+  // 1. Try exact label match (no dots involved)
+  const exactMatches = allTasks.filter(t => t.label === trimmed);
+  if (exactMatches.length === 1) {
+    return { task: exactMatches[0] };
+  }
+  if (exactMatches.length > 1) {
+    // Multiple tasks with same name — need disambiguation
+    const suggestions = exactMatches.map(t =>
+      t.groupPath.length > 0 ? `${t.groupPath.join('.')}.${t.label}` : t.label
+    );
+    return {
+      kind: 'ambiguous',
+      message: `Multiple tasks match "${trimmed}". Did you mean ${suggestions.map(s => `\`${s}\``).join(' or ')}?`,
+    };
+  }
+
+  // 2. Try dot-notation: split at last dot (greedy right-to-left)
+  const lastDotIdx = trimmed.lastIndexOf('.');
+  if (lastDotIdx > 0) {
+    const groupPrefix = trimmed.substring(0, lastDotIdx);
+    const taskLabel = trimmed.substring(lastDotIdx + 1);
+
+    // Find tasks whose label matches and whose group path ends with the prefix
+    const matches = allTasks.filter(t => {
+      if (t.label !== taskLabel) return false;
+      return matchesGroupPath(t.groupPath, groupPrefix);
+    });
+
+    if (matches.length === 1) {
+      return { task: matches[0] };
+    }
+    if (matches.length > 1) {
+      const suggestions = matches.map(t =>
+        t.groupPath.length > 0 ? `${t.groupPath.join('.')}.${t.label}` : t.label
+      );
+      return {
+        kind: 'ambiguous',
+        message: `Multiple tasks match "${trimmed}". Did you mean ${suggestions.map(s => `\`${s}\``).join(' or ')}?`,
+      };
+    }
+
+    // Try further left splits (for dots in group names)
+    // e.g., "U.S. Operations.Task A" — last dot split tried "U.S. Operations" + "Task A"
+    // Now try "U.S." + "Operations.Task A" — but that doesn't help.
+    // The greedy approach handles this: "U.S. Operations" is the group name.
+    // If the group name itself contains dots, the last dot split already tried the correct split.
+  }
+
+  // 3. No match found — try case-insensitive as a fallback for suggestions
+  const caseInsensitive = allTasks.filter(t =>
+    t.label.toLowerCase() === trimmed.toLowerCase()
+  );
+  if (caseInsensitive.length > 0) {
+    return {
+      kind: 'not_found',
+      message: `No task found with name "${trimmed}". Did you mean "${caseInsensitive[0].label}" (case mismatch)?`,
+    };
+  }
+
+  return {
+    kind: 'not_found',
+    message: `No task found with name "${trimmed}".`,
+  };
+}
+
+/**
+ * Check if a task's group path matches a dot-separated prefix.
+ * The prefix can be a single group name or a dot-separated path.
+ * Matching is done from the end of the group path.
+ *
+ * Example: groupPath = ["Backend", "API"], prefix = "Backend" → true
+ * Example: groupPath = ["Backend", "API"], prefix = "API" → true
+ * Example: groupPath = ["Backend", "API"], prefix = "Backend.API" → true
+ */
+function matchesGroupPath(groupPath: string[], prefix: string): boolean {
+  // Simple case: prefix is a single segment
+  if (!prefix.includes('.')) {
+    return groupPath.some(g => g === prefix);
+  }
+
+  // Multi-segment prefix: try matching from the start of the group path
+  const pathStr = groupPath.join('.');
+  // Check if the full prefix matches any contiguous section of the path
+  return pathStr === prefix || pathStr.endsWith('.' + prefix) || pathStr.startsWith(prefix + '.') || pathStr.includes('.' + prefix + '.');
+}

package/src/gantt/types.ts

@@ -0,0 +1,168 @@
+// ============================================================
+// Gantt Chart Types
+// ============================================================
+
+import type { DgmoError } from '../diagnostics';
+import type { TagGroup } from '../utils/tag-groups';
+
+// ── Duration ────────────────────────────────────────────────
+
+/** Calendar units: d (days), w (weeks), m (months), q (quarters), y (years). bd = business days. */
+export type DurationUnit = 'd' | 'bd' | 'w' | 'm' | 'q' | 'y';
+
+export interface Duration {
+  amount: number;
+  unit: DurationUnit;
+}
+
+export interface Offset {
+  duration: Duration;
+  direction: 1 | -1;
+}
+
+// ── Parsed Elements ─────────────────────────────────────────
+
+export interface GanttDependency {
+  targetName: string; // raw string from `-> X` or `-> Group.X`
+  offset?: Offset;
+  lineNumber: number;
+}
+
+export interface GanttTask {
+  id: string; // unique, generated during parse (e.g. "group:taskIdx")
+  label: string;
+  duration: Duration | null; // null for explicit-date-only tasks
+  explicitStart?: string; // YYYY-MM-DD from `2024-01-15 -> 30d:` or `2024-01-15:`
+  uncertain: boolean;
+  progress: number | null; // 0-100 or null
+  offset?: Offset; // task-level offset: shifts start date forward (+) or backward (-)
+  dependencies: GanttDependency[];
+  metadata: Record<string, string>; // tag values from pipe metadata
+  lineNumber: number;
+  groupPath: string[]; // e.g. ["Backend", "API"] for nested groups
+  comment?: string; // accumulated // comment lines
+}
+
+export interface GanttGroup {
+  name: string;
+  color: string | null;
+  metadata: Record<string, string>;
+  lineNumber: number;
+  children: GanttNode[];
+}
+
+export interface GanttParallelBlock {
+  kind: 'parallel';
+  lineNumber: number;
+  children: GanttNode[];
+}
+
+/** A node in the gantt tree: either a task, group, or parallel block. */
+export type GanttNode =
+  | ({ kind: 'task' } & GanttTask)
+  | ({ kind: 'group' } & GanttGroup)
+  | GanttParallelBlock;
+
+// ── Holidays ────────────────────────────────────────────────
+
+export type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+
+export interface HolidayDate {
+  date: string; // YYYY-MM-DD
+  label: string;
+  lineNumber: number;
+}
+
+export interface HolidayRange {
+  startDate: string; // YYYY-MM-DD
+  endDate: string; // YYYY-MM-DD
+  label: string;
+  lineNumber: number;
+}
+
+export interface GanttHolidays {
+  dates: HolidayDate[];
+  ranges: HolidayRange[];
+  workweek: Weekday[]; // default: ['mon', 'tue', 'wed', 'thu', 'fri']
+}
+
+// ── Eras & Markers (reuse timeline types) ───────────────────
+
+export interface GanttEra {
+  startDate: string;
+  endDate: string;
+  label: string;
+  color: string | null;
+}
+
+export interface GanttMarker {
+  date: string;
+  label: string;
+  color: string | null;
+  lineNumber: number;
+}
+
+// ── Chart Options ───────────────────────────────────────────
+
+export interface GanttOptions {
+  start: string | null; // YYYY[-MM[-DD]] or null for relative timeline
+  title: string | null;
+  titleLineNumber: number | null;
+  orientation: 'horizontal' | 'vertical';
+  todayMarker: 'off' | 'on' | string; // 'on' = current date, string = YYYY-MM-DD
+  criticalPath: boolean;
+  dependencies: boolean;
+  sort: 'default' | 'tag';
+  defaultSwimlaneGroup: string | null; // tag group name from `sort: tag:Team`
+}
+
+// ── Parsed Result ───────────────────────────────────────────
+
+export interface ParsedGantt {
+  nodes: GanttNode[]; // top-level tree (groups, tasks, parallel blocks)
+  holidays: GanttHolidays;
+  tagGroups: TagGroup[];
+  eras: GanttEra[];
+  markers: GanttMarker[];
+  options: GanttOptions;
+  diagnostics: DgmoError[];
+  error: string | null;
+}
+
+// ── Resolved Schedule ───────────────────────────────────────
+
+export interface ResolvedTask {
+  task: GanttTask;
+  startDate: Date;
+  endDate: Date;
+  isCriticalPath: boolean;
+  isUncertain: boolean; // true if task.uncertain OR any predecessor is uncertain
+  isMilestone: boolean;
+  groupPath: string[];
+  effectiveMetadata: Record<string, string>; // merged with inherited tags
+}
+
+export interface ResolvedGroup {
+  name: string;
+  color: string | null;
+  metadata: Record<string, string>;
+  startDate: Date;
+  endDate: Date;
+  progress: number | null; // aggregate progress (weighted average)
+  lineNumber: number;
+  depth: number;
+}
+
+export interface ResolvedSchedule {
+  tasks: ResolvedTask[];
+  groups: ResolvedGroup[];
+  startDate: Date;
+  endDate: Date;
+  holidays: GanttHolidays;
+  tagGroups: TagGroup[];
+  eras: GanttEra[];
+  markers: GanttMarker[];
+  options: GanttOptions;
+  diagnostics: DgmoError[];
+  error: string | null;
+}

package/src/graph/flowchart-parser.ts

@@ -90,10 +90,6 @@ function parseNodeRef(
  */
 function splitArrows(line: string): string[] {
   const segments: string[] = [];
-  // Match: optional `-label(color)->` or just `->`
-  // We scan left to right looking for `->` and work backwards to find the `-` start.
-  const arrowRe = /(?:^|\s)-([^>\s(][^(>]*?)?\s*(?:\(([^)]+)\))?\s*->|(?:^|\s)->/g;
-
   let lastIndex = 0;
   // Simpler approach: find all `->` positions, then determine if there's a label prefix
   const arrowPositions: { start: number; end: number; label?: string; color?: string }[] = [];
@@ -482,3 +478,30 @@ export function looksLikeFlowchart(content: string): boolean {
 
   return shapeNearArrow;
 }
+
+// ============================================================
+// Symbol extraction (for completion API)
+// ============================================================
+
+import type { DiagramSymbols } from '../completion';
+
+// Node ID: identifier at line start followed by a shape delimiter or space (arrow line)
+const NODE_ID_RE = /^([a-zA-Z_][\w-]*)[\s([</{]/;
+
+/**
+ * Extract node IDs (entities) from flowchart document text.
+ * Used by the dgmo completion API for ghost hints and popup completions.
+ */
+export function extractSymbols(docText: string): DiagramSymbols {
+  const entities: string[] = [];
+  let inMetadata = true;
+  for (const rawLine of docText.split('\n')) {
+    const line = rawLine.trim();
+    if (inMetadata && /^[a-z-]+\s*:/i.test(line)) continue;
+    inMetadata = false;
+    if (line.length === 0 || /^\s/.test(rawLine)) continue;
+    const m = NODE_ID_RE.exec(line);
+    if (m && !entities.includes(m[1]!)) entities.push(m[1]!);
+  }
+  return { kind: 'flowchart', entities, keywords: [] };
+}

package/src/graph/flowchart-renderer.ts

@@ -8,7 +8,7 @@ import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
 import { mix } from '../palettes/color-utils';
 import type { ParsedGraph, GraphShape } from './types';
-import type { LayoutResult, LayoutNode, LayoutEdge } from './layout';
+import type { LayoutResult, LayoutNode } from './layout';
 import { parseFlowchart } from './flowchart-parser';
 import { layoutGraph } from './layout';
 
@@ -246,7 +246,6 @@ export function renderFlowchart(
 
   // Center the diagram in the area below the title
   const scaledW = diagramW * scale;
-  const scaledH = diagramH * scale;
   const offsetX = (width - scaledW) / 2;
   const offsetY = titleHeight + DIAGRAM_PADDING;
 

package/src/graph/state-parser.ts

@@ -5,7 +5,6 @@ import { measureIndent, extractColor } from '../utils/parsing';
 import type {
   ParsedGraph,
   GraphNode,
-  GraphEdge,
   GraphGroup,
   GraphDirection,
 } from './types';

package/src/graph/state-renderer.ts

@@ -8,7 +8,7 @@ import { FONT_FAMILY } from '../fonts';
 import type { PaletteColors } from '../palettes';
 import { mix } from '../palettes/color-utils';
 import type { ParsedGraph } from './types';
-import type { LayoutResult, LayoutNode, LayoutEdge } from './layout';
+import type { LayoutResult, LayoutNode } from './layout';
 import { parseState } from './state-parser';
 import { layoutGraph } from './layout';
 
@@ -76,8 +76,6 @@ function selfLoopPath(node: LayoutNode): string {
 // Main renderer
 // ============================================================
 
-type GSelection = d3Selection.Selection<SVGGElement, unknown, null, undefined>;
-
 export function renderState(
   container: HTMLDivElement,
   graph: ParsedGraph,

package/src/index.ts

@@ -217,10 +217,13 @@ export type {
 } from './initiative-status/layout';
 
 export { renderInitiativeStatus, renderInitiativeStatusForExport } from './initiative-status/renderer';
+export type { ISRenderOptions } from './initiative-status/renderer';
 
 export { collapseInitiativeStatus } from './initiative-status/collapse';
 export type { CollapseResult } from './initiative-status/collapse';
 
+export { filterInitiativeStatusByTags } from './initiative-status/filter';
+
 export { parseSitemap, looksLikeSitemap } from './sitemap/parser';
 
 export type {
@@ -259,6 +262,30 @@ export { renderInfra, parseAndLayoutInfra, computeInfraLegendGroups } from './in
 export type { InfraLegendGroup } from './infra/renderer';
 export type { CollapsedSitemapResult } from './sitemap/collapse';
 
+// ── Gantt Chart ───────────────────────────────────────────
+export { parseGantt } from './gantt/parser';
+export { calculateSchedule } from './gantt/calculator';
+export { renderGantt, buildTagLaneRowList } from './gantt/renderer';
+export type { GanttInteractiveOptions, GanttRow, GanttGroupRow, GanttTaskRow, GanttLaneHeaderRow } from './gantt/renderer';
+export { resolveTaskName, collectTasks } from './gantt/resolver';
+export type {
+  ParsedGantt,
+  GanttTask,
+  GanttGroup,
+  GanttParallelBlock,
+  GanttNode,
+  GanttDependency,
+  GanttHolidays,
+  GanttEra,
+  GanttMarker,
+  GanttOptions,
+  Duration,
+  DurationUnit,
+  ResolvedSchedule,
+  ResolvedTask,
+  ResolvedGroup,
+} from './gantt/types';
+
 export { collapseOrgTree } from './org/collapse';
 export type { CollapsedOrgResult } from './org/collapse';
 
@@ -361,6 +388,16 @@ export type {
   DecodedDiagramUrl,
 } from './sharing';
 
+// ============================================================
+// Completion (symbol extraction API)
+// ============================================================
+
+export {
+  registerExtractor,
+  extractDiagramSymbols,
+} from './completion';
+export type { DiagramSymbols, ExtractFn } from './completion';
+
 // ============================================================
 // Branding
 // ============================================================

package/src/infra/compute.ts

@@ -22,8 +22,6 @@ import type {
   InfraAvailabilityPercentiles,
   InfraProperty,
 } from './types';
-import { INFRA_BEHAVIOR_KEYS } from './types';
-
 // ============================================================
 // Helpers
 // ============================================================
@@ -71,11 +69,6 @@ function serverlessCapacity(node: InfraNode): number {
   return concurrency / (durationMs / 1000);
 }
 
-/** Backward-compatible helper used by overload detection. */
-function getInstances(node: InfraNode): number {
-  return getInstanceRange(node).min;
-}
-
 /** Compute dynamic instance count based on load and max-rps. */
 function computeDynamicInstances(node: InfraNode, computedRps: number): number {
   const { min, max } = getInstanceRange(node);

package/src/infra/layout.ts

@@ -9,8 +9,6 @@ import dagre from '@dagrejs/dagre';
 import type {
   ComputedInfraModel,
   ComputedInfraNode,
-  ComputedInfraEdge,
-  InfraGroup,
 } from './types';
 
 // ============================================================

package/src/infra/parser.ts

@@ -11,11 +11,8 @@ import { measureIndent } from '../utils/parsing';
 import type {
   ParsedInfra,
   InfraNode,
-  InfraEdge,
   InfraGroup,
   InfraTagGroup,
-  InfraTagValue,
-  InfraProperty,
 } from './types';
 import { INFRA_BEHAVIOR_KEYS, EDGE_ONLY_KEYS } from './types';
 
@@ -116,7 +113,6 @@ export function parseInfra(content: string): ParsedInfra {
   };
 
   const nodeMap = new Map<string, InfraNode>();
-  const edgeNodeId = 'edge';
 
   const setError = (line: number, message: string) => {
     const diag = makeDgmoError(line, message);
@@ -573,3 +569,49 @@ export function parseInfra(content: string): ParsedInfra {
 
   return result;
 }
+
+// ============================================================
+// Symbol extraction (for completion API)
+// ============================================================
+
+import type { DiagramSymbols } from '../completion';
+
+/**
+ * Extract component names (entities) from infra document text.
+ * Used by the dgmo completion API for ghost hints and popup completions.
+ */
+export function extractSymbols(docText: string): DiagramSymbols {
+  const entities: string[] = [];
+  let inMetadata = true;
+  let inTagGroup = false;
+  for (const rawLine of docText.split('\n')) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const indented = /^\s/.test(rawLine);
+
+    // Metadata phase: skip until first non-metadata root-level line.
+    // All lines (including indented) are skipped while inMetadata = true.
+    if (inMetadata) {
+      if (!indented && !/^[a-z-]+\s*:/i.test(line)) inMetadata = false;
+      else continue;
+    }
+
+    if (!indented) {
+      // Root-level: tag group declaration, group header, or component
+      if (/^tag\s*:/i.test(line)) { inTagGroup = true; continue; }
+      inTagGroup = false;
+      if (/^\[/.test(line)) continue; // group header
+      const m = COMPONENT_RE.exec(line);
+      if (m && !entities.includes(m[1]!)) entities.push(m[1]!);
+    } else {
+      // Indented: skip tag values, connections, and properties; extract grouped components
+      if (inTagGroup) continue;
+      if (/^->/.test(line)) continue; // simple connection
+      if (/^-[^>]+-?>/.test(line)) continue; // labeled connection
+      if (/^\w[\w-]*\s*:/.test(line)) continue; // property (key: value)
+      const m = COMPONENT_RE.exec(line);
+      if (m && !entities.includes(m[1]!)) entities.push(m[1]!);
+    }
+  }
+  return { kind: 'infra', entities, keywords: [] };
+}