Create project on initialization

Author: DylanBlakemore

cmd/project.go

@@ -3,13 +3,15 @@ package cmd
 import (
 	"errors"
 	"fmt"
+	"strings"
 
 	"github.com/spf13/cobra"
 
 	"github.com/InitiatDev/initiat-cli/internal/client"
 	"github.com/InitiatDev/initiat-cli/internal/config"
 	"github.com/InitiatDev/initiat-cli/internal/env"
 	"github.com/InitiatDev/initiat-cli/internal/project"
+	"github.com/InitiatDev/initiat-cli/internal/prompt"
 	"github.com/InitiatDev/initiat-cli/internal/setup"
 	"github.com/InitiatDev/initiat-cli/internal/storage"
 	"github.com/InitiatDev/initiat-cli/internal/table"
@@ -163,7 +165,26 @@ func runProjectInit(cmd *cobra.Command, args []string) error {
 	c := client.New()
 	proj, err := c.GetProjectBySlug(orgSlug, projectSlug)
 	if err != nil {
-		return fmt.Errorf("❌ Failed to get project info: %w", err)
+		if errors.Is(err, client.ErrProjectNotFound) {
+			fmt.Printf("⚠️  Project \"%s/%s\" does not exist.\n", orgSlug, projectSlug)
+			create, promptErr := prompt.PromptYesNo("Would you like to create it?")
+			if promptErr != nil {
+				return fmt.Errorf("❌ Failed to read user input: %w", promptErr)
+			}
+			if !create {
+				return fmt.Errorf("❌ Project creation cancelled")
+			}
+
+			projectName := slugToTitle(projectSlug)
+			fmt.Printf("Creating project \"%s\"...\n", projectCtx.String())
+			proj, err = c.CreateProject(orgSlug, projectName, projectSlug, "")
+			if err != nil {
+				return fmt.Errorf("❌ Failed to create project: %w", err)
+			}
+			fmt.Printf("✅ Project \"%s\" created successfully!\n", projectCtx.String())
+		} else {
+			return fmt.Errorf("❌ Failed to get project info: %w", err)
+		}
 	}
 
 	if !checkProjectInitStatus(proj) {
@@ -204,6 +225,16 @@ func ensureInitiatFileExists(orgSlug, projectSlug string) error {
 	return nil
 }
 
+func slugToTitle(slug string) string {
+	words := strings.Split(slug, "-")
+	for i, word := range words {
+		if len(word) > 0 {
+			words[i] = strings.ToUpper(word[:1]) + strings.ToLower(word[1:])
+		}
+	}
+	return strings.Join(words, " ")
+}
+
 func checkProjectInitStatus(project *types.Project) bool {
 	if project.KeyInitialized {
 		fmt.Println("Project key already initialized on server")

cmd/project_test.go

@@ -217,10 +217,16 @@ func TestProjectInitKeyAlreadyInitialized(t *testing.T) {
 	_ = runProjectInit(projectInitCmd, []string{})
 }
 
-func TestProjectInitKeyNotFound(t *testing.T) {
+func TestProjectInitKeyNotFound_UserDeclines(t *testing.T) {
 	capture := testutil.CaptureStdout()
 	defer capture.Restore()
 
+	mock, err := testutil.MockStdin("n\n")
+	if err != nil {
+		t.Fatalf("Failed to mock stdin: %v", err)
+	}
+	defer mock.Restore()
+
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
 		w.Header().Set("Content-Type", "application/json")
@@ -231,14 +237,122 @@ func TestProjectInitKeyNotFound(t *testing.T) {
 	setupTestEnvironment(t, server.URL)
 
 	projectPath = "test-org/non-existent"
-	err := runProjectInit(projectInitCmd, []string{})
+	err = runProjectInit(projectInitCmd, []string{})
 	if err == nil {
-		t.Error("Expected error for non-existent project")
+		t.Error("Expected error when user declines to create project")
 		return
 	}
-	if !strings.Contains(err.Error(), "Failed to get project info") {
-		t.Errorf("Expected specific error message, got: %v", err)
+	if !strings.Contains(err.Error(), "Project creation cancelled") {
+		t.Errorf("Expected 'Project creation cancelled' error, got: %v", err)
+	}
+	capture.AssertContains(t, "does not exist")
+	capture.AssertContains(t, "Would you like to create it?")
+}
+
+func TestProjectInitKeyNotFound_UserCreates(t *testing.T) {
+	capture := testutil.CaptureStdout()
+	defer capture.Restore()
+
+	mock, err := testutil.MockStdin("y\n")
+	if err != nil {
+		t.Fatalf("Failed to mock stdin: %v", err)
+	}
+	defer mock.Restore()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/projects/test-org":
+			if r.Method == "POST" {
+				var req types.CreateProjectRequest
+				if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+					t.Fatalf("Failed to decode request: %v", err)
+				}
+
+				projectData := types.Project{
+					ID:             1,
+					Name:           "New Project",
+					Slug:           "new-project",
+					CompositeSlug:  "test-org/new-project",
+					Description:    "",
+					KeyInitialized: false,
+					KeyVersion:     0,
+					Role:           "Owner",
+					Organization: struct {
+						ID   int    `json:"id"`
+						Name string `json:"name"`
+						Slug string `json:"slug"`
+					}{
+						ID:   1,
+						Name: "Test Org",
+						Slug: "test-org",
+					},
+				}
+
+				response := map[string]interface{}{
+					"success": true,
+					"message": "Project created successfully",
+					"data": map[string]interface{}{
+						"project": projectData,
+					},
+				}
+
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusCreated)
+				json.NewEncoder(w).Encode(response)
+				return
+			}
+		case "/api/v1/projects/test-org/new-project":
+			if r.Method == "GET" {
+				w.WriteHeader(http.StatusNotFound)
+				w.Header().Set("Content-Type", "application/json")
+				json.NewEncoder(w).Encode(map[string]string{"error": "project not found"})
+				return
+			}
+		case "/api/v1/projects/test-org/new-project/initialize":
+			if r.Method != "POST" {
+				t.Errorf("Expected POST, got %s", r.Method)
+			}
+
+			var req types.InitializeProjectKeyRequest
+			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+				t.Fatalf("Failed to decode request: %v", err)
+			}
+
+			if req.WrappedProjectKey == "" {
+				t.Error("Expected wrapped project key")
+			}
+
+			if _, err := crypto.Decode(req.WrappedProjectKey); err != nil {
+				t.Errorf("Invalid encoded wrapped key: %v", err)
+			}
+
+			response := map[string]interface{}{
+				"success": true,
+				"message": "Project key initialized successfully",
+			}
+			w.Header().Set("Content-Type", "application/json")
+			json.NewEncoder(w).Encode(response)
+
+		default:
+			t.Errorf("Unexpected request path: %s", r.URL.Path)
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	setupTestEnvironment(t, server.URL)
+
+	projectPath = "test-org/new-project"
+	err = runProjectInit(projectInitCmd, []string{})
+	if err != nil {
+		t.Fatalf("runProjectInit failed: %v", err)
 	}
+
+	capture.AssertContains(t, "does not exist")
+	capture.AssertContains(t, "Would you like to create it?")
+	capture.AssertContains(t, "Creating project")
+	capture.AssertContains(t, "created successfully")
+	capture.AssertContains(t, "initialized successfully")
 }
 
 func setupTestEnvironment(t *testing.T, serverURL string) {

internal/client/client.go

@@ -3,6 +3,7 @@ package client
 import (
 	"crypto/ed25519"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -19,6 +20,8 @@ const (
 	debugPreviewLength    = 20 // Length of key preview for debug output
 )
 
+var ErrProjectNotFound = errors.New("project not found")
+
 type Client struct {
 	baseURL    string
 	httpClient *http.Client
@@ -151,6 +154,10 @@ func (c *Client) GetProjectBySlug(orgSlug, projectSlug string) (*types.Project,
 		return nil, err
 	}
 
+	if statusCode == http.StatusNotFound {
+		return nil, ErrProjectNotFound
+	}
+
 	var project types.Project
 	if err := httputil.HandleGetResponse(statusCode, body, &project); err != nil {
 		return nil, fmt.Errorf("get project failed: %w", err)
@@ -159,6 +166,32 @@ func (c *Client) GetProjectBySlug(orgSlug, projectSlug string) (*types.Project,
 	return &project, nil
 }
 
+func (c *Client) CreateProject(orgSlug string, name, slug, description string) (*types.Project, error) {
+	createReq := types.CreateProjectRequest{
+		Name:        name,
+		Slug:        slug,
+		Description: description,
+	}
+
+	jsonData, err := json.Marshal(createReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal create project request: %w", err)
+	}
+
+	url := routes.BuildURL(c.baseURL, routes.Project.Create(orgSlug))
+	statusCode, body, err := httputil.DoSignedRequest(c.httpClient, routes.POST, url, jsonData)
+	if err != nil {
+		return nil, err
+	}
+
+	var createResp types.CreateProjectResponse
+	if err := httputil.HandleStandardResponse(statusCode, body, &createResp); err != nil {
+		return nil, fmt.Errorf("create project failed: %w", err)
+	}
+
+	return &createResp.Project, nil
+}
+
 func (c *Client) InitializeProjectKey(orgSlug, projectSlug string, wrappedKey []byte) error {
 	initReq := types.InitializeProjectKeyRequest{
 		WrappedProjectKey: crypto.Encode(wrappedKey),