fix upload sarif file

cmd/analyze.go

@@ -251,7 +251,7 @@ func loadsToolAndPatterns(toolName string, onlyEnabledPatterns bool) (domain.Too
 		}
 	}
 	var patterns []domain.PatternConfiguration
-	patterns, err = codacyclient.GetDefaultToolPatternsConfig(domain.InitFlags{}, tool.Uuid, onlyEnabledPatterns)
+	patterns, err = codacyclient.GetToolPatternsConfig(domain.InitFlags{}, tool.Uuid, onlyEnabledPatterns)
 	if err != nil {
 		fmt.Println("Error:", err)
 		return domain.Tool{}, []domain.PatternConfiguration{}

cmd/configsetup/default_config.go

@@ -200,7 +200,7 @@ func createDefaultConfigurationsForSpecificTools(discoveredToolNames map[string]
 // createToolConfigurationsForUUIDs creates tool configurations for specific UUIDs
 func createToolConfigurationsForUUIDs(uuids []string, toolsConfigDir string, initFlags domain.InitFlags) error {
 	for _, uuid := range uuids {
-		patternsConfig, err := codacyclient.GetDefaultToolPatternsConfig(initFlags, uuid, true)
+		patternsConfig, err := codacyclient.GetToolPatternsConfig(initFlags, uuid, true)
 		if err != nil {
 			logToolConfigWarning(uuid, "Failed to get default patterns", err)
 			continue

cmd/configsetup/repository_config.go

@@ -98,7 +98,7 @@ func CreateToolConfigurationFile(toolName string, flags domain.InitFlags) error
 		return fmt.Errorf("tool '%s' not found in supported tools", toolName)
 	}
 
-	patternsConfig, err := codacyclient.GetDefaultToolPatternsConfig(flags, toolUUID, true)
+	patternsConfig, err := codacyclient.GetToolPatternsConfig(flags, toolUUID, true)
 	if err != nil {
 		return fmt.Errorf("failed to get default patterns: %w", err)
 	}

cmd/upload.go

@@ -9,7 +9,9 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -43,6 +45,47 @@ var uploadResultsCmd = &cobra.Command{
 	},
 }
 
+var sarifShortNameMap = map[string]string{
+	// The keys here MUST match the exact string found in run.Tool.Driver.Name
+	"ESLint (deprecated)": "eslint",
+	"ESLint":              "eslint-8",
+	"ESLint9":             "eslint-9",
+	"PMD":                 "pmd",
+	"PMD7":                "pmd-7",
+	"Trivy":               "trivy",
+	"Pylint":              "pylintpython3",
+	"dartanalyzer":        "dartanalyzer",
+	"Semgrep":             "semgrep",
+	"Lizard":              "lizard",
+	"revive":              "revive",
+}
+
+func getToolShortName(fullName string) string {
+	if shortName, ok := sarifShortNameMap[fullName]; ok {
+		return shortName
+	}
+	// Fallback: Use the original name if no mapping is found
+	return fullName
+}
+
+func getRelativePath(baseDir string, fullURI string) string {
+
+	localPath := fullURI
+	u, err := url.Parse(fullURI)
+	if err == nil && u.Scheme == "file" {
+		// url.Path extracts the local path component correctly
+		localPath = u.Path
+	}
+	relativePath, err := filepath.Rel(baseDir, localPath)
+	if err != nil {
+		// Fallback to the normalized absolute path if calculation fails
+		fmt.Printf("Warning: Could not get relative path for '%s' relative to '%s': %v. Using absolute path.\n", localPath, baseDir, err)
+		return localPath
+	}
+
+	return relativePath
+}
+
 func processSarifAndSendResults(sarifPath string, commitUUID string, projectToken string, apiToken string, tools map[string]*plugins.ToolInfo) {
 	if projectToken == "" && apiToken == "" && provider == "" && repository == "" {
 		fmt.Println("Error: api-token, provider and repository are required when project-token is not provided")
@@ -86,6 +129,12 @@ func processSarif(sarif Sarif, tools map[string]*plugins.ToolInfo) [][]map[strin
 	var codacyIssues []map[string]interface{}
 	var payloads [][]map[string]interface{}
 
+	baseDir, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Error getting current working directory: %v\n", err)
+		os.Exit(1)
+	}
+
 	for _, run := range sarif.Runs {
 		var toolName = getToolName(strings.ToLower(run.Tool.Driver.Name), run.Tool.Driver.Version)
 		tool, patterns := loadsToolAndPatterns(toolName, false)
@@ -98,8 +147,12 @@ func processSarif(sarif Sarif, tools map[string]*plugins.ToolInfo) [][]map[strin
 				continue
 			}
 			for _, location := range result.Locations {
+
+				fullURI := location.PhysicalLocation.ArtifactLocation.URI
+				relativePath := getRelativePath(baseDir, fullURI)
+
 				issue := map[string]interface{}{
-					"source":   location.PhysicalLocation.ArtifactLocation.URI,
+					"source":   relativePath,
 					"line":     location.PhysicalLocation.Region.StartLine,
 					"type":     pattern.ID,
 					"message":  result.Message.Text,
@@ -119,8 +172,12 @@ func processSarif(sarif Sarif, tools map[string]*plugins.ToolInfo) [][]map[strin
 		// Iterate through run.Artifacts and create entries in the results object
 		for _, artifact := range run.Artifacts {
 			if artifact.Location.URI != "" {
+
+				fullURI := artifact.Location.URI
+				relativePath := getRelativePath(baseDir, fullURI)
+
 				results = append(results, map[string]interface{}{
-					"filename": artifact.Location.URI,
+					"filename": relativePath,
 					"results":  []map[string]interface{}{},
 				})
 			}
@@ -169,10 +226,10 @@ func processSarif(sarif Sarif, tools map[string]*plugins.ToolInfo) [][]map[strin
 			}
 
 		}
-
+		var toolShortName = getToolShortName(toolName)
 		payload := []map[string]interface{}{
 			{
-				"tool": toolName,
+				"tool": toolShortName,
 				"issues": map[string]interface{}{
 					"Success": map[string]interface{}{
 						"results": results,

cmd/upload_test.go

@@ -0,0 +1,129 @@
+package cmd
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetRelativePath(t *testing.T) {
+	const baseDir = "/home/user/project/src"
+
+	tests := []struct {
+		name     string
+		baseDir  string
+		fullURI  string
+		expected string
+	}{
+		{
+			name:     "1. File URI with standard path",
+			baseDir:  baseDir,
+			fullURI:  "file:///home/user/project/src/lib/file.go",
+			expected: "lib/file.go",
+		},
+		{
+			name:     "2. File URI with baseDir as the file path",
+			baseDir:  baseDir,
+			fullURI:  "file:///home/user/project/src",
+			expected: ".",
+		},
+		{
+			name:     "3. Simple path (no scheme)",
+			baseDir:  baseDir,
+			fullURI:  "/home/user/project/src/main.go",
+			expected: "main.go",
+		},
+		{
+			name:    "4. URI outside baseDir (should return absolute path if relative fails)",
+			baseDir: baseDir,
+			fullURI: "file:///etc/config/app.json",
+			// This is outside of baseDir, so we expect the absolute path starting from the baseDir root
+			expected: "../../../../etc/config/app.json",
+		},
+		{
+			name:     "5. Plain URI with different scheme (should be treated as plain path)",
+			baseDir:  baseDir,
+			fullURI:  "http://example.com/api/v1/file.go",
+			expected: "http://example.com/api/v1/file.go",
+		},
+		{
+			name:     "6. Empty URI",
+			baseDir:  baseDir,
+			fullURI:  "",
+			expected: "",
+		},
+		{
+			name:     "7. Windows path on a file URI (should correctly strip the leading slash from the path component)",
+			baseDir:  "C:\\Users\\dev\\repo",
+			fullURI:  "file:///C:/Users/dev/repo/app/main.go",
+			expected: "/C:/Users/dev/repo/app/main.go",
+		},
+		{
+			name:     "8. URI with spaces (URL encoded)",
+			baseDir:  baseDir,
+			fullURI:  "file:///home/user/project/src/file%20with%20spaces.go",
+			expected: "file with spaces.go",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual := getRelativePath(tt.baseDir, tt.fullURI)
+			expectedNormalized := filepath.FromSlash(tt.expected)
+			assert.Equal(t, expectedNormalized, actual, "Relative path should match expected")
+		})
+	}
+}
+func TestGetToolShortName(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "MappedTool_ESLint8",
+			input:    "ESLint",
+			expected: "eslint-8",
+		},
+		{
+			name:     "MappedTool_PMD7",
+			input:    "PMD7",
+			expected: "pmd-7",
+		},
+		{
+			name:     "MappedTool_Pylint",
+			input:    "Pylint",
+			expected: "pylintpython3",
+		},
+		{
+			name:     "UnmappedTool_Fallback",
+			input:    "NewToolName",
+			expected: "NewToolName",
+		},
+		{
+			name:     "UnmappedTool_AnotherFallback",
+			input:    "SomeAnalyzer",
+			expected: "SomeAnalyzer",
+		},
+		{
+			name:     "EmptyInput_Fallback",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "MappedTool_Deprecated",
+			input:    "ESLint (deprecated)",
+			expected: "eslint",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual := getToolShortName(tt.input)
+			if actual != tt.expected {
+				t.Errorf("getToolShortName(%q) = %q; want %q", tt.input, actual, tt.expected)
+			}
+		})
+	}
+}

codacy-client/client.go

@@ -170,13 +170,13 @@ func parsePatternConfigurations(response []byte) ([]domain.PatternConfiguration,
 	return patternConfigurations, pagination.Cursor, nil
 }
 
-// GetDefaultToolPatternsConfig fetches the default patterns for a tool
-func GetDefaultToolPatternsConfig(initFlags domain.InitFlags, toolUUID string, onlyEnabledPatterns bool) ([]domain.PatternConfiguration, error) {
-	return GetDefaultToolPatternsConfigWithCodacyAPIBase(CodacyApiBase, initFlags, toolUUID, onlyEnabledPatterns)
+// GetToolPatternsConfig fetches the default patterns for a tool
+func GetToolPatternsConfig(initFlags domain.InitFlags, toolUUID string, onlyEnabledPatterns bool) ([]domain.PatternConfiguration, error) {
+	return GetToolPatternsConfigWithCodacyAPIBase(CodacyApiBase, initFlags, toolUUID, onlyEnabledPatterns)
 }
 
-// GetDefaultToolPatternsConfigWithCodacyAPIBase fetches the default patterns for a tool, and a base api url
-func GetDefaultToolPatternsConfigWithCodacyAPIBase(codacyAPIBaseURL string, initFlags domain.InitFlags, toolUUID string, onlyEnabledPatterns bool) ([]domain.PatternConfiguration, error) {
+// GetToolPatternsConfigWithCodacyAPIBase fetches the default patterns for a tool, and a base api url
+func GetToolPatternsConfigWithCodacyAPIBase(codacyAPIBaseURL string, initFlags domain.InitFlags, toolUUID string, onlyEnabledPatterns bool) ([]domain.PatternConfiguration, error) {
 	baseURL := fmt.Sprintf("%s/api/v3/tools/%s/patterns", codacyAPIBaseURL, toolUUID)
 	if onlyEnabledPatterns {
 		baseURL += "?enabled=true"
@@ -187,14 +187,7 @@ func GetDefaultToolPatternsConfigWithCodacyAPIBase(codacyAPIBaseURL string, init
 		return nil, err
 	}
 
-	onlyRecommendedPatterns := make([]domain.PatternConfiguration, 0)
-	for _, pattern := range allPaterns {
-		if pattern.PatternDefinition.Enabled {
-			onlyRecommendedPatterns = append(onlyRecommendedPatterns, pattern)
-		}
-	}
-
-	return onlyRecommendedPatterns, nil
+	return allPaterns, nil
 }
 
 // GetRepositoryToolPatterns fetches the patterns for a tool in a repository

codacy-client/client_test.go

@@ -2,7 +2,6 @@ package codacyclient
 
 import (
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -91,7 +90,7 @@ func TestGetPageAndGetAllPages(t *testing.T) {
 	assert.Len(t, allItems, 3)
 }
 
-func TestGetDefaultToolPatternsConfig_Empty(t *testing.T) {
+func TestGetToolPatternsConfig_Empty(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		resp := map[string]interface{}{
 			"data":       []interface{}{},
@@ -104,52 +103,7 @@ func TestGetDefaultToolPatternsConfig_Empty(t *testing.T) {
 	CodacyApiBase = ts.URL
 
 	initFlags := domain.InitFlags{ApiToken: "dummy"}
-	patterns, err := GetDefaultToolPatternsConfigWithCodacyAPIBase(CodacyApiBase, initFlags, "tool-uuid", true)
+	patterns, err := GetToolPatternsConfigWithCodacyAPIBase(CodacyApiBase, initFlags, "tool-uuid", true)
 	assert.NoError(t, err)
 	assert.Empty(t, patterns)
 }
-
-func TestGetDefaultToolPatternsConfig_WithNonRecommended(t *testing.T) {
-
-	config := []domain.PatternDefinition{
-		{
-			Id:      "internal_id_1",
-			Enabled: true,
-		},
-		{
-			Id:      "internal_id_2",
-			Enabled: false,
-		},
-	}
-
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-
-		resp := map[string]interface{}{
-			"data":       config,
-			"pagination": map[string]interface{}{"cursor": ""},
-		}
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(resp)
-	}))
-	defer ts.Close()
-
-	expected := []domain.PatternConfiguration{
-		{
-			Enabled: true,
-			PatternDefinition: domain.PatternDefinition{
-				Id:      "internal_id_1",
-				Enabled: true,
-			},
-		},
-	}
-
-	CodacyApiBase = ts.URL
-
-	initFlags := domain.InitFlags{ApiToken: "dummy"}
-	patterns, err := GetDefaultToolPatternsConfigWithCodacyAPIBase(CodacyApiBase, initFlags, "tool-uuid", true)
-
-	fmt.Println(len(patterns))
-
-	assert.NoError(t, err)
-	assert.Equal(t, expected, patterns)
-}