fx local mode/eslint version

Author: zhamborova

cmd/init.go

@@ -224,8 +224,7 @@ func configFileTemplate(tools []domain.Tool) string {
 			sb.WriteString(fmt.Sprintf("    - %s@%s\n", runtime, runtimeVersions[runtime]))
 		}
 	} else {
-		// In local mode with no tools specified, use the default tool list from plugins.GetToolVersions()
-
+		// If no tools were specified (local mode), include all tools in sorted order
 		for toolName := range defaultVersions {
 			if runtime, ok := runtimeDependencies[toolName]; ok {
 				if toolName == "dartanalyzer" {
@@ -269,19 +268,32 @@ func configFileTemplate(tools []domain.Tool) string {
 			}
 		}
 	} else {
-		// Write tools only once in local mode
+		// If no tools were specified (local mode), include all tools in sorted order
 		var sortedTools []string
-		seen := make(map[string]bool)
-		for toolName := range defaultVersions {
-			if defaultVersions[toolName] != "" && !seen[toolName] {
-				sortedTools = append(sortedTools, toolName)
-				seen[toolName] = true
+
+		// Get supported tools from plugin system
+		supportedTools, err := plugins.GetSupportedTools()
+		if err != nil {
+			log.Printf("Warning: failed to get supported tools: %v", err)
+			return sb.String()
+		}
+
+		// Convert map keys to slice and sort them
+		for toolName := range supportedTools {
+			if version, ok := defaultVersions[toolName]; ok {
+				// Skip tools without a version
+				if version != "" {
+					sortedTools = append(sortedTools, toolName)
+				}
 			}
 		}
 		sort.Strings(sortedTools)
+
+		// Write sorted tools
 		for _, toolName := range sortedTools {
-			version := defaultVersions[toolName]
-			sb.WriteString(fmt.Sprintf("    - %s@%s\n", toolName, version))
+			if version, ok := defaultVersions[toolName]; ok {
+				sb.WriteString(fmt.Sprintf("    - %s@%s\n", toolName, version))
+			}
 		}
 	}
 

plugins/tool-utils.go

@@ -250,6 +250,23 @@ func ProcessTools(configs []ToolConfig, toolDir string, runtimes map[string]*Run
 	return result, nil
 }
 
+// GetSupportedTools returns a map of supported tool names
+func GetSupportedTools() (map[string]struct{}, error) {
+	entries, err := toolsFS.ReadDir("tools")
+	if err != nil {
+		return nil, fmt.Errorf("error reading tools directory: %w", err)
+	}
+
+	tools := make(map[string]struct{})
+	for _, entry := range entries {
+		if entry.IsDir() {
+			tools[entry.Name()] = struct{}{}
+		}
+	}
+
+	return tools, nil
+}
+
 // GetToolVersions returns a map of tool names to their default versions
 func GetToolVersions() map[string]string {
 	return GetPluginManager().GetToolVersions()

plugins/tool-utils_test.go

@@ -152,3 +152,49 @@ 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",
+				"dartanalyzer",
+				"semgrep",
+				"lizard",
+				"codacy-enigma-cli",
+			},
+			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")
+		})
+	}
+}