Makefile

@@ -37,6 +37,3 @@ clean:
 
 all: install
 	go-mod-clean --all --auto
-
-autocomplete:
-	go-mod-clean --bash > ~/.local/share/bash-completion/completions/go-mod-clean

argv.go

@@ -1,10 +1,5 @@
 package main
 
-import (
-	"fmt"
-	"os"
-)
-
 /*
 	this parses the command line arguements
 */
@@ -12,18 +7,12 @@ import (
 var argv args
 
 type args struct {
-	Trim     bool      `arg:"--trim"      default:"true"     help:"trim entries from go.sum"`
+	Trim    bool `arg:"--trim"      default:"true"     help:"trim entries from go.sum"`
-	Verbose  bool      `arg:"--verbose"                      help:"show more"`
+	Verbose bool `arg:"--verbose"                      help:"show more"`
-	Restore  bool      `arg:"--restore"                      help:"only restore from go/pkg/mod/"`
+	Restore bool `arg:"--restore"                      help:"only restore from go/pkg/mod/"`
-	Force    bool      `arg:"--force"                        help:"remove things and redo them no matter what"`
+	Force   bool `arg:"--force"                        help:"remove things and redo them no matter what"`
-	Purge    *EmptyCmd `arg:"subcommand:purge"               help:"purge all git notes. (this is where the autogenerated files are stored)"`
+	Strict  bool `arg:"--strict"                       help:"never make go.* files unless everything is perfect"`
-	Smart    *EmptyCmd `arg:"subcommand:lax"                 help:"try something but never do os.Exit(-1)"`
+	Purge   bool `arg:"--purge"                        help:"purge all the git notes. this might be bad for you."`
-	Strict   *EmptyCmd `arg:"subcommand:strict"              help:"never make go.* files unless everything is perfect"`
-	Bash     bool      `arg:"--bash"                         help:"generate bash completion"`
-	BashAuto []string  `arg:"--auto-complete"                help:"todo: move this to go-arg"`
-}
-
-type EmptyCmd struct {
 }
 
 func (args) Version() string {
@@ -40,16 +29,3 @@ go-mod-clean will try to verify your go.* files are using the newest package ver
 * Try to trim go.sum of non-existent entries
 `
 }
-
-func (a args) DoAutoComplete(argv []string) {
-	switch argv[0] {
-	case "checkout":
-		fmt.Println("user devel master ")
-	default:
-		if argv[0] == ARGNAME {
-			// list the subcommands here
-			fmt.Println("strict restore purge lax")
-		}
-	}
-	os.Exit(0)
-}

cleanGoSum.go

@@ -8,22 +8,19 @@ import (
 	"sort"
 	"strings"
 
-	"go.wit.com/lib/gui/shell"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
 // This will recreate your go.sum and go.mod files
+
 // checks to see if every 'master' git branch version
 // matches the go.sum file
-
-// THIS IS IN lib/forgepb AND THIS SHOULD BE SWITCHED TO THERE
-// but I can't do it because forge as an app and forge packages aren't yet strong enough to use here (2025 may)
 func cleanGoDepsCheckOk(check *gitpb.Repo) error {
-	// var err error = nil
+	var err error = nil
-	// var fixes [][]string
+	var fixes [][]string
-	log.Printf("%s repo go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
+	log.Printf("current repo %s go dependancy count: %d", check.GetGoPath(), check.GoDepsLen())
 	if check.GoDeps == nil {
 		return errors.New("check.GoDeps == nil")
 	}
@@ -37,7 +34,8 @@ func cleanGoDepsCheckOk(check *gitpb.Repo) error {
 				continue
 			}
 			log.Info("not found:", depRepo.GetGoPath())
-			return errors.New("not found: " + depRepo.GetGoPath())
+			err = errors.New("not found: " + depRepo.GetGoPath())
+			continue
 		}
 		// log.Info("found dep", depRepo.GetGoPath())
 		if depRepo.GetVersion() != found.GetMasterVersion() {
@@ -50,43 +48,38 @@ func cleanGoDepsCheckOk(check *gitpb.Repo) error {
 			if forge.Config.IsReadOnly(check.GetGoPath()) {
 				ends += "(ignoring read-only) "
 				if argv.Verbose {
-					log.Printf("%-48s  ok error .%s. vs .%s. %s\n", depRepo.GetGoPath(),
+					log.Printf("%-48s  ok error .%s. vs .%s. %s", depRepo.GetGoPath(),
 						depRepo.GetVersion(), found.GetMasterVersion(), ends)
 				}
 			} else {
 				if forge.CheckOverride(depRepo.GetGoPath()) {
 					ends += "(override) "
 					if argv.Verbose {
-						log.Printf("%-48s  ok error .%s. vs .%s. %s\n", depRepo.GetGoPath(),
+						log.Printf("%-48s  ok error .%s. vs .%s. %s", depRepo.GetGoPath(),
 							depRepo.GetVersion(), found.GetMasterVersion(), ends)
 						// skip this gopath because it's probably broken forever
 					}
 					continue
 				} else {
-					log.Printf("%-48s     error %10s vs %10s %s\n", depRepo.GetGoPath(),
+					log.Printf("%-48s     error %10s vs %10s %s", depRepo.GetGoPath(),
 						depRepo.GetVersion(), found.GetMasterVersion(), ends)
 					errs := fmt.Sprintf("%s error %s vs %s %s", depRepo.GetGoPath(),
 						depRepo.GetVersion(), found.GetMasterVersion(), ends)
 					if ok, _ := forgepb.ValidGoVersion(found.GetMasterVersion()); ok {
 						// can't go get invalid version numbers
 						cmd := []string{"go", "get", depRepo.GetGoPath() + "@" + found.GetMasterVersion()}
-						// fixes = append(fixes, cmd)
+						fixes = append(fixes, cmd)
-						if _, err := shell.RunVerbose(cmd); err != nil {
-							return err
-						}
-					} else {
-						return errors.New(errs)
 					}
+					err = errors.New(errs)
 				}
 			}
 		}
 	}
-	/*
+	for i, cmd := range fixes {
-		for i, cmd := range fixes {
+		log.Info("try cmd", i, cmd)
-			log.Info("try cmd", i, cmd)
+		check.RunRealtime(cmd)
-		}
+	}
-	*/
+	return err
-	return nil
 }
 
 func trimGoSum(check *gitpb.Repo) error {
@@ -110,10 +103,6 @@ func trimGoSum(check *gitpb.Repo) error {
 	}
 
 	for _, line := range strings.Split(string(data), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
 		parts := strings.Fields(line)
 		if len(parts) < 3 {
 			log.Info("WIERD OR BAD:", line)

doSmart.go

@@ -10,16 +10,12 @@ import (
 func doSmart(repo *gitpb.Repo) error {
 	// if the repo has go.mod in the repo...
 	if err := repo.RepoIgnoresGoMod(); err != nil {
-		if repo.ParseGoSum() {
-			return nil
-		}
 		log.Info("go-mod-clean can not run on this repo", repo.GetGoPath())
 		log.Info("go.mod and go.sum must be git metadata to continue")
-		// return nil
+		repo.ParseGoSum()
-		if repo.Exists("go.sum") {
+		return nil
-			return nil
-		}
 	}
+
 	// erase the go.mod and go.sum files
 	eraseGoMod(repo)
 
@@ -27,31 +23,30 @@ func doSmart(repo *gitpb.Repo) error {
 	cname := repo.GetCurrentBranchName()
 	if err := repo.AutogenRestore(cname); err == nil {
 		log.Info(repo.GetGoPath(), "files were restored ok from git metadata (notes)")
-		if repo.Exists("go.mod") {
+		configSave = true
-			return nil
+		return nil
-		}
+	}
-		// autogen restore didn't find go.mod
+
+	// attempt to restore from ~/go/pkg/mod/
+	if err := restoreFromGoPkg(repo); err == nil {
+		configSave = true
+		return nil
 	}
 
 	// actually will re-create go.sum and go.mod now
 	if err := redoGoMod(repo); err != nil {
 		return err
 	}
-	log.Info(repo.GetGoPath(), "the files should have been restored with redoGoMod()")
-	/*
-		if repo.Exists("go.mod") {
-			return nil
-		}
-	*/
 
 	// the first time, it'll attempt to fix some stuff
-	if err := cleanGoDepsCheckOk(repo); err != nil {
+	cleanGoDepsCheckOk(repo)
-		return err
+	// try to trim junk
-	}
-
-	// trim junk that might have been added by cleanGoDepsCheckOk()
 	if err := trimGoSum(repo); err != nil {
 		return err
 	}
+	repo.ParseGoSum()
+
+	// everything worked more or less
+	configSave = true
 	return nil
 }

doStrict.go

@@ -2,15 +2,12 @@ package main
 
 import (
 	"errors"
-	"os"
 
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
 func doStrict(repo *gitpb.Repo) error {
-	var err error
-
 	if !repo.IsValidDir() {
 		log.Info(repo.GetGoPath(), "is invalid. fix your repos.pb file with 'forge' first")
 		log.Info("")
@@ -22,11 +19,6 @@ func doStrict(repo *gitpb.Repo) error {
 
 	repo.Run([]string{"git", "notes", "remove"})
 
-	if err := repo.RepoIgnoresGoMod(); err != nil {
-		log.Info(repo.GetGoPath(), "git repo does not ignore go.mod. do nothing here", err)
-		return nil
-	}
-
 	// erase the go.mod and go.sum files
 	eraseGoMod(repo)
 
@@ -38,8 +30,8 @@ func doStrict(repo *gitpb.Repo) error {
 		return errors.New(repo.GetGoPath() + " not in the git master branch")
 	}
 
-	// not sure if this really needs to be run a second time. probably not, but whatever. who cares
+	err := repo.RepoIgnoresGoMod()
-	if err := repo.RepoIgnoresGoMod(); err != nil {
+	if err != nil {
 		log.Info(repo.GetGoPath(), "some wierd git error happened. investigate.", err)
 		return err
 	}
@@ -60,80 +52,39 @@ func doStrict(repo *gitpb.Repo) error {
 	log.Info(repo.GetGoPath(), "GOING TO MAKE NEW go.* FILES")
 
 	// actually will re-create go.sum and go.mod now
-	os.Unsetenv("GO111MODULE")
+	if err := redoGoMod(repo); err != nil {
-	if result, err := repo.RunQuiet([]string{"go", "mod", "init", repo.GetGoPath()}); err != nil {
+		log.Info(repo.GetGoPath(), "redoGoMod() failed", err)
-		log.Warn("go mod init failed", err)
-		for _, line := range result.Stdout {
-			log.Warn("stdout:", line)
-		}
-		for _, line := range result.Stderr {
-			log.Warn("stderr:", line)
-		}
 		return err
 	}
 
-	if !repo.Exists("go.mod") {
-		// well, if go mod init fails, then we will just error since 'go mod init' almost never fails
-		return err
-	}
-
-	os.Unsetenv("GO111MODULE")
-	if result, err := repo.RunQuiet([]string{"go", "mod", "tidy"}); err != nil {
-		// I guess the thing to do, if go mod tidy fails, is to just leave the repo alone
-		// it's either primitive or could be a go support project but not in go
-		for _, line := range result.Stdout {
-			log.Warn("stdout:", line)
-		}
-		for _, line := range result.Stderr {
-			log.Warn("stderr:", line)
-		}
-		return nil
-	}
-
 	// the first time, it'll attempt to fix some stuff
-	log.Info(repo.GetGoPath(), "Running: updateToNewestReleases()")
 	cleanGoDepsCheckOk(repo)
-
+	// try to trim junk
-	if repo.Exists("go.sum") {
+	if err := trimGoSum(repo); err != nil {
-		// try to trim junk
+		log.Info(repo.GetGoPath(), "trimGoSum() failed", err)
-		log.Info(repo.GetGoPath(), "Running: trimGoSum()")
+		return err
-		if err := trimGoSum(repo); err != nil {
-			log.Info(repo.GetGoPath(), "trimGoSum() failed", err)
-			return err
-		}
 	}
-
 	if repo.ParseGoSum() {
 		log.Info(repo.GetGoPath(), "ParseGoSum() ok")
 	} else {
 		log.Info(repo.GetGoPath(), "ParseGoSum() failed")
 	}
 
-	if !repo.GetGoPrimitive() {
+	// check go.sum file
-		// check go.sum file
+	if err := cleanGoDepsCheckOk(repo); err != nil {
-		if err := cleanGoDepsCheckOk(repo); err != nil {
+		log.Info("forge.FinalGoDepsCheck() failed. boo. :", repo.GetGoPath())
-			log.Info(repo.GetGoPath(), "forge.FinalGoDepsCheck() failed. boo.")
+		return err
-			return err
-		}
-	}
-
-	if repo.Exists("go.sum") {
-		// try to trim junk
-		log.Info(repo.GetGoPath(), "Running: trimGoSum()")
-		if err := trimGoSum(repo); err != nil {
-			log.Info(repo.GetGoPath(), "trimGoSum() failed", err)
-			return err
-		}
 	}
 
 	// put the files in the notes section in git
 	// this way, git commits are not messed up
 	// with this autogenerated code
 	if err := saveAsMetadata(repo); err != nil {
-		log.Info(repo.GetGoPath(), "save go.mod as git metadata failed", err)
+		log.Info("save go.mod as git metadata failed", repo.GetGoPath(), err)
 		return err
 	}
 
 	// everything worked!
+	configSave = true
 	return nil
 }

exit.go

@@ -8,7 +8,7 @@ import (
 )
 
 func okExit(check *gitpb.Repo, msg string) {
-	log.Info("exit() go-mod-clean on", check.Namespace, "ok")
+	log.Info("exit() go-mod-clean on", check.GetGoPath(), "ok")
 	log.DaemonMode(true)
 	log.Info(msg)
 	os.Exit(0)
@@ -16,9 +16,9 @@ func okExit(check *gitpb.Repo, msg string) {
 
 func badExit(check *gitpb.Repo, err error) {
 	log.DaemonMode(true)
-	log.Info("go-mod-clean failed: ", err, forge.Config.ReposDir)
+	log.Info("go-mod-clean failed: ", err, forge.GetGoSrc())
 	if check != nil {
-		if argv.Strict != nil {
+		if argv.Strict {
 			// if in strict mode, remove the go.mod and go.sum
 			eraseGoMod(check)
 		}

main.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	"go.wit.com/dev/alexflint/arg"
-	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
@@ -15,8 +14,7 @@ import (
 var VERSION string
 var BUILDTIME string
 
-// used for shell auto completion
+var golangVersion string = "1.21"
-var ARGNAME string = "go-mod-clean"
 
 var pp *arg.Parser
 var forge *forgepb.Forge
@@ -25,25 +23,24 @@ var forge *forgepb.Forge
 var configSave bool
 
 func main() {
+	var check *gitpb.Repo
 	log.Info("go-mod-clean version", VERSION, "built on", BUILDTIME)
-
-	// command line parsing & handling
-	prep.Bash(ARGNAME, argv.DoAutoComplete) // todo: make this: prep.Bash(argv)
 	pp = arg.MustParse(&argv)
 
+	// load the ~/.config/forge/ config
+	// this lets you configure repos you have read/write access too
 	forge = forgepb.Init()
 
 	// figure out what directory we are running in
-	check := findPwdRepo()
+	check = findPwdRepo()
 	if check == nil {
 		log.Info("this directory isn't in a golang project (not in ~/go/src nor a go.work file)")
 		badExit(nil, nil)
 	}
 
 	// deletes all the git notes
-	if argv.Purge != nil {
+	if argv.Purge {
-		purgeNotes(check) // purges all the 'git notes'
+		purgeNotes(check)
-		eraseGoMod(check) // erase the go.mod and go.sum files
 		okExit(check, "notes gone")
 	}
 
@@ -55,27 +52,24 @@ func main() {
 		okExit(check, "go.mod and go.sum restored from ~/go/pkg/mod/")
 	}
 
-	if argv.Strict != nil {
+	if err := doMain(check); err != nil {
-		log.Info("Starting --strict mode")
+		badExit(check, err)
-		if err := doStrict(check); err != nil {
-			badExit(check, err)
-		}
-		okExit(check, "go.mod seems clean")
 	}
-	if argv.Smart != nil {
-		// best effort
-		if err := doSmart(check); err != nil {
-			// badExit(check, err)
-		}
-		okExit(check, "maybe it's ok")
-	}
-
 	if argv.Force {
 		if err := doForce(check); err != nil {
 			badExit(check, err)
 		}
+	} else {
+		if err := doSmart(check); err != nil {
+			badExit(check, err)
+		}
 	}
 
+	if configSave {
+		forge.ConfigSave()
+	}
+
+	log.Info("forge.FinalGoDepsCheck() worked :", check.GetGoPath())
 	okExit(check, "go.sum seems clean")
 }
 
@@ -84,16 +78,16 @@ func findPwdRepo() *gitpb.Repo {
 	// attempt to use the working directory
 	// this is probably what happens most of the time
 	pwd, _ := os.Getwd()
-	if strings.HasPrefix(pwd, forge.Config.ReposDir) {
+	if strings.HasPrefix(pwd, forge.GetGoSrc()) {
-		gopath := strings.TrimPrefix(pwd, forge.Config.ReposDir)
+		gopath := strings.TrimPrefix(pwd, forge.GetGoSrc())
 		gopath = strings.Trim(gopath, "/")
+		log.Info("findRepo() trying gopath", gopath)
 		check = forge.FindByGoPath(gopath)
 		if check != nil {
-			log.Info(check.Namespace, "was found ok in forge")
+			log.Info("findRepo() worked", check.GetGoPath())
 			return check
 		}
 	}
-	log.Info("findRepo() forge could not find GO path:", pwd)
 	return nil
 }
 
@@ -110,3 +104,17 @@ func saveAsMetadata(repo *gitpb.Repo) error {
 	}
 	return nil
 }
+
+func doMain(repo *gitpb.Repo) error {
+	if argv.Strict {
+		return doStrict(repo)
+	}
+	if argv.Force {
+		err := doForce(repo)
+		return err
+	}
+
+	// if --force or --strict is not set, fall back to a "smart" guess
+	// at what the user probably would want
+	return doSmart(repo)
+}

redoGoMod.go

@@ -5,6 +5,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/go-cmd/cmd"
 	"go.wit.com/lib/protobuf/gitpb"
@@ -15,14 +16,14 @@ import (
 // testing to see where this stuff is coming from
 func eraseGoMod(repo *gitpb.Repo) {
 	// unset the go development ENV var to generate release files
-	if _, err := repo.RunQuiet([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
+	if err := repo.StrictRun([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
 		log.Warn(repo.GetGoPath(), "rm go.mod go.sum failed", err)
 	}
 }
 
 // sets the required golang version in go.mod
 func setGoVersion(repo *gitpb.Repo, version string) error {
-	if _, err := repo.RunQuiet([]string{"go", "mod", "edit", "-go=" + version}); err != nil {
+	if err := repo.StrictRun([]string{"go", "mod", "edit", "-go=" + version}); err != nil {
 		log.Warn(repo.GetGoPath(), "go mod edit failed", err)
 		return err
 	}
@@ -30,7 +31,7 @@ func setGoVersion(repo *gitpb.Repo, version string) error {
 }
 
 func goTidy(fullpath string) (cmd.Status, error) {
-	if result, err := runVerbose(fullpath, []string{"go", "mod", "tidy"}); err == nil {
+	if result, err := runVerbose(fullpath, []string{"go", "mod", "tidy", "-go=" + golangVersion}); err == nil {
 		return result, nil
 	} else {
 		return result, err
@@ -41,18 +42,26 @@ func goTidy(fullpath string) (cmd.Status, error) {
 func redoGoMod(repo *gitpb.Repo) error {
 	// unset the go development ENV var to generate release files
 	os.Unsetenv("GO111MODULE")
-	if _, err := repo.RunQuiet([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
+	if err := repo.StrictRun([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
 		log.Warn("rm go.mod go.sum failed", err)
 		return err
 	}
-
+	if err := repo.StrictRun([]string{"go", "mod", "init", repo.GetGoPath()}); err != nil {
-	if _, err := repo.RunQuiet([]string{"go", "mod", "init", repo.GetGoPath()}); err != nil {
 		log.Warn("go mod init failed", err)
 		return err
 	}
 
-	if _, err := repo.RunQuiet([]string{"go", "mod", "tidy"}); err != nil {
+	if result, err := goTidy(repo.FullPath); err != nil {
-		log.Warn("go mod init failed", err)
+		if tinyFixer(result) {
+			if _, err := goTidy(repo.FullPath); err != nil {
+				return err
+			}
+		}
+	}
+
+	// most things should build with golang after 1.21 // todo: allow this to be set somewhere
+	if err := setGoVersion(repo, golangVersion); err != nil {
+		log.Warn(repo.GetGoPath(), "go mod edit failed", err)
 		return err
 	}
 
@@ -63,3 +72,19 @@ func redoGoMod(repo *gitpb.Repo) error {
 
 	return fmt.Errorf("check.ParseGoSum() failed")
 }
+
+func tinyFixer(result cmd.Status) bool {
+	for _, line := range result.Stdout {
+		if strings.Contains(line, "requires go@") {
+			log.Info("tinyFixer:", line)
+			parts := strings.Split(line, "requires go@")
+			if len(parts) == 2 {
+				parts = strings.Split(parts[1], ",")
+				golangVersion = parts[0]
+				return true
+			}
+			log.Info("tinyFixer:", line, "golangVersion", golangVersion)
+		}
+	}
+	return false
+}

restore.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"path/filepath"
 
-	"go.wit.com/lib/gui/shell"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
@@ -15,27 +14,11 @@ func restoreFromGoPkg(repo *gitpb.Repo) error {
 	if err != nil {
 		badExit(nil, err)
 	}
-	repo.RunVerboseOnError([]string{"rm", "-f", "go.mod", "go.sum"})
 	rver := repo.GetLastTag()
 	if rver == "" {
 		return errors.New("could not get master version")
 	}
-	goget := repo.GetGoPath() + "@" + rver
-	moddir := filepath.Join(homedir, "go/pkg/mod", repo.GetGoPath()+"@"+rver)
-	if shell.IsDir(moddir) {
-		// things are ok
-	} else {
-		return errors.New("must run go get " + goget)
-	}
-
 	modfile := filepath.Join(homedir, "go/pkg/mod", repo.GetGoPath()+"@"+rver, "go.mod")
-	if shell.Exists(modfile) {
-		// go.mod exists
-	} else {
-		log.Info(repo.GetGoPath(), "does not have file:", modfile)
-		// nothing to do. this repo does not have a go.mod file
-		return nil
-	}
 	log.Info("mod path should be", modfile)
 	data, err := os.ReadFile(modfile)
 	if err != nil {