adhdev 0.9.67 → 0.9.69

package/dist/cli/index.js

@@ -2699,6 +2699,19 @@ var init_saved_sessions = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/config/mesh-config.ts
+var mesh_config_exports = {};
+__export(mesh_config_exports, {
+  addNode: () => addNode,
+  createMesh: () => createMesh,
+  deleteMesh: () => deleteMesh,
+  getMesh: () => getMesh,
+  getMeshByRepo: () => getMeshByRepo,
+  listMeshes: () => listMeshes,
+  normalizeRepoIdentity: () => normalizeRepoIdentity,
+  removeNode: () => removeNode,
+  updateMesh: () => updateMesh,
+  updateNode: () => updateNode
+});
 function getMeshConfigPath() {
   return (0, import_path2.join)(getConfigDir(), "meshes.json");
 }
@@ -2843,6 +2856,10 @@ var init_mesh_config = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/mesh/coordinator-prompt.ts
+var coordinator_prompt_exports = {};
+__export(coordinator_prompt_exports, {
+  buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt
+});
 function buildCoordinatorSystemPrompt(ctx) {
   const { mesh, status, userInstruction } = ctx;
   const sections = [];
@@ -37487,6 +37504,7 @@ function validateProviderDefinition(raw) {
   }
   validateCapabilities(provider, controls, errors);
   validateCanonicalHistory(provider.canonicalHistory, errors);
+  validateMeshCoordinator(provider.meshCoordinator, errors);
   for (const control of controls) {
     validateControl(control, errors);
   }
@@ -37577,6 +37595,60 @@ function validateCanonicalHistory(raw, errors) {
     }
   }
 }
+function validateMeshCoordinator(raw, errors) {
+  if (raw === void 0) return;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    errors.push("meshCoordinator must be an object");
+    return;
+  }
+  const meshCoordinator = raw;
+  if (typeof meshCoordinator.supported !== "boolean") {
+    errors.push("meshCoordinator.supported must be boolean");
+  }
+  if (meshCoordinator.reason !== void 0 && (typeof meshCoordinator.reason !== "string" || !meshCoordinator.reason.trim())) {
+    errors.push("meshCoordinator.reason must be a non-empty string when provided");
+  }
+  const mcpConfig = meshCoordinator.mcpConfig;
+  if (mcpConfig === void 0) return;
+  if (!mcpConfig || typeof mcpConfig !== "object" || Array.isArray(mcpConfig)) {
+    errors.push("meshCoordinator.mcpConfig must be an object");
+    return;
+  }
+  const config2 = mcpConfig;
+  const mode = config2.mode;
+  if (!["auto_import", "manual", "none"].includes(String(mode))) {
+    errors.push("meshCoordinator.mcpConfig.mode must be one of: auto_import, manual, none");
+  }
+  const format = config2.format;
+  if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
+    errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
+  }
+  for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+    const value = config2[key];
+    if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
+      errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+    }
+  }
+  if (config2.requiresRestart !== void 0 && typeof config2.requiresRestart !== "boolean") {
+    errors.push("meshCoordinator.mcpConfig.requiresRestart must be boolean when provided");
+  }
+  if (mode === "auto_import") {
+    if (format === void 0) {
+      errors.push("meshCoordinator.mcpConfig.format is required for auto_import MCP setup");
+    }
+    if (typeof config2.path !== "string" || !config2.path.trim()) {
+      errors.push("meshCoordinator.mcpConfig.path is required for auto_import MCP setup");
+    }
+  }
+  if (mode === "manual") {
+    if (typeof config2.instructions !== "string" || !config2.instructions.trim()) {
+      errors.push("meshCoordinator.mcpConfig.instructions is required for manual MCP setup");
+    }
+    if (typeof config2.template !== "string" || !config2.template.trim()) {
+      errors.push("meshCoordinator.mcpConfig.template is required for manual MCP setup");
+    }
+  }
+}
 function validateControl(control, errors) {
   if (!control || typeof control !== "object") {
     errors.push("controls: each control must be an object");
@@ -37618,6 +37690,8 @@ var init_provider_schema = __esm({
       "type",
       "name",
       "category",
+      "transcriptAuthority",
+      "transcriptContext",
       "aliases",
       "cdpPorts",
       "targetFilter",
@@ -37662,6 +37736,7 @@ var init_provider_schema = __esm({
       "staticConfigOptions",
       "spawnArgBuilder",
       "auth",
+      "meshCoordinator",
       "contractVersion",
       "capabilities",
       "providerVersion",
@@ -39831,6 +39906,75 @@ var init_command_log = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/commands/mesh-coordinator.ts
+function resolveMeshCoordinatorSetup(options) {
+  const { provider, meshId, workspace } = options;
+  const config2 = provider?.meshCoordinator;
+  if (!config2?.supported) {
+    return {
+      kind: "unsupported",
+      reason: config2?.reason || "Provider does not declare Repo Mesh coordinator support"
+    };
+  }
+  const mcpConfig = config2.mcpConfig;
+  if (!mcpConfig || mcpConfig.mode === "none") {
+    return {
+      kind: "unsupported",
+      reason: config2.reason || "Provider does not declare a usable Repo Mesh MCP configuration mode"
+    };
+  }
+  const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
+  if (mcpConfig.mode === "auto_import") {
+    const path40 = mcpConfig.path?.trim();
+    if (!path40) {
+      return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
+    }
+    return {
+      kind: "auto_import",
+      serverName,
+      configPath: (0, import_path4.join)(workspace, path40),
+      configFormat: mcpConfig.format
+    };
+  }
+  if (mcpConfig.mode === "manual") {
+    const instructions = mcpConfig.instructions?.trim();
+    const template = mcpConfig.template;
+    if (!instructions || !template?.trim()) {
+      return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
+    }
+    return {
+      kind: "manual",
+      serverName,
+      configFormat: mcpConfig.format,
+      configPathCommand: mcpConfig.configPathCommand,
+      requiresRestart: mcpConfig.requiresRestart === true,
+      instructions,
+      template: renderMeshCoordinatorTemplate(template, {
+        meshId,
+        workspace,
+        serverName,
+        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+      })
+    };
+  }
+  return {
+    kind: "unsupported",
+    reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`
+  };
+}
+function renderMeshCoordinatorTemplate(template, values) {
+  return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_2, key) => values[key] || "");
+}
+var import_path4, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND;
+var init_mesh_coordinator = __esm({
+  "../../oss/packages/daemon-core/src/commands/mesh-coordinator.ts"() {
+    "use strict";
+    import_path4 = require("path");
+    DEFAULT_SERVER_NAME = "adhdev-mesh";
+    DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/status/snapshot.ts
 function buildRecentReadDebugSignature(snapshot) {
   return [
@@ -39876,7 +40020,8 @@ function buildAvailableProviders(providerLoader) {
     ...provider.enabled !== void 0 ? { enabled: provider.enabled } : {},
     ...provider.machineStatus !== void 0 ? { machineStatus: provider.machineStatus } : {},
     ...provider.lastDetection !== void 0 ? { lastDetection: provider.lastDetection } : {},
-    ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {}
+    ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {},
+    ...provider.meshCoordinator !== void 0 ? { meshCoordinator: provider.meshCoordinator } : {}
   }));
 }
 function buildMachineInfo(profile = "full") {
@@ -40603,6 +40748,7 @@ var init_router = __esm({
     init_logger();
     init_debug_trace();
     init_runtime_surface();
+    init_mesh_coordinator();
     init_builders();
     init_snapshot();
     init_snapshot();
@@ -41251,6 +41397,178 @@ var init_router = __esm({
             updateConfig({ machineNickname: nickname || null });
             return { success: true };
           }
+          // ─── Mesh CRUD (local meshes.json) ───
+          case "list_meshes": {
+            try {
+              const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              return { success: true, meshes: listMeshes2() };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "get_mesh": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const mesh = getMesh3(meshId);
+              if (!mesh) return { success: false, error: "Mesh not found" };
+              return { success: true, mesh };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "create_mesh": {
+            const name = typeof args?.name === "string" ? args.name.trim() : "";
+            const repoIdentity = typeof args?.repoIdentity === "string" ? args.repoIdentity.trim() : "";
+            const repoRemoteUrl = typeof args?.repoRemoteUrl === "string" ? args.repoRemoteUrl.trim() : void 0;
+            const defaultBranch = typeof args?.defaultBranch === "string" ? args.defaultBranch.trim() : void 0;
+            if (!name) return { success: false, error: "name required" };
+            try {
+              const { createMesh: createMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const mesh = createMesh2({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+              return { success: true, mesh };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "delete_mesh": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { deleteMesh: deleteMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const deleted = deleteMesh3(meshId);
+              return { success: true, deleted };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "add_mesh_node": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+            if (!meshId) return { success: false, error: "meshId required" };
+            if (!workspace) return { success: false, error: "workspace required" };
+            try {
+              const { addNode: addNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const node = addNode3(meshId, { workspace });
+              if (!node) return { success: false, error: "Mesh not found" };
+              return { success: true, node };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          case "remove_mesh_node": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+            if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+            try {
+              const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const removed = removeNode3(meshId, nodeId);
+              return { success: true, removed };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          // ─── Mesh Coordinator Launch ───
+          case "launch_mesh_coordinator": {
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const cliType = typeof args?.cliType === "string" ? args.cliType.trim() : "claude-cli";
+            if (!meshId) return { success: false, error: "meshId required" };
+            try {
+              const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+              const { buildCoordinatorSystemPrompt: buildCoordinatorSystemPrompt2 } = await Promise.resolve().then(() => (init_coordinator_prompt(), coordinator_prompt_exports));
+              const mesh = getMesh3(meshId);
+              if (!mesh) return { success: false, error: "Mesh not found" };
+              if (mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
+              const workspace = mesh.nodes[0].workspace;
+              const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
+              const coordinatorSetup = resolveMeshCoordinatorSetup({
+                provider: providerMeta,
+                meshId,
+                workspace
+              });
+              if (coordinatorSetup.kind === "unsupported") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: coordinatorSetup.reason,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
+              if (coordinatorSetup.kind === "manual") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_manual_mcp_setup_required",
+                  error: coordinatorSetup.instructions,
+                  meshId,
+                  cliType,
+                  workspace,
+                  meshCoordinatorSetup: coordinatorSetup
+                };
+              }
+              if (coordinatorSetup.configFormat !== "claude_mcp_json") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
+              const { existsSync: existsSync28, readFileSync: readFileSync21, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4 } = await import("fs");
+              const mcpConfigPath = coordinatorSetup.configPath;
+              const hadExistingMcpConfig = existsSync28(mcpConfigPath);
+              let existingMcpConfig = {};
+              if (hadExistingMcpConfig) {
+                try {
+                  existingMcpConfig = JSON.parse(readFileSync21(mcpConfigPath, "utf-8"));
+                  copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
+                } catch {
+                }
+              }
+              const mcpConfig = {
+                ...existingMcpConfig,
+                mcpServers: {
+                  ...existingMcpConfig.mcpServers || {},
+                  [coordinatorSetup.serverName]: {
+                    command: "adhdev-mcp",
+                    args: ["--repo-mesh", meshId]
+                  }
+                }
+              };
+              writeFileSync15(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
+              LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
+              let systemPrompt = "";
+              try {
+                systemPrompt = buildCoordinatorSystemPrompt2({ mesh });
+              } catch {
+                systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
+              }
+              const launchResult = await this.deps.cliManager.handleCliCommand("launch_cli", {
+                cliType,
+                dir: workspace,
+                initialPrompt: systemPrompt
+              });
+              if (!launchResult?.success) {
+                return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
+              }
+              LOG.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+              return {
+                success: true,
+                meshId,
+                cliType,
+                workspace,
+                sessionId: launchResult.sessionId || launchResult.id,
+                mcpConfigWritten: true
+              };
+            } catch (e) {
+              LOG.error("MeshCoordinator", `Failed: ${e.message}`);
+              return { success: false, error: e.message };
+            }
+          }
           default:
             break;
         }
@@ -64418,7 +64736,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join35(s) {
+        value: function join36(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -80284,9 +80602,9 @@ function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
   const dir = options?.dirname || __dirname;
   const possiblePaths = [
-    (0, import_path4.join)(dir, "..", "..", "package.json"),
-    (0, import_path4.join)(dir, "..", "package.json"),
-    (0, import_path4.join)(dir, "package.json")
+    (0, import_path5.join)(dir, "..", "..", "package.json"),
+    (0, import_path5.join)(dir, "..", "package.json"),
+    (0, import_path5.join)(dir, "package.json")
   ];
   for (const p of possiblePaths) {
     try {
@@ -80297,12 +80615,12 @@ function resolvePackageVersion(options) {
   }
   return injectedVersion;
 }
-var import_fs8, import_path4;
+var import_fs8, import_path5;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     import_fs8 = require("fs");
-    import_path4 = require("path");
+    import_path5 = require("path");
   }
 });
 
@@ -89739,7 +90057,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.67" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.69" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;