mini-coder 0.5.12 → 0.5.14

package/src/ui/commands.ts

@@ -17,9 +17,12 @@ import { getOAuthProviders } from "@mariozechner/pi-ai/oauth";
 import { getErrorMessage } from "../errors.ts";
 import type { AppState } from "../index.ts";
 import { getAvailableModels, saveOAuthCredentials } from "../index.ts";
-import { COMMANDS } from "../input.ts";
+import { COMMANDS, SKILL_COMMAND } from "../input.ts";
+import { connectMcpServer, disconnectMcpServer } from "../mcp.ts";
 import {
   clearConversationState,
+  computeSessionContextTokens,
+  computeSessionStats,
   forkSession,
   listPromptHistory,
   listSessions,
@@ -30,9 +33,15 @@ import {
   undoLastTurn,
 } from "../session.ts";
 import { updateSettings } from "../settings.ts";
+import { clearQueuedUserMessages } from "../submit.ts";
 import { collapseWhitespace, truncateText } from "../text.ts";
 import { getTodoItems } from "../tools.ts";
-import { buildHelpText, COMMAND_DESCRIPTIONS } from "./help.ts";
+import {
+  buildHelpText,
+  COMMAND_DESCRIPTIONS,
+  SKILL_REFERENCE_DESCRIPTION,
+  SKILL_REFERENCE_LABEL,
+} from "./help.ts";
 import { type ActiveOverlay, OVERLAY_MAX_VISIBLE } from "./overlay.ts";
 import type { UiRenderPriority } from "./runtime.ts";
 import { abbreviatePath } from "./status.ts";
@@ -74,6 +83,22 @@ interface UiCommandRuntime {
   openInBrowser: (url: string) => void;
 }
 
+interface UiCommandDeps {
+  /** Connect a configured MCP server on demand. */
+  connectMcpServer: (
+    server: AppState["mcpServers"][number],
+  ) => Promise<string[]>;
+  /** Disconnect an MCP server and clear its imported tools. */
+  disconnectMcpServer: (
+    server: AppState["mcpServers"][number],
+  ) => Promise<void>;
+}
+
+const defaultUiCommandDeps: UiCommandDeps = {
+  connectMcpServer,
+  disconnectMcpServer,
+};
+
 /** Public command actions consumed by `ui.ts` and unit tests. */
 interface UiCommandController {
   /** Apply a model selection and persist it to settings. */
@@ -212,14 +237,117 @@ interface OverlayItem {
   filterText: string;
 }
 
+function formatSkillLabel(skill: AppState["skills"][number]): string {
+  return skill.description
+    ? `${skill.name}  ·  ${skill.description}`
+    : skill.name;
+}
+
+function formatToolCount(count: number): string {
+  return `${count} tool${count === 1 ? "" : "s"}`;
+}
+
+function formatMcpServerLabel(server: AppState["mcpServers"][number]): string {
+  return `${server.name}  ·  ${server.enabled ? "on" : "off"}  ·  ${formatToolCount(server.tools.length)}`;
+}
+
+function formatMcpToggleMessage(
+  server: AppState["mcpServers"][number],
+  toolCount: number,
+): string {
+  const action = server.enabled ? "Enabled" : "Disabled";
+  const delta = `${server.enabled ? "+" : "-"}${toolCount}`;
+  const toolSuffix = toolCount === 1 ? "tool" : "tools";
+  return `${action} MCP server "${server.name}" (${delta} ${toolSuffix}).`;
+}
+
+function isRepoLocalMcpServer(state: AppState, serverName: string): boolean {
+  return (
+    state.repoSettings.mcp?.servers?.some(
+      (entry) => entry.name === serverName,
+    ) ?? false
+  );
+}
+
+function persistMcpServerSettings(
+  state: AppState,
+  server: AppState["mcpServers"][number],
+): void {
+  if (isRepoLocalMcpServer(state, server.name)) {
+    return;
+  }
+
+  state.settings = updateSettings(state.settingsPath, {
+    mcp: {
+      servers: [
+        {
+          name: server.name,
+          url: server.url,
+          enabled: server.enabled,
+        },
+      ],
+    },
+  });
+}
+
+async function toggleMcpServer(
+  server: AppState["mcpServers"][number],
+  state: AppState,
+  runtime: UiCommandRuntime,
+  deps: UiCommandDeps,
+): Promise<void> {
+  try {
+    if (server.enabled) {
+      const toolCount = server.tools.length;
+      await deps.disconnectMcpServer(server);
+      server.enabled = false;
+      persistMcpServerSettings(state, server);
+      runtime.appendInfoMessage(
+        formatMcpToggleMessage(server, toolCount),
+        state,
+      );
+      runtime.requestRender("normal");
+      return;
+    }
+
+    const warnings = await deps.connectMcpServer(server);
+    if (!server.connected) {
+      for (const warning of warnings) {
+        runtime.appendInfoMessage(warning, state);
+      }
+      runtime.requestRender("normal");
+      return;
+    }
+
+    server.enabled = true;
+    persistMcpServerSettings(state, server);
+    runtime.appendInfoMessage(
+      formatMcpToggleMessage(server, server.tools.length),
+      state,
+    );
+    for (const warning of warnings) {
+      runtime.appendInfoMessage(warning, state);
+    }
+    runtime.requestRender("normal");
+  } catch (error) {
+    runtime.appendInfoMessage(
+      `MCP server "${server.name}": ${getErrorMessage(error)}`,
+      state,
+    );
+    runtime.requestRender("normal");
+  }
+}
+
 /**
  * Create the UI command controller bound to the current UI runtime hooks.
  *
  * @param runtime - State mutation and rendering hooks owned by `ui.ts`.
+ * @param deps - Internal MCP command dependencies, mainly for tests.
  * @returns Command actions for slash commands and overlays.
  */
 export function createCommandController(
   runtime: UiCommandRuntime,
+  deps: UiCommandDeps = defaultUiCommandDeps,
 ): UiCommandController {
   const openSelectOverlay = (
     state: AppState,
@@ -235,20 +363,52 @@ export function createCommandController(
       focused: true,
       highlightColor: state.theme.accentText,
       onSelect,
+      onKeyPress: (key) => {
+        if (key === "escape") {
+          runtime.dismissOverlay();
+          return;
+        }
+        return false;
+      },
       onBlur: runtime.dismissOverlay,
     });
 
     runtime.openOverlay({ select, title });
   };
 
-  const showCommandAutocomplete = (state: AppState): void => {
-    const items = COMMANDS.map((command) => ({
-      label: `/${command}  ${COMMAND_DESCRIPTIONS[command] ?? ""}`,
-      value: command,
-      filterText: command,
+  const handleSkillCommand = (state: AppState): void => {
+    const items = state.skills.map((skill) => ({
+      label: formatSkillLabel(skill),
+      value: skill.name,
+      filterText: `${skill.name} ${skill.description ?? ""}`,
     }));
 
-    runtime.setInputValue("");
+    openSelectOverlay(
+      state,
+      "Select a skill",
+      items,
+      "type to filter skills...",
+      (skillName) => {
+        runtime.setInputValue(`/${SKILL_COMMAND}:${skillName}`);
+        runtime.dismissOverlay();
+      },
+    );
+  };
+
+  const showCommandAutocomplete = (state: AppState): void => {
+    const items: OverlayItem[] = [
+      ...COMMANDS.map((command) => ({
+        label: `/${command}  ${COMMAND_DESCRIPTIONS[command] ?? ""}`,
+        value: command,
+        filterText: command,
+      })),
+      {
+        label: `${SKILL_REFERENCE_LABEL}  ${SKILL_REFERENCE_DESCRIPTION}`,
+        value: SKILL_COMMAND,
+        filterText: `${SKILL_COMMAND} ${SKILL_REFERENCE_LABEL}`,
+      },
+    ];
+
     openSelectOverlay(
       state,
       "Commands",
@@ -256,6 +416,12 @@ export function createCommandController(
       "type to filter commands...",
       (value) => {
         runtime.dismissOverlay();
+        if (value === SKILL_COMMAND) {
+          handleSkillCommand(state);
+          return;
+        }
+
+        runtime.setInputValue("");
         handleCommand(value, state);
       },
     );
@@ -376,11 +542,17 @@ export function createCommandController(
       items,
       "type to filter sessions...",
       (sessionId) => {
+        clearQueuedUserMessages(state);
         if (sessionId !== currentSessionId) {
           const picked = sessions.find((session) => session.id === sessionId);
           if (picked) {
             state.session = picked;
             replaceConversationState(state, loadMessages(state.db, picked.id));
+            state.stats = computeSessionStats(state.db, picked.id);
+            state.contextTokens = computeSessionContextTokens(
+              state.db,
+              picked.id,
+            );
             runtime.scrollConversationToBottom();
           }
         }
@@ -394,6 +566,7 @@ export function createCommandController(
     if (state.running) {
       return;
     }
+    clearQueuedUserMessages(state);
     state.session = null;
     clearConversationState(state);
     await runtime.reloadPromptContext(state);
@@ -408,10 +581,14 @@ export function createCommandController(
     const forked = forkSession(state.db, state.session.id);
     state.session = forked;
     replaceConversationState(state, loadMessages(state.db, forked.id));
+    state.stats = computeSessionStats(state.db, forked.id);
+    state.contextTokens = computeSessionContextTokens(state.db, forked.id);
     runtime.appendInfoMessage("Forked session.", state);
   };
 
   const handleUndoCommand = async (state: AppState): Promise<void> => {
+    clearQueuedUserMessages(state);
+
     if (state.running && state.abortController) {
       state.abortController.abort();
     }
@@ -426,6 +603,11 @@ export function createCommandController(
     const removed = undoLastTurn(state.db, state.session.id);
     if (removed) {
       replaceConversationState(state, loadMessages(state.db, state.session.id));
+      state.stats = computeSessionStats(state.db, state.session.id);
+      state.contextTokens = computeSessionContextTokens(
+        state.db,
+        state.session.id,
+      );
       runtime.scrollConversationToBottom();
       runtime.requestRender("normal");
     }
@@ -445,6 +627,34 @@ export function createCommandController(
     });
   };
 
+  const handleMcpCommand = (state: AppState): void => {
+    if (state.mcpServers.length === 0) {
+      return;
+    }
+
+    const items = state.mcpServers.map((server) => ({
+      label: formatMcpServerLabel(server),
+      value: server.name,
+      filterText: `${server.name} ${server.url} ${server.enabled ? "on" : "off"}`,
+    }));
+
+    openSelectOverlay(
+      state,
+      "Toggle MCP servers",
+      items,
+      "type to filter MCP servers...",
+      (serverName) => {
+        const server = state.mcpServers.find(
+          (entry) => entry.name === serverName,
+        );
+        runtime.dismissOverlay();
+        if (server) {
+          void toggleMcpServer(server, state, runtime, deps);
+        }
+      },
+    );
+  };
+
   const performLogin = async (
     provider: OAuthProviderInterface,
     state: AppState,
@@ -611,12 +821,18 @@ export function createCommandController(
       case "verbose":
         handleVerboseCommand(state);
         return true;
+      case "mcp":
+        handleMcpCommand(state);
+        return true;
       case "todo":
         handleTodoCommand(state);
         return true;
       case "help":
         handleHelpCommand(state);
         return true;
+      case SKILL_COMMAND:
+        handleSkillCommand(state);
+        return true;
       default:
         return false;
     }

package/src/ui/conversation.test.ts

@@ -55,17 +55,6 @@ function collectTextNodes(node: Node | null): TextNode[] {
   return node.children.flatMap((child) => collectTextNodes(child));
 }
 
-function findTextNode(node: Node | null, content: string): TextNode {
-  const textNode = collectTextNodes(node).find(
-    (text) => text.content === content,
-  );
-  expect(textNode).toBeDefined();
-  if (!textNode) {
-    throw new Error(`Missing text node: ${content}`);
-  }
-  return textNode;
-}
-
 function makeAssistantToolCallMessage(): AssistantMessage {
   return {
     role: "assistant",
@@ -146,7 +135,7 @@ describe("ui/conversation", () => {
     expect(lines.join("\n")).not.toContain('"path"');
   });
 
-  test("shell tool-call previews use cel-tui syntax scopes for custom colors", () => {
+  test("shell tool-call previews render the command instead of raw JSON", () => {
     const node = renderAssistantMessage(
       {
         content: [
@@ -169,9 +158,220 @@ describe("ui/conversation", () => {
       },
     );
 
-    expect(findTextNode(node, "true").props.fgColor).toBe(
-      DEFAULT_THEME.secondaryAccentText,
+    const lines = collectRenderedLines(node);
+    expect(lines).toContain("│ shell ->");
+    expect(lines.join("\n")).toContain('if true; then echo "$HOME"; fi');
+    expect(lines.join("\n")).not.toContain('"command"');
+  });
+
+  test("compact shell tool-call previews only render the visible tail slice", () => {
+    const command = Array.from(
+      { length: 14 },
+      (_, index) => `echo line ${index + 1}`,
+    ).join("\n");
+
+    const compactLines = collectRenderedLines(
+      renderAssistantMessage(
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-shell",
+              name: "shell",
+              arguments: { command },
+            },
+          ],
+        },
+        {
+          showReasoning: true,
+          verbose: false,
+          theme: DEFAULT_THEME,
+          cwd: "/tmp/project",
+          previewWidth: 80,
+        },
+      ),
+    );
+    const verboseLines = collectRenderedLines(
+      renderAssistantMessage(
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-shell",
+              name: "shell",
+              arguments: { command },
+            },
+          ],
+        },
+        {
+          showReasoning: true,
+          verbose: true,
+          theme: DEFAULT_THEME,
+          cwd: "/tmp/project",
+          previewWidth: 80,
+        },
+      ),
     );
+
+    expect(compactLines).toContain("│ shell ->");
+    expect(compactLines).toContain("│ echo line 14");
+    expect(compactLines).toContain("│ And 6 lines more");
+    expect(compactLines).not.toContain("│ echo line 1");
+    expect(verboseLines).toContain("│ echo line 1");
+    expect(compactLines.length).toBeLessThan(verboseLines.length);
+  });
+
+  test("MCP tool-call previews honor verbose mode", () => {
+    const args = {
+      query: "routing",
+      section: "guides",
+      limit: 10,
+      offset: 0,
+      filter1: "alpha",
+      filter2: "beta",
+      filter3: "gamma",
+      filter4: "delta",
+      filter5: "epsilon",
+      filter6: "zeta",
+      filter7: "eta",
+      filter8: "theta",
+    };
+
+    const compactLines = collectRenderedLines(
+      renderAssistantMessage(
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-mcp",
+              name: "docs__search",
+              arguments: args,
+            },
+          ],
+        },
+        {
+          showReasoning: true,
+          verbose: false,
+          theme: DEFAULT_THEME,
+          cwd: "/tmp/project",
+          previewWidth: 80,
+        },
+      ),
+    );
+    const verboseLines = collectRenderedLines(
+      renderAssistantMessage(
+        {
+          content: [
+            {
+              type: "toolCall",
+              id: "call-mcp",
+              name: "docs__search",
+              arguments: args,
+            },
+          ],
+        },
+        {
+          showReasoning: true,
+          verbose: true,
+          theme: DEFAULT_THEME,
+          cwd: "/tmp/project",
+          previewWidth: 80,
+        },
+      ),
+    );
+
+    expect(compactLines).toContain("│ docs__search ->");
+    expect(compactLines.some((line) => line.includes("And "))).toBe(true);
+    expect(compactLines.join("\n")).not.toContain('"query": "routing"');
+    expect(verboseLines.join("\n")).toContain('"query": "routing"');
+    expect(compactLines.length).toBeLessThan(verboseLines.length);
+  });
+
+  test("shell tool results render structured stdout/stderr details without stderr labels or error styling", () => {
+    const stdout = Array.from(
+      { length: 12 },
+      (_, index) => `line ${index + 1}`,
+    ).join("\n");
+    const node = renderToolResult(
+      "shell",
+      { command: "run-tests" },
+      "Exit code: 1\nlegacy text should be ignored when details exist",
+      true,
+      {
+        showReasoning: true,
+        verbose: false,
+        theme: DEFAULT_THEME,
+        cwd: "/tmp/project",
+        previewWidth: 48,
+      },
+      {
+        stdout,
+        stderr: "boom",
+        exitCode: 1,
+      },
+    );
+    const lines = collectRenderedLines(node);
+    const textNodes = collectTextNodes(node);
+
+    expect(lines).toContain("│ shell <-");
+    expect(lines).toContain("│ boom");
+    expect(lines).toContain("│ exit 1");
+    expect(lines).toContain("│ And 6 lines more");
+    expect(lines.join("\n")).not.toContain("stderr:");
+    expect(lines.join("\n")).not.toContain("legacy text should be ignored");
+    expect(
+      textNodes.some(
+        (textNode) =>
+          textNode.content === "boom" &&
+          textNode.props.fgColor === DEFAULT_THEME.toolText,
+      ),
+    ).toBe(true);
+    expect(
+      textNodes.some(
+        (textNode) =>
+          textNode.content === "exit 1" &&
+          textNode.props.fgColor === DEFAULT_THEME.toolText,
+      ),
+    ).toBe(true);
+  });
+
+  test("shell tool results still render legacy flattened results from persisted history without stderr labels", () => {
+    const node = renderToolResult(
+      "shell",
+      { command: "run-tests" },
+      "Exit code: 1\nout\n\n[stderr]\nerr",
+      true,
+      {
+        showReasoning: true,
+        verbose: true,
+        theme: DEFAULT_THEME,
+        cwd: "/tmp/project",
+        previewWidth: 80,
+      },
+    );
+    const lines = collectRenderedLines(node);
+    const textNodes = collectTextNodes(node);
+
+    expect(lines).toContain("│ out");
+    expect(lines).toContain("│ err");
+    expect(lines).toContain("│ exit 1");
+    expect(lines.join("\n")).not.toContain("stderr:");
+    expect(lines.join("\n")).not.toContain("[stderr]");
+    expect(lines.join("\n")).not.toContain("Exit code:");
+    expect(
+      textNodes.some(
+        (textNode) =>
+          textNode.content === "err" &&
+          textNode.props.fgColor === DEFAULT_THEME.toolText,
+      ),
+    ).toBe(true);
+    expect(
+      textNodes.some(
+        (textNode) =>
+          textNode.content === "exit 1" &&
+          textNode.props.fgColor === DEFAULT_THEME.toolText,
+      ),
+    ).toBe(true);
   });
 
   test("read tool results include the resolved path, hide model paging hints, and render fewer body lines when verbose is off", () => {
@@ -292,17 +492,12 @@ describe("ui/conversation", () => {
       },
     );
 
-    expect(findTextNode(node, "42").props.fgColor).toBe(
-      DEFAULT_THEME.secondaryAccentText,
-    );
-    expect(
-      findTextNode(node, "supercalifragilisticexpialidociousIdentifier")
-        .content,
-    ).toBe("supercalifragilisticexpialidociousIdentifier");
     expect(
-      findTextNode(node, "supercalifragilisticexpialidociousIdentifier").props
-        .fgColor,
-    ).toBeUndefined();
+      collectTextNodes(node).some(
+        (textNode) =>
+          textNode.content === "supercalifragilisticexpialidociousIdentifier",
+      ),
+    ).toBe(true);
   });
 
   test("grep tool results render grouped files and lines instead of raw JSON", () => {
@@ -353,8 +548,38 @@ describe("ui/conversation", () => {
     expect(lines).toContain("│   858:   spec: ToolBlockSpec,");
     expect(lines.join("\n")).not.toContain('"files"');
     expect(lines.join("\n")).not.toContain('"kind"');
-    expect(
-      findTextNode(node, "  857: function renderToolBlock(").props.fgColor,
-    ).toBe(DEFAULT_THEME.toolText);
+  });
+
+  test("MCP tool results honor verbose mode", () => {
+    const output = Array.from(
+      { length: 14 },
+      (_, index) => `result ${index + 1}`,
+    ).join("\n");
+
+    const compactLines = collectRenderedLines(
+      renderToolResult("docs__search", { query: "routing" }, output, false, {
+        showReasoning: true,
+        verbose: false,
+        theme: DEFAULT_THEME,
+        cwd: "/tmp/project",
+        previewWidth: 80,
+      }),
+    );
+    const verboseLines = collectRenderedLines(
+      renderToolResult("docs__search", { query: "routing" }, output, false, {
+        showReasoning: true,
+        verbose: true,
+        theme: DEFAULT_THEME,
+        cwd: "/tmp/project",
+        previewWidth: 80,
+      }),
+    );
+
+    expect(compactLines).toContain("│ docs__search <-");
+    expect(compactLines).toContain("│ result 14");
+    expect(compactLines).toContain("│ And 6 lines more");
+    expect(compactLines).not.toContain("│ result 1");
+    expect(verboseLines).toContain("│ result 1");
+    expect(compactLines.length).toBeLessThan(verboseLines.length);
   });
 });