@codacy/analysis-runner 0.19.0 → 0.20.0

package/dist/index.d.ts

@@ -218,14 +218,54 @@ declare function readBaselineConfig(repositoryRoot: string, configFile?: string)
  * {@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.
+ *
+ * Config paths are relativized exactly as in {@link writeCodacyConfigFile} — the
+ * baseline is compared against the config it snapshots, so the two must agree on
+ * the stored form.
  */
 declare function writeBaselineConfig(repositoryRoot: string, config: CodacyConfig, configFile?: string): Promise<string>;
+/**
+ * Rewrites every tool's `localConfigurationFile` to its repository-relative form,
+ * for serialization.
+ *
+ * Adapters detect their native config by joining `ctx.repositoryRoot`, so the
+ * in-memory value is absolute — and an absolute path names the machine that ran
+ * `init` (`/Users/someone/dev/repo/eslint.config.mjs`). Serializing it verbatim made
+ * `codacy.config.json` unshareable: committed and cloned elsewhere, every tool
+ * pointed at a directory that does not exist. The stored form is therefore relative
+ * (`eslint.config.mjs`), and {@link resolveLocalConfigPaths} restores absolute paths
+ * on read, so adapters see no difference.
+ *
+ * Returns a copy rather than mutating: `init` and `update-config` keep using the
+ * config object after writing it (baseline snapshot, summary output), and they need
+ * the resolved paths.
+ */
+declare function relativizeLocalConfigPaths(config: CodacyConfig, repositoryRoot: string): CodacyConfig;
+/**
+ * Resolves every stored `localConfigurationFile` against `repositoryRoot`, so
+ * adapters always receive an absolute path regardless of how the file on disk
+ * stored it.
+ *
+ * `path.resolve` covers both forms with no branching: a repo-relative path is
+ * joined to the root, and a legacy absolute path — written by a CLI version that
+ * serialized paths verbatim — is returned unchanged. Such a path is only usable on
+ * the machine that produced it; that is the pre-existing breakage this normalization
+ * stops from spreading further, not one it can repair.
+ *
+ * Mutates in place, like {@link coerceParameterValues}: both run on a config that
+ * was just parsed and has no other owner yet.
+ */
+declare function resolveLocalConfigPaths(config: CodacyConfig, repositoryRoot: string): void;
 /**
  * Writes a CodacyConfig to disk at the exact resolved path, creating only the
  * parent directory. Unlike {@link writeCodacyConfig}, this has NO `.codacy/`
  * side effects, so it is safe to write to an arbitrary location (e.g. a scratch
  * config a user is experimenting with).
  *
+ * Per-tool `localConfigurationFile` paths are stored relative to `repositoryRoot`
+ * so the written file stays machine-independent — see
+ * {@link relativizeLocalConfigPaths}.
+ *
  * Pass `configFile` to write to a non-default location.
  */
 declare function writeCodacyConfigFile(repositoryRoot: string, config: CodacyConfig, configFile?: string): Promise<string>;
@@ -1184,4 +1224,4 @@ declare function buildPayloads(issues: NormalizedIssue[], resolveShortName: (too
  */
 declare function uploadReport(options: UploadOptions): Promise<UploadResult>;
 
-export { type AdapterFactory, type AnalyzeOptions, type AutoFilters, type CategoryFilter, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ConfigOperation, type DiscoverOptions, type DiscoveryExcludes, type ExecutionMode, type IgnoredFilesResult, type InitAutoStats, type InitDefaultStats, type InitDiscoveryOptions, type InitLocalStats, type InitRemoteStats, type LoggerOptions, type MergeOptions, type NormalizedIssue, type PatternMetadataLookup, type RemoteAuth, type SeverityFilter, type UploadAuth, type UploadOptions, type UploadResult, analyze, applyCodacyYamlExcludes, applyConfigOperation, buildPayloads, 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, parseReport, pruneEmptyTools, readBaselineConfig, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, registerUnsupportedTool, resolveApiToken, resolveBaselinePath, resolveConfigPath, resolveDiscoveryExcludes, resolveEngineToAdapter, resolveHeadCommit, resolveRemoteAuth, resolveRepositoryRoot, resolveResultsApiBaseUrl, rotateLogFiles, saveCredentials, updateConfigIncremental, uploadReport, validateApiToken, writeBaselineConfig, writeCodacyConfig, writeCodacyConfigFile };
+export { type AdapterFactory, type AnalyzeOptions, type AutoFilters, type CategoryFilter, type CodacyYamlConfig, type CodacyYamlEngineConfig, type ConfigOperation, type DiscoverOptions, type DiscoveryExcludes, type ExecutionMode, type IgnoredFilesResult, type InitAutoStats, type InitDefaultStats, type InitDiscoveryOptions, type InitLocalStats, type InitRemoteStats, type LoggerOptions, type MergeOptions, type NormalizedIssue, type PatternMetadataLookup, type RemoteAuth, type SeverityFilter, type UploadAuth, type UploadOptions, type UploadResult, analyze, applyCodacyYamlExcludes, applyConfigOperation, buildPayloads, 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, parseReport, pruneEmptyTools, readBaselineConfig, readCodacyConfig, readCodacyYaml, registerAdapter, registerLazyAdapter, registerUnsupportedTool, relativizeLocalConfigPaths, resolveApiToken, resolveBaselinePath, resolveConfigPath, resolveDiscoveryExcludes, resolveEngineToAdapter, resolveHeadCommit, resolveLocalConfigPaths, resolveRemoteAuth, resolveRepositoryRoot, resolveResultsApiBaseUrl, rotateLogFiles, saveCredentials, updateConfigIncremental, uploadReport, validateApiToken, writeBaselineConfig, writeCodacyConfig, writeCodacyConfigFile };

package/dist/index.js

@@ -73,12 +73,14 @@ __export(index_exports, {
   registerAdapter: () => registerAdapter,
   registerLazyAdapter: () => registerLazyAdapter,
   registerUnsupportedTool: () => registerUnsupportedTool,
+  relativizeLocalConfigPaths: () => relativizeLocalConfigPaths,
   resolveApiToken: () => resolveApiToken,
   resolveBaselinePath: () => resolveBaselinePath,
   resolveConfigPath: () => resolveConfigPath,
   resolveDiscoveryExcludes: () => resolveDiscoveryExcludes,
   resolveEngineToAdapter: () => resolveEngineToAdapter,
   resolveHeadCommit: () => resolveHeadCommit,
+  resolveLocalConfigPaths: () => resolveLocalConfigPaths,
   resolveProxyConfig: () => import_tooling8.resolveProxyConfig,
   resolveRemoteAuth: () => resolveRemoteAuth,
   resolveRepositoryRoot: () => resolveRepositoryRoot,
@@ -177,7 +179,7 @@ function resolveBaselinePath(repositoryRoot, configFile) {
   const stem = import_path.default.basename(configPath, ext);
   return import_path.default.join(dir, `${stem}.baseline${ext}`);
 }
-async function readConfigAtPath(configPath) {
+async function readConfigAtPath(configPath, repositoryRoot) {
   let raw;
   try {
     raw = await import_promises.default.readFile(configPath, "utf-8");
@@ -192,21 +194,91 @@ async function readConfigAtPath(configPath) {
     throw new Error(`Invalid config at ${configPath}: expected a JSON object`);
   }
   const config = parsed;
+  assertConfigShape(config, configPath);
   coerceParameterValues(config);
+  resolveLocalConfigPaths(config, repositoryRoot);
   return config;
 }
+function assertConfigShape(config, configPath) {
+  const fail = (detail) => {
+    throw new Error(`Invalid config at ${configPath}: ${detail}`);
+  };
+  const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+  if (config.exclude !== void 0 && !isStringArray(config.exclude))
+    fail(`"exclude" must be an array of strings`);
+  if (config.includeFiles !== void 0 && !isStringArray(config.includeFiles))
+    fail(`"includeFiles" must be an array of strings`);
+  if (!Array.isArray(config.tools)) fail(`"tools" must be an array`);
+  config.tools.forEach((tool, i) => {
+    const at = `tools[${i}]`;
+    if (typeof tool !== "object" || tool === null || Array.isArray(tool))
+      fail(`${at} must be an object`);
+    if (typeof tool.toolId !== "string" || tool.toolId === "")
+      fail(`${at}.toolId must be a non-empty string`);
+    if (tool.localConfigurationFile !== void 0 && typeof tool.localConfigurationFile !== "string")
+      fail(`${at}.localConfigurationFile must be a string ("${tool.toolId}")`);
+    if (tool.exclude !== void 0 && !isStringArray(tool.exclude))
+      fail(`${at}.exclude must be an array of strings ("${tool.toolId}")`);
+    if (tool.extraFilePatterns !== void 0 && !isStringArray(tool.extraFilePatterns))
+      fail(`${at}.extraFilePatterns must be an array of strings ("${tool.toolId}")`);
+    if (!Array.isArray(tool.patterns)) fail(`${at}.patterns must be an array ("${tool.toolId}")`);
+    tool.patterns.forEach((pattern, j) => {
+      const patternAt = `${at}.patterns[${j}]`;
+      if (typeof pattern !== "object" || pattern === null || Array.isArray(pattern))
+        fail(`${patternAt} must be an object`);
+      if (typeof pattern.patternId !== "string" || pattern.patternId === "")
+        fail(`${patternAt}.patternId must be a non-empty string`);
+      if (pattern.parameters === void 0) return;
+      if (typeof pattern.parameters !== "object" || pattern.parameters === null || Array.isArray(pattern.parameters))
+        fail(`${patternAt}.parameters must be an object ("${pattern.patternId}")`);
+      for (const [name, value] of Object.entries(pattern.parameters)) {
+        const isPrimitive = typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+        if (!isPrimitive)
+          fail(
+            `${patternAt}.parameters.${name} must be a string, number, or boolean ("${pattern.patternId}")`
+          );
+      }
+    });
+  });
+}
 async function readCodacyConfig(repositoryRoot, configFile) {
-  return readConfigAtPath(resolveConfigPath(repositoryRoot, configFile));
+  return readConfigAtPath(resolveConfigPath(repositoryRoot, configFile), repositoryRoot);
 }
 async function readBaselineConfig(repositoryRoot, configFile) {
-  return readConfigAtPath(resolveBaselinePath(repositoryRoot, configFile));
+  return readConfigAtPath(resolveBaselinePath(repositoryRoot, configFile), repositoryRoot);
 }
 async function writeBaselineConfig(repositoryRoot, config, configFile) {
   const baselinePath = resolveBaselinePath(repositoryRoot, configFile);
+  const serializable = relativizeLocalConfigPaths(config, repositoryRoot);
   await import_promises.default.mkdir(import_path.default.dirname(baselinePath), { recursive: true });
-  await import_promises.default.writeFile(baselinePath, JSON.stringify(config, null, 2) + "\n");
+  await import_promises.default.writeFile(baselinePath, JSON.stringify(serializable, null, 2) + "\n");
   return baselinePath;
 }
+function toRepoRelativeConfigPath(configFilePath, repositoryRoot) {
+  const normalized = configFilePath.replace(/\\/g, "/");
+  if (!import_path.default.isAbsolute(configFilePath)) return normalized;
+  const relative = import_path.default.relative(repositoryRoot, configFilePath);
+  const escapesRoot = relative === ".." || relative.startsWith(`..${import_path.default.sep}`);
+  if (!relative || escapesRoot || import_path.default.isAbsolute(relative)) return normalized;
+  return relative.replace(/\\/g, "/");
+}
+function relativizeLocalConfigPaths(config, repositoryRoot) {
+  const root = import_path.default.resolve(repositoryRoot);
+  return {
+    ...config,
+    tools: config.tools.map((tool) => {
+      if (!tool.localConfigurationFile) return tool;
+      const relative = toRepoRelativeConfigPath(tool.localConfigurationFile, root);
+      return relative === tool.localConfigurationFile ? tool : { ...tool, localConfigurationFile: relative };
+    })
+  };
+}
+function resolveLocalConfigPaths(config, repositoryRoot) {
+  for (const tool of config.tools) {
+    if (!tool.localConfigurationFile) continue;
+    tool.localConfigurationFile = import_path.default.resolve(repositoryRoot, tool.localConfigurationFile);
+  }
+}
 function coerceParameterValues(config) {
   for (const tool of config.tools) {
     for (const pattern of tool.patterns) {
@@ -221,8 +293,9 @@ function coerceParameterValues(config) {
 }
 async function writeCodacyConfigFile(repositoryRoot, config, configFile) {
   const configPath = resolveConfigPath(repositoryRoot, configFile);
+  const serializable = relativizeLocalConfigPaths(config, repositoryRoot);
   await import_promises.default.mkdir(import_path.default.dirname(configPath), { recursive: true });
-  await import_promises.default.writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  await import_promises.default.writeFile(configPath, JSON.stringify(serializable, null, 2) + "\n");
   return configPath;
 }
 async function writeCodacyConfig(repositoryRoot, config, configFile) {
@@ -7990,13 +8063,15 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
         toolId: adapter.id,
         patterns: selectedPatterns.map((p) => ({ patternId: p.id }))
       };
-      tools.push(toolEntry);
-      await applyAdapterParameterSuggestions(
+      await applyAdapterConfigSuggestions(
         adapter,
         toolEntry,
         repositoryRoot,
-        filesVisibleTo(adapter.id)
+        filesVisibleTo(adapter.id),
+        repoLanguages,
+        filters
       );
+      if (toolEntry.patterns.length > 0) tools.push(toolEntry);
     }
   }
   let selectedUnsupported = 0;
@@ -8049,8 +8124,8 @@ async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, on
     }
   };
 }
-async function applyAdapterParameterSuggestions(adapter, toolEntry, repositoryRoot, repoFiles) {
-  if (!adapter.suggestParameters) return;
+async function applyAdapterConfigSuggestions(adapter, toolEntry, repositoryRoot, repoFiles, repoLanguages, filters) {
+  if (!adapter.suggestConfiguration) return;
   const logger = {
     debug() {
     },
@@ -8075,15 +8150,38 @@ async function applyAdapterParameterSuggestions(adapter, toolEntry, repositoryRo
       logger,
       runner: "local"
     };
-    const suggestions = await adapter.suggestParameters(ctx);
-    if (!suggestions) return;
-    for (const pattern of toolEntry.patterns) {
-      const params = suggestions[pattern.patternId];
-      if (!params) continue;
-      pattern.parameters = { ...pattern.parameters, ...params };
+    const suggestion = await adapter.suggestConfiguration(ctx);
+    if (!suggestion) return;
+    const staticSelection = toolEntry.patterns;
+    if (suggestion.disablePatterns?.length) {
+      const drop = new Set(suggestion.disablePatterns);
+      toolEntry.patterns = toolEntry.patterns.filter((p) => !drop.has(p.patternId));
+    }
+    if (suggestion.enablePatterns?.length) {
+      const { severityFilter, categoryFilter } = buildFilterLookups(filters);
+      const metadata = new Map((adapter.patternsMetadata ?? []).map((p) => [p.id, p]));
+      const present = new Set(toolEntry.patterns.map((p) => p.patternId));
+      for (const patternId of suggestion.enablePatterns) {
+        if (present.has(patternId)) continue;
+        const pattern = metadata.get(patternId);
+        if (!pattern) continue;
+        if (!passesSelectionGates(pattern, repoLanguages, severityFilter, categoryFilter)) continue;
+        toolEntry.patterns.push({ patternId });
+        present.add(patternId);
+      }
+    }
+    if (toolEntry.patterns.length === 0) {
+      toolEntry.patterns = staticSelection;
+    }
+    if (suggestion.parameters) {
+      for (const pattern of toolEntry.patterns) {
+        const params = suggestion.parameters[pattern.patternId];
+        if (!params) continue;
+        pattern.parameters = { ...pattern.parameters, ...params };
+      }
     }
   } catch (err) {
-    logger.error("suggestParameters failed", {
+    logger.error("suggestConfiguration failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -8109,6 +8207,13 @@ function deduplicateToolFamilies(candidates, localConfigs) {
       continue;
     }
     const withConfig = group.filter((a) => localConfigs.has(a.id));
+    const configuredFamilies = groupByToolFamily(withConfig);
+    if (configuredFamilies.size > 1) {
+      for (const members of configuredFamilies.values()) {
+        result.push(members.length === 1 ? members[0] : highestVersion(members));
+      }
+      continue;
+    }
     const pool = withConfig.length > 0 ? withConfig : group;
     if (pool.length === 1) {
       result.push(pool[0]);
@@ -8123,17 +8228,27 @@ function deduplicateToolFamilies(candidates, localConfigs) {
       group.filter((a) => a.alternativeGroupDefault).map((a) => toolFamily(a.id))
     );
     const defaultFamilyMembers = defaultFamilies.size === 1 ? pool.filter((a) => defaultFamilies.has(toolFamily(a.id))) : [];
-    const ranked = [...defaultFamilyMembers.length > 0 ? defaultFamilyMembers : pool].sort(
-      (a, b) => {
-        const majorA = parseInt(a.preferredVersion.split(".")[0], 10) || 0;
-        const majorB = parseInt(b.preferredVersion.split(".")[0], 10) || 0;
-        return majorB - majorA;
-      }
-    );
-    result.push(ranked[0]);
+    result.push(highestVersion(defaultFamilyMembers.length > 0 ? defaultFamilyMembers : pool));
   }
   return result;
 }
+function groupByToolFamily(adapters) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    const family = toolFamily(adapter.id);
+    const members = byFamily.get(family) ?? [];
+    members.push(adapter);
+    byFamily.set(family, members);
+  }
+  return byFamily;
+}
+function highestVersion(adapters) {
+  return [...adapters].sort((a, b) => {
+    const majorA = parseInt(a.preferredVersion.split(".")[0], 10) || 0;
+    const majorB = parseInt(b.preferredVersion.split(".")[0], 10) || 0;
+    return majorB - majorA;
+  })[0];
+}
 function filterAutoPatterns(patterns, mappings, detectedKeys, repoLanguages, filters) {
   const allMappedPrefixes = [];
   const prefixToKeys = /* @__PURE__ */ new Map();
@@ -8159,8 +8274,7 @@ function filterAutoPatterns(patterns, mappings, detectedKeys, repoLanguages, fil
       }
     }
   }
-  const severityFilter = filters?.severities.length ? new Map(filters.severities.map((s) => [s.level, s.all])) : void 0;
-  const categoryFilter = filters?.categories.length ? new Map(filters.categories.map((c) => [c.category, c.all])) : void 0;
+  const { severityFilter, categoryFilter } = buildFilterLookups(filters);
   const result = [];
   for (const pattern of patterns) {
     const matchedKeys = findMappedKeys(
@@ -8180,15 +8294,25 @@ function filterAutoPatterns(patterns, mappings, detectedKeys, repoLanguages, fil
         }
       }
     }
-    if (pattern.languages.length > 0 && repoLanguages.size > 0) {
-      if (!pattern.languages.some((lang) => repoLanguages.has(lang))) continue;
-    }
-    if (severityFilter && !severityFilter.has(pattern.severityLevel)) continue;
-    if (categoryFilter && !categoryFilter.has(pattern.category)) continue;
+    if (!passesSelectionGates(pattern, repoLanguages, severityFilter, categoryFilter)) continue;
     result.push(pattern);
   }
   return result;
 }
+function buildFilterLookups(filters) {
+  return {
+    severityFilter: filters?.severities.length ? new Map(filters.severities.map((s) => [s.level, s.all])) : void 0,
+    categoryFilter: filters?.categories.length ? new Map(filters.categories.map((c) => [c.category, c.all])) : void 0
+  };
+}
+function passesSelectionGates(pattern, repoLanguages, severityFilter, categoryFilter) {
+  if (pattern.languages.length > 0 && repoLanguages.size > 0) {
+    if (!pattern.languages.some((lang) => repoLanguages.has(lang))) return false;
+  }
+  if (severityFilter && !severityFilter.has(pattern.severityLevel)) return false;
+  if (categoryFilter && !categoryFilter.has(pattern.category)) return false;
+  return true;
+}
 function findMappedKeys(patternId, patternTags, allPrefixes, prefixToKeys, allTags, tagToKeys) {
   const matched = /* @__PURE__ */ new Set();
   let longestPrefix = "";
@@ -8656,12 +8780,14 @@ async function safeReadBody(res) {
   registerAdapter,
   registerLazyAdapter,
   registerUnsupportedTool,
+  relativizeLocalConfigPaths,
   resolveApiToken,
   resolveBaselinePath,
   resolveConfigPath,
   resolveDiscoveryExcludes,
   resolveEngineToAdapter,
   resolveHeadCommit,
+  resolveLocalConfigPaths,
   resolveProxyConfig,
   resolveRemoteAuth,
   resolveRepositoryRoot,

package/package.json

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