PLUTO-1395] Handle multiple pmd/eslint versions

Author: zhamborova

cmd/analyze.go

@@ -402,7 +402,7 @@ func runLizardAnalysis(workDirectory string, pathsToCheck []string, outputFile s
 		}
 	} else {
 		fmt.Println("No configuration file found for Lizard, using default patterns, run init with repository token to get a custom configuration")
-		patterns, err = tools.FetchDefaultEnabledPatterns(Lizard)
+		patterns, err = tools.FetchDefaultEnabledPatterns(domain.Lizard)
 		if err != nil {
 			return fmt.Errorf("failed to fetch default patterns: %v", err)
 		}

cmd/init.go

@@ -123,6 +123,8 @@ func configFileTemplate(tools []domain.Tool) string {
 	toolsMap := make(map[string]bool)
 	toolVersions := make(map[string]string)
 
+	toolsWithLatestVersion, _, _ := KeepToolsWithLatestVersion(tools)
+
 	// Track needed runtimes
 	needsNode := false
 	needsPython := false
@@ -131,17 +133,17 @@ func configFileTemplate(tools []domain.Tool) string {
 
 	// Default versions
 	defaultVersions := map[string]string{
-		ESLint:       "8.57.0",
-		Trivy:        "0.59.1",
-		PyLint:       "3.3.6",
-		PMD:          "6.55.0",
-		DartAnalyzer: "3.7.2",
-		Semgrep:      "1.78.0",
-		Lizard:       "1.17.19",
+		domain.ESLint:       "8.57.0",
+		domain.Trivy:        "0.59.1",
+		domain.PyLint:       "3.3.6",
+		domain.PMD:          "6.55.0",
+		domain.DartAnalyzer: "3.7.2",
+		domain.Semgrep:      "1.78.0",
+		domain.Lizard:       "1.17.19",
 	}
 
 	// Build map of enabled tools with their versions
-	for _, tool := range tools {
+	for _, tool := range toolsWithLatestVersion {
 		toolsMap[tool.Uuid] = true
 		if tool.Version != "" {
 			toolVersions[tool.Uuid] = tool.Version
@@ -150,13 +152,14 @@ func configFileTemplate(tools []domain.Tool) string {
 		}
 
 		// Check if tool needs a runtime
-		if tool.Uuid == ESLint {
+		switch tool.Uuid {
+		case domain.ESLint, domain.ESLint9:
 			needsNode = true
-		} else if tool.Uuid == PyLint || tool.Uuid == Lizard {
+		case domain.PyLint, domain.Lizard:
 			needsPython = true
-		} else if tool.Uuid == DartAnalyzer {
+		case domain.DartAnalyzer:
 			needsDart = true
-		} else if tool.Uuid == PMD {
+		case domain.PMD, domain.PMD7:
 			needsJava = true
 		}
 	}
@@ -191,31 +194,21 @@ func configFileTemplate(tools []domain.Tool) string {
 
 	// If we have tools from the API (enabled tools), use only those
 	if len(tools) > 0 {
-		// Add only the tools that are in the API response (enabled tools)
-		uuidToName := map[string]string{
-			ESLint:       "eslint",
-			Trivy:        "trivy",
-			PyLint:       "pylint",
-			PMD:          "pmd",
-			DartAnalyzer: "dartanalyzer",
-			Semgrep:      "semgrep",
-			Lizard:       "lizard",
-		}
-
-		for uuid, name := range uuidToName {
+		for uuid, meta := range domain.SupportedToolsMetadata {
 			if toolsMap[uuid] {
-				sb.WriteString(fmt.Sprintf("    - %s@%s\n", name, toolVersions[uuid]))
+				sb.WriteString(fmt.Sprintf("    - %s@%s\n", meta.Name, toolVersions[uuid]))
 			}
 		}
+
 	} else {
 		// If no tools were specified (local mode), include all defaults
-		sb.WriteString(fmt.Sprintf("    - eslint@%s\n", defaultVersions[ESLint]))
-		sb.WriteString(fmt.Sprintf("    - trivy@%s\n", defaultVersions[Trivy]))
-		sb.WriteString(fmt.Sprintf("    - pylint@%s\n", defaultVersions[PyLint]))
-		sb.WriteString(fmt.Sprintf("    - pmd@%s\n", defaultVersions[PMD]))
-		sb.WriteString(fmt.Sprintf("    - dartanalyzer@%s\n", defaultVersions[DartAnalyzer]))
-		sb.WriteString(fmt.Sprintf("    - semgrep@%s\n", defaultVersions[Semgrep]))
-		sb.WriteString(fmt.Sprintf("    - lizard@%s\n", defaultVersions[Lizard]))
+		sb.WriteString(fmt.Sprintf("    - eslint@%s\n", defaultVersions[domain.ESLint]))
+		sb.WriteString(fmt.Sprintf("    - trivy@%s\n", defaultVersions[domain.Trivy]))
+		sb.WriteString(fmt.Sprintf("    - pylint@%s\n", defaultVersions[domain.PyLint]))
+		sb.WriteString(fmt.Sprintf("    - pmd@%s\n", defaultVersions[domain.PMD]))
+		sb.WriteString(fmt.Sprintf("    - dartanalyzer@%s\n", defaultVersions[domain.DartAnalyzer]))
+		sb.WriteString(fmt.Sprintf("    - semgrep@%s\n", defaultVersions[domain.Semgrep]))
+		sb.WriteString(fmt.Sprintf("    - lizard@%s\n", defaultVersions[domain.Lizard]))
 	}
 
 	return sb.String()
@@ -253,27 +246,31 @@ func buildRepositoryConfigurationFiles(token string) error {
 		return err
 	}
 
-	// Map UUID to tool shortname for lookup
-	uuidToName := map[string]string{
-		ESLint:       "eslint",
-		Trivy:        "trivy",
-		PyLint:       "pylint",
-		PMD:          "pmd",
-		DartAnalyzer: "dartanalyzer",
-		Lizard:       "lizard",
-		Semgrep:      "semgrep",
+	toolsWithLatestVersion, uuidToName, familyToVersions := KeepToolsWithLatestVersion(apiTools)
+
+	for family, versions := range familyToVersions {
+		if len(versions) > 1 {
+			kept := ", "
+			for _, tool := range toolsWithLatestVersion {
+				if domain.SupportedToolsMetadata[tool.Uuid].Name == family {
+					kept = tool.Version
+					break
+				}
+			}
+			fmt.Printf("⚠️  Multiple versions of '%s' detected: [%s], keeping %s\n", family, strings.Join(versions, ", "), kept)
+		}
 	}
 
 	// Generate languages configuration based on API tools response
-	if err := tools.CreateLanguagesConfigFile(apiTools, toolsConfigDir, uuidToName, initFlags); err != nil {
+	if err := tools.CreateLanguagesConfigFile(toolsWithLatestVersion, toolsConfigDir, uuidToName, initFlags); err != nil {
 		return fmt.Errorf("failed to create languages configuration file: %w", err)
 	}
 
 	// Filter out any tools that use configuration file
-	configuredToolsWithUI := tools.FilterToolsByConfigUsage(apiTools)
+	configuredToolsWithUI := tools.FilterToolsByConfigUsage(toolsWithLatestVersion)
 
 	// Create main config files with all enabled API tools
-	err = createConfigurationFiles(apiTools, false)
+	err = createConfigurationFiles(toolsWithLatestVersion, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -298,43 +295,48 @@ func buildRepositoryConfigurationFiles(token string) error {
 func createToolFileConfigurations(tool domain.Tool, patternConfiguration []domain.PatternConfiguration) error {
 	toolsConfigDir := config.Config.ToolsConfigDirectory()
 	switch tool.Uuid {
-	case ESLint:
+	case domain.ESLint, domain.ESLint9:
 		err := tools.CreateEslintConfig(toolsConfigDir, patternConfiguration)
 		if err != nil {
 			return fmt.Errorf("failed to write eslint config: %v", err)
 		}
 		fmt.Println("ESLint configuration created based on Codacy settings. Ignoring plugin rules. ESLint plugins are not supported yet.")
-	case Trivy:
+	case domain.Trivy:
 		err := createTrivyConfigFile(patternConfiguration, toolsConfigDir)
 		if err != nil {
 			return fmt.Errorf("failed to create Trivy config: %v", err)
 		}
 		fmt.Println("Trivy configuration created based on Codacy settings")
-	case PMD:
+	case domain.PMD:
 		err := createPMDConfigFile(patternConfiguration, toolsConfigDir)
 		if err != nil {
 			return fmt.Errorf("failed to create PMD config: %v", err)
 		}
-		fmt.Println("PMD configuration created based on Codacy settings")
-	case PyLint:
+	case domain.PMD7:
+		err := createPMD7ConfigFile(patternConfiguration, toolsConfigDir)
+		if err != nil {
+			return fmt.Errorf("failed to create PMD7 config: %v", err)
+		}
+		fmt.Println("PMD7 configuration created based on Codacy settings")
+	case domain.PyLint:
 		err := createPylintConfigFile(patternConfiguration, toolsConfigDir)
 		if err != nil {
 			return fmt.Errorf("failed to create Pylint config: %v", err)
 		}
 		fmt.Println("Pylint configuration created based on Codacy settings")
-	case DartAnalyzer:
+	case domain.DartAnalyzer:
 		err := createDartAnalyzerConfigFile(patternConfiguration, toolsConfigDir)
 		if err != nil {
 			return fmt.Errorf("failed to create Dart Analyzer config: %v", err)
 		}
 		fmt.Println("Dart configuration created based on Codacy settings")
-	case Semgrep:
+	case domain.Semgrep:
 		err := createSemgrepConfigFile(patternConfiguration, toolsConfigDir)
 		if err != nil {
 			return fmt.Errorf("failed to create Semgrep config: %v", err)
 		}
 		fmt.Println("Semgrep configuration created based on Codacy settings")
-	case Lizard:
+	case domain.Lizard:
 		err := createLizardConfigFile(toolsConfigDir, patternConfiguration)
 		if err != nil {
 			return fmt.Errorf("failed to create Lizard config: %v", err)
@@ -345,7 +347,12 @@ func createToolFileConfigurations(tool domain.Tool, patternConfiguration []domai
 }
 
 func createPMDConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
-	pmdConfigurationString := tools.CreatePmdConfig(config)
+	pmdConfigurationString := tools.CreatePmd6Config(config)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultFilePerms)
+}
+
+func createPMD7ConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
+	pmdConfigurationString := tools.CreatePmd7Config(config)
 	return os.WriteFile(filepath.Join(toolsConfigDir, "ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultFilePerms)
 }
 
@@ -429,37 +436,39 @@ func createLizardConfigFile(toolsConfigDir string, patternConfiguration []domain
 
 // buildDefaultConfigurationFiles creates default configuration files for all tools
 func buildDefaultConfigurationFiles(toolsConfigDir string) error {
-	for _, tool := range AvailableTools {
+	for tool := range domain.SupportedToolsMetadata {
 		patternsConfig, err := codacyclient.GetDefaultToolPatternsConfig(initFlags, tool)
 		if err != nil {
 			return fmt.Errorf("failed to get default tool patterns config: %w", err)
 		}
 		switch tool {
-		case ESLint:
+		case domain.ESLint:
 			if err := tools.CreateEslintConfig(toolsConfigDir, patternsConfig); err != nil {
 				return fmt.Errorf("failed to create eslint config file: %v", err)
 			}
-		case Trivy:
+		case domain.Trivy:
 			if err := createTrivyConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Trivy configuration: %w", err)
 			}
-		case PMD:
+		case domain.PMD:
 			if err := createPMDConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default PMD configuration: %w", err)
 			}
-		case PyLint:
+		case domain.PMD7, domain.ESLint9:
+			continue
+		case domain.PyLint:
 			if err := createPylintConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Pylint configuration: %w", err)
 			}
-		case DartAnalyzer:
+		case domain.DartAnalyzer:
 			if err := createDartAnalyzerConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Dart Analyzer configuration: %w", err)
 			}
-		case Semgrep:
+		case domain.Semgrep:
 			if err := createSemgrepConfigFile(patternsConfig, toolsConfigDir); err != nil {
 				return fmt.Errorf("failed to create default Semgrep configuration: %w", err)
 			}
-		case Lizard:
+		case domain.Lizard:
 			if err := createLizardConfigFile(toolsConfigDir, patternsConfig); err != nil {
 				return fmt.Errorf("failed to create default Lizard configuration: %w", err)
 			}
@@ -468,23 +477,50 @@ func buildDefaultConfigurationFiles(toolsConfigDir string) error {
 	return nil
 }
 
-const (
-	ESLint       string = "f8b29663-2cb2-498d-b923-a10c6a8c05cd"
-	Trivy        string = "2fd7fbe0-33f9-4ab3-ab73-e9b62404e2cb"
-	PMD          string = "9ed24812-b6ee-4a58-9004-0ed183c45b8f"
-	PyLint       string = "31677b6d-4ae0-4f56-8041-606a8d7a8e61"
-	DartAnalyzer string = "d203d615-6cf1-41f9-be5f-e2f660f7850f"
-	Semgrep      string = "6792c561-236d-41b7-ba5e-9d6bee0d548b"
-	Lizard       string = "76348462-84b3-409a-90d3-955e90abfb87"
-)
+// KeepToolsWithLatestVersion filters the tools to keep only the latest version of each tool family.
+func KeepToolsWithLatestVersion(tools []domain.Tool) (
+	toolsWithLatestVersion []domain.Tool,
+	uuidToName map[string]string,
+	familyToVersions map[string][]string,
+) {
+	latestTools := map[string]domain.Tool{}
+	uuidToName = map[string]string{}
+	seen := map[string][]domain.Tool{}
+	familyToVersions = map[string][]string{}
+
+	for _, tool := range tools {
+		meta, ok := domain.SupportedToolsMetadata[tool.Uuid]
+		if !ok {
+			continue
+		}
+
+		// Track all tools seen per family
+		seen[meta.Name] = append(seen[meta.Name], tool)
+
+		// Pick the best version
+		current, exists := latestTools[meta.Name]
+		if !exists || domain.SupportedToolsMetadata[current.Uuid].Priority > meta.Priority {
+			latestTools[meta.Name] = tool
+			uuidToName[tool.Uuid] = meta.Name
+		}
+	}
+
+	// Populate final list and version map for logging
+	for family, tools := range seen {
+		var versions []string
+		for _, t := range tools {
+			v := t.Version
+			if v == "" {
+				v = "(unknown)"
+			}
+			versions = append(versions, v)
+		}
+		familyToVersions[family] = versions
+	}
+
+	for _, tool := range latestTools {
+		toolsWithLatestVersion = append(toolsWithLatestVersion, tool)
+	}
 
-// AvailableTools lists all tool UUIDs supported by Codacy CLI.
-var AvailableTools = []string{
-	ESLint,
-	Trivy,
-	PMD,
-	PyLint,
-	DartAnalyzer,
-	Semgrep,
-	Lizard,
+	return
 }

cmd/init_test.go

@@ -35,7 +35,7 @@ func TestConfigFileTemplate(t *testing.T) {
 			name: "only eslint enabled",
 			tools: []domain.Tool{
 				{
-					Uuid:    ESLint,
+					Uuid:    domain.ESLint,
 					Name:    "eslint",
 					Version: "9.4.0",
 				},
@@ -55,7 +55,7 @@ func TestConfigFileTemplate(t *testing.T) {
 			name: "only pylint enabled",
 			tools: []domain.Tool{
 				{
-					Uuid:    PyLint,
+					Uuid:    domain.PyLint,
 					Name:    "pylint",
 					Version: "3.4.0",
 				},
@@ -75,12 +75,12 @@ func TestConfigFileTemplate(t *testing.T) {
 			name: "eslint and trivy enabled",
 			tools: []domain.Tool{
 				{
-					Uuid:    ESLint,
+					Uuid:    domain.ESLint,
 					Name:    "eslint",
 					Version: "9.4.0",
 				},
 				{
-					Uuid:    Trivy,
+					Uuid:    domain.Trivy,
 					Name:    "trivy",
 					Version: "0.60.0",
 				},
@@ -100,22 +100,22 @@ func TestConfigFileTemplate(t *testing.T) {
 			name: "all tools enabled",
 			tools: []domain.Tool{
 				{
-					Uuid:    ESLint,
+					Uuid:    domain.ESLint,
 					Name:    "eslint",
 					Version: "9.4.0",
 				},
 				{
-					Uuid:    Trivy,
+					Uuid:    domain.Trivy,
 					Name:    "trivy",
 					Version: "0.60.0",
 				},
 				{
-					Uuid:    PyLint,
+					Uuid:    domain.PyLint,
 					Name:    "pylint",
 					Version: "3.4.0",
 				},
 				{
-					Uuid:    PMD,
+					Uuid:    domain.PMD,
 					Name:    "pmd",
 					Version: "6.56.0",
 				},