Function calculateLongestChain

packages/cli/src/commands/analyze.ts:163–221

(nodes: Array<{ id: string }>, edges: Array<{ from: string; to: string }>)

}

function calculateLongestChain(nodes: Array<{ id: string }>, edges: Array<{ from: string; to: string }>): number {
  if (nodes.length === 0) return 0

  // Build adjacency list for forward traversal
  const graph = new Map<string, string[]>()
  for (const node of nodes) {
    graph.set(node.id, [])
  }
  for (const edge of edges) {
    const neighbors = graph.get(edge.from)
    if (neighbors) {
      neighbors.push(edge.to)
    }
  }

  // Find blocks with no incoming edges (entry points)
  const incomingCount = new Map<string, number>()
  for (const node of nodes) {
    incomingCount.set(node.id, 0)
  }
  for (const edge of edges) {
    const count = incomingCount.get(edge.to) ?? 0
    incomingCount.set(edge.to, count + 1)
  }

  // Topological sort with BFS to find longest path
  const maxDepth = new Map<string, number>()
  const queue: string[] = []

  for (const node of nodes) {
    if (incomingCount.get(node.id) === 0) {
      queue.push(node.id)
      maxDepth.set(node.id, 1)
    }
  }

  while (queue.length > 0) {
    const nodeId = queue.shift()
    if (!nodeId) break
    const currentDepth = maxDepth.get(nodeId) ?? 1
    const neighbors = graph.get(nodeId) ?? []

    for (const neighbor of neighbors) {
      const newDepth = currentDepth + 1
      const existingDepth = maxDepth.get(neighbor) ?? 0
      if (newDepth > existingDepth) {
        maxDepth.set(neighbor, newDepth)
      }

      const count = incomingCount.get(neighbor) ?? 0
      incomingCount.set(neighbor, count - 1)
      if (count - 1 === 0) {
        queue.push(neighbor)
      }
    }
  }

  return Math.max(0, ...maxDepth.values())