@codacy/analysis-runner 0.10.1 → 0.11.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { OutputFormat, Logger, AnalysisResult, ToolAdapter, AdapterDescriptor, CodacyConfig, ConfigurationFileCheckResult, CodacyToolConfig, IssueSeverity, IssueCategory, Language, DiscoveryResult, Issue, PatternSummary, LogLevel } from '@codacy/tooling';
+import { OutputFormat, Logger, AnalysisResult, ToolAdapter, AdapterDescriptor, CodacyConfig, ConfigurationFileCheckResult, CodacyToolConfig, IssueSeverity, IssueCategory, Language, DiscoveryResult, PatternEntry, Issue, PatternSummary, LogLevel } from '@codacy/tooling';
 export { AnalysisResult, OutputFormat } from '@codacy/tooling';
 
 /**
@@ -94,6 +94,17 @@ declare function registerAdapter(adapter: Readonly<ToolAdapter>): void;
  * and inspect-mode metadata display without loading the full module.
  */
 declare function registerLazyAdapter(descriptor: AdapterDescriptor, factory: AdapterFactory): void;
+/**
+ * Register an unsupported (cloud-only) tool by descriptor alone.
+ *
+ * These tools exist on Codacy Cloud but have no local analyzer in this CLI. They are
+ * registered so that `getRegisteredDescriptors()` (and therefore `info`, `init --auto`,
+ * and config generation) can see them, but they are intentionally excluded from
+ * `getRegisteredAdapters()`/`getAdapter()` since there is nothing to execute.
+ *
+ * The descriptor should have `unsupported: true`.
+ */
+declare function registerUnsupportedTool(descriptor: AdapterDescriptor): void;
 /**
  * Returns all registered adapters, optionally filtered by tool ID list.
  *
@@ -309,6 +320,53 @@ declare function parseAutoFilters(raw: string): {
     unknown: string[];
 };
 
+/**
+ * Codacy API client — thin wrappers around the generated OpenAPI client.
+ *
+ * The generated client (src/api/client/) is produced from the Codacy OpenAPI spec
+ * and should never be edited by hand. All API interactions go through this file.
+ *
+ * Authentication: Codacy uses an `api-token` header (not Bearer). We set it via
+ * `OpenAPI.HEADERS` before each call group. `configureApiToken()` must be called
+ * before any authenticated endpoint is used.
+ *
+ * Pagination: all list endpoints use cursor-based pagination. `fetchAllPages()`
+ * follows cursors until the response contains no next cursor.
+ */
+
+/** Result of fetching cloud-ignored files, with pagination cap. */
+interface IgnoredFilesResult {
+    /** File paths ignored in Codacy Cloud. */
+    files: string[];
+    /** Total number of files fetched (same as files.length). */
+    totalFetched: number;
+    /** Whether the fetch was stopped because it hit the 1000-file cap. */
+    capped: boolean;
+}
+/**
+ * Configures the API token used for authenticated requests.
+ * Must be called before `getRepository`, `listRepositoryTools`, or
+ * `listRepositoryToolPatterns`. Public endpoints (listTools, listPatterns)
+ * do not require a token.
+ */
+declare function configureApiToken(token: string): void;
+/**
+ * Validates an API token by calling the authenticated user endpoint.
+ * Returns user info on success; caller should catch errors for invalid tokens.
+ */
+declare function validateApiToken(token: string): Promise<{
+    valid: boolean;
+    name?: string;
+    email?: string;
+}>;
+/**
+ * Fetches files individually ignored in Codacy Cloud for a repository.
+ * Uses cursor-based pagination capped at 10 pages (1000 files max) to avoid
+ * unbounded fetching for repositories with very large ignore lists.
+ * Requires `configureApiToken()` to have been called.
+ */
+declare function listIgnoredFiles(provider: string, org: string, repo: string): Promise<IgnoredFilesResult>;
+
 /**
  * Init mode logic — builds a CodacyConfig from five distinct sources:
  *
@@ -348,8 +406,10 @@ declare function initLocalConfig(repositoryRoot: string, adapters: Readonly<Tool
 interface InitDefaultStats {
     /** Total number of tools listed by the Codacy API. */
     totalApiTools: number;
-    /** Number of tool entries added to the config from API defaults. */
+    /** Number of supported (local-adapter) tool entries added from API defaults. */
     addedTools: number;
+    /** Number of unsupported (cloud-only) tool entries added from API defaults. */
+    addedUnsupported: number;
     /** Whether a .codacy.yaml file was found and its exclude paths were applied. */
     codacyYamlApplied: boolean;
 }
@@ -373,6 +433,8 @@ interface InitRemoteStats {
     totalRemoteTools: number;
     /** Number of those tools that have a registered local adapter. */
     matchedAdapters: number;
+    /** Number of those tools included as unsupported (cloud-only) entries. */
+    unsupportedTools: number;
     /** Whether a .codacy.yaml file was found and its exclude paths were applied. */
     codacyYamlApplied: boolean;
     /** Number of cloud-ignored files fetched from the Codacy API. */
@@ -383,8 +445,10 @@ interface InitRemoteStats {
 /**
  * `--remote <provider> <org> <repo>` mode.
  * Fetches the full tool/pattern configuration from the repository's Codacy settings.
- * The remote config is treated as the source of truth — only tools with a registered
- * adapter are included.
+ * The remote config is treated as the source of truth: tools with a registered adapter
+ * are included as supported tools, and enabled tools without a local adapter are tracked
+ * as unsupported (cloud-only) entries (subject to the trackability filter — deprecated and
+ * client-side/standalone-only tools are skipped).
  *
  * @param onRemoteToolsFound - Optional callback invoked once after the list of enabled
  *   remote tools is fetched. Receives the total count of enabled tools and the count
@@ -418,8 +482,10 @@ interface InitAutoStats {
     detectedFrameworks: number;
     /** Number of libraries detected by discover. */
     detectedLibraries: number;
-    /** Number of tool entries added to the config. */
+    /** Number of tool entries added to the config (supported + unsupported). */
     selectedTools: number;
+    /** Number of those entries that are unsupported (cloud-only) tools. */
+    selectedUnsupported: number;
     /** Whether a .codacy.yaml file was found and its exclude paths were applied. */
     codacyYamlApplied: boolean;
 }
@@ -440,8 +506,16 @@ interface InitAutoStats {
  * ESLint core rules and their `@typescript-eslint` equivalents may both be
  * enabled, potentially causing duplicate findings. This will be addressed in v2
  * via conflict-resolution metadata in the mapping files.
+ *
+ * Unsupported (cloud-only) tools — descriptors with `unsupported: true` — are
+ * also filled when their languages overlap the detected stack. Their patterns are
+ * loaded lazily via `loadUnsupportedPatterns`; when it is not provided they are
+ * skipped. Tools that ship framework-specific patterns (e.g. PHPCS, dartanalyzer,
+ * SonarCSharp, CodeNarc) carry curated `frameworkMappings` on their descriptor, so
+ * those patterns are gated on detected frameworks exactly like supported tools;
+ * tools without mappings have every committed pattern treated as universal.
  */
-declare function initAutoConfig(repositoryRoot: string, adapters: Readonly<ToolAdapter>[], descriptors: AdapterDescriptor[], filters?: AutoFilters, onDiscoveryComplete?: (result: DiscoveryResult) => void, rawFilterString?: string): Promise<{
+declare function initAutoConfig(repositoryRoot: string, adapters: Readonly<ToolAdapter>[], descriptors: AdapterDescriptor[], filters?: AutoFilters, onDiscoveryComplete?: (result: DiscoveryResult) => void, rawFilterString?: string, loadUnsupportedPatterns?: (toolId: string) => readonly PatternEntry[]): Promise<{
     config: CodacyConfig;
     stats: InitAutoStats;
 }>;
@@ -552,53 +626,6 @@ declare function listDiffFiles(repositoryRoot: string, base?: string): string[];
  */
 declare function listPrFiles(repositoryRoot: string): string[];
 
-/**
- * Codacy API client — thin wrappers around the generated OpenAPI client.
- *
- * The generated client (src/api/client/) is produced from the Codacy OpenAPI spec
- * and should never be edited by hand. All API interactions go through this file.
- *
- * Authentication: Codacy uses an `api-token` header (not Bearer). We set it via
- * `OpenAPI.HEADERS` before each call group. `configureApiToken()` must be called
- * before any authenticated endpoint is used.
- *
- * Pagination: all list endpoints use cursor-based pagination. `fetchAllPages()`
- * follows cursors until the response contains no next cursor.
- */
-
-/** Result of fetching cloud-ignored files, with pagination cap. */
-interface IgnoredFilesResult {
-    /** File paths ignored in Codacy Cloud. */
-    files: string[];
-    /** Total number of files fetched (same as files.length). */
-    totalFetched: number;
-    /** Whether the fetch was stopped because it hit the 1000-file cap. */
-    capped: boolean;
-}
-/**
- * Configures the API token used for authenticated requests.
- * Must be called before `getRepository`, `listRepositoryTools`, or
- * `listRepositoryToolPatterns`. Public endpoints (listTools, listPatterns)
- * do not require a token.
- */
-declare function configureApiToken(token: string): void;
-/**
- * Validates an API token by calling the authenticated user endpoint.
- * Returns user info on success; caller should catch errors for invalid tokens.
- */
-declare function validateApiToken(token: string): Promise<{
-    valid: boolean;
-    name?: string;
-    email?: string;
-}>;
-/**
- * Fetches files individually ignored in Codacy Cloud for a repository.
- * Uses cursor-based pagination capped at 10 pages (1000 files max) to avoid
- * unbounded fetching for repositories with very large ignore lists.
- * Requires `configureApiToken()` to have been called.
- */
-declare function listIgnoredFiles(provider: string, org: string, repo: string): Promise<IgnoredFilesResult>;
-
 /**
  * Structured file + stderr logger for the analysis pipeline.
  *
@@ -673,4 +700,4 @@ interface DiscoverOptions {
  */
 declare function discover(repositoryRoot: string, options?: DiscoverOptions): Promise<DiscoveryResult>;
 
-export { type AdapterFactory, type AnalyzeOptions, type AutoFilters, type CategoryFilter, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ConfigOperation, type DiscoverOptions, type ExecutionMode, type IgnoredFilesResult, type InitAutoStats, type InitDefaultStats, type InitLocalStats, type InitRemoteStats, type LoggerOptions, type PatternMetadataLookup, type SeverityFilter, analyze, applyCodacyYamlExcludes, applyConfigOperation, buildToolConfig, clearAdapters, computePatternSummary, configureApiToken, createCodacyConfig, createLogger, detectLanguages, diffConfigs, discover, formatOutput, formatTextSummary, getAdapter, getRegisteredAdapters, getRegisteredDescriptors, initAutoConfig, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, intersectConfigs, listDiffFiles, listIgnoredFiles, listPrFiles, listStagedFiles, mergeConfigs, parseAutoFilters, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, resolveConfigPath, resolveEngineToAdapter, rotateLogFiles, validateApiToken, writeCodacyConfig, writeCodacyConfigFile };
+export { type AdapterFactory, type AnalyzeOptions, type AutoFilters, type CategoryFilter, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ConfigOperation, type DiscoverOptions, type ExecutionMode, type IgnoredFilesResult, type InitAutoStats, type InitDefaultStats, type InitLocalStats, type InitRemoteStats, type LoggerOptions, type PatternMetadataLookup, type SeverityFilter, analyze, applyCodacyYamlExcludes, applyConfigOperation, buildToolConfig, clearAdapters, computePatternSummary, configureApiToken, createCodacyConfig, createLogger, detectLanguages, diffConfigs, discover, formatOutput, formatTextSummary, getAdapter, getRegisteredAdapters, getRegisteredDescriptors, initAutoConfig, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, intersectConfigs, listDiffFiles, listIgnoredFiles, listPrFiles, listStagedFiles, mergeConfigs, parseAutoFilters, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, registerUnsupportedTool, resolveConfigPath, resolveEngineToAdapter, rotateLogFiles, validateApiToken, writeCodacyConfig, writeCodacyConfigFile };

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,
@@ -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() {
@@ -231,6 +243,88 @@ var import_fs = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var import_minimatch = require("minimatch");
 var MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+var PURE_EXTENSION_PATTERN = /^\*\*\/\*(\.[^*/.]+)$/;
+function pureExtensionOf(pattern) {
+  const m = PURE_EXTENSION_PATTERN.exec(pattern);
+  return m ? m[1] : null;
+}
+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;
+      }
+      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);
+      }
+    }
+    this.matchAll = matchAll;
+    this.literalPaths = literalPaths;
+    this.literalNames = literalNames;
+    this.exts = exts;
+    this.residualPath = residualPath;
+    this.residualName = residualName;
+  }
+  /** 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;
+  }
+  /**
+   * 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;
+  }
+};
 function listRepoFiles(repositoryRoot) {
   try {
     const tracked = (0, import_child_process.execSync)("git ls-files", {
@@ -280,29 +374,19 @@ function filterOversizedFiles(files, repositoryRoot, logger) {
   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;
-    });
-  });
+  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);
   }
-  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 })
-    );
-  });
+  const matcher = new CompiledMatcher(patterns);
+  if (matcher.matchAll) return files;
+  return files.filter((file) => matcher.matches(file, import_path2.default.basename(file)));
 }
 function listStagedFiles(repositoryRoot) {
   try {
@@ -392,14 +476,15 @@ function detectDefaultBranch(repositoryRoot) {
 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_minimatch.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))
     )
   );
 }
@@ -634,6 +719,20 @@ 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";
@@ -727,23 +826,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 +853,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 +920,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 +1053,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,
@@ -953,22 +1099,47 @@ async function analyze(options) {
   allFiles = filterOversizedFiles(allFiles, options.repositoryRoot, logger);
   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;
     }
-    const configCtx = makeToolContext(baseCtx, adapter, toolFiles);
-    const configCheck = await adapter.checkLocalConfigurationFile(configCtx);
+    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 };
+      }
+    }
+  );
+  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";
@@ -1301,13 +1472,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 +1504,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"),
           "-"
         ]);
       }
@@ -1954,6 +2127,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 +2174,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 +2217,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 +2272,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 +2329,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 +2394,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 +2601,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 +2659,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 +2717,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,6 +6385,37 @@ 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) {
@@ -6185,34 +6518,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 +6555,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 +6570,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 +6650,7 @@ async function initRemoteConfig(repositoryRoot, provider, organization, reposito
     stats: {
       totalRemoteTools: remoteTools.length,
       matchedAdapters,
+      unsupportedTools,
       codacyYamlApplied,
       ignoredFilesCount: ignoredFilesResult.totalFetched,
       ignoredFilesCapped: ignoredFilesResult.capped
@@ -6372,7 +6712,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 +6761,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 +6807,7 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
       detectedFrameworks: discoveryResult.frameworks.length,
       detectedLibraries: discoveryResult.libraries.length,
       selectedTools: tools.length,
+      selectedUnsupported,
       codacyYamlApplied
     }
   };
@@ -6760,6 +7129,7 @@ function createLogger(options = {}) {
   readCodacyYaml,
   registerAdapter,
   registerLazyAdapter,
+  registerUnsupportedTool,
   resolveConfigPath,
   resolveEngineToAdapter,
   rotateLogFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/analysis-runner",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Core orchestration engine for Codacy analysis",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,11 +12,11 @@
     "cli-table3": "^0.6",
     "minimatch": "10.2.4",
     "yaml": "^2.6.0",
-    "@codacy/tooling": "0.10.1"
+    "@codacy/tooling": "0.11.0"
   },
   "devDependencies": {
     "@codacy/openapi-typescript-codegen": "0.0.9",
-    "@codacy/tools-dummy-1": "0.10.1"
+    "@codacy/tools-dummy-1": "0.11.0"
   },
   "license": "MIT",
   "author": "Codacy <support@codacy.com> (https://www.codacy.com)",