@reqord/web 0.1.0

package/src/lib/dashboard-data.ts

@@ -0,0 +1,224 @@
+import type { Requirement, Specification, TaskEntry } from "@reqord/shared";
+import { getAllRequirements } from "./data";
+import { getAllSpecifications } from "./specification-data";
+import { loadTasksYaml } from "./tasks-data";
+import { getAllFeedbacks } from "./feedback-data";
+
+export type Warning = {
+  type:
+    | "missing_specification"
+    | "unapproved_dependency"
+    | "design_verification_error";
+  message: string;
+  severity: "error" | "warning" | "info";
+  relatedId: string;
+};
+
+export type CriticalPathItem = {
+  issueNumber: number;
+  title: string;
+  url: string;
+  priority: string;
+  status: string;
+  estimatedHours: number;
+  specId: string;
+};
+
+export type StatusBreakdown = Record<string, number>;
+
+export type CategorySummary = {
+  total: number;
+  breakdown: StatusBreakdown;
+  approvalRate: number;
+};
+
+export type IssueSummary = {
+  total: number;
+  completed: number;
+  completionRate: number;
+};
+
+export type DashboardData = {
+  requirements: CategorySummary;
+  specifications: CategorySummary;
+  issues: IssueSummary;
+  healthScore: number;
+  warnings: Warning[];
+  criticalPath: CriticalPathItem[] | null;
+};
+
+// Health score weights
+const HEALTH_WEIGHTS = {
+  requirements: 40,
+  specifications: 30,
+  issues: 30,
+} as const;
+
+function isApproved(status: string): boolean {
+  return status === "approved" || status === "implemented";
+}
+
+export function groupByStatus(
+  items: Array<{ status: string }>
+): Record<string, number> {
+  const result: Record<string, number> = {};
+
+  for (const item of items) {
+    result[item.status] = (result[item.status] || 0) + 1;
+  }
+
+  return result;
+}
+
+function calculateApprovalRate(items: Array<{ status: string }>): number {
+  if (items.length === 0) {
+    return 0;
+  }
+
+  const approvedCount = items.filter((item) => isApproved(item.status)).length;
+
+  return approvedCount / items.length;
+}
+
+function calculateIssueSummary(tasks: TaskEntry[]): IssueSummary {
+  const totalIssues = tasks.length;
+  const completedIssues = tasks.filter((t) => t.status === "closed").length;
+
+  return {
+    total: totalIssues,
+    completed: completedIssues,
+    completionRate: totalIssues > 0 ? completedIssues / totalIssues : 0,
+  };
+}
+
+export async function detectWarnings(
+  requirements: Requirement[],
+  specifications: Specification[]
+): Promise<Warning[]> {
+  const warnings: Warning[] = [];
+  const allFeedbacks = await getAllFeedbacks();
+
+  const specsByReqId = new Map<string, Specification[]>();
+  for (const spec of specifications) {
+    const specs = specsByReqId.get(spec.requirementId) || [];
+    specs.push(spec);
+    specsByReqId.set(spec.requirementId, specs);
+  }
+
+  const reqMap = new Map<string, Requirement>();
+  for (const req of requirements) {
+    reqMap.set(req.id, req);
+  }
+
+  for (const req of requirements) {
+    if (req.status !== "draft") {
+      const specs = specsByReqId.get(req.id);
+      if (!specs || specs.length === 0) {
+        warnings.push({
+          type: "missing_specification",
+          message: `Requirement ${req.id} has no specification`,
+          severity: "warning",
+          relatedId: req.id,
+        });
+      }
+    }
+  }
+
+  for (const req of requirements) {
+    for (const depId of req.dependencies.blockedBy) {
+      const dep = reqMap.get(depId);
+      if (dep && !isApproved(dep.status)) {
+        warnings.push({
+          type: "unapproved_dependency",
+          message: `Requirement ${req.id} is blocked by unapproved requirement ${depId}`,
+          severity: "warning",
+          relatedId: req.id,
+        });
+      }
+    }
+  }
+
+  for (const spec of specifications) {
+    const unresolvedFeedbacks = allFeedbacks.filter((f) => {
+      const linked = f.linkedTo.specifications.includes(spec.id)
+        || (f.linkedTo.createdSpecifications ?? []).includes(spec.id);
+      const resolved = f.linkedTo.resolved?.specifications?.includes(spec.id) ?? false;
+      return linked && !resolved;
+    });
+
+    const hasCriticalFeedback = unresolvedFeedbacks.some(
+      (f) => f.severity === "critical" || f.severity === "high"
+    );
+
+    if (hasCriticalFeedback) {
+      warnings.push({
+        type: "design_verification_error",
+        message: `Specification ${spec.id} has critical/high unresolved feedback requiring attention`,
+        severity: "error",
+        relatedId: spec.id,
+      });
+    }
+  }
+
+  return warnings;
+}
+
+export function extractCriticalPath(
+  tasks: TaskEntry[]
+): CriticalPathItem[] | null {
+  if (tasks.length === 0) {
+    return null;
+  }
+
+  const items: CriticalPathItem[] = tasks.map((task) => ({
+    issueNumber: task.number,
+    title: task.title,
+    url: task.url,
+    priority: task.priority ?? "",
+    status: task.status,
+    estimatedHours: task.estimatedHours ?? 0,
+    specId: task.linkedTo.specifications[0] ?? "",
+  }));
+
+  return items;
+}
+
+export async function getDashboardData(): Promise<DashboardData> {
+  const requirements = await getAllRequirements();
+  const specifications = await getAllSpecifications();
+  const tasksIndex = await loadTasksYaml();
+  const allTasks = tasksIndex.tasks;
+
+  const requirementsBreakdown = groupByStatus(requirements);
+  const requirementsApprovalRate = calculateApprovalRate(requirements);
+
+  const specificationsBreakdown = groupByStatus(specifications);
+  const specificationsApprovalRate = calculateApprovalRate(specifications);
+
+  const issues = calculateIssueSummary(allTasks);
+
+  const healthScore =
+    requirementsApprovalRate * HEALTH_WEIGHTS.requirements +
+    specificationsApprovalRate * HEALTH_WEIGHTS.specifications +
+    issues.completionRate * HEALTH_WEIGHTS.issues;
+
+  const warnings = await detectWarnings(requirements, specifications);
+  const criticalPath = extractCriticalPath(allTasks);
+
+  return {
+    requirements: {
+      total: requirements.length,
+      breakdown: requirementsBreakdown,
+      approvalRate: requirementsApprovalRate,
+    },
+    specifications: {
+      total: specifications.length,
+      breakdown: specificationsBreakdown,
+      approvalRate: specificationsApprovalRate,
+    },
+    issues,
+    healthScore,
+    warnings,
+    criticalPath,
+  };
+}

package/src/lib/data.ts

@@ -0,0 +1,21 @@
+import type { Requirement } from "@reqord/shared";
+import { getRepository } from "./get-repository";
+
+export async function getAllRequirements(): Promise<Requirement[]> {
+  const repo = getRepository();
+  return repo.findAll();
+}
+
+export async function getRequirementById(
+  id: string,
+): Promise<Requirement | null> {
+  const repo = getRepository();
+  return repo.findById(id);
+}
+
+export async function getRequirementDescription(
+  id: string,
+): Promise<string | null> {
+  const repo = getRepository();
+  return repo.loadDescription(id);
+}

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

@@ -0,0 +1,98 @@
+import type { Node, Edge } from "@xyflow/react";
+import type { Requirement, Specification, TaskEntry } from "@reqord/shared";
+import { EDGE_STYLES } from "@/components/graph/edge-styles";
+
+export interface DrillDownGraphData {
+  nodes: Node[];
+  edges: Edge[];
+}
+
+const LAYOUT = {
+  REQ_X: 0,
+  SPEC_X: 400,
+  ISSUE_X: 800,
+  VERTICAL_GAP: 120,
+  ISSUE_VERTICAL_GAP: 80,
+};
+
+export function buildDrillDownGraphData(
+  requirement: Requirement,
+  specifications: Specification[],
+  tasks: TaskEntry[],
+): DrillDownGraphData {
+  const nodes: Node[] = [];
+  const edges: Edge[] = [];
+
+  // 1. Requirement node (left)
+  nodes.push({
+    id: requirement.id,
+    type: "requirement",
+    position: { x: LAYOUT.REQ_X, y: 0 },
+    data: {
+      label: requirement.title,
+      status: requirement.status,
+      priority: requirement.priority,
+      specCount: specifications.length,
+    },
+  });
+
+  // 2. Specification nodes (middle column) + implements edges
+  const addedIssueIds = new Set<string>();
+  specifications.forEach((spec, i) => {
+    const specNodeId = spec.id;
+    nodes.push({
+      id: specNodeId,
+      type: "specification",
+      position: { x: LAYOUT.SPEC_X, y: i * LAYOUT.VERTICAL_GAP },
+      data: {
+        label: spec.id,
+        status: spec.status,
+      },
+    });
+
+    edges.push({
+      id: `impl-${requirement.id}-${specNodeId}`,
+      source: requirement.id,
+      target: specNodeId,
+      style: EDGE_STYLES.implements,
+      animated: false,
+    });
+
+    // 3. Issue nodes (right column) from tasks.yaml linked to this spec
+    const specTasks = tasks.filter((t) =>
+      t.linkedTo.specifications.includes(spec.id),
+    );
+    let issueOffset = 0;
+    specTasks.forEach((task) => {
+      const issueNodeId = `issue-${task.number}`;
+      if (!addedIssueIds.has(issueNodeId)) {
+        addedIssueIds.add(issueNodeId);
+        nodes.push({
+          id: issueNodeId,
+          type: "issue",
+          position: {
+            x: LAYOUT.ISSUE_X,
+            y: i * LAYOUT.VERTICAL_GAP + issueOffset * LAYOUT.ISSUE_VERTICAL_GAP,
+          },
+          data: {
+            label: task.title,
+            status: task.status,
+            issueNumber: task.number,
+            issueUrl: task.url,
+          },
+        });
+        issueOffset++;
+      }
+
+      edges.push({
+        id: `track-${specNodeId}-${issueNodeId}`,
+        source: specNodeId,
+        target: issueNodeId,
+        style: EDGE_STYLES.tracks,
+        animated: false,
+      });
+    });
+  });
+
+  return { nodes, edges };
+}

package/src/lib/feedback-data.ts

@@ -0,0 +1,33 @@
+import type { FeedbackEntry } from "@reqord/shared";
+import type { FeedbackRepository } from "./feedback-repository";
+import { LocalFeedbackRepository } from "./local-feedback-repository";
+
+let instance: FeedbackRepository | null = null;
+
+function getFeedbackRepository(): FeedbackRepository {
+  if (instance) {
+    return instance;
+  }
+
+  const dataSource = process.env.REQORD_DATA_SOURCE ?? "local";
+
+  switch (dataSource) {
+    case "local":
+      instance = new LocalFeedbackRepository();
+      break;
+    default:
+      throw new Error(`Unknown REQORD_DATA_SOURCE: ${dataSource}`);
+  }
+
+  return instance;
+}
+
+export async function getAllFeedbacks(): Promise<FeedbackEntry[]> {
+  const repo = getFeedbackRepository();
+  return repo.findAll();
+}
+
+export async function findUnresolvedByArtifactId(artifactId: string): Promise<FeedbackEntry[]> {
+  const repo = getFeedbackRepository();
+  return repo.findUnresolvedByArtifactId(artifactId);
+}

package/src/lib/feedback-repository.ts

@@ -0,0 +1,6 @@
+import type { FeedbackEntry } from "@reqord/shared";
+
+export interface FeedbackRepository {
+  findAll(): Promise<FeedbackEntry[]>;
+  findUnresolvedByArtifactId(artifactId: string): Promise<FeedbackEntry[]>;
+}

package/src/lib/file-system.ts

@@ -0,0 +1,167 @@
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  readdir,
+  access,
+  rm,
+} from "node:fs/promises";
+import { join } from "node:path";
+import { load as yamlLoad, dump as yamlDump, JSON_SCHEMA } from "js-yaml";
+
+export async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readText(path: string): Promise<string> {
+  return readFile(path, "utf-8");
+}
+
+export async function writeText(
+  path: string,
+  content: string,
+): Promise<void> {
+  await writeFile(path, content, "utf-8");
+}
+
+export async function mkdirp(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}
+
+export async function readdirFiles(
+  dirPath: string,
+  filter?: (name: string) => boolean,
+): Promise<string[]> {
+  try {
+    const entries = await readdir(dirPath);
+    return filter ? entries.filter(filter) : entries;
+  } catch {
+    return [];
+  }
+}
+
+export async function remove(path: string): Promise<void> {
+  await rm(path, { recursive: true, force: true });
+}
+
+export function joinPath(...segments: string[]): string {
+  return join(...segments);
+}
+
+export function fixUnquotedHash(content: string, filePath: string): string {
+  const lines = content.split("\n");
+  const fixedLines: string[] = [];
+  let modified = false;
+  let inBlockScalar = false;
+  let blockIndent = -1;
+
+  for (const line of lines) {
+    if (line.trim() === "") {
+      fixedLines.push(line);
+      continue;
+    }
+
+    if (/^\s*#/.test(line)) {
+      fixedLines.push(line);
+      continue;
+    }
+
+    if (/:\s+[>|][-+]?\s*$/.test(line)) {
+      inBlockScalar = true;
+      blockIndent = -1;
+      fixedLines.push(line);
+      continue;
+    }
+
+    if (inBlockScalar) {
+      const currentIndent = line.length - line.trimStart().length;
+      if (blockIndent === -1) {
+        blockIndent = currentIndent;
+        fixedLines.push(line);
+        continue;
+      }
+      if (currentIndent >= blockIndent && blockIndent > 0) {
+        fixedLines.push(line);
+        continue;
+      }
+      inBlockScalar = false;
+    }
+
+    if (!/ #\d/.test(line)) {
+      fixedLines.push(line);
+      continue;
+    }
+
+    const kvMatch = line.match(/^(\s*[\w-]+:\s+)('.*'|".*")\s*$/);
+    if (kvMatch) {
+      fixedLines.push(line);
+      continue;
+    }
+
+    const listMatch = line.match(/^(\s*-\s+)('.*'|".*")\s*$/);
+    if (listMatch) {
+      fixedLines.push(line);
+      continue;
+    }
+
+    const kvUnquoted = line.match(/^(\s*[\w-]+:\s+)(.+)$/);
+    if (kvUnquoted) {
+      const [, prefix, value] = kvUnquoted;
+      if (/ #\d/.test(value) && !(/^'.*'$/.test(value) || /^".*"$/.test(value))) {
+        const escaped = value.replace(/'/g, "''");
+        fixedLines.push(`${prefix}'${escaped}'`);
+        modified = true;
+        continue;
+      }
+    }
+
+    const listUnquoted = line.match(/^(\s*-\s+)(.+)$/);
+    if (listUnquoted) {
+      const [, prefix, value] = listUnquoted;
+      if (/ #\d/.test(value) && !(/^'.*'$/.test(value) || /^".*"$/.test(value))) {
+        const escaped = value.replace(/'/g, "''");
+        fixedLines.push(`${prefix}'${escaped}'`);
+        modified = true;
+        continue;
+      }
+    }
+
+    fixedLines.push(line);
+  }
+
+  if (modified) {
+    console.warn(
+      `[reqord] Warning: Auto-fixed unquoted ' #' in YAML plain scalar (${filePath}). Data would be silently truncated by js-yaml.`,
+    );
+  }
+
+  return fixedLines.join("\n");
+}
+
+export async function readYAML<T>(filePath: string): Promise<T> {
+  const content = await readFile(filePath, "utf-8");
+  const fixed = fixUnquotedHash(content, filePath);
+  try {
+    return yamlLoad(fixed, { schema: JSON_SCHEMA }) as T;
+  } catch (error) {
+    throw new Error(
+      `YAML構文エラー (${filePath}): ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export async function writeYAML(filePath: string, data: unknown): Promise<void> {
+  const yamlContent = yamlDump(data, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+    schema: JSON_SCHEMA,
+  });
+  await writeFile(filePath, yamlContent, "utf-8");
+}