refactor: update dependencies

Author: archandatta

cmd/create.go

@@ -37,7 +37,7 @@ func (c CreateCmd) Create(ctx context.Context, ci CreateInput) error {
 		return fmt.Errorf("failed to create directory: %w", err)
 	}
 
-	pterm.Println(fmt.Sprintf("\nCreating a new %s %s\n", ci.Language, ci.Template))
+	pterm.Sprintf("\nCreating a new %s %s\n", ci.Language, ci.Template)
 
 	spinner, _ := pterm.DefaultSpinner.Start("Copying template files...")
 
@@ -46,33 +46,12 @@ func (c CreateCmd) Create(ctx context.Context, ci CreateInput) error {
 		return fmt.Errorf("failed to copy template files: %w", err)
 	}
 
-	ok, _ := create.InstallDependencies(appPath, ci.Language)
-	if !ok {
-		pterm.Warning.Println("Failed to install dependencies. Please install them manually:")
-		switch ci.Language {
-		case create.LanguageTypeScript:
-			pterm.Println(fmt.Sprintf("  cd %s", ci.Name))
-			pterm.Println("  npm install")
-		case create.LanguagePython:
-			pterm.Println(fmt.Sprintf("  cd %s", ci.Name))
-			pterm.Println("  uv venv && source .venv/bin/activate && uv sync")
-		}
-		pterm.Println()
-	} else {
-		spinner.Success(fmt.Sprintf("✔ %s environment set up successfully", ci.Language))
+	nextSteps, err := create.InstallDependencies(ci.Name, appPath, ci.Language)
+	if err != nil {
+		return fmt.Errorf("failed to install dependencies: %w", err)
 	}
-
 	pterm.Success.Println("🎉 Kernel app created successfully!")
 	pterm.Println()
-
-	nextSteps := fmt.Sprintf(`Next steps:
-  brew install onkernel/tap/kernel
-  cd %s
-  kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
-  kernel deploy index.ts
-  kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'
-`, ci.Name)
-
 	pterm.FgYellow.Println(nextSteps)
 
 	return nil

cmd/create_test.go

@@ -1,12 +1,15 @@
 package cmd
 
 import (
+	"bytes"
 	"context"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
 
 	"github.com/onkernel/cli/pkg/create"
+	"github.com/pterm/pterm"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -234,6 +237,14 @@ func TestCreateCommand_DependencyInstallationFails(t *testing.T) {
 		os.Chdir(orgDir)
 	})
 
+	var outputBuf bytes.Buffer
+	multiWriter := io.MultiWriter(&outputBuf, os.Stdout)
+	pterm.SetDefaultOutput(multiWriter)
+
+	t.Cleanup(func() {
+		pterm.SetDefaultOutput(os.Stdout)
+	})
+
 	// Override the install command to use a command that will fail
 	originalInstallCommands := create.InstallCommands
 	create.InstallCommands = map[string]string{
@@ -252,6 +263,93 @@ func TestCreateCommand_DependencyInstallationFails(t *testing.T) {
 		Language: create.LanguageTypeScript,
 		Template: "sample-app",
 	})
+
+	output := outputBuf.String()
+
+	assert.Contains(t, output, "cd test-app", "should print cd command")
+	assert.Contains(t, output, "pnpm install", "should print pnpm install command")
+}
+
+// TestCreateCommand_RequiredToolMissing tests that the app is created
+func TestCreateCommand_RequiredToolMissing(t *testing.T) {
+	tests := []struct {
+		name     string
+		language string
+		template string
+	}{
+		{
+			name:     "typescript with missing pnpm",
+			language: create.LanguageTypeScript,
+			template: "sample-app",
+		},
+		{
+			name:     "python with missing uv",
+			language: create.LanguagePython,
+			template: "sample-app",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			appName := "test-app"
+
+			orgDir, err := os.Getwd()
+			require.NoError(t, err)
+
+			err = os.Chdir(tmpDir)
+			require.NoError(t, err)
+
+			t.Cleanup(func() {
+				os.Chdir(orgDir)
+			})
+
+			// Override the required tool to point to a non-existent command
+			originalRequiredTools := create.RequiredTools
+			create.RequiredTools = map[string]string{
+				create.LanguageTypeScript: "nonexistent-pnpm-tool",
+				create.LanguagePython:     "nonexistent-uv-tool",
+			}
+
+			// Restore original required tools after test
+			t.Cleanup(func() {
+				create.RequiredTools = originalRequiredTools
+			})
+
+			// Create the app - should succeed even though required tool is missing
+			c := CreateCmd{}
+			err = c.Create(context.Background(), CreateInput{
+				Name:     appName,
+				Language: tt.language,
+				Template: tt.template,
+			})
+
+			// Should not return an error - the command should complete successfully
+			// but skip dependency installation
+			require.NoError(t, err, "app creation should succeed even when required tool is missing")
+
+			// Verify the app directory and files were created
+			appPath := filepath.Join(tmpDir, appName)
+			assert.DirExists(t, appPath, "app directory should exist")
+
+			// Language-specific file checks
+			switch tt.language {
+			case create.LanguageTypeScript:
+				assert.FileExists(t, filepath.Join(appPath, "package.json"), "package.json should exist")
+				assert.FileExists(t, filepath.Join(appPath, "index.ts"), "index.ts should exist")
+				assert.FileExists(t, filepath.Join(appPath, "tsconfig.json"), "tsconfig.json should exist")
+
+				// node_modules should NOT exist since pnpm was not available
+				assert.NoDirExists(t, filepath.Join(appPath, "node_modules"), "node_modules should not exist when pnpm is missing")
+			case create.LanguagePython:
+				assert.FileExists(t, filepath.Join(appPath, "pyproject.toml"), "pyproject.toml should exist")
+				assert.FileExists(t, filepath.Join(appPath, "main.py"), "main.py should exist")
+
+				// .venv should NOT exist since uv was not available
+				assert.NoDirExists(t, filepath.Join(appPath, ".venv"), ".venv should not exist when uv is missing")
+			}
+		})
+	}
 }
 
 func getTemplateInfo() []struct {

pkg/create/dependencies.go

@@ -8,22 +8,93 @@ import (
 )
 
 // InstallDependencies sets up project dependencies based on language
-func InstallDependencies(appPath string, language string) (bool, error) {
+func InstallDependencies(appName string, appPath string, language string) (string, error) {
 	installCommand, ok := InstallCommands[language]
 	if !ok {
-		return false, fmt.Errorf("unsupported language: %s", language)
+		return "", fmt.Errorf("unsupported language: %s", language)
 	}
 
-	spinner, _ := pterm.DefaultSpinner.Start(fmt.Sprintf("Setting up %s environment...", language))
+	requiredTool := RequiredTools[language]
+	if requiredTool != "" && !RequiredTools.CheckToolAvailable(language) {
+		return getNextStepsWithToolInstall(appName, language, requiredTool), nil
+	}
+
+	spinner, _ := pterm.DefaultSpinner.Start(pterm.Sprintf("Setting up %s environment...", language))
 
 	cmd := exec.Command("sh", "-c", installCommand)
 	cmd.Dir = appPath
 
 	if err := cmd.Run(); err != nil {
 		spinner.Stop()
-		return false, nil
+		pterm.Warning.Println("Failed to install dependencies. Please install them manually:")
+		switch language {
+		case LanguageTypeScript:
+			pterm.Printfln("  cd %s", appName)
+			pterm.Printfln("  pnpm install")
+		case LanguagePython:
+			pterm.Printfln("  cd %s", appName)
+			pterm.Println("  uv venv && source .venv/bin/activate && uv sync")
+		}
+		pterm.Println()
+		return getNextStepsStandard(appName), nil
 	}
 
-	spinner.Success(fmt.Sprintf("%s environment set up successfully", language))
-	return true, nil
+	spinner.Success(pterm.Sprintf("✔ %s environment set up successfully", language))
+
+	return getNextStepsStandard(appName), nil
+}
+
+// getNextStepsWithToolInstall returns next steps message including tool installation
+func getNextStepsWithToolInstall(appName string, language string, requiredTool string) string {
+	pterm.Warning.Printfln(" %s is not installed or not in PATH", requiredTool)
+
+	switch language {
+	case LanguageTypeScript:
+		return pterm.FgYellow.Sprintf(`Next steps:
+  # Install pnpm (choose one):
+  npm install -g pnpm
+  # or: brew install pnpm
+  # or: curl -fsSL https://get.pnpm.io/install.sh | sh -
+
+  # Then install dependencies:
+  cd %s
+  pnpm install
+
+  # Deploy your app:
+  brew install onkernel/tap/kernel
+  kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
+  kernel deploy index.ts
+  kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'
+`, appName)
+	case LanguagePython:
+		return pterm.FgYellow.Sprintf(`Next steps:
+  # Install uv (choose one):
+  curl -LsSf https://astral.sh/uv/install.sh | sh
+  # or: brew install uv
+  # or: pipx install uv
+
+  # Then set up your environment:
+  cd %s
+  uv venv && source .venv/bin/activate && uv sync
+
+  # Deploy your app:
+  brew install onkernel/tap/kernel
+  kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
+  kernel deploy index.py
+  kernel invoke py-basic get-page-title --payload '{"url": "https://www.google.com"}'
+`, appName)
+	default:
+		return ""
+	}
+}
+
+// getNextStepsStandard returns standard next steps message
+func getNextStepsStandard(appName string) string {
+	return pterm.FgYellow.Sprintf(`Next steps:
+  brew install onkernel/tap/kernel
+  cd %s
+  kernel login  # or: export KERNEL_API_KEY=<YOUR_API_KEY>
+  kernel deploy index.ts
+  kernel invoke ts-basic get-page-title --payload '{"url": "https://www.google.com"}'
+`, appName)
 }

pkg/create/types.go

@@ -1,5 +1,7 @@
 package create
 
+import "os/exec"
+
 const (
 	DefaultAppName = "my-kernel-app"
 	AppNamePrompt  = "What is the name of your project?"
@@ -14,8 +16,20 @@ const (
 	LanguageShorthandPython     = "py"
 )
 
+type Tools map[string]string
+
+var RequiredTools = Tools{
+	LanguageTypeScript: "pnpm",
+	LanguagePython:     "uv",
+}
+
+func (t Tools) CheckToolAvailable(tool string) bool {
+	_, err := exec.LookPath(t[tool])
+	return err == nil
+}
+
 var InstallCommands = map[string]string{
-	LanguageTypeScript: "npm install",
+	LanguageTypeScript: "pnpm install",
 	LanguagePython:     "uv venv",
 }