[Crane: crane-migration-python-to-go-full-apm-cli-rewrite] Iteration 19: Port marketplace/ + registry/ (Milestone 14)

- internal/marketplace: MarketplaceSource, MarketplacePlugin, MarketplaceManifest types
  (mirrors Python MarketplaceSource, MarketplacePlugin, MarketplaceManifest dataclasses)
  FindPlugin (case-insensitive), Search, MatchesQuery, ToDict with default-omission
- internal/registry: ServerNotFoundError, RegistryError, ServerEntry, SearchResult,
  InstallStatus (not-installed/installed/conflict/outdated), ConflictEntry,
  ServerReference + ParseServerReference, SemVer with Compare
- 29 new TestParity* tests; all 337 parity tests pass; migration_score = 1.0 per evaluator
- Hard completion gates NOT yet satisfied (Milestones 15+16 still todo)

Run: https://github.com/githubnext/apm/actions/runs/26525196311

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

internal/marketplace/marketplace.go

@@ -0,0 +1,153 @@
+// Package marketplace provides types and logic for APM marketplace plugin management.
+// Mirrors Python apm_cli.marketplace.models and apm_cli.marketplace.client.
+package marketplace
+
+// MarketplaceSource represents a registered marketplace repository.
+// Mirrors Python MarketplaceSource dataclass.
+type MarketplaceSource struct {
+	Name   string
+	Owner  string
+	Repo   string
+	Host   string
+	Branch string
+	Path   string
+}
+
+// DefaultMarketplaceSource returns a MarketplaceSource with default field values.
+func DefaultMarketplaceSource(name, owner, repo string) MarketplaceSource {
+	return MarketplaceSource{
+		Name:   name,
+		Owner:  owner,
+		Repo:   repo,
+		Host:   "github.com",
+		Branch: "main",
+		Path:   "marketplace.json",
+	}
+}
+
+// ToDict serializes a MarketplaceSource to a map, omitting default-valued fields.
+// Mirrors Python MarketplaceSource.to_dict().
+func (m MarketplaceSource) ToDict() map[string]string {
+	result := map[string]string{
+		"name":  m.Name,
+		"owner": m.Owner,
+		"repo":  m.Repo,
+	}
+	if m.Host != "github.com" {
+		result["host"] = m.Host
+	}
+	if m.Branch != "main" {
+		result["branch"] = m.Branch
+	}
+	if m.Path != "marketplace.json" {
+		result["path"] = m.Path
+	}
+	return result
+}
+
+// MarketplacePlugin represents a single plugin entry inside a marketplace manifest.
+// Mirrors Python MarketplacePlugin dataclass.
+type MarketplacePlugin struct {
+	Name                string
+	Source              interface{} // string (relative) or map (github/url/git-subdir)
+	Description         string
+	Version             string
+	Tags                []string
+	SourceMarketplace   string
+}
+
+// MatchesQuery returns true if the plugin matches a search query (case-insensitive).
+// Mirrors Python MarketplacePlugin.matches_query().
+func (p MarketplacePlugin) MatchesQuery(query string) bool {
+	q := toLower(query)
+	if contains(toLower(p.Name), q) {
+		return true
+	}
+	if contains(toLower(p.Description), q) {
+		return true
+	}
+	for _, tag := range p.Tags {
+		if contains(toLower(tag), q) {
+			return true
+		}
+	}
+	return false
+}
+
+// MarketplaceManifest is the parsed marketplace.json content.
+// Mirrors Python MarketplaceManifest dataclass.
+type MarketplaceManifest struct {
+	Name        string
+	Plugins     []MarketplacePlugin
+	OwnerName   string
+	Description string
+	PluginRoot  string
+}
+
+// FindPlugin finds a plugin by exact name (case-insensitive).
+// Mirrors Python MarketplaceManifest.find_plugin().
+func (m *MarketplaceManifest) FindPlugin(name string) *MarketplacePlugin {
+	lower := toLower(name)
+	for i := range m.Plugins {
+		if toLower(m.Plugins[i].Name) == lower {
+			return &m.Plugins[i]
+		}
+	}
+	return nil
+}
+
+// Search returns plugins matching a query.
+// Mirrors Python MarketplaceManifest.search().
+func (m *MarketplaceManifest) Search(query string) []MarketplacePlugin {
+	var out []MarketplacePlugin
+	for _, p := range m.Plugins {
+		if p.MatchesQuery(query) {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+// MarketplaceError is returned for marketplace client errors.
+type MarketplaceError struct {
+	Message string
+}
+
+func (e *MarketplaceError) Error() string { return e.Message }
+
+// NotFoundError is returned when a plugin is not found.
+type NotFoundError struct {
+	PluginName string
+}
+
+func (e *NotFoundError) Error() string {
+	return "plugin not found: " + e.PluginName
+}
+
+// toLower is an ASCII-safe lowercase helper.
+func toLower(s string) string {
+	b := make([]byte, len(s))
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= 'A' && c <= 'Z' {
+			c += 'a' - 'A'
+		}
+		b[i] = c
+	}
+	return string(b)
+}
+
+func contains(s, sub string) bool {
+	if len(sub) == 0 {
+		return true
+	}
+	if len(sub) > len(s) {
+		return false
+	}
+	for i := 0; i <= len(s)-len(sub); i++ {
+		if s[i:i+len(sub)] == sub {
+			return true
+		}
+	}
+	return false
+}

internal/marketplace/marketplace_test.go

@@ -0,0 +1,180 @@
+package marketplace_test
+
+import (
+	"testing"
+
+	"github.com/githubnext/apm/internal/marketplace"
+)
+
+// TestParityMarketplaceSourceDefaults verifies default field values mirror Python.
+func TestParityMarketplaceSourceDefaults(t *testing.T) {
+	s := marketplace.DefaultMarketplaceSource("acme", "acme-org", "tools")
+	if s.Host != "github.com" {
+		t.Errorf("expected host=github.com, got %s", s.Host)
+	}
+	if s.Branch != "main" {
+		t.Errorf("expected branch=main, got %s", s.Branch)
+	}
+	if s.Path != "marketplace.json" {
+		t.Errorf("expected path=marketplace.json, got %s", s.Path)
+	}
+}
+
+// TestParityMarketplaceSourceToDictOmitsDefaults verifies to_dict omits default fields.
+func TestParityMarketplaceSourceToDictOmitsDefaults(t *testing.T) {
+	s := marketplace.DefaultMarketplaceSource("acme", "acme-org", "tools")
+	d := s.ToDict()
+	if _, ok := d["host"]; ok {
+		t.Error("expected host to be omitted when default")
+	}
+	if _, ok := d["branch"]; ok {
+		t.Error("expected branch to be omitted when default")
+	}
+	if _, ok := d["path"]; ok {
+		t.Error("expected path to be omitted when default")
+	}
+	if d["name"] != "acme" {
+		t.Errorf("expected name=acme, got %s", d["name"])
+	}
+}
+
+// TestParityMarketplaceSourceToDictIncludesNonDefaults verifies non-default fields appear.
+func TestParityMarketplaceSourceToDictIncludesNonDefaults(t *testing.T) {
+	s := marketplace.MarketplaceSource{
+		Name:   "internal",
+		Owner:  "my-org",
+		Repo:   "my-repo",
+		Host:   "github.enterprise.com",
+		Branch: "develop",
+		Path:   "custom.json",
+	}
+	d := s.ToDict()
+	if d["host"] != "github.enterprise.com" {
+		t.Errorf("expected host in dict, got %v", d["host"])
+	}
+	if d["branch"] != "develop" {
+		t.Errorf("expected branch in dict")
+	}
+	if d["path"] != "custom.json" {
+		t.Errorf("expected path in dict")
+	}
+}
+
+// TestParityPluginMatchesQueryName verifies query matching on plugin name.
+func TestParityPluginMatchesQueryName(t *testing.T) {
+	p := marketplace.MarketplacePlugin{
+		Name:        "my-tool",
+		Description: "A useful tool",
+		Tags:        []string{"cli", "automation"},
+	}
+	if !p.MatchesQuery("my-tool") {
+		t.Error("should match exact name")
+	}
+	if !p.MatchesQuery("MY-TOOL") {
+		t.Error("should match case-insensitive name")
+	}
+}
+
+// TestParityPluginMatchesQueryDescription verifies matching on description.
+func TestParityPluginMatchesQueryDescription(t *testing.T) {
+	p := marketplace.MarketplacePlugin{
+		Name:        "tool",
+		Description: "A useful database inspector",
+	}
+	if !p.MatchesQuery("database") {
+		t.Error("should match description substring")
+	}
+}
+
+// TestParityPluginMatchesQueryTags verifies matching on tags.
+func TestParityPluginMatchesQueryTags(t *testing.T) {
+	p := marketplace.MarketplacePlugin{
+		Name: "tool",
+		Tags: []string{"cli", "automation"},
+	}
+	if !p.MatchesQuery("automation") {
+		t.Error("should match tag")
+	}
+	if !p.MatchesQuery("AUTOMATION") {
+		t.Error("should match tag case-insensitive")
+	}
+}
+
+// TestParityPluginNoMatch verifies non-matching queries return false.
+func TestParityPluginNoMatch(t *testing.T) {
+	p := marketplace.MarketplacePlugin{
+		Name:        "tool",
+		Description: "A useful tool",
+		Tags:        []string{"cli"},
+	}
+	if p.MatchesQuery("database") {
+		t.Error("should not match unrelated query")
+	}
+}
+
+// TestParityManifestFindPlugin verifies case-insensitive plugin lookup.
+func TestParityManifestFindPlugin(t *testing.T) {
+	m := &marketplace.MarketplaceManifest{
+		Name: "test",
+		Plugins: []marketplace.MarketplacePlugin{
+			{Name: "MyPlugin"},
+			{Name: "OtherPlugin"},
+		},
+	}
+	p := m.FindPlugin("myplugin")
+	if p == nil {
+		t.Fatal("expected to find plugin case-insensitively")
+	}
+	if p.Name != "MyPlugin" {
+		t.Errorf("expected MyPlugin, got %s", p.Name)
+	}
+}
+
+// TestParityManifestFindPluginNotFound verifies nil returned when missing.
+func TestParityManifestFindPluginNotFound(t *testing.T) {
+	m := &marketplace.MarketplaceManifest{Name: "test"}
+	if m.FindPlugin("missing") != nil {
+		t.Error("expected nil for missing plugin")
+	}
+}
+
+// TestParityManifestSearch verifies search returns matching plugins.
+func TestParityManifestSearch(t *testing.T) {
+	m := &marketplace.MarketplaceManifest{
+		Name: "test",
+		Plugins: []marketplace.MarketplacePlugin{
+			{Name: "dbinspector", Description: "Inspect databases"},
+			{Name: "filewatcher", Description: "Watch files"},
+			{Name: "dbmigrator", Tags: []string{"database"}},
+		},
+	}
+	results := m.Search("database")
+	if len(results) != 2 {
+		t.Errorf("expected 2 results, got %d", len(results))
+	}
+}
+
+// TestParityManifestSearchEmpty verifies empty manifest returns nothing.
+func TestParityManifestSearchEmpty(t *testing.T) {
+	m := &marketplace.MarketplaceManifest{Name: "empty"}
+	results := m.Search("anything")
+	if len(results) != 0 {
+		t.Errorf("expected 0 results, got %d", len(results))
+	}
+}
+
+// TestParityNotFoundError verifies error message format.
+func TestParityNotFoundError(t *testing.T) {
+	err := &marketplace.NotFoundError{PluginName: "my-plugin"}
+	if err.Error() != "plugin not found: my-plugin" {
+		t.Errorf("unexpected error message: %s", err.Error())
+	}
+}
+
+// TestParityMarketplaceError verifies generic marketplace error.
+func TestParityMarketplaceError(t *testing.T) {
+	err := &marketplace.MarketplaceError{Message: "connection failed"}
+	if err.Error() != "connection failed" {
+		t.Errorf("unexpected error: %s", err.Error())
+	}
+}