mini-coder 0.5.12 → 0.5.13

package/src/settings.ts

@@ -2,7 +2,8 @@
  * User settings persistence and startup resolution.
  *
  * Stores global defaults such as model, effort, reasoning visibility,
- * and verbose tool output in a JSON file under the app data directory.
+ * verbose tool output, custom providers, and MCP server settings in a JSON
+ * file under the app data directory.
  *
  * @module
  */
@@ -23,6 +24,22 @@ export interface CustomProvider {
   apiKey?: string;
 }
 
+/** A single configured MCP server endpoint. */
+export interface McpServerConfig {
+  /** Stable server identifier. Used as the imported tool-name prefix. */
+  name: string;
+  /** Absolute Streamable HTTP MCP endpoint URL. */
+  url: string;
+  /** Whether the server should start enabled. */
+  enabled: boolean;
+}
+
+/** MCP-related user settings. */
+export interface McpSettings {
+  /** MCP servers to connect to at startup. */
+  servers?: McpServerConfig[];
+}
+
 /** Default reasoning effort when no saved setting exists. */
 const DEFAULT_EFFORT: ThinkingLevel = "medium";
 
@@ -44,6 +61,8 @@ export interface UserSettings {
   verbose?: boolean;
   /** Custom OpenAI-compatible provider endpoints. */
   customProviders?: CustomProvider[];
+  /** MCP server definitions to manage and connect when enabled. */
+  mcp?: McpSettings;
 }
 
 /** Resolved startup settings after applying defaults and availability checks. */
@@ -65,6 +84,8 @@ const THINKING_LEVELS = new Set<ThinkingLevel>([
   "xhigh",
 ]);
 
+const MCP_SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+
 /**
  * Load and validate user settings from disk.
  *
@@ -80,13 +101,81 @@ export function loadSettings(path: string): UserSettings {
   }
 
   try {
-    const raw = JSON.parse(readFileSync(path, "utf-8")) as unknown;
-    return sanitizeSettings(raw);
+    return parseSettingsFile(path);
   } catch (error) {
-    throw new Error(
-      `Failed to read settings ${path}: ${getErrorMessage(error)}`,
-    );
+    throw createSettingsReadError(path, error);
+  }
+}
+
+/**
+ * Load settings for startup without aborting on invalid JSON.
+ *
+ * Missing files and invalid JSON content are treated as empty settings so
+ * startup behaves like there are no saved settings. Other filesystem errors
+ * still fail with the same descriptive read error as {@link loadSettings}.
+ *
+ * @param path - Absolute path to `settings.json`.
+ * @returns The validated settings object, or `{}` when startup should ignore invalid JSON.
+ */
+export function loadStartupSettings(path: string): UserSettings {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    return parseSettingsFile(path);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return {};
+    }
+    throw createSettingsReadError(path, error);
+  }
+}
+
+/**
+ * Merge two settings objects using startup overlay semantics.
+ *
+ * Scalar fields use override-wins. `customProviders` merges by provider name,
+ * and `mcp.servers` merges by server name. Same-name override entries replace
+ * base entries while keeping the base ordering stable; new override entries are
+ * appended in override order.
+ *
+ * @param base - Base settings, usually the global settings file.
+ * @param override - Higher-priority settings, usually a repo-local overlay.
+ * @returns The merged effective settings.
+ */
+export function mergeUserSettings(
+  base: UserSettings,
+  override: UserSettings,
+): UserSettings {
+  const sanitizedBase = sanitizeSettings(base);
+  const sanitizedOverride = sanitizeSettings(override);
+  const merged: UserSettings = {
+    ...sanitizedBase,
+    ...sanitizedOverride,
+  };
+
+  const customProviders = mergeNamedEntries(
+    sanitizedBase.customProviders,
+    sanitizedOverride.customProviders,
+  );
+  if (customProviders) {
+    merged.customProviders = customProviders;
+  } else {
+    delete merged.customProviders;
+  }
+
+  const servers = mergeNamedEntries(
+    sanitizedBase.mcp?.servers,
+    sanitizedOverride.mcp?.servers,
+  );
+  if (servers) {
+    merged.mcp = { servers };
+  } else {
+    delete merged.mcp;
   }
+
+  return merged;
 }
 
 /**
@@ -123,7 +212,7 @@ export function updateSettings(
   update: Partial<UserSettings>,
 ): UserSettings {
   const current = loadSettings(path);
-  const merged = { ...current, ...sanitizeSettings(update) };
+  const merged = mergeUserSettings(current, sanitizeSettings(update));
   return saveSettings(path, merged);
 }
 
@@ -156,6 +245,46 @@ export function resolveStartupSettings(
   };
 }
 
+function mergeNamedEntries<T extends { name: string }>(
+  base: readonly T[] | undefined,
+  override: readonly T[] | undefined,
+): T[] | undefined {
+  if (!base?.length && !override?.length) {
+    return undefined;
+  }
+
+  const merged = [...(base ?? [])];
+  const indexes = new Map<string, number>();
+
+  for (const [index, entry] of merged.entries()) {
+    indexes.set(entry.name, index);
+  }
+
+  for (const entry of override ?? []) {
+    const existingIndex = indexes.get(entry.name);
+    if (existingIndex === undefined) {
+      indexes.set(entry.name, merged.length);
+      merged.push(entry);
+      continue;
+    }
+
+    merged[existingIndex] = entry;
+  }
+
+  return merged.length > 0 ? merged : undefined;
+}
+
+function parseSettingsFile(path: string): UserSettings {
+  const raw = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+  return sanitizeSettings(raw);
+}
+
+function createSettingsReadError(path: string, error: unknown): Error {
+  return new Error(
+    `Failed to read settings ${path}: ${getErrorMessage(error)}`,
+  );
+}
+
 /**
  * Validate and normalize a parsed settings object.
  *
@@ -193,6 +322,11 @@ function sanitizeSettings(value: unknown): UserSettings {
     settings.customProviders = customProviders;
   }
 
+  const mcp = sanitizeMcpSettings(candidate.mcp);
+  if (mcp) {
+    settings.mcp = mcp;
+  }
+
   return settings;
 }
 
@@ -244,6 +378,64 @@ function sanitizeCustomProviders(value: unknown): CustomProvider[] | undefined {
   return result.length > 0 ? result : undefined;
 }
 
+function sanitizeMcpSettings(value: unknown): McpSettings | undefined {
+  const candidate = toRecord(value);
+  if (!candidate) {
+    return undefined;
+  }
+
+  const servers = sanitizeMcpServers(candidate.servers);
+  if (!servers) {
+    return undefined;
+  }
+
+  return { servers };
+}
+
+/** Try to parse a single MCP server entry, returning null on failure. */
+function parseMcpServer(item: unknown): McpServerConfig | null {
+  const candidate = toRecord(item);
+  if (!candidate) {
+    return null;
+  }
+
+  const name = readString(candidate, "name")?.trim() ?? "";
+  const url = readString(candidate, "url")?.trim() ?? "";
+  const enabled = readBoolean(candidate, "enabled") ?? true;
+
+  if (!name || !url || !MCP_SERVER_NAME_PATTERN.test(name)) {
+    return null;
+  }
+
+  return { name, url, enabled };
+}
+
+/**
+ * Validate and normalize configured MCP servers.
+ *
+ * Drops entries with missing/invalid names or URLs, and deduplicates by name
+ * (first entry wins).
+ */
+function sanitizeMcpServers(value: unknown): McpServerConfig[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const result: McpServerConfig[] = [];
+  const seen = new Set<string>();
+
+  for (const item of value) {
+    const entry = parseMcpServer(item);
+    if (!entry || seen.has(entry.name)) {
+      continue;
+    }
+    seen.add(entry.name);
+    result.push(entry);
+  }
+
+  return result.length > 0 ? result : undefined;
+}
+
 /**
  * Check whether a value is a valid thinking level.
  *

package/src/skills.ts

@@ -226,6 +226,15 @@ export function discoverSkills(scanPaths: string[]): Skill[] {
 // Catalog generation
 // ---------------------------------------------------------------------------
 
+function escapeXml(value: string): string {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
 /**
  * Build the XML skill catalog for the system prompt.
  *
@@ -243,9 +252,9 @@ export function buildSkillCatalog(skills: Skill[]): string {
     .map(
       (s) =>
         `  <skill>\n` +
-        `    <name>${s.name}</name>\n` +
-        `    <description>${s.description}</description>\n` +
-        `    <location>${s.path}</location>\n` +
+        `    <name>${escapeXml(s.name)}</name>\n` +
+        `    <description>${escapeXml(s.description)}</description>\n` +
+        `    <location>${escapeXml(s.path)}</location>\n` +
         `  </skill>`,
     )
     .join("\n");

package/src/submit.ts

@@ -215,6 +215,20 @@ function recordRawPromptHistory(
   truncatePromptHistory(state.db, MAX_PROMPT_HISTORY);
 }
 
+/**
+ * Drop any resolved steering messages still queued on the active app state.
+ *
+ * Raw prompt-history rows are intentionally left untouched because queue resets
+ * must not rewrite global input-history behavior.
+ *
+ * @param state - Mutable application state containing the queued steering list.
+ */
+export function clearQueuedUserMessages(
+  state: Pick<AppState, "queuedUserMessages">,
+): void {
+  state.queuedUserMessages.length = 0;
+}
+
 /**
  * Queue resolved user content for the next model-request boundary of an active run.
  *
@@ -301,6 +315,8 @@ export async function submitResolvedInput(
     throw new Error("Cannot submit empty input.");
   }
 
+  clearQueuedUserMessages(state);
+
   const session = ensureSession(state);
   recordRawPromptHistory(rawInput, state, session.id);
 
@@ -347,6 +363,7 @@ export async function submitResolvedInput(
     stopReason = result.stopReason;
     return result.stopReason;
   } finally {
+    clearQueuedUserMessages(state);
     state.running = false;
     state.abortController = null;
     hooks?.onTurnEnd?.(state, stopReason);

package/src/theme.ts

@@ -2,8 +2,7 @@
  * UI theme definition and default colors.
  *
  * All UI colors are read from the active {@link Theme} object — the UI
- * never hardcodes colors. Plugins can return a `Partial<Theme>` in their
- * result to override any color. Multiple overrides are merged left-to-right.
+ * never hardcodes colors. Theme overrides are merged left-to-right.
  *
  * Theme values are cel-tui {@link Color} palette references. The default
  * theme prefers ANSI 16-color palette entries so it adapts cleanly to the
@@ -12,11 +11,47 @@
  * @module
  */
 
+import type { SyntaxHighlightTheme } from "@cel-tui/components";
 import type { Color } from "@cel-tui/types";
 
 /** A cel-tui palette color or the terminal default when undefined. */
 type ThemeColor = Color | undefined;
 
+type SyntaxThemeRegistration = Exclude<SyntaxHighlightTheme, string>;
+type SyntaxThemeTokenColor = NonNullable<
+  SyntaxThemeRegistration["tokenColors"]
+>[number];
+type SyntaxThemeVariant = "markdown" | "code" | "shell";
+
+/** ANSI16 fallback hex values for syntax-highlighter theme overrides. */
+const ANSI_COLOR_HEX: Readonly<Record<Color, string>> = {
+  color00: "#000000",
+  color01: "#cd3131",
+  color02: "#0dbc79",
+  color03: "#e5e510",
+  color04: "#2472c8",
+  color05: "#bc3fbc",
+  color06: "#11a8cd",
+  color07: "#e5e5e5",
+  color08: "#666666",
+  color09: "#f14c4c",
+  color10: "#23d18b",
+  color11: "#f5f543",
+  color12: "#3b8eea",
+  color13: "#d670d6",
+  color14: "#29b8db",
+  color15: "#ffffff",
+};
+
+const syntaxThemeCache: Record<
+  SyntaxThemeVariant,
+  WeakMap<Theme, SyntaxThemeRegistration>
+> = {
+  markdown: new WeakMap(),
+  code: new WeakMap(),
+  shell: new WeakMap(),
+};
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -132,7 +167,7 @@ export const DEFAULT_THEME: Theme = {
  * mutated.
  *
  * @param base - The base theme to start from.
- * @param overrides - Partial theme objects to merge (from plugins).
+ * @param overrides - Partial theme objects to merge.
  * @returns A complete {@link Theme} with all overrides applied.
  */
 export function mergeThemes(
@@ -145,3 +180,151 @@ export function mergeThemes(
   }
   return merged;
 }
+
+function colorToHex(color: ThemeColor): string | undefined {
+  return color ? ANSI_COLOR_HEX[color] : undefined;
+}
+
+function pushSyntaxTokenColor(
+  tokenColors: SyntaxThemeTokenColor[],
+  scope: string | readonly string[],
+  foreground: ThemeColor,
+  fontStyle?: string,
+): void {
+  const foregroundHex = colorToHex(foreground);
+  if (!foregroundHex && !fontStyle) {
+    return;
+  }
+
+  tokenColors.push({
+    scope,
+    settings: {
+      ...(foregroundHex ? { foreground: foregroundHex } : {}),
+      ...(fontStyle ? { fontStyle } : {}),
+    },
+  });
+}
+
+function pushCodeSyntaxTokenColors(
+  tokenColors: SyntaxThemeTokenColor[],
+  theme: Theme,
+): void {
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["comment", "quote", "doctag", "markup.quote"],
+    theme.mutedText,
+    "italic",
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["keyword", "operator"],
+    theme.secondaryAccentText,
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["command", "function_", "function", "title"],
+    theme.accentText,
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["builtin", "built_in", "class_", "class", "inherited__", "type"],
+    theme.accentText,
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["escape", "literal", "number", "symbol"],
+    theme.secondaryAccentText ?? theme.accentText,
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["code", "string", "markup.code"],
+    theme.diffAdded,
+  );
+  pushSyntaxTokenColor(tokenColors, "regexp", theme.diffRemoved);
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["attr", "attribute", "params", "property", "selector-attr"],
+    theme.accentText,
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    [
+      "name",
+      "tag",
+      "selector-class",
+      "selector-id",
+      "selector-pseudo",
+      "selector-tag",
+    ],
+    theme.accentText,
+  );
+}
+
+function pushMarkdownSyntaxTokenColors(
+  tokenColors: SyntaxThemeTokenColor[],
+  theme: Theme,
+): void {
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["quote", "markup.quote"],
+    theme.mutedText,
+    "italic",
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["section", "markup.heading"],
+    theme.accentText,
+    "bold",
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["bullet", "markup.list"],
+    theme.secondaryAccentText,
+    "bold",
+  );
+  pushSyntaxTokenColor(
+    tokenColors,
+    ["code", "string", "markup.code"],
+    theme.diffAdded,
+  );
+  pushSyntaxTokenColor(tokenColors, "link", theme.accentText, "underline");
+  pushSyntaxTokenColor(tokenColors, "strong", undefined, "bold");
+  pushSyntaxTokenColor(tokenColors, "emphasis", undefined, "italic");
+}
+
+/**
+ * Build the shared syntax-highlight theme registration for a UI theme variant.
+ *
+ * Markdown, read/code blocks, and shell/tool previews all flow through this
+ * helper so active-theme overrides stay consistent in one place. Variant names
+ * are included in the registration so cel-tui's internal SyntaxHighlight cache
+ * does not collapse code and shell renders onto the same custom-theme key.
+ *
+ * @param theme - Active UI theme.
+ * @param variant - Semantic highlighting variant for the rendered content.
+ * @returns A cached cel-tui syntax-highlight theme registration.
+ */
+export function getSyntaxHighlightTheme(
+  theme: Theme,
+  variant: SyntaxThemeVariant,
+): SyntaxThemeRegistration {
+  const cache = syntaxThemeCache[variant];
+  const cached = cache.get(theme);
+  if (cached) {
+    return cached;
+  }
+
+  const tokenColors: SyntaxThemeTokenColor[] = [];
+  if (variant === "markdown") {
+    pushMarkdownSyntaxTokenColors(tokenColors, theme);
+  } else {
+    pushCodeSyntaxTokenColors(tokenColors, theme);
+  }
+
+  const syntaxTheme: SyntaxThemeRegistration = {
+    name: `mini-coder-${variant}`,
+    tokenColors,
+  };
+  cache.set(theme, syntaxTheme);
+  return syntaxTheme;
+}

package/src/tool-common.ts

@@ -23,6 +23,8 @@ import { validateToolArguments } from "@mariozechner/pi-ai";
 export interface ToolExecResult {
   /** Content blocks for the tool result. */
   content: (TextContent | ImageContent)[];
+  /** Optional structured metadata preserved on the tool-result message. */
+  details?: unknown;
   /** Whether the execution encountered an error. */
   isError: boolean;
 }