@picoai/tickets 0.3.0 → 0.4.0

package/src/lib/validation.js

@@ -432,6 +432,224 @@ export function validateTicket(ticketPath, allFields = false) {
   return [issues, frontMatter, body];
 }
 
+function loadPlanningRows(ticketPaths) {
+  const rows = [];
+
+  for (const ticketPath of ticketPaths) {
+    try {
+      const [frontMatter] = loadTicket(ticketPath);
+      rows.push({
+        ticket_path: ticketPath,
+        id: frontMatter.id ?? "",
+        status: frontMatter.status ?? "",
+        dependencies: Array.isArray(frontMatter.dependencies) ? frontMatter.dependencies : [],
+        blocks: Array.isArray(frontMatter.blocks) ? frontMatter.blocks : [],
+        related: Array.isArray(frontMatter.related) ? frontMatter.related : [],
+        planning: {
+          node_type: frontMatter.planning?.node_type ?? "work",
+          group_ids: Array.isArray(frontMatter.planning?.group_ids) ? frontMatter.planning.group_ids : [],
+          lane: frontMatter.planning?.lane ?? null,
+          rank: frontMatter.planning?.rank ?? null,
+          horizon: frontMatter.planning?.horizon ?? null,
+          precedes: Array.isArray(frontMatter.planning?.precedes) ? frontMatter.planning.precedes : [],
+        },
+      });
+    } catch {
+      // Ticket parsing errors are already surfaced by validateTicket.
+    }
+  }
+
+  return rows;
+}
+
+function relationshipIssue(ticketPath, code, message) {
+  return {
+    severity: "error",
+    code,
+    message,
+    ticket_path: ticketPath,
+  };
+}
+
+function collectCycleNodes(adjacency) {
+  const state = new Map();
+  const cycleNodes = new Set();
+  const stack = [];
+
+  function visit(nodeId) {
+    const status = state.get(nodeId) ?? 0;
+    if (status === 1) {
+      const startIndex = stack.indexOf(nodeId);
+      for (const entry of stack.slice(startIndex)) {
+        cycleNodes.add(entry);
+      }
+      cycleNodes.add(nodeId);
+      return;
+    }
+    if (status === 2) {
+      return;
+    }
+
+    state.set(nodeId, 1);
+    stack.push(nodeId);
+    for (const nextId of adjacency.get(nodeId) ?? []) {
+      visit(nextId);
+    }
+    stack.pop();
+    state.set(nodeId, 2);
+  }
+
+  for (const nodeId of adjacency.keys()) {
+    visit(nodeId);
+  }
+
+  return cycleNodes;
+}
+
+export function validatePlanningTopology(targetTicketPaths, allTicketPaths = targetTicketPaths) {
+  const issues = [];
+  const allRows = loadPlanningRows(allTicketPaths);
+  const rowsById = new Map(allRows.map((row) => [row.id, row]));
+  const targetPaths = new Set(targetTicketPaths);
+  const targetRows = allRows.filter((row) => targetPaths.has(row.ticket_path));
+
+  for (const row of targetRows) {
+    for (const [key, values] of [
+      ["dependencies", row.dependencies],
+      ["blocks", row.blocks],
+      ["related", row.related],
+    ]) {
+      for (const relationId of values) {
+        if (typeof relationId === "string" && isUuidv7(relationId) && !rowsById.has(relationId)) {
+          issues.push(
+            relationshipIssue(row.ticket_path, "RELATIONSHIP_TARGET_MISSING", `${key} references missing ticket ${relationId}`),
+          );
+        }
+      }
+    }
+
+    for (const relationId of row.planning.group_ids) {
+      if (typeof relationId === "string" && isUuidv7(relationId) && !rowsById.has(relationId)) {
+        issues.push(
+          relationshipIssue(
+            row.ticket_path,
+            "PLANNING_TARGET_MISSING",
+            `planning.group_ids references missing ticket ${relationId}`,
+          ),
+        );
+        continue;
+      }
+      const target = rowsById.get(relationId);
+      if (target && !["group", "checkpoint"].includes(target.planning.node_type)) {
+        issues.push(
+          relationshipIssue(
+            row.ticket_path,
+            "PLANNING_GROUP_TARGET_INVALID",
+            `planning.group_ids must reference a group or checkpoint ticket: ${relationId}`,
+          ),
+        );
+      }
+    }
+
+    for (const relationId of row.planning.precedes) {
+      if (typeof relationId === "string" && isUuidv7(relationId) && !rowsById.has(relationId)) {
+        issues.push(
+          relationshipIssue(
+            row.ticket_path,
+            "PLANNING_TARGET_MISSING",
+            `planning.precedes references missing ticket ${relationId}`,
+          ),
+        );
+        continue;
+      }
+      if (relationId === row.id) {
+        issues.push(
+          relationshipIssue(
+            row.ticket_path,
+            "PLANNING_PRECEDES_SELF_REFERENCE",
+            "planning.precedes must not contain the ticket's own id",
+          ),
+        );
+      }
+    }
+  }
+
+  const precedesAdjacency = new Map();
+  for (const row of allRows) {
+    precedesAdjacency.set(row.id, [...row.planning.precedes]);
+  }
+  const precedesCycles = collectCycleNodes(precedesAdjacency);
+  for (const row of targetRows) {
+    if (precedesCycles.has(row.id)) {
+      issues.push(
+        relationshipIssue(row.ticket_path, "PLANNING_PRECEDES_CYCLE", "planning.precedes contains a cycle"),
+      );
+    }
+  }
+
+  const groupAdjacency = new Map();
+  for (const row of allRows) {
+    if (!["group", "checkpoint"].includes(row.planning.node_type)) {
+      continue;
+    }
+    const edges = row.planning.group_ids.filter((groupId) => {
+      const target = rowsById.get(groupId);
+      return target && ["group", "checkpoint"].includes(target.planning.node_type);
+    });
+    groupAdjacency.set(row.id, edges);
+  }
+  const groupCycles = collectCycleNodes(groupAdjacency);
+  for (const row of targetRows) {
+    if (groupCycles.has(row.id)) {
+      issues.push(
+        relationshipIssue(
+          row.ticket_path,
+          "PLANNING_GROUP_CYCLE",
+          "group/checkpoint membership contains a cycle",
+        ),
+      );
+    }
+  }
+
+  const ranksByScope = new Map();
+  for (const row of allRows) {
+    if (!Number.isInteger(row.planning.rank)) {
+      continue;
+    }
+    const scopeKey = JSON.stringify({
+      node_type: row.planning.node_type,
+      group_ids: [...row.planning.group_ids].sort((a, b) => a.localeCompare(b)),
+      lane: row.planning.lane ?? null,
+      horizon: row.planning.horizon ?? null,
+      rank: row.planning.rank,
+    });
+    if (!ranksByScope.has(scopeKey)) {
+      ranksByScope.set(scopeKey, []);
+    }
+    ranksByScope.get(scopeKey).push(row);
+  }
+
+  for (const rows of ranksByScope.values()) {
+    if (rows.length < 2) {
+      continue;
+    }
+    for (const row of rows) {
+      if (!targetPaths.has(row.ticket_path)) {
+        continue;
+      }
+      issues.push(
+        relationshipIssue(
+          row.ticket_path,
+          "PLANNING_RANK_CONFLICT",
+          "planning.rank conflicts with another ticket in the same peer set",
+        ),
+      );
+    }
+  }
+
+  return issues;
+}
+
 export function validateRunLog(logPath, machineStrictDefault) {
   const issues = [];
   const filename = path.basename(logPath);