feature: enhance language detection and logging in config command

- Added functionality to detect file extensions in the specified path before language detection.
- Implemented logging for recognized file extensions and detected languages using the logger package.
- Improved error handling for invalid configurations in the Codacy YAML file.
- Refactored the detectLanguagesInPath function to utilize the new detectFileExtensions function for better clarity and maintainability.

Author: andrzej-janczak

cmd/config.go

@@ -16,7 +16,9 @@ import (
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/tools"
 	"codacy/cli-v2/utils"
+	"codacy/cli-v2/utils/logger"
 
+	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"gopkg.in/yaml.v3"
 )
@@ -165,8 +167,24 @@ var configDiscoverCmd = &cobra.Command{
 
 		fmt.Printf("Discovering languages and tools for path: %s\n", discoverPath)
 
+		// Detect file extensions first
+		extCount, err := detectFileExtensions(discoverPath)
+		if err != nil {
+			log.Fatalf("Error detecting file extensions: %v", err)
+		}
+
 		defaultToolLangMap := tools.GetDefaultToolLanguageMapping()
 
+		if len(extCount) > 0 {
+			recognizedExts := getRecognizableExtensions(extCount, defaultToolLangMap)
+			if len(recognizedExts) > 0 {
+				logger.Debug("Detected recognizable file extensions", logrus.Fields{
+					"extensions": recognizedExts,
+					"path":       discoverPath,
+				})
+			}
+		}
+
 		detectedLanguages, err := detectLanguagesInPath(discoverPath, defaultToolLangMap)
 		if err != nil {
 			log.Fatalf("Error detecting languages: %v", err)
@@ -175,7 +193,10 @@ var configDiscoverCmd = &cobra.Command{
 			fmt.Println("No known languages detected in the provided path.")
 			return
 		}
-		fmt.Printf("Detected languages: %v\n", getSortedKeys(detectedLanguages))
+		logger.Debug("Detected languages in path", logrus.Fields{
+			"languages": getSortedKeys(detectedLanguages),
+			"path":      discoverPath,
+		})
 
 		toolsConfigDir := config.Config.ToolsConfigsDirectory()
 		if err := updateLanguagesConfig(detectedLanguages, toolsConfigDir, defaultToolLangMap); err != nil {
@@ -192,13 +213,16 @@ var configDiscoverCmd = &cobra.Command{
 
 		codacyYAMLPath := config.Config.ProjectConfigFile()
 		if err := updateCodacyYAML(detectedLanguages, codacyYAMLPath, defaultToolLangMap, configResetInitFlags, currentCliMode); err != nil {
+			if strings.Contains(err.Error(), "❌ Fatal:") {
+				fmt.Println(err)
+				os.Exit(1)
+			}
 			log.Fatalf("Error updating %s: %v", codacyYAMLPath, err)
 		}
 		fmt.Printf("Updated %s with relevant tools.\n", filepath.Base(codacyYAMLPath))
 
 		fmt.Println("\n✅ Successfully discovered languages and updated configurations.")
 		fmt.Println("   Please review the changes in '.codacy/codacy.yaml' and '.codacy/tools-configs/languages-config.yaml'.")
-		fmt.Println("   Run 'codacy-cli install' to install any newly added tools.")
 	},
 }
 
@@ -211,11 +235,12 @@ func getSortedKeys(m map[string]struct{}) []string {
 	return keys
 }
 
-// detectLanguagesInPath walks the directory and detects languages based on file extensions.
+// detectLanguagesInPath detects languages based on file extensions found in the path.
 func detectLanguagesInPath(rootPath string, toolLangMap map[string]domain.ToolLanguageInfo) (map[string]struct{}, error) {
 	detectedLangs := make(map[string]struct{})
 	extToLang := make(map[string][]string)
 
+	// Build extension to language mapping
 	for _, toolInfo := range toolLangMap {
 		for _, lang := range toolInfo.Languages {
 			if lang == "Multiple" || lang == "Generic" { // Skip generic language types for direct detection
@@ -227,23 +252,19 @@ func detectLanguagesInPath(rootPath string, toolLangMap map[string]domain.ToolLa
 		}
 	}
 
-	err := filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if !info.IsDir() {
-			ext := strings.ToLower(filepath.Ext(path))
-			if langs, ok := extToLang[ext]; ok {
-				for _, lang := range langs {
-					detectedLangs[lang] = struct{}{}
-				}
+	// Get file extensions from the path
+	extCount, err := detectFileExtensions(rootPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to detect file extensions in path %s: %w", rootPath, err)
+	}
+
+	// Map extensions to languages
+	for ext := range extCount {
+		if langs, ok := extToLang[ext]; ok {
+			for _, lang := range langs {
+				detectedLangs[lang] = struct{}{}
 			}
 		}
-		return nil
-	})
-
-	if err != nil {
-		return nil, fmt.Errorf("failed to walk path %s: %w", rootPath, err)
 	}
 
 	return detectedLangs, nil
@@ -355,15 +376,19 @@ func updateCodacyYAML(detectedLanguages map[string]struct{}, codacyYAMLPath stri
 			return fmt.Errorf("error reading %s: %w", codacyYAMLPath, err)
 		}
 		if err := yaml.Unmarshal(content, &configData); err != nil {
-			return fmt.Errorf("error parsing %s: %w", codacyYAMLPath, err)
+			if strings.Contains(err.Error(), "cannot unmarshal") {
+				return fmt.Errorf(
+					"❌ Fatal: %s contains invalid configuration - run 'codacy-cli config reset' to fix: %v",
+					filepath.Base(codacyYAMLPath), err)
+			}
+			return fmt.Errorf(
+				"❌ Fatal: %s is broken or has invalid YAML format - run 'codacy-cli config reset' to reinitialize your configuration",
+				filepath.Base(codacyYAMLPath))
 		}
 	} else if os.IsNotExist(err) {
-		// If codacy.yaml doesn't exist, create a basic structure
-		configData = make(map[string]interface{})
-		configData["tools"] = []interface{}{}
-		configData["runtimes"] = []interface{}{} // Initialize runtimes as well
+		return fmt.Errorf("codacy.yaml file not found")
 	} else {
-		return fmt.Errorf("error statting %s: %w", codacyYAMLPath, err)
+		return fmt.Errorf("error accessing %s: %w", codacyYAMLPath, err)
 	}
 
 	toolsRaw, _ := configData["tools"].([]interface{})
@@ -533,6 +558,70 @@ func updateCodacyYAML(detectedLanguages map[string]struct{}, codacyYAMLPath stri
 	return os.WriteFile(codacyYAMLPath, yamlData, utils.DefaultFilePerms)
 }
 
+// detectFileExtensions walks the directory and collects all unique file extensions with their counts
+func detectFileExtensions(rootPath string) (map[string]int, error) {
+	extCount := make(map[string]int)
+
+	err := filepath.Walk(rootPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			ext := strings.ToLower(filepath.Ext(path))
+			if ext != "" {
+				extCount[ext]++
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to walk path %s: %w", rootPath, err)
+	}
+
+	return extCount, nil
+}
+
+// getRecognizableExtensions returns a sorted list of extensions that are mapped to languages
+func getRecognizableExtensions(extCount map[string]int, toolLangMap map[string]domain.ToolLanguageInfo) []string {
+	// Build set of recognized extensions
+	recognizedExts := make(map[string]struct{})
+	for _, toolInfo := range toolLangMap {
+		for _, ext := range toolInfo.Extensions {
+			recognizedExts[ext] = struct{}{}
+		}
+	}
+
+	// Filter and format recognized extensions with counts
+	type extInfo struct {
+		ext   string
+		count int
+	}
+	var recognizedExtList []extInfo
+
+	for ext, count := range extCount {
+		if _, ok := recognizedExts[ext]; ok {
+			recognizedExtList = append(recognizedExtList, extInfo{ext, count})
+		}
+	}
+
+	// Sort by count (descending) and then by extension name
+	sort.Slice(recognizedExtList, func(i, j int) bool {
+		if recognizedExtList[i].count != recognizedExtList[j].count {
+			return recognizedExtList[i].count > recognizedExtList[j].count
+		}
+		return recognizedExtList[i].ext < recognizedExtList[j].ext
+	})
+
+	// Format extensions with their counts
+	result := make([]string, len(recognizedExtList))
+	for i, info := range recognizedExtList {
+		result[i] = fmt.Sprintf("%s (%d files)", info.ext, info.count)
+	}
+
+	return result
+}
+
 func init() {
 	// Define flags for the config reset command. These are the same flags used by the init command.
 	configResetCmd.Flags().StringVar(&configResetInitFlags.ApiToken, "api-token", "", "Optional Codacy API token. If defined, configurations will be fetched from Codacy.")

tools/language_config.go

@@ -16,11 +16,6 @@ import (
 
 // defaultToolLanguageMap defines the default mapping of tools to their supported languages and file extensions
 var defaultToolLanguageMap = map[string]domain.ToolLanguageInfo{
-	"cppcheck": {
-		Name:       "cppcheck",
-		Languages:  []string{"C", "CPP"},
-		Extensions: []string{".c", ".cpp", ".cc", ".h", ".hpp"},
-	},
 	"pylint": {
 		Name:       "pylint",
 		Languages:  []string{"Python"},