@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-6mjm0xrg.js

@@ -0,0 +1,253 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-b0b9ky2w.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-z9pphyhq.js";
+import {
+  getPluginCommands,
+  init_AppState,
+  init_loadPluginAgents,
+  init_loadPluginCommands,
+  init_loadPluginHooks,
+  init_lspPluginIntegration,
+  init_manager,
+  init_mcpPluginIntegration,
+  init_notifications,
+  init_pluginLoader,
+  loadAllPlugins,
+  loadPluginAgents,
+  loadPluginHooks,
+  loadPluginLspServers,
+  loadPluginMcpServers,
+  reinitializeLspServerManager,
+  useAppState,
+  useNotifications,
+  useSetAppState
+} from "./chunk-730qrdey.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  count,
+  init_array
+} from "./chunk-b75fzr8e.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-b8x1gk3y.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_debug,
+  init_errors,
+  logForDebugging,
+  toError
+} from "./chunk-sbbj6ta3.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/useManagePlugins.ts
+init_notifications();
+init_analytics();
+init_manager();
+init_AppState();
+init_array();
+init_debug();
+init_diagLogs();
+init_errors();
+init_log();
+init_loadPluginAgents();
+init_loadPluginCommands();
+init_loadPluginHooks();
+init_lspPluginIntegration();
+init_mcpPluginIntegration();
+var import_react = __toESM(require_react(), 1);
+init_pluginFlagging();
+init_pluginLoader();
+function useManagePlugins({
+  enabled = true
+} = {}) {
+  const setAppState = useSetAppState();
+  const needsRefresh = useAppState((s) => s.plugins.needsRefresh);
+  const { addNotification } = useNotifications();
+  const initialPluginLoad = import_react.useCallback(async () => {
+    try {
+      const { enabled: enabled2, disabled, errors } = await loadAllPlugins();
+      await detectAndUninstallDelistedPlugins();
+      const flagged = getFlaggedPlugins();
+      if (Object.keys(flagged).length > 0) {
+        addNotification({
+          key: "plugin-delisted-flagged",
+          text: "Plugins flagged. Check /plugins",
+          color: "warning",
+          priority: "high"
+        });
+      }
+      let commands = [];
+      let agents = [];
+      try {
+        commands = await getPluginCommands();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-commands",
+          error: `Failed to load plugin commands: ${errorMessage}`
+        });
+      }
+      try {
+        agents = await loadPluginAgents();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-agents",
+          error: `Failed to load plugin agents: ${errorMessage}`
+        });
+      }
+      try {
+        await loadPluginHooks();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({
+          type: "generic-error",
+          source: "plugin-hooks",
+          error: `Failed to load plugin hooks: ${errorMessage}`
+        });
+      }
+      const mcpServerCounts = await Promise.all(enabled2.map(async (p) => {
+        if (p.mcpServers)
+          return Object.keys(p.mcpServers).length;
+        const servers = await loadPluginMcpServers(p, errors);
+        if (servers)
+          p.mcpServers = servers;
+        return servers ? Object.keys(servers).length : 0;
+      }));
+      const mcp_count = mcpServerCounts.reduce((sum, n) => sum + n, 0);
+      const lspServerCounts = await Promise.all(enabled2.map(async (p) => {
+        if (p.lspServers)
+          return Object.keys(p.lspServers).length;
+        const servers = await loadPluginLspServers(p, errors);
+        if (servers)
+          p.lspServers = servers;
+        return servers ? Object.keys(servers).length : 0;
+      }));
+      const lsp_count = lspServerCounts.reduce((sum, n) => sum + n, 0);
+      reinitializeLspServerManager();
+      setAppState((prevState) => {
+        const existingLspErrors = prevState.plugins.errors.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+        const newErrorKeys = new Set(errors.map((e) => e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`));
+        const filteredExisting = existingLspErrors.filter((e) => {
+          const key = e.type === "generic-error" ? `generic-error:${e.source}:${e.error}` : `${e.type}:${e.source}`;
+          return !newErrorKeys.has(key);
+        });
+        const mergedErrors = [...filteredExisting, ...errors];
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled: enabled2,
+            disabled,
+            commands,
+            errors: mergedErrors
+          }
+        };
+      });
+      logForDebugging(`Loaded plugins - Enabled: ${enabled2.length}, Disabled: ${disabled.length}, Commands: ${commands.length}, Agents: ${agents.length}, Errors: ${errors.length}`);
+      const hook_count = enabled2.reduce((sum, p) => {
+        if (!p.hooksConfig)
+          return sum;
+        return sum + Object.values(p.hooksConfig).reduce((s, matchers) => s + (matchers?.reduce((h, m) => h + m.hooks.length, 0) ?? 0), 0);
+      }, 0);
+      return {
+        enabled_count: enabled2.length,
+        disabled_count: disabled.length,
+        inline_count: count(enabled2, (p) => p.source.endsWith("@inline")),
+        marketplace_count: count(enabled2, (p) => !p.source.endsWith("@inline")),
+        error_count: errors.length,
+        skill_count: commands.length,
+        agent_count: agents.length,
+        hook_count,
+        mcp_count,
+        lsp_count,
+        ant_enabled_names: process.env.USER_TYPE === "ant" && enabled2.length > 0 ? enabled2.map((p) => p.name).sort().join(",") : undefined
+      };
+    } catch (error) {
+      const errorObj = toError(error);
+      logError(errorObj);
+      logForDebugging(`Error loading plugins: ${error}`);
+      setAppState((prevState) => {
+        const existingLspErrors = prevState.plugins.errors.filter((e) => e.source === "lsp-manager" || e.source.startsWith("plugin:"));
+        const newError = {
+          type: "generic-error",
+          source: "plugin-system",
+          error: errorObj.message
+        };
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled: [],
+            disabled: [],
+            commands: [],
+            errors: [...existingLspErrors, newError]
+          }
+        };
+      });
+      return {
+        enabled_count: 0,
+        disabled_count: 0,
+        inline_count: 0,
+        marketplace_count: 0,
+        error_count: 1,
+        skill_count: 0,
+        agent_count: 0,
+        hook_count: 0,
+        mcp_count: 0,
+        lsp_count: 0,
+        load_failed: true,
+        ant_enabled_names: undefined
+      };
+    }
+  }, [setAppState, addNotification]);
+  import_react.useEffect(() => {
+    if (!enabled)
+      return;
+    initialPluginLoad().then((metrics) => {
+      const { ant_enabled_names, ...baseMetrics } = metrics;
+      const allMetrics = {
+        ...baseMetrics,
+        has_custom_plugin_cache_dir: !!process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR
+      };
+      logEvent("tengu_plugins_loaded", {
+        ...allMetrics,
+        ...ant_enabled_names !== undefined && {
+          enabled_names: ant_enabled_names
+        }
+      });
+      logForDiagnosticsNoPII("info", "tengu_plugins_loaded", allMetrics);
+    });
+  }, [initialPluginLoad, enabled]);
+  import_react.useEffect(() => {
+    if (!enabled || !needsRefresh)
+      return;
+    addNotification({
+      key: "plugin-reload-pending",
+      text: "Plugins changed. Run /reload-plugins to activate.",
+      color: "suggestion",
+      priority: "low"
+    });
+  }, [enabled, needsRefresh, addNotification]);
+}
+
+export { useManagePlugins };

package/dist/chunk-6mtvk568.js

@@ -0,0 +1,89 @@
+// @bun
+import {
+  init_sessionFileAccessHooks,
+  isMemoryFileAccess,
+  registerSessionFileAccessHooks
+} from "./chunk-730qrdey.js";
+import"./chunk-cfmxfyg6.js";
+import"./chunk-vwtd8nde.js";
+import"./chunk-nsw7n8c5.js";
+import"./chunk-v7n7nnwc.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-tggpkxkz.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xfxyj6qk.js";
+import"./chunk-n8326eqb.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-ps540063.js";
+import"./chunk-fz0qs5hv.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-re8evv5h.js";
+import"./chunk-g3jde8ef.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-6p1yy212.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-gdr19kp1.js";
+import"./chunk-zp37prdd.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-ya2a18ws.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-14as9yqj.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-vn4hnzzj.js";
+import"./chunk-3tqnjgfx.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_sessionFileAccessHooks();
+
+export {
+  registerSessionFileAccessHooks,
+  isMemoryFileAccess
+};

package/dist/chunk-6n2qgm9v.js

@@ -0,0 +1,8 @@
+// @bun
+import {
+  init_external
+} from "./chunk-55wgxwa9.js";
+
+// node_modules/.bun/zod@4.3.6/node_modules/zod/index.js
+init_external();
+init_external();

package/dist/chunk-6n3ckbjv.js

@@ -0,0 +1,348 @@
+// @bun
+import {
+  describeMcpConfigFilePath,
+  getMcpConfigsByScope,
+  getScopeLabel,
+  init_config,
+  init_utils
+} from "./chunk-730qrdey.js";
+import {
+  Link,
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-zp37prdd.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/mcp/McpParsingWarnings.tsx
+function McpConfigErrorSection(t0) {
+  const $ = import_compiler_runtime.c(26);
+  const {
+    scope,
+    parsingErrors,
+    warnings
+  } = t0;
+  const hasErrors = parsingErrors.length > 0;
+  const hasWarnings = warnings.length > 0;
+  if (!hasErrors && !hasWarnings) {
+    return null;
+  }
+  let t1;
+  if ($[0] !== hasErrors || $[1] !== hasWarnings) {
+    t1 = (hasErrors || hasWarnings) && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: hasErrors ? "error" : "warning",
+      children: [
+        "[",
+        hasErrors ? "Failed to parse" : "Contains warnings",
+        "]",
+        " "
+      ]
+    }, undefined, true, undefined, this);
+    $[0] = hasErrors;
+    $[1] = hasWarnings;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  let t2;
+  if ($[3] !== scope) {
+    t2 = getScopeLabel(scope);
+    $[3] = scope;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] !== t2) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: t2
+    }, undefined, false, undefined, this);
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  let t4;
+  if ($[7] !== t1 || $[8] !== t3) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        t1,
+        t3
+      ]
+    }, undefined, true, undefined, this);
+    $[7] = t1;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: "Location: "
+    }, undefined, false, undefined, this);
+    $[10] = t5;
+  } else {
+    t5 = $[10];
+  }
+  let t6;
+  if ($[11] !== scope) {
+    t6 = describeMcpConfigFilePath(scope);
+    $[11] = scope;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== t6) {
+    t7 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        t5,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: t6
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[13] = t6;
+    $[14] = t7;
+  } else {
+    t7 = $[14];
+  }
+  let t8;
+  if ($[15] !== parsingErrors) {
+    t8 = parsingErrors.map(_temp);
+    $[15] = parsingErrors;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== warnings) {
+    t9 = warnings.map(_temp2);
+    $[17] = warnings;
+    $[18] = t9;
+  } else {
+    t9 = $[18];
+  }
+  let t10;
+  if ($[19] !== t8 || $[20] !== t9) {
+    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      marginLeft: 1,
+      flexDirection: "column",
+      children: [
+        t8,
+        t9
+      ]
+    }, undefined, true, undefined, this);
+    $[19] = t8;
+    $[20] = t9;
+    $[21] = t10;
+  } else {
+    t10 = $[21];
+  }
+  let t11;
+  if ($[22] !== t10 || $[23] !== t4 || $[24] !== t7) {
+    t11 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      marginTop: 1,
+      children: [
+        t4,
+        t7,
+        t10
+      ]
+    }, undefined, true, undefined, this);
+    $[22] = t10;
+    $[23] = t4;
+    $[24] = t7;
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  return t11;
+}
+function _temp2(warning, i_0) {
+  const serverName_0 = warning.mcpErrorMetadata?.serverName;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "\u2514 "
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: "warning",
+          children: "[Warning]"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: [
+            " ",
+            serverName_0 && `[${serverName_0}] `,
+            warning.path && warning.path !== "" ? `${warning.path}: ` : "",
+            warning.message
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, `warning-${i_0}`, false, undefined, this);
+}
+function _temp(error, i) {
+  const serverName = error.mcpErrorMetadata?.serverName;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "\u2514 "
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: "error",
+          children: "[Error]"
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: [
+            " ",
+            serverName && `[${serverName}] `,
+            error.path && error.path !== "" ? `${error.path}: ` : "",
+            error.message
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, `error-${i}`, false, undefined, this);
+}
+function McpParsingWarnings() {
+  const $ = import_compiler_runtime.c(6);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = {
+      scope: "user",
+      config: getMcpConfigsByScope("user")
+    };
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  let t1;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = {
+      scope: "project",
+      config: getMcpConfigsByScope("project")
+    };
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      scope: "local",
+      config: getMcpConfigsByScope("local")
+    };
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = [t0, t1, t2, {
+      scope: "enterprise",
+      config: getMcpConfigsByScope("enterprise")
+    }];
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const scopes = t3;
+  const hasParsingErrors = scopes.some(_temp3);
+  const hasWarnings = scopes.some(_temp4);
+  if (!hasParsingErrors && !hasWarnings) {
+    return null;
+  }
+  let t4;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      bold: true,
+      children: "MCP Config Diagnostics"
+    }, undefined, false, undefined, this);
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      marginTop: 1,
+      marginBottom: 1,
+      children: [
+        t4,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: [
+              "For help configuring MCP servers, see:",
+              " ",
+              /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+                url: "https://code.claude.com/docs/en/mcp",
+                children: "https://code.claude.com/docs/en/mcp"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        }, undefined, false, undefined, this),
+        scopes.map(_temp5)
+      ]
+    }, undefined, true, undefined, this);
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  return t5;
+}
+function _temp5(t0) {
+  const {
+    scope,
+    config: config_1
+  } = t0;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(McpConfigErrorSection, {
+    scope,
+    parsingErrors: filterErrors(config_1.errors, "fatal"),
+    warnings: filterErrors(config_1.errors, "warning")
+  }, scope, false, undefined, this);
+}
+function _temp4(t0) {
+  const {
+    config: config_0
+  } = t0;
+  return filterErrors(config_0.errors, "warning").length > 0;
+}
+function _temp3(t0) {
+  const {
+    config
+  } = t0;
+  return filterErrors(config.errors, "fatal").length > 0;
+}
+function filterErrors(errors, severity) {
+  return errors.filter((e) => e.mcpErrorMetadata?.severity === severity);
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_McpParsingWarnings = __esm(() => {
+  init_config();
+  init_utils();
+  init_ink();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { McpParsingWarnings, init_McpParsingWarnings };