mono-pilot 0.2.10 → 0.2.13

package/dist/src/tools/exit-plan-mode.js

@@ -0,0 +1,83 @@
+import { Type } from "@sinclair/typebox";
+import { createModeStateData, modeRuntimeStore, MODE_STATE_ENTRY_TYPE, } from "../extensions/mode-runtime.js";
+const MODE_STATUS_KEY = "mono-pilot-mode";
+const DESCRIPTION = `
+Use this tool when you are in Plan mode, have finished updating the plan file, and are ready to leave Plan mode.
+
+## How This Tool Works
+- You should have already written your plan to the plan file specified in the plan mode system message
+- This tool does NOT take plan content as input
+- This tool switches the runtime mode from Plan to Agent
+- This tool should be called only after the user explicitly approves the plan or asks to proceed with execution
+
+## When to Use This Tool
+IMPORTANT: Only use this tool when the task requires planning implementation steps for code changes. For research-only tasks where you're gathering information, searching files, or reading files, do NOT use this tool.
+
+## Before Using This Tool
+Ensure your plan is complete and unambiguous:
+- If you have unresolved questions about requirements or approach, use AskQuestion first
+- If you do not see a plan file path in system_reminder, do NOT call this tool because there is no concrete plan artifact to finalize and no need to exit Plan mode for execution.
+- Present the finalized plan to the user and wait for explicit approval before calling this tool
+- Once your plan is finalized, use THIS tool to exit Plan mode
+
+**Important:** Do NOT call this tool immediately after drafting a plan. Wait for explicit user approval in the conversation first.
+
+## Examples
+
+1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
+2. Initial task: "Help me implement yank mode for vim" - Draft and present the plan, wait for user approval, then use this tool.
+3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use AskQuestion first, present the finalized plan, then call this tool only after user approval.
+`.trim();
+const exitPlanModeSchema = Type.Object({});
+function updateModeStatus(ctx) {
+    if (!ctx.hasUI)
+        return;
+    const { activeMode } = modeRuntimeStore.getSnapshot();
+    const statusText = activeMode === "plan"
+        ? ctx.ui.theme.fg("warning", "mode:plan")
+        : activeMode === "ask"
+            ? ctx.ui.theme.fg("borderAccent", "mode:ask")
+            : ctx.ui.theme.fg("muted", "mode:agent");
+    ctx.ui.setStatus(MODE_STATUS_KEY, statusText);
+}
+function persistModeState(pi) {
+    pi.appendEntry(MODE_STATE_ENTRY_TYPE, createModeStateData(modeRuntimeStore.getSnapshot()));
+}
+export default function exitPlanModeExtension(pi) {
+    pi.registerTool({
+        name: "ExitPlanMode",
+        label: "ExitPlanMode",
+        description: DESCRIPTION,
+        parameters: exitPlanModeSchema,
+        async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+            const before = modeRuntimeStore.getSnapshot();
+            if (before.activeMode !== "plan") {
+                const details = {
+                    previous_mode: before.activeMode,
+                    active_mode: before.activeMode,
+                    changed: false,
+                    plan_file: before.planFilePath,
+                };
+                return {
+                    content: [{ type: "text", text: "Plan mode is not active." }],
+                    details,
+                };
+            }
+            const { changed, snapshot } = modeRuntimeStore.setMode("agent");
+            if (changed) {
+                persistModeState(pi);
+            }
+            updateModeStatus(ctx);
+            const details = {
+                previous_mode: before.activeMode,
+                active_mode: snapshot.activeMode,
+                changed,
+                plan_file: snapshot.planFilePath,
+            };
+            return {
+                content: [{ type: "text", text: "Exited Plan mode. Switched to Agent mode." }],
+                details,
+            };
+        },
+    });
+}

package/dist/{tools → src/tools}/fetch-mcp-resource.js

@@ -1,9 +1,11 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
+import { keyHint } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { McpServerError, resolveTargetServer } from "../src/mcp/servers.js";
-import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../src/mcp/protocol.js";
-import { formatErrorMessage, isRecord, toNonEmptyString } from "../src/mcp/config.js";
+import { McpServerError, resolveTargetServer } from "../mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../mcp/protocol.js";
+import { formatErrorMessage, isRecord, toNonEmptyString } from "../mcp/config.js";
 const DESCRIPTION = `Reads a specific resource from an MCP server, identified by server name and resource URI. Optionally, set downloadPath (relative to the workspace) to save the resource to disk; when set, the resource will be downloaded and not returned to the model.`;
 const fetchMcpResourceSchema = Type.Object({
     server: Type.String({ description: "The MCP server identifier" }),
@@ -83,6 +85,32 @@ export default function fetchMcpResourceExtension(pi) {
         label: "FetchMcpResource",
         description: DESCRIPTION,
         parameters: fetchMcpResourceSchema,
+        renderCall(args, theme) {
+            const input = args;
+            const server = typeof input.server === "string" && input.server.trim().length > 0 ? input.server : "(missing server)";
+            const uri = typeof input.uri === "string" && input.uri.trim().length > 0 ? input.uri : "(missing uri)";
+            let text = theme.fg("toolTitle", theme.bold("FetchMcpResource"));
+            text += ` ${theme.fg("toolOutput", `${server} :: ${uri}`)}`;
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { expanded, isPartial }, theme) {
+            if (isPartial) {
+                return new Text(theme.fg("muted", "Fetching resource..."), 0, 0);
+            }
+            const textBlock = result.content.find((entry) => entry.type === "text" && typeof entry.text === "string");
+            if (!textBlock) {
+                return new Text(theme.fg("error", "No text result returned."), 0, 0);
+            }
+            const fullText = textBlock.text;
+            const lineCount = fullText.split("\n").length;
+            if (!expanded) {
+                const summary = `${lineCount} lines (click or ${keyHint("expandTools", "to expand")})`;
+                return new Text(theme.fg("muted", summary), 0, 0);
+            }
+            let text = fullText.split("\n").map((line) => theme.fg("toolOutput", line)).join("\n");
+            text += theme.fg("muted", `\n(click or ${keyHint("expandTools", "to collapse")})`);
+            return new Text(text, 0, 0);
+        },
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
             let serverName;
             let uri;