Add human-readable table output for CLI commands

Replace JSON output with formatted tables for better readability:
- Add format package with table rendering and color utilities
- Add global --output (-o) flag to choose table/json/wide formats
- Add --no-color flag with NO_COLOR env var support
- Convert clone list/status to table output
- Convert snapshot list to table output
- Convert instance status to table output
- Improve branch list and config list formatting

Default output is now human-readable tables. Use --output=json
or -o json for machine-readable JSON output (backwards compatible).

Author: claude

engine/cmd/cli/commands/branch/actions.go

@@ -13,10 +13,12 @@ import (
 	"text/template"
 	"time"
 
+	"github.com/fatih/color"
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands"
 	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands/config"
+	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands/format"
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/client/dblabapi/types"
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/models"
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/util"
@@ -116,18 +118,22 @@ func list(cliCtx *cli.Context) error {
 
 func formatBranchList(cliCtx *cli.Context, branches []string) string {
 	baseBranch := getBaseBranch(cliCtx)
+	cfg := format.FromContext(cliCtx)
 
 	s := strings.Builder{}
+	green := color.New(color.FgGreen, color.Bold).SprintFunc()
 
 	for _, branch := range branches {
-		var prefixStar = "  "
+		prefix := "  "
 
 		if baseBranch == branch {
-			prefixStar = "* "
-			branch = "\033[1;32m" + branch + "\033[0m"
+			prefix = "* "
+			if !cfg.NoColor {
+				branch = green(branch)
+			}
 		}
 
-		s.WriteString(prefixStar + branch + "\n")
+		s.WriteString(prefix + branch + "\n")
 	}
 
 	return s.String()

engine/cmd/cli/commands/clone/actions.go

@@ -19,6 +19,7 @@ import (
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands"
+	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands/format"
 	"gitlab.com/postgres-ai/database-lab/v3/internal/observer"
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/client/dblabapi/types"
 	"gitlab.com/postgres-ai/database-lab/v3/pkg/log"
@@ -49,12 +50,78 @@ func list(cliCtx *cli.Context) error {
 		return err
 	}
 
-	commandResponse, err := json.MarshalIndent(viewCloneList.Cloning.Clones, "", "    ")
+	cfg := format.FromContext(cliCtx)
+
+	if cfg.IsJSON() {
+		return outputJSON(cliCtx.App.Writer, viewCloneList.Cloning.Clones)
+	}
+
+	return printCloneList(cfg, viewCloneList.Cloning.Clones)
+}
+
+func printCloneList(cfg format.Config, clones []*models.CloneView) error {
+	if len(clones) == 0 {
+		_, err := fmt.Fprintln(cfg.Writer, "No clones found.")
+		return err
+	}
+
+	t := format.NewTable(cfg.Writer, cfg.NoColor)
+
+	if cfg.IsWide() {
+		t.SetHeaders("ID", "STATUS", "BRANCH", "SNAPSHOT", "SIZE", "DB", "PORT", "CREATED")
+	} else {
+		t.SetHeaders("ID", "STATUS", "BRANCH", "SNAPSHOT", "SIZE", "CREATED")
+	}
+
+	for _, clone := range clones {
+		snapshotID := ""
+		if clone.Snapshot != nil {
+			snapshotID = format.Truncate(clone.Snapshot.ID, 16)
+		}
+
+		created := ""
+		if clone.CreatedAt != nil {
+			created = format.FormatTime(clone.CreatedAt.Time)
+		}
+
+		status := format.FormatStatus(string(clone.Status.Code), cfg.NoColor)
+		size := format.FormatBytes(uint64(clone.Metadata.CloneDiffSize))
+
+		if cfg.IsWide() {
+			t.Append([]string{
+				clone.ID,
+				status,
+				clone.Branch,
+				snapshotID,
+				size,
+				clone.DB.DBName,
+				clone.DB.Port,
+				created,
+			})
+		} else {
+			t.Append([]string{
+				clone.ID,
+				status,
+				clone.Branch,
+				snapshotID,
+				size,
+				created,
+			})
+		}
+	}
+
+	t.Render()
+
+	return nil
+}
+
+func outputJSON(w io.Writer, v any) error {
+	data, err := json.MarshalIndent(v, "", "    ")
 	if err != nil {
 		return err
 	}
 
-	_, err = fmt.Fprintln(cliCtx.App.Writer, string(commandResponse))
+	_, err = fmt.Fprintln(w, string(data))
 
 	return err
 }
@@ -79,14 +146,65 @@ func status(cliCtx *cli.Context) error {
 		return err
 	}
 
-	commandResponse, err := json.MarshalIndent(cloneView, "", "    ")
-	if err != nil {
-		return err
+	cfg := format.FromContext(cliCtx)
+
+	if cfg.IsJSON() {
+		return outputJSON(cliCtx.App.Writer, cloneView)
 	}
 
-	_, err = fmt.Fprintln(cliCtx.App.Writer, string(commandResponse))
+	return printCloneStatus(cfg, cloneView)
+}
 
-	return err
+func printCloneStatus(cfg format.Config, clone *models.CloneView) error {
+	w := cfg.Writer
+
+	status := format.FormatStatus(string(clone.Status.Code), cfg.NoColor)
+
+	fmt.Fprintf(w, "ID:          %s\n", clone.ID)
+	fmt.Fprintf(w, "Status:      %s\n", status)
+
+	if clone.Status.Message != "" {
+		fmt.Fprintf(w, "Message:     %s\n", clone.Status.Message)
+	}
+
+	fmt.Fprintf(w, "Branch:      %s\n", clone.Branch)
+
+	if clone.Snapshot != nil {
+		fmt.Fprintf(w, "Snapshot:    %s\n", clone.Snapshot.ID)
+	}
+
+	fmt.Fprintf(w, "Protected:   %s\n", format.FormatBool(clone.Protected, cfg.NoColor))
+
+	if clone.CreatedAt != nil {
+		fmt.Fprintf(w, "Created:     %s (%s)\n", format.FormatTimeAbs(clone.CreatedAt.Time), format.FormatTime(clone.CreatedAt.Time))
+	}
+
+	if clone.DeleteAt != nil {
+		fmt.Fprintf(w, "Delete at:   %s\n", format.FormatTimeAbs(clone.DeleteAt.Time))
+	}
+
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Database:")
+	fmt.Fprintf(w, "  Host:      %s\n", clone.DB.Host)
+	fmt.Fprintf(w, "  Port:      %s\n", clone.DB.Port)
+	fmt.Fprintf(w, "  Username:  %s\n", clone.DB.Username)
+	fmt.Fprintf(w, "  Database:  %s\n", clone.DB.DBName)
+
+	if clone.DB.ConnStr != "" {
+		fmt.Fprintf(w, "  ConnStr:   %s\n", clone.DB.ConnStr)
+	}
+
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Metadata:")
+	fmt.Fprintf(w, "  Diff size:     %s\n", format.FormatBytes(uint64(clone.Metadata.CloneDiffSize)))
+	fmt.Fprintf(w, "  Logical size:  %s\n", format.FormatBytes(uint64(clone.Metadata.LogicalSize)))
+	fmt.Fprintf(w, "  Cloning time:  %.2fs\n", clone.Metadata.CloningTime)
+
+	if clone.Metadata.MaxIdleMinutes > 0 {
+		fmt.Fprintf(w, "  Max idle:      %d min\n", clone.Metadata.MaxIdleMinutes)
+	}
+
+	return nil
 }
 
 // create runs a request to create a new clone.

engine/cmd/cli/commands/config/actions.go

@@ -9,19 +9,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"sort"
-	"strings"
 
 	"github.com/urfave/cli/v2"
 
 	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands"
-)
-
-// headers of a config list.
-const (
-	envHeader      = "ENV "
-	urlHeader      = "URL"
-	fwServerHeader = "Forwarding server URL"
-	fwPortHeader   = "Forwarding local port"
+	"gitlab.com/postgres-ai/database-lab/v3/cmd/cli/commands/format"
 )
 
 // createEnvironment creates a new CLI environment.
@@ -126,73 +118,47 @@ func list() func(*cli.Context) error {
 			return commands.ToActionError(err)
 		}
 
+		if len(cfg.Environments) == 0 {
+			_, err = fmt.Fprintln(cliCtx.App.Writer, "No environments configured.")
+			return commands.ToActionError(err)
+		}
+
 		environmentNames := make([]string, 0, len(cfg.Environments))
-		maxNameLen := 0
-		maxURLLen := len(urlHeader)
-		maxFwServerLen := len(fwServerHeader)
 
 		for environmentName := range cfg.Environments {
 			environmentNames = append(environmentNames, environmentName)
-
-			nameLength := len(environmentName)
-			if maxNameLen < nameLength {
-				maxNameLen = nameLength
-			}
-
-			urlLength := len(cfg.Environments[environmentName].URL)
-			if maxURLLen < urlLength {
-				maxURLLen = urlLength
-			}
-
-			urlFwLength := len(cfg.Environments[environmentName].Forwarding.ServerURL)
-			if maxFwServerLen < urlFwLength {
-				maxFwServerLen = urlFwLength
-			}
 		}
 
 		sort.Strings(environmentNames)
 
-		listOutput := buildListOutput(cfg, environmentNames, maxNameLen, maxURLLen, maxFwServerLen)
+		fmtCfg := format.FromContext(cliCtx)
 
-		_, err = fmt.Fprintf(cliCtx.App.Writer, "Available CLI environments:\n%s", listOutput)
+		_, _ = fmt.Fprintln(cliCtx.App.Writer, "Available CLI environments:")
 
-		return commands.ToActionError(err)
-	}
-}
+		t := format.NewTable(cliCtx.App.Writer, fmtCfg.NoColor)
+		t.SetHeaders("", "ENV", "URL", "FORWARDING SERVER", "LOCAL PORT")
+
+		for _, envName := range environmentNames {
+			env := cfg.Environments[envName]
+			marker := ""
 
-func buildListOutput(cfg *CLIConfig, environmentNames []string, maxNameLen, maxURLLen, maxFwLen int) string {
-	// TODO(akartasov): Draw as a table.
-	const outputAlign = 2
-
-	s := strings.Builder{}
-
-	s.WriteString(envHeader)
-	s.WriteString(strings.Repeat(" ", maxNameLen+outputAlign))
-	s.WriteString(urlHeader)
-	s.WriteString(strings.Repeat(" ", maxURLLen-len(urlHeader)+outputAlign))
-	s.WriteString(fwServerHeader)
-	s.WriteString(strings.Repeat(" ", maxFwLen-len(fwServerHeader)+outputAlign))
-	s.WriteString(fwPortHeader)
-	s.WriteString("\n")
-
-	for _, environmentName := range environmentNames {
-		if environmentName == cfg.CurrentEnvironment {
-			s.WriteString("[*] ")
-		} else {
-			s.WriteString("[ ] ")
+			if envName == cfg.CurrentEnvironment {
+				marker = "*"
+			}
+
+			t.Append([]string{
+				marker,
+				envName,
+				env.URL,
+				env.Forwarding.ServerURL,
+				env.Forwarding.LocalPort,
+			})
 		}
 
-		s.WriteString(environmentName)
-		s.WriteString(strings.Repeat(" ", maxNameLen-len(environmentName)+outputAlign))
-		s.WriteString(cfg.Environments[environmentName].URL)
-		s.WriteString(strings.Repeat(" ", maxURLLen-len(cfg.Environments[environmentName].URL)+outputAlign))
-		s.WriteString(cfg.Environments[environmentName].Forwarding.ServerURL)
-		s.WriteString(strings.Repeat(" ", maxFwLen-len(cfg.Environments[environmentName].Forwarding.ServerURL)+outputAlign))
-		s.WriteString(cfg.Environments[environmentName].Forwarding.LocalPort)
-		s.WriteString("\n")
-	}
+		t.Render()
 
-	return s.String()
+		return nil
+	}
 }
 
 // switchEnvironment switches to another CLI environment.