@reqord/web 0.1.0

package/src/lib/gantt-data.ts

@@ -0,0 +1,168 @@
+import type { TaskEntry } from "@reqord/shared";
+
+export const DEFAULT_HOURS = 4;
+
+export type GanttTask = {
+  id: string;
+  title: string;
+  issueNumber: number;
+  issueUrl: string;
+  priority: string;
+  state: string;
+  estimatedHours: number;
+  startOffset: number;
+  dependencies: number[];
+  isCriticalPath: boolean;
+};
+
+export type GanttGroup = {
+  priority: string;
+  label: string;
+  tasks: GanttTask[];
+};
+
+export type GanttData = {
+  specId: string;
+  groups: GanttGroup[];
+  totalEstimatedHours: number;
+  timelineStart: number;
+  timelineEnd: number;
+};
+
+type PriorityConfig = {
+  priority: string;
+  label: string;
+  isSerial: boolean;
+};
+
+const PRIORITY_CONFIGS: Record<string, PriorityConfig> = {
+  P0: { priority: "P0", label: "P0: Sequential", isSerial: true },
+  P1: { priority: "P1", label: "P1: Parallel", isSerial: false },
+  P2: { priority: "P2", label: "P2: Parallel", isSerial: false },
+  P3: { priority: "P3", label: "P3: Parallel", isSerial: false },
+};
+
+function getEstimatedHours(task: TaskEntry): number {
+  return task.estimatedHours ?? DEFAULT_HOURS;
+}
+
+function createGanttTask(
+  task: TaskEntry,
+  startOffset: number,
+  isCriticalPath: boolean,
+): GanttTask {
+  return {
+    id: String(task.number),
+    title: task.title,
+    issueNumber: task.number,
+    issueUrl: task.url,
+    priority: task.priority ?? "",
+    state: task.status,
+    estimatedHours: getEstimatedHours(task),
+    startOffset,
+    dependencies: [],
+    isCriticalPath,
+  };
+}
+
+function groupTasksByPriority(
+  tasks: TaskEntry[],
+): Map<string, TaskEntry[]> {
+  const groups = new Map<string, TaskEntry[]>();
+
+  for (const task of tasks) {
+    if (!task.priority) continue;
+    const existing = groups.get(task.priority) || [];
+    groups.set(task.priority, [...existing, task]);
+  }
+
+  return groups;
+}
+
+function calculateStartOffsets(taskGroups: Map<string, TaskEntry[]>): Map<string, number> {
+  const startOffsets = new Map<string, number>();
+
+  const p0Tasks = taskGroups.get("P0") || [];
+  const p1Tasks = taskGroups.get("P1") || [];
+  const p2Tasks = taskGroups.get("P2") || [];
+
+  const p0TotalTime = p0Tasks.reduce((sum, t) => sum + getEstimatedHours(t), 0);
+  const p1StartTime = p0TotalTime;
+  const p1MaxHours = p1Tasks.length > 0
+    ? Math.max(...p1Tasks.map(getEstimatedHours))
+    : 0;
+  const p2StartTime = p1Tasks.length > 0 ? p1StartTime + p1MaxHours : p1StartTime;
+  const p2MaxHours = p2Tasks.length > 0
+    ? Math.max(...p2Tasks.map(getEstimatedHours))
+    : 0;
+  const p3StartTime = p2Tasks.length > 0 ? p2StartTime + p2MaxHours : p2StartTime;
+
+  startOffsets.set("P0", 0);
+  startOffsets.set("P1", p1StartTime);
+  startOffsets.set("P2", p2StartTime);
+  startOffsets.set("P3", p3StartTime);
+
+  return startOffsets;
+}
+
+function createPriorityGroup(
+  priority: string,
+  tasks: TaskEntry[],
+  startOffset: number,
+  config: PriorityConfig,
+): GanttGroup {
+  let currentOffset = startOffset;
+  const ganttTasks = config.isSerial
+    ? tasks.map((task) => {
+        const ganttTask = createGanttTask(task, currentOffset, true);
+        currentOffset += getEstimatedHours(task);
+        return ganttTask;
+      })
+    : tasks.map((task) => createGanttTask(task, startOffset, false));
+
+  return {
+    priority,
+    label: config.label,
+    tasks: ganttTasks,
+  };
+}
+
+function calculateTimelineEnd(groups: GanttGroup[]): number {
+  const allTasks = groups.flatMap((g) => g.tasks);
+
+  if (allTasks.length === 0) {
+    return 0;
+  }
+
+  return Math.max(...allTasks.map((task) => task.startOffset + task.estimatedHours));
+}
+
+export function transformToGanttData(
+  specId: string,
+  tasks: TaskEntry[],
+): GanttData {
+  const taskGroups = groupTasksByPriority(tasks);
+  const startOffsets = calculateStartOffsets(taskGroups);
+
+  const groups: GanttGroup[] = [];
+
+  for (const [priority, config] of Object.entries(PRIORITY_CONFIGS)) {
+    const priorityTasks = taskGroups.get(priority);
+    if (priorityTasks && priorityTasks.length > 0) {
+      const startOffset = startOffsets.get(priority) || 0;
+      groups.push(createPriorityGroup(priority, priorityTasks, startOffset, config));
+    }
+  }
+
+  const totalEstimatedHours = groups
+    .flatMap((g) => g.tasks)
+    .reduce((sum, t) => sum + t.estimatedHours, 0);
+
+  return {
+    specId,
+    groups,
+    totalEstimatedHours,
+    timelineStart: 0,
+    timelineEnd: calculateTimelineEnd(groups),
+  };
+}

package/src/lib/get-repository.ts

@@ -0,0 +1,43 @@
+import type { RequirementRepository } from "./repository";
+import { LocalRequirementRepository } from "./local-repository";
+import type { SpecificationRepository } from "./specification-repository";
+import { LocalSpecificationRepository } from "./local-specification-repository";
+
+let instance: RequirementRepository | null = null;
+let specInstance: SpecificationRepository | null = null;
+
+export function getRepository(): RequirementRepository {
+  if (instance) {
+    return instance;
+  }
+
+  const dataSource = process.env.REQORD_DATA_SOURCE ?? "local";
+
+  switch (dataSource) {
+    case "local":
+      instance = new LocalRequirementRepository();
+      break;
+    default:
+      throw new Error(`Unknown REQORD_DATA_SOURCE: ${dataSource}`);
+  }
+
+  return instance;
+}
+
+export function getSpecificationRepository(): SpecificationRepository {
+  if (specInstance) {
+    return specInstance;
+  }
+
+  const dataSource = process.env.REQORD_DATA_SOURCE ?? "local";
+
+  switch (dataSource) {
+    case "local":
+      specInstance = new LocalSpecificationRepository();
+      break;
+    default:
+      throw new Error(`Unknown REQORD_DATA_SOURCE: ${dataSource}`);
+  }
+
+  return specInstance;
+}

package/src/lib/graph-data.ts

@@ -0,0 +1,161 @@
+import type { Requirement, Specification, TaskEntry } from "@reqord/shared";
+
+export type NodeType = "requirement" | "specification" | "issue";
+export type EdgeType = "dependency" | "implements" | "tracks";
+
+export type MultiLevelNode = {
+  id: string;
+  type: NodeType;
+  data: {
+    label: string;
+    status: string;
+    priority?: string;
+    issueNumber?: number;
+    issueUrl?: string;
+  };
+  position: { x: number; y: number };
+};
+
+export type MultiLevelEdge = {
+  id: string;
+  source: string;
+  target: string;
+  type: EdgeType;
+};
+
+export type MultiLevelGraphData = {
+  nodes: MultiLevelNode[];
+  edges: MultiLevelEdge[];
+};
+
+const COLUMN_X = {
+  requirement: 0,
+  specification: 400,
+  issue: 800,
+} as const;
+
+const NODE_SPACING = {
+  requirement: 120,
+  specification: 120,
+  issue: 80,
+} as const;
+
+function createRequirementNode(
+  req: Requirement,
+  index: number,
+): MultiLevelNode {
+  return {
+    id: req.id,
+    type: "requirement",
+    data: {
+      label: req.title,
+      status: req.status,
+      priority: req.priority,
+    },
+    position: { x: COLUMN_X.requirement, y: index * NODE_SPACING.requirement },
+  };
+}
+
+function createDependencyEdges(req: Requirement): MultiLevelEdge[] {
+  return req.dependencies.blockedBy.map((blockerId) => ({
+    id: `dep-${blockerId}-${req.id}`,
+    source: blockerId,
+    target: req.id,
+    type: "dependency" as const,
+  }));
+}
+
+function createSpecificationNode(
+  spec: Specification,
+  specIndex: number,
+): MultiLevelNode {
+  return {
+    id: spec.id,
+    type: "specification",
+    data: {
+      label: spec.id,
+      status: spec.status,
+    },
+    position: {
+      x: COLUMN_X.specification,
+      y: specIndex * NODE_SPACING.specification,
+    },
+  };
+}
+
+function createImplementsEdge(spec: Specification): MultiLevelEdge {
+  return {
+    id: `impl-${spec.id}-${spec.requirementId}`,
+    source: spec.id,
+    target: spec.requirementId,
+    type: "implements",
+  };
+}
+
+function createIssueNode(
+  task: TaskEntry,
+  specIndex: number,
+  issueIndex: number,
+): MultiLevelNode {
+  const issueId = `issue-${task.number}`;
+  return {
+    id: issueId,
+    type: "issue",
+    data: {
+      label: `Issue #${task.number}`,
+      status: task.status,
+      priority: task.priority,
+      issueNumber: task.number,
+      issueUrl: task.url,
+    },
+    position: {
+      x: COLUMN_X.issue,
+      y:
+        specIndex * NODE_SPACING.specification +
+        issueIndex * NODE_SPACING.issue,
+    },
+  };
+}
+
+function createTracksEdge(issueId: string, specId: string): MultiLevelEdge {
+  return {
+    id: `track-${issueId}-${specId}`,
+    source: issueId,
+    target: specId,
+    type: "tracks",
+  };
+}
+
+export function buildMultiLevelGraphData(
+  requirements: Requirement[],
+  specifications: Specification[],
+  tasks: TaskEntry[],
+): MultiLevelGraphData {
+  const nodes: MultiLevelNode[] = [];
+  const edges: MultiLevelEdge[] = [];
+  const addedIssueIds = new Set<string>();
+
+  requirements.forEach((req, index) => {
+    nodes.push(createRequirementNode(req, index));
+    edges.push(...createDependencyEdges(req));
+  });
+
+  specifications.forEach((spec, specIndex) => {
+    nodes.push(createSpecificationNode(spec, specIndex));
+    edges.push(createImplementsEdge(spec));
+
+    const specTasks = tasks.filter((t) =>
+      t.linkedTo.specifications.includes(spec.id),
+    );
+    specTasks.forEach((task, issueIndex) => {
+      const issueId = `issue-${task.number}`;
+      if (!addedIssueIds.has(issueId)) {
+        nodes.push(createIssueNode(task, specIndex, issueIndex));
+        addedIssueIds.add(issueId);
+      }
+      edges.push(createTracksEdge(issueId, spec.id));
+    });
+  });
+
+  return { nodes, edges };
+}

package/src/lib/id-generator.ts

@@ -0,0 +1,23 @@
+import { REQORD_DIR, REQUIREMENTS_DIR } from "@reqord/shared";
+import * as fs from "./file-system";
+
+export async function generateNextId(cwd: string): Promise<string> {
+  const reqDir = fs.joinPath(cwd, REQORD_DIR, REQUIREMENTS_DIR);
+  const files = await fs.readdirFiles(reqDir, (name) =>
+    /^req-\d{6}\.yaml$/.test(name),
+  );
+
+  let maxNum = 0;
+  for (const file of files) {
+    const match = file.match(/^req-(\d{6})\.yaml$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNum) {
+        maxNum = num;
+      }
+    }
+  }
+
+  const nextNum = maxNum + 1;
+  return `req-${String(nextNum).padStart(6, "0")}`;
+}

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

@@ -0,0 +1,36 @@
+import { FeedbackIndexSchema, type FeedbackEntry } from "@reqord/shared";
+import type { FeedbackRepository } from "./feedback-repository";
+import { readYAML, joinPath } from "./file-system";
+import { getIssuesDir } from "./reqord-root";
+
+export class LocalFeedbackRepository implements FeedbackRepository {
+  async findAll(): Promise<FeedbackEntry[]> {
+    const indexPath = joinPath(getIssuesDir(), "feedbacks.yaml");
+    try {
+      const raw = await readYAML<unknown>(indexPath);
+      const parsed = FeedbackIndexSchema.safeParse(raw);
+      if (!parsed.success) return [];
+      return parsed.data.feedbacks;
+    } catch {
+      return [];
+    }
+  }
+
+  async findUnresolvedByArtifactId(artifactId: string): Promise<FeedbackEntry[]> {
+    const feedbacks = await this.findAll();
+    return feedbacks.filter((f) => {
+      const linked = [
+        ...f.linkedTo.requirements,
+        ...(f.linkedTo.createdRequirements ?? []),
+        ...f.linkedTo.specifications,
+        ...(f.linkedTo.createdSpecifications ?? []),
+      ];
+      if (!linked.includes(artifactId)) return false;
+      const resolved = [
+        ...(f.linkedTo.resolved?.requirements ?? []),
+        ...(f.linkedTo.resolved?.specifications ?? []),
+      ];
+      return !resolved.includes(artifactId);
+    });
+  }
+}

package/src/lib/local-repository.ts

@@ -0,0 +1,78 @@
+import { RequirementSchema, type Requirement } from "@reqord/shared";
+import type { RequirementRepository } from "./repository";
+import * as fs from "./file-system";
+import { generateNextId } from "./id-generator";
+import { getReqordRoot, getRequirementsDir } from "./reqord-root";
+
+export class LocalRequirementRepository implements RequirementRepository {
+  async findAll(): Promise<Requirement[]> {
+    const reqDir = getRequirementsDir();
+    const files = await fs.readdirFiles(reqDir, (name) =>
+      /^req-\d{6}\.yaml$/.test(name),
+    );
+
+    const requirements: Requirement[] = [];
+    for (const file of files.sort()) {
+      const raw = await fs.readYAML<unknown>(fs.joinPath(reqDir, file));
+      const result = RequirementSchema.safeParse(raw);
+      if (result.success) {
+        requirements.push(result.data);
+      }
+    }
+    return requirements;
+  }
+
+  async findById(id: string): Promise<Requirement | null> {
+    const reqDir = getRequirementsDir();
+    const yamlPath = fs.joinPath(reqDir, `${id}.yaml`);
+
+    if (!(await fs.exists(yamlPath))) {
+      return null;
+    }
+
+    const raw = await fs.readYAML<unknown>(yamlPath);
+    const result = RequirementSchema.safeParse(raw);
+    if (!result.success) {
+      throw new Error(`Invalid requirement ${id}: ${result.error.message}`);
+    }
+    return result.data;
+  }
+
+  async loadDescription(id: string): Promise<string | null> {
+    const reqDir = getRequirementsDir();
+    const descPath = fs.joinPath(reqDir, id, "description.md");
+
+    if (!(await fs.exists(descPath))) {
+      return null;
+    }
+
+    return fs.readText(descPath);
+  }
+
+  async save(requirement: Requirement): Promise<void> {
+    const reqDir = getRequirementsDir();
+    await fs.mkdirp(reqDir);
+    const yamlPath = fs.joinPath(reqDir, `${requirement.id}.yaml`);
+    await fs.writeYAML(yamlPath, requirement);
+  }
+
+  async saveDescription(id: string, content: string): Promise<void> {
+    const reqDir = getRequirementsDir();
+    const descDir = fs.joinPath(reqDir, id);
+    await fs.mkdirp(descDir);
+    await fs.writeText(fs.joinPath(descDir, "description.md"), content);
+  }
+
+  async deleteById(id: string): Promise<void> {
+    const reqDir = getRequirementsDir();
+    const yamlPath = fs.joinPath(reqDir, `${id}.yaml`);
+    const descDir = fs.joinPath(reqDir, id);
+
+    await fs.remove(yamlPath);
+    await fs.remove(descDir);
+  }
+
+  async generateNextId(): Promise<string> {
+    return generateNextId(getReqordRoot());
+  }
+}

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

@@ -0,0 +1,61 @@
+import { SpecificationSchema, type Specification } from "@reqord/shared";
+import type { SpecificationRepository } from "./specification-repository";
+import * as fs from "./file-system";
+import { getSpecificationsDir } from "./reqord-root";
+
+export class LocalSpecificationRepository implements SpecificationRepository {
+  async findAll(): Promise<Specification[]> {
+    const specDir = getSpecificationsDir();
+    const files = await fs.readdirFiles(specDir, (name) =>
+      /^spec-\d{6}\.yaml$/.test(name),
+    );
+
+    const specifications: Specification[] = [];
+    for (const file of files.sort()) {
+      try {
+        const raw = await fs.readYAML<unknown>(fs.joinPath(specDir, file));
+        const result = SpecificationSchema.safeParse(raw);
+        if (result.success) {
+          specifications.push(result.data);
+        }
+      } catch {
+        // Skip files with invalid YAML
+      }
+    }
+    return specifications;
+  }
+
+  async findById(id: string): Promise<Specification | null> {
+    const specDir = getSpecificationsDir();
+    const yamlPath = fs.joinPath(specDir, `${id}.yaml`);
+
+    if (!(await fs.exists(yamlPath))) {
+      return null;
+    }
+
+    const raw = await fs.readYAML<unknown>(yamlPath);
+    const result = SpecificationSchema.safeParse(raw);
+    if (!result.success) {
+      throw new Error(`Invalid specification ${id}: ${result.error.message}`);
+    }
+    return result.data;
+  }
+
+  async loadDesign(id: string): Promise<string | null> {
+    const specDir = getSpecificationsDir();
+    const designPath = fs.joinPath(specDir, id, "design.md");
+
+    if (!(await fs.exists(designPath))) {
+      return null;
+    }
+
+    return fs.readText(designPath);
+  }
+
+  async findByRequirementId(
+    requirementId: string,
+  ): Promise<Specification[]> {
+    const all = await this.findAll();
+    return all.filter((spec) => spec.requirementId === requirementId);
+  }
+}

package/src/lib/repository.ts

@@ -0,0 +1,11 @@
+import type { Requirement } from "@reqord/shared";
+
+export interface RequirementRepository {
+  findAll(): Promise<Requirement[]>;
+  findById(id: string): Promise<Requirement | null>;
+  loadDescription(id: string): Promise<string | null>;
+  save(requirement: Requirement): Promise<void>;
+  saveDescription(id: string, content: string): Promise<void>;
+  deleteById(id: string): Promise<void>;
+  generateNextId(): Promise<string>;
+}

package/src/lib/reqord-root.ts

@@ -0,0 +1,33 @@
+import { REQORD_DIR, SPECIFICATIONS_DIR, ISSUES_DIR } from "@reqord/shared";
+import * as fs from "./file-system";
+
+let cachedRoot: string | null = null;
+
+export function getReqordRoot(): string {
+  if (cachedRoot) {
+    return cachedRoot;
+  }
+
+  const envRoot = process.env.REQORD_ROOT;
+  if (!envRoot) {
+    throw new Error(
+      "REQORD_ROOT environment variable is not set. " +
+        "Set it to the project root containing .reqord/ directory.",
+    );
+  }
+
+  cachedRoot = envRoot;
+  return cachedRoot;
+}
+
+export function getRequirementsDir(): string {
+  return fs.joinPath(getReqordRoot(), REQORD_DIR, "requirements");
+}
+
+export function getSpecificationsDir(): string {
+  return fs.joinPath(getReqordRoot(), REQORD_DIR, SPECIFICATIONS_DIR);
+}
+
+export function getIssuesDir(): string {
+  return fs.joinPath(getReqordRoot(), REQORD_DIR, ISSUES_DIR);
+}

package/src/lib/specification-data.ts

@@ -0,0 +1,28 @@
+import type { Specification } from "@reqord/shared";
+import { getSpecificationRepository } from "./get-repository";
+
+export async function getAllSpecifications(): Promise<Specification[]> {
+  const repo = getSpecificationRepository();
+  return repo.findAll();
+}
+
+export async function getSpecificationById(
+  id: string,
+): Promise<Specification | null> {
+  const repo = getSpecificationRepository();
+  return repo.findById(id);
+}
+
+export async function getSpecificationDesign(
+  id: string,
+): Promise<string | null> {
+  const repo = getSpecificationRepository();
+  return repo.loadDesign(id);
+}
+
+export async function getSpecificationsByRequirementId(
+  requirementId: string,
+): Promise<Specification[]> {
+  const repo = getSpecificationRepository();
+  return repo.findByRequirementId(requirementId);
+}

package/src/lib/specification-file.ts

@@ -0,0 +1,12 @@
+import * as fs from "./file-system";
+import { getSpecificationsDir } from "./reqord-root";
+
+export async function loadSpecFile(
+  specId: string,
+  filename: string,
+): Promise<string | null> {
+  const specDir = getSpecificationsDir();
+  const filePath = fs.joinPath(specDir, specId, filename);
+  if (!(await fs.exists(filePath))) return null;
+  return fs.readText(filePath);
+}

package/src/lib/specification-repository.ts

@@ -0,0 +1,8 @@
+import type { Specification } from "@reqord/shared";
+
+export interface SpecificationRepository {
+  findAll(): Promise<Specification[]>;
+  findById(id: string): Promise<Specification | null>;
+  loadDesign(id: string): Promise<string | null>;
+  findByRequirementId(requirementId: string): Promise<Specification[]>;
+}

package/src/lib/tasks-data.ts

@@ -0,0 +1,32 @@
+import {
+  TasksIndexSchema,
+  type TaskEntry,
+  type TasksIndex,
+  REQORD_DIR,
+  ISSUES_DIR,
+} from "@reqord/shared";
+import * as fs from "./file-system";
+import { getReqordRoot } from "./reqord-root";
+
+export function getTasksFilePath(): string {
+  return fs.joinPath(getReqordRoot(), REQORD_DIR, ISSUES_DIR, "tasks.yaml");
+}
+
+export async function loadTasksYaml(): Promise<TasksIndex> {
+  const filePath = getTasksFilePath();
+  try {
+    const raw = await fs.readYAML<unknown>(filePath);
+    const parsed = TasksIndexSchema.safeParse(raw);
+    if (!parsed.success) {
+      return { title: "Tasks", tasks: [] };
+    }
+    return parsed.data;
+  } catch {
+    return { title: "Tasks", tasks: [] };
+  }
+}
+
+export async function getAllTasks(): Promise<TaskEntry[]> {
+  const index = await loadTasksYaml();
+  return index.tasks;
+}