pi-subagents-router 1.0.2

package/src/agent-router.ts

@@ -0,0 +1,243 @@
+/**
+ * pi-subagents — Agent Router Extension
+ *
+ * v2.0: Supervisor-based routing (refactored from monolithic agent-router.ts)
+ *
+ * Entry point that wires the Supervisor into the VS Code extension host.
+ * Exposes:
+ *   - "route_agent" tool       (single-agent, same behavior as v1)
+ *   - "plan_and_route" tool   (multi-agent workflow, NEW)
+ *   - "/assign-agent" command  (backward-compatible shortcut)
+ *   - "list_agents" tool      (list all available agents)
+ *
+ * @see https://github.com/tintinweb/pi-subagents
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+
+import { Supervisor } from "./Supvisor.ts";
+import { BUILTIN_AGENTS } from "./BuiltinAgents.ts";
+
+const PI_SUBAGENTS_REPO = "https://github.com/tintinweb/pi-subagents";
+
+// ============================================================================
+// Entry point
+// ============================================================================
+
+export default async function(pi: ExtensionAPI) {
+  // Build the supervisor with builtin agents
+  const supervisor = new Supervisor([...BUILTIN_AGENTS], pi);
+
+  // ---- Register route_agent tool (UNCHANGED behavior) ------------------
+  pi.registerTool({
+    name: "route_agent",
+    label: "Route Agent",
+    description: `Route tasks to appropriate sub-agents via pi-subagents (${PI_SUBAGENTS_REPO})`,
+    parameters: Type.Object({
+      taskDescription: Type.String({ description: "Description of the task to be performed" }),
+      forceAgent: Type.Optional(Type.String({ description: "Optionally force a specific agent type" })),
+      runInBackground: Type.Optional(Type.Boolean({ description: "Run the agent in background (non-blocking)" })),
+      thinking: Type.Optional(Type.String({ description: "Thinking level" })),
+      model: Type.Optional(Type.String({ description: "Model to use" })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
+      const { taskDescription, forceAgent, runInBackground, thinking, model } = params;
+
+      // If forceAgent is specified, use it directly
+      if (forceAgent) {
+        const result = await supervisor.routeAgent(
+          taskDescription,
+          forceAgent,
+          runInBackground,
+          thinking,
+          model
+        );
+
+        if (result.success) {
+          const agent = BUILTIN_AGENTS.find((a) => a.name === result.agentType);
+          return {
+            content: [{
+              type: "text",
+              text: `Routed to agent: ${result.agentType} via pi-subagents\n\n${agent?.description ?? ""}\n\nAgent ID: ${result.agentId ?? "foreground"}\n\nExecuted by: ${PI_SUBAGENTS_REPO}`,
+            }],
+            details: {
+              agentType: result.agentType,
+              reason: result.reason ?? "Forced by user",
+              subagentRepo: PI_SUBAGENTS_REPO,
+              agentId: result.agentId,
+            },
+          };
+        } else {
+          return {
+            content: [{
+              type: "text",
+              text: `Failed to spawn agent '${forceAgent}': ${result.error}`,
+            }],
+            details: { error: result.error },
+          };
+        }
+      }
+
+      // Otherwise, analyze and route normally
+      const result = await supervisor.routeAgent(
+        taskDescription,
+        undefined,
+        runInBackground,
+        thinking,
+        model
+      );
+
+      if (result.success) {
+        const agent = BUILTIN_AGENTS.find((a) => a.name === result.agentType);
+        return {
+          content: [{
+            type: "text",
+            text: `Routed to agent: ${result.agentType} via pi-subagents\n\nDescription: ${agent?.description ?? ""}\n\nReason: ${result.reason ?? ""}\n\nAgent ID: ${result.agentId ?? "foreground"}\n\nExecuted by: ${PI_SUBAGENTS_REPO}`,
+          }],
+          details: {
+            agentType: result.agentType,
+            reason: result.reason,
+            subagentRepo: PI_SUBAGENTS_REPO,
+            agentId: result.agentId,
+          },
+        };
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to spawn agent: ${result.error}`,
+          }],
+          details: { error: result.error },
+        };
+      }
+    },
+  });
+
+  // ---- Register plan_and_route tool (NEW — multi-agent workflow) --------
+  pi.registerTool({
+    name: "plan_and_route",
+    label: "Plan and Route",
+    description: `Plan a multi-agent workflow via pi-subagents (${PI_SUBAGENTS_REPO}). Launches multiple agents in parallel based on goal keywords.`,
+    parameters: Type.Object({
+      goal: Type.String({ description: "The goal description for multi-agent execution" }),
+      forceAgents: Type.Optional(Type.Array(Type.String({ description: "Agent names to force" }))),
+      runInBackground: Type.Optional(Type.Boolean({ description: "Run agents in background" })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx: any) {
+      const { goal, forceAgents, runInBackground } = params;
+
+      const result = await supervisor.planAndRoute(goal, { forceAgents, background: runInBackground });
+
+      if (result.success) {
+        return {
+          content: [{
+            type: "text",
+            text: `Multi-agent workflow launched successfully!\n\nAgents: ${(result.agents ?? []).join(", ")}\nSteps:\n${(result.steps ?? []).join("\n")}`,
+          }],
+          details: {
+            agents: result.agents,
+            results: result.results,
+            subagentRepo: PI_SUBAGENTS_REPO,
+          },
+        };
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to plan workflow: ${result.error}`,
+          }],
+          details: { error: result.error },
+        };
+      }
+    },
+  });
+
+  // ---- Register /assign-agent command (UNCHANGED behavior) --------------
+  pi.registerCommand("assign-agent", {
+    description: `Route tasks to appropriate sub-agents via pi-subagents (${PI_SUBAGENTS_REPO})`,
+    handler: async (input: string, ctx: any) => {
+      if (!input) {
+        ctx.ui.notify("Please provide a task description", "error");
+        return;
+      }
+
+      const result = await supervisor.routeAgent(input, undefined, false);
+
+      if (result.success) {
+        ctx.ui.notify(`Routed to ${result.agentType}: ${result.reason ?? ""} (via pi-subagents)`, "info");
+      } else {
+        ctx.ui.notify(`Failed to spawn agent: ${result.error}`, "error");
+      }
+    },
+  });
+
+  // ---- Register list_agents tool (UNCHANGED behavior) ------------------
+  pi.registerTool({
+    name: "list_agents",
+    label: "List Agents",
+    description: `List all available agents and their routing criteria (${PI_SUBAGENTS_REPO})`,
+    parameters: Type.Object({}),
+    async execute() {
+      const agents = [
+        ...BUILTIN_AGENTS,
+         // TODO: add filesystem agents here when implemented
+      ];
+
+      let response = `Available Agents (routed via pi-subagents):\n\n`;
+      agents.forEach((agent, index) => {
+        response += `${index + 1}. **${agent.name}**\n`;
+        response += `   Description: ${agent.description}\n`;
+        response += `   Thinking: ${agent.thinking ?? "medium"}\n`;
+        response += `   Triggers: ${agent.triggers?.join(", ") ?? "none"}\n`;
+        response += `   Use When: ${agent.useWhen?.join(", ") ?? "any"}\n`;
+        response += `   Avoid When: ${agent.avoidWhen?.join(", ") ?? "none"}\n`;
+        response += `   Tools: ${agent.tools?.join(", ") ?? "default"}\n\n`;
+      });
+
+      return {
+        content: [{ type: "text", text: response }],
+        details: {
+          agents: agents.map((a) => ({
+            name: a.name,
+            description: a.description,
+            useWhen: a.useWhen,
+            avoidWhen: a.avoidWhen,
+          })),
+          subagentRepo: PI_SUBAGENTS_REPO,
+        },
+      };
+    },
+  });
+
+  // ---- Intercept input (UNCHANGED behavior from old code) --------------
+  pi.on("input", async (event: any, ctx: any) => {
+    // Skip commands / special prefixes
+    if (event.text.startsWith("/") || event.text.startsWith("!")) {
+      return { action: "continue" };
+    }
+
+    // Analyze and route
+    const result = await supervisor.routeAgent(event.text, undefined, true);
+
+    if (result.success) {
+      ctx.ui.notify(
+        `Auto-routed to ${result.agentType}: ${result.reason ?? ""} (via pi-subagents)`,
+        "info"
+      );
+      return { action: "handled" };
+    } else {
+      // Fallback to text transformation instead of suppressing
+      ctx.ui.notify(`Auto-routing failed: ${result.error}`, "warning");
+      return {
+        action: "transform",
+        text: `[ROUTED] ${event.text}`,
+      };
+    }
+  });
+
+  // ---- Session start notification (UNCHANGED) --------------------------
+  pi.on("session_start", async (_event: any, ctx: any) => {
+    ctx.ui.notify(`${PI_SUBAGENTS_REPO} engine loaded — route_agent and plan_and_route available`, "info");
+  });
+}