@codacy/analysis-runner 0.10.1 → 0.12.0

package/dist/index.js

@@ -63,6 +63,7 @@ __export(index_exports, {
   readCodacyYaml: () => readCodacyYaml,
   registerAdapter: () => registerAdapter,
   registerLazyAdapter: () => registerLazyAdapter,
+  registerUnsupportedTool: () => registerUnsupportedTool,
   resolveConfigPath: () => resolveConfigPath,
   resolveEngineToAdapter: () => resolveEngineToAdapter,
   rotateLogFiles: () => rotateLogFiles,
@@ -75,7 +76,7 @@ module.exports = __toCommonJS(index_exports);
 // src/analyze.ts
 var import_os = __toESM(require("os"));
 var import_path3 = __toESM(require("path"));
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_util = require("util");
 var import_tooling3 = require("@codacy/tooling");
 
@@ -92,6 +93,9 @@ function registerAdapter(adapter) {
 function registerLazyAdapter(descriptor, factory) {
   entries.set(descriptor.id, { descriptor, factory });
 }
+function registerUnsupportedTool(descriptor) {
+  entries.set(descriptor.id, { descriptor });
+}
 function resolveEntry(input) {
   const exact = entries.get(input);
   if (exact) return exact;
@@ -103,15 +107,23 @@ function resolveEntry(input) {
 }
 async function loadAdapter(entry) {
   if (entry.resolved) return entry.resolved;
+  if (!entry.factory) {
+    throw new Error(
+      `Tool "${entry.descriptor.id}" is unsupported and has no local adapter to load`
+    );
+  }
   entry.resolved = await entry.factory();
   return entry.resolved;
 }
+function isLoadable(entry) {
+  return entry.factory !== void 0;
+}
 async function getRegisteredAdapters(toolIds) {
   if (toolIds && toolIds.length > 0) {
-    const matched = toolIds.map((id) => resolveEntry(id)).filter((e) => e !== void 0);
+    const matched = toolIds.map((id) => resolveEntry(id)).filter((e) => e !== void 0).filter(isLoadable);
     return Promise.all(matched.map(loadAdapter));
   }
-  return Promise.all(Array.from(entries.values()).map(loadAdapter));
+  return Promise.all(Array.from(entries.values()).filter(isLoadable).map(loadAdapter));
 }
 function getRegisteredDescriptors(toolIds) {
   if (toolIds && toolIds.length > 0) {
@@ -121,7 +133,7 @@ function getRegisteredDescriptors(toolIds) {
 }
 async function getAdapter(toolId) {
   const entry = entries.get(toolId);
-  if (!entry) return void 0;
+  if (!entry || !isLoadable(entry)) return void 0;
   return loadAdapter(entry);
 }
 function clearAdapters() {
@@ -226,84 +238,98 @@ function createCodacyConfig(params = {}) {
 }
 
 // src/files.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_fs = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
+var import_minimatch2 = require("minimatch");
+
+// src/glob-matcher.ts
 var import_minimatch = require("minimatch");
-var MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
-function listRepoFiles(repositoryRoot) {
-  try {
-    const tracked = (0, import_child_process.execSync)("git ls-files", {
-      cwd: repositoryRoot,
-      encoding: "utf-8",
-      maxBuffer: 50 * 1024 * 1024
-    }).trim();
-    const untracked = (0, import_child_process.execSync)("git ls-files --others --exclude-standard", {
-      cwd: repositoryRoot,
-      encoding: "utf-8",
-      maxBuffer: 50 * 1024 * 1024
-    }).trim();
-    const files = /* @__PURE__ */ new Set();
-    for (const f of tracked.split("\n")) {
-      if (f) files.add(f);
-    }
-    for (const f of untracked.split("\n")) {
-      if (f) files.add(f);
-    }
-    return Array.from(files).sort();
-  } catch {
-    return [];
-  }
+var PURE_EXTENSION_PATTERN = /^\*\*\/\*(\.[^*/.]+)$/;
+function pureExtensionOf(pattern) {
+  const m = PURE_EXTENSION_PATTERN.exec(pattern);
+  return m ? m[1] : null;
 }
-function filterOversizedFiles(files, repositoryRoot, logger) {
-  const result = [];
-  let skipped = 0;
-  for (const f of files) {
-    try {
-      const stat = import_fs.default.statSync(import_path2.default.join(repositoryRoot, f));
-      if (stat.size > MAX_FILE_SIZE_BYTES) {
-        skipped++;
-        logger?.debug("Skipping oversized file", {
-          file: f,
-          sizeKB: Math.round(stat.size / 1024),
-          limitKB: MAX_FILE_SIZE_BYTES / 1024
-        });
+var CompiledMatcher = class {
+  /** True if any pattern is the bare `"*"` wildcard (matches every file). */
+  matchAll;
+  literalPaths;
+  literalNames;
+  exts;
+  // Residual globs are split by whether they contain a path separator so the
+  // hot loop never runs a full-path match for a slash-less pattern (which can
+  // only ever match via the basename) — that call is always wasted on nested
+  // files. Slash patterns match against the full path; slash-less ones against
+  // the basename, which together reproduce the old dual check exactly.
+  residualPath;
+  residualName;
+  constructor(patterns) {
+    let matchAll = false;
+    const literalPaths = /* @__PURE__ */ new Set();
+    const literalNames = /* @__PURE__ */ new Set();
+    const exts = /* @__PURE__ */ new Set();
+    const residualPath = [];
+    const residualName = [];
+    for (const pattern of patterns) {
+      if (pattern === "*") {
+        matchAll = true;
         continue;
       }
-    } catch {
+      const ext = pureExtensionOf(pattern);
+      if (ext !== null) {
+        exts.add(ext);
+        continue;
+      }
+      const mm = new import_minimatch.Minimatch(pattern, { dot: true });
+      if (mm.hasMagic()) {
+        (pattern.includes("/") ? residualPath : residualName).push(mm);
+      } else if (pattern.includes("/")) {
+        literalPaths.add(pattern);
+      } else {
+        literalNames.add(pattern);
+      }
     }
-    result.push(f);
+    this.matchAll = matchAll;
+    this.literalPaths = literalPaths;
+    this.literalNames = literalNames;
+    this.exts = exts;
+    this.residualPath = residualPath;
+    this.residualName = residualName;
   }
-  if (skipped > 0) {
-    logger?.info("Filtered oversized files", { skipped, remaining: result.length });
+  /** True when this matcher holds no patterns at all (matches nothing). */
+  get isEmpty() {
+    return !this.matchAll && this.literalPaths.size === 0 && this.literalNames.size === 0 && this.exts.size === 0 && this.residualPath.length === 0 && this.residualName.length === 0;
   }
-  return result;
-}
-function applyExclusions(files, globalExclude, toolExclude) {
-  const allExclusions = [...globalExclude, ...toolExclude];
-  if (allExclusions.length === 0) return files;
-  return files.filter((file) => {
-    const basename = import_path2.default.basename(file);
-    return !allExclusions.some((pattern) => {
-      if ((0, import_minimatch.minimatch)(file, pattern, { dot: true })) return true;
-      if (!pattern.includes("/") && (0, import_minimatch.minimatch)(basename, pattern, { dot: true })) return true;
-      return false;
-    });
-  });
-}
-function routeFilesToTool(files, adapter, toolConfig) {
-  const patterns = [...adapter.filePatterns];
-  if (toolConfig?.extraFilePatterns) {
-    patterns.push(...toolConfig.extraFilePatterns);
+  /**
+   * Returns true if `file` matches any pattern. `basename` must be
+   * `path.basename(file)` — passed in so callers compute it once per file.
+   *
+   * Mirrors the historical dual check: a pattern matches if it matches the full
+   * relative path, or (for patterns with no path separator) the basename. For
+   * globstar/slash patterns the full-path check already subsumes the basename
+   * check, so gating the basename check on `!includes("/")` is equivalent to
+   * the old unconditional basename check used by `routeFilesToTool`.
+   */
+  matches(file, basename) {
+    if (this.matchAll) return true;
+    if (this.literalPaths.size > 0 && this.literalPaths.has(file)) return true;
+    if (this.literalNames.size > 0 && this.literalNames.has(basename)) return true;
+    if (this.exts.size > 0) {
+      const dot = basename.lastIndexOf(".");
+      if (dot >= 0 && this.exts.has(basename.slice(dot))) return true;
+    }
+    for (const m of this.residualPath) {
+      if (m.match(file)) return true;
+    }
+    for (const m of this.residualName) {
+      if (m.match(basename)) return true;
+    }
+    return false;
   }
-  if (patterns.includes("*")) return files;
-  return files.filter((file) => {
-    const basename = import_path2.default.basename(file);
-    return patterns.some(
-      (pattern) => (0, import_minimatch.minimatch)(basename, pattern, { dot: true }) || (0, import_minimatch.minimatch)(file, pattern, { dot: true })
-    );
-  });
-}
+};
+
+// src/git-scope.ts
+var import_child_process = require("child_process");
 function listStagedFiles(repositoryRoot) {
   try {
     const output = (0, import_child_process.execSync)("git diff --cached --name-only --diff-filter=d", {
@@ -333,7 +359,7 @@ function listDiffFiles(repositoryRoot, base) {
 }
 function listPrFiles(repositoryRoot) {
   try {
-    const output = (0, import_child_process.execSync)("gh pr view --json files --jq '.files[].path'", {
+    const output = (0, import_child_process.execSync)('gh pr view --json files --jq ".files[].path"', {
       cwd: repositoryRoot,
       encoding: "utf-8",
       maxBuffer: 10 * 1024 * 1024,
@@ -389,23 +415,95 @@ function detectDefaultBranch(repositoryRoot) {
     "Cannot auto-detect default branch: no origin/HEAD, origin/main, or origin/master found. Specify a base explicitly with --diff <base>."
   );
 }
+
+// src/files.ts
+var MAX_FILE_SIZE_BYTES = 150 * 1024;
+function listRepoFiles(repositoryRoot) {
+  try {
+    const tracked = (0, import_child_process2.execSync)("git ls-files", {
+      cwd: repositoryRoot,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    }).trim();
+    const untracked = (0, import_child_process2.execSync)("git ls-files --others --exclude-standard", {
+      cwd: repositoryRoot,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    }).trim();
+    const files = /* @__PURE__ */ new Set();
+    for (const f of tracked.split("\n")) {
+      if (f) files.add(f);
+    }
+    for (const f of untracked.split("\n")) {
+      if (f) files.add(f);
+    }
+    return Array.from(files).sort();
+  } catch {
+    return [];
+  }
+}
+function filterOversizedFiles(files, repositoryRoot, logger) {
+  const result = [];
+  const skipped = [];
+  for (const f of files) {
+    try {
+      const stat = import_fs.default.statSync(import_path2.default.join(repositoryRoot, f));
+      if (stat.size > MAX_FILE_SIZE_BYTES) {
+        skipped.push({ filePath: f, sizeBytes: stat.size });
+        logger?.debug("Skipping oversized file", {
+          file: f,
+          sizeKB: Math.round(stat.size / 1024),
+          limitKB: MAX_FILE_SIZE_BYTES / 1024
+        });
+        continue;
+      }
+    } catch {
+    }
+    result.push(f);
+  }
+  if (skipped.length > 0) {
+    logger?.info("Filtered oversized files", {
+      skipped: skipped.length,
+      remaining: result.length,
+      limitKB: MAX_FILE_SIZE_BYTES / 1024
+    });
+  }
+  return { files: result, skipped };
+}
+function applyExclusions(files, globalExclude, toolExclude) {
+  if (globalExclude.length === 0 && toolExclude.length === 0) return files;
+  const matcher = new CompiledMatcher([...globalExclude, ...toolExclude]);
+  if (matcher.isEmpty) return files;
+  return files.filter((file) => !matcher.matches(file, import_path2.default.basename(file)));
+}
+function routeFilesToTool(files, adapter, toolConfig) {
+  const patterns = [...adapter.filePatterns];
+  if (toolConfig?.extraFilePatterns) {
+    patterns.push(...toolConfig.extraFilePatterns);
+  }
+  const matcher = new CompiledMatcher(patterns);
+  if (matcher.matchAll) return files;
+  return files.filter((file) => matcher.matches(file, import_path2.default.basename(file)));
+}
 function filterByTargetFiles(allFiles, targetPatterns) {
   if (targetPatterns.length === 0) return allFiles;
   const normalized = targetPatterns.map((p) => p.replace(/^\.\//, ""));
+  const exact = new Set(normalized);
+  const globs = normalized.map((p) => new import_minimatch2.Minimatch(p, { dot: true, matchBase: false })).filter((m) => m.hasMagic());
+  const dirPrefixes = normalized.filter((p) => p.endsWith("/"));
   return allFiles.filter(
-    (f) => normalized.some(
-      (pattern) => (
-        // Exact match (fast path)
-        f === pattern || // Glob match
-        (0, import_minimatch.minimatch)(f, pattern, { dot: true, matchBase: false }) || // Directory prefix (e.g. "src/subdir/" matches all files under it)
-        pattern.endsWith("/") && f.startsWith(pattern)
-      )
+    (f) => (
+      // Exact match (fast path)
+      exact.has(f) || // Glob match
+      globs.some((m) => m.match(f)) || // Directory prefix (e.g. "src/subdir/" matches all files under it)
+      dirPrefixes.some((p) => f.startsWith(p))
     )
   );
 }
 
 // src/executor.ts
 var import_tooling2 = require("@codacy/tooling");
+var HARD_TIMEOUT_GRACE_MS = 2e3;
 async function runTool(adapter, ctx, codacyToolConfig, timeoutMs) {
   const startTime = Date.now();
   ctx.logger.debug("runTool started", {
@@ -413,12 +511,18 @@ async function runTool(adapter, ctx, codacyToolConfig, timeoutMs) {
     fileCount: ctx.targetFiles.length,
     timeoutMs
   });
+  const abortController = new AbortController();
+  ctx.signal = abortController.signal;
+  const abortTimer = setTimeout(() => abortController.abort(), timeoutMs);
+  abortTimer.unref?.();
+  let hardTimer;
   try {
     const timeoutPromise = new Promise((_resolve, reject) => {
-      setTimeout(
+      hardTimer = setTimeout(
         () => reject(new Error(`TIMEOUT: Tool ${adapter.id} exceeded ${(0, import_tooling2.formatDuration)(timeoutMs)}`)),
-        timeoutMs
+        timeoutMs + HARD_TIMEOUT_GRACE_MS
       );
+      hardTimer.unref?.();
     });
     const result = await Promise.race([adapter.analyze(ctx, codacyToolConfig), timeoutPromise]);
     ctx.logger.debug("runTool completed", {
@@ -465,6 +569,9 @@ async function runTool(adapter, ctx, codacyToolConfig, timeoutMs) {
         filesAnalyzed: ctx.targetFiles.length
       }
     };
+  } finally {
+    clearTimeout(abortTimer);
+    if (hardTimer) clearTimeout(hardTimer);
   }
 }
 async function runToolsSequential(tools, timeoutMs, callbacks) {
@@ -623,7 +730,7 @@ function computePatternSummary(issues, lookup) {
 }
 
 // src/analyze.ts
-var execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
+var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
 var nullLogger = {
   debug: () => {
   },
@@ -634,10 +741,24 @@ var nullLogger = {
   error: () => {
   }
 };
+var CHECK_CONCURRENCY = 12;
+async function mapWithConcurrency(items, concurrency, task) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await task(items[index], index);
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
 async function analyze(options) {
   const startedAt = /* @__PURE__ */ new Date();
   const mode = options.mode || "standard";
-  const toolTimeout = options.toolTimeout || 6e5;
+  const toolTimeout = options.toolTimeout || 9e5;
   const parallelTools = options.parallelTools || 1;
   const logger = options.logger ?? nullLogger;
   const phaseTimings = {
@@ -727,23 +848,25 @@ async function analyze(options) {
   const unavailable = [];
   const availabilityTimeout = 6e4;
   const availabilityStartMs = Date.now();
-  for (const adapter of adapters) {
+  const checkAvailabilityOf = async (adapter) => {
     const ctx = makeToolContext(baseCtx, adapter, []);
     const checkStart = Date.now();
     logger.debug("Checking availability", { toolId: adapter.id });
+    let timer;
     try {
       const availability = await Promise.race([
         adapter.checkAvailability(ctx),
-        new Promise(
-          (_, reject) => setTimeout(
+        new Promise((_, reject) => {
+          timer = setTimeout(
             () => reject(
               new Error(
                 `checkAvailability timed out after ${(0, import_tooling3.formatDuration)(availabilityTimeout)}`
               )
             ),
             availabilityTimeout
-          )
-        )
+          );
+          timer.unref?.();
+        })
       ]);
       if (availability.available) {
         logger.debug("Tool available", {
@@ -752,38 +875,57 @@ async function analyze(options) {
           installation: availability.installation,
           durationMs: Date.now() - checkStart
         });
-        ready.push({
-          toolId: adapter.id,
-          displayName: adapter.displayName,
-          version: availability.version ?? adapter.preferredVersion,
-          installation: availability.installation ?? "global",
-          runner: "local"
-        });
-      } else {
-        logger.warn("Tool unavailable", {
-          toolId: adapter.id,
-          reason: availability.reason,
-          durationMs: Date.now() - checkStart
-        });
-        unavailable.push({
+        return {
+          kind: "ready",
+          status: {
+            toolId: adapter.id,
+            displayName: adapter.displayName,
+            version: availability.version ?? adapter.preferredVersion,
+            installation: availability.installation ?? "global",
+            runner: "local"
+          }
+        };
+      }
+      logger.warn("Tool unavailable", {
+        toolId: adapter.id,
+        reason: availability.reason,
+        durationMs: Date.now() - checkStart
+      });
+      return {
+        kind: "unavailable",
+        status: {
           toolId: adapter.id,
           displayName: adapter.displayName,
           reason: availability.reason || "Tool is not available",
           ...availability.installHint ? { remediation: availability.installHint } : {}
-        });
-      }
+        }
+      };
     } catch (err) {
       logger.warn("Availability check failed", {
         toolId: adapter.id,
         error: err instanceof Error ? err.message : String(err),
         durationMs: Date.now() - checkStart
       });
-      unavailable.push({
-        toolId: adapter.id,
-        displayName: adapter.displayName,
-        reason: `Availability check failed: ${err instanceof Error ? err.message : String(err)}`
-      });
+      return {
+        kind: "unavailable",
+        status: {
+          toolId: adapter.id,
+          displayName: adapter.displayName,
+          reason: `Availability check failed: ${err instanceof Error ? err.message : String(err)}`
+        }
+      };
+    } finally {
+      if (timer) clearTimeout(timer);
     }
+  };
+  const availabilityOutcomes = await mapWithConcurrency(
+    adapters,
+    CHECK_CONCURRENCY,
+    checkAvailabilityOf
+  );
+  for (const outcome of availabilityOutcomes) {
+    if (outcome.kind === "ready") ready.push(outcome.status);
+    else unavailable.push(outcome.status);
   }
   phaseTimings.availabilityMs = Date.now() - availabilityStartMs;
   const capability = {
@@ -800,6 +942,31 @@ async function analyze(options) {
     readyAfter: capability.ready.length,
     configuredToolCount: configuredIds.size
   });
+  const representedIds = /* @__PURE__ */ new Set([
+    ...capability.ready.map((t) => t.toolId),
+    ...capability.unavailable.map((t) => t.toolId)
+  ]);
+  const requestedLower = options.tools?.map((t) => t.toLowerCase());
+  const inScope = (toolId) => {
+    if (!requestedLower) return true;
+    const id = toolId.toLowerCase();
+    return requestedLower.some((r) => id.includes(r) || r.includes(id));
+  };
+  const descriptorsById = new Map(getRegisteredDescriptors().map((d) => [d.id, d]));
+  for (const toolConfig of codacyConfig.tools) {
+    if (!toolConfig?.toolId) continue;
+    if (representedIds.has(toolConfig.toolId)) continue;
+    if (!inScope(toolConfig.toolId)) continue;
+    const descriptor = descriptorsById.get(toolConfig.toolId);
+    if (!descriptor?.unsupported) continue;
+    capability.unavailable.push({
+      toolId: toolConfig.toolId,
+      displayName: descriptor.displayName ?? toolConfig.toolId,
+      reason: "No local analyzer (configured on Codacy Cloud)",
+      availableVia: "cloud"
+    });
+    representedIds.add(toolConfig.toolId);
+  }
   if (mode === "auto-install" && capability.unavailable.length > 0) {
     const installStartMs = Date.now();
     const installErrors = [];
@@ -908,8 +1075,9 @@ async function analyze(options) {
     }
     return buildResult(startedAt, options.repositoryRoot, mode, capability, [], [], []);
   }
-  if (mode === "strict" && capability.unavailable.length > 0) {
-    const missingTools = capability.unavailable.map((u) => u.toolId).join(", ");
+  const strictMissing = capability.unavailable.filter((u) => u.availableVia !== "cloud");
+  if (mode === "strict" && strictMissing.length > 0) {
+    const missingTools = strictMissing.map((u) => u.toolId).join(", ");
     return buildResult(
       startedAt,
       options.repositoryRoot,
@@ -950,25 +1118,52 @@ async function analyze(options) {
     allFiles = filterByTargetFiles(allFiles, options.files);
     logger.debug("Filtered by target files", { afterFilter: allFiles.length });
   }
-  allFiles = filterOversizedFiles(allFiles, options.repositoryRoot, logger);
+  const oversize = filterOversizedFiles(allFiles, options.repositoryRoot, logger);
+  allFiles = oversize.files;
+  const skippedFiles = oversize.skipped;
   phaseTimings.fileDiscoveryMs = Date.now() - fileDiscoveryStartMs;
   const fileRoutingStartMs = Date.now();
-  const readyAdapters = adapters.filter((a) => capability.ready.some((r) => r.toolId === a.id));
+  const readyById = new Map(capability.ready.map((r) => [r.toolId, r]));
+  const readyAdapters = adapters.filter((a) => readyById.has(a.id));
+  const filesAfterGlobalExclude = applyExclusions(allFiles, globalExclude, []);
   const toolRuns = [];
+  const candidates = [];
   for (const adapter of readyAdapters) {
     const toolConfig = getToolConfig(codacyConfig, adapter.id);
     if (!toolConfig) continue;
-    const toolExclude = toolConfig?.exclude || [];
-    const filesAfterExclusion = applyExclusions(allFiles, globalExclude, toolExclude);
-    const toolFiles = routeFilesToTool(filesAfterExclusion, adapter, toolConfig);
-    const readyEntryForFiles = capability.ready.find((r) => r.toolId === adapter.id);
-    if (readyEntryForFiles) {
-      readyEntryForFiles.filesRouted = toolFiles.length;
+    const toolExclude = toolConfig.exclude || [];
+    const filesForTool = toolExclude.length > 0 ? applyExclusions(filesAfterGlobalExclude, toolExclude, []) : filesAfterGlobalExclude;
+    const toolFiles = routeFilesToTool(filesForTool, adapter, toolConfig);
+    const readyEntry = readyById.get(adapter.id);
+    if (readyEntry) {
+      readyEntry.filesRouted = toolFiles.length;
+    }
+    candidates.push({
+      adapter,
+      toolFiles,
+      configCtx: makeToolContext(baseCtx, adapter, toolFiles),
+      readyEntry
+    });
+  }
+  const configChecks = await mapWithConcurrency(
+    candidates,
+    CHECK_CONCURRENCY,
+    async (c) => {
+      try {
+        return await c.adapter.checkLocalConfigurationFile(c.configCtx);
+      } catch (err) {
+        logger.debug("Local config check failed, assuming none", {
+          toolId: c.adapter.id,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return { found: false };
+      }
     }
-    const configCtx = makeToolContext(baseCtx, adapter, toolFiles);
-    const configCheck = await adapter.checkLocalConfigurationFile(configCtx);
+  );
+  for (let i = 0; i < candidates.length; i++) {
+    const { adapter, toolFiles, configCtx, readyEntry } = candidates[i];
+    const configCheck = configChecks[i];
     const codacyToolConfig = buildToolConfig(codacyConfig, adapter, configCheck);
-    const readyEntry = capability.ready.find((r) => r.toolId === adapter.id);
     if (readyEntry) {
       if (configCheck.found && codacyToolConfig.useLocalConfigurationFile) {
         readyEntry.configSource = "local";
@@ -1042,7 +1237,8 @@ async function analyze(options) {
     allErrors,
     allSummaries,
     patternSummary,
-    phaseTimings
+    phaseTimings,
+    skippedFiles
   );
 }
 function makeToolContext(base, adapter, targetFiles) {
@@ -1068,7 +1264,7 @@ function resolveGitScope(repositoryRoot, scope) {
   const base = scope.diff === true ? void 0 : scope.diff;
   return listDiffFiles(repositoryRoot, base);
 }
-function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors, toolResults, patternSummary, phaseTimings) {
+function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors, toolResults, patternSummary, phaseTimings, skippedFiles) {
   const completedAt = /* @__PURE__ */ new Date();
   return {
     metadata: {
@@ -1083,7 +1279,8 @@ function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors
     issues,
     errors,
     toolResults,
-    ...patternSummary ? { patternSummary } : {}
+    ...patternSummary ? { patternSummary } : {},
+    ...skippedFiles && skippedFiles.length > 0 ? { skippedFiles } : {}
   };
 }
 
@@ -1092,6 +1289,7 @@ var import_path4 = __toESM(require("path"));
 var import_tooling4 = require("@codacy/tooling");
 var import_ansis = __toESM(require("ansis"));
 var import_cli_table3 = __toESM(require("cli-table3"));
+var MAX_SKIPPED_FILES_SHOWN = 5;
 function formatOutput(result, format) {
   switch (format) {
     case "json":
@@ -1249,9 +1447,30 @@ function formatText(result) {
     lines.push(...formatErrorSection(result));
     lines.push("");
   }
+  if (result.skippedFiles && result.skippedFiles.length > 0) {
+    lines.push(...formatSkippedFilesSection(result.skippedFiles));
+    lines.push("");
+  }
   lines.push(formatTextSummary(result, isInspect));
   return lines.join("\n");
 }
+function formatSkippedFilesSection(skipped) {
+  const limitKB = Math.round(MAX_FILE_SIZE_BYTES / 1024);
+  const out = [""];
+  out.push(
+    import_ansis.default.yellow(
+      `\u26A0 ${skipped.length} file${skipped.length !== 1 ? "s" : ""} skipped (exceeding the ${limitKB} KB size limit):`
+    )
+  );
+  for (const f of skipped.slice(0, MAX_SKIPPED_FILES_SHOWN)) {
+    out.push(import_ansis.default.dim(`  - ${f.filePath} (${Math.round(f.sizeBytes / 1024)} KB)`));
+  }
+  const remaining = skipped.length - MAX_SKIPPED_FILES_SHOWN;
+  if (remaining > 0) {
+    out.push(import_ansis.default.dim(`  \u2026 and ${remaining} more`));
+  }
+  return out;
+}
 function formatTextSummary(result, isInspect) {
   const lines = [];
   const inspect = isInspect ?? result.metadata.executionMode === "inspect";
@@ -1301,13 +1520,14 @@ function formatTextSummary(result, isInspect) {
         ]);
       }
       for (const tool of unavailableTools) {
+        const isUnsupported = tool.availableVia === "cloud";
         table.push([
-          import_ansis.default.dim.red(tool.displayName ?? tool.toolId),
+          isUnsupported ? import_ansis.default.dim(tool.displayName ?? tool.toolId) : import_ansis.default.dim.red(tool.displayName ?? tool.toolId),
           "-",
+          isUnsupported ? import_ansis.default.dim("Unsupported") : "-",
           "-",
           "-",
-          "-",
-          tool.reason
+          isUnsupported ? import_ansis.default.dim("No local analyzer (Codacy Cloud)") : tool.reason
         ]);
       }
       lines.push(table.toString());
@@ -1332,13 +1552,14 @@ function formatTextSummary(result, isInspect) {
         ]);
       }
       for (const tool of unavailableTools) {
+        const isUnsupported = tool.availableVia === "cloud";
         table.push([
-          import_ansis.default.dim.red(tool.displayName ?? tool.toolId),
-          "-",
+          isUnsupported ? import_ansis.default.dim(tool.displayName ?? tool.toolId) : import_ansis.default.dim.red(tool.displayName ?? tool.toolId),
           "-",
+          isUnsupported ? import_ansis.default.dim("Unsupported") : "-",
           "-",
           "-",
-          import_ansis.default.dim("missing binary"),
+          isUnsupported ? import_ansis.default.dim("cloud-only") : import_ansis.default.dim("missing binary"),
           "-"
         ]);
       }
@@ -1391,6 +1612,13 @@ function formatTextSummary(result, isInspect) {
   return lines.join("\n");
 }
 var MAX_ERRORS_PER_GROUP = 5;
+var MAX_ERROR_MESSAGE_LENGTH = 240;
+function flattenErrorMessage(message) {
+  return message.replace(/\s+/g, " ").trim();
+}
+function truncateErrorMessage(message) {
+  return message.length > MAX_ERROR_MESSAGE_LENGTH ? `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}\u2026` : message;
+}
 function formatErrorSection(result) {
   const lines = [];
   const displayNameMap = /* @__PURE__ */ new Map();
@@ -1412,13 +1640,14 @@ function formatErrorSection(result) {
     const deduped = [];
     const seen = /* @__PURE__ */ new Map();
     for (const err of groupErrors) {
-      const dedupKey = `${err.filePath ?? ""}|||${err.message}`;
+      const flat = flattenErrorMessage(err.message);
+      const dedupKey = `${err.filePath ?? ""}|||${flat}`;
       const idx = seen.get(dedupKey);
       if (idx !== void 0) {
         deduped[idx].count++;
       } else {
         seen.set(dedupKey, deduped.length);
-        deduped.push({ filePath: err.filePath, message: err.message, count: 1 });
+        deduped.push({ filePath: err.filePath, message: truncateErrorMessage(flat), count: 1 });
       }
     }
     const shown = deduped.slice(0, MAX_ERRORS_PER_GROUP);
@@ -1745,7 +1974,7 @@ function applyConfigOperation(op, source, dest) {
 // src/init.ts
 var import_promises4 = __toESM(require("fs/promises"));
 var import_path7 = __toESM(require("path"));
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_tooling5 = require("@codacy/tooling");
 
 // src/discover.ts
@@ -1954,6 +2183,12 @@ var DEPENDENCY_CATALOG = /* @__PURE__ */ new Map([
   ["gson", { displayName: "Gson", kind: "library" }],
   ["okhttp", { displayName: "OkHttp", kind: "library" }],
   ["retrofit", { displayName: "Retrofit", kind: "library" }],
+  ["spock-core", { displayName: "Spock", kind: "library" }],
+  // --- Groovy — Frameworks ---
+  // Grails/GORM artifact IDs vary (grails-core, grails-web, gorm-hibernate5, …);
+  // the `grails-`/`gorm-` prefix rules below catch the rest.
+  ["grails-core", { displayName: "Grails", kind: "framework" }],
+  ["gorm-core", { displayName: "GORM", kind: "library" }],
   // --- Go — Frameworks ---
   ["github.com/gin-gonic/gin", { displayName: "Gin", kind: "framework" }],
   ["github.com/labstack/echo", { displayName: "Echo", kind: "framework" }],
@@ -1995,9 +2230,20 @@ var DEPENDENCY_CATALOG = /* @__PURE__ */ new Map([
   // --- PHP — Frameworks ---
   ["laravel/framework", { displayName: "Laravel", kind: "framework" }],
   ["symfony/framework-bundle", { displayName: "Symfony", kind: "framework" }],
+  ["symfony/symfony", { displayName: "Symfony", kind: "framework" }],
   ["codeigniter4/framework", { displayName: "CodeIgniter", kind: "framework" }],
   ["slim/slim", { displayName: "Slim", kind: "framework" }],
   ["cakephp/cakephp", { displayName: "CakePHP", kind: "framework" }],
+  // WordPress is rarely a real Composer dependency; these are the common
+  // "WordPress as a dependency" packages used by Bedrock/Composer-based sites.
+  ["johnpbloch/wordpress-core", { displayName: "WordPress", kind: "framework" }],
+  ["johnpbloch/wordpress", { displayName: "WordPress", kind: "framework" }],
+  ["roots/wordpress", { displayName: "WordPress", kind: "framework" }],
+  ["drupal/core", { displayName: "Drupal", kind: "framework" }],
+  ["drupal/core-recommended", { displayName: "Drupal", kind: "framework" }],
+  ["magento/product-community-edition", { displayName: "Magento", kind: "framework" }],
+  ["magento/product-enterprise-edition", { displayName: "Magento", kind: "framework" }],
+  ["magento/framework", { displayName: "Magento", kind: "framework" }],
   // --- PHP — Libraries ---
   ["phpunit/phpunit", { displayName: "PHPUnit", kind: "library" }],
   ["guzzlehttp/guzzle", { displayName: "Guzzle", kind: "library" }],
@@ -2027,7 +2273,32 @@ var DEPENDENCY_CATALOG = /* @__PURE__ */ new Map([
   ["scalatest", { displayName: "ScalaTest", kind: "library" }],
   ["specs2-core", { displayName: "Specs2", kind: "library" }],
   ["cats-core", { displayName: "Cats", kind: "library" }],
-  ["circe-core", { displayName: "Circe", kind: "library" }]
+  ["circe-core", { displayName: "Circe", kind: "library" }],
+  // --- Dart — Frameworks ---
+  // `flutter` and `angular` appear as plain keys in pubspec.yaml.
+  ["flutter", { displayName: "Flutter", kind: "framework" }],
+  ["flutter_test", { displayName: "Flutter", kind: "framework" }],
+  ["angular", { displayName: "Angular", kind: "framework" }],
+  // --- Dart — Libraries ---
+  // Kept to Dart-specific names with negligible cross-ecosystem collision risk
+  // (generic names like "get"/"provider" are intentionally omitted).
+  ["riverpod", { displayName: "Riverpod", kind: "library" }],
+  ["flutter_bloc", { displayName: "Bloc", kind: "library" }],
+  ["dio", { displayName: "Dio", kind: "library" }],
+  // --- .NET (C# / VB) — Libraries ---
+  // NuGet package IDs. Microsoft.* families are also covered by prefix rules below.
+  ["EntityFramework", { displayName: "Entity Framework", kind: "library" }],
+  ["NUnit", { displayName: "NUnit", kind: "library" }],
+  ["Moq", { displayName: "Moq", kind: "library" }],
+  ["NSubstitute", { displayName: "NSubstitute", kind: "library" }],
+  ["FluentAssertions", { displayName: "FluentAssertions", kind: "library" }],
+  ["Shouldly", { displayName: "Shouldly", kind: "library" }],
+  ["NLog", { displayName: "NLog", kind: "library" }],
+  ["log4net", { displayName: "log4net", kind: "library" }],
+  ["Newtonsoft.Json", { displayName: "Json.NET", kind: "library" }],
+  ["AutoMapper", { displayName: "AutoMapper", kind: "library" }],
+  ["Dapper", { displayName: "Dapper", kind: "library" }],
+  ["MediatR", { displayName: "MediatR", kind: "library" }]
 ]);
 var DEPENDENCY_PREFIX_RULES = [
   { prefix: "@angular/", classification: { displayName: "Angular", kind: "framework" } },
@@ -2057,7 +2328,35 @@ var DEPENDENCY_PREFIX_RULES = [
   { prefix: "@shopify/", classification: { displayName: "Shopify", kind: "platform" } },
   { prefix: "@aws-sdk/", classification: { displayName: "AWS SDK", kind: "library" } },
   { prefix: "@google-cloud/", classification: { displayName: "Google Cloud", kind: "library" } },
-  { prefix: "@azure/", classification: { displayName: "Azure SDK", kind: "library" } }
+  { prefix: "@azure/", classification: { displayName: "Azure SDK", kind: "library" } },
+  // Groovy — Grails/GORM artifact families (build.gradle artifactIds).
+  { prefix: "grails-", classification: { displayName: "Grails", kind: "framework" } },
+  { prefix: "gorm-", classification: { displayName: "GORM", kind: "library" } },
+  // .NET — Microsoft package families and common test/logging libraries. More
+  // specific prefixes (Blazor) must precede broader ones (ASP.NET Core).
+  {
+    prefix: "Microsoft.AspNetCore.Components.WebAssembly",
+    classification: { displayName: "Blazor", kind: "framework" }
+  },
+  {
+    prefix: "Microsoft.AspNetCore.",
+    classification: { displayName: "ASP.NET Core", kind: "framework" }
+  },
+  {
+    prefix: "Microsoft.EntityFrameworkCore",
+    classification: { displayName: "Entity Framework", kind: "library" }
+  },
+  {
+    prefix: "Microsoft.Azure.Functions",
+    classification: { displayName: "Azure Functions", kind: "framework" }
+  },
+  {
+    prefix: "Microsoft.Azure.WebJobs",
+    classification: { displayName: "Azure Functions", kind: "framework" }
+  },
+  { prefix: "xunit", classification: { displayName: "xUnit", kind: "library" } },
+  { prefix: "MSTest.", classification: { displayName: "MSTest", kind: "library" } },
+  { prefix: "Serilog", classification: { displayName: "Serilog", kind: "library" } }
 ];
 function classifyDependency(name) {
   const exact = DEPENDENCY_CATALOG.get(name);
@@ -2086,7 +2385,12 @@ var NOTABLE_ANY_DEPTH = /* @__PURE__ */ new Set([
   "Package.swift",
   "Jenkinsfile",
   "Vagrantfile",
-  "Procfile"
+  "Procfile",
+  "pubspec.yaml",
+  "mix.exs",
+  "shard.yml",
+  "packages.config",
+  "Directory.Packages.props"
 ]);
 var NOTABLE_ROOT_ONLY = /* @__PURE__ */ new Set([
   ".dockerignore",
@@ -2146,6 +2450,7 @@ function isNotableFile(filePath) {
   const isRoot = !filePath.includes("/");
   if (NOTABLE_ANY_DEPTH.has(basename)) return true;
   if (isRoot && NOTABLE_ROOT_ONLY.has(basename)) return true;
+  if (/\.(csproj|vbproj|fsproj|sln)$/i.test(basename)) return true;
   for (const prefix of NOTABLE_PATH_PREFIXES) {
     if (filePath.startsWith(prefix)) return true;
   }
@@ -2352,6 +2657,51 @@ function parsePackageSwift(content) {
   }
   return deps;
 }
+function parsePubspecYaml(content) {
+  const deps = [];
+  let inSection = false;
+  let childIndent = -1;
+  for (const rawLine of content.split("\n")) {
+    const trimmed = rawLine.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const indent = rawLine.length - rawLine.trimStart().length;
+    if (indent === 0) {
+      inSection = /^(dependencies|dev_dependencies|dependency_overrides):/.test(trimmed);
+      childIndent = -1;
+      continue;
+    }
+    if (!inSection) continue;
+    if (childIndent === -1) childIndent = indent;
+    if (indent !== childIndent) continue;
+    const m = trimmed.match(/^([a-zA-Z0-9_.]+)\s*:(?:\s*["']?\^?([0-9][^"'#\s]*))?/);
+    if (m) deps.push({ name: m[1], version: m[2] });
+  }
+  return deps;
+}
+function parseXmlDependencyElements(content, elementRegex, nameAttr) {
+  const deps = [];
+  const nameRegex = new RegExp(`\\b${nameAttr}\\s*=\\s*["']([^"']+)["']`, "i");
+  const versionRegex = /\bversion\s*=\s*["']([^"']+)["']/i;
+  let match;
+  while ((match = elementRegex.exec(content)) !== null) {
+    const attrs = match[1];
+    const nameMatch = attrs.match(nameRegex);
+    if (!nameMatch) continue;
+    const versionMatch = attrs.match(versionRegex);
+    deps.push({ name: nameMatch[1].trim(), version: versionMatch?.[1]?.trim() });
+  }
+  return deps;
+}
+function parseCsproj(content) {
+  return parseXmlDependencyElements(
+    content,
+    /<Package(?:Reference|Version)\s+([^>]+?)\/?>/gi,
+    "Include"
+  );
+}
+function parsePackagesConfig(content) {
+  return parseXmlDependencyElements(content, /<package\s+([^>]+?)\/?>/gi, "id");
+}
 var MANIFEST_PARSERS = /* @__PURE__ */ new Map([
   ["package.json", parsePackageJson],
   ["requirements.txt", parseRequirementsTxt],
@@ -2365,7 +2715,15 @@ var MANIFEST_PARSERS = /* @__PURE__ */ new Map([
   ["Cargo.toml", parseCargoToml],
   ["composer.json", parseComposerJson],
   ["Podfile", parsePodfile],
-  ["Package.swift", parsePackageSwift]
+  ["Package.swift", parsePackageSwift],
+  ["pubspec.yaml", parsePubspecYaml],
+  ["packages.config", parsePackagesConfig],
+  ["Directory.Packages.props", parseCsproj]
+]);
+var MANIFEST_SUFFIX_PARSERS = /* @__PURE__ */ new Map([
+  [".csproj", parseCsproj],
+  [".vbproj", parseCsproj],
+  [".fsproj", parseCsproj]
 ]);
 
 // src/discover.ts
@@ -2415,39 +2773,39 @@ function findNotableFiles(files) {
   }
   return Array.from(notable).sort();
 }
-async function extractDependencies(repositoryRoot, files) {
-  const manifestFiles = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const basename = file.split("/").pop() ?? file;
-    if (MANIFEST_PARSERS.has(basename)) {
-      const existing = manifestFiles.get(basename) ?? [];
-      existing.push(file);
-      manifestFiles.set(basename, existing);
-    }
+function resolveManifestParser(filePath) {
+  const basename = filePath.split("/").pop() ?? filePath;
+  const byName = MANIFEST_PARSERS.get(basename);
+  if (byName) return byName;
+  const lowerBasename = basename.toLowerCase();
+  for (const [suffix, parser] of MANIFEST_SUFFIX_PARSERS) {
+    if (lowerBasename.endsWith(suffix)) return parser;
   }
+  return void 0;
+}
+async function extractDependencies(repositoryRoot, files) {
   const allDeps = [];
-  for (const [manifestName, paths] of manifestFiles) {
-    const parser = MANIFEST_PARSERS.get(manifestName);
-    for (const filePath of paths) {
-      let content;
-      try {
-        content = await import_promises2.default.readFile(import_path5.default.join(repositoryRoot, filePath), "utf-8");
-      } catch {
-        continue;
-      }
-      const rawDeps = parser(content);
-      for (const raw of rawDeps) {
-        const classification = classifyDependency(raw.name);
-        if (classification) {
-          allDeps.push({
-            name: raw.name,
-            displayName: classification.displayName,
-            kind: classification.kind,
-            source: "manifest",
-            manifestFile: filePath,
-            version: raw.version
-          });
-        }
+  for (const filePath of files) {
+    const parser = resolveManifestParser(filePath);
+    if (!parser) continue;
+    let content;
+    try {
+      content = await import_promises2.default.readFile(import_path5.default.join(repositoryRoot, filePath), "utf-8");
+    } catch {
+      continue;
+    }
+    const rawDeps = parser(content);
+    for (const raw of rawDeps) {
+      const classification = classifyDependency(raw.name);
+      if (classification) {
+        allDeps.push({
+          name: raw.name,
+          displayName: classification.displayName,
+          kind: classification.kind,
+          source: "manifest",
+          manifestFile: filePath,
+          version: raw.version
+        });
       }
     }
   }
@@ -6083,13 +6441,44 @@ async function listIgnoredFiles(provider, org, repo) {
 }
 
 // src/init.ts
+function deriveApiToolId(tool) {
+  return tool.prefix ? tool.prefix.replace(/_$/, "") : tool.shortName;
+}
+function isTrackableTool(tool) {
+  if (tool.clientSide) return false;
+  if (tool.standalone) return false;
+  if (/\bdeprecated\b/i.test(tool.name ?? "")) return false;
+  return true;
+}
+function buildAdapterByUuid(adapters, apiTools) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    byKey.set(adapter.id.toLowerCase(), adapter);
+    byKey.set(adapter.displayName.toLowerCase(), adapter);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const tool of apiTools) {
+    const candidates = [];
+    if (tool.prefix) candidates.push(tool.prefix.replace(/_$/, "").toLowerCase());
+    if (tool.shortName) candidates.push(tool.shortName.toLowerCase());
+    if (tool.name) candidates.push(tool.name.toLowerCase());
+    for (const candidate of candidates) {
+      const adapter = byKey.get(candidate);
+      if (adapter) {
+        result.set(tool.uuid, adapter);
+        break;
+      }
+    }
+  }
+  return result;
+}
 async function detectLanguages(repositoryRoot, precomputedFiles) {
   let files;
   if (precomputedFiles) {
     files = precomputedFiles;
   } else {
     try {
-      const output = (0, import_child_process3.execSync)("git ls-files", {
+      const output = (0, import_child_process4.execSync)("git ls-files", {
         cwd: repositoryRoot,
         encoding: "utf-8",
         maxBuffer: 50 * 1024 * 1024
@@ -6185,34 +6574,32 @@ async function initDefaultConfig(repositoryRoot, adapters) {
   );
   const apiTools = await listTools();
   const repoLanguages = new Set(base.metadata.languages);
+  const adapterByUuid = buildAdapterByUuid(adapters, apiTools);
   const updatedTools = [...base.tools];
   const coveredToolIds = new Set(updatedTools.map((t) => t.toolId));
   let addedTools = 0;
-  for (const adapter of adapters) {
-    if (toolsWithLocalConfig.has(adapter.id)) continue;
-    const apiTool = apiTools.find(
-      (t) => t.prefix ? t.prefix.replace(/_$/, "") === adapter.id : t.shortName === adapter.id
-    );
-    if (!apiTool) continue;
+  let addedUnsupported = 0;
+  for (const apiTool of apiTools) {
+    const adapter = adapterByUuid.get(apiTool.uuid);
+    if (adapter && toolsWithLocalConfig.has(adapter.id)) continue;
+    if (!adapter && !isTrackableTool(apiTool)) continue;
     if (!apiTool.enabledByDefault) continue;
     if (apiTool.languages.length > 0 && repoLanguages.size > 0) {
       const hasOverlap = apiTool.languages.some((lang) => repoLanguages.has(lang));
       if (!hasOverlap) continue;
     }
+    const toolId = adapter ? adapter.id : deriveApiToolId(apiTool);
+    if (coveredToolIds.has(toolId)) continue;
     let patterns = [];
     try {
       const apiPatterns = await listPatterns(apiTool.uuid);
       patterns = apiPatterns.filter((p) => p.enabled).map((p) => ({ patternId: p.id }));
     } catch {
     }
-    if (!coveredToolIds.has(adapter.id)) {
-      updatedTools.push({
-        toolId: adapter.id,
-        patterns
-      });
-      coveredToolIds.add(adapter.id);
-      addedTools++;
-    }
+    updatedTools.push({ toolId, patterns });
+    coveredToolIds.add(toolId);
+    if (adapter) addedTools++;
+    else addedUnsupported++;
   }
   const baseConfig = createCodacyConfig({
     source: "default",
@@ -6224,7 +6611,10 @@ async function initDefaultConfig(repositoryRoot, adapters) {
     repositoryRoot,
     adapters
   );
-  return { config, stats: { totalApiTools: apiTools.length, addedTools, codacyYamlApplied } };
+  return {
+    config,
+    stats: { totalApiTools: apiTools.length, addedTools, addedUnsupported, codacyYamlApplied }
+  };
 }
 async function initRemoteConfig(repositoryRoot, provider, organization, repositoryName, adapters, apiToken, onRemoteToolsFound, onToolProcessed, onIgnoredFilesFetched) {
   configureApiToken(apiToken);
@@ -6236,56 +6626,61 @@ async function initRemoteConfig(repositoryRoot, provider, organization, reposito
   } catch {
   }
   onIgnoredFilesFetched?.(ignoredFilesResult.totalFetched, ignoredFilesResult.capped);
-  const adapterByName = /* @__PURE__ */ new Map();
-  for (const adapter of adapters) {
-    adapterByName.set(adapter.id, adapter);
-    adapterByName.set(adapter.displayName.toLowerCase(), adapter);
-  }
   const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters);
   const allApiTools = await listTools();
-  const adapterByUuid = /* @__PURE__ */ new Map();
-  for (const apiTool of allApiTools) {
-    const adapter = apiTool.prefix ? adapterByName.get(apiTool.prefix.replace(/_$/, "")) : adapterByName.get(apiTool.name);
-    if (adapter) {
-      adapterByUuid.set(apiTool.uuid, adapter);
-    }
-  }
+  const adapterByUuid = buildAdapterByUuid(adapters, allApiTools);
+  const apiToolByUuid = new Map(allApiTools.map((t) => [t.uuid, t]));
   const matchedAdapterCount = remoteTools.filter((t) => adapterByUuid.has(t.uuid)).length;
   onRemoteToolsFound?.(remoteTools.length, matchedAdapterCount);
+  const fetchPatterns = async (uuid) => {
+    try {
+      const configuredPatterns = await listRepositoryToolPatterns(
+        provider,
+        organization,
+        repositoryName,
+        uuid
+      );
+      return configuredPatterns.map((cp) => {
+        const params = cp.parameters.length > 0 ? Object.fromEntries(cp.parameters.map((p) => [p.name, p.value])) : void 0;
+        return {
+          patternId: cp.patternDefinition.id,
+          ...params ? { parameters: params } : {}
+        };
+      });
+    } catch {
+      return [];
+    }
+  };
   const tools = [];
   let matchedAdapters = 0;
+  let unsupportedTools = 0;
   for (const remoteTool of remoteTools) {
-    const adapter = adapterByUuid.get(remoteTool.uuid);
-    if (!adapter) continue;
-    matchedAdapters++;
     const usesLocalConfig = remoteTool.settings.usesConfigurationFile;
-    const localConfigPath = localConfigs.get(adapter.id);
-    let patterns = [];
-    if (!usesLocalConfig) {
-      try {
-        const configuredPatterns = await listRepositoryToolPatterns(
-          provider,
-          organization,
-          repositoryName,
-          remoteTool.uuid
-        );
-        patterns = configuredPatterns.map((cp) => {
-          const params = cp.parameters.length > 0 ? Object.fromEntries(cp.parameters.map((p) => [p.name, p.value])) : void 0;
-          return {
-            patternId: cp.patternDefinition.id,
-            ...params ? { parameters: params } : {}
-          };
-        });
-      } catch {
-      }
+    const adapter = adapterByUuid.get(remoteTool.uuid);
+    if (adapter) {
+      matchedAdapters++;
+      const localConfigPath = localConfigs.get(adapter.id);
+      const patterns2 = usesLocalConfig ? [] : await fetchPatterns(remoteTool.uuid);
+      onToolProcessed?.(adapter.displayName, patterns2.length, usesLocalConfig);
+      tools.push({
+        toolId: adapter.id,
+        ...localConfigPath ? { localConfigurationFile: localConfigPath } : {},
+        // Honour local config when the API says usesConfigurationFile, OR when a
+        // local config exists and no patterns were configured (backwards-compat).
+        ...usesLocalConfig || localConfigPath && patterns2.length === 0 ? { useLocalConfigurationFile: true } : {},
+        patterns: patterns2
+      });
+      continue;
     }
-    onToolProcessed?.(adapter.displayName, patterns.length, usesLocalConfig);
+    const apiTool = apiToolByUuid.get(remoteTool.uuid);
+    if (!apiTool || !isTrackableTool(apiTool)) continue;
+    const toolId = deriveApiToolId(apiTool);
+    const patterns = usesLocalConfig ? [] : await fetchPatterns(remoteTool.uuid);
+    unsupportedTools++;
+    onToolProcessed?.(apiTool.name ?? toolId, patterns.length, usesLocalConfig);
     tools.push({
-      toolId: adapter.id,
-      ...localConfigPath ? { localConfigurationFile: localConfigPath } : {},
-      // Honour local config when the API says usesConfigurationFile, OR when a
-      // local config exists and no patterns were configured (backwards-compat).
-      ...usesLocalConfig || localConfigPath && patterns.length === 0 ? { useLocalConfigurationFile: true } : {},
+      toolId,
+      ...usesLocalConfig ? { useLocalConfigurationFile: true } : {},
       patterns
     });
   }
@@ -6311,6 +6706,7 @@ async function initRemoteConfig(repositoryRoot, provider, organization, reposito
     stats: {
       totalRemoteTools: remoteTools.length,
       matchedAdapters,
+      unsupportedTools,
       codacyYamlApplied,
       ignoredFilesCount: ignoredFilesResult.totalFetched,
       ignoredFilesCapped: ignoredFilesResult.capped
@@ -6372,7 +6768,7 @@ async function initContainerConfig(repositoryRoot, adapters) {
   }
   return createCodacyConfig({ source: "container", tools, includeFiles });
 }
-async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, onDiscoveryComplete, rawFilterString) {
+async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, onDiscoveryComplete, rawFilterString, loadUnsupportedPatterns) {
   const discoveryResult = await discover(repositoryRoot);
   onDiscoveryComplete?.(discoveryResult);
   const detectedKeys = /* @__PURE__ */ new Set();
@@ -6421,6 +6817,34 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
       });
     }
   }
+  let selectedUnsupported = 0;
+  const selectedFamilies = new Set(tools.map((t) => toolFamily(t.toolId)));
+  for (const desc of descriptors) {
+    if (!desc.unsupported) continue;
+    if (!loadUnsupportedPatterns) break;
+    if (!desc.languages.includes("*") && desc.languages.length > 0 && repoLanguages.size > 0 && !desc.languages.some((lang) => repoLanguages.has(lang))) {
+      continue;
+    }
+    const family = toolFamily(desc.id);
+    if (selectedFamilies.has(family)) continue;
+    const patternsMetadata = loadUnsupportedPatterns(desc.id);
+    if (patternsMetadata.length === 0) continue;
+    const selectedPatterns = filterAutoPatterns(
+      patternsMetadata,
+      desc.frameworkMappings,
+      detectedKeys,
+      repoLanguages,
+      filters
+    );
+    if (selectedPatterns.length > 0) {
+      tools.push({
+        toolId: desc.id,
+        patterns: selectedPatterns.map((p) => ({ patternId: p.id }))
+      });
+      selectedFamilies.add(family);
+      selectedUnsupported++;
+    }
+  }
   const baseConfig = createCodacyConfig({
     source: "auto",
     languages: discoveryResult.languages,
@@ -6439,6 +6863,7 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
       detectedFrameworks: discoveryResult.frameworks.length,
       detectedLibraries: discoveryResult.libraries.length,
       selectedTools: tools.length,
+      selectedUnsupported,
       codacyYamlApplied
     }
   };
@@ -6760,6 +7185,7 @@ function createLogger(options = {}) {
   readCodacyYaml,
   registerAdapter,
   registerLazyAdapter,
+  registerUnsupportedTool,
   resolveConfigPath,
   resolveEngineToAdapter,
   rotateLogFiles,