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

package/dist/index.js

@@ -27677,7 +27677,6 @@ ${lastSnapshot}`;
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildMachineInfo: () => buildMachineInfo2,
-      buildMeshGraph: () => buildMeshGraph,
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
@@ -29733,227 +29732,6 @@ ${lastSnapshot}`;
       };
     }
     init_mesh_work_queue();
-    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
-      };
-    }
     init_mesh_events();
     var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
     var P2P_NEXT_ACTION = "Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.";
@@ -48157,6 +47935,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;
         }