🎨 Add colors

bdsoha · bdsoha · commit 5a784ecebd4f · 2025-08-28T10:38:31.000+03:00
Closes kloudkit/ws-meta#43
diff --git a/cmd/feature/install/install.go b/cmd/feature/install/install.go
@@ -9,6 +9,7 @@ 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"
 )
 
@@ -60,7 +61,7 @@ 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", styles.Error().Render(fmt.Sprintf("Error: %v", err)))
 		os.Exit(1)
 	}
 }
@@ -69,7 +70,7 @@ 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", styles.Error().Render(fmt.Sprintf("Error: The feature path [%s] could not be found", feature)))
 		os.Exit(1)
 	}
 
diff --git a/cmd/info/env.go b/cmd/info/env.go
@@ -12,29 +12,21 @@ 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{
diff --git a/cmd/info/extensions.go b/cmd/info/extensions.go
@@ -30,11 +30,14 @@ func fetchExtensions() [][]string {
 }
 
 func showExtensions(writer io.Writer) {
-	fmt.Fprintln(writer, styles.Header().Render("Extensions"))
+	extensions := fetchExtensions()
+
+	fmt.Fprintf(writer, "\n%s\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())
 }
diff --git a/cmd/info/info.go b/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", 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())
 }
diff --git a/cmd/info/uptime.go b/cmd/info/uptime.go
@@ -52,18 +52,30 @@ 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", 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", 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{
diff --git a/cmd/logs/logs.go b/cmd/logs/logs.go
@@ -22,13 +22,19 @@ func execute(cmd *cobra.Command, args []string) {
 	level, _ := cmd.Flags().GetString("level")
 
 	if level != "" && level != "info" && level != "warn" && level != "error" && level != "debug" {
-		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render("Invalid log level. Must be one of: debug, info, warn, error"))
+		fmt.Fprintf(cmd.ErrOrStderr(), "%s\n\n", styles.ErrorBadge().Render("ERROR"))
+		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render("Invalid log level. Must be one of:"))
+		fmt.Fprintf(cmd.ErrOrStderr(), "  %s %s\n", styles.Code().Render("debug"), styles.Muted().Render("- Debug information"))
+		fmt.Fprintf(cmd.ErrOrStderr(), "  %s %s\n", styles.Code().Render("info"), styles.Muted().Render("- General information"))
+		fmt.Fprintf(cmd.ErrOrStderr(), "  %s %s\n", styles.Code().Render("warn"), styles.Muted().Render("- Warning messages"))
+		fmt.Fprintf(cmd.ErrOrStderr(), "  %s %s\n", styles.Code().Render("error"), styles.Muted().Render("- Error messages only"))
 		os.Exit(1)
 	}
 
 	reader, err := logger.NewReader(tail, level)
 	if err != nil {
-		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render(fmt.Sprintf("Error: %s", err)))
+		fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.ErrorBadge().Render("ERROR"))
+		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render(fmt.Sprintf("Failed to initialize log reader: %s", err)))
 		os.Exit(1)
 	}
 
@@ -39,6 +45,7 @@ func execute(cmd *cobra.Command, args []string) {
 	}
 
 	if err != nil {
+		fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.ErrorBadge().Render("ERROR"))
 		fmt.Fprintln(cmd.ErrOrStderr(), styles.Error().Render(fmt.Sprintf("Error reading logs: %s", err)))
 		os.Exit(1)
 	}
diff --git a/cmd/root.go b/cmd/root.go
@@ -35,14 +35,17 @@ var versionCmd = &cobra.Command{
 
 func Execute() {
 	if err := rootCmd.Execute(); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%s\n", styles.Error().Render(fmt.Sprintf("Error: %v", err)))
 		os.Exit(1)
 	}
 }
 
 func init() {
 	rootCmd.PersistentFlags().BoolVar(&noColor, "no-color", false, "Disable color output")
 
+	rootCmd.SetHelpTemplate(styles.HelpTemplate())
+	rootCmd.SetUsageTemplate(styles.UsageTemplate())
+
 	cobra.OnInitialize(func() {
 		if _, exists := os.LookupEnv("WS_LOGGING_NO_COLOR"); exists {
 			styles.ColorEnabled = false
diff --git a/cmd/serve/current.go b/cmd/serve/current.go
@@ -1,9 +1,11 @@
 package serve
 
 import (
+	"fmt"
 	"os"
 
 	"github.com/kloudkit/ws-cli/internals/server"
+	"github.com/kloudkit/ws-cli/internals/styles"
 	"github.com/spf13/cobra"
 )
 
@@ -21,12 +23,12 @@ var currentCmd = &cobra.Command{
 
 		currentDir, err := os.Getwd()
 		if err != nil {
-			cmd.PrintErrf("Error getting current directory: %v\n", err)
+			fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.Error().Render(fmt.Sprintf("Error getting current directory: %v", err)))
 			os.Exit(1)
 		}
 
 		if err := server.ServeDirectory(config, currentDir, "current directory"); err != nil {
-			cmd.PrintErrf("Error starting server: %v\n", err)
+			fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.Error().Render(fmt.Sprintf("Error starting server: %v", err)))
 			os.Exit(1)
 		}
 	},
diff --git a/cmd/serve/font.go b/cmd/serve/font.go
@@ -1,9 +1,11 @@
 package serve
 
 import (
+	"fmt"
 	"os"
 
 	"github.com/kloudkit/ws-cli/internals/server"
+	"github.com/kloudkit/ws-cli/internals/styles"
 	"github.com/spf13/cobra"
 )
 
@@ -20,7 +22,7 @@ var fontCmd = &cobra.Command{
 		}
 
 		if err := server.ServeDirectory(config, "/usr/share/fonts/", "fonts"); err != nil {
-			cmd.PrintErrf("Error starting server: %v\n", err)
+			fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.Error().Render(fmt.Sprintf("Error starting server: %v", err)))
 			os.Exit(1)
 		}
 	},
diff --git a/cmd/template/apply.go b/cmd/template/apply.go
@@ -28,9 +28,11 @@ func runApply(cmd *cobra.Command, args []string) error {
 	config, _ := template.GetTemplate(templateName)
 	sourcePath := template.SupportedTemplates[templateName].SourcePath
 
-	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Success().Render("Template applied successfully:"))
-	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Key().Render("Source:"), sourcePath)
-	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s/%s\n", styles.Key().Render("Target:"), targetPath, config.OutputName)
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", styles.SuccessBadge().Render("SUCCESS"))
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", styles.Success().Render("Template applied successfully"))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Key().Render("Source:"), styles.Code().Render(sourcePath))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Key().Render("Target:"), styles.Code().Render(fmt.Sprintf("%s/%s", targetPath, config.OutputName)))
+	fmt.Fprintf(cmd.OutOrStdout(), "\n%s\n", styles.Muted().Render("💡 Use 'ws-cli template show --local "+templateName+"' to view the applied template"))
 
 	return nil
 }
diff --git a/cmd/template/list.go b/cmd/template/list.go
@@ -2,6 +2,7 @@ package template
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/kloudkit/ws-cli/internals/path"
 	"github.com/kloudkit/ws-cli/internals/styles"
@@ -20,20 +21,30 @@ func runList(cmd *cobra.Command, args []string) error {
 	templates := template.SupportedTemplates
 	names := template.GetTemplateNames()
 
+	fmt.Fprintf(cmd.OutOrStdout(), "\n%s\n\n", styles.SuccessBadge().Render(fmt.Sprintf("%d TEMPLATES AVAILABLE", len(names))))
+
 	listItems := make([]any, len(names))
 	for i, name := range names {
 		config := templates[name]
 		resolvedPath := path.ResolveConfigPath(config.SourcePath)
 		location := styles.Muted().Render(fmt.Sprintf("(%s)", path.ShortenHomePath(resolvedPath)))
-		listItems[i] = fmt.Sprintf("%s %s", styles.Key().Render(name), location)
+
+		localIndicator := ""
+		if _, err := os.Stat(config.OutputName); err == nil {
+			localIndicator = styles.InfoBadge().Render("APPLIED")
+		}
+
+		listItems[i] = fmt.Sprintf("%s %s %s", styles.Key().Render(name), location, localIndicator)
 	}
 
 	l := styles.List(listItems...)
 
-	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", styles.Success().Render("Available Templates"))
 	fmt.Fprintf(cmd.OutOrStdout(), "%s\n\n", l.String())
-	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Muted().Render("Use 'ws-cli template apply <name>' to apply a template"))
-	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Muted().Render("Use 'ws-cli template show <name>' to view template contents"))
+
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Muted().Render("🚀 Quick actions:"))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Code().Render("ws-cli template apply <name>"), styles.Muted().Render("- Apply a template"))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Code().Render("ws-cli template show <name>"), styles.Muted().Render("- View template contents"))
+	fmt.Fprintf(cmd.OutOrStdout(), "  %s %s\n", styles.Code().Render("ws-cli template show --local <name>"), styles.Muted().Render("- View applied template"))
 
 	return nil
 }
diff --git a/cmd/template/show.go b/cmd/template/show.go
@@ -14,18 +14,12 @@ var showCmd = &cobra.Command{
 	Short: "Display the contents of a configuration template",
 	Long: fmt.Sprintf(`Display the contents of a configuration template.
 
-Available templates: %s`, strings.Join(template.GetTemplateNames(), ", ")),
+  Available templates: %s`, strings.Join(template.GetTemplateNames(), ", ")),
 	Args:              cobra.ExactArgs(1),
 	ValidArgsFunction: templateCompletion,
 	RunE:              runShow,
 }
 
-func init() {
-	showCmd.Flags().Bool("local", false, "Show the local version of the template (if applied)")
-
-	TemplateCmd.AddCommand(showCmd)
-}
-
 func runShow(cmd *cobra.Command, args []string) error {
 	templateName := args[0]
 	local, _ := cmd.Flags().GetBool("local")
@@ -35,21 +29,19 @@ func runShow(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	if styles.ColorEnabled {
-		if local {
-			fmt.Fprintf(cmd.OutOrStdout(), "%sLocal template '%s':%s\n\n", styles.ColorHeader, templateName, styles.ColorText)
-		} else {
-			fmt.Fprintf(cmd.OutOrStdout(), "%sTemplate '%s':%s\n\n", styles.ColorHeader, templateName, styles.ColorText)
-		}
-		fmt.Fprintf(cmd.OutOrStdout(), "%s%s%s\n", styles.ColorMuted, content, styles.ColorText)
-	} else {
-		if local {
-			fmt.Fprintf(cmd.OutOrStdout(), "Local template '%s':\n\n", templateName)
-		} else {
-			fmt.Fprintf(cmd.OutOrStdout(), "Template '%s':\n\n", templateName)
-		}
-		fmt.Fprintf(cmd.OutOrStdout(), "%s\n", content)
+	headerText := "Template"
+	if local {
+		headerText = "Local Template"
 	}
 
+	fmt.Fprintf(cmd.OutOrStdout(), "\n%s\n\n", styles.SuccessBadge().Render(fmt.Sprintf("%s '%s'", headerText, templateName)))
+	fmt.Fprintf(cmd.OutOrStdout(), "%s\n", styles.Code().MarginLeft(2).Render(content))
+
 	return nil
 }
+
+func init() {
+	showCmd.Flags().Bool("local", false, "Show the local version of the template (if applied)")
+
+	TemplateCmd.AddCommand(showCmd)
+}
diff --git a/internals/styles/colors.go b/internals/styles/colors.go
@@ -16,4 +16,13 @@ var (
 	ColorAccent  = frappe.Teal().Hex
 	ColorHeader  = frappe.Mauve().Hex
 	ColorBorder  = frappe.Surface2().Hex
+
+	BgSuccess = frappe.Green().Hex
+	BgWarning = frappe.Yellow().Hex
+	BgError   = frappe.Red().Hex
+	BgInfo    = frappe.Blue().Hex
+	BgMuted   = frappe.Surface0().Hex
+	BgAccent  = frappe.Surface1().Hex
+
+	ColorBase = frappe.Base().Hex
 )
diff --git a/internals/styles/help.go b/internals/styles/help.go
diff --git a/internals/styles/styles.go b/internals/styles/styles.go

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ import (`
`9`	`9`
`10`	`10`	`"github.com/apenella/go-ansible/v2/pkg/execute"`
`11`	`11`	`"github.com/apenella/go-ansible/v2/pkg/playbook"`
	`12`	`+ "github.com/kloudkit/ws-cli/internals/styles"`
`12`	`13`	`"github.com/spf13/cobra"`
`13`	`14`	`)`
`14`	`15`
`@@ -60,7 +61,7 @@ func runPlay(feature string, vars map[string]interface{}, errorOut io.Writer) {`
`60`	`61`	`err := exec.Execute(context.Background())`
`61`	`62`
`62`	`63`	`if err != nil {`
`63`		`- fmt.Fprintln(errorOut, err)`
	`64`	`+ fmt.Fprintf(errorOut, "%s\n", styles.Error().Render(fmt.Sprintf("Error: %v", err)))`
`64`	`65`	`os.Exit(1)`
`65`	`66`	`}`
`66`	`67`	`}`
`@@ -69,7 +70,7 @@ func getFeaturePath(root string, feature string, errorOut io.Writer) string {`
`69`	`70`	`feature = filepath.Join(root, feature+".yaml")`
`70`	`71`
`71`	`72`	`if _, err := os.Stat(feature); os.IsNotExist(err) {`
`72`		`- fmt.Fprintf(errorOut, "ERROR: The feature path [%s] could not be found.\n", feature)`
	`73`	`+ fmt.Fprintf(errorOut, "%s\n", styles.Error().Render(fmt.Sprintf("Error: The feature path [%s] could not be found", feature)))`
`73`	`74`	`os.Exit(1)`
`74`	`75`	`}`
`75`	`76`
Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,14 @@ func fetchExtensions() [][]string {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`func showExtensions(writer io.Writer) {`
`33`		`- fmt.Fprintln(writer, styles.Header().Render("Extensions"))`
	`33`	`+ extensions := fetchExtensions()`
	`34`	`+`
	`35`	`+ fmt.Fprintf(writer, "\n%s\n", styles.InfoBadge().Render(fmt.Sprintf("%d Extensions", len(extensions))))`
	`36`	`+`
`34`	`37`	`fmt.Fprintln(writer)`
`35`	`38`
`36`	`39`	`t := styles.Table("Name", "Version").`
`37`		`- Rows(fetchExtensions()...)`
	`40`	`+ Rows(extensions...)`
`38`	`41`
`39`	`42`	`fmt.Fprintln(writer, t.Render())`
`40`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`	`1`	`package serve`
`2`	`2`
`3`	`3`	`import (`
	`4`	`+ "fmt"`
`4`	`5`	`"os"`
`5`	`6`
`6`	`7`	`"github.com/kloudkit/ws-cli/internals/server"`
	`8`	`+ "github.com/kloudkit/ws-cli/internals/styles"`
`7`	`9`	`"github.com/spf13/cobra"`
`8`	`10`	`)`
`9`	`11`
`@@ -20,7 +22,7 @@ var fontCmd = &cobra.Command{`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`if err := server.ServeDirectory(config, "/usr/share/fonts/", "fonts"); err != nil {`
`23`		`- cmd.PrintErrf("Error starting server: %v\n", err)`
	`25`	`+ fmt.Fprintf(cmd.ErrOrStderr(), "%s\n", styles.Error().Render(fmt.Sprintf("Error starting server: %v", err)))`
`24`	`26`	`os.Exit(1)`
`25`	`27`	`}`
`26`	`28`	`},`