Add endless-scrolling TUI table for interactive list commands

Co-authored-by: Isaac

Author: simonfaltum

cmd/root/io.go

@@ -49,6 +49,7 @@ func (f *outputFlag) initializeIO(ctx context.Context, cmd *cobra.Command) (cont
 
 	cmdIO := cmdio.NewIO(ctx, f.output, cmd.InOrStdin(), cmd.OutOrStdout(), cmd.ErrOrStderr(), headerTemplate, template)
 	ctx = cmdio.InContext(ctx, cmdIO)
+	ctx = cmdio.WithCommand(ctx, cmd)
 	cmd.SetContext(ctx)
 	return ctx, nil
 }

experimental/aitools/cmd/render.go

@@ -4,18 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"strings"
-	"text/tabwriter"
 
 	"github.com/databricks/cli/libs/tableview"
 	"github.com/databricks/databricks-sdk-go/service/sql"
 )
 
-const (
-	// maxColumnWidth is the maximum display width for any single column in static table output.
-	maxColumnWidth = 40
-)
-
 // extractColumns returns column names from the query result manifest.
 func extractColumns(manifest *sql.ResultManifest) []string {
 	if manifest == nil || manifest.Schema == nil {
@@ -53,42 +46,7 @@ func renderJSON(w io.Writer, columns []string, rows [][]string) error {
 
 // renderStaticTable writes query results as a formatted text table.
 func renderStaticTable(w io.Writer, columns []string, rows [][]string) error {
-	tw := tabwriter.NewWriter(w, 0, 4, 2, ' ', 0)
-
-	// Header row.
-	fmt.Fprintln(tw, strings.Join(columns, "\t"))
-
-	// Separator.
-	seps := make([]string, len(columns))
-	for i, col := range columns {
-		width := len(col)
-		for _, row := range rows {
-			if i < len(row) {
-				width = max(width, len(row[i]))
-			}
-		}
-		width = min(width, maxColumnWidth)
-		seps[i] = strings.Repeat("-", width)
-	}
-	fmt.Fprintln(tw, strings.Join(seps, "\t"))
-
-	// Data rows.
-	for _, row := range rows {
-		vals := make([]string, len(columns))
-		for i := range columns {
-			if i < len(row) {
-				vals[i] = row[i]
-			}
-		}
-		fmt.Fprintln(tw, strings.Join(vals, "\t"))
-	}
-
-	if err := tw.Flush(); err != nil {
-		return err
-	}
-
-	fmt.Fprintf(w, "\n%d rows\n", len(rows))
-	return nil
+	return tableview.RenderStaticTable(w, columns, rows)
 }
 
 // renderInteractiveTable displays query results in the interactive table browser.

libs/cmdio/context.go

@@ -0,0 +1,33 @@
+package cmdio
+
+import (
+	"context"
+
+	"github.com/spf13/cobra"
+)
+
+type cmdKeyType struct{}
+
+// WithCommand stores the cobra.Command in context.
+func WithCommand(ctx context.Context, cmd *cobra.Command) context.Context {
+	return context.WithValue(ctx, cmdKeyType{}, cmd)
+}
+
+// CommandFromContext retrieves the cobra.Command from context.
+func CommandFromContext(ctx context.Context) *cobra.Command {
+	cmd, _ := ctx.Value(cmdKeyType{}).(*cobra.Command)
+	return cmd
+}
+
+type maxItemsKeyType struct{}
+
+// WithMaxItems stores a max items limit in context.
+func WithMaxItems(ctx context.Context, n int) context.Context {
+	return context.WithValue(ctx, maxItemsKeyType{}, n)
+}
+
+// GetMaxItems retrieves the max items limit from context (0 = unlimited).
+func GetMaxItems(ctx context.Context) int {
+	n, _ := ctx.Value(maxItemsKeyType{}).(int)
+	return n
+}

libs/cmdio/render.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/databricks/cli/libs/diag"
 	"github.com/databricks/cli/libs/flags"
+	"github.com/databricks/cli/libs/tableview"
 	"github.com/databricks/databricks-sdk-go/listing"
 	"github.com/fatih/color"
 	"github.com/nwidger/jsoncolor"
@@ -265,6 +266,24 @@ func Render(ctx context.Context, v any) error {
 
 func RenderIterator[T any](ctx context.Context, i listing.Iterator[T]) error {
 	c := fromContext(ctx)
+
+	// Launch paginated TUI when interactive and text output.
+	if c.outputFormat == flags.OutputText && c.capabilities.SupportsPrompt() {
+		cmd := CommandFromContext(ctx)
+		var cfg *tableview.TableConfig
+		if cmd != nil {
+			cfg = tableview.GetConfig(cmd)
+		}
+		if cfg == nil {
+			cfg = tableview.AutoDetect(i)
+		}
+		if cfg != nil {
+			iter := tableview.WrapIterator(i, cfg.Columns)
+			maxItems := GetMaxItems(ctx)
+			return tableview.RunPaginated(ctx, c.out, cfg, iter, maxItems)
+		}
+	}
+
 	return renderWithTemplate(ctx, newIteratorRenderer(i), c.outputFormat, c.out, c.headerTemplate, c.template)
 }
 

libs/tableview/autodetect.go

@@ -0,0 +1,116 @@
+package tableview
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"unicode"
+
+	"github.com/databricks/databricks-sdk-go/listing"
+)
+
+const maxAutoColumns = 8
+
+var autoCache sync.Map // reflect.Type -> *TableConfig
+
+// AutoDetect creates a TableConfig by reflecting on the element type of the iterator.
+// It picks up to maxAutoColumns top-level scalar fields.
+// Returns nil if no suitable columns are found.
+func AutoDetect[T any](iter listing.Iterator[T]) *TableConfig {
+	var zero T
+	t := reflect.TypeOf(zero)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	if cached, ok := autoCache.Load(t); ok {
+		return cached.(*TableConfig)
+	}
+
+	cfg := autoDetectFromType(t)
+	if cfg != nil {
+		autoCache.Store(t, cfg)
+	}
+	return cfg
+}
+
+func autoDetectFromType(t reflect.Type) *TableConfig {
+	if t.Kind() != reflect.Struct {
+		return nil
+	}
+
+	var columns []ColumnDef
+	for i := range t.NumField() {
+		if len(columns) >= maxAutoColumns {
+			break
+		}
+		field := t.Field(i)
+		if !field.IsExported() || field.Anonymous {
+			continue
+		}
+		if !isScalarKind(field.Type.Kind()) {
+			continue
+		}
+
+		header := fieldHeader(field)
+		fieldIdx := i
+		columns = append(columns, ColumnDef{
+			Header: header,
+			Extract: func(v any) string {
+				val := reflect.ValueOf(v)
+				if val.Kind() == reflect.Ptr {
+					if val.IsNil() {
+						return ""
+					}
+					val = val.Elem()
+				}
+				f := val.Field(fieldIdx)
+				return fmt.Sprintf("%v", f.Interface())
+			},
+		})
+	}
+
+	if len(columns) == 0 {
+		return nil
+	}
+	return &TableConfig{Columns: columns}
+}
+
+func isScalarKind(k reflect.Kind) bool {
+	switch k {
+	case reflect.String, reflect.Bool,
+		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Float32, reflect.Float64:
+		return true
+	}
+	return false
+}
+
+// fieldHeader converts a struct field to a display header.
+// Uses the json tag if available, otherwise the field name.
+func fieldHeader(f reflect.StructField) string {
+	tag := f.Tag.Get("json")
+	if tag != "" {
+		name, _, _ := strings.Cut(tag, ",")
+		if name != "" && name != "-" {
+			return snakeToTitle(name)
+		}
+	}
+	return f.Name
+}
+
+func snakeToTitle(s string) string {
+	words := strings.Split(s, "_")
+	for i, w := range words {
+		if w == "id" {
+			words[i] = "ID"
+		} else if len(w) > 0 {
+			runes := []rune(w)
+			runes[0] = unicode.ToUpper(runes[0])
+			words[i] = string(runes)
+		}
+	}
+	return strings.Join(words, " ")
+}

libs/tableview/autodetect_test.go

@@ -0,0 +1,132 @@
+package tableview
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type scalarStruct struct {
+	Name    string  `json:"name"`
+	Age     int     `json:"age"`
+	Active  bool    `json:"is_active"`
+	Score   float64 `json:"score"`
+}
+
+type nestedStruct struct {
+	ID     string `json:"id"`
+	Config struct {
+		Key string
+	}
+	Label string `json:"label"`
+}
+
+type manyFieldsStruct struct {
+	F1  string `json:"f1"`
+	F2  string `json:"f2"`
+	F3  string `json:"f3"`
+	F4  string `json:"f4"`
+	F5  string `json:"f5"`
+	F6  string `json:"f6"`
+	F7  string `json:"f7"`
+	F8  string `json:"f8"`
+	F9  string `json:"f9"`
+	F10 string `json:"f10"`
+}
+
+type noExportedFields struct {
+	hidden string //nolint:unused
+}
+
+type jsonTagStruct struct {
+	WorkspaceID string `json:"workspace_id"`
+	DisplayName string `json:"display_name"`
+	NoTag       string
+}
+
+func TestAutoDetectScalarFields(t *testing.T) {
+	iter := &fakeIterator[scalarStruct]{items: []scalarStruct{{Name: "alice", Age: 30, Active: true, Score: 9.5}}}
+	cfg := AutoDetect[scalarStruct](iter)
+	require.NotNil(t, cfg)
+	assert.Len(t, cfg.Columns, 4)
+	assert.Equal(t, "Name", cfg.Columns[0].Header)
+	assert.Equal(t, "Age", cfg.Columns[1].Header)
+	assert.Equal(t, "Is Active", cfg.Columns[2].Header)
+	assert.Equal(t, "Score", cfg.Columns[3].Header)
+
+	val := scalarStruct{Name: "bob", Age: 25, Active: false, Score: 7.2}
+	assert.Equal(t, "bob", cfg.Columns[0].Extract(val))
+	assert.Equal(t, "25", cfg.Columns[1].Extract(val))
+	assert.Equal(t, "false", cfg.Columns[2].Extract(val))
+	assert.Equal(t, "7.2", cfg.Columns[3].Extract(val))
+}
+
+func TestAutoDetectSkipsNestedFields(t *testing.T) {
+	iter := &fakeIterator[nestedStruct]{items: []nestedStruct{{ID: "123", Label: "test"}}}
+	cfg := AutoDetect[nestedStruct](iter)
+	require.NotNil(t, cfg)
+	assert.Len(t, cfg.Columns, 2)
+	assert.Equal(t, "ID", cfg.Columns[0].Header)
+	assert.Equal(t, "Label", cfg.Columns[1].Header)
+}
+
+func TestAutoDetectPointerType(t *testing.T) {
+	iter := &fakeIterator[*scalarStruct]{items: []*scalarStruct{{Name: "ptr", Age: 1}}}
+	cfg := AutoDetect[*scalarStruct](iter)
+	require.NotNil(t, cfg)
+	assert.Len(t, cfg.Columns, 4)
+
+	val := &scalarStruct{Name: "ptr", Age: 1}
+	assert.Equal(t, "ptr", cfg.Columns[0].Extract(val))
+	assert.Equal(t, "1", cfg.Columns[1].Extract(val))
+}
+
+func TestAutoDetectCappedAtMaxColumns(t *testing.T) {
+	iter := &fakeIterator[manyFieldsStruct]{items: []manyFieldsStruct{{}}}
+	cfg := AutoDetect[manyFieldsStruct](iter)
+	require.NotNil(t, cfg)
+	assert.Len(t, cfg.Columns, maxAutoColumns)
+}
+
+func TestAutoDetectNoExportedFields(t *testing.T) {
+	iter := &fakeIterator[noExportedFields]{items: []noExportedFields{{}}}
+	cfg := AutoDetect[noExportedFields](iter)
+	assert.Nil(t, cfg)
+}
+
+func TestAutoDetectJsonTags(t *testing.T) {
+	iter := &fakeIterator[jsonTagStruct]{items: []jsonTagStruct{{}}}
+	cfg := AutoDetect[jsonTagStruct](iter)
+	require.NotNil(t, cfg)
+	assert.Equal(t, "Workspace ID", cfg.Columns[0].Header)
+	assert.Equal(t, "Display Name", cfg.Columns[1].Header)
+	assert.Equal(t, "NoTag", cfg.Columns[2].Header)
+}
+
+func TestAutoDetectCaching(t *testing.T) {
+	iter1 := &fakeIterator[scalarStruct]{items: []scalarStruct{{}}}
+	cfg1 := AutoDetect[scalarStruct](iter1)
+
+	iter2 := &fakeIterator[scalarStruct]{items: []scalarStruct{{}}}
+	cfg2 := AutoDetect[scalarStruct](iter2)
+
+	// Should return the same cached pointer.
+	assert.Same(t, cfg1, cfg2)
+}
+
+func TestSnakeToTitle(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"workspace_id", "Workspace ID"},
+		{"display_name", "Display Name"},
+		{"id", "ID"},
+		{"simple", "Simple"},
+		{"a_b_c", "A B C"},
+	}
+	for _, tt := range tests {
+		assert.Equal(t, tt.expected, snakeToTitle(tt.input))
+	}
+}