@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-30rst83v.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  require_dist_cjs
+} from "./chunk-xsq9ae7x.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+protocol-http@5.3.12/node_modules/@smithy/protocol-http/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var types = require_dist_cjs();
+  var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
+    return {
+      setHttpHandler(handler) {
+        runtimeConfig.httpHandler = handler;
+      },
+      httpHandler() {
+        return runtimeConfig.httpHandler;
+      },
+      updateHttpClientConfig(key, value) {
+        runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+      },
+      httpHandlerConfigs() {
+        return runtimeConfig.httpHandler.httpHandlerConfigs();
+      }
+    };
+  };
+  var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
+    return {
+      httpHandler: httpHandlerExtensionConfiguration.httpHandler()
+    };
+  };
+
+  class Field {
+    name;
+    kind;
+    values;
+    constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
+      this.name = name;
+      this.kind = kind;
+      this.values = values;
+    }
+    add(value) {
+      this.values.push(value);
+    }
+    set(values) {
+      this.values = values;
+    }
+    remove(value) {
+      this.values = this.values.filter((v) => v !== value);
+    }
+    toString() {
+      return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
+    }
+    get() {
+      return this.values;
+    }
+  }
+
+  class Fields {
+    entries = {};
+    encoding;
+    constructor({ fields = [], encoding = "utf-8" }) {
+      fields.forEach(this.setField.bind(this));
+      this.encoding = encoding;
+    }
+    setField(field) {
+      this.entries[field.name.toLowerCase()] = field;
+    }
+    getField(name) {
+      return this.entries[name.toLowerCase()];
+    }
+    removeField(name) {
+      delete this.entries[name.toLowerCase()];
+    }
+    getByType(kind) {
+      return Object.values(this.entries).filter((field) => field.kind === kind);
+    }
+  }
+
+  class HttpRequest {
+    method;
+    protocol;
+    hostname;
+    port;
+    path;
+    query;
+    headers;
+    username;
+    password;
+    fragment;
+    body;
+    constructor(options) {
+      this.method = options.method || "GET";
+      this.hostname = options.hostname || "localhost";
+      this.port = options.port;
+      this.query = options.query || {};
+      this.headers = options.headers || {};
+      this.body = options.body;
+      this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+      this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+      this.username = options.username;
+      this.password = options.password;
+      this.fragment = options.fragment;
+    }
+    static clone(request) {
+      const cloned = new HttpRequest({
+        ...request,
+        headers: { ...request.headers }
+      });
+      if (cloned.query) {
+        cloned.query = cloneQuery(cloned.query);
+      }
+      return cloned;
+    }
+    static isInstance(request) {
+      if (!request) {
+        return false;
+      }
+      const req = request;
+      return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+    }
+    clone() {
+      return HttpRequest.clone(this);
+    }
+  }
+  function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+      const param = query[paramName];
+      return {
+        ...carry,
+        [paramName]: Array.isArray(param) ? [...param] : param
+      };
+    }, {});
+  }
+
+  class HttpResponse {
+    statusCode;
+    reason;
+    headers;
+    body;
+    constructor(options) {
+      this.statusCode = options.statusCode;
+      this.reason = options.reason;
+      this.headers = options.headers || {};
+      this.body = options.body;
+    }
+    static isInstance(response) {
+      if (!response)
+        return false;
+      const resp = response;
+      return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+  }
+  function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+  }
+  exports.Field = Field;
+  exports.Fields = Fields;
+  exports.HttpRequest = HttpRequest;
+  exports.HttpResponse = HttpResponse;
+  exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
+  exports.isValidHostname = isValidHostname;
+  exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
+});
+
+export { require_dist_cjs2 as require_dist_cjs };

package/dist/chunk-328dhq0p.js

@@ -0,0 +1,208 @@
+// @bun
+import {
+  SETTING_SOURCE_TO_SCOPE,
+  cacheAndRegisterPlugin,
+  getAddDirEnabledPlugins,
+  getInMemoryInstalledPlugins,
+  getPluginById,
+  init_addDirPluginSettings,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  init_pluginInstallationHelpers,
+  migrateFromEnabledPlugins,
+  registerPluginInstallation,
+  scopeToSettingSource
+} from "./chunk-5eecpt8g.js";
+import {
+  getInitialSettings,
+  getSettingsForSource,
+  init_schemas,
+  init_settings1 as init_settings,
+  isLocalPluginSource,
+  updateSettingsForSource
+} from "./chunk-hgba8zda.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginStartupCheck.ts
+import { join } from "path";
+async function checkEnabledPlugins() {
+  const settings = getInitialSettings();
+  const enabledPlugins = [];
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (pluginId.includes("@") && value) {
+      enabledPlugins.push(pluginId);
+    }
+  }
+  if (settings.enabledPlugins) {
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      const idx = enabledPlugins.indexOf(pluginId);
+      if (value) {
+        if (idx === -1) {
+          enabledPlugins.push(pluginId);
+        }
+      } else {
+        if (idx !== -1) {
+          enabledPlugins.splice(idx, 1);
+        }
+      }
+    }
+  }
+  return enabledPlugins;
+}
+function getPluginEditableScopes() {
+  const result = new Map;
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (!pluginId.includes("@")) {
+      continue;
+    }
+    if (value === true) {
+      result.set(pluginId, "flag");
+    } else if (value === false) {
+      result.delete(pluginId);
+    }
+  }
+  const scopeSources = [
+    { scope: "managed", source: "policySettings" },
+    { scope: "user", source: "userSettings" },
+    { scope: "project", source: "projectSettings" },
+    { scope: "local", source: "localSettings" },
+    { scope: "flag", source: "flagSettings" }
+  ];
+  for (const { scope, source } of scopeSources) {
+    const settings = getSettingsForSource(source);
+    if (!settings?.enabledPlugins) {
+      continue;
+    }
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      if (pluginId in addDirPlugins && addDirPlugins[pluginId] !== value) {
+        logForDebugging(`Plugin ${pluginId} from --add-dir (${addDirPlugins[pluginId]}) overridden by ${source} (${value})`);
+      }
+      if (value === true) {
+        result.set(pluginId, scope);
+      } else if (value === false) {
+        result.delete(pluginId);
+      }
+    }
+  }
+  logForDebugging(`Found ${result.size} enabled plugins with scopes: ${Array.from(result.entries()).map(([id, scope]) => `${id}(${scope})`).join(", ")}`);
+  return result;
+}
+function isPersistableScope(scope) {
+  return scope !== "flag";
+}
+function settingSourceToScope(source) {
+  return SETTING_SOURCE_TO_SCOPE[source];
+}
+async function getInstalledPlugins() {
+  migrateFromEnabledPlugins().catch((error) => {
+    logError(error);
+  });
+  const v2Data = getInMemoryInstalledPlugins();
+  const installed = Object.keys(v2Data.plugins);
+  logForDebugging(`Found ${installed.length} installed plugins`);
+  return installed;
+}
+async function findMissingPlugins(enabledPlugins) {
+  try {
+    const installedPlugins = await getInstalledPlugins();
+    const notInstalled = enabledPlugins.filter((id) => !installedPlugins.includes(id));
+    const lookups = await Promise.all(notInstalled.map(async (pluginId) => {
+      try {
+        const plugin = await getPluginById(pluginId);
+        return { pluginId, found: plugin !== null && plugin !== undefined };
+      } catch (error) {
+        logForDebugging(`Failed to check plugin ${pluginId} in marketplace: ${error}`);
+        return { pluginId, found: false };
+      }
+    }));
+    const missing = lookups.filter(({ found }) => found).map(({ pluginId }) => pluginId);
+    return missing;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function installSelectedPlugins(pluginsToInstall, onProgress, scope = "user") {
+  const projectPath = scope !== "user" ? getCwd() : undefined;
+  const settingSource = scopeToSettingSource(scope);
+  const settings = getSettingsForSource(settingSource);
+  const updatedEnabledPlugins = { ...settings?.enabledPlugins };
+  const installed = [];
+  const failed = [];
+  for (let i = 0;i < pluginsToInstall.length; i++) {
+    const pluginId = pluginsToInstall[i];
+    if (!pluginId)
+      continue;
+    if (onProgress) {
+      onProgress(pluginId, i + 1, pluginsToInstall.length);
+    }
+    try {
+      const pluginInfo = await getPluginById(pluginId);
+      if (!pluginInfo) {
+        failed.push({
+          name: pluginId,
+          error: "Plugin not found in any marketplace"
+        });
+        continue;
+      }
+      const { entry, marketplaceInstallLocation } = pluginInfo;
+      if (!isLocalPluginSource(entry.source)) {
+        await cacheAndRegisterPlugin(pluginId, entry, scope, projectPath);
+      } else {
+        registerPluginInstallation({
+          pluginId,
+          installPath: join(marketplaceInstallLocation, entry.source),
+          version: entry.version
+        }, scope, projectPath);
+      }
+      updatedEnabledPlugins[pluginId] = true;
+      installed.push(pluginId);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      failed.push({ name: pluginId, error: errorMessage });
+      logError(error);
+    }
+  }
+  updateSettingsForSource(settingSource, {
+    ...settings,
+    enabledPlugins: updatedEnabledPlugins
+  });
+  return { installed, failed };
+}
+var init_pluginStartupCheck = __esm(() => {
+  init_cwd();
+  init_debug();
+  init_log();
+  init_settings();
+  init_addDirPluginSettings();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_pluginInstallationHelpers();
+  init_schemas();
+});
+
+export { checkEnabledPlugins, getPluginEditableScopes, isPersistableScope, settingSourceToScope, getInstalledPlugins, findMissingPlugins, installSelectedPlugins, init_pluginStartupCheck };

package/dist/chunk-32q1kp1y.js

@@ -0,0 +1,197 @@
+// @bun
+import {
+  ValidationErrorsList,
+  init_ValidationErrorsList
+} from "./chunk-b3r6mj2e.js";
+import {
+  Select,
+  init_CustomSelect
+} 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 {
+  Dialog,
+  init_Dialog
+} from "./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 {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-aa3rx320.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./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 {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/InvalidSettingsDialog.tsx
+init_ink();
+init_CustomSelect();
+init_Dialog();
+init_ValidationErrorsList();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function InvalidSettingsDialog(t0) {
+  const $ = import_compiler_runtime.c(13);
+  const {
+    settingsErrors,
+    onContinue,
+    onExit
+  } = t0;
+  let t1;
+  if ($[0] !== onContinue || $[1] !== onExit) {
+    t1 = function handleSelect2(value) {
+      if (value === "exit") {
+        onExit();
+      } else {
+        onContinue();
+      }
+    };
+    $[0] = onContinue;
+    $[1] = onExit;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handleSelect = t1;
+  let t2;
+  if ($[3] !== settingsErrors) {
+    t2 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ValidationErrorsList, {
+      errors: settingsErrors
+    }, undefined, false, undefined, this);
+    $[3] = settingsErrors;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: "Files with errors are skipped entirely, not just the invalid settings."
+    }, undefined, false, undefined, this);
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = [{
+      label: "Exit and fix manually",
+      value: "exit"
+    }, {
+      label: "Continue without these settings",
+      value: "continue"
+    }];
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== handleSelect) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+      options: t4,
+      onChange: handleSelect
+    }, undefined, false, undefined, this);
+    $[7] = handleSelect;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] !== onExit || $[10] !== t2 || $[11] !== t5) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Settings Error",
+      onCancel: onExit,
+      color: "warning",
+      children: [
+        t2,
+        t3,
+        t5
+      ]
+    }, undefined, true, undefined, this);
+    $[9] = onExit;
+    $[10] = t2;
+    $[11] = t5;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  return t6;
+}
+export {
+  InvalidSettingsDialog
+};