@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

package/dist/builtin/mcp/mcp-panel-renderer.ts

@@ -0,0 +1,243 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+  fg,
+  rainbowProgress,
+  type PanelTheme,
+  type ServerState,
+  type ToolState,
+  type VisibleItem,
+} from "./mcp-panel-types.ts";
+
+export interface McpPanelRenderContext {
+  width: number;
+  theme: PanelTheme;
+  authOnly: boolean;
+  descSearchActive: boolean;
+  descQuery: string;
+  nameQuery: string;
+  noticeLines: string[];
+  servers: ServerState[];
+  visibleItems: VisibleItem[];
+  cursorIndex: number;
+  importNotice: string | null;
+  authNotice: string | null;
+  authInFlight: string | null;
+  confirmingDiscard: boolean;
+  discardSelected: number;
+  dirty: boolean;
+  maxVisible: number;
+}
+
+function bold(text: string): string {
+  return `\x1b[1m${text}\x1b[22m`;
+}
+
+function italic(text: string): string {
+  return `\x1b[3m${text}\x1b[23m`;
+}
+
+function inverse(text: string): string {
+  return `\x1b[7m${text}\x1b[27m`;
+}
+
+function renderConnectionStatus(context: McpPanelRenderContext, server: ServerState): string {
+  const t = context.theme;
+  if (context.authInFlight === server.name) return `  ${fg(t.needsAuth, "authenticating")}`;
+  if (server.connectionStatus === "needs-auth") return `  ${fg(t.needsAuth, "needs auth")}`;
+  if (server.connectionStatus === "connecting") return `  ${fg(t.needsAuth, "connecting")}`;
+  if (server.connectionStatus === "failed") return `  ${fg(t.cancel, "failed")}`;
+  if (context.authOnly && server.connectionStatus === "connected") return `  ${fg(t.direct, "connected")}`;
+  if (context.authOnly) return `  ${fg(t.description, "idle")}`;
+  return "";
+}
+
+function renderServerRow(context: McpPanelRenderContext, server: ServerState, isCursor: boolean): string {
+  const t = context.theme;
+  const expandIcon = server.expanded ? "▾" : "▸";
+  const prefix = isCursor ? fg(t.selected, expandIcon) : fg(t.border, server.expanded ? expandIcon : "·");
+  const nameStr = isCursor ? bold(fg(t.selected, server.name)) : server.name;
+  const importLabel = server.source === "import" ? fg(t.description, ` (${server.importKind ?? "import"})`) : "";
+  const statusLabel = renderConnectionStatus(context, server);
+
+  if (!server.hasCachedData && !context.authOnly) {
+    return `${prefix}   ${nameStr}${importLabel}  ${fg(t.description, "(not cached)")}${statusLabel}`;
+  }
+
+  const directCount = server.tools.filter((tool) => tool.isDirect).length;
+  const totalCount = server.tools.length;
+  let toggleIcon = fg(t.description, "○");
+  if (directCount === totalCount && totalCount > 0) {
+    toggleIcon = fg(t.direct, "●");
+  } else if (directCount > 0) {
+    toggleIcon = fg(t.needsAuth, "◐");
+  }
+
+  let toolInfo = "";
+  if (totalCount > 0) {
+    toolInfo = `${directCount}/${totalCount}`;
+    if (directCount > 0) {
+      const tokens = server.tools.filter((tool) => tool.isDirect).reduce((sum, tool) => sum + tool.estimatedTokens, 0);
+      toolInfo += `  ~${tokens.toLocaleString()}`;
+    }
+    toolInfo = fg(t.description, toolInfo);
+  }
+
+  return `${prefix} ${toggleIcon} ${nameStr}${importLabel}  ${toolInfo}${statusLabel}`;
+}
+
+function renderToolRow(context: McpPanelRenderContext, tool: ToolState, isCursor: boolean, innerW: number): string {
+  const t = context.theme;
+  const toggleIcon = tool.isDirect ? fg(t.direct, "●") : fg(t.description, "○");
+  const cursor = isCursor ? fg(t.selected, "▸") : " ";
+  const nameStr = isCursor ? bold(fg(t.selected, tool.name)) : tool.name;
+  const prefixLen = 7 + visibleWidth(tool.name);
+  const maxDescLen = Math.max(0, innerW - prefixLen - 8);
+  const descStr = maxDescLen > 5 && tool.description
+    ? fg(t.description, "— " + truncateToWidth(tool.description, maxDescLen, "…"))
+    : "";
+
+  return `  ${cursor} ${toggleIcon} ${nameStr} ${descStr}`;
+}
+
+function renderFooterStats(context: McpPanelRenderContext): string {
+  const t = context.theme;
+  if (context.authOnly) return fg(t.description, "select a server to authenticate");
+
+  const directCount = context.servers.reduce((sum, server) => sum + server.tools.filter((tool) => tool.isDirect).length, 0);
+  const totalTokens = context.servers.reduce(
+    (sum, server) => sum + server.tools.filter((tool) => tool.isDirect).reduce((tokens, tool) => tokens + tool.estimatedTokens, 0),
+    0,
+  );
+  const stats = directCount > 0 ? `${directCount} direct  ~${totalTokens.toLocaleString()} tokens` : "no direct tools";
+  return fg(t.description, stats + (context.dirty ? fg(t.needsAuth, "  (unsaved)") : ""));
+}
+
+function renderHints(context: McpPanelRenderContext, innerW: number, row: (content: string) => string): string[] {
+  const t = context.theme;
+  const hints = context.authOnly
+    ? [
+        italic("↑↓") + " Navigate",
+        italic("⏎") + " Auth",
+        italic("CTRL+A") + " Auth",
+        italic("Escape") + " Clear/Close",
+        italic("CTRL+C") + " Quit",
+      ]
+    : [
+        italic("↑↓") + " Navigate",
+        italic("Space") + " Toggle",
+        italic("⏎") + " Expand/Auth",
+        italic("CTRL+A") + " Auth",
+        italic("CTRL+R") + " Reconnect",
+        italic("?") + " Desc Search",
+        italic("CTRL+S") + " Save",
+        italic("Escape") + " Clear/Close",
+        italic("CTRL+C") + " Quit",
+      ];
+
+  const lines: string[] = [];
+  const gap = "  ";
+  const gapW = 2;
+  const maxW = innerW - 2;
+  let curLine = "";
+  let curW = 0;
+  for (const hint of hints) {
+    const hw = visibleWidth(hint);
+    const needed = curW === 0 ? hw : gapW + hw;
+    if (curW > 0 && curW + needed > maxW) {
+      lines.push(row(fg(t.hint, curLine)));
+      curLine = hint;
+      curW = hw;
+    } else {
+      curLine += (curW > 0 ? gap : "") + hint;
+      curW += needed;
+    }
+  }
+  if (curLine) lines.push(row(fg(t.hint, curLine)));
+  return lines;
+}
+
+export function renderMcpPanel(context: McpPanelRenderContext): string[] {
+  const innerW = context.width - 2;
+  const lines: string[] = [];
+  const t = context.theme;
+  const row = (content: string) =>
+    fg(t.border, "│") + truncateToWidth(" " + content, innerW, "…", true) + fg(t.border, "│");
+  const emptyRow = () => fg(t.border, "│") + " ".repeat(innerW) + fg(t.border, "│");
+  const divider = () => fg(t.border, "├" + "─".repeat(innerW) + "┤");
+
+  const titleText = context.authOnly ? " MCP OAuth " : " MCP Servers ";
+  const borderLen = innerW - visibleWidth(titleText);
+  const leftB = Math.floor(borderLen / 2);
+  const rightB = borderLen - leftB;
+  lines.push(fg(t.border, "╭" + "─".repeat(leftB)) + fg(t.title, titleText) + fg(t.border, "─".repeat(rightB) + "╮"));
+  lines.push(emptyRow());
+
+  const cursor = fg(t.selected, "│");
+  const searchIcon = fg(t.border, "◎");
+  if (context.descSearchActive) {
+    lines.push(row(`${searchIcon}  ${fg(t.needsAuth, "desc:")} ${context.descQuery}${cursor}`));
+  } else if (context.nameQuery) {
+    lines.push(row(`${searchIcon}  ${context.nameQuery}${cursor}`));
+  } else {
+    lines.push(row(`${searchIcon}  ${fg(t.placeholder, italic("search..."))}`));
+  }
+
+  lines.push(emptyRow());
+  if (context.noticeLines.length > 0) {
+    for (const notice of context.noticeLines) lines.push(row(fg(t.hint, italic(notice))));
+    lines.push(emptyRow());
+  }
+  lines.push(divider());
+
+  if (context.servers.length === 0) {
+    lines.push(emptyRow());
+    lines.push(row(fg(t.hint, italic(context.authOnly ? "No OAuth-capable MCP servers configured." : "No MCP servers configured."))));
+    lines.push(emptyRow());
+  } else {
+    const total = context.visibleItems.length;
+    const startIdx = Math.max(0, Math.min(context.cursorIndex - Math.floor(context.maxVisible / 2), total - context.maxVisible));
+    const endIdx = Math.min(startIdx + context.maxVisible, total);
+    lines.push(emptyRow());
+
+    for (let i = startIdx; i < endIdx; i++) {
+      const item = context.visibleItems[i];
+      const isCursor = i === context.cursorIndex;
+      const server = context.servers[item.serverIndex];
+      if (item.type === "server") {
+        lines.push(row(renderServerRow(context, server, isCursor)));
+      } else if (item.toolIndex !== undefined) {
+        lines.push(row(renderToolRow(context, server.tools[item.toolIndex], isCursor, innerW)));
+      }
+    }
+
+    lines.push(emptyRow());
+    if (total > context.maxVisible) {
+      const prog = Math.round(((context.cursorIndex + 1) / total) * 10);
+      lines.push(row(`${rainbowProgress(prog, 10)}  ${fg(t.hint, `${context.cursorIndex + 1}/${total}`)}`));
+      lines.push(emptyRow());
+    }
+    if (context.importNotice) {
+      lines.push(row(fg(t.needsAuth, italic(context.importNotice))));
+      lines.push(emptyRow());
+    }
+    if (context.authNotice) {
+      lines.push(row(fg(t.needsAuth, italic(context.authNotice))));
+      lines.push(emptyRow());
+    }
+  }
+
+  lines.push(divider());
+  lines.push(emptyRow());
+  if (context.confirmingDiscard) {
+    const discardBtn = context.discardSelected === 0 ? inverse(bold(fg(t.cancel, "  Discard  "))) : fg(t.hint, "  Discard  ");
+    const keepBtn = context.discardSelected === 1 ? inverse(bold(fg(t.confirm, "  Keep  "))) : fg(t.hint, "  Keep  ");
+    lines.push(row(`Discard unsaved changes?  ${discardBtn}   ${keepBtn}`));
+  } else {
+    lines.push(row(renderFooterStats(context)));
+  }
+
+  lines.push(emptyRow());
+  lines.push(...renderHints(context, innerW, row));
+  lines.push(fg(t.border, "╰" + "─".repeat(innerW) + "╯"));
+  return lines;
+}

package/dist/builtin/mcp/mcp-panel-state.ts

@@ -0,0 +1,227 @@
+import { isToolExcluded } from "./types.ts";
+import type { MetadataCache, ServerCacheEntry, CachedTool } from "./metadata-cache.ts";
+import { resourceNameToToolName } from "./resource-tools.ts";
+import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
+import type { ServerState, ToolState, VisibleItem } from "./mcp-panel-types.ts";
+
+export type ToolPrefix = "server" | "none" | "short";
+
+type ToolFilter = true | string[] | false;
+
+export function getToolPrefix(config: McpConfig): ToolPrefix {
+  return config.settings?.toolPrefix ?? "server";
+}
+
+function fuzzyScore(query: string, text: string): number {
+  const lq = query.toLowerCase();
+  const lt = text.toLowerCase();
+  if (lt.includes(lq)) return 100 + (lq.length / lt.length) * 50;
+  let score = 0;
+  let qi = 0;
+  let consecutive = 0;
+  for (let i = 0; i < lt.length && qi < lq.length; i++) {
+    if (lt[i] === lq[qi]) {
+      score += 10 + consecutive;
+      consecutive += 5;
+      qi++;
+    } else {
+      consecutive = 0;
+    }
+  }
+  return qi === lq.length ? score : 0;
+}
+
+function estimateTokens(tool: CachedTool): number {
+  const schemaLen = JSON.stringify(tool.inputSchema ?? {}).length;
+  const descLen = tool.description?.length ?? 0;
+  return Math.ceil((tool.name.length + descLen + schemaLen) / 4) + 10;
+}
+
+function getToolFilter(config: McpConfig, serverName: string): ToolFilter {
+  const definition = config.mcpServers[serverName];
+  const globalDirect = config.settings?.directTools;
+  if (definition?.directTools !== undefined) return definition.directTools;
+  return globalDirect ? globalDirect : false;
+}
+
+function isDirectTool(toolFilter: ToolFilter, toolName: string): boolean {
+  return toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(toolName));
+}
+
+function cachedToolState(tool: CachedTool, toolFilter: ToolFilter): ToolState {
+  const isDirect = isDirectTool(toolFilter, tool.name);
+  return {
+    name: tool.name,
+    description: tool.description ?? "",
+    isDirect,
+    wasDirect: isDirect,
+    estimatedTokens: estimateTokens(tool),
+  };
+}
+
+function cachedResourceToolState(
+  resource: { uri: string; name: string; description?: string },
+  toolFilter: ToolFilter,
+): ToolState {
+  const baseName = `get_${resourceNameToToolName(resource.name)}`;
+  const isDirect = isDirectTool(toolFilter, baseName);
+  const cachedTool: CachedTool = { name: baseName, description: resource.description };
+  return {
+    name: baseName,
+    description: resource.description ?? `Read resource: ${resource.uri}`,
+    isDirect,
+    wasDirect: isDirect,
+    estimatedTokens: estimateTokens(cachedTool),
+  };
+}
+
+export function buildServerStates(
+  config: McpConfig,
+  cache: MetadataCache | null,
+  provenance: Map<string, ServerProvenance>,
+  callbacks: McpPanelCallbacks,
+  authOnly: boolean,
+  prefix: ToolPrefix,
+): ServerState[] {
+  const servers: ServerState[] = [];
+
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (authOnly && !callbacks.canAuthenticate(serverName)) continue;
+    const prov = provenance.get(serverName);
+    const serverCache = cache?.servers?.[serverName];
+    const toolFilter = getToolFilter(config, serverName);
+    const tools: ToolState[] = [];
+
+    if (serverCache && !authOnly) {
+      for (const tool of serverCache.tools ?? []) {
+        if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) continue;
+        tools.push(cachedToolState(tool, toolFilter));
+      }
+      if (definition.exposeResources !== false) {
+        for (const resource of serverCache.resources ?? []) {
+          const baseName = `get_${resourceNameToToolName(resource.name)}`;
+          if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) continue;
+          tools.push(cachedResourceToolState(resource, toolFilter));
+        }
+      }
+    }
+
+    servers.push({
+      name: serverName,
+      expanded: false,
+      source: prov?.kind ?? "user",
+      importKind: prov?.importKind,
+      excludeTools: definition.excludeTools,
+      exposeResources: definition.exposeResources !== false,
+      connectionStatus: callbacks.getConnectionStatus(serverName),
+      tools,
+      hasCachedData: !!serverCache,
+    });
+  }
+
+  return servers;
+}
+
+export function rebuildVisibleItems(
+  servers: ServerState[],
+  nameQuery: string,
+  descSearchActive: boolean,
+  descQuery: string,
+  authOnly: boolean,
+): VisibleItem[] {
+  const query = descSearchActive ? descQuery : nameQuery;
+  const mode = descSearchActive ? "desc" : "name";
+  const items: VisibleItem[] = [];
+
+  for (let si = 0; si < servers.length; si++) {
+    const server = servers[si];
+    if (query && authOnly) {
+      const score = mode === "name" ? fuzzyScore(query, server.name) : 0;
+      if (score > 0) items.push({ type: "server", serverIndex: si });
+      continue;
+    }
+
+    items.push({ type: "server", serverIndex: si });
+    if (server.expanded || query) {
+      for (let ti = 0; ti < server.tools.length; ti++) {
+        const tool = server.tools[ti];
+        if (query) {
+          const score = mode === "name"
+            ? Math.max(fuzzyScore(query, tool.name), fuzzyScore(query, server.name) * 0.6)
+            : fuzzyScore(query, tool.description);
+          if (score === 0) continue;
+        }
+        items.push({ type: "tool", serverIndex: si, toolIndex: ti });
+      }
+    }
+  }
+
+  if (!query || authOnly) return items;
+  return items.filter((item) => {
+    if (item.type === "server") {
+      return items.some((other) => other.type === "tool" && other.serverIndex === item.serverIndex);
+    }
+    return true;
+  });
+}
+
+export function calculateDirty(servers: ServerState[]): boolean {
+  return servers.some((server) => server.tools.some((tool) => tool.isDirect !== tool.wasDirect));
+}
+
+export function buildMcpPanelResult(servers: ServerState[]): McpPanelResult {
+  const changes = new Map<string, true | string[] | false>();
+  for (const server of servers) {
+    const changed = server.tools.some((tool) => tool.isDirect !== tool.wasDirect);
+    if (!changed) continue;
+    const directTools = server.tools.filter((tool) => tool.isDirect);
+    if (directTools.length === server.tools.length && server.tools.length > 0) {
+      changes.set(server.name, true);
+    } else if (directTools.length === 0) {
+      changes.set(server.name, false);
+    } else {
+      changes.set(server.name, directTools.map((tool) => tool.name));
+    }
+  }
+  return { changes, cancelled: false };
+}
+
+export function rebuildServerTools(server: ServerState, entry: ServerCacheEntry, prefix: ToolPrefix): void {
+  const existingState = new Map<string, boolean>();
+  for (const tool of server.tools) existingState.set(tool.name, tool.isDirect);
+
+  const newTools: ToolState[] = [];
+  for (const tool of entry.tools ?? []) {
+    if (isToolExcluded(tool.name, server.name, prefix, server.excludeTools)) continue;
+
+    const prev = existingState.get(tool.name);
+    const isDirect = prev !== undefined ? prev : false;
+    newTools.push({
+      name: tool.name,
+      description: tool.description ?? "",
+      isDirect,
+      wasDirect: prev !== undefined ? server.tools.find((oldTool) => oldTool.name === tool.name)?.wasDirect ?? false : false,
+      estimatedTokens: estimateTokens(tool),
+    });
+  }
+
+  if (server.exposeResources) {
+    for (const resource of entry.resources ?? []) {
+      const baseName = `get_${resourceNameToToolName(resource.name)}`;
+      if (isToolExcluded(baseName, server.name, prefix, server.excludeTools)) continue;
+
+      const prev = existingState.get(baseName);
+      const isDirect = prev !== undefined ? prev : false;
+      const cachedTool: CachedTool = { name: baseName, description: resource.description };
+      newTools.push({
+        name: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        isDirect,
+        wasDirect: prev !== undefined ? server.tools.find((tool) => tool.name === baseName)?.wasDirect ?? false : false,
+        estimatedTokens: estimateTokens(cachedTool),
+      });
+    }
+  }
+
+  server.tools = newTools;
+}

package/dist/builtin/mcp/mcp-panel-types.ts

@@ -0,0 +1,86 @@
+export interface PanelTheme {
+  border: string;
+  title: string;
+  selected: string;
+  direct: string;
+  needsAuth: string;
+  placeholder: string;
+  description: string;
+  hint: string;
+  confirm: string;
+  cancel: string;
+}
+
+export const DEFAULT_THEME: PanelTheme = {
+  border: "2",
+  title: "2",
+  selected: "36",
+  direct: "32",
+  needsAuth: "33",
+  placeholder: "2;3",
+  description: "2",
+  hint: "2",
+  confirm: "32",
+  cancel: "31",
+};
+
+export function fg(code: string, text: string): string {
+  if (!code) return text;
+  return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+const RAINBOW_COLORS = [
+  "38;2;178;129;214",
+  "38;2;215;135;175",
+  "38;2;254;188;56",
+  "38;2;228;192;15",
+  "38;2;137;210;129",
+  "38;2;0;175;175",
+  "38;2;23;143;185",
+];
+
+export function rainbowProgress(filled: number, total: number): string {
+  const dots: string[] = [];
+  for (let i = 0; i < total; i++) {
+    const color = RAINBOW_COLORS[i % RAINBOW_COLORS.length];
+    dots.push(fg(color, i < filled ? "●" : "○"));
+  }
+  return dots.join(" ");
+}
+
+export type ConnectionStatus = "connected" | "idle" | "failed" | "needs-auth" | "connecting";
+
+export interface ToolState {
+  name: string;
+  description: string;
+  isDirect: boolean;
+  wasDirect: boolean;
+  estimatedTokens: number;
+}
+
+export interface ServerState {
+  name: string;
+  expanded: boolean;
+  source: "user" | "project" | "import";
+  importKind?: string;
+  excludeTools?: string[];
+  exposeResources: boolean;
+  connectionStatus: ConnectionStatus;
+  tools: ToolState[];
+  hasCachedData: boolean;
+}
+
+export interface VisibleItem {
+  type: "server" | "tool";
+  serverIndex: number;
+  toolIndex?: number;
+}
+
+export interface PanelTui {
+  requestRender(): void;
+}
+
+export interface McpPanelOptions {
+  noticeLines?: string[];
+  authOnly?: boolean;
+}