Step 392: add dependency graph data and critical path

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-16 13:47:46 -07:00
parent 47152e31c5
commit bb36e253f2
3 changed files with 448 additions and 0 deletions
--- a/editor/tests/step392_test.cpp
+++ b/editor/tests/step392_test.cpp
@@ -0,0 +1,249 @@
+// Step 392: Dependency Graph Data (12 tests)
+
+#include <cassert>
+#include <iostream>
+#include <string>
+#include "DependencyGraph.h"
+
+static WorkItem makeItem(const std::string& id,
+                         const std::string& name = "doWork",
+                         const std::string& workerType = "slm",
+                         const std::string& contextWidth = "local",
+                         const std::string& priority = "medium",
+                         const std::vector<std::string>& deps = {}) {
+    WorkItem item;
+    item.id = id;
+    item.nodeId = id + "_node";
+    item.nodeName = name;
+    item.nodeType = "Function";
+    item.bufferId = "main.py";
+    item.workerType = workerType;
+    item.contextWidth = contextWidth;
+    item.priority = priority;
+    item.status = WI_READY;
+    item.createdAt = workItemTimestamp();
+    item.dependencies = deps;
+    return item;
+}
+
+int main() {
+    int passed = 0;
+
+    // Test 1: Graph has correct node count
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "funcA"));
+        wf.queue.enqueue(makeItem("t2", "funcB"));
+        wf.queue.enqueue(makeItem("t3", "funcC"));
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes.size() == 3);
+        std::cout << "PASS: test 1 — graph has correct node count\n";
+        passed++;
+    }
+
+    // Test 2: Edges match dependencies
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "funcA"));
+        wf.queue.enqueue(makeItem("t2", "funcB", "slm", "local", "medium", {"t1"}));
+        wf.queue.enqueue(makeItem("t3", "funcC", "slm", "local", "medium", {"t2"}));
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.edges.size() == 2);
+        // t1 -> t2
+        assert(graph.edges[0].from == "t1");
+        assert(graph.edges[0].to == "t2");
+        assert(graph.edges[0].type == "depends-on");
+        // t2 -> t3
+        assert(graph.edges[1].from == "t2");
+        assert(graph.edges[1].to == "t3");
+        std::cout << "PASS: test 2 — edges match dependencies\n";
+        passed++;
+    }
+
+    // Test 3: Critical path is longest chain
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "funcA"));
+        wf.queue.enqueue(makeItem("t2", "funcB", "slm", "local", "medium", {"t1"}));
+        wf.queue.enqueue(makeItem("t3", "funcC", "slm", "local", "medium", {"t2"}));
+        wf.queue.enqueue(makeItem("t4", "funcD")); // independent, shorter
+
+        auto graph = buildDependencyGraph(wf);
+        auto path = getCriticalPath(graph);
+        assert(path.size() == 3); // t1 -> t2 -> t3
+        assert(path[0] == "t1");
+        assert(path[1] == "t2");
+        assert(path[2] == "t3");
+        std::cout << "PASS: test 3 — critical path is longest chain\n";
+        passed++;
+    }
+
+    // Test 4: Node status matches workflow state
+    {
+        WorkflowState wf("test");
+        auto item = makeItem("t1", "funcA");
+        item.status = WI_COMPLETE;
+        wf.queue.enqueue(item);
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes.size() == 1);
+        assert(graph.nodes[0].status == WI_COMPLETE);
+        std::cout << "PASS: test 4 — node status matches workflow state\n";
+        passed++;
+    }
+
+    // Test 5: Worker type populated from routing
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "funcA", "llm"));
+        wf.queue.enqueue(makeItem("t2", "getName", "template"));
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes[0].workerType == "llm");
+        assert(graph.nodes[1].workerType == "template");
+        std::cout << "PASS: test 5 — worker type populated\n";
+        passed++;
+    }
+
+    // Test 6: JSON serialization
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "funcA"));
+        wf.queue.enqueue(makeItem("t2", "funcB", "slm", "local", "medium", {"t1"}));
+
+        auto graph = buildDependencyGraph(wf);
+        json j = graphToJson(graph);
+
+        assert(j.contains("nodes"));
+        assert(j.contains("edges"));
+        assert(j["nodes"].size() == 2);
+        assert(j["edges"].size() == 1);
+        assert(j["nodes"][0]["id"] == "t1");
+
+        // Roundtrip
+        auto restored = GraphData::fromJson(j);
+        assert(restored.nodes.size() == 2);
+        assert(restored.edges.size() == 1);
+        std::cout << "PASS: test 6 — JSON serialization\n";
+        passed++;
+    }
+
+    // Test 7: Empty workflow produces empty graph
+    {
+        WorkflowState wf("test");
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes.empty());
+        assert(graph.edges.empty());
+
+        auto path = getCriticalPath(graph);
+        assert(path.empty());
+        std::cout << "PASS: test 7 — empty workflow produces empty graph\n";
+        passed++;
+    }
+
+    // Test 8: Single-node graph
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "only"));
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes.size() == 1);
+        assert(graph.edges.empty());
+
+        auto path = getCriticalPath(graph);
+        assert(path.size() == 1);
+        assert(path[0] == "t1");
+        std::cout << "PASS: test 8 — single-node graph\n";
+        passed++;
+    }
+
+    // Test 9: Complex graph (diamond dependencies)
+    {
+        //     t1
+        //    /  \.
+        //  t2    t3
+        //    \  /
+        //     t4
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "root"));
+        wf.queue.enqueue(makeItem("t2", "left", "slm", "local", "medium", {"t1"}));
+        wf.queue.enqueue(makeItem("t3", "right", "slm", "local", "medium", {"t1"}));
+        wf.queue.enqueue(makeItem("t4", "merge", "slm", "local", "medium", {"t2", "t3"}));
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes.size() == 4);
+        assert(graph.edges.size() == 4); // t1->t2, t1->t3, t2->t4, t3->t4
+
+        auto path = getCriticalPath(graph);
+        // Longest path: t1 -> t2 -> t4 or t1 -> t3 -> t4 (both length 3)
+        assert(path.size() == 3);
+        assert(path[0] == "t1");
+        assert(path[2] == "t4");
+        std::cout << "PASS: test 9 — complex graph (diamond dependencies)\n";
+        passed++;
+    }
+
+    // Test 10: Graph updates after task completion
+    {
+        WorkflowState wf("test");
+        auto item1 = makeItem("t1", "funcA");
+        auto item2 = makeItem("t2", "funcB", "slm", "local", "medium", {"t1"});
+        wf.queue.enqueue(item1);
+        wf.queue.enqueue(item2);
+
+        auto graph1 = buildDependencyGraph(wf);
+        assert(graph1.nodes[0].status == WI_READY);
+
+        // Complete t1
+        item1.status = WI_COMPLETE;
+        wf.queue.updateItem("t1", item1);
+
+        auto graph2 = buildDependencyGraph(wf);
+        bool t1Complete = false;
+        for (const auto& n : graph2.nodes) {
+            if (n.id == "t1" && n.status == WI_COMPLETE) t1Complete = true;
+        }
+        assert(t1Complete);
+        std::cout << "PASS: test 10 — graph updates after task completion\n";
+        passed++;
+    }
+
+    // Test 11: Node label and type from work item
+    {
+        WorkflowState wf("test");
+        auto item = makeItem("t1", "myFunction");
+        item.nodeType = "Method";
+        item.priority = "critical";
+        wf.queue.enqueue(item);
+
+        auto graph = buildDependencyGraph(wf);
+        assert(graph.nodes[0].label == "myFunction");
+        assert(graph.nodes[0].type == "Method");
+        assert(graph.nodes[0].priority == "critical");
+        std::cout << "PASS: test 11 — node label and type from work item\n";
+        passed++;
+    }
+
+    // Test 12: 5-function chain critical path = 5
+    {
+        WorkflowState wf("test");
+        wf.queue.enqueue(makeItem("t1", "step1"));
+        wf.queue.enqueue(makeItem("t2", "step2", "slm", "local", "medium", {"t1"}));
+        wf.queue.enqueue(makeItem("t3", "step3", "slm", "local", "medium", {"t2"}));
+        wf.queue.enqueue(makeItem("t4", "step4", "slm", "local", "medium", {"t3"}));
+        wf.queue.enqueue(makeItem("t5", "step5", "slm", "local", "medium", {"t4"}));
+
+        auto graph = buildDependencyGraph(wf);
+        auto path = getCriticalPath(graph);
+        assert(path.size() == 5);
+        assert(path[0] == "t1");
+        assert(path[4] == "t5");
+        std::cout << "PASS: test 12 — 5-function chain critical path\n";
+        passed++;
+    }
+
+    std::cout << "\nStep 392 result: " << passed << "/12 tests passed\n";
+    return (passed == 12) ? 0 : 1;
+}