move tools defaults

Author: andrzej-janczak

cmd/init.go

@@ -159,16 +159,8 @@ func configFileTemplate(tools []tools.Tool) string {
 	// Track needed runtimes
 	neededRuntimes := make(map[string]bool)
 
-	// Default versions
-	defaultVersions := map[string]string{
-		ESLint:       "9.3.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",
-	}
+	// Get tool versions from plugin configurations
+	defaultVersions := plugins.GetToolVersions()
 
 	// Get runtime versions all at once
 	runtimeVersions := plugins.GetRuntimeVersions()
@@ -179,28 +171,11 @@ func configFileTemplate(tools []tools.Tool) string {
 		if tool.Version != "" {
 			toolVersions[tool.Uuid] = tool.Version
 		} else {
-			toolVersions[tool.Uuid] = defaultVersions[tool.Uuid]
-		}
-	}
-
-	// Convert tools to ToolConfig format
-	var toolConfigs []plugins.ToolConfig
-	for _, tool := range tools {
-		toolName := toolNameMap[tool.Uuid]
-		if toolName == "" {
-			log.Printf("Warning: Unknown tool UUID %s", tool.Uuid)
-			continue
-		}
-
-		version := tool.Version
-		if version == "" {
-			version = defaultVersions[tool.Uuid]
+			toolName := toolNameMap[tool.Uuid]
+			if defaultVersion, ok := defaultVersions[toolName]; ok {
+				toolVersions[tool.Uuid] = defaultVersion
+			}
 		}
-
-		toolConfigs = append(toolConfigs, plugins.ToolConfig{
-			Name:    toolName,
-			Version: version,
-		})
 	}
 
 	// Process tools to get their configurations
@@ -214,18 +189,6 @@ func configFileTemplate(tools []tools.Tool) string {
 		runtimeInfos[runtime] = runtimeInfo
 	}
 
-	toolInfos, err := plugins.ProcessTools(toolConfigs, os.TempDir(), runtimeInfos)
-	if err != nil {
-		log.Printf("Warning: Failed to process tool configurations: %v", err)
-	} else {
-		// Get required runtimes from tool configurations
-		for _, info := range toolInfos {
-			if info.Runtime != "" {
-				neededRuntimes[info.Runtime] = true
-			}
-		}
-	}
-
 	// Start building the YAML content
 	var sb strings.Builder
 	sb.WriteString("runtimes:\n")
@@ -277,28 +240,33 @@ func configFileTemplate(tools []tools.Tool) string {
 			// Find the UUID for this tool name to get its version
 			for uuid, toolName := range toolNameMap {
 				if toolName == name && toolsMap[uuid] {
-					sb.WriteString(fmt.Sprintf("    - %s@%s\n", name, toolVersions[uuid]))
+					version := toolVersions[uuid]
+					sb.WriteString(fmt.Sprintf("    - %s@%s\n", name, version))
 					break
 				}
 			}
 		}
 	} else {
-		// If no tools were specified (local mode), include all defaults in sorted order
-		tools := []struct {
-			name string
-			uuid string
-		}{
-			{"dartanalyzer", DartAnalyzer},
-			{"eslint", ESLint},
-			{"lizard", Lizard},
-			{"pmd", PMD},
-			{"pylint", PyLint},
-			{"semgrep", Semgrep},
-			{"trivy", Trivy},
+		// If no tools were specified (local mode), include all tools in sorted order
+		var sortedTools []string
+		for _, name := range []string{
+			"dartanalyzer",
+			"eslint",
+			"lizard",
+			"pmd",
+			"pylint",
+			"semgrep",
+			"trivy",
+		} {
+			if version, ok := defaultVersions[name]; ok {
+				sortedTools = append(sortedTools, fmt.Sprintf("%s@%s", name, version))
+			}
 		}
+		sort.Strings(sortedTools)
 
-		for _, tool := range tools {
-			sb.WriteString(fmt.Sprintf("    - %s@%s\n", tool.name, defaultVersions[tool.uuid]))
+		// Write sorted tools
+		for _, tool := range sortedTools {
+			sb.WriteString(fmt.Sprintf("    - %s\n", tool))
 		}
 	}
 

plugins/tool-utils.go

@@ -70,6 +70,7 @@ type DownloadConfig struct {
 type ToolPluginConfig struct {
 	Name            string             `yaml:"name"`
 	Description     string             `yaml:"description"`
+	DefaultVersion  string             `yaml:"default_version"`
 	Runtime         string             `yaml:"runtime"`
 	RuntimeBinaries RuntimeBinaries    `yaml:"runtime_binaries"`
 	Installation    InstallationConfig `yaml:"installation"`
@@ -379,3 +380,39 @@ func GetSupportedTools() (map[string]struct{}, error) {
 
 	return supportedTools, nil
 }
+
+// GetToolVersions returns a map of tool names to their default versions
+func GetToolVersions() map[string]string {
+	versions := make(map[string]string)
+
+	// Read the tools directory from embedded filesystem
+	entries, err := toolsFS.ReadDir("tools")
+	if err != nil {
+		return versions
+	}
+
+	// Process each tool directory
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		tool := entry.Name()
+		pluginPath := fmt.Sprintf("tools/%s/plugin.yaml", tool)
+		data, err := toolsFS.ReadFile(pluginPath)
+		if err != nil {
+			continue
+		}
+
+		var config ToolPluginConfig
+		if err := yaml.Unmarshal(data, &config); err != nil {
+			continue
+		}
+
+		if config.DefaultVersion != "" {
+			versions[tool] = config.DefaultVersion
+		}
+	}
+
+	return versions
+}

plugins/tools/dartanalyzer/plugin.yaml

@@ -1,5 +1,6 @@
 name: dartanalyzer
-description: Dart Analyzer
+description: The Dart analyzer enforces the Dart style guide and other conventions. It's a static analysis tool that looks for potential errors and enforces style guidelines.
+default_version: 3.7.2
 runtime: "{{.Runtime}}"
 runtime_binaries:
   package_manager: dart

plugins/tools/eslint/plugin.yaml

@@ -1,5 +1,6 @@
 name: eslint
-description: ESLint JavaScript linter
+description: ESLint is a tool for identifying and reporting on patterns found in ECMAScript/JavaScript code.
+default_version: 9.3.0
 runtime: node
 runtime_binaries:
   package_manager: npm

plugins/tools/lizard/plugin.yaml

@@ -1,5 +1,6 @@
 name: lizard
-description: Lizard code complexity analyzer
+description: Lizard is an extensible Cyclomatic Complexity Analyzer for many programming languages.
+default_version: 1.17.19
 runtime: python
 runtime_binaries:
   package_manager: python3

plugins/tools/pmd/plugin.yaml

@@ -1,5 +1,6 @@
 name: pmd
-description: PMD - An extensible cross-language static code analyzer
+description: PMD is a source code analyzer that finds common programming flaws like unused variables, empty catch blocks, unnecessary object creation, and so forth.
+default_version: 6.55.0
 runtime: java
 runtime_binaries:
   execution: java

plugins/tools/pylint/plugin.yaml

@@ -1,5 +1,6 @@
 name: pylint
-description: Python linter
+description: Pylint is a Python static code analysis tool which looks for programming errors, helps enforcing a coding standard, sniffs for code smells and offers simple refactoring suggestions.
+default_version: 3.3.6
 runtime: python
 runtime_binaries:
   package_manager: python3

plugins/tools/semgrep/plugin.yaml

@@ -1,5 +1,6 @@
 name: semgrep
-description: Static Analysis Security Testing (SAST) tool
+description: Semgrep is a fast, open-source, static analysis tool for finding bugs and enforcing code standards at editor, commit, and CI time.
+default_version: 1.78.0
 runtime: python
 runtime_binaries:
   package_manager: python3

plugins/tools/trivy/plugin.yaml

@@ -1,5 +1,6 @@
 name: trivy
-description: Trivy vulnerability scanner
+description: Trivy is a comprehensive security scanner for containers and other artifacts.
+default_version: 0.59.1
 download:
   url_template: "https://github.com/aquasecurity/trivy/releases/download/v{{.Version}}/trivy_{{.Version}}_{{.OS}}-{{.Arch}}.{{.Extension}}"
   file_name_template: "trivy_{{.Version}}_{{.OS}}_{{.Arch}}"

tools/getTools.go

@@ -2,13 +2,16 @@ package tools
 
 import (
 	"codacy/cli-v2/plugins"
+	"codacy/cli-v2/utils/logger"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 	"time"
+
+	"github.com/sirupsen/logrus"
 )
 
 func enrichToolsWithVersion(tools []Tool) ([]Tool, error) {
@@ -118,18 +121,26 @@ func GetRepositoryTools(codacyBase string, apiToken string, provider string, org
 
 	// Filter enabled tools
 	var enabledTools []Tool
+	var unsupportedTools []string
+
 	for _, tool := range response.Data {
 		if tool.Settings.Enabled {
 			toolName := strings.ToLower(tool.Name)
-			fmt.Printf("Checking tool %s (lowercase: %s)\n", tool.Name, toolName)
 			if _, exists := supportedTools[toolName]; exists {
 				enabledTools = append(enabledTools, tool)
 			} else {
-				fmt.Printf("Tool %s not found in supported tools\n", tool.Name)
+				unsupportedTools = append(unsupportedTools, tool.Name)
 			}
 		}
 	}
 
+	// Log unsupported tools once
+	if len(unsupportedTools) > 0 {
+		logger.Warn("Some tools are not supported", logrus.Fields{
+			"unsupported_tools": strings.Join(unsupportedTools, ", "),
+		})
+	}
+
 	return enrichToolsWithVersion(enabledTools)
 }