mini-coder 0.5.12 → 0.5.14

package/src/index.ts

@@ -1,9 +1,9 @@
 /**
  * Entry point for mini-coder.
  *
- * Discovers available LLM providers, loads context (AGENTS.md, skills,
- * plugins), opens the session database, selects a model, and starts
- * the TUI.
+ * Discovers available LLM providers, loads configured MCP tools,
+ * loads prompt context (AGENTS.md, skills, and theme), opens the session
+ * database, selects a model, and starts the TUI.
  *
  * @module
  */
@@ -13,8 +13,8 @@ import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import type {
+  AssistantMessage,
   KnownProvider,
-  Message,
   Model,
   OAuthCredentials,
   ThinkingLevel,
@@ -23,7 +23,16 @@ import type {
 } from "@mariozechner/pi-ai";
 import { getEnvApiKey, getModels, getProviders } from "@mariozechner/pi-ai";
 import { getOAuthApiKey, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
-import type { ToolHandler } from "./agent.ts";
+import {
+  runAgentLoop,
+  type ToolHandler,
+  type ToolUpdateCallback,
+} from "./agent.ts";
+import {
+  extractAssistantActivitySnippet,
+  extractAssistantErrorText,
+  extractAssistantText,
+} from "./assistant-output.ts";
 import {
   type CliOptions,
   parseCliArgs,
@@ -31,17 +40,14 @@ import {
   shouldUseHeadlessMode,
   type TtyState,
 } from "./cli.ts";
+import {
+  readShellDelegationContext,
+  type ShellDelegationContext,
+} from "./delegation.ts";
 import { getErrorMessage } from "./errors.ts";
 import { type GitState, getGitState } from "./git.ts";
+import { discoverMcpServers, type McpServerState } from "./mcp.ts";
 import { canonicalizePath } from "./paths.ts";
-import {
-  type AgentContext,
-  destroyPlugins,
-  initPlugins,
-  type LoadedPlugin,
-  loadPluginConfig,
-  type PluginEntry,
-} from "./plugins.ts";
 import {
   type AgentsMdFile,
   buildSystemPrompt,
@@ -52,7 +58,8 @@ import {
   appendMessage,
   createConversationSnapshot,
   createSession,
-  filterModelMessages,
+  deleteSession,
+  loadCompactedModelMessages,
   type loadMessages,
   openDatabase,
   type Session,
@@ -61,15 +68,20 @@ import {
 } from "./session.ts";
 import {
   type CustomProvider,
-  loadSettings,
+  loadStartupSettings,
+  mergeUserSettings,
   resolveStartupSettings,
   type UserSettings,
 } from "./settings.ts";
 import { discoverSkills, type Skill } from "./skills.ts";
-import { DEFAULT_THEME, mergeThemes, type Theme } from "./theme.ts";
+import { DEFAULT_THEME, type Theme } from "./theme.ts";
 import {
+  createDelegateToolHandler,
+  createDelegationAwareShellToolHandler,
   createTodoReadToolHandler,
   createTodoWriteToolHandler,
+  type DelegateRunResult,
+  delegateTool,
   editTool,
   editToolHandler,
   grepTool,
@@ -79,7 +91,6 @@ import {
   readTool,
   readToolHandler,
   shellTool,
-  shellToolHandler,
   todoReadTool,
   todoWriteTool,
 } from "./tools.ts";
@@ -95,9 +106,6 @@ const DATA_DIR = join(homedir(), ".config", "mini-coder");
 /** SQLite database path. */
 const DB_PATH = join(DATA_DIR, "mini-coder.db");
 
-/** Plugin config file path. */
-const PLUGIN_CONFIG_PATH = join(DATA_DIR, "plugins.json");
-
 /** OAuth credentials file path. */
 const AUTH_PATH = join(DATA_DIR, "auth.json");
 
@@ -362,19 +370,128 @@ function selectModel(
 // Tool wiring
 // ---------------------------------------------------------------------------
 
+type ToolRuntimeState = Pick<
+  AppState,
+  | "agentsMd"
+  | "cwd"
+  | "db"
+  | "delegationDepth"
+  | "delegationBudgetRemaining"
+  | "effort"
+  | "git"
+  | "mcpServers"
+  | "messages"
+  | "providers"
+  | "skills"
+> & {
+  model: Model<string>;
+};
+
+/**
+ * Run one isolated delegated subtask with the current model and toolset.
+ *
+ * @param task - Raw delegated subtask prompt.
+ * @param state - Runtime state to inherit into the delegated child run.
+ * @param context - Delegation context reserved for the child run.
+ * @param signal - Optional abort signal from the parent run.
+ * @param onUpdate - Optional progressive tool-update callback.
+ * @returns The delegated subagent result summary.
+ */
+async function runDelegatedTask(
+  task: string,
+  state: ToolRuntimeState,
+  context: ShellDelegationContext,
+  signal?: AbortSignal,
+  onUpdate?: ToolUpdateCallback,
+): Promise<DelegateRunResult> {
+  const session = createSession(state.db, {
+    cwd: state.cwd,
+    model: `${state.model.provider}/${state.model.id}`,
+    effort: state.effort,
+  });
+  let finalAssistantMessage: AssistantMessage | null = null;
+
+  try {
+    const userMessage = {
+      role: "user",
+      content: task,
+      timestamp: Date.now(),
+    } satisfies UserMessage;
+    const turn = appendMessage(state.db, session.id, userMessage);
+    const messages = loadCompactedModelMessages(state.db, session.id);
+    const childState: ToolRuntimeState = {
+      ...state,
+      delegationDepth: context.depth,
+      delegationBudgetRemaining: context.remainingBudget,
+      messages,
+    };
+    const { tools, toolHandlers } = buildTools(childState);
+
+    const result = await runAgentLoop({
+      db: state.db,
+      sessionId: session.id,
+      turn,
+      model: state.model,
+      systemPrompt: buildPrompt(childState),
+      tools,
+      toolHandlers,
+      messages,
+      cwd: state.cwd,
+      apiKey: state.providers.get(state.model.provider),
+      effort: state.effort,
+      signal,
+      onEvent: (event) => {
+        switch (event.type) {
+          case "assistant_message": {
+            const snippet = extractAssistantActivitySnippet(event.message);
+            if (snippet) {
+              onUpdate?.({
+                content: [
+                  {
+                    type: "text",
+                    text: `Subagent: ${snippet}`,
+                  },
+                ],
+                isError: false,
+              });
+            }
+            break;
+          }
+          case "done":
+          case "error":
+          case "aborted":
+            finalAssistantMessage = event.message;
+            break;
+          default:
+            break;
+        }
+      },
+    });
+
+    return {
+      stopReason: result.stopReason,
+      finalText: extractAssistantText(finalAssistantMessage),
+      errorText: extractAssistantErrorText(finalAssistantMessage),
+    };
+  } finally {
+    deleteSession(state.db, session.id);
+  }
+}
+
 /**
  * Build tool definitions and handler map for the current model.
  *
  * Returns the `Tool[]` to send to the model and the handler map
  * for the agent loop to dispatch tool calls.
  */
-function buildTools(
-  model: Model<string>,
-  plugins: LoadedPlugin[],
-  messages: AppState["messages"],
-): { tools: Tool[]; toolHandlers: Map<string, ToolHandler> } {
+function buildTools(state: ToolRuntimeState): {
+  tools: Tool[];
+  toolHandlers: Map<string, ToolHandler>;
+} {
+  const { mcpServers, messages, model } = state;
   const tools: Tool[] = [
     shellTool,
+    delegateTool,
     readTool,
     grepTool,
     editTool,
@@ -382,7 +499,33 @@ function buildTools(
     todoReadTool,
   ];
   const toolHandlers = new Map<string, ToolHandler>([
-    [shellTool.name, shellToolHandler],
+    [
+      shellTool.name,
+      createDelegationAwareShellToolHandler({
+        getDelegationContext: () => ({
+          depth: state.delegationDepth,
+          remainingBudget: state.delegationBudgetRemaining,
+        }),
+        setDelegationContext: (context) => {
+          state.delegationBudgetRemaining = context.remainingBudget;
+        },
+      }),
+    ],
+    [
+      delegateTool.name,
+      createDelegateToolHandler({
+        getDelegationContext: () => ({
+          depth: state.delegationDepth,
+          remainingBudget: state.delegationBudgetRemaining,
+        }),
+        setDelegationContext: (context) => {
+          state.delegationBudgetRemaining = context.remainingBudget;
+        },
+        runSubagent: (task, context, signal, onUpdate) => {
+          return runDelegatedTask(task, state, context, signal, onUpdate);
+        },
+      }),
+    ],
     [readTool.name, readToolHandler],
     [grepTool.name, grepToolHandler],
     [editTool.name, editToolHandler],
@@ -390,26 +533,23 @@ function buildTools(
     [todoReadTool.name, createTodoReadToolHandler(messages)],
   ]);
 
+  for (const server of mcpServers) {
+    if (!server.enabled || !server.connected) {
+      continue;
+    }
+
+    tools.push(...server.tools);
+    for (const [name, handler] of server.toolHandlers) {
+      toolHandlers.set(name, handler);
+    }
+  }
+
   // Conditionally register readImage for vision-capable models
   if (model.input.includes("image")) {
     tools.push(readImageTool);
     toolHandlers.set(readImageTool.name, readImageToolHandler);
   }
 
-  // Add plugin tools
-  for (const plugin of plugins) {
-    if (plugin.result.tools) {
-      for (const tool of plugin.result.tools) {
-        tools.push(tool);
-      }
-    }
-    if (plugin.result.toolHandlers) {
-      for (const [name, handler] of plugin.result.toolHandlers) {
-        toolHandlers.set(name, handler);
-      }
-    }
-  }
-
   return { tools, toolHandlers };
 }
 
@@ -429,21 +569,13 @@ function getSkillScanPaths(cwd: string, gitRoot: string | null): string[] {
   ];
 }
 
-/** Load AGENTS.md files, skills, plugins, git state, and the merged theme. */
-export async function loadPromptContext(
-  messages: readonly Message[],
-  opts?: {
-    cwd?: string;
-    pluginEntries?: PluginEntry[];
-    pluginConfigPath?: string;
-  },
-): Promise<{
+/** Load AGENTS.md files, skills, git state, and the active theme. */
+export async function loadPromptContext(opts?: { cwd?: string }): Promise<{
   cwd: string;
   canonicalCwd: string;
   git: GitState | null;
   agentsMd: AgentsMdFile[];
   skills: Skill[];
-  plugins: LoadedPlugin[];
   theme: Theme;
 }> {
   const cwd = opts?.cwd ?? process.cwd();
@@ -459,20 +591,6 @@ export async function loadPromptContext(
   );
   const agentsMd = discoverAgentsMd(cwd, scanRoot, join(home, ".agents"));
   const skills = discoverSkills(getSkillScanPaths(canonicalCwd, gitRoot));
-  const pluginEntries =
-    opts?.pluginEntries ??
-    loadPluginConfig(opts?.pluginConfigPath ?? PLUGIN_CONFIG_PATH);
-  const context: AgentContext = {
-    cwd,
-    messages,
-    dataDir: DATA_DIR,
-  };
-  const plugins = await initPlugins(pluginEntries, context, (entry, err) => {
-    console.error(`Plugin "${entry.name}" failed to init: ${err.message}`);
-  });
-  const themeOverrides = plugins
-    .map((plugin) => plugin.result.theme)
-    .filter((theme): theme is Partial<Theme> => theme != null);
 
   return {
     cwd,
@@ -480,8 +598,38 @@ export async function loadPromptContext(
     git,
     agentsMd,
     skills,
-    plugins,
-    theme: mergeThemes(DEFAULT_THEME, ...themeOverrides),
+    theme: DEFAULT_THEME,
+  };
+}
+
+/**
+ * Load global and repo-local settings for the current launch.
+ *
+ * The repo-local overlay is read only and is loaded only when a git root is
+ * known. Invalid startup content in either file is treated as empty settings.
+ *
+ * @param opts - Optional settings path and git-root override for tests.
+ * @returns Global settings, repo-local overlay settings, and the merged result.
+ */
+export function loadUserSettingsForLaunch(opts?: {
+  settingsPath?: string;
+  gitRoot?: string | null;
+}): {
+  settings: UserSettings;
+  repoSettings: UserSettings;
+  effectiveSettings: UserSettings;
+} {
+  const settingsPath = opts?.settingsPath ?? SETTINGS_PATH;
+  const gitRoot = opts?.gitRoot ?? null;
+  const settings = loadStartupSettings(settingsPath);
+  const repoSettings = gitRoot
+    ? loadStartupSettings(join(gitRoot, ".mini-coder", "settings.json"))
+    : {};
+
+  return {
+    settings,
+    repoSettings,
+    effectiveSettings: mergeUserSettings(settings, repoSettings),
   };
 }
 
@@ -490,25 +638,17 @@ export async function reloadPromptContext(
   state: AppState,
   runtime?: {
     loadPromptContext?: typeof loadPromptContext;
-    destroyPlugins?: typeof destroyPlugins;
   },
 ): Promise<void> {
   const loadContext = runtime?.loadPromptContext ?? loadPromptContext;
-  const destroyLoadedPlugins = runtime?.destroyPlugins ?? destroyPlugins;
-  const previousPlugins = state.plugins;
-  const context = await loadContext(filterModelMessages(state.messages));
+  const context = await loadContext();
 
   state.cwd = context.cwd;
   state.canonicalCwd = context.canonicalCwd;
   state.git = context.git;
   state.agentsMd = context.agentsMd;
   state.skills = context.skills;
-  state.plugins = context.plugins;
   state.theme = context.theme;
-
-  await destroyLoadedPlugins(previousPlugins, (entry, err) => {
-    console.error(`Plugin "${entry.name}" failed to destroy: ${err.message}`);
-  });
 }
 
 // ---------------------------------------------------------------------------
@@ -535,20 +675,26 @@ export interface AppState {
   agentsMd: AgentsMdFile[];
   /** Discovered skills. */
   skills: Skill[];
-  /** Loaded plugins. */
-  plugins: LoadedPlugin[];
-  /** Active theme (default + plugin overrides). */
+  /** Active theme. */
   theme: Theme;
   /** Version label shown in the empty conversation banner. */
   versionLabel: string;
   /** Current git state (null if not in a repo). */
   git: GitState | null;
+  /** Delegated-subagent depth inherited by this app process. */
+  delegationDepth: number;
+  /** Delegated-subagent budget reset at the start of each top-level agent run. */
+  delegationBudgetLimit: number;
+  /** Remaining delegated-subagent launches in the active run. */
+  delegationBudgetRemaining: number;
   /** Available provider credentials (provider → API key). */
   providers: Map<string, string>;
   /** OAuth credentials on disk. */
   oauthCredentials: Record<string, OAuthCredentials>;
   /** Loaded global user settings. */
   settings: UserSettings;
+  /** Loaded repo-local settings overlay for the current app run. */
+  repoSettings: UserSettings;
   /** Absolute path to the global settings file. */
   settingsPath: string;
   /** Working directory as entered by the user/shell (for display and tool execution). */
@@ -567,9 +713,11 @@ export interface AppState {
   showReasoning: boolean;
   /** Whether to show full (un-truncated) tool output. */
   verbose: boolean;
+  /** Configured MCP servers, including their current enabled/disabled state. */
+  mcpServers: McpServerState[];
   /** Models discovered from custom OpenAI-compatible providers. */
   customModels: Model<string>[];
-  /** Warnings from startup (e.g. unreachable custom providers). */
+  /** Warnings from startup (e.g. unreachable custom providers or MCP servers). */
   startupWarnings: string[];
 }
 
@@ -587,13 +735,17 @@ export async function init(): Promise<AppState> {
   // Discover providers (env + OAuth)
   const { providers, oauthCredentials } = await discoverProviders();
 
-  // Load user settings and resolve startup defaults
-  const settings = loadSettings(SETTINGS_PATH);
+  const promptContext = await loadPromptContext({ cwd });
+  const { settings, repoSettings, effectiveSettings } =
+    loadUserSettingsForLaunch({
+      settingsPath: SETTINGS_PATH,
+      gitRoot: promptContext.git?.root ?? null,
+    });
 
-  // Discover custom providers from settings
+  // Discover custom providers from effective settings
   const builtInProviderNames = new Set(providers.keys());
   const customResult = await discoverCustomProviders(
-    settings.customProviders ?? [],
+    effectiveSettings.customProviders ?? [],
     builtInProviderNames,
   );
 
@@ -602,10 +754,13 @@ export async function init(): Promise<AppState> {
     providers.set(name, key);
   }
 
+  const mcpResult = await discoverMcpServers(effectiveSettings.mcp);
+  const delegation = readShellDelegationContext(process.env);
+
   const builtInModels = listAvailableModels(providers);
   const availableModels = [...builtInModels, ...customResult.models];
   const startup = resolveStartupSettings(
-    settings,
+    effectiveSettings,
     availableModels.map((model) => `${model.provider}/${model.id}`),
   );
   const model = selectModel(availableModels, startup.modelId);
@@ -614,12 +769,6 @@ export async function init(): Promise<AppState> {
   const db = openDatabase(DB_PATH);
   const effort = startup.effort;
   const conversation = createConversationSnapshot();
-  const promptContext = await loadPromptContext(
-    filterModelMessages(conversation.messages),
-    {
-      cwd,
-    },
-  );
 
   return {
     db,
@@ -631,13 +780,16 @@ export async function init(): Promise<AppState> {
     contextTokens: conversation.contextTokens,
     agentsMd: promptContext.agentsMd,
     skills: promptContext.skills,
-    plugins: promptContext.plugins,
     theme: promptContext.theme,
     versionLabel: resolveAppVersionLabel(),
     git: promptContext.git,
+    delegationDepth: delegation.depth,
+    delegationBudgetLimit: delegation.remainingBudget,
+    delegationBudgetRemaining: delegation.remainingBudget,
     providers,
     oauthCredentials,
     settings,
+    repoSettings,
     settingsPath: SETTINGS_PATH,
     cwd: promptContext.cwd,
     canonicalCwd: promptContext.canonicalCwd,
@@ -647,8 +799,9 @@ export async function init(): Promise<AppState> {
     queuedUserMessages: [],
     showReasoning: startup.showReasoning,
     verbose: startup.verbose,
+    mcpServers: mcpResult.servers,
     customModels: customResult.models,
-    startupWarnings: customResult.warnings,
+    startupWarnings: [...customResult.warnings, ...mcpResult.warnings],
   };
 }
 
@@ -674,7 +827,9 @@ function resolvePromptOs(): "linux" | "mac" | "docker" {
  * Separated from `init` because turns still rebuild the assembled prompt
  * from the session-stable prompt context plus the current runtime state.
  */
-export function buildPrompt(state: AppState): string {
+export function buildPrompt(
+  state: Pick<AppState, "cwd" | "model" | "git" | "agentsMd" | "skills">,
+): string {
   return buildSystemPrompt({
     cwd: state.cwd,
     modelLabel: state.model
@@ -686,9 +841,6 @@ export function buildPrompt(state: AppState): string {
     git: state.git,
     agentsMd: state.agentsMd,
     skills: state.skills,
-    pluginSuffixes: state.plugins
-      .map((p) => p.result.systemPromptSuffix)
-      .filter((s): s is string => s != null),
   });
 }
 
@@ -697,8 +849,22 @@ export function buildToolList(state: AppState): {
   tools: Tool[];
   toolHandlers: Map<string, ToolHandler>;
 } {
-  if (!state.model) return { tools: [], toolHandlers: new Map() };
-  return buildTools(state.model, state.plugins, state.messages);
+  const { model } = state;
+  if (!model) return { tools: [], toolHandlers: new Map() };
+  return buildTools({
+    agentsMd: state.agentsMd,
+    cwd: state.cwd,
+    db: state.db,
+    delegationDepth: state.delegationDepth,
+    delegationBudgetRemaining: state.delegationBudgetRemaining,
+    effort: state.effort,
+    git: state.git,
+    mcpServers: state.mcpServers,
+    messages: state.messages,
+    model,
+    providers: state.providers,
+    skills: state.skills,
+  });
 }
 
 /**
@@ -747,9 +913,7 @@ export function getAvailableModels(state: AppState): Model<string>[] {
 
 /** Clean up resources on shutdown. */
 export async function shutdown(state: AppState): Promise<void> {
-  await destroyPlugins(state.plugins, (entry, err) => {
-    console.error(`Plugin "${entry.name}" failed to destroy: ${err.message}`);
-  });
+  await Promise.allSettled(state.mcpServers.map((server) => server.close()));
   state.db.close();
 }
 
@@ -776,7 +940,8 @@ type HeadlessCliStopReason = "stop" | "length" | "error" | "aborted";
  *
  * Non-TTY detection only decides whether headless mode should run at all.
  * Once headless mode is selected, `--json` is the only switch that chooses
- * NDJSON streaming versus final-text output.
+ * NDJSON streaming versus the default text mode (stdout final answer plus
+ * stderr activity snippets).
  *
  * @param state - Initialized application state for the run.
  * @param cli - Parsed CLI options.

package/src/input.ts

@@ -23,6 +23,7 @@ export const COMMANDS = [
   "undo",
   "reasoning",
   "verbose",
+  "mcp",
   "todo",
   "login",
   "logout",
@@ -31,8 +32,11 @@ export const COMMANDS = [
   "effort",
 ] as const;
 
+/** Slash helper that opens the interactive skill picker when submitted alone. */
+export const SKILL_COMMAND = "skill" as const;
+
 /** A recognized slash command name. */
-type Command = (typeof COMMANDS)[number];
+type Command = (typeof COMMANDS)[number] | typeof SKILL_COMMAND;
 
 const COMMAND_SET: ReadonlySet<string> = new Set(COMMANDS);
 
@@ -73,6 +77,14 @@ function isCommand(value: string): value is Command {
 }
 
 function parseSlashInput(trimmed: string): ParsedInput | null {
+  if (trimmed === `/${SKILL_COMMAND}`) {
+    return {
+      type: "command",
+      command: SKILL_COMMAND,
+      args: "",
+    };
+  }
+
   const skillMatch = trimmed.match(/^\/skill:(\S+)(?:\s+(.*))?$/s);
   if (skillMatch?.[1]) {
     return {