@adhdev/daemon-core 0.9.77-rc.51 → 0.9.77-rc.53

package/dist/index.mjs

@@ -7388,6 +7388,231 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 
 // src/index.ts
 init_mesh_work_queue();
+
+// src/mesh/mesh-visualization.ts
+function isDirty(git) {
+  if (!git) return false;
+  return git.staged + git.modified + git.untracked + git.deleted + git.renamed > 0;
+}
+function dirtyFileCount(git) {
+  if (!git) return 0;
+  return git.staged + git.modified + git.untracked + git.deleted + git.renamed;
+}
+function detectOrphanReasons(node, defaultBranch) {
+  const reasons = [];
+  const git = node.git;
+  if (!git) {
+    reasons.push("No git status available");
+    return reasons;
+  }
+  if (!git.isGitRepo) {
+    reasons.push("Not a git repository");
+    return reasons;
+  }
+  if (git.branch === null && git.headCommit) {
+    reasons.push("Detached HEAD");
+  }
+  if (git.branch && !git.upstream) {
+    if (defaultBranch && git.branch !== defaultBranch) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+  if (git.branch && git.upstream === null && defaultBranch && git.branch !== defaultBranch) {
+    if (!reasons.includes(`No upstream: ${git.branch}`)) {
+      reasons.push(`No upstream: ${git.branch}`);
+    }
+  }
+  if (node.error) {
+    reasons.push(`Error: ${node.error}`);
+  }
+  return reasons;
+}
+function nodeHealthPriority(health) {
+  switch (health) {
+    case "online":
+      return 0;
+    case "dirty":
+      return 1;
+    case "degraded":
+      return 2;
+    case "wrong_branch":
+      return 3;
+    case "offline":
+      return 4;
+    case "unknown":
+      return 5;
+    default:
+      return 5;
+  }
+}
+function pickDominantHealth(healths) {
+  if (healths.length === 0) return "unknown";
+  return healths.reduce(
+    (best, h) => nodeHealthPriority(h) > nodeHealthPriority(best) ? h : best
+  );
+}
+function buildMeshGraph(status) {
+  const nodes = [];
+  const edges = [];
+  const warnings = [];
+  const branchToNodeIds = /* @__PURE__ */ new Map();
+  for (const nodeStatus of status.nodes) {
+    const git = nodeStatus.git;
+    const branch = git?.branch || null;
+    const orphanReasons = detectOrphanReasons(nodeStatus, null);
+    const dirty = isDirty(git);
+    const dfc = dirtyFileCount(git);
+    let type = "worktreeNode";
+    if (orphanReasons.length > 0) {
+      type = "orphanNode";
+    }
+    const graphNode = {
+      id: nodeStatus.nodeId,
+      type,
+      label: nodeStatus.machineLabel || nodeStatus.nodeId.slice(0, 8),
+      workspace: nodeStatus.workspace,
+      branch,
+      health: nodeStatus.health,
+      ahead: git?.ahead ?? 0,
+      behind: git?.behind ?? 0,
+      dirty,
+      dirtyFiles: dfc,
+      hasConflicts: git?.hasConflicts ?? false,
+      activeSessionCount: nodeStatus.activeSessions?.length ?? 0,
+      activeSessions: nodeStatus.activeSessions ?? [],
+      providers: nodeStatus.providers ?? [],
+      isOrphan: orphanReasons.length > 0,
+      orphanReasons,
+      source: nodeStatus
+    };
+    nodes.push(graphNode);
+    if (branch) {
+      const list = branchToNodeIds.get(branch) ?? [];
+      list.push(graphNode.id);
+      branchToNodeIds.set(branch, list);
+    }
+  }
+  const branchUpstreamCounts = /* @__PURE__ */ new Map();
+  for (const n of status.nodes) {
+    const b = n.git?.branch;
+    const upstream = n.git?.upstream;
+    if (b && upstream) {
+      branchUpstreamCounts.set(b, (branchUpstreamCounts.get(b) ?? 0) + 1);
+    }
+  }
+  let inferredDefaultBranch = null;
+  let bestCount = 0;
+  for (const [b, count] of branchUpstreamCounts) {
+    if (count > bestCount) {
+      bestCount = count;
+      inferredDefaultBranch = b;
+    }
+  }
+  const defaultBranchNodeId = inferredDefaultBranch ? `__branch_${inferredDefaultBranch}` : null;
+  if (defaultBranchNodeId && inferredDefaultBranch) {
+    const branchNodes = branchToNodeIds.get(inferredDefaultBranch) ?? [];
+    const branchHealths = branchNodes.map(
+      (id) => nodes.find((n) => n.id === id).health
+    );
+    const defaultNode = {
+      id: defaultBranchNodeId,
+      type: "defaultBranchNode",
+      label: inferredDefaultBranch,
+      workspace: "",
+      branch: inferredDefaultBranch,
+      health: pickDominantHealth(branchHealths),
+      ahead: 0,
+      behind: 0,
+      dirty: false,
+      dirtyFiles: 0,
+      hasConflicts: false,
+      activeSessionCount: 0,
+      activeSessions: [],
+      providers: [],
+      isOrphan: false,
+      orphanReasons: [],
+      nextStepHint: branchNodes.length > 0 ? `${branchNodes.length} node(s) on default branch` : void 0,
+      source: {
+        nodeId: defaultBranchNodeId,
+        machineLabel: inferredDefaultBranch,
+        workspace: "",
+        health: "online",
+        providers: [],
+        activeSessions: []
+      }
+    };
+    nodes.push(defaultNode);
+    const seenBranches = /* @__PURE__ */ new Set();
+    for (const n of nodes) {
+      if (n.type === "defaultBranchNode") continue;
+      if (!n.branch) continue;
+      if (n.branch === inferredDefaultBranch) {
+        edges.push({
+          id: `${defaultBranchNodeId}--${n.id}`,
+          source: defaultBranchNodeId,
+          target: n.id,
+          type: "parentBranch",
+          label: "default"
+        });
+        continue;
+      }
+      if (seenBranches.has(n.branch)) continue;
+      seenBranches.add(n.branch);
+      edges.push({
+        id: `${defaultBranchNodeId}--branch_${n.branch}`,
+        source: defaultBranchNodeId,
+        target: n.branch,
+        type: "parentBranch",
+        label: n.branch
+      });
+    }
+  }
+  for (const [branch, ids] of branchToNodeIds) {
+    if (ids.length < 2) continue;
+    for (let i = 1; i < ids.length; i++) {
+      edges.push({
+        id: `wt_${ids[0]}--${ids[i]}`,
+        source: ids[0],
+        target: ids[i],
+        type: "worktreeLink",
+        label: branch
+      });
+    }
+  }
+  const orphanCount = nodes.filter((n) => n.isOrphan).length;
+  if (orphanCount > 0) {
+    warnings.push(`${orphanCount} orphan node(s) detected`);
+  }
+  const conflictCount = nodes.filter((n) => n.hasConflicts).length;
+  if (conflictCount > 0) {
+    warnings.push(`${conflictCount} node(s) with merge conflicts`);
+  }
+  const offlineCount = nodes.filter((n) => n.health === "offline").length;
+  if (offlineCount > 0) {
+    warnings.push(`${offlineCount} node(s) offline`);
+  }
+  const stats = {
+    totalNodes: status.nodes.length,
+    onlineNodes: status.nodes.filter((n) => n.health === "online").length,
+    dirtyNodes: nodes.filter((n) => n.dirty).length,
+    orphanNodes: orphanCount,
+    errorNodes: status.nodes.filter((n) => !!n.error).length,
+    offlineNodes: offlineCount,
+    totalActiveSessions: status.nodes.reduce((sum, n) => sum + (n.activeSessions?.length ?? 0), 0)
+  };
+  return {
+    meshId: status.meshId,
+    meshName: status.meshName,
+    repoIdentity: status.repoIdentity,
+    refreshedAt: status.refreshedAt,
+    nodes,
+    edges,
+    stats,
+    warnings
+  };
+}
+
+// src/index.ts
 init_mesh_events();
 
 // src/mesh/p2p-relay-failure.ts
@@ -33807,6 +34032,7 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildMeshGraph,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload,