refactor workflor to trigger tests

Author: reshmifrog

.github/actions/checkout-jfrog-repo/action.yml

@@ -0,0 +1,44 @@
+name: 'Checkout JFrog Repository'
+description: 'Checkout a JFrog repository with conditional logic based on whether repo/ref are provided'
+
+inputs:
+  repository:
+    description: 'Repository to checkout (e.g., jfrog/jfrog-cli). If empty, step is skipped.'
+    required: false
+    default: ''
+  ref:
+    description: 'Branch/tag/SHA to checkout'
+    required: false
+    default: 'master'
+  path:
+    description: 'Relative path to checkout to'
+    required: true
+  default-repository:
+    description: 'Default repository to use if repository input is empty but checkout is still needed'
+    required: false
+    default: ''
+  default-ref:
+    description: 'Default ref to use with default-repository'
+    required: false
+    default: 'master'
+
+runs:
+  using: 'composite'
+  steps:
+    # Checkout from specified repository if provided
+    - name: Checkout from specified repo
+      if: inputs.repository != ''
+      uses: actions/checkout@v5
+      with:
+        repository: ${{ inputs.repository }}
+        ref: ${{ inputs.ref }}
+        path: ${{ inputs.path }}
+
+    # Checkout from default repository if no specific repo but default is provided
+    - name: Checkout from default repo
+      if: inputs.repository == '' && inputs.default-repository != ''
+      uses: actions/checkout@v5
+      with:
+        repository: ${{ inputs.default-repository }}
+        ref: ${{ inputs.default-ref }}
+        path: ${{ inputs.path }}

.github/tools/detect-deps/main.go

@@ -0,0 +1,211 @@
+// Package main provides a tool to detect and resolve JFrog module dependencies
+// by parsing go.mod using `go mod edit -json` and checking for branch availability
+// in forked repositories.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+// GoMod represents the JSON structure from `go mod edit -json`
+type GoMod struct {
+	Module  Module    `json:"Module"`
+	Go      string    `json:"Go"`
+	Require []Require `json:"Require"`
+	Replace []Replace `json:"Replace"`
+}
+
+// Module represents the module path
+type Module struct {
+	Path string `json:"Path"`
+}
+
+// Require represents a required module
+type Require struct {
+	Path     string `json:"Path"`
+	Version  string `json:"Version"`
+	Indirect bool   `json:"Indirect"`
+}
+
+// Replace represents a replace directive
+type Replace struct {
+	Old ModuleVersion `json:"Old"`
+	New ModuleVersion `json:"New"`
+}
+
+// ModuleVersion represents a module with optional version
+type ModuleVersion struct {
+	Path    string `json:"Path"`
+	Version string `json:"Version,omitempty"`
+}
+
+// DependencyInfo holds information about a detected dependency
+type DependencyInfo struct {
+	Name       string // Short name like "build-info-go"
+	ModulePath string // Full module path like "github.com/jfrog/build-info-go"
+	Repo       string // Repository like "jfrog/build-info-go"
+	Ref        string // Branch or tag reference
+}
+
+// jfrogDependencies maps short names to their module paths
+var jfrogDependencies = map[string]string{
+	"build-info-go":    "github.com/jfrog/build-info-go",
+	"jfrog-client-go":  "github.com/jfrog/jfrog-client-go",
+	"jfrog-cli-core":   "github.com/jfrog/jfrog-cli-core/v2",
+}
+
+func main() {
+	// Get current branch from environment
+	currentBranch := os.Getenv("CURRENT_BRANCH")
+	if currentBranch == "" {
+		currentBranch = "main"
+	}
+
+	// Parse go.mod
+	goMod, err := parseGoMod()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error parsing go.mod: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Build a map of replace directives
+	replaces := make(map[string]Replace)
+	for _, r := range goMod.Replace {
+		replaces[r.Old.Path] = r
+	}
+
+	// Open GITHUB_OUTPUT file for writing outputs
+	outputFile := os.Getenv("GITHUB_OUTPUT")
+	var output *os.File
+	if outputFile != "" {
+		var err error
+		output, err = os.OpenFile(outputFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error opening GITHUB_OUTPUT: %v\n", err)
+			os.Exit(1)
+		}
+		defer output.Close()
+	}
+
+	fmt.Println("============================================")
+	fmt.Println("Detecting JFrog dependencies...")
+	fmt.Println("============================================")
+	fmt.Printf("Current branch: %s\n\n", currentBranch)
+
+	// Process each dependency
+	for name, modulePath := range jfrogDependencies {
+		info := detectDependency(name, modulePath, replaces, currentBranch)
+		writeOutput(output, name, info)
+	}
+}
+
+// parseGoMod runs `go mod edit -json` and parses the output
+func parseGoMod() (*GoMod, error) {
+	cmd := exec.Command("go", "mod", "edit", "-json")
+	out, err := cmd.Output()
+	if err != nil {
+		return nil, fmt.Errorf("failed to run go mod edit -json: %w", err)
+	}
+
+	var goMod GoMod
+	if err := json.Unmarshal(out, &goMod); err != nil {
+		return nil, fmt.Errorf("failed to parse go.mod JSON: %w", err)
+	}
+
+	return &goMod, nil
+}
+
+// detectDependency determines the repository and ref for a dependency
+func detectDependency(name, modulePath string, replaces map[string]Replace, currentBranch string) *DependencyInfo {
+	// Check if there's a replace directive for this module
+	if replace, ok := replaces[modulePath]; ok {
+		// Parse the replace target
+		newPath := replace.New.Path
+		if strings.HasPrefix(newPath, "github.com/") {
+			// Extract repo and version/ref
+			parts := strings.TrimPrefix(newPath, "github.com/")
+			repo := parts
+			ref := replace.New.Version
+
+			// Handle version format like "v1.2.3-0.20240101-abc123"
+			// The ref might be a pseudo-version containing a commit hash
+			if ref != "" {
+				fmt.Printf("Found replace directive: %s => %s @ %s\n", name, repo, ref)
+				return &DependencyInfo{
+					Name:       name,
+					ModulePath: modulePath,
+					Repo:       repo,
+					Ref:        ref,
+				}
+			}
+		}
+	}
+
+	// No replace directive found, check if current branch exists in the dependency repo
+	repo := fmt.Sprintf("jfrog/%s", name)
+	if name == "jfrog-cli-core" {
+		repo = "jfrog/jfrog-cli-core"
+	}
+
+	// Check if the current branch exists in the repo
+	if branchExists(repo, currentBranch) {
+		fmt.Printf("Branch '%s' exists in %s, using it\n", currentBranch, repo)
+		return &DependencyInfo{
+			Name:       name,
+			ModulePath: modulePath,
+			Repo:       repo,
+			Ref:        currentBranch,
+		}
+	}
+
+	// Fall back to master
+	fmt.Printf("No matching branch for %s, will use default (master)\n", name)
+	return nil
+}
+
+// branchExists checks if a branch exists in a GitHub repository
+func branchExists(repo, branch string) bool {
+	if branch == "" || branch == "main" || branch == "master" {
+		return false // Don't try to match main/master, use defaults
+	}
+
+	url := fmt.Sprintf("https://github.com/%s.git", repo)
+	cmd := exec.Command("git", "ls-remote", "--heads", url, branch)
+	out, err := cmd.Output()
+	if err != nil {
+		return false
+	}
+
+	// If output contains the branch name, it exists
+	return strings.Contains(string(out), fmt.Sprintf("refs/heads/%s", branch))
+}
+
+// writeOutput writes the dependency info to GITHUB_OUTPUT
+func writeOutput(output *os.File, name string, info *DependencyInfo) {
+	// Convert name to output key format (e.g., "build-info-go" -> "build_info_go")
+	keyName := strings.ReplaceAll(name, "-", "_")
+
+	var repo, ref string
+	if info != nil {
+		repo = info.Repo
+		ref = info.Ref
+	}
+
+	// Write to GITHUB_OUTPUT if available
+	if output != nil {
+		fmt.Fprintf(output, "%s_repo=%s\n", keyName, repo)
+		fmt.Fprintf(output, "%s_ref=%s\n", keyName, ref)
+	}
+
+	// Also print for visibility
+	if info != nil {
+		fmt.Printf("  %s_repo=%s\n", keyName, repo)
+		fmt.Printf("  %s_ref=%s\n", keyName, ref)
+	} else {
+		fmt.Printf("  %s: using default\n", keyName)
+	}
+}