Support --format for mcpd add (#102)

Author: peteski22

cmd/add.go

@@ -2,12 +2,14 @@ package cmd
 
 import (
 	"fmt"
+	"io"
 	"strings"
 
 	"github.com/spf13/cobra"
 
-	"github.com/mozilla-ai/mcpd/v2/internal/cmd"
+	internalcmd "github.com/mozilla-ai/mcpd/v2/internal/cmd"
 	cmdopts "github.com/mozilla-ai/mcpd/v2/internal/cmd/options"
+	"github.com/mozilla-ai/mcpd/v2/internal/cmd/output"
 	"github.com/mozilla-ai/mcpd/v2/internal/config"
 	"github.com/mozilla-ai/mcpd/v2/internal/filter"
 	"github.com/mozilla-ai/mcpd/v2/internal/flags"
@@ -20,27 +22,29 @@ import (
 
 // AddCmd should be used to represent the 'add' command.
 type AddCmd struct {
-	*cmd.BaseCmd
+	*internalcmd.BaseCmd
 	Version         string
 	Tools           []string
 	Runtime         string
 	Source          string
+	Format          internalcmd.OutputFormat
 	cfgLoader       config.Loader
-	packagePrinter  printer.Printer
+	packagePrinter  output.Printer[config.ServerEntry]
 	registryBuilder registry.Builder
 }
 
 // NewAddCmd creates a newly configured (Cobra) command.
-func NewAddCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error) {
+func NewAddCmd(baseCmd *internalcmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error) {
 	opts, err := cmdopts.NewOptions(opt...)
 	if err != nil {
 		return nil, err
 	}
 
 	c := &AddCmd{
 		BaseCmd:         baseCmd,
+		Format:          internalcmd.FormatText, // Default to plain text
 		cfgLoader:       opts.ConfigLoader,
-		packagePrinter:  opts.Printer,
+		packagePrinter:  &printer.ServerEntryPrinter{},
 		registryBuilder: opts.RegistryBuilder,
 	}
 
@@ -81,26 +85,38 @@ func NewAddCmd(baseCmd *cmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command,
 		"Optional, specify the source registry of the server package (e.g. `mcpm`)",
 	)
 
+	allowed := internalcmd.AllowedOutputFormats()
+	cobraCommand.Flags().Var(
+		&c.Format,
+		"format",
+		fmt.Sprintf("Specify the output format (one of: %s)", allowed.String()),
+	)
+
 	return cobraCommand, nil
 }
 
 // run is configured (via NewAddCmd) to be called by the Cobra framework when the command is executed.
 // It may return an error (or nil, when there is no error).
 func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
+	handler, err := internalcmd.FormatHandler(cmd.OutOrStdout(), c.Format, c.packagePrinter)
+	if err != nil {
+		return err
+	}
+
 	if len(args) == 0 || strings.TrimSpace(args[0]) == "" {
-		return fmt.Errorf("server name is required and cannot be empty")
+		return handler.HandleError(fmt.Errorf("server name is required and cannot be empty"))
 	}
 
 	name := strings.TrimSpace(args[0])
 
 	logger, err := c.Logger()
 	if err != nil {
-		return err
+		return handler.HandleError(err)
 	}
 
 	reg, err := c.registryBuilder.Build()
 	if err != nil {
-		return err
+		return handler.HandleError(err)
 	}
 
 	pkg, err := reg.Resolve(name, c.options()...)
@@ -114,35 +130,37 @@ func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
 			"source", c.Source,
 			"error", err,
 		)
-		return fmt.Errorf("⚠️ Failed to get package '%s@%s' from registry: %w", name, c.Version, err)
+		return handler.HandleError(fmt.Errorf(
+			"⚠️ Failed to get package '%s@%s' from registry: %w",
+			name,
+			c.Version,
+			err),
+		)
 	}
 
 	entry, err := parseServerEntry(pkg, runtime.Runtime(c.Runtime), c.Tools, c.MCPDSupportedRuntimes())
 	if err != nil {
-		return fmt.Errorf("error parsing server entry: %w", err)
+		return handler.HandleError(fmt.Errorf("error parsing server entry: %w", err))
 	}
 
 	cfg, err := c.cfgLoader.Load(flags.ConfigFile)
 	if err != nil {
-		return err
+		return handler.HandleError(err)
 	}
 
 	err = cfg.AddServer(entry)
 	if err != nil {
-		return err
+		return handler.HandleError(err)
 	}
 
-	// User-friendly output + logging
-	_, err = fmt.Fprintf(
-		cmd.OutOrStdout(),
-		"✓ Added server '%s' (version: %s), tools: %s\n",
-		name,
-		entry.PackageVersion(),
-		strings.Join(entry.Tools, ", "),
-	)
-	if err != nil {
-		return err
-	}
+	// User-friendly output for text format.
+	c.packagePrinter.SetHeader(func(w io.Writer, count int) {
+		_, _ = fmt.Fprintln(w)
+	})
+	c.packagePrinter.SetFooter(func(w io.Writer, count int) {
+		_, _ = fmt.Fprintln(w)
+	})
+
 	logger.Debug(
 		"Server added",
 		"name", name,
@@ -152,16 +170,7 @@ func (c *AddCmd) run(cmd *cobra.Command, args []string) error {
 	)
 
 	// Print the package info.
-	if err = c.packagePrinter.PrintPackage(pkg); err != nil {
-		return err
-	}
-
-	_, err = fmt.Fprintln(cmd.OutOrStdout())
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return handler.HandleResult(entry)
 }
 
 // selectRuntime returns the most appropriate runtime from a set of installations,

cmd/add_test.go

@@ -3,11 +3,8 @@ package cmd
 import (
 	"bytes"
 	"errors"
-	"slices"
 	"testing"
 
-	"github.com/mozilla-ai/mcpd/v2/internal/printer"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -48,23 +45,6 @@ func (f *fakeLoader) Load(_ string) (config.Modifier, error) {
 	return f.cfg, f.err
 }
 
-type fakePrinter struct {
-	printed packages.Package
-	opts    []printer.PackagePrinterOption
-	err     error
-}
-
-func (f *fakePrinter) PrintPackage(pkg packages.Package) error {
-	f.printed = pkg
-	return f.err
-}
-
-func (f *fakePrinter) SetOptions(opt ...printer.PackagePrinterOption) error {
-	f.opts = slices.Clone(opt)
-
-	return nil
-}
-
 type fakeRegistry struct {
 	pkg packages.Package
 	err error
@@ -103,6 +83,7 @@ func TestAddCmd_Success(t *testing.T) {
 		Version: "1.2.3",
 		InstallationDetails: map[runtime.Runtime]packages.Installation{
 			runtime.UVX: {
+				Command:     "uvx",
 				Package:     "mcp-server-1",
 				Recommended: true,
 			},
@@ -114,13 +95,12 @@ func TestAddCmd_Success(t *testing.T) {
 		&cmd.BaseCmd{},
 		cmdopts.WithConfigLoader(&fakeLoader{cfg: cfg}),
 		cmdopts.WithRegistryBuilder(&fakeBuilder{reg: &fakeRegistry{pkg: pkg}}),
-		cmdopts.WithPrinter(&fakePrinter{}),
 	)
 	require.NoError(t, err)
 	require.NotNil(t, cmdObj)
 
 	cmdObj.SetOut(buf)
-	cmdObj.SetArgs([]string{"mcp-server-1", "--version=1.2.3", "--tool=toolA", "--runtime=uvx"})
+	cmdObj.SetArgs([]string{"server1", "--version=1.2.3", "--tool=toolA", "--runtime=uvx"})
 
 	err = cmdObj.Execute()
 	require.NoError(t, err)
@@ -134,7 +114,6 @@ func TestAddCmd_MissingArgs(t *testing.T) {
 	cmdObj, err := NewAddCmd(&cmd.BaseCmd{},
 		cmdopts.WithConfigLoader(&fakeLoader{}),
 		cmdopts.WithRegistryBuilder(&fakeBuilder{}),
-		cmdopts.WithPrinter(&fakePrinter{}),
 	)
 	require.NoError(t, err)
 
@@ -149,7 +128,6 @@ func TestAddCmd_RegistryFails(t *testing.T) {
 	cmdObj, err := NewAddCmd(&cmd.BaseCmd{},
 		cmdopts.WithConfigLoader(&fakeLoader{}),
 		cmdopts.WithRegistryBuilder(&fakeBuilder{err: errors.New("registry error")}),
-		cmdopts.WithPrinter(&fakePrinter{}),
 	)
 	require.NoError(t, err)
 
@@ -160,7 +138,7 @@ func TestAddCmd_RegistryFails(t *testing.T) {
 }
 
 func TestAddCmd_BasicServerAdd(t *testing.T) {
-	output := &bytes.Buffer{}
+	o := &bytes.Buffer{}
 
 	pkg := packages.Package{
 		ID:      "testserver",
@@ -173,32 +151,31 @@ func TestAddCmd_BasicServerAdd(t *testing.T) {
 		},
 		InstallationDetails: map[runtime.Runtime]packages.Installation{
 			"uvx": {
+				Command:     "uvx",
 				Package:     "mcp-server-testserver",
 				Recommended: true,
 			},
 		},
 	}
 
 	cfg := &fakeConfig{}
-	fp := &fakePrinter{}
 	cmdObj, err := NewAddCmd(
 		&cmd.BaseCmd{},
 		cmdopts.WithConfigLoader(&fakeLoader{cfg: cfg}),
 		cmdopts.WithRegistryBuilder(&fakeBuilder{reg: &fakeRegistry{pkg: pkg}}),
-		cmdopts.WithPrinter(fp),
 	)
 	require.NoError(t, err)
 
-	cmdObj.SetOut(output)
-	cmdObj.SetErr(output)
+	cmdObj.SetOut(o)
+	cmdObj.SetErr(o)
 	cmdObj.SetArgs([]string{"testserver"})
 
 	// Run the command
 	err = cmdObj.Execute()
 	require.NoError(t, err)
 
 	// Output assertions
-	outStr := output.String()
+	outStr := o.String()
 	assert.Contains(t, outStr, "✓ Added server 'testserver'")
 	assert.Contains(t, outStr, "version: latest")
 

cmd/root.go

@@ -9,7 +9,6 @@ import (
 	"github.com/mozilla-ai/mcpd/v2/internal/cmd"
 	"github.com/mozilla-ai/mcpd/v2/internal/cmd/options"
 	"github.com/mozilla-ai/mcpd/v2/internal/flags"
-	"github.com/mozilla-ai/mcpd/v2/internal/printer"
 )
 
 type RootCmd struct {
@@ -74,17 +73,7 @@ func NewRootCmd(c *RootCmd) (*cobra.Command, error) {
 	}
 
 	for _, fn := range fns {
-		p, err := printer.NewPrinter(rootCmd.OutOrStdout())
-		if err != nil {
-			return nil, err
-		}
-
-		opts := []options.CmdOption{
-			options.WithPrinter(p),
-			options.WithRegistryBuilder(c.BaseCmd),
-		}
-
-		tempCmd, err := fn(c.BaseCmd, opts...)
+		tempCmd, err := fn(c.BaseCmd, options.WithRegistryBuilder(c.BaseCmd))
 		if err != nil {
 			return nil, err
 		}

cmd/search.go

@@ -27,7 +27,7 @@ type SearchCmd struct {
 	Format          internalcmd.OutputFormat
 	IsOfficial      bool
 	registryBuilder registry.Builder
-	packagePrinter  printer.Printer
+	packagePrinter  output.Printer[packages.Package]
 }
 
 func NewSearchCmd(baseCmd *internalcmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobra.Command, error) {
@@ -36,16 +36,13 @@ func NewSearchCmd(baseCmd *internalcmd.BaseCmd, opt ...cmdopts.CmdOption) (*cobr
 		return nil, err
 	}
 
-	// Override printer options to show separator for search.
-	if err = opts.Printer.SetOptions(printer.WithSeparator(true)); err != nil {
-		return nil, err
-	}
+	pkgPrinter := printer.NewPackagePrinter()
 
 	c := &SearchCmd{
 		BaseCmd:         baseCmd,
 		Format:          internalcmd.FormatText, // Default to plain text
 		registryBuilder: opts.RegistryBuilder,
-		packagePrinter:  opts.Printer,
+		packagePrinter:  printer.NewPackageResultsPrinter(pkgPrinter),
 	}
 
 	cobraCommand := &cobra.Command{
@@ -152,18 +149,9 @@ func (c *SearchCmd) filters() map[string]string {
 }
 
 func (c *SearchCmd) run(cmd *cobra.Command, args []string) (err error) {
-	// Configure the handler based on the requested format.
-	var handler output.Handler[packages.Package]
-	switch c.Format {
-	case internalcmd.FormatJSON:
-		handler = output.NewJSONHandler[packages.Package](cmd.OutOrStdout(), 2)
-	case internalcmd.FormatYAML:
-		handler = output.NewYAMLHandler[packages.Package](cmd.OutOrStdout(), 2)
-	case internalcmd.FormatText:
-		pkgListPrinter := printer.NewPackageListPrinter(c.packagePrinter)
-		handler = output.NewTextHandler[packages.Package](cmd.OutOrStdout(), pkgListPrinter)
-	default:
-		return fmt.Errorf("unexpected error, no handler for output format: %s", c.Format)
+	handler, err := internalcmd.FormatHandler(cmd.OutOrStdout(), c.Format, c.packagePrinter)
+	if err != nil {
+		return err
 	}
 
 	// Name not required, default to the wildcard.
@@ -182,5 +170,5 @@ func (c *SearchCmd) run(cmd *cobra.Command, args []string) (err error) {
 		return handler.HandleError(err)
 	}
 
-	return handler.HandleResults(results)
+	return handler.HandleResults(results...)
 }