feat(graph): Improve why command output

The `graph why` command is a tool for developers to understand the
dependency graph. This change improves its output to be more useful and
clearer.

The output now includes the requirement specifier from the parent package
along with the parent package name. This makes it easier to understand
not just which package is pulling in a dependency, but which version or
range of versions it requires.

The output for top-level dependencies specified on the command line or
in a requirements file is also improved to clearly label them as such.

Cycle detection is included to prevent infinite loops and make it clear
where circular dependencies exist.

Signed-off-by: Doug Hellmann <dhellmann@redhat.com>

Author: dhellmann

src/fromager/commands/bootstrap.py

@@ -374,9 +374,14 @@ def write_constraints_file(
             output.write(f"{dep_name}=={node.version}\n")
 
     for dep_name in conflicting_deps:
-        logger.error("finding why %s was being used", dep_name)
         for node in graph.get_nodes_by_name(dep_name):
-            find_why(graph, node, -1, 1, [])
+            find_why(
+                graph=graph,
+                node=node,
+                max_depth=-1,
+                depth=0,
+                req_type=[],
+            )
 
     return ret
 

src/fromager/commands/graph.py

@@ -205,8 +205,7 @@ def why(
     if version:
         package_nodes = [node for node in package_nodes if node.version in version]
     for node in package_nodes:
-        print(f"\n{node.key}")
-        find_why(graph, node, depth, 1, requirement_type)
+        find_why(graph, node, depth, 0, requirement_type)
 
 
 def find_why(
@@ -215,22 +214,50 @@ def find_why(
     max_depth: int,
     depth: int,
     req_type: list[RequirementType],
-):
+    seen: set[str] | None = None,
+) -> None:
+    if seen is None:
+        seen = set()
+
+    if node.key in seen:
+        print(f"{'  ' * depth} * {node.key} has a cycle")
+        return
+
+    # Print the name of the package we are asking about. We do this here because
+    # we might be invoked for multiple packages and we want the format to be
+    # consistent.
+    if depth == 0:
+        print(f"\n{node.key}")
+
+    seen = set([node.key]).union(seen)
     all_skipped = True
     is_toplevel = False
     for parent in node.parents:
+        # Show the toplevel dependencies regardless of the req_type because they
+        # are the ones that are actually installed and may influence other
+        # dependencies.
         if parent.destination_node.key == ROOT:
             is_toplevel = True
-            print(f" * {node.key} is a toplevel dependency")
+            print(
+                f"{'  ' * depth} * {node.key} is a toplevel dependency with req {parent.req}"
+            )
             continue
+        # Skip dependencies that don't match the req_type.
         if req_type and parent.req_type not in req_type:
             continue
         all_skipped = False
         print(
-            f"{'  ' * depth} * is an {parent.req_type} dependency of {parent.destination_node.key} with req {parent.req}"
+            f"{'  ' * depth} * {node.key} is an {parent.req_type} dependency of {parent.destination_node.key} with req {parent.req}"
         )
         if max_depth and (max_depth == -1 or depth <= max_depth):
-            find_why(graph, parent.destination_node, max_depth, depth + 1, [])
+            find_why(
+                graph=graph,
+                node=parent.destination_node,
+                max_depth=max_depth,
+                depth=depth + 1,
+                req_type=req_type,
+                seen=seen,
+            )
 
     if all_skipped and not is_toplevel:
         print(