autohand-cli 0.7.7 → 0.7.9

package/dist/chunk-NTFNUTY2.js

@@ -0,0 +1,589 @@
+import {
+  saveConfig
+} from "./chunk-K6CZ2AGI.js";
+import {
+  showModal,
+  showPassword
+} from "./chunk-6SM6N7DJ.js";
+
+// src/commands/search.ts
+import chalk from "chalk";
+
+// src/actions/web.ts
+import * as https from "https";
+import * as http from "http";
+var globalSearchConfig = {
+  provider: "duckduckgo"
+};
+function configureSearch(config) {
+  globalSearchConfig = { ...globalSearchConfig, ...config };
+}
+function getSearchConfig() {
+  return { ...globalSearchConfig };
+}
+async function simpleFetch(url, options = {}) {
+  const timeout = options.timeout ?? 1e4;
+  const maxLength = options.maxLength ?? 5e4;
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === "https:" ? https : http;
+    const req = protocol.get(url, {
+      timeout,
+      headers: {
+        "User-Agent": "Autohand-CLI/1.0 (https://autohand.ai)",
+        "Accept": "text/html,application/json,text/plain,*/*",
+        "Accept-Language": "en-US,en;q=0.9"
+      }
+    }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        simpleFetch(res.headers.location, options).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+        if (data.length > maxLength) {
+          res.destroy();
+          resolve(data.slice(0, maxLength) + "\n... (truncated)");
+        }
+      });
+      res.on("end", () => resolve(data));
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+function htmlToText(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<(\/?(p|div|br|h[1-6]|li|tr|td|th|blockquote|pre|hr))[^>]*>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&[a-z]+;/gi, "").replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function webSearch(query, options = {}) {
+  const maxResults = options.maxResults ?? 5;
+  const searchType = options.searchType ?? "general";
+  let enhancedQuery = query;
+  switch (searchType) {
+    case "packages":
+      enhancedQuery = `${query} npm package OR pypi package site:npmjs.com OR site:pypi.org`;
+      break;
+    case "docs":
+      enhancedQuery = `${query} documentation OR docs OR guide`;
+      break;
+    case "changelog":
+      enhancedQuery = `${query} changelog OR release notes OR what's new`;
+      break;
+  }
+  const provider = options.provider ?? globalSearchConfig.provider;
+  const braveApiKey = globalSearchConfig.braveApiKey ?? process.env.BRAVE_SEARCH_API_KEY;
+  const parallelApiKey = globalSearchConfig.parallelApiKey ?? process.env.PARALLEL_API_KEY;
+  switch (provider) {
+    case "brave":
+      if (!braveApiKey) {
+        throw new Error(
+          "Brave Search requires an API key. Configure it with /search or set BRAVE_SEARCH_API_KEY environment variable. Get a free API key at: https://brave.com/search/api/"
+        );
+      }
+      return braveSearch(enhancedQuery, braveApiKey, maxResults);
+    case "parallel":
+      if (!parallelApiKey) {
+        throw new Error(
+          "Parallel.ai Search requires an API key. Configure it with /search or set PARALLEL_API_KEY environment variable. Get an API key at: https://platform.parallel.ai"
+        );
+      }
+      return parallelSearch(enhancedQuery, parallelApiKey, maxResults);
+    case "duckduckgo":
+    default:
+      return duckduckgoSearch(enhancedQuery, maxResults);
+  }
+}
+async function duckduckgoSearch(query, maxResults) {
+  try {
+    const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const html = await simpleFetch(searchUrl, { timeout: 15e3, maxLength: 1e5 });
+    if (html.includes("anomaly-modal") || html.includes("bots use DuckDuckGo") || html.includes("cc=botnet")) {
+      throw new Error(
+        "DuckDuckGo blocked this search with a CAPTCHA challenge. Configure a different search provider with /search command. Options: brave (https://brave.com/search/api/) or parallel (https://platform.parallel.ai)"
+      );
+    }
+    const results = [];
+    const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([^<]*)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([^<]*(?:<[^>]+>[^<]*)*)<\/a>/gi;
+    let match;
+    while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+      const url = match[1];
+      const title = match[2].trim();
+      const snippet = htmlToText(match[3]).slice(0, 300);
+      if (url && title && !url.includes("duckduckgo.com")) {
+        results.push({ title, url, snippet });
+      }
+    }
+    if (results.length === 0) {
+      const altRegex = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*>([^<]+)<\/a>/gi;
+      while ((match = altRegex.exec(html)) !== null && results.length < maxResults) {
+        const url = match[1];
+        const title = match[2].trim();
+        if (url && title && !url.includes("duckduckgo.com") && title.length > 5) {
+          results.push({ title, url, snippet: "" });
+        }
+      }
+    }
+    if (results.length === 0) {
+      throw new Error(
+        "No search results found. DuckDuckGo may be rate-limiting requests. Configure a different search provider with /search command."
+      );
+    }
+    return results;
+  } catch (error) {
+    throw new Error(`DuckDuckGo search failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function parallelSearch(query, apiKey, maxResults) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify({
+      objective: query,
+      search_queries: [query],
+      max_results: maxResults,
+      excerpts: {
+        max_chars_per_result: 500
+      }
+    });
+    const options = {
+      hostname: "api.parallel.ai",
+      port: 443,
+      path: "/v1beta/search",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+        "x-api-key": apiKey,
+        "parallel-beta": "search-extract-2025-10-10"
+      }
+    };
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 400) {
+          reject(new Error(`Parallel.ai API error: HTTP ${res.statusCode} - ${data}`));
+          return;
+        }
+        try {
+          const json = JSON.parse(data);
+          const results = [];
+          if (json.results && Array.isArray(json.results)) {
+            for (const result of json.results.slice(0, maxResults)) {
+              results.push({
+                title: result.title || result.url || "Untitled",
+                url: result.url || "",
+                snippet: result.excerpt || result.content?.slice(0, 300) || ""
+              });
+            }
+          } else if (json.search_results && Array.isArray(json.search_results)) {
+            for (const result of json.search_results.slice(0, maxResults)) {
+              results.push({
+                title: result.title || result.url || "Untitled",
+                url: result.url || "",
+                snippet: result.snippet || result.description || ""
+              });
+            }
+          }
+          resolve(results);
+        } catch (parseError) {
+          reject(new Error(`Failed to parse Parallel.ai response: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+        }
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Parallel.ai request timed out"));
+    });
+    req.write(postData);
+    req.end();
+  });
+}
+async function braveSearch(query, apiKey, maxResults) {
+  const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`;
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      headers: {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": apiKey
+      }
+    }, (res) => {
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`Brave Search API error: HTTP ${res.statusCode}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (json.web?.results) {
+            const results = json.web.results.slice(0, maxResults).map((r) => ({
+              title: r.title || "",
+              url: r.url || "",
+              snippet: r.description || ""
+            }));
+            resolve(results);
+          } else {
+            resolve([]);
+          }
+        } catch (parseError) {
+          reject(new Error(`Failed to parse Brave Search response: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+        }
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Brave Search request timed out"));
+    });
+  });
+}
+async function fetchUrl(url, options = {}) {
+  const maxLength = options.maxLength ?? 3e4;
+  try {
+    const content = await simpleFetch(url, { timeout: 15e3, maxLength: maxLength * 2 });
+    if (content.trim().startsWith("{") || content.trim().startsWith("[")) {
+      try {
+        const json = JSON.parse(content);
+        return JSON.stringify(json, null, 2).slice(0, maxLength);
+      } catch {
+      }
+    }
+    const text = htmlToText(content);
+    return text.slice(0, maxLength);
+  } catch (error) {
+    throw new Error(`Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getNpmInfo(packageName, version) {
+  try {
+    const url = version ? `https://registry.npmjs.org/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}` : `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+    const content = await simpleFetch(url, { timeout: 1e4 });
+    const data = JSON.parse(content);
+    return {
+      registry: "npm",
+      name: data.name,
+      version: data.version,
+      description: data.description || "",
+      homepage: data.homepage,
+      repository: typeof data.repository === "string" ? data.repository : data.repository?.url,
+      license: data.license,
+      dependencies: data.dependencies,
+      keywords: data.keywords,
+      authors: data.maintainers?.map((m) => m.name || m.email)
+    };
+  } catch (error) {
+    throw new Error(`Failed to get npm info for ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getPyPIInfo(packageName, version) {
+  try {
+    const url = version ? `https://pypi.org/pypi/${encodeURIComponent(packageName)}/${encodeURIComponent(version)}/json` : `https://pypi.org/pypi/${encodeURIComponent(packageName)}/json`;
+    const content = await simpleFetch(url, { timeout: 1e4 });
+    const data = JSON.parse(content);
+    const info = data.info;
+    return {
+      registry: "pypi",
+      name: info.name,
+      version: info.version,
+      description: info.summary || "",
+      homepage: info.home_page || info.project_url,
+      repository: info.project_urls?.Repository || info.project_urls?.Source,
+      license: info.license,
+      dependencies: info.requires_dist?.reduce((acc, dep) => {
+        const [name] = dep.split(/[<>=!;\s]/);
+        acc[name] = dep;
+        return acc;
+      }, {}),
+      keywords: info.keywords?.split(",").map((k) => k.trim()).filter(Boolean),
+      authors: info.author ? [info.author] : []
+    };
+  } catch (error) {
+    throw new Error(`Failed to get PyPI info for ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getCargoInfo(packageName, version) {
+  try {
+    const url = `https://crates.io/api/v1/crates/${encodeURIComponent(packageName)}`;
+    const content = await simpleFetch(url, { timeout: 1e4 });
+    const data = JSON.parse(content);
+    const crate = data.crate;
+    const ver = version ? data.versions?.find((v) => v.num === version) : data.versions?.[0];
+    return {
+      registry: "crates",
+      name: crate.name,
+      version: ver?.num || crate.newest_version,
+      description: crate.description || "",
+      homepage: crate.homepage,
+      repository: crate.repository,
+      license: ver?.license,
+      keywords: crate.keywords,
+      authors: ver?.published_by?.name ? [ver.published_by.name] : []
+    };
+  } catch (error) {
+    throw new Error(`Failed to get Cargo info for ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getRubyGemsInfo(packageName, version) {
+  try {
+    const url = version ? `https://rubygems.org/api/v1/versions/${encodeURIComponent(packageName)}.json` : `https://rubygems.org/api/v1/gems/${encodeURIComponent(packageName)}.json`;
+    const content = await simpleFetch(url, { timeout: 1e4 });
+    const data = JSON.parse(content);
+    const gem = Array.isArray(data) ? data.find((v) => v.number === version) || data[0] : data;
+    return {
+      registry: "rubygems",
+      name: gem.name || packageName,
+      version: gem.version || gem.number,
+      description: gem.info || gem.summary || "",
+      homepage: gem.homepage_uri,
+      repository: gem.source_code_uri,
+      license: gem.licenses?.[0],
+      keywords: [],
+      authors: gem.authors ? [gem.authors] : []
+    };
+  } catch (error) {
+    throw new Error(`Failed to get RubyGems info for ${packageName}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getGoModuleInfo(modulePath, _version) {
+  try {
+    const url = `https://proxy.golang.org/${encodeURIComponent(modulePath)}/@latest`;
+    const content = await simpleFetch(url, { timeout: 1e4 });
+    const data = JSON.parse(content);
+    return {
+      registry: "go",
+      name: modulePath,
+      version: data.Version || "latest",
+      description: `Go module: ${modulePath}`,
+      homepage: `https://pkg.go.dev/${modulePath}`,
+      repository: modulePath.startsWith("github.com") ? `https://${modulePath}` : void 0,
+      license: void 0,
+      // Go proxy doesn't provide license info
+      keywords: [],
+      authors: []
+    };
+  } catch (error) {
+    throw new Error(`Failed to get Go module info for ${modulePath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getPackageInfo(packageName, options = {}) {
+  const registry = options.registry || detectRegistry(packageName);
+  switch (registry) {
+    case "npm":
+      return getNpmInfo(packageName, options.version);
+    case "pypi":
+      return getPyPIInfo(packageName, options.version);
+    case "crates":
+      return getCargoInfo(packageName, options.version);
+    case "rubygems":
+      return getRubyGemsInfo(packageName, options.version);
+    case "go":
+      return getGoModuleInfo(packageName, options.version);
+    default:
+      return getNpmInfo(packageName, options.version);
+  }
+}
+function detectRegistry(packageName) {
+  if (packageName.includes("/") && (packageName.startsWith("github.com/") || packageName.startsWith("golang.org/") || packageName.startsWith("google.golang.org/"))) {
+    return "go";
+  }
+  if (packageName.includes("_") && !packageName.startsWith("@")) {
+    return "crates";
+  }
+  return "npm";
+}
+function formatSearchResults(results) {
+  if (results.length === 0) {
+    return "No results found.";
+  }
+  return results.map((r, i) => {
+    const lines = [`${i + 1}. **${r.title}**`, `   ${r.url}`];
+    if (r.snippet) {
+      lines.push(`   ${r.snippet}`);
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function formatPackageInfo(info) {
+  const registryLabels = {
+    npm: "npm",
+    pypi: "PyPI",
+    crates: "crates.io",
+    maven: "Maven",
+    go: "Go",
+    rubygems: "RubyGems"
+  };
+  const lines = [
+    `**${info.name}** v${info.version} (${registryLabels[info.registry]})`,
+    "",
+    info.description || "No description",
+    ""
+  ];
+  if (info.homepage) {
+    lines.push(`Homepage: ${info.homepage}`);
+  }
+  if (info.repository) {
+    lines.push(`Repository: ${info.repository}`);
+  }
+  if (info.license) {
+    lines.push(`License: ${info.license}`);
+  }
+  if (info.keywords?.length) {
+    lines.push(`Keywords: ${info.keywords.join(", ")}`);
+  }
+  if (info.authors?.length) {
+    lines.push(`Authors: ${info.authors.join(", ")}`);
+  }
+  if (info.dependencies && Object.keys(info.dependencies).length > 0) {
+    lines.push("", "Dependencies:");
+    for (const [name, version] of Object.entries(info.dependencies).slice(0, 10)) {
+      lines.push(`  - ${name}: ${version}`);
+    }
+    if (Object.keys(info.dependencies).length > 10) {
+      lines.push(`  ... and ${Object.keys(info.dependencies).length - 10} more`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/search.ts
+async function search(ctx) {
+  const currentConfig = getSearchConfig();
+  const config = ctx.config;
+  console.log(chalk.bold("\nWeb Search Configuration\n"));
+  console.log(chalk.gray(`Current provider: ${chalk.cyan(currentConfig.provider)}`));
+  const braveKeySet = !!(currentConfig.braveApiKey || process.env.BRAVE_SEARCH_API_KEY);
+  const parallelKeySet = !!(currentConfig.parallelApiKey || process.env.PARALLEL_API_KEY);
+  console.log(chalk.gray(`Brave API key: ${braveKeySet ? chalk.green("configured") : chalk.yellow("not set")}`));
+  console.log(chalk.gray(`Parallel API key: ${parallelKeySet ? chalk.green("configured") : chalk.yellow("not set")}`));
+  console.log();
+  const providerOptions = [
+    {
+      label: `DuckDuckGo ${chalk.gray("(no API key required, may be blocked by CAPTCHA)")}`,
+      value: "duckduckgo"
+    },
+    {
+      label: `Brave Search ${chalk.gray("(requires API key)")} ${braveKeySet ? chalk.green("\u2713") : ""}`,
+      value: "brave"
+    },
+    {
+      label: `Parallel.ai ${chalk.gray("(requires API key)")} ${parallelKeySet ? chalk.green("\u2713") : ""}`,
+      value: "parallel"
+    }
+  ];
+  try {
+    const result = await showModal({
+      title: "Select search provider:",
+      options: providerOptions,
+      initialIndex: providerOptions.findIndex((c) => c.value === currentConfig.provider)
+    });
+    if (!result) {
+      console.log(chalk.gray("Search configuration cancelled."));
+      return null;
+    }
+    const provider = result.value;
+    let braveApiKey = currentConfig.braveApiKey;
+    let parallelApiKey = currentConfig.parallelApiKey;
+    if (provider === "brave" && !braveKeySet) {
+      console.log(chalk.gray("\nGet your free Brave Search API key at: https://brave.com/search/api/\n"));
+      const apiKey = await showPassword({
+        title: "Enter Brave Search API key:"
+      });
+      if (apiKey?.trim()) {
+        braveApiKey = apiKey.trim();
+      } else {
+        console.log(chalk.yellow("No API key entered. Brave Search will not work without an API key."));
+        return null;
+      }
+    }
+    if (provider === "parallel" && !parallelKeySet) {
+      console.log(chalk.gray("\nGet your Parallel.ai API key at: https://platform.parallel.ai\n"));
+      const apiKey = await showPassword({
+        title: "Enter Parallel.ai API key:"
+      });
+      if (apiKey?.trim()) {
+        parallelApiKey = apiKey.trim();
+      } else {
+        console.log(chalk.yellow("No API key entered. Parallel.ai Search will not work without an API key."));
+        return null;
+      }
+    }
+    configureSearch({
+      provider,
+      braveApiKey,
+      parallelApiKey
+    });
+    if (config) {
+      config.search = {
+        provider,
+        braveApiKey,
+        parallelApiKey
+      };
+      await saveConfig(config);
+      console.log(chalk.green(`
+\u2713 Search provider set to ${provider} and saved to config`));
+    } else {
+      console.log(chalk.green(`
+\u2713 Search provider set to ${provider} (session only)`));
+    }
+    switch (provider) {
+      case "duckduckgo":
+        console.log(chalk.gray("Note: DuckDuckGo may block automated requests with a CAPTCHA."));
+        break;
+      case "brave":
+        console.log(chalk.gray("Brave Search is now active. Free tier allows 2,000 queries/month."));
+        break;
+      case "parallel":
+        console.log(chalk.gray("Parallel.ai Search is now active with deep research capabilities."));
+        break;
+    }
+    return null;
+  } catch (error) {
+    throw error;
+  }
+}
+var metadata = {
+  command: "/search",
+  description: "configure web search provider (brave, duckduckgo, parallel)",
+  implemented: true
+};
+
+export {
+  configureSearch,
+  webSearch,
+  fetchUrl,
+  getPackageInfo,
+  formatSearchResults,
+  formatPackageInfo,
+  search,
+  metadata
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Web search and URL fetching capabilities for up-to-date information
+ * about packages, dependencies, documentation, and changelogs.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-GDTZQSJ6.cjs → chunk-O3EX3SAD.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkPMMSDR44cjs = require('./chunk-PMMSDR44.cjs');
+var _chunkAQNY2M6Qcjs = require('./chunk-AQNY2M6Q.cjs');
 
 // src/skills/CommunitySkillsCache.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
@@ -9,7 +9,7 @@ var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_MAX_SKILLS_CACHE = 50;
 var CommunitySkillsCache = class {
   constructor(config = {}) {
-    this.cacheDir = config.cacheDir || _path2.default.join(_chunkPMMSDR44cjs.AUTOHAND_HOME, "community-skills", "cache");
+    this.cacheDir = config.cacheDir || _path2.default.join(_chunkAQNY2M6Qcjs.AUTOHAND_HOME, "community-skills", "cache");
     this.ttlMs = _nullishCoalesce(config.ttlMs, () => ( DEFAULT_TTL_MS));
     this.maxSkillsCache = _nullishCoalesce(config.maxSkillsCache, () => ( DEFAULT_MAX_SKILLS_CACHE));
   }