fix: languages-config.yaml is created by init command

- Added language configuration file generation during init using API data
- Created YAML config in compact format mapping tools to supported languages
- Moved language config generation to dedicated file in tools package
- Tools now check file extensions during analyze to skip unsupported languages

This prevents tools from running on unsupported file types (e.g., pylint on C++ files).

Author: andrzej-janczak

cmd/analyze.go

@@ -120,8 +120,9 @@ func IsToolSupportedForFile(toolName string, filePath string, langConfig *Langua
 
 // FilterToolsByLanguageSupport filters tools by language support for the given files
 func FilterToolsByLanguageSupport(tools map[string]*plugins.ToolInfo, files []string) map[string]*plugins.ToolInfo {
-	if len(files) == 0 {
-		// If no files specified, return all tools
+
+	if len(files) == 0 || files[0] == "." {
+		// If no files specified or current directory, return all tools
 		return tools
 	}
 

cmd/init.go

@@ -255,6 +255,20 @@ 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",
+	}
+
+	// Generate languages configuration based on API tools response
+	if err := tools.CreateLanguagesConfigFile(apiTools, toolsConfigDir, uuidToName); 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)
 

tools/language_config.go

@@ -0,0 +1,104 @@
+package tools
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"codacy/cli-v2/utils"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ToolLanguageInfo contains language and extension information for a tool
+type ToolLanguageInfo struct {
+	Name       string   `yaml:"name"`
+	Languages  []string `yaml:"languages,flow"`
+	Extensions []string `yaml:"extensions,flow"`
+}
+
+// LanguagesConfig represents the structure of the languages configuration file
+type LanguagesConfig struct {
+	Tools []ToolLanguageInfo `yaml:"tools"`
+}
+
+// CreateLanguagesConfigFile creates languages-config.yaml based on API response
+func CreateLanguagesConfigFile(apiTools []Tool, toolsConfigDir string, toolIDMap map[string]string) error {
+	// Map tool names to their language/extension information
+	toolLanguageMap := map[string]ToolLanguageInfo{
+		"cppcheck": {
+			Name:       "cppcheck",
+			Languages:  []string{"C", "CPP"},
+			Extensions: []string{".c", ".cpp", ".cc", ".h", ".hpp"},
+		},
+		"pylint": {
+			Name:       "pylint",
+			Languages:  []string{"Python"},
+			Extensions: []string{".py"},
+		},
+		"eslint": {
+			Name:       "eslint",
+			Languages:  []string{"JavaScript", "TypeScript", "JSX", "TSX"},
+			Extensions: []string{".js", ".jsx", ".ts", ".tsx"},
+		},
+		"pmd": {
+			Name:       "pmd",
+			Languages:  []string{"Java", "JavaScript", "JSP", "Velocity", "XML", "Apex", "Scala", "Ruby", "VisualForce"},
+			Extensions: []string{".java", ".js", ".jsp", ".vm", ".xml", ".cls", ".trigger", ".scala", ".rb", ".page", ".component"},
+		},
+		"trivy": {
+			Name:       "trivy",
+			Languages:  []string{"Multiple"},
+			Extensions: []string{},
+		},
+		"dartanalyzer": {
+			Name:       "dartanalyzer",
+			Languages:  []string{"Dart"},
+			Extensions: []string{".dart"},
+		},
+	}
+
+	// Build a list of tool language info for enabled tools
+	var configTools []ToolLanguageInfo
+
+	for _, tool := range apiTools {
+		shortName, exists := toolIDMap[tool.Uuid]
+		if !exists {
+			// Skip tools we don't recognize
+			continue
+		}
+
+		// Get language info for this tool
+		langInfo, exists := toolLanguageMap[shortName]
+		if exists {
+			configTools = append(configTools, langInfo)
+		}
+	}
+
+	// If we have no tools or couldn't match any, include all known tools
+	if len(configTools) == 0 {
+		for _, langInfo := range toolLanguageMap {
+			configTools = append(configTools, langInfo)
+		}
+	}
+
+	// Create the config structure
+	config := LanguagesConfig{
+		Tools: configTools,
+	}
+
+	// Marshal to YAML
+	data, err := yaml.Marshal(config)
+	if err != nil {
+		return fmt.Errorf("failed to marshal languages config to YAML: %w", err)
+	}
+
+	// Write the file
+	configPath := filepath.Join(toolsConfigDir, "languages-config.yaml")
+	if err := os.WriteFile(configPath, data, utils.DefaultFilePerms); err != nil {
+		return fmt.Errorf("failed to write languages config file: %w", err)
+	}
+
+	fmt.Println("Created languages configuration file based on enabled tools")
+	return nil
+}

tools/language_config_test.go

@@ -0,0 +1,112 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCreateLanguagesConfigFile(t *testing.T) {
+	// Create a temporary directory for test
+	tempDir, err := os.MkdirTemp("", "codacy-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Define test tool IDs
+	const (
+		testESLintID       = "eslint-id"
+		testPyLintID       = "pylint-id"
+		testTrivyID        = "trivy-id"
+		testPMDID          = "pmd-id"
+		testDartAnalyzerID = "dartanalyzer-id"
+	)
+
+	// Create a map of tool IDs to names
+	toolIDMap := map[string]string{
+		testESLintID:       "eslint",
+		testPyLintID:       "pylint",
+		testTrivyID:        "trivy",
+		testPMDID:          "pmd",
+		testDartAnalyzerID: "dartanalyzer",
+	}
+
+	// Create mock tool data
+	mockTools := []Tool{
+		{
+			Uuid: testPyLintID, // Pylint
+			Name: "Pylint",
+		},
+		{
+			Uuid: testESLintID, // ESLint
+			Name: "ESLint",
+		},
+	}
+
+	// Call the function under test
+	err = CreateLanguagesConfigFile(mockTools, tempDir, toolIDMap)
+	if err != nil {
+		t.Fatalf("CreateLanguagesConfigFile failed: %v", err)
+	}
+
+	// Verify the file was created
+	configPath := filepath.Join(tempDir, "languages-config.yaml")
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		t.Fatalf("languages-config.yaml was not created")
+	}
+
+	// Read the file content
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatalf("Failed to read generated file: %v", err)
+	}
+
+	// Check content has expected tools
+	content := string(data)
+	if !strings.Contains(content, "name: pylint") {
+		t.Errorf("Expected pylint in config, but it was not found")
+	}
+	if !strings.Contains(content, "name: eslint") {
+		t.Errorf("Expected eslint in config, but it was not found")
+	}
+
+	// Verify other tools are not included
+	if strings.Contains(content, "name: trivy") {
+		t.Errorf("Unexpected trivy in config")
+	}
+	if strings.Contains(content, "name: pmd") {
+		t.Errorf("Unexpected pmd in config")
+	}
+
+	// Check for flow style arrays
+	if !strings.Contains(content, "languages: [") {
+		t.Errorf("Expected flow-style array for languages, but not found")
+	}
+	if !strings.Contains(content, "extensions: [") {
+		t.Errorf("Expected flow-style array for extensions, but not found")
+	}
+
+	// Test with no tools - should include all tools
+	emptyTools := []Tool{}
+	err = CreateLanguagesConfigFile(emptyTools, tempDir, toolIDMap)
+	if err != nil {
+		t.Fatalf("CreateLanguagesConfigFile failed with empty tools: %v", err)
+	}
+
+	// Read the file again
+	data, err = os.ReadFile(configPath)
+	if err != nil {
+		t.Fatalf("Failed to read generated file: %v", err)
+	}
+
+	// With empty tools, all tools should be included
+	content = string(data)
+	for toolName := range toolIDMap {
+		shortName := toolIDMap[toolName]
+		if !strings.Contains(content, "name: "+shortName) {
+			t.Errorf("Expected %s in config when no tools specified, but it was not found", shortName)
+		}
+	}
+}