bosun 0.40.2 → 0.40.3

package/task/task-store.mjs

@@ -429,6 +429,7 @@ function defaultMeta() {
     version: 1,
     projectId: null,
     lastFullSync: null,
+    epicDependencies: {},
     sprintOrderMode: "parallel",
     taskCount: 0,
     stats: {
@@ -808,6 +809,25 @@ function ensureSprintsMap() {
   return _store.sprints;
 }
 
+function ensureEpicDependenciesMap() {
+  if (!_store._meta || typeof _store._meta !== "object") {
+    _store._meta = defaultMeta();
+  }
+  if (!_store._meta.epicDependencies || typeof _store._meta.epicDependencies !== "object") {
+    _store._meta.epicDependencies = {};
+  }
+  const map = _store._meta.epicDependencies;
+  for (const [key, value] of Object.entries(map)) {
+    const epicId = String(key || "").trim();
+    if (!epicId) {
+      delete map[key];
+      continue;
+    }
+    map[epicId] = uniqueStringList(Array.isArray(value) ? value : []);
+  }
+  return map;
+}
+
 export function listSprints() {
   ensureLoaded();
   const sprints = Object.values(ensureSprintsMap());
@@ -1693,12 +1713,18 @@ export function getGlobalDagOfDags() {
       return String(a.to).localeCompare(String(b.to));
     });
 
+  const epicDependencies = getEpicDependencies();
+
   return {
     sprintOrderMode: mode,
     sprintCount: nodes.length,
     edgeCount: edges.length,
+    epicDependencies,
     nodes,
-    edges,
+    edges: edges.map((edge) => ({
+      ...edge,
+      kind: edge.taskLinks.some((link) => link?.type === 'sequence') ? 'sequential' : 'dependency',
+    })),
   };
 }
 
@@ -1706,6 +1732,54 @@ export function getDagOfDags() {
   return getGlobalDagOfDags();
 }
 
+export function getEpicDependencies() {
+  ensureLoaded();
+  const map = ensureEpicDependenciesMap();
+  return Object.entries(map).map(([epicId, dependencies]) => ({
+    epicId,
+    dependencies: uniqueStringList(Array.isArray(dependencies) ? dependencies : []),
+  }));
+}
+
+export function setEpicDependencies(epicId, dependencies = []) {
+  ensureLoaded();
+  const normalizedEpicId = String(epicId || '').trim();
+  if (!normalizedEpicId) return null;
+  const cleaned = uniqueStringList((Array.isArray(dependencies) ? dependencies : [])
+    .map((entry) => String(entry || '').trim())
+    .filter((entry) => entry && entry !== normalizedEpicId));
+  const map = ensureEpicDependenciesMap();
+  if (cleaned.length > 0) map[normalizedEpicId] = cleaned;
+  else delete map[normalizedEpicId];
+  saveStore();
+  return { epicId: normalizedEpicId, dependencies: [...(map[normalizedEpicId] || [])] };
+}
+
+export function addEpicDependency(epicId, dependencyEpicId) {
+  ensureLoaded();
+  const normalizedEpicId = String(epicId || '').trim();
+  const normalizedDependency = String(dependencyEpicId || '').trim();
+  if (!normalizedEpicId || !normalizedDependency || normalizedEpicId === normalizedDependency) return null;
+  const map = ensureEpicDependenciesMap();
+  const next = uniqueStringList([...(map[normalizedEpicId] || []), normalizedDependency]);
+  map[normalizedEpicId] = next;
+  saveStore();
+  return { epicId: normalizedEpicId, dependencies: [...next] };
+}
+
+export function removeEpicDependency(epicId, dependencyEpicId) {
+  ensureLoaded();
+  const normalizedEpicId = String(epicId || '').trim();
+  const normalizedDependency = String(dependencyEpicId || '').trim();
+  if (!normalizedEpicId || !normalizedDependency) return null;
+  const map = ensureEpicDependenciesMap();
+  const next = uniqueStringList((map[normalizedEpicId] || []).filter((entry) => entry !== normalizedDependency));
+  if (next.length > 0) map[normalizedEpicId] = next;
+  else delete map[normalizedEpicId];
+  saveStore();
+  return { epicId: normalizedEpicId, dependencies: [...(map[normalizedEpicId] || [])] };
+}
+
 export function canStartTask(taskId, options = {}) {
   return canTaskStart(taskId, options);
 }
@@ -1721,6 +1795,7 @@ export function canTaskStart(taskId, options = {}) {
       blockingTaskIds: [],
       missingDependencyTaskIds: [],
       blockingSprintIds: [],
+      blockingEpicIds: [],
       sprintOrderMode,
     };
   }
@@ -1732,6 +1807,7 @@ export function canTaskStart(taskId, options = {}) {
       blockingTaskIds: [],
       missingDependencyTaskIds: [],
       blockingSprintIds: [],
+      blockingEpicIds: [],
       sprintOrderMode,
     };
   }
@@ -1756,6 +1832,7 @@ export function canTaskStart(taskId, options = {}) {
       blockingTaskIds: uniqueStringList(blockingTaskIds),
       missingDependencyTaskIds: uniqueStringList(missingDependencyTaskIds),
       blockingSprintIds: [],
+      blockingEpicIds: [],
       sprintOrderMode,
     };
   }
@@ -1787,6 +1864,42 @@ export function canTaskStart(taskId, options = {}) {
           blockingTaskIds: uniqueStringList(blockingTaskIds),
           missingDependencyTaskIds: [],
           blockingSprintIds: [sprintId],
+          blockingEpicIds: [],
+          sprintOrderMode,
+          sprintTaskOrderMode,
+        };
+      }
+    }
+  }
+
+  const taskEpicId = String(task?.epicId || task?.meta?.epicId || '').trim();
+  if (taskEpicId) {
+    const epicDependenciesMap = ensureEpicDependenciesMap();
+    const requiredEpics = uniqueStringList(epicDependenciesMap[taskEpicId] || []);
+    if (requiredEpics.length > 0) {
+      const blockingEpicIds = [];
+      const blockingEpicTaskIds = [];
+      for (const requiredEpicId of requiredEpics) {
+        let hasIncomplete = false;
+        for (const candidate of Object.values(_store.tasks)) {
+          if (!candidate) continue;
+          const candidateEpicId = String(candidate?.epicId || candidate?.meta?.epicId || '').trim();
+          if (candidateEpicId !== requiredEpicId) continue;
+          if (!isTaskTerminal(candidate)) {
+            hasIncomplete = true;
+            blockingEpicTaskIds.push(candidate.id);
+          }
+        }
+        if (hasIncomplete) blockingEpicIds.push(requiredEpicId);
+      }
+      if (blockingEpicIds.length > 0) {
+        return {
+          canStart: false,
+          reason: "epic_dependencies_unresolved",
+          blockingTaskIds: uniqueStringList(blockingEpicTaskIds),
+          missingDependencyTaskIds: [],
+          blockingSprintIds: [],
+          blockingEpicIds: uniqueStringList(blockingEpicIds),
           sprintOrderMode,
           sprintTaskOrderMode,
         };
@@ -1818,6 +1931,7 @@ export function canTaskStart(taskId, options = {}) {
           blockingTaskIds: uniqueStringList(blockingTaskIds),
           missingDependencyTaskIds: [],
           blockingSprintIds: uniqueStringList(blockingSprintIds),
+          blockingEpicIds: [],
           sprintOrderMode,
           sprintTaskOrderMode,
         };
@@ -1831,6 +1945,7 @@ export function canTaskStart(taskId, options = {}) {
     blockingTaskIds: [],
     missingDependencyTaskIds: [],
     blockingSprintIds: [],
+    blockingEpicIds: [],
     sprintOrderMode,
   };
 }

package/ui/demo.html

@@ -2964,6 +2964,30 @@
         }
         return { ok: true, data: { nodes, edges } };
       }
+      if (route === '/api/tasks/epic-dependencies') {
+        const map = STATE.epicDependencies && typeof STATE.epicDependencies === 'object'
+          ? STATE.epicDependencies
+          : (STATE.epicDependencies = {});
+        if (method === 'GET') {
+          const data = Object.entries(map).map(([epicId, dependencies]) => ({
+            epicId,
+            dependencies: Array.isArray(dependencies)
+              ? dependencies.map((value) => String(value || '').trim()).filter(Boolean)
+              : [],
+          }));
+          return { ok: true, source: 'demo', data };
+        }
+        if (method === 'PUT') {
+          const epicId = String(body?.epicId || body?.id || '').trim();
+          if (!epicId) return { ok: false, error: 'epicId required' };
+          const dependencies = Array.isArray(body?.dependencies)
+            ? body.dependencies.map((value) => String(value || '').trim()).filter(Boolean).filter((value) => value !== epicId)
+            : [];
+          if (dependencies.length) map[epicId] = [...new Set(dependencies)];
+          else delete map[epicId];
+          return { ok: true, source: 'demo', data: { epicId, dependencies: map[epicId] || [] } };
+        }
+      }
       if (route === '/api/tasks/attachments/upload') {
         const taskId = body?.taskId || body?.id || params.get('taskId');
         const t = findTask(taskId);
@@ -3117,7 +3141,8 @@
           data: t,
           dag: { sprintId: t.sprintId || null, sprint: { nodes: [] }, global: { nodes: [] } },
         };
-      }      if (route === '/api/tasks/retry') {
+      }
+      if (route === '/api/tasks/retry') {
         const t = findTask(body?.taskId);
         if (t) { t.status = 'todo'; t.updated = Date.now(); addLog('info', 'task-executor', `Task retried: ${t.title}`); }
         return { ok: true, data: t || null };

package/ui/styles/components.css

@@ -5461,14 +5461,49 @@ select.input {
     radial-gradient(circle at 10% 20%, rgba(249, 115, 22, 0.12), transparent 40%),
     radial-gradient(circle at 85% 80%, rgba(56, 189, 248, 0.08), transparent 40%),
     var(--bg-card);
-  overflow: auto;
-  padding: 10px;
+  overflow: hidden;
+  padding: 8px;
+  min-height: 460px;
+  touch-action: none;
+  cursor: grab;
+}
+
+.task-dag-canvas-wrap.is-panning {
+  cursor: grabbing;
 }
 
 .task-dag-canvas {
   width: 100%;
   min-width: 680px;
-  height: 420px;
+  height: 460px;
+}
+
+.task-dag-header-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+
+.task-dag-controls {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+
+.task-dag-zoom-pill,
+.task-dag-wire-pill {
+  display: inline-flex;
+  align-items: center;
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  background: var(--bg-card-hover);
+  padding: 3px 8px;
+  font-size: 11px;
+  color: var(--text-secondary);
 }
 
 .dag-node rect {
@@ -5480,6 +5515,11 @@ select.input {
   filter: drop-shadow(0 6px 12px rgba(0, 0, 0, 0.35));
 }
 
+.dag-node-selected rect {
+  stroke: var(--accent);
+  filter: drop-shadow(0 0 0 2px rgba(56, 189, 248, 0.25));
+}
+
 @media (max-width: 900px) {
   .task-comment-composer {
     grid-template-columns: 1fr;