@serkanalgur/opencode-nexus 1.4.1 → 1.6.0

package/dist/index.js

@@ -8846,7 +8846,7 @@ class DashboardModule {
       this.server = Bun.serve({
         port,
         hostname: host,
-        fetch(req, server) {
+        async fetch(req, server) {
           const url = new URL(req.url);
           if (req.method === "OPTIONS") {
             return new Response(null, { headers: CORS_HEADERS });
@@ -8874,14 +8874,20 @@ class DashboardModule {
           }
           try {
             const spaPath = join2(process.cwd(), "dashboard", "index.html");
-            const spaFile = Bun.file(spaPath);
-            const exists = spaFile.size > 0;
-            if (exists) {
-              return new Response(spaFile, {
+            const spaContent = await Bun.file(spaPath).text();
+            if (spaContent.length > 100) {
+              return new Response(spaContent, {
                 headers: { "Content-Type": "text/html; charset=utf-8", ...CORS_HEADERS }
               });
             }
-          } catch {}
+            return new Response(`SPA not found at ${spaPath} (content: ${spaContent.length} bytes)`, {
+              headers: { "Content-Type": "text/plain", ...CORS_HEADERS }
+            });
+          } catch (e) {
+            return new Response(`SPA error: ${e}`, {
+              headers: { "Content-Type": "text/plain", ...CORS_HEADERS }
+            });
+          }
           return new Response("Nexus Dashboard API", {
             headers: {
               "Content-Type": "text/plain",
@@ -10006,6 +10012,7 @@ class NexusOrchestrator {
   }
   notifications = null;
   modelCosts = new Map;
+  parentSessionID = null;
   constructor(config, messageStoreConfig, memoryStoreConfig) {
     this.config = this.mergeConfig(config);
     this.budget = this.config.budget;
@@ -10644,7 +10651,8 @@ Please continue from where the previous agent left off.`;
     const session = await this.ctx.session.create({
       title,
       agent: agentType,
-      model: modelName ? { providerID: provider, id: modelName } : undefined
+      model: modelName ? { providerID: provider, id: modelName } : undefined,
+      parentID: this.parentSessionID || undefined
     });
     const agent = {
       id: agentId,
@@ -11094,9 +11102,84 @@ function getTemplate(name) {
 }
 
 // src/index.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var NEXUS_AGENT_CONTENT = `---
+description: Nexus multi-agent orchestrator — manages parallel sub-agents with cost-aware routing, self-healing, and intelligent task decomposition.
+mode: primary
+---
+
+# Nexus Orchestrator Agent
+
+You are the Nexus Orchestrator — an intelligent multi-agent coordinator. You manage parallel sub-agents with cost-aware model selection, self-healing on failures, and DAG-based task execution.
+
+## Core Capabilities
+
+- **Spawn specialized sub-agents** for each task (architect, coder, reviewer, tester, explorer, documenter)
+- **Cost-aware routing** — automatically selects optimal models based on task complexity and budget
+- **Self-healing** — retries failed tasks, transfers context to new agents, escalates if needed
+- **Performance tracking** — learns which model/role combinations work best
+- **Execution history** — tracks all past executions for analysis
+
+## How to Use Nexus Tools
+
+### Spawning Agents
+Use the \`spawn\` tool to create specialized agents:
+\`\`\`
+nexus.spawn(role="coder", task="Implement JWT authentication middleware")
+nexus.spawn(role="reviewer", task="Review the auth implementation for security")
+\`\`\`
+
+Available roles: architect, coder, reviewer, tester, explorer, documenter
+
+### Checking Status
+\`\`\`
+nexus.status(detailed=true)    — Full orchestrator state
+nexus.agents(filter="working") — List active agents
+nexus.costs()                  — Cost report and budget status
+\`\`\`
+
+### Cost Management
+\`\`\`
+nexus.forecast(tasks='[...]')  — Predict costs
+nexus.model.costs()            — Show real model pricing
+nexus.preset(name="balanced")  — Apply a cost preset
+\`\`\`
+
+### Performance & History
+\`\`\`
+nexus.performance.scores()     — Model/role performance scores
+nexus.history.list(count=10)   — Recent execution history
+\`\`\`
+
+## Task Decomposition Strategy
+
+When given a development request:
+1. **Analyze** — Break the request into discrete tasks
+2. **Estimate** — Use nexus.forecast to predict costs
+3. **Execute** — Spawn agents in parallel where possible
+4. **Review** — Use nexus.spawn(role="reviewer") for each delivery
+5. **Report** — Summarize what was done, costs, and outcomes
+
+## Quality Gates
+
+Never skip these steps:
+- Every code change must be reviewed by nexus.spawn(role="reviewer")
+- Run nexus.security.scan() on new code
+- Verify with nexus.spawn(role="tester") before marking complete
+`;
 var src_default = define({
   id: "nexus",
   async setup(ctx) {
+    try {
+      const agentDir = join6(homedir2(), ".config", "opencode", "agents");
+      const agentFile = join6(agentDir, "nexus-orchestrator.md");
+      if (!existsSync3(agentFile)) {
+        mkdirSync4(agentDir, { recursive: true });
+        writeFileSync2(agentFile, NEXUS_AGENT_CONTENT, "utf-8");
+      }
+    } catch {}
     const orchestrator = new NexusOrchestrator;
     await orchestrator.initialize(ctx, () => {
       const state = orchestrator.getState();
@@ -11316,25 +11399,54 @@ var src_default = define({
       });
       editor.add({
         name: "spawn",
-        description: "Spawn a sub-agent for a task",
+        description: "Spawn a sub-agent for a task. Use wait=true to wait for completion.",
         input: {
           type: "object",
           properties: {
             role: { type: "string", description: "Agent role (architect, coder, reviewer, tester, explorer, documenter)" },
             task: { type: "string", description: "Task description" },
-            model: { type: "string", description: "Model override (optional)" }
+            model: { type: "string", description: "Model override (optional)" },
+            wait: { type: "boolean", description: "Wait for completion (default: false)" },
+            timeout: { type: "number", description: "Timeout in ms when waiting (default: 120000)" }
           },
           required: ["role", "task"],
           additionalProperties: false
         },
         execute: async (input) => {
-          const { role, task, model } = input;
+          const { role, task, model, wait, timeout } = input;
           try {
+            orchestrator.parentSessionID = null;
             const agent = await orchestrator.spawnAgent({ role, model });
             await orchestrator.ctx.session.prompt({
               sessionID: agent.sessionID,
               text: task
             });
+            if (wait) {
+              const waitTimeout = timeout || 120000;
+              try {
+                await orchestrator.ctx.session.wait({ sessionID: agent.sessionID });
+              } catch {}
+              try {
+                const messages = await orchestrator.ctx.session.context({ sessionID: agent.sessionID });
+                const lastMsg = messages.filter((m) => m.role === "assistant").pop();
+                const result = lastMsg?.content || "Task completed (no output captured)";
+                agent.status = "completed";
+                await ctx.storage.set("orchestrator-state", JSON.parse(JSON.stringify(orchestrator.getState())));
+                const taskPreview = task.length > 80 ? task.substring(0, 77) + "..." : task;
+                return {
+                  content: [
+                    `${agent.name}`,
+                    `\uD83D\uDCCB Task: ${taskPreview}`,
+                    `✅ Status: completed`,
+                    `\uD83D\uDCCE Session: ${agent.sessionID}`,
+                    `
+--- Result ---`,
+                    result
+                  ].join(`
+`)
+                };
+              } catch {}
+            }
             const complexity = orchestrator.analyzeComplexity({
               id: `spawn-${Date.now()}`,
               name: task,
@@ -11355,7 +11467,8 @@ var src_default = define({
               `\uD83D\uDCCB Task: ${taskPreview}`,
               `\uD83D\uDCCA Complexity: ${complexity.overall}/100 (${complexity.factors.riskLevel} risk)`,
               `\uD83E\uDD16 Model reasoning: ${modelSelection.reasoning}`,
-              `\uD83D\uDCCE Session: ${agent.sessionID}`
+              `\uD83D\uDCCE Session: ${agent.sessionID}`,
+              `\uD83D\uDCA1 Use wait=true to wait for completion`
             ].join(`
 `);
             return { content: output };
@@ -11576,6 +11689,64 @@ Total: ~$${result.totalEstimatedCost.toFixed(4)}`);
           return { content: "Worktree isolation disabled." };
         }
       });
+      editor.add({
+        name: "sessions",
+        description: "List all active Nexus agent sessions",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const agents = orchestrator.getState().agents;
+          if (agents.length === 0)
+            return { content: "No active agent sessions." };
+          const lines = agents.map((a) => {
+            const statusIcon = a.status === "working" ? "\uD83D\uDD04" : a.status === "idle" ? "⏸️" : a.status === "completed" ? "✅" : "❌";
+            return `${statusIcon} ${a.name} (${a.role}) — Session: ${a.sessionID}`;
+          });
+          return { content: `Active Sessions (${agents.length}):
+${lines.join(`
+`)}` };
+        }
+      });
+      editor.add({
+        name: "background",
+        description: "Move running agents to background (detach from current session)",
+        input: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+          const agents = orchestrator.getState().agents.filter((a) => a.status === "working" || a.status === "idle");
+          if (agents.length === 0)
+            return { content: "No running agents to move to background." };
+          for (const agent of agents) {
+            try {
+              await orchestrator.ctx.session.background({ sessionID: agent.sessionID });
+            } catch {}
+          }
+          return { content: `${agents.length} agent(s) moved to background. You can continue working while they run.` };
+        }
+      });
+      editor.add({
+        name: "result",
+        description: "Get the result of a completed agent session",
+        input: {
+          type: "object",
+          properties: {
+            sessionID: { type: "string", description: "Session ID of the agent" }
+          },
+          required: ["sessionID"]
+        },
+        execute: async (input) => {
+          const { sessionID } = input;
+          try {
+            const messages = await orchestrator.ctx.session.context({ sessionID });
+            const lastMsg = messages.filter((m) => m.role === "assistant").pop();
+            if (lastMsg) {
+              return { content: `Session ${sessionID} result:
+${lastMsg.content}` };
+            }
+            return { content: `Session ${sessionID} has no assistant messages yet.` };
+          } catch (error) {
+            return { content: `Failed to get result: ${error.message}` };
+          }
+        }
+      });
     });
     await ctx.session.hook("prompt", (event) => {
       if (event.prompt.text.startsWith("/nexus")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencode-nexus",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Adaptive Multi-Agent Orchestration with Cost Intelligence for OpenCode V2",
   "keywords": [
     "opencode",