@evantahler/mcpx 0.18.3 → 0.18.5

package/src/commands/search.ts

@@ -1,50 +1,46 @@
 import type { Command } from "commander";
+import { DEFAULTS } from "../constants.ts";
 import { getContext } from "../context.ts";
-import { search } from "../search/index.ts";
-import { getStaleServers } from "../search/staleness.ts";
 import { formatError, formatSearchResults } from "../output/formatter.ts";
 import { logger } from "../output/logger.ts";
-import { DEFAULTS } from "../constants.ts";
+import { search } from "../search/index.ts";
+import { getStaleServers } from "../search/staleness.ts";
 
 export function registerSearchCommand(program: Command) {
-  program
-    .command("search <terms...>")
-    .description("search tools by keyword and/or semantic similarity")
-    .option("-k, --keyword", "keyword/glob search only")
-    .option("-q, --query", "semantic search only")
-    .option("-n, --limit <number>", "max results to return", String(DEFAULTS.SEARCH_TOP_K))
-    .action(
-      async (terms: string[], options: { keyword?: boolean; query?: boolean; limit: string }) => {
-        const query = terms.join(" ");
-        const { config, formatOptions } = await getContext(program);
+	program
+		.command("search <terms...>")
+		.description("search tools by keyword and/or semantic similarity")
+		.option("-k, --keyword", "keyword/glob search only")
+		.option("-q, --query", "semantic search only")
+		.option("-n, --limit <number>", "max results to return", String(DEFAULTS.SEARCH_TOP_K))
+		.action(async (terms: string[], options: { keyword?: boolean; query?: boolean; limit: string }) => {
+			const query = terms.join(" ");
+			const { config, formatOptions } = await getContext(program);
 
-        if (config.searchIndex.tools.length === 0) {
-          console.error(formatError("No search index found. Run: mcpx index", formatOptions));
-          process.exit(1);
-        }
+			if (config.searchIndex.tools.length === 0) {
+				console.error(formatError("No search index found. Run: mcpx index", formatOptions));
+				process.exit(1);
+			}
 
-        const stale = getStaleServers(config.searchIndex, config.servers);
-        if (stale.length > 0) {
-          logger.warn(
-            `Warning: index has tools for removed servers: ${stale.join(", ")}. Run: mcpx index`,
-          );
-        }
+			const stale = getStaleServers(config.searchIndex, config.servers);
+			if (stale.length > 0) {
+				logger.warn(`Warning: index has tools for removed servers: ${stale.join(", ")}. Run: mcpx index`);
+			}
 
-        const spinner = logger.startSpinner("Searching...", formatOptions);
+			const spinner = logger.startSpinner("Searching...", formatOptions);
 
-        try {
-          const results = await search(query, config.searchIndex, {
-            keywordOnly: options.keyword,
-            semanticOnly: options.query,
-            topK: parseInt(options.limit, 10),
-          });
-          spinner.stop();
-          console.log(formatSearchResults(results, formatOptions));
-        } catch (err) {
-          spinner.stop();
-          console.error(formatError(String(err), formatOptions));
-          process.exit(1);
-        }
-      },
-    );
+			try {
+				const results = await search(query, config.searchIndex, {
+					keywordOnly: options.keyword,
+					semanticOnly: options.query,
+					topK: parseInt(options.limit, 10),
+				});
+				spinner.stop();
+				console.log(formatSearchResults(results, formatOptions));
+			} catch (err) {
+				spinner.stop();
+				console.error(formatError(String(err), formatOptions));
+				process.exit(1);
+			}
+		});
 }

package/src/commands/servers.ts

@@ -1,60 +1,56 @@
 import { cyan, dim, green, yellow } from "ansis";
 import type { Command } from "commander";
-import { isStdioServer, isHttpServer } from "../config/schemas.ts";
+import { isHttpServer, isStdioServer } from "../config/schemas.ts";
 import { isInteractive } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerServersCommand(program: Command) {
-  program
-    .command("servers")
-    .description("List configured MCP servers")
-    .action(
-      withCommand(program, {}, async ({ config, formatOptions }) => {
-        const servers = Object.entries(config.servers.mcpServers);
+	program
+		.command("servers")
+		.description("List configured MCP servers")
+		.action(
+			withCommand(program, {}, async ({ config, formatOptions }) => {
+				const servers = Object.entries(config.servers.mcpServers);
 
-        if (!isInteractive(formatOptions)) {
-          console.log(
-            JSON.stringify(
-              servers.map(([name, cfg]) => ({
-                name,
-                type: isStdioServer(cfg) ? "stdio" : "http",
-                ...(isHttpServer(cfg) ? { transport: cfg.transport ?? "http" } : {}),
-                ...(isStdioServer(cfg)
-                  ? { command: cfg.command, args: cfg.args ?? [] }
-                  : { url: cfg.url }),
-              })),
-              null,
-              2,
-            ),
-          );
-          return;
-        }
+				if (!isInteractive(formatOptions)) {
+					console.log(
+						JSON.stringify(
+							servers.map(([name, cfg]) => ({
+								name,
+								type: isStdioServer(cfg) ? "stdio" : "http",
+								...(isHttpServer(cfg) ? { transport: cfg.transport ?? "http" } : {}),
+								...(isStdioServer(cfg) ? { command: cfg.command, args: cfg.args ?? [] } : { url: cfg.url }),
+							})),
+							null,
+							2,
+						),
+					);
+					return;
+				}
 
-        if (servers.length === 0) {
-          console.log(dim("No servers configured"));
-          return;
-        }
+				if (servers.length === 0) {
+					console.log(dim("No servers configured"));
+					return;
+				}
 
-        const maxName = Math.max(...servers.map(([n]) => n.length));
+				const maxName = Math.max(...servers.map(([n]) => n.length));
 
-        function typeLabel(cfg: (typeof servers)[number][1]): string {
-          if (isStdioServer(cfg)) return "stdio";
-          if (isHttpServer(cfg) && cfg.transport === "sse") return "http/sse";
-          if (isHttpServer(cfg) && cfg.transport === "streamable-http") return "http/streamable";
-          return "http";
-        }
-        const maxType = Math.max(...servers.map(([, cfg]) => typeLabel(cfg).length));
+				function typeLabel(cfg: (typeof servers)[number][1]): string {
+					if (isStdioServer(cfg)) return "stdio";
+					if (isHttpServer(cfg) && cfg.transport === "sse") return "http/sse";
+					if (isHttpServer(cfg) && cfg.transport === "streamable-http") return "http/streamable";
+					return "http";
+				}
+				const maxType = Math.max(...servers.map(([, cfg]) => typeLabel(cfg).length));
 
-        for (const [name, cfg] of servers) {
-          const n = cyan(name.padEnd(maxName));
-          const type = isStdioServer(cfg)
-            ? green(typeLabel(cfg).padEnd(maxType))
-            : yellow(typeLabel(cfg).padEnd(maxType));
-          const detail = isStdioServer(cfg)
-            ? dim([cfg.command, ...(cfg.args ?? [])].join(" "))
-            : dim(cfg.url);
-          console.log(`${n}  ${type}  ${detail}`);
-        }
-      }),
-    );
+				for (const [name, cfg] of servers) {
+					const n = cyan(name.padEnd(maxName));
+					const type = isStdioServer(cfg)
+						? green(typeLabel(cfg).padEnd(maxType))
+						: yellow(typeLabel(cfg).padEnd(maxType));
+					const detail = isStdioServer(cfg) ? dim([cfg.command, ...(cfg.args ?? [])].join(" ")) : dim(cfg.url);
+					console.log(`${n}  ${type}  ${detail}`);
+				}
+			}),
+		);
 }

package/src/commands/skill.ts

@@ -1,112 +1,106 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import type { Command } from "commander";
-import { resolve, dirname, join } from "path";
-import { readFile, mkdir, writeFile, access } from "fs/promises";
-import { homedir } from "os";
 
 interface SkillTarget {
-  label: string;
-  dir: string;
-  filename: string;
+	label: string;
+	dir: string;
+	filename: string;
 }
 
 export function registerSkillCommand(program: Command) {
-  const skill = program.command("skill").description("manage mcpx skills");
+	const skill = program.command("skill").description("manage mcpx skills");
 
-  skill
-    .command("install")
-    .description("install the mcpx skill for an AI agent")
-    .option("--claude", "install for Claude Code")
-    .option("--cursor", "install for Cursor")
-    .option("--global", "install to global location (e.g. ~/.claude/skills/)")
-    .option("--project", "install to project location (default)")
-    .option("-f, --force", "overwrite if file already exists")
-    .action(
-      async (options: {
-        claude?: boolean;
-        cursor?: boolean;
-        global?: boolean;
-        project?: boolean;
-        force?: boolean;
-      }) => {
-        if (!options.claude && !options.cursor) {
-          console.error("error: specify at least one agent target: --claude, --cursor");
-          process.exit(1);
-        }
+	skill
+		.command("install")
+		.description("install the mcpx skill for an AI agent")
+		.option("--claude", "install for Claude Code")
+		.option("--cursor", "install for Cursor")
+		.option("--global", "install to global location (e.g. ~/.claude/skills/)")
+		.option("--project", "install to project location (default)")
+		.option("-f, --force", "overwrite if file already exists")
+		.action(
+			async (options: { claude?: boolean; cursor?: boolean; global?: boolean; project?: boolean; force?: boolean }) => {
+				if (!options.claude && !options.cursor) {
+					console.error("error: specify at least one agent target: --claude, --cursor");
+					process.exit(1);
+				}
 
-        const agents: {
-          name: string;
-          sourcePath: string;
-          globalDir: string;
-          projectDir: string;
-          filename: string;
-        }[] = [];
+				const agents: {
+					name: string;
+					sourcePath: string;
+					globalDir: string;
+					projectDir: string;
+					filename: string;
+				}[] = [];
 
-        if (options.claude) {
-          agents.push({
-            name: "Claude Code",
-            sourcePath: resolve(dirname(Bun.main), "..", ".claude", "skills", "mcpx.md"),
-            globalDir: join(homedir(), ".claude", "skills"),
-            projectDir: resolve(".claude", "skills"),
-            filename: "mcpx.md",
-          });
-        }
+				if (options.claude) {
+					agents.push({
+						name: "Claude Code",
+						sourcePath: resolve(dirname(Bun.main), "..", ".claude", "skills", "mcpx.md"),
+						globalDir: join(homedir(), ".claude", "skills"),
+						projectDir: resolve(".claude", "skills"),
+						filename: "mcpx.md",
+					});
+				}
 
-        if (options.cursor) {
-          agents.push({
-            name: "Cursor",
-            sourcePath: resolve(dirname(Bun.main), "..", ".cursor", "rules", "mcpx.mdc"),
-            globalDir: join(homedir(), ".cursor", "rules"),
-            projectDir: resolve(".cursor", "rules"),
-            filename: "mcpx.mdc",
-          });
-        }
+				if (options.cursor) {
+					agents.push({
+						name: "Cursor",
+						sourcePath: resolve(dirname(Bun.main), "..", ".cursor", "rules", "mcpx.mdc"),
+						globalDir: join(homedir(), ".cursor", "rules"),
+						projectDir: resolve(".cursor", "rules"),
+						filename: "mcpx.mdc",
+					});
+				}
 
-        for (const agent of agents) {
-          let content: string;
-          try {
-            content = await readFile(agent.sourcePath, "utf-8");
-          } catch {
-            console.error(`Could not read skill file: ${agent.sourcePath}`);
-            process.exit(1);
-          }
+				for (const agent of agents) {
+					let content: string;
+					try {
+						content = await readFile(agent.sourcePath, "utf-8");
+					} catch {
+						console.error(`Could not read skill file: ${agent.sourcePath}`);
+						process.exit(1);
+					}
 
-          // Determine targets — default to project if neither flag is set
-          const targets: SkillTarget[] = [];
+					// Determine targets — default to project if neither flag is set
+					const targets: SkillTarget[] = [];
 
-          if (options.global) {
-            targets.push({
-              label: "global",
-              dir: agent.globalDir,
-              filename: agent.filename,
-            });
-          }
-          if (options.project || !options.global) {
-            targets.push({
-              label: "project",
-              dir: agent.projectDir,
-              filename: agent.filename,
-            });
-          }
+					if (options.global) {
+						targets.push({
+							label: "global",
+							dir: agent.globalDir,
+							filename: agent.filename,
+						});
+					}
+					if (options.project || !options.global) {
+						targets.push({
+							label: "project",
+							dir: agent.projectDir,
+							filename: agent.filename,
+						});
+					}
 
-          for (const target of targets) {
-            const dest = join(target.dir, target.filename);
+					for (const target of targets) {
+						const dest = join(target.dir, target.filename);
 
-            // Check if file already exists
-            if (!options.force) {
-              try {
-                await access(dest);
-                console.error(`${dest} already exists (use --force to overwrite)`);
-                process.exit(1);
-              } catch {
-                // File doesn't exist — good
-              }
-            }
+						// Check if file already exists
+						if (!options.force) {
+							try {
+								await access(dest);
+								console.error(`${dest} already exists (use --force to overwrite)`);
+								process.exit(1);
+							} catch {
+								// File doesn't exist — good
+							}
+						}
 
-            await mkdir(target.dir, { recursive: true });
-            await writeFile(dest, content, "utf-8");
-            console.log(`Installed mcpx skill for ${agent.name} (${target.label}): ${dest}`);
-          }
-        }
-      },
-    );
+						await mkdir(target.dir, { recursive: true });
+						await writeFile(dest, content, "utf-8");
+						console.log(`Installed mcpx skill for ${agent.name} (${target.label}): ${dest}`);
+					}
+				}
+			},
+		);
 }

package/src/commands/task.ts

@@ -1,66 +1,56 @@
 import type { Command } from "commander";
-import {
-  formatCallResult,
-  formatError,
-  formatTaskStatus,
-  formatTasksList,
-} from "../output/formatter.ts";
+import { formatCallResult, formatTaskStatus, formatTasksList } from "../output/formatter.ts";
 import { withCommand } from "./with-command.ts";
 
 export function registerTaskCommand(program: Command) {
-  program
-    .command("task <action> <server> [taskId]")
-    .description("manage tasks (actions: get, list, result, cancel)")
-    .action(
-      withCommand(
-        program,
-        { spinnerText: "Connecting..." },
-        async (
-          { manager, formatOptions, spinner },
-          action: string,
-          server: string,
-          taskId?: string,
-        ) => {
-          spinner.update(`Connecting to ${server}...`);
+	program
+		.command("task <action> <server> [taskId]")
+		.description("manage tasks (actions: get, list, result, cancel)")
+		.action(
+			withCommand(
+				program,
+				{ spinnerText: "Connecting..." },
+				async ({ manager, formatOptions, spinner }, action: string, server: string, taskId?: string) => {
+					spinner.update(`Connecting to ${server}...`);
 
-          switch (action) {
-            case "list": {
-              const result = await manager.listTasks(server);
-              spinner.stop();
-              console.log(formatTasksList(result.tasks, result.nextCursor, formatOptions));
-              break;
-            }
-            case "get": {
-              if (!taskId) {
-                throw new Error("Usage: mcpx task get <server> <taskId>");
-              }
-              const task = await manager.getTask(server, taskId);
-              spinner.stop();
-              console.log(formatTaskStatus(task, formatOptions));
-              break;
-            }
-            case "result": {
-              if (!taskId) {
-                throw new Error("Usage: mcpx task result <server> <taskId>");
-              }
-              const result = await manager.getTaskResult(server, taskId);
-              spinner.stop();
-              console.log(formatCallResult(result, formatOptions));
-              break;
-            }
-            case "cancel": {
-              if (!taskId) {
-                throw new Error("Usage: mcpx task cancel <server> <taskId>");
-              }
-              const cancelled = await manager.cancelTask(server, taskId);
-              spinner.stop();
-              console.log(formatTaskStatus(cancelled, formatOptions));
-              break;
-            }
-            default:
-              throw new Error(`Unknown task action: "${action}". Use: get, list, result, cancel`);
-          }
-        },
-      ),
-    );
+					switch (action) {
+						case "list": {
+							const result = await manager.listTasks(server);
+							spinner.stop();
+							console.log(formatTasksList(result.tasks, result.nextCursor, formatOptions));
+							break;
+						}
+						case "get": {
+							if (!taskId) {
+								throw new Error("Usage: mcpx task get <server> <taskId>");
+							}
+							const task = await manager.getTask(server, taskId);
+							spinner.stop();
+							console.log(formatTaskStatus(task, formatOptions));
+							break;
+						}
+						case "result": {
+							if (!taskId) {
+								throw new Error("Usage: mcpx task result <server> <taskId>");
+							}
+							const result = await manager.getTaskResult(server, taskId);
+							spinner.stop();
+							console.log(formatCallResult(result, formatOptions));
+							break;
+						}
+						case "cancel": {
+							if (!taskId) {
+								throw new Error("Usage: mcpx task cancel <server> <taskId>");
+							}
+							const cancelled = await manager.cancelTask(server, taskId);
+							spinner.stop();
+							console.log(formatTaskStatus(cancelled, formatOptions));
+							break;
+						}
+						default:
+							throw new Error(`Unknown task action: "${action}". Use: get, list, result, cancel`);
+					}
+				},
+			),
+		);
 }