@diagrammo/dgmo 0.6.3 → 0.7.1

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/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';
 

package/src/infra/renderer.ts

@@ -1667,8 +1667,8 @@ function renderLegend(
     const isActive = activeGroup != null && group.name.toLowerCase() === activeGroup.toLowerCase();
 
     const groupBg = isDark
-      ? mix(palette.bg, palette.text, 85)
-      : mix(palette.bg, palette.text, 92);
+      ? mix(palette.surface, palette.bg, 50)
+      : mix(palette.surface, palette.bg, 30);
 
     const pillLabel = group.name;
     const pillWidth = pillLabel.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
@@ -1798,12 +1798,42 @@ export function renderInfra(
 
   const shouldAnimate = animate !== false;
 
+  // In app mode with legend + title, render the title as a separate fixed-size SVG
+  // so the legend can be inserted between title and diagram.
+  const fixedTitleH = fixedLegend && title ? 40 : 0;
+  const diagramViewHeight = fixedLegend
+    ? layout.height + (title && !fixedTitleH ? titleOffset : 0) + legendOffset
+    : totalHeight;
+
+  if (fixedTitleH) {
+    const titleSvg = d3Selection.select(container)
+      .append('svg')
+      .attr('class', 'infra-title-fixed')
+      .attr('width', '100%')
+      .attr('height', fixedTitleH)
+      .attr('viewBox', `0 0 ${totalWidth} ${fixedTitleH}`)
+      .attr('preserveAspectRatio', 'xMidYMid meet')
+      .style('display', 'block');
+    titleSvg.append('text')
+      .attr('class', 'chart-title')
+      .attr('x', totalWidth / 2)
+      .attr('y', 28)
+      .attr('text-anchor', 'middle')
+      .attr('font-family', FONT_FAMILY)
+      .attr('font-size', 18)
+      .attr('font-weight', '700')
+      .attr('fill', palette.text)
+      .attr('data-line-number', titleLineNumber != null ? titleLineNumber : '')
+      .text(title!);
+  }
+
+  const fixedOverheadH = (fixedLegend ? LEGEND_HEIGHT + LEGEND_FIXED_GAP : 0) + fixedTitleH;
   const rootSvg = d3Selection.select(container)
     .append('svg')
     .attr('xmlns', 'http://www.w3.org/2000/svg')
     .attr('width', '100%')
-    .attr('height', fixedLegend ? `calc(100% - ${LEGEND_HEIGHT + LEGEND_FIXED_GAP}px)` : '100%')
-    .attr('viewBox', `0 0 ${totalWidth} ${totalHeight}`)
+    .attr('height', fixedOverheadH > 0 ? `calc(100% - ${fixedOverheadH}px)` : '100%')
+    .attr('viewBox', `0 0 ${totalWidth} ${diagramViewHeight}`)
     .attr('preserveAspectRatio', 'xMidYMid meet');
 
   // Inject animation keyframes + edge label hover styles
@@ -1850,11 +1880,13 @@ export function renderInfra(
     `);
   }
 
+  // Content group offset: skip title space (unless title was extracted to fixed SVG)
+  const contentTitleOffset = fixedTitleH ? 0 : titleOffset;
   const svg = rootSvg.append('g')
-    .attr('transform', `translate(0, ${titleOffset})`);
+    .attr('transform', `translate(0, ${contentTitleOffset + legendOffset})`);
 
-  // Title
-  if (title) {
+  // Title (inside rootSvg when not using fixed title)
+  if (title && !fixedTitleH) {
     rootSvg.append('text')
       .attr('class', 'chart-title')
       .attr('x', totalWidth / 2)
@@ -1887,22 +1919,26 @@ export function renderInfra(
   }
   renderEdgeLabels(svg, layout.edges, layout.nodes, layout.groups, palette, isDark, shouldAnimate, layout.direction);
 
-  // Legend at bottom
+  // Legend at top
   if (hasLegend) {
     if (fixedLegend) {
-      // Render legend in a separate SVG that stays at fixed pixel size
+      // Render legend in a separate SVG that stays at fixed pixel size, inserted between title and diagram
       const containerWidth = container.clientWidth || totalWidth;
       const legendSvg = d3Selection.select(container)
-        .append('svg')
+        .insert('svg', 'svg:last-of-type')
         .attr('class', 'infra-legend-fixed')
         .attr('width', '100%')
         .attr('height', LEGEND_HEIGHT + LEGEND_FIXED_GAP)
         .attr('viewBox', `0 0 ${containerWidth} ${LEGEND_HEIGHT + LEGEND_FIXED_GAP}`)
         .attr('preserveAspectRatio', 'xMidYMid meet')
-        .style('display', 'block');
+        .style('display', 'block')
+        .style('pointer-events', 'none');
       renderLegend(legendSvg, legendGroups, containerWidth, LEGEND_FIXED_GAP / 2, palette, isDark, activeGroup ?? null);
+      // Re-enable pointer events on interactive legend elements
+      legendSvg.selectAll('.infra-legend-group').style('pointer-events', 'auto');
     } else {
-      renderLegend(rootSvg, legendGroups, totalWidth, titleOffset + layout.height + 4, palette, isDark, activeGroup ?? null);
+      // Export mode: render legend at top (below title)
+      renderLegend(rootSvg, legendGroups, totalWidth, titleOffset, palette, isDark, activeGroup ?? null);
     }
   }
 }

package/src/initiative-status/filter.ts

@@ -0,0 +1,63 @@
+// ============================================================
+// Initiative Status — Tag-Based Filter
+//
+// Immutable graph transform: returns a new ParsedInitiativeStatus
+// with hidden-value nodes removed, their edges dropped,
+// and group.nodeLabels cleaned.
+// ============================================================
+
+import type { ParsedInitiativeStatus } from './types';
+
+/**
+ * Filter an initiative-status graph by hiding nodes whose tag metadata
+ * matches any hidden value. Returns a new (immutable copy) ParsedInitiativeStatus.
+ *
+ * @param parsed  Fully-resolved parsed result (defaults already injected)
+ * @param hiddenTagValues  Map<groupKey, Set<hiddenValues>> — all keys/values lowercase
+ * @returns Filtered copy; original is not mutated
+ */
+export function filterInitiativeStatusByTags(
+  parsed: ParsedInitiativeStatus,
+  hiddenTagValues: Map<string, Set<string>>
+): ParsedInitiativeStatus {
+  // Fast path: no filtering
+  if (hiddenTagValues.size === 0) return parsed;
+
+  // Build set of hidden node labels
+  const hiddenNodeLabels = new Set<string>();
+  for (const node of parsed.nodes) {
+    for (const [groupKey, hiddenValues] of hiddenTagValues) {
+      const nodeValue = node.metadata[groupKey];
+      if (nodeValue && hiddenValues.has(nodeValue.toLowerCase())) {
+        hiddenNodeLabels.add(node.label);
+        break;
+      }
+    }
+  }
+
+  // No nodes hidden — return input unchanged
+  if (hiddenNodeLabels.size === 0) return parsed;
+
+  // Filter nodes
+  const nodes = parsed.nodes.filter((n) => !hiddenNodeLabels.has(n.label));
+
+  // Filter edges: remove edges where source OR target is hidden
+  const edges = parsed.edges.filter(
+    (e) => !hiddenNodeLabels.has(e.source) && !hiddenNodeLabels.has(e.target)
+  );
+
+  // Clean group nodeLabels; remove empty groups
+  const groups = parsed.groups
+    .map((g) => ({
+      ...g,
+      nodeLabels: g.nodeLabels.filter((l) => !hiddenNodeLabels.has(l)),
+    }))
+    .filter((g) => g.nodeLabels.length > 0);
+
+  return {
+    ...parsed,
+    nodes,
+    edges,
+    groups,
+  };
+}