more improvements with autocomplete

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,30 @@
+// 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?
+}
+
+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.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"go.wit.com/dev/alexflint/arg"
 	"go.wit.com/lib/gui/shell"
@@ -31,11 +32,13 @@ type BashAuto struct {
 	appName string // a good way to track the name of the binary ?
 }
 
+/*
 func dumpjunk() {
 	fmt.Fprintln(os.Stderr, "")
 	fmt.Fprintln(os.Stderr, os.Args)
 	os.Exit(0)
 }
+*/
 
 // argname is the name of the executable
 func Bash(argname string, autocomplete func([]string)) *BashAuto {
@@ -58,6 +61,27 @@ func Bash(argname string, autocomplete func([]string)) *BashAuto {
 	return myBash
 }
 
+// print out auto complete debugging info
+func (pb *Auto) AutoDebug() {
+	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)
+	// fmt.Println("--all --gui --verbose --force")
+}
+
+// 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 myBash.appName
@@ -92,58 +116,3 @@ func doBash(argname string) {
 	}
 	os.Exit(0)
 }
-
-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
-}
-
-/*
-// 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, "")
-}
-*/

bash2.go

@@ -0,0 +1,237 @@
+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 doHandlePB(pb *Auto) 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)
+				pb.Debugf("AUTO HISTORY: ctime='%v' age=%s argv='%v'", found.Ctime, shell.FormatDuration(dur), 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 parseArgv(argname string) *Auto {
+	newauto := new(Auto)
+	newauto.Argname = argname
+	if len(os.Args) == 0 {
+		return newauto
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "--bash" {
+		newauto.SetupAuto = true
+		return newauto
+	}
+
+	// HACK: set debug flag if --autodebug is passed
+	for _, s := range os.Args {
+		if s == "--autodebug" {
+			newauto.Debug = true
+		}
+	}
+
+	// should we do auto complete here?
+	if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
+		newauto.IsAuto = true
+		newauto.Arg0 = os.Args[0]
+		newauto.Arg1 = os.Args[1]
+		newauto.Partial = os.Args[2]
+		newauto.Arg3 = os.Args[3]
+		if len(os.Args) < 5 {
+			// the user is doing autocomplete on the command itself
+			newauto.Partial = ""
+			newauto.Cmd = ""
+			newauto.Argv = []string{""}
+			return newauto
+		}
+		newauto.Argv = os.Args[4:]
+		if newauto.Partial == "''" {
+			newauto.Partial = ""
+			newauto.Cmd = "todo:findme"
+		}
+		// set pb.Cmd to the first thing that doesn't have a '-' arg
+		for _, s := range newauto.Argv {
+			if strings.HasPrefix(s, "-") {
+				continue
+			}
+			newauto.Cmd = s
+			break
+		}
+		if newauto.Cmd == "" {
+			newauto.Cmd = strings.Join(newauto.Argv, "BLAH")
+		}
+		return newauto
+	}
+	return newauto
+}
+
+// also try to parse/send cur (?)
+func Bash2(argname string, autocomplete func(*Auto)) {
+	newauto := parseArgv(argname)
+	if newauto.SetupAuto {
+		doBash2(argname)
+		os.Exit(0)
+	}
+
+	if newauto.Debug {
+		// dump debug info
+		newauto.AutoDebug()
+	}
+
+	if len(os.Args) > 1 && os.Args[1] == "--auto-complete" {
+		doHandlePB(newauto)
+		autocomplete(newauto)
+		os.Exit(0)
+	}
+
+	arg.Register(&argBash)
+}

bashCompletion.go

@@ -0,0 +1,75 @@
+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
+}