@reqord/web 0.1.0

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

@@ -0,0 +1,309 @@
+import { describe, it, expect } from "vitest";
+import type { Requirement, Specification, TaskEntry } from "@reqord/shared";
+import { buildMultiLevelGraphData } from "../../lib/graph-data";
+
+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}`,
+    status: "open",
+    linkedTo: { specifications: specIds },
+    syncedAt: "2026-01-01T00:00:00Z",
+    priority: "P1",
+    ...overrides,
+  };
+}
+
+describe("buildMultiLevelGraphData", () => {
+  describe("empty inputs", () => {
+    it("returns empty nodes and edges when both arrays are empty", () => {
+      const result = buildMultiLevelGraphData([], [], []);
+      expect(result.nodes).toEqual([]);
+      expect(result.edges).toEqual([]);
+    });
+  });
+
+  describe("requirements only", () => {
+    it("creates requirement nodes without specification or issue nodes", () => {
+      const req1 = makeReq("req-000001");
+      const req2 = makeReq("req-000002");
+      const result = buildMultiLevelGraphData([req1, req2], [], []);
+      expect(result.nodes).toHaveLength(2);
+      expect(result.nodes[0]).toMatchObject({
+        id: "req-000001",
+        type: "requirement",
+        data: { label: "Requirement req-000001", status: "draft", priority: "medium" },
+        position: { x: 0, y: 0 },
+      });
+      expect(result.nodes[1]).toMatchObject({
+        id: "req-000002",
+        type: "requirement",
+        position: { x: 0, y: 120 },
+      });
+      expect(result.edges).toEqual([]);
+    });
+
+    it("creates dependency edges from blockedBy relationships", () => {
+      const req1 = makeReq("req-000001");
+      const req2 = makeReq("req-000002", {
+        dependencies: { blockedBy: ["req-000001"], blocks: [], relatedTo: [] },
+      });
+      const result = buildMultiLevelGraphData([req1, req2], [], []);
+      expect(result.edges).toHaveLength(1);
+      expect(result.edges[0]).toMatchObject({
+        id: "dep-req-000001-req-000002",
+        source: "req-000001",
+        target: "req-000002",
+        type: "dependency",
+      });
+    });
+  });
+
+  describe("requirements and specifications", () => {
+    it("creates specification nodes at center column", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const result = buildMultiLevelGraphData([req1], [spec1], []);
+      const specNode = result.nodes.find((n) => n.type === "specification");
+      expect(specNode).toMatchObject({
+        id: "spec-000001",
+        type: "specification",
+        data: { label: "spec-000001", status: "draft" },
+        position: { x: 400, y: 0 },
+      });
+    });
+
+    it("creates implements edge from specification to requirement", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const result = buildMultiLevelGraphData([req1], [spec1], []);
+      const implementsEdge = result.edges.find((e) => e.type === "implements");
+      expect(implementsEdge).toMatchObject({
+        id: "impl-spec-000001-req-000001",
+        source: "spec-000001",
+        target: "req-000001",
+        type: "implements",
+      });
+    });
+
+    it("creates implements edge even when requirementId does not exist", () => {
+      const spec1 = makeSpec("spec-000001", "req-999999");
+      const result = buildMultiLevelGraphData([], [spec1], []);
+      expect(result.edges).toHaveLength(1);
+      expect(result.edges[0]).toMatchObject({
+        source: "spec-000001",
+        target: "req-999999",
+        type: "implements",
+      });
+    });
+
+    it("creates multiple implements edges when multiple specs reference same requirement", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+      const result = buildMultiLevelGraphData([req1], [spec1, spec2], []);
+      const implementsEdges = result.edges.filter((e) => e.type === "implements");
+      expect(implementsEdges).toHaveLength(2);
+      expect(implementsEdges[0].target).toBe("req-000001");
+      expect(implementsEdges[1].target).toBe("req-000001");
+    });
+  });
+
+  describe("requirements, specifications, and tasks", () => {
+    it("creates issue nodes at right column", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(123, ["spec-000001"], {
+        title: "Implement feature X",
+        url: "https://github.com/test/repo/issues/123",
+        priority: "P1",
+        status: "open",
+      });
+      const result = buildMultiLevelGraphData([req1], [spec1], [task]);
+      const issueNode = result.nodes.find((n) => n.type === "issue");
+      expect(issueNode).toMatchObject({
+        id: "issue-123",
+        type: "issue",
+        data: {
+          label: "Issue #123",
+          status: "open",
+          priority: "P1",
+          issueNumber: 123,
+          issueUrl: "https://github.com/test/repo/issues/123",
+        },
+        position: { x: 800, y: 0 },
+      });
+    });
+
+    it("creates tracks edge from issue to specification", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(123, ["spec-000001"], {
+        title: "Implement feature X",
+        url: "https://github.com/test/repo/issues/123",
+        priority: "P1",
+        status: "open",
+      });
+      const result = buildMultiLevelGraphData([req1], [spec1], [task]);
+      const tracksEdge = result.edges.find((e) => e.type === "tracks");
+      expect(tracksEdge).toMatchObject({
+        id: "track-issue-123-spec-000001",
+        source: "issue-123",
+        target: "spec-000001",
+        type: "tracks",
+      });
+    });
+
+    it("creates all three node types and three edge types correctly", () => {
+      const req1 = makeReq("req-000001");
+      const req2 = makeReq("req-000002", {
+        dependencies: { blockedBy: ["req-000001"], blocks: [], relatedTo: [] },
+      });
+      const spec1 = makeSpec("spec-000001", "req-000002");
+      const task = makeTask(123, ["spec-000001"], {
+        title: "Implement feature X",
+        url: "https://github.com/test/repo/issues/123",
+        priority: "P1",
+        status: "open",
+      });
+      const result = buildMultiLevelGraphData([req1, req2], [spec1], [task]);
+      const reqNodes = result.nodes.filter((n) => n.type === "requirement");
+      const specNodes = result.nodes.filter((n) => n.type === "specification");
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(reqNodes).toHaveLength(2);
+      expect(specNodes).toHaveLength(1);
+      expect(issueNodes).toHaveLength(1);
+      const depEdges = result.edges.filter((e) => e.type === "dependency");
+      const implEdges = result.edges.filter((e) => e.type === "implements");
+      const trackEdges = result.edges.filter((e) => e.type === "tracks");
+      expect(depEdges).toHaveLength(1);
+      expect(implEdges).toHaveLength(1);
+      expect(trackEdges).toHaveLength(1);
+    });
+
+    it("does not create issue nodes or tracks edges when no tasks match spec", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const result = buildMultiLevelGraphData([req1], [spec1], []);
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      const trackEdges = result.edges.filter((e) => e.type === "tracks");
+      expect(issueNodes).toHaveLength(0);
+      expect(trackEdges).toHaveLength(0);
+    });
+
+    it("only includes tasks linked to the matching spec", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task1 = makeTask(123, ["spec-000001"]);
+      const task2 = makeTask(124, ["spec-000002"]);
+      const result = buildMultiLevelGraphData([req1], [spec1], [task1, task2]);
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(1);
+      expect(issueNodes[0].id).toBe("issue-123");
+    });
+
+    it("positions multiple issues vertically with offset", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task1 = makeTask(123, ["spec-000001"]);
+      const task2 = makeTask(124, ["spec-000001"]);
+      const result = buildMultiLevelGraphData([req1], [spec1], [task1, task2]);
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(2);
+      expect(issueNodes[0].position).toEqual({ x: 800, y: 0 });
+      expect(issueNodes[1].position).toEqual({ x: 800, y: 80 });
+    });
+
+    it("creates only one issue node when a task is linked to multiple specs", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+      const task = makeTask(123, ["spec-000001", "spec-000002"]);
+      const result = buildMultiLevelGraphData([req1], [spec1, spec2], [task]);
+      const issueNodes = result.nodes.filter((n) => n.type === "issue");
+      expect(issueNodes).toHaveLength(1);
+      expect(issueNodes[0].id).toBe("issue-123");
+      const tracksEdges = result.edges.filter((e) => e.type === "tracks");
+      expect(tracksEdges).toHaveLength(2);
+      expect(tracksEdges.map((e) => e.target)).toEqual(
+        expect.arrayContaining(["spec-000001", "spec-000002"]),
+      );
+    });
+  });
+
+  describe("node positioning", () => {
+    it("positions requirement nodes at x=0", () => {
+      const req1 = makeReq("req-000001");
+      const req2 = makeReq("req-000002");
+      const result = buildMultiLevelGraphData([req1, req2], [], []);
+      expect(result.nodes[0].position.x).toBe(0);
+      expect(result.nodes[1].position.x).toBe(0);
+    });
+
+    it("positions specification nodes at x=400", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const spec2 = makeSpec("spec-000002", "req-000001");
+      const result = buildMultiLevelGraphData([req1], [spec1, spec2], []);
+      const specNodes = result.nodes.filter((n) => n.type === "specification");
+      expect(specNodes[0].position.x).toBe(400);
+      expect(specNodes[1].position.x).toBe(400);
+    });
+
+    it("positions issue nodes at x=800", () => {
+      const req1 = makeReq("req-000001");
+      const spec1 = makeSpec("spec-000001", "req-000001");
+      const task = makeTask(123, ["spec-000001"]);
+      const result = buildMultiLevelGraphData([req1], [spec1], [task]);
+      const issueNode = result.nodes.find((n) => n.type === "issue");
+      expect(issueNode?.position.x).toBe(800);
+    });
+  });
+});

package/src/__tests__/lib/local-feedback-repository.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/file-system", () => ({
+  readYAML: vi.fn(),
+  joinPath: vi.fn((...parts: string[]) => parts.join("/")),
+}));
+
+vi.mock("../../lib/reqord-root", () => ({
+  getIssuesDir: vi.fn(() => "/test/.reqord/issues"),
+}));
+
+import { LocalFeedbackRepository } from "../../lib/local-feedback-repository";
+import { readYAML } from "../../lib/file-system";
+
+const mockReadYAML = vi.mocked(readYAML);
+
+describe("LocalFeedbackRepository", () => {
+  let repo: LocalFeedbackRepository;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    repo = new LocalFeedbackRepository();
+  });
+
+  it("feedbacks.yaml存在時にFeedbackEntry配列を返す", async () => {
+    mockReadYAML.mockResolvedValue({
+      feedbacks: [
+        {
+          githubIssue: 42,
+          type: "bug",
+          severity: "high",
+          linkedTo: {
+            requirements: ["req-000001"],
+            createdRequirements: [],
+            specifications: [],
+            createdSpecifications: [],
+          },
+          syncedAt: "2026-01-01T00:00:00Z",
+          status: "open",
+        },
+      ],
+    });
+
+    const result = await repo.findAll();
+
+    expect(result).toHaveLength(1);
+    expect(result[0].githubIssue).toBe(42);
+    expect(result[0].type).toBe("bug");
+  });
+
+  it("feedbacks.yaml不在時に空配列を返す", async () => {
+    mockReadYAML.mockRejectedValue(new Error("ENOENT"));
+
+    const result = await repo.findAll();
+
+    expect(result).toEqual([]);
+  });
+
+  it("不正なYAML時に空配列を返す", async () => {
+    mockReadYAML.mockResolvedValue({ invalid: "data" });
+
+    const result = await repo.findAll();
+
+    expect(result).toEqual([]);
+  });
+
+  it("feedbacks配列が空の場合に空配列を返す", async () => {
+    mockReadYAML.mockResolvedValue({ feedbacks: [] });
+
+    const result = await repo.findAll();
+
+    expect(result).toEqual([]);
+  });
+});

package/src/__tests__/lib/local-specification-repository.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { dump as yamlDump, JSON_SCHEMA } from "js-yaml";
+
+function makeSpecYaml(overrides: Record<string, unknown> = {}) {
+  return yamlDump(
+    {
+      id: "spec-000001",
+      requirementId: "req-000001",
+      version: "1.0.0",
+      status: "draft",
+      createdAt: "2026-02-08T14:07:39.737Z",
+      updatedAt: "2026-02-08T14:07:54.055Z",
+      versionHistory: [],
+      files: {
+        design: "specifications/spec-000001/design.md",
+        supplementary: [],
+      },
+      ...overrides,
+    },
+    { schema: JSON_SCHEMA },
+  );
+}
+
+describe("LocalSpecificationRepository", () => {
+  let tmpDir: string;
+  let specDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "reqord-spec-test-"));
+    specDir = join(tmpDir, ".reqord", "specifications");
+    await mkdir(specDir, { recursive: true });
+    process.env.REQORD_ROOT = tmpDir;
+    vi.resetModules();
+  });
+
+  afterEach(async () => {
+    delete process.env.REQORD_ROOT;
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  async function getRepo() {
+    const { LocalSpecificationRepository } = await import(
+      "../../lib/local-specification-repository"
+    );
+    return new LocalSpecificationRepository();
+  }
+
+  describe("findAll", () => {
+    it("returns all valid specification files sorted by ID", async () => {
+      await writeFile(
+        join(specDir, "spec-000002.yaml"),
+        makeSpecYaml({ id: "spec-000002", requirementId: "req-000002" }),
+      );
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001", requirementId: "req-000001" }),
+      );
+
+      const repo = await getRepo();
+      const specs = await repo.findAll();
+
+      expect(specs).toHaveLength(2);
+      expect(specs[0].id).toBe("spec-000001");
+      expect(specs[1].id).toBe("spec-000002");
+    });
+
+    it("skips invalid YAML files", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001" }),
+      );
+      await writeFile(join(specDir, "spec-000002.yaml"), "invalid: yaml: content:");
+
+      const repo = await getRepo();
+      const specs = await repo.findAll();
+
+      expect(specs).toHaveLength(1);
+      expect(specs[0].id).toBe("spec-000001");
+    });
+
+    it("skips files not matching spec-NNNNNN.yaml pattern", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001" }),
+      );
+      await writeFile(join(specDir, "notes.txt"), "not a spec");
+
+      const repo = await getRepo();
+      const specs = await repo.findAll();
+
+      expect(specs).toHaveLength(1);
+    });
+
+    it("returns empty array when directory has no files", async () => {
+      const repo = await getRepo();
+      const specs = await repo.findAll();
+
+      expect(specs).toEqual([]);
+    });
+  });
+
+  describe("findById", () => {
+    it("returns a specification when it exists", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001" }),
+      );
+
+      const repo = await getRepo();
+      const spec = await repo.findById("spec-000001");
+
+      expect(spec).not.toBeNull();
+      expect(spec!.id).toBe("spec-000001");
+      expect(spec!.requirementId).toBe("req-000001");
+    });
+
+    it("returns null when specification does not exist", async () => {
+      const repo = await getRepo();
+      const spec = await repo.findById("spec-999999");
+
+      expect(spec).toBeNull();
+    });
+
+    it("throws on invalid specification data", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        yamlDump({ id: "spec-000001" }, { schema: JSON_SCHEMA }),
+      );
+
+      const repo = await getRepo();
+      await expect(repo.findById("spec-000001")).rejects.toThrow(
+        "Invalid specification",
+      );
+    });
+  });
+
+  describe("loadDesign", () => {
+    it("returns design content when design.md exists", async () => {
+      const designDir = join(specDir, "spec-000001");
+      await mkdir(designDir, { recursive: true });
+      await writeFile(join(designDir, "design.md"), "# Design\n\nSome content");
+
+      const repo = await getRepo();
+      const design = await repo.loadDesign("spec-000001");
+
+      expect(design).toBe("# Design\n\nSome content");
+    });
+
+    it("returns null when design.md does not exist", async () => {
+      const repo = await getRepo();
+      const design = await repo.loadDesign("spec-999999");
+
+      expect(design).toBeNull();
+    });
+  });
+
+  describe("findByRequirementId", () => {
+    it("returns specifications matching the requirement ID", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001", requirementId: "req-000001" }),
+      );
+      await writeFile(
+        join(specDir, "spec-000002.yaml"),
+        makeSpecYaml({ id: "spec-000002", requirementId: "req-000002" }),
+      );
+      await writeFile(
+        join(specDir, "spec-000003.yaml"),
+        makeSpecYaml({ id: "spec-000003", requirementId: "req-000001" }),
+      );
+
+      const repo = await getRepo();
+      const specs = await repo.findByRequirementId("req-000001");
+
+      expect(specs).toHaveLength(2);
+      expect(specs.map((s) => s.id)).toEqual(["spec-000001", "spec-000003"]);
+    });
+
+    it("returns empty array when no specifications match", async () => {
+      await writeFile(
+        join(specDir, "spec-000001.yaml"),
+        makeSpecYaml({ id: "spec-000001", requirementId: "req-000001" }),
+      );
+
+      const repo = await getRepo();
+      const specs = await repo.findByRequirementId("req-999999");
+
+      expect(specs).toEqual([]);
+    });
+  });
+});

package/src/__tests__/lib/reqord-root.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+describe("getReqordRoot", () => {
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    originalEnv = process.env.REQORD_ROOT;
+    // Clear module cache to reset the cached root
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.REQORD_ROOT = originalEnv;
+    } else {
+      delete process.env.REQORD_ROOT;
+    }
+  });
+
+  it("returns the REQORD_ROOT env value", async () => {
+    process.env.REQORD_ROOT = "/test/path";
+    const { getReqordRoot } = await import("../../lib/reqord-root");
+    expect(getReqordRoot()).toBe("/test/path");
+  });
+
+  it("throws when REQORD_ROOT is not set", async () => {
+    delete process.env.REQORD_ROOT;
+    const { getReqordRoot } = await import("../../lib/reqord-root");
+    expect(() => getReqordRoot()).toThrow("REQORD_ROOT");
+  });
+});

package/src/__tests__/lib/specification-file.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("loadSpecFile", () => {
+  let tmpDir: string;
+  let specDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "reqord-spec-file-test-"));
+    specDir = join(tmpDir, ".reqord", "specifications");
+    await mkdir(specDir, { recursive: true });
+    process.env.REQORD_ROOT = tmpDir;
+    vi.resetModules();
+  });
+
+  afterEach(async () => {
+    delete process.env.REQORD_ROOT;
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  async function getLoadSpecFile() {
+    const { loadSpecFile } = await import("../../lib/specification-file");
+    return loadSpecFile;
+  }
+
+  it("returns file content when file exists", async () => {
+    const specSubDir = join(specDir, "spec-000001");
+    await mkdir(specSubDir, { recursive: true });
+    await writeFile(join(specSubDir, "design.md"), "# Design\n\nContent here");
+
+    const loadSpecFile = await getLoadSpecFile();
+    const content = await loadSpecFile("spec-000001", "design.md");
+
+    expect(content).toBe("# Design\n\nContent here");
+  });
+
+  it("returns null when file does not exist", async () => {
+    const loadSpecFile = await getLoadSpecFile();
+    const content = await loadSpecFile("spec-999999", "nonexistent.md");
+
+    expect(content).toBeNull();
+  });
+
+  it("returns null when spec directory does not exist", async () => {
+    const loadSpecFile = await getLoadSpecFile();
+    const content = await loadSpecFile("spec-999999", "design.md");
+
+    expect(content).toBeNull();
+  });
+
+  it("loads research.md correctly", async () => {
+    const specSubDir = join(specDir, "spec-000001");
+    await mkdir(specSubDir, { recursive: true });
+    await writeFile(join(specSubDir, "research.md"), "# Research\n\nFindings");
+
+    const loadSpecFile = await getLoadSpecFile();
+    const content = await loadSpecFile("spec-000001", "research.md");
+
+    expect(content).toBe("# Research\n\nFindings");
+  });
+});