Add interactive mode for index creation

Author: azzazzel

internal/pkg/cli/command/index/create.go

@@ -1,8 +1,10 @@
 package index
 
 import (
+	"context"
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/MakeNowJust/heredoc"
 	"github.com/pinecone-io/cli/internal/pkg/utils/docslinks"
@@ -12,6 +14,7 @@ import (
 	indexpresenters "github.com/pinecone-io/cli/internal/pkg/utils/index/presenters"
 	"github.com/pinecone-io/cli/internal/pkg/utils/interactive"
 	"github.com/pinecone-io/cli/internal/pkg/utils/log"
+	"github.com/pinecone-io/cli/internal/pkg/utils/models"
 	"github.com/pinecone-io/cli/internal/pkg/utils/msg"
 	"github.com/pinecone-io/cli/internal/pkg/utils/pcio"
 	"github.com/pinecone-io/cli/internal/pkg/utils/sdk"
@@ -24,6 +27,7 @@ import (
 type createIndexOptions struct {
 	CreateOptions index.CreateOptions
 	json          bool
+	interactive   bool
 }
 
 func NewCreateIndexCmd() *cobra.Command {
@@ -43,10 +47,14 @@ func NewCreateIndexCmd() *cobra.Command {
 
 		The CLI will try to automatically infer missing settings from those provided.
 
+		Use the %s flag to enable interactive mode, which will guide you through configuring
+		the index settings step by step.
+
 		For detailed documentation, see:
 		%s
 		`, style.Code("pc index create"),
 			style.Emphasis("--model"),
+			style.Code("--interactive"),
 			style.URL(docslinks.DocsIndexCreate)),
 		Example: heredoc.Doc(`
 		# create default index (serverless)
@@ -67,6 +75,9 @@ func NewCreateIndexCmd() *cobra.Command {
 		# create a serverless index with the default sparse model
 		$ pc index create my-index --model sparse --cloud aws --region us-east-1
 
+		# create an index using interactive mode
+		$ pc index create my-index --interactive
+
 		`),
 		Args:         index.ValidateIndexNameArgs,
 		SilenceUsage: true,
@@ -110,13 +121,265 @@ func NewCreateIndexCmd() *cobra.Command {
 	cmd.Flags().StringToStringVar(&options.CreateOptions.Tags.Value, "tags", map[string]string{}, "Custom user tags to add to an index")
 
 	cmd.Flags().BoolVar(&options.json, "json", false, "Output as JSON")
+	cmd.Flags().BoolVarP(&options.interactive, "interactive", "i", false, "Enable interactive mode to configure index settings step by step")
 
 	return cmd
 }
 
+func collectInteractiveConfiguration(ctx context.Context, options index.CreateOptions) (index.CreateOptions, bool) {
+	pcio.Println(style.InfoMsg("Interactive mode: Let's configure your index step by step.\n"))
+	pcio.Println(style.Hint("Press Esc or Ctrl+C at any time to exit interactive mode.\n"))
+
+	// Variables for model data (will be populated when needed)
+	var availableModels []models.ModelInfo
+	var modelsErr error
+
+	// Index type selection - determine default based on existing flags
+	var defaultChoice string
+	if options.Serverless.Value {
+		defaultChoice = "Serverless"
+	} else if options.Pod.Value {
+		defaultChoice = "Pod"
+	} else {
+		defaultChoice = "Serverless"
+	}
+
+	choice, exit := interactive.GetChoice(
+		"Select index type",
+		[]string{
+			"Serverless",
+			"Pod",
+		},
+		defaultChoice)
+
+	if exit {
+		return options, true
+	}
+
+	switch choice {
+	case "Serverless":
+		options.Serverless.Value = true
+		options.Pod.Value = false
+	case "Pod":
+		options.Serverless.Value = false
+		options.Pod.Value = true
+	}
+
+	// Serverless configuration
+	if options.Serverless.Value {
+		// Fetch available models for serverless
+		availableModels, modelsErr = models.GetModels(ctx, true)
+		if modelsErr != nil {
+			pcio.Println(style.WarnMsg("Warning: Could not fetch available models!"))
+		}
+
+		// Model selection
+		if modelsErr != nil {
+			options.Model.Value = "llama-text-embed-v2"
+		} else {
+			// Create model choices
+			modelChoices := make([]string, 0, len(availableModels)+1)
+			modelChoices = append(modelChoices, "None (custom vectors)")
+
+			for _, model := range availableModels {
+				modelChoices = append(modelChoices, model.Model)
+			}
+
+			// Determine default model choice
+			var defaultModelChoice string
+			if options.Model.Value != "" {
+				defaultModelChoice = options.Model.Value
+			} else {
+				defaultModelChoice = "llama-text-embed-v2" // Default dense model
+			}
+
+			modelChoice, exit := interactive.GetChoice("Select inference model", modelChoices, defaultModelChoice)
+			if exit {
+				return options, true
+			}
+
+			if modelChoice == "None (custom vectors)" {
+				options.Model.Value = ""
+			} else {
+				options.Model.Value = modelChoice
+			}
+		}
+
+		// Cloud and region
+		cloud, exit := interactive.GetInput("Cloud provider (aws, gcp, azure)", options.Cloud.Value)
+		if exit {
+			return options, true
+		}
+		options.Cloud.Value = cloud
+
+		region, exit := interactive.GetInput("Region (e.g., us-east-1)", options.Region.Value)
+		if exit {
+			return options, true
+		}
+		options.Region.Value = region
+
+		// Vector type (only for serverless without model)
+		if options.Model.Value == "" {
+			vectorType, exit := interactive.GetChoice("Vector type", []string{"dense", "sparse"}, options.VectorType.Value)
+			if exit {
+				return options, true
+			}
+			options.VectorType.Value = vectorType
+		}
+	}
+
+	// Environment (for pod)
+	if options.Pod.Value {
+		environment, exit := interactive.GetInput("Environment", options.Environment.Value)
+		if exit {
+			return options, true
+		}
+		options.Environment.Value = environment
+
+		podType, exit := interactive.GetInput("Pod type", options.PodType.Value)
+		if exit {
+			return options, true
+		}
+		options.PodType.Value = podType
+
+		shards, exit := interactive.GetIntInput("Number of shards", int(options.Shards.Value))
+		if exit {
+			return options, true
+		}
+		options.Shards.Value = int32(shards)
+
+		replicas, exit := interactive.GetIntInput("Number of replicas", int(options.Replicas.Value))
+		if exit {
+			return options, true
+		}
+		options.Replicas.Value = int32(replicas)
+	}
+
+	// Common settings
+
+	// Handle dimension based on vector type
+	// Sparse models always use dimension 0, dense models may support multiple dimensions
+	isSparse := false
+	if options.Model.Value != "" {
+		// Check if the selected model is sparse
+		if modelsErr == nil {
+			for _, model := range availableModels {
+				if model.Model == options.Model.Value && model.VectorType != nil && *model.VectorType == "sparse" {
+					isSparse = true
+					break
+				}
+			}
+		}
+	} else {
+		// For custom vectors, check the vector type
+		isSparse = options.VectorType.Value == "sparse"
+	}
+
+	if isSparse {
+		// Sparse vectors always use dimension 0
+		options.Dimension.Value = 0
+	} else {
+		// Ask for dimension for dense models and custom vectors
+		dimension, exit := interactive.GetIntInput("Dimension (0 for auto)", int(options.Dimension.Value))
+		if exit {
+			return options, true
+		}
+		options.Dimension.Value = int32(dimension)
+	}
+
+	// Only ask for metric if not sparse (sparse always uses dotproduct)
+	// isSparse is already determined above
+
+	if !isSparse {
+		metric, exit := interactive.GetChoice("Metric", []string{"cosine", "euclidean", "dotproduct"}, options.Metric.Value)
+		if exit {
+			return options, true
+		}
+		options.Metric.Value = metric
+	} else {
+		// Sparse vectors always use dotproduct
+		options.Metric.Value = "dotproduct"
+	}
+
+	// Set default deletion protection to disabled if not already set
+	defaultDeletionProtection := options.DeletionProtection.Value
+	if defaultDeletionProtection == "" {
+		defaultDeletionProtection = "disabled"
+	}
+
+	deletionProtection, exit := interactive.GetChoice("Deletion protection", []string{"enabled", "disabled"}, defaultDeletionProtection)
+	if exit {
+		return options, true
+	}
+	options.DeletionProtection.Value = deletionProtection
+
+	// Tags
+	useTags := interactive.GetConfirmation("Add custom tags?")
+
+	if useTags {
+		// Initialize tags map if it doesn't exist
+		if options.Tags.Value == nil {
+			options.Tags.Value = make(map[string]string)
+		}
+
+		pcio.Println("Enter tags in key=value format. Press Enter with empty input to finish.")
+
+		for {
+			// Show current tags
+			if len(options.Tags.Value) > 0 {
+				for k, v := range options.Tags.Value {
+					pcio.Printf("  %s=%s\n", style.Emphasis(k), style.ResourceName(v))
+				}
+				pcio.Println()
+			}
+
+			tagInput, exit := interactive.GetInput("Tag (key=value)", "")
+			if exit {
+				return options, true
+			}
+
+			// Empty input means done adding tags
+			if strings.TrimSpace(tagInput) == "" {
+				break
+			}
+
+			// Parse key=value format
+			parts := strings.SplitN(tagInput, "=", 2)
+			if len(parts) != 2 {
+				pcio.Println(style.FailMsg("Invalid format. Please use key=value format."))
+				continue
+			}
+
+			key := strings.TrimSpace(parts[0])
+			value := strings.TrimSpace(parts[1])
+
+			if key == "" || value == "" {
+				pcio.Println(style.FailMsg("Both key and value must be non-empty."))
+				continue
+			}
+
+			// Add the tag
+			options.Tags.Value[key] = value
+		}
+	}
+
+	pcio.Println(style.SuccessMsg("\nConfiguration complete!"))
+	return options, false
+}
+
 func runCreateIndexCmd(options createIndexOptions, cmd *cobra.Command, args []string) {
 	ctx := cmd.Context()
 
+	// If interactive mode is enabled, collect configuration interactively
+	if options.interactive {
+		var exit bool
+		options.CreateOptions, exit = collectInteractiveConfiguration(ctx, options.CreateOptions)
+		if exit {
+			pcio.Println(style.InfoMsg("Interactive mode cancelled."))
+			return
+		}
+	}
+
 	// validationErrors := index.ValidateCreateOptions(options.CreateOptions)
 	// if len(validationErrors) > 0 {
 	// 	msg.FailMsgMultiLine(validationErrors...)