Merge pull request #86 from nebari-dev/rename-env-to-workspace

refactor: rename environment to workspace

Author: Adam-D-Lewis

app.go

@@ -191,89 +191,89 @@ func (a *App) startEmbeddedServer(cfg *config.Config, database *gorm.DB) {
 	logToFile("startEmbeddedServer: server stopped")
 }
 
-// Environment represents a simplified environment for the frontend
-type Environment struct {
+// WailsWorkspace represents a simplified workspace for the Wails frontend
+type WailsWorkspace struct {
 	ID             string `json:"id"`
 	Name           string `json:"name"`
 	Status         string `json:"status"`
 	PackageManager string `json:"packageManager"`
 	CreatedAt      string `json:"createdAt"`
 }
 
-// ListEnvironments returns all environments
-func (a *App) ListEnvironments() ([]Environment, error) {
+// ListWorkspaces returns all workspaces
+func (a *App) ListWorkspaces() ([]WailsWorkspace, error) {
 	if a.db == nil {
 		return nil, fmt.Errorf("database not connected")
 	}
 
-	var envs []models.Environment
-	if err := a.db.Order("created_at DESC").Find(&envs).Error; err != nil {
+	var workspaces []models.Workspace
+	if err := a.db.Order("created_at DESC").Find(&workspaces).Error; err != nil {
 		return nil, err
 	}
 
-	result := make([]Environment, len(envs))
-	for i, env := range envs {
-		result[i] = Environment{
-			ID:             env.ID.String(),
-			Name:           env.Name,
-			Status:         string(env.Status),
-			PackageManager: env.PackageManager,
-			CreatedAt:      env.CreatedAt.Format("2006-01-02 15:04:05"),
+	result := make([]WailsWorkspace, len(workspaces))
+	for i, ws := range workspaces {
+		result[i] = WailsWorkspace{
+			ID:             ws.ID.String(),
+			Name:           ws.Name,
+			Status:         string(ws.Status),
+			PackageManager: ws.PackageManager,
+			CreatedAt:      ws.CreatedAt.Format("2006-01-02 15:04:05"),
 		}
 	}
 	return result, nil
 }
 
-// CreateEnvironment creates a new environment
-func (a *App) CreateEnvironment(name string, pixiToml string) (*Environment, error) {
+// CreateWorkspace creates a new workspace
+func (a *App) CreateWorkspace(name string, pixiToml string) (*WailsWorkspace, error) {
 	if a.db == nil {
 		return nil, fmt.Errorf("database not connected")
 	}
 
-	env := models.Environment{
+	ws := models.Workspace{
 		Name:           name,
-		Status:         models.EnvStatusPending,
+		Status:         models.WsStatusPending,
 		PackageManager: "pixi",
 	}
 
-	if err := a.db.Create(&env).Error; err != nil {
+	if err := a.db.Create(&ws).Error; err != nil {
 		return nil, err
 	}
 
-	return &Environment{
-		ID:             env.ID.String(),
-		Name:           env.Name,
-		Status:         string(env.Status),
-		PackageManager: env.PackageManager,
-		CreatedAt:      env.CreatedAt.Format("2006-01-02 15:04:05"),
+	return &WailsWorkspace{
+		ID:             ws.ID.String(),
+		Name:           ws.Name,
+		Status:         string(ws.Status),
+		PackageManager: ws.PackageManager,
+		CreatedAt:      ws.CreatedAt.Format("2006-01-02 15:04:05"),
 	}, nil
 }
 
-// DeleteEnvironment deletes an environment by ID
-func (a *App) DeleteEnvironment(id string) error {
+// DeleteWorkspace deletes a workspace by ID
+func (a *App) DeleteWorkspace(id string) error {
 	if a.db == nil {
 		return fmt.Errorf("database not connected")
 	}
 
-	return a.db.Where("id = ?", id).Delete(&models.Environment{}).Error
+	return a.db.Where("id = ?", id).Delete(&models.Workspace{}).Error
 }
 
-// GetEnvironment gets a single environment by ID
-func (a *App) GetEnvironment(id string) (*Environment, error) {
+// GetWorkspace gets a single workspace by ID
+func (a *App) GetWorkspace(id string) (*WailsWorkspace, error) {
 	if a.db == nil {
 		return nil, fmt.Errorf("database not connected")
 	}
 
-	var env models.Environment
-	if err := a.db.Where("id = ?", id).First(&env).Error; err != nil {
+	var ws models.Workspace
+	if err := a.db.Where("id = ?", id).First(&ws).Error; err != nil {
 		return nil, err
 	}
 
-	return &Environment{
-		ID:             env.ID.String(),
-		Name:           env.Name,
-		Status:         string(env.Status),
-		PackageManager: env.PackageManager,
-		CreatedAt:      env.CreatedAt.Format("2006-01-02 15:04:05"),
+	return &WailsWorkspace{
+		ID:             ws.ID.String(),
+		Name:           ws.Name,
+		Status:         string(ws.Status),
+		PackageManager: ws.PackageManager,
+		CreatedAt:      ws.CreatedAt.Format("2006-01-02 15:04:05"),
 	}, nil
 }

cmd/nebi/client.go

@@ -12,8 +12,8 @@ import (
 	"github.com/nebari-dev/nebi/internal/localstore"
 )
 
-// ErrEnvNotFound is returned when an environment name is not found on the server.
-var ErrEnvNotFound = errors.New("environment not found on server")
+// ErrWsNotFound is returned when a workspace name is not found on the server.
+var ErrWsNotFound = errors.New("workspace not found on server")
 
 // resolveServerFlag returns the server argument, falling back to the default server from config.
 func resolveServerFlag(serverArg string) (string, error) {
@@ -50,20 +50,20 @@ func getAuthenticatedClient(serverArg string) (*cliclient.Client, error) {
 	return cliclient.New(serverURL, cred.Token), nil
 }
 
-// findEnvByName searches for an environment by name on the server.
-func findEnvByName(client *cliclient.Client, ctx context.Context, name string) (*cliclient.Environment, error) {
-	envs, err := client.ListEnvironments(ctx)
+// findWsByName searches for a workspace by name on the server.
+func findWsByName(client *cliclient.Client, ctx context.Context, name string) (*cliclient.Workspace, error) {
+	workspaces, err := client.ListWorkspaces(ctx)
 	if err != nil {
-		return nil, fmt.Errorf("listing environments: %w", err)
+		return nil, fmt.Errorf("listing workspaces: %w", err)
 	}
 
-	for i := range envs {
-		if envs[i].Name == name {
-			return &envs[i], nil
+	for i := range workspaces {
+		if workspaces[i].Name == name {
+			return &workspaces[i], nil
 		}
 	}
 
-	return nil, fmt.Errorf("%w: %q", ErrEnvNotFound, name)
+	return nil, fmt.Errorf("%w: %q", ErrWsNotFound, name)
 }
 
 // findGlobalWorkspaceByName looks up a global workspace by name in the local index.
@@ -161,9 +161,9 @@ func saveOrigin(server, name, tag, action, tomlContent, lockContent string) erro
 	return store.SaveIndex(idx)
 }
 
-// parseEnvRef parses a reference in the format env:tag.
-// Returns (env, tag) where tag may be empty if not specified.
-func parseEnvRef(ref string) (string, string) {
+// parseWsRef parses a reference in the format workspace:tag.
+// Returns (workspace, tag) where tag may be empty if not specified.
+func parseWsRef(ref string) (string, string) {
 	if idx := strings.LastIndex(ref, ":"); idx != -1 {
 		return ref[:idx], ref[idx+1:]
 	}
@@ -179,21 +179,21 @@ func formatTimestamp(ts string) string {
 	return t.Format("2006-01-02 15:04")
 }
 
-// waitForEnvReady polls until the environment reaches ready state or timeout.
-func waitForEnvReady(client *cliclient.Client, ctx context.Context, envID string, timeout time.Duration) (*cliclient.Environment, error) {
+// waitForWsReady polls until the workspace reaches ready state or timeout.
+func waitForWsReady(client *cliclient.Client, ctx context.Context, wsID string, timeout time.Duration) (*cliclient.Workspace, error) {
 	deadline := time.Now().Add(timeout)
 	for time.Now().Before(deadline) {
-		env, err := client.GetEnvironment(ctx, envID)
+		ws, err := client.GetWorkspace(ctx, wsID)
 		if err != nil {
-			return nil, fmt.Errorf("failed to get environment status: %w", err)
+			return nil, fmt.Errorf("failed to get workspace status: %w", err)
 		}
-		switch env.Status {
+		switch ws.Status {
 		case "ready":
-			return env, nil
+			return ws, nil
 		case "failed", "error":
-			return nil, fmt.Errorf("environment setup failed")
+			return nil, fmt.Errorf("workspace setup failed")
 		}
 		time.Sleep(500 * time.Millisecond)
 	}
-	return nil, fmt.Errorf("timeout waiting for environment to be ready")
+	return nil, fmt.Errorf("timeout waiting for workspace to be ready")
 }

cmd/nebi/diff.go

@@ -199,7 +199,7 @@ func resolveLocalSource(dir, defaultLabel string) (*diffSource, error) {
 }
 
 func resolveServerSource(ref string) (*diffSource, error) {
-	envName, tag := parseEnvRef(ref)
+	wsName, tag := parseWsRef(ref)
 
 	server, err := resolveServerFlag(diffServer)
 	if err != nil {
@@ -213,26 +213,26 @@ func resolveServerSource(ref string) (*diffSource, error) {
 
 	ctx := context.Background()
 
-	env, err := findEnvByName(client, ctx, envName)
+	ws, err := findWsByName(client, ctx, wsName)
 	if err != nil {
 		return nil, err
 	}
 
-	versionNumber, err := resolveVersionNumber(client, ctx, env.ID, envName, tag)
+	versionNumber, err := resolveVersionNumber(client, ctx, ws.ID, wsName, tag)
 	if err != nil {
 		return nil, err
 	}
 
-	toml, err := client.GetVersionPixiToml(ctx, env.ID, versionNumber)
+	toml, err := client.GetVersionPixiToml(ctx, ws.ID, versionNumber)
 	if err != nil {
 		return nil, fmt.Errorf("fetching pixi.toml: %w", err)
 	}
 
-	lock, _ := client.GetVersionPixiLock(ctx, env.ID, versionNumber)
+	lock, _ := client.GetVersionPixiLock(ctx, ws.ID, versionNumber)
 
-	label := envName
+	label := wsName
 	if tag != "" {
-		label = envName + ":" + tag
+		label = wsName + ":" + tag
 	}
 
 	return &diffSource{
@@ -243,9 +243,9 @@ func resolveServerSource(ref string) (*diffSource, error) {
 }
 
 // resolveVersionNumber resolves a tag or latest version to a version number.
-func resolveVersionNumber(client *cliclient.Client, ctx context.Context, envID, envName, tag string) (int32, error) {
+func resolveVersionNumber(client *cliclient.Client, ctx context.Context, wsID, wsName, tag string) (int32, error) {
 	if tag != "" {
-		tags, err := client.GetEnvironmentTags(ctx, envID)
+		tags, err := client.GetWorkspaceTags(ctx, wsID)
 		if err != nil {
 			return 0, fmt.Errorf("getting tags: %w", err)
 		}
@@ -254,15 +254,15 @@ func resolveVersionNumber(client *cliclient.Client, ctx context.Context, envID,
 				return int32(t.VersionNumber), nil
 			}
 		}
-		return 0, fmt.Errorf("tag %q not found for environment %q", tag, envName)
+		return 0, fmt.Errorf("tag %q not found for workspace %q", tag, wsName)
 	}
 
-	versions, err := client.GetEnvironmentVersions(ctx, envID)
+	versions, err := client.GetWorkspaceVersions(ctx, wsID)
 	if err != nil {
 		return 0, fmt.Errorf("getting versions: %w", err)
 	}
 	if len(versions) == 0 {
-		return 0, fmt.Errorf("environment %q has no versions", envName)
+		return 0, fmt.Errorf("workspace %q has no versions", wsName)
 	}
 	latest := versions[0]
 	for _, v := range versions {

cmd/nebi/main.go

@@ -13,7 +13,7 @@ var Version = "dev"
 
 var rootCmd = &cobra.Command{
 	Use:   "nebi",
-	Short: "Nebi - Local-first environment management for Pixi",
+	Short: "Nebi - Local-first workspace management for Pixi",
 	Long:  `Nebi manages Pixi workspaces locally and syncs them to remote servers.`,
 	Example: `  # Track a workspace and push it to a server
   nebi init

cmd/nebi/publish.go

@@ -39,16 +39,16 @@ func init() {
 }
 
 func runWorkspacePublish(cmd *cobra.Command, args []string) error {
-	envName, tag := parseEnvRef(args[0])
+	wsName, tag := parseWsRef(args[0])
 	if tag == "" {
 		return fmt.Errorf("tag is required; usage: nebi workspace publish <workspace>:<tag>")
 	}
 
 	// Parse optional repo:oci-tag from second positional arg
-	repo := envName
+	repo := wsName
 	ociTag := tag
 	if len(args) == 2 {
-		r, t := parseEnvRef(args[1])
+		r, t := parseWsRef(args[1])
 		repo = r
 		if t != "" {
 			ociTag = t
@@ -67,8 +67,8 @@ func runWorkspacePublish(cmd *cobra.Command, args []string) error {
 
 	ctx := context.Background()
 
-	// Find environment on server
-	env, err := findEnvByName(client, ctx, envName)
+	// Find workspace on server
+	ws, err := findWsByName(client, ctx, wsName)
 	if err != nil {
 		return err
 	}
@@ -85,8 +85,8 @@ func runWorkspacePublish(cmd *cobra.Command, args []string) error {
 		Tag:        ociTag,
 	}
 
-	fmt.Fprintf(os.Stderr, "Publishing %s:%s to %s:%s...\n", envName, tag, repo, ociTag)
-	resp, err := client.PublishEnvironment(ctx, env.ID, req)
+	fmt.Fprintf(os.Stderr, "Publishing %s:%s to %s:%s...\n", wsName, tag, repo, ociTag)
+	resp, err := client.PublishWorkspace(ctx, ws.ID, req)
 	if err != nil {
 		return fmt.Errorf("failed to publish: %w", err)
 	}