@adhdev/daemon-core 0.9.77-rc.59 → 0.9.77-rc.60

package/dist/index.mjs

@@ -7388,231 +7388,6 @@ 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
@@ -25957,6 +25732,69 @@ ${block}`);
           return { success: false, error: e.message };
         }
       }
+      case "mesh_status": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
+          const mesh = meshRecord?.mesh;
+          if (!mesh) return { success: false, error: "Mesh not found" };
+          const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const queue = getQueue2(meshId);
+          const queueSummary = getMeshQueueStats2(meshId);
+          const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
+          const ledgerSummary = getLedgerSummary2(meshId);
+          const nodeStatuses = [];
+          for (const node of mesh.nodes || []) {
+            const status = {
+              nodeId: node.id || node.nodeId,
+              workspace: node.workspace,
+              repoRoot: node.repoRoot,
+              isLocalWorktree: node.isLocalWorktree,
+              worktreeBranch: node.worktreeBranch,
+              daemonId: node.daemonId,
+              machineId: node.machineId,
+              health: "unknown"
+            };
+            if (node.workspace && typeof node.workspace === "string") {
+              try {
+                const { execFile: execFile3 } = await import("child_process");
+                const { promisify: promisify3 } = await import("util");
+                const execFileAsync3 = promisify3(execFile3);
+                const branch = await execFileAsync3("git", ["-C", node.workspace, "branch", "--show-current"], {
+                  encoding: "utf8",
+                  timeout: 1e4
+                }).then((r) => r.stdout.trim()).catch(() => "");
+                const porc = await execFileAsync3("git", ["-C", node.workspace, "status", "--porcelain"], {
+                  encoding: "utf8",
+                  timeout: 1e4
+                }).then((r) => r.stdout.trim()).catch(() => "");
+                const dirty = porc.length > 0;
+                status.branch = branch;
+                status.isDirty = dirty;
+                status.uncommittedChanges = porc ? porc.split("\n").filter(Boolean).length : 0;
+                status.health = branch ? dirty ? "dirty" : "online" : "degraded";
+              } catch {
+                status.health = "degraded";
+              }
+            }
+            nodeStatuses.push(status);
+          }
+          return {
+            success: true,
+            meshId: mesh.id,
+            meshName: mesh.name,
+            repoIdentity: mesh.repoIdentity,
+            defaultBranch: mesh.defaultBranch,
+            nodes: nodeStatuses,
+            queue: { tasks: queue, summary: queueSummary },
+            ledger: { entries: ledgerEntries, summary: ledgerSummary }
+          };
+        } catch (e) {
+          return { success: false, error: e.message };
+        }
+      }
       default:
         break;
     }
@@ -34032,7 +33870,6 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
-  buildMeshGraph,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildP2pRelayFailurePayload,