fixed problem with initializition due to tools processing

Author: franciscoovazevedo

.codacy/codacy.yaml

@@ -2,7 +2,7 @@ runtimes:
     - [email protected]
     - [email protected]
 tools:
-    - eslint@8.57.0
+    - eslint@9.3.0
     - [email protected]
     - [email protected]
     - [email protected]

cmd/init.go

@@ -42,7 +42,16 @@ var initCmd = &cobra.Command{
 	Short: "Bootstraps project configuration",
 	Long:  "Bootstraps project configuration, creates codacy configuration file",
 	Run: func(cmd *cobra.Command, args []string) {
-		config.Config.CreateLocalCodacyDir()
+		// Create local codacy directory first
+		if err := config.Config.CreateLocalCodacyDir(); err != nil {
+			log.Fatalf("Failed to create local codacy directory: %v", err)
+		}
+
+		// Create tools-configs directory
+		toolsConfigDir := config.Config.ToolsConfigDirectory()
+		if err := os.MkdirAll(toolsConfigDir, 0777); err != nil {
+			log.Fatalf("Failed to create tools-configs directory: %v", err)
+		}
 
 		cliLocalMode := len(initFlags.apiToken) == 0
 
@@ -93,25 +102,27 @@ cli-config.yaml
 
 func createConfigurationFiles(tools []tools.Tool, cliLocalMode bool) error {
 	configFile, err := os.Create(config.Config.ProjectConfigFile())
-	defer configFile.Close()
 	if err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("failed to create project config file: %w", err)
 	}
+	defer configFile.Close()
 
-	_, err = configFile.WriteString(configFileTemplate(tools))
+	configContent := configFileTemplate(tools)
+	_, err = configFile.WriteString(configContent)
 	if err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("failed to write project config file: %w", err)
 	}
 
 	cliConfigFile, err := os.Create(config.Config.CliConfigFile())
-	defer cliConfigFile.Close()
 	if err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("failed to create CLI config file: %w", err)
 	}
+	defer cliConfigFile.Close()
 
-	_, err = cliConfigFile.WriteString(cliConfigFileTemplate(cliLocalMode))
+	cliConfigContent := cliConfigFileTemplate(cliLocalMode)
+	_, err = cliConfigFile.WriteString(cliConfigContent)
 	if err != nil {
-		log.Fatal(err)
+		return fmt.Errorf("failed to write CLI config file: %w", err)
 	}
 
 	return nil
@@ -162,7 +173,7 @@ func cliConfigFileTemplate(cliLocalMode bool) string {
 }
 
 func buildRepositoryConfigurationFiles(token string) error {
-	fmt.Println("Fetching repository configuration from codacy using api token ...")
+	fmt.Println("Fetching repository configuration from codacy ...")
 
 	toolsConfigDir := config.Config.ToolsConfigDirectory()
 

plugins/tool-utils.go

@@ -294,3 +294,34 @@ 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()
+		pluginPath := filepath.Join("tools", toolName, "plugin.yaml")
+
+		// Check if plugin.yaml exists
+		_, err := toolsFS.ReadFile(pluginPath)
+		if err != nil {
+			continue // Skip if no plugin.yaml
+		}
+
+		supportedTools[toolName] = struct{}{}
+	}
+
+	return supportedTools, nil
+}

plugins/tool-utils_test.go

@@ -152,3 +152,45 @@ func TestProcessToolsWithDownload(t *testing.T) {
 	}
 	assert.Contains(t, trivyInfo.DownloadURL, expectedArch)
 }
+
+func TestGetSupportedTools(t *testing.T) {
+	tests := []struct {
+		name          string
+		expectedTools []string
+		expectedError bool
+	}{
+		{
+			name: "should return supported tools",
+			expectedTools: []string{
+				"eslint",
+				"pmd",
+				"pylint",
+				"trivy",
+			},
+			expectedError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			supportedTools, err := GetSupportedTools()
+
+			if tt.expectedError {
+				assert.Error(t, err)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.NotNil(t, supportedTools)
+
+			// Check that all expected tools are supported
+			for _, expectedTool := range tt.expectedTools {
+				_, exists := supportedTools[expectedTool]
+				assert.True(t, exists, "tool %s should be supported", expectedTool)
+			}
+
+			// Check that we have exactly the expected number of tools
+			assert.Equal(t, len(tt.expectedTools), len(supportedTools), "number of supported tools should match")
+		})
+	}
+}

tools/getTools.go

@@ -1,7 +1,7 @@
 package tools
 
 import (
-	"codacy/cli-v2/config"
+	"codacy/cli-v2/plugins"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -107,13 +107,16 @@ func GetRepositoryTools(codacyBase string, apiToken string, provider string, org
 		return nil, err
 	}
 
-	cliSupportedTools := config.Config.Tools()
+	supportedTools, err := plugins.GetSupportedTools()
+	if err != nil {
+		return nil, err
+	}
 
 	// Filter enabled tools
 	var enabledTools []Tool
 	for _, tool := range response.Data {
 		if tool.Settings.Enabled {
-			if _, exists := cliSupportedTools[strings.ToLower(tool.Name)]; exists {
+			if _, exists := supportedTools[strings.ToLower(tool.Name)]; exists {
 				enabledTools = append(enabledTools, tool)
 			}
 		}