@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-08gaq1e6.js

@@ -0,0 +1,253 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-rzeekzsp.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-6va3sq9g.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-5eecpt8g.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-0dc7sstd.js

@@ -0,0 +1,112 @@
+// @bun
+import {
+  detectAndGetBackend,
+  ensureBackendsRegistered,
+  getBackendByType,
+  getCachedBackend,
+  getCachedDetectionResult,
+  getInProcessBackend,
+  getResolvedTeammateMode,
+  getTeammateExecutor,
+  init_registry,
+  isInProcessEnabled,
+  markInProcessFallback,
+  registerITermBackend,
+  registerTmuxBackend,
+  resetBackendDetection
+} from "./chunk-5eecpt8g.js";
+import"./chunk-czvztj44.js";
+import"./chunk-46xsszyy.js";
+import"./chunk-2zcggr61.js";
+import"./chunk-q0q2tsae.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-d9y2zh54.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xffq0yyv.js";
+import"./chunk-02gx6hwz.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-w2yzntwd.js";
+import"./chunk-kdqsfmc5.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-0fzmdbg5.js";
+import"./chunk-sn49y8be.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-8rjvjb5t.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-nw5zdpcj.js";
+import"./chunk-aa3rx320.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-n2pzg3mt.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tdgkxc3j.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-zrw9ava1.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-hgba8zda.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_registry();
+
+export {
+  resetBackendDetection,
+  registerTmuxBackend,
+  registerITermBackend,
+  markInProcessFallback,
+  isInProcessEnabled,
+  getTeammateExecutor,
+  getResolvedTeammateMode,
+  getInProcessBackend,
+  getCachedDetectionResult,
+  getCachedBackend,
+  getBackendByType,
+  ensureBackendsRegistered,
+  detectAndGetBackend
+};

package/dist/chunk-0et2fwnm.js

@@ -0,0 +1,169 @@
+// @bun
+import {
+  Box_default,
+  init_Box,
+  init_dom,
+  init_reconciler,
+  markCommitStart,
+  markDirty,
+  scheduleRenderFrom
+} from "./chunk-aa3rx320.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_state,
+  markScrollActivity
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/ink/components/ScrollBox.tsx
+function ScrollBox({
+  children,
+  ref,
+  stickyScroll,
+  ...style
+}) {
+  const domRef = import_react.useRef(null);
+  const [, forceRender] = import_react.useState(0);
+  const listenersRef = import_react.useRef(new Set);
+  const renderQueuedRef = import_react.useRef(false);
+  const notify = () => {
+    for (const l of listenersRef.current)
+      l();
+  };
+  function scrollMutated(el) {
+    markScrollActivity();
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current)
+      return;
+    renderQueuedRef.current = true;
+    queueMicrotask(() => {
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
+  }
+  import_react.useImperativeHandle(ref, () => ({
+    scrollTo(y) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.pendingScrollDelta = undefined;
+      el.scrollAnchor = undefined;
+      el.scrollTop = Math.max(0, Math.floor(y));
+      scrollMutated(el);
+    },
+    scrollToElement(el, offset = 0) {
+      const box = domRef.current;
+      if (!box)
+        return;
+      box.stickyScroll = false;
+      box.pendingScrollDelta = undefined;
+      box.scrollAnchor = {
+        el,
+        offset
+      };
+      scrollMutated(box);
+    },
+    scrollBy(dy) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.scrollAnchor = undefined;
+      el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+      scrollMutated(el);
+    },
+    scrollToBottom() {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.pendingScrollDelta = undefined;
+      el.stickyScroll = true;
+      markDirty(el);
+      notify();
+      forceRender((n) => n + 1);
+    },
+    getScrollTop() {
+      return domRef.current?.scrollTop ?? 0;
+    },
+    getPendingDelta() {
+      return domRef.current?.pendingScrollDelta ?? 0;
+    },
+    getScrollHeight() {
+      return domRef.current?.scrollHeight ?? 0;
+    },
+    getFreshScrollHeight() {
+      const content = domRef.current?.childNodes[0];
+      return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+    },
+    getViewportHeight() {
+      return domRef.current?.scrollViewportHeight ?? 0;
+    },
+    getViewportTop() {
+      return domRef.current?.scrollViewportTop ?? 0;
+    },
+    isSticky() {
+      const el = domRef.current;
+      if (!el)
+        return false;
+      return el.stickyScroll ?? Boolean(el.attributes["stickyScroll"]);
+    },
+    subscribe(listener) {
+      listenersRef.current.add(listener);
+      return () => listenersRef.current.delete(listener);
+    },
+    setClampBounds(min, max) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.scrollClampMin = min;
+      el.scrollClampMax = max;
+    }
+  }), []);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("ink-box", {
+    ref: (el) => {
+      domRef.current = el;
+      if (el)
+        el.scrollTop ??= 0;
+    },
+    style: {
+      flexWrap: "nowrap",
+      flexDirection: style.flexDirection ?? "row",
+      flexGrow: style.flexGrow ?? 0,
+      flexShrink: style.flexShrink ?? 1,
+      ...style,
+      overflowX: "scroll",
+      overflowY: "scroll"
+    },
+    ...stickyScroll ? {
+      stickyScroll: true
+    } : {},
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+      flexDirection: "column",
+      flexGrow: 1,
+      flexShrink: 0,
+      width: "100%",
+      children
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, ScrollBox_default;
+var init_ScrollBox = __esm(() => {
+  init_state();
+  init_dom();
+  init_reconciler();
+  init_Box();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  ScrollBox_default = ScrollBox;
+});
+
+export { ScrollBox_default, init_ScrollBox };