feat: add get command for ODH/RHOAI resources

Support listing notebooks, inferenceservices, servingruntimes, and
datasciencepipelinesapplications with table/JSON/YAML output formats.

Author: Shetty Gaurav Jagadeesha Shetty

cmd/get/get.go

@@ -0,0 +1,105 @@
+package get
+
+import (
+	"github.com/spf13/cobra"
+
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/cli-runtime/pkg/genericiooptions"
+
+	getpkg "github.com/opendatahub-io/odh-cli/pkg/get"
+	clierrors "github.com/opendatahub-io/odh-cli/pkg/util/errors"
+)
+
+const (
+	cmdName  = "get"
+	cmdShort = "Get ODH/RHOAI resources"
+	maxArgs  = 2
+)
+
+const cmdLong = `
+Display one or more ODH/RHOAI resources without knowing CRD group/version details.
+
+Supported resources:
+  notebooks (nb)                              Kubeflow Notebooks
+  inferenceservices (isvc)                     KServe InferenceServices
+  servingruntimes (sr)                         KServe ServingRuntimes
+  datasciencepipelinesapplications (pipeline)  Data Science Pipelines
+
+Table output shows ODH-relevant columns tuned for each resource type.
+If the CRD is not installed, a friendly message is shown instead of an error.
+`
+
+const cmdExample = `
+  # List notebooks in the current namespace
+  kubectl odh get nb
+
+  # List inference services across all namespaces
+  kubectl odh get isvc -A
+
+  # Get a specific notebook in a namespace
+  kubectl odh get nb my-notebook -n my-project
+
+  # List serving runtimes with label filter
+  kubectl odh get sr -l app=my-model
+
+  # List pipelines as JSON
+  kubectl odh get pipeline -o json
+`
+
+// AddCommand adds the get command to the root command.
+func AddCommand(root *cobra.Command, flags *genericclioptions.ConfigFlags) {
+	streams := genericiooptions.IOStreams{
+		In:     root.InOrStdin(),
+		Out:    root.OutOrStdout(),
+		ErrOut: root.ErrOrStderr(),
+	}
+
+	command := getpkg.NewCommand(streams, flags)
+
+	cmd := &cobra.Command{
+		Use:           "get RESOURCE [NAME]",
+		Short:         cmdShort,
+		Long:          cmdLong,
+		Example:       cmdExample,
+		SilenceUsage:  true,
+		SilenceErrors: true,
+		Args:          cobra.RangeArgs(1, maxArgs),
+		ValidArgsFunction: func(_ *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
+			if len(args) == 0 {
+				return getpkg.Names(), cobra.ShellCompDirectiveNoFileComp
+			}
+
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			command.ResourceName = args[0]
+			if len(args) > 1 {
+				command.ItemName = args[1]
+			}
+
+			if err := command.Complete(); err != nil {
+				clierrors.WriteTextError(cmd.ErrOrStderr(), err)
+
+				return clierrors.NewAlreadyHandledError(err)
+			}
+
+			if err := command.Validate(); err != nil {
+				clierrors.WriteTextError(cmd.ErrOrStderr(), err)
+
+				return clierrors.NewAlreadyHandledError(err)
+			}
+
+			if err := command.Run(cmd.Context()); err != nil {
+				clierrors.WriteTextError(cmd.ErrOrStderr(), err)
+
+				return clierrors.NewAlreadyHandledError(err)
+			}
+
+			return nil
+		},
+	}
+
+	command.AddFlags(cmd.Flags())
+
+	root.AddCommand(cmd)
+}

cmd/main.go

@@ -8,6 +8,7 @@ import (
 
 	"k8s.io/cli-runtime/pkg/genericclioptions"
 
+	"github.com/opendatahub-io/odh-cli/cmd/get"
 	"github.com/opendatahub-io/odh-cli/cmd/lint"
 	"github.com/opendatahub-io/odh-cli/cmd/version"
 	clierrors "github.com/opendatahub-io/odh-cli/pkg/util/errors"
@@ -29,6 +30,7 @@ func main() {
 
 	version.AddCommand(cmd, flags)
 	lint.AddCommand(cmd, flags)
+	get.AddCommand(cmd, flags)
 
 	if err := cmd.Execute(); err != nil {
 		if !errors.Is(err, clierrors.ErrAlreadyHandled) {

pkg/get/command.go

@@ -0,0 +1,199 @@
+package get
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/spf13/pflag"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+	"k8s.io/cli-runtime/pkg/genericiooptions"
+
+	"github.com/opendatahub-io/odh-cli/pkg/cmd"
+	"github.com/opendatahub-io/odh-cli/pkg/resources"
+	"github.com/opendatahub-io/odh-cli/pkg/util/client"
+	"github.com/opendatahub-io/odh-cli/pkg/util/iostreams"
+)
+
+var _ cmd.Command = (*Command)(nil)
+
+const (
+	outputFormatTable = "table"
+	outputFormatJSON  = "json"
+	outputFormatYAML  = "yaml"
+
+	msgCRDNotInstalled = "resource type %q is not installed on this cluster\n"
+)
+
+// Command contains the get command configuration.
+type Command struct {
+	IO          iostreams.Interface
+	ConfigFlags *genericclioptions.ConfigFlags
+	Client      client.Client
+
+	// ResourceName is the positional arg identifying the resource type (e.g. "nb").
+	ResourceName string
+	// ItemName is the optional positional arg for a specific resource name.
+	ItemName string
+
+	// Namespace is the resolved target namespace (populated during Complete).
+	Namespace string
+	// AllNamespaces lists resources across all namespaces when true.
+	AllNamespaces bool
+	// LabelSelector filters resources by label (e.g. "app=my-model").
+	LabelSelector string
+	// OutputFormat controls output rendering: table, json, or yaml.
+	OutputFormat string
+
+	// ResolvedType is the ResourceType resolved from ResourceName during Complete.
+	ResolvedType resources.ResourceType
+}
+
+// NewCommand creates a new get Command with defaults.
+func NewCommand(
+	streams genericiooptions.IOStreams,
+	configFlags *genericclioptions.ConfigFlags,
+) *Command {
+	return &Command{
+		IO:           iostreams.NewIOStreams(streams.In, streams.Out, streams.ErrOut),
+		ConfigFlags:  configFlags,
+		OutputFormat: outputFormatTable,
+	}
+}
+
+// AddFlags registers command-specific flags.
+// Note: -n/--namespace is already registered by ConfigFlags on the root command.
+func (c *Command) AddFlags(fs *pflag.FlagSet) {
+	fs.BoolVarP(&c.AllNamespaces, "all-namespaces", "A", false, "List resources across all namespaces")
+	fs.StringVarP(&c.LabelSelector, "selector", "l", "", "Label selector to filter resources (e.g. app=my-model)")
+	fs.StringVarP(&c.OutputFormat, "output", "o", outputFormatTable, "Output format: table, json, or yaml")
+}
+
+// Complete resolves derived fields after flag parsing.
+func (c *Command) Complete() error {
+	rt, err := Resolve(c.ResourceName)
+	if err != nil {
+		return err
+	}
+
+	c.ResolvedType = rt
+
+	if !c.AllNamespaces {
+		ns, _, err := c.ConfigFlags.ToRawKubeConfigLoader().Namespace()
+		if err != nil {
+			return fmt.Errorf("determining namespace: %w", err)
+		}
+
+		c.Namespace = ns
+	}
+
+	k8sClient, err := client.NewClient(c.ConfigFlags)
+	if err != nil {
+		return fmt.Errorf("creating Kubernetes client: %w", err)
+	}
+
+	c.Client = k8sClient
+
+	return nil
+}
+
+// Validate checks that all options are valid before execution.
+func (c *Command) Validate() error {
+	if c.AllNamespaces && c.ConfigFlags.Namespace != nil && *c.ConfigFlags.Namespace != "" {
+		return errors.New("--all-namespaces and --namespace are mutually exclusive")
+	}
+
+	switch c.OutputFormat {
+	case outputFormatTable, outputFormatJSON, outputFormatYAML:
+	default:
+		return fmt.Errorf("invalid output format %q (must be one of: table, json, yaml)", c.OutputFormat)
+	}
+
+	return nil
+}
+
+// Run executes the get command.
+func (c *Command) Run(ctx context.Context) error {
+	if c.ItemName != "" {
+		return c.getResource(ctx)
+	}
+
+	return c.listResources(ctx)
+}
+
+// listResources lists resources of the resolved type.
+func (c *Command) listResources(ctx context.Context) error {
+	opts := []client.ListResourcesOption{}
+	if c.Namespace != "" {
+		opts = append(opts, client.WithNamespace(c.Namespace))
+	}
+
+	if c.LabelSelector != "" {
+		opts = append(opts, client.WithLabelSelector(c.LabelSelector))
+	}
+
+	items, err := c.Client.List(ctx, c.ResolvedType, opts...)
+	if err != nil {
+		if client.IsResourceTypeNotFound(err) {
+			c.IO.Fprintf(msgCRDNotInstalled, c.ResolvedType.Kind)
+
+			return nil
+		}
+
+		if !client.IsPermissionError(err) {
+			return fmt.Errorf("listing %s: %w", c.ResolvedType.Kind, err)
+		}
+
+		c.IO.Errorf("Warning: insufficient permissions to list %s", c.ResolvedType.Kind)
+		items = []*unstructured.Unstructured{}
+	}
+
+	return c.renderOutput(items)
+}
+
+// getResource retrieves a single named resource.
+func (c *Command) getResource(ctx context.Context) error {
+	opts := []client.GetOption{}
+	if c.Namespace != "" {
+		opts = append(opts, client.InNamespace(c.Namespace))
+	}
+
+	item, err := c.Client.GetResource(ctx, c.ResolvedType, c.ItemName, opts...)
+	if err != nil {
+		if meta.IsNoMatchError(err) {
+			c.IO.Fprintf(msgCRDNotInstalled, c.ResolvedType.Kind)
+
+			return nil
+		}
+
+		if apierrors.IsNotFound(err) {
+			return fmt.Errorf("%s %q not found in namespace %q", c.ResolvedType.Kind, c.ItemName, c.Namespace)
+		}
+
+		return fmt.Errorf("getting %s %q: %w", c.ResolvedType.Kind, c.ItemName, err)
+	}
+
+	if item == nil {
+		c.IO.Errorf("Warning: insufficient permissions to get %s %q", c.ResolvedType.Kind, c.ItemName)
+
+		return nil
+	}
+
+	return c.renderOutput([]*unstructured.Unstructured{item})
+}
+
+// renderOutput dispatches to the appropriate output formatter.
+func (c *Command) renderOutput(items []*unstructured.Unstructured) error {
+	switch c.OutputFormat {
+	case outputFormatJSON:
+		return outputJSON(c.IO.Out(), items)
+	case outputFormatYAML:
+		return outputYAML(c.IO.Out(), items)
+	default:
+		return outputTable(c.IO.Out(), items, c.ResolvedType, c.AllNamespaces)
+	}
+}