feature: add config reset command for Codacy CLI

- Introduced a new `config reset` command to reset Codacy configuration to default or repository-specific settings.
- Implemented logic to handle API token validation and ensure required flags are provided when using remote configurations.
- Added YAML parsing for CLI mode configuration from `.codacy/cli-config.yaml`.
- Updated error handling and user feedback for better clarity during configuration resets.

Author: andrzej-janczak

cmd/config.go

@@ -11,36 +11,85 @@ import (
 	"codacy/cli-v2/utils"
 
 	"github.com/spf13/cobra"
+	// Added import for YAML parsing
 )
 
-// configUpdateInitFlags holds the flags for the config update command, similar to init command flags.
-var configUpdateInitFlags domain.InitFlags
+// configResetInitFlags holds the flags for the config reset command.
+var configResetInitFlags domain.InitFlags
 
 var configCmd = &cobra.Command{
 	Use:   "config",
 	Short: "Manage Codacy configuration",
 }
 
-var configUpdateCmd = &cobra.Command{
-	Use:   "update",
-	Short: "Update Codacy configuration, or initialize if it doesn't exist",
-	Long:  "Updates the Codacy configuration files. If .codacy/codacy.yaml does not exist, it runs the initialization process.",
+// cliConfigYaml defines the structure for parsing .codacy/cli-config.yaml
+type cliConfigYaml struct {
+	Mode string `yaml:"mode"`
+}
+
+var configResetCmd = &cobra.Command{
+	Use:   "reset",
+	Short: "Reset Codacy configuration to default or repository-specific settings",
+	Long: "Resets the Codacy configuration files and tool-specific configurations. " +
+		"This command will overwrite an existing configuration with local default configurations " +
+		"if no API token is provided (and current mode is not 'remote'). If an API token is provided, it will fetch and apply " +
+		"repository-specific configurations from the Codacy API, effectively resetting to those.",
 	Run: func(cmd *cobra.Command, args []string) {
+		// Get current CLI mode from config
+		currentCliMode, err := config.Config.GetCliMode()
+		if err != nil {
+			// Log the error for debugging purposes
+			log.Printf("Warning: Could not determine CLI mode from cli-config.yaml: %v. Defaulting to 'local' mode.", err)
+			// Show a user-facing warning on stdout
+			fmt.Println("⚠️  Warning: Could not read or parse .codacy/cli-config.yaml. Defaulting to 'local' CLI mode.")
+			fmt.Println("   You might want to run 'codacy-cli init' or 'codacy-cli config reset --api-token ...' to correctly set up your configuration.")
+			fmt.Println()
+			currentCliMode = "local" // Default to local as per existing logic
+		}
+
+		apiTokenFlagProvided := len(configResetInitFlags.ApiToken) > 0
+
+		// If current mode is 'remote', prevent resetting to local without explicit API token for a remote reset.
+		if currentCliMode == "remote" && !apiTokenFlagProvided {
+			fmt.Println("Error: Your Codacy CLI is currently configured in 'remote' (cloud) mode.")
+			fmt.Println("To reset your configuration using remote settings, you must provide the --api-token, --provider, --organization, and --repository flags.")
+			fmt.Println("Running 'config reset' without these flags is not permitted while configured for 'remote' mode.")
+			fmt.Println("This prevents an accidental switch to a local default configuration.")
+			fmt.Println()
+			if errHelp := cmd.Help(); errHelp != nil {
+				log.Printf("Warning: Failed to display command help: %v\n", errHelp)
+			}
+			os.Exit(1)
+		}
+
+		// Validate flags: if API token is provided, other related flags must also be provided.
+		if apiTokenFlagProvided {
+			if configResetInitFlags.Provider == "" || configResetInitFlags.Organization == "" || configResetInitFlags.Repository == "" {
+				fmt.Println("Error: When using --api-token, you must also provide --provider, --organization, and --repository flags.")
+				fmt.Println("Please provide all required flags and try again.")
+				fmt.Println()
+				if errHelp := cmd.Help(); errHelp != nil {
+					log.Fatalf("Failed to display command help: %v", errHelp)
+				}
+				os.Exit(1)
+			}
+		}
+
 		codacyConfigFile := config.Config.ProjectConfigFile()
 		// Check if the main configuration file exists
 		if _, err := os.Stat(codacyConfigFile); os.IsNotExist(err) {
 			fmt.Println("Configuration file (.codacy/codacy.yaml) not found, running initialization logic...")
-			runConfigUpdateLogic(cmd, args, configUpdateInitFlags)
+			runConfigResetLogic(cmd, args, configResetInitFlags)
 		} else {
-			fmt.Println("Updating existing Codacy configuration...")
-			runConfigUpdateLogic(cmd, args, configUpdateInitFlags)
+			fmt.Println("Resetting existing Codacy configuration...")
+			runConfigResetLogic(cmd, args, configResetInitFlags)
 		}
 	},
 }
 
-// runConfigUpdateLogic contains the core logic for updating or initializing the configuration.
+// runConfigResetLogic contains the core logic for resetting or initializing the configuration.
 // It mirrors the behavior of the original init command but uses shared functions from the configsetup package.
-func runConfigUpdateLogic(cmd *cobra.Command, args []string, flags domain.InitFlags) {
+func runConfigResetLogic(cmd *cobra.Command, args []string, flags domain.InitFlags) {
 	// Create local .codacy directory first
 	if err := config.Config.CreateLocalCodacyDir(); err != nil {
 		log.Fatalf("Failed to create local codacy directory: %v", err)
@@ -57,7 +106,7 @@ func runConfigUpdateLogic(cmd *cobra.Command, args []string, flags domain.InitFl
 
 	if cliLocalMode {
 		fmt.Println()
-		fmt.Println("ℹ️  No API token was specified. Proceeding with local default configurations.")
+		fmt.Println("ℹ️  Resetting to local default configurations.")
 		noTools := []domain.Tool{} // Empty slice for tools as we are in local mode without specific toolset from API initially
 		if err := configsetup.CreateConfigurationFiles(noTools, cliLocalMode); err != nil {
 			log.Fatalf("Failed to create base configuration files: %v", err)
@@ -72,7 +121,7 @@ func runConfigUpdateLogic(cmd *cobra.Command, args []string, flags domain.InitFl
 		}
 	} else {
 		// API token provided, fetch configuration from Codacy
-		fmt.Println("API token specified. Fetching repository-specific configurations from Codacy...")
+		fmt.Println("API token specified. Fetching and applying repository-specific configurations from Codacy...")
 		if err := configsetup.BuildRepositoryConfigurationFiles(flags); err != nil {
 			log.Fatalf("Failed to build repository-specific configuration files: %v", err)
 		}
@@ -84,7 +133,7 @@ func runConfigUpdateLogic(cmd *cobra.Command, args []string, flags domain.InitFl
 	}
 
 	fmt.Println()
-	fmt.Println("✅ Successfully initialized/updated Codacy configuration!")
+	fmt.Println("✅ Successfully reset Codacy configuration!")
 	fmt.Println()
 	fmt.Println("🔧 Next steps:")
 	fmt.Println("  1. Run 'codacy-cli install' to install all dependencies based on the new/updated configuration.")
@@ -93,14 +142,14 @@ func runConfigUpdateLogic(cmd *cobra.Command, args []string, flags domain.InitFl
 }
 
 func init() {
-	// Define flags for the config update command. These are the same flags used by the init command.
-	configUpdateCmd.Flags().StringVar(&configUpdateInitFlags.ApiToken, "api-token", "", "Optional Codacy API token. If defined, configurations will be fetched from Codacy.")
-	configUpdateCmd.Flags().StringVar(&configUpdateInitFlags.Provider, "provider", "", "Provider (e.g., gh, bb, gl) to fetch configurations from Codacy. Required when api-token is provided.")
-	configUpdateCmd.Flags().StringVar(&configUpdateInitFlags.Organization, "organization", "", "Remote organization name to fetch configurations from Codacy. Required when api-token is provided.")
-	configUpdateCmd.Flags().StringVar(&configUpdateInitFlags.Repository, "repository", "", "Remote repository name to fetch configurations from Codacy. Required when api-token is provided.")
-
-	// Add the update subcommand to the config command
-	configCmd.AddCommand(configUpdateCmd)
+	// 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.")
+	configResetCmd.Flags().StringVar(&configResetInitFlags.Provider, "provider", "", "Provider (e.g., gh, bb, gl) to fetch configurations from Codacy. Required when api-token is provided.")
+	configResetCmd.Flags().StringVar(&configResetInitFlags.Organization, "organization", "", "Remote organization name to fetch configurations from Codacy. Required when api-token is provided.")
+	configResetCmd.Flags().StringVar(&configResetInitFlags.Repository, "repository", "", "Remote repository name to fetch configurations from Codacy. Required when api-token is provided.")
+
+	// Add the reset subcommand to the config command
+	configCmd.AddCommand(configResetCmd)
 	// Add the config command to the root command
 	rootCmd.AddCommand(configCmd)
 }

config/config.go

@@ -8,8 +8,15 @@ import (
 
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/utils"
+
+	"gopkg.in/yaml.v3" // Added import for YAML parsing
 )
 
+// CliConfigYaml defines the structure for parsing .codacy/cli-config.yaml
+type CliConfigYaml struct {
+	Mode string `yaml:"mode"`
+}
+
 type ConfigType struct {
 	repositoryDirectory string
 
@@ -231,3 +238,35 @@ func (c *ConfigType) IsToolInstalled(name string, tool *plugins.ToolInfo) bool {
 
 // Global singleton config-file
 var Config = ConfigType{}
+
+// GetCliMode reads and parses the .codacy/cli-config.yaml file to determine the CLI's operational mode.
+// It returns "local" by default and an error if the file doesn't exist or an error occurs during parsing.
+func (c *ConfigType) GetCliMode() (string, error) {
+	cliConfigFilePath := c.CliConfigFile()
+	currentCliMode := "local" // Default to local
+
+	content, readErr := os.ReadFile(cliConfigFilePath)
+	if readErr != nil {
+		if os.IsNotExist(readErr) {
+			// File does not exist. Return default mode and the error so the caller can warn.
+			return currentCliMode, readErr
+		}
+		// Some other error occurred during reading the file.
+		return currentCliMode, fmt.Errorf("failed to read %s: %w", cliConfigFilePath, readErr)
+	}
+
+	// If ReadFile was successful, the file exists. Now parse it.
+	var parsedCliConfig CliConfigYaml
+	if yamlErr := yaml.Unmarshal(content, &parsedCliConfig); yamlErr != nil {
+		return currentCliMode, fmt.Errorf("failed to parse %s: %w", cliConfigFilePath, yamlErr)
+	}
+
+	if parsedCliConfig.Mode == "remote" || parsedCliConfig.Mode == "local" {
+		currentCliMode = parsedCliConfig.Mode
+	} else {
+		// Invalid mode value in the config file.
+		return "local", fmt.Errorf("invalid mode value \"%s\" in %s", parsedCliConfig.Mode, cliConfigFilePath)
+	}
+
+	return currentCliMode, nil
+}

docs/config-reset-scenarios.md

@@ -0,0 +1,28 @@
+# Codacy CLI `config reset` Command Scenarios
+ 
+This document outlines the possible scenarios for the `codacy-cli config reset` command, considering the current CLI mode (as defined in `.codacy/cli-config.yaml`) and the flags provided during the command execution.
+
+| Current CLI Mode (`.codacy/cli-config.yaml`) | `config reset` Flags Provided                                  | Behavior                                                                                                                                                                                                                                                           |
+| :------------------------------------------- | :------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Local**                                    | No flags                                                       | Resets configuration to local default settings. Creates/overwrites `.codacy/codacy.yaml` and `tools-configs/` with defaults. `cli-config.yaml` is set to `mode: local`.                                                                                             |
+| **Local**                                    | `--api-token <token>`<br>(missing provider/org/repo)            | **Error:** Command exits. Message indicates that `--provider`, `--organization`, and `--repository` are required when `--api-token` is used.                                                                                                                            |
+| **Local**                                    | `--api-token <token>`<br>`--provider <p>`<br>`--organization <o>`<br>`--repository <r>` | Fetches repository-specific configurations from Codacy API. Creates/overwrites `.codacy/codacy.yaml` and `tools-configs/` based on API response. `cli-config.yaml` is set to `mode: remote`.                                                           |
+| **Remote**                                   | No flags                                                       | **Error:** Command exits. Message indicates that the CLI is in 'remote' mode, and to reset, API flags (`--api-token`, `--provider`, etc.) must be provided. This prevents accidental reset to local defaults.                                                          |
+| **Remote**                                   | `--api-token <token>`<br>(missing provider/org/repo)            | **Error:** Command exits. Message indicates that `--provider`, `--organization`, and `--repository` are required when `--api-token` is used.                                                                                                                            |
+| **Remote**                                   | `--api-token <token>`<br>`--provider <p>`<br>`--organization <o>`<br>`--repository <r>` | Fetches repository-specific configurations from Codacy API. Creates/overwrites `.codacy/codacy.yaml` and `tools-configs/` based on API response. `cli-config.yaml` remains/is set to `mode: remote`.                                                        |
+| File missing or unparseable (`.codacy/cli-config.yaml`) | No flags                                                       | (Defaults to Local mode) Resets configuration to local default settings. Creates/overwrites `.codacy/codacy.yaml` and `tools-configs/` with defaults. `cli-config.yaml` is set to `mode: local`. **User-facing warning printed to console and logged regarding `cli-config.yaml` issue.**         |
+| File missing or unparseable (`.codacy/cli-config.yaml`) | `--api-token <token>`<br>(missing provider/org/repo)            | (Defaults to Local mode) **Error:** Command exits. Message indicates that `--provider`, `--organization`, and `--repository` are required when `--api-token` is used. **User-facing warning printed to console and logged regarding `cli-config.yaml` issue.**                                       |
+| File missing or unparseable (`.codacy/cli-config.yaml`) | `--api-token <token>`<br>`--provider <p>`<br>`--organization <o>`<br>`--repository <r>` | (Defaults to Local mode) Fetches repository-specific configurations from Codacy API. Creates/overwrites `.codacy/codacy.yaml` and `tools-configs/` based on API response. `cli-config.yaml` is set to `mode: remote`. **User-facing warning printed to console and logged regarding `cli-config.yaml` issue.** |
+
+## Key Points
+
+*   The `runConfigResetLogic` function determines whether to use local defaults or fetch from the API based purely on the presence of the `ApiToken` flag at the time of its execution.
+*   The `cliLocalMode` variable within `runConfigResetLogic` (which influences `CreateConfigurationFiles` and `CliConfigFileTemplate`) is set based on `len(flags.ApiToken) == 0`.
+    *   If an API token is provided to `config reset`, the resulting `.codacy/cli-config.yaml` will always be set to `mode: remote`.
+    *   If no token is provided, it will be set to `mode: local`.
+*   The validation logic in the `configResetCmd.Run` function occurs *before* `runConfigResetLogic` is called. This validation is responsible for:
+    *   Informing the user with a console warning if `.codacy/cli-config.yaml` is missing or unparseable, then defaulting to 'local' mode for subsequent checks.
+    *   Ensuring that if the (potentially defaulted) current CLI mode is "remote", an API token *must* be supplied to proceed with the reset.
+    *   Ensuring that if an API token *is* supplied, then `--provider`, `--organization`, and `--repository` flags must also be supplied.
+
+This table should cover the main operational flows and error conditions for the `config reset` command based on the implemented logic.