From 0d6d5ebd4bdd0bea80f22857f64ce0234aa54e73 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Wed, 25 Oct 2023 02:14:46 -0700
Subject: [PATCH 01/11] prototype of /status /add /commit in sql cmd

---
 go/cmd/dolt/commands/sql.go | 134 ++++++++++++++++++++++--------------
 1 file changed, 82 insertions(+), 52 deletions(-)

diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go
index 36cbf851bc..207a7cffec 100644
--- a/go/cmd/dolt/commands/sql.go
+++ b/go/cmd/dolt/commands/sql.go
@@ -260,7 +260,7 @@ func (cmd SqlCmd) Exec(ctx context.Context, commandStr string, args []string, dE
 		}
 
 		if isTty {
-			err := execShell(sqlCtx, queryist, format)
+			err := execShell(sqlCtx, queryist, format, cliCtx)
 			if err != nil {
 				return sqlHandleVErrAndExitCode(queryist, errhand.VerboseErrorFromError(err), usage)
 			}
@@ -685,7 +685,7 @@ func buildBatchSqlErr(stmtStartLine int, query string, err error) error {
 
 // execShell starts a SQL shell. Returns when the user exits the shell. The Root of the sqlEngine may
 // be updated by any queries which were processed.
-func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResultFormat) error {
+func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResultFormat, cliCtx cli.CliContext) error {
 	_ = iohelp.WriteLine(cli.CliOut, welcomeMsg)
 	historyFile := filepath.Join(".sqlhistory") // history file written to working dir
 
@@ -750,65 +750,95 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 			return
 		}
 
-		closureFormat := format
-
-		// TODO: there's a bug in the readline library when editing multi-line history entries.
-		// Longer term we need to switch to a new readline library, like in this bug:
-		// https://github.com/cockroachdb/cockroach/issues/15460
-		// For now, we store all history entries as single-line strings to avoid the issue.
-		singleLine := strings.ReplaceAll(query, "\n", " ")
-
-		if err := shell.AddHistory(singleLine); err != nil {
-			// TODO: handle better, like by turning off history writing for the rest of the session
-			shell.Println(color.RedString(err.Error()))
-		}
-
-		query = strings.TrimSuffix(query, shell.LineTerminator())
-
-		// TODO: it would be better to build this into the statement parser rather than special case it here
-		for _, terminator := range verticalOutputLineTerminators {
-			if strings.HasSuffix(query, terminator) {
-				closureFormat = engine.FormatVertical
-			}
-			query = strings.TrimSuffix(query, terminator)
-		}
-
+		cont := true
 		var nextPrompt string
 		var multiPrompt string
-		var sqlSch sql.Schema
-		var rowIter sql.RowIter
 
-		func() {
-			subCtx, stop := signal.NotifyContext(initialCtx, os.Interrupt, syscall.SIGTERM)
-			defer stop()
+		// If the query starts with a slash, it's a shell command. We don't want to print the query in that case.
+		if strings.HasPrefix(query, "/") {
+			// cli cmd everything after the slash
+			cliCmd := query[1:]
 
-			sqlCtx := sql.NewContext(subCtx, sql.WithSession(sqlCtx.Session))
+			// TODO: determine if we can get rid of the ";" as the terminator for cli commands.
+			cliCmd = strings.TrimSuffix(cliCmd, ";")
 
-			if sqlSch, rowIter, err = processQuery(sqlCtx, query, qryist); err != nil {
-				verr := formatQueryError("", err)
-				shell.Println(verr.Verbose())
-			} else if rowIter != nil {
-				switch closureFormat {
-				case engine.FormatTabular, engine.FormatVertical:
-					err = engine.PrettyPrintResultsExtended(sqlCtx, closureFormat, sqlSch, rowIter)
-				default:
-					err = engine.PrettyPrintResults(sqlCtx, closureFormat, sqlSch, rowIter)
+			// TODO: Run the string through an arg parser of some sort.
+			switch cliCmd {
+			case "status":
+				StatusCmd{}.Exec(sqlCtx, cliCmd, []string{}, nil, cliCtx)
+			case "add":
+				// this adds everything. need args!
+				AddCmd{}.Exec(sqlCtx, cliCmd, []string{"."}, nil, cliCtx)
+			case "commit":
+				CommitCmd{}.Exec(sqlCtx, cliCmd, []string{}, nil, cliCtx)
+			}
+			nextPrompt = fmt.Sprintf("%s> ", sqlCtx.GetCurrentDatabase())
+		} else {
+
+			closureFormat := format
+
+			// TODO: there's a bug in the readline library when editing multi-line history entries.
+			// Longer term we need to switch to a new readline library, like in this bug:
+			// https://github.com/cockroachdb/cockroach/issues/15460
+			// For now, we store all history entries as single-line strings to avoid the issue.
+			singleLine := strings.ReplaceAll(query, "\n", " ")
+
+			if err := shell.AddHistory(singleLine); err != nil {
+				// TODO: handle better, like by turning off history writing for the rest of the session
+				shell.Println(color.RedString(err.Error()))
+			}
+
+			query = strings.TrimSuffix(query, shell.LineTerminator())
+
+			// TODO: it would be better to build this into the statement parser rather than special case it here
+			for _, terminator := range verticalOutputLineTerminators {
+				if strings.HasSuffix(query, terminator) {
+					closureFormat = engine.FormatVertical
+				}
+				query = strings.TrimSuffix(query, terminator)
+			}
+
+			var sqlSch sql.Schema
+			var rowIter sql.RowIter
+
+			cont = func() bool {
+				subCtx, stop := signal.NotifyContext(initialCtx, os.Interrupt, syscall.SIGTERM)
+				defer stop()
+
+				sqlCtx := sql.NewContext(subCtx, sql.WithSession(sqlCtx.Session))
+
+				if sqlSch, rowIter, err = processQuery(sqlCtx, query, qryist); err != nil {
+					verr := formatQueryError("", err)
+					shell.Println(verr.Verbose())
+				} else if rowIter != nil {
+					switch closureFormat {
+					case engine.FormatTabular, engine.FormatVertical:
+						err = engine.PrettyPrintResultsExtended(sqlCtx, closureFormat, sqlSch, rowIter)
+					default:
+						err = engine.PrettyPrintResults(sqlCtx, closureFormat, sqlSch, rowIter)
+					}
+
+					if err != nil {
+						shell.Println(color.RedString(err.Error()))
+					}
 				}
 
-				if err != nil {
-					shell.Println(color.RedString(err.Error()))
+				db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
+				if ok {
+					sqlCtx.SetCurrentDatabase(db)
 				}
-			}
+				if branch != "" {
+					dirty, _ = isDirty(sqlCtx, qryist)
+				}
+				nextPrompt, multiPrompt = formattedPrompts(db, branch, dirty)
 
-			db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
-			if ok {
-				sqlCtx.SetCurrentDatabase(db)
-			}
-			if branch != "" {
-				dirty, _ = isDirty(sqlCtx, qryist)
-			}
-			nextPrompt, multiPrompt = formattedPrompts(db, branch, dirty)
-		}()
+				return true
+			}()
+		}
+
+		if !cont {
+			return
+		}
 
 		shell.SetPrompt(nextPrompt)
 		shell.SetMultiPrompt(multiPrompt)

From 21f19c49b889fe01f60a3960f6b90d9dfd02d021 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Wed, 13 Dec 2023 19:39:19 -0800
Subject: [PATCH 02/11] POC for / support in dolt sql

---
 go/cmd/dolt/commands/add.go      |   5 +-
 go/cmd/dolt/commands/branch.go   |   5 +-
 go/cmd/dolt/commands/checkout.go |   5 +-
 go/cmd/dolt/commands/commit.go   |   5 +-
 go/cmd/dolt/commands/diff.go     |   5 +-
 go/cmd/dolt/commands/log.go      |   5 +-
 go/cmd/dolt/commands/merge.go    |   5 +-
 go/cmd/dolt/commands/reset.go    |   5 +-
 go/cmd/dolt/commands/sql.go      | 172 +++++++++++++++++++++++++++----
 go/cmd/dolt/commands/status.go   |   6 +-
 10 files changed, 191 insertions(+), 27 deletions(-)

diff --git a/go/cmd/dolt/commands/add.go b/go/cmd/dolt/commands/add.go
index b3b22e2667..9de23efe7b 100644
--- a/go/cmd/dolt/commands/add.go
+++ b/go/cmd/dolt/commands/add.go
@@ -103,7 +103,10 @@ func generateAddSql(apr *argparser.ArgParseResults) string {
 func (cmd AddCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateAddArgParser()
 	helpPr, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, addDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, helpPr)
+	apr, err := cli.ParseArgs(ap, args, helpPr)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), nil)
+	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/branch.go b/go/cmd/dolt/commands/branch.go
index 7c5c49e7dc..ccc0daf917 100644
--- a/go/cmd/dolt/commands/branch.go
+++ b/go/cmd/dolt/commands/branch.go
@@ -106,7 +106,10 @@ func (cmd BranchCmd) EventType() eventsapi.ClientEventType {
 func (cmd BranchCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
 	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, branchDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	}
 
 	queryEngine, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/checkout.go b/go/cmd/dolt/commands/checkout.go
index 124b929ae4..f1fdf95357 100644
--- a/go/cmd/dolt/commands/checkout.go
+++ b/go/cmd/dolt/commands/checkout.go
@@ -87,7 +87,10 @@ func (cmd CheckoutCmd) EventType() eventsapi.ClientEventType {
 func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateCheckoutArgParser()
 	helpPrt, usagePrt := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, checkoutDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, helpPrt)
+	apr, err := cli.ParseArgs(ap, args, helpPrt)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usagePrt)
+	}
 
 	queryEngine, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/commit.go b/go/cmd/dolt/commands/commit.go
index e3a3481b80..d9f48d5022 100644
--- a/go/cmd/dolt/commands/commit.go
+++ b/go/cmd/dolt/commands/commit.go
@@ -105,7 +105,10 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
 func performCommit(ctx context.Context, commandStr string, args []string, cliCtx cli.CliContext, temporaryDEnv *env.DoltEnv) (int, bool) {
 	ap := cli.CreateCommitArgParser()
 	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, commitDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage), false
+	}
 
 	if err := cli.VerifyCommitArgs(apr); err != nil {
 		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), help), false
diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go
index 6b97a0d828..8b06822a16 100644
--- a/go/cmd/dolt/commands/diff.go
+++ b/go/cmd/dolt/commands/diff.go
@@ -188,7 +188,10 @@ func (cmd DiffCmd) RequiresRepo() bool {
 func (cmd DiffCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
 	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, diffDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	}
 
 	verr := cmd.validateArgs(apr)
 	if verr != nil {
diff --git a/go/cmd/dolt/commands/log.go b/go/cmd/dolt/commands/log.go
index 0f78e6badb..1ccea786dc 100644
--- a/go/cmd/dolt/commands/log.go
+++ b/go/cmd/dolt/commands/log.go
@@ -100,7 +100,10 @@ func (cmd LogCmd) Exec(ctx context.Context, commandStr string, args []string, dE
 func (cmd LogCmd) logWithLoggerFunc(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
 	help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, logDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return handleErrAndExit(err)
+	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/merge.go b/go/cmd/dolt/commands/merge.go
index 6f086f1007..acae6ee048 100644
--- a/go/cmd/dolt/commands/merge.go
+++ b/go/cmd/dolt/commands/merge.go
@@ -95,7 +95,10 @@ func (cmd MergeCmd) Exec(ctx context.Context, commandStr string, args []string,
 	ap := cli.CreateMergeArgParser()
 	ap.SupportsFlag(cli.NoJsonMergeFlag, "", "Do not attempt to automatically resolve multiple changes to the same JSON value, report a conflict instead.")
 	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, mergeDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/reset.go b/go/cmd/dolt/commands/reset.go
index 5dda84551c..275d457728 100644
--- a/go/cmd/dolt/commands/reset.go
+++ b/go/cmd/dolt/commands/reset.go
@@ -92,7 +92,10 @@ func (cmd ResetCmd) RequiresRepo() bool {
 func (cmd ResetCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateResetArgParser()
 	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, resetDocContent, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go
index 207a7cffec..5eab40de30 100644
--- a/go/cmd/dolt/commands/sql.go
+++ b/go/cmd/dolt/commands/sql.go
@@ -21,6 +21,7 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"syscall"
 	"time"
@@ -96,7 +97,7 @@ const (
 
 	welcomeMsg = `# Welcome to the DoltSQL shell.
 # Statements must be terminated with ';'.
-# "exit" or "quit" (or Ctrl-D) to exit.`
+# "exit" or "quit" (or Ctrl-D) to exit. "/help;" for help.`
 )
 
 // TODO: get rid of me, use a real integration point to define system variables
@@ -754,27 +755,18 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 		var nextPrompt string
 		var multiPrompt string
 
+		re := regexp.MustCompile(`\s*/(.*)`)
+		matches := re.FindStringSubmatch(query)
 		// If the query starts with a slash, it's a shell command. We don't want to print the query in that case.
-		if strings.HasPrefix(query, "/") {
-			// cli cmd everything after the slash
-			cliCmd := query[1:]
-
-			// TODO: determine if we can get rid of the ";" as the terminator for cli commands.
-			cliCmd = strings.TrimSuffix(cliCmd, ";")
-
-			// TODO: Run the string through an arg parser of some sort.
-			switch cliCmd {
-			case "status":
-				StatusCmd{}.Exec(sqlCtx, cliCmd, []string{}, nil, cliCtx)
-			case "add":
-				// this adds everything. need args!
-				AddCmd{}.Exec(sqlCtx, cliCmd, []string{"."}, nil, cliCtx)
-			case "commit":
-				CommitCmd{}.Exec(sqlCtx, cliCmd, []string{}, nil, cliCtx)
+		if len(matches) > 1 {
+			slashCmd := matches[1]
+			err := handleSlashCommand(sqlCtx, slashCmd, cliCtx)
+			if err != nil {
+				shell.Println(color.RedString(err.Error()))
 			}
+
 			nextPrompt = fmt.Sprintf("%s> ", sqlCtx.GetCurrentDatabase())
 		} else {
-
 			closureFormat := format
 
 			// TODO: there's a bug in the readline library when editing multi-line history entries.
@@ -850,6 +842,72 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 	return nil
 }
 
+var slashCmds = []cli.Command{
+	StatusCmd{},
+	DiffCmd{},
+	LogCmd{},
+	AddCmd{},
+	CommitCmd{},
+	CheckoutCmd{},
+	ResetCmd{},
+	BranchCmd{},
+	MergeCmd{},
+	SlashHelp{},
+}
+
+// parseSlashCmd parses a command line string into a slice of strings, splitting on spaces, but allowing spaces within
+// double quotes. For example, the string `foo "bar baz"` would be parsed into the slice `[]string{"foo", "bar baz"}`.
+// This is quick and dirty for slash command prototype, and doesn't try and handle all the crazy edge cases that come
+// up with supporting many types of quotes. Also, pretty sure a dangling quote will break it. But it's a start.
+func parseSlashCmd(cmd string) []string {
+
+	// TODO: determine if we can get rid of the ";" as the terminator for cli commands.
+	cmd = strings.TrimSuffix(cmd, ";")
+	cmd = strings.TrimRight(cmd, " \t\n\r\v\f")
+	cmd = strings.TrimLeft(cmd, " \t\n\r\v\f")
+
+	r := regexp.MustCompile(`"[^"\\]*(?:\\.[^"\\]*)*"|\S+`)
+	cmdWords := r.FindAllString(cmd, -1)
+
+	for i := range cmdWords {
+		if cmdWords[i][0] == '"' {
+			cmdWords[i] = cmdWords[i][1 : len(cmdWords[i])-1]
+			cmdWords[i] = strings.ReplaceAll(cmdWords[i], `\"`, `"`)
+		}
+	}
+
+	if len(cmdWords) == 0 {
+		return []string{}
+	}
+
+	return cmdWords
+}
+
+func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliContext) error {
+
+	cliCmd := parseSlashCmd(fullCmd)
+	if len(cliCmd) == 0 {
+		// Print help?? NM4
+		return fmt.Errorf("Empty command. Use `/help;` for help.")
+	}
+
+	subCmd := cliCmd[0]
+	subCmdArgs := cliCmd[1:]
+	status := 1
+
+	subCmdInst, ok := findSlashCmd(subCmd)
+	if ok {
+		status = subCmdInst.Exec(sqlCtx, subCmd, subCmdArgs, nil, cliCtx)
+	} else {
+		return fmt.Errorf("Unknown command: %s", subCmd) // NM4 - print help maybe?
+	}
+
+	if status != 0 {
+		return fmt.Errorf("error executing command: %s", cliCmd)
+	}
+	return nil
+}
+
 // formattedPrompts returns the prompt and multiline prompt for the current session. If the db is empty, the prompt will
 // be "> ", otherwise it will be "db> ". If the branch is empty, the multiline prompt will be "-> ", left padded for
 // alignment with the prompt.
@@ -1191,3 +1249,81 @@ func updateFileReadProgressOutput() {
 	displayStr := fmt.Sprintf("Processed %.1f%% of the file", percent)
 	fileReadProg.displayStrLen = cli.DeleteAndPrint(fileReadProg.displayStrLen, displayStr)
 }
+
+type SlashHelp struct{}
+
+func (s SlashHelp) Name() string {
+	return "help"
+}
+
+func (s SlashHelp) Description() string {
+	return "What you see right now."
+}
+
+func (s SlashHelp) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
+	if args != nil && len(args) > 0 {
+		subCmd := args[0]
+		subCmdInst, ok := findSlashCmd(subCmd)
+		if ok {
+			foo, _ := cli.HelpAndUsagePrinters(subCmdInst.Docs())
+			foo()
+
+		} else {
+			cli.Println(fmt.Sprintf("Unknown command: %s", subCmd))
+		}
+		return 0
+	}
+
+	qryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
+	if closeFunc != nil {
+		defer closeFunc()
+	}
+	if err != nil {
+		return 1 // NM4 - better error handling
+	}
+
+	dbName, branch, _ := getDBBranchFromSession(sqlCtx, qryist)
+
+	cli.Println("Dolt SQL Shell Help")
+	cli.Printf("Default behavior is to interpret SQL statements.     (e.g. '%s/%s> select * from my_table;')\n", dbName, branch)
+	cli.Printf("Dolt CLI commands can be invoked with a leading '/'. (e.g. '%s/%s> /status;')\n", dbName, branch)
+	cli.Println("All statements are terminated with a ';'.")
+	cli.Println("\nAvailable commands:")
+	for _, cmdInst := range slashCmds {
+		cli.Println(fmt.Sprintf("  %10s - %s", cmdInst.Name(), cmdInst.Description()))
+	}
+	cli.Printf("\nFor more information on a specific command, type '/help <command>;' (e.g. '%s/%s> /help status;')\n", dbName, branch)
+
+	moreWords := `
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+Still need assistance? Talk directly to Dolt developers on Discord! https://discord.gg/gqr7K4VNKe
+Found a bug? Want additional features? Please let us know! https://github.com/dolthub/dolt/issues
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-`
+
+	cli.Println(moreWords)
+
+	return 0
+}
+
+func findSlashCmd(cmd string) (cli.Command, bool) {
+	for _, cmdInst := range slashCmds {
+		if cmdInst.Name() == cmd {
+			return cmdInst, true
+		}
+	}
+	return nil, false
+}
+
+func (s SlashHelp) Docs() *cli.CommandDocumentation {
+	return &cli.CommandDocumentation{
+		CommandStr: "/help",
+		ShortDesc:  "What you see right now.",
+		LongDesc:   "It would seem that you are crying out for help. Please join us on Discord (https://discord.gg/gqr7K4VNKe)!",
+		Synopsis:   []string{},
+		ArgParser:  s.ArgParser(),
+	}
+}
+
+func (s SlashHelp) ArgParser() *argparser.ArgParser {
+	return &argparser.ArgParser{}
+}
diff --git a/go/cmd/dolt/commands/status.go b/go/cmd/dolt/commands/status.go
index e64078a369..d4440f039a 100644
--- a/go/cmd/dolt/commands/status.go
+++ b/go/cmd/dolt/commands/status.go
@@ -105,7 +105,11 @@ func (cmd StatusCmd) Exec(ctx context.Context, commandStr string, args []string,
 	// parse arguments
 	ap := cmd.ArgParser()
 	help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, statusDocs, ap))
-	apr := cli.ParseArgsOrDie(ap, args, help)
+	apr, err := cli.ParseArgs(ap, args, help)
+	if err != nil {
+		return handleStatusVErr(err)
+	}
+
 	showIgnoredTables := apr.Contains(cli.ShowIgnoredFlag)
 
 	// configure SQL engine

From bf7a663c4c4ac88069215b9e890d368d7512984f Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Thu, 28 Dec 2023 11:07:17 -0800
Subject: [PATCH 03/11] Correctly track an existing Queryist

Bug fix - existing commands in the wild may be creating multiple queryist
objects, which could result in busted session handling
---
 go/cmd/dolt/cli/cli_context.go   | 22 ++++++++++--------
 go/cmd/dolt/commands/checkout.go | 39 ++++++++++++++++++--------------
 go/cmd/dolt/commands/sql.go      | 31 +++++++++++++++++--------
 3 files changed, 57 insertions(+), 35 deletions(-)

diff --git a/go/cmd/dolt/cli/cli_context.go b/go/cmd/dolt/cli/cli_context.go
index 5e1bc23aa4..cae0f45e51 100644
--- a/go/cmd/dolt/cli/cli_context.go
+++ b/go/cmd/dolt/cli/cli_context.go
@@ -44,17 +44,21 @@ func NewCliContext(args *argparser.ArgParseResults, config *env.DoltCliConfig, l
 		return nil, errhand.VerboseErrorFromError(errors.New("Invariant violated. args, config, and latebind must be non nil."))
 	}
 
-	return LateBindCliContext{globalArgs: args, config: config, bind: latebind}, nil
+	return LateBindCliContext{globalArgs: args, config: config, activeContext: &QueryistContext{}, bind: latebind}, nil
+}
+
+type QueryistContext struct {
+	sqlCtx *sql.Context
+	qryist *Queryist
 }
 
 // LateBindCliContext is a struct that implements CliContext. Its primary purpose is to wrap the global arguments and
 // provide an implementation of the QueryEngine function. This instance is stateful to ensure that the Queryist is only
 // created once.
 type LateBindCliContext struct {
-	globalArgs *argparser.ArgParseResults
-	queryist   Queryist
-	sqlCtx     *sql.Context
-	config     *env.DoltCliConfig
+	globalArgs    *argparser.ArgParseResults
+	config        *env.DoltCliConfig
+	activeContext *QueryistContext
 
 	bind LateBindQueryist
 }
@@ -68,8 +72,8 @@ func (lbc LateBindCliContext) GlobalArgs() *argparser.ArgParseResults {
 // LateBindQueryist is made, and caches the result. Note that if this is called twice, the closer function returns will
 // be nil, callers should check if is nil.
 func (lbc LateBindCliContext) QueryEngine(ctx context.Context) (Queryist, *sql.Context, func(), error) {
-	if lbc.queryist != nil {
-		return lbc.queryist, lbc.sqlCtx, nil, nil
+	if lbc.activeContext != nil && lbc.activeContext.qryist != nil && lbc.activeContext.sqlCtx != nil {
+		return *lbc.activeContext.qryist, lbc.activeContext.sqlCtx, nil, nil
 	}
 
 	qryist, sqlCtx, closer, err := lbc.bind(ctx)
@@ -77,8 +81,8 @@ func (lbc LateBindCliContext) QueryEngine(ctx context.Context) (Queryist, *sql.C
 		return nil, nil, nil, err
 	}
 
-	lbc.queryist = qryist
-	lbc.sqlCtx = sqlCtx
+	lbc.activeContext.qryist = &qryist
+	lbc.activeContext.sqlCtx = sqlCtx
 
 	return qryist, sqlCtx, closer, nil
 }
diff --git a/go/cmd/dolt/commands/checkout.go b/go/cmd/dolt/commands/checkout.go
index f1fdf95357..78a24713f5 100644
--- a/go/cmd/dolt/commands/checkout.go
+++ b/go/cmd/dolt/commands/checkout.go
@@ -144,13 +144,16 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 	if err != nil {
 		// In fringe cases the server can't start because the default branch doesn't exist, `dolt checkout <existing branch>`
 		// offers an escape hatch.
-		if !branchOrTrack && strings.Contains(err.Error(), "cannot resolve default branch head for database") {
-			err := saveHeadBranch(dEnv.FS, branchName)
-			if err != nil {
-				cli.PrintErr(err)
-				return 1
+		if dEnv != nil {
+			// NM4 I hate everything about this.
+			if !branchOrTrack && strings.Contains(err.Error(), "cannot resolve default branch head for database") {
+				err := saveHeadBranch(dEnv.FS, branchName)
+				if err != nil {
+					cli.PrintErr(err)
+					return 1
+				}
+				return 0
 			}
-			return 0
 		}
 		return HandleVErrAndExitCode(handleErrors(branchName, err), usagePrt)
 	}
@@ -172,17 +175,19 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 		cli.Println(message)
 	}
 
-	if strings.Contains(message, "Switched to branch") {
-		err := saveHeadBranch(dEnv.FS, branchName)
-		if err != nil {
-			cli.PrintErr(err)
-			return 1
-		}
-		// This command doesn't modify `dEnv` which could break tests that call multiple commands in sequence.
-		// We must reload it so that it includes changes to the repo state.
-		err = dEnv.ReloadRepoState()
-		if err != nil {
-			return 1
+	if dEnv != nil {
+		if strings.Contains(message, "Switched to branch") {
+			err := saveHeadBranch(dEnv.FS, branchName)
+			if err != nil {
+				cli.PrintErr(err)
+				return 1
+			}
+			// This command doesn't modify `dEnv` which could break tests that call multiple commands in sequence.
+			// We must reload it so that it includes changes to the repo state.
+			err = dEnv.ReloadRepoState()
+			if err != nil {
+				return 1
+			}
 		}
 	}
 
diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go
index 5eab40de30..8b4e1f1cf2 100644
--- a/go/cmd/dolt/commands/sql.go
+++ b/go/cmd/dolt/commands/sql.go
@@ -759,13 +759,27 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 		matches := re.FindStringSubmatch(query)
 		// If the query starts with a slash, it's a shell command. We don't want to print the query in that case.
 		if len(matches) > 1 {
-			slashCmd := matches[1]
-			err := handleSlashCommand(sqlCtx, slashCmd, cliCtx)
-			if err != nil {
-				shell.Println(color.RedString(err.Error()))
-			}
+			func() {
+				subCtx, stop := signal.NotifyContext(initialCtx, os.Interrupt, syscall.SIGTERM)
+				defer stop()
+				sqlCtx := sql.NewContext(subCtx, sql.WithSession(sqlCtx.Session))
 
-			nextPrompt = fmt.Sprintf("%s> ", sqlCtx.GetCurrentDatabase())
+				slashCmd := matches[1]
+				err := handleSlashCommand(sqlCtx, slashCmd, cliCtx)
+				if err != nil {
+					shell.Println(color.RedString(err.Error()))
+				}
+
+				// NM4 - TODO: move this to a separate function
+				db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
+				if ok {
+					sqlCtx.SetCurrentDatabase(db)
+				}
+				if branch != "" {
+					dirty, _ = isDirty(sqlCtx, qryist)
+				}
+				nextPrompt, multiPrompt = formattedPrompts(db, branch, dirty)
+			}()
 		} else {
 			closureFormat := format
 
@@ -817,7 +831,7 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 
 				db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
 				if ok {
-					sqlCtx.SetCurrentDatabase(db)
+					sqlCtx.SetCurrentDatabase(db) // NM4 - what exactly does this do
 				}
 				if branch != "" {
 					dirty, _ = isDirty(sqlCtx, qryist)
@@ -884,7 +898,6 @@ func parseSlashCmd(cmd string) []string {
 }
 
 func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliContext) error {
-
 	cliCmd := parseSlashCmd(fullCmd)
 	if len(cliCmd) == 0 {
 		// Print help?? NM4
@@ -980,7 +993,7 @@ func getDBBranchFromSession(sqlCtx *sql.Context, qryist cli.Queryist) (db string
 // isDirty returns true if the workspace is dirty, false otherwise. This function _assumes_ you are on a database
 // with a branch. If you are not, you will get an error.
 func isDirty(sqlCtx *sql.Context, qryist cli.Queryist) (bool, error) {
-	_, resp, err := qryist.Query(sqlCtx, "select count(table_name) > 0 as dirty from dolt_Status")
+	_, resp, err := qryist.Query(sqlCtx, "select count(table_name) > 0 as dirty from dolt_status")
 
 	if err != nil {
 		cli.Println(color.RedString("Failure to get DB Name for session: " + err.Error()))

From 5f730662caa591b65036c868fbc5fff481495423 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Mon, 3 Jun 2024 08:59:54 -0700
Subject: [PATCH 04/11] Refactor to move sql slash into it's own file

---
 go/cmd/dolt/commands/sql.go       | 166 ++-------------------------
 go/cmd/dolt/commands/sql_slash.go | 180 ++++++++++++++++++++++++++++++
 2 files changed, 191 insertions(+), 155 deletions(-)
 create mode 100644 go/cmd/dolt/commands/sql_slash.go

diff --git a/go/cmd/dolt/commands/sql.go b/go/cmd/dolt/commands/sql.go
index 8b4e1f1cf2..e064b951b4 100644
--- a/go/cmd/dolt/commands/sql.go
+++ b/go/cmd/dolt/commands/sql.go
@@ -770,15 +770,7 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 					shell.Println(color.RedString(err.Error()))
 				}
 
-				// NM4 - TODO: move this to a separate function
-				db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
-				if ok {
-					sqlCtx.SetCurrentDatabase(db)
-				}
-				if branch != "" {
-					dirty, _ = isDirty(sqlCtx, qryist)
-				}
-				nextPrompt, multiPrompt = formattedPrompts(db, branch, dirty)
+				nextPrompt, multiPrompt = postCommandUpdate(sqlCtx, qryist)
 			}()
 		} else {
 			closureFormat := format
@@ -829,14 +821,7 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 					}
 				}
 
-				db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
-				if ok {
-					sqlCtx.SetCurrentDatabase(db) // NM4 - what exactly does this do
-				}
-				if branch != "" {
-					dirty, _ = isDirty(sqlCtx, qryist)
-				}
-				nextPrompt, multiPrompt = formattedPrompts(db, branch, dirty)
+				nextPrompt, multiPrompt = postCommandUpdate(sqlCtx, qryist)
 
 				return true
 			}()
@@ -856,69 +841,18 @@ func execShell(sqlCtx *sql.Context, qryist cli.Queryist, format engine.PrintResu
 	return nil
 }
 
-var slashCmds = []cli.Command{
-	StatusCmd{},
-	DiffCmd{},
-	LogCmd{},
-	AddCmd{},
-	CommitCmd{},
-	CheckoutCmd{},
-	ResetCmd{},
-	BranchCmd{},
-	MergeCmd{},
-	SlashHelp{},
-}
-
-// parseSlashCmd parses a command line string into a slice of strings, splitting on spaces, but allowing spaces within
-// double quotes. For example, the string `foo "bar baz"` would be parsed into the slice `[]string{"foo", "bar baz"}`.
-// This is quick and dirty for slash command prototype, and doesn't try and handle all the crazy edge cases that come
-// up with supporting many types of quotes. Also, pretty sure a dangling quote will break it. But it's a start.
-func parseSlashCmd(cmd string) []string {
-
-	// TODO: determine if we can get rid of the ";" as the terminator for cli commands.
-	cmd = strings.TrimSuffix(cmd, ";")
-	cmd = strings.TrimRight(cmd, " \t\n\r\v\f")
-	cmd = strings.TrimLeft(cmd, " \t\n\r\v\f")
-
-	r := regexp.MustCompile(`"[^"\\]*(?:\\.[^"\\]*)*"|\S+`)
-	cmdWords := r.FindAllString(cmd, -1)
-
-	for i := range cmdWords {
-		if cmdWords[i][0] == '"' {
-			cmdWords[i] = cmdWords[i][1 : len(cmdWords[i])-1]
-			cmdWords[i] = strings.ReplaceAll(cmdWords[i], `\"`, `"`)
-		}
-	}
-
-	if len(cmdWords) == 0 {
-		return []string{}
-	}
-
-	return cmdWords
-}
-
-func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliContext) error {
-	cliCmd := parseSlashCmd(fullCmd)
-	if len(cliCmd) == 0 {
-		// Print help?? NM4
-		return fmt.Errorf("Empty command. Use `/help;` for help.")
-	}
-
-	subCmd := cliCmd[0]
-	subCmdArgs := cliCmd[1:]
-	status := 1
-
-	subCmdInst, ok := findSlashCmd(subCmd)
+// postCommandUpdate is a helper function that is run after the shell has completed a command. It updates the the database
+// if needed, and generates new prompts for the shell (based on the branch and if the workspace is dirty).
+func postCommandUpdate(sqlCtx *sql.Context, qryist cli.Queryist) (string, string) {
+	db, branch, ok := getDBBranchFromSession(sqlCtx, qryist)
 	if ok {
-		status = subCmdInst.Exec(sqlCtx, subCmd, subCmdArgs, nil, cliCtx)
-	} else {
-		return fmt.Errorf("Unknown command: %s", subCmd) // NM4 - print help maybe?
+		sqlCtx.SetCurrentDatabase(db)
 	}
-
-	if status != 0 {
-		return fmt.Errorf("error executing command: %s", cliCmd)
+	dirty := false
+	if branch != "" {
+		dirty, _ = isDirty(sqlCtx, qryist)
 	}
-	return nil
+	return formattedPrompts(db, branch, dirty)
 }
 
 // formattedPrompts returns the prompt and multiline prompt for the current session. If the db is empty, the prompt will
@@ -1262,81 +1196,3 @@ func updateFileReadProgressOutput() {
 	displayStr := fmt.Sprintf("Processed %.1f%% of the file", percent)
 	fileReadProg.displayStrLen = cli.DeleteAndPrint(fileReadProg.displayStrLen, displayStr)
 }
-
-type SlashHelp struct{}
-
-func (s SlashHelp) Name() string {
-	return "help"
-}
-
-func (s SlashHelp) Description() string {
-	return "What you see right now."
-}
-
-func (s SlashHelp) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
-	if args != nil && len(args) > 0 {
-		subCmd := args[0]
-		subCmdInst, ok := findSlashCmd(subCmd)
-		if ok {
-			foo, _ := cli.HelpAndUsagePrinters(subCmdInst.Docs())
-			foo()
-
-		} else {
-			cli.Println(fmt.Sprintf("Unknown command: %s", subCmd))
-		}
-		return 0
-	}
-
-	qryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
-	if closeFunc != nil {
-		defer closeFunc()
-	}
-	if err != nil {
-		return 1 // NM4 - better error handling
-	}
-
-	dbName, branch, _ := getDBBranchFromSession(sqlCtx, qryist)
-
-	cli.Println("Dolt SQL Shell Help")
-	cli.Printf("Default behavior is to interpret SQL statements.     (e.g. '%s/%s> select * from my_table;')\n", dbName, branch)
-	cli.Printf("Dolt CLI commands can be invoked with a leading '/'. (e.g. '%s/%s> /status;')\n", dbName, branch)
-	cli.Println("All statements are terminated with a ';'.")
-	cli.Println("\nAvailable commands:")
-	for _, cmdInst := range slashCmds {
-		cli.Println(fmt.Sprintf("  %10s - %s", cmdInst.Name(), cmdInst.Description()))
-	}
-	cli.Printf("\nFor more information on a specific command, type '/help <command>;' (e.g. '%s/%s> /help status;')\n", dbName, branch)
-
-	moreWords := `
--+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
-Still need assistance? Talk directly to Dolt developers on Discord! https://discord.gg/gqr7K4VNKe
-Found a bug? Want additional features? Please let us know! https://github.com/dolthub/dolt/issues
--+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-`
-
-	cli.Println(moreWords)
-
-	return 0
-}
-
-func findSlashCmd(cmd string) (cli.Command, bool) {
-	for _, cmdInst := range slashCmds {
-		if cmdInst.Name() == cmd {
-			return cmdInst, true
-		}
-	}
-	return nil, false
-}
-
-func (s SlashHelp) Docs() *cli.CommandDocumentation {
-	return &cli.CommandDocumentation{
-		CommandStr: "/help",
-		ShortDesc:  "What you see right now.",
-		LongDesc:   "It would seem that you are crying out for help. Please join us on Discord (https://discord.gg/gqr7K4VNKe)!",
-		Synopsis:   []string{},
-		ArgParser:  s.ArgParser(),
-	}
-}
-
-func (s SlashHelp) ArgParser() *argparser.ArgParser {
-	return &argparser.ArgParser{}
-}
diff --git a/go/cmd/dolt/commands/sql_slash.go b/go/cmd/dolt/commands/sql_slash.go
new file mode 100644
index 0000000000..e8921d624d
--- /dev/null
+++ b/go/cmd/dolt/commands/sql_slash.go
@@ -0,0 +1,180 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/dolthub/dolt/go/cmd/dolt/cli"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+	"github.com/dolthub/dolt/go/libraries/utils/argparser"
+	"github.com/dolthub/go-mysql-server/sql"
+)
+
+var slashCmds = []cli.Command{
+	StatusCmd{},
+	DiffCmd{},
+	LogCmd{},
+	AddCmd{},
+	CommitCmd{},
+	CheckoutCmd{},
+	ResetCmd{},
+	BranchCmd{},
+	MergeCmd{},
+	SlashHelp{},
+}
+
+// parseSlashCmd parses a command line string into a slice of strings, splitting on spaces, but allowing spaces within
+// double quotes. For example, the string `foo "bar baz"` would be parsed into the slice `[]string{"foo", "bar baz"}`.
+// This is quick and dirty for slash command prototype, and doesn't try and handle all the crazy edge cases that come
+// up with supporting many types of quotes. Also, pretty sure a dangling quote will break it. But it's a start.
+func parseSlashCmd(cmd string) []string {
+
+	// TODO: determine if we can get rid of the ";" as the terminator for cli commands.
+	cmd = strings.TrimSuffix(cmd, ";")
+	cmd = strings.TrimRight(cmd, " \t\n\r\v\f")
+	cmd = strings.TrimLeft(cmd, " \t\n\r\v\f")
+
+	r := regexp.MustCompile(`"[^"\\]*(?:\\.[^"\\]*)*"|\S+`)
+	cmdWords := r.FindAllString(cmd, -1)
+
+	for i := range cmdWords {
+		if cmdWords[i][0] == '"' {
+			cmdWords[i] = cmdWords[i][1 : len(cmdWords[i])-1]
+			cmdWords[i] = strings.ReplaceAll(cmdWords[i], `\"`, `"`)
+		}
+	}
+
+	if len(cmdWords) == 0 {
+		return []string{}
+	}
+
+	return cmdWords
+}
+
+func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliContext) error {
+	cliCmd := parseSlashCmd(fullCmd)
+	if len(cliCmd) == 0 {
+		// Print help?? NM4
+		return fmt.Errorf("Empty command. Use `/help;` for help.")
+	}
+
+	subCmd := cliCmd[0]
+	subCmdArgs := cliCmd[1:]
+	status := 1
+
+	subCmdInst, ok := findSlashCmd(subCmd)
+	if ok {
+		status = subCmdInst.Exec(sqlCtx, subCmd, subCmdArgs, nil, cliCtx)
+	} else {
+		return fmt.Errorf("Unknown command: %s", subCmd) // NM4 - print help maybe?
+	}
+
+	if status != 0 {
+		return fmt.Errorf("error executing command: %s", cliCmd)
+	}
+	return nil
+}
+
+type SlashHelp struct{}
+
+func (s SlashHelp) Name() string {
+	return "help"
+}
+
+func (s SlashHelp) Description() string {
+	return "What you see right now."
+}
+
+func (s SlashHelp) Docs() *cli.CommandDocumentation {
+	return &cli.CommandDocumentation{
+		CommandStr: "/help",
+		ShortDesc:  "What you see right now.",
+		LongDesc:   "It would seem that you are crying out for help. Please join us on Discord (https://discord.gg/gqr7K4VNKe)!",
+		Synopsis:   []string{},
+		ArgParser:  s.ArgParser(),
+	}
+}
+
+func (s SlashHelp) Exec(ctx context.Context, _ string, args []string, _ *env.DoltEnv, cliCtx cli.CliContext) int {
+	if args != nil && len(args) > 0 {
+		subCmd := args[0]
+		subCmdInst, ok := findSlashCmd(subCmd)
+		if ok {
+			foo, _ := cli.HelpAndUsagePrinters(subCmdInst.Docs())
+			foo()
+
+		} else {
+			cli.Println(fmt.Sprintf("Unknown command: %s", subCmd))
+		}
+		return 0
+	}
+
+	qryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
+	if closeFunc != nil {
+		defer closeFunc()
+	}
+	if err != nil {
+		return 1 // NM4 - better error handling
+	}
+
+	prompt := generateHelpPrompt(sqlCtx, qryist)
+
+	cli.Println("Dolt SQL Shell Help")
+	cli.Printf("Default behavior is to interpret SQL statements.     (e.g. '%sselect * from my_table;')\n", prompt)
+	cli.Printf("Dolt CLI commands can be invoked with a leading '/'. (e.g. '%s/status;')\n", prompt)
+	cli.Println("All statements are terminated with a ';'.")
+	cli.Println("\nAvailable commands:")
+	for _, cmdInst := range slashCmds {
+		cli.Println(fmt.Sprintf("  %10s - %s", cmdInst.Name(), cmdInst.Description()))
+	}
+	cli.Printf("\nFor more information on a specific command, type '/help <command>;' (e.g. '%s/help status;')\n", prompt)
+
+	moreWords := `
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+Still need assistance? Talk directly to Dolt developers on Discord! https://discord.gg/gqr7K4VNKe
+Found a bug? Want additional features? Please let us know! https://github.com/dolthub/dolt/issues
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-`
+
+	cli.Println(moreWords)
+
+	return 0
+}
+
+func generateHelpPrompt(sqlCtx *sql.Context, qryist cli.Queryist) string {
+	db, branch, _ := getDBBranchFromSession(sqlCtx, qryist)
+	dirty := false
+	if branch != "" {
+		dirty, _ = isDirty(sqlCtx, qryist)
+	}
+	prompt, _ := formattedPrompts(db, branch, dirty)
+	return prompt
+}
+
+func (s SlashHelp) ArgParser() *argparser.ArgParser {
+	return &argparser.ArgParser{}
+}
+
+func findSlashCmd(cmd string) (cli.Command, bool) {
+	for _, cmdInst := range slashCmds {
+		if cmdInst.Name() == cmd {
+			return cmdInst, true
+		}
+	}
+	return nil, false
+}

From db653400e7d352e768127e6f4b8441a03802f3ac Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Mon, 3 Jun 2024 10:29:16 -0700
Subject: [PATCH 05/11] Add expect tests for sql slash commands

---
 .../bats/sql-shell-slash-cmds.expect          | 69 +++++++++++++++++++
 integration-tests/bats/sql-shell.bats         |  9 +++
 2 files changed, 78 insertions(+)
 create mode 100755 integration-tests/bats/sql-shell-slash-cmds.expect

diff --git a/integration-tests/bats/sql-shell-slash-cmds.expect b/integration-tests/bats/sql-shell-slash-cmds.expect
new file mode 100755
index 0000000000..624b6d276f
--- /dev/null
+++ b/integration-tests/bats/sql-shell-slash-cmds.expect
@@ -0,0 +1,69 @@
+#!/usr/bin/expect
+
+set timeout 5
+set env(NO_COLOR) 1
+
+
+proc expect_with_defaults {pattern action} {
+    expect {
+        -re $pattern {
+#            puts "Matched pattern: $pattern"
+            eval $action
+        }
+        timeout {
+            puts "<<Timeout>>";
+            exit 1
+        }
+        eof {
+            puts "<<End of File reached>>";
+            exit 1
+        }
+        failed {
+            puts "<<Failed>>";
+            exit 1
+        }
+    }
+}
+proc expect_with_defaults_2 {patternA patternB action} {
+    expect {
+        -re $patternA {
+#            puts "Matched pattern: $patternA"
+            exp_continue
+        }
+        -re $patternB {
+#            puts "Matched pattern: $patternB"
+            eval $action
+        }
+        timeout {
+            puts "<<Timeout>>";
+            exit 1
+        }
+        eof {
+            puts "<<End of File reached>>";
+            exit 1
+        }
+        failed {
+            puts "<<Failed>>";
+            exit 1
+        }
+    }
+}
+
+
+
+spawn dolt sql
+
+expect_with_defaults {dolt-repo-[0-9]+/main\*> } { send "/commit -A -m \"sql-shell-slash-cmds commit\";\r"; }
+
+expect_with_defaults {dolt-repo-[0-9]+/main> }   { send "/log -n 1;\r"; }
+
+expect_with_defaults_2 {sql-shell-slash-cmds commit} {dolt-repo-[0-9]+/main> } { send "/status;\r"; }
+
+expect_with_defaults {dolt-repo-[0-9]+/main> }   { send "/reset HEAD~1;\r"; }
+
+expect_with_defaults {dolt-repo-[0-9]+/main\*> } { send "/diff;\r"; }
+
+expect_with_defaults_2 {diff --dolt a/tbl b/tbl} {dolt-repo-[0-9]+/main\*> } {send "quit\r";}
+
+expect eof
+exit
diff --git a/integration-tests/bats/sql-shell.bats b/integration-tests/bats/sql-shell.bats
index bb3e05ebd4..a59e0b6932 100644
--- a/integration-tests/bats/sql-shell.bats
+++ b/integration-tests/bats/sql-shell.bats
@@ -67,6 +67,15 @@ teardown() {
     [[ "$output" =~ "+---------------------" ]] || false
 }
 
+# bats test_tags=no_lambda
+@test "sql-shell: sql shell executes slash commands" {
+    skiponwindows "Need to install expect and make this script work on windows."
+    run $BATS_TEST_DIRNAME/sql-shell-slash-cmds.expect
+    echo "$output"
+
+    [ "$status" -eq 0 ]
+}
+
 # bats test_tags=no_lambda
 @test "sql-shell: sql shell prompt updates" {
     skiponwindows "Need to install expect and make this script work on windows."

From de581aec148417738029b1dcb7efa61f49a8bdf7 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Mon, 3 Jun 2024 12:00:28 -0700
Subject: [PATCH 06/11] Remove todos

---
 go/cmd/dolt/commands/checkout.go  | 2 +-
 go/cmd/dolt/commands/sql_slash.go | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/go/cmd/dolt/commands/checkout.go b/go/cmd/dolt/commands/checkout.go
index 78a24713f5..3a1fff2e69 100644
--- a/go/cmd/dolt/commands/checkout.go
+++ b/go/cmd/dolt/commands/checkout.go
@@ -145,7 +145,7 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 		// In fringe cases the server can't start because the default branch doesn't exist, `dolt checkout <existing branch>`
 		// offers an escape hatch.
 		if dEnv != nil {
-			// NM4 I hate everything about this.
+			// TODO - This error handling is not great.
 			if !branchOrTrack && strings.Contains(err.Error(), "cannot resolve default branch head for database") {
 				err := saveHeadBranch(dEnv.FS, branchName)
 				if err != nil {
diff --git a/go/cmd/dolt/commands/sql_slash.go b/go/cmd/dolt/commands/sql_slash.go
index e8921d624d..bedd2f5620 100644
--- a/go/cmd/dolt/commands/sql_slash.go
+++ b/go/cmd/dolt/commands/sql_slash.go
@@ -70,7 +70,6 @@ func parseSlashCmd(cmd string) []string {
 func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliContext) error {
 	cliCmd := parseSlashCmd(fullCmd)
 	if len(cliCmd) == 0 {
-		// Print help?? NM4
 		return fmt.Errorf("Empty command. Use `/help;` for help.")
 	}
 
@@ -82,7 +81,7 @@ func handleSlashCommand(sqlCtx *sql.Context, fullCmd string, cliCtx cli.CliConte
 	if ok {
 		status = subCmdInst.Exec(sqlCtx, subCmd, subCmdArgs, nil, cliCtx)
 	} else {
-		return fmt.Errorf("Unknown command: %s", subCmd) // NM4 - print help maybe?
+		return fmt.Errorf("Unknown command: %s. Use `/help;` for a list of command.", subCmd)
 	}
 
 	if status != 0 {
@@ -130,7 +129,8 @@ func (s SlashHelp) Exec(ctx context.Context, _ string, args []string, _ *env.Dol
 		defer closeFunc()
 	}
 	if err != nil {
-		return 1 // NM4 - better error handling
+		cli.Println(fmt.Sprintf("error getting query engine: %s", err))
+		return 1
 	}
 
 	prompt := generateHelpPrompt(sqlCtx, qryist)

From 9d03474531f5ffeb7d955ff655ef1b474d088c7b Mon Sep 17 00:00:00 2001
From: macneale4 <macneale4@users.noreply.github.com>
Date: Mon, 3 Jun 2024 19:16:02 +0000
Subject: [PATCH 07/11] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/cmd/dolt/commands/sql_slash.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/go/cmd/dolt/commands/sql_slash.go b/go/cmd/dolt/commands/sql_slash.go
index bedd2f5620..ff004a9afb 100644
--- a/go/cmd/dolt/commands/sql_slash.go
+++ b/go/cmd/dolt/commands/sql_slash.go
@@ -20,10 +20,11 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/dolthub/go-mysql-server/sql"
+
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/utils/argparser"
-	"github.com/dolthub/go-mysql-server/sql"
 )
 
 var slashCmds = []cli.Command{

From 6ee5814e47c247e9e4110c838801281049918377 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Mon, 3 Jun 2024 17:22:00 -0700
Subject: [PATCH 08/11] Ensure --help returns exit status 0.

---
 go/cmd/dolt/commands/add.go      |  7 +++----
 go/cmd/dolt/commands/branch.go   |  7 +++----
 go/cmd/dolt/commands/checkout.go | 23 +++++++++++------------
 go/cmd/dolt/commands/commit.go   |  9 ++++-----
 go/cmd/dolt/commands/diff.go     |  9 ++++-----
 go/cmd/dolt/commands/log.go      |  7 +++----
 go/cmd/dolt/commands/merge.go    |  7 +++----
 go/cmd/dolt/commands/reset.go    |  9 ++++-----
 go/cmd/dolt/commands/status.go   | 13 ++++++-------
 go/cmd/dolt/commands/utils.go    | 26 +++++++++++++++++++++-----
 10 files changed, 62 insertions(+), 55 deletions(-)

diff --git a/go/cmd/dolt/commands/add.go b/go/cmd/dolt/commands/add.go
index 9de23efe7b..d0bf880636 100644
--- a/go/cmd/dolt/commands/add.go
+++ b/go/cmd/dolt/commands/add.go
@@ -102,10 +102,9 @@ func generateAddSql(apr *argparser.ArgParseResults) string {
 // Exec executes the command
 func (cmd AddCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateAddArgParser()
-	helpPr, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, addDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, helpPr)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), nil)
+	apr, _, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, addDocs)
+	if terminate {
+		return status
 	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/branch.go b/go/cmd/dolt/commands/branch.go
index ccc0daf917..4a94751376 100644
--- a/go/cmd/dolt/commands/branch.go
+++ b/go/cmd/dolt/commands/branch.go
@@ -105,10 +105,9 @@ func (cmd BranchCmd) EventType() eventsapi.ClientEventType {
 // Exec executes the command
 func (cmd BranchCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
-	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, branchDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, branchDocs)
+	if terminate {
+		return status
 	}
 
 	queryEngine, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/checkout.go b/go/cmd/dolt/commands/checkout.go
index 3a1fff2e69..1d04393519 100644
--- a/go/cmd/dolt/commands/checkout.go
+++ b/go/cmd/dolt/commands/checkout.go
@@ -86,15 +86,14 @@ func (cmd CheckoutCmd) EventType() eventsapi.ClientEventType {
 // Exec executes the command
 func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateCheckoutArgParser()
-	helpPrt, usagePrt := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, checkoutDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, helpPrt)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usagePrt)
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, checkoutDocs)
+	if terminate {
+		return status
 	}
 
 	queryEngine, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
 	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usagePrt)
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
 	}
 	if closeFunc != nil {
 		defer closeFunc()
@@ -113,7 +112,7 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 	// won't be as nice.
 	branchOrTrack := apr.Contains(cli.CheckoutCreateBranch) || apr.Contains(cli.CreateResetBranch) || apr.Contains(cli.TrackFlag)
 	if (branchOrTrack && apr.NArg() > 1) || (!branchOrTrack && apr.NArg() == 0) {
-		usagePrt()
+		usage()
 		return 1
 	}
 
@@ -125,7 +124,7 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 		branchName, _ = apr.GetValue(cli.CreateResetBranch)
 	} else if apr.Contains(cli.TrackFlag) {
 		if apr.NArg() > 0 {
-			usagePrt()
+			usage()
 			return 1
 		}
 		remoteAndBranchName, _ := apr.GetValue(cli.TrackFlag)
@@ -136,7 +135,7 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 
 	sqlQuery, err := generateCheckoutSql(args)
 	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usagePrt)
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
 	}
 
 	rows, err := GetRowsForSql(queryEngine, sqlCtx, sqlQuery)
@@ -155,20 +154,20 @@ func (cmd CheckoutCmd) Exec(ctx context.Context, commandStr string, args []strin
 				return 0
 			}
 		}
-		return HandleVErrAndExitCode(handleErrors(branchName, err), usagePrt)
+		return HandleVErrAndExitCode(handleErrors(branchName, err), usage)
 	}
 
 	if len(rows) != 1 {
-		return HandleVErrAndExitCode(errhand.BuildDError("expected 1 row response from %s, got %d", sqlQuery, len(rows)).Build(), usagePrt)
+		return HandleVErrAndExitCode(errhand.BuildDError("expected 1 row response from %s, got %d", sqlQuery, len(rows)).Build(), usage)
 	}
 
 	if len(rows[0]) < 2 {
-		return HandleVErrAndExitCode(errhand.BuildDError("no 'message' field in response from %s", sqlQuery).Build(), usagePrt)
+		return HandleVErrAndExitCode(errhand.BuildDError("no 'message' field in response from %s", sqlQuery).Build(), usage)
 	}
 
 	var message string
 	if message, ok = rows[0][1].(string); !ok {
-		return HandleVErrAndExitCode(errhand.BuildDError("expected string value for 'message' field in response from %s ", sqlQuery).Build(), usagePrt)
+		return HandleVErrAndExitCode(errhand.BuildDError("expected string value for 'message' field in response from %s ", sqlQuery).Build(), usage)
 	}
 
 	if message != "" {
diff --git a/go/cmd/dolt/commands/commit.go b/go/cmd/dolt/commands/commit.go
index d9f48d5022..56b50a864c 100644
--- a/go/cmd/dolt/commands/commit.go
+++ b/go/cmd/dolt/commands/commit.go
@@ -104,14 +104,13 @@ func (cmd CommitCmd) Exec(ctx context.Context, commandStr string, args []string,
 // (e.g. because --skip-empty was specified as an argument).
 func performCommit(ctx context.Context, commandStr string, args []string, cliCtx cli.CliContext, temporaryDEnv *env.DoltEnv) (int, bool) {
 	ap := cli.CreateCommitArgParser()
-	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, commitDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage), false
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, commitDocs)
+	if terminate {
+		return status, false
 	}
 
 	if err := cli.VerifyCommitArgs(apr); err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), help), false
+		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage), false
 	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go
index 8b06822a16..7b9107e5f5 100644
--- a/go/cmd/dolt/commands/diff.go
+++ b/go/cmd/dolt/commands/diff.go
@@ -185,12 +185,11 @@ func (cmd DiffCmd) RequiresRepo() bool {
 }
 
 // Exec executes the command
-func (cmd DiffCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
+func (cmd DiffCmd) Exec(ctx context.Context, commandStr string, args []string, _ *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
-	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, diffDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, diffDocs)
+	if terminate {
+		return status
 	}
 
 	verr := cmd.validateArgs(apr)
diff --git a/go/cmd/dolt/commands/log.go b/go/cmd/dolt/commands/log.go
index 1ccea786dc..195d97aa57 100644
--- a/go/cmd/dolt/commands/log.go
+++ b/go/cmd/dolt/commands/log.go
@@ -99,10 +99,9 @@ func (cmd LogCmd) Exec(ctx context.Context, commandStr string, args []string, dE
 
 func (cmd LogCmd) logWithLoggerFunc(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cmd.ArgParser()
-	help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, logDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return handleErrAndExit(err)
+	apr, _, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, logDocs)
+	if terminate {
+		return status
 	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/merge.go b/go/cmd/dolt/commands/merge.go
index acae6ee048..b65e96f0fa 100644
--- a/go/cmd/dolt/commands/merge.go
+++ b/go/cmd/dolt/commands/merge.go
@@ -94,10 +94,9 @@ func (cmd MergeCmd) RequiresRepo() bool {
 func (cmd MergeCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateMergeArgParser()
 	ap.SupportsFlag(cli.NoJsonMergeFlag, "", "Do not attempt to automatically resolve multiple changes to the same JSON value, report a conflict instead.")
-	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, mergeDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, mergeDocs)
+	if terminate {
+		return status
 	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/reset.go b/go/cmd/dolt/commands/reset.go
index 275d457728..7f4e272e18 100644
--- a/go/cmd/dolt/commands/reset.go
+++ b/go/cmd/dolt/commands/reset.go
@@ -89,12 +89,11 @@ func (cmd ResetCmd) RequiresRepo() bool {
 }
 
 // Exec executes the command
-func (cmd ResetCmd) Exec(ctx context.Context, commandStr string, args []string, dEnv *env.DoltEnv, cliCtx cli.CliContext) int {
+func (cmd ResetCmd) Exec(ctx context.Context, commandStr string, args []string, _ *env.DoltEnv, cliCtx cli.CliContext) int {
 	ap := cli.CreateResetArgParser()
-	help, usage := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, resetDocContent, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usage)
+	apr, usage, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, resetDocContent)
+	if terminate {
+		return status
 	}
 
 	queryist, sqlCtx, closeFunc, err := cliCtx.QueryEngine(ctx)
diff --git a/go/cmd/dolt/commands/status.go b/go/cmd/dolt/commands/status.go
index d4440f039a..1c5b1465e6 100644
--- a/go/cmd/dolt/commands/status.go
+++ b/go/cmd/dolt/commands/status.go
@@ -100,14 +100,11 @@ func (cmd StatusCmd) EventType() eventsapi.ClientEventType {
 	return eventsapi.ClientEventType_STATUS
 }
 
-// Exec executes the command
 func (cmd StatusCmd) Exec(ctx context.Context, commandStr string, args []string, _ *env.DoltEnv, cliCtx cli.CliContext) int {
-	// parse arguments
 	ap := cmd.ArgParser()
-	help, _ := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, statusDocs, ap))
-	apr, err := cli.ParseArgs(ap, args, help)
-	if err != nil {
-		return handleStatusVErr(err)
+	apr, _, terminate, status := ParseArgsAndPrintHelp(ap, commandStr, args, statusDocs)
+	if terminate {
+		return status
 	}
 
 	showIgnoredTables := apr.Contains(cli.ShowIgnoredFlag)
@@ -660,7 +657,9 @@ and have %v and %v different commits each, respectively.
 }
 
 func handleStatusVErr(err error) int {
-	cli.PrintErrln(errhand.VerboseErrorFromError(err).Verbose())
+	if err != argparser.ErrHelp {
+		cli.PrintErrln(errhand.VerboseErrorFromError(err).Verbose())
+	}
 	return 1
 }
 
diff --git a/go/cmd/dolt/commands/utils.go b/go/cmd/dolt/commands/utils.go
index 1b694e60a6..6577bbbb48 100644
--- a/go/cmd/dolt/commands/utils.go
+++ b/go/cmd/dolt/commands/utils.go
@@ -24,11 +24,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/mysql_db"
-	"github.com/gocraft/dbr/v2"
-	"github.com/gocraft/dbr/v2/dialect"
-
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
@@ -40,6 +35,10 @@ import (
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 	"github.com/dolthub/dolt/go/store/datas"
 	"github.com/dolthub/dolt/go/store/util/outputpager"
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/mysql_db"
+	"github.com/gocraft/dbr/v2"
+	"github.com/gocraft/dbr/v2/dialect"
 )
 
 type CommitInfo struct {
@@ -774,6 +773,23 @@ func getHashOf(queryist cli.Queryist, sqlCtx *sql.Context, ref string) (string,
 	return rows[0][0].(string), nil
 }
 
+func ParseArgsAndPrintHelp(
+	ap *argparser.ArgParser,
+	commandStr string,
+	args []string,
+	docs cli.CommandDocumentationContent) (apr *argparser.ArgParseResults, usage cli.UsagePrinter, terminate bool, exitStatus int) {
+	helpPrt, usagePrt := cli.HelpAndUsagePrinters(cli.CommandDocsForCommandString(commandStr, docs, ap))
+	var err error
+	apr, err = cli.ParseArgs(ap, args, helpPrt)
+	if err != nil {
+		if err == argparser.ErrHelp {
+			return nil, usagePrt, true, 0
+		}
+		return nil, usagePrt, true, HandleVErrAndExitCode(errhand.VerboseErrorFromError(err), usagePrt)
+	}
+	return apr, usagePrt, false, 0
+}
+
 func HandleVErrAndExitCode(verr errhand.VerboseError, usage cli.UsagePrinter) int {
 	if verr != nil {
 		if msg := verr.Verbose(); strings.TrimSpace(msg) != "" {

From 05fc0e822ebbe940690eddd5dafa903fe7b6c120 Mon Sep 17 00:00:00 2001
From: macneale4 <macneale4@users.noreply.github.com>
Date: Tue, 4 Jun 2024 16:13:28 +0000
Subject: [PATCH 09/11] [ga-format-pr] Run go/utils/repofmt/format_repo.sh and
 go/Godeps/update.sh

---
 go/cmd/dolt/commands/utils.go | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/go/cmd/dolt/commands/utils.go b/go/cmd/dolt/commands/utils.go
index 6577bbbb48..ab7119e51a 100644
--- a/go/cmd/dolt/commands/utils.go
+++ b/go/cmd/dolt/commands/utils.go
@@ -24,6 +24,11 @@ import (
 	"strings"
 	"time"
 
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/mysql_db"
+	"github.com/gocraft/dbr/v2"
+	"github.com/gocraft/dbr/v2/dialect"
+
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
@@ -35,10 +40,6 @@ import (
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 	"github.com/dolthub/dolt/go/store/datas"
 	"github.com/dolthub/dolt/go/store/util/outputpager"
-	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/mysql_db"
-	"github.com/gocraft/dbr/v2"
-	"github.com/gocraft/dbr/v2/dialect"
 )
 
 type CommitInfo struct {

From 3c8582817b8d0225a3bb5975a783f7e625d08436 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Tue, 4 Jun 2024 11:59:12 -0700
Subject: [PATCH 10/11] Suppress warning about dumb terminals

---
 go/store/util/outputpager/page_output.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/go/store/util/outputpager/page_output.go b/go/store/util/outputpager/page_output.go
index c2596dc0fa..20064b1595 100644
--- a/go/store/util/outputpager/page_output.go
+++ b/go/store/util/outputpager/page_output.go
@@ -72,7 +72,8 @@ func Start() *Pager {
 		// -S ... Chop (truncate) long lines rather than wrapping.
 		// -R ... Output "raw" control characters.
 		// -X ... Don't use termcap init/deinit strings.
-		cmd = exec.Command(lessPath, "-FSRX")
+		// -d ... Don't complain about dumb terminals.
+		cmd = exec.Command(lessPath, "-FSRXd")
 	}
 
 	stdin, stdout, err := os.Pipe()

From 9cbf1ecf94125ff9c62df3d790bf018580e21800 Mon Sep 17 00:00:00 2001
From: Neil Macneale IV <neil@dolthub.com>
Date: Tue, 4 Jun 2024 12:38:52 -0700
Subject: [PATCH 11/11] expect tests fail for the remote case. punting

---
 integration-tests/bats/sql-shell.bats | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/integration-tests/bats/sql-shell.bats b/integration-tests/bats/sql-shell.bats
index a59e0b6932..7777cea8db 100644
--- a/integration-tests/bats/sql-shell.bats
+++ b/integration-tests/bats/sql-shell.bats
@@ -70,6 +70,9 @@ teardown() {
 # bats test_tags=no_lambda
 @test "sql-shell: sql shell executes slash commands" {
     skiponwindows "Need to install expect and make this script work on windows."
+    if [ "$SQL_ENGINE" = "remote-engine" ]; then
+      skip "Current test setup results in remote calls having a clean branch, where this expect script expects dirty."
+    fi
     run $BATS_TEST_DIRNAME/sql-shell-slash-cmds.expect
     echo "$output"