rm GoSrc()

Signed-off-by: Jeff Carr <jcarr@wit.com>

.gitignore

@@ -4,3 +4,4 @@ go.sum
 /files/*
 /work/*
 go-clean
+go-mod-clean

Makefile

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

all.go

@@ -1,32 +0,0 @@
-package main
-
-import (
-	"fmt"
-)
-
-// rethink this. do not run on non-master git branches
-func doAll() {
-	if argv.All {
-		if forge.IsGoWork() {
-			var warning []string
-			warning = append(warning, "go-mod-clean --recursive may not work unless you are in ~/go/src")
-			warning = append(warning, "you can continue anyway, but it hasn't been tested as much.")
-			simpleStdin(true, warning)
-		}
-		var warning []string
-		warning = append(warning, "go-mod-clean will recreate go.mod and go.sum")
-		warning = append(warning, "because you have selected --recursive")
-		warning = append(warning, "this will redo _every_ repo. This is probably fine.")
-		warning = append(warning, fmt.Sprintf("You have %d total repositories in %s", forge.Repos.Len(), forge.GetGoSrc()))
-		warning = append(warning, "")
-		warning = append(warning, "However, this will also, at times, do:")
-		warning = append(warning, "")
-		warning = append(warning, "rm -rf ~/go/pkg/")
-		warning = append(warning, "rm -rf ~/.config/go-build/")
-		warning = append(warning, "")
-		warning = append(warning, "Which is also probably fine, but will clear all your build cache and go mod cache")
-		warning = append(warning, "")
-		simpleStdin(false, warning)
-		// purgeGoCaches()
-	}
-}

argv.go

@@ -1,5 +1,10 @@
 package main
 
+import (
+	"fmt"
+	"os"
+)
+
 /*
 	this parses the command line arguements
 */
@@ -7,13 +12,18 @@ package main
 var argv args
 
 type args struct {
-	All     bool `arg:"--all"       default:"false"    help:"redo every repo found in go/src or go.work"`
+	Trim     bool      `arg:"--trim"      default:"true"     help:"trim entries from go.sum"`
-	Auto    bool `arg:"--auto"                         help:"don't approve via STDIN"`
+	Verbose  bool      `arg:"--verbose"                      help:"show more"`
-	Trim    bool `arg:"--trim"      default:"true"     help:"trim entries from go.sum"`
+	Restore  bool      `arg:"--restore"                      help:"only restore from go/pkg/mod/"`
-	Verbose bool `arg:"--verbose"                      help:"show more"`
+	Force    bool      `arg:"--force"                        help:"remove things and redo them no matter what"`
-	Notes   bool `arg:"--metadata"                     help:"save as git metadata (notes)"`
+	Purge    *EmptyCmd `arg:"subcommand:purge"               help:"purge all git notes. (this is where the autogenerated files are stored)"`
-	Restore bool `arg:"--restore"   default:"true"     help:"restore from git metadata"`
+	Smart    *EmptyCmd `arg:"subcommand:lax"                 help:"try something but never do os.Exit(-1)"`
-	Force   bool `arg:"--force"                        help:"remove the old one"`
+	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 {
@@ -25,8 +35,21 @@ func (a args) Description() string {
 go-mod-clean will try to verify your go.* files are using the newest package versions
 
 * Recreate go.* with 'go mod init' and 'go mod tidy'
-* Set your required go in go.mod (default is go1.20
+* Set your required go in go.mod (default is go1.21
 * Check that the most recent master branch versions are used
 * 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,71 +8,85 @@ 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("current repo %s go dependancy count: %d", check.GetGoPath(), check.GoDepsLen())
+	log.Printf("%s repo go dependancy count: %d\n", check.GetGoPath(), check.GoDepsLen())
+	if check.GoDeps == nil {
+		return errors.New("check.GoDeps == nil")
+	}
 	all := check.GoDeps.SortByGoPath()
 	for all.Scan() {
 		depRepo := all.Next()
-		found := forge.Repos.FindByGoPath(depRepo.GetGoPath())
+		found := forge.FindByGoPath(depRepo.GetGoPath())
 		if found == nil {
 			if forge.CheckOverride(depRepo.GetGoPath()) {
 				// skip this gopath because it's probably broken forever
 				continue
 			}
 			log.Info("not found:", depRepo.GetGoPath())
-			err = errors.New("not found: " + depRepo.GetGoPath())
+			return errors.New("not found: " + depRepo.GetGoPath())
-			continue
 		}
 		// log.Info("found dep", depRepo.GetGoPath())
 		if depRepo.GetVersion() != found.GetMasterVersion() {
-			check := forge.Repos.FindByGoPath(depRepo.GoPath)
+			check := forge.FindByGoPath(depRepo.GetGoPath())
 			var ends string
 			if check.CheckDirty() {
 				ends = "(dirty) "
 			}
 
-			if forge.Config.IsReadOnly(check.GoPath) {
+			if forge.Config.IsReadOnly(check.GetGoPath()) {
 				ends += "(ignoring read-only) "
 				if argv.Verbose {
-					log.Printf("%-48s  ok error .%s. vs .%s. %s", depRepo.GetGoPath(),
+					log.Printf("%-48s  ok error .%s. vs .%s. %s\n", 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", depRepo.GetGoPath(),
+						log.Printf("%-48s  ok error .%s. vs .%s. %s\n", 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", depRepo.GetGoPath(),
+					log.Printf("%-48s     error %10s vs %10s %s\n", depRepo.GetGoPath(),
 						depRepo.GetVersion(), found.GetMasterVersion(), ends)
 					errs := fmt.Sprintf("%s error %s vs %s %s", depRepo.GetGoPath(),
 						depRepo.GetVersion(), found.GetMasterVersion(), ends)
-					cmd := []string{"go", "get", depRepo.GetGoPath() + "@" + found.GetMasterVersion()}
+					if ok, _ := forgepb.ValidGoVersion(found.GetMasterVersion()); ok {
-					fixes = append(fixes, cmd)
+						// can't go get invalid version numbers
-					err = errors.New(errs)
+						cmd := []string{"go", "get", depRepo.GetGoPath() + "@" + found.GetMasterVersion()}
+						// fixes = append(fixes, cmd)
+						if _, err := shell.RunVerbose(cmd); err != nil {
+							return err
+						}
+					} else {
+						return errors.New(errs)
+					}
 				}
 			}
 		}
 	}
-	for i, cmd := range fixes {
+	/*
-		log.Info("try cmd", i, cmd)
+		for i, cmd := range fixes {
-		check.RunRealtime(cmd)
+			log.Info("try cmd", i, cmd)
-	}
+		}
-	return err
+	*/
+	return nil
 }
 
 func trimGoSum(check *gitpb.Repo) error {
@@ -96,6 +110,10 @@ 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)
@@ -143,7 +161,7 @@ func trimGoSum(check *gitpb.Repo) error {
 		if good[gopath] {
 			fmt.Fprintf(newf, "%s %s\n", gopath, stuff[gopath])
 			fmt.Fprintf(newf, "%s %s\n", gopath, modver[gopath])
-			check := forge.Repos.FindByGoPath(gopath)
+			check := forge.FindByGoPath(gopath)
 			if check == nil {
 				log.Info("gopath does not really exist:", gopath)
 			}

doForce.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"errors"
+
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
+// this will make go.mod and go.sum files no matter what
+// thsi will clean out everything and start over
+func doForce(repo *gitpb.Repo) error {
+	// var perfect bool = true
+	if !repo.IsValidDir() {
+		log.Info(repo.GetGoPath(), "is invalid. fix your repos.pb file with 'forge' first")
+		log.Info("")
+		log.Info("go install go.wit.com/apps/forge@latest")
+		log.Info("")
+		return errors.New(repo.GetGoPath() + " is invalid. fix your repository list with 'forge' first")
+	}
+	log.Info(repo.GetGoPath(), "is valid according to forge")
+
+	// purge the git meta-data if --force
+	repo.Run([]string{"git", "notes", "remove"})
+
+	// erase the go.mod and go.sum files
+	eraseGoMod(repo)
+
+	// actually will re-create go.sum and go.mod now
+	if err := redoGoMod(repo); err != nil {
+		return err
+	}
+
+	// the first time, it'll attempt to fix some stuff
+	cleanGoDepsCheckOk(repo)
+
+	// try to trim junk
+	if err := trimGoSum(repo); err != nil {
+		return err
+	}
+	repo.ParseGoSum()
+
+	configSave = true
+	return nil
+}

doRestore.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
+func restoreFromGoPkg(repo *gitpb.Repo) error {
+	homedir, err := os.UserHomeDir()
+	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 {
+		return err
+	}
+	modf, err := os.OpenFile("go.mod", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return err
+	}
+	defer modf.Close()
+	modf.Write(data)
+
+	modfile = filepath.Join(homedir, "go/pkg/mod", repo.GetGoPath()+"@"+rver, "go.sum")
+	log.Info("mod path should be", modfile)
+	data, err = os.ReadFile(modfile)
+	if err == nil {
+		sumf, _ := os.OpenFile("go.sum", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+		defer sumf.Close()
+		sumf.Write(data)
+	}
+
+	// try go.sum, but no error checking since it might not be there
+	return nil
+}

doSmart.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
+// this will make go.mod and go.sum files, but you have to
+// have the files in .gitignore for now
+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
+		if repo.Exists("go.sum") {
+			return nil
+		}
+	}
+	// erase the go.mod and go.sum files
+	eraseGoMod(repo)
+
+	// try to restore from the git metadata
+	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") {
+			return nil
+		}
+		// autogen restore didn't find go.mod
+	}
+
+	// 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 {
+		return err
+	}
+
+	// trim junk that might have been added by cleanGoDepsCheckOk()
+	if err := trimGoSum(repo); err != nil {
+		return err
+	}
+	return nil
+}

doStrict.go

@@ -0,0 +1,139 @@
+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("")
+		log.Info("go install go.wit.com/apps/forge@latest")
+		log.Info("")
+		return errors.New(repo.GetGoPath() + " is invalid. fix your repository list with 'forge' first")
+	}
+	log.Info(repo.GetGoPath(), "is valid according to forge")
+
+	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)
+
+	if repo.GetMasterBranchName() != repo.GetCurrentBranchName() {
+		log.Info("")
+		log.Info("You are not operating on your git master branch.")
+		log.Info("Publishing go.mod & go.sum files must come from from git version tag on the master branch")
+		log.Info("")
+		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
+	if err := repo.RepoIgnoresGoMod(); err != nil {
+		log.Info(repo.GetGoPath(), "some wierd git error happened. investigate.", err)
+		return err
+	}
+
+	if forge.Config.IsReadOnly(repo.GetGoPath()) {
+		log.Info("you can not push to read only repositories.", repo.GetGoPath())
+		log.Info("change your .config/forge/ to indicate you own this repository")
+		return nil
+	}
+
+	if repo.CheckDirty() {
+		log.Info("")
+		log.Info("You can not continue on a dirty git repo.")
+		log.Info("")
+		return errors.New(repo.GetGoPath() + " git repo is dirty")
+	}
+
+	log.Info(repo.GetGoPath(), "GOING TO MAKE NEW go.* FILES")
+
+	// actually will re-create go.sum and go.mod now
+	os.Unsetenv("GO111MODULE")
+	if result, err := repo.RunQuiet([]string{"go", "mod", "init", repo.GetGoPath()}); err != nil {
+		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)
+
+	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
+		}
+	}
+
+	if repo.ParseGoSum() {
+		log.Info(repo.GetGoPath(), "ParseGoSum() ok")
+	} else {
+		log.Info(repo.GetGoPath(), "ParseGoSum() failed")
+	}
+
+	if !repo.GetGoPrimitive() {
+		// check go.sum file
+		if err := cleanGoDepsCheckOk(repo); err != nil {
+			log.Info(repo.GetGoPath(), "forge.FinalGoDepsCheck() failed. boo.")
+			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)
+		return err
+	}
+
+	// everything worked!
+	return nil
+}

exit.go

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

isTracked.go

@@ -1,62 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-
-	"go.wit.com/lib/protobuf/gitpb"
-)
-
-func isTracked(file string) (bool, error) {
-	cmd := exec.Command("git", "ls-files", "--error-unmatch", file)
-	err := cmd.Run()
-	if err == nil {
-		return true, nil
-	}
-	if exitError, ok := err.(*exec.ExitError); ok && exitError.ExitCode() == 1 {
-		return false, nil // File not tracked
-	}
-	return false, fmt.Errorf("error checking tracked status: %v", err)
-}
-
-func isIgnored(file string) (bool, error) {
-	cmd := exec.Command("git", "check-ignore", "-q", file)
-	err := cmd.Run()
-	if err == nil {
-		return true, nil
-	}
-	if exitError, ok := err.(*exec.ExitError); ok && exitError.ExitCode() == 1 {
-		return false, nil // File not ignored
-	}
-	return false, fmt.Errorf("error checking ignored status: %v", err)
-}
-
-func repoIgnoresGoMod(repo *gitpb.Repo) (bool, error) {
-	os.Chdir(repo.FullPath)
-	file := "go.mod"
-
-	tracked, err := isTracked(file)
-	if err != nil {
-		fmt.Printf("%s Error checking if tracked: %v\n", repo.GoPath, err)
-		return false, err
-	}
-
-	if tracked {
-		fmt.Printf("%s %s is tracked by Git.\n", repo.GoPath, file)
-		return false, nil
-	}
-
-	ignored, err := isIgnored(file)
-	if err != nil {
-		fmt.Printf("%s Error checking if ignored: %v\n", repo.GoPath, err)
-		return false, err
-	}
-
-	if ignored {
-		fmt.Printf("%s %s is ignored by Git.\n", repo.GoPath, file)
-		return true, nil
-	}
-	fmt.Printf("%s %s is neither tracked nor ignored by Git.\n", repo.GoPath, file)
-	return false, nil
-}

main.go

@@ -1,11 +1,11 @@
 package main
 
 import (
-	"errors"
 	"os"
 	"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,6 +15,9 @@ import (
 var VERSION string
 var BUILDTIME string
 
+// used for shell auto completion
+var ARGNAME string = "go-mod-clean"
+
 var pp *arg.Parser
 var forge *forgepb.Forge
 
@@ -22,42 +25,57 @@ 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()
 
-	if argv.All {
+	// figure out what directory we are running in
-		// run this on every single repo
+	check := findPwdRepo()
-		// do this before publishing new golang versions
+	if check == nil {
-		all := forge.Repos.SortByGoPath()
+		log.Info("this directory isn't in a golang project (not in ~/go/src nor a go.work file)")
-		for all.Scan() {
+		badExit(nil, nil)
-			check = all.Next()
+	}
-			if err := doMain(check); err != nil {
-				badExit(check, err)
-			}
-		}
-	} else {
-		// figure out what directory we are running in
-		check = findPwdRepo()
-		if check == nil {
-			log.Info("this directory isn't in a golang project (not in ~/go/src nor a go.work file)")
-			os.Exit(-1)
-		}
 
-		if err := doMain(check); err != nil {
+	// deletes all the git notes
+	if argv.Purge != nil {
+		purgeNotes(check) // purges all the 'git notes'
+		eraseGoMod(check) // erase the go.mod and go.sum files
+		okExit(check, "notes gone")
+	}
+
+	if argv.Restore {
+		// attempt to restore from ~/go/pkg/mod/
+		if err := restoreFromGoPkg(check); err != nil {
+			badExit(check, err)
+		}
+		okExit(check, "go.mod and go.sum restored from ~/go/pkg/mod/")
+	}
+
+	if argv.Strict != nil {
+		log.Info("Starting --strict mode")
+		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)
 		}
 	}
 
-	if configSave {
-		forge.ConfigSave()
-	}
-
-	log.Info("forge.FinalGoDepsCheck() worked :", check.GoPath)
 	okExit(check, "go.sum seems clean")
 }
 
@@ -66,22 +84,22 @@ 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.GetGoSrc()) {
+	if strings.HasPrefix(pwd, forge.Config.ReposDir) {
-		gopath := strings.TrimPrefix(pwd, forge.GetGoSrc())
+		gopath := strings.TrimPrefix(pwd, forge.Config.ReposDir)
 		gopath = strings.Trim(gopath, "/")
-		log.Info("findRepo() trying gopath", gopath)
+		check = forge.FindByGoPath(gopath)
-		check = forge.Repos.FindByGoPath(gopath)
 		if check != nil {
-			log.Info("findRepo() worked", check.GoPath)
+			log.Info(check.Namespace, "was found ok in forge")
 			return check
 		}
 	}
+	log.Info("findRepo() forge could not find GO path:", pwd)
 	return nil
 }
 
 func saveAsMetadata(repo *gitpb.Repo) error {
 	cname := repo.GetCurrentBranchName()
-	if repo.GoPrimitive {
+	if repo.GetGoPrimitive() {
 		if err := repo.AutogenSave([]string{"go.mod"}, cname, true); err != nil {
 			return err
 		}
@@ -92,113 +110,3 @@ func saveAsMetadata(repo *gitpb.Repo) error {
 	}
 	return nil
 }
-
-func doMain(repo *gitpb.Repo) error {
-	if !repo.IsValid() {
-		log.Info(repo.GoPath, "is invalid. fix your repos.pb file with 'forge' first")
-		log.Info("")
-		log.Info("go install go.wit.com/apps/forge@latest")
-		log.Info("")
-		return errors.New(repo.GoPath + " is invalid. fix your repository list with 'forge' first")
-	} else {
-		log.Info(repo.GoPath, "is valid according to forge")
-	}
-
-	// skip restore if --force
-	if !argv.Force {
-		// erase the go.mod and go.sum files
-		eraseGoMod(repo)
-		cname := repo.GetCurrentBranchName()
-		// try to restore from the git metadata
-		if err := repo.AutogenRestore(cname); err != nil {
-			// ignore errors here
-		}
-		if err := repo.ValidGoSum(); err == nil {
-			log.Info(repo.GoPath, "go.mod and go.sum were restored ok")
-			configSave = true
-			return nil
-		}
-	}
-
-	// double check here. use --force to remake them
-	if err := repo.ValidGoSum(); err == nil {
-		log.Info(repo.GoPath, "go.mod and go.sum are already valid")
-		return nil
-	}
-
-	if repo.GetMasterBranchName() != repo.GetCurrentBranchName() {
-		log.Info("")
-		log.Info("You can only run go-mod-clean on a git master branch.")
-		log.Info("Publishing go.mod & go.sum files must come from from git version tag")
-		log.Info("Anything else doesn't make sense.")
-		log.Info("")
-		return errors.New(repo.GoPath + " not in the git master branch")
-	}
-
-	ok, err := repoIgnoresGoMod(repo)
-	if err != nil {
-		log.Info(repo.GoPath, "some wierd git error happened. investigate.", err)
-		return err
-	}
-	// if ok, then git owns 'go.mod' and we can't really do anything
-	// todo: ignore this with --force
-	if ok {
-		log.Info(repo.GoPath, "git says it does not own go.mod")
-		// continue and attempt to create go.mod and go.sum
-	} else {
-		if forge.Config.IsReadOnly(repo.GoPath) {
-			log.Info("skipping read only", repo.GoPath)
-			return nil
-		}
-		// continue and attempt to create go.mod and go.sum
-	}
-
-	if repo.CheckDirty() {
-		log.Info("")
-		log.Info("You can not run this on dirty branches.")
-		log.Info("")
-		return errors.New(repo.GoPath + " git repo is dirty")
-	}
-
-	log.Info(repo.GoPath, "GOING TO MAKE NEW go.* FILES")
-
-	// actually will re-create go.sum and go.mod now
-	if err := redoGoMod(repo); err != nil {
-		return err
-	}
-
-	if argv.Trim {
-		// the first time, it'll attempt to fix some stuff
-		cleanGoDepsCheckOk(repo)
-		// try to trim junk
-		if err := trimGoSum(repo); err != nil {
-			return err
-		}
-		repo.ParseGoSum()
-	}
-
-	/*
-		data, _ := repo.ReadFile("go.mod")
-		log.Info(string(data))
-		data, _ = repo.ReadFile("go.sum")
-		log.Info(string(data))
-	*/
-
-	// check go.sum file
-	if err := cleanGoDepsCheckOk(repo); err != nil {
-		log.Info("forge.FinalGoDepsCheck() failed. boo. :", repo.GoPath)
-		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("save go.mod as git metadata failed", repo.GoPath, err)
-		return err
-	}
-
-	// everything worked!
-	configSave = true
-	return nil
-}

notes.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"strings"
+
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
+func purgeNotes(repo *gitpb.Repo) error {
+	result := repo.Run([]string{"git", "notes", "list"})
+	for _, line := range result.Stdout {
+		parts := strings.Fields(line)
+		log.Info("line:", line, "part", parts[1])
+		blah := repo.Run([]string{"git", "notes", "remove", parts[1]})
+		log.Info(strings.Join(blah.Stdout, "\n"))
+	}
+	return nil
+}

redoGoMod.go

@@ -3,9 +3,10 @@ package main
 // recreates the go.mod and go.sum files
 
 import (
-	"errors"
+	"fmt"
 	"os"
 
+	"github.com/go-cmd/cmd"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
@@ -14,74 +15,51 @@ 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.StrictRun([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
+	if _, err := repo.RunQuiet([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
-		log.Warn(repo.GoPath, "rm go.mod go.sum failed", err)
+		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 {
-	// most things should build with golang after 1.20
+	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)
-		log.Warn(repo.GoPath, "go mod edit failed", err)
 		return err
 	}
 	return nil
 }
 
+func goTidy(fullpath string) (cmd.Status, error) {
+	if result, err := runVerbose(fullpath, []string{"go", "mod", "tidy"}); err == nil {
+		return result, nil
+	} else {
+		return result, err
+	}
+}
+
 // wrapper around 'go mod init' and 'go mod tidy'
 func redoGoMod(repo *gitpb.Repo) error {
 	// unset the go development ENV var to generate release files
 	os.Unsetenv("GO111MODULE")
-	if err := repo.StrictRun([]string{"rm", "-f", "go.mod", "go.sum"}); err != nil {
+	if _, err := repo.RunQuiet([]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.GoPath}); 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.StrictRun([]string{"go", "mod", "tidy"}); err != nil {
+
-		log.Warn("go mod tidy failed", err)
+	if _, err := repo.RunQuiet([]string{"go", "mod", "tidy"}); err != nil {
+		log.Warn("go mod init failed", err)
 		return err
 	}
 
-	// most things should build with golang after 1.20 // todo: allow this to be set somewhere
+	// parse the go.mod and go.sum files
-	if err := setGoVersion(repo, "1.20"); err != nil {
+	if repo.ParseGoSum() {
-		log.Warn(repo.GoPath, "go mod edit failed", err)
+		return nil
-		return err
 	}
 
-	repo.GoDeps = nil
+	return fmt.Errorf("check.ParseGoSum() failed")
-	repo.GoPrimitive = false
-
-	// if there is not a go.sum file, it better be a primitive golang project
-	if !repo.Exists("go.sum") {
-		// todo. fix this logic
-		ok, err := repo.IsPrimitive()
-		if err != nil {
-			// this means this repo does not depend on any other package
-			log.Info("PRIMATIVE repo error:", repo.GoPath, "err =", err)
-			return err
-		}
-
-		if ok {
-			// this means the repo is primitive so there is no go.sum
-			repo.GoPrimitive = true
-			repo.GoDeps = new(gitpb.GoDeps)
-			return nil
-		}
-	}
-
-	if !repo.Exists("go.sum") {
-		// this should never happen
-		data, _ := repo.ReadFile("go.mod")
-		log.Info(string(data))
-		return errors.New("missing go.sum file on non-primitive go.mod")
-	}
-
-	repo.GoDeps = new(gitpb.GoDeps)
-	// return the attempt to parse go.sum
-	_, err := repo.ParseGoSum()
-	return err
 }

run.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/go-cmd/cmd"
 	"go.wit.com/lib/gui/shell"
 	"go.wit.com/log"
 )
@@ -68,3 +69,43 @@ func runStrict(wd string, cmd []string) {
 		log.Info(i, line)
 	}
 }
+
+func runVerbose(wd string, argv []string) (cmd.Status, error) {
+	var err error
+	log.DaemonMode(true)
+	defer log.DaemonMode(false)
+	if wd != "" {
+		if err = os.Chdir(wd); err != nil {
+			var s cmd.Status
+			s.Stdout = []string{"notreal stdout from runVerbose()"}
+			return s, fmt.Errorf("cd %s failed %v", wd, err)
+		}
+	}
+	log.Info(wd, "running:", wd, argv)
+	// result := shell.Run(cmd)
+	result := shell.Run(argv)
+	if result.Error != nil {
+		log.Info("cmd failed", wd, argv, err)
+		for _, line := range result.Stdout {
+			log.Info(line)
+		}
+		for i, line := range result.Stderr {
+			log.Info("STDERR:", i, line)
+		}
+		return result, result.Error
+	}
+	if result.Exit != 0 {
+		log.Info("cmd failed", wd, argv, err)
+		for _, line := range result.Stdout {
+			log.Info(line)
+		}
+		for i, line := range result.Stderr {
+			log.Info("STDERR:", i, line)
+		}
+		return result, fmt.Errorf("cmd failed with %d", result.Exit)
+	}
+	for _, line := range result.Stdout {
+		log.Info(line)
+	}
+	return result, nil
+}

stdin.go

@@ -24,10 +24,7 @@ func showOptions(b bool, s []string) {
 }
 
 // if b == true, default is to continue with 'Y'
-func simpleStdin(b bool, s []string) {
+func simpleStdinOld(b bool, s []string) {
-	if argv.Auto {
-		return
-	}
 	err := errors.New("user cancelled via stdin")
 	showOptions(b, s)
 	scanner := bufio.NewScanner(os.Stdin)