attempt to autocomplete --gui

Makefile

@@ -1,6 +1,6 @@
 # git remote add github git@github.com:wit-go/gui-debugger.git
 
-all: goimports vet
+all: auto.pb.go goimports vet
 	@echo common init code for common packages
 
 goimports:
@@ -8,3 +8,11 @@ goimports:
 
 vet:
 	@GO111MODULE=off go vet
+
+clean:
+	rm -f *.pb.go *.patch
+	-rm -f go.*
+	go-mod-clean purge
+
+auto.pb.go: auto.proto
+	autogenpb --proto auto.proto

auto.proto

@@ -0,0 +1,31 @@
+// Copyright 2025 WIT.COM Inc Licensed GPL 3.0
+
+syntax = "proto3";
+
+package httppb;
+
+import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
+import "google/protobuf/duration.proto"; // for duration
+
+message Auto {                                          // `autogenpb:marshal` `autogenpb:sort` `autogenpb:nomutex`
+        google.protobuf.Timestamp   ctime         = 1;  // when the user tried this autocomplete
+        google.protobuf.Duration    duration      = 2;  // time since the last autocomplete
+        string                      argname       = 3;  // what the shell thinks the name of the executable is
+        string                      arg0          = 4;  // what os.Exec() has as os.Argv[0]   // not interesting
+        string                      arg1          = 5;  // should always be "--auto-complete" // not interesting
+        string                      arg3          = 6;  // usually argv3 == argv0
+        repeated string             argv          = 7;  // use this to store whatever you want while the whole POST happens
+        string                      cmd           = 8;  // the cmd being processed. For "git pull <tab>", cmd would be "pull"
+        string                      partial       = 9;  // set to the partial string trying to be matched
+        bool                        isAuto        = 10; // is true if '--auto-complete' is set
+        bool                        setupAuto     = 11; // is true if '--bash' is set // setup bash autocomplete here
+        bool                        debug         = 12; // print debugging info if true
+        bool                        newline       = 13; // was a newline was sent to STDERR?
+        string                      last          = 14; // the last arg
+}
+
+message Autos {                                         // `autogenpb:marshal` `autogenpb:sort` `autogenpb:nomutex`
+        string                      uuid          = 1;  // `autogenpb:uuid:94210ebf-a534-4b33-aadd-2f5e1f56ae38`
+        string                      version       = 2;  // `autogenpb:version:v0.0.1`
+        repeated Auto               autos         = 3;  // THIS MUST BE  HttpRequest  and then  HttpRequests
+}

bash.orig.go

@@ -0,0 +1,114 @@
+package prep
+
+// initializes logging and command line options
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/log"
+)
+
+/*
+This struct can be used with the go-arg package. These
+are the generic default command line arguments for the 'GUI' package
+*/
+var argBash ArgsBash
+
+type ArgsBash struct {
+	Bash bool `arg:"--bash"                               help:"generate bash completion"`
+}
+
+// try this struct out (?)
+var myAuto *AutoArgs
+
+// this is a work in progress
+type AutoArgs struct {
+	id       int               // should be unique
+	hidden   bool              // don't update the toolkits when it's hidden
+	Auto     func([]string)    // the function for shell autocomplete
+	appName  string            // a good way to track the name of the binary ?
+	pp       *arg.Parser       // for parsing the command line args.  Yay to alexf lint!
+	autoFunc func(*Auto)       // also a function for autocomplete
+	match    map[string]string // maps for strings
+}
+
+// argname is the name of the executable
+func Bash(argname string, autocomplete func([]string)) *AutoArgs {
+	myAuto = new(AutoArgs)
+	myAuto.appName = argname
+
+	if len(os.Args) > 1 && os.Args[1] == "--bash" {
+		doBash(argname)
+		os.Exit(0)
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
+		autocomplete(os.Args[2:])
+		os.Exit(0)
+	}
+
+	arg.Register(&argBash)
+
+	// parse go.Arg here?
+	return myAuto
+}
+
+// print out auto complete debugging info
+func (pb *Auto) PrintDebug() {
+	dur := pb.Duration.AsDuration()
+	pb.Debugf("AUTOCOMPLETE: arg0='%s' arg1='%s' partial='%s' cmd='%s' age=%s argv=%v\n", pb.Arg0, pb.Arg1, pb.Partial, pb.Cmd, shell.FormatDuration(dur), pb.Argv)
+}
+
+// returns the last command (is blank if the current arg is not blank)
+func GetLast(cur string, argv []string) string {
+	if cur != "''" {
+		return ""
+	}
+	for _, s := range argv {
+		if strings.HasPrefix(s, "-") {
+			continue
+		}
+		return s
+	}
+	return ""
+}
+
+// returns the name of the executable registered for shell autocomplete
+func AppName() string {
+	return myAuto.appName
+}
+
+// makes a bash autocomplete file for your command
+func doBash(argname string) {
+	fmt.Println(makeBashCompletionText(argname))
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		log.Printf("%v\n", err)
+		os.Exit(0)
+	}
+	filename := filepath.Join(homeDir, ".local/share/bash-completion/completions", argname)
+	if shell.Exists(filename) {
+		log.Println(filename, "file already exists")
+		os.Exit(0)
+	}
+	basedir, _ := filepath.Split(filename)
+	if !shell.IsDir(basedir) {
+		os.MkdirAll(basedir, os.ModePerm)
+	}
+
+	if f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
+		f.Write([]byte(makeBashCompletionText(argname)))
+		f.Close()
+		log.Println("bash file created:", filename)
+		log.Println("restart bash")
+	} else {
+		log.Info(filename, err)
+	}
+	os.Exit(0)
+}

complete.go

@@ -0,0 +1,388 @@
+package prep
+
+// initializes logging and command line options
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/log"
+	durationpb "google.golang.org/protobuf/types/known/durationpb"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
+)
+
+// makes a bash autocomplete file for your command
+func doBash2(argname string) {
+	fmt.Println(makeBashCompletionText2(argname))
+
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		log.Printf("%v\n", err)
+		os.Exit(0)
+	}
+	filename := filepath.Join(homeDir, ".local/share/bash-completion/completions", argname)
+	if shell.Exists(filename) {
+		log.Println(filename, "file already exists")
+		// os.Exit(0)
+	}
+	basedir, _ := filepath.Split(filename)
+	if !shell.IsDir(basedir) {
+		os.MkdirAll(basedir, os.ModePerm)
+	}
+
+	if f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644); err == nil {
+		f.Write([]byte(makeBashCompletionText2(argname)))
+		f.Close()
+		log.Println("bash file created:", filename)
+		log.Println("restart bash")
+	} else {
+		log.Info(filename, err)
+	}
+	os.Exit(0)
+}
+
+func (pb *Auto) Debugf(fmts string, parts ...any) {
+	fmts = strings.TrimSpace(fmts)
+	fmts += "\n"
+	// NOTE: env doesn't work probably most (all?) the time because bash
+	// doesn't send all the ENV to autocomplete. so, trap on a "--autodebug" command line arg
+	if os.Getenv("AUTOCOMPLETE_VERBOSE") == "true" || pb.Debug {
+		if !pb.Newline {
+			fmt.Fprintf(os.Stderr, "\n")
+			pb.Newline = true
+		}
+		fmt.Fprintf(os.Stderr, fmts, parts...)
+	} else {
+		// fmt.Fprintf(os.Stderr, "NOT DOING ANYTHING\n")
+	}
+}
+
+// makes a bash autocomplete file for your command
+func (pb *Auto) doHandlePB() error {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+	basedir := filepath.Join(homeDir, ".cache/autocomplete")
+	os.MkdirAll(basedir, os.ModePerm)
+	fullname := filepath.Join(basedir, pb.Argname+".pb")
+
+	all := NewAutos()
+	var last *Auto
+	data, err := os.ReadFile(fullname)
+	if err == nil {
+		err = all.Unmarshal(data)
+		if err == nil {
+			for found := range all.IterAll() {
+				dur := time.Since(found.Ctime.AsTime())
+				pb.Duration = durationpb.New(dur)
+				// found.PrintDebug()
+				cmd := fmt.Sprintf("cmd='%s'", found.Cmd)
+				arglast := fmt.Sprintf("last='%s'", found.Last)
+				pb.Debugf("AUTO HISTORY: age=%-6.6s %-18.18s %-18.18s partial='%s' argv='%v'", shell.FormatDuration(dur), cmd, arglast, found.Partial, found.Argv)
+				last = found
+			}
+		}
+	}
+
+	if all.Len() > 15 {
+		pb.Debugf("DEBUG: trim() history is over 100 len=%d vs new=%d", all.Len(), all.Len()-90)
+		all.Autos = all.Autos[all.Len()-10:]
+		// newall.Autos = all.Autos[0:10]
+		// for _, found := range all.Autos[0:10] {
+		// 	newall.Append(found)
+		// }
+	}
+
+	// need this for the first time the user runs autocomplete
+	if last == nil {
+		last = new(Auto)
+	}
+
+	now := time.Now()
+	pb.Ctime = timestamppb.New(now)
+	duration := time.Since(last.Ctime.AsTime())
+	all.Append(pb)
+
+	data, err = all.Marshal()
+	if err != nil {
+		return err
+	}
+
+	f, err := os.OpenFile(fullname, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	defer f.Close()
+	if err != nil {
+		return err
+	}
+	_, err = f.Write(data)
+	pb.Debugf("WRITE DEBUG: write PB='%s' len(pb)=%d len(data)=%d dur=%v err=%v", fullname, all.Len(), len(data), duration, err)
+	return err
+}
+
+/*
+// prints help to STDERR // TODO: move everything below this to go-args
+func (args) doBashHelp() {
+	if argv.BashAuto[1] != "''" {
+		// if this is not blank, then the user has typed something
+		return
+	}
+	if argv.BashAuto[0] != ARGNAME {
+		// if this is not the name of the command, the user already started doing something
+		return
+	}
+	if argv.BashAuto[0] == ARGNAME {
+		me.pp.WriteHelp(os.Stderr)
+		return
+	}
+	fmt.Fprintln(os.Stderr, "")
+	fmt.Fprintln(os.Stderr, "hello world")
+	fmt.Fprintln(os.Stderr, "")
+}
+*/
+
+func (pb *Auto) Autocomplete(notsure any, sendthis string) {
+	parts := strings.Split(sendthis, " ")
+	var all []string
+	for _, part := range parts {
+		var found bool
+		for _, s := range os.Args {
+			if s == part {
+				found = true
+			}
+		}
+		if found {
+			continue
+		}
+		all = append(all, part)
+	}
+	fmt.Printf("%s", strings.Join(all, " "))
+}
+
+func (pb *Auto) Autocomplete2(sendthis string) {
+	dur := pb.Duration.AsDuration()
+	if dur < time.Millisecond*200 {
+		pb.Debug = true
+		/*
+			pb.Debugf("TODO: show extended help here '%s' '%s' %v dur=%v\n", pb.Arg0, pb.Arg1, pb.Argv, shell.FormatDuration(dur))
+			pb.PrintDebug()
+			fmt.Println(" ")
+		*/
+		if myAuto.pp == nil {
+			pb.Debugf("myAuto.pp == nil")
+		} else {
+			pb.Debugf("myAuto.pp != nil")
+			if pb.Cmd == "" {
+				myAuto.pp.WriteHelp(os.Stderr)
+			} else {
+				myAuto.pp.WriteHelpForSubcommand(os.Stderr, pb.Cmd)
+			}
+		}
+	}
+
+	parts := strings.Split(sendthis, " ")
+	var all []string
+	for _, part := range parts {
+		var found bool
+		for _, s := range os.Args {
+			if s == part {
+				found = true
+			}
+		}
+		if found {
+			continue
+		}
+		all = append(all, part)
+	}
+	fmt.Printf("%s", strings.Join(all, " "))
+	/*
+		if dur > time.Millisecond*200 {
+			if dur < time.Millisecond*800 {
+				// fmt.Println("a b")
+				fmt.Println(pb.Partial + " hello world")
+			}
+		}
+	*/
+}
+
+func parseArgv(argname string) *Auto {
+	pb := new(Auto)
+	pb.Argname = argname
+	if len(os.Args) == 0 {
+		return pb
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "--bash" {
+		pb.SetupAuto = true
+		return pb
+	}
+
+	// HACK: set debug flag if --autodebug is passed
+	for _, s := range os.Args {
+		if s == "--autodebug" {
+			pb.Debug = true
+		}
+	}
+
+	// should we do auto complete here?
+	if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
+		pb.IsAuto = true
+		pb.Arg0 = os.Args[0]
+		pb.Arg1 = os.Args[1]
+		pb.Partial = os.Args[2]
+		pb.Arg3 = os.Args[3]
+		if len(os.Args) < 5 {
+			// the user is doing autocomplete on the command itself
+			pb.Partial = ""
+			pb.Cmd = ""
+			pb.Argv = []string{""}
+			return pb
+		}
+		pb.Argv = os.Args[4:]
+		if pb.Partial == "''" {
+			pb.Partial = ""
+			pb.Cmd = "todo:findme"
+		}
+		// set pb.Cmd to the first thing that doesn't have a '-' arg
+		for _, s := range pb.Argv {
+			if strings.HasPrefix(s, "-") {
+				continue
+			}
+			pb.Cmd = s
+			break
+		}
+		if pb.Partial == "'"+pb.Cmd+"'" {
+			// not really a command, it's just a partially inputed string from the user
+			pb.Cmd = ""
+		}
+		// try to figure out what the last argv is
+		for _, s := range pb.Argv {
+			p := fmt.Sprintf("'%s'", s)
+			if pb.Partial == p {
+				pb.Debugf("DEBUG: MATCH Partial %s %s", s, p)
+				continue
+			} else {
+				pb.Debugf("DEBUG: NO MATCH Partial %s %s", s, p)
+			}
+			pb.Last = s
+		}
+		// if pb.Cmd == "" {
+		// 	pb.Cmd = strings.Join(pb.Argv, "BLAH")
+		// }
+	}
+	return pb
+}
+
+// also try to parse/send cur (?)
+func Bash2(argname string, appAutoFunc func(*Auto)) *Auto {
+	pb := parseArgv(argname)
+	if pb.SetupAuto {
+		// --bash was passed. try to configure bash-completion
+		doBash2(argname)
+		os.Exit(0)
+	}
+
+	if pb.Debug {
+		// dump debug info
+		pb.PrintDebug()
+	}
+
+	if pb.IsAuto {
+		pb.doHandlePB()
+		if pb.Debug {
+			// TODO:
+			// check here to see if there was any completion text sent
+			// if not, send "reset bash newline\n" to cause bash to redraw PS1 for the user
+		}
+		arg.Register(&argBash)
+		// flags := []string{pb.Arg3, pb.Arg0}
+		// arg.InitFlags(flags)
+
+		appAutoFunc(pb) // run the autocomplete function the user made for their application
+		os.Exit(0)
+	}
+
+	arg.Register(&argBash)
+	return pb
+}
+
+// also try to parse/send cur (?)
+// func Bash3(appAutoFunc func(*Auto), dest any) *Auto {
+func Bash3(dest any) *Auto {
+	myAuto = new(AutoArgs)
+	findAppInfo(dest) // parses back to main() for argv info
+
+	pb := parseArgv(myAuto.appName)
+	if pb.SetupAuto {
+		// --bash was passed. try to configure bash-completion
+		doBash2(myAuto.appName)
+		os.Exit(0)
+	}
+
+	myAuto.match = make(map[string]string)
+	myAuto.match["--gui"] = "andlabs gocui"
+
+	if pb.Debug {
+		// dump debug info
+		pb.PrintDebug()
+	}
+
+	pb.doHandlePB() // read in the history protobuf file
+
+	// turn on debugging if duration < 200 milliseconds
+	dur := pb.Duration.AsDuration()
+	if dur < time.Millisecond*200 {
+		pb.Debug = true
+	}
+
+	// prepart["--gui"] = "andlabs gocui"
+
+	arg.Register(&argBash)
+	flags := []string{}
+	for _, s := range pb.Argv {
+		if s == "--autodebug" {
+			continue
+		}
+		flags = append(flags, s)
+	}
+	// pb.Debug = true
+	pb.Debugf("DEBUG: MustParse(%v)", flags)
+	var err error
+	myAuto.pp, err = arg.ParseFlags(flags, dest)
+	if err != nil {
+		pb.Debugf("DEBUG: Parse error: %v", err)
+	}
+
+	if myAuto.pp == nil {
+		pb.Debugf("DEBUG: myAuto.pp == nil after ParseFlags()")
+	} else {
+		pb.Debugf("DEBUG: myAuto.pp is ok after ParseFlags()")
+	}
+
+	if pb.IsAuto {
+		for key, val := range myAuto.match {
+			if pb.Last == key {
+				pb.Debugf("DEBUG: last=%s found key %s = %s", pb.Last, key, val)
+				pb.Autocomplete2(val)
+				os.Exit(0)
+			} else {
+				pb.Debugf("DEBUG: NO MATCH last='%s' found key '%s' = %s", pb.Last, key, val)
+			}
+		}
+		myAuto.autoFunc(pb) // run the autocomplete function the user made for their application
+		if pb.Debug {
+			// TODO:
+			// check here to see if there was any completion text sent
+			// if not, send "reset bash newline\n" to cause bash to redraw PS1 for the user
+		}
+		os.Exit(0)
+	}
+
+	arg.Register(&argBash)
+	myAuto.pp = arg.MustParse(dest)
+	return pb
+}

debugger.go

@@ -40,3 +40,32 @@ func Debugger() {
 	CHAN = log.NewFlag("CHAN", true, full, short, "chan() test code output")
 	WARN = log.NewFlag("WARN", true, full, short, "should warn the user")
 }
+
+// Versioned is the interface that the destination struct should implement to
+// make a version string appear at the top of the help message.
+type Appnamed interface {
+	// Version returns the version string that will be printed on a line by itself
+	// at the top of the help message.
+	Appname() string
+}
+
+type AutoFuncd interface {
+	// Version returns the version string that will be printed on a line by itself
+	// at the top of the help message.
+	DoAutoComplete(*Auto)
+}
+
+// Described is the interface that the destination struct should implement to
+func findAppInfo(tmp interface{}) {
+	if tmp, ok := tmp.(Appnamed); ok {
+		myAuto.appName = tmp.Appname()
+	} else {
+		panic("you need to make the function argv.Appname()")
+	}
+
+	if tmp, ok := tmp.(AutoFuncd); ok {
+		myAuto.autoFunc = tmp.DoAutoComplete
+	} else {
+		panic("you need to make the function argv.DoAutoComplete()")
+	}
+}

gui.go

@@ -3,8 +3,12 @@ package prep
 // initializes logging and command line options
 
 import (
+	"os"
+
 	"go.wit.com/dev/alexflint/arg"
 	"go.wit.com/gui"
+	"go.wit.com/lib/fhelp"
+	"go.wit.com/log"
 )
 
 var argGui ArgsGui
@@ -14,7 +18,8 @@ This struct can be used with the go-arg package. These
 are the generic default command line arguments for the 'GUI' package
 */
 type ArgsGui struct {
-	GuiPluginHack string `arg:"--gui-check-plugin" help:"hack to verify GO plugins load"`
+	GuiPlugin  string `arg:"--gui"              help:"select the plugin (andlabs,gocui,etc)"`
+	GuiVerbose bool   `arg:"--gui-verbose"      help:"enable all logging"`
 }
 
 /*
@@ -46,14 +51,57 @@ func ArgToolkit() string {
 func postMustParse(s string) string {
 	switch s {
 	case "PluginHack":
-		return argGui.GuiPluginHack
+	case "VERBOSE":
+		if argGui.GuiVerbose == true {
+			return "true"
+		}
+		return "false"
+	case "DEFAULT":
+		if argGui.GuiPlugin != "" {
+			return argGui.GuiPlugin
+		}
+		return "gocui"
+	case "FILE":
+		return "someplugin"
 	default:
 		return ""
 	}
+	return "unknown"
 }
 
-func Gui() *gui.Node {
+var prepGui *GuiPrep
-	arg.Register(&argDebugger)
 
-	return gui.PreInit(postMustParse)
+type GuiPrep struct {
+	rootn  *gui.Node
+	hidden bool // don't update the toolkits when it's hidden
+	Auto   func([]string)
+}
+
+func Gui() *GuiPrep {
+	if len(os.Args) > 1 && os.Args[1] == "--gui-check-plugin" {
+		gui.TestPluginAndExitNew(os.Args[2])
+		os.Exit(0)
+	}
+	arg.Register(&argGui)
+
+	prepGui = new(GuiPrep)
+	prepGui.rootn = gui.PreInit(postMustParse)
+	return prepGui
+}
+
+func (g *GuiPrep) Start() error {
+	// me.myGui.InitEmbed(resources)
+	if pname, err := g.rootn.Default(); err != nil {
+		if !fhelp.BuildPlugin("gocui") {
+			log.Info("You can't run the forge GUI since the plugins did not build", pname)
+			return nil
+		}
+		if err := g.rootn.LoadToolkitNew("gocui"); err != nil {
+			log.Info("The plugins built, but still failed to load", pname)
+			return err
+		}
+	} else {
+		log.Info("The plugins built and loaded!", pname)
+	}
+	return nil
 }

shell.go

@@ -0,0 +1,103 @@
+package prep
+
+// initializes logging and command line options
+
+import (
+	"fmt"
+)
+
+func makeBashCompletionText(argname string) string {
+	var out string
+
+	out += fmt.Sprintf("# add this in your bashrc:\n")
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("# todo: add this to go-arg as a 'hidden' go-arg option --bash\n")
+	out += fmt.Sprintf("#\n")
+	out += fmt.Sprintf("# Put the below in the file: ~/.local/share/bash-completion/completions/%s\n", argname)
+	out += fmt.Sprintf("#\n")
+	out += fmt.Sprintf("# todo: make this output work/parse with:\n")
+	out += fmt.Sprintf("# complete -C %s --bash go\n", argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("_%s_complete()\n", argname)
+	out += fmt.Sprintf("{\n")
+	out += fmt.Sprintf("	# sets local to this func vars\n")
+	out += fmt.Sprintf("	local cur prev all\n")
+	out += fmt.Sprintf("	cur=${COMP_WORDS[COMP_CWORD]}\n")
+	out += fmt.Sprintf("	prev=${COMP_WORDS[COMP_CWORD-1]}\n")
+	out += fmt.Sprintf("	all=${COMP_WORDS[@]}\n")
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("	# this is where we generate the go-arg output\n")
+	out += fmt.Sprintf("        GOARGS=$(%s --auto-complete $prev \\'$cur\\' $all)\n", argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("	# this compares the command line input from the user\n")
+	out += fmt.Sprintf("	# to whatever strings we output\n")
+	out += fmt.Sprintf("        COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) )  # THIS WORKS\n")
+	out += fmt.Sprintf("	return 0\n")
+	out += fmt.Sprintf("}\n")
+	out += fmt.Sprintf("complete -F _%s_complete %s\n", argname, argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("# copy and paste the above into your bash shell should work\n")
+	return out
+}
+
+func makeBashCompletionText2(argname string) string {
+	var out string
+
+	out += fmt.Sprintf("# add this in your bashrc:\n")
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("# todo: add this to go-arg as a 'hidden' go-arg option --bash\n")
+	out += fmt.Sprintf("#\n")
+	out += fmt.Sprintf("# Put the below in the file: ~/.local/share/bash-completion/completions/%s\n", argname)
+	out += fmt.Sprintf("#\n")
+	out += fmt.Sprintf("# todo: make this output work/parse with:\n")
+	out += fmt.Sprintf("# complete -C %s --bash go\n", argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("_%s_complete()\n", argname)
+	out += fmt.Sprintf("{\n")
+	out += fmt.Sprintf("	# sets local to this func vars\n")
+	out += fmt.Sprintf("	local cur prev all\n")
+	out += fmt.Sprintf("	cur=${COMP_WORDS[COMP_CWORD]}\n")
+	out += fmt.Sprintf("	# prev=${COMP_WORDS[COMP_CWORD-1]}\n")
+	out += fmt.Sprintf("	all=${COMP_WORDS[@]}\n")
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("	# this is where we generate the go-arg output\n")
+	out += fmt.Sprintf("        GOARGS=$(%s --auto-complete \\'$cur\\' $all)\n", argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("	# this compares the command line input from the user\n")
+	out += fmt.Sprintf("	# to whatever strings we output\n")
+	out += fmt.Sprintf("        COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) )  # THIS WORKS\n")
+	out += fmt.Sprintf("	return 0\n")
+	out += fmt.Sprintf("}\n")
+	out += fmt.Sprintf("complete -F _%s_complete %s\n", argname, argname)
+	out += fmt.Sprintf("\n")
+	out += fmt.Sprintf("# copy and paste the above into your bash shell should work\n")
+	return out
+}
+
+// zsh:
+/*
+#compdef forge
+
+# Zsh completion function for the 'forge' command.
+
+_forge_completions() {
+  local -a words
+  local -i CURRENT
+
+  # Zsh's equivalent of Bash's COMP_WORDS and COMP_CWORD
+  words=("${(@)words}")
+  CURRENT=$CURRENT
+
+  # Generate the completion suggestions by calling the forge command.
+  # The output is split into an array.
+  local -a suggestions
+  suggestions=("${(@f)$(forge --auto-complete "'${words[CURRENT]}'" "${words[@]}")}")
+
+  # Pass the suggestions to the Zsh completion system.
+  _describe 'completions' suggestions
+}
+
+# Register the function to be called for the 'forge' command.
+_forge_completions "$@"
+
+*/

smartcd.test

@@ -0,0 +1,18 @@
+_cd_complete()
+{
+	# sets local to this func vars
+	local cur prev all
+	cur=${COMP_WORDS[COMP_CWORD]}
+	# prev=${COMP_WORDS[COMP_CWORD-1]}
+	all=${COMP_WORDS[@]}
+
+	# this is where we generate the go-arg output
+        GOARGS=$(smartcd --auto-complete \'$cur\' $all)
+
+	# this compares the command line input from the user
+	# to whatever strings we output
+        COMPREPLY=( $(compgen -W "$GOARGS" -- $cur) )  # THIS WORKS
+	return 0
+}
+complete -F _cd_complete cd
+