agent-enderun 0.9.1 → 0.9.3

package/framework-mcp/node_modules/undici-types/webidl.d.ts

@@ -0,0 +1,228 @@
+// These types are not exported, and are only used internally
+
+/**
+ * Take in an unknown value and return one that is of type T
+ */
+type Converter<T> = (object: unknown) => T
+
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
+
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
+
+interface ConvertToIntOpts {
+  clamp?: boolean
+  enforceRange?: boolean
+}
+
+interface WebidlErrors {
+  exception (opts: { header: string, message: string }): TypeError
+  /**
+   * @description Throw an error when conversion from one type to another has failed
+   */
+  conversionFailed (opts: {
+    prefix: string
+    argument: string
+    types: string[]
+  }): TypeError
+  /**
+   * @description Throw an error when an invalid argument is provided
+   */
+  invalidArgument (opts: {
+    prefix: string
+    value: string
+    type: string
+  }): TypeError
+}
+
+interface WebidlUtil {
+  /**
+   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+   */
+  Type (object: unknown):
+    | 'Undefined'
+    | 'Boolean'
+    | 'String'
+    | 'Symbol'
+    | 'Number'
+    | 'BigInt'
+    | 'Null'
+    | 'Object'
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  ConvertToInt (
+    V: unknown,
+    bitLength: number,
+    signedness: 'signed' | 'unsigned',
+    opts?: ConvertToIntOpts
+  ): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
+}
+
+interface WebidlConverters {
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-DOMString
+   */
+  DOMString (V: unknown, prefix: string, argument: string, opts?: {
+    legacyNullToEmptyString: boolean
+  }): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-ByteString
+   */
+  ByteString (V: unknown, prefix: string, argument: string): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-USVString
+   */
+  USVString (V: unknown): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-boolean
+   */
+  boolean (V: unknown): boolean
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-any
+   */
+  any <Value>(V: Value): Value
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-long-long
+   */
+  ['long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
+   */
+  ['unsigned long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+   */
+  ['unsigned long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+   */
+  ['unsigned short'] (V: unknown, opts?: ConvertToIntOpts): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+   */
+  ArrayBuffer (V: unknown): ArrayBufferLike
+  ArrayBuffer (V: unknown, opts: { allowShared: false }): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike
+  ): NodeJS.TypedArray | ArrayBufferLike
+  TypedArray (
+    V: unknown,
+    TypedArray: NodeJS.TypedArray | ArrayBufferLike,
+    opts?: { allowShared: false }
+  ): NodeJS.TypedArray | ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (V: unknown, opts?: { allowShared: boolean }): DataView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource (
+    V: unknown,
+    opts?: { allowShared: boolean }
+  ): NodeJS.TypedArray | ArrayBufferLike | DataView
+
+  ['sequence<ByteString>']: SequenceConverter<string>
+  
+  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
+
+  ['record<ByteString, ByteString>']: RecordConverter<string, string>
+
+  [Key: string]: (...args: any[]) => unknown
+}
+
+export interface Webidl {
+  errors: WebidlErrors
+  util: WebidlUtil
+  converters: WebidlConverters
+
+  /**
+   * @description Performs a brand-check on {@param V} to ensure it is a
+   * {@param cls} object.
+   */
+  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-sequence
+   * @description Convert a value, V, to a WebIDL sequence type.
+   */
+  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
+
+  illegalConstructor (): never
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-to-record
+   * @description Convert a value, V, to a WebIDL record type.
+   */
+  recordConverter <K extends string, V>(
+    keyConverter: Converter<K>,
+    valueConverter: Converter<V>
+  ): RecordConverter<K, V>
+
+  /**
+   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
+   * interfaces are allowed.
+   */
+  interfaceConverter <Interface>(cls: Interface): (
+    V: unknown,
+    opts?: { strict: boolean }
+  ) => asserts V is typeof cls
+
+  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
+  // from the converters given?
+  /**
+   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
+   * allowed, values allowed, optional and required keys. Auto converts the value to
+   * a type given a converter.
+   */
+  dictionaryConverter (converters: {
+    key: string,
+    defaultValue?: () => unknown,
+    required?: boolean,
+    converter: (...args: unknown[]) => unknown,
+    allowedValues?: unknown[]
+  }[]): (V: unknown) => Record<string, unknown>
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
+   * @description allows a type, V, to be null
+   */
+  nullableConverter <T>(
+    converter: Converter<T>
+  ): (V: unknown) => ReturnType<typeof converter> | null
+
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
+}

package/framework-mcp/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,150 @@
+/// <reference types="node" />
+
+import type { Blob } from 'buffer'
+import type { MessagePort } from 'worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+  
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: (typeof MessagePort)[]
+  source?: typeof MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: ReadonlyArray<typeof MessagePort>
+  readonly source: typeof MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: typeof MessagePort | null,
+    ports?: (typeof MessagePort)[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: any
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}

package/framework-mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-enderun/mcp",
-  "version": "0.9.0",
+  "version": "0.9.3",
   "description": "Agent Enderun Model Context Protocol (MCP) Server",
   "type": "module",
   "scripts": {

package/framework-mcp/src/declarations.d.ts

@@ -0,0 +1,3 @@
+declare module "@modelcontextprotocol/sdk/server/index.js";
+declare module "@modelcontextprotocol/sdk/server/stdio.js";
+declare module "@modelcontextprotocol/sdk/types.js";

package/framework-mcp/src/index.ts

@@ -0,0 +1,300 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+
+const server = new Server(
+    {
+        name: "agent-enderun-mcp",
+        version: "0.9.3",
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+const TOOLS: any[] = [
+    {
+        name: "read_file",
+        description: "Read the content of a file within the project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "write_file",
+        description: "Write content to a file. Creates directories if missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                content: { type: "string", description: "Complete content of the file" },
+            },
+            required: ["path", "content"],
+        },
+    },
+    {
+        name: "replace_text",
+        description: "Surgically replace a string in a file with another string.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                oldText: { type: "string", description: "The exact text to find" },
+                newText: { type: "string", description: "The text to replace it with" },
+            },
+            required: ["path", "oldText", "newText"],
+        },
+    },
+    {
+        name: "patch_file",
+        description: "Safely update a file by replacing a specific line range with new content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                startLine: { type: "number", description: "Starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Ending line number (inclusive)" },
+                newContent: { type: "string", description: "The new lines to insert" },
+            },
+            required: ["path", "startLine", "endLine", "newContent"],
+        },
+    },
+    {
+        name: "get_framework_status",
+        description: "Get the current project phase, active traces, and agent states.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "update_project_memory",
+        description: "Update a specific section in PROJECT_MEMORY.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
+                content: { type: "string", description: "Markdown content to append or set" },
+            },
+            required: ["section", "content"],
+        },
+    },
+    {
+        name: "orchestrate_loop",
+        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "send_agent_message",
+        description: "Send a Hermes protocol message to another agent.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to: { type: "string", description: "Target agent (e.g., @backend, @qa)" },
+                category: { type: "string", enum: ["ACTION", "DELEGATION", "INFO", "ALERT"] },
+                content: { type: "string", description: "Message content" },
+                traceId: { type: "string", description: "Active Trace ID" },
+            },
+            required: ["to", "category", "content", "traceId"],
+        },
+    },
+    {
+        name: "log_agent_action",
+        description: "Log an agent action to the framework logs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "The agent name (e.g., @manager, @backend)" },
+                action: { type: "string", description: "Action type or name" },
+                traceId: { type: "string", description: "The active Trace ID" },
+                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "The status of the action" },
+                summary: { type: "string", description: "Brief description of the action taken" },
+                findings: { type: "array", items: { type: "string" }, description: "Optional findings or details" }
+            },
+            required: ["agent", "action", "traceId", "status", "summary"]
+        }
+    },
+    {
+        name: "update_contract_hash",
+        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
+        inputSchema: { type: "object", properties: {} }
+    }
+];
+
+server.onRequest(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+
+server.onRequest(CallToolRequestSchema, async (request: any) => {
+    const { name, arguments: args } = request.params as { name: string, arguments?: Record<string, unknown> };
+
+    const projectRoot = process.cwd();
+
+    try {
+        switch (name) {
+        case "read_file": {
+            const filePath = path.join(projectRoot, args?.path as string);
+            const content = fs.readFileSync(filePath, "utf8");
+            return { content: [{ type: "text", text: content }] };
+        }
+
+        case "write_file": {
+            const filePath = path.join(projectRoot, args?.path as string);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, args?.content as string);
+            return { content: [{ type: "text", text: `✅ File written: ${args?.path}` }] };
+        }
+
+        case "replace_text": {
+            const filePath = path.join(projectRoot, args?.path as string);
+            let content = fs.readFileSync(filePath, "utf8");
+            const oldText = args?.oldText as string;
+            const newText = args?.newText as string;
+        
+            if (!content.includes(oldText)) {
+                throw new Error(`Text not found in file: ${oldText}`);
+            }
+        
+            content = content.replace(oldText, newText);
+            fs.writeFileSync(filePath, content);
+            return { content: [{ type: "text", text: `✅ Surgical edit successful in ${args?.path}` }] };
+        }
+
+        case "patch_file": {
+            const filePath = path.join(projectRoot, args?.path as string);
+            const lines = fs.readFileSync(filePath, "utf8").split("\n");
+            const start = (args?.startLine as number) - 1;
+            const end = (args?.endLine as number);
+            const newContent = (args?.newContent as string).split("\n");
+
+            if (start < 0 || start > lines.length) throw new Error("Invalid start line.");
+        
+            lines.splice(start, end - start, ...newContent);
+            fs.writeFileSync(filePath, lines.join("\n"));
+            return { content: [{ type: "text", text: `✅ File patched successfully: ${args?.path}` }] };
+        }
+
+        case "get_framework_status": {
+            const output = execSync("npx agent-enderun status").toString();
+            return { content: [{ type: "text", text: output }] };
+        }
+
+        case "update_project_memory": {
+            const section = args?.section as string;
+            const content = args?.content as string;
+            // Escape quotes for shell
+            const safeContent = content.replace(/"/g, "\\\"");
+            execSync(`npx agent-enderun update_project_memory "${section}" "${safeContent}"`);
+            return { content: [{ type: "text", text: `✅ Section ${section} updated.` }] };
+        }
+
+        case "orchestrate_loop": {
+            const output = execSync("npx agent-enderun orchestrate").toString();
+            return { content: [{ type: "text", text: output }] };
+        }
+
+        case "send_agent_message": {
+            interface SendAgentMessageArgs {
+                to: string;
+                category: "ACTION" | "DELEGATION" | "INFO" | "ALERT";
+                content: string;
+                traceId: string;
+            }
+            const { to, category, content, traceId } = args as any as SendAgentMessageArgs;
+            const frameworkDir = fs.existsSync(path.join(projectRoot, ".enderun")) ? ".enderun" : ".gemini";
+            const messagePath = path.join(projectRoot, frameworkDir, "messages", `${to.replace("@", "")}.json`);
+        
+            const message = {
+                timestamp: new Date().toISOString(),
+                from: "@mcp",
+                to,
+                category,
+                traceId,
+                content,
+                status: "PENDING"
+            };
+
+            fs.mkdirSync(path.dirname(messagePath), { recursive: true });
+            fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
+        
+            return { content: [{ type: "text", text: `✅ Message sent to ${to}` }] };
+        }
+
+        case "log_agent_action": {
+            interface LogAgentActionArgs {
+                agent: string;
+                action: string;
+                traceId: string;
+                status: "SUCCESS" | "FAILURE";
+                summary: string;
+                findings?: string[];
+            }
+            const { agent, action, traceId, status, summary, findings } = args as any as LogAgentActionArgs;
+            
+            const candidates = [
+                ".gemini/antigravity",
+                ".gemini/antigravity-cli",
+                ".gemini",
+                ".claude",
+                ".agent",
+                ".enderun",
+            ];
+            let frameworkDir = ".enderun";
+            for (const c of candidates) {
+                if (fs.existsSync(path.join(projectRoot, c))) {
+                    frameworkDir = c;
+                    break;
+                }
+            }
+            
+            const agentName = agent.replace("@", "");
+            const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
+            
+            const logEntry = {
+                timestamp: new Date().toISOString(),
+                agent,
+                action,
+                requestId: traceId,
+                status,
+                summary,
+                findings: findings || []
+            };
+            
+            fs.mkdirSync(path.dirname(logPath), { recursive: true });
+            fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
+            
+            return { content: [{ type: "text", text: `✅ Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
+        }
+
+        case "update_contract_hash": {
+            const output = execSync("npx agent-enderun update-contract").toString();
+            return { content: [{ type: "text", text: output }] };
+        }
+
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            isError: true,
+            content: [{ type: "text", text: message }],
+        };
+    }
+});
+
+async function run() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+
+run().catch(console.error);