🎨 Add colors

Closes kloudkit/ws-meta#43

Author: bdsoha

cmd/clip/paste.go

@@ -7,7 +7,7 @@ import (
 
 var pasteCmd = &cobra.Command{
 	Use:   "paste",
-	Short: "Paste clipboard content to the terminal",
+	Short: "Paste clipboard content",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		return clipboard.Paste(cmd.OutOrStdout())
 	},

cmd/feature/feature.go

@@ -1,7 +1,6 @@
 package feature
 
 import (
-	"github.com/kloudkit/ws-cli/cmd/feature/install"
 	"github.com/kloudkit/ws-cli/internals/env"
 	"github.com/spf13/cobra"
 )
@@ -18,5 +17,5 @@ func init() {
 		"Root directory of extra features",
 	)
 
-	FeatureCmd.AddCommand(install.InstallCmd)
+	FeatureCmd.AddCommand(installCmd, listCmd, infoCmd)
 }

cmd/feature/info.go

@@ -0,0 +1,50 @@
+package feature
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/kloudkit/ws-cli/internals/features"
+	"github.com/kloudkit/ws-cli/internals/styles"
+	"github.com/spf13/cobra"
+)
+
+var infoCmd = &cobra.Command{
+	Use:   "info <name>",
+	Short: "Show detailed information about a feature",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		featuresDir, _ := cmd.Flags().GetString("root")
+		featureName := args[0]
+
+		feature, err := features.InfoFeature(featuresDir, featureName)
+		if err != nil {
+			return fmt.Errorf("failed to get feature info: %w", err)
+		}
+
+		fmt.Fprintf(
+			cmd.OutOrStdout(),
+			"\n%s\n  %s\n\n",
+			styles.InfoBadge().Render(strings.ToUpper(feature.Name)),
+			feature.Description,
+		)
+
+		if len(feature.Vars) > 0 {
+			fmt.Fprintf(
+				cmd.OutOrStdout(),
+				"%s\n",
+				styles.Badge().Render("Options"),
+			)
+
+			listItems := make([]any, len(feature.Vars))
+			for i, v := range feature.Vars {
+				listItems[i] = styles.Key().UnsetBold().Render(v)
+			}
+
+			fmt.Fprintln(cmd.OutOrStdout(), styles.List(listItems...))
+		}
+
+		fmt.Fprintln(cmd.OutOrStdout())
+		return nil
+	},
+}

cmd/feature/install/install.go cmd/feature/install.gocmd/feature/install/install.go renamed to cmd/feature/install.go

@@ -1,4 +1,4 @@
-package install
+package feature
 
 import (
 	"context"
@@ -9,15 +9,16 @@ import (
 
 	"github.com/apenella/go-ansible/v2/pkg/execute"
 	"github.com/apenella/go-ansible/v2/pkg/playbook"
+	"github.com/kloudkit/ws-cli/internals/styles"
 	"github.com/spf13/cobra"
 )
 
-var InstallCmd = &cobra.Command{
+var installCmd = &cobra.Command{
 	Use:   "install",
 	Short: "Install extra pre-configured features",
 }
 
-var features = map[string]string{
+var installableFeatures = map[string]string{
 	"cloudflared": "Install Cloudflare tunnel CLI",
 	"codex":       "Install codex CLI",
 	"conan":       "Install Conan CLI and related tools",
@@ -42,7 +43,7 @@ var features = map[string]string{
 var customCmd = &cobra.Command{
 	Use:   "custom",
 	Short: "Install a custom feature",
-	Run:   install("custom"),
+	RunE:  installFeature("custom"),
 }
 
 func runPlay(feature string, vars map[string]interface{}, errorOut io.Writer) {
@@ -60,7 +61,8 @@ func runPlay(feature string, vars map[string]interface{}, errorOut io.Writer) {
 	err := exec.Execute(context.Background())
 
 	if err != nil {
-		fmt.Fprintln(errorOut, err)
+		fmt.Fprintf(errorOut, "%s\n\n", styles.ErrorBadge().Render("ERROR"))
+		fmt.Fprintf(errorOut, "%s\n", styles.Error().Render(err.Error()))
 		os.Exit(1)
 	}
 }
@@ -69,15 +71,16 @@ func getFeaturePath(root string, feature string, errorOut io.Writer) string {
 	feature = filepath.Join(root, feature+".yaml")
 
 	if _, err := os.Stat(feature); os.IsNotExist(err) {
-		fmt.Fprintf(errorOut, "ERROR: The feature path [%s] could not be found.\n", feature)
+		fmt.Fprintf(errorOut, "%s\n\n", styles.ErrorBadge().Render("ERROR"))
+		fmt.Fprintf(errorOut, "%s\n", styles.Error().Render(fmt.Sprintf("The feature path [%s] could not be found", feature)))
 		os.Exit(1)
 	}
 
 	return feature
 }
 
-func install(feature string) func(*cobra.Command, []string) {
-	return func(cmd *cobra.Command, args []string) {
+func installFeature(feature string) func(*cobra.Command, []string) error {
+	return func(cmd *cobra.Command, args []string) error {
 		root, _ := cmd.Flags().GetString("root")
 		rawVars, _ := cmd.Flags().GetStringToString("opt")
 
@@ -96,11 +99,12 @@ func install(feature string) func(*cobra.Command, []string) {
 		feature = getFeaturePath(root, feature, cmd.ErrOrStderr())
 
 		runPlay(feature, vars, cmd.ErrOrStderr())
+		return nil
 	}
 }
 
 func init() {
-	InstallCmd.PersistentFlags().StringToString(
+	installCmd.PersistentFlags().StringToString(
 		"opt",
 		map[string]string{},
 		"Optional variables to use during installation",
@@ -109,13 +113,13 @@ func init() {
 	customCmd.Flags().String("feature", "", "The custom feature to install")
 	customCmd.MarkFlagRequired("feature")
 
-	InstallCmd.AddCommand(customCmd)
+	installCmd.AddCommand(customCmd)
 
-	for feature, description := range features {
-		InstallCmd.AddCommand(&cobra.Command{
+	for feature, description := range installableFeatures {
+		installCmd.AddCommand(&cobra.Command{
 			Use:   feature,
 			Short: description,
-			Run:   install(feature),
+			RunE:  installFeature(feature),
 		})
 	}
 }

cmd/feature/list.go

@@ -0,0 +1,56 @@
+package feature
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/kloudkit/ws-cli/internals/features"
+	"github.com/kloudkit/ws-cli/internals/styles"
+	"github.com/spf13/cobra"
+)
+
+var listCmd = &cobra.Command{
+	Use:     "list",
+	Short:   "List available features that can be installed",
+	Aliases: []string{"ls"},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		featuresDir, _ := cmd.Flags().GetString("root")
+
+		availableFeatures, err := features.ListFeatures(featuresDir)
+		if err != nil {
+			return fmt.Errorf("failed to list features: %w", err)
+		}
+
+		if len(availableFeatures) == 0 {
+			fmt.Fprintln(cmd.OutOrStdout(), styles.Warning().Render("No features found"))
+			return nil
+		}
+
+		fmt.Fprintf(
+			cmd.OutOrStdout(),
+			"\n%s\n\n",
+			styles.InfoBadge().Render(fmt.Sprintf("%d FEATURES AVAILABLE", len(availableFeatures))),
+		)
+
+		featuresTable := styles.Table("NAME", "DESCRIPTION", "OPTIONS")
+
+		for _, feature := range availableFeatures {
+			var options string
+			if len(feature.Vars) > 0 {
+				var styledVars []string
+				for _, v := range feature.Vars {
+					styledVars = append(styledVars, styles.Key().UnsetBold().Render(v))
+				}
+				options = strings.Join(styledVars, ", ")
+			} else {
+				options = styles.Muted().Render("-")
+			}
+
+			featuresTable.Row(feature.Name, feature.Description, options)
+		}
+
+		fmt.Fprintln(cmd.OutOrStdout(), featuresTable.String())
+
+		return nil
+	},
+}

cmd/info/env.go

@@ -12,36 +12,29 @@ import (
 )
 
 func showEnvironment(writer io.Writer) {
-	fmt.Fprintln(writer, styles.Header().Render("Environment Variables"))
-
-	var envVars [][]string
-	for key, value := range env.GetAll() {
+	allVars := env.GetAll()
+	var wsVars [][]string
+	for key, value := range allVars {
 		if strings.HasPrefix(key, "WS_") {
-			envVars = append(envVars, []string{key, value})
+			wsVars = append(wsVars, []string{key, value})
 		}
 	}
 
-	if len(envVars) == 0 {
-		fmt.Fprintln(writer, styles.Warning().Render("  No environment variables found"))
-		return
-	}
+	fmt.Fprintf(writer, "\n%s\n\n", styles.InfoBadge().Render(fmt.Sprintf("%d WORKSPACE VARIABLES", len(wsVars))))
 
-	sort.Slice(envVars, func(i, j int) bool {
-		return envVars[i][0] < envVars[j][0]
+	sort.Slice(wsVars, func(i, j int) bool {
+		return wsVars[i][0] < wsVars[j][0]
 	})
 
-	t := styles.Table("Variable", "Value").
-		Rows(envVars...)
-
-	fmt.Fprintln(writer)
-	fmt.Fprintln(writer, t.Render())
+	fmt.Fprintf(writer, "%s\n\n", styles.Table().Rows(wsVars...).Render())
 }
 
 var envCmd = &cobra.Command{
 	Use:   "env",
 	Short: "Display effective workspace environment variables",
-	Run: func(cmd *cobra.Command, args []string) {
+	RunE: func(cmd *cobra.Command, args []string) error {
 		showEnvironment(cmd.OutOrStdout())
+		return nil
 	},
 }
 

cmd/info/extensions.go

@@ -30,20 +30,24 @@ func fetchExtensions() [][]string {
 }
 
 func showExtensions(writer io.Writer) {
-	fmt.Fprintln(writer, styles.Header().Render("Extensions"))
+	extensions := fetchExtensions()
+
+	fmt.Fprintf(writer, "\n%s\n\n", styles.InfoBadge().Render(fmt.Sprintf("%d EXTENSIONS", len(extensions))))
+
 	fmt.Fprintln(writer)
 
 	t := styles.Table("Name", "Version").
-		Rows(fetchExtensions()...)
+		Rows(extensions...)
 
 	fmt.Fprintln(writer, t.Render())
 }
 
 var extensionsCmd = &cobra.Command{
 	Use:   "extensions",
 	Short: "Display installed extensions",
-	Run: func(cmd *cobra.Command, args []string) {
+	RunE: func(cmd *cobra.Command, args []string) error {
 		showExtensions(cmd.OutOrStdout())
+		return nil
 	},
 }
 

cmd/info/info.go

@@ -44,15 +44,15 @@ func readJson(content map[string]any, key string) string {
 func showVersion(writer io.Writer) {
 	content := readJsonFile()
 
-	fmt.Fprintln(writer, styles.Header().Render("Versions"))
+	fmt.Fprintf(writer, "\n%s\n\n", styles.InfoBadge().Render("VERSIONS"))
+
 	fmt.Fprintln(writer)
 
-	t := styles.Table("", "Value").
-		Rows(
-			[]string{"workspace", readJson(content, "version")},
-			[]string{"ws-cli", Version},
-			[]string{"VSCode", readJson(content, "vscode.version")},
-		)
+	t := styles.Table().Rows(
+		[]string{"workspace", readJson(content, "version")},
+		[]string{"ws-cli", Version},
+		[]string{"VSCode", readJson(content, "vscode.version")},
+	)
 
 	fmt.Fprintln(writer, t.Render())
 }

cmd/info/uptime.go

@@ -52,25 +52,38 @@ func humanizeDuration(duration time.Duration) string {
 }
 
 func showUptime(writer io.Writer) {
-	started, running, _ := readStartup()
+	started, running, err := readStartup()
 
-	fmt.Fprintln(writer, styles.Header().Render("Uptime"))
-	fmt.Fprintln(writer)
+	if err != nil {
+		fmt.Fprintf(writer, "%s\n\n", styles.WarningBadge().Render("WARNING"))
+		fmt.Fprintf(writer, "%s\n", styles.Warning().Render("Could not read workspace startup time"))
+		return
+	}
+
+	var statusBadge string
+	if running.Hours() < 1 {
+		statusBadge = styles.InfoBadge().Render("RECENTLY STARTED")
+	} else if running.Hours() < 36 {
+		statusBadge = styles.SuccessBadge().Render("ACTIVE")
+	} else {
+		statusBadge = styles.Highlighted().Render("LONG RUNNING")
+	}
+	fmt.Fprintf(writer, "\n%s\n\n", statusBadge)
 
-	t := styles.Table("", "Value").
-		Rows(
-			[]string{"started", started.String()},
-			[]string{"running", humanizeDuration(running)},
-		)
+	t := styles.Table().Rows(
+		[]string{"Started at", styles.Code().Render(started.Format("2006-01-02 15:04:05 MST"))},
+		[]string{"Running for", styles.Value().Render(humanizeDuration(running))},
+	)
 
-	fmt.Fprintln(writer, t.Render())
+	fmt.Fprintf(writer, "%s\n\n", t.Render())
 }
 
 var uptimeCmd = &cobra.Command{
 	Use:   "uptime",
 	Short: "Display the workspace uptime",
-	Run: func(cmd *cobra.Command, args []string) {
+	RunE: func(cmd *cobra.Command, args []string) error {
 		showUptime(cmd.OutOrStdout())
+		return nil
 	},
 }