@reqord/web 0.1.0

package/src/__tests__/lib/drilldown-graph-data.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect } from "vitest";
+import type { Requirement, Specification, TaskEntry } from "@reqord/shared";
+import { buildDrillDownGraphData } from "../../lib/drilldown-graph-data";
+import { EDGE_STYLES } from "../../components/graph/edge-styles";
+
+function makeReq(
+  id: string,
+  overrides: Partial<Requirement> = {},
+): Requirement {
+  return {
+    id,
+    version: "1.0.0",
+    title: `Requirement ${id}`,
+    status: "draft",
+    priority: "medium",
+    createdAt: "2026-01-01T00:00:00Z",
+    updatedAt: "2026-01-01T00:00:00Z",
+    versionHistory: [],
+    files: {
+      description: `requirements/${id}/description.md`,
+      supplementary: [],
+    },
+    successCriteria: [],
+    format: { type: "free-form" },
+    dependencies: { blockedBy: [], blocks: [], relatedTo: [] },
+    ...overrides,
+  } as Requirement;
+}
+
+function makeSpec(
+  id: string,
+  reqId: string,
+  overrides: Partial<Specification> = {},
+): Specification {
+  return {
+    id,
+    requirementId: reqId,
+    version: "1.0.0",
+    status: "draft",
+    createdAt: "2026-01-01T00:00:00Z",
+    updatedAt: "2026-01-01T00:00:00Z",
+    versionHistory: [],
+    files: { design: `specifications/${id}/design.md`, supplementary: [] },
+    ...overrides,
+  } as Specification;
+}
+
+function makeTask(
+  number: number,
+  specIds: string[],
+  overrides: Partial<TaskEntry> = {},
+): TaskEntry {
+  return {
+    number,
+    title: `Task ${number}`,
+    url: `https://github.com/test/repo/issues/${number}`,
+    linkedTo: { specifications: specIds },
+    status: "open",
+    syncedAt: "2026-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("buildDrillDownGraphData", () => {
+  describe("requirement only (no specifications)", () => {
+    it("returns a single requirement node at x=0, y=0 and no edges", () => {
+      const req = makeReq("req-000001");
+
+      const result = buildDrillDownGraphData(req, [], []);
+
+      expect(result.nodes).toHaveLength(1);
+      expect(result.nodes[0]).toMatchObject({
+        id: "req-000001",
+        type: "requirement",
+        position: { x: 0, y: 0 },
+      });
+      expect(result.edges).toHaveLength(0);
+    });
+
+    it("includes requirement data in the node matching RequirementNodeData", () => {
+      const req = makeReq("req-000001", {
+        title: "My Feature",
+        status: "approved",
+        priority: "high",
+      });
+
+      const result = buildDrillDownGraphData(req, [], []);
+
+      expect(result.nodes[0].data).toMatchObject({
+        label: "My Feature",
+        status: "approved",
+        priority: "high",
+        specCount: 0,
+      });
+    });
+  });
+
+  describe("requirement with specifications", () => {
+    it("creates 3 nodes and 2 implements edges for 2 specs", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+
+      const result = buildDrillDownGraphData(req, [spec1, spec2], []);
+
+      expect(result.nodes).toHaveLength(3);
+      expect(result.edges).toHaveLength(2);
+    });
+
+    it("positions spec nodes at x=400 with vertical gap of 120", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+
+      const result = buildDrillDownGraphData(req, [spec1, spec2], []);
+
+      const specNodes = result.nodes.filter((n) => n.type === "specification");
+      expect(specNodes[0].position).toEqual({ x: 400, y: 0 });
+      expect(specNodes[1].position).toEqual({ x: 400, y: 120 });
+    });
+
+    it("creates implements edges from requirement to spec with correct style", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+
+      const result = buildDrillDownGraphData(req, [spec1], []);
+
+      expect(result.edges[0]).toMatchObject({
+        id: "impl-req-000001-spec-000001",
+        source: "req-000001",
+        target: "spec-000001",
+        style: EDGE_STYLES.implements,
+      });
+    });
+
+    it("includes spec data in specification nodes matching SpecificationNodeData", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001", {
+        status: "approved",
+      });
+
+      const result = buildDrillDownGraphData(req, [spec1], []);
+
+      const specNode = result.nodes.find((n) => n.type === "specification");
+      expect(specNode?.data).toMatchObject({
+        label: "spec-000001",
+        status: "approved",
+      });
+    });
+  });
+
+  describe("requirement with specifications and tasks", () => {
+    it("creates issue nodes at x=800 with tracks edges", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(42, ["spec-000001"]);
+
+      const result = buildDrillDownGraphData(req, [spec1], [task]);
+
+      const issueNode = result.nodes.find((n) => n.type === "issue");
+      expect(issueNode).toMatchObject({
+        id: "issue-42",
+        type: "issue",
+        position: { x: 800, y: 0 },
+      });
+    });
+
+    it("includes issue data in the node matching IssueNodeData", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(42, ["spec-000001"], {
+        title: "Implement feature",
+        status: "open",
+      });
+
+      const result = buildDrillDownGraphData(req, [spec1], [task]);
+
+      const issueNode = result.nodes.find((n) => n.type === "issue");
+      expect(issueNode?.data).toMatchObject({
+        label: "Implement feature",
+        status: "open",
+        issueNumber: 42,
+        issueUrl: "https://github.com/test/repo/issues/42",
+      });
+    });
+
+    it("creates tracks edges from spec to issue", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(42, ["spec-000001"]);
+
+      const result = buildDrillDownGraphData(req, [spec1], [task]);
+
+      const tracksEdge = result.edges.find((e) =>
+        e.id.startsWith("track-"),
+      );
+      expect(tracksEdge).toMatchObject({
+        id: "track-spec-000001-issue-42",
+        source: "spec-000001",
+        target: "issue-42",
+        style: EDGE_STYLES.tracks,
+      });
+    });
+
+    it("positions issues based on spec index and task index", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+      const task10 = makeTask(10, ["spec-000001"]);
+      const task11 = makeTask(11, ["spec-000001"]);
+      const task20 = makeTask(20, ["spec-000002"]);
+
+      const result = buildDrillDownGraphData(req, [spec1, spec2], [task10, task11, task20]);
+
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(3);
+      expect(issueNodes[0].position).toEqual({ x: 800, y: 0 });
+      expect(issueNodes[1].position).toEqual({ x: 800, y: 80 });
+      expect(issueNodes[2].position).toEqual({ x: 800, y: 120 });
+    });
+
+    it("does not create issue nodes when no tasks are linked to spec", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+
+      const result = buildDrillDownGraphData(req, [spec1], []);
+
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(0);
+      expect(result.edges).toHaveLength(1);
+      expect(result.edges[0].id).toMatch(/^impl-/);
+    });
+
+    it("does not create issue nodes for tasks linked to other specs", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(42, ["spec-000002"]);
+
+      const result = buildDrillDownGraphData(req, [spec1], [task]);
+
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(0);
+    });
+
+    it("a task linked to multiple specs creates one issue node with edges to each spec", () => {
+      const req = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+      const task = makeTask(42, ["spec-000001", "spec-000002"]);
+
+      const result = buildDrillDownGraphData(req, [spec1, spec2], [task]);
+
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(1);
+      expect(issueNodes[0].id).toBe("issue-42");
+
+      const tracksEdges = result.edges.filter((e) => e.id.startsWith("track-"));
+      expect(tracksEdges).toHaveLength(2);
+      expect(tracksEdges.map((e) => e.id)).toEqual(
+        expect.arrayContaining([
+          "track-spec-000001-issue-42",
+          "track-spec-000002-issue-42",
+        ]),
+      );
+    });
+  });
+});

package/src/__tests__/lib/gantt-data.test.ts

@@ -0,0 +1,299 @@
+import type { TaskEntry } from "@reqord/shared";
+import { describe, expect, it } from "vitest";
+import { DEFAULT_HOURS, transformToGanttData } from "../../lib/gantt-data";
+
+function makeTask(overrides: Partial<TaskEntry> = {}): TaskEntry {
+  return {
+    number: 1,
+    title: "Test task",
+    url: "https://github.com/test/1",
+    linkedTo: { specifications: ["spec-000001"] },
+    priority: "P0",
+    status: "open",
+    syncedAt: "2026-01-01T00:00:00Z",
+    ...overrides,
+  };
+}
+
+describe("transformToGanttData", () => {
+  describe("P0 tasks: serial placement", () => {
+    it("places P0 tasks sequentially with cumulative startOffset", () => {
+      const tasks = [
+        makeTask({ number: 1, title: "P0 Task 1", priority: "P0" }),
+        makeTask({ number: 2, title: "P0 Task 2", priority: "P0" }),
+        makeTask({ number: 3, title: "P0 Task 3", priority: "P0" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p0Group = result.groups.find((g) => g.priority === "P0");
+      expect(p0Group).toBeDefined();
+      expect(p0Group!.tasks).toHaveLength(3);
+      expect(p0Group!.tasks[0].startOffset).toBe(0);
+      expect(p0Group!.tasks[1].startOffset).toBe(4);
+      expect(p0Group!.tasks[2].startOffset).toBe(8);
+    });
+
+    it("marks all P0 tasks as critical path", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P0" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p0Group = result.groups.find((g) => g.priority === "P0");
+      expect(p0Group!.tasks.every((task) => task.isCriticalPath)).toBe(true);
+    });
+  });
+
+  describe("P1 tasks: parallel placement after P0", () => {
+    it("places all P1 tasks at P0 total time", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P0" }),
+        makeTask({ number: 3, title: "P1 Task 1", priority: "P1" }),
+        makeTask({ number: 4, title: "P1 Task 2", priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p1Group = result.groups.find((g) => g.priority === "P1");
+      expect(p1Group).toBeDefined();
+      expect(p1Group!.tasks).toHaveLength(2);
+      // P0 total: 2 * 4 = 8 hours
+      expect(p1Group!.tasks[0].startOffset).toBe(8);
+      expect(p1Group!.tasks[1].startOffset).toBe(8);
+    });
+
+    it("marks P1 tasks as not on critical path", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p1Group = result.groups.find((g) => g.priority === "P1");
+      expect(p1Group!.tasks.every((task) => !task.isCriticalPath)).toBe(true);
+    });
+  });
+
+  describe("P2 tasks: parallel placement after P1", () => {
+    it("places all P2 tasks at P1 start + max P1 hours", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P0" }),
+        makeTask({ number: 3, priority: "P1" }),
+        makeTask({ number: 4, priority: "P1" }),
+        makeTask({ number: 5, title: "P2 Task 1", priority: "P2" }),
+        makeTask({ number: 6, title: "P2 Task 2", priority: "P2" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p2Group = result.groups.find((g) => g.priority === "P2");
+      expect(p2Group).toBeDefined();
+      expect(p2Group!.tasks).toHaveLength(2);
+      // P0 total: 2 * 4 = 8, P1 start: 8, P1 max hours: 4
+      // P2 start: 8 + 4 = 12
+      expect(p2Group!.tasks[0].startOffset).toBe(12);
+      expect(p2Group!.tasks[1].startOffset).toBe(12);
+    });
+
+    it("marks P2 tasks as not on critical path", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P2" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p2Group = result.groups.find((g) => g.priority === "P2");
+      expect(p2Group!.tasks.every((task) => !task.isCriticalPath)).toBe(true);
+    });
+  });
+
+  describe("P1 only (no P0): parallel placement at zero", () => {
+    it("places P1 tasks at startOffset 0 when no P0 tasks exist", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P1" }),
+        makeTask({ number: 2, priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const p1Group = result.groups.find((g) => g.priority === "P1");
+      expect(p1Group).toBeDefined();
+      expect(p1Group!.tasks).toHaveLength(2);
+      expect(p1Group!.tasks[0].startOffset).toBe(0);
+      expect(p1Group!.tasks[1].startOffset).toBe(0);
+    });
+  });
+
+  describe("timelineEnd calculation", () => {
+    it("calculates timelineEnd as max(startOffset + estimatedHours)", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P0" }),
+        makeTask({ number: 3, priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      // P0: [0-4], [4-8]
+      // P1: [8-12]
+      // timelineEnd should be 12
+      expect(result.timelineEnd).toBe(12);
+    });
+
+    it("handles P2 tasks in timelineEnd calculation", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P1" }),
+        makeTask({ number: 3, priority: "P2" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      // P0: [0-4]
+      // P1: [4-8]
+      // P2: [8-12]
+      // timelineEnd should be 12
+      expect(result.timelineEnd).toBe(12);
+    });
+  });
+
+  describe("empty cases", () => {
+    it("returns empty groups and timelineEnd=0 for zero tasks", () => {
+      const result = transformToGanttData("spec-000001", []);
+
+      expect(result.groups).toEqual([]);
+      expect(result.timelineEnd).toBe(0);
+      expect(result.timelineStart).toBe(0);
+    });
+  });
+
+  describe("estimatedHours", () => {
+    it("uses DEFAULT_HOURS when task has no estimatedHours", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const allTasks = result.groups.flatMap((g) => g.tasks);
+      expect(
+        allTasks.every((task) => task.estimatedHours === DEFAULT_HOURS),
+      ).toBe(true);
+    });
+
+    it("uses task estimatedHours when provided", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0", estimatedHours: 8 }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const task = result.groups[0].tasks[0];
+      expect(task.estimatedHours).toBe(8);
+    });
+  });
+
+  describe("group labels", () => {
+    it("assigns correct labels to priority groups", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P1" }),
+        makeTask({ number: 3, priority: "P2" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      expect(result.groups.find((g) => g.priority === "P0")?.label).toBe(
+        "P0: Sequential",
+      );
+      expect(result.groups.find((g) => g.priority === "P1")?.label).toBe(
+        "P1: Parallel",
+      );
+      expect(result.groups.find((g) => g.priority === "P2")?.label).toBe(
+        "P2: Parallel",
+      );
+    });
+  });
+
+  describe("specId preservation", () => {
+    it("preserves specId in output", () => {
+      const tasks = [makeTask({ number: 1, priority: "P0" })];
+
+      const result = transformToGanttData("spec-000042", tasks);
+
+      expect(result.specId).toBe("spec-000042");
+    });
+  });
+
+  describe("task properties", () => {
+    it("maps all task properties to GanttTask", () => {
+      const tasks = [
+        makeTask({
+          number: 123,
+          title: "Test Feature",
+          url: "https://github.com/test/123",
+          priority: "P0",
+          status: "open",
+        }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const task = result.groups[0].tasks[0];
+      expect(task.id).toBe("123");
+      expect(task.title).toBe("Test Feature");
+      expect(task.issueNumber).toBe(123);
+      expect(task.issueUrl).toBe("https://github.com/test/123");
+      expect(task.priority).toBe("P0");
+      expect(task.state).toBe("open");
+      expect(task.dependencies).toEqual([]);
+    });
+  });
+
+  describe("tasks without priority", () => {
+    it("skips tasks that have no priority field", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: undefined }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      const allTasks = result.groups.flatMap((g) => g.tasks);
+      expect(allTasks).toHaveLength(1);
+      expect(allTasks[0].issueNumber).toBe(1);
+    });
+  });
+
+  describe("totalEstimatedHours", () => {
+    it("sums estimated hours of all tasks", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0", estimatedHours: 2 }),
+        makeTask({ number: 2, priority: "P1", estimatedHours: 3 }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      expect(result.totalEstimatedHours).toBe(5);
+    });
+
+    it("uses DEFAULT_HOURS for tasks without estimatedHours in total", () => {
+      const tasks = [
+        makeTask({ number: 1, priority: "P0" }),
+        makeTask({ number: 2, priority: "P1" }),
+      ];
+
+      const result = transformToGanttData("spec-000001", tasks);
+
+      expect(result.totalEstimatedHours).toBe(2 * DEFAULT_HOURS);
+    });
+  });
+});