Fixes

ai/agent.go

@@ -185,13 +185,13 @@ func (am *AgentManager) Close() error {
 }
 
 var defaultConfig AgentConfig = AgentConfig{
-	Type:          AgentTypeClaude,
-	Model:         "claude-haiku-4-5",
-	MaxTokens:     10000,
-	MaxConcurrent: 4,
-	Debug:         false,
-	Verbose:       false,
-	// Temperature:   0.2,
+	Type:            AgentTypeClaude,
+	Model:           "claude-haiku-4-5",
+	MaxTokens:       10000,
+	MaxConcurrent:   4,
+	Debug:           false,
+	Verbose:         false,
+	Temperature:     0.2,
 	StrictMCPConfig: true,
 	CacheTTL:        24 * time.Hour, // Default 24 hour TTL
 	NoCache:         false,

api/human.go

@@ -48,30 +48,30 @@ func Human(content any, styles ...string) Text {
 	if content == nil {
 		return Text{}
 	}
+
+	style := uniqueStyles("", styles...)
 	switch t := content.(type) {
 
 	case Text:
 		return t
 	case Textable:
-		return Text{}.Add(t)
+		return Text{}.Append(t, styles...)
 	case time.Time:
+		if t.IsZero() {
+			return Text{}
+		}
 		if t.Truncate(time.Hour * 24).Equal(t) {
 			return Text{
 				Content: t.Format("2006-01-02"),
-				Style:   strings.Join(append(styles, "date"), " "),
-			}
+			}.Styles(style, "date")
 		}
 		// Only omit timezone if it's UTC
 		if t.Location() == time.UTC {
 			return Text{
-				Content: t.Format("2006-01-02 15:04:05"),
-				Style:   strings.Join(append(styles, "date"), " "),
-			}
+				Content: t.Format("2006-01-02T15:04:05Z")}.Styles(style, "date")
 		}
 		return Text{
-			Content: t.Format(time.RFC3339),
-			Style:   strings.Join(append(styles, "date"), " "),
-		}
+			Content: t.Format(time.RFC3339)}.Styles(style, "date")
 	case *time.Time:
 		if t == nil {
 			return Text{}
@@ -92,8 +92,7 @@ func Human(content any, styles ...string) Text {
 		}
 		return Text{
 			Content: v,
-			Style:   strings.Join(append(styles, "duration"), " "),
-		}
+		}.Styles(style, "duration")
 	case *time.Duration:
 		if t == nil {
 			return Text{}
@@ -108,8 +107,7 @@ func Human(content any, styles ...string) Text {
 	case float32, float64:
 		return Text{
 			Content: fmt.Sprintf("%.2f", t),
-			Style:   strings.Join(append(styles, "number"), " "),
-		}
+		}.Styles(style, "number")
 
 	case bool:
 		if t {
@@ -119,7 +117,7 @@ func Human(content any, styles ...string) Text {
 		}
 	}
 
-	return Text{Content: fmt.Sprintf("%v", content), Style: strings.Join(styles, " ")}
+	return Text{Content: fmt.Sprintf("%v", content), Style: style}
 }
 
 func HumanNumber(value int64, styles ...string) Text {

api/human_test.go

@@ -19,7 +19,7 @@ func TestHuman(t *testing.T) {
 		{input: 123345633, expected: "123M"},
 		{input: 67.89, expected: "67.89"},
 		{input: fmt.Sprintf("(%v in, %v out)", Human(5403200), Human(9003200)), expected: "(5.4M in, 9M out)"},
-		{input: time.Date(2023, 10, 5, 14, 30, 0, 0, time.UTC), expected: "2023-10-05 14:30:00"},
+		{input: time.Date(2023, 10, 5, 14, 30, 0, 0, time.UTC), expected: "2023-10-05T14:30:00Z"},
 		{input: time.Date(2023, 10, 5, 0, 0, 0, 0, time.UTC), expected: "2023-10-05"},
 
 		{input: Text{Content: "Preformatted Text"}, expected: "Preformatted Text"},

api/meta.go

@@ -392,17 +392,20 @@ func (tv TypedValue) Visit(visitor VisitorFunc) bool {
 	return true
 }
 
-func TryTypedValue(o any) *TypedValue {
+type TypeOptions struct {
+	SkipTable bool
+	SkipTree  bool
+}
+
+func TryTypedValue(o any, opts ...TypeOptions) *TypedValue {
+
 	switch v := o.(type) {
 	case *PrettyData:
 		return &TypedValue{Textable: v}
-	// TextTable and TextTree must come before Textable since they implement Textable
 	case TextTable:
 		return &TypedValue{Table: &v}
 	case TextTree:
 		return &TypedValue{Tree: &v}
-	case Textable:
-		return &TypedValue{Textable: v}
 	case TextList:
 		return &TypedValue{Slice: &v}
 	case TextMap:
@@ -411,18 +414,41 @@ func TryTypedValue(o any) *TypedValue {
 		return &TypedValue{TypedMap: &v}
 	case TypedList:
 		return &TypedValue{TypedList: &v}
-	case TreeNode:
-		return &TypedValue{Tree: lo.ToPtr(NewTree(v))}
-	case TreeMixin:
-		return &TypedValue{Tree: lo.ToPtr(NewTree(v.Tree()))}
+	}
+
+	skipTable := false
+	skipTree := false
+	for _, opt := range opts {
+		skipTable = skipTable || opt.SkipTable
+		skipTree = skipTree || opt.SkipTree
+	}
+
+	if !skipTable {
+		switch v := o.(type) {
+		case []TableMixin:
+			return &TypedValue{Table: lo.ToPtr(NewTable(v))}
+		case []TableRowMixin2:
+			return &TypedValue{Table: lo.ToPtr(NewTableFromMixin(v))}
+		case []PrettyDataRow:
+			return &TypedValue{Table: lo.ToPtr(NewTableFromRows(v))}
+		}
+	}
+
+	if !skipTree {
+		switch v := o.(type) {
+		case TreeNode:
+			return &TypedValue{Tree: lo.ToPtr(NewTree(v))}
+		case TreeMixin:
+			return &TypedValue{Tree: lo.ToPtr(NewTree(v.Tree()))}
+		}
+	}
+
+	switch v := o.(type) {
 	case Pretty:
 		return &TypedValue{Textable: v.Pretty()}
-	case []TableMixin:
-		return &TypedValue{Table: lo.ToPtr(NewTable(v))}
-	case []TableRowMixin2:
-		return &TypedValue{Table: lo.ToPtr(NewTableFromMixin(v))}
-	case []PrettyDataRow:
-		return &TypedValue{Table: lo.ToPtr(NewTableFromRows(v))}
+	case Textable:
+		return &TypedValue{Textable: v}
+
 	}
 	return nil
 }

api/styles.go

@@ -105,7 +105,7 @@ func ResolveStyles(styles ...string) Class {
 				resolved.Font.Underline = false
 			}
 
-			if class == "line-through" || class == "strikethrough" {
+			if class == "line-through" || class == "strikethrough" || class == "text-strikethrough" {
 				resolved.Font.Strikethrough = true
 			}
 

api/text.go

@@ -214,13 +214,34 @@ func (t Text) AddIcon(icon Textable, styles ...string) Text {
 	return t.Add(icon)
 }
 
-func (t Text) Styles(classes ...string) Text {
-	if t.Style != "" {
-		// Append new classes to existing style
-		t.Style = t.Style + " " + strings.Join(classes, " ")
-	} else {
-		t.Style = strings.Join(classes, " ")
+func uniqueStyles(existing string, styles ...string) string {
+	styleSet := make(map[string]struct{})
+	if existing != "" {
+		for _, s := range strings.Split(existing, " ") {
+			styleSet[s] = struct{}{}
+		}
 	}
+	for _, style := range styles {
+		for _, s := range strings.Split(style, " ") {
+			if s != "" {
+				styleSet[s] = struct{}{}
+			}
+		}
+	}
+	uniq := ""
+	for s := range styleSet {
+		if uniq == "" {
+			uniq = s
+		} else {
+			uniq += " " + s
+		}
+	}
+
+	return uniq
+}
+
+func (t Text) Styles(classes ...string) Text {
+	t.Style = uniqueStyles(t.Style, classes...)
 	return t
 }
 

cobra_command.go

@@ -172,6 +172,7 @@
 		// Call the function
 		result, err := fn(optsValue.Interface().(T))
 		if err != nil {
+			logger.GetSlogLogger().WithSkipReportLevel(1).Errorf("Command %s failed: %v", name, err)
 			return err
 		}
 

exec/exec.go

@@ -583,7 +583,7 @@ func (p *Process) Run() *Process {
 	cmd.Stderr = p.captureOutput.GetStderrWriter()
 	cmd.Stdout = p.captureOutput.GetStdoutWriter()
 
-	p.log.Debugf(api.Text{}.Append("run", "text-muted").Append(icons.MinimalArrow, "text-muted").Space().Add(p.Short()).ANSI())
+	p.log.Tracef(api.Text{}.Append("run", "text-muted").Append(icons.MinimalArrow, "text-muted").Space().Add(p.Short()).ANSI())
 
 	now := time.Now()
 	p.Started = &now

flags.go

@@ -3,6 +3,7 @@ package clicky
 import (
 	"github.com/flanksource/commons/collections"
 	"github.com/flanksource/commons/logger"
+	"github.com/samber/lo"
 	"github.com/spf13/pflag"
 )
 
@@ -65,8 +66,16 @@ func BindAllFlags(flags *pflag.FlagSet, filters ...string) *AllFlags {
 		flags.BoolVar(&Flags.PDF, "pdf", false, "Output in PDF format")
 
 		// Display structure flags (additive with format)
-		flags.BoolVar(&Flags.Tree, "tree", false, "Display in tree structure (additive with format)")
-		flags.BoolVar(&Flags.Table, "table", false, "Display in table structure (additive with format)")
+		// Display structure flags (additive with format)
+		flags.BoolFunc("tree", "Display in tree structure (additive with format)", func(s string) error {
+			Flags.Tree = lo.ToPtr(s == "true")
+			return nil
+		})
+		flags.BoolFunc("table", "Display in table structure (additive with format), or false to disable tables",
+			func(b string) error {
+				Flags.Table = lo.ToPtr(b == "true")
+				return nil
+			})
 	}
 
 	return Flags

formatters/manager.go

@@ -208,9 +208,9 @@ func (f FormatManager) FormatWithOptions(options FormatOptions, data ...any) (st
 	// Handle display structure overrides (additive flags)
 	// Tree flag: For text formats, use tree visual; for structured formats, pass tree data through
 	// Table flag: Convert to table structure before applying format
-	if options.Tree {
+	if options.Tree != nil && *options.Tree {
 		return f.treeFormatter.Format(data...)
-	} else if options.Table {
+	} else if options.Table != nil && *options.Table {
 		logger.V(4).Infof("Applying table structure transformation before %s formatting", format)
 		// Convert data to table structure first, then apply the format
 		// For text-based formats, apply table formatting directly

formatters/options.go

@@ -3,6 +3,7 @@ package formatters
 import (
 	"flag"
 
+	"github.com/samber/lo"
 	"github.com/spf13/pflag"
 
 	"github.com/flanksource/clicky/api"
@@ -33,8 +34,8 @@ type FormatOptions struct {
 	PDF      bool `json:"pdf,omitempty"`
 
 	// Display structure flags (additive with format flags)
-	Tree  bool `json:"tree,omitempty"`  // Display in tree structure
-	Table bool `json:"table,omitempty"` // Display in table structure
+	Tree  *bool `json:"tree,omitempty"`  // Display in tree structure
+	Table *bool `json:"table,omitempty"` // Display in table structure
 
 	// Paging options
 	Page  int `json:"page,omitempty"`  // Current page (1-indexed)
@@ -44,6 +45,14 @@ type FormatOptions struct {
 	depth int // Hidden field for tracking nesting depth in recursive formatting
 }
 
+func (o FormatOptions) SkipTable() bool {
+	return (o.Table != nil && !*o.Table) || (o.Tree != nil && *o.Tree)
+}
+
+func (o FormatOptions) SkipTree() bool {
+	return (o.Tree != nil && !*o.Tree) || (o.Table != nil && *o.Table)
+}
+
 func MergeOptions(opts ...FormatOptions) FormatOptions {
 	merged := FormatOptions{}
 	for _, opt := range opts {
@@ -68,11 +77,11 @@ func MergeOptions(opts ...FormatOptions) FormatOptions {
 		if opt.Filter != "" {
 			merged.Filter = opt.Filter
 		}
-		if opt.Tree {
-			merged.Tree = true
+		if opt.Tree != nil {
+			merged.Tree = opt.Tree
 		}
-		if opt.Table {
-			merged.Table = true
+		if opt.Table != nil {
+			merged.Table = opt.Table
 		}
 		if opt.Page > 0 {
 			merged.Page = opt.Page
@@ -133,8 +142,15 @@ func BindFlags(flags *flag.FlagSet, options *FormatOptions) {
 	flags.BoolVar(&options.PDF, "pdf", false, "Output in PDF format")
 
 	// Display structure flags (additive with format)
-	flags.BoolVar(&options.Tree, "tree", false, "Display in tree structure (additive with format)")
-	flags.BoolVar(&options.Table, "table", false, "Display in table structure (additive with format)")
+	flags.BoolFunc("tree", "Display in tree structure (additive with format)", func(s string) error {
+		options.Tree = lo.ToPtr(s == "true")
+		return nil
+	})
+	flags.BoolFunc("table", "Display in table structure (additive with format), or false to disable tables",
+		func(b string) error {
+			options.Table = lo.ToPtr(b == "true")
+			return nil
+		})
 }
 
 // BindPFlags adds formatting flags to the provided pflag set (for cobra)
@@ -155,8 +171,15 @@ func BindPFlags(flags *pflag.FlagSet, options *FormatOptions) {
 	flags.BoolVar(&options.PDF, "pdf", false, "Output in PDF format")
 
 	// Display structure flags (additive with format)
-	flags.BoolVar(&options.Tree, "tree", false, "Display in tree structure (additive with format)")
-	flags.BoolVar(&options.Table, "table", false, "Display in table structure (additive with format)")
+	flags.BoolFunc("tree", "Display in tree structure (additive with format)", func(s string) error {
+		options.Tree = lo.ToPtr(s == "true")
+		return nil
+	})
+	flags.BoolFunc("table", "Display in table structure (additive with format), or false to disable tables",
+		func(b string) error {
+			options.Table = lo.ToPtr(b == "true")
+			return nil
+		})
 }
 
 // ResolveFormat resolves the output format from format-specific flags