feat: Enhance tool language configuration with API integration

- Added support for Trivy in the tool language mapping.
- Updated GetToolLanguageMappingFromAPI to dynamically fetch tool configurations from the public API.
- Improved error handling and logging for API failures.
- Refactored GetDefaultToolLanguageMapping to prioritize API data over hardcoded values.

This update streamlines the configuration process and ensures up-to-date tool language mappings.

Author: andrzej-janczak

integration-tests/config-discover/expected/codacy.yaml

@@ -10,3 +10,4 @@ tools:
     - [email protected]
     - [email protected]
     - [email protected]
+    - [email protected]

tools/language_config.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"fmt"
+	"log"
 	"os"
 	"path/filepath"
 	"slices"
@@ -12,83 +13,105 @@ import (
 	"codacy/cli-v2/config"
 	"codacy/cli-v2/domain"
 	"codacy/cli-v2/utils"
+	"codacy/cli-v2/utils/logger"
 
+	"github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v3"
 )
 
 //
 // This file is responsible for building the languages-config.yaml file.
 //
 
-// defaultToolLanguageMap defines the default mapping of tools to their supported languages and file extensions
-var DefaultToolLanguageMap = map[string]domain.ToolLanguageInfo{
-	"pylint": {
-		Name:       "pylint",
-		Languages:  []string{"Python"},
-		Extensions: []string{".py"},
-	},
-	"eslint": {
-		Name:       "eslint",
-		Languages:  []string{"JavaScript", "TypeScript", "JSX", "TSX"},
-		Extensions: []string{".js", ".jsx", ".ts", ".tsx"},
-	},
-	"pmd": {
-		Name:       "pmd",
-		Languages:  []string{"Java", "JavaScript", "JSP", "Velocity", "XML", "Apex", "Scala", "Ruby", "VisualForce"},
-		Extensions: []string{".java", ".js", ".jsp", ".vm", ".xml", ".cls", ".trigger", ".scala", ".rb", ".page", ".component"},
-	},
-	"trivy": {
-		Name:       "trivy",
-		Languages:  []string{"Multiple"},
-		Extensions: []string{},
-	},
-	"dartanalyzer": {
-		Name:       "dartanalyzer",
-		Languages:  []string{"Dart"},
-		Extensions: []string{".dart"},
-	},
-	"lizard": {
-		Name:       "lizard",
-		Languages:  []string{"C", "CPP", "Java", "C#", "JavaScript", "TypeScript", "VueJS", "Objective-C", "Swift", "Python", "Ruby", "TTCN-3", "PHP", "Scala", "GDScript", "Golang", "Lua", "Rust", "Fortran", "Kotlin", "Solidity", "Erlang", "Zig", "Perl"},
-		Extensions: []string{".c", ".cpp", ".cc", ".h", ".hpp", ".java", ".cs", ".js", ".jsx", ".ts", ".tsx", ".vue", ".m", ".swift", ".py", ".rb", ".ttcn", ".php", ".scala", ".gd", ".go", ".lua", ".rs", ".f", ".f90", ".kt", ".sol", ".erl", ".zig", ".pl"},
-	},
-	"semgrep": {
-		Name:       "semgrep",
-		Languages:  []string{"C", "CPP", "C#", "Generic", "Go", "Java", "JavaScript", "JSON", "Kotlin", "Python", "TypeScript", "Ruby", "Rust", "JSX", "PHP", "Scala", "Swift", "Terraform"},
-		Extensions: []string{".c", ".cpp", ".h", ".hpp", ".cs", ".go", ".java", ".js", ".json", ".kt", ".py", ".ts", ".rb", ".rs", ".jsx", ".php", ".scala", ".swift", ".tf", ".tfvars"},
-	},
-	"codacy-enigma-cli": {
-		Name:       "codacy-enigma-cli",
-		Languages:  []string{"Multiple"},
-		Extensions: []string{},
-	},
-	"revive": {
-		Name:       "revive",
-		Languages:  []string{"Go"},
-		Extensions: []string{".go"},
-	},
-}
-
-// GetToolLanguageMappingFromAPI returns tool language mapping from API data
-// This can be used instead of the hardcoded DefaultToolLanguageMap
+// GetToolLanguageMappingFromAPI gets the tool language mapping from the public API
+//
+// TODO: cache this with TTL time
 func GetToolLanguageMappingFromAPI() (map[string]domain.ToolLanguageInfo, error) {
-	configTools, err := buildToolLanguageConfigFromAPI()
+	// Get tools from API (same as buildToolLanguageConfigFromAPI)
+	allTools, err := codacyclient.GetToolsVersions()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get tools from API: %w", err)
+	}
+
+	// Get language file extensions from API
+	languageTools, err := codacyclient.GetLanguageTools()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get language tools from API: %w", err)
+	}
+
+	// Create map of language name to file extensions
+	languageExtensionsMap := make(map[string][]string)
+	for _, langTool := range languageTools {
+		languageExtensionsMap[strings.ToLower(langTool.Name)] = langTool.FileExtensions
 	}
 
-	// Convert slice to map for compatibility with existing code
+	// Build the tool to language mapping (same pattern as buildToolLanguageConfigFromAPI)
 	result := make(map[string]domain.ToolLanguageInfo)
-	for _, tool := range configTools {
-		result[tool.Name] = tool
+	supportedToolNames := make(map[string]bool)
+
+	// Get supported tool names from metadata
+	for _, meta := range domain.SupportedToolsMetadata {
+		supportedToolNames[meta.Name] = true
+	}
+
+	// Group tools by name and keep only supported ones
+	toolsByName := make(map[string]domain.Tool)
+	for _, tool := range allTools {
+		if supportedToolNames[strings.ToLower(tool.ShortName)] {
+			// Keep the tool with latest version (first one in the response)
+			if _, exists := toolsByName[strings.ToLower(tool.ShortName)]; !exists {
+				toolsByName[strings.ToLower(tool.ShortName)] = tool
+			}
+		}
+	}
+
+	// Build configuration for each supported tool
+	for toolName, tool := range toolsByName {
+		configTool := domain.ToolLanguageInfo{
+			Name:       toolName,
+			Languages:  tool.Languages,
+			Extensions: []string{},
+		}
+
+		// Build extensions from API language data
+		extensionsSet := make(map[string]struct{})
+		for _, apiLang := range tool.Languages {
+			lowerLang := strings.ToLower(apiLang)
+			if extensions, exists := languageExtensionsMap[lowerLang]; exists {
+				for _, ext := range extensions {
+					extensionsSet[ext] = struct{}{}
+				}
+			}
+		}
+
+		// Convert set to sorted slice
+		for ext := range extensionsSet {
+			configTool.Extensions = append(configTool.Extensions, ext)
+		}
+		slices.Sort(configTool.Extensions)
+
+		// Sort languages alphabetically
+		slices.Sort(configTool.Languages)
+
+		result[toolName] = configTool
 	}
 
 	return result, nil
 }
 
 // GetDefaultToolLanguageMapping returns the default mapping of tools to their supported languages and file extensions
+// This function now uses the public API instead of hardcoded mappings.
 func GetDefaultToolLanguageMapping() map[string]domain.ToolLanguageInfo {
-	return DefaultToolLanguageMap
+	// Try to get the mapping from API, fallback to hardcoded only if API fails
+	apiMapping, err := GetToolLanguageMappingFromAPI()
+	if err != nil {
+		logger.Error("Failed to get tool language mapping from API", logrus.Fields{
+			"error": err,
+		})
+		// print fatal error and exit
+		log.Fatalf("Failed to get tool language mapping from API: %v", err)
+	}
+	return apiMapping
 }
 
 // buildToolLanguageConfigFromAPI builds tool language configuration using only API data