analyze now receives initFlags and fetches config file if non existent

Author: franciscoovazevedo

cmd/analyze.go

@@ -1,6 +1,8 @@
 package cmd
 
 import (
+	"codacy/cli-v2/cmd/cmdutils"
+	"codacy/cli-v2/cmd/configsetup"
 	"codacy/cli-v2/config"
 	"codacy/cli-v2/domain"
 	"codacy/cli-v2/plugins"
@@ -41,6 +43,18 @@ type LanguagesConfig struct {
 	} `yaml:"tools" json:"tools"`
 }
 
+// toolConfigFileName maps tool names to their configuration filenames
+var toolConfigFileName = map[string]string{
+	"eslint":       "eslint.config.mjs",
+	"trivy":        "trivy.yaml",
+	"pmd":          "ruleset.xml",
+	"pylint":       "pylint.rc",
+	"dartanalyzer": "analysis_options.yaml",
+	"semgrep":      "semgrep.yaml",
+	"revive":       "revive.toml",
+	"lizard":       "lizard.yaml",
+}
+
 // LoadLanguageConfig loads the language configuration from the file
 func LoadLanguageConfig() (*LanguagesConfig, error) {
 	// First, try to load the YAML config
@@ -219,6 +233,7 @@ func init() {
 	analyzeCmd.Flags().StringVarP(&toolsToAnalyzeParam, "tool", "t", "", "Which tool to run analysis with. If not specified, all configured tools will be run")
 	analyzeCmd.Flags().StringVar(&outputFormat, "format", "", "Output format (use 'sarif' for SARIF format)")
 	analyzeCmd.Flags().BoolVar(&autoFix, "fix", false, "Apply auto fix to your issues when available")
+	cmdutils.AddCloudFlags(analyzeCmd, &initFlags)
 	rootCmd.AddCommand(analyzeCmd)
 }
 
@@ -279,7 +294,41 @@ func validateToolName(toolName string) error {
 	return nil
 }
 
-func runToolByName(toolName string, workDirectory string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string, tool *plugins.ToolInfo, runtime *plugins.RuntimeInfo) error {
+func checkIfConfigExistsAndIsNeeded(toolName string, cliLocalMode bool) error {
+	configFileName := toolConfigFileName[toolName]
+	if configFileName == "" {
+		// Tool doesn't use config file
+		return nil
+	}
+
+	// Use the configuration system to get the tools config directory
+	toolsConfigDir := config.Config.ToolsConfigDirectory()
+	toolConfigPath := filepath.Join(toolsConfigDir, configFileName)
+
+	// Check if the config file exists
+	if _, err := os.Stat(toolConfigPath); os.IsNotExist(err) {
+		// Only show error if we're in remote mode and need the config file
+		if !cliLocalMode && initFlags.ApiToken != "" {
+			fmt.Printf("Creating new config file for tool %s\n", toolName)
+			configsetup.CreateToolConfigurationFile(toolName, initFlags)
+		} else if !cliLocalMode {
+			fmt.Printf("config file not found for tool %s: %s and no api token provided \n", toolName, toolConfigPath)
+		} else {
+			fmt.Printf("config file not found for tool %s: %s please add a config file to the tools-configs directory\n", toolName, toolConfigPath)
+		}
+	} else if err != nil {
+		fmt.Printf("error checking config file for tool %s: %v\n", toolName, err)
+	} else {
+		fmt.Printf("Config file found for %s: %s\n", toolName, toolConfigPath)
+	}
+	return nil
+}
+
+func runToolByName(toolName string, workDirectory string, pathsToCheck []string, autoFix bool, outputFile string, outputFormat string, tool *plugins.ToolInfo, runtime *plugins.RuntimeInfo, cliLocalMode bool) error {
+	err := checkIfConfigExistsAndIsNeeded(toolName, cliLocalMode)
+	if err != nil {
+		return err
+	}
 	switch toolName {
 	case "eslint":
 		binaryPath := runtime.Binaries[tool.Runtime]
@@ -310,7 +359,7 @@ func runToolByName(toolName string, workDirectory string, pathsToCheck []string,
 	return fmt.Errorf("unsupported tool: %s", toolName)
 }
 
-func runTool(workDirectory string, toolName string, pathsToCheck []string, outputFile string, autoFix bool, outputFormat string) error {
+func runTool(workDirectory string, toolName string, pathsToCheck []string, outputFile string, autoFix bool, outputFormat string, cliLocalMode bool) error {
 	err := validateToolName(toolName)
 	if err != nil {
 		return err
@@ -368,7 +417,7 @@ func runTool(workDirectory string, toolName string, pathsToCheck []string, outpu
 			runtime = config.Config.Runtimes()[tool.Runtime]
 		}
 	}
-	return runToolByName(toolName, workDirectory, pathsToCheck, autoFix, outputFile, outputFormat, tool, runtime)
+	return runToolByName(toolName, workDirectory, pathsToCheck, autoFix, outputFile, outputFormat, tool, runtime, cliLocalMode)
 }
 
 // validatePaths checks if all provided paths exist and returns an error if any don't
@@ -384,6 +433,13 @@ func validatePaths(paths []string) error {
 	return nil
 }
 
+func validateCloudMode(cliLocalMode bool) error {
+	if cliLocalMode {
+		fmt.Println("Warning: cannot run in cloud mode")
+	}
+	return nil
+}
+
 var analyzeCmd = &cobra.Command{
 	Use:   "analyze",
 	Short: "Analyze code using configured tools",
@@ -401,6 +457,10 @@ var analyzeCmd = &cobra.Command{
 			log.Fatalf("Failed to get current working directory: %v", err)
 		}
 
+		cliLocalMode := len(initFlags.ApiToken) == 0
+
+		validateCloudMode(cliLocalMode)
+
 		var toolsToRun map[string]*plugins.ToolInfo
 
 		if toolsToAnalyzeParam != "" {
@@ -437,7 +497,7 @@ var analyzeCmd = &cobra.Command{
 			var sarifOutputs []string
 			for toolName := range toolsToRun {
 				tmpFile := filepath.Join(tmpDir, fmt.Sprintf("%s.sarif", toolName))
-				if err := runTool(workDirectory, toolName, args, tmpFile, autoFix, outputFormat); err != nil {
+				if err := runTool(workDirectory, toolName, args, tmpFile, autoFix, outputFormat, cliLocalMode); err != nil {
 					log.Printf("Tool failed to run: %v\n", err)
 				}
 				sarifOutputs = append(sarifOutputs, tmpFile)
@@ -472,7 +532,7 @@ var analyzeCmd = &cobra.Command{
 		} else {
 			// Run tools without merging outputs
 			for toolName := range toolsToRun {
-				if err := runTool(workDirectory, toolName, args, outputFile, autoFix, outputFormat); err != nil {
+				if err := runTool(workDirectory, toolName, args, outputFile, autoFix, outputFormat, cliLocalMode); err != nil {
 					log.Printf("Tool failed to run: %v\n", err)
 				}
 			}

cmd/analyze_test.go

@@ -2,9 +2,14 @@ package cmd
 
 import (
 	"codacy/cli-v2/plugins"
+	"os"
+	"path/filepath"
 	"testing"
 
+	"codacy/cli-v2/domain"
+
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGetFileExtension(t *testing.T) {
@@ -262,3 +267,145 @@ func TestValidatePaths(t *testing.T) {
 		})
 	}
 }
+
+func TestCheckIfConfigExistsAndIsNeeded(t *testing.T) {
+	// Save original initFlags
+	originalFlags := initFlags
+	defer func() { initFlags = originalFlags }()
+
+	tests := []struct {
+		name             string
+		toolName         string
+		cliLocalMode     bool
+		apiToken         string
+		configFileExists bool
+		expectError      bool
+		description      string
+	}{
+		{
+			name:             "tool_without_config_file",
+			toolName:         "unsupported-tool",
+			cliLocalMode:     false,
+			apiToken:         "test-token",
+			configFileExists: false,
+			expectError:      false,
+			description:      "Tool that doesn't use config files should return without error",
+		},
+		{
+			name:             "config_file_exists",
+			toolName:         "eslint",
+			cliLocalMode:     false,
+			apiToken:         "test-token",
+			configFileExists: true,
+			expectError:      false,
+			description:      "When config file exists, should find it successfully",
+		},
+		{
+			name:             "remote_mode_with_token_no_config",
+			toolName:         "eslint",
+			cliLocalMode:     false,
+			apiToken:         "test-token",
+			configFileExists: false,
+			expectError:      false,
+			description:      "Remote mode with token should attempt to create config",
+		},
+		{
+			name:             "remote_mode_without_token_no_config",
+			toolName:         "eslint",
+			cliLocalMode:     false,
+			apiToken:         "",
+			configFileExists: false,
+			expectError:      false,
+			description:      "Remote mode without token should show appropriate message",
+		},
+		{
+			name:             "local_mode_no_config",
+			toolName:         "eslint",
+			cliLocalMode:     true,
+			apiToken:         "",
+			configFileExists: false,
+			expectError:      false,
+			description:      "Local mode should show message about adding config file",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup temporary directory
+			tmpDir, err := os.MkdirTemp("", "codacy-test-*")
+			require.NoError(t, err)
+			defer os.RemoveAll(tmpDir)
+
+			// Create config file if needed
+			if tt.configFileExists && toolConfigFileName[tt.toolName] != "" {
+				configPath := filepath.Join(tmpDir, toolConfigFileName[tt.toolName])
+				err := os.WriteFile(configPath, []byte("test config"), 0644)
+				require.NoError(t, err)
+			}
+
+			// Setup initFlags
+			initFlags = domain.InitFlags{
+				ApiToken: tt.apiToken,
+			}
+
+			// Mock config directory (this would need actual mocking in real implementation)
+			// For now, we'll create a simple test that verifies the function doesn't panic
+
+			// Execute the function
+			err = checkIfConfigExistsAndIsNeeded(tt.toolName, tt.cliLocalMode)
+
+			// Verify results
+			if tt.expectError {
+				assert.Error(t, err, tt.description)
+			} else {
+				assert.NoError(t, err, tt.description)
+			}
+		})
+	}
+}
+
+func TestToolConfigFileNameMap(t *testing.T) {
+	expectedTools := map[string]string{
+		"eslint":       "eslint.config.mjs",
+		"trivy":        "trivy.yaml",
+		"pmd":          "ruleset.xml",
+		"pylint":       "pylint.rc",
+		"dartanalyzer": "analysis_options.yaml",
+		"semgrep":      "semgrep.yaml",
+		"revive":       "revive.toml",
+		"lizard":       "lizard.yaml",
+	}
+
+	for toolName, expectedFileName := range expectedTools {
+		t.Run(toolName, func(t *testing.T) {
+			actualFileName, exists := toolConfigFileName[toolName]
+			assert.True(t, exists, "Tool %s should exist in toolConfigFileName map", toolName)
+			assert.Equal(t, expectedFileName, actualFileName, "Config filename for %s should match expected", toolName)
+		})
+	}
+}
+
+func TestGetFileExtension(t *testing.T) {
+	tests := []struct {
+		filePath string
+		expected string
+	}{
+		{"test.js", ".js"},
+		{"test.jsx", ".jsx"},
+		{"test.ts", ".ts"},
+		{"test.tsx", ".tsx"},
+		{"test.py", ".py"},
+		{"test.java", ".java"},
+		{"test", ""},
+		{"test.JS", ".js"}, // Should be lowercase
+		{"/path/to/test.py", ".py"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.filePath, func(t *testing.T) {
+			result := GetFileExtension(tt.filePath)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}

cmd/configsetup/setup.go

@@ -483,6 +483,34 @@ func createToolConfigurationFiles(tools []domain.Tool, flags domain.InitFlags) e
 	return nil
 }
 
+// CreateToolConfigurationFile creates a configuration file for a single tool
+func CreateToolConfigurationFile(toolName string, flags domain.InitFlags) error {
+	// Find the tool UUID by tool name
+	toolUuid := getToolUuidByName(toolName)
+	if toolUuid == "" {
+		return fmt.Errorf("tool '%s' not found in supported tools", toolName)
+	}
+
+	patternsConfig, err := codacyclient.GetDefaultToolPatternsConfig(flags, toolUuid)
+	if err != nil {
+		return fmt.Errorf("failed to get default patterns: %w", err)
+	}
+
+	// Get the tool object to pass to createToolFileConfiguration
+	tool := domain.Tool{Uuid: toolUuid}
+	return createToolFileConfiguration(tool, patternsConfig)
+}
+
+// getToolUuidByName finds the UUID for a tool given its name
+func getToolUuidByName(toolName string) string {
+	for uuid, toolInfo := range domain.SupportedToolsMetadata {
+		if toolInfo.Name == toolName {
+			return uuid
+		}
+	}
+	return ""
+}
+
 // createToolFileConfiguration creates a configuration file for a single tool using the registry
 func createToolFileConfiguration(tool domain.Tool, patternConfiguration []domain.PatternConfiguration) error {
 	creator, exists := toolConfigRegistry[tool.Uuid]