mono-pilot 0.2.9 → 0.2.12

package/dist/{tools → src/tools}/call-mcp-tool.js

@@ -1,9 +1,9 @@
-import { homedir } from "node:os";
-import { resolve } from "node:path";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, keyHint, truncateTail, } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { createRpcRequestId, extractStringHeaders, formatErrorMessage, formatJsonRpcError, getHeaderKeys, inferTransport, isRecord, isServerEnabled, MCP_CONFIG_RELATIVE_PATH, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toBoolean, toNonEmptyString, initializeMcpSession, } from "../src/utils/mcp-client.js";
+import { McpServerError, resolveTargetServer } from "../mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../mcp/protocol.js";
+import { formatErrorMessage, getHeaderKeys, isRecord, toBoolean, toNonEmptyString } from "../mcp/config.js";
 const DESCRIPTION = `Call an MCP tool by server identifier and tool name with arbitrary JSON arguments. IMPORTANT: Always read the tool's schema/descriptor BEFORE calling to ensure correct parameters.
 
 Example:
@@ -45,10 +45,7 @@ async function callRemoteMcpTool(options) {
     if (!callBody || callBody.result === undefined) {
         throw new Error("MCP tools/call returned no result.");
     }
-    return {
-        result: callBody.result,
-        sessionId,
-    };
+    return { result: callBody.result, sessionId };
 }
 function normalizeServerName(value) {
     const normalized = value.trim();
@@ -142,27 +139,7 @@ function formatToolCallResultOutput(server, toolName, result) {
         lines.push(JSON.stringify(result, null, 2));
         lines.push("```");
     }
-    return {
-        text: lines.join("\n"),
-        contentItems,
-        isError,
-        hasStructuredContent,
-    };
-}
-function getCollapsedResultText(text, expanded) {
-    if (text.length === 0) {
-        return { output: text, remaining: 0 };
-    }
-    const lines = text.split("\n");
-    // Use 20 lines as the standard collapse threshold
-    const MAX_COLLAPSED_RESULT_LINES = 20;
-    if (expanded || lines.length <= MAX_COLLAPSED_RESULT_LINES) {
-        return { output: text, remaining: 0 };
-    }
-    return {
-        output: lines.slice(0, MAX_COLLAPSED_RESULT_LINES).join("\n"),
-        remaining: lines.length - MAX_COLLAPSED_RESULT_LINES,
-    };
+    return { text: lines.join("\n"), contentItems, isError, hasStructuredContent };
 }
 export default function callMcpToolExtension(pi) {
     pi.registerTool({
@@ -171,10 +148,16 @@ export default function callMcpToolExtension(pi) {
         description: DESCRIPTION,
         parameters: callMcpToolSchema,
         renderCall(args, theme) {
-            const server = typeof args.server === "string" ? args.server : "(missing server)";
-            const toolName = typeof args.toolName === "string" ? args.toolName : "(missing tool)";
+            const input = args;
+            const server = typeof input.server === "string" && input.server.trim() ? input.server.trim() : "(missing server)";
+            const toolName = typeof input.toolName === "string" && input.toolName.trim() ? input.toolName.trim() : "(missing tool)";
+            const commandArgs = [server, toolName];
+            if (input.arguments && typeof input.arguments === "object" && Object.keys(input.arguments).length > 0) {
+                const json = JSON.stringify(input.arguments);
+                commandArgs.push(json.length > 120 ? `${json.slice(0, 119)}…` : json);
+            }
             let text = theme.fg("toolTitle", theme.bold("CallMcpTool"));
-            text += ` ${theme.fg("toolOutput", `${server} :: ${toolName}`)}`;
+            text += ` ${theme.fg("toolOutput", commandArgs.join(" "))}`;
             return new Text(text, 0, 0);
         },
         renderResult(result, { expanded, isPartial }, theme) {
@@ -185,15 +168,18 @@ export default function callMcpToolExtension(pi) {
             if (!textBlock || typeof textBlock.text !== "string") {
                 return new Text(theme.fg("error", "No text result returned."), 0, 0);
             }
-            const { output, remaining } = getCollapsedResultText(textBlock.text, expanded);
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
             const isErrorResult = result.isError === true || result.details?.is_error === true;
-            let text = output
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg(isErrorResult ? "error" : "muted", summary), 0, 0);
+            }
+            let text = fullText
                 .split("\n")
                 .map((line) => (isErrorResult ? theme.fg("error", line) : theme.fg("toolOutput", line)))
                 .join("\n");
-            if (!expanded && remaining > 0) {
-                text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("expandTools", "to expand")})`;
-            }
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
             return new Text(text, 0, 0);
         },
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
@@ -217,75 +203,21 @@ export default function callMcpToolExtension(pi) {
                     isError: true,
                 };
             }
-            const configPath = resolveMcpConfigPath(ctx.cwd);
-            if (!configPath) {
-                const workspaceCandidate = resolve(ctx.cwd, MCP_CONFIG_RELATIVE_PATH);
-                const homeCandidate = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
-                const message = `MCP config not found. Checked:\n- ${workspaceCandidate}\n- ${homeCandidate}`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            let servers;
+            let server;
+            let configPaths;
             try {
-                servers = await parseMcpConfig(configPath);
+                const result = await resolveTargetServer(ctx.cwd, serverName);
+                server = result.server;
+                configPaths = result.configPaths;
             }
             catch (error) {
                 const message = formatErrorMessage(error);
+                const transport = error instanceof McpServerError ? error.transport : undefined;
+                const paths = error instanceof McpServerError ? error.configPaths : undefined;
                 return {
                     content: [{ type: "text", text: message }],
                     details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverConfig = servers[serverName];
-            if (!serverConfig) {
-                const message = `MCP server '${serverName}' not found in ${configPath}.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            if (!isServerEnabled(serverConfig)) {
-                const message = `MCP server '${serverName}' is disabled in config.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        transport: inferTransport(serverConfig),
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const transport = inferTransport(serverConfig);
-            if (transport === "stdio") {
-                const command = toNonEmptyString(serverConfig.command);
-                const message = `MCP stdio transport is not supported yet in CallMcpTool.` +
-                    (command ? ` Configured command: ${command}` : "");
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
+                        config_paths: paths,
                         server: serverName,
                         tool_name: toolName,
                         transport,
@@ -294,26 +226,10 @@ export default function callMcpToolExtension(pi) {
                     isError: true,
                 };
             }
-            const serverUrl = toNonEmptyString(serverConfig.url);
-            if (!serverUrl) {
-                const message = `MCP server '${serverName}' is missing a remote URL.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        transport,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const headers = extractStringHeaders(serverConfig.headers);
             try {
                 const remoteResult = await callRemoteMcpTool({
-                    serverUrl,
-                    serverHeaders: headers,
+                    serverUrl: server.url,
+                    serverHeaders: server.headers,
                     toolName,
                     argumentsValue,
                     signal,
@@ -331,12 +247,12 @@ export default function callMcpToolExtension(pi) {
                 return {
                     content: [{ type: "text", text: output }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         tool_name: toolName,
-                        transport,
-                        server_url: serverUrl,
-                        header_keys: getHeaderKeys(headers),
+                        transport: "remote",
+                        server_url: server.url,
+                        header_keys: getHeaderKeys(server.headers),
                         session_id: remoteResult.sessionId,
                         content_items: formatted.contentItems,
                         is_error: formatted.isError,
@@ -351,12 +267,12 @@ export default function callMcpToolExtension(pi) {
                 return {
                     content: [{ type: "text", text: `CallMcpTool failed: ${message}` }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         tool_name: toolName,
-                        transport,
-                        server_url: serverUrl,
-                        header_keys: getHeaderKeys(headers),
+                        transport: "remote",
+                        server_url: server.url,
+                        header_keys: getHeaderKeys(server.headers),
                         error: message,
                     },
                     isError: true,

package/dist/src/tools/codex-apply-patch-description.md

@@ -0,0 +1,52 @@
+Use this tool to edit files with codex-style patch syntax.
+
+Patch envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Each file section starts with one header:
+
+*** Add File: <path>
+*** Delete File: <path>
+*** Update File: <path>
+
+For update sections, you can optionally rename with:
+
+*** Move to: <new path>
+
+Then include one or more chunks introduced by `@@` (optionally followed by a context header):
+
+@@
+@@ class MyClass
+@@ def my_function(...)
+
+Inside each update chunk, every line must start with one of:
+
+- ` ` (space): context line
+- `-`: removed line
+- `+`: added line
+
+Optional EOF anchor:
+
+*** End of File
+
+Grammar:
+
+Patch := Begin { FileOp } End
+Begin := "*** Begin Patch" NEWLINE
+End := "*** End Patch" NEWLINE
+FileOp := AddFile | DeleteFile | UpdateFile
+AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
+DeleteFile := "*** Delete File: " path NEWLINE
+UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Chunk }
+MoveTo := "*** Move to: " path NEWLINE
+Chunk := "@@" [ header ] NEWLINE { ChunkLine } [ "*** End of File" NEWLINE ]
+ChunkLine := (" " | "-" | "+") text NEWLINE
+
+Important constraints:
+
+- Paths must be relative (absolute paths are rejected)
+- `*** Begin Patch` and `*** End Patch` are required
+- Multiple file operations are supported in a single patch