@codacy/analysis-runner 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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';
+import { OutputFormat, Logger, ProxyConfig, AnalysisResult, ToolAdapter, AdapterDescriptor, CodacyConfig, ConfigurationFileCheckResult, CodacyToolConfig, IssueSeverity, IssueCategory, Language, DiscoveryResult, PatternEntry, Issue, PatternSummary, LogLevel } from '@codacy/tooling';
+export { AnalysisResult, OutputFormat, ProxyConfig, configureProxy, resolveProxyConfig } from '@codacy/tooling';
 
 /**
  * Main analysis entry point — orchestrates the full analysis pipeline.
@@ -66,6 +66,15 @@ interface AnalyzeOptions {
     onToolComplete?: (toolId: string, displayName: string, issueCount: number, durationMs: number) => void;
     /** Called when a tool reports mid-execution progress (e.g. "Linting 50/200 files"). */
     onToolProgress?: (toolId: string, displayName: string, message: string) => void;
+    /**
+     * Optional proxy/TLS configuration for outbound HTTP (API calls and tool
+     * downloads). When provided, it is applied via `configureProxy` at the start of
+     * `analyze()`, installing a global fetch dispatcher. Library consumers that
+     * make API calls outside `analyze()` (e.g. init) should instead call
+     * `configureProxy` themselves once at startup. Omit to rely on environment
+     * variables (HTTP(S)_PROXY, NO_PROXY, SSL_CERT_FILE, CODACY_CLI_INSECURE).
+     */
+    proxy?: Partial<ProxyConfig>;
 }
 /**
  * Runs analysis on the given repository and returns the unified result.
@@ -181,6 +190,15 @@ declare function formatTextSummary(result: AnalysisResult, isInspect?: boolean):
  * (e.g. synced from Codacy Cloud) while testing a variant side-by-side.
  */
 declare function resolveConfigPath(repositoryRoot: string, configFile?: string): string;
+/**
+ * Resolves the absolute path to the config's baseline snapshot — the config the
+ * generator last produced, used by `update-config` to distinguish user-disabled
+ * patterns from default-off ones. It is a sibling of the config file
+ * (`<name>.json` → `<name>.baseline.json`), so `.codacy/codacy.config.json` maps
+ * to `.codacy/codacy.config.baseline.json`. It lives outside `.codacy/generated/`
+ * so it is committed and travels with the config.
+ */
+declare function resolveBaselinePath(repositoryRoot: string, configFile?: string): string;
 /**
  * Reads a CodacyConfig from disk.
  * Returns null if the file doesn't exist. Throws on parse/permission errors
@@ -189,6 +207,19 @@ declare function resolveConfigPath(repositoryRoot: string, configFile?: string):
  * Pass `configFile` to read from a non-default location.
  */
 declare function readCodacyConfig(repositoryRoot: string, configFile?: string): Promise<CodacyConfig | null>;
+/**
+ * Reads the config's baseline snapshot (see {@link resolveBaselinePath}).
+ * Returns null when no baseline exists (e.g. a config created before baselines
+ * were introduced), so `update-config` can fall back gracefully.
+ */
+declare function readBaselineConfig(repositoryRoot: string, configFile?: string): Promise<CodacyConfig | null>;
+/**
+ * Writes the config's baseline snapshot next to the config file (see
+ * {@link resolveBaselinePath}). No `.codacy/` side effects. Callers write this
+ * after every `init`/`update-config` so the next update diffs against the exact
+ * generator output. Returns the path written.
+ */
+declare function writeBaselineConfig(repositoryRoot: string, config: CodacyConfig, configFile?: string): Promise<string>;
 /**
  * Writes a CodacyConfig to disk at the exact resolved path, creating only the
  * parent directory. Unlike {@link writeCodacyConfig}, this has NO `.codacy/`
@@ -261,13 +292,23 @@ declare function createCodacyConfig(params?: {
 
 /** The set operation to apply between two configs. */
 type ConfigOperation = "merge" | "intersect" | "diff";
+/** Options for {@link mergeConfigs}. */
+interface MergeOptions {
+    /**
+     * When a pattern exists on both sides, keep dest's parameters instead of the
+     * default source-wins behavior. Used by the incremental update so the user's
+     * tuned parameters (dest) survive over freshly-generated defaults (source).
+     */
+    preferDestParameters?: boolean;
+}
 /**
  * Union of source and dest at the tool and pattern level.
  * Tools present on only one side are carried over as-is; tools on both sides are
- * combined (config-file rule, then per-tool pattern union with source parameters
- * winning). Never drops tools.
+ * combined (config-file rule, then per-tool pattern union). Parameters of a
+ * pattern on both sides come from source unless `options.preferDestParameters`.
+ * Never drops tools.
  */
-declare function mergeConfigs(source: CodacyConfig, dest: CodacyConfig): CodacyConfig;
+declare function mergeConfigs(source: CodacyConfig, dest: CodacyConfig, options?: MergeOptions): CodacyConfig;
 /**
  * Intersection of source and dest: only tools present in both, and per-tool only
  * the patterns present in both (config-file rule applies when either side uses a
@@ -286,6 +327,40 @@ declare function intersectConfigs(source: CodacyConfig, dest: CodacyConfig): Cod
 declare function diffConfigs(source: CodacyConfig, dest: CodacyConfig): CodacyConfig;
 /** Dispatches to the {@link mergeConfigs}, {@link intersectConfigs}, or {@link diffConfigs}. */
 declare function applyConfigOperation(op: ConfigOperation, source: CodacyConfig, dest: CodacyConfig): CodacyConfig;
+/**
+ * Returns a copy of `config` with tools that would do nothing removed — a tool
+ * with no enabled patterns and no native config file. Used after the incremental
+ * update so a tool whose every pattern was removed (e.g. its language/framework
+ * left the repo) drops out entirely. Config-file tools are always kept (they run
+ * from their own file). Does not mutate the input.
+ */
+declare function pruneEmptyTools(config: CodacyConfig): CodacyConfig;
+/**
+ * Incrementally updates a Codacy config while preserving user customizations.
+ *
+ * Three-way merge over the enabled-only config model (a disabled pattern is
+ * indistinguishable from a default-off one, so a naive re-generate + merge would
+ * resurrect patterns the user deliberately removed):
+ *
+ *   - `base`    — the config the generator last produced (pre-user-edit baseline)
+ *   - `current` — the user's live config (baseline + their edits)
+ *   - `next`    — the config the generator produces now (for the current stack)
+ *
+ *   added        = next − base       (genuinely new tools/patterns to add)
+ *   removed      = base − next       (tools/patterns whose stack element is gone)
+ *   result       = (current − removed) + added
+ *
+ * User-disabled patterns stay absent (they're in `base`, so never in `added`);
+ * user-tuned parameters and manual excludes ride along in `current` (dest wins on
+ * parameter conflicts via `preferDestParameters`). Identity/provenance metadata
+ * (`createdAt`, `source`, organization, …) come from `current`; `updatedAt` is
+ * refreshed and `metadata.languages` is refreshed from `next` (an incremental
+ * update is effectively a re-discovery, so the recorded stack must reflect the
+ * current repository, not the languages captured when the config was first
+ * written). Top-level `exclude` is reconciled with the same three-way logic, and
+ * any tool left with no patterns and no config file is pruned. Inputs are not mutated.
+ */
+declare function updateConfigIncremental(base: CodacyConfig, current: CodacyConfig, next: CodacyConfig): CodacyConfig;
 
 /**
  * auto-filters.ts — Parses and applies --auto filter syntax.
@@ -778,4 +853,4 @@ declare function discover(repositoryRoot: string, options?: DiscoverOptions): Pr
  */
 declare function getKnownDisplayNames(): Set<string>;
 
-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, createNullLogger, deleteCredentials, detectLanguages, diffConfigs, discover, formatOutput, formatTextSummary, getAdapter, getKnownDisplayNames, getRegisteredAdapters, getRegisteredDescriptors, initAutoConfig, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, intersectConfigs, listDiffFiles, listIgnoredFiles, listPrFiles, listStagedFiles, loadCredentials, mergeConfigs, parseAutoFilters, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, registerUnsupportedTool, resolveApiToken, resolveConfigPath, resolveEngineToAdapter, rotateLogFiles, saveCredentials, 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 MergeOptions, type PatternMetadataLookup, type SeverityFilter, analyze, applyCodacyYamlExcludes, applyConfigOperation, buildToolConfig, clearAdapters, computePatternSummary, configureApiToken, createCodacyConfig, createLogger, createNullLogger, deleteCredentials, detectLanguages, diffConfigs, discover, formatOutput, formatTextSummary, getAdapter, getKnownDisplayNames, getRegisteredAdapters, getRegisteredDescriptors, initAutoConfig, initContainerConfig, initDefaultConfig, initLocalConfig, initRemoteConfig, intersectConfigs, listDiffFiles, listIgnoredFiles, listPrFiles, listStagedFiles, loadCredentials, mergeConfigs, parseAutoFilters, pruneEmptyTools, readBaselineConfig, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, registerUnsupportedTool, resolveApiToken, resolveBaselinePath, resolveConfigPath, resolveEngineToAdapter, rotateLogFiles, saveCredentials, updateConfigIncremental, validateApiToken, writeBaselineConfig, writeCodacyConfig, writeCodacyConfigFile };

package/dist/index.js

@@ -37,6 +37,7 @@ __export(index_exports, {
   clearAdapters: () => clearAdapters,
   computePatternSummary: () => computePatternSummary,
   configureApiToken: () => configureApiToken,
+  configureProxy: () => import_tooling6.configureProxy,
   createCodacyConfig: () => createCodacyConfig,
   createLogger: () => createLogger,
   createNullLogger: () => createNullLogger,
@@ -63,17 +64,23 @@ __export(index_exports, {
   loadCredentials: () => loadCredentials,
   mergeConfigs: () => mergeConfigs,
   parseAutoFilters: () => parseAutoFilters,
+  pruneEmptyTools: () => pruneEmptyTools,
+  readBaselineConfig: () => readBaselineConfig,
   readCodacyConfig: () => readCodacyConfig,
   readCodacyYaml: () => readCodacyYaml,
   registerAdapter: () => registerAdapter,
   registerLazyAdapter: () => registerLazyAdapter,
   registerUnsupportedTool: () => registerUnsupportedTool,
   resolveApiToken: () => resolveApiToken,
+  resolveBaselinePath: () => resolveBaselinePath,
   resolveConfigPath: () => resolveConfigPath,
   resolveEngineToAdapter: () => resolveEngineToAdapter,
+  resolveProxyConfig: () => import_tooling6.resolveProxyConfig,
   rotateLogFiles: () => rotateLogFiles,
   saveCredentials: () => saveCredentials,
+  updateConfigIncremental: () => updateConfigIncremental,
   validateApiToken: () => validateApiToken,
+  writeBaselineConfig: () => writeBaselineConfig,
   writeCodacyConfig: () => writeCodacyConfig,
   writeCodacyConfigFile: () => writeCodacyConfigFile
 });
@@ -82,6 +89,7 @@ module.exports = __toCommonJS(index_exports);
 // src/analyze.ts
 var import_os2 = __toESM(require("os"));
 var import_path4 = __toESM(require("path"));
+var import_fs3 = __toESM(require("fs"));
 var import_child_process3 = require("child_process");
 var import_util = require("util");
 var import_tooling3 = require("@codacy/tooling");
@@ -154,8 +162,14 @@ var CONFIG_FILE = "codacy.config.json";
 function resolveConfigPath(repositoryRoot, configFile) {
   return configFile ? import_path.default.resolve(repositoryRoot, configFile) : import_path.default.join(repositoryRoot, CODACY_DIR, CONFIG_FILE);
 }
-async function readCodacyConfig(repositoryRoot, configFile) {
+function resolveBaselinePath(repositoryRoot, configFile) {
   const configPath = resolveConfigPath(repositoryRoot, configFile);
+  const dir = import_path.default.dirname(configPath);
+  const ext = import_path.default.extname(configPath);
+  const stem = import_path.default.basename(configPath, ext);
+  return import_path.default.join(dir, `${stem}.baseline${ext}`);
+}
+async function readConfigAtPath(configPath) {
   let raw;
   try {
     raw = await import_promises.default.readFile(configPath, "utf-8");
@@ -165,10 +179,26 @@ async function readCodacyConfig(repositoryRoot, configFile) {
     }
     throw err;
   }
-  const config = JSON.parse(raw);
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid config at ${configPath}: expected a JSON object`);
+  }
+  const config = parsed;
   coerceParameterValues(config);
   return config;
 }
+async function readCodacyConfig(repositoryRoot, configFile) {
+  return readConfigAtPath(resolveConfigPath(repositoryRoot, configFile));
+}
+async function readBaselineConfig(repositoryRoot, configFile) {
+  return readConfigAtPath(resolveBaselinePath(repositoryRoot, configFile));
+}
+async function writeBaselineConfig(repositoryRoot, config, configFile) {
+  const baselinePath = resolveBaselinePath(repositoryRoot, configFile);
+  await import_promises.default.mkdir(import_path.default.dirname(baselinePath), { recursive: true });
+  await import_promises.default.writeFile(baselinePath, JSON.stringify(config, null, 2) + "\n");
+  return baselinePath;
+}
 function coerceParameterValues(config) {
   for (const tool of config.tools) {
     for (const pattern of tool.patterns) {
@@ -557,7 +587,7 @@ function routeFilesToTool(files, adapter, toolConfig) {
 }
 function filterByTargetFiles(allFiles, targetPatterns) {
   if (targetPatterns.length === 0) return allFiles;
-  const normalized = targetPatterns.map((p) => p.replace(/^\.\//, ""));
+  const normalized = targetPatterns.map((p) => p.replace(/\\/g, "/").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("/"));
@@ -987,6 +1017,7 @@ async function mapWithConcurrency(items, concurrency, task) {
 }
 async function analyze(options) {
   const startedAt = /* @__PURE__ */ new Date();
+  if (options.proxy) (0, import_tooling3.configureProxy)(options.proxy);
   const mode = options.mode || "standard";
   const toolTimeout = options.toolTimeout || 9e5;
   const parallelTools = options.parallelTools || 1;
@@ -1023,6 +1054,26 @@ async function analyze(options) {
       []
     );
   }
+  const rootStat = import_fs3.default.statSync(options.repositoryRoot, { throwIfNoEntry: false });
+  if (!rootStat?.isDirectory()) {
+    return buildResult(
+      startedAt,
+      options.repositoryRoot,
+      mode,
+      emptyCapability,
+      [],
+      [
+        {
+          toolId: "runner",
+          phase: "requirementCheck",
+          kind: "RepositoryNotFound",
+          message: `${options.repositoryRoot} does not exist or is not a directory. Pass a path to an existing repository, or a quoted glob (e.g. "src/**/*.ts") to scope files.`,
+          level: "error"
+        }
+      ],
+      []
+    );
+  }
   try {
     await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
       cwd: options.repositoryRoot
@@ -2110,13 +2161,13 @@ function buildConfigFileTool(toolId, source, dest, listFn) {
   applyToolLevelLists(tool, source, dest, listFn);
   return tool;
 }
-function mergePatterns(source, dest) {
+function mergePatterns(source, dest, preferDest = false) {
   const sourceMap = indexByPatternId(source);
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dp of dest) {
     const sp = sourceMap.get(dp.patternId);
-    result.push(clonePattern(sp ?? dp));
+    result.push(clonePattern(preferDest ? dp : sp ?? dp));
     seen.add(dp.patternId);
   }
   for (const sp of source) {
@@ -2137,12 +2188,12 @@ function diffPatterns(source, dest) {
   const sourceIds = new Set(source.map((p) => p.patternId));
   return dest.filter((dp) => !sourceIds.has(dp.patternId)).map(clonePattern);
 }
-function combineTool(op, toolId, source, dest) {
+function combineTool(op, toolId, source, dest, preferDest = false) {
   const listFn = op === "merge" ? unionList : intersectList;
   if (usesConfigFile(source) || usesConfigFile(dest)) {
     return buildConfigFileTool(toolId, source, dest, listFn);
   }
-  const patterns = op === "merge" ? mergePatterns(source.patterns, dest.patterns) : intersectPatterns(source.patterns, dest.patterns);
+  const patterns = op === "merge" ? mergePatterns(source.patterns, dest.patterns, preferDest) : intersectPatterns(source.patterns, dest.patterns);
   const tool = { toolId, patterns };
   if (dest.useLocalConfigurationFile !== void 0) {
     tool.useLocalConfigurationFile = dest.useLocalConfigurationFile;
@@ -2162,13 +2213,14 @@ function buildResultConfig(dest, tools) {
   if (dest.includeFiles !== void 0) result.includeFiles = structuredClone(dest.includeFiles);
   return result;
 }
-function mergeConfigs(source, dest) {
+function mergeConfigs(source, dest, options = {}) {
+  const preferDest = options.preferDestParameters === true;
   const sourceMap = indexByToolId(source.tools);
   const seen = /* @__PURE__ */ new Set();
   const tools = [];
   for (const d of dest.tools) {
     const s = sourceMap.get(d.toolId);
-    tools.push(s ? combineTool("merge", d.toolId, s, d) : cloneTool(d));
+    tools.push(s ? combineTool("merge", d.toolId, s, d, preferDest) : cloneTool(d));
     seen.add(d.toolId);
   }
   for (const s of source.tools) {
@@ -2226,6 +2278,39 @@ function applyConfigOperation(op, source, dest) {
     }
   }
 }
+function pruneEmptyTools(config) {
+  const tools = config.tools.filter((t) => !isEmptyTool(t));
+  if (tools.length === config.tools.length) return config;
+  return { ...config, tools };
+}
+function threeWayList(base = [], current = [], next = []) {
+  const baseSet = new Set(base);
+  const nextSet = new Set(next);
+  const removed = new Set(base.filter((x) => !nextSet.has(x)));
+  const added = next.filter((x) => !baseSet.has(x));
+  const kept = current.filter((x) => !removed.has(x));
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const x of [...kept, ...added]) {
+    if (!seen.has(x)) {
+      seen.add(x);
+      result.push(x);
+    }
+  }
+  return result;
+}
+function updateConfigIncremental(base, current, next) {
+  const added = diffConfigs(base, next);
+  const removed = diffConfigs(next, base);
+  const afterRemoval = diffConfigs(removed, current);
+  const merged = mergeConfigs(added, afterRemoval, { preferDestParameters: true });
+  const exclude = threeWayList(base.exclude, current.exclude, next.exclude);
+  const result = { ...merged };
+  if (exclude.length > 0) result.exclude = exclude;
+  else delete result.exclude;
+  result.metadata = { ...merged.metadata, languages: [...next.metadata.languages] };
+  return pruneEmptyTools(result);
+}
 
 // src/init.ts
 var import_promises4 = __toESM(require("fs/promises"));
@@ -2540,11 +2625,24 @@ var DEPENDENCY_CATALOG = /* @__PURE__ */ new Map([
   // --- Scala — Frameworks ---
   ["play-server", { displayName: "Play Framework", kind: "framework" }],
   ["akka-actor", { displayName: "Akka", kind: "framework" }],
+  ["spray-can", { displayName: "Spray", kind: "framework" }],
   // --- Scala — Libraries ---
   ["scalatest", { displayName: "ScalaTest", kind: "library" }],
   ["specs2-core", { displayName: "Specs2", kind: "library" }],
   ["cats-core", { displayName: "Cats", kind: "library" }],
   ["circe-core", { displayName: "Circe", kind: "library" }],
+  // --- Elixir — Frameworks ---
+  ["phoenix", { displayName: "Phoenix", kind: "framework" }],
+  ["plug", { displayName: "Plug", kind: "framework" }],
+  ["plug_cowboy", { displayName: "Plug", kind: "framework" }],
+  // --- Elixir — Libraries ---
+  ["ecto", { displayName: "Ecto", kind: "library" }],
+  ["ecto_sql", { displayName: "Ecto", kind: "library" }],
+  ["phoenix_ecto", { displayName: "Ecto", kind: "library" }],
+  // --- Crystal — Frameworks ---
+  ["amber", { displayName: "Amber", kind: "framework" }],
+  ["lucky", { displayName: "Lucky", kind: "framework" }],
+  ["kemal", { displayName: "Kemal", kind: "framework" }],
   // --- Dart — Frameworks ---
   // `flutter` and `angular` appear as plain keys in pubspec.yaml. NOTE: `angular`
   // here is Dart's AngularDart. The npm package `angular` is AngularJS (1.x) — a
@@ -2682,6 +2780,31 @@ var FILE_SIGNAL_RULES = [
     name: "suitecloud.config.js",
     matches: (f) => pathBasename(f) === "suitecloud.config.js",
     classification: { displayName: "SuiteScript", kind: "platform" }
+  },
+  {
+    name: ".github/workflows",
+    matches: (f) => f.startsWith(".github/workflows/"),
+    classification: { displayName: "GitHub Actions", kind: "framework" }
+  },
+  {
+    name: ".circleci",
+    matches: (f) => f.startsWith(".circleci/"),
+    classification: { displayName: "CircleCI", kind: "framework" }
+  },
+  {
+    name: ".gitlab-ci.yml",
+    matches: (f) => f === ".gitlab-ci.yml" || f.startsWith(".gitlab/"),
+    classification: { displayName: "GitLab CI", kind: "framework" }
+  },
+  {
+    name: "bitbucket-pipelines.yml",
+    matches: (f) => f === "bitbucket-pipelines.yml",
+    classification: { displayName: "Bitbucket Pipelines", kind: "framework" }
+  },
+  {
+    name: "azure-pipelines.yml",
+    matches: (f) => f === "azure-pipelines.yml" || f === "azure-pipelines.yaml",
+    classification: { displayName: "Azure Pipelines", kind: "framework" }
   }
 ];
 function detectFileSignals(files) {
@@ -2927,6 +3050,15 @@ function parseGemfile(content) {
   }
   return deps;
 }
+function parseMixExs(content) {
+  const deps = [];
+  const depRegex = /\{:([a-zA-Z_][a-zA-Z0-9_]*)\s*,\s*"([^"]*)"/g;
+  let match;
+  while ((match = depRegex.exec(content)) !== null) {
+    deps.push({ name: match[1], version: match[2] || void 0 });
+  }
+  return deps;
+}
 function parseGoMod(content) {
   const deps = [];
   const singleRegex = /^require\s+(\S+)\s+(\S+)/gm;
@@ -2966,6 +3098,15 @@ function parseBuildGradle(content) {
   }
   return deps;
 }
+function parseBuildSbt(content) {
+  const deps = [];
+  const depRegex = /"([^"]+)"\s*%%?\s*"([^"]+)"\s*%\s*"([^"]+)"/g;
+  let match;
+  while ((match = depRegex.exec(content)) !== null) {
+    deps.push({ name: match[2], version: match[3] });
+  }
+  return deps;
+}
 function parseCargoToml(content) {
   const deps = [];
   let inDepsSection = false;
@@ -3046,6 +3187,41 @@ function parsePubspecYaml(content) {
   }
   return deps;
 }
+function parseShardYml(content) {
+  const deps = [];
+  let inSection = false;
+  let depIndent = -1;
+  let current;
+  const flush = () => {
+    if (current) deps.push(current);
+    current = void 0;
+  };
+  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) {
+      flush();
+      inSection = /^(dependencies|development_dependencies):/.test(trimmed);
+      depIndent = -1;
+      continue;
+    }
+    if (!inSection) continue;
+    if (depIndent === -1) depIndent = indent;
+    if (indent === depIndent) {
+      flush();
+      const m = trimmed.match(/^([a-zA-Z0-9_-]+)\s*:/);
+      current = m ? { name: m[1] } : void 0;
+      continue;
+    }
+    if (indent > depIndent && current) {
+      const v = trimmed.match(/^version\s*:\s*["']?(?:~>|[~^])?\s*([0-9][^"'\s]*)/);
+      if (v) current.version = v[1];
+    }
+  }
+  flush();
+  return deps;
+}
 function parseXmlDependencyElements(content, elementRegex, nameAttr) {
   const deps = [];
   const nameRegex = new RegExp(`\\b${nameAttr}\\s*=\\s*["']([^"']+)["']`, "i");
@@ -3080,11 +3256,14 @@ var MANIFEST_PARSERS = /* @__PURE__ */ new Map([
   ["pom.xml", parsePomXml],
   ["build.gradle", parseBuildGradle],
   ["build.gradle.kts", parseBuildGradle],
+  ["build.sbt", parseBuildSbt],
   ["Cargo.toml", parseCargoToml],
   ["composer.json", parseComposerJson],
   ["Podfile", parsePodfile],
   ["Package.swift", parsePackageSwift],
   ["pubspec.yaml", parsePubspecYaml],
+  ["mix.exs", parseMixExs],
+  ["shard.yml", parseShardYml],
   ["packages.config", parsePackagesConfig],
   ["Directory.Packages.props", parseCsproj]
 ]);
@@ -7133,6 +7312,11 @@ async function initContainerConfig(repositoryRoot, adapters) {
   }
   return createCodacyConfig({ source: "container", tools, includeFiles });
 }
+function hasMatchingFiles(files, filePatterns) {
+  const matcher = new CompiledMatcher(filePatterns);
+  if (matcher.matchAll) return files.length > 0;
+  return files.some((file) => matcher.matches(file, file.split("/").pop() ?? ""));
+}
 async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, onDiscoveryComplete, rawFilterString, loadUnsupportedPatterns) {
   const discoveryResult = await discover(repositoryRoot);
   onDiscoveryComplete?.(discoveryResult);
@@ -7142,6 +7326,7 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
   for (const lib of discoveryResult.libraries) detectedKeys.add(lib.displayName);
   const repoLanguages = new Set(discoveryResult.languages);
   const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters);
+  const repoFiles = listRepoFiles(repositoryRoot);
   const descriptorMap = new Map(descriptors.map((d) => [d.id, d]));
   const candidates = [];
   for (const adapter of adapters) {
@@ -7149,6 +7334,7 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
       const hasOverlap = adapter.languages.some((lang) => repoLanguages.has(lang));
       if (!hasOverlap) continue;
     }
+    if (!hasMatchingFiles(repoFiles, adapter.filePatterns)) continue;
     candidates.push(adapter);
   }
   const deduped = deduplicateToolFamilies(candidates, localConfigs);
@@ -7192,6 +7378,7 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
     }
     const family = toolFamily(desc.id);
     if (selectedFamilies.has(family)) continue;
+    if (!hasMatchingFiles(repoFiles, desc.filePatterns)) continue;
     const patternsMetadata = loadUnsupportedPatterns(desc.id);
     if (patternsMetadata.length === 0) continue;
     const selectedPatterns = filterAutoPatterns(
@@ -7410,6 +7597,9 @@ function parseAutoFilters(raw) {
   return { filters: { severities, categories }, unknown };
 }
 
+// src/index.ts
+var import_tooling6 = require("@codacy/tooling");
+
 // src/credentials.ts
 var import_crypto = __toESM(require("crypto"));
 var import_promises5 = __toESM(require("fs/promises"));
@@ -7482,6 +7672,7 @@ async function resolveApiToken() {
   clearAdapters,
   computePatternSummary,
   configureApiToken,
+  configureProxy,
   createCodacyConfig,
   createLogger,
   createNullLogger,
@@ -7508,17 +7699,23 @@ async function resolveApiToken() {
   loadCredentials,
   mergeConfigs,
   parseAutoFilters,
+  pruneEmptyTools,
+  readBaselineConfig,
   readCodacyConfig,
   readCodacyYaml,
   registerAdapter,
   registerLazyAdapter,
   registerUnsupportedTool,
   resolveApiToken,
+  resolveBaselinePath,
   resolveConfigPath,
   resolveEngineToAdapter,
+  resolveProxyConfig,
   rotateLogFiles,
   saveCredentials,
+  updateConfigIncremental,
   validateApiToken,
+  writeBaselineConfig,
   writeCodacyConfig,
   writeCodacyConfigFile
 });

package/package.json

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