@rainhole/rain-code 1.1.0

package/dist/chunk-ftqwza3a.js

@@ -0,0 +1,43 @@
+// @bun
+import {
+  require_src as require_src3
+} from "./chunk-fpy4nam9.js";
+import {
+  require_src as require_src2
+} from "./chunk-6tq2v3rk.js";
+import {
+  require_src1 as require_src
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/OTLPMetricExporter.js
+var require_OTLPMetricExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var exporter_metrics_otlp_http_1 = require_src2();
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src();
+
+  class OTLPMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporterBase {
+    constructor(config) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config ?? {}, "METRICS"), otlp_transformer_1.ProtobufMetricsSerializer, "MetricsExportService", "/opentelemetry.proto.collector.metrics.v1.MetricsService/Export"), config);
+    }
+  }
+  exports.OTLPMetricExporter = OTLPMetricExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporter_1 = require_OTLPMetricExporter();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return OTLPMetricExporter_1.OTLPMetricExporter;
+  } });
+});
+export default require_src4();

package/dist/chunk-fyc5fepv.js

@@ -0,0 +1,10 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/commands/assistant/assistant.ts
+var NewInstallWizard = () => null;
+var computeDefaultInstallDir = () => Promise.resolve("");
+export {
+  computeDefaultInstallDir,
+  NewInstallWizard
+};

package/dist/chunk-fz0ch109.js

@@ -0,0 +1,329 @@
+// @bun
+import {
+  DEFAULT_MANIFEST_VERSION,
+  EXCLUDE_PATTERNS,
+  LATEST_MANIFEST_VERSION,
+  MANIFEST_SCHEMAS,
+  MANIFEST_SCHEMAS_LOOSE,
+  McpbManifestSchema,
+  McpbManifestSchema1 as McpbManifestSchema2,
+  McpbManifestSchema2 as McpbManifestSchema3,
+  McpbManifestSchema3 as McpbManifestSchema4,
+  buildManifest,
+  cleanMcpb,
+  createMcpConfig,
+  exports_0_1,
+  exports_0_2,
+  exports_0_3,
+  exports_0_4,
+  extractSignatureBlock,
+  getAllFiles,
+  getAllFilesWithCount,
+  getDefaultAuthorEmail,
+  getDefaultAuthorInfo,
+  getDefaultAuthorName,
+  getDefaultAuthorUrl,
+  getDefaultBasicInfo,
+  getDefaultEntryPoint,
+  getDefaultOptionalFields,
+  getDefaultRepositoryUrl,
+  getDefaultServerConfig,
+  initExtension,
+  init_0_1,
+  init_0_2,
+  init_0_3,
+  init_0_4,
+  init_constants,
+  init_files,
+  init_init,
+  init_pack,
+  init_sign,
+  init_unpack,
+  init_validate,
+  packExtension,
+  printNextSteps,
+  promptAuthorInfo,
+  promptBasicInfo,
+  promptCompatibility,
+  promptLocalization,
+  promptLongDescription,
+  promptOptionalFields,
+  promptPrompts,
+  promptServerConfig,
+  promptTools,
+  promptUrls,
+  promptUserConfig,
+  promptVisualAssets,
+  readMcpbIgnorePatterns,
+  readPackageJson,
+  shouldExclude,
+  signMcpbFile,
+  unpackExtension,
+  unsignMcpbFile,
+  validateManifest,
+  verifyCertificateChain,
+  verifyMcpbFile
+} from "./chunk-ze6zvkg6.js";
+import {
+  exports_external,
+  init_zod,
+  unionType
+} from "./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-vyjeh50y.js";
+import"./chunk-v78fj8by.js";
+import"./chunk-sd36yzx8.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm,
+  __export
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/schemas/any.js
+var exports_any = {};
+__export(exports_any, {
+  McpbManifestSchema: () => McpbManifestSchema5
+});
+var McpbManifestSchema5;
+var init_any = __esm(() => {
+  init_zod();
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  McpbManifestSchema5 = unionType([
+    McpbManifestSchema,
+    McpbManifestSchema2,
+    McpbManifestSchema3,
+    McpbManifestSchema4
+  ]);
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/schemas/index.js
+var VERSIONED_MANIFEST_SCHEMAS;
+var init_schemas = __esm(() => {
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  init_any();
+  VERSIONED_MANIFEST_SCHEMAS = {
+    "0.1": McpbManifestSchema,
+    "0.2": McpbManifestSchema2,
+    "0.3": McpbManifestSchema3,
+    "0.4": McpbManifestSchema4
+  };
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/shared/common.js
+var McpbUserConfigValuesSchema, McpbSignatureInfoSchema;
+var init_common = __esm(() => {
+  init_zod();
+  McpbUserConfigValuesSchema = exports_external.record(exports_external.string(), exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean(), exports_external.array(exports_external.string())]));
+  McpbSignatureInfoSchema = exports_external.strictObject({
+    status: exports_external.enum(["signed", "unsigned", "self-signed"]),
+    publisher: exports_external.string().optional(),
+    issuer: exports_external.string().optional(),
+    valid_from: exports_external.string().optional(),
+    valid_to: exports_external.string().optional(),
+    fingerprint: exports_external.string().optional()
+  });
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/shared/config.js
+function replaceVariables(value, variables) {
+  if (typeof value === "string") {
+    let result = value;
+    for (const [key, replacement] of Object.entries(variables)) {
+      const pattern = new RegExp(`\\$\\{${key}\\}`, "g");
+      if (result.match(pattern)) {
+        if (Array.isArray(replacement)) {
+          console.warn(`Cannot replace ${key} with array value in string context: "${value}"`, { key, replacement });
+        } else {
+          result = result.replace(pattern, replacement);
+        }
+      }
+    }
+    return result;
+  } else if (Array.isArray(value)) {
+    const result = [];
+    for (const item of value) {
+      if (typeof item === "string" && item.match(/^\$\{user_config\.[^}]+\}$/)) {
+        const varName = item.match(/^\$\{([^}]+)\}$/)?.[1];
+        if (varName && variables[varName]) {
+          const replacement = variables[varName];
+          if (Array.isArray(replacement)) {
+            result.push(...replacement);
+          } else {
+            result.push(replacement);
+          }
+        } else {
+          result.push(item);
+        }
+      } else {
+        result.push(replaceVariables(item, variables));
+      }
+    }
+    return result;
+  } else if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = replaceVariables(val, variables);
+    }
+    return result;
+  }
+  return value;
+}
+async function getMcpConfigForManifest(options) {
+  const { manifest, extensionPath, systemDirs, userConfig, pathSeparator, logger } = options;
+  const baseConfig = manifest.server?.mcp_config;
+  if (!baseConfig) {
+    return;
+  }
+  let result = {
+    ...baseConfig
+  };
+  if (baseConfig.platform_overrides) {
+    if (process.platform in baseConfig.platform_overrides) {
+      const platformConfig = baseConfig.platform_overrides[process.platform];
+      result.command = platformConfig.command || result.command;
+      result.args = platformConfig.args || result.args;
+      result.env = platformConfig.env || result.env;
+    }
+  }
+  if (hasRequiredConfigMissing({ manifest, userConfig })) {
+    logger?.warn(`Extension ${manifest.name} has missing required configuration, skipping MCP config`);
+    return;
+  }
+  const variables = {
+    __dirname: extensionPath,
+    pathSeparator,
+    "/": pathSeparator,
+    ...systemDirs
+  };
+  const mergedConfig = {};
+  if (manifest.user_config) {
+    for (const [key, configOption] of Object.entries(manifest.user_config)) {
+      if (configOption.default !== undefined) {
+        mergedConfig[key] = configOption.default;
+      }
+    }
+  }
+  if (userConfig) {
+    Object.assign(mergedConfig, userConfig);
+  }
+  for (const [key, value] of Object.entries(mergedConfig)) {
+    const userConfigKey = `user_config.${key}`;
+    if (Array.isArray(value)) {
+      variables[userConfigKey] = value.map(String);
+    } else if (typeof value === "boolean") {
+      variables[userConfigKey] = value ? "true" : "false";
+    } else {
+      variables[userConfigKey] = String(value);
+    }
+  }
+  result = replaceVariables(result, variables);
+  return result;
+}
+function isInvalidSingleValue(value) {
+  return value === undefined || value === null || value === "";
+}
+function hasRequiredConfigMissing({ manifest, userConfig }) {
+  if (!manifest.user_config) {
+    return false;
+  }
+  const config = userConfig || {};
+  for (const [key, configOption] of Object.entries(manifest.user_config)) {
+    if (configOption.required) {
+      const value = config[key];
+      if (isInvalidSingleValue(value) || Array.isArray(value) && (value.length === 0 || value.some(isInvalidSingleValue))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var init_config = () => {};
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/types.js
+var init_types = () => {};
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/index.js
+var init_dist = __esm(() => {
+  init_init();
+  init_pack();
+  init_unpack();
+  init_files();
+  init_sign();
+  init_validate();
+  init_schemas();
+  init_common();
+  init_config();
+  init_constants();
+  init_types();
+});
+init_dist();
+
+export {
+  verifyMcpbFile,
+  verifyCertificateChain,
+  validateManifest,
+  exports_any as vAny,
+  exports_0_4 as v0_4,
+  exports_0_3 as v0_3,
+  exports_0_2 as v0_2,
+  exports_0_1 as v0_1,
+  unsignMcpbFile,
+  unpackExtension,
+  signMcpbFile,
+  shouldExclude,
+  replaceVariables,
+  readPackageJson,
+  readMcpbIgnorePatterns,
+  promptVisualAssets,
+  promptUserConfig,
+  promptUrls,
+  promptTools,
+  promptServerConfig,
+  promptPrompts,
+  promptOptionalFields,
+  promptLongDescription,
+  promptLocalization,
+  promptCompatibility,
+  promptBasicInfo,
+  promptAuthorInfo,
+  printNextSteps,
+  packExtension,
+  initExtension,
+  hasRequiredConfigMissing,
+  getMcpConfigForManifest,
+  getDefaultServerConfig,
+  getDefaultRepositoryUrl,
+  getDefaultOptionalFields,
+  getDefaultEntryPoint,
+  getDefaultBasicInfo,
+  getDefaultAuthorUrl,
+  getDefaultAuthorName,
+  getDefaultAuthorInfo,
+  getDefaultAuthorEmail,
+  getAllFilesWithCount,
+  getAllFiles,
+  extractSignatureBlock,
+  createMcpConfig,
+  cleanMcpb,
+  buildManifest,
+  VERSIONED_MANIFEST_SCHEMAS,
+  McpbUserConfigValuesSchema,
+  McpbSignatureInfoSchema,
+  MANIFEST_SCHEMAS_LOOSE,
+  MANIFEST_SCHEMAS,
+  LATEST_MANIFEST_VERSION,
+  EXCLUDE_PATTERNS,
+  DEFAULT_MANIFEST_VERSION
+};

package/dist/chunk-fzhn8z8j.js

@@ -0,0 +1,253 @@
+// @bun
+import {
+  detectAndUninstallDelistedPlugins
+} from "./chunk-rwhswkma.js";
+import {
+  getFlaggedPlugins,
+  init_pluginFlagging
+} from "./chunk-bsa118r4.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-hknbjky3.js";
+import {
+  count,
+  init_array
+} from "./chunk-1cwdhk7a.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-36b2q5fg.js";
+import {
+  init_log,
+  logError
+} from "./chunk-y3r7v9pq.js";
+import {
+  init_debug,
+  init_errors,
+  logForDebugging,
+  toError
+} from "./chunk-404qm8xt.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 };