ccjk 13.6.4 → 13.6.7

package/dist/shared/ccjk.BI-hdI7P.mjs

@@ -0,0 +1,30 @@
+import a from '../chunks/index5.mjs';
+import { i as inquirer } from '../chunks/index6.mjs';
+import { g as getMcpServices, M as MCP_SERVICE_CONFIGS } from './ccjk.DKXs7Fbm.mjs';
+import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+
+async function selectMcpServices() {
+  ensureI18nInitialized();
+  const mcpServices = await getMcpServices();
+  const defaultSelectedIds = new Set(
+    MCP_SERVICE_CONFIGS.filter((c) => c.defaultSelected).map((c) => c.id)
+  );
+  const choices = mcpServices.map((service) => ({
+    name: `${service.name} - ${a.gray(service.description)}`,
+    value: service.id,
+    checked: defaultSelectedIds.has(service.id)
+  }));
+  const { services } = await inquirer.prompt({
+    type: "checkbox",
+    name: "services",
+    message: `${i18n.t("mcp:selectMcpServices")}${i18n.t("common:multiSelectHint")}`,
+    choices
+  });
+  if (services === void 0) {
+    console.log(a.yellow(i18n.t("common:cancelled")));
+    return void 0;
+  }
+  return services;
+}
+
+export { selectMcpServices as s };

package/dist/shared/{ccjk.DwSebGy0.mjs → ccjk.BOO14f66.mjs}

@@ -597,4 +597,4 @@ class TaskPersistence {
 }
 const taskPersistence = new TaskPersistence();
 
-export { taskPersistence as t };
+export { TaskPersistence as T, taskPersistence as t };

package/dist/shared/ccjk.BnsY5WxD.mjs

@@ -0,0 +1,171 @@
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+async function executeCommand(command, args = [], options = {}) {
+  try {
+    const fullCommand = buildCommand(command, args);
+    const execOptions = {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      timeout: options.timeout,
+      shell: typeof options.shell === "string" ? options.shell : options.shell ? "/bin/sh" : void 0,
+      encoding: options.encoding || "utf8",
+      maxBuffer: options.maxBuffer || 1024 * 1024 * 10
+      // 10MB default
+    };
+    const { stdout, stderr } = await execAsync(fullCommand, execOptions);
+    return {
+      success: true,
+      stdout: stdout.toString().trim(),
+      stderr: stderr.toString().trim(),
+      exitCode: 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      stdout: error.stdout?.toString().trim() || "",
+      stderr: error.stderr?.toString().trim() || "",
+      exitCode: error.code || 1,
+      error: error.message
+    };
+  }
+}
+function executeCommandStream(command, args = [], options = {}) {
+  return new Promise((resolve) => {
+    const spawnOptions = {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      shell: options.shell !== false
+    };
+    const child = spawn(command, args, spawnOptions);
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      if (options.onStdout) {
+        options.onStdout(text);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      if (options.onStderr) {
+        options.onStderr(text);
+      }
+    });
+    child.on("close", (code) => {
+      resolve({
+        success: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code || 0,
+        error: code !== 0 ? `Command exited with code ${code}` : void 0
+      });
+    });
+    child.on("error", (error) => {
+      resolve({
+        success: false,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: 1,
+        error: error.message
+      });
+    });
+    if (options.timeout) {
+      setTimeout(() => {
+        child.kill();
+        resolve({
+          success: false,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          exitCode: 1,
+          error: `Command timed out after ${options.timeout}ms`
+        });
+      }, options.timeout);
+    }
+  });
+}
+function buildCommand(command, args) {
+  const escapedArgs = args.map(escapeArgument);
+  return [command, ...escapedArgs].join(" ");
+}
+function escapeArgument(arg) {
+  if (/[\s"'`$&|;<>(){}[\]\\]/.test(arg)) {
+    const escaped = arg.replace(/"/g, '\\"');
+    return `"${escaped}"`;
+  }
+  return arg;
+}
+async function commandExists(command) {
+  const isWindows = process.platform === "win32";
+  const checkCommand = isWindows ? "where" : "which";
+  try {
+    const result = await executeCommand(checkCommand, [command]);
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+async function getCommandPath(command) {
+  const isWindows = process.platform === "win32";
+  const checkCommand = isWindows ? "where" : "which";
+  try {
+    const result = await executeCommand(checkCommand, [command]);
+    if (result.success) {
+      return result.stdout.split("\n")[0].trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseVersion(output) {
+  const patterns = [
+    /version\s+v?(\d+\.\d+\.\d+)/i,
+    /v?(\d+\.\d+\.\d+)/,
+    /(\d+\.\d+\.\d+)/
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+async function getCommandVersion(command, versionFlag = "--version") {
+  try {
+    const result = await executeCommand(command, [versionFlag]);
+    if (result.success) {
+      return parseVersion(result.stdout || result.stderr);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function executeCommandSequence(commands) {
+  const results = [];
+  for (const cmd of commands) {
+    const result = await executeCommand(
+      cmd.command,
+      cmd.args || [],
+      cmd.options || {}
+    );
+    results.push(result);
+    if (!result.success) {
+      break;
+    }
+  }
+  return results;
+}
+async function executeCommandParallel(commands) {
+  const promises = commands.map(
+    (cmd) => executeCommand(cmd.command, cmd.args || [], cmd.options || {})
+  );
+  return Promise.all(promises);
+}
+
+export { escapeArgument as a, buildCommand as b, commandExists as c, executeCommandParallel as d, executeCommand as e, executeCommandSequence as f, executeCommandStream as g, getCommandPath as h, getCommandVersion as i, parseVersion as p };

package/dist/shared/{ccjk.C4m4ypdk.mjs → ccjk.DHaUdzX3.mjs}

@@ -1,12 +1,13 @@
 import a from '../chunks/index5.mjs';
 import { i as inquirer } from '../chunks/index6.mjs';
-import { h as getMcpService, i as dynamicMcpRegistry, r as readCodexConfig, j as applyCodexPlatformCommand, w as writeCodexConfig, M as MCP_SERVICE_CONFIGS } from '../chunks/codex.mjs';
+import { a as getMcpService, d as dynamicMcpRegistry, M as MCP_SERVICE_CONFIGS } from './ccjk.DKXs7Fbm.mjs';
 import { SETTINGS_FILE, CLAUDE_DIR, ClAUDE_CONFIG_FILE, CODEX_CONFIG_FILE } from '../chunks/constants.mjs';
 import { exists, ensureDir } from '../chunks/fs-operations.mjs';
 import { readJsonConfig, writeJsonConfig } from '../chunks/json-config.mjs';
-import { d as deepMerge, r as readMcpConfig, b as buildMcpServerConfig, w as writeMcpConfig } from '../chunks/claude-config.mjs';
+import { g as deepMerge, r as readMcpConfig, a as buildMcpServerConfig, w as writeMcpConfig } from '../chunks/claude-config.mjs';
 import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
-import { k as isWindows, m as getSystemRoot } from '../chunks/platform.mjs';
+import { r as readCodexConfig, g as applyCodexPlatformCommand, w as writeCodexConfig } from '../chunks/codex.mjs';
+import { i as isWindows, m as getSystemRoot } from '../chunks/platform.mjs';
 
 function readClaudeConfig(configPath = SETTINGS_FILE) {
   try {

package/dist/shared/ccjk.DKXs7Fbm.mjs

@@ -0,0 +1,361 @@
+import { execSync } from 'node:child_process';
+import process__default from 'node:process';
+import { ensureI18nInitialized, i18n } from '../chunks/index2.mjs';
+
+const MCP_SERVICE_CONFIGS = [
+  // Documentation and research services
+  {
+    id: "context7",
+    requiresApiKey: false,
+    defaultSelected: true,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@upstash/context7-mcp@latest"],
+      env: {}
+    }
+  },
+  {
+    id: "open-websearch",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "open-websearch@latest"],
+      env: {
+        MODE: "stdio",
+        DEFAULT_SEARCH_ENGINE: "duckduckgo",
+        ALLOWED_SEARCH_ENGINES: "duckduckgo,bing,brave"
+      }
+    }
+  },
+  {
+    id: "mcp-deepwiki",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "mcp-deepwiki@latest"],
+      env: {}
+    }
+  },
+  {
+    id: "spec-workflow",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@pimzino/spec-workflow-mcp@latest"],
+      env: {}
+    }
+  },
+  {
+    id: "serena",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "uvx",
+      args: ["--from", "git+https://github.com/oraios/serena", "serena", "start-mcp-server", "--context", "ide-assistant", "--enable-web-dashboard", "false"],
+      env: {}
+    },
+    platformRequirements: {
+      requiredCommands: ["uvx"]
+    }
+  },
+  {
+    id: "Playwright",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@playwright/mcp@latest", "--browser", "chromium"],
+      env: {}
+    },
+    platformRequirements: {
+      platforms: ["macos", "windows"],
+      requiresGui: true
+    }
+  },
+  {
+    id: "intent-engine",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@origintask/intent-engine@latest", "mcp"],
+      env: {}
+    }
+  },
+  {
+    id: "sqlite",
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@anthropic-ai/mcp-server-sqlite@latest"],
+      env: {}
+    }
+  }
+];
+async function getMcpServices() {
+  ensureI18nInitialized();
+  const mcpServiceList = [
+    {
+      id: "context7",
+      name: i18n.t("mcp:services.context7.name"),
+      description: i18n.t("mcp:services.context7.description")
+    },
+    {
+      id: "open-websearch",
+      name: i18n.t("mcp:services.open-websearch.name"),
+      description: i18n.t("mcp:services.open-websearch.description")
+    },
+    {
+      id: "mcp-deepwiki",
+      name: i18n.t("mcp:services.mcp-deepwiki.name"),
+      description: i18n.t("mcp:services.mcp-deepwiki.description")
+    },
+    {
+      id: "spec-workflow",
+      name: i18n.t("mcp:services.spec-workflow.name"),
+      description: i18n.t("mcp:services.spec-workflow.description")
+    },
+    {
+      id: "serena",
+      name: i18n.t("mcp:services.serena.name"),
+      description: i18n.t("mcp:services.serena.description")
+    },
+    {
+      id: "Playwright",
+      name: i18n.t("mcp:services.Playwright.name"),
+      description: i18n.t("mcp:services.Playwright.description")
+    },
+    {
+      id: "intent-engine",
+      name: i18n.t("mcp:services.intent-engine.name"),
+      description: i18n.t("mcp:services.intent-engine.description")
+    },
+    {
+      id: "sqlite",
+      name: i18n.t("mcp:services.sqlite.name"),
+      description: i18n.t("mcp:services.sqlite.description")
+    }
+  ];
+  return MCP_SERVICE_CONFIGS.map((config) => {
+    const serviceInfo = mcpServiceList.find((s) => s.id === config.id);
+    const service = {
+      id: config.id,
+      name: serviceInfo?.name || config.id,
+      description: serviceInfo?.description || "",
+      requiresApiKey: config.requiresApiKey,
+      config: config.config
+    };
+    if (config.apiKeyEnvVar) {
+      service.apiKeyEnvVar = config.apiKeyEnvVar;
+    }
+    return service;
+  });
+}
+async function getMcpService(id) {
+  const services = await getMcpServices();
+  return services.find((service) => service.id === id);
+}
+function detectPlatform() {
+  const platform = process__default.platform;
+  const env = process__default.env;
+  const isWsl = !!(env.WSL_DISTRO_NAME || env.WSLENV || env.PATH && env.PATH.includes("/mnt/c/"));
+  const isTermux = !!(env.TERMUX_VERSION || env.PREFIX?.includes("com.termux"));
+  const isHeadless = !!(env.SSH_CLIENT || env.SSH_TTY || env.SSH_CONNECTION || !env.DISPLAY && platform === "linux");
+  const hasGui = (() => {
+    if (platform === "darwin")
+      return true;
+    if (platform === "win32")
+      return !isHeadless;
+    if (isWsl || isTermux)
+      return false;
+    if (platform === "linux")
+      return !!env.DISPLAY || !!env.WAYLAND_DISPLAY;
+    return false;
+  })();
+  let detectedPlatform;
+  if (platform === "darwin") {
+    detectedPlatform = "macos";
+  } else if (platform === "win32") {
+    detectedPlatform = "windows";
+  } else if (isWsl) {
+    detectedPlatform = "wsl";
+  } else if (isTermux) {
+    detectedPlatform = "termux";
+  } else if (platform === "linux") {
+    detectedPlatform = "linux";
+  } else {
+    detectedPlatform = "unknown";
+  }
+  return {
+    platform: detectedPlatform,
+    hasGui,
+    isHeadless
+  };
+}
+function isCommandAvailable(command) {
+  try {
+    execSync(`which ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMcpServiceCompatible(serviceId) {
+  const config = MCP_SERVICE_CONFIGS.find((c) => c.id === serviceId);
+  if (!config) {
+    return { compatible: false, reason: "Service not found" };
+  }
+  const requirements = config.platformRequirements;
+  if (!requirements) {
+    return { compatible: true };
+  }
+  const { platform, hasGui } = detectPlatform();
+  if (requirements.platforms && requirements.platforms.length > 0) {
+    if (platform !== "unknown" && !requirements.platforms.includes(platform)) {
+      return {
+        compatible: false,
+        reason: `Not supported on ${platform}. Requires: ${requirements.platforms.join(", ")}`
+      };
+    }
+  }
+  if (requirements.requiresGui && !hasGui) {
+    return {
+      compatible: false,
+      reason: "Requires GUI environment (X11/Wayland/Desktop)"
+    };
+  }
+  if (requirements.requiredCommands) {
+    for (const cmd of requirements.requiredCommands) {
+      if (!isCommandAvailable(cmd)) {
+        return {
+          compatible: false,
+          reason: `Required command not found: ${cmd}`
+        };
+      }
+    }
+  }
+  return { compatible: true };
+}
+async function getMcpServicesWithCompatibility() {
+  const allServices = await getMcpServices();
+  return allServices.map((service) => {
+    const { compatible, reason } = isMcpServiceCompatible(service.id);
+    return {
+      ...service,
+      compatible,
+      incompatibleReason: reason
+    };
+  });
+}
+const DEFAULT_MCP_TOOL_SEARCH_CONFIG = {
+  mcpAutoEnableThreshold: 10,
+  excludedServices: ["mcp-search", "context7"]
+};
+function getMcpToolSearchConfig() {
+  const env = process__default.env;
+  return {
+    mcpAutoEnableThreshold: env.MCP_AUTO_THRESHOLD || DEFAULT_MCP_TOOL_SEARCH_CONFIG.mcpAutoEnableThreshold,
+    dynamicServiceDiscovery: env.MCP_DYNAMIC_DISCOVERY !== "false",
+    listChangedNotifications: env.MCP_LIST_CHANGED !== "false",
+    excludedServices: env.MCP_EXCLUDED_SERVICES?.split(",").map((s) => s.trim()).filter(Boolean) || DEFAULT_MCP_TOOL_SEARCH_CONFIG.excludedServices
+  };
+}
+class DynamicMcpServiceRegistry {
+  _services = /* @__PURE__ */ new Map();
+  _listeners = /* @__PURE__ */ new Set();
+  _enabled = false;
+  /**
+   * Enable dynamic service discovery
+   */
+  enable() {
+    this._enabled = true;
+  }
+  /**
+   * Disable dynamic service discovery
+   */
+  disable() {
+    this._enabled = false;
+  }
+  /**
+   * Check if dynamic discovery is enabled
+   */
+  isEnabled() {
+    return this._enabled;
+  }
+  /**
+   * Add a service dynamically
+   */
+  addService(serviceId, config) {
+    if (!this._enabled) {
+      return false;
+    }
+    const isUpdate = this._services.has(serviceId);
+    this._services.set(serviceId, config);
+    this._notify({
+      type: isUpdate ? "updated" : "added",
+      serviceId,
+      timestamp: Date.now(),
+      config
+    });
+    return true;
+  }
+  /**
+   * Remove a service dynamically
+   */
+  removeService(serviceId) {
+    if (!this._enabled || !this._services.has(serviceId)) {
+      return false;
+    }
+    const config = this._services.get(serviceId);
+    this._services.delete(serviceId);
+    this._notify({
+      type: "removed",
+      serviceId,
+      timestamp: Date.now(),
+      config
+    });
+    return true;
+  }
+  /**
+   * Get a service configuration
+   */
+  getService(serviceId) {
+    return this._services.get(serviceId);
+  }
+  /**
+   * List all dynamically registered services
+   */
+  listServices() {
+    return new Map(this._services);
+  }
+  /**
+   * Subscribe to list change notifications
+   */
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /**
+   * Notify all listeners of a change
+   */
+  _notify(notification) {
+    const toolSearchConfig = getMcpToolSearchConfig();
+    if (toolSearchConfig.listChangedNotifications) {
+      for (const listener of Array.from(this._listeners)) {
+        try {
+          listener(notification);
+        } catch (error) {
+          console.error("Error notifying MCP list change listener:", error);
+        }
+      }
+    }
+  }
+}
+const dynamicMcpRegistry = new DynamicMcpServiceRegistry();
+
+export { MCP_SERVICE_CONFIGS as M, getMcpService as a, getMcpServicesWithCompatibility as b, dynamicMcpRegistry as d, getMcpServices as g, isMcpServiceCompatible as i };

package/dist/shared/{ccjk.BP5hsTZQ.mjs → ccjk.Dz0ssUQx.mjs}

@@ -490,4 +490,4 @@ async function updatePromptOnly(aiOutputLang) {
 ${a.green(i18n.t("common:complete"))}`);
 }
 
-export { configureOutputStyle as a, configureApiCompletely as c, formatApiKeyDisplay as f, modifyApiConfigPartially as m, updatePromptOnly as u, validateApiKey as v };
+export { configureApiCompletely as a, configureOutputStyle as c, formatApiKeyDisplay as f, modifyApiConfigPartially as m, updatePromptOnly as u, validateApiKey as v };