open-agents-ai 0.141.5 → 0.141.7

package/dist/index.js

@@ -43351,81 +43351,7 @@ async function handleSlashCommand(input, ctx) {
       return "handled";
     }
     case "cohere": {
-      const cohereSubCmd = (arg || "").trim().split(/\s+/);
-      const cohereAction = cohereSubCmd[0]?.toLowerCase() || "";
-      if (cohereAction === "stats") {
-        try {
-          const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
-          const nexusTool = new NexusTool2(ctx.repoRoot || process.cwd());
-          try {
-            const st = await nexusTool.execute({ action: "status" });
-            if (!st.success || !st.output.includes("connected")) {
-              renderInfo("Connecting to nexus daemon...");
-              await nexusTool.execute({ action: "connect" });
-              await new Promise((r) => setTimeout(r, 1e3));
-            }
-          } catch {
-          }
-          const result = await nexusTool.execute({ action: "cohere_stats" });
-          if (result.success) {
-            renderInfo(result.output);
-          } else {
-            renderWarning("Stats unavailable: " + (result.error || "daemon not running"));
-          }
-        } catch {
-          renderWarning("COHERE stats unavailable \u2014 daemon not running. Use /expose first.");
-        }
-        return "handled";
-      }
-      if (cohereAction === "models") {
-        try {
-          const { NexusTool: NexusTool2 } = __require("../../execution/dist/tools/nexus.js");
-          const nexusTool = new NexusTool2(ctx.repoRoot || process.cwd());
-          const result = await nexusTool.execute({ action: "cohere_list_models" });
-          if (result.success) {
-            renderInfo(result.output);
-          } else {
-            renderWarning("Model list unavailable: " + (result.error || "daemon not running"));
-          }
-        } catch {
-          renderWarning("COHERE models unavailable \u2014 daemon not running. Use /expose first.");
-        }
-        return "handled";
-      }
-      if (cohereAction === "allow" && cohereSubCmd[1]) {
-        try {
-          const { NexusTool: NexusTool2 } = __require("../../execution/dist/tools/nexus.js");
-          const nexusTool = new NexusTool2(ctx.repoRoot || process.cwd());
-          const result = await nexusTool.execute({ action: "cohere_allow_model", model: cohereSubCmd[1] });
-          renderInfo(result.success ? result.output : result.error || "Failed");
-        } catch {
-          renderWarning("Daemon not running.");
-        }
-        return "handled";
-      }
-      if (cohereAction === "deny" && cohereSubCmd[1]) {
-        try {
-          const { NexusTool: NexusTool2 } = __require("../../execution/dist/tools/nexus.js");
-          const nexusTool = new NexusTool2(ctx.repoRoot || process.cwd());
-          const result = await nexusTool.execute({ action: "cohere_deny_model", model: cohereSubCmd[1] });
-          renderInfo(result.success ? result.output : result.error || "Failed");
-        } catch {
-          renderWarning("Daemon not running.");
-        }
-        return "handled";
-      }
-      if (ctx.cohereToggle) {
-        const active = ctx.cohereToggle();
-        if (active) {
-          renderInfo("COHERE enabled \u2014 participating in distributed cognitive commons");
-          renderInfo("Your identity kernel and memory deltas will be shared with the mesh");
-          renderInfo("Use /cohere again to disconnect, /cohere stats for network info");
-        } else {
-          renderInfo("COHERE disabled \u2014 disconnected from cognitive commons");
-        }
-      } else {
-        renderWarning("COHERE not available \u2014 requires nexus connection (/expose or /p2p)");
-      }
+      await showCohereDashboard(ctx);
       return "handled";
     }
     case "listen":
@@ -44301,6 +44227,126 @@ async function handleExposeConfig(ctx) {
     }
   }
 }
+async function showCohereDashboard(ctx) {
+  const isActive = ctx.isCohere?.() ?? false;
+  let stats = { queriesAnswered: 0, queriesSent: 0, insightsShared: 0, peersConnected: 0 };
+  let modelList = [];
+  try {
+    const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+    const nexus = new NexusTool2(ctx.repoRoot);
+    try {
+      const st = await nexus.execute({ action: "status" });
+      if (!st.success || !st.output.includes("connected")) {
+        await nexus.execute({ action: "connect" });
+        await new Promise((r) => setTimeout(r, 1500));
+      }
+    } catch {
+    }
+    try {
+      const r = await nexus.execute({ action: "cohere_stats" });
+      if (r.success) {
+        try {
+          const d = JSON.parse(r.output);
+          Object.assign(stats, d);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      const r = await nexus.execute({ action: "cohere_list_models" });
+      if (r.success) {
+        try {
+          modelList = JSON.parse(r.output).models || [];
+        } catch {
+          modelList = r.output.split("\n").filter((l) => l.trim());
+        }
+      }
+    } catch {
+    }
+  } catch {
+  }
+  while (true) {
+    const currentActive = ctx.isCohere?.() ?? false;
+    const toggleLabel = currentActive ? "Disable COHERE" : "Enable COHERE";
+    const toggleDetail = currentActive ? `Active \u2014 forwarding ${ctx.config.model}` : "Join the distributed cognitive commons";
+    const items = [
+      { key: "hdr-status", label: selectColors.dim(`\u2500\u2500\u2500 Status: ${currentActive ? "ACTIVE" : "OFF"} \u2500\u2500\u2500`) },
+      { key: "toggle", label: toggleLabel, detail: toggleDetail },
+      { key: "hdr-network", label: selectColors.dim("\u2500\u2500\u2500 Network \u2500\u2500\u2500") },
+      { key: "stats", label: "Network Stats", detail: `${stats.queriesAnswered} answered \xB7 ${stats.queriesSent} sent \xB7 ${stats.insightsShared} shared` },
+      { key: "identity", label: "Identity Kernel", detail: "View/publish identity snapshot" },
+      { key: "ipfs", label: "IPFS Storage", detail: "Pinned CIDs and content sharing" },
+      { key: "hdr-models", label: selectColors.dim("\u2500\u2500\u2500 Model Exposure \u2500\u2500\u2500") },
+      ...modelList.slice(0, 10).map((m) => ({
+        key: `model:${m}`,
+        label: m,
+        detail: "Toggle exposure to mesh"
+      }))
+    ];
+    if (modelList.length === 0) {
+      items.push({ key: "no-models", label: selectColors.dim("No models detected"), detail: "Models appear after /cohere is enabled" });
+    }
+    const result = await tuiSelect({
+      items,
+      title: "COHERE Cognitive Commons",
+      activeKey: currentActive ? "toggle" : void 0,
+      rl: ctx.rl,
+      skipKeys: ["hdr-status", "hdr-network", "hdr-models", "no-models"],
+      availableRows: ctx.availableContentRows?.()
+    });
+    if (!result.confirmed || !result.key)
+      break;
+    switch (result.key) {
+      case "toggle": {
+        ctx.cohereToggle?.();
+        continue;
+      }
+      case "stats": {
+        try {
+          const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+          const nexus = new NexusTool2(ctx.repoRoot);
+          const r = await nexus.execute({ action: "cohere_stats" });
+          if (r.success) {
+            try {
+              const d = JSON.parse(r.output);
+              Object.assign(stats, d);
+            } catch {
+            }
+          }
+        } catch {
+        }
+        continue;
+      }
+      case "identity": {
+        try {
+          const { IdentityKernelTool: IdentityKernelTool2 } = __require("@open-agents/execution");
+          const ik = new IdentityKernelTool2(ctx.repoRoot);
+          await ik.execute({ operation: "publish_snapshot" });
+        } catch {
+        }
+        continue;
+      }
+      case "ipfs": {
+        break;
+      }
+      default: {
+        if (result.key.startsWith("model:")) {
+          const modelName = result.key.slice(6);
+          try {
+            const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+            const nexus = new NexusTool2(ctx.repoRoot);
+            await nexus.execute({ action: "cohere_allow_model", model: modelName });
+          } catch {
+          }
+          continue;
+        }
+        break;
+      }
+    }
+    break;
+  }
+}
 async function showModelPicker(ctx, local = false) {
   try {
     const BRAILLE_CYCLE = ["\u2800", "\u2840", "\u28C0", "\u28C4", "\u28E4", "\u28E6", "\u28F6", "\u28F7", "\u28FF", "\u28F7", "\u28F6", "\u28E6", "\u28E4", "\u28C4", "\u28C0", "\u2840"];
@@ -58475,12 +58521,39 @@ Rationale: ${proposal.rationale}${provenanceNote}`;
       statusBar.setCohereActive(cohereEnabled);
       saveProjectSettings(repoRoot, { cohere: cohereEnabled });
       saveGlobalSettings({ cohere: cohereEnabled });
-      try {
-        const { NexusTool: NexusTool2 } = __require("../../execution/dist/tools/nexus.js");
-        const nexusTool = new NexusTool2(repoRoot);
-        nexusTool.execute({ action: cohereEnabled ? "cohere_enable" : "cohere_disable" }).catch(() => {
-        });
-      } catch {
+      if (cohereEnabled) {
+        (async () => {
+          try {
+            const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+            const nexusTool = new NexusTool2(repoRoot);
+            try {
+              const st = await nexusTool.execute({ action: "status" });
+              if (!st.success || !st.output.includes("connected")) {
+                await nexusTool.execute({ action: "connect" });
+                await new Promise((r) => setTimeout(r, 1500));
+              }
+            } catch {
+            }
+            await nexusTool.execute({ action: "cohere_enable" }).catch(() => {
+            });
+          } catch {
+          }
+          try {
+            if (!commandCtx.isExposeActive?.()) {
+              writeContent(() => renderInfo("COHERE: exposing local inference to mesh..."));
+              await commandCtx.exposeStart?.("passthrough");
+            }
+          } catch {
+          }
+        })();
+      } else {
+        try {
+          const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+          const nexusTool = new NexusTool2(repoRoot);
+          nexusTool.execute({ action: "cohere_disable" }).catch(() => {
+          });
+        } catch {
+        }
       }
       return cohereEnabled;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.141.5",
+  "version": "0.141.7",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",