zenox 1.0.5 → 1.1.1

package/dist/cli/constants.d.ts

@@ -8,3 +8,11 @@ export interface AgentInfo {
 }
 export declare const AGENTS: AgentInfo[];
 export declare const DEFAULT_MODELS: Record<AgentName, string>;
+export type McpName = "exa" | "grep_app" | "sequential-thinking";
+export interface McpInfo {
+    name: McpName;
+    displayName: string;
+    description: string;
+    recommended: boolean;
+}
+export declare const MCP_SERVERS: McpInfo[];

package/dist/cli/index.js

@@ -2256,6 +2256,9 @@ var {
   Help
 } = import__.default;
 
+// node_modules/@clack/prompts/dist/index.mjs
+import { stripVTControlCharacters as S2 } from "node:util";
+
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -2880,6 +2883,21 @@ ${import_picocolors2.default.cyan(d2)}
     }
   } }).prompt();
 };
+var Me = (t = "", n = "") => {
+  const r2 = `
+${t}
+`.split(`
+`), i = S2(n).length, s = Math.max(r2.reduce((a, l2) => {
+    const $2 = S2(l2);
+    return $2.length > a ? $2.length : a;
+  }, 0), i) + 2, c = r2.map((a) => `${import_picocolors2.default.gray(o)}  ${import_picocolors2.default.dim(a)}${" ".repeat(s - S2(a).length)}${import_picocolors2.default.gray(o)}`).join(`
+`);
+  process.stdout.write(`${import_picocolors2.default.gray(o)}
+${import_picocolors2.default.green(C)}  ${import_picocolors2.default.reset(n)} ${import_picocolors2.default.gray(_2.repeat(Math.max(s - i - 1, 1)) + me)}
+${c}
+${import_picocolors2.default.gray(de + _2.repeat(s + 2) + pe)}
+`);
+};
 var xe = (t = "") => {
   process.stdout.write(`${import_picocolors2.default.gray(d2)}  ${import_picocolors2.default.red(t)}
 
@@ -2972,7 +2990,7 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/cli/install.ts
-var import_picocolors3 = __toESM(require_picocolors(), 1);
+var import_picocolors5 = __toESM(require_picocolors(), 1);
 
 // src/cli/config-manager.ts
 import { existsSync } from "node:fs";
@@ -3106,6 +3124,26 @@ var DEFAULT_MODELS = {
   oracle: "openai/gpt-5.2",
   "ui-planner": "google/gemini-3-pro-high"
 };
+var MCP_SERVERS = [
+  {
+    name: "exa",
+    displayName: "Exa",
+    description: "Web search & code context via Exa AI",
+    recommended: true
+  },
+  {
+    name: "grep_app",
+    displayName: "grep.app",
+    description: "GitHub code search - find real-world examples",
+    recommended: true
+  },
+  {
+    name: "sequential-thinking",
+    displayName: "Sequential Thinking",
+    description: "Structured reasoning for complex problems",
+    recommended: true
+  }
+];
 
 // src/cli/config-manager.ts
 var CONFIG_FILENAMES = ["opencode.json", "opencode.jsonc"];
@@ -3172,17 +3210,17 @@ function addPluginToJsonc(content) {
     const afterTrimmed = afterBrace.trimStart();
     if (afterTrimmed.startsWith("}")) {
       return `${beforeBrace}
-  "plugins": ["${PACKAGE_NAME}"]
+  "plugin": ["${PACKAGE_NAME}"]
 }`;
     } else {
       return `${beforeBrace}
-  "plugins": ["${PACKAGE_NAME}"],
+  "plugin": ["${PACKAGE_NAME}"],
   ${afterBrace.trimStart()}`;
     }
   }
 }
 function addPluginToJson(config) {
-  const existingKey = config.plugins ? "plugins" : config.plugin ? "plugin" : "plugins";
+  const existingKey = config.plugins ? "plugins" : config.plugin ? "plugin" : "plugin";
   const existingPlugins = config.plugins ?? config.plugin ?? [];
   const newConfig = {
     [existingKey]: [PACKAGE_NAME, ...existingPlugins],
@@ -3209,7 +3247,7 @@ function getDefaultConfigPath(directory) {
 }
 async function createDefaultConfig(configPath) {
   const defaultConfig = {
-    plugins: [PACKAGE_NAME]
+    plugin: [PACKAGE_NAME]
   };
   await writeFile(configPath, JSON.stringify(defaultConfig, null, 2) + `
 `, "utf-8");
@@ -3267,28 +3305,77 @@ function getCurrentModels(config) {
   }
   return result;
 }
+function getDisabledMcps(config) {
+  return config?.disabled_mcps ?? [];
+}
+async function updateDisabledMcps(disabledMcps) {
+  const existing = await readZenoxConfig() ?? {};
+  if (disabledMcps.length === 0) {
+    const { disabled_mcps: _3, ...rest } = existing;
+    if (Object.keys(rest).length === 0) {
+      return;
+    }
+    await writeZenoxConfig(rest);
+  } else {
+    await writeZenoxConfig({
+      ...existing,
+      disabled_mcps: disabledMcps
+    });
+  }
+}
 
 // src/cli/model-picker.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
 var CUSTOM_MODEL_OPTION = "__custom__";
+function formatModelName(modelId) {
+  return modelId.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
 function extractUserModels(config) {
-  const models = new Set;
+  const models = new Map;
   const provider = config.provider;
-  if (!provider)
-    return [];
-  for (const providerConfig of Object.values(provider)) {
-    if (typeof providerConfig !== "object" || providerConfig === null)
-      continue;
-    const providerModels = providerConfig.models;
-    if (typeof providerModels !== "object" || providerModels === null)
-      continue;
-    for (const modelId of Object.keys(providerModels)) {
-      models.add(modelId);
+  if (provider) {
+    for (const [providerName, providerConfig] of Object.entries(provider)) {
+      if (!providerConfig || typeof providerConfig !== "object")
+        continue;
+      const providerModels = providerConfig.models;
+      if (!providerModels)
+        continue;
+      for (const [modelId, modelConfig] of Object.entries(providerModels)) {
+        const fullId = `${providerName}/${modelId}`;
+        const cfg = modelConfig;
+        models.set(fullId, {
+          id: fullId,
+          displayName: cfg?.name ?? formatModelName(modelId),
+          provider: providerName
+        });
+      }
     }
   }
-  return Array.from(models).sort();
+  if (config.model && typeof config.model === "string" && config.model.includes("/")) {
+    const [providerName, modelId] = config.model.split("/");
+    if (!models.has(config.model)) {
+      models.set(config.model, {
+        id: config.model,
+        displayName: formatModelName(modelId),
+        provider: providerName
+      });
+    }
+  }
+  if (config.small_model && typeof config.small_model === "string" && config.small_model.includes("/")) {
+    const [providerName, modelId] = config.small_model.split("/");
+    if (!models.has(config.small_model)) {
+      models.set(config.small_model, {
+        id: config.small_model,
+        displayName: formatModelName(modelId),
+        provider: providerName
+      });
+    }
+  }
+  return Array.from(models.values()).sort((a, b3) => a.id.localeCompare(b3.id));
 }
 function buildModelOptions(agent, userModels, currentModel) {
   const options = [];
+  const userModelIds = userModels.map((m2) => m2.id);
   const isDefault = !currentModel || currentModel === agent.defaultModel;
   options.push({
     value: agent.defaultModel,
@@ -3296,16 +3383,16 @@ function buildModelOptions(agent, userModels, currentModel) {
     hint: "Recommended - Default"
   });
   for (const model of userModels) {
-    if (model === agent.defaultModel)
+    if (model.id === agent.defaultModel)
       continue;
-    const isCurrent = currentModel === model;
+    const isCurrent = currentModel === model.id;
     options.push({
-      value: model,
-      label: `${model}${isCurrent ? " (Current)" : ""}`,
-      hint: "From your config"
+      value: model.id,
+      label: `${model.id}${isCurrent ? " (Current)" : ""}`,
+      hint: `${model.displayName} • Your config`
     });
   }
-  if (currentModel && currentModel !== agent.defaultModel && !userModels.includes(currentModel)) {
+  if (currentModel && currentModel !== agent.defaultModel && !userModelIds.includes(currentModel)) {
     options.push({
       value: currentModel,
       label: `${currentModel} (Current)`,
@@ -3320,9 +3407,11 @@ function buildModelOptions(agent, userModels, currentModel) {
   return options;
 }
 async function pickModelForAgent(agent, userModels, currentModel) {
+  Me(`${import_picocolors3.default.bold(agent.description)}
+${import_picocolors3.default.dim(`Default: ${agent.defaultModel}`)}`, agent.displayName);
   const options = buildModelOptions(agent, userModels, currentModel);
   const selected = await ve({
-    message: `${agent.displayName} agent model:`,
+    message: "Select model:",
     options
   });
   if (pD(selected))
@@ -3397,6 +3486,63 @@ async function selectAgentsToReconfigure(currentModels) {
   return selected;
 }
 
+// src/cli/mcp-picker.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+async function askConfigureMcps() {
+  const result = await ve({
+    message: "Configure MCP servers?",
+    options: [
+      {
+        value: "keep_all",
+        label: "Keep all enabled (Recommended)",
+        hint: "All MCPs are free & enhance capabilities"
+      },
+      {
+        value: "customize",
+        label: "Customize",
+        hint: "Disable specific MCPs"
+      }
+    ]
+  });
+  if (pD(result))
+    return null;
+  return result;
+}
+async function pickMcpsToEnable(currentDisabled) {
+  Me(`${import_picocolors4.default.dim("All MCPs are free and recommended for best experience.")}
+${import_picocolors4.default.dim("Unselect only if you have specific conflicts.")}`, "MCP Servers");
+  const allMcpNames = MCP_SERVERS.map((m2) => m2.name);
+  const options = MCP_SERVERS.map((mcp) => {
+    const hint = mcp.recommended ? `${mcp.description} ${import_picocolors4.default.green("• Recommended")}` : mcp.description;
+    return {
+      value: mcp.name,
+      label: mcp.displayName,
+      hint
+    };
+  });
+  const initialValues = allMcpNames.filter((name) => !currentDisabled.includes(name));
+  const selected = await fe({
+    message: "Select MCPs to ENABLE (unselect to disable):",
+    options,
+    initialValues,
+    required: false
+  });
+  if (pD(selected))
+    return null;
+  const enabledMcps = selected;
+  const disabledMcps = allMcpNames.filter((name) => !enabledMcps.includes(name));
+  return disabledMcps;
+}
+function showMcpStatus(disabledMcps) {
+  M2.info("MCP Server Status:");
+  for (const mcp of MCP_SERVERS) {
+    const isDisabled = disabledMcps.includes(mcp.name);
+    const status = isDisabled ? import_picocolors4.default.red("✗ Disabled") : import_picocolors4.default.green("✓ Enabled");
+    const rec = mcp.recommended ? import_picocolors4.default.dim(" (Recommended)") : "";
+    M2.message(`  ${mcp.displayName}: ${status}${rec}`);
+  }
+}
+
 // src/cli/install.ts
 async function runInstall(options = {}) {
   const { noTui = false, configPath: customConfigPath } = options;
@@ -3408,7 +3554,7 @@ async function runInstall(options = {}) {
   await runInteractive(cwd, customConfigPath);
 }
 async function runInteractive(cwd, customConfigPath) {
-  Ie(import_picocolors3.default.cyan(`${PACKAGE_NAME} installer`));
+  Ie(import_picocolors5.default.cyan(`${PACKAGE_NAME} installer`));
   const configFile = customConfigPath ? { path: customConfigPath, format: "json" } : findConfigFile(cwd);
   let opencodeConfig = null;
   if (!configFile) {
@@ -3491,7 +3637,33 @@ async function runInteractive(cwd, customConfigPath) {
       M2.info("Using default models - no zenox.json needed");
     }
   }
-  Se(import_picocolors3.default.green(`${PACKAGE_NAME} installed successfully!`));
+  const mcpChoice = await askConfigureMcps();
+  if (mcpChoice === null) {
+    xe("Installation cancelled");
+    process.exit(0);
+  }
+  if (mcpChoice === "customize") {
+    const zenoxConfig = await readZenoxConfig();
+    const currentDisabled = getDisabledMcps(zenoxConfig);
+    const disabledMcps = await pickMcpsToEnable(currentDisabled);
+    if (disabledMcps === null) {
+      xe("Installation cancelled");
+      process.exit(0);
+    }
+    if (disabledMcps.length > 0) {
+      const spinner = Y2();
+      spinner.start("Saving MCP configuration");
+      try {
+        await updateDisabledMcps(disabledMcps);
+        spinner.stop(`Disabled ${disabledMcps.length} MCP(s)`);
+      } catch (err) {
+        spinner.stop("Failed to save MCP config");
+        M2.error(err instanceof Error ? err.message : "Unknown error");
+        process.exit(1);
+      }
+    }
+  }
+  Se(import_picocolors5.default.green(`${PACKAGE_NAME} installed successfully!`));
 }
 async function runNonInteractive(cwd, customConfigPath) {
   const configFile = customConfigPath ? { path: customConfigPath, format: "json" } : findConfigFile(cwd);
@@ -3515,9 +3687,9 @@ async function runNonInteractive(cwd, customConfigPath) {
 }
 
 // src/cli/config.ts
-var import_picocolors4 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 async function runConfig() {
-  Ie(import_picocolors4.default.cyan(`${PACKAGE_NAME} model configurator`));
+  Ie(import_picocolors6.default.cyan(`${PACKAGE_NAME} model configurator`));
   const cwd = process.cwd();
   let userModels = [];
   const configFile = findConfigFile(cwd);
@@ -3533,7 +3705,7 @@ async function runConfig() {
   for (const agent of AGENTS) {
     const model = currentModels[agent.name] ?? agent.defaultModel;
     const isCustom = currentModels[agent.name] !== undefined;
-    const suffix = isCustom ? import_picocolors4.default.yellow(" (custom)") : import_picocolors4.default.dim(" (default)");
+    const suffix = isCustom ? import_picocolors6.default.yellow(" (custom)") : import_picocolors6.default.dim(" (default)");
     M2.message(`  ${agent.displayName}: ${model}${suffix}`);
   }
   const selectedAgents = await selectAgentsToReconfigure(currentModels);
@@ -3543,7 +3715,7 @@ async function runConfig() {
   }
   if (selectedAgents.length === 0) {
     M2.warn("No agents selected");
-    Se(import_picocolors4.default.yellow("No changes made"));
+    Se(import_picocolors6.default.yellow("No changes made"));
     return;
   }
   const newModels = {};
@@ -3586,7 +3758,42 @@ async function runConfig() {
   } else {
     M2.info("All agents using default models - zenox.json not needed");
   }
-  Se(import_picocolors4.default.green("Configuration updated!"));
+  Se(import_picocolors6.default.green("Configuration updated!"));
+}
+
+// src/cli/mcp.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+async function runMcp() {
+  Ie(import_picocolors7.default.cyan(`${PACKAGE_NAME} MCP configurator`));
+  const zenoxConfig = await readZenoxConfig();
+  const currentDisabled = getDisabledMcps(zenoxConfig);
+  showMcpStatus(currentDisabled);
+  const newDisabled = await pickMcpsToEnable(currentDisabled);
+  if (newDisabled === null) {
+    xe("Configuration cancelled");
+    process.exit(0);
+  }
+  const hasChanges = newDisabled.length !== currentDisabled.length || newDisabled.some((m2) => !currentDisabled.includes(m2));
+  if (!hasChanges) {
+    Se(import_picocolors7.default.yellow("No changes made"));
+    return;
+  }
+  const spinner = Y2();
+  spinner.start("Saving MCP configuration");
+  try {
+    await updateDisabledMcps(newDisabled);
+    if (newDisabled.length === 0) {
+      spinner.stop("All MCPs enabled");
+    } else {
+      spinner.stop(`Updated ${getZenoxConfigPath()}`);
+    }
+  } catch (err) {
+    spinner.stop("Failed to save config");
+    M2.error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+  showMcpStatus(newDisabled);
+  Se(import_picocolors7.default.green("MCP configuration updated!"));
 }
 
 // src/cli/index.ts
@@ -3611,4 +3818,12 @@ program2.command("config").alias("models").description("Reconfigure sub-agent mo
     process.exit(1);
   }
 });
+program2.command("mcp").description("Configure MCP servers (enable/disable)").action(async () => {
+  try {
+    await runMcp();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : "Unknown error");
+    process.exit(1);
+  }
+});
 program2.parse();

package/dist/cli/mcp-picker.d.ts

@@ -0,0 +1,4 @@
+import { type McpName } from "./constants";
+export declare function askConfigureMcps(): Promise<"keep_all" | "customize" | null>;
+export declare function pickMcpsToEnable(currentDisabled: McpName[]): Promise<McpName[] | null>;
+export declare function showMcpStatus(disabledMcps: McpName[]): void;

package/dist/cli/mcp.d.ts

@@ -0,0 +1 @@
+export declare function runMcp(): Promise<void>;

package/dist/cli/model-picker.d.ts

@@ -1,7 +1,7 @@
-import type { OpencodeConfig } from "./types";
+import type { OpencodeConfig, UserModelInfo } from "./types";
 import type { AgentName, AgentInfo } from "./constants";
-export declare function extractUserModels(config: OpencodeConfig): string[];
-export declare function pickModelForAgent(agent: AgentInfo, userModels: string[], currentModel?: string): Promise<string | null>;
-export declare function pickModelsForAllAgents(userModels: string[], currentModels: Partial<Record<AgentName, string>>): Promise<Partial<Record<AgentName, string>> | null>;
+export declare function extractUserModels(config: OpencodeConfig): UserModelInfo[];
+export declare function pickModelForAgent(agent: AgentInfo, userModels: UserModelInfo[], currentModel?: string): Promise<string | null>;
+export declare function pickModelsForAllAgents(userModels: UserModelInfo[], currentModels: Partial<Record<AgentName, string>>): Promise<Partial<Record<AgentName, string>> | null>;
 export declare function askConfigureModels(): Promise<"defaults" | "customize" | null>;
 export declare function selectAgentsToReconfigure(currentModels: Partial<Record<AgentName, string>>): Promise<AgentName[] | null>;

package/dist/cli/types.d.ts

@@ -1,8 +1,28 @@
+export interface ModelConfig {
+    id?: string;
+    name?: string;
+    options?: Record<string, unknown>;
+    variants?: Record<string, unknown>;
+}
+export interface ProviderConfig {
+    npm?: string;
+    name?: string;
+    options?: Record<string, unknown>;
+    models?: Record<string, ModelConfig>;
+}
 export interface OpencodeConfig {
     plugins?: string[];
     plugin?: string[];
+    model?: string;
+    small_model?: string;
+    provider?: Record<string, ProviderConfig>;
     [key: string]: unknown;
 }
+export interface UserModelInfo {
+    id: string;
+    displayName: string;
+    provider: string;
+}
 export interface InstallOptions {
     noTui?: boolean;
     configPath?: string;

package/dist/cli/zenox-config.d.ts

@@ -1,4 +1,4 @@
-import type { AgentName } from "./constants";
+import type { AgentName, McpName } from "./constants";
 export interface ZenoxConfigAgents {
     [key: string]: {
         model: string;
@@ -7,10 +7,12 @@ export interface ZenoxConfigAgents {
 export interface ZenoxConfig {
     agents?: ZenoxConfigAgents;
     disabled_agents?: string[];
-    disabled_mcps?: string[];
+    disabled_mcps?: McpName[];
 }
 export declare function getZenoxConfigPath(): string;
 export declare function readZenoxConfig(): Promise<ZenoxConfig | null>;
 export declare function writeZenoxConfig(config: ZenoxConfig): Promise<void>;
 export declare function updateAgentModels(models: Partial<Record<AgentName, string>>): Promise<void>;
 export declare function getCurrentModels(config: ZenoxConfig | null): Partial<Record<AgentName, string>>;
+export declare function getDisabledMcps(config: ZenoxConfig | null): McpName[];
+export declare function updateDisabledMcps(disabledMcps: McpName[]): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenox",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "description": "OpenCode plugin with specialized agents (explorer, librarian, oracle, ui-planner), background tasks for parallel execution, and smart orchestration",
   "author": "Ayush",
   "license": "MIT",