feat(plugin): setup basic structure

Author: t0mmylam

.gitignore

@@ -2,4 +2,6 @@
 .cursor
 .pytest_cache
 .idea
-**/err.txt
+**/err.txt
+plugin/bin/
+coverage.out

plugin/Makefile

@@ -0,0 +1,44 @@
+SHELL := /bin/bash
+
+BINARY ?= skyhook
+BIN_DIR ?= bin
+OUTPUT ?= $(BIN_DIR)/$(BINARY)
+VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo dev)
+GIT_SHA ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
+LDFLAGS ?= -s -w \
+	-X github.com/NVIDIA/skyhook/plugin/pkg/version.Version=$(VERSION) \
+	-X github.com/NVIDIA/skyhook/plugin/pkg/version.GitSHA=$(GIT_SHA)
+
+.PHONY: all build install clean test test-unit test-coverage fmt vet help
+
+all: fmt vet test build  ## Run all checks and build
+
+help:  ## Display this help
+	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z_0-9-]+:.*?##/ { printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
+
+
+##@ Testing
+
+test: test-unit  ## Run all tests
+
+test-unit:  ## Run unit tests
+	go test -v -race -coverprofile=coverage.out ./...
+
+test-coverage: test-unit  ## Run tests and open coverage report
+	go tool cover -html=coverage.out
+
+##@ Build
+
+build:  ## Build binary
+	@mkdir -p $(BIN_DIR)
+	go build -ldflags "$(LDFLAGS)" -o $(OUTPUT) .
+
+install:  ## Install binary to GOPATH
+	go install -ldflags "$(LDFLAGS)" .
+
+##@ Cleanup
+
+clean:  ## Clean build artifacts
+	rm -rf $(BIN_DIR)
+	rm -f coverage.out
+

plugin/cmd/root.go

@@ -0,0 +1,126 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
+
+	"github.com/NVIDIA/skyhook/plugin/pkg/version"
+)
+
+const defaultNamespace = "skyhook"
+
+// GlobalOptions holds persistent CLI options (kubeconfig, namespace, output, etc.).
+type GlobalOptions struct {
+	ConfigFlags  *genericclioptions.ConfigFlags
+	OutputFormat string
+	Verbose      bool
+}
+
+// NewGlobalOptions creates a new GlobalOptions with default values.
+func NewGlobalOptions() *GlobalOptions {
+	flags := genericclioptions.NewConfigFlags(true)
+	if flags.Namespace == nil {
+		flags.Namespace = new(string)
+	}
+	if *flags.Namespace == "" {
+		*flags.Namespace = defaultNamespace
+	}
+
+	return &GlobalOptions{
+		ConfigFlags:  flags,
+		OutputFormat: "table",
+	}
+}
+
+func (o *GlobalOptions) addFlags(flagset *pflag.FlagSet) {
+	o.ConfigFlags.AddFlags(flagset)
+	flagset.StringVarP(&o.OutputFormat, "output", "o", o.OutputFormat, "Output format. One of: table|json|yaml|wide")
+	flagset.BoolVarP(&o.Verbose, "verbose", "v", false, "Enable verbose output")
+}
+
+func (o *GlobalOptions) validate() error {
+	validFormats := map[string]struct{}{
+		"table": {},
+		"json":  {},
+		"yaml":  {},
+		"wide":  {},
+	}
+	o.OutputFormat = strings.ToLower(o.OutputFormat)
+	if _, ok := validFormats[o.OutputFormat]; !ok {
+		return fmt.Errorf("invalid output format %q", o.OutputFormat)
+	}
+	// No validation needed for boolean Verbose flag
+	return nil
+}
+
+// Namespace returns the namespace selected via kubeconfig or flag (default "skyhook").
+func (o *GlobalOptions) Namespace() string {
+	if o.ConfigFlags == nil || o.ConfigFlags.Namespace == nil {
+		return defaultNamespace
+	}
+	ns := strings.TrimSpace(*o.ConfigFlags.Namespace)
+	if ns == "" {
+		return defaultNamespace
+	}
+	return ns
+}
+
+// NewSkyhookCommand creates the root skyhook command with all subcommands.
+func NewSkyhookCommand(opts *GlobalOptions) *cobra.Command {
+	// skyhookCmd represents the root command
+	skyhookCmd := &cobra.Command{
+		Use:           "skyhook",
+		Short:         "Skyhook SRE plugin",
+		Long:          "kubectl-compatible helper for managing Skyhook deployments.",
+		Version:       version.Summary(),
+		SilenceErrors: true,
+		SilenceUsage:  true,
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			return opts.validate()
+		},
+	}
+
+	// Add global flags
+	opts.addFlags(skyhookCmd.PersistentFlags())
+
+	// Customize the version output template
+	skyhookCmd.SetVersionTemplate("Skyhook plugin: {{.Version}}\n")
+
+	// Add subcommands
+	skyhookCmd.AddCommand(
+		NewVersionCmd(opts),
+	)
+
+	return skyhookCmd
+}
+
+// Execute runs the Skyhook CLI and returns the exit code.
+func Execute() int {
+	opts := NewGlobalOptions()
+	if err := NewSkyhookCommand(opts).Execute(); err != nil {
+		return 1
+	}
+	return 0
+}

plugin/cmd/root_test.go

@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cmd
+
+import (
+	"testing"
+)
+
+// TestNewSkyhookCommand verifies the root command is properly configured
+func TestNewSkyhookCommand(t *testing.T) {
+	opts := NewGlobalOptions()
+	cmd := NewSkyhookCommand(opts)
+
+	if cmd == nil {
+		t.Fatal("NewSkyhookCommand returned nil")
+	}
+
+	// Verify version command is registered
+	found := false
+	for _, c := range cmd.Commands() {
+		if c.Name() == "version" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Error("version command not registered")
+	}
+}
+
+// TestGlobalOptions_Validate tests the validation logic
+func TestGlobalOptions_Validate(t *testing.T) {
+	tests := []struct {
+		name         string
+		outputFormat string
+		wantErr      bool
+	}{
+		{"valid json", "json", false},
+		{"valid yaml", "yaml", false},
+		{"valid table", "table", false},
+		{"valid wide", "wide", false},
+		{"case insensitive", "JSON", false},
+		{"invalid format", "invalid", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			opts := NewGlobalOptions()
+			opts.OutputFormat = tt.outputFormat
+
+			err := opts.validate()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

plugin/cmd/version.go

@@ -0,0 +1,142 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+
+	"github.com/NVIDIA/skyhook/plugin/pkg/client"
+	"github.com/NVIDIA/skyhook/plugin/pkg/version"
+)
+
+// NewVersionCmd creates the version command.
+func NewVersionCmd(globals *GlobalOptions) *cobra.Command {
+	var timeout time.Duration
+	var clientOnly bool
+
+	// versionCmd represents the version command
+	versionCmd := &cobra.Command{
+		Use:   "version",
+		Short: "Show plugin and Skyhook operator versions",
+		Long: `Display version information for the Skyhook plugin and the Skyhook operator running in the cluster.
+
+The plugin version is always shown. By default, the command also queries the cluster
+to discover the Skyhook operator version. Use --client-only to skip the cluster query.`,
+		Example: `  # Show both plugin and operator versions
+  skyhook version
+  kubectl skyhook version
+
+  # Show only the plugin version (no cluster query)
+  skyhook version --client-only
+
+  # Query operator in a specific namespace
+  skyhook version -n skyhook-system`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Fprintf(cmd.OutOrStdout(), "Skyhook plugin:\t%s\n", version.Summary())
+
+			if clientOnly {
+				return nil
+			}
+
+			clientFactory := client.NewFactory(globals.ConfigFlags)
+			cli, err := clientFactory.Client()
+			if err != nil {
+				return fmt.Errorf("initializing kubernetes client: %w", err)
+			}
+
+			ctx, cancel := context.WithTimeout(cmd.Context(), timeout)
+			defer cancel()
+
+			opVersion, err := discoverOperatorVersion(ctx, cli.Kubernetes(), globals.Namespace())
+			if err != nil {
+				fmt.Fprintf(cmd.OutOrStdout(), "Skyhook operator:\tunknown (%v)\n", err)
+				return nil
+			}
+
+			fmt.Fprintf(cmd.OutOrStdout(), "Skyhook operator:\t%s\n", opVersion)
+			return nil
+		},
+	}
+
+	versionCmd.Flags().DurationVar(&timeout, "timeout", 10*time.Second, "Time limit for contacting the Kubernetes API")
+	versionCmd.Flags().BoolVar(&clientOnly, "client-only", false, "Only print the plugin version without querying the cluster")
+
+	return versionCmd
+}
+
+func discoverOperatorVersion(ctx context.Context, kube kubernetes.Interface, namespace string) (string, error) {
+	if kube == nil {
+		return "", fmt.Errorf("nil kubernetes client")
+	}
+	if namespace == "" {
+		namespace = defaultNamespace
+	}
+
+	deploymentName := "skyhook-operator-controller-manager"
+	deployment, err := kube.AppsV1().Deployments(namespace).Get(ctx, deploymentName, metav1.GetOptions{})
+	if err != nil {
+		if errors.IsNotFound(err) {
+			return "", fmt.Errorf("skyhook operator deployment %q not found in namespace %q", deploymentName, namespace)
+		}
+		return "", fmt.Errorf("querying operator deployment: %w", err)
+	}
+
+	// Try to get version from Helm label (preferred for Helm deployments)
+	if v := deployment.Labels["app.kubernetes.io/version"]; strings.TrimSpace(v) != "" {
+		return strings.TrimSpace(v), nil
+	}
+
+	// Fallback: parse version from container image tag (works for kustomize deployments)
+	if len(deployment.Spec.Template.Spec.Containers) > 0 {
+		image := deployment.Spec.Template.Spec.Containers[0].Image
+		if tag := extractImageTag(image); tag != "" && tag != "latest" {
+			return tag, nil
+		}
+	}
+
+	return "", fmt.Errorf("unable to determine operator version from deployment labels or image tag")
+}
+
+// extractImageTag extracts the tag from a container image reference.
+// Examples:
+//   - "ghcr.io/nvidia/skyhook/operator:v1.2.3" -> "v1.2.3"
+//   - "ghcr.io/nvidia/skyhook/operator:v1.2.3@sha256:..." -> "v1.2.3"
+//   - "ghcr.io/nvidia/skyhook/operator" -> ""
+func extractImageTag(image string) string {
+	// Remove digest if present (e.g., @sha256:...)
+	if idx := strings.Index(image, "@"); idx > 0 {
+		image = image[:idx]
+	}
+
+	// Split on ":" to get tag
+	parts := strings.Split(image, ":")
+	if len(parts) < 2 {
+		return ""
+	}
+
+	return strings.TrimSpace(parts[len(parts)-1])
+}