fix merge conflicts

Author: udaykb2

agent/cli/cli_test.go

@@ -19,7 +19,7 @@ func TestGetCommands_HasPluginsAndSkillsNamespaces(t *testing.T) {
 		assert.NotNil(t, sub.Action, "plugins subcommand %q must have an Action", sub.Name)
 		pluginsNames = append(pluginsNames, sub.Name)
 	}
-	assert.ElementsMatch(t, []string{"publish", "install", "update", "delete", "list"}, pluginsNames)
+	assert.ElementsMatch(t, []string{"publish", "install", "update", "delete", "list", "search"}, pluginsNames)
 
 	skills := commands[1]
 	assert.Equal(t, "skills", skills.Name)
@@ -38,6 +38,6 @@ func TestGetCommands_HasPluginsAndSkillsNamespaces(t *testing.T) {
 func TestGetCommands_PluginsPublishDescription(t *testing.T) {
 	commands := GetCommands()
 	publish := commands[0].Subcommands[0]
-	assert.Contains(t, publish.Description, "Publish an agent plugin to Artifactory")
-	assert.Contains(t, publish.Description, "Signs and attaches evidence")
+	assert.Equal(t, "publish", publish.Name)
+	assert.Equal(t, "Publish an agent plugin to Artifactory.", publish.Description)
 }

agent/common/file_operations_test.go

@@ -83,7 +83,7 @@ func TestEnsureDestinationDir_CreatesUnderExistingParent(t *testing.T) {
 
 func TestEnsureDestinationDir_CreatesNestedPath(t *testing.T) {
 	root := t.TempDir()
-	dest := filepath.Join(root, ".cursor", "plugins", "alpha")
+	dest := filepath.Join(root, "nested", "plugins", "alpha")
 	require.NoError(t, EnsureDestinationDir(dest))
 	info, err := os.Stat(dest)
 	require.NoError(t, err)

agent/common/property_search.go

@@ -0,0 +1,209 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils"
+	"github.com/jfrog/jfrog-cli-core/v2/utils/config"
+	"github.com/jfrog/jfrog-client-go/artifactory"
+	"github.com/jfrog/jfrog-client-go/artifactory/services"
+	clientutils "github.com/jfrog/jfrog-client-go/utils"
+	"github.com/jfrog/jfrog-client-go/utils/errorutils"
+	"github.com/jfrog/jfrog-client-go/utils/log"
+)
+
+// artifactoryPropertySearchAPI is the Artifactory REST path for GET property search.
+// See https://jfrog.com/help/r/jfrog-rest-apis/property-search
+const artifactoryPropertySearchAPI = "api/search/prop"
+
+// artifactoryStorageURIInfix is the "/api/storage/" segment in item URIs returned by property search.
+// Built from jfrog-client-go StorageRestApi (Artifactory Storage REST API path).
+const artifactoryStorageURIInfix = "/" + services.StorageRestApi
+
+// PropertySearchResult is one artifact hit from Artifactory GET api/search/prop.
+type PropertySearchResult struct {
+	Repo    string
+	Name    string
+	Version string
+	URI     string
+}
+
+// PropertySearchOptions configures a property search by package name key.
+type PropertySearchOptions struct {
+	NamePropertyKey string
+	Query           string
+	RepoKey         string
+}
+
+type propSearchResponse struct {
+	Results []propSearchResultItem `json:"results"`
+}
+
+type propSearchResultItem struct {
+	URI string `json:"uri"`
+}
+
+// HTTP client settings for property search: same defaults as jfrog-client-go config.NewConfigBuilder
+// (3 retries, 0 ms retry wait) and standard CLI lightweight API calls via utils.CreateServiceManager.
+const (
+	propertySearchHTTPRetries            = 3
+	propertySearchHTTPRetryWaitMilliSecs = 0
+)
+
+func createPropertySearchServiceManager(serverDetails *config.ServerDetails) (artifactory.ArtifactoryServicesManager, error) {
+	return utils.CreateServiceManager(
+		serverDetails,
+		propertySearchHTTPRetries,
+		propertySearchHTTPRetryWaitMilliSecs,
+		false,
+	)
+}
+
+// SearchByProperty calls GET api/search/prop?{namePropertyKey}={query}[&repos={repoKey}].
+func SearchByProperty(serverDetails *config.ServerDetails, opts PropertySearchOptions) ([]PropertySearchResult, error) {
+	query, err := validatePropertySearchOpts(opts)
+	if err != nil {
+		return nil, err
+	}
+	serviceManager, err := createPropertySearchServiceManager(serverDetails)
+	if err != nil {
+		return nil, err
+	}
+	artURL := clientutils.AddTrailingSlashIfNeeded(serviceManager.GetConfig().GetServiceDetails().GetUrl())
+	searchURL := propertySearchRequestURL(artURL, opts, query)
+	uris, err := fetchPropertySearchURIs(serviceManager, searchURL)
+	if err != nil {
+		return nil, err
+	}
+	return propertySearchResultsFromURIs(uris), nil
+}
+
+func validatePropertySearchOpts(opts PropertySearchOptions) (string, error) {
+	if strings.TrimSpace(opts.NamePropertyKey) == "" {
+		return "", fmt.Errorf("name property key is required for property search")
+	}
+	query := strings.TrimSpace(opts.Query)
+	if query == "" {
+		return "", fmt.Errorf("search query is required for property search")
+	}
+	return query, nil
+}
+
+func propertySearchRequestURL(artURL string, opts PropertySearchOptions, query string) string {
+	searchURL := fmt.Sprintf("%s%s?%s=%s", artURL, artifactoryPropertySearchAPI, opts.NamePropertyKey, url.QueryEscape(query))
+	if strings.TrimSpace(opts.RepoKey) != "" {
+		searchURL += "&repos=" + url.QueryEscape(opts.RepoKey)
+	}
+	return searchURL
+}
+
+func fetchPropertySearchURIs(serviceManager artifactory.ArtifactoryServicesManager, searchURL string) ([]string, error) {
+	log.Debug("Property search request:", searchURL)
+
+	httpDetails := serviceManager.GetConfig().GetServiceDetails().CreateHttpClientDetails()
+	resp, body, _, err := serviceManager.Client().SendGet(searchURL, true, &httpDetails)
+	if err != nil {
+		return nil, err
+	}
+	if err = errorutils.CheckResponseStatusWithBody(resp, body, http.StatusOK); err != nil {
+		return nil, err
+	}
+	var wrapper propSearchResponse
+	if err = json.Unmarshal(body, &wrapper); err != nil {
+		return nil, errorutils.CheckErrorf("failed to parse property search response: %s", err.Error())
+	}
+	uris := make([]string, len(wrapper.Results))
+	for i, item := range wrapper.Results {
+		uris[i] = item.URI
+	}
+	return uris, nil
+}
+
+func propertySearchResultsFromURIs(uris []string) []PropertySearchResult {
+	results := make([]PropertySearchResult, 0, len(uris))
+	for _, uri := range uris {
+		parsed, ok := parsePropertySearchURI(uri)
+		if !ok {
+			log.Warn(fmt.Sprintf("Skipping property search result with unparseable URI: %s", uri))
+			continue
+		}
+		results = append(results, parsed)
+	}
+	return results
+}
+
+// parsePropertySearchURI extracts repo, slug, and version from a storage URI like:
+// https://host/artifactory/api/storage/{repo}/{slug}/{version}/{slug}-{version}.zip
+func parsePropertySearchURI(uri string) (PropertySearchResult, bool) {
+	idx := strings.Index(uri, artifactoryStorageURIInfix)
+	if idx == -1 {
+		return PropertySearchResult{}, false
+	}
+	path := uri[idx+len(artifactoryStorageURIInfix):]
+	parts := strings.SplitN(path, "/", 4)
+	if len(parts) < 3 {
+		return PropertySearchResult{}, false
+	}
+	return PropertySearchResult{
+		Repo:    parts[0],
+		Name:    parts[1],
+		Version: parts[2],
+		URI:     uri,
+	}, true
+}
+
+// GetItemPropertyDescription returns the first non-empty value among descriptionPropertyKeys on repoPath.
+func GetItemPropertyDescription(
+	serverDetails *config.ServerDetails,
+	repoPath string,
+	descriptionPropertyKeys []string,
+) (string, error) {
+	serviceManager, err := createPropertySearchServiceManager(serverDetails)
+	if err != nil {
+		return "", err
+	}
+	props, err := serviceManager.GetItemProps(repoPath)
+	if err != nil {
+		return "", err
+	}
+	for _, key := range descriptionPropertyKeys {
+		if descs, ok := props.Properties[key]; ok && len(descs) > 0 {
+			return descs[0], nil
+		}
+	}
+	return "", nil
+}
+
+// SearchRowsByProperty runs property search and resolves optional description properties per hit.
+func SearchRowsByProperty(
+	serverDetails *config.ServerDetails,
+	opts PropertySearchOptions,
+	descriptionPropertyKeys []string,
+) ([]SearchResultRow, error) {
+	hits, err := SearchByProperty(serverDetails, opts)
+	if err != nil {
+		return nil, err
+	}
+	rows := make([]SearchResultRow, 0, len(hits))
+	for _, hit := range hits {
+		desc := ""
+		repoPath := fmt.Sprintf("%s/%s/%s/%s-%s.zip", hit.Repo, hit.Name, hit.Version, hit.Name, hit.Version)
+		d, err := GetItemPropertyDescription(serverDetails, repoPath, descriptionPropertyKeys)
+		if err != nil {
+			log.Debug(fmt.Sprintf("Could not fetch description for %s: %s", repoPath, err.Error()))
+		} else {
+			desc = d
+		}
+		rows = append(rows, SearchResultRow{
+			Name:        hit.Name,
+			Version:     hit.Version,
+			Repository:  hit.Repo,
+			Description: desc,
+		})
+	}
+	return rows, nil
+}

agent/common/property_search_test.go

@@ -0,0 +1,46 @@
+package common
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParsePropertySearchURI_Valid(t *testing.T) {
+	uri := "https://example.com/artifactory/api/storage/plugins-local/my-plugin/1.0.0/my-plugin-1.0.0.zip"
+	got, ok := parsePropertySearchURI(uri)
+	require.True(t, ok)
+	assert.Equal(t, "plugins-local", got.Repo)
+	assert.Equal(t, "my-plugin", got.Name)
+	assert.Equal(t, "1.0.0", got.Version)
+	assert.Equal(t, uri, got.URI)
+}
+
+func TestParsePropertySearchURI_Invalid(t *testing.T) {
+	_, ok := parsePropertySearchURI("https://example.com/artifactory/plugins-local/foo")
+	assert.False(t, ok)
+}
+
+func TestValidatePropertySearchOpts(t *testing.T) {
+	_, err := validatePropertySearchOpts(PropertySearchOptions{})
+	require.Error(t, err)
+
+	got, err := validatePropertySearchOpts(PropertySearchOptions{
+		NamePropertyKey: "agentplugins.name",
+		Query:           " my-plugin ",
+	})
+	require.NoError(t, err)
+	assert.Equal(t, "my-plugin", got)
+}
+
+func TestPropertySearchRequestURL(t *testing.T) {
+	opts := PropertySearchOptions{
+		NamePropertyKey: "agentplugins.name",
+		Query:           "demo",
+		RepoKey:         "plugins-local",
+	}
+	got := propertySearchRequestURL("https://example.com/artifactory/", opts, "demo")
+	assert.Contains(t, got, "https://example.com/artifactory/"+artifactoryPropertySearchAPI+"?agentplugins.name=demo")
+	assert.Contains(t, got, "repos=plugins-local")
+}

agent/common/search_output.go

@@ -0,0 +1,44 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/jfrog/jfrog-cli-core/v2/utils/coreutils"
+	"github.com/jfrog/jfrog-client-go/utils/log"
+)
+
+// SearchResultRow is one row in agent skills/plugins search output.
+type SearchResultRow struct {
+	Name        string `json:"name" col-name:"Name"`
+	Version     string `json:"version" col-name:"Version"`
+	Repository  string `json:"repository" col-name:"Repository"`
+	Description string `json:"description" col-name:"Description"`
+}
+
+// PrintSearchResultsOptions configures table/json output for search commands.
+type PrintSearchResultsOptions struct {
+	Query           string
+	Format          string
+	TableTitle      string
+	EmptyTableLabel string
+	NotFoundMessage string
+}
+
+// PrintSearchResults prints search rows as a table or JSON.
+func PrintSearchResults(rows []SearchResultRow, opts PrintSearchResultsOptions) error {
+	if len(rows) == 0 {
+		log.Info(fmt.Sprintf(opts.NotFoundMessage, opts.Query))
+		return nil
+	}
+	if strings.EqualFold(opts.Format, "json") {
+		data, err := json.MarshalIndent(rows, "", "  ")
+		if err != nil {
+			return fmt.Errorf("failed to marshal results: %w", err)
+		}
+		fmt.Println(string(data))
+		return nil
+	}
+	return coreutils.PrintTable(rows, opts.TableTitle, opts.EmptyTableLabel, false)
+}

agent/common/search_output_test.go

@@ -0,0 +1,55 @@
+package common
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPrintSearchResults_Table(t *testing.T) {
+	rows := []SearchResultRow{
+		{Name: "my-item", Version: "1.0.0", Repository: "repo-a", Description: "desc"},
+	}
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := PrintSearchResults(rows, PrintSearchResultsOptions{
+		Query:           "q",
+		Format:          "table",
+		TableTitle:      "Items",
+		EmptyTableLabel: "No items found",
+		NotFoundMessage: "No items for '%s'.",
+	})
+	require.NoError(t, err)
+
+	_ = w.Close()
+	os.Stdout = old
+
+	var buf bytes.Buffer
+	_, _ = buf.ReadFrom(r)
+	assert.Contains(t, buf.String(), "my-item")
+}
+
+func TestPrintSearchResults_JSON(t *testing.T) {
+	rows := []SearchResultRow{{Name: "a", Version: "1.0.0", Repository: "r"}}
+	old := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := PrintSearchResults(rows, PrintSearchResultsOptions{Query: "a", Format: "json", NotFoundMessage: "%s"})
+	require.NoError(t, err)
+
+	_ = w.Close()
+	os.Stdout = old
+
+	var buf bytes.Buffer
+	_, _ = buf.ReadFrom(r)
+	var parsed []SearchResultRow
+	require.NoError(t, json.Unmarshal(buf.Bytes(), &parsed))
+	assert.Len(t, parsed, 1)
+}