@evo-dev/core 0.0.1-alpha → 0.0.1-alpha.1

package/src/team/mcp.ts

@@ -0,0 +1,401 @@
+import { createInterface } from "node:readline";
+import type { Readable, Writable } from "node:stream";
+import { TeamMessageBroker, type TeamMessageBrokerOptions, type TeamMessageType } from "./index.ts";
+
+export interface TeamsMcpServerOptions extends TeamMessageBrokerOptions {
+  defaultRunId?: string;
+  defaultFromRoleId?: string;
+  now?: Date;
+}
+
+export type JsonRpcId = string | number;
+
+export interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: JsonRpcId | null;
+  result?: Record<string, unknown>;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+export interface McpToolDefinition {
+  name: string;
+  title: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+}
+
+const PROTOCOL_VERSION = "2025-11-25";
+const SUPPORTED_PROTOCOL_VERSIONS = new Set([PROTOCOL_VERSION, "2025-06-18"]);
+const MESSAGE_TYPES = new Set<TeamMessageType>(["request", "result", "issue", "notice"]);
+
+export function getTeamsMcpTools(): McpToolDefinition[] {
+  return [
+    {
+      name: "list_agents",
+      title: "List EvoDev Team Agents",
+      description: "List role agents in the current EvoDev team run.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          runId: {
+            type: "string",
+            description: "Optional EvoDev team run id. Defaults to the latest run.",
+          },
+        },
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          agents: { type: "array" },
+        },
+        required: ["agents"],
+      },
+    },
+    {
+      name: "send_message",
+      title: "Send EvoDev Team Message",
+      description: "Send a structured message to another EvoDev role agent.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          runId: {
+            type: "string",
+            description: "Optional EvoDev team run id. Defaults to the latest run.",
+          },
+          toRoleId: {
+            type: "string",
+            description: "Target role id.",
+          },
+          message: {
+            type: "string",
+            description: "Message body to deliver.",
+          },
+          type: {
+            type: "string",
+            enum: ["request", "result", "issue", "notice"],
+            description: "Message type.",
+          },
+          fromRoleId: {
+            type: "string",
+            description: "Optional sender role id for audit context.",
+          },
+        },
+        required: ["toRoleId", "message"],
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          ok: { type: "boolean" },
+          messageId: { type: "string" },
+          deliveredTo: { type: "string" },
+          cc: { type: "array" },
+        },
+        required: ["ok"],
+      },
+    },
+    {
+      name: "spawn_role",
+      title: "Spawn EvoDev Role Agent",
+      description: "Create or reuse one EvoDev role agent.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          runId: {
+            type: "string",
+            description: "Optional EvoDev team run id. Defaults to the current team run.",
+          },
+          roleId: {
+            type: "string",
+            description: "Role id to create or reuse.",
+          },
+          reason: {
+            type: "string",
+            description: "Reason for lifecycle change.",
+          },
+          fromRoleId: {
+            type: "string",
+            description: "Optional sender role id for audit context.",
+          },
+        },
+        required: ["roleId"],
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          ok: { type: "boolean" },
+          created: { type: "boolean" },
+          agent: { type: "object" },
+          error: { type: "string" },
+          message: { type: "string" },
+        },
+        required: ["ok"],
+      },
+    },
+    {
+      name: "stop_role",
+      title: "Stop EvoDev Role Agent",
+      description: "Stop one EvoDev role agent.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          runId: {
+            type: "string",
+            description: "Optional EvoDev team run id. Defaults to the current team run.",
+          },
+          roleId: {
+            type: "string",
+            description: "Role id to stop.",
+          },
+          reason: {
+            type: "string",
+            description: "Reason for lifecycle change.",
+          },
+          fromRoleId: {
+            type: "string",
+            description: "Optional sender role id for audit context.",
+          },
+        },
+        required: ["roleId"],
+      },
+      outputSchema: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          ok: { type: "boolean" },
+          stopped: { type: "boolean" },
+          agent: { type: "object" },
+          error: { type: "string" },
+          message: { type: "string" },
+        },
+        required: ["ok"],
+      },
+    },
+  ];
+}
+
+export async function handleTeamsMcpLine(
+  line: string,
+  options: TeamsMcpServerOptions = {},
+): Promise<JsonRpcResponse | null> {
+  try {
+    return await handleTeamsMcpMessage(JSON.parse(line), options);
+  } catch (error) {
+    return jsonRpcError(null, -32700, "Parse error", describeError(error));
+  }
+}
+
+export async function handleTeamsMcpMessage(
+  message: unknown,
+  options: TeamsMcpServerOptions = {},
+): Promise<JsonRpcResponse | null> {
+  const request = parseRequest(message);
+  if (request === null) return null;
+
+  try {
+    if (request.method === "initialize")
+      return jsonRpcResult(request.id, initializeResult(request));
+    if (request.method === "ping") return jsonRpcResult(request.id, {});
+    if (request.method === "tools/list") {
+      return jsonRpcResult(request.id, { tools: getTeamsMcpTools() });
+    }
+    if (request.method === "tools/call") {
+      return jsonRpcResult(request.id, await callTeamsTool(request.params, options));
+    }
+    return jsonRpcError(request.id, -32601, `Method not found: ${request.method}`);
+  } catch (error) {
+    return jsonRpcError(request.id, -32603, describeError(error));
+  }
+}
+
+export async function runTeamsMcpStdioServer(
+  options: TeamsMcpServerOptions & {
+    input?: Readable;
+    output?: Writable;
+  } = {},
+): Promise<void> {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+
+  for await (const line of lines) {
+    if (line.trim() === "") continue;
+    const response = await handleTeamsMcpLine(line, options);
+    if (response !== null) {
+      output.write(`${JSON.stringify(response)}\n`);
+    }
+  }
+}
+
+function initializeResult(request: ParsedRequest): Record<string, unknown> {
+  const params = isRecord(request.params) ? request.params : {};
+  const requestedVersion =
+    typeof params.protocolVersion === "string" ? params.protocolVersion : PROTOCOL_VERSION;
+  const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requestedVersion)
+    ? requestedVersion
+    : PROTOCOL_VERSION;
+  return {
+    protocolVersion,
+    capabilities: {
+      tools: {
+        listChanged: false,
+      },
+    },
+    serverInfo: {
+      name: "evodev-teams",
+      version: "0.0.1-alpha",
+    },
+    instructions:
+      "Use list_agents to discover EvoDev role agents, spawn_role to create or reuse role agents in the current EvoDev team run, send_message to communicate through the EvoDev broker, and stop_role to stop roles. Role lifecycle is tracked by EvoDev Teams MCP/CLI (`evodev team ...`), not direct tmux orchestration.",
+  };
+}
+
+async function callTeamsTool(
+  params: unknown,
+  options: TeamsMcpServerOptions,
+): Promise<Record<string, unknown>> {
+  const input = expectRecord(params, "tools/call params");
+  const name = expectString(input.name, "tools/call params.name");
+  const args = input.arguments === undefined ? {} : expectRecord(input.arguments, "arguments");
+  const broker = new TeamMessageBroker(options);
+
+  if (name === "list_agents") {
+    const agents = await broker.listAgents({
+      runId: optionalString(args.runId) ?? options.defaultRunId,
+    });
+    return toolResult({ agents });
+  }
+
+  if (name === "send_message") {
+    const toRoleId = expectString(args.toRoleId, "arguments.toRoleId");
+    const message = expectString(args.message, "arguments.message");
+    const type = parseMessageType(args.type);
+    const fromRoleId = optionalString(args.fromRoleId) ?? options.defaultFromRoleId;
+    const result = await broker.send({
+      runId: optionalString(args.runId) ?? options.defaultRunId,
+      fromRoleId,
+      toRoleId,
+      message,
+      type,
+      now: options.now,
+    });
+    return result.ok ? toolResult({ ...result }) : toolResult({ ...result }, true);
+  }
+
+  if (name === "spawn_role") {
+    const roleId = expectString(args.roleId, "arguments.roleId");
+    const fromRoleId = optionalString(args.fromRoleId) ?? options.defaultFromRoleId;
+    const result = await broker.spawnRole({
+      runId: optionalString(args.runId) ?? options.defaultRunId,
+      fromRoleId,
+      roleId,
+      reason: optionalString(args.reason),
+      now: options.now,
+    });
+    return result.ok ? toolResult({ ...result }) : toolResult({ ...result }, true);
+  }
+
+  if (name === "stop_role") {
+    const roleId = expectString(args.roleId, "arguments.roleId");
+    const fromRoleId = optionalString(args.fromRoleId) ?? options.defaultFromRoleId;
+    const result = await broker.stopRole({
+      runId: optionalString(args.runId) ?? options.defaultRunId,
+      fromRoleId,
+      roleId,
+      reason: optionalString(args.reason),
+      now: options.now,
+    });
+    return result.ok ? toolResult({ ...result }) : toolResult({ ...result }, true);
+  }
+
+  throw new Error(`Unknown Teams MCP tool: ${name}`);
+}
+
+function toolResult(
+  structuredContent: Record<string, unknown>,
+  isError = false,
+): Record<string, unknown> {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(structuredContent, null, 2),
+      },
+    ],
+    structuredContent,
+    isError,
+  };
+}
+
+interface ParsedRequest {
+  id: JsonRpcId;
+  method: string;
+  params?: unknown;
+}
+
+function parseRequest(message: unknown): ParsedRequest | null {
+  if (!isRecord(message)) throw new Error("Invalid JSON-RPC message; expected object.");
+  if (message.jsonrpc !== "2.0") throw new Error("Invalid JSON-RPC version.");
+  if (message.id === undefined) return null;
+  if (typeof message.id !== "string" && typeof message.id !== "number") {
+    throw new Error("Invalid JSON-RPC id.");
+  }
+  const method = expectString(message.method, "method");
+  return { id: message.id, method, params: message.params };
+}
+
+function parseMessageType(value: unknown): TeamMessageType | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value === "string" && MESSAGE_TYPES.has(value as TeamMessageType)) {
+    return value as TeamMessageType;
+  }
+  throw new Error("arguments.type must be request, result, issue, or notice.");
+}
+
+function jsonRpcResult(id: JsonRpcId, result: Record<string, unknown>): JsonRpcResponse {
+  return { jsonrpc: "2.0", id, result };
+}
+
+function jsonRpcError(
+  id: JsonRpcId | null,
+  code: number,
+  message: string,
+  data?: unknown,
+): JsonRpcResponse {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+
+function expectRecord(value: unknown, path: string): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error(`Invalid ${path}; expected object.`);
+  return value;
+}
+
+function expectString(value: unknown, path: string): string {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid ${path}; expected non-empty string.`);
+  }
+  return value;
+}
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/workflow/index.ts

@@ -13,7 +13,7 @@ export interface WorkflowManifest {
   steps: WorkflowStep[];
   requiredEvidence: string[];
   verification: {
-    policy: "fail-closed";
+    policy: "advisory";
     antiCriteria: string[];
   };
   privacy: {
@@ -41,7 +41,7 @@ export interface WorkflowPlan {
   steps: Array<WorkflowStep & { plannedOnly: true }>;
   requiredEvidence: string[];
   warnings: string[];
-  blockers: string[];
+  advisories: string[];
 }
 
 export async function scanWorkflowManifests(workflowsDir: string): Promise<WorkflowManifest[]> {
@@ -84,10 +84,10 @@ export function planWorkflow(input: {
 }): WorkflowPlan {
   const mode = input.contract?.route.mode ?? null;
   const warnings: string[] = [];
-  const blockers: string[] = [];
+  const advisories: string[] = [];
 
   if (mode !== null && !input.workflow.modes.includes(mode)) {
-    blockers.push(`Workflow ${input.workflow.id} does not support task mode ${mode}.`);
+    advisories.push(`Workflow ${input.workflow.id} does not list task mode ${mode}.`);
   }
 
   return {
@@ -97,7 +97,7 @@ export function planWorkflow(input: {
     steps: input.workflow.steps.map((step) => ({ ...step, plannedOnly: true })),
     requiredEvidence: input.workflow.requiredEvidence,
     warnings,
-    blockers,
+    advisories,
   };
 }
 
@@ -128,7 +128,7 @@ export function formatWorkflowPlan(plan: WorkflowPlan): string {
     "Required evidence:",
     ...plan.requiredEvidence.map((item) => `  - ${item}`),
     ...plan.warnings.map((warning) => `Warning: ${warning}`),
-    ...plan.blockers.map((blocker) => `Blocker: ${blocker}`),
+    ...plan.advisories.map((advisory) => `Advisory: ${advisory}`),
   ].join("\n");
 }