feat(libstore): add findCycles() to DependencyGraph

Adds cycle detection to DependencyGraph using DFS with back-edge detection.

This will be used by the cycle detection feature for build errors.

Each cycle is represented as a path that starts and ends at the same node,
e.g., [A, B, C, A].

Author: lovesegfault

src/libstore/include/nix/store/dependency-graph-impl.hh

@@ -17,6 +17,7 @@
 #include "nix/util/error.hh"
 
 #include <boost/graph/graph_traits.hpp>
+#include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/reverse_graph.hpp>
 #include <boost/graph/properties.hpp>
 
@@ -222,6 +223,61 @@ DependencyGraph<NodeId, EdgeProperty>::getEdgeProperty(const NodeId & from, cons
     return graph[edge];
 }
 
+template<GraphNodeId NodeId, typename EdgeProperty>
+std::vector<std::vector<NodeId>> DependencyGraph<NodeId, EdgeProperty>::findCycles() const
+{
+    using vertex_descriptor = typename boost::graph_traits<Graph>::vertex_descriptor;
+    using edge_descriptor = typename boost::graph_traits<Graph>::edge_descriptor;
+
+    std::vector<std::vector<vertex_descriptor>> cycleDescriptors;
+    std::vector<vertex_descriptor> dfsPath;
+
+    // Custom DFS visitor to detect back edges and extract cycles
+    class CycleFinder : public boost::default_dfs_visitor
+    {
+    public:
+        std::vector<std::vector<vertex_descriptor>> & cycles;
+        std::vector<vertex_descriptor> & dfsPath;
+
+        CycleFinder(std::vector<std::vector<vertex_descriptor>> & cycles, std::vector<vertex_descriptor> & dfsPath)
+            : cycles(cycles)
+            , dfsPath(dfsPath)
+        {
+        }
+
+        void discover_vertex(vertex_descriptor v, const Graph & g)
+        {
+            dfsPath.push_back(v);
+        }
+
+        void finish_vertex(vertex_descriptor v, const Graph & g)
+        {
+            if (!dfsPath.empty() && dfsPath.back() == v) {
+                dfsPath.pop_back();
+            }
+        }
+
+        void back_edge(edge_descriptor e, const Graph & g)
+        {
+            auto target = boost::target(e, g);
+            auto cycleStart = std::ranges::find(dfsPath, target);
+            std::vector<vertex_descriptor> cycle(cycleStart, dfsPath.end());
+            cycle.push_back(target);
+            cycles.push_back(std::move(cycle));
+        }
+    };
+
+    CycleFinder visitor(cycleDescriptors, dfsPath);
+    boost::depth_first_search(graph, boost::visitor(visitor));
+
+    // Convert vertex_descriptors to NodeIds using ranges
+    return cycleDescriptors | std::views::transform([&](const auto & cycleVerts) {
+               return cycleVerts | std::views::transform([&](auto v) { return getNodeId(v); })
+                      | std::ranges::to<std::vector<NodeId>>();
+           })
+           | std::ranges::to<std::vector>();
+}
+
 template<GraphNodeId NodeId, typename EdgeProperty>
 std::vector<NodeId> DependencyGraph<NodeId, EdgeProperty>::getAllNodes() const
 {

src/libstore/include/nix/store/dependency-graph.hh

@@ -5,6 +5,7 @@
 #include "nix/util/canon-path.hh"
 
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/graph/reverse_graph.hpp>
 
@@ -137,6 +138,12 @@ public:
 
     std::vector<NodeId> getAllNodes() const;
 
+    /**
+     * Find all cycles in the graph using DFS.
+     * Returns vector of cycles, each represented as a path that starts and ends at the same node.
+     */
+    std::vector<std::vector<NodeId>> findCycles() const;
+
     size_t numVertices() const
     {
         return boost::num_vertices(graph);