open-agents-ai 0.141.6 → 0.142.0

package/dist/index.js

@@ -43351,83 +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 joining distributed cognitive commons");
-          renderInfo(`Forwarding inference: ${ctx.config.backendUrl} (${ctx.config.model})`);
-          renderInfo("Auto-connecting to nexus mesh + exposing local inference...");
-          renderInfo("Use /cohere stats for network info, /cohere again to disconnect");
-        } else {
-          renderInfo("COHERE disabled \u2014 disconnected from cognitive commons");
-          renderInfo("Local inference no longer forwarded to mesh");
-        }
-      } else {
-        renderWarning("COHERE not available \u2014 requires nexus connection (/expose or /p2p)");
-      }
+      await showCohereDashboard(ctx);
       return "handled";
     }
     case "listen":
@@ -44303,6 +44227,226 @@ 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": {
+        const statItems = [
+          { key: "hdr", label: selectColors.dim("\u2500\u2500\u2500 Network Activity \u2500\u2500\u2500") },
+          { key: "answered", label: `Queries answered: ${c2.bold(String(stats.queriesAnswered || 0))}` },
+          { key: "sent", label: `Queries sent: ${c2.bold(String(stats.queriesSent || 0))}` },
+          { key: "insights", label: `Insights shared: ${c2.bold(String(stats.insightsShared || 0))}` },
+          { key: "peers", label: `Peers connected: ${c2.bold(String(stats.peersConnected || 0))}` },
+          { key: "hdr2", label: selectColors.dim("\u2500\u2500\u2500 Actions \u2500\u2500\u2500") },
+          { key: "refresh", label: "Refresh Stats", detail: "Fetch latest from daemon" }
+        ];
+        const statResult = await tuiSelect({
+          items: statItems,
+          title: "Stats",
+          breadcrumbs: ["COHERE"],
+          rl: ctx.rl,
+          skipKeys: ["hdr", "hdr2", "answered", "sent", "insights", "peers"],
+          availableRows: ctx.availableContentRows?.()
+        });
+        if (statResult.key === "refresh") {
+          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 {
+                Object.assign(stats, JSON.parse(r.output));
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        continue;
+      }
+      case "identity": {
+        const idItems = [
+          { key: "hdr", label: selectColors.dim("\u2500\u2500\u2500 Identity Kernel \u2500\u2500\u2500") },
+          { key: "publish", label: "Publish Snapshot", detail: "Publish current identity to IPFS" },
+          { key: "view", label: "View Self-State", detail: "Show current identity kernel" },
+          { key: "history", label: "Version History", detail: "Show identity evolution" }
+        ];
+        const idResult = await tuiSelect({
+          items: idItems,
+          title: "Identity",
+          breadcrumbs: ["COHERE"],
+          rl: ctx.rl,
+          skipKeys: ["hdr"],
+          availableRows: ctx.availableContentRows?.()
+        });
+        if (idResult.confirmed && idResult.key) {
+          try {
+            const { IdentityKernelTool: IdentityKernelTool2 } = __require("@open-agents/execution");
+            const ik = new IdentityKernelTool2(ctx.repoRoot);
+            if (idResult.key === "publish") {
+              await ik.execute({ operation: "publish_snapshot" });
+            } else if (idResult.key === "view") {
+              await ik.execute({ operation: "hydrate" });
+            } else if (idResult.key === "history") {
+              const snapDir = join52(ctx.repoRoot, ".oa", "identity", "snapshots");
+              if (existsSync37(snapDir)) {
+                const snaps = readdirSync10(snapDir).filter((f) => f.endsWith(".json")).sort().reverse();
+                const snapItems = snaps.slice(0, 20).map((f) => ({
+                  key: f,
+                  label: f.replace(".json", ""),
+                  detail: `${formatFileSize(statSync13(join52(snapDir, f)).size)}`
+                }));
+                if (snapItems.length > 0) {
+                  await tuiSelect({
+                    items: snapItems,
+                    title: "Versions",
+                    breadcrumbs: ["COHERE", "Identity"],
+                    rl: ctx.rl,
+                    availableRows: ctx.availableContentRows?.()
+                  });
+                }
+              }
+            }
+          } catch {
+          }
+        }
+        continue;
+      }
+      case "ipfs": {
+        const ipfsItems = [
+          { key: "hdr", label: selectColors.dim("\u2500\u2500\u2500 IPFS / Helia \u2500\u2500\u2500") },
+          { key: "status", label: "Storage Status", detail: "Helia blocks, local fallback, sizes" },
+          { key: "cids", label: "Pinned CIDs", detail: "List all pinned content" },
+          { key: "publish", label: "Publish Identity", detail: "Share identity kernel via IPFS" },
+          { key: "peers", label: "Peer Info", detail: "Peer ID + multiaddrs" }
+        ];
+        const ipfsResult = await tuiSelect({
+          items: ipfsItems,
+          title: "IPFS",
+          breadcrumbs: ["COHERE"],
+          rl: ctx.rl,
+          skipKeys: ["hdr"],
+          availableRows: ctx.availableContentRows?.()
+        });
+        if (ipfsResult.confirmed && ipfsResult.key) {
+          if (ipfsResult.key === "cids") {
+            try {
+              const { NexusTool: NexusTool2 } = __require("@open-agents/execution");
+              const nexus = new NexusTool2(ctx.repoRoot);
+              const r = await nexus.execute({ action: "ipfs_ls" });
+              if (r.success) {
+                const data = JSON.parse(r.output);
+                const pins = data.pins || [];
+                if (pins.length > 0) {
+                  const cidItems = pins.map((p) => ({
+                    key: p.cid,
+                    label: p.cid.slice(0, 30) + "...",
+                    detail: p.source || "unknown"
+                  }));
+                  await tuiSelect({
+                    items: cidItems,
+                    title: "Pinned CIDs",
+                    breadcrumbs: ["COHERE", "IPFS"],
+                    rl: ctx.rl,
+                    availableRows: ctx.availableContentRows?.()
+                  });
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        continue;
+      }
+      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"];

package/package.json

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