@evantahler/mcpx 0.15.4 → 0.15.9

package/src/config/loader.ts

@@ -1,6 +1,7 @@
 import { join, resolve } from "path";
 import { homedir } from "os";
 import { interpolateEnv } from "./env.ts";
+import { ENV } from "../constants.ts";
 import {
   type Config,
   type ServersFile,
@@ -36,7 +37,7 @@ function resolveConfigDir(configFlag?: string): string {
   if (configFlag) return resolve(configFlag);
 
   // 2. MCP_CONFIG_PATH env var
-  const envPath = process.env.MCP_CONFIG_PATH;
+  const envPath = process.env[ENV.CONFIG_PATH];
   if (envPath) return resolve(envPath);
 
   // 3. ./servers.json exists in cwd → use cwd
@@ -107,9 +108,14 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Confi
   return { configDir, servers, auth, searchIndex };
 }
 
+/** Write a JSON file to the config directory */
+async function saveJsonFile(configDir: string, filename: string, data: unknown): Promise<void> {
+  await Bun.write(join(configDir, filename), JSON.stringify(data, null, 2) + "\n");
+}
+
 /** Save auth.json to the config directory */
 export async function saveAuth(configDir: string, auth: AuthFile): Promise<void> {
-  await Bun.write(join(configDir, "auth.json"), JSON.stringify(auth, null, 2) + "\n");
+  return saveJsonFile(configDir, "auth.json", auth);
 }
 
 /** Load search.json from the config directory */
@@ -120,12 +126,12 @@ export async function loadSearchIndex(configDir: string): Promise<SearchIndex> {
 
 /** Save search.json to the config directory */
 export async function saveSearchIndex(configDir: string, index: SearchIndex): Promise<void> {
-  await Bun.write(join(configDir, "search.json"), JSON.stringify(index, null, 2) + "\n");
+  return saveJsonFile(configDir, "search.json", index);
 }
 
 /** Save servers.json to the config directory */
 export async function saveServers(configDir: string, servers: ServersFile): Promise<void> {
-  await Bun.write(join(configDir, "servers.json"), JSON.stringify(servers, null, 2) + "\n");
+  return saveJsonFile(configDir, "servers.json", servers);
 }
 
 /** Load servers.json without env interpolation (preserves ${VAR} placeholders) */

package/src/constants.ts

@@ -0,0 +1,19 @@
+/** Environment variable names used by mcpx */
+export const ENV = {
+  DEBUG: "MCP_DEBUG",
+  CONCURRENCY: "MCP_CONCURRENCY",
+  TIMEOUT: "MCP_TIMEOUT",
+  MAX_RETRIES: "MCP_MAX_RETRIES",
+  STRICT_ENV: "MCP_STRICT_ENV",
+  CONFIG_PATH: "MCP_CONFIG_PATH",
+} as const;
+
+/** Default values for configurable options */
+export const DEFAULTS = {
+  CONCURRENCY: 5,
+  TIMEOUT_SECONDS: 1800,
+  MAX_RETRIES: 3,
+  TASK_TTL_MS: 60_000,
+  SEARCH_TOP_K: 10,
+  LOG_LEVEL: "warning",
+} as const;

package/src/context.ts

@@ -4,6 +4,7 @@ import { ServerManager } from "./client/manager.ts";
 import type { Config } from "./config/schemas.ts";
 import type { FormatOptions } from "./output/formatter.ts";
 import { logger } from "./output/logger.ts";
+import { ENV, DEFAULTS } from "./constants.ts";
 
 export interface AppContext {
   config: Config;
@@ -21,14 +22,14 @@ export async function getContext(program: Command): Promise<AppContext> {
 
   const verbose = !!(
     (opts.verbose as boolean | undefined) ||
-    process.env.MCP_DEBUG === "1" ||
-    process.env.MCP_DEBUG === "true"
+    process.env[ENV.DEBUG] === "1" ||
+    process.env[ENV.DEBUG] === "true"
   );
   const showSecrets = !!(opts.showSecrets as boolean | undefined);
-  const concurrency = Number(process.env.MCP_CONCURRENCY ?? 5);
-  const timeout = Number(process.env.MCP_TIMEOUT ?? 1800) * 1000;
-  const maxRetries = Number(process.env.MCP_MAX_RETRIES ?? 3);
-  const logLevel = (opts.logLevel as string | undefined) ?? "warning";
+  const concurrency = Number(process.env[ENV.CONCURRENCY] ?? DEFAULTS.CONCURRENCY);
+  const timeout = Number(process.env[ENV.TIMEOUT] ?? DEFAULTS.TIMEOUT_SECONDS) * 1000;
+  const maxRetries = Number(process.env[ENV.MAX_RETRIES] ?? DEFAULTS.MAX_RETRIES);
+  const logLevel = (opts.logLevel as string | undefined) ?? DEFAULTS.LOG_LEVEL;
 
   const json = !!(opts.json as boolean | undefined);
   // Commander's --no-interactive sets opts.interactive = false (default true)

package/src/output/format-output.ts

@@ -0,0 +1,18 @@
+import type { FormatOptions } from "./formatter.ts";
+import { isInteractive } from "./formatter.ts";
+
+/**
+ * Format output with automatic JSON/interactive branching.
+ * In non-interactive mode, returns JSON.stringify of jsonData.
+ * In interactive mode, calls interactiveFn() for formatted output.
+ */
+export function formatOutput(
+  jsonData: unknown,
+  interactiveFn: () => string,
+  options: FormatOptions,
+): string {
+  if (!isInteractive(options)) {
+    return JSON.stringify(jsonData, null, 2);
+  }
+  return interactiveFn();
+}

package/src/output/format-table.ts

@@ -0,0 +1,63 @@
+import ansis from "ansis";
+import { dim } from "ansis";
+import { wrapDescription } from "./formatter.ts";
+
+export interface Column<T> {
+  value: (item: T) => string;
+  style: (text: string) => string;
+}
+
+export interface TableOptions<T> {
+  columns: Column<T>[];
+  description?: (item: T) => string | undefined;
+  separator?: string;
+  emptyMessage?: string;
+}
+
+/** Measure visible length of a string (excluding ANSI escape codes) */
+function visibleLength(s: string): number {
+  return ansis.strip(s).length;
+}
+
+/** Get terminal width, or undefined if not a TTY */
+function getTerminalWidth(): number | undefined {
+  if (process.stdout.isTTY) return Math.max(process.stdout.columns - 1, 40);
+  return undefined;
+}
+
+/**
+ * Format a list of items as an aligned table with optional description wrapping.
+ */
+export function formatTable<T>(items: T[], options: TableOptions<T>): string {
+  if (items.length === 0) {
+    return dim(options.emptyMessage ?? "No items found");
+  }
+
+  const sep = options.separator ?? "  ";
+  const termWidth = getTerminalWidth();
+
+  // Calculate max width for each column
+  const maxWidths = options.columns.map((col) =>
+    Math.max(...items.map((item) => col.value(item).length)),
+  );
+
+  return items
+    .map((item) => {
+      const parts = options.columns.map((col, i) => {
+        const raw = col.value(item);
+        const pad = maxWidths[i]! - raw.length;
+        return col.style(raw) + " ".repeat(Math.max(0, pad));
+      });
+      const prefix = parts.join(sep);
+
+      const desc = options.description?.(item);
+      if (desc) {
+        const pw = visibleLength(prefix) + sep.length;
+        const formatted = termWidth != null ? wrapDescription(desc, pw, termWidth) : dim(desc);
+        return `${prefix}${sep}${formatted}`;
+      }
+
+      return prefix;
+    })
+    .join("\n");
+}