@cdxgen/cdxgen 13.1.0 → 13.3.0

package/lib/inventory/aiInventory.js

@@ -10,7 +10,9 @@ import {
 import { communityAiConfigParser } from "./communityAiConfigParser.js";
 import { mergeServices, trimComponents } from "./depsUtils.js";
 import { classifyMcpReference } from "./mcp.js";
+import { mcpbBundleParser } from "./mcpbBundle.js";
 import { mcpConfigParser } from "./mcpConfigParser.js";
+import { mcpServerManifestParser } from "./mcpServerManifest.js";
 
 /** Project types treated as AI-related inventory for collection and parsing. */
 export const AI_INVENTORY_PROJECT_TYPES = ["mcp", "ai-skill", "ai"];
@@ -64,6 +66,16 @@ const AI_INVENTORY_PARSERS = [
     parser: mcpConfigParser,
     types: ["mcp"],
   },
+  {
+    id: mcpServerManifestParser.id,
+    parser: mcpServerManifestParser,
+    types: ["mcp"],
+  },
+  {
+    id: mcpbBundleParser.id,
+    parser: mcpbBundleParser,
+    types: ["mcp"],
+  },
   {
     id: communityAiConfigParser.id,
     parser: communityAiConfigParser,

package/lib/inventory/analyzer.js

@@ -25,6 +25,23 @@ import {
 } from "./analyzerScope.js";
 import { classifyMcpReference } from "./mcp.js";
 import { isLocalHost, sanitizeMcpRefToken } from "./mcpDiscovery.js";
+import {
+  isPackageStyleUrlReference,
+  STYLE_PACKAGE_REFERENCE_PATTERNS,
+} from "./stylePackageRefs.js";
+import {
+  extractSvelteScriptLanguages,
+  extractSvelteStyleReferences,
+  findSvelteRunes,
+  getSvelteTemplateParser,
+  maskSvelteScripts,
+  parseSvelteConfigSource,
+  primeSvelteParser,
+  SVELTE_DEFAULT_LIB_ALIAS,
+  SVELTE_KIT_VIRTUAL_MODULE_PREFIXES,
+  SVELTE_SCRIPT_EXECUTABLE_PACKAGE_MAP,
+  SVELTE_STYLE_LANG_PACKAGES,
+} from "./svelteUtils.js";
 
 const IGNORE_DIRS = readEnvironmentVariable("ASTGEN_IGNORE_DIRS")
   ? readEnvironmentVariable("ASTGEN_IGNORE_DIRS").split(",")
@@ -53,7 +70,7 @@ const IGNORE_DIRS = readEnvironmentVariable("ASTGEN_IGNORE_DIRS")
 
 const IGNORE_FILE_PATTERN = new RegExp(
   readEnvironmentVariable("ASTGEN_IGNORE_FILE_PATTERN") ||
-    "(test|spec|mock|setup-jest|\\.d)\\.(js|ts|tsx)$|(?<!vite\\.|vue\\.)(conf|config)\\.(js|ts|tsx)$",
+    "(test|spec|mock|setup-jest|\\.d)\\.(js|ts|tsx)$|(?<!vite\\.|vue\\.|svelte\\.)(conf|config)\\.(js|ts|tsx)$",
   "i",
 );
 
@@ -327,7 +344,15 @@ const vueBindRegex = /(:\[)([\s\S]*?)(])/gi;
 
 const fileToParseableCode = (file) => {
   let code = readFileSync(file, "utf-8");
-  if (file.endsWith(".vue") || file.endsWith(".svelte")) {
+  if (file.endsWith(".svelte")) {
+    // Svelte components have no <template> element — markup sits at the top
+    // level — so the Vue blanking path would leave the raw Svelte markup in
+    // the Babel input. Mask everything outside the script bodies instead;
+    // the mask preserves offsets and newlines, so import line numbers stay
+    // true to the original file.
+    return maskSvelteScripts(code);
+  }
+  if (file.endsWith(".vue")) {
     code = code
       .replace(vueCommentRegex, (match) => match.replaceAll(/\S/g, " "))
       .replace(
@@ -355,6 +380,49 @@ const fileToParseableCode = (file) => {
   return code;
 };
 
+/**
+ * Read a file and produce its Babel `File` AST. `.svelte` components prefer
+ * the optional atom-parsetools template parser (which re-emits the markup as
+ * JSX with absolute offsets) and fall back to a Babel parse of the masked
+ * script buffer, both position-preserving. Every other extension goes through
+ * `fileToParseableCode` unchanged.
+ *
+ * @param {string} file Absolute file path.
+ * @returns {Object} Babel `File` AST.
+ */
+const parseSourceFileAST = (file) => {
+  if (!file.endsWith(".svelte")) {
+    return parse(fileToParseableCode(file), babelParserOptions);
+  }
+  const code = readFileSync(file, "utf-8");
+  const maskedSource = maskSvelteScripts(code);
+  const templateParser = getSvelteTemplateParser();
+  if (templateParser) {
+    try {
+      return templateParser.parseSvelteFile(file, code, babelParserOptions);
+    } catch (err) {
+      // A genuinely broken template must not abort the component: parse the
+      // masked script buffer, recording the template failure when the
+      // fallback entry point is available. If that also throws, fall through
+      // to the built-in mask parse below.
+      try {
+        if (typeof templateParser.parseSvelteScriptBuffer === "function") {
+          return templateParser.parseSvelteScriptBuffer(
+            file,
+            code,
+            maskedSource,
+            babelParserOptions,
+            err?.message || String(err),
+          );
+        }
+      } catch (_fallbackErr) {
+        // ignore — the tier 1 parse below is the last resort
+      }
+    }
+  }
+  return parse(maskedSource, babelParserOptions);
+};
+
 const isWasmPath = (modulePath) =>
   typeof modulePath === "string" && /\.wasm([?#].*)?$/i.test(modulePath);
 
@@ -414,11 +482,6 @@ const ANGULAR_WORKSPACE_PACKAGE_STRING_KEYS = new Set([
 
 const ANGULAR_STYLE_FILE_EXTENSIONS = [".css", ".less", ".sass", ".scss"];
 
-const ANGULAR_STYLE_REFERENCE_PATTERNS = [
-  /@(?:import|use|forward)\s+(?:url\(\s*)?['"]([^'"\n)]+)['"]/g,
-  /url\(\s*['"](~?[^'"\n)]+)['"]\s*\)/g,
-];
-
 const ANGULAR_CONFIG_EVIDENCE_FILE_NAMES = new Set([
   "karma.conf.js",
   "karma.conf.cjs",
@@ -626,16 +689,6 @@ const angularUrlRegex = /^[a-z][a-z0-9+.-]*:/i;
 const angularBareFileRegex =
   /^[\w.-]+\.(css|eot|gif|html|ico|jpeg|jpg|js|json|less|mjs|png|sass|scss|svg|ts|ttf|webp|woff|woff2)$/i;
 
-const isAngularStyleUrlPackageReference = (reference) => {
-  const normalizedReference = String(reference || "")
-    .trim()
-    .replaceAll("\\", "/");
-  return (
-    normalizedReference.startsWith("~") ||
-    normalizedReference.startsWith("node_modules/")
-  );
-};
-
 const stripAngularRouteFragment = (reference) =>
   String(reference || "")
     .split("#")[0]
@@ -770,19 +823,19 @@ const extractScriptSegmentExecutableName = (scriptSegment) => {
   };
 };
 
-const addAngularExecutablePackageRef = (
+const addScriptExecutablePackageRef = (
   allImports,
   allExports,
   src,
   file,
   executable,
+  executablePackageMap,
 ) => {
   const executableName = executable?.executableName;
   if (!executableName) {
     return;
   }
-  const packageName =
-    ANGULAR_SCRIPT_EXECUTABLE_PACKAGE_MAP[executableName.toLowerCase()];
+  const packageName = executablePackageMap[executableName.toLowerCase()];
   if (packageName) {
     setAngularPackageRef(
       allImports,
@@ -1103,7 +1156,7 @@ const getAssignmentTargetName = (astNode) => {
  * references for any import, require or dynamic import files.
  */
 const parseFileASTTree = (src, file, allImports, allExports) => {
-  const ast = parse(fileToParseableCode(file), babelParserOptions);
+  const ast = parseSourceFileAST(file);
   const wasmBufferByVarName = new Map();
   const wasmResultByVarName = new Map();
   const wasmInstanceByVarName = new Map();
@@ -2105,7 +2158,7 @@ const parseAngularStyleFiles = (
       } catch {
         continue;
       }
-      for (const referencePattern of ANGULAR_STYLE_REFERENCE_PATTERNS) {
+      for (const referencePattern of STYLE_PACKAGE_REFERENCE_PATTERNS) {
         for (const match of content.matchAll(referencePattern)) {
           const reference = match[1];
           if (!reference) {
@@ -2113,7 +2166,7 @@ const parseAngularStyleFiles = (
           }
           if (
             match[0]?.trim().startsWith("url") &&
-            !isAngularStyleUrlPackageReference(reference)
+            !isPackageStyleUrlReference(reference)
           ) {
             continue;
           }
@@ -2136,12 +2189,19 @@ const parseAngularStyleFiles = (
   }
 };
 
-const addAngularScriptPackageRefs = (
+/**
+ * Walk an npm script value's shell segments and attribute each leading
+ * executable to the npm package that provides it, using the given
+ * executable→package map plus the `cdx:npm:bin/` fallback for npx-style
+ * package hints. Shared by the Angular and Svelte script-evidence passes.
+ */
+const addScriptExecutableSegmentRefs = (
   allImports,
   allExports,
   src,
   file,
   scriptValue,
+  executablePackageMap,
 ) => {
   const script = String(scriptValue || "");
   if (!script) {
@@ -2153,14 +2213,33 @@ const addAngularScriptPackageRefs = (
     .filter(Boolean);
   for (const scriptSegment of scriptSegments) {
     const executable = extractScriptSegmentExecutableName(scriptSegment);
-    addAngularExecutablePackageRef(
+    addScriptExecutablePackageRef(
       allImports,
       allExports,
       src,
       file,
       executable,
+      executablePackageMap,
     );
   }
+};
+
+const addAngularScriptPackageRefs = (
+  allImports,
+  allExports,
+  src,
+  file,
+  scriptValue,
+) => {
+  addScriptExecutableSegmentRefs(
+    allImports,
+    allExports,
+    src,
+    file,
+    scriptValue,
+    ANGULAR_SCRIPT_EXECUTABLE_PACKAGE_MAP,
+  );
+  const script = String(scriptValue || "");
   for (const commandPackage of ANGULAR_SCRIPT_COMMAND_PACKAGES) {
     if (commandPackage.pattern.test(script)) {
       for (const packageName of commandPackage.packages) {
@@ -2953,7 +3032,7 @@ const parseVueConfigFiles = (
       if (!dataValue) {
         continue;
       }
-      for (const referencePattern of ANGULAR_STYLE_REFERENCE_PATTERNS) {
+      for (const referencePattern of STYLE_PACKAGE_REFERENCE_PATTERNS) {
         referencePattern.lastIndex = 0;
         for (const styleMatch of dataValue.matchAll(referencePattern)) {
           const reference = styleMatch[1];
@@ -2962,7 +3041,7 @@ const parseVueConfigFiles = (
           }
           if (
             styleMatch[0]?.trim().startsWith("url") &&
-            !isAngularStyleUrlPackageReference(reference)
+            !isPackageStyleUrlReference(reference)
           ) {
             continue;
           }
@@ -2980,6 +3059,363 @@ const parseVueConfigFiles = (
   }
 };
 
+// ---------------------------------------------------------------------------
+// Svelte / SvelteKit evidence
+// ---------------------------------------------------------------------------
+
+const SVELTE_CONFIG_FILE_NAMES = new Set([
+  "svelte.config.cjs",
+  "svelte.config.js",
+  "svelte.config.mjs",
+  "svelte.config.mts",
+  "svelte.config.ts",
+]);
+
+const SVELTE_RUNE_MODULE_EXTENSIONS = [".svelte.js", ".svelte.ts"];
+
+const getFilesByBaseNames = (
+  dir,
+  fileNames,
+  deep,
+  result = [],
+  rootDir = dir,
+  excludePatterns = [],
+  noIgnore = false,
+) => {
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return result;
+  }
+  for (const entry of files) {
+    if (!noIgnore && entry.startsWith(".")) {
+      continue;
+    }
+    const file = join(dir, entry);
+    let fileStat;
+    try {
+      fileStat = lstatSync(file);
+    } catch {
+      continue;
+    }
+    if (fileStat.isSymbolicLink()) {
+      continue;
+    }
+    if (
+      shouldExcludeAnalyzerPath(
+        rootDir,
+        file,
+        excludePatterns,
+        fileStat.isDirectory(),
+      )
+    ) {
+      continue;
+    }
+    if (fileStat.isDirectory()) {
+      const dirName = basename(file);
+      if (
+        !noIgnore &&
+        (dirName.startsWith("__") ||
+          IGNORE_DIRS.includes(dirName.toLowerCase()) ||
+          dirName === "node_modules")
+      ) {
+        continue;
+      }
+      if (deep) {
+        getFilesByBaseNames(
+          file,
+          fileNames,
+          deep,
+          result,
+          rootDir,
+          excludePatterns,
+          noIgnore,
+        );
+      }
+      continue;
+    }
+    if (fileNames.has(entry)) {
+      result.push(file);
+    }
+  }
+  return result;
+};
+
+const getLineColumnFromIndex = (content, index) => {
+  const clampedIndex = Math.max(
+    0,
+    Math.min(Number(index) || 0, String(content).length),
+  );
+  const prefix = content.slice(0, clampedIndex);
+  const prefixLines = prefix.split(/\r?\n/);
+  return {
+    column: prefixLines[prefixLines.length - 1].length,
+    line: prefixLines.length,
+  };
+};
+
+const hasSvelteComponentEvidence = (allImports) =>
+  Object.keys(allImports).some(
+    (importName) =>
+      importName === "svelte" ||
+      importName.startsWith("svelte/") ||
+      importName.startsWith("@sveltejs/"),
+  );
+
+/**
+ * Attribute framework usage recorded inside a Svelte component: the Svelte
+ * compiler itself (component presence plus rune usage), the CSS
+ * preprocessor required by `<style lang="…">`, packages referenced from
+ * style-block `@use`/`@import`/`url()` rules, and `typescript` for
+ * `<script lang="ts">`.
+ */
+const addSvelteComponentRefs = (allImports, allExports, src, file, content) => {
+  setSyntheticImportRef(allImports, allExports, src, file, "svelte", [], {
+    column: 0,
+    line: 1,
+  });
+  for (const styleBlock of extractSvelteStyleReferences(content)) {
+    const stylePackage = SVELTE_STYLE_LANG_PACKAGES[styleBlock.lang || ""];
+    if (stylePackage) {
+      setSyntheticImportRef(
+        allImports,
+        allExports,
+        src,
+        file,
+        stylePackage,
+        [],
+        getLineColumnFromIndex(content, styleBlock.start),
+      );
+    }
+    for (const styleReference of styleBlock.references) {
+      setAngularPackageRef(
+        allImports,
+        allExports,
+        src,
+        file,
+        styleReference.reference,
+        getLineColumnFromIndex(content, styleReference.index),
+      );
+    }
+  }
+  for (const scriptLang of extractSvelteScriptLanguages(content)) {
+    if (scriptLang === "ts" || scriptLang === "typescript") {
+      setSyntheticImportRef(
+        allImports,
+        allExports,
+        src,
+        file,
+        "typescript",
+        [],
+        { column: 0, line: 1 },
+      );
+    }
+  }
+  for (const rune of findSvelteRunes(content, true)) {
+    setSyntheticImportRef(
+      allImports,
+      allExports,
+      src,
+      file,
+      "svelte",
+      [],
+      getLineColumnFromIndex(content, rune.index),
+    );
+  }
+};
+
+const addSvelteConfigRefs = (allImports, allExports, src, file, facts) => {
+  // `adapter: "netlify"` names an adapter package without importing it; the
+  // imported form (`import adapter from "@sveltejs/adapter-node"`) is already
+  // collected by the regular config-file parse.
+  const adapterName = facts.adapterName;
+  if (adapterName) {
+    const packageName = adapterName.startsWith("@")
+      ? adapterName
+      : `@sveltejs/adapter-${adapterName}`;
+    setSyntheticImportRef(allImports, allExports, src, file, packageName, [], {
+      column: 0,
+      line: 1,
+    });
+  }
+};
+
+const normalizeSvelteAliasTarget = (aliasTarget) =>
+  String(aliasTarget || "")
+    .replaceAll("\\", "/")
+    .replace(/^\.\//, "")
+    .replace(/\/+$/, "");
+
+/**
+ * Re-key SvelteKit virtual modules and path aliases so they never surface as
+ * junk package names: `$app/*`, `$env/*`, and `$service-worker` become
+ * `@sveltejs/kit` evidence (the package that provides those modules), and
+ * `$lib/*` plus any configured `$alias/*` become relative file references.
+ * Original occurrences are kept, so file and line evidence survives.
+ */
+const reattributeSvelteKitModules = (allImports, _allExports, kitAliases) => {
+  const aliasEntries = Object.entries(kitAliases || {}).filter(([aliasKey]) =>
+    aliasKey.startsWith("$"),
+  );
+  for (const importKey of Object.keys(allImports)) {
+    const isVirtualModule = SVELTE_KIT_VIRTUAL_MODULE_PREFIXES.some(
+      (prefix) => importKey === prefix || importKey.startsWith(`${prefix}/`),
+    );
+    const aliasEntry = aliasEntries.find(
+      ([aliasKey]) =>
+        importKey === aliasKey || importKey.startsWith(`${aliasKey}/`),
+    );
+    if (!isVirtualModule && !aliasEntry) {
+      continue;
+    }
+    const occurrences = allImports[importKey] || [];
+    const targetKey = isVirtualModule
+      ? "@sveltejs/kit"
+      : aliasEntry
+        ? importKey === aliasEntry[0]
+          ? normalizeSvelteAliasTarget(aliasEntry[1])
+          : `${normalizeSvelteAliasTarget(aliasEntry[1])}/${importKey.slice(aliasEntry[0].length + 1)}`
+        : undefined;
+    if (!targetKey) {
+      delete allImports[importKey];
+      continue;
+    }
+    allImports[targetKey] = allImports[targetKey] || new Set();
+    for (const occurrence of occurrences) {
+      if (isVirtualModule) {
+        allImports[targetKey].add(occurrence);
+      } else {
+        // A path alias resolves inside the project, never to a package.
+        allImports[targetKey].add({
+          ...occurrence,
+          importedAs: importKey,
+          isExternal: false,
+        });
+      }
+    }
+    delete allImports[importKey];
+  }
+};
+
+/**
+ * Collect Svelte framework evidence after the main parse fan-out: component
+ * facts (runes, style/script languages, style package references),
+ * `svelte.config.*` facts (string-form adapter, `kit.alias`), npm script
+ * executables (`svelte-kit sync`, `svelte-check`, ...), and re-attribution
+ * of SvelteKit virtual modules. Returns the resolved alias map (or undefined
+ * when the project shows no Svelte evidence at all).
+ *
+ * `srcFiles` is the file list the parse fan-out already walked, so the Svelte
+ * pass costs no extra directory traversal on projects that turn out not to be
+ * Svelte projects at all.
+ */
+const parseSvelteEvidenceFiles = (
+  src,
+  allImports,
+  allExports,
+  searchOptions,
+  srcFiles,
+) => {
+  const componentFiles = [];
+  const runeModuleFiles = [];
+  for (const srcFile of srcFiles || []) {
+    if (srcFile.endsWith(".svelte")) {
+      componentFiles.push(srcFile);
+    } else if (
+      SVELTE_RUNE_MODULE_EXTENSIONS.some((extension) =>
+        srcFile.endsWith(extension),
+      )
+    ) {
+      runeModuleFiles.push(srcFile);
+    }
+  }
+  if (
+    !componentFiles.length &&
+    !runeModuleFiles.length &&
+    !hasSvelteComponentEvidence(allImports)
+  ) {
+    return undefined;
+  }
+  for (const componentFile of componentFiles) {
+    let content;
+    try {
+      content = readFileSync(componentFile, "utf-8");
+    } catch {
+      continue;
+    }
+    addSvelteComponentRefs(allImports, allExports, src, componentFile, content);
+  }
+  for (const runeModuleFile of runeModuleFiles) {
+    let content;
+    try {
+      content = readFileSync(runeModuleFile, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const rune of findSvelteRunes(content, false)) {
+      setSyntheticImportRef(
+        allImports,
+        allExports,
+        src,
+        runeModuleFile,
+        "svelte",
+        [],
+        getLineColumnFromIndex(content, rune.index),
+      );
+    }
+  }
+  const configAndManifestFiles = getFilesByBaseNames(
+    src,
+    new Set([...SVELTE_CONFIG_FILE_NAMES, "package.json"]),
+    searchOptions.deep,
+    [],
+    src,
+    searchOptions.exclude,
+    searchOptions.noIgnore,
+  );
+  const kitAliases = {};
+  for (const evidenceFile of configAndManifestFiles) {
+    const evidenceFileName = basename(evidenceFile);
+    let content;
+    try {
+      content = readFileSync(evidenceFile, "utf-8");
+    } catch {
+      continue;
+    }
+    if (SVELTE_CONFIG_FILE_NAMES.has(evidenceFileName)) {
+      const facts = parseSvelteConfigSource(content);
+      addSvelteConfigRefs(allImports, allExports, src, evidenceFile, facts);
+      Object.assign(kitAliases, facts.aliases);
+    } else {
+      let packageJson;
+      try {
+        packageJson = JSON.parse(content);
+      } catch {
+        continue;
+      }
+      if (!packageJson?.scripts || typeof packageJson.scripts !== "object") {
+        continue;
+      }
+      for (const scriptValue of Object.values(packageJson.scripts)) {
+        addScriptExecutableSegmentRefs(
+          allImports,
+          allExports,
+          src,
+          evidenceFile,
+          scriptValue,
+          SVELTE_SCRIPT_EXECUTABLE_PACKAGE_MAP,
+        );
+      }
+    }
+  }
+  if (!kitAliases.$lib) {
+    kitAliases.$lib = SVELTE_DEFAULT_LIB_ALIAS;
+  }
+  reattributeSvelteKitModules(allImports, allExports, kitAliases);
+  return kitAliases;
+};
+
 /**
  * Total source volume, in bytes, below which the file walk stays on the calling
  * thread even when the file count would allow threads.
@@ -3037,6 +3473,11 @@ export const findJSImportsExports = async (src, deep) => {
   const allExports = {};
   try {
     const searchOptions = normalizeAnalyzerSearchOptions(deep);
+    // Resolve the optional Svelte template parser before the fan-out so the
+    // inline path can use it; worker threads resolve it lazily at module
+    // scope of astWorker.js. Absence is silent — tier 1 covers all scope
+    // evidence.
+    await primeSvelteParser();
     const promiseMap = await getAllSrcJSAndTSFiles(src, deep);
     const srcFiles = promiseMap.flat();
     const tasks = srcFiles.map((file) => ({ src, file }));
@@ -3119,6 +3560,13 @@ export const findJSImportsExports = async (src, deep) => {
       searchOptions.exclude,
       searchOptions.noIgnore,
     );
+    parseSvelteEvidenceFiles(
+      src,
+      allImports,
+      allExports,
+      searchOptions,
+      srcFiles,
+    );
     return { allImports, allExports };
   } catch (_err) {
     return { allImports, allExports };
@@ -4229,7 +4677,7 @@ export const detectExtensionCapabilities = (src, deep = false) => {
   };
   for (const file of srcFiles) {
     try {
-      const ast = parse(fileToParseableCode(file), babelParserOptions);
+      const ast = parseSourceFileAST(file);
       traverse(ast, {
         MemberExpression: (path) => {
           addSignal(getMemberChainString(path?.node));
@@ -4276,6 +4724,7 @@ const MCP_STDIO_TRANSPORT_NAMES = new Set(["StdioServerTransport"]);
 const MCP_HTTP_TRANSPORT_NAMES = new Set([
   "NodeStreamableHTTPServerTransport",
   "StreamableHTTPServerTransport",
+  "WebStandardsStreamableHTTPServerTransport",
 ]);
 const MCP_STDIO_CLIENT_TRANSPORT_NAMES = new Set(["StdioClientTransport"]);
 const MCP_HTTP_CLIENT_TRANSPORT_NAMES = new Set([
@@ -4289,7 +4738,7 @@ const MCP_AUTH_HELPERS = new Set([
   "createProtectedResourceMetadataRouter",
   "setupAuthServer",
 ]);
-const MCP_APP_FACTORIES = new Set(["createMcpExpressApp"]);
+const MCP_APP_FACTORIES = new Set(["createMcpExpressApp", "createMcpHandler"]);
 const MCP_CLIENT_CONSTRUCTOR_NAMES = new Set([
   "Client",
   "MCPClient",
@@ -4345,6 +4794,15 @@ const MCP_PROVIDER_HOST_PATTERNS = [
   ["deepseek", /(?:^|\.)deepseek\.com$/i],
   ["ollama", /(?:^|\.)ollama\.com$/i],
   ["groq", /(?:^|\.)groq\.com$/i],
+  ["xai", /(?:^|\.)x\.ai$/i],
+  [
+    "aws-bedrock",
+    /(?:^|\.)bedrock(?:-runtime)?(?:\.[a-z0-9-]+)?\.amazonaws\.com$/i,
+  ],
+  ["openrouter", /(?:^|\.)openrouter\.ai$/i],
+  ["cerebras", /(?:^|\.)api\.cerebras\.ai$/i],
+  ["dashscope", /(?:^|\.)dashscope(?:-intl)?\.aliyuncs\.com$/i],
+  ["nvidia-nim", /(?:^|\.)integrate\.api\.nvidia\.com$/i],
 ];
 
 const providerFamilyFromImportSource = (sourceValue) => {
@@ -5447,7 +5905,7 @@ export const detectMcpInventory = (src, deep = false) => {
     const authMetadataByAlias = new Map();
     let fileHasMcpImports = false;
     try {
-      const ast = parse(fileToParseableCode(file), babelParserOptions);
+      const ast = parseSourceFileAST(file);
       traverse(ast, {
         ImportDeclaration: (path) => {
           const sourceValue = getLiteralStringValue(path?.node?.source);