Add TS and Python templates

cmd/create.go

@@ -90,7 +90,7 @@ func runCreateApp(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to get language: %w", err)
 	}
 
-	template, err = create.PromptForTemplate(template)
+	template, err = create.PromptForTemplate(template, language)
 	if err != nil {
 		return fmt.Errorf("failed to get template: %w", err)
 	}

pkg/create/prompts.go

@@ -92,21 +92,33 @@ func PromptForLanguage(providedLanguage string) (string, error) {
 		return l, nil
 	}
 
+	pterm.Warning.Printfln("Language '%s' not found. Please select from available languages.\n", providedLanguage)
 	return handleLanguagePrompt()
 }
 
-// TODO: add validation for template
-func PromptForTemplate(providedTemplate string) (string, error) {
-	if providedTemplate != "" {
-		return providedTemplate, nil
-	}
-
+func handleTemplatePrompt(templateKVs TemplateKeyValues) (string, error) {
 	template, err := pterm.DefaultInteractiveSelect.
-		WithOptions(GetSupportedTemplates()).
+		WithOptions(templateKVs.GetTemplateDisplayValues()).
 		WithDefaultText(TemplatePrompt).
 		Show()
 	if err != nil {
 		return "", err
 	}
-	return template, nil
+
+	return templateKVs.GetTemplateKeyFromValue(template)
+}
+
+func PromptForTemplate(providedTemplate string, providedLanguage string) (string, error) {
+	templateKVs := GetSupportedTemplatesForLanguage(NormalizeLanguage(providedLanguage))
+
+	if providedTemplate == "" {
+		return handleTemplatePrompt(templateKVs)
+	}
+
+	if templateKVs.ContainsKey(providedTemplate) {
+		return providedTemplate, nil
+	}
+
+	pterm.Warning.Printfln("Template '%s' not found. Please select from available templates.\n", providedTemplate)
+	return handleTemplatePrompt(templateKVs)
 }

pkg/create/templates.go

@@ -0,0 +1,111 @@
+package create
+
+import (
+	"fmt"
+	"slices"
+	"sort"
+)
+
+type TemplateInfo struct {
+	Name        string
+	Description string
+	Languages   []string
+}
+
+type TemplateKeyValue struct {
+	Key   string
+	Value string
+}
+
+type TemplateKeyValues []TemplateKeyValue
+
+var Templates = map[string]TemplateInfo{
+	"sample-app": {
+		Name:        "Sample App",
+		Description: "Implements basic Kernel apps",
+		Languages:   []string{LanguageTypeScript, LanguagePython},
+	},
+	"advanced-sample": {
+		Name:        "Advanced Sample",
+		Description: "Implements sample actions with advanced Kernel configs",
+		Languages:   []string{LanguageTypeScript, LanguagePython},
+	},
+	"computer-use": {
+		Name:        "Computer Use",
+		Description: "Implements the Anthropic Computer Use SDK",
+		Languages:   []string{LanguageTypeScript, LanguagePython},
+	},
+	"cua": {
+		Name:        "CUA Sample",
+		Description: "Implements a Computer Use Agent (OpenAI CUA) sample",
+		Languages:   []string{LanguageTypeScript, LanguagePython},
+	},
+	"magnitude": {
+		Name:        "Magnitude",
+		Description: "Implements the Magnitude.run SDK",
+		Languages:   []string{LanguageTypeScript},
+	},
+	"gemini-cua": {
+		Name:        "Gemini CUA",
+		Description: "Implements Gemini 2.5 Computer Use Agent",
+		Languages:   []string{LanguageTypeScript},
+	},
+	"browser-use": {
+		Name:        "Browser Use",
+		Description: "Implements Browser Use SDK",
+		Languages:   []string{LanguagePython},
+	},
+	"stagehand": {
+		Name:        "Stagehand",
+		Description: "Implements the Stagehand v3 SDK",
+		Languages:   []string{LanguageTypeScript},
+	},
+}
+
+// GetSupportedTemplatesForLanguage returns a list of all supported template names for a given language
+func GetSupportedTemplatesForLanguage(language string) TemplateKeyValues {
+	templates := make(TemplateKeyValues, 0, len(Templates))
+	for tn := range Templates {
+		if slices.Contains(Templates[tn].Languages, language) {
+			templates = append(templates, TemplateKeyValue{
+				Key:   tn,
+				Value: fmt.Sprintf("%s - %s", Templates[tn].Name, Templates[tn].Description),
+			})
+		}
+	}
+
+	sort.Slice(templates, func(i, j int) bool {
+		return templates[i].Key < templates[j].Key
+	})
+
+	return templates
+}
+
+// GetTemplateDisplayValues extracts display values from TemplateKeyValue slice
+func (tkv TemplateKeyValues) GetTemplateDisplayValues() []string {
+	options := make([]string, len(tkv))
+	for i, kv := range tkv {
+		options[i] = kv.Value
+	}
+	return options
+}
+
+// GetTemplateKeyFromValue maps the selected display value back to the template key
+func (tkv TemplateKeyValues) GetTemplateKeyFromValue(selectedValue string) (string, error) {
+	for _, kv := range tkv {
+		if kv.Value == selectedValue {
+			return kv.Key, nil
+		}
+	}
+	return "", fmt.Errorf("template not found: %s", selectedValue)
+}
+
+// ContainsKey checks if a template key exists in the TemplateKeyValues
+func (tkv TemplateKeyValues) ContainsKey(key string) bool {
+	for _, kv := range tkv {
+		if kv.Key == key {
+			return true
+		}
+	}
+	return false
+}

pkg/create/templates_test.go

@@ -0,0 +1,113 @@
+package create
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetSupportedTemplatesForLanguage_Deterministic(t *testing.T) {
+	// Run the function multiple times to ensure consistent ordering
+	const iterations = 10
+	language := LanguageTypeScript
+
+	var firstResult TemplateKeyValues
+	for i := 0; i < iterations; i++ {
+		result := GetSupportedTemplatesForLanguage(language)
+
+		if i == 0 {
+			firstResult = result
+		} else {
+			// Verify that each iteration produces the same order
+			assert.Equal(t, len(firstResult), len(result), "All iterations should return the same number of templates")
+			for j := range result {
+				assert.Equal(t, firstResult[j].Key, result[j].Key, "Template at index %d should be consistent across iterations", j)
+				assert.Equal(t, firstResult[j].Value, result[j].Value, "Template value at index %d should be consistent across iterations", j)
+			}
+		}
+	}
+}
+
+func TestTemplateKeyValues_GetTemplateDisplayValues(t *testing.T) {
+	templates := TemplateKeyValues{
+		{Key: "sample-app", Value: "Sample App - Implements basic Kernel apps"},
+		{Key: "advanced-sample", Value: "Advanced Sample - Implements sample actions with advanced Kernel configs"},
+	}
+
+	displayValues := templates.GetTemplateDisplayValues()
+
+	assert.Len(t, displayValues, 2)
+	assert.Equal(t, "Sample App - Implements basic Kernel apps", displayValues[0])
+	assert.Equal(t, "Advanced Sample - Implements sample actions with advanced Kernel configs", displayValues[1])
+}
+
+func TestTemplateKeyValues_GetTemplateKeyFromValue(t *testing.T) {
+	templates := TemplateKeyValues{
+		{Key: "sample-app", Value: "Sample App - Implements basic Kernel apps"},
+		{Key: "advanced-sample", Value: "Advanced Sample - Implements sample actions with advanced Kernel configs"},
+	}
+
+	tests := []struct {
+		name          string
+		selectedValue string
+		wantKey       string
+		wantErr       bool
+	}{
+		{
+			name:          "Valid value returns correct key",
+			selectedValue: "Sample App - Implements basic Kernel apps",
+			wantKey:       "sample-app",
+			wantErr:       false,
+		},
+		{
+			name:          "Invalid value returns error",
+			selectedValue: "Non-existent template",
+			wantKey:       "",
+			wantErr:       true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			key, err := templates.GetTemplateKeyFromValue(tt.selectedValue)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.wantKey, key)
+			}
+		})
+	}
+}
+
+func TestTemplateKeyValues_ContainsKey(t *testing.T) {
+	templates := TemplateKeyValues{
+		{Key: "sample-app", Value: "Sample App - Implements basic Kernel apps"},
+		{Key: "advanced-sample", Value: "Advanced Sample - Implements sample actions with advanced Kernel configs"},
+	}
+
+	tests := []struct {
+		name string
+		key  string
+		want bool
+	}{
+		{
+			name: "Existing key returns true",
+			key:  "sample-app",
+			want: true,
+		},
+		{
+			name: "Non-existing key returns false",
+			key:  "non-existent",
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := templates.ContainsKey(tt.key)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

pkg/create/types.go

@@ -14,35 +14,12 @@ const (
 	LanguageShorthandPython     = "py"
 )
 
-type TemplateInfo struct {
-	Name        string
-	Description string
-	Languages   []string
-}
-
-var Templates = map[string]TemplateInfo{
-	"sample-app": {
-		Name:        "Sample App",
-		Description: "Implements basic Kernel apps",
-		Languages:   []string{LanguageTypeScript, LanguagePython},
-	},
-}
-
 // SupportedLanguages returns a list of all supported languages
 var SupportedLanguages = []string{
 	LanguageTypeScript,
 	LanguagePython,
 }
 
-// GetSupportedTemplates returns a list of all supported template names
-func GetSupportedTemplates() []string {
-	templates := make([]string, 0, len(Templates))
-	for tn := range Templates {
-		templates = append(templates, tn)
-	}
-	return templates
-}
-
 // Helper to normalize language input (handle shorthand)
 func NormalizeLanguage(language string) string {
 	switch language {

pkg/create/types_test.go

@@ -24,21 +24,3 @@ func TestNormalizeLanguage(t *testing.T) {
 		})
 	}
 }
-
-func TestTemplates(t *testing.T) {
-	// Should have at least one template
-	assert.NotEmpty(t, Templates, "Templates map should not be empty")
-
-	// Sample app should exist
-	sampleApp, exists := Templates["sample-app"]
-	assert.True(t, exists, "sample-app template should exist")
-
-	// Sample app should have required fields
-	assert.NotEmpty(t, sampleApp.Name, "Template should have a name")
-	assert.NotEmpty(t, sampleApp.Description, "Template should have a description")
-	assert.NotEmpty(t, sampleApp.Languages, "Template should support at least one language")
-
-	// Should support both typescript and python
-	assert.Contains(t, sampleApp.Languages, string(LanguageTypeScript), "sample-app should support typescript")
-	assert.Contains(t, sampleApp.Languages, string(LanguagePython), "sample-app should support python")
-}

pkg/templates/python/.python-version

@@ -0,0 +1 @@
+3.11

pkg/templates/python/advanced-sample/README.md

@@ -0,0 +1,3 @@
+# Kernel Python Advanced Sample App
+
+This is a collection of Kernel actions that demonstrate how to use the Kernel SDK.