Function bodies 285 total

func NewRootCmd(version string) *cobra.Command {
	var cfgFile string

	const exampleConfig = `repo_path: "/path/to/your/repo"
kubeconfig: "/path/to/your/.kube/config"
env_type: "dev"
env_region: "us-phoenix-1"
env_realm: "oc1"
category: "tenant"
log_file: "toolkit.log"
log_format: "console" # console|json|slog
log_level: "" # debug|info|warn|error (empty uses debug flag)
debug: false
filter: ""
metadata_file: "" # Optional path to a YAML or JSON file with additional metadata (e.g. tenants)
`

	home, _ := os.UserHomeDir()
	cfgDir := filepath.Join(home, ".config")
	defaultKube := filepath.Join(home, ".kube", "config")
	defaultConfig := filepath.Join(cfgDir, "toolkit", "config.yaml")
	defaultMetadata := filepath.Join(cfgDir, "toolkit", "metadata.yaml")

	rootCmd := &cobra.Command{
		Use:           "toolkit",
		Short:         "Toolkit CLI",
		Long:          "Toolkit CLI for managing and visualizing infrastructure and configuration.",
		SilenceUsage:  true,
		SilenceErrors: false,
		RunE:  

func runRootE(cfgFile *string, version string) func(cmd *cobra.Command, _ []string) error {
	return func(_ *cobra.Command, _ []string) error {
		// Parse config file with proper error handling (kept out of OnInitialize to preserve error semantics and tests).
		if err := readConfigFile(cfgFile); err != nil {
			return err
		}

		var cfg config.Config
		if err := viper.Unmarshal(&cfg); err != nil {
			return fmt.Errorf("unmarshal config: %w", err)
		}

		logFormat, logLevel, err := logOptionsFromViper()
		if err != nil {
			return err
		}

		logger, err := logging.NewFileLoggerWithLevel(cfg.Debug, cfg.LogFile, logFormat, logLevel)
		if err != nil {
			return fmt.Errorf("initialize logger: %w", err)
		}
		defer func() {
			_ = logger.Sync()
		}()

		// Validate config after log options so flag errors surface first.
		if err := cfg.Validate(); err != nil {
			return fmt.Errorf("validate config: %w", err)
		}

		ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.S

func readConfigFile(cfgFile *string) error {
	if cfgFile == nil || *cfgFile == "" {
		return nil
	}
	viper.SetConfigFile(*cfgFile)
	if err := viper.ReadInConfig(); err != nil && !errors.Is(err, os.ErrNotExist) {
		return fmt.Errorf("read config file: %w", err)
	}
	return nil
}

func logOptionsFromViper() (string, string, error) {
	logFormat := viper.GetString("log_format")
	if err := validateLogFormat(logFormat); err != nil {
		return "", "", err
	}
	logLevel, err := normalizeLogLevel(viper.GetString("log_level"))
	if err != nil {
		return "", "", err
	}
	return logFormat, logLevel, nil
}

func validateLogFormat(logFormat string) error {
	switch logFormat {
	case "console", "json", "slog":
		return nil
	default:
		return fmt.Errorf("invalid log_format %q (valid: console|json|slog)", logFormat)
	}
}

func normalizeLogLevel(level string) (string, error) {
	logLevel := strings.ToLower(level)
	switch logLevel {
	case "", "debug", "info", "warn", "warning", "error":
		if logLevel == "warning" {
			logLevel = "warn"
		}
		return logLevel, nil
	default:
		return "", fmt.Errorf("invalid log_level %q (valid: debug|info|warn|error or empty)", logLevel)
	}
}

func addPersistentFlags(rootCmd *cobra.Command, cfgFile *string, defaultKube, defaultConfig, defaultMetadata string) {
	rootCmd.PersistentFlags().StringVar(cfgFile, "config", defaultConfig, "Path to config file (YAML or JSON)")
	rootCmd.PersistentFlags().String("repo_path", "", "Path to the repository")
	rootCmd.PersistentFlags().String("env_type", "", "Environment type (e.g. dev, prod)")
	rootCmd.PersistentFlags().String("env_region", "", "Environment region")
	rootCmd.PersistentFlags().String("env_realm", "", "Environment realm")
	rootCmd.PersistentFlags().StringP("category", "c", "", "Category to display")
	_ = rootCmd.RegisterFlagCompletionFunc("category", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
		return domain.Aliases, cobra.ShellCompDirectiveNoFileComp
	})
	rootCmd.PersistentFlags().StringP("filter", "f", "", "Initial filter for current category")
	rootCmd.PersistentFlags().String("metadata_file", defaultMetadata, "Optional path to a YA

func addCompletionCommand(rootCmd *cobra.Command) {
	completionCmd := &cobra.Command{
		Use:   "completion [bash|zsh|fish|powershell]",
		Short: "Generate shell completion scripts",
		Long: `To load completions:

Bash:
  $ source <(toolkit completion bash)
  # To load completions for each session, execute once:
  # Linux:
  $ toolkit completion bash > /etc/bash_completion.d/toolkit
  # macOS:
  $ toolkit completion bash > /usr/local/etc/bash_completion.d/toolkit

Zsh:
  $ echo "autoload -U compinit; compinit" >> ~/.zshrc
  $ toolkit completion zsh > "${fpath[1]}/_toolkit"

Fish:
  $ toolkit completion fish | source
  $ toolkit completion fish > ~/.config/fish/completions/toolkit.fish

PowerShell:
  PS> toolkit completion powershell | Out-String | Invoke-Expression
  # To load completions for every new session, run:
  PS> toolkit completion powershell > $PROFILE
`,
		Args:      cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
		ValidArgs: []string{"bash", "zsh", "fish", "powersh

func addVersionCheckCommand(rootCmd *cobra.Command, currentVersion string) {
	versionCmd := &cobra.Command{
		Use:   "version",
		Short: "Print the version number and check for updates",
		RunE: func(cmd *cobra.Command, _ []string) error {
			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "toolkit version: %s\n", currentVersion)
			check, _ := cmd.Flags().GetBool("check")
			if check {
				ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
				defer cancel()
				latest, err := fetchLatestRelease(ctx)
				if err != nil {
					return fmt.Errorf("failed to check latest version: %w", err)
				}
				if latest == currentVersion {
					_, _ = fmt.Fprintln(cmd.OutOrStdout(), "You are running the latest version.")
				} else {
					_, _ = fmt.Fprintf(cmd.OutOrStdout(), "A newer version is available: %s\n", latest)
				}
			}
			return nil
		},
	}
	versionCmd.Flags().Bool("check", false, "Check for the latest release on GitHub")
	rootCmd.AddCommand(versionCmd)
}

func addInitCommand(rootCmd *cobra.Command, defaultConfig, exampleConfig string) {
	initCmd := &cobra.Command{
		Use:   "init",
		Short: "Scaffold an example config file",
		RunE: func(_ *cobra.Command, _ []string) error {
			if _, err := os.Stat(defaultConfig); err == nil {
				return fmt.Errorf("config file already exists at %s", defaultConfig)
			}
			if err := os.MkdirAll(filepath.Dir(defaultConfig), 0o750); err != nil {
				return fmt.Errorf("failed to create config directory: %w", err)
			}
			if err := os.WriteFile(defaultConfig, []byte(exampleConfig), 0o600); err != nil {
				return fmt.Errorf("failed to write config file: %w", err)
			}
			fmt.Printf("Example config written to %s\n", defaultConfig)
			return nil
		},
	}
	rootCmd.AddCommand(initCmd)
}

func Execute(version string) {
	cmd := NewRootCmd(version)
	if err := cmd.Execute(); err != nil {
		// Let Cobra print the error once; just exit with non-zero status.
		os.Exit(1)
	}
}

func runToolkit(ctx context.Context, logger logging.Logger, cfg config.Config, version string) error {
	category, _ := domain.ParseCategory(cfg.Category)
	env := models.Environment{
		Type:   cfg.EnvType,
		Region: cfg.EnvRegion,
		Realm:  cfg.EnvRealm,
	}
	repoPath := cfg.RepoPath
	kubeConfig := cfg.KubeConfig

	ctx = logging.WithContext(ctx, logger)
	logger.Infow("starting toolkit",
		"repo", repoPath,
		"env", env,
		"category", category,
	)

	model, err := tui.NewModel(
		tui.WithRepoPath(repoPath),
		tui.WithKubeConfig(kubeConfig),
		tui.WithEnvironment(env),
		tui.WithCategory(category),
		tui.WithLogger(logger),
		tui.WithContext(ctx),
		tui.WithLoader(production.NewLoader(ctx, cfg.MetadataFile)),
		tui.WithFilter(cfg.Filter),
		tui.WithVersion(version),
	)
	if err != nil {
		logger.Errorw("failed to create toolkit model", "error", err)
		return fmt.Errorf("create toolkit model: %w", err)
	}
	p := tea.NewProgram(model, tea.WithAltScreen(), tea.WithContext(ctx))
	_, err = p.Run()

func IsMatch(item models.Filterable, filter string, ignoreCase bool) bool {
	if filter == "" {
		return true
	}

	if ignoreCase {
		filter = strings.ToLower(filter)
	}

	for _, value := range item.GetFilterableFields() {
		if value == "" {
			continue
		}

		if ignoreCase {
			value = strings.ToLower(value)
		}

		if strings.Contains(value, filter) {
			return true
		}
	}

	return false
}

func (c Config) Validate() error {
	if c.RepoPath == "" {
		return errors.New("config: RepoPath is required")
	}
	if c.KubeConfig == "" {
		return errors.New("config: KubeConfig is required")
	}
	if c.EnvType == "" {
		return errors.New("config: EnvType is required")
	}
	if c.EnvRegion == "" {
		return errors.New("config: EnvRegion is required")
	}
	if c.EnvRealm == "" {
		return errors.New("config: EnvRealm is required")
	}
	if c.Category == "" {
		return errors.New("config: Category is required")
	}
	_, err := domain.ParseCategory(c.Category)
	if err != nil {
		return fmt.Errorf("config: invalid category: %w", err)
	}
	return nil
}

func listSubDirs(dirPath string) ([]string, error) {
	var subDirs []string

	entries, err := os.ReadDir(dirPath)
	if err != nil {
		return nil, err
	}

	for _, entry := range entries {
		if entry.IsDir() {
			subDirs = append(subDirs, entry.Name())
		}
	}

	return subDirs, nil
}

func getTenants(tenantMap map[string]idMap, tenantMeta []models.TenantMetadata) []models.Tenant {
	// Build id -> TenantMetadata map for quick lookup
	idToMeta := make(map[string]models.TenantMetadata, len(tenantMeta))
	consumed := make(map[string]bool, len(tenantMeta))
	for _, m := range tenantMeta {
		idToMeta[m.ID] = m
	}

	tenants := make([]models.Tenant, 0, len(tenantMap)+len(tenantMeta))

	// First: process tenantMap, merging with metadata if any id matches
	for k, v := range tenantMap {
		ids := make([]string, 0, len(v))
		for id := range v {
			ids = append(ids, id)
		}

		tenantName := k
		isInternal := true
		note := ""
		for _, id := range ids {
			if m, ok := idToMeta[id]; ok {
				tenantName = merge(tenantName, m.Name)
				isInternal = merge(isInternal, m.IsInternal)
				note = merge(note, m.Note)
				consumed[id] = true
				break
			}
		}

		tenant := models.Tenant{
			IDs:        ids,
			Name:       tenantName,
			IsInternal: isInternal,
			Note:       note,
		}
		tenant

func getEnvironments(tenancies []models.ServiceTenancy) []models.Environment {
	var environments []models.Environment
	for _, t := range tenancies {
		environments = append(environments, t.Environments()...)
	}

	return environments
}

func isValidEnvironment(env models.Environment, allEnvs []models.Environment) bool {
	for _, e := range allEnvs {
		if e.Equals(env) {
			return true
		}
	}

	return false
}

func LoadDataset(ctx context.Context, repoPath string, env models.Environment, metadata *models.Metadata) (*models.Dataset, error) {
	serviceTenancies, err := terraform.LoadServiceTenancies(ctx, repoPath)
	if err != nil {
		return nil, err
	}

	environments := getEnvironments(serviceTenancies)
	if err := validateEnvironment(env, environments); err != nil {
		return nil, err
	}

	realm := env.Realm

	limitGroup, consolePropertyDefinitionGroup, propertyDefinitionGroup, err := loadDefinitionGroups(repoPath)
	if err != nil {
		return nil, err
	}

	tenancyOverrideGroup, err := LoadTenancyOverrideGroup(ctx, repoPath, realm, metadata)
	if err != nil {
		return nil, err
	}

	limitRegionalOverrides, err := LoadLimitRegionalOverrides(ctx, repoPath, realm)
	if err != nil {
		return nil, err
	}
	consolePropertyRegionalOverrides, err := LoadConsolePropertyRegionalOverrides(ctx, repoPath, realm)
	if err != nil {
		return nil, err
	}
	propertyRegionalOverrides, err := LoadPropertyRegionalOverrides(ct

func validateEnvironment(env models.Environment, allEnvs []models.Environment) error {
	if !isValidEnvironment(env, allEnvs) {
		return errors.New("environment is not valid or in the list")
	}
	return nil
}

func loadDefinitionGroups(repoPath string) (
	*models.LimitDefinitionGroup,
	*models.ConsolePropertyDefinitionGroup,
	*models.PropertyDefinitionGroup,
	error,
) {
	limitsRoot := getLimitsRoot(repoPath)
	limitDefinitionPath := getConfigPath(limitsRoot, limitsKey+definitionSuffix)
	limitGroup, err := jsonutil.LoadFile[models.LimitDefinitionGroup](limitDefinitionPath)
	if err != nil {
		return nil, nil, nil, err
	}

	consolePropertyDefinitionPath := getConfigPath(limitsRoot, consolePropertiesKey+definitionSuffix)
	consolePropertyDefinitionGroup, err := jsonutil.LoadFile[models.ConsolePropertyDefinitionGroup](consolePropertyDefinitionPath)
	if err != nil {
		return nil, nil, nil, err
	}

	propertyDefinitionPath := getConfigPath(limitsRoot, propertiesKey+definitionSuffix)
	propertyDefinitionGroup, err := jsonutil.LoadFile[models.PropertyDefinitionGroup](propertyDefinitionPath)
	if err != nil {
		return nil, nil, nil, err
	}

	return limitGroup, consolePropertyDefinitionGroup, propertyDefini

func LoadTenancyOverrideGroup(ctx context.Context, repoPath, realm string, metadata *models.Metadata) (models.TenancyOverrideGroup, error) {
	tenantMap := make(map[string]idMap)
	limitsRoot := getLimitsRoot(repoPath)

	limitTenancyOverrideMap, err := loadTenancyOverrides[models.LimitTenancyOverride](
		ctx, limitsRoot, realm, limitsKey+tenancyOverridesKey)
	if err != nil {
		return models.TenancyOverrideGroup{}, err
	}
	updateTenants(tenantMap, limitTenancyOverrideMap)

	consolePropertyTenancyOverrideMap, err := loadTenancyOverrides[models.ConsolePropertyTenancyOverride](
		ctx, limitsRoot, realm, consolePropertiesKey+tenancyOverridesKey)
	if err != nil {
		return models.TenancyOverrideGroup{}, err
	}
	updateTenants(tenantMap, consolePropertyTenancyOverrideMap)

	propertyTenancyOverrideMap, err := loadTenancyOverrides[models.PropertyTenancyOverride](
		ctx, limitsRoot, realm, propertiesKey+tenancyOverridesKey)
	if err != nil {
		return models.TenancyOverrideGroup{}, err
	}
	updateTenan

func LoadMetadata(path string) (*models.Metadata, error) {
	ext := strings.ToLower(filepath.Ext(path))
	switch ext {
	case ".json":
		return jsonutil.LoadFile[models.Metadata](path)
	case ".yaml", ".yml":
		return loadYAML(path, ext)
	default:
		return nil, fmt.Errorf("unsupported metadata file extension: %s", ext)
	}
}

func loadYAML(path, ext string) (*models.Metadata, error) {
	allowedExt := map[string]struct{}{ext: {}}
	baseDir := filepath.Dir(path)
	data, err := fs.SafeReadFile(path, baseDir, allowedExt)
	if err != nil {
		return nil, fmt.Errorf("failed to read YAML file: %w", err)
	}

	var out models.Metadata
	err = yaml.Unmarshal(data, &out)
	return &out, err
}

func (e Category) IsScopeOf(o Category) bool {
	if !e.IsScope() {
		return false
	}

	categories := e.ScopedCategories()
	return slices.Contains(categories, o)
}

func (e Category) IsScope() bool {
	switch e { //nolint:exhaustive
	case Tenant, LimitDefinition, ConsolePropertyDefinition, PropertyDefinition, GpuPool:
		return true
	}
	return false
}

func (e Category) ScopedCategories() []Category {
	switch e { //nolint:exhaustive
	case Tenant:
		return []Category{
			LimitTenancyOverride,
			ConsolePropertyTenancyOverride,
			PropertyTenancyOverride,
			DedicatedAICluster,
		}
	case LimitDefinition:
		return []Category{LimitTenancyOverride, LimitRegionalOverride}
	case ConsolePropertyDefinition:
		return []Category{
			ConsolePropertyTenancyOverride,
			ConsolePropertyRegionalOverride,
		}
	case PropertyDefinition:
		return []Category{
			PropertyTenancyOverride,
			PropertyRegionalOverride,
		}
	case GpuPool:
		return []Category{GpuNode}
	default:
		return nil
	}
}

func (e Category) GetAliases() []string {
	cat := e.String()
	short := GetInitials(cat)
	aliases := []string{strings.ToLower(short), strings.ToLower(cat)}

	if e == DedicatedAICluster {
		aliases = append(aliases, "dac")
	}
	return aliases
}

func init() {
	aliasToCat = make(map[string]Category)

	for c := Tenant; c <= Alias; c++ {
		for _, a := range c.GetAliases() {
			aliasToCat[a] = c
		}
		Categories = append(Categories, c)
	}

	Aliases = make([]string, 0, len(aliasToCat))
	for k := range aliasToCat {
		Aliases = append(Aliases, k)
	}
}

func (e Category) Definition() Category {
	switch e { //nolint:exhaustive
	case LimitTenancyOverride, LimitRegionalOverride:
		return LimitDefinition
	case ConsolePropertyTenancyOverride, ConsolePropertyRegionalOverride:
		return ConsolePropertyDefinition
	case PropertyTenancyOverride, PropertyRegionalOverride:
		return PropertyDefinition
	case GpuNode:
		return GpuPool
	default:
		return Category(-1)
	}
}

func ParseCategory(s string) (Category, error) {
	key := strings.ToLower(strings.TrimSpace(s))
	if c, ok := aliasToCat[key]; ok {
		return c, nil
	}
	return CategoryUnknown, fmt.Errorf("parse category %q: %w", s, ErrUnknownCategory)
}

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[CategoryUnknown-0]
	_ = x[Tenant-1]
	_ = x[LimitDefinition-2]
	_ = x[ConsolePropertyDefinition-3]
	_ = x[PropertyDefinition-4]
	_ = x[LimitTenancyOverride-5]
	_ = x[ConsolePropertyTenancyOverride-6]
	_ = x[PropertyTenancyOverride-7]
	_ = x[LimitRegionalOverride-8]
	_ = x[ConsolePropertyRegionalOverride-9]
	_ = x[PropertyRegionalOverride-10]
	_ = x[BaseModel-11]
	_ = x[ModelArtifact-12]
	_ = x[Environment-13]
	_ = x[ServiceTenancy-14]
	_ = x[GpuPool-15]
	_ = x[GpuNode-16]
	_ = x[DedicatedAICluster-17]
	_ = x[Alias-18]
}

func (i Category) String() string {
	if i < 0 || i >= Category(len(_Category_index)-1) {
		return "Category(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _Category_name[_Category_index[i]:_Category_index[i+1]]
}

func ListFiles(ctx context.Context, dirPath, ext string) ([]string, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	var out []string

	entries, err := os.ReadDir(dirPath)
	if err != nil {
		return nil, fmt.Errorf("failed to read directory: %w", err)
	}
	for _, e := range entries {
		if !e.IsDir() && filepath.Ext(e.Name()) == ext {
			out = append(out, filepath.Join(dirPath, e.Name()))
		}
	}
	return out, nil
}

func SafeReadFile(path string, baseDir string, allowExt map[string]struct{}) ([]byte, error) {
	clean := filepath.Clean(path)

	absTarget, err := filepath.Abs(clean)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	absBase, err := filepath.Abs(filepath.Clean(baseDir))
	if err != nil {
		return nil, fmt.Errorf("failed to read file: %w", err)
	}

	// Ensure absTarget is within absBase
	if !strings.HasPrefix(absTarget, absBase+string(os.PathSeparator)) && absTarget != absBase {
		return nil, fmt.Errorf("access outside trusted dir %s", absBase)
	}

	ext := strings.ToLower(filepath.Ext(absTarget))
	if _, ok := allowExt[ext]; !ok {
		return nil, fmt.Errorf("extension %s not permitted", ext)
	}

	return os.ReadFile(absTarget) // #nosec G304 -- absTarget validated above
}

func LoadBaseModels(ctx context.Context, client dynamic.Interface) ([]models.BaseModel, error) {
	gvr := schema.GroupVersionResource{
		Group:    "ome.io",
		Version:  "v1beta1",
		Resource: "clusterbasemodels",
	}
	list, err := client.Resource(gvr).List(ctx, v1.ListOptions{})
	if err != nil {
		return nil, fmt.Errorf("list ClusterBaseModel: %w", err)
	}
	result := make([]models.BaseModel, 0, len(list.Items))
	for _, item := range list.Items {
		bm := parseBaseModel(&item)
		result = append(result, bm)
	}
	return result, nil
}

func parseBaseModel(obj *unstructured.Unstructured) models.BaseModel {
	spec, _, _ := unstructured.NestedMap(obj.Object, "spec")
	status, _, _ := unstructured.NestedMap(obj.Object, "status")
	capabilities, _, _ := unstructured.NestedStringSlice(spec, "modelCapabilities")
	metadata, _, _ := unstructured.NestedStringMap(spec, "additionalMetadata")

	var dacShapeConfigs *models.DacShapeConfigs
	if dac, ok := metadata["dacShapeConfigs"]; ok && dac != "" {
		dacShapeConfigs = unmarshalYaml[models.DacShapeConfigs](dac)
	}

	labels := getLabels(obj)
	annotations := getAnnotations(obj)

	var runtime string
	var runtimeType string
	if value, ok := annotations["models.ome.io/runtime"]; ok {
		runtime = value
		runtimeType = "Serving"
	} else if value, ok := annotations["models.ome.io/training-runtime"]; ok {
		runtime = value
		runtimeType = "Fine-tuning"
	}

	name := obj.GetName()
	var internalName string
	if value, ok := metadata["internalName"]; ok {
		internalName = value
	} else {
		interna

func NewConfig(kubeconfig, ctx string) (*rest.Config, error) {
	loadingRules := &clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig}
	overrides := &clientcmd.ConfigOverrides{CurrentContext: ctx}
	config, err := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
		loadingRules, overrides).ClientConfig()
	if err != nil {
		return nil, fmt.Errorf("failed to load kubeconfig: %w", err)
	}
	// Apply sensible defaults for client throttling; allow override if already set.
	if config.QPS == 0 {
		config.QPS = 20
	}
	if config.Burst == 0 {
		config.Burst = 40
	}
	// Identify this client in user agent.
	rest.AddUserAgent(config, "toolkit")
	return config, nil
}

func NewClientsetFromRestConfig(config *rest.Config) (kubernetes.Interface, error) {
	if config == nil {
		return nil, errors.New("config is nil")
	}
	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		return nil, fmt.Errorf("failed to create k8s client: %w", err)
	}
	return clientset, nil
}

func NewClientsetFromKubeConfig(kubeconfig, ctx string) (kubernetes.Interface, error) {
	config, err := NewConfig(kubeconfig, ctx)
	if err != nil {
		return nil, fmt.Errorf("failed to create config from kubeconfig: %w", err)
	}
	return NewClientsetFromRestConfig(config)
}

func NewDynamicClient(config *rest.Config) (dynamic.Interface, error) {
	if config == nil {
		return nil, errors.New("config is nil")
	}
	dynamicClient, err := dynamic.NewForConfig(config)
	if err != nil {
		return nil, fmt.Errorf("failed to create dynamic client: %w", err)
	}
	return dynamicClient, nil
}

func NewDynamicClientFromKubeConfig(kubeconfig, ctx string) (dynamic.Interface, error) {
	config, err := NewConfig(kubeconfig, ctx)
	if err != nil {
		return nil, fmt.Errorf("failed to create config from kubeconfig: %w", err)
	}
	return NewDynamicClient(config)
}

func ToggleCordon(ctx context.Context, kubeconfig, contextName, nodeName string) (bool, error) {
	clientset, err := NewClientsetFromKubeConfig(kubeconfig, contextName)
	if err != nil {
		return false, err
	}
	return toggleCordon(ctx, clientset, nodeName)
}

func DrainNode(ctx context.Context, kubeconfig, contextName, nodeName string) error {
	clientset, err := NewClientsetFromKubeConfig(kubeconfig, contextName)
	if err != nil {
		return err
	}
	return drainNode(ctx, clientset, nodeName)
}

func toggleCordon(ctx context.Context, clientset kubernetes.Interface, nodeName string) (bool, error) {
	helper := &drain.Helper{
		Ctx:    ctx,
		Client: clientset,
	}

	// Get the current node
	node, err := clientset.CoreV1().Nodes().Get(ctx, nodeName, v1.GetOptions{})
	if err != nil {
		return false, err
	}

	// Determine new cordon state (toggle current value)
	cordonState := !node.Spec.Unschedulable

	// Apply the new state
	return cordonState, runCordonOrUncordon(helper, node, cordonState)
}

func drainNode(ctx context.Context, clientset kubernetes.Interface, nodeName string) error {
	logger := logging.FromContext(ctx)
	helper := &drain.Helper{
		Ctx:                 ctx,
		Client:              clientset,
		Out:                 logWriter{logger},
		ErrOut:              logWriter{logger},
		IgnoreAllDaemonSets: true,
		DeleteEmptyDirData:  true,
		GracePeriodSeconds:  -1, // Use pod's termination grace period
	}
	return runNodeDrain(helper, nodeName)
}

func listDedicatedAIClusters(ctx context.Context, client dynamic.Interface) ([]models.DedicatedAICluster, error) {
	cache, err := buildPodCache(ctx, client)
	if err != nil {
		return nil, err
	}
	v1Clusters, err := listDedicatedAIClustersV1(ctx, client, cache)
	if err != nil {
		return nil, err
	}
	v2Clusters, err := listDedicatedAIClustersV2(ctx, client, cache)
	if err != nil {
		return nil, err
	}
	return append(v1Clusters, v2Clusters...), nil
}

func listDedicatedAIClustersGeneric(
	ctx context.Context,
	client dynamic.Interface,
	gvr schema.GroupVersionResource,
	extract func(item unstructured.Unstructured) models.DedicatedAICluster,
) ([]models.DedicatedAICluster, error) {
	list, err := client.Resource(gvr).List(ctx, v1.ListOptions{})
	if err != nil {
		return nil, err
	}
	dacs := make([]models.DedicatedAICluster, 0, len(list.Items))
	for _, item := range list.Items {
		dacs = append(dacs, extract(item))
	}
	return dacs, nil
}

func listDedicatedAIClustersV1(ctx context.Context, client dynamic.Interface, cache PodCache) ([]models.DedicatedAICluster, error) {
	gvr := schema.GroupVersionResource{
		Group:    "ome.oracle.com",
		Version:  "v1alpha1",
		Resource: "dedicatedaiclusters",
	}
	return listDedicatedAIClustersGeneric(ctx, client, gvr, func(item unstructured.Unstructured) models.DedicatedAICluster {
		name, _, _ := unstructured.NestedString(item.Object, "metadata", "name")
		spec, _, _ := unstructured.NestedMap(item.Object, "spec")
		status, _, _ := unstructured.NestedMap(item.Object, "status")
		labels, hasLabels, _ := unstructured.NestedMap(item.Object, "metadata", "labels")
		creationTimestampStr, _, _ := unstructured.NestedString(item.Object, "metadata", "creationTimestamp")
		var age string
		if t, err := time.Parse(time.RFC3339, creationTimestampStr); err == nil {
			age = FormatAge(time.Since(t))
		}

		dacType, _ := spec["type"].(string)
		unitShape, _ := spec["unitShape"].(string)
		size, _ := s

func listDedicatedAIClustersV2(ctx context.Context, client dynamic.Interface, cache PodCache) ([]models.DedicatedAICluster, error) {
	gvr := schema.GroupVersionResource{
		Group:    "ome.io",
		Version:  "v1beta1",
		Resource: "dedicatedaiclusters",
	}
	return listDedicatedAIClustersGeneric(ctx, client, gvr, func(item unstructured.Unstructured) models.DedicatedAICluster {
		name, _, _ := unstructured.NestedString(item.Object, "metadata", "name")
		spec, _, _ := unstructured.NestedMap(item.Object, "spec")
		status, _, _ := unstructured.NestedMap(item.Object, "status")
		labels, hasLabels, _ := unstructured.NestedMap(item.Object, "metadata", "labels")
		creationTimestampStr, _, _ := unstructured.NestedString(item.Object, "metadata", "creationTimestamp")
		var age string
		if t, err := time.Parse(time.RFC3339, creationTimestampStr); err == nil {
			age = FormatAge(time.Since(t))
		}

		profile, _ := spec["profile"].(string)
		count, _ := spec["count"].(int64)

		tenantID := "missing"
		if