@codacy/analysis-runner 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { OutputFormat, Logger, AnalysisResult, ToolAdapter, CodacyConfig, ConfigurationFileCheckResult, CodacyToolConfig, Language, LogLevel } from '@codacy/tooling';
+import { OutputFormat, Logger, AnalysisResult, ToolAdapter, AdapterDescriptor, CodacyConfig, ConfigurationFileCheckResult, CodacyToolConfig, Language, LogLevel } from '@codacy/tooling';
 export { AnalysisResult, OutputFormat } from '@codacy/tooling';
 
 /**
@@ -60,16 +60,55 @@ interface AnalyzeOptions {
 declare function analyze(options: AnalyzeOptions): Promise<AnalysisResult>;
 
 /**
- * Tool adapter registry — stores registered adapters for discovery by the runner.
+ * Tool adapter registry — stores adapters for discovery by the runner.
  *
- * Adapters must be registered before calling analyze(). The registry is a simple
- * in-memory map keyed by adapter ID. clearAdapters() is provided for testing.
+ * Supports two registration modes:
+ * - **Eager** (`registerAdapter`): stores a fully resolved adapter. Used by tests
+ *   and programmatic consumers that already have the adapter object.
+ * - **Lazy** (`registerLazyAdapter`): stores lightweight metadata plus a factory
+ *   function that dynamically imports the full adapter module on first use. Used
+ *   by the CLI to avoid loading all 30+ adapter modules at startup.
+ *
+ * `clearAdapters()` is provided for testing.
  */
 
-/** Register a tool adapter so the runner can discover and invoke it. */
+/** Async factory that loads and returns a full ToolAdapter. */
+type AdapterFactory = () => Promise<Readonly<ToolAdapter>>;
+/**
+ * Register a fully resolved tool adapter (eager mode).
+ *
+ * The adapter is available immediately — no dynamic import needed. This is the
+ * path used by tests and by consumers that import adapters directly.
+ */
 declare function registerAdapter(adapter: Readonly<ToolAdapter>): void;
-/** Returns all registered adapters, optionally filtered by tool ID list. */
-declare function getRegisteredAdapters(toolIds?: string[]): Readonly<ToolAdapter>[];
+/**
+ * Register an adapter lazily via its descriptor and a factory function.
+ *
+ * The factory is only called when the adapter is first needed for analysis.
+ * The descriptor provides enough information for fuzzy matching, file routing,
+ * and inspect-mode metadata display without loading the full module.
+ */
+declare function registerLazyAdapter(descriptor: AdapterDescriptor, factory: AdapterFactory): void;
+/**
+ * Returns all registered adapters, optionally filtered by tool ID list.
+ *
+ * This is async because lazy entries may need to import their module on first
+ * access. For callers that only need metadata, use `getRegisteredDescriptors`.
+ */
+declare function getRegisteredAdapters(toolIds?: string[]): Promise<Readonly<ToolAdapter>[]>;
+/**
+ * Returns descriptors for all registered adapters (sync, no module loading).
+ *
+ * Useful when only metadata is needed — e.g. file routing, fuzzy matching,
+ * or init-mode tool discovery.
+ */
+declare function getRegisteredDescriptors(toolIds?: string[]): AdapterDescriptor[];
+/**
+ * Loads and returns a single adapter by its ID (exact match).
+ *
+ * Returns undefined if no adapter with that ID is registered.
+ */
+declare function getAdapter(toolId: string): Promise<Readonly<ToolAdapter> | undefined>;
 /** Remove all registered adapters. Used in tests to reset state between runs. */
 declare function clearAdapters(): void;
 
@@ -206,6 +245,10 @@ interface InitRemoteStats {
     matchedAdapters: 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. */
+    ignoredFilesCount: number;
+    /** Whether the fetch was stopped because it hit the 1000-file cap. */
+    ignoredFilesCapped: boolean;
 }
 /**
  * `--remote <provider> <org> <repo>` mode.
@@ -219,8 +262,10 @@ interface InitRemoteStats {
  * @param onToolProcessed - Optional callback invoked after each tool's patterns are
  *   fetched. Receives the adapter's display name, the number of patterns configured, and
  *   whether the tool uses a local configuration file. Useful for real-time CLI progress.
+ * @param onIgnoredFilesFetched - Optional callback invoked after cloud-ignored files are
+ *   fetched. Receives the count and whether the 1000-file cap was reached.
  */
-declare function initRemoteConfig(repositoryRoot: string, provider: string, organization: string, repositoryName: string, adapters: Readonly<ToolAdapter>[], apiToken: string, onRemoteToolsFound?: (totalEnabledTools: number, matchedAdapters: number) => void, onToolProcessed?: (displayName: string, patternCount: number, usesConfigFile: boolean) => void): Promise<{
+declare function initRemoteConfig(repositoryRoot: string, provider: string, organization: string, repositoryName: string, adapters: Readonly<ToolAdapter>[], apiToken: string, onRemoteToolsFound?: (totalEnabledTools: number, matchedAdapters: number) => void, onToolProcessed?: (displayName: string, patternCount: number, usesConfigFile: boolean) => void, onIgnoredFilesFetched?: (count: number, capped: boolean) => void): Promise<{
     config: CodacyConfig;
     stats: InitRemoteStats;
 }>;
@@ -334,6 +379,15 @@ declare function listPrFiles(repositoryRoot: string): string[];
  * 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
@@ -350,6 +404,13 @@ declare function validateApiToken(token: string): Promise<{
     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.
@@ -403,4 +464,4 @@ declare function rotateLogFiles(logsDir: string, maxFiles: number): void;
  */
 declare function createLogger(options?: LoggerOptions): Logger;
 
-export { type AnalyzeOptions, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ExecutionMode, type InitDefaultStats, type InitLocalStats, type InitRemoteStats, type LoggerOptions, analyze, applyCodacyYamlExcludes, buildToolConfig, clearAdapters, configureApiToken, createCodacyConfig, createLogger, detectLanguages, formatOutput, formatTextSummary, getRegisteredAdapters, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, listDiffFiles, listPrFiles, listStagedFiles, readCodacyConfig, readCodacyYaml, registerAdapter, resolveEngineToAdapter, rotateLogFiles, validateApiToken, writeCodacyConfig };
+export { type AdapterFactory, type AnalyzeOptions, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ExecutionMode, type IgnoredFilesResult, type InitDefaultStats, type InitLocalStats, type InitRemoteStats, type LoggerOptions, analyze, applyCodacyYamlExcludes, buildToolConfig, clearAdapters, configureApiToken, createCodacyConfig, createLogger, detectLanguages, formatOutput, formatTextSummary, getAdapter, getRegisteredAdapters, getRegisteredDescriptors, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, listDiffFiles, listIgnoredFiles, listPrFiles, listStagedFiles, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, resolveEngineToAdapter, rotateLogFiles, validateApiToken, writeCodacyConfig };

package/dist/index.js

@@ -40,17 +40,21 @@ __export(index_exports, {
   detectLanguages: () => detectLanguages,
   formatOutput: () => formatOutput,
   formatTextSummary: () => formatTextSummary,
+  getAdapter: () => getAdapter,
   getRegisteredAdapters: () => getRegisteredAdapters,
+  getRegisteredDescriptors: () => getRegisteredDescriptors,
   initContainerConfig: () => initContainerConfig,
   initDefaultConfig: () => initDefaultConfig,
   initLocalConfig: () => initLocalConfig,
   initRemoteConfig: () => initRemoteConfig,
   listDiffFiles: () => listDiffFiles,
+  listIgnoredFiles: () => listIgnoredFiles,
   listPrFiles: () => listPrFiles,
   listStagedFiles: () => listStagedFiles,
   readCodacyConfig: () => readCodacyConfig,
   readCodacyYaml: () => readCodacyYaml,
   registerAdapter: () => registerAdapter,
+  registerLazyAdapter: () => registerLazyAdapter,
   resolveEngineToAdapter: () => resolveEngineToAdapter,
   rotateLogFiles: () => rotateLogFiles,
   validateApiToken: () => validateApiToken,
@@ -62,29 +66,55 @@ module.exports = __toCommonJS(index_exports);
 var import_os = __toESM(require("os"));
 var import_path3 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
+var import_util = require("util");
 
 // src/registry.ts
-var adapters = /* @__PURE__ */ new Map();
+var import_tooling = require("@codacy/tooling");
+var entries = /* @__PURE__ */ new Map();
 function registerAdapter(adapter) {
-  adapters.set(adapter.id, adapter);
+  entries.set(adapter.id, {
+    descriptor: (0, import_tooling.extractDescriptor)(adapter),
+    factory: async () => adapter,
+    resolved: adapter
+  });
+}
+function registerLazyAdapter(descriptor, factory) {
+  entries.set(descriptor.id, { descriptor, factory });
 }
-function resolveAdapter(input) {
-  const exact = adapters.get(input);
+function resolveEntry(input) {
+  const exact = entries.get(input);
   if (exact) return exact;
   const needle = input.toLowerCase();
-  const matches = Array.from(adapters.values()).filter((a) => {
-    return a.id.toLowerCase().includes(needle) || a.displayName.toLowerCase().includes(needle);
+  const matches = Array.from(entries.values()).filter((e) => {
+    return e.descriptor.id.toLowerCase().includes(needle) || e.descriptor.displayName.toLowerCase().includes(needle);
   });
   return matches.length === 1 ? matches[0] : void 0;
 }
-function getRegisteredAdapters(toolIds) {
+async function loadAdapter(entry) {
+  if (entry.resolved) return entry.resolved;
+  entry.resolved = await entry.factory();
+  return entry.resolved;
+}
+async function getRegisteredAdapters(toolIds) {
   if (toolIds && toolIds.length > 0) {
-    return toolIds.map((id) => resolveAdapter(id)).filter((a) => a !== void 0);
+    const matched = toolIds.map((id) => resolveEntry(id)).filter((e) => e !== void 0);
+    return Promise.all(matched.map(loadAdapter));
   }
-  return Array.from(adapters.values());
+  return Promise.all(Array.from(entries.values()).map(loadAdapter));
+}
+function getRegisteredDescriptors(toolIds) {
+  if (toolIds && toolIds.length > 0) {
+    return toolIds.map((id) => resolveEntry(id)).filter((e) => e !== void 0).map((e) => e.descriptor);
+  }
+  return Array.from(entries.values()).map((e) => e.descriptor);
+}
+async function getAdapter(toolId) {
+  const entry = entries.get(toolId);
+  if (!entry) return void 0;
+  return loadAdapter(entry);
 }
 function clearAdapters() {
-  adapters.clear();
+  entries.clear();
 }
 
 // src/config.ts
@@ -429,6 +459,7 @@ async function runToolsParallel(tools, timeoutMs, concurrency, callbacks) {
 }
 
 // src/analyze.ts
+var execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
 var nullLogger = {
   debug: () => {
   },
@@ -451,26 +482,20 @@ async function analyze(options) {
     checkedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    (0, import_child_process2.execSync)("git rev-parse --is-inside-work-tree", {
-      cwd: options.repositoryRoot,
-      stdio: "pipe"
+    await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: options.repositoryRoot
     });
-  } catch {
+  } catch (err) {
+    const isGitMissing = err instanceof Error && "code" in err && err.code === "ENOENT";
+    const message = isGitMissing ? "git is not installed. Codacy analysis requires git for file discovery." : `${options.repositoryRoot} is not a git repository. Codacy analysis requires a git repository for file discovery. Run \`git init\` to initialize one.`;
+    const kind = isGitMissing ? "GitNotInstalled" : "NotAGitRepository";
     return buildResult(
       startedAt,
       options.repositoryRoot,
       mode,
       emptyCapability,
       [],
-      [
-        {
-          toolId: "runner",
-          phase: "requirementCheck",
-          kind: "NotAGitRepository",
-          message: `${options.repositoryRoot} is not a git repository. Codacy analysis requires a git repository for file discovery. Run \`git init\` to initialize one.`,
-          level: "error"
-        }
-      ],
+      [{ toolId: "runner", phase: "requirementCheck", kind, message, level: "error" }],
       []
     );
   }
@@ -515,8 +540,9 @@ async function analyze(options) {
       []
     );
   }
-  const adapters2 = getRegisteredAdapters(options.tools);
-  logger.info("Pipeline started", { mode, toolCount: adapters2.length, parallelTools, toolTimeout });
+  const requestedTools = options.tools ?? codacyConfig.tools.map((t) => t.toolId);
+  const adapters = await getRegisteredAdapters(requestedTools);
+  logger.info("Pipeline started", { mode, toolCount: adapters.length, parallelTools, toolTimeout });
   const globalDir = import_path3.default.join(import_os.default.homedir(), ".codacy");
   const baseCtx = {
     repositoryRoot: options.repositoryRoot,
@@ -528,7 +554,7 @@ async function analyze(options) {
   const ready = [];
   const unavailable = [];
   const availabilityTimeout = 6e4;
-  for (const adapter of adapters2) {
+  for (const adapter of adapters) {
     const ctx = makeToolContext(baseCtx, adapter, []);
     const checkStart = Date.now();
     logger.debug("Checking availability", { toolId: adapter.id });
@@ -600,7 +626,7 @@ async function analyze(options) {
     const installErrors = [];
     for (let i = capability.unavailable.length - 1; i >= 0; i--) {
       const status = capability.unavailable[i];
-      const adapter = adapters2.find((a) => a.id === status.toolId);
+      const adapter = adapters.find((a) => a.id === status.toolId);
       if (!adapter) continue;
       const ctx = makeToolContext(baseCtx, adapter, []);
       logger.info(`${adapter.displayName} is missing, attempting install...`);
@@ -674,7 +700,7 @@ async function analyze(options) {
   }
   if (mode === "inspect") {
     for (const tool of capability.ready) {
-      const adapter = adapters2.find((a) => a.id === tool.toolId);
+      const adapter = adapters.find((a) => a.id === tool.toolId);
       if (!adapter) continue;
       const ctx = makeToolContext(baseCtx, adapter, []);
       const availability = await adapter.checkAvailability(ctx).catch(() => null);
@@ -741,7 +767,7 @@ async function analyze(options) {
     allFiles = filterByTargetFiles(allFiles, options.files);
     logger.debug("Filtered by target files", { afterFilter: allFiles.length });
   }
-  const readyAdapters = adapters2.filter((a) => capability.ready.some((r) => r.toolId === a.id));
+  const readyAdapters = adapters.filter((a) => capability.ready.some((r) => r.toolId === a.id));
   const toolRuns = [];
   for (const adapter of readyAdapters) {
     const toolConfig = getToolConfig(codacyConfig, adapter.id);
@@ -769,6 +795,10 @@ async function analyze(options) {
       logger.debug("No files routed, skipping", { toolId: adapter.id });
       continue;
     }
+    if (!codacyToolConfig.useLocalConfigurationFile && codacyToolConfig.patterns.length === 0) {
+      logger.debug("No patterns and no local config, skipping", { toolId: adapter.id });
+      continue;
+    }
     logger.debug("Files routed to tool", { toolId: adapter.id, fileCount: toolFiles.length });
     logger.debug("Tool config resolved", {
       toolId: adapter.id,
@@ -982,8 +1012,11 @@ function formatText(result) {
       byFile.set(issue.filePath, existing);
     }
     for (const [filePath, issues] of byFile) {
+      const count = issues.length;
       lines.push("");
-      lines.push(import_ansis.default.bold.white(filePath));
+      lines.push(
+        `${import_ansis.default.bold.white(filePath)}  ${import_ansis.default.dim(`${count} issue${count !== 1 ? "s" : ""}`)}`
+      );
       for (const issue of issues) {
         if (issue.multilineContent && issue.multilineContent.length > 1) {
           formatMultilineIssue(lines, issue);
@@ -1206,7 +1239,7 @@ function colorSeverity(severity) {
 var import_promises3 = __toESM(require("fs/promises"));
 var import_path6 = __toESM(require("path"));
 var import_child_process3 = require("child_process");
-var import_tooling = require("@codacy/tooling");
+var import_tooling2 = require("@codacy/tooling");
 
 // src/codacy-yaml.ts
 var import_promises2 = __toESM(require("fs/promises"));
@@ -1249,16 +1282,16 @@ function extractStringArray(value) {
   if (!Array.isArray(value)) return [];
   return value.filter((v) => typeof v === "string");
 }
-function resolveEngineToAdapter(engineName, adapters2) {
-  const exact = adapters2.find((a) => a.id === engineName);
+function resolveEngineToAdapter(engineName, adapters) {
+  const exact = adapters.find((a) => a.id === engineName);
   if (exact) return exact.id;
   const needle = engineName.toLowerCase();
-  const matches = adapters2.filter((a) => {
+  const matches = adapters.filter((a) => {
     return a.id.toLowerCase().includes(needle) || a.displayName.toLowerCase().includes(needle);
   });
   return matches.length === 1 ? matches[0].id : void 0;
 }
-function applyCodacyYamlExcludes(config, yamlConfig, adapters2, logger) {
+function applyCodacyYamlExcludes(config, yamlConfig, adapters, logger) {
   const hasGlobalIncludes = yamlConfig.includePaths.length > 0;
   const hasEngineIncludes = Array.from(yamlConfig.engines.values()).some(
     (e) => e.includePaths.length > 0
@@ -1270,7 +1303,7 @@ function applyCodacyYamlExcludes(config, yamlConfig, adapters2, logger) {
   const tools = config.tools.map((tool) => ({ ...tool }));
   for (const [engineName, engineConfig] of yamlConfig.engines) {
     if (engineConfig.excludePaths.length === 0) continue;
-    const adapterId = resolveEngineToAdapter(engineName, adapters2);
+    const adapterId = resolveEngineToAdapter(engineName, adapters);
     if (!adapterId) {
       logger?.warn(`Could not resolve .codacy.yaml engine "${engineName}" to a registered adapter`);
       continue;
@@ -4795,6 +4828,34 @@ async function listRepositoryToolPatterns(provider, org, repo, toolUuid) {
   );
   return all;
 }
+async function listIgnoredFiles(provider, org, repo) {
+  const MAX_PAGES = 10;
+  const files = [];
+  let cursor;
+  let pages = 0;
+  while (pages < MAX_PAGES) {
+    const page = await RepositoryService.listIgnoredFiles(
+      provider,
+      org,
+      repo,
+      void 0,
+      // branch — use default branch
+      void 0,
+      // search
+      cursor,
+      100
+    );
+    files.push(...page.data.map((f) => f.filepath));
+    cursor = page.pagination?.cursor;
+    pages++;
+    if (!cursor || page.data.length === 0) break;
+  }
+  return {
+    files,
+    totalFetched: files.length,
+    capped: pages >= MAX_PAGES && cursor !== void 0
+  };
+}
 
 // src/init.ts
 async function detectLanguages(repositoryRoot) {
@@ -4813,7 +4874,7 @@ async function detectLanguages(repositoryRoot) {
   for (const file of files) {
     const basename = import_path6.default.basename(file);
     const ext = import_path6.default.extname(file).toLowerCase();
-    for (const [lang, config] of Object.entries(import_tooling.LANGUAGE_CONFIG)) {
+    for (const [lang, config] of Object.entries(import_tooling2.LANGUAGE_CONFIG)) {
       if (config.extensions.includes(ext)) {
         detected.add(lang);
       } else if (config.files.includes(basename)) {
@@ -4823,10 +4884,10 @@ async function detectLanguages(repositoryRoot) {
   }
   return Array.from(detected).sort();
 }
-async function detectLocalConfigFiles(repositoryRoot, adapters2) {
+async function detectLocalConfigFiles(repositoryRoot, adapters) {
   const found = /* @__PURE__ */ new Map();
   const checks = await Promise.allSettled(
-    adapters2.map(async (adapter) => {
+    adapters.map(async (adapter) => {
       const result = await adapter.checkLocalConfigurationFile({
         repositoryRoot,
         generatedConfigDir: import_path6.default.join(repositoryRoot, ".codacy", "generated"),
@@ -4857,17 +4918,17 @@ var silentLogger = {
   error: () => {
   }
 };
-async function enrichWithCodacyYaml(config, repositoryRoot, adapters2) {
+async function enrichWithCodacyYaml(config, repositoryRoot, adapters) {
   const yamlConfig = await readCodacyYaml(repositoryRoot);
   if (!yamlConfig) return { config, codacyYamlApplied: false };
   return {
-    config: applyCodacyYamlExcludes(config, yamlConfig, adapters2),
+    config: applyCodacyYamlExcludes(config, yamlConfig, adapters),
     codacyYamlApplied: true
   };
 }
-async function initLocalConfigBase(repositoryRoot, adapters2) {
+async function initLocalConfigBase(repositoryRoot, adapters) {
   const languages = await detectLanguages(repositoryRoot);
-  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters2);
+  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters);
   const tools = [];
   for (const [toolId, configPath] of localConfigs.entries()) {
     tools.push({
@@ -4879,17 +4940,17 @@ async function initLocalConfigBase(repositoryRoot, adapters2) {
   }
   return createCodacyConfig({ source: "local", languages, tools });
 }
-async function initLocalConfig(repositoryRoot, adapters2) {
-  const baseConfig = await initLocalConfigBase(repositoryRoot, adapters2);
+async function initLocalConfig(repositoryRoot, adapters) {
+  const baseConfig = await initLocalConfigBase(repositoryRoot, adapters);
   const { config, codacyYamlApplied } = await enrichWithCodacyYaml(
     baseConfig,
     repositoryRoot,
-    adapters2
+    adapters
   );
   return { config, stats: { codacyYamlApplied } };
 }
-async function initDefaultConfig(repositoryRoot, adapters2) {
-  const base = await initLocalConfigBase(repositoryRoot, adapters2);
+async function initDefaultConfig(repositoryRoot, adapters) {
+  const base = await initLocalConfigBase(repositoryRoot, adapters);
   const toolsWithLocalConfig = new Set(
     base.tools.filter((t) => t.useLocalConfigurationFile).map((t) => t.toolId)
   );
@@ -4898,7 +4959,7 @@ async function initDefaultConfig(repositoryRoot, adapters2) {
   const updatedTools = [...base.tools];
   const coveredToolIds = new Set(updatedTools.map((t) => t.toolId));
   let addedTools = 0;
-  for (const adapter of adapters2) {
+  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
@@ -4932,20 +4993,26 @@ async function initDefaultConfig(repositoryRoot, adapters2) {
   const { config, codacyYamlApplied } = await enrichWithCodacyYaml(
     baseConfig,
     repositoryRoot,
-    adapters2
+    adapters
   );
   return { config, stats: { totalApiTools: apiTools.length, addedTools, codacyYamlApplied } };
 }
-async function initRemoteConfig(repositoryRoot, provider, organization, repositoryName, adapters2, apiToken, onRemoteToolsFound, onToolProcessed) {
+async function initRemoteConfig(repositoryRoot, provider, organization, repositoryName, adapters, apiToken, onRemoteToolsFound, onToolProcessed, onIgnoredFilesFetched) {
   configureApiToken(apiToken);
   const repoInfo = await getRepository(provider, organization, repositoryName);
   const remoteTools = await listRepositoryTools(provider, organization, repositoryName);
+  let ignoredFilesResult = { files: [], totalFetched: 0, capped: false };
+  try {
+    ignoredFilesResult = await listIgnoredFiles(provider, organization, repositoryName);
+  } catch {
+  }
+  onIgnoredFilesFetched?.(ignoredFilesResult.totalFetched, ignoredFilesResult.capped);
   const adapterByName = /* @__PURE__ */ new Map();
-  for (const adapter of adapters2) {
+  for (const adapter of adapters) {
     adapterByName.set(adapter.id, adapter);
     adapterByName.set(adapter.displayName.toLowerCase(), adapter);
   }
-  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters2);
+  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters);
   const allApiTools = await listTools();
   const adapterByUuid = /* @__PURE__ */ new Map();
   for (const apiTool of allApiTools) {
@@ -5002,17 +5069,26 @@ async function initRemoteConfig(repositoryRoot, provider, organization, reposito
     repositoryId: repoInfo.repositoryId != null ? String(repoInfo.repositoryId) : void 0,
     repositoryName
   });
+  if (ignoredFilesResult.files.length > 0) {
+    baseConfig.exclude = [.../* @__PURE__ */ new Set([...baseConfig.exclude ?? [], ...ignoredFilesResult.files])];
+  }
   const { config, codacyYamlApplied } = await enrichWithCodacyYaml(
     baseConfig,
     repositoryRoot,
-    adapters2
+    adapters
   );
   return {
     config,
-    stats: { totalRemoteTools: remoteTools.length, matchedAdapters, codacyYamlApplied }
+    stats: {
+      totalRemoteTools: remoteTools.length,
+      matchedAdapters,
+      codacyYamlApplied,
+      ignoredFilesCount: ignoredFilesResult.totalFetched,
+      ignoredFilesCapped: ignoredFilesResult.capped
+    }
   };
 }
-async function initContainerConfig(repositoryRoot, adapters2) {
+async function initContainerConfig(repositoryRoot, adapters) {
   const codacyrcPath = import_path6.default.join(repositoryRoot, ".codacyrc");
   let raw;
   try {
@@ -5032,7 +5108,7 @@ async function initContainerConfig(repositoryRoot, adapters2) {
     }
   }
   const includeFiles = Array.isArray(parsed.files) ? parsed.files.filter((f) => typeof f === "string") : [];
-  const adapterById = new Map(adapters2.map((a) => [a.id, a]));
+  const adapterById = new Map(adapters.map((a) => [a.id, a]));
   const tools = [];
   if (Array.isArray(parsed.tools)) {
     for (const toolEntry of parsed.tools) {
@@ -5079,15 +5155,15 @@ var LEVEL_ORDER = {
   error: 3
 };
 function rotateLogFiles(logsDir, maxFiles) {
-  let entries;
+  let entries2;
   try {
-    entries = import_fs.default.readdirSync(logsDir).filter((f) => f.startsWith("analysis-") && f.endsWith(".log"));
+    entries2 = import_fs.default.readdirSync(logsDir).filter((f) => f.startsWith("analysis-") && f.endsWith(".log"));
   } catch {
     return;
   }
-  if (entries.length <= maxFiles) return;
-  entries.sort();
-  const toRemove = entries.slice(0, entries.length - maxFiles);
+  if (entries2.length <= maxFiles) return;
+  entries2.sort();
+  const toRemove = entries2.slice(0, entries2.length - maxFiles);
   for (const f of toRemove) {
     try {
       import_fs.default.unlinkSync(import_path7.default.join(logsDir, f));
@@ -5185,17 +5261,21 @@ function createLogger(options = {}) {
   detectLanguages,
   formatOutput,
   formatTextSummary,
+  getAdapter,
   getRegisteredAdapters,
+  getRegisteredDescriptors,
   initContainerConfig,
   initDefaultConfig,
   initLocalConfig,
   initRemoteConfig,
   listDiffFiles,
+  listIgnoredFiles,
   listPrFiles,
   listStagedFiles,
   readCodacyConfig,
   readCodacyYaml,
   registerAdapter,
+  registerLazyAdapter,
   resolveEngineToAdapter,
   rotateLogFiles,
   validateApiToken,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/analysis-runner",
-  "version": "0.3.0",
+  "version": "0.5.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.3.0"
+    "@codacy/tooling": "0.5.0"
   },
   "devDependencies": {
     "@codacy/openapi-typescript-codegen": "0.0.9",
-    "@codacy/tools-dummy-1": "0.3.0"
+    "@codacy/tools-dummy-1": "0.5.0"
   },
   "license": "MIT",
   "author": "Codacy <support@codacy.com> (https://www.codacy.com)",