remove unneccessary fmt.Sprintf's

satisfy linter
conversion from string cells to any cells in printer.Table
2026-08-24 22:04:18 +02:00 · 2026-07-07 06:43:34 +02:00 · 2026-07-07 06:37:21 +02:00 · 2026-07-07 06:30:07 +02:00 · 2026-07-07 06:29:40 +02:00 · 2026-07-07 05:29:31 +02:00
54 changed files with 1376 additions and 1405 deletions
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,110 +0,0 @@
-version: "2"
-
-linters:
-  enable:
-    - errcheck
-    - govet
-    - ineffassign
-    - staticcheck
-    - unused
-    - arangolint
-    - asasalint
-    - asciicheck
-    - bidichk
-    - bodyclose
-    - canonicalheader
-    - clickhouselint
-    - containedctx
-    #- contextcheck
-    - copyloopvar
-    #- cyclop
-    - decorder
-    - dogsled
-    - dupword
-    - durationcheck
-    - embeddedstructfieldcheck
-    - errchkjson
-    - errname
-    #- errorlint
-    - exhaustive
-    - exptostd
-    - fatcontext
-    - funcorder
-    #- funlen
-    - ginkgolinter
-    - gocheckcompilerdirectives
-    - gochecknoinits
-    - gochecksumtype
-    #- gocognit
-    - gocritic
-    #- gocyclo
-    #- godoclint
-    - goheader
-    - gomoddirectives
-    - gomodguard_v2
-    - goprintffuncname
-    #- gosec
-    - gosmopolitan
-    - grouper
-    - iface
-    - importas
-    - inamedparam
-    - interfacebloat
-    - intrange
-    - iotamixing
-    - lll
-    - loggercheck
-    - makezero
-    - misspell
-    - modernize
-    - nakedret
-    #- nestif
-    - nilerr
-    - nilnesserr
-    - nlreturn
-    - nonamedreturns
-    - nosprintfhostport
-    - paralleltest
-    - perfsprint
-    - prealloc
-    #- predeclared
-    - promlinter
-    - protogetter
-    - reassign
-    - recvcheck
-    #- revive
-    - rowserrcheck
-    - sloglint
-    - spancheck
-    - sqlclosecheck
-    - tagalign
-    - testableexamples
-    - testifylint
-    - testpackage
-    - thelper
-    - tparallel
-    - unconvert
-    - unparam
-    - unqueryvet
-    - usestdlibvars
-    - usetesting
-    - varnamelen
-    - wastedassign
-    - whitespace
-    - wsl_v5
-    - zerologlint
-
-  settings:
-    varnamelen:
-      ignore-names:
-        - err
-        - wg
-        - mu
-        - ts
-        - to
-        - es
-        - op
-        - fd
-        - id
-        - fn
-      
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -16,7 +16,6 @@ builds:
    goos:
      - linux
      - darwin
-    tool: "go1.26.4"

 changelog:
  sort: asc
--- a/.woodpecker/build.yaml
+++ b/.woodpecker/build.yaml
@@ -2,7 +2,7 @@ matrix:
  platform:
    - linux/amd64
  goversion:
-    - 1.26.4
+    - 1.25.8

 labels:
  platform: ${platform}
@@ -21,6 +21,6 @@ steps:
      event: [push,manual]
    image: golang:${goversion}
    commands:
-      - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin v2.12.2
+      - curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin v2.5.0
      - golangci-lint --version
      - golangci-lint run ./...
--- a/.woodpecker/release.yaml
+++ b/.woodpecker/release.yaml
@@ -6,8 +6,8 @@ labels:
 steps:
  goreleaser:
    image: goreleaser/goreleaser
-    # when:
-    #   event: [tag,manual]
+    when:
+      event: [tag,manual]
    environment:
      GITEA_TOKEN:
        from_secret: DEPLOY_TOKEN
--- a/4
+++ b/4
@@ -68,10 +68,10 @@ test: clean buildlocal
 testlint: test lint

 lint:
-	golangci-lint run --enable-only errcheck,govet,ineffassign,staticcheck,unused
+	golangci-lint run

 lint-full:
-	golangci-lint run --show-stats=false
+	golangci-lint run --enable-all --exclude-use-default --disable exhaustivestruct,exhaustruct,depguard,interfacer,deadcode,golint,structcheck,scopelint,varcheck,ifshort,maligned,nosnakecase,godot,funlen,gofumpt,cyclop,noctx,gochecknoglobals,paralleltest

 testfuzzy: clean
 	go test -fuzz ./... $(ARGS)
--- a/README.md
+++ b/README.md
@@ -536,6 +536,7 @@ index                       - manage indicies
  update                    - update an index
  delete                    - delete an index
  close                     - close an index
+  allocation                - explain index allocation
  fields                    - show info about field capabilities
  ilm                       - show ilm status
  alias                     - manage index aliases
@@ -563,7 +564,6 @@ search                      - search within an index
 shard                       - manage shards
  list                      - list shards
  show                      - show details about a shard
-  allocation                - explain shard allocation
 snapshot                    - manage snapshots
  list                      - list snapshots
  show                      - show details about a snapshot
--- a/TODO.md
+++ b/TODO.md
@@ -3,7 +3,13 @@

 - index show: add more details, see screenshots

+- add shard explain, aka:
+  get /_cluster/allocation/explain {"index":"yourindex", "primary": true, "shard":0}
+
+
 - add datastream support:
  https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-stream
  
  also exclude data stream backing indices from index ls
+  
+- table any2string
--- a/cmd/cluster_reroute.go
+++ b/cmd/cluster_reroute.go
@@ -177,6 +177,7 @@ func ClusterRerouteAllocatePrimary(conf *cfg.Config, stale bool) *cli.Command {
 	if stale {
 		name = "allocate-stale-primary"
 		usage = "allocate a stale primary shard to a node"
+
 	}

 	return &cli.Command{
--- a/cmd/completion.go
+++ b/cmd/completion.go
@@ -48,10 +48,8 @@ func complete(cmd *cli.Command, what int) {
 		return
 	}

-	var (
-		list []string
-		err  error
-	)
+	var list []string
+	var err error

 	switch what {
 	case Cindex:
--- a/cmd/ilm_forecast.go
+++ b/cmd/ilm_forecast.go
@@ -71,7 +71,7 @@ func IlmForecastList(conf *cfg.Config) *cli.Command {
 			},
 			&cli.StringFlag{
 				Name:        "within",
-				Usage:       "<duration> within which to forecast",
+				Usage:       "<duration> withing which to forecast",
 				Destination: &conf.Ilm.Within,
 				Aliases:     []string{"w"},
 			},
@@ -121,7 +121,7 @@ func IlmForecastShow(conf *cfg.Config) *cli.Command {
 			},
 			&cli.StringFlag{
 				Name:        "within",
-				Usage:       "duration within which to forecast",
+				Usage:       "duration withing which to forecast",
 				Destination: &conf.Ilm.Within,
 				Aliases:     []string{"w"},
 			},
--- a/cmd/index.go
+++ b/cmd/index.go
@@ -19,6 +19,7 @@ package cmd
 import (
 	"context"
 	"errors"
+	"fmt"

 	"codeberg.org/scip/esctl/pkg/cfg"
 	"codeberg.org/scip/esctl/pkg/es"
@@ -39,6 +40,7 @@ func Index(conf *cfg.Config) *cli.Command {
 			IndexCreate(conf, true),
 			IndexDelete(conf),
 			IndexClose(conf),
+			IndexAllocation(conf),
 			IndexFields(conf),
 			IndexIlm(conf),

@@ -94,6 +96,38 @@ func IndexList(conf *cfg.Config) *cli.Command {
 	}
 }

+func IndexAllocation(conf *cfg.Config) *cli.Command {
+	return &cli.Command{
+		Name:    "allocation",
+		Aliases: []string{"a"},
+		Usage:   "explain index allocation",
+
+		Flags: []cli.Flag{
+			&cli.IntFlag{
+				Name:        "shard",
+				Usage:       "shard number to explain for",
+				Destination: &conf.Shards,
+				Aliases:     []string{"s"},
+			},
+			&cli.BoolFlag{
+				Name:        "primary",
+				Usage:       "explain primary allocation (default true)",
+				Destination: &conf.Primary,
+				Aliases:     []string{"p"},
+			},
+		},
+
+		Action: func(ctx context.Context, cmd *cli.Command) error {
+			index := cmd.Args().Get(0)
+			if index == "" {
+				return errors.New("no index specified")
+			}
+
+			return es.IndexAllocation(conf, cmd.Args().Get(0))
+		},
+	}
+}
+
 func IndexShow(conf *cfg.Config) *cli.Command {
 	return &cli.Command{
 		Name:    "show",
@@ -162,7 +196,7 @@ Valid field mapping types: integer, text, date, keyword`,
 		Action: func(ctx context.Context, cmd *cli.Command) error {
 			args := cmd.Args()
 			if args.Len() == 0 {
-				return errors.New("no index specified")
+				return fmt.Errorf("no index specified")
 			}

 			mappings := args.Slice()[1:]
--- a/cmd/index_alias.go
+++ b/cmd/index_alias.go
@@ -38,8 +38,7 @@ func IndexAlias(conf *cfg.Config) *cli.Command {
 			IndexAliasDelete(conf),
 			IndexAliasRollover(conf),
 			// FIXME: implement IndexAliasAdd
-			// see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-update-aliases
-			// IndexAliasAdd(conf),
+			//IndexAliasAdd(conf), // see https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-update-aliases
 		},
 	}
 }
--- a/cmd/index_template.go
+++ b/cmd/index_template.go
@@ -19,6 +19,7 @@ package cmd
 import (
 	"context"
 	"errors"
+	"fmt"
 	"slices"

 	"codeberg.org/scip/esctl/pkg/cfg"
@@ -179,7 +180,7 @@ https://www.elastic.co/docs/reference/elasticsearch/index-settings
 		Action: func(ctx context.Context, cmd *cli.Command) error {
 			args := cmd.Args()
 			if args.Len() == 0 {
-				return errors.New("no name specified")
+				return fmt.Errorf("no name specified")
 			}

 			if conf.Mode != "" {
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -31,61 +31,9 @@ import (
 	"github.com/urfave/cli/v3"
 )

-const (
-	versionFmt = `esctl version: %s
-  build: %s
-  branch: %s
-  commit: %s
-  go version: %s
-  API Version: %s
-`
-
-	jsonPathUsage = `jsonPath usage:
-
-name.last          >> "Anderson"
-age                >> 37
-children           >> ["Sara","Alex","Jack"]
-children.#         >> 3
-children.1         >> "Alex"
-child*.2           >> "Jack"
-c?ildren.0         >> "Sara"
-fav\.movie         >> "Deer Hunter"
-friends.#.first    >> ["Dale","Roger","Jane"]
-friends.1.last     >> "Craig"
-
-You can also  query an array for  the first match by  using #(...), or
-find all matches  with #(...)#. Queries support the ==,  !=, <, <=, >,
->= comparison operators  and the simple pattern matching  % (like) and
-!% (not like) operators. Eg:
-
-friends.#(last=="Murphy").first    >> "Dale"
-friends.#(last=="Murphy")#.first   >> ["Dale","Jane"]
-friends.#(age>45)#.last            >> ["Craig","Murphy"]
-friends.#(first%"D*").last         >> "Murphy"
-friends.#(first!%"D*").last        >> "Craig"
-friends.#(nets.#(=="fb"))#.first   >> ["Dale","Roger"]
-
-To extract more than one field, use:
-
-{"ns":source.namespace_name,"time":source.@timestamp} >>
-
-{
-  "ns": "3f80316965c64405-275a75782e984bcc8d82",
-  "time": "2026-06-10T04:23:38.914080361+00:00"
-}
-{
-  "ns": "3f80316965c64405-f0e1dcef668e45bb9afd",
-  "time": "2026-06-10T09:39:00.554892542+00:00"
-}
-
-
-Documentation: https://github.com/tidwall/gjson/blob/master/SYNTAX.md`
-)
-
 func Finish(err error) int {
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "Error: ", err.Error())
-
 		return 1
 	}

@@ -179,7 +127,6 @@ func Main() int {
 					return nil, err
 				} else {
 					fmt.Println(cmd.UsageText)
-
 					return nil, nil
 				}
 			}
@@ -214,13 +161,53 @@ func Main() int {
 }

 func HelpJsonPath(conf *cfg.Config) *cli.Command {
+	msg := `jsonPath usage:
+
+name.last          >> "Anderson"
+age                >> 37
+children           >> ["Sara","Alex","Jack"]
+children.#         >> 3
+children.1         >> "Alex"
+child*.2           >> "Jack"
+c?ildren.0         >> "Sara"
+fav\.movie         >> "Deer Hunter"
+friends.#.first    >> ["Dale","Roger","Jane"]
+friends.1.last     >> "Craig"
+
+You can also  query an array for  the first match by  using #(...), or
+find all matches  with #(...)#. Queries support the ==,  !=, <, <=, >,
+>= comparison operators  and the simple pattern matching  % (like) and
+!% (not like) operators. Eg:
+
+friends.#(last=="Murphy").first    >> "Dale"
+friends.#(last=="Murphy")#.first   >> ["Dale","Jane"]
+friends.#(age>45)#.last            >> ["Craig","Murphy"]
+friends.#(first%"D*").last         >> "Murphy"
+friends.#(first!%"D*").last        >> "Craig"
+friends.#(nets.#(=="fb"))#.first   >> ["Dale","Roger"]
+
+To extract more than one field, use:
+
+{"ns":source.namespace_name,"time":source.@timestamp} >>
+
+{
+  "ns": "3f80316965c64405-275a75782e984bcc8d82",
+  "time": "2026-06-10T04:23:38.914080361+00:00"
+}
+{
+  "ns": "3f80316965c64405-f0e1dcef668e45bb9afd",
+  "time": "2026-06-10T09:39:00.554892542+00:00"
+}
+
+
+Documentation: https://github.com/tidwall/gjson/blob/master/SYNTAX.md`
+
 	return &cli.Command{
 		Name:  "help-jsonpath",
 		Usage: "show jsonpath help",

 		Action: func(ctx context.Context, cmd *cli.Command) error {
-			_, err := fmt.Println(jsonPathUsage)
-
+			_, err := fmt.Println(msg)
 			return err
 		},
 	}
@@ -232,9 +219,8 @@ func Version(conf *cfg.Config) *cli.Command {
 		Usage: "show esctl version information",

 		Action: func(ctx context.Context, cmd *cli.Command) error {
-			_, err := fmt.Printf(versionFmt,
+			_, err := fmt.Printf("esctl version: %s\n  build: %s\n  branch: %s\n  commit: %s\n  go version: %s\n  API Version: %s\n",
 				cfg.Version, cfg.BUILD, cfg.BRANCH, cfg.COMMIT, cfg.GOVERSION, cfg.APIVERSION)
-
 			return err
 		},
 	}
@@ -341,6 +327,7 @@ func HelpUsage(conf *cfg.Config) *cli.Command {
 			})
 		},
 	}
+
 }

 // copy of cmd.Walk() with the exception to skip hidden commands and its siblings
--- a/cmd/shards.go
+++ b/cmd/shards.go
@@ -35,7 +35,6 @@ func Shard(conf *cfg.Config) *cli.Command {
 		Commands: []*cli.Command{
 			ShardList(conf),
 			ShardShow(conf),
-			ShardAllocation(conf),
 		},
 	}
 }
@@ -95,41 +94,3 @@ func ShardShow(conf *cfg.Config) *cli.Command {
 		},
 	}
 }
-
-func ShardAllocation(conf *cfg.Config) *cli.Command {
-	return &cli.Command{
-		Name:    "allocation",
-		Aliases: []string{"a"},
-		Usage:   "explain shard allocation",
-
-		Flags: []cli.Flag{
-			&cli.IntFlag{
-				Name:        "shard",
-				Usage:       "shard number to explain for",
-				Destination: &conf.Shards,
-				Aliases:     []string{"s"},
-			},
-			&cli.BoolFlag{
-				Name:        "primary",
-				Usage:       "explain primary allocation (default true)",
-				Destination: &conf.Primary,
-				Aliases:     []string{"p"},
-			},
-			&cli.StringFlag{
-				Name:        "node",
-				Usage:       "explain a shard only if it is currently located on the specified node name or node ID",
-				Destination: &conf.FromNode,
-				Aliases:     []string{"n"},
-			},
-		},
-
-		Action: func(ctx context.Context, cmd *cli.Command) error {
-			index := cmd.Args().Get(0)
-			if index == "" {
-				return errors.New("no index specified")
-			}
-
-			return es.ShardAllocation(conf, cmd.Args().Get(0))
-		},
-	}
-}
--- a/cmd/utilities.go
+++ b/cmd/utilities.go
@@ -26,10 +26,9 @@ import (
 func addReference(ref string) string {
 	indentedRef := []string{}

-	for line := range strings.SplitSeq(ref, "\n") {
+	for _, line := range strings.Split(ref, "\n") {
 		indentedRef = append(indentedRef, "   "+line)
 	}
-
 	return fmt.Sprintf("%s\nREFERENCE:\n%s\n",
 		cli.SubcommandHelpTemplate,
 		strings.Join(indentedRef, "\n"))
--- a/go.mod
+++ b/go.mod
@@ -14,7 +14,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 module codeberg.org/scip/esctl

-go 1.26
+go 1.25.8

 require (
 	github.com/MichaelMure/go-term-markdown v0.1.4
--- a/pkg/cfg/cluster.go
+++ b/pkg/cfg/cluster.go
@@ -55,6 +55,37 @@ func (cluster *Cluster) SetClient(client *elasticsearch.TypedClient) {
 	cluster.client = client
 }

+func (cluster *Cluster) getTransport() elastictransport.Option {
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+
+	if cluster.DebugHTTP {
+		return elastictransport.WithTransport(
+			&DebugTransport{Transport: transport},
+		)
+	}
+
+	return elastictransport.WithTransport(transport)
+}
+
+func (cluster *Cluster) getDefaultOptions() []elasticsearch.Option {
+	// These headers are  not needed with ES 9, but with  ES 8, we set
+	// them here  so every API call uses it.  The only exception being
+	// the api repl, which does it on its own.
+	headers := http.Header{}
+	headers.Add("content-type", "application/json")
+	headers.Add("Accept", "application/json")
+
+	return []elasticsearch.Option{
+		elasticsearch.WithAddresses(cluster.Uri),
+		elasticsearch.WithTransportOptions(
+			cluster.getTransport(),
+			elastictransport.WithHeader(headers),
+		),
+	}
+}
+
 // return the  go-elasticsearch client  object but before  doing that,
 // check if we need to tune auth
 func (cluster *Cluster) ES() *elasticsearch.TypedClient {
@@ -83,8 +114,7 @@ func (cluster *Cluster) CheckAuth() error {
 		} else {
 			// k, try interactively
 			fmt.Fprintf(os.Stderr, "Enter password for elasticsearch user %s@%s: ", cluster.User, cluster.Name)
-
-			pass, err := term.ReadPassword(syscall.Stdin)
+			pass, err := term.ReadPassword(int(syscall.Stdin))
 			if err != nil {
 				return err
 			}
@@ -95,7 +125,6 @@ func (cluster *Cluster) CheckAuth() error {
 			}

 			cluster.Pass = string(pass)
-
 			fmt.Println()
 		}

@@ -103,6 +132,7 @@ func (cluster *Cluster) CheckAuth() error {
 		opts = append(opts, elasticsearch.WithBasicAuth(cluster.User, cluster.Pass))

 		es, err := elasticsearch.NewTyped(opts...)
+
 		if err != nil {
 			return fmt.Errorf("failed to setup elasticsearch connection: %w", err)
 		}
@@ -175,37 +205,6 @@ func (cluster *Cluster) IsReachable() (bool, error) {
 	return true, conn.Close()
 }

-func (cluster *Cluster) getDefaultOptions() []elasticsearch.Option {
-	// These headers are  not needed with ES 9, but with  ES 8, we set
-	// them here  so every API call uses it.  The only exception being
-	// the api repl, which does it on its own.
-	headers := http.Header{}
-	headers.Add("Content-Type", "application/json")
-	headers.Add("Accept", "application/json")
-
-	return []elasticsearch.Option{
-		elasticsearch.WithAddresses(cluster.Uri),
-		elasticsearch.WithTransportOptions(
-			cluster.getTransport(),
-			elastictransport.WithHeader(headers),
-		),
-	}
-}
-
-func (cluster *Cluster) getTransport() elastictransport.Option {
-	transport := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-
-	if cluster.DebugHTTP {
-		return elastictransport.WithTransport(
-			&DebugTransport{Transport: transport},
-		)
-	}
-
-	return elastictransport.WithTransport(transport)
-}
-
 func (conf *Config) SetupES() error {
 	for name, cluster := range conf.Clusters {
 		cluster.Name = name
@@ -221,6 +220,7 @@ func (conf *Config) SetupES() error {
 		}

 		es, err := elasticsearch.NewTyped(opts...)
+
 		if err != nil {
 			return fmt.Errorf("failed to setup elasticsearch connection: %w", err)
 		}
--- a/pkg/cfg/config.go
+++ b/pkg/cfg/config.go
@@ -151,6 +151,45 @@ func (conf *Config) Init() error {
 	return nil
 }

+func (conf *Config) determineDefaultCluster() error {
+	if conf.CurrentCluster != "" {
+		// -C specified, set current cluster explicitly, no matter what the config says
+		current, exists := conf.Clusters[conf.CurrentCluster]
+		if !exists {
+			return fmt.Errorf("no cluster with alias %s configured", conf.CurrentCluster)
+		} else {
+			conf.DefaultCluster = current
+
+			// disable all others
+			for _, cluster := range conf.Clusters {
+				cluster.Default = false
+			}
+
+			conf.DefaultCluster.Default = true
+		}
+	} else {
+		// we need to determine ourselfes
+		if len(conf.Clusters) == 1 {
+			// ok, just one cluster configured, use this, of course
+			for name, cluster := range conf.Clusters {
+				conf.DefaultCluster = cluster
+				conf.CurrentCluster = name
+				conf.DefaultCluster.Default = true
+			}
+		} else {
+			// multiple ones exists, look if one is set as default
+			for name, cluster := range conf.Clusters {
+				if cluster.Default {
+					conf.DefaultCluster = cluster
+					conf.CurrentCluster = name
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
 // we are  using reflect to  clone a config obj  w/o the ES  stuff for
 // shorter repr.Println() output (the ES structure is just too large)
 func (conf *Config) Clone() Config {
@@ -159,14 +198,14 @@ func (conf *Config) Clone() Config {
 	ref := reflect.ValueOf(*conf)
 	typeOfS := ref.Type()

-	for idx := range ref.NumField() {
-		field := typeOfS.Field(idx).Name
+	for i := 0; i < ref.NumField(); i++ {
+		field := typeOfS.Field(i).Name

-		if field == "Clusters" || field == "DefaultCluster" || !ref.Field(idx).CanInterface() {
+		if field == "Clusters" || field == "DefaultCluster" || !ref.Field(i).CanInterface() {
 			continue
 		}

-		reflect.ValueOf(&clone).Elem().FieldByName(field).Set(reflect.ValueOf(ref.Field(idx).Interface()))
+		reflect.ValueOf(&clone).Elem().FieldByName(field).Set(reflect.ValueOf(ref.Field(i).Interface()))
 	}

 	return clone
@@ -227,7 +266,6 @@ func (conf *Config) LoadConfig() error {
 		for _, cluster := range conf.Clusters {
 			if cluster.Default {
 				conf.DefaultCluster = cluster
-
 				break
 			}
 		}
@@ -240,47 +278,9 @@ func (conf *Config) LoadConfig() error {
 	return nil
 }

-func (conf *Config) determineDefaultCluster() error {
-	if conf.CurrentCluster != "" {
-		// -C specified, set current cluster explicitly, no matter what the config says
-		current, exists := conf.Clusters[conf.CurrentCluster]
-		if !exists {
-			return fmt.Errorf("no cluster with alias %s configured", conf.CurrentCluster)
-		} else {
-			conf.DefaultCluster = current
-
-			// disable all others
-			for _, cluster := range conf.Clusters {
-				cluster.Default = false
-			}
-
-			conf.DefaultCluster.Default = true
-		}
-	} else {
-		// we need to determine ourselfes
-		if len(conf.Clusters) == 1 {
-			// ok, just one cluster configured, use this, of course
-			for name, cluster := range conf.Clusters {
-				conf.DefaultCluster = cluster
-				conf.CurrentCluster = name
-				conf.DefaultCluster.Default = true
-			}
-		} else {
-			// multiple ones exists, look if one is set as default
-			for name, cluster := range conf.Clusters {
-				if cluster.Default {
-					conf.DefaultCluster = cluster
-					conf.CurrentCluster = name
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
 func fileExists(filename string) bool {
 	info, err := os.Stat(filename)
+
 	if err != nil {
 		// return false on any error
 		return false
--- a/pkg/cfg/jq.go
+++ b/pkg/cfg/jq.go
@@ -25,7 +25,6 @@ import (

 func isJQinstalled() bool {
 	cmd := exec.CommandContext(context.Background(), "jq", "-h")
-
 	out, err := cmd.Output()
 	if err != nil {
 		return false
--- a/pkg/cfg/transport.go
+++ b/pkg/cfg/transport.go
@@ -43,10 +43,9 @@ func (t *DebugTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 		}

 		var pretty bytes.Buffer
-
 		err = json.Indent(&pretty, buf.Bytes(), "", "\t")
 		if err != nil {
-			return nil, fmt.Errorf("json parse error: %w", err)
+			return nil, fmt.Errorf("json parse error: %s", err)
 		}

 		content = pretty.String()
--- a/pkg/es/api.go
+++ b/pkg/es/api.go
@@ -26,7 +26,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log"
 	"log/slog"
 	"net/http"
 	"os"
@@ -93,8 +92,9 @@ func ApiRepl(conf *cfg.Config) error {
 		EOFPrompt:         "exit",
 		HistorySearchFold: true,
 	})
+
 	if err != nil {
-		return fmt.Errorf("failed to initialize readline lib: %w", err)
+		return fmt.Errorf("failed to initialize readline lib: %s", err)
 	}

 	for {
@@ -112,13 +112,11 @@ func ApiRepl(conf *cfg.Config) error {
 		parts := strings.SplitN(strings.TrimSpace(text), " ", 3)
 		if len(parts) < 2 {
 			fmt.Println("error: you need to input a verb, uri [and post data]")
-
 			continue
 		}

 		if !slices.Contains(verbs, strings.ToLower(parts[0])) {
 			fmt.Println("error: verb must be one of " + strings.Join(verbs, ","))
-
 			continue
 		}

@@ -146,7 +144,6 @@ func ApiRepl(conf *cfg.Config) error {
 		pageJsonOutput(conf, raw)
 	}

-	//nolint:nilerr
 	return nil
 }

@@ -178,6 +175,7 @@ func pageJsonOutput(conf *cfg.Config, raw []byte) {
 			pager.Stderr = os.Stderr

 			err := pager.Run()
+
 			if err != nil {
 				fmt.Printf("failed to execute pager '%s': %s", conf.Pager, err)
 			}
@@ -199,16 +197,16 @@ func CallAPI(conf *cfg.Config, verb, path, data string) ([]byte, error) {
 	verb = strings.ToUpper(verb)

 	// we're using port-forwards anyway
-	noVerifyTransport := &http.Transport{
+	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
 	}

-	client := &http.Client{Transport: noVerifyTransport}
+	client := &http.Client{Transport: tr}

 	if conf.DebugHTTP {
 		client = &http.Client{
 			Transport: &cfg.DebugTransport{
-				Transport: noVerifyTransport}}
+				Transport: tr}}
 	}

 	req, err := http.NewRequest(verb, conf.DefaultCluster.Uri+path, bytes.NewBuffer([]byte(data)))
@@ -217,7 +215,7 @@ func CallAPI(conf *cfg.Config, verb, path, data string) ([]byte, error) {
 	}

 	req.Header.Add("Content-Type", "application/json")
-	req.Header.Add("Accept", "application/json")
+	req.Header.Add("accept", "application/json")

 	// make sure we have got all we need
 	if err := conf.DefaultCluster.CheckAuth(); err != nil {
@@ -235,16 +233,11 @@ func CallAPI(conf *cfg.Config, verb, path, data string) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer func() {
-		if err := resp.Body.Close(); err != nil {
-			log.Fatal(err)
-		}
-	}()

 	// Read and print response
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
+		return nil, fmt.Errorf("failed to read response body: %s", err)
 	}

 	return body, nil
@@ -256,7 +249,6 @@ func prettyfiJson(conf *cfg.Config, raw []byte) (string, error) {
 		cmd.Stdin = bytes.NewReader(raw)

 		var out bytes.Buffer
-
 		cmd.Stdout = &out

 		err := cmd.Run()
@@ -266,12 +258,10 @@ func prettyfiJson(conf *cfg.Config, raw []byte) (string, error) {

 		return out.String(), nil
 	}
-
 	var pretty bytes.Buffer
-
 	err := json.Indent(&pretty, raw, "", "\t")
 	if err != nil {
-		return "", fmt.Errorf("json parse error: %w", err)
+		return "", fmt.Errorf("json parse error: %s", err)
 	}

 	return pretty.String(), nil
@@ -280,10 +270,10 @@ func prettyfiJson(conf *cfg.Config, raw []byte) (string, error) {
 // interactively  read  arbitrary  JSON  data  from  STDIN,  which  is
 // virtually a repl inside the primary repl
 func readJSON(input string) (string, error) {
-	data := strings.Builder{}
+	data := ""

 	if input != "" {
-		data.WriteString(input)
+		data = input
 	} else {
 		scanner := bufio.NewScanner(os.Stdin)
 		for scanner.Scan() {
@@ -293,23 +283,23 @@ func readJSON(input string) (string, error) {
 				break
 			}

-			data.WriteString(line)
+			data += line
 		}
 	}

-	if data.Len() == 0 {
-		return "", nil
+	if data == "" {
+		return data, nil
 	}

 	// validate
 	check := map[string]any{}
-
-	err := json.Unmarshal([]byte(data.String()), &check)
+	err := json.Unmarshal([]byte(data), &check)
 	if err != nil {
-		return "", fmt.Errorf("error: input data is not proper JSON: %w", err)
+		return "", fmt.Errorf("error: input data is not proper JSON: %s", err)
+
 	}

-	return data.String(), nil
+	return data, nil
 }

 func ApiList(conf *cfg.Config, pattern string) error {
@@ -348,7 +338,6 @@ func ApiList(conf *cfg.Config, pattern string) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -356,13 +345,10 @@ func ApiList(conf *cfg.Config, pattern string) error {
 func ApiPathNames() []string {
 	assets.LoadAssetOpenApi()

-	paths := make([]string, len(assets.OpenAPI.Spec().Paths.Paths))
-
-	idx := 0
+	paths := []string{}

 	for path := range assets.OpenAPI.Spec().Paths.Paths {
-		paths[idx] = path
-		idx++
+		paths = append(paths, path)
 	}

 	return paths
@@ -370,7 +356,6 @@ func ApiPathNames() []string {

 func ApiShow(conf *cfg.Config, showpath, verb string) error {
 	assets.LoadAssetOpenApi()
-
 	out := printer.Builder{}

 	op, err := matchOperation(showpath, verb)
@@ -387,20 +372,18 @@ func ApiShow(conf *cfg.Config, showpath, verb string) error {
 	sample := getApiExample(op)
 	description := markdown.Render(cleanMarkup.ReplaceAllString(op.Op.Description, ""), width, cfg.DefaultMargin)

-	var (
-		bold = lipgloss.NewStyle().
+	var bold = lipgloss.NewStyle().
 		Bold(true)
-		paragraph = lipgloss.NewStyle().
+	var paragraph = lipgloss.NewStyle().
 		MarginBottom(1).
 		MarginLeft(cfg.DefaultMargin)
-		boldparagraph = lipgloss.NewStyle().
+	var boldparagraph = lipgloss.NewStyle().
 		MarginBottom(1).
 		MarginLeft(cfg.DefaultMargin).
 		Bold(true)
-		indentparagraph = lipgloss.NewStyle().
+	var indentparagraph = lipgloss.NewStyle().
 		MarginBottom(1).
 		MarginLeft(2)
-	)

 	out.WriteStringLine(bold.Render("ID: " + op.Op.ID))
 	out.WriteStringLine(paragraph.Render(fmt.Sprintf("%s %s", op.Verb, showpath)))
@@ -416,11 +399,10 @@ func ApiShow(conf *cfg.Config, showpath, verb string) error {

 	if len(params.Path) > 0 {
 		out.WriteStringLine(bold.Render("Path Parameters"))
-
 		for _, param := range params.Path {
 			out.WriteStringLine(boldparagraph.Render(param.Param))
-
 			if param.Description != "" {
+				//out.WriteStringLine(indentparagraph.Render(param.Description))
 				out.WriteStringLine(param.Description)
 			}
 		}
@@ -428,10 +410,8 @@ func ApiShow(conf *cfg.Config, showpath, verb string) error {

 	if len(params.Query) > 0 {
 		out.WriteStringLine(bold.Render("Query Parameters"))
-
 		for _, param := range params.Query {
 			out.WriteStringLine(boldparagraph.Render(param.Param))
-
 			if param.Description != "" {
 				out.WriteStringLine(indentparagraph.Render(param.Description))
 			}
@@ -513,8 +493,10 @@ func getApiExample(op *Op) string {
 					if hassource {
 						sample = strings.TrimSpace(source.(string))
 					}
+
 				}
 			}
+
 		}
 	}

@@ -527,13 +509,11 @@ func getApiExample(op *Op) string {
 func matchOperation(showpath, verb string) (*Op, error) {
 	ops := []*Op{}
 	op := &Op{}
-
 	var found bool

 	for path, item := range assets.OpenAPI.Spec().Paths.Paths {
 		if path == showpath {
 			ops = findOperation(item.PathItemProps)
-
 			break
 		}
 	}
@@ -550,7 +530,6 @@ func matchOperation(showpath, verb string) (*Op, error) {
 		if strings.ToLower(item.Verb) == verb {
 			op = item
 			found = true
-
 			break
 		}
 	}
--- a/pkg/es/ccr.go
+++ b/pkg/es/ccr.go
@@ -46,8 +46,9 @@ func CcrStatus(conf *cfg.Config, leader, follower string) error {
 		}

 		// reverse attribution
-		follower, leader = leader, follower
-
+		f := follower
+		follower = leader
+		leader = f
 		slog.Debug("leader/follower attribution is invalid, reversing", "leader", leader, "follower", follower)
 	}

@@ -57,7 +58,7 @@ func CcrStatus(conf *cfg.Config, leader, follower string) error {
 		res, err := conf.Clusters[alias].ES().Cat.Indices().
 			Do(context.Background())
 		if err != nil {
-			return fmt.Errorf("failed to get indicies on %s: %w", alias, esErrorString(err))
+			return fmt.Errorf("failed to get indicies on %s: %s", alias, esErrorString(err))
 		}

 		indices[alias] = make(map[string]*types.IndicesRecord, len(res))
@@ -86,19 +87,17 @@ func CcrRemoteInfo(conf *cfg.Config, index string) error {
 	res, err := conf.DefaultCluster.ES().Cluster.RemoteInfo().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to retrieve follower info: %w", esErrorString(err))
+		return fmt.Errorf("failed to retrieve follower info: %s", esErrorString(err))
 	}

 	slog.Debug("ccr remote info", "info", res)

 	remote := ""
-
 	var info *types.ClusterRemoteProxyInfo

 	for name, data := range res {
 		remote = name
 		info = data.(*types.ClusterRemoteProxyInfo)
-
 		break
 	}

--- a/pkg/es/ccr_follower.go
+++ b/pkg/es/ccr_follower.go
@@ -18,7 +18,6 @@ package es

 import (
 	"context"
-	"errors"
 	"fmt"
 	"log/slog"

@@ -30,18 +29,17 @@ func getRemoteName(conf *cfg.Config) (string, error) {
 	res, err := conf.DefaultCluster.ES().Cluster.RemoteInfo().
 		Do(context.Background())
 	if err != nil {
-		return "", fmt.Errorf("failed to retrieve follower info: %w", esErrorString(err))
+		return "", fmt.Errorf("failed to retrieve follower info: %s", esErrorString(err))
 	}

 	remote := ""
 	for name := range res {
 		remote = name
-
 		break
 	}

 	if remote == "" {
-		return "", errors.New("cluster doesn't have a follower")
+		return "", fmt.Errorf("cluster doesn't have a follower")
 	}

 	return remote, nil
@@ -63,31 +61,26 @@ func CcrFollowerRenew(conf *cfg.Config, index string) error {
 	if err := wrapError(IndexClose, conf, index); err != nil {
 		return err
 	}
-
 	fmt.Printf("closed %s", index)

 	if err := wrapError(CcrFollowerPause, conf, index); err != nil {
 		return err
 	}
-
 	fmt.Printf("paused %s", index)

 	if err := wrapError(CcrFollowerUnfollow, conf, index); err != nil {
 		return err
 	}
-
 	fmt.Printf("unfollowed %s", index)

 	if err := wrapError(IndexDelete, conf, index); err != nil {
 		return err
 	}
-
 	fmt.Printf("deleted %s", index)

 	if err := CcrFollowerAdd(conf, index); err != nil {
 		return err
 	}
-
 	fmt.Printf("added follower %s", index)

 	return nil
@@ -96,8 +89,9 @@ func CcrFollowerRenew(conf *cfg.Config, index string) error {
 func CcrFollowerResume(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Ccr.ResumeFollow(index).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to resume ccr following: %w", esErrorString(err))
+		return fmt.Errorf("failed to resume ccr following: %s", esErrorString(err))
 	}

 	return nil
@@ -106,8 +100,9 @@ func CcrFollowerResume(conf *cfg.Config, index string) error {
 func CcrFollowerPause(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Ccr.PauseFollow(index).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to pause ccr following: %w", esErrorString(err))
+		return fmt.Errorf("failed to pause ccr following: %s", esErrorString(err))
 	}

 	return nil
@@ -116,8 +111,9 @@ func CcrFollowerPause(conf *cfg.Config, index string) error {
 func CcrFollowerUnfollow(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Ccr.ForgetFollower(index).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to unfollow index: %w", esErrorString(err))
+		return fmt.Errorf("failed to unfollow index: %s", esErrorString(err))
 	}

 	return nil
@@ -138,8 +134,9 @@ func CcrFollowerAdd(conf *cfg.Config, index string) error {
 	}

 	_, err = create.Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to create follower index: %w", esErrorString(err))
+		return fmt.Errorf("failed to create follower index: %s", esErrorString(err))
 	}

 	return nil
@@ -149,7 +146,7 @@ func CcrFollowerShow(conf *cfg.Config, index string) error {
 	res, err := conf.DefaultCluster.ES().Ccr.FollowStats(index).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to retrieve follower index info: %w", esErrorString(err))
+		return fmt.Errorf("failed to retrieve follower index info: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "follower stats", res.Indices)
--- a/pkg/es/cluster.go
+++ b/pkg/es/cluster.go
@@ -38,22 +38,22 @@ type clusterReachable struct {
 }

 func ClusterList(conf *cfg.Config) error {
-	var (
-		mu sync.Mutex
-		wg sync.WaitGroup
-	)
-
+	var mu sync.Mutex
+	var wg sync.WaitGroup
 	reachable := make(map[string]clusterReachable, len(conf.Clusters))

 	// check endpoints in parallel to speed things up
 	for name, cluster := range conf.Clusters {
-		wg.Go(func() {
+		wg.Add(1)
+
+		go func() {
+			defer wg.Done()
 			online, err := cluster.IsReachable()

 			mu.Lock()
 			reachable[name] = clusterReachable{reachable: online, err: err}
 			mu.Unlock()
-		})
+		}()
 	}

 	wg.Wait()
@@ -121,26 +121,26 @@ func getClusterStatus(conf *cfg.Config) (*apiResponse, error) {

 	var err error

-	for range gocount {
-		res := <-responses
+	for i := 0; i < gocount; i++ {
+		r := <-responses

-		err = errors.Join(err, res.error)
+		err = errors.Join(err, r.error)

-		switch res.which {
+		switch r.which {
 		case ResponseHealth:
-			all.health = res.health
+			all.health = r.health
 		case ResponseCcr:
-			all.ccr = res.ccr
+			all.ccr = r.ccr
 		case ResponseInfo:
-			all.info = res.info
+			all.info = r.info
 		case ResponseStats:
-			all.stats = res.stats
+			all.stats = r.stats
 		case ResponseIndices:
-			all.indices = res.indices
+			all.indices = r.indices
 		case ResponseTasks:
-			all.tasks = res.tasks
+			all.tasks = r.tasks
 		case ResponseHealthReport:
-			all.healthreport = res.healthreport
+			all.healthreport = r.healthreport
 		}
 	}

@@ -155,10 +155,8 @@ func ClusterStatus(conf *cfg.Config) error {

 	slog.Debug("ES result", "cluster health", res.health)

-	var (
-		isleader     bool
-		ccrfollowing string
-	)
+	var isleader bool
+	var ccrfollowing string

 	if res.ccr != nil {
 		isleader = len(res.ccr.AutoFollowStats.AutoFollowedClusters) == 0
@@ -175,7 +173,6 @@ func ClusterStatus(conf *cfg.Config) error {

 	// look for red indices, if any
 	redindices := 0
-
 	for _, index := range *res.indices {
 		if *index.Health == "red" {
 			redindices++
@@ -184,7 +181,6 @@ func ClusterStatus(conf *cfg.Config) error {

 	// look for long running tasks
 	longtasks := 0
-
 	for _, task := range *res.tasks {
 		if strings.Contains(*task.RunningTime, "d") {
 			longtasks++
@@ -217,7 +213,7 @@ func ClusterStatus(conf *cfg.Config) error {
 	}

 	if conf.Verbose {
-		table = gatherClusterStats(res.stats, table)
+		table = gatherClusterStats(conf, res.stats, table)
 	}

 	if res.health.Status.Name != "green" {
@@ -245,11 +241,9 @@ func ClusterStatus(conf *cfg.Config) error {
 	return nil
 }

-func gatherClusterStats(clusterstats *clusterstats.Response, table *printer.Table) *printer.Table {
-	var (
-		querycount int64
-		vmversion  string
-	)
+func gatherClusterStats(conf *cfg.Config, clusterstats *clusterstats.Response, table *printer.Table) *printer.Table {
+	var querycount int64
+	var vmversion string

 	for _, count := range clusterstats.Indices.Search.Queries {
 		querycount += count
--- a/pkg/es/cluster_reroute.go
+++ b/pkg/es/cluster_reroute.go
@@ -118,7 +118,6 @@ func ClusterRerouteAllocatePrimary(conf *cfg.Config, index string, stale bool) e
 		if stale {
 			which = "stale"
 		}
-
 		return fmt.Errorf("failed to allocate %s primary shard: %w", which, err)
 	}

--- a/pkg/es/cluster_settings.go
+++ b/pkg/es/cluster_settings.go
@@ -35,12 +35,11 @@ func ClusterSettingsList(conf *cfg.Config) error {
 		FlatSettings(true).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get cluster settings: %w", esErrorString(err))
+		return fmt.Errorf("failed to get cluster settings: %s", esErrorString(err))
 	}

 	table := printer.NewTable(conf, 2, 0)
 	table.Addheaders("setting", "value")
-
 	entries := [][]any{}

 	settingshash := res.Persistent // == map[string]json.RawMessage
@@ -76,25 +75,23 @@ func ClusterSettingsSet(conf *cfg.Config, args cli.Args) error {
 		case conf.Transient:
 			message, err := json.Marshal(value)
 			if err != nil {
-				return fmt.Errorf("failed to marshall transient value <%v> to valid JSON: %w", value, err)
+				return fmt.Errorf("failed to marshall transient value <%v> to valid JSON: %s", value, err)
 			}
-
 			put.AddTransient(setting, message)
 		case conf.Persistent:
 			fallthrough
 		default:
 			message, err := json.Marshal(value)
 			if err != nil {
-				return fmt.Errorf("failed to marshall persistent value <%v> to valid JSON: %w", value, err)
+				return fmt.Errorf("failed to marshall persistent value <%v> to valid JSON: %s", value, err)
 			}
-
 			put.AddPersistent(setting, message)
 		}
 	}

 	_, err := put.Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to set settings: %w", esErrorString(err))
+		return fmt.Errorf("failed to set settings: %s", esErrorString(err))
 	}

 	return nil
@@ -103,14 +100,15 @@ func ClusterSettingsSet(conf *cfg.Config, args cli.Args) error {
 func ClusterSettingsSetSingle(conf *cfg.Config, setting, value string) error {
 	message, err := json.Marshal(value)
 	if err != nil {
-		return fmt.Errorf("failed to marshall persistent value <%v> to valid JSON: %w", value, err)
+		return fmt.Errorf("failed to marshall persistent value <%v> to valid JSON: %s", value, err)
 	}

 	_, err = conf.DefaultCluster.ES().Cluster.PutSettings().
 		AddPersistent(setting, message).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to set %s: %w", setting, esErrorString(err))
+		return fmt.Errorf("failed to set %s: %s", setting, esErrorString(err))
 	}

 	return nil
--- a/pkg/es/cluster_settings_const.go
+++ b/pkg/es/cluster_settings_const.go
--- a/pkg/es/cluster_util.go
+++ b/pkg/es/cluster_util.go
@@ -37,7 +37,6 @@ func checkClusterIsLeader(conf *cfg.Config, leader string) bool {
 		Do(context.Background())
 	if err != nil {
 		fmt.Printf("failed to get ccr stats from %s: %s", leader, esErrorString(err))
-
 		return false
 	}

@@ -48,7 +47,6 @@ func checkClusterIsLeader(conf *cfg.Config, leader string) bool {

 	if stats.AutoFollowStats.AutoFollowedClusters[0].ClusterName != "" {
 		fmt.Println("leader/follower attribution is invalid, reverse cluster attribution and retry")
-
 		return false
 	}

@@ -60,15 +58,14 @@ func checkClusterStatus(conf *cfg.Config, leader, follower string) bool {
 	status := map[string]*health.Response{}

 	for _, cluster := range []string{leader, follower} {
-		clusterHealth, err := conf.Clusters[leader].ES().Cluster.Health().
+		st, err := conf.Clusters[leader].ES().Cluster.Health().
 			Do(context.Background())
 		if err != nil {
 			fmt.Printf("failed to get health from %s: %s", cluster, esErrorString(err))
-
 			return false
 		}

-		status[cluster] = clusterHealth
+		status[cluster] = st
 	}

 	table := printer.NewTable(conf, 3, 6)
@@ -101,7 +98,6 @@ func checkClusterStatus(conf *cfg.Config, leader, follower string) bool {

 	if err := table.Print(); err != nil {
 		fmt.Println(err)
-
 		return false
 	}

@@ -124,7 +120,6 @@ func findIlmErrors(conf *cfg.Config, leader, follower string) bool {
 			Do(context.Background())
 		if err != nil {
 			fmt.Printf("failed to get ilm status from %s: %s", cluster, esErrorString(err))
-
 			return false
 		}

@@ -163,7 +158,6 @@ func findIlmErrors(conf *cfg.Config, leader, follower string) bool {

 			if err := table.Print(); err != nil {
 				fmt.Println(err)
-
 				return false
 			}
 		}
@@ -180,7 +174,6 @@ func findIndicesOnlyOnLeader(conf *cfg.Config, indices ClusterIndices, leader, f
 	}

 	indexOnlyOnLeader := map[string]*types.IndicesRecord{}
-
 	for name, index := range indices[leader] {
 		if exclude.MatchString(name) {
 			continue
@@ -202,11 +195,9 @@ func findIndicesOnlyOnLeader(conf *cfg.Config, indices ClusterIndices, leader, f
 			}

 			isWritable := false
-
 			for _, alias := range res[name].Aliases {
 				if *alias.IsWriteIndex {
 					isWritable = true
-
 					break
 				}
 			}
@@ -236,10 +227,8 @@ func findIndicesOnlyOnLeader(conf *cfg.Config, indices ClusterIndices, leader, f
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		fmt.Println(err)
-
 		return false
 	}

@@ -286,10 +275,8 @@ func findOrphanedIndices(conf *cfg.Config, indices ClusterIndices, leader, follo
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		fmt.Println(err)
-
 		return false
 	}

@@ -322,10 +309,8 @@ func findFailedFollowerIndices(conf *cfg.Config, indices ClusterIndices, followe
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		fmt.Println(err)
-
 		return false
 	}

--- a/pkg/es/datastream.go
+++ b/pkg/es/datastream.go
@@ -32,7 +32,7 @@ func DatastreamNames(conf *cfg.Config) ([]string, error) {
 	res, err := conf.DefaultCluster.ES().Indices.GetDataStream().
 		Do(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("failed to get data streams: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get data streams: %s", esErrorString(err))
 	}

 	dss := make([]string, len(res.DataStreams))
@@ -47,7 +47,7 @@ func DatastreamList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Indices.GetDataStream().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get data streams: %w", esErrorString(err))
+		return fmt.Errorf("failed to get data streams: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "data streams", res)
@@ -65,22 +65,21 @@ func DatastreamList(conf *cfg.Config) error {
 	table := printer.NewTable(conf, 7, size)
 	table.Addheaders("name", "ilm policy", "hidden", "system", "replicated", "generation", "timestamp field")

-	for idx, datastream := range list {
-		name := printer.Colorize(conf, datastream.Status.String(), datastream.Name)
-
+	for idx, ds := range list {
+		name := printer.Colorize(conf, ds.Status.String(), ds.Name)
 		policy := ""
-		if datastream.IlmPolicy != nil {
-			policy = *datastream.IlmPolicy
+		if ds.IlmPolicy != nil {
+			policy = *ds.IlmPolicy
 		}

 		table.Entries[idx] = []any{
 			name,
 			policy,
-			datastream.Hidden,
-			*datastream.System,
-			*datastream.Replicated,
-			datastream.Generation,
-			datastream.TimestampField.Name,
+			ds.Hidden,
+			*ds.System,
+			*ds.Replicated,
+			ds.Generation,
+			ds.TimestampField.Name,
 		}

 		if idx == size-1 {
@@ -89,7 +88,6 @@ func DatastreamList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -130,7 +128,7 @@ func DatastreamShow(conf *cfg.Config, dsname string) error {
 		Name(dsname).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get data stream: %w", esErrorString(err))
+		return fmt.Errorf("failed to get data stream: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "data stream", res)
@@ -143,29 +141,28 @@ func DatastreamShow(conf *cfg.Config, dsname string) error {
 		Name(dsname).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get data stream stats: %w", esErrorString(err))
+		return fmt.Errorf("failed to get data stream stats: %s", esErrorString(err))
 	}

 	table := printer.NewTable(conf, 11, 2)
 	table.Addheaders("data stream property", "value")

-	datastream := res.DataStreams[0]
-
-	name := printer.Colorize(conf, datastream.Status.String(), datastream.Name)
+	ds := res.DataStreams[0]

+	name := printer.Colorize(conf, ds.Status.String(), ds.Name)
 	policy := ""
-	if datastream.IlmPolicy != nil {
-		policy = *datastream.IlmPolicy
+	if ds.IlmPolicy != nil {
+		policy = *ds.IlmPolicy
 	}

 	table.Entries = [][]any{
 		{"name", name},
 		{"ilm policy", policy},
-		{"hidden", datastream.Hidden},
-		{"system", *datastream.System},
-		{"replicated", *datastream.Replicated},
-		{"generation", datastream.Generation},
-		{"timestamp field", datastream.TimestampField.Name},
+		{"hidden", ds.Hidden},
+		{"system", *ds.System},
+		{"replicated", *ds.Replicated},
+		{"generation", ds.Generation},
+		{"timestamp field", ds.TimestampField.Name},
 		{"backing indices", stats.BackingIndices},
 		{"size", printer.Bytes(stats.TotalStoreSizeBytes)},
 		{"shards-failed", stats.Shards_.Failed},
@@ -176,13 +173,13 @@ func DatastreamShow(conf *cfg.Config, dsname string) error {
 		return err
 	}

-	table = printer.NewTable(conf, 5, len(datastream.Indices))
+	table = printer.NewTable(conf, 5, len(ds.Indices))
 	table.Addheaders("backing index name", "uuid", "prefer ilm", "ilm policy", "managed by")

-	for idx, index := range datastream.Indices {
+	for idx, index := range ds.Indices {
 		policy := ""
-		if datastream.IlmPolicy != nil {
-			policy = *datastream.IlmPolicy
+		if ds.IlmPolicy != nil {
+			policy = *ds.IlmPolicy
 		}

 		table.Entries[idx] = []any{
@@ -193,13 +190,12 @@ func DatastreamShow(conf *cfg.Config, dsname string) error {
 			index.ManagedBy.Name,
 		}

-		if idx < len(datastream.Indices) {
+		if idx < len(ds.Indices) {
 			fmt.Println()
 		}
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -210,8 +206,9 @@ func DatastreamShow(conf *cfg.Config, dsname string) error {
 func DatastreamCreate(conf *cfg.Config, dsname string) error {
 	_, err := conf.DefaultCluster.ES().Indices.CreateDataStream(dsname).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to create datastream: %w", esErrorString(err))
+		return fmt.Errorf("failed to create datastream: %s", esErrorString(err))
 	}

 	return nil
@@ -220,8 +217,9 @@ func DatastreamCreate(conf *cfg.Config, dsname string) error {
 func DatastreamDelete(conf *cfg.Config, dsname string) error {
 	_, err := conf.DefaultCluster.ES().Indices.DeleteDataStream(dsname).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to delete datastream: %w", esErrorString(err))
+		return fmt.Errorf("failed to delete datastream: %s", esErrorString(err))
 	}

 	return nil
@@ -229,8 +227,9 @@ func DatastreamDelete(conf *cfg.Config, dsname string) error {

 func DatastreamRollover(conf *cfg.Config, ds string) error {
 	res, err := RolloverAlias(conf, ds)
+
 	if err != nil {
-		return fmt.Errorf("failed to rollover data stream: %w", esErrorString(err))
+		return fmt.Errorf("failed to rollover data stream: %s", esErrorString(err))
 	}

 	table := printer.NewTable(conf, 2, 5)
--- a/pkg/es/doc.go
+++ b/pkg/es/doc.go
@@ -22,7 +22,6 @@ import (
 	"errors"
 	"fmt"
 	"math/rand/v2"
-	"strconv"
 	"strings"

 	"codeberg.org/scip/esctl/pkg/cfg"
@@ -43,16 +42,16 @@ func DocAdd(conf *cfg.Config, jsondoc string) error {

 	err := json.Unmarshal([]byte(jsondoc), &data)
 	if err != nil {
-		return fmt.Errorf("supplied document was not valid JSON: %w", err)
+		return fmt.Errorf("supplied document was not valid JSON: %s", err)
 	}

-	now := strconv.FormatInt(rand.Int64(), 10)
+	now := fmt.Sprintf("%d", rand.Int64())

 	res, err := conf.DefaultCluster.ES().Create(conf.Index, now).
 		Document(data).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to create new doc in index %s: %w", conf.Index, esErrorString(err))
+		return fmt.Errorf("failed to create new doc in index %s: %s", conf.Index, esErrorString(err))
 	}

 	fmt.Println(res.Id_)
@@ -64,7 +63,7 @@ func DocShow(conf *cfg.Config, id string) error {
 	res, err := conf.DefaultCluster.ES().Get(conf.Index, id).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to retrieve doc in index %s: %w", conf.Index, esErrorString(err))
+		return fmt.Errorf("failed to retrieve doc in index %s: %s", conf.Index, esErrorString(err))
 	}

 	if !res.Found {
@@ -95,7 +94,7 @@ func DocDelete(conf *cfg.Config, queries []string) error {
 		_, err := conf.DefaultCluster.ES().Delete(conf.Index, id).
 			Do(context.Background())
 		if err != nil {
-			return fmt.Errorf("failed to delete doc in index %s: %w", conf.Index, esErrorString(err))
+			return fmt.Errorf("failed to delete doc in index %s: %s", conf.Index, esErrorString(err))
 		}

 		return nil
@@ -118,7 +117,7 @@ func DocDelete(conf *cfg.Config, queries []string) error {
 		Request(req).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to delete docs in index %s: %w", conf.Index, esErrorString(err))
+		return fmt.Errorf("failed to delete docs in index %s: %s", conf.Index, esErrorString(err))
 	}

 	return nil
--- a/pkg/es/duration.go
+++ b/pkg/es/duration.go
@@ -45,6 +45,7 @@ Convert a  duration into  an integer.  Valid  time units  are "s", "m", "h" and
 	via https://codeberg.org/scip/tablizer/src/branch/main/lib/sort.go#L113
 */
 func parseDuration(duration string) time.Duration {
+
 	seconds := 0

 	for _, match := range matchDuration.FindAllStringSubmatch(duration, -1) {
@@ -110,14 +111,12 @@ func formatDuration(val time.Duration) string {
 		if esd.minutes == 0 {
 			return fmt.Sprintf("%dh", esd.hours)
 		}
-
 		return fmt.Sprintf("%dh:%dm", esd.hours, int64(esd.minutes))

 	default:
 		if esd.minutes == 0 && hoursLeft == 0 {
 			return fmt.Sprintf("%dd", int64(days))
 		}
-
 		return fmt.Sprintf("%dd:%dh:%dm",
 			int64(days),
 			int64(hoursLeft),
--- a/pkg/es/errors.go
+++ b/pkg/es/errors.go
@@ -17,31 +17,29 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 package es

 import (
-	"errors"
 	"fmt"
-	"strings"

 	"github.com/elastic/go-elasticsearch/v9/typedapi/types"
 )

-func esErrorString(err error) error {
+func esErrorString(err error) string {
 	msg := err.Error()

-	//nolint:gocritic
-	switch errVal := err.(type) {
+	switch e := err.(type) {
 	case *types.ElasticsearchError:
-		var causes strings.Builder
+		causes := ""

-		for _, cause := range errVal.ErrorCause.RootCause {
-			fmt.Fprintf(&causes, "%s\n", *cause.Reason)
+		for _, cause := range e.ErrorCause.RootCause {
+			causes += fmt.Sprintf("%s\n", *cause.Reason)
 		}

-		if errVal.ErrorCause.Reason != nil {
-			msg = *errVal.ErrorCause.Reason + ": " + causes.String()
+		if e.ErrorCause.Reason != nil {
+			msg = *e.ErrorCause.Reason + ": " + causes
 		} else {
-			msg = fmt.Sprintf("http status %d: ", errVal.Status)
-		}
+			msg = fmt.Sprintf("http status %d: ", e.Status)
 		}

-	return errors.New(msg)
+	}
+
+	return msg
 }
--- a/pkg/es/ilm.go
+++ b/pkg/es/ilm.go
@@ -37,7 +37,7 @@ func IlmRetry(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Ilm.Retry(index).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to retry ilm: %w", esErrorString(err))
+		return fmt.Errorf("failed to retry ilm: %s", esErrorString(err))
 	}

 	return nil
@@ -47,7 +47,7 @@ func IlmStatus(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Ilm.GetStatus().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get ilm status: %w", esErrorString(err))
+		return fmt.Errorf("failed to get ilm status: %s", esErrorString(err))
 	}

 	fmt.Println(res.OperationMode.Name)
@@ -59,7 +59,7 @@ func IlmNames(conf *cfg.Config) ([]string, error) {
 	res, err := conf.DefaultCluster.ES().Ilm.GetLifecycle().
 		Do(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("failed to get ilm policies: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get ilm policies: %s", esErrorString(err))
 	}

 	names := make([]string, len(res))
@@ -82,7 +82,7 @@ func IlmList(conf *cfg.Config, pattern string) error {

 	res, err := ilm.Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get ilm policies: %w", esErrorString(err))
+		return fmt.Errorf("failed to get ilm policies: %s", esErrorString(err))
 	}

 	if conf.Debug {
@@ -102,7 +102,6 @@ func IlmList(conf *cfg.Config, pattern string) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -111,7 +110,7 @@ func IlmShow(conf *cfg.Config, policy string) error {
 		Policy(policy).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get ilm status: %w", esErrorString(err))
+		return fmt.Errorf("failed to get ilm status: %s", esErrorString(err))
 	}

 	if conf.Debug {
@@ -167,7 +166,6 @@ func IlmShowTree(conf *cfg.Config, ilm types.IlmPolicy) error {
 			}

 			indent += "    "
-
 			continue
 		}

@@ -262,7 +260,7 @@ func ilmPhaseString(phase *types.Phase, short bool) string {
 	}

 	if phase.Actions.SearchableSnapshot != nil {
-		out = append(out, "searchable-snapshot:"+phase.Actions.SearchableSnapshot.SnapshotRepository)
+		out = append(out, fmt.Sprintf("searchable-snapshot:%s", phase.Actions.SearchableSnapshot.SnapshotRepository))
 	}

 	return strings.Join(out, ",")
@@ -272,7 +270,7 @@ func IlmExplain(conf *cfg.Config, index string) error {
 	res, err := conf.DefaultCluster.ES().Ilm.ExplainLifecycle(index).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get ilm state: %w", esErrorString(err))
+		return fmt.Errorf("failed to get ilm state: %s", esErrorString(err))
 	}

 	slog.Debug("ilm status", "ilm", res)
@@ -288,7 +286,6 @@ func IlmExplain(conf *cfg.Config, index string) error {
 	table.Addheaders("ilm status field", "value")

 	info := ""
-
 	err = json.Unmarshal(ilm.StepInfo["reason"], &info)
 	if err != nil {
 		return fmt.Errorf("failed to unmarshal step info: %w", err)
@@ -348,9 +345,7 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 	if cfg.HaveHot() {
 		hot := types.Phase{}
-
 		var actions types.IlmActionsVariant = esdsl.NewIlmActions()
-
 		rollover := &types.RolloverAction{}
 		haveroll := false

@@ -388,14 +383,15 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 		hot.Actions = actions.IlmActionsCaster()
 		phases.PhasesCaster().Hot = &hot
-	} else if policy != nil {
+	} else {
+		if policy != nil {
 			// update
 			phases.PhasesCaster().Hot = policy.Phases.Hot
 		}
+	}

 	if cfg.HaveWarm() {
 		warm := types.Phase{}
-
 		var actions types.IlmActionsVariant = esdsl.NewIlmActions()

 		if policy != nil {
@@ -421,14 +417,15 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 		warm.Actions = actions.IlmActionsCaster()
 		phases.PhasesCaster().Warm = &warm
-	} else if policy != nil && policy.Phases.Warm != nil {
+	} else {
+		if policy != nil && policy.Phases.Warm != nil {
 			// update
 			phases.PhasesCaster().Warm = policy.Phases.Warm
 		}
+	}

 	if cfg.HaveCold() {
 		cold := types.Phase{}
-
 		var actions types.IlmActionsVariant = esdsl.NewIlmActions()

 		if policy != nil {
@@ -455,14 +452,15 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 		cold.Actions = actions.IlmActionsCaster()
 		phases.PhasesCaster().Cold = &cold
-	} else if policy != nil && policy.Phases.Cold != nil {
+	} else {
+		if policy != nil && policy.Phases.Cold != nil {
 			// update
 			phases.PhasesCaster().Cold = policy.Phases.Cold
 		}
+	}

 	if cfg.HaveFrozen() {
 		froze := types.Phase{}
-
 		var actions types.IlmActionsVariant = esdsl.NewIlmActions()

 		if policy != nil {
@@ -481,15 +479,16 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 		froze.Actions = actions.IlmActionsCaster()
 		phases.PhasesCaster().Frozen = &froze
-	} else if policy != nil && policy.Phases.Frozen != nil {
+	} else {
+		if policy != nil && policy.Phases.Frozen != nil {
 			// update
 			phases.PhasesCaster().Frozen = policy.Phases.Frozen
 		}
+	}

 	if cfg.HaveDelete() {
 		del := types.Phase{}
 		delete := types.DeleteAction{}
-
 		var actions types.IlmActionsVariant = esdsl.NewIlmActions()

 		if policy != nil {
@@ -508,10 +507,12 @@ func IlmCreate(conf *cfg.Config, policyname string) error {
 		actions.IlmActionsCaster().Delete = &delete
 		del.Actions = actions.IlmActionsCaster()
 		phases.PhasesCaster().Delete = &del
-	} else if policy != nil && policy.Phases.Delete != nil {
+	} else {
+		if policy != nil && policy.Phases.Delete != nil {
 			// update
 			phases.PhasesCaster().Delete = policy.Phases.Delete
 		}
+	}

 	put := &putlifecycle.Request{}
 	newpolicy := &types.IlmPolicy{}
@@ -522,7 +523,7 @@ func IlmCreate(conf *cfg.Config, policyname string) error {

 	_, err = ilm.Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed create ilm policy: %w", esErrorString(err))
+		return fmt.Errorf("failed create ilm policy: %s", esErrorString(err))
 	}

 	return nil
--- a/pkg/es/ilm_forecast.go
+++ b/pkg/es/ilm_forecast.go
@@ -138,7 +138,6 @@ func IlmForecastList(conf *cfg.Config, filter string) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -155,11 +154,14 @@ func IlmForecastShow(conf *cfg.Config) error {
 	}

 	within := parseDuration(conf.Ilm.Within)
-
 	var toBeFreed int64 = 0

 	for _, phase := range phaseData {
-		age := max(virtualAge(&phase), phase.age)
+		age := virtualAge(&phase)
+
+		if age < phase.age {
+			age = phase.age
+		}

 		if age+within >= phase.minage {
 			toBeFreed += phase.size
@@ -194,26 +196,24 @@ func getIlmPhaseData(conf *cfg.Config) ([]PhaseData, error) {

 	wg.Wait()

-	var (
-		ilmdetails  *explainlifecycle.Response
-		indicesres  *indices.Response
-		ilmpolicies getlifecycle.Response
-	)
+	var ilmdetails *explainlifecycle.Response
+	var indicesres *indices.Response
+	var ilmpolicies getlifecycle.Response

-	for range 3 {
-		res := <-responses
+	for i := 0; i < 3; i++ {
+		r := <-responses

-		if res.error != nil {
-			return nil, res.error
+		if r.error != nil {
+			return nil, r.error
 		}

-		switch res.which {
+		switch r.which {
 		case ResponseExplain:
-			ilmdetails = res.explainlifecycle
+			ilmdetails = r.explainlifecycle
 		case ResponseIndices:
-			indicesres = res.indicesbytes
+			indicesres = r.indicesbytes
 		case ResponseLifecycle:
-			ilmpolicies = *res.lifecycle
+			ilmpolicies = *r.lifecycle
 		}
 	}

--- a/pkg/es/index.go
+++ b/pkg/es/index.go
@@ -37,8 +37,9 @@ import (
 func IndexNames(conf *cfg.Config) ([]string, error) {
 	res, err := conf.DefaultCluster.ES().Cat.Indices().
 		Do(context.Background())
+
 	if err != nil {
-		return nil, fmt.Errorf("failed to get indicies: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get indicies: %s", esErrorString(err))
 	}

 	indices := make([]string, len(res))
@@ -96,7 +97,7 @@ func IndexList(conf *cfg.Config) error {

 	res, err := cat.Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get indicies: %w", esErrorString(err))
+		return fmt.Errorf("failed to get indicies: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "indicies", res)
@@ -125,7 +126,6 @@ func IndexList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -133,14 +133,13 @@ func IndexShow(conf *cfg.Config, indexpattern string) error {
 	res, err := conf.DefaultCluster.ES().Indices.Get(indexpattern).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get index: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index: %s", esErrorString(err))
 	}

 	slog.Debug("index show", "index", res)

 	for name, index := range res {
 		fields := make([]string, len(index.Mappings.Properties))
-
 		idx := 0
 		for field := range index.Mappings.Properties {
 			fields[idx] = field
@@ -196,7 +195,6 @@ func IndexCreate(conf *cfg.Config, index string, mappings []string) error {
 	if conf.Shards > 0 {
 		settings.NumberOfShards(strconv.Itoa(conf.Shards))
 	}
-
 	if conf.Replicas > 0 {
 		settings.NumberOfReplicas(strconv.Itoa(conf.Replicas))
 	}
@@ -234,8 +232,9 @@ func IndexCreate(conf *cfg.Config, index string, mappings []string) error {

 	_, err := create.Settings(settings).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to create index: %w", esErrorString(err))
+		return fmt.Errorf("failed to create index: %s", esErrorString(err))
 	}

 	return nil
@@ -245,7 +244,7 @@ func IndexDelete(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Indices.Delete(index).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to delete index: %w", esErrorString(err))
+		return fmt.Errorf("failed to delete index: %s", esErrorString(err))
 	}

 	return nil
@@ -254,27 +253,85 @@ func IndexDelete(conf *cfg.Config, index string) error {
 func IndexClose(conf *cfg.Config, index string) error {
 	_, err := conf.DefaultCluster.ES().Indices.Close(index).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to close index: %w", esErrorString(err))
+		return fmt.Errorf("failed to close index: %s", esErrorString(err))
 	}

 	return nil
 }

+func IndexAllocation(conf *cfg.Config, index string) error {
+	res, err := conf.DefaultCluster.ES().Cluster.AllocationExplain().
+		Index(index).
+		Primary(conf.Primary).
+		Shard(conf.Shards).
+		Do(context.Background())
+	if err != nil {
+		return fmt.Errorf("failed to get index allocation explain: %s", esErrorString(err))
+	}
+
+	slog.Debug("ES result", "index", res)
+
+	currentNode := res.CurrentNode
+
+	table := printer.NewTable(conf, 2, 10)
+	table.Addheaders("index allocation setting", "value")
+
+	roles := make([]string, len(currentNode.Roles))
+	for idx, role := range currentNode.Roles {
+		roles[idx] = role.Name
+	}
+
+	table.Entries = [][]any{
+		{"Index", index},
+		{"Current node", currentNode.Name},
+		{"Current k8s node", currentNode.Attributes["k8s_node_name"]},
+		{"Current node address", currentNode.TransportAddress},
+		{"Current node id", currentNode.Id},
+		{"Current node weight", currentNode.WeightRanking},
+		{"Current node roles", roles},
+		{"Can rebalance cluster", res.CanRebalanceCluster.Name},
+		{"Can rebalance to another node", res.CanRebalanceToOtherNode.Name},
+		{"Can remain on current node", res.CanRemainOnCurrentNode.Name},
+	}
+
+	if err := table.Print(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+/*
+func IndexModify(conf *cfg.Config, index string) error {
+	settings := esdsl.NewIndexSettings().NumberOfReplicas(strconv.Itoa(conf.Replicas))
+
+	_, err := conf.DefaultCluster.ES().Indices.PutSettings().
+		Indices(index).
+		Index(settings).
+		Do(context.Background())
+	if err != nil {
+		return fmt.Errorf("failed to modify index settings: %s", esErrorString(err))
+	}
+
+	return nil
+}
+*/
+
 func IndexFields(conf *cfg.Config, index string) error {
 	res, err := conf.DefaultCluster.ES().FieldCaps().
 		Index(index).
 		Fields("*").
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to retrieve field capabilties: %w", esErrorString(err))
+		return fmt.Errorf("failed to retrieve field capabilties: %s", esErrorString(err))
 	}

 	table := printer.NewTable(conf, 5, 0)
 	table.Addheaders("field", "type", "searchable", "aggretable", "metadata")

 	idx := 0
-
 	for name, field := range res.Fields {
 		for fieldtype, caps := range field {
 			// fields only have 1 type, so this one is it
--- a/pkg/es/index_alias.go
+++ b/pkg/es/index_alias.go
@@ -35,7 +35,7 @@ func IndexAliasCreate(conf *cfg.Config, index, alias string) error {
 	slog.Debug("create alias", "result", res)

 	if err != nil {
-		return fmt.Errorf("failed to create index alias: %w", esErrorString(err))
+		return fmt.Errorf("failed to create index alias: %s", esErrorString(err))
 	}

 	return nil
@@ -52,8 +52,9 @@ func IndexAliasList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Indices.GetAlias().
 		Index("_all").
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to list index aliases: %w", esErrorString(err))
+		return fmt.Errorf("failed to list index aliases: %s", esErrorString(err))
 	}

 	slog.Debug("aliases list", "result", res)
@@ -101,7 +102,7 @@ func IndexAliasDelete(conf *cfg.Config, index, alias string) error {
 	slog.Debug("delete alias", "result", res)

 	if err != nil {
-		return fmt.Errorf("failed to delete index alias: %w", esErrorString(err))
+		return fmt.Errorf("failed to delete index alias: %s", esErrorString(err))
 	}

 	return nil
@@ -109,8 +110,9 @@ func IndexAliasDelete(conf *cfg.Config, index, alias string) error {

 func IndexAliasRollover(conf *cfg.Config, alias string) error {
 	res, err := RolloverAlias(conf, alias)
+
 	if err != nil {
-		return fmt.Errorf("failed to rollover index alias: %w", esErrorString(err))
+		return fmt.Errorf("failed to rollover index alias: %s", esErrorString(err))
 	}

 	table := printer.NewTable(conf, 2, 5)
--- a/pkg/es/index_template.go
+++ b/pkg/es/index_template.go
@@ -22,7 +22,6 @@ import (
 	"errors"
 	"fmt"
 	"log/slog"
-	"maps"
 	"strconv"
 	"strings"

@@ -36,8 +35,9 @@ import (
 func IndexTemplateList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Indices.GetIndexTemplate().
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to get index templates: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index templates: %s", esErrorString(err))
 	}

 	slog.Debug("res", "index templates", res)
@@ -55,7 +55,6 @@ func IndexTemplateList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -63,8 +62,9 @@ func IndexTemplateShow(conf *cfg.Config, tplname string) error {
 	res, err := conf.DefaultCluster.ES().Indices.GetIndexTemplate().
 		Name(tplname).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to get index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index template: %s", esErrorString(err))
 	}

 	slog.Debug("res", "index template", res)
@@ -108,11 +108,10 @@ func IndexTemplateShow(conf *cfg.Config, tplname string) error {

 	err = getIndexTemplateSettings(conf, tplname, table)
 	if err != nil {
-		return err
+		return nil
 	}

 	fmt.Println()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -137,7 +136,6 @@ func IndexTemplateShow(conf *cfg.Config, tplname string) error {
 		}

 		fmt.Println()
-
 		if err := table.Print(); err != nil {
 			return err
 		}
@@ -225,8 +223,9 @@ func IndexTemplateCreate(conf *cfg.Config, name string, mappings []string) error
 	create.IndexPatterns(conf.Patterns...)

 	_, err := create.Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to create index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to create index template: %s", esErrorString(err))
 	}

 	return nil
@@ -241,8 +240,9 @@ func IndexTemplateModify(conf *cfg.Config, name string, mappings []string) error
 	res, err := conf.DefaultCluster.ES().Indices.GetIndexTemplate().
 		Name(name).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to get index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index template: %s", esErrorString(err))
 	}

 	slog.Debug("res", "index template", res)
@@ -334,8 +334,9 @@ func IndexTemplateModify(conf *cfg.Config, name string, mappings []string) error
 	modify.IndexPatterns(patterns...)

 	_, err = modify.Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to modify index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to modify index template: %s", esErrorString(err))
 	}

 	if conf.Rollover {
@@ -351,7 +352,7 @@ func IndexTemplateDelete(conf *cfg.Config, name string) error {
 	_, err := conf.DefaultCluster.ES().Indices.DeleteIndexTemplate(name).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to delete index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to delete index template: %s", esErrorString(err))
 	}

 	return nil
@@ -364,8 +365,9 @@ func rolloverAliasIndexTemplate(conf *cfg.Config, name string) error {
 	res, err := conf.DefaultCluster.ES().Indices.GetIndexTemplate().
 		Name(name).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to get index template: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index template: %s", esErrorString(err))
 	}

 	slog.Debug("res", "index template", res)
@@ -382,7 +384,7 @@ func rolloverAliasIndexTemplate(conf *cfg.Config, name string) error {
 		res, err := conf.DefaultCluster.ES().Indices.ResolveIndex(pattern).
 			Do(context.Background())
 		if err != nil {
-			return fmt.Errorf("failed to resolve index pattern: %w", esErrorString(err))
+			return fmt.Errorf("failed to resolve index pattern: %s", esErrorString(err))
 		}

 		for _, index := range res.Indices {
@@ -414,6 +416,7 @@ func rolloverAliasIndexTemplate(conf *cfg.Config, name string) error {
 	}

 	return nil
+
 }

 func modMappings(mappings []string) (types.TypeMappingVariant, error) {
@@ -445,7 +448,9 @@ func modMappings(mappings []string) (types.TypeMappingVariant, error) {
 func modMeta(conf *cfg.Config, meta types.Metadata) (map[string]json.RawMessage, error) {
 	metadata := map[string]json.RawMessage{}

-	maps.Copy(metadata, meta)
+	for key, value := range meta {
+		metadata[key] = value
+	}

 	for _, meta := range conf.Meta {
 		parts := strings.Split(meta, ":")
--- a/pkg/es/index_template_settings.go
+++ b/pkg/es/index_template_settings.go
@@ -43,7 +43,6 @@ func getIndexTemplateSettings(conf *cfg.Config, tplname string, table *printer.T
 		if err != nil {
 			return err
 		}
-
 		fmt.Println(output)
 	}

--- a/pkg/es/license.go
+++ b/pkg/es/license.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"strconv"

 	"codeberg.org/scip/esctl/pkg/cfg"
 	"codeberg.org/scip/esctl/pkg/printer"
@@ -30,7 +29,7 @@ func LicenseShow(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().License.Get().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get license: %w", esErrorString(err))
+		return fmt.Errorf("failed to get license: %s", esErrorString(err))
 	}

 	slog.Debug("license show", "license", res)
@@ -39,14 +38,12 @@ func LicenseShow(conf *cfg.Config) error {

 	lic := res.License

-	var (
-		maxnodes = "infinite"
-		maxunits = "infinite"
-		expire   = "never"
-	)
+	var maxnodes = "infinite"
+	var maxunits = "infinite"
+	var expire = "never"

 	if lic.MaxNodes != nil {
-		maxnodes = strconv.FormatInt(*lic.MaxNodes, 10)
+		maxnodes = fmt.Sprintf("%d", *lic.MaxNodes)
 	}

 	if lic.ExpiryDate != nil {
@@ -54,7 +51,7 @@ func LicenseShow(conf *cfg.Config) error {
 	}

 	if lic.MaxResourceUnits != nil {
-		maxunits = strconv.Itoa(*lic.MaxResourceUnits)
+		maxunits = fmt.Sprintf("%d", *lic.MaxResourceUnits)
 	}

 	table.Entries = [][]any{
--- a/pkg/es/node.go
+++ b/pkg/es/node.go
@@ -20,7 +20,6 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
-	"strconv"
 	"strings"
 	"time"

@@ -33,7 +32,7 @@ func NodeList(conf *cfg.Config) error {
 	// get nodes
 	nodes, err := conf.DefaultCluster.ES().Cat.Nodes().Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get nodes: %w", esErrorString(err))
+		return fmt.Errorf("failed to get nodes: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "nodes", nodes)
@@ -54,7 +53,6 @@ func NodeList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -66,7 +64,7 @@ func NodeNames(conf *cfg.Config) ([]string, error) {
 	nodes, err := conf.DefaultCluster.ES().Cat.Nodes().
 		Do(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("failed to get nodes: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get nodes: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "nodes", nodes)
@@ -88,7 +86,7 @@ func NodeShow(conf *cfg.Config, nodename string) error {
 		Metric("os, jvm, thread_pool, remote_cluster_server").
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get node info: %w", esErrorString(err))
+		return fmt.Errorf("failed to get node info: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "node", res)
@@ -97,7 +95,7 @@ func NodeShow(conf *cfg.Config, nodename string) error {
 		NodeId(nodename).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get node stats: %w", esErrorString(err))
+		return fmt.Errorf("failed to get node stats: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "stat", stats)
@@ -161,7 +159,7 @@ func NodeClients(conf *cfg.Config, nodename string) error {
 		NodeId(nodename).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get node stats: %w", esErrorString(err))
+		return fmt.Errorf("failed to get node stats: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "stat", stats)
@@ -189,7 +187,7 @@ func NodeClients(conf *cfg.Config, nodename string) error {

 				table.AddRow(
 					agent,
-					strconv.FormatInt(*client.Id, 10),
+					fmt.Sprintf("%d", *client.Id),
 					time.UnixMilli(*client.LastRequestTimeMillis).String(),
 					*client.RemoteAddress,
 					uri,
@@ -201,6 +199,5 @@ func NodeClients(conf *cfg.Config, nodename string) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }
--- a/pkg/es/parallel.go
+++ b/pkg/es/parallel.go
@@ -69,8 +69,7 @@ func getApiData(
 	which string) {
 	defer wg.Done()

-	apiRes := apiResponse{}
-
+	ar := apiResponse{}
 	var arerr error

 	switch which {
@@ -78,47 +77,47 @@ func getApiData(
 		res, err := es.Cluster.Health().
 			Do(context.Background())

-		apiRes.health = res
-		apiRes.which = ResponseHealth
+		ar.health = res
+		ar.which = ResponseHealth
 		arerr = err

 	case "healthreport":
 		report, err := getHealthReport(conf)

-		apiRes.healthreport = report
-		apiRes.which = ResponseHealthReport
+		ar.healthreport = report
+		ar.which = ResponseHealthReport
 		arerr = err

 	case "info":
 		res, err := es.Info().
 			Do(context.Background())

-		apiRes.info = res
-		apiRes.which = ResponseInfo
+		ar.info = res
+		ar.which = ResponseInfo
 		arerr = err

 	case "ccr":
 		res, err := es.Ccr.Stats().
 			Do(context.Background())

-		apiRes.ccr = res
-		apiRes.which = ResponseCcr
+		ar.ccr = res
+		ar.which = ResponseCcr
 		arerr = err

 	case "stats":
 		res, err := es.Cluster.Stats().
 			Do(context.Background())

-		apiRes.stats = res
-		apiRes.which = ResponseStats
+		ar.stats = res
+		ar.which = ResponseStats
 		arerr = err

 	case "indices":
 		res, err := es.Cat.Indices().
 			Do(context.Background())

-		apiRes.indices = &res
-		apiRes.which = ResponseIndices
+		ar.indices = &res
+		ar.which = ResponseIndices
 		arerr = err

 	case "indicesbytes":
@@ -127,16 +126,16 @@ func getApiData(
 			Bytes(bytes.Bytes{Name: "b"}).
 			Do(context.Background())

-		apiRes.indicesbytes = &res
-		apiRes.which = ResponseIndices
+		ar.indicesbytes = &res
+		ar.which = ResponseIndices
 		arerr = err

 	case "tasks":
 		res, err := es.Cat.Tasks().
 			Do(context.Background())

-		apiRes.tasks = &res
-		apiRes.which = ResponseTasks
+		ar.tasks = &res
+		ar.which = ResponseTasks
 		arerr = err

 	case "explain":
@@ -144,8 +143,8 @@ func getApiData(
 			ExplainLifecycle("_all").
 			Do(context.Background())

-		apiRes.explainlifecycle = res
-		apiRes.which = ResponseExplain
+		ar.explainlifecycle = res
+		ar.which = ResponseExplain
 		arerr = err

 	case "policies":
@@ -153,14 +152,14 @@ func getApiData(
 			GetLifecycle().
 			Do(context.Background())

-		apiRes.lifecycle = &res
-		apiRes.which = ResponseLifecycle
+		ar.lifecycle = &res
+		ar.which = ResponseLifecycle
 		arerr = err
 	}

 	if arerr != nil {
-		apiRes.error = fmt.Errorf("failed to get data from API: %w", arerr)
+		ar.error = fmt.Errorf("failed to get data from API: %s", arerr)
 	}

-	reschan <- apiRes
+	reschan <- ar
 }
--- a/pkg/es/role.go
+++ b/pkg/es/role.go
@@ -30,11 +30,10 @@ func RoleNames(conf *cfg.Config) ([]string, error) {
 	res, err := conf.DefaultCluster.ES().Security.GetRole().
 		Do(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("failed to get roles: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get roles: %s", esErrorString(err))
 	}

 	roles := make([]string, len(res))
-
 	idx := 0
 	for name := range res {
 		roles[idx] = name
@@ -48,7 +47,7 @@ func RoleList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Security.GetRole().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get roles: %w", esErrorString(err))
+		return fmt.Errorf("failed to get roles: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "roles", res)
@@ -67,7 +66,6 @@ func RoleList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -76,7 +74,7 @@ func RoleShow(conf *cfg.Config, rolename string) error {
 		Name(rolename).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get role: %w", esErrorString(err))
+		return fmt.Errorf("failed to get role: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "role", res)
@@ -134,9 +132,7 @@ func roleRemoteClusters(conf *cfg.Config, role types.Role) error {

 	table := printer.NewTable(conf, 2, len(role.RemoteCluster))
 	table.Addheaders("remote cluster", "privilege")
-
 	idx := 0
-
 	for _, priv := range role.RemoteCluster {
 		perms := []string{}
 		for _, perm := range priv.Privileges {
@@ -149,7 +145,6 @@ func roleRemoteClusters(conf *cfg.Config, role types.Role) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -160,7 +155,6 @@ func roleClusters(conf *cfg.Config, role types.Role) error {

 	table := printer.NewTable(conf, 1, len(role.Cluster))
 	table.Addheaders("cluster rights")
-
 	idx := 0
 	for _, cluster := range role.Cluster {
 		table.Entries[idx] = []any{cluster.Name}
@@ -168,7 +162,6 @@ func roleClusters(conf *cfg.Config, role types.Role) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -179,9 +172,7 @@ func roleRemoteIndices(conf *cfg.Config, role types.Role) error {

 	table := printer.NewTable(conf, 3, len(role.RemoteIndices))
 	table.Addheaders("remote index names", "index permissions", "allow restricted")
-
 	idx := 0
-
 	for _, priv := range role.RemoteIndices {
 		perms := []string{}
 		for _, perm := range priv.Privileges {
@@ -194,7 +185,6 @@ func roleRemoteIndices(conf *cfg.Config, role types.Role) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -205,9 +195,7 @@ func roleIndices(conf *cfg.Config, role types.Role) error {

 	table := printer.NewTable(conf, 3, len(role.Indices))
 	table.Addheaders("index names", "index permissions", "allow restricted")
-
 	idx := 0
-
 	for _, priv := range role.Indices {
 		perms := []string{}
 		for _, perm := range priv.Privileges {
@@ -220,7 +208,6 @@ func roleIndices(conf *cfg.Config, role types.Role) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }

@@ -231,7 +218,6 @@ func roleApplications(conf *cfg.Config, role types.Role) error {

 	table := printer.NewTable(conf, 3, len(role.Applications))
 	table.Addheaders("application", "privileges", "resources")
-
 	idx := 0
 	for _, priv := range role.Applications {
 		table.Entries[idx] = []any{
@@ -244,6 +230,5 @@ func roleApplications(conf *cfg.Config, role types.Role) error {
 	}

 	table.Sort()
-
 	return table.Print()
 }
--- a/pkg/es/role_diff.go
+++ b/pkg/es/role_diff.go
@@ -75,7 +75,7 @@ type Register struct {
 func getCsvRecords(conf *cfg.Config, csvfile string) (map[string]Record, error) {
 	data, err := os.ReadFile(csvfile)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read CSV file: %w", err)
+		return nil, fmt.Errorf("failed to read CSV file: %s", err)
 	}

 	csvreader := csv.NewReader(bytes.NewReader(data))
@@ -85,7 +85,7 @@ func getCsvRecords(conf *cfg.Config, csvfile string) (map[string]Record, error)

 	rows, err := csvreader.ReadAll()
 	if err != nil {
-		return nil, fmt.Errorf("failed to parse CSV: %w", err)
+		return nil, fmt.Errorf("failed to parse CSV: %s", err)
 	}

 	records := make(map[string]Record, len(rows)-1)
@@ -118,7 +118,7 @@ func getCsvRecords(conf *cfg.Config, csvfile string) (map[string]Record, error)
 func getCsvRecord(conf *cfg.Config, csvfile, rolename string) (*Record, error) {
 	fd, err := os.Open(csvfile)
 	if err != nil {
-		return nil, fmt.Errorf("failed to open CSV file: %w", err)
+		return nil, fmt.Errorf("failed to open CSV file: %s", err)
 	}
 	defer func() {
 		if err := fd.Close(); err != nil {
@@ -179,7 +179,6 @@ func diffRoles(conf *cfg.Config, records map[string]Record, res getrole.Response
 	// iterate over records from CSV and register only those which are not deployed
 	for name := range records {
 		reg := Register{name: name, defined: true}
-
 		_, deployed := deployed[name]
 		if !deployed {
 			rows = append(rows, reg)
@@ -211,7 +210,7 @@ func RoleDiff(conf *cfg.Config, csvfile, role string) error {
 	res, err := conf.DefaultCluster.ES().Security.GetRole().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get roles: %w", esErrorString(err))
+		return fmt.Errorf("failed to get roles: %s", esErrorString(err))
 	}

 	rows := diffRoles(conf, records, res)
@@ -246,11 +245,10 @@ func getRoleMappingGroups(conf *cfg.Config, rolename string) ([]string, error) {
 	mappings, err := conf.DefaultCluster.ES().Security.GetRoleMapping().
 		Do(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("failed to get role mappings: %w", esErrorString(err))
+		return nil, fmt.Errorf("failed to get role mappings: %s", esErrorString(err))
 	}

 	groups := []string{}
-
 	for _, mapping := range mappings {
 		if slices.Contains(mapping.Roles, rolename) {
 			for _, rule := range mapping.Rules.Any {
@@ -264,13 +262,13 @@ func getRoleMappingGroups(conf *cfg.Config, rolename string) ([]string, error) {
 	return groups, nil
 }

-func compareSlices(name string, left, right []string) {
-	slices.Sort(left)
-	slices.Sort(right)
+func compareSlices(name string, a, b []string) {
+	slices.Sort(a)
+	slices.Sort(b)

-	if slices.Compare(left, right) != 0 {
+	if slices.Compare(a, b) != 0 {
 		fmt.Printf("%s differs:\ndeployed: %s\n     csv: %s\n",
-			name, strings.Join(left, ","), strings.Join(right, ","))
+			name, strings.Join(a, ","), strings.Join(b, ","))
 	} else {
 		fmt.Printf("deployed %s matches csv definition\n", name)
 	}
@@ -281,7 +279,7 @@ func RoleDiffSingle(conf *cfg.Config, csvfile, rolename string) error {
 		Name(rolename).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get role: %w", esErrorString(err))
+		return fmt.Errorf("failed to get role: %s", esErrorString(err))
 	}

 	record, err := getCsvRecord(conf, csvfile, rolename)
@@ -291,19 +289,16 @@ func RoleDiffSingle(conf *cfg.Config, csvfile, rolename string) error {

 	if !record.defined {
 		fmt.Printf("role %s is not defined\n", rolename)
-
 		return nil
 	}

 	role, exists := res[rolename]
 	if !exists {
 		fmt.Printf("role %s is not deployed\n", rolename)
-
 		return nil
 	} else {
 		fmt.Printf("role %s is deployed\n", rolename)
 	}
-
 	slog.Debug("found role", "role", role)

 	if conf.Debug {
@@ -315,7 +310,6 @@ func RoleDiffSingle(conf *cfg.Config, csvfile, rolename string) error {
 	if err != nil {
 		return err
 	}
-
 	slog.Debug("group mappings", "groups", groups)

 	// check cluster setting
@@ -327,7 +321,6 @@ func RoleDiffSingle(conf *cfg.Config, csvfile, rolename string) error {
 	// check index names+privs
 	indices := []string{}
 	privs := []string{}
-
 	for _, index := range role.Indices {
 		for _, name := range index.Names {
 			indices = append(indices, strings.ReplaceAll(name, "**", "*"))
@@ -340,7 +333,6 @@ func RoleDiffSingle(conf *cfg.Config, csvfile, rolename string) error {

 	// check kibana application space
 	spaces := []string{}
-
 	for _, app := range role.Applications {
 		for _, resource := range app.Resources {
 			if strings.Contains(resource, "space:") {
--- a/pkg/es/rollover.go
+++ b/pkg/es/rollover.go
@@ -31,17 +31,14 @@ func RolloverConditions(conf *cfg.Config) types.RolloverConditionsVariant {
 	if conf.MaxAge != "" {
 		cond.MaxAge(esdsl.NewDuration().String(conf.MaxAge))
 	}
-
 	if conf.MaxDocs > 0 {
 		cond.MaxDocs(int64(conf.MaxDocs))
 	}
-
 	if conf.MaxShardSize > 0 {
 		bs := esdsl.NewByteSize()
 		bs.Int64(int64(conf.MaxShardSize))
 		cond.MaxPrimaryShardSize(bs)
 	}
-
 	if conf.MaxShardDocs > 0 {
 		cond.MaxPrimaryShardDocs(int64(conf.MaxShardDocs))
 	}
--- a/pkg/es/search.go
+++ b/pkg/es/search.go
@@ -82,13 +82,13 @@ func explainSearch(conf *cfg.Config, search *search.Search) error {
 		Size(1). // one's enough for explain
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to call explain search (esdsl): %w", esErrorString(err))
+		return fmt.Errorf("failed to call explain search (esdsl): %s", esErrorString(err))
 	}

 	if conf.Debug {
 		raw, err := json.Marshal(res)
 		if err != nil {
-			return fmt.Errorf("failed to marshal explain result: %w", err)
+			return fmt.Errorf("failed to marshal explain result: %s", err)
 		}

 		value := gjson.Get(string(raw), "hits.hits.0._explanation")
@@ -111,7 +111,6 @@ func explainSearch(conf *cfg.Config, search *search.Search) error {

 func explain(res *types.ExplanationDetail, indent string) {
 	fmt.Println(indent + "- " + res.Description)
-
 	for _, ex := range res.Details {
 		fmt.Println(indent + "  - " + ex.Description)
 		fmt.Println(indent + fmt.Sprintf("    score: %f", res.Value))
@@ -135,7 +134,7 @@ func validateSearch(conf *cfg.Config, queries []string) error {
 	res, err := validate.
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to validate search (esdsl): %w", esErrorString(err))
+		return fmt.Errorf("failed to validate search (esdsl): %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "search", res)
@@ -155,7 +154,7 @@ func searchOnce(conf *cfg.Config, search *search.Search) error {
 		Size(conf.To).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to run search (esdsl): %w", esErrorString(err))
+		return fmt.Errorf("failed to run search (esdsl): %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "search", res)
@@ -168,10 +167,9 @@ func searchOnce(conf *cfg.Config, search *search.Search) error {
 // https://www.elastic.co/docs/reference/elasticsearch/clients/go/using-the-api/searching#_pit_search_after
 func searchPit(conf *cfg.Config, req *search.Request) error {
 	ctx := context.Background()
-
 	pit, err := conf.DefaultCluster.ES().OpenPointInTime(conf.Index).KeepAlive("1m").Do(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to open point-in-time request for search: %w", err)
+		return fmt.Errorf("failed to open point-in-time request for search: %s", err)
 	}
 	defer func() {
 		_, err := conf.DefaultCluster.ES().ClosePointInTime().Id(pit.Id).Do(ctx)
@@ -194,7 +192,7 @@ func searchPit(conf *cfg.Config, req *search.Request) error {
 	for {
 		res, err := search.Do(ctx)
 		if err != nil {
-			return fmt.Errorf("failed to run search (esdsl pit): %w", esErrorString(err))
+			return fmt.Errorf("failed to run search (esdsl pit): %s", esErrorString(err))
 		}

 		if len(res.Hits.Hits) == 0 {
@@ -224,7 +222,7 @@ func searchTail(conf *cfg.Config, search *search.Search) error {
 	for {
 		res, err := search.Do(context.Background())
 		if err != nil {
-			return fmt.Errorf("failed to run search (esdsl): %w", esErrorString(err))
+			return fmt.Errorf("failed to run search (esdsl): %s", esErrorString(err))
 		}

 		slog.Debug("ES result", "search", res)
--- a/pkg/es/search_filter.go
+++ b/pkg/es/search_filter.go
@@ -63,7 +63,6 @@ type filter struct {
 // must match literally, and range filters using -r "@timestamp:2026-05-28T10:00:00 to now"
 func NewFilter(query string) (*filter, error) {
 	var separator string
-
 	var criteria int // we use the constants on top for this

 	switch {
@@ -77,7 +76,7 @@ func NewFilter(query string) (*filter, error) {

 	part := strings.Split(query, separator)
 	if len(part) != 2 {
-		return nil, errors.New("search queries must be in the form field<sep>pattern where <sep> must be one of: = or !=")
+		return nil, fmt.Errorf("search queries must be in the form field<sep>pattern where <sep> must be one of: = or !=")
 	}

 	flt := &filter{term: part[0], filter: part[1], criteria: criteria}
@@ -235,6 +234,7 @@ func addFilters(conf *cfg.Config) ([]types.QueryVariant, error) {
 		}

 		filters[count-1] = rng
+
 	}

 	return filters, nil
@@ -247,6 +247,7 @@ func addSort(conf *cfg.Config, search *search.Search) *search.Search {
 		Index(conf.Index).
 		Fields(conf.SortBy).
 		Do(context.Background())
+
 	if err != nil {
 		// whatever it was, do not add Sort()
 		slog.Debug("get field capabilities", "field", conf.SortBy, "error", esErrorString(err))
--- a/pkg/es/shard.go
+++ b/pkg/es/shard.go
@@ -40,7 +40,8 @@ func colorzizeShard(conf *cfg.Config, state, name string) string {
 }

 func resolvePrirep(state string) string {
-	if state == "p" {
+	switch state {
+	case "p":
 		return "primary"
 	}

@@ -85,7 +86,7 @@ func ShardList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Cat.Shards().
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get shards: %w", esErrorString(err))
+		return fmt.Errorf("failed to get shards: %s", esErrorString(err))
 	}

 	shardlist := filterShards(conf, res)
@@ -124,7 +125,6 @@ func printShards(conf *cfg.Config, shardlist shards.Response) error {
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -136,7 +136,7 @@ func ShardShow(conf *cfg.Config, index string) error {
 	res, err := conf.DefaultCluster.ES().Cat.Shards().Index(index).
 		Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get shards: %w", esErrorString(err))
+		return fmt.Errorf("failed to get shards: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "shards", res)
@@ -145,63 +145,3 @@ func ShardShow(conf *cfg.Config, index string) error {

 	return printShards(conf, res)
 }
-
-func ShardAllocation(conf *cfg.Config, index string) error {
-	explain := conf.DefaultCluster.ES().Cluster.AllocationExplain().
-		Index(index).
-		Primary(conf.Primary).
-		Shard(conf.Shards)
-
-	if conf.FromNode != "" {
-		explain.CurrentNode(conf.FromNode)
-	}
-
-	res, err := explain.Do(context.Background())
-	if err != nil {
-		return fmt.Errorf("failed to get shard allocation explain: %w", esErrorString(err))
-	}
-
-	slog.Debug("ES result", "explain", res)
-
-	currentNode := res.CurrentNode
-
-	table := printer.NewTable(conf, 2, 10)
-	table.Addheaders("shard allocation setting", "value")
-
-	roles := make([]string, len(currentNode.Roles))
-	for idx, role := range currentNode.Roles {
-		roles[idx] = role.Name
-	}
-
-	table.Entries = [][]any{
-		{"Index", index},
-		{"Current state", res.CurrentState},
-		{"Current node", currentNode.Name},
-		{"Current k8s node", currentNode.Attributes["k8s_node_name"]},
-		{"Current node address", currentNode.TransportAddress},
-		{"Current node id", currentNode.Id},
-		{"Current node weight", currentNode.WeightRanking},
-		{"Current node roles", roles},
-		{"Can rebalance cluster", res.CanRebalanceCluster.Name},
-		{"Can rebalance to another node", res.CanRebalanceToOtherNode.Name},
-		{"Can remain on current node", res.CanRemainOnCurrentNode.Name},
-	}
-
-	if res.CurrentState == "unassigned" {
-		table.AddRow("Unassignment reason", res.UnassignedInfo.Reason.String()+" at "+res.UnassignedInfo.At.(string))
-	}
-
-	for _, nodeDecision := range res.NodeAllocationDecisions {
-		for _, decider := range nodeDecision.Deciders {
-			table.AddRow("Allocation decider", decider.Decider)
-			table.AddRow("    -> decision", decider.Decision.String())
-			table.AddRow("    -> explanation", decider.Explanation)
-		}
-	}
-
-	if err := table.Print(); err != nil {
-		return err
-	}
-
-	return nil
-}
--- a/pkg/es/snapshot.go
+++ b/pkg/es/snapshot.go
@@ -45,7 +45,7 @@ func SnapshotList(conf *cfg.Config) error {
 	// get partial indicies
 	ires, err := conf.DefaultCluster.ES().Cat.Indices().Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get indicies: %w", esErrorString(err))
+		return fmt.Errorf("failed to get indicies: %s", esErrorString(err))
 	}

 	indicies := map[string]int{}
@@ -58,7 +58,7 @@ func SnapshotList(conf *cfg.Config) error {
 	// get snapshots
 	sres, err := conf.DefaultCluster.ES().Cat.Snapshots().Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get snapshots: %w", esErrorString(err))
+		return fmt.Errorf("failed to get snapshots: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "indicies", sres)
@@ -98,7 +98,6 @@ func SnapshotList(conf *cfg.Config) error {
 	}

 	table.Sort()
-
 	if err := table.Print(); err != nil {
 		return err
 	}
@@ -109,7 +108,7 @@ func SnapshotList(conf *cfg.Config) error {
 func SnapshotShow(conf *cfg.Config, snapshot string) error {
 	res, err := conf.DefaultCluster.ES().Snapshot.Get("*", snapshot).Do(context.Background())
 	if err != nil {
-		return fmt.Errorf("failed to get snapshot: %w", esErrorString(err))
+		return fmt.Errorf("failed to get snapshot: %s", esErrorString(err))
 	}

 	slog.Debug("ES result", "snapshot", res)
--- a/pkg/es/task.go
+++ b/pkg/es/task.go
@@ -30,15 +30,15 @@ import (
 func TaskList(conf *cfg.Config) error {
 	res, err := conf.DefaultCluster.ES().Cat.Tasks().
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to get index templates: %w", esErrorString(err))
+		return fmt.Errorf("failed to get index templates: %s", esErrorString(err))
 	}

 	slog.Debug("res", "tasks", res)

 	table := printer.NewTable(conf, 8, len(res))
 	table.Addheaders("task id", "action", "start time", "run time", "node", "type")
-
 	for idx, task := range res {
 		var ts time.Time

@@ -66,8 +66,9 @@ func TaskCancel(conf *cfg.Config, taskid string) error {
 	_, err := conf.DefaultCluster.ES().Tasks.Cancel().
 		TaskId(taskid).
 		Do(context.Background())
+
 	if err != nil {
-		return fmt.Errorf("failed to cancel task: %w", esErrorString(err))
+		return fmt.Errorf("failed to cancel task: %s", esErrorString(err))
 	}

 	return nil
--- a/pkg/printer/cast.go
+++ b/pkg/printer/cast.go
@@ -26,7 +26,6 @@ import (
 )

 func any2string(in any) string {
-	//nolint:gocritic
 	switch val := in.(type) {
 	case string:
 		return val
@@ -46,10 +45,10 @@ func any2string(in any) string {
 		return val.Format("2006-01-02 15:04:05")
 	case []byte:
 		return string(val)
+	case types.DateTime, types.Percentage:
+		return val.(string)
 	case nil:
 		return "null"
-	case types.Percentage, types.DateTime:
-		return val.(string)
 	}

 	return ""
@@ -79,7 +78,6 @@ func (data *Table) preprocessRows() {
 	// determine max width per column
 	for _, entries := range data.rows {
 		currentWidth := 0
-
 		for idx, entry := range entries {
 			length := visibleLen(entry)

--- a/pkg/printer/doc.go
+++ b/pkg/printer/doc.go
@@ -33,6 +33,7 @@ func PrintDocs(conf *cfg.Config, hits []types.Hit) {
 	for _, hit := range hits {
 		PrintDoc(conf, hit)
 	}
+
 }

 func PrintDoc(conf *cfg.Config, hit types.Hit) {
--- a/pkg/printer/pager.go
+++ b/pkg/printer/pager.go
@@ -34,14 +34,12 @@ var (
 	titleStyle = func() lipgloss.Style {
 		b := lipgloss.RoundedBorder()
 		b.Right = "├"
-
 		return lipgloss.NewStyle().BorderStyle(b).Padding(0, 1)
 	}()

 	infoStyle = func() lipgloss.Style {
 		b := lipgloss.RoundedBorder()
 		b.Left = "┤"
-
 		return titleStyle.BorderStyle(b)
 	}()
 )
@@ -58,9 +56,10 @@ func (m model) Init() tea.Cmd {
 }

 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmd tea.Cmd
-
-	cmds := make([]tea.Cmd, 1)
+	var (
+		cmd  tea.Cmd
+		cmds []tea.Cmd
+	)

 	switch msg := msg.(type) {
 	case tea.KeyMsg:
@@ -91,7 +90,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 	// Handle keyboard and mouse events in the viewport
 	m.viewport, cmd = m.viewport.Update(msg)
-	cmds[0] = cmd
+	cmds = append(cmds, cmd)

 	return m, tea.Batch(cmds...)
 }
@@ -100,7 +99,6 @@ func (m model) View() string {
 	if !m.ready {
 		return "\n  Initializing..."
 	}
-
 	return fmt.Sprintf("%s\n%s\n%s", m.headerView(), m.viewport.View(), m.footerView())
 }

@@ -108,25 +106,30 @@ func (m model) headerView() string {
 	// title := titleStyle.Render("RPN Help Overview")
 	title := titleStyle.Render(m.title)
 	line := strings.Repeat("─", max(0, m.viewport.Width-lipgloss.Width(title)))
-
 	return lipgloss.JoinHorizontal(lipgloss.Center, title, line)
 }

 func (m model) footerView() string {
 	info := infoStyle.Render(fmt.Sprintf("%3.f%%", m.viewport.ScrollPercent()*100))
 	line := strings.Repeat("─", max(0, m.viewport.Width-lipgloss.Width(info)))
-
 	return lipgloss.JoinHorizontal(lipgloss.Center, line, info)
 }

+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
 func Pager(title, message string) {
-	pager := tea.NewProgram(
+	p := tea.NewProgram(
 		model{content: message, title: title},
 		tea.WithAltScreen(),       // use the full size of the terminal in its "alternate screen buffer"
 		tea.WithMouseCellMotion(), // turn on mouse support so we can track the mouse wheel
 	)

-	if _, err := pager.Run(); err != nil {
+	if _, err := p.Run(); err != nil {
 		fmt.Println("could not run pager:", err)
 		os.Exit(1)
 	}
--- a/pkg/printer/table.go
+++ b/pkg/printer/table.go
@@ -55,7 +55,6 @@ func NewTable(conf *cfg.Config, columns, rows int) *Table {
 func NewTableEmpty(conf *cfg.Config) *Table {
 	table := Table{Mode: conf.Output, maxwidth: cfg.GetTermWidth()}
 	table.alignInts = conf.AlignInts
-
 	return &table
 }

@@ -71,14 +70,14 @@ func (table *Table) WithHeaders(headers ...string) *Table {
 	return table
 }

-func (table *Table) Print() error {
-	switch table.Mode {
+func (data *Table) Print() error {
+	switch data.Mode {
 	case "json":
-		return table.PrintJSON()
+		return data.PrintJSON()
 	case "yaml":
-		return table.PrintYAML()
+		return data.PrintYAML()
 	default:
-		return table.PrintTSV()
+		return data.PrintTSV()
 	}
 }

@@ -86,12 +85,26 @@ var (
 	ansiCtrlSeq = regexp.MustCompile(`\033.[0-9;]+m`)
 )

-func (table *Table) PrintYAML() error {
-	raw := table.toMap()
+// needed for json and yaml output
+func (data *Table) toMap() []map[string]any {
+	raw := make([]map[string]any, len(data.Entries))
+
+	for idx, entries := range data.Entries {
+		raw[idx] = make(map[string]any, len(data.Headers))
+		for eidx, entry := range entries {
+			raw[idx][data.Headers[eidx]] = entry
+		}
+	}
+
+	return raw
+}
+
+func (data *Table) PrintYAML() error {
+	raw := data.toMap()

 	body, err := yaml.Marshal(raw)
 	if err != nil {
-		return fmt.Errorf("failed to produce YAML output: %w", err)
+		return fmt.Errorf("failed to produce YAML output: %s", err)
 	}

 	fmt.Println(string(body))
@@ -99,12 +112,12 @@ func (table *Table) PrintYAML() error {
 	return nil
 }

-func (table *Table) PrintJSON() error {
-	raw := table.toMap()
+func (data *Table) PrintJSON() error {
+	raw := data.toMap()

 	body, err := json.MarshalIndent(raw, "", "  ")
 	if err != nil {
-		return fmt.Errorf("failed to produce JSON output: %w", err)
+		return fmt.Errorf("failed to produce JSON output: %s", err)
 	}

 	fmt.Println(string(body))
@@ -112,35 +125,34 @@ func (table *Table) PrintJSON() error {
 	return nil
 }

-func (table *Table) PrintTSV() error {
+func (data *Table) PrintTSV() error {
 	// length's, convert cell types
-	table.preprocessRows()
+	data.preprocessRows()

 	// output headers
-	for idx, header := range table.Headers {
-		if idx+1 != len(table.Headers) {
-			fmt.Print(header, strings.Repeat(" ", table.lenHeaders[idx]-visibleLen(header)))
+	for idx, header := range data.Headers {
+		if idx+1 != len(data.Headers) {
+			fmt.Print(header, strings.Repeat(" ", data.lenHeaders[idx]-visibleLen(header)))
 		} else {
 			// no padding for last header
 			fmt.Print(header)
 		}

-		if idx < len(table.Headers)-1 {
+		if idx < len(data.Headers)-1 {
 			fmt.Print("  ")
 		}
 	}
-
 	fmt.Println()

-	for _, entries := range table.rows {
+	for _, entries := range data.rows {
 		currentWidth := 0

 		for idx, entry := range entries {
 			length := visibleLen(entry)

-			if length+currentWidth > table.maxwidth && table.maxwidth-currentWidth > 1 {
+			if length+currentWidth > data.maxwidth && data.maxwidth-currentWidth > 1 {
 				// text is too wide to be put into one line, wrap it
-				wrapper := wordwrap.Wrapper(table.maxwidth-currentWidth, false)
+				wrapper := wordwrap.Wrapper(data.maxwidth-currentWidth, false)
 				wrapped := wrapper(entry)

 				// and indent it
@@ -153,71 +165,55 @@ func (table *Table) PrintTSV() error {
 				}
 			}

-			currentWidth += table.lenHeaders[idx]
+			currentWidth += data.lenHeaders[idx]

-			switch {
-			case isInt(entry) && table.alignInts:
+			if isInt(entry) && data.alignInts {
 				// align right
-				fmt.Print(strings.Repeat(" ", table.lenHeaders[idx]-length), entry)
-			case length < table.lenHeaders[idx] && idx+1 != len(entries):
+				fmt.Print(strings.Repeat(" ", data.lenHeaders[idx]-length), entry)
+			} else if length < data.lenHeaders[idx] && idx+1 != len(entries) {
 				// pad right, if required
-				fmt.Print(entry, strings.Repeat(" ", table.lenHeaders[idx]-length))
-			default:
+				fmt.Print(entry, strings.Repeat(" ", data.lenHeaders[idx]-length))
+			} else {
 				// no padding for last entry
 				fmt.Print(entry)
 			}

-			if idx < len(table.Headers)-1 {
+			if idx < len(data.Headers)-1 {
 				fmt.Print("  ")
 			}
 		}
-
 		fmt.Println()
 	}

 	return nil
 }

-func (table *Table) Sort() {
+func (data *Table) Sort() {
 	// sanity checks
-	if len(table.Entries) == 0 {
+	if len(data.Entries) == 0 {
 		return
 	}

-	table.preprocessRows()
+	data.preprocessRows()

-	sort.Slice(table.rows, func(i, j int) bool {
-		return table.rows[i][0] < table.rows[j][0]
+	sort.Slice(data.rows, func(i, j int) bool {
+		return data.rows[i][0] < data.rows[j][0]
 	})
 }

-func (table *Table) Addheaders(headers ...string) {
+func (data *Table) Addheaders(headers ...string) {
 	for idx, header := range headers {
-		switch table.Mode {
+		switch data.Mode {
 		case "json", "yaml":
-			table.Headers[idx] = strings.ReplaceAll(strings.ToLower(header), " ", "_")
+			data.Headers[idx] = strings.ReplaceAll(strings.ToLower(header), " ", "_")
 		default:
-			table.Headers[idx] = bold(strings.ReplaceAll(strings.ToUpper(header), " ", "-"))
+			data.Headers[idx] = bold(strings.ReplaceAll(strings.ToUpper(header), " ", "-"))
 		}
 	}
 }

-func (table *Table) AddRow(fields ...any) {
-	table.Entries = append(table.Entries, fields)
-}
-
-// needed for json and yaml output
-func (table *Table) toMap() []map[string]any {
-	raw := make([]map[string]any, len(table.Entries))
-
-	for idx, entries := range table.Entries {
-		raw[idx] = make(map[string]any, len(table.Headers))
-		for eidx, entry := range entries {
-			raw[idx][table.Headers[eidx]] = entry
-		}
-	}
-
-	return raw
+func (data *Table) AddRow(fields ...any) {
+	data.Entries = append(data.Entries, fields)
 }

 // return the length of a string but only visible chars, w/o ansi color escapes
Author	SHA1	Message	Date
Thomas von Dein	3abe8b62a2	remove unneccessary fmt.Sprintf's	2026-07-07 06:43:34 +02:00
Thomas von Dein	86f17329b0	satisfy linter	2026-07-07 06:37:21 +02:00
Thomas von Dein	2d8ecae73b	conversion from string cells to any cells in printer.Table	2026-07-07 06:30:07 +02:00
Thomas von Dein	033dd0ccd1	add type caster to table, convert cells automatically, users use any	2026-07-07 06:29:40 +02:00
Thomas von Dein	0d81e5c3bc	remove markdown output support	2026-07-07 05:29:31 +02:00