replace semgrep with opengrep

Author: heliocodacy

.codacy/codacy.yaml

@@ -10,6 +10,6 @@ tools:
     - pmd@6.55.0
     - pylint@3.3.9
     - revive@1.12.0
-    - semgrep@1.78.0
+    - opengrep@1.16.2
     - trivy@0.66.0
     - dartanalyzer@3.7.2

cmd/analyze.go

@@ -273,7 +273,7 @@ var versionedToolNames = map[string]map[int]string{
 
 var simpleToolAliases = map[string]string{
 	"lizard":  "Lizard",
-	"semgrep": "Semgrep",
+	"opengrep": "Opengrep",
 	"pylint":  "pylintpython3",
 	"trivy":   "Trivy",
 }
@@ -405,9 +405,9 @@ func runToolByName(toolName string, workDirectory string, pathsToCheck []string,
 	case "dartanalyzer":
 		binaryPath := tool.Binaries[tool.Runtime]
 		return tools.RunDartAnalyzer(workDirectory, tool.InstallDir, binaryPath, pathsToCheck, outputFile, outputFormat)
-	case "semgrep":
+	case "opengrep":
 		binaryPath := tool.Binaries[toolName]
-		return tools.RunSemgrep(workDirectory, binaryPath, pathsToCheck, outputFile, outputFormat)
+		return tools.RunOpengrep(workDirectory, binaryPath, pathsToCheck, outputFile, outputFormat)
 	case "lizard":
 		binaryPath := tool.Binaries[tool.Runtime]
 		return lizard.RunLizard(workDirectory, binaryPath, pathsToCheck, outputFile, outputFormat)

cmd/analyze_integration_test.go

@@ -114,7 +114,7 @@ func TestToolConfigFileNameMapCompleteness(t *testing.T) {
 		"pmd":          constants.PMDConfigFileName,
 		"pylint":       constants.PylintConfigFileName,
 		"dartanalyzer": constants.DartAnalyzerConfigFileName,
-		"semgrep":      constants.SemgrepConfigFileName,
+		"opengrep":     constants.OpengrepConfigFileName,
 		"revive":       constants.ReviveConfigFileName,
 		"lizard":       constants.LizardConfigFileName,
 	}

cmd/analyze_test.go

@@ -449,7 +449,7 @@ func TestToolConfigFileNameMap(t *testing.T) {
 		"pmd":          constants.PMDConfigFileName,
 		"pylint":       constants.PylintConfigFileName,
 		"dartanalyzer": constants.DartAnalyzerConfigFileName,
-		"semgrep":      constants.SemgrepConfigFileName,
+		"opengrep":     constants.OpengrepConfigFileName,
 		"revive":       constants.ReviveConfigFileName,
 		"lizard":       constants.LizardConfigFileName,
 	}

cmd/configsetup/tool_creators.go

@@ -24,7 +24,7 @@ var toolConfigRegistry = map[string]ToolConfigCreator{
 	domain.PMD7:         &pmd7ConfigCreator{},
 	domain.PyLint:       &pylintConfigCreator{},
 	domain.DartAnalyzer: &dartAnalyzerConfigCreator{},
-	domain.Semgrep:      &semgrepConfigCreator{},
+	domain.Opengrep:     &opengrepConfigCreator{},
 	domain.Lizard:       &lizardConfigCreator{},
 	domain.Revive:       &reviveConfigCreator{},
 }
@@ -121,23 +121,23 @@ func (d *dartAnalyzerConfigCreator) GetConfigFileName() string {
 }
 func (d *dartAnalyzerConfigCreator) GetToolName() string { return "Dart Analyzer" }
 
-// semgrepConfigCreator implements ToolConfigCreator for Semgrep
-type semgrepConfigCreator struct{}
+// opengrepConfigCreator implements ToolConfigCreator for Opengrep
+type opengrepConfigCreator struct{}
 
-func (s *semgrepConfigCreator) CreateConfig(toolsConfigDir string, patterns []domain.PatternConfiguration) error {
-	configData, err := tools.GetSemgrepConfig(patterns)
+func (s *opengrepConfigCreator) CreateConfig(toolsConfigDir string, patterns []domain.PatternConfiguration) error {
+	configData, err := tools.GetOpengrepConfig(patterns)
 	if err != nil {
-		return fmt.Errorf("failed to create Semgrep config: %v", err)
+		return fmt.Errorf("failed to create Opengrep config: %v", err)
 	}
-	err = writeConfigFile(filepath.Join(toolsConfigDir, constants.SemgrepConfigFileName), configData)
+	err = writeConfigFile(filepath.Join(toolsConfigDir, constants.OpengrepConfigFileName), configData)
 	if err == nil {
-		fmt.Println("Semgrep configuration created based on Codacy settings")
+		fmt.Println("Opengrep configuration created based on Codacy settings")
 	}
 	return err
 }
 
-func (s *semgrepConfigCreator) GetConfigFileName() string { return constants.SemgrepConfigFileName }
-func (s *semgrepConfigCreator) GetToolName() string       { return "Semgrep" }
+func (s *opengrepConfigCreator) GetConfigFileName() string { return constants.OpengrepConfigFileName }
+func (s *opengrepConfigCreator) GetToolName() string       { return "Opengrep" }
 
 // lizardConfigCreator implements ToolConfigCreator for Lizard
 type lizardConfigCreator struct{}

cmd/init_test.go

@@ -25,7 +25,7 @@ func TestConfigFileTemplate(t *testing.T) {
 				"node@22.2.0",
 				"python@3.11.11",
 				"eslint@8.57.0",
-				"trivy@0.66.0",
+				"trivy@0.69.3",
 				"pylint@3.3.6",
 				"pmd@7.11.0",
 			},

cmd/upload.go

@@ -55,7 +55,7 @@ var sarifShortNameMap = map[string]string{
 	"Trivy":               "trivy",
 	"Pylint":              "pylintpython3",
 	"dartanalyzer":        "dartanalyzer",
-	"Semgrep":             "semgrep",
+	"Opengrep":            "opengrep",
 	"Lizard":              "lizard",
 	"revive":              "revive",
 }

config/tools-installer.go

@@ -7,6 +7,7 @@ import (
 	"codacy/cli-v2/utils"
 	"codacy/cli-v2/utils/logger"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"os/exec"
@@ -297,29 +298,43 @@ func installDownloadBasedTool(toolInfo *plugins.ToolInfo) error {
 		return fmt.Errorf("failed to create installation directory: %w", err)
 	}
 
-	// Extract based on file extension
-	logger.Debug("Extracting tool", logrus.Fields{
-		"tool":             toolInfo.Name,
-		"version":          toolInfo.Version,
-		"fileName":         fileName,
-		"extractDirectory": toolInfo.InstallDir,
-	})
+	isArchive := strings.HasSuffix(fileName, ".zip") || strings.HasSuffix(fileName, ".tar.gz") || strings.HasSuffix(fileName, ".tgz")
 
-	if strings.HasSuffix(fileName, ".zip") {
-		err = utils.ExtractZip(file.Name(), toolInfo.InstallDir)
-	} else {
-		err = utils.ExtractTarGz(file, toolInfo.InstallDir)
-	}
+	if isArchive {
+		// Extract based on file extension
+		logger.Debug("Extracting tool", logrus.Fields{
+			"tool":             toolInfo.Name,
+			"version":          toolInfo.Version,
+			"fileName":         fileName,
+			"extractDirectory": toolInfo.InstallDir,
+		})
 
-	if err != nil {
-		return fmt.Errorf("failed to extract tool: %w", err)
-	}
+		if strings.HasSuffix(fileName, ".zip") {
+			err = utils.ExtractZip(file.Name(), toolInfo.InstallDir)
+		} else {
+			err = utils.ExtractTarGz(file, toolInfo.InstallDir)
+		}
+
+		if err != nil {
+			return fmt.Errorf("failed to extract tool: %w", err)
+		}
 
-	// Make sure all binaries are executable
-	for _, binaryPath := range toolInfo.Binaries {
-		err = os.Chmod(filepath.Join(toolInfo.InstallDir, filepath.Base(binaryPath)), constants.DefaultDirPerms)
-		if err != nil && !os.IsNotExist(err) {
-			return fmt.Errorf("failed to make binary executable: %w", err)
+		// Make sure all binaries are executable
+		for _, binaryPath := range toolInfo.Binaries {
+			err = os.Chmod(filepath.Join(toolInfo.InstallDir, filepath.Base(binaryPath)), constants.DefaultDirPerms)
+			if err != nil && !os.IsNotExist(err) {
+				return fmt.Errorf("failed to make binary executable: %w", err)
+			}
+		}
+	} else {
+		// Bare binary — copy directly to the binary destination path
+		logger.Debug("Installing bare binary", logrus.Fields{
+			"tool":         toolInfo.Name,
+			"version":      toolInfo.Version,
+			"downloadPath": downloadPath,
+		})
+		if err = installBareBinary(downloadPath, toolInfo); err != nil {
+			return fmt.Errorf("failed to install binary: %w", err)
 		}
 	}
 
@@ -330,6 +345,44 @@ func installDownloadBasedTool(toolInfo *plugins.ToolInfo) error {
 	return nil
 }
 
+// installBareBinary copies a downloaded bare binary to its destination path and makes it executable.
+func installBareBinary(downloadPath string, toolInfo *plugins.ToolInfo) error {
+	var destPath string
+	for _, p := range toolInfo.Binaries {
+		destPath = p
+		break
+	}
+	if destPath == "" {
+		return fmt.Errorf("no binary destination defined for tool %s", toolInfo.Name)
+	}
+
+	if err := os.MkdirAll(filepath.Dir(destPath), constants.DefaultDirPerms); err != nil {
+		return fmt.Errorf("failed to create binary directory: %w", err)
+	}
+
+	src, err := os.Open(downloadPath)
+	if err != nil {
+		return fmt.Errorf("failed to open downloaded binary: %w", err)
+	}
+	defer src.Close()
+
+	dst, err := os.Create(destPath)
+	if err != nil {
+		return fmt.Errorf("failed to create binary file: %w", err)
+	}
+	defer dst.Close()
+
+	if _, err = io.Copy(dst, src); err != nil {
+		return fmt.Errorf("failed to copy binary: %w", err)
+	}
+
+	if err = os.Chmod(destPath, constants.DefaultDirPerms); err != nil {
+		return fmt.Errorf("failed to make binary executable: %w", err)
+	}
+
+	return nil
+}
+
 func installPythonTool(name string, toolInfo *plugins.ToolInfo) error {
 	logger.Debug("Starting Python tool installation", logrus.Fields{
 		"tool":    toolInfo.Name,

constants/tool_configs.go

@@ -12,7 +12,7 @@ const (
 	PMDConfigFileName          = "ruleset.xml"
 	PylintConfigFileName       = "pylint.rc"
 	DartAnalyzerConfigFileName = "analysis_options.yaml"
-	SemgrepConfigFileName      = "semgrep.yaml"
+	OpengrepConfigFileName     = "semgrep.yaml"
 	ReviveConfigFileName       = "revive.toml"
 	LizardConfigFileName       = "lizard.yaml"
 )
@@ -24,7 +24,7 @@ var ToolConfigFileNames = map[string]string{
 	"pmd":          PMDConfigFileName,
 	"pylint":       PylintConfigFileName,
 	"dartanalyzer": DartAnalyzerConfigFileName,
-	"semgrep":      SemgrepConfigFileName,
+	"opengrep":     OpengrepConfigFileName,
 	"revive":       ReviveConfigFileName,
 	"lizard":       LizardConfigFileName,
 }

domain/tool.go

@@ -28,7 +28,7 @@ const (
 	PMD7         string = "ed7e8287-707d-485a-a0cb-e211004432c2"
 	PyLint       string = "31677b6d-4ae0-4f56-8041-606a8d7a8e61"
 	DartAnalyzer string = "d203d615-6cf1-41f9-be5f-e2f660f7850f"
-	Semgrep      string = "6792c561-236d-41b7-ba5e-9d6bee0d548b"
+	Opengrep     string = "6792c561-236d-41b7-ba5e-9d6bee0d548b"
 	Lizard       string = "76348462-84b3-409a-90d3-955e90abfb87"
 	Revive       string = "bd81d1f4-1406-402d-9181-1274ee09f1aa"
 )
@@ -48,6 +48,6 @@ var SupportedToolsMetadata = map[string]ToolInfo{
 	Trivy:        {Name: "trivy", Priority: 0},
 	DartAnalyzer: {Name: "dartanalyzer", Priority: 0},
 	Lizard:       {Name: "lizard", Priority: 0},
-	Semgrep:      {Name: "semgrep", Priority: 0},
+	Opengrep:     {Name: "opengrep", Priority: 0},
 	Revive:       {Name: "revive", Priority: 0},
 }