critical-path

Sprint Critical Path Analysis

Builds a dependency graph of all sprint tickets, identifies the critical path (longest chain of dependent work), and flags at-risk items that could delay sprint completion. Reveals parallel work opportunities.

Usage

/critical-path [--sprint <sprint-id>] [--mermaid] [--slack] [--format text|json]

• --sprint <id>: Analyze specific sprint (defaults to active)
• --mermaid: Output dependency graph as Mermaid diagram
• --slack: Share critical path to Slack channel
• --format: Output format (text, json, markdown)

Workflow

Phase 1: Data Collection

Fetches all active sprint tickets with dependency relationships.

class SprintAnalyzer {
  constructor() {
    this.sprint = null;
    this.tickets = [];
    this.dependencies = new Map();
  }

  async collectSprintData(sprintId = null) {
    try {
      // Get active sprint
      let sprint = null;
      if (sprintId) {
        sprint = await jira.getSprint({ sprintId });
      } else {
        const sprints = await jira.getSprintsFromBoard({
          boardId: detectBoardId(),
          state: "active"
        });

        if (sprints.length === 0) {
          console.error("ERROR: No active sprint found");
          return gracefulFailure("No active sprint; use --sprint to specify");
        }

        sprint = sprints[0];
      }

      this.sprint = sprint;
      console.log(`✓ Sprint: ${sprint.name} (${sprint.id})`);

      // Fetch all sprint tickets with expanded issue links
      const tickets = await jira.getIssuesByJQL({
        jql: `sprint = ${sprint.id}`,
        expand: ["changelog", "changelog.histories"],
        maxResults: 500
      });

      this.tickets = tickets.map(ticket => ({
        key: ticket.key,
        title: ticket.summary,
        status: ticket.status,
        storyPoints: ticket.customfield_storypoints || 0,
        assignee: ticket.assignee?.name || "Unassigned",
        priority: ticket.priority?.name || "Medium",
        dueDate: ticket.duedate,
        issueLinks: ticket.issuelinks || [],
        created: ticket.created,
        updated: ticket.updated,
        issuetype: ticket.issuetype.name
      }));

      console.log(`✓ Collected ${this.tickets.length} sprint tickets`);
      return this.tickets;
    } catch (err) {
      console.error(`ERROR: Failed to collect sprint data: ${err.message}`);
      return gracefulFailure("Unable to fetch sprint information");
    }
  }

  buildDependencyMap() {
    // Map: ticket key → array of keys it blocks
    const blockingMap = new Map();
    // Map: ticket key → array of keys blocking it
    const blockedByMap = new Map();

    // Initialize maps
    for (const ticket of this.tickets) {
      blockingMap.set(ticket.key, []);
      blockedByMap.set(ticket.key, []);
    }

    // Process issue links
    for (const ticket of this.tickets) {
      for (const link of ticket.issueLinks) {
        const linkType = link.type.name.toLowerCase();

        // "blocks" relationship
        if (linkType === "blocks") {
          const blockedKey = link.outwardIssue?.key;
          if (blockedKey && blockedByMap.has(blockedKey)) {
            blockingMap.get(ticket.key).push(blockedKey);
            blockedByMap.get(blockedKey).push(ticket.key);
          }
        }

        // "is blocked by" relationship
        if (linkType === "is blocked by") {
          const blockerKey = link.outwardIssue?.key;
          if (blockerKey && blockingMap.has(blockerKey)) {
            blockedByMap.get(ticket.key).push(blockerKey);
            blockingMap.get(blockerKey).push(ticket.key);
          }
        }

        // "depends on" relationship
        if (linkType === "depends on" || linkType === "dependency") {
          const depKey = link.outwardIssue?.key;
          if (depKey && blockingMap.has(depKey)) {
            blockingMap.get(depKey).push(ticket.key);
            blockedByMap.get(ticket.key).push(depKey);
          }
        }
      }
    }

    this.dependencies = {
      blocking: blockingMap,
      blockedBy: blockedByMap
    };

    console.log(`✓ Built dependency map`);
    return this.dependencies;
  }
}

const analyzer = new SprintAnalyzer();
await analyzer.collectSprintData(argv.sprint);
analyzer.buildDependencyMap();