Cli punchlist

app/root.go

@@ -78,22 +78,7 @@ func RootCmd() *cobra.Command {
 	cmd.AddCommand(verCmd.NewVersionCmd())
 
 	// Apply the custom help function to the current command
-	shared.SetSanitizedHelpFunc(cmd)
-
-	// Recursively apply to all subcommands
-	for _, subCmd := range cmd.Commands() {
-		applySanitizedHelpFuncRecursively(subCmd)
-	}
+	shared.ApplySanitizedHelpFuncRecursively(cmd)
 
 	return cmd
 }
-
-func applySanitizedHelpFuncRecursively(cmd *cobra.Command) {
-	// Apply the custom help function to the current command
-	shared.SetSanitizedHelpFunc(cmd)
-
-	// Recursively apply to all subcommands
-	for _, subCmd := range cmd.Commands() {
-		applySanitizedHelpFuncRecursively(subCmd)
-	}
-}

app/shared/generate/generate.go

@@ -13,6 +13,7 @@ import (
 type writeFunc func(string) (*os.File, error)
 
 func WriteDocs(cmd *cobra.Command, dir string) error {
+
 	return writeCmd(cmd, ".", 0, func(s string) (*os.File, error) {
 		fullPath := filepath.Join(dir, s)
 		err := os.MkdirAll(filepath.Dir(fullPath), 0755)
@@ -71,7 +72,7 @@ func createIndexFile(cmd *cobra.Command, dir string, write writeFunc, first bool
 
 	file.WriteString(header.String() + "\n\n")
 
-	return doc.GenMarkdownCustom(cmd, file, linkHandler(dir))
+	return doc.GenMarkdownCustom(cmd, file, linkHandler())
 }
 
 // createCmdFile creates a file for the command, and writes the command's documentation to it.
@@ -94,10 +95,10 @@ func createCmdFile(cmd *cobra.Command, dir string, idx int, write writeFunc) err
 
 	file.WriteString(header.String() + "\n\n")
 
-	return doc.GenMarkdownCustom(cmd, file, linkHandler(dir))
+	return doc.GenMarkdownCustom(cmd, file, linkHandler())
 }
 
-func linkHandler(dir string) func(string) string { // dir string unused -- what is it?
+func linkHandler() func(string) string {
 	return func(s string) string {
 		// trying just linking ids??
 		s = strings.TrimSuffix(s, ".md")

app/shared/help.go

@@ -18,8 +18,10 @@ func SetSanitizedHelpFunc(cmd *cobra.Command) {
 	originalHelpFunc := cmd.HelpFunc()
 
 	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		cmd.Short = removeBackticks(cmd.Short)
-		cmd.Long = removeBackticks(cmd.Long)
+		cmd.Short = wrapTextToTerminalWidth(removeBackticks(cmd.Short))
+		cmd.Long = wrapTextToTerminalWidth(removeBackticks(cmd.Long))
+		wrapFlags(cmd.Flags())
+		wrapFlags(cmd.PersistentFlags())
 
 		// Delegate to the original HelpFunc to avoid recursion
 		if originalHelpFunc != nil {
@@ -32,3 +34,11 @@ func SetSanitizedHelpFunc(cmd *cobra.Command) {
 		}
 	})
 }
+
+func ApplySanitizedHelpFuncRecursively(cmd *cobra.Command) {
+	SetSanitizedHelpFunc(cmd)
+
+	for _, subCmd := range cmd.Commands() {
+		ApplySanitizedHelpFuncRecursively(subCmd)
+	}
+}

app/shared/wrap.go

@@ -0,0 +1,170 @@
+package shared
+
+import (
+	"os"
+	"strings"
+
+	"github.com/spf13/pflag"
+	"golang.org/x/term"
+)
+
+// wrapTextToTerminalWidth wraps text by detecting the current
+// terminal width (columns) and using that as the wrap limit.
+// If it can't get the terminal width, it will wrap it to 80
+func wrapTextToTerminalWidth(text string) string {
+	// Get the terminal size from standard output.
+	width, _, err := term.GetSize(int(os.Stdout.Fd()))
+	if err != nil {
+		width = 80
+	}
+
+	return WrapText(text, width)
+}
+
+// WrapText wraps text by the specified width
+func WrapText(text string, width int) string {
+	return wrapText(text, width-2) // for safety, sometimes terminal still doesn't wrap properly
+}
+
+// wrapFlag wraps all flag descriptions. It does this by accounting for the characters
+// that are to the left of the flag description, as well as the terminal width.
+// If the width can't be determined, it won't wrap the flags.
+func wrapFlags(f *pflag.FlagSet) {
+	width, _, err := term.GetSize(int(os.Stdout.Fd()))
+	if err != nil {
+		return
+	}
+
+	/* example unwrapped output:
+	Flags:
+	      --csv string                CSV file containing the parameters to pass to the action
+	  -m, --csv-mapping stringArray   mapping of CSV columns to action parameters. format: "csv_column:action_param_name" OR "csv_column:action_param_position"
+	  -h, --help                      help for exec-action
+	  -n, --namespace string          namespace to execute the action in
+	  -N, --nonce int                 nonce override (-1 means request from server) (default -1)
+	  -p, --param stringArray         named parameters that will override any positional or CSV parameters. format: "name:type=value"
+	      --sync                      synchronous broadcast (wait for it to be included in a block)
+
+	Global Flags:
+	  -Y, --assume-yes           Assume yes for all prompts
+	      --chain-id string      the expected/intended Kwil Chain ID
+	  -c, --config string        the path to the Kwil CLI persistent global settings file (default "/Users/brennanlamey/.kwil-cli/config.json")
+	      --output string        the format for command output - either 'text' or 'json' (default "text")
+	      --private-key string   the private key of the wallet that will be used for signing
+	      --provider string      the Kwil provider RPC endpoint (default "http://127.0.0.1:8484")
+	  -S, --silence              Silence logs
+	*/
+
+	// we first find the widest flag (shorthand, long, and type).
+	// Cobra adjusts the width of all flags to the widest flag.
+	var widest int
+	f.VisitAll(func(f *pflag.Flag) {
+		length := 2 // initial offset value
+		if f.Shorthand != "" {
+			length += 2 // -x,
+		}
+		if f.Shorthand != "" && f.Name != "" {
+			length += 2 // account for the comma and space between: -x, --name
+		}
+		if f.Name != "" {
+			length += len(f.Name) + 2 // --name
+		}
+		if f.Value.Type() != "" {
+			length += len(f.Value.Type()) + 1 // type, plus the space between type and name
+		}
+		// an additional 3 spaces, between the end and the start of the description
+		length += 3
+
+		if length > widest {
+			widest = length
+		}
+	})
+
+	wrapTo := width - widest - 4
+	// now we wrap the descriptions
+	f.VisitAll(func(f *pflag.Flag) {
+		if f.Usage == "" {
+			return
+		}
+
+		str := f.Usage
+
+		f.Usage = wrapLine(str, wrapTo)
+	})
+}
+
+// wrapLine wraps a single paragraph (with no \n) to the given width.
+func wrapLine(text string, width int) string {
+	words := strings.Fields(text)
+	if len(words) == 0 {
+		return ""
+	}
+
+	var sb strings.Builder
+	lineLen := 0
+
+	for i, w := range words {
+		// First word on a line
+		if i == 0 {
+			sb.WriteString(w)
+			lineLen = len(w)
+			continue
+		}
+		// Check if adding this word + 1 space exceeds width
+		if lineLen+1+len(w) > width {
+			sb.WriteString("\n")
+			sb.WriteString(w)
+			lineLen = len(w)
+		} else {
+			sb.WriteString(" ")
+			sb.WriteString(w)
+			lineLen += 1 + len(w)
+		}
+	}
+
+	return sb.String()
+}
+
+// wrapText removes single line breaks (replacing them with spaces),
+// preserves double breaks (or lines starting with '-') as separators,
+// and wraps each "paragraph" to the given width.
+func wrapText(text string, width int) string {
+	// Split the original text by lines
+	lines := strings.Split(text, "\n")
+
+	var resultParts []string
+	var currentParagraph []string
+
+	// Flush the current paragraph: join with spaces, wrap, add to results
+	flushParagraph := func() {
+		if len(currentParagraph) > 0 {
+			joined := strings.Join(currentParagraph, " ")
+			wrapped := wrapLine(joined, width)
+			resultParts = append(resultParts, wrapped)
+			currentParagraph = nil
+		}
+	}
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+
+		// If line is blank or starts with '-', we preserve it as-is (separator).
+		if trimmed == "" || strings.HasPrefix(trimmed, "-") {
+			// Flush whatever paragraph we have so far
+			flushParagraph()
+			// Then just keep this line as its own entry (unwrapped).
+			// For blank lines, 'trimmed' == "", but we append the original line
+			// so it remains a visual blank line. Or if it's "-something", keep it as is.
+			resultParts = append(resultParts, line)
+		} else {
+			// Accumulate into our current paragraph
+			currentParagraph = append(currentParagraph, trimmed)
+		}
+	}
+
+	// Flush last paragraph if needed
+	flushParagraph()
+
+	// Rejoin everything with newlines
+	return strings.Join(resultParts, "\n")
+}

cmd/kwil-cli/cmds/call-action.go

@@ -150,12 +150,25 @@ func (r *respCall) MarshalJSON() ([]byte, error) {
 	return bts, nil
 }
 
+func getStringRows(v [][]any) [][]string {
+	var rows [][]string
+	for _, r := range v {
+		var row []string
+		for _, c := range r {
+			row = append(row, fmt.Sprintf("%v", c))
+		}
+		rows = append(rows, row)
+	}
+
+	return rows
+}
+
 func (r *respCall) MarshalText() (text []byte, err error) {
 	if !r.PrintLogs {
-		return recordsToTable(r.Data.QueryResult.ExportToStringMap(), r.tableConf), nil
+		return recordsToTable(r.Data.QueryResult.ColumnNames, getStringRows(r.Data.QueryResult.Values), r.tableConf), nil
 	}
 
-	bts := recordsToTable(r.Data.QueryResult.ExportToStringMap(), r.tableConf)
+	bts := recordsToTable(r.Data.QueryResult.ColumnNames, getStringRows(r.Data.QueryResult.Values), r.tableConf)
 
 	if len(r.Data.Logs) > 0 {
 		bts = append(bts, []byte("\n\nLogs:")...)

cmd/kwil-cli/cmds/exec-sql.go

@@ -104,7 +104,7 @@ func execSQLCmd() *cobra.Command {
 		},
 	}
 
-	cmd.Flags().StringVarP(&sqlStmt, "statement", "s", "", "the SQL statement to execute")
+	cmd.Flags().StringVarP(&sqlStmt, "stmt", "s", "", "the SQL statement to execute")
 	cmd.Flags().StringVarP(&sqlFilepath, "file", "f", "", "the file containing the SQL statement(s) to execute")
 	cmd.Flags().StringArrayVarP(&params, "param", "p", nil, `the parameters to pass to the SQL statement. format: "key:type=value"`)
 	common.BindTxFlags(cmd)

cmd/kwil-cli/cmds/query.go

@@ -34,15 +34,27 @@ kwil-cli query "SELECT * FROM my_table WHERE id = $id" --param id:int=1`
 func queryCmd() *cobra.Command {
 	var namedParams []string
 	var gwAuth, rpcAuth bool
+	var stmt string
 
 	cmd := &cobra.Command{
 		Use:     "query",
 		Short:   "Execute a SELECT statement against the database",
 		Long:    queryLong,
 		Example: queryExample,
+		Args:    cobra.MaximumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) != 1 {
-				return display.PrintErr(cmd, fmt.Errorf("SELECT statement must be the only argument"))
+			var sqlStmt string
+			switch {
+			case stmt != "" && len(args) == 0:
+				sqlStmt = stmt
+			case stmt == "" && len(args) == 1:
+				sqlStmt = args[0]
+			case stmt != "" && len(args) == 1:
+				return display.PrintErr(cmd, fmt.Errorf("cannot provide both a --stmt flag and an argument"))
+			case stmt == "" && len(args) == 0:
+				return display.PrintErr(cmd, fmt.Errorf("no SQL statement provided"))
+			default:
+				return display.PrintErr(cmd, fmt.Errorf("unexpected error"))
 			}
 
 			tblConf, err := getTableConfig(cmd)
@@ -69,13 +81,13 @@ func queryCmd() *cobra.Command {
 				return display.PrintErr(cmd, err)
 			}
 
-			_, err = parse.Parse(args[0])
+			_, err = parse.Parse(sqlStmt)
 			if err != nil {
 				return display.PrintErr(cmd, fmt.Errorf("failed to parse SQL statement: %s", err))
 			}
 
 			return client.DialClient(cmd.Context(), cmd, dialFlags, func(ctx context.Context, cl clientType.Client, conf *config.KwilCliConfig) error {
-				res, err := cl.Query(ctx, args[0], params)
+				res, err := cl.Query(ctx, sqlStmt, params)
 				if err != nil {
 					return display.PrintErr(cmd, err)
 				}
@@ -85,6 +97,7 @@ func queryCmd() *cobra.Command {
 		},
 	}
 
+	cmd.Flags().StringVarP(&stmt, "stmt", "s", "", "the SELECT statement to execute")
 	cmd.Flags().StringArrayVarP(&namedParams, "param", "p", nil, `named parameters that will be used in the query. format: "key:type=value"`)
 	cmd.Flags().BoolVar(&rpcAuth, "rpc-auth", false, "signals that the call is being made to a kwil node and should be authenticated with the private key")
 	cmd.Flags().BoolVar(&gwAuth, "gateway-auth", false, "signals that the call is being made to a gateway and should be authenticated with the private key")
@@ -106,5 +119,5 @@ func (r *respRelations) MarshalJSON() ([]byte, error) {
 }
 
 func (r *respRelations) MarshalText() ([]byte, error) {
-	return recordsToTable(r.Data.ExportToStringMap(), r.conf), nil
+	return recordsToTable(r.Data.ColumnNames, getStringRows(r.Data.Values), r.conf), nil
 }

cmd/kwil-cli/cmds/root.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/kwilteam/kwil-db/app/custom"
+	"github.com/kwilteam/kwil-db/app/shared"
 	"github.com/kwilteam/kwil-db/app/shared/bind"
 	"github.com/kwilteam/kwil-db/app/shared/display"
 	"github.com/kwilteam/kwil-db/app/shared/version"
@@ -72,5 +73,7 @@ func NewRootCmd() *cobra.Command {
 		queryCmd(),
 	)
 
+	shared.ApplySanitizedHelpFuncRecursively(rootCmd)
+
 	return rootCmd
 }