@grainulation/orchard 1.0.1 → 1.0.2

package/lib/planner.js

@@ -1,6 +1,6 @@
-'use strict';
+"use strict";
 
-const path = require('node:path');
+const path = require("node:path");
 
 /**
  * Build an adjacency list from sprint dependencies.
@@ -66,8 +66,12 @@ function topoSort(config) {
   }
 
   if (order.length !== sprints.length) {
-    const remaining = sprints.map((s) => s.path).filter((p) => !order.includes(p));
-    throw new Error(`Dependency cycle detected involving: ${remaining.join(', ')}`);
+    const remaining = sprints
+      .map((s) => s.path)
+      .filter((p) => !order.includes(p));
+    throw new Error(
+      `Dependency cycle detected involving: ${remaining.join(", ")}`,
+    );
   }
 
   return order;
@@ -92,14 +96,14 @@ function printDependencyGraph(config, root) {
   const sprints = config.sprints || [];
 
   if (sprints.length === 0) {
-    console.log('No sprints configured in orchard.json.');
+    console.log("No sprints configured in orchard.json.");
     return;
   }
 
-  console.log('');
+  console.log("");
   console.log(`  Sprint Dependency Graph (${sprints.length} sprints)`);
-  console.log('  ' + '='.repeat(50));
-  console.log('');
+  console.log("  " + "=".repeat(50));
+  console.log("");
 
   // Build lookup
   const byPath = new Map();
@@ -137,20 +141,23 @@ function printDependencyGraph(config, root) {
 
   for (let level = 0; level <= maxLevel; level++) {
     const items = levels.get(level) || [];
-    const prefix = level === 0 ? 'ROOT' : `L${level}  `;
+    const prefix = level === 0 ? "ROOT" : `L${level}  `;
 
     for (const p of items) {
       const s = byPath.get(p);
       const name = path.basename(p);
-      const status = s.status || 'unknown';
-      const assignee = s.assigned_to || 'unassigned';
-      const indent = '  '.repeat(level + 1);
+      const status = s.status || "unknown";
+      const assignee = s.assigned_to || "unassigned";
+      const indent = "  ".repeat(level + 1);
 
       const marker =
-        status === 'active' ? '[*]' :
-        status === 'done' ? '[x]' :
-        status === 'blocked' ? '[!]' :
-        '[ ]';
+        status === "active"
+          ? "[*]"
+          : status === "done"
+            ? "[x]"
+            : status === "blocked"
+              ? "[!]"
+              : "[ ]";
 
       console.log(`${indent}${marker} ${name} (${assignee})`);
 
@@ -161,28 +168,149 @@ function printDependencyGraph(config, root) {
     }
 
     if (level < maxLevel) {
-      console.log('  ' + ' '.repeat(level * 2) + '  |');
+      console.log("  " + " ".repeat(level * 2) + "  |");
     }
   }
 
-  console.log('');
+  console.log("");
 
   // Show deadline summary
   const withDeadlines = sprints.filter((s) => s.deadline);
   if (withDeadlines.length > 0) {
-    console.log('  Deadlines:');
+    console.log("  Deadlines:");
     withDeadlines
       .sort((a, b) => a.deadline.localeCompare(b.deadline))
       .forEach((s) => {
         const name = path.basename(s.path);
         const days = daysUntil(s.deadline);
-        const urgency = days < 0 ? 'OVERDUE' : days <= 3 ? 'URGENT' : `${days}d`;
+        const urgency =
+          days < 0 ? "OVERDUE" : days <= 3 ? "URGENT" : `${days}d`;
         console.log(`    ${name}: ${s.deadline} (${urgency})`);
       });
-    console.log('');
+    console.log("");
   }
 }
 
+/**
+ * Generate a Mermaid diagram string for the sprint dependency graph.
+ * Color-coded nodes: green (done/compiled), blue (active), amber (blocked), red (cycle).
+ * Highlights critical path with thick edges.
+ */
+function generateMermaid(config) {
+  const sprints = config.sprints || [];
+  if (sprints.length === 0) return 'graph TD\n  empty["No sprints configured"]';
+
+  const lines = ["graph TD"];
+
+  // Style definitions for status colors
+  lines.push("  classDef done fill:#22c55e,stroke:#16a34a,color:#fff");
+  lines.push("  classDef compiled fill:#22c55e,stroke:#16a34a,color:#fff");
+  lines.push("  classDef active fill:#3b82f6,stroke:#2563eb,color:#fff");
+  lines.push("  classDef blocked fill:#f59e0b,stroke:#d97706,color:#fff");
+  lines.push("  classDef notstarted fill:#6b7280,stroke:#4b5563,color:#fff");
+  lines.push("  classDef conflict fill:#ef4444,stroke:#dc2626,color:#fff");
+
+  const byPath = new Map();
+  for (const s of sprints) byPath.set(s.path, s);
+
+  // Sanitize path into a valid Mermaid node ID
+  function nodeId(p) {
+    return p.replace(/[^a-zA-Z0-9]/g, "_");
+  }
+
+  function nodeLabel(s) {
+    const name = path.basename(s.path);
+    const status = s.status || "unknown";
+    const assignee = s.assigned_to ? ` (${s.assigned_to})` : "";
+    return `${name}${assignee}\\n${status}`;
+  }
+
+  // Detect cycles for marking
+  const cycleSet = new Set(detectCycles(config));
+
+  // Compute critical path (longest path lengths)
+  let criticalEdges = new Set();
+  try {
+    const order = topoSort(config);
+    const dist = new Map();
+    const prev = new Map();
+    for (const p of order) dist.set(p, 0);
+
+    for (const p of order) {
+      const s = byPath.get(p);
+      for (const dep of s.depends_on || []) {
+        if (dist.has(dep) && dist.get(dep) + 1 > dist.get(p)) {
+          dist.set(p, dist.get(dep) + 1);
+          prev.set(p, dep);
+        }
+      }
+    }
+
+    // Find the node with max distance — that's the end of critical path
+    let maxNode = null;
+    let maxDist = 0;
+    for (const [p, d] of dist) {
+      if (d >= maxDist) {
+        maxDist = d;
+        maxNode = p;
+      }
+    }
+
+    // Walk back to build critical path edges
+    let cur = maxNode;
+    while (cur && prev.has(cur)) {
+      const from = prev.get(cur);
+      criticalEdges.add(`${nodeId(from)}-->${nodeId(cur)}`);
+      cur = from;
+    }
+  } catch {
+    // cycles — no critical path
+  }
+
+  // Node declarations
+  for (const s of sprints) {
+    const id = nodeId(s.path);
+    const label = nodeLabel(s);
+    lines.push(`  ${id}["${label}"]`);
+  }
+
+  // Edges
+  for (const s of sprints) {
+    for (const dep of s.depends_on || []) {
+      if (!byPath.has(dep)) continue;
+      const edgeKey = `${nodeId(dep)}-->${nodeId(s.path)}`;
+      if (criticalEdges.has(edgeKey)) {
+        lines.push(`  ${nodeId(dep)} ==> ${nodeId(s.path)}`);
+      } else {
+        lines.push(`  ${nodeId(dep)} --> ${nodeId(s.path)}`);
+      }
+    }
+  }
+
+  // Apply classes
+  for (const s of sprints) {
+    const id = nodeId(s.path);
+    if (cycleSet.length > 0 && cycleSet.has(s.path)) {
+      lines.push(`  class ${id} conflict`);
+    } else {
+      const status = s.status || "unknown";
+      const cls =
+        status === "done"
+          ? "done"
+          : status === "compiled"
+            ? "compiled"
+            : status === "active"
+              ? "active"
+              : status === "blocked"
+                ? "blocked"
+                : "notstarted";
+      lines.push(`  class ${id} ${cls}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
 function daysUntil(dateStr) {
   const target = new Date(dateStr);
   const now = new Date();
@@ -194,5 +322,6 @@ module.exports = {
   topoSort,
   detectCycles,
   printDependencyGraph,
+  generateMermaid,
   daysUntil,
 };