[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)
 
+	dedupedTools, _, _ := DeduplicateTools(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 dedupedTools {
 		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",
+	dedupedTools, uuidToName, familyToVersions := DeduplicateTools(apiTools)
+
+	for family, versions := range familyToVersions {
+		if len(versions) > 1 {
+			kept := ", "
+			for _, tool := range dedupedTools {
+				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(dedupedTools, 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(dedupedTools)
 
 	// Create main config files with all enabled API tools
-	err = createConfigurationFiles(apiTools, false)
+	err = createConfigurationFiles(dedupedTools, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -298,7 +295,7 @@ 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)
@@ -310,31 +307,32 @@ func createToolFileConfigurations(tool domain.Tool, patternConfiguration []domai
 			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:
 		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)
@@ -349,6 +347,16 @@ func createPMDConfigFile(config []domain.PatternConfiguration, toolsConfigDir st
 	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)
+}
+
+func createDefaultPMD7ConfigFile(toolsConfigDir string) error {
+	pmdConfigurationString := tools.CreatePmd7Config([]domain.PatternConfiguration{})
+	return os.WriteFile(filepath.Join(toolsConfigDir, "ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultFilePerms)
+}
+
 func createPylintConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
 	pylintConfigurationString := pylint.GeneratePylintRC(config)
 	return os.WriteFile(filepath.Join(toolsConfigDir, "pylint.rc"), []byte(pylintConfigurationString), utils.DefaultFilePerms)
@@ -429,37 +437,41 @@ 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, domain.ESLint9:
 			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:
+			if err := createPMD7ConfigFile(patternsConfig, toolsConfigDir); err != nil {
+				return fmt.Errorf("failed to create default PMD7 configuration: %w", err)
+			}
+		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 +480,49 @@ 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"
-)
+func DeduplicateTools(tools []domain.Tool) (
+	deduped []domain.Tool,
+	uuidToName map[string]string,
+	familyToVersions map[string][]string,
+) {
+	dedupedMap := 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 := dedupedMap[meta.Name]
+		if !exists || domain.SupportedToolsMetadata[current.Uuid].Priority > meta.Priority {
+			dedupedMap[meta.Name] = tool
+			uuidToName[tool.Uuid] = meta.Name
+		}
+	}
+
+	// Populate final deduped 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 dedupedMap {
+		deduped = append(deduped, tool)
+	}
 
-// AvailableTools lists all tool UUIDs supported by Codacy CLI.
-var AvailableTools = []string{
-	ESLint,
-	Trivy,
-	PMD,
-	PyLint,
-	DartAnalyzer,
-	Semgrep,
-	Lizard,
+	return
 }

domain/tool.go

@@ -16,3 +16,32 @@ type Tool struct {
 		UsesConfigurationFile bool `json:"usesConfigurationFile"`
 	} `json:"settings"`
 }
+
+const (
+	ESLint       string = "f8b29663-2cb2-498d-b923-a10c6a8c05cd"
+	ESLint9      string = "2a30ab97-477f-4769-8b88-af596ce7a94c"
+	Trivy        string = "2fd7fbe0-33f9-4ab3-ab73-e9b62404e2cb"
+	PMD          string = "9ed24812-b6ee-4a58-9004-0ed183c45b8f"
+	PMD7         string = "ed7e8287-707d-485a-a0cb-e211004432c2"
+	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"
+)
+
+type ToolInfo struct {
+	Name     string
+	Priority int // lower means newer
+}
+
+var SupportedToolsMetadata = map[string]ToolInfo{
+	ESLint9:      {Name: "eslint", Priority: 0},
+	ESLint:       {Name: "eslint", Priority: 1},
+	PMD7:         {Name: "pmd", Priority: 0},
+	PMD:          {Name: "pmd", Priority: 1},
+	PyLint:       {Name: "pylint", Priority: 0},
+	Trivy:        {Name: "trivy", Priority: 0},
+	DartAnalyzer: {Name: "dartanalyzer", Priority: 0},
+	Lizard:       {Name: "lizard", Priority: 0},
+	Semgrep:      {Name: "semgrep", Priority: 0},
+}

plugins/tool-utils.go

@@ -347,35 +347,3 @@ func getDownloadURL(urlTemplate string, fileName string, version string, mappedA
 
 	return buf.String()
 }
-
-// GetSupportedTools returns a map of supported tool names based on the tools folder
-func GetSupportedTools() (map[string]struct{}, error) {
-	supportedTools := make(map[string]struct{})
-
-	// Read all directories in the tools folder
-	entries, err := toolsFS.ReadDir("tools")
-	if err != nil {
-		return nil, fmt.Errorf("failed to read tools directory: %w", err)
-	}
-
-	// For each directory, check if it has a plugin.yaml file
-	for _, entry := range entries {
-		if !entry.IsDir() {
-			continue
-		}
-
-		toolName := entry.Name()
-		// Always use forward slashes for embedded filesystem paths
-		pluginPath := fmt.Sprintf("tools/%s/plugin.yaml", toolName)
-
-		// Check if plugin.yaml exists
-		_, err := toolsFS.ReadFile(pluginPath)
-		if err != nil {
-			continue // Skip if no plugin.yaml
-		}
-
-		supportedTools[toolName] = struct{}{}
-	}
-
-	return supportedTools, nil
-}