.gitignore

@@ -1,5 +1,4 @@
 *.swp
-*.pb
 go.mod
 go.sum
 /resources/*.so

Makefile

@@ -6,27 +6,25 @@ BUILDTIME = $(shell date +%Y.%m.%d_%H%M)
 # make gocui     # try the ncurses gui plugin
 # make andlabs   # try the andlabs gui plugin (uses GTK)
 
-default: install-verbose tag
-
-tag:
-	forge tag list
+default: install
+	forge --gui andlabs
 
 vet:
 	@GO111MODULE=off go vet
 	@echo this go binary package builds okay
 
+verbose:
+	GO111MODULE=off go build -v -x \
+		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+
 build: goimports vet plugin
 	GO111MODULE=off go build \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
-install: goimports plugin
+install: goimports vet plugin
 	GO111MODULE=off go install \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
-	cp -f ~/go/bin/forge ~/go/bin/last.forge # this is a hack so that go-deb can build a .deb file for forge # TODO: remove this
-
-install-verbose: goimports vet plugin
-	GO111MODULE=off go install -v -x \
-		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+	cp -f ~/go/bin/forge ~/go/bin/last.forge # this is a hack so that go-deb can build a .deb file for forge
 
 install-raw: goimports vet plugin
 	go install \
@@ -36,17 +34,12 @@ plugin:
 	rm -f resources/*.so
 	# -cp ../../toolkits/gocui/gocui.so resources/
 
-GTK: clean install
-	forge --gui andlabs
+andlabs: install
+	forge --gui andlabs --debugger
 
-GTK-verbose: clean install
-	forge --gui andlabs --gui-verbose
-
-CUI: install
-	forge --gui gocui
-
-CUI-verbose: install
-	forge --gui gocui --gui-verbose >/tmp/forge.log 2>&1
+gocui: install
+	# forge --gui gocui --gui-verbose  >/tmp/forge.log 2>&1
+	forge --gui gocui --gui-verbose --debugger
 
 goimports:
 	reset
@@ -57,30 +50,10 @@ goimports:
 clean:
 	-rm -f forge go.*
 	# -rm -f ~/go/src/repos.pb
-	go-mod-clean purge
+	go-mod-clean --purge
 
 identify-protobuf:
 	autogenpb --identify ~/go/src/repos.pb
 
 devel:
 	forge clean devel --force --verbose
-
-pull: install
-	FORGE_URL="https://forge.grid.wit.com/" forge pull check
-
-# cloudflare blocks POST due to captcha checks / human detection?
-# POST must be direct socket. probably for the best anyway
-submit:
-	FORGE_URL="https://forge.grid.wit.com/" forge patch submit "forge auto commit"
-
-commit:
-	FORGE_URL="https://forge.grid.wit.com/" forge commit --all
-
-check: install
-	FORGE_URL="https://forge.grid.wit.com/" forge patch check
-
-doc:
-	echo "/*" > doc.go
-	forge -h >> doc.go
-	echo "*/" >> doc.go
-	echo "package main" >> doc.go

README.md

@@ -1,33 +1,5 @@
 # forge
 
-forge is a GUI front end for 'git' designed with the
-intent of simplifying federated git development.
-
-## Install:
-
-* go install go.wit.com/apps/forge@latest
-
-## Theory
-
-* Software engineering is the art of making things work.
-* Release engineering is the art of making things perfect.
-
-## Rules
-
-1) forge is only a GUI and wrapper around 'git'
-2) forge _only_ os.Exec()'s git. Anything forge does
-    can be done on the command line using 'git' directly
-3) forge's default behavior is to use 3 branches:
-    a) The git upstream master/main branch
-    b) A "devel" branch that is published
-    c) a "user" branch that can be local only to the developer
-
-## Development Goals
-
-* have a GUI that also works on the command line
-
-## Notes
-
 This can be used to maintain git repositories
 expiremental work on federated git
 
@@ -37,17 +9,22 @@ expiremental work on federated git
 * uses a GUI or the console(console display needs work)
 * always wrap around 'git' -- it basically just types 'git' commands really fast
 
-## building from sources
+## Notes & Goals:
+
+* use a GUI that also works on the command line
+* andlabs GTK gui plugin starts breaking around 200 repos
+
+## Install:
+
+* go install go.wit.com/apps/forge@latest
+
+## building from sources (may work Jan 2026)
 
 ```
-# note as of Feb 2025. Forge has an option in forge to build itself.
-# The instructions below are out of date, but provide the general idea.
-# accurate instructions are in the forge code itself
-
 go install go.wit.com/apps/go-clone@latest      # this tool makes it easier to 'git clone' repos and recursively 'git clone' the dependancies
 go install go.wit.com/apps/autogenpb@latest     # this tool will generate the protobuf *pb.go files (also Marshal(), Sort(), etc.)
 
-go-clone go.wit.com/apps/forge                  # this will 'git clone' about 20 repos into ~/go/src (or where your go.work file is)
+go-clone --recursive go.wit.com/apps/forge      # this will 'git clone' about 20 repos into ~/go/src (or where your go.work file is)
 
 cd go.wit.com/lib/protobuf/forgepb
 make                                            # autogenpb will make .pb.go, marshal.pb.go and sort.pb.go files
@@ -62,18 +39,3 @@ make                        # this runs GO111MODULE=off go build insuring that y
 ## Debian packages:
 
 Instructions are on https://mirrors.wit.com/
-
-## possible 'git bug' integration ideas:
-
-```
-git pull origin +refs/bugs/\*:refs/bugs/\*
-git pull origin +refs/identities/\*:refs/identities/\*
-
-
-# remove the caches
-rm -rf .git/git-bug
-
-
-# rebuild the cache with any command
-git bug user
-```

applyPatch.go

@@ -3,6 +3,17 @@
 
 package main
 
+import (
+	"os"
+	"path/filepath"
+	"strings"
+
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
 /*
 // saves the patches in ~/.config/forge/currentpatches/
 func savePatchset(pset *forgepb.Patchset) error {
@@ -12,10 +23,42 @@ func savePatchset(pset *forgepb.Patchset) error {
 	log.Info("savePatches() GIT_AUTHOR_EMAIL", pset.GetGitAuthorEmail())
 	log.Info("savePatches() Branch Name", pset.GetStartBranchName())
 	log.Info("savePatches() Start Hash", pset.GetStartBranchHash())
+
+	var count int
+	var bad int
+	var lasterr error
+	all := pset.Patches.SortByFilename()
+	for all.Scan() {
+		p := all.Next()
+		basedir := filepath.Join(os.Getenv("FORGE_CONFIG"), "currentpatches")
+		if fullname, err := savePatchFile(p, basedir); err != nil {
+			log.Info(fullname, "save failed", err)
+			bad += 1
+			lasterr = err
+		}
+		count += 1
+	}
+	log.Info("pset has", count, "total patches, ", bad, "bad save patches")
+	if bad == 0 {
+		return lasterr
+	}
+	return nil
 }
 */
 
-/*
+// re-run git CheckDirty() on everything
+func IsAnythingDirty() bool {
+	me.found = new(gitpb.Repos)
+	findAll() // select all the repos
+	doCheckDirtyAndConfigSave()
+	found := findDirty()
+	if found.Len() == 0 {
+		return false
+	} else {
+		return true
+	}
+}
+
 // From 18ee541f89be2e9f9a91c54873da87885e8ffdf5 Mon Sep 17 00:00:00 2001
 // From: Jeff Carr <jcarr@wit.com>
 // Date: Sun, 5 Jan 2025 01:18:47 -0600
@@ -29,6 +72,84 @@ func countCurrentPatches(repo *gitpb.Repo) int {
 	return len(result.Stdout)
 }
 
+func applyPatchsetOLD(pset *forgepb.Patchset) error {
+	var everythingworked bool = true
+	tmpdir, err := os.MkdirTemp("", "forge")
+	if err != nil {
+		return err
+	}
+	// log.Info("got to applyPatches() pset", pset)
+	log.Info("applyPatches() NAME", pset.Name)
+	log.Info("applyPatches() COMMENT", pset.Comment)
+	log.Info("applyPatches() GIT_AUTHOR_NAME", pset.GetGitAuthorName())
+	log.Info("applyPatches() GIT_AUTHOR_EMAIL", pset.GetGitAuthorEmail())
+	all := pset.Patches.SortByFilename()
+	for all.Scan() {
+		p := all.Next()
+
+		basedir := me.forge.GetGoSrc()
+		if fullname, err := savePatchFile(p, basedir); err != nil {
+			log.Info(fullname, "save failed", err)
+			continue
+		} else {
+			basedir, filename := filepath.Split(fullname)
+			cmd := []string{"git", "am", filename}
+			log.Info("Should run: at", basedir, ":", cmd)
+			log.Info(basedir, filename)
+			result := shell.PathRun(basedir, cmd)
+			for _, line := range result.Stdout {
+				log.Warn("stdout:", line)
+			}
+			for _, line := range result.Stderr {
+				log.Warn("stderr:", line)
+			}
+		}
+		everythingworked = false
+	}
+	if everythingworked {
+		os.RemoveAll(tmpdir) // clean up
+	}
+	log.Info("THIS IS THE END MY FRIEND")
+	return nil
+}
+
+func savePatchFile(p *forgepb.Patch, basedir string) (string, error) {
+	basepath, filename := filepath.Split(p.Filename)
+	fulldir := filepath.Join(basedir, basepath)
+	err := os.MkdirAll(fulldir, os.ModePerm)
+	if err != nil {
+		log.Info("applyPathces() MkdirAll failed for", fulldir)
+		log.Info("applyPathces() MkdirAll failed err", err)
+		return "", err
+	}
+	tmpname := filepath.Join(fulldir, filename)
+	log.Info("pset filename FILENAME IS REAL?", tmpname)
+	raw, _ := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	raw.Write(p.Data)
+	raw.Close()
+	return tmpname, nil
+}
+
+func readPatchFile(pbfile string) (*forgepb.Patchset, error) {
+	bytes, err := os.ReadFile(pbfile)
+	if err != nil {
+		log.Info("readfile error", pbfile, err)
+		return nil, err
+	}
+	return handleBytes(bytes)
+}
+
+func handleBytes(bytes []byte) (*forgepb.Patchset, error) {
+	var pset *forgepb.Patchset
+	pset = new(forgepb.Patchset)
+	err := pset.Unmarshal(bytes)
+	if err != nil {
+		log.Info("Unmarshal failed", err)
+		return nil, err
+	}
+	return pset, nil
+}
+
 func doRegister(newurl string) error {
 	var url string
 	url = me.urlbase + "/register?url=" + newurl
@@ -45,4 +166,3 @@ func doRegister(newurl string) error {
 	}
 	return nil
 }
-*/

argv.go

@@ -6,8 +6,6 @@ package main
 import (
 	"fmt"
 	"os"
-
-	"go.wit.com/lib/gui/prep"
 )
 
 /*
@@ -17,46 +15,39 @@ import (
 var argv args
 
 type args struct {
-	Help       *EmptyCmd    `arg:"subcommand:help"                      help:"New to forge? This is for you.'"`
-	Checkout   *CheckoutCmd `arg:"subcommand:checkout"                  help:"switch branches using 'git checkout'"`
-	Clean      *CleanCmd    `arg:"subcommand:clean"                     help:"start over at the beginning"`
-	Commit     *CommitCmd   `arg:"subcommand:commit"                    help:"'git commit' but errors out if on wrong branch"`
-	Config     *ConfigCmd   `arg:"subcommand:config"                    help:"show your .config/forge/ settings"`
-	Dirty      *DirtyCmd    `arg:"subcommand:dirty"                     help:"show dirty git repos"`
-	GitFetch   *FindCmd     `arg:"subcommand:fetch"                     help:"run 'git fetch master'"`
-	Gui        *EmptyCmd    `arg:"subcommand:gui"                       help:"open the gui"`
-	List       *FindCmd     `arg:"subcommand:list"                      help:"print a table of the current repos"`
-	Merge      *MergeCmd    `arg:"subcommand:merge"                     help:"merge branches"`
-	Normal     *NormalCmd   `arg:"subcommand:normal"                    help:"set every repo to the default state for software development"`
-	Patch      *PatchCmd    `arg:"subcommand:patch"                     help:"make patchsets"`
-	Pull       *PullCmd     `arg:"subcommand:pull"                      help:"run 'git pull'"`
-	Tag        *TagCmd      `arg:"subcommand:tag"                       help:"manage git tags"`
-	URL        string       `arg:"--connect"                            help:"forge url"`
-	All        bool         `arg:"--all"                                help:"git commit --all"`
-	Build      string       `arg:"--build"                              help:"build a repo"`
-	Install    string       `arg:"--install"                            help:"install a repo"`
-	BuildForge bool         `arg:"--forge-rebuild"                      help:"download and rebuild forge"`
-	Force      bool         `arg:"--force"                              help:"try to strong arm things"`
-	Verbose    bool         `arg:"--verbose"                            help:"show more output"`
+	Checkout *CheckoutCmd `arg:"subcommand:checkout"                  help:"switch branches using 'git checkout'"`
+	Clean    *CleanCmd    `arg:"subcommand:clean"                     help:"start over at the beginning"`
+	Commit   *EmptyCmd    `arg:"subcommand:commit"                    help:"'git commit' but errors out if on wrong branch"`
+	Config   *ConfigCmd   `arg:"subcommand:config"                    help:"show your .config/forge/ settings"`
+	Dirty    *DirtyCmd    `arg:"subcommand:dirty"                     help:"show repos git says are dirty"`
+	GitFetch *FindCmd     `arg:"subcommand:fetch"                     help:"run 'git fetch master'"`
+	List     *FindCmd     `arg:"subcommand:list"                      help:"print a table of the current repos"`
+	Patch    *PatchCmd    `arg:"subcommand:patch"                     help:"make patchsets"`
+	GitPull  *FindCmd     `arg:"subcommand:pull"                      help:"run 'git pull'"`
+	URL      string       `arg:"--connect"                            help:"forge url"`
+	All      bool         `arg:"--all"                                help:"git commit --all"`
+	Show     string       `arg:"--show"                               help:"show a repo"`
+	Build    string       `arg:"--build"                              help:"build a repo"`
+	Install  string       `arg:"--install"                            help:"install a repo"`
+	Force    bool         `arg:"--force"                              help:"try to strong arm things"`
+	Verbose  bool         `arg:"--verbose"                            help:"show more output"`
+	Bash     bool         `arg:"--bash"                               help:"generate bash completion"`
+	BashAuto []string     `arg:"--auto-complete"                      help:"todo: move this to go-arg"`
 }
 
 type EmptyCmd struct {
 }
 
-type NormalCmd struct {
-	On  *EmptyCmd `arg:"subcommand:on"        help:"turn normal mode on"`
-	Off *EmptyCmd `arg:"subcommand:off"        help:"turn normal mode off"`
-}
-
-type CommitCmd struct {
-	Submit bool `arg:"--submit"    default:"true"     help:"submit the patches to forge"`
-}
-
 type testCmd string
 
 type CleanCmd struct {
-	Verify *EmptyCmd `arg:"subcommand:verify"        help:"rescan repo"`
-	Repo   string    `arg:"--repo"                   help:"which repo to look at"`
+	Delete   *EmptyCmd      `arg:"subcommand:delete"        help:"rescan repo"`
+	Devel    *CleanDevelCmd `arg:"subcommand:devel"         help:"clean and verify the devel branches"`
+	Force    *EmptyCmd      `arg:"subcommand:force"         help:"do destructive stuff"`
+	GitReset *EmptyCmd      `arg:"subcommand:git-reset"     help:"git reset --hard"`
+	Pub      *EmptyCmd      `arg:"subcommand:pub"           help:"clean target version numbers"`
+	User     *EmptyCmd      `arg:"subcommand:user"          help:"clean the user branches"`
+	Repo     string         `arg:"--repo"                   help:"which repo to look at"`
 }
 
 type CleanDevelCmd struct {
@@ -64,28 +55,10 @@ type CleanDevelCmd struct {
 }
 
 type PatchCmd struct {
-	Check  *EmptyCmd  `arg:"subcommand:check"         help:"check the state of the patches"`
-	List   *EmptyCmd  `arg:"subcommand:list"          help:"your downloaded patchsets"`
-	Get    *EmptyCmd  `arg:"subcommand:get"           help:"get the new patchsets"`
-	Show   *EmptyCmd  `arg:"subcommand:show"          help:"your pending commits to your code"`
-	Submit *SubmitCmd `arg:"subcommand:submit"        help:"submit your commits"`
-	Repos  *SubmitCmd `arg:"subcommand:repos"         help:"show repos with patches"`
-}
-
-type SubmitCmd struct {
-	Match string `arg:"positional"`
-}
-
-type PullCmd struct {
-	Check   *EmptyCmd `arg:"subcommand:check"         help:"check repo versions"`
-	Dirty   *EmptyCmd `arg:"subcommand:dirty"         help:"only check dirty repos"`
-	Patches *EmptyCmd `arg:"subcommand:patches"       help:"only check repos with patches"`
-}
-
-type TagCmd struct {
-	List   *EmptyCmd `arg:"subcommand:list"          help:"list the tags"`
-	Clean  *EmptyCmd `arg:"subcommand:clean"         help:"clean out old and duplicate tags"`
-	Delete string    `arg:"--delete"                 help:"delete a tag"`
+	List   *EmptyCmd `arg:"subcommand:list"          help:"your downloaded patchsets"`
+	Get    *EmptyCmd `arg:"subcommand:get"           help:"get the new patchsets"`
+	Show   *EmptyCmd `arg:"subcommand:show"          help:"your pending commits to your code"`
+	Submit string    `arg:"--submit"                 help:"submit your commits"`
 }
 
 type ConfigAddCmd struct {
@@ -117,12 +90,6 @@ type CheckoutCmd struct {
 	Master *FindCmd `arg:"subcommand:master"                    help:"git checkout master"`
 }
 
-type MergeCmd struct {
-	Devel   *FindCmd  `arg:"subcommand:devel"                     help:"merge user to devel"`
-	Master  *FindCmd  `arg:"subcommand:master"                    help:"merge devel to master"`
-	Publish *EmptyCmd `arg:"subcommand:publish"                    help:"increment versions and publish master branch"`
-}
-
 type DirtyCmd struct {
 }
 
@@ -133,7 +100,6 @@ type FindCmd struct {
 	Private   bool `arg:"--private"                       help:"your private repos from your .config/forge/"`
 	Dirty     bool `arg:"--dirty"                         help:"only use dirty git repos"`
 	User      bool `arg:"--user"                          help:"show repos on the user branch"`
-	Full      bool `arg:"--full"                          help:"show full repo names"`
 	// ReadOnly  bool `arg:"--readonly"                      help:"include read-only repos"`
 }
 
@@ -143,63 +109,47 @@ func (args) Version() string {
 
 func (a args) Description() string {
 	return `
-forge -- a tool to manage lots of git repos. forge includes a GUI and TUI.
+forge -- a tool to git repos at go.wit.com
 
-	forge only executes the 'git' command. Everything it does, you can run by hand with 'git'.
-`
+	but you can probably use it for other things
+	`
 }
 
-// handles shell autocomplete
-func DoAutoComplete(pb *prep.Auto) {
-	switch pb.Cmd {
-	case "checkout":
-		pb.Autocomplete2("devel master user")
-	case "clean":
-		pb.Autocomplete2("")
-	case "commit":
-		pb.Autocomplete2("--all")
-	case "config":
-		fmt.Println("add fix list")
-	case "dirty":
-		fmt.Println("")
-	case "gui":
-		fmt.Println("")
-	case "--gui":
-		pb.Autocomplete2("andlabs gocui")
-	case "list":
-		pb.Autocomplete2("--mine --favorites --dirty")
-	case "merge":
-		pb.Autocomplete2("devel master --all")
-	case "normal":
-		pb.Autocomplete2("on off")
-	case "pull":
-		pb.Autocomplete2("--force check")
-	case "patch":
-		fmt.Println("check get list repos submit show")
-	case "tag":
-		fmt.Println("list --delete clean")
-	default:
-		if pb.Cmd == "" {
-			pb.Autocomplete2("help list checkout clean commit dirty fetch gui normal merge patch pull tag --gui")
-		} else {
-			pb.Autocomplete2("list checkout clean commit dirty normal merge tag")
-		}
+/*
+	This supports GO projects so far.
+		It will work from ~/go/src or where your go.work file is.
+		Since I mostly use ~/go/src, that has been tested more.
+
+Examples:
+	forge                                        # opens the GUI
+	forge list                                   # show every repo state
+	forge dirty                                  # check for dirty git repos
+	forge pull                                   # run 'git pull' in every repo
+	forge checkout                               # switch git branches
+
+	forge config add --private --path /opt/bob   # add a private repo /opt/bob
+	forge config add --directory --writable \
+		--gopath 'go.wit.com/user/bob'       # directory contains r/w repos
+	forge config add --private --writeable \
+		--gopath 'go.wit.com/user/bob/work'  # a GO repo that can not be published
+
+	`
+}
+*/
+
+func (args) doBashHelpDebug() {
+	fmt.Fprintln(os.Stderr, "")
+	fmt.Fprintln(os.Stderr, "hello world")
+	var more string
+	p0 := "0" + argv.BashAuto[0]
+	p1 := "1" + argv.BashAuto[1]
+	p2 := "2" + argv.BashAuto[2]
+	if len(argv.BashAuto[1]) >= 0 {
+		more = "more"
+	} else {
+		more = "less"
 	}
-	os.Exit(0)
-}
-
-func (args) Appname() string {
-	return ARGNAME
-}
-
-func ifBlank(arg string) bool {
-	if arg == "''" {
-		// if empty, the user has not typed something
-		return true
-	}
-	return false
-}
-
-func (a args) DoAutoComplete(autoArgv *prep.Auto) {
-	DoAutoComplete(autoArgv)
+	p1a := fmt.Sprintf("1a.%s.%+v.\n", argv.BashAuto[1], len(argv.BashAuto[1]))
+	fmt.Fprintln(os.Stderr, "pull something else", argv.BashAuto, len(argv.BashAuto), p0, p1, p2, p1a, "end", more)
+	fmt.Fprintln(os.Stderr, "")
 }

argvAutoshell.go

@@ -0,0 +1,115 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+/*
+	handles shell autocomplete
+*/
+
+// used for shell auto completion
+// var ARGNAME string = "forge" // todo: get this from $0 ?
+
+func deleteMatch() {
+	// f := forgedb.InitSimple()
+	fmt.Println("go.wit.com/lib/gui/repostatus todo: need to do this")
+}
+
+func (args) doBashAuto() {
+	argv.doBashHelp()
+	switch argv.BashAuto[0] {
+	case "checkout":
+		fmt.Println("user devel master ")
+	case "clean":
+		// me.pp.WriteHelp(os.Stderr)
+		// me.pp.WriteUsageForSubcommand(os.Stderr, me.pp.SubcommandNames()...)
+		// me.pp.WriteHelpForSubcommand(os.Stderr, me.pp.SubcommandNames()...)
+		me.pp.WriteHelpForSubcommand(os.Stderr, "clean")
+		fmt.Println("devel user")
+	case "commit":
+		fmt.Println("--all")
+	case "config":
+		fmt.Println("add fix list")
+	case "delete":
+		deleteMatch()
+	case "dirty":
+		fmt.Println("--verbose")
+	case "examine":
+		fmt.Println("fix")
+	case "list":
+		fmt.Println("--all --mine --favorites --private")
+	case "pull":
+		fmt.Println("--force")
+	case "patch":
+		fmt.Println("get list --submit show")
+	case "user":
+		fmt.Println("--force")
+	case "devel":
+		fmt.Println("--force")
+	case "master":
+		fmt.Println("")
+	case "verify":
+		fmt.Println("user devel master")
+	default:
+		if argv.BashAuto[0] == ARGNAME {
+			// list the subcommands here
+			fmt.Println("--bash list checkout clean commit config dirty fetch patch pull")
+		}
+	}
+	os.Exit(0)
+}
+
+// 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, "")
+}
+
+// complete -F forge --bash forge
+func (args) doBash() {
+	fmt.Println("# add this in your bashrc:")
+	fmt.Println("")
+	fmt.Println("# todo: add this to go-arg as a 'hidden' go-arg option --bash")
+	fmt.Println("#")
+	fmt.Println("# todo: can this output work/parse with:")
+	fmt.Println("# complete -C `" + ARGNAME + " --bash` " + ARGNAME)
+	fmt.Println("")
+	fmt.Println("_" + ARGNAME + "_complete()")
+	fmt.Println("{")
+	fmt.Println("	# sets local to this func vars")
+	fmt.Println("	local cur prev all")
+	fmt.Println("	cur=${COMP_WORDS[COMP_CWORD]}")
+	fmt.Println("	prev=${COMP_WORDS[COMP_CWORD-1]}")
+	fmt.Println("	all=${COMP_WORDS[@]}")
+	fmt.Println("")
+	fmt.Println("	# this is where we generate the go-arg output")
+	fmt.Println("        GOARGS=$(" + ARGNAME + " --auto-complete $prev \\'$cur\\' $all)")
+	fmt.Println("")
+	fmt.Println("	# this compares the command line input from the user")
+	fmt.Println("	# to whatever strings we output")
+	fmt.Println("        COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) )  # THIS WORKS")
+	fmt.Println("	return 0")
+	fmt.Println("}")
+	fmt.Println("complete -F _" + ARGNAME + "_complete " + ARGNAME)
+	fmt.Println("")
+	fmt.Println("# copy and paste the above into your bash shell should work")
+	os.Exit(0)
+}

build

@@ -3,6 +3,3 @@
 # include forgeConfig
 mkdir -p  files/usr/bin/
 cp ../utils/wit-utils/forgeConfig/forgeConfig files/usr/bin/
-
-mkdir -p files/usr/share/bash-completion/completions/
-forge --bash > files/usr/share/bash-completion/completions/forge

config.go

@@ -1,36 +0,0 @@
-package main
-
-// functions to import and export the protobuf
-// data to and from config files
-
-import (
-	"fmt"
-
-	"go.wit.com/lib/config"
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/log"
-)
-
-func forgeConfigSave() error {
-	return me.forge.Config.ConfigSave()
-}
-
-func setForgeMode(fmode forgepb.ForgeMode) {
-	if me.forge.Config.Mode == fmode {
-		return
-	}
-	log.Info("changing mode", me.forge.Config.Mode, fmode)
-	me.forge.Config.Mode = fmode
-	config.SetChanged("forge", true)
-	me.forge.Config.ConfigSave()
-}
-
-func sampleConfig(all *forgepb.ForgeConfigs) {
-	new1 := new(forgepb.ForgeConfig)
-	new1.GoPath = "go.wit.com"
-	new1.Writable = true
-	new1.Directory = true
-	all.Append(new1)
-
-	fmt.Println("first time user. adding an example config file with", len(all.ForgeConfigs), "repos")
-}

control

@@ -3,6 +3,6 @@ Build-Depends: golang, protoc-gen-go, autogenpb, go-mod-clean
 Package: forge
 Maintainer: Jeff Carr <jcarr@wit.com>
 Architecture: amd64
-Depends: go-gui-toolkits, autogenpb, go-mod-clean, go-clone
+Depends: go-gui-toolkits
 Recommends: go-clone
 Description: 'forge' an attempt at federated 'git'

debug.go

@@ -1,88 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// An app to submit patches for the 30 GO GUI repos
-
-import (
-	"fmt"
-	"time"
-
-	"go.wit.com/gui"
-	"go.wit.com/lib/debugger"
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func init() {
-	if debugger.ArgDebug() {
-		log.Info("cmd line --debugger == true")
-		go func() {
-			log.Sleep(2)
-			debugger.DebugWindow()
-		}()
-	}
-}
-
-func debug() {
-	defer func() {
-		if r := recover(); r != nil {
-			gui.Crash(r, "forge debug()")
-		}
-	}()
-	time.Sleep(2 * time.Second)
-	for {
-		now := time.Now()
-
-		if me.repoAllB != nil {
-			tmp := fmt.Sprintf("All (%d)", me.forge.Repos.Len())
-			me.repoAllB.SetLabel(tmp)
-		}
-
-		if me.repoDevelMergeB != nil {
-			found := findMergeToDevel()
-			tmp := fmt.Sprintf("needs merge to devel (%d)", found.Len())
-			me.repoDevelMergeB.SetLabel(tmp)
-		}
-
-		if me.repoWritableB != nil {
-			found := gitpb.NewRepos()
-			for repo := range me.forge.Repos.IterByFullPath() {
-				if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-					continue
-				}
-
-				found.AppendByFullPath(repo)
-
-			}
-			tmp := fmt.Sprintf("writable (%d)", found.Len())
-			me.repoWritableB.SetLabel(tmp)
-		}
-
-		dirty := me.forge.CheckDirty()
-
-		if me.repoDirtyB != nil {
-			tmp := fmt.Sprintf("dirty (%d)", dirty.Len())
-			me.repoDirtyB.SetLabel(tmp)
-		}
-
-		if me.reposWinB != nil {
-			tmp := fmt.Sprintf("Repos (%d)", me.forge.Repos.Len())
-			if dirty.Len() > 0 {
-				tmp = fmt.Sprintf("Repos (%d) (%d dirty)", me.forge.Repos.Len(), dirty.Len())
-			}
-			me.reposWinB.SetLabel(tmp)
-		}
-
-		// check for new patches
-		log.Info("should check for packages here")
-		//		if err := me.forge.ListPatches(); err != nil {
-		//			log.Info("List Patchsets Failed", err)
-		//		}
-
-		log.Printf("finished a forge scan here in (%s)\n", shell.FormatDuration(time.Since(now)))
-		time.Sleep(90 * time.Second)
-	}
-}

doCheckout.go

@@ -5,43 +5,347 @@ package main
 
 import (
 	"fmt"
+	"path/filepath"
 	"time"
 
 	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
+var ErrorNotAllReposOnMaster error = fmt.Errorf("not all repos on are on the master branch")
+var ErrorNotAllReposOnDevel error = fmt.Errorf("not all repos on are on the devel branch")
+var ErrorNotAllReposOnUser error = fmt.Errorf("not all repos on are on the user branch")
+
+func IsEverythingOnMaster() (int, int, int, error) {
+	var total int
+	var count int
+	var nope int
+
+	// first make sure every repo is on the master branch
+	all := me.forge.Repos.All()
+	for all.Scan() {
+		repo := all.Next()
+		total += 1
+		if repo.GetMasterBranchName() == repo.GetCurrentBranchName() {
+			count += 1
+		} else {
+			nope += 1
+		}
+	}
+	if total != count {
+		// log.Info(ErrorNotAllReposOnMaster)
+		return total, count, nope, ErrorNotAllReposOnMaster
+	}
+	return total, count, nope, nil
+}
+
+func IsEverythingOnDevel() (int, int, int, error) {
+	var total int
+	var count int
+	var nope int
+
+	// first make sure every repo is on the master branch
+	all := me.forge.Repos.All()
+	for all.Scan() {
+		repo := all.Next()
+		total += 1
+		if repo.GetDevelBranchName() == repo.GetCurrentBranchName() {
+			count += 1
+		} else {
+			nope += 1
+		}
+	}
+	if total != count {
+		return total, count, nope, ErrorNotAllReposOnDevel
+	}
+	return total, count, nope, nil
+}
+
+func IsEverythingOnUser() (int, int, int, error) {
+	var total int
+	var count int
+	var nope int
+
+	// first make sure every repo is on the master branch
+	all := me.forge.Repos.All()
+	for all.Scan() {
+		repo := all.Next()
+		total += 1
+		if repo.GetCurrentBranchName() == repo.GetUserBranchName() {
+			count += 1
+		} else {
+			nope += 1
+		}
+	}
+	if total != count {
+		return total, count, nope, ErrorNotAllReposOnUser
+	}
+	return total, count, nope, nil
+}
+
+func doGitReset() {
+	all := me.found.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+			// log.Info("is readonly", repo.GetGoPath())
+			if repo.CheckDirty() {
+				log.Info("is readonly and dirty", repo.GetGoPath())
+				cmd := []string{"git", "reset", "--hard"}
+				repo.RunRealtime(cmd)
+			}
+		} else {
+			// log.Info("is not readonly", repo.GetGoPath())
+		}
+	}
+}
+
+func rillCheckoutUser(repo *gitpb.Repo) error {
+	if repo.IsDirty() {
+		// never do dirty repos
+		return nil
+	}
+	if repo.GetCurrentBranchName() == repo.GetMasterBranchName() {
+		// repo is already on devel branch. have to move them there first for now
+		// return repo.CheckoutDevel()
+	}
+	if repo.GetCurrentBranchName() == repo.GetUserBranchName() {
+		// repo is already on user branch
+		return nil
+	}
+	if err := repo.CheckoutUser(); err != nil {
+		log.Info(repo.GetFullPath(), err)
+		return err
+	}
+	return nil
+}
+
 // trys to figure out if there is still something to update
+func doAllCheckoutUser() error {
+	now := time.Now()
+	me.forge.RillFuncError(rillCheckoutUser)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+
+	total, count, nope, err := IsEverythingOnUser()
+	log.Printf("User branch check. %d total repos. (%d ok) (%d not on user branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
+	if err != nil {
+		// display all repos not on user
+		me.found = new(gitpb.Repos)
+		all := me.forge.Repos.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
+				me.found.AppendByGoPath(repo)
+			}
+		}
+		me.forge.PrintHumanTable(me.found)
+		log.Printf("There are %d repos that are NOT on the user branch\n", me.found.Len())
+		return err
+	}
+	return nil
+}
+
+func rillCheckoutDevel(repo *gitpb.Repo) error {
+	if repo.IsDirty() {
+		// never do dirty repos
+		return nil
+	}
+	if repo.GetCurrentBranchName() == repo.GetDevelBranchName() {
+		// repo is already on devel branch
+		return nil
+	}
+	repo.CheckoutDevel()
+	return nil
+}
+
+// is every repo on the devel branch?
+func doAllCheckoutDevel() error {
+	now := time.Now()
+	log.Info("going to rill:")
+	me.forge.RillFuncError(rillCheckoutDevel)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+
+	total, count, nope, err := IsEverythingOnDevel()
+	log.Printf("Devel branch check. %d total repos. (%d ok) (%d not on devel branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
+	if err != nil {
+		// display all repos not on user
+		me.found = new(gitpb.Repos)
+		all := me.forge.Repos.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			if repo.GetCurrentBranchName() != repo.GetDevelBranchName() {
+				me.found.AppendByGoPath(repo)
+			}
+		}
+		me.forge.PrintHumanTable(me.found)
+		log.Printf("There are %d repos that are NOT on the devel branch\n", me.found.Len())
+		return err
+	}
+	return nil
+}
+
+func rillCheckoutMaster(repo *gitpb.Repo) error {
+	if repo.IsDirty() {
+		// never do dirty repos
+		return nil
+	}
+	if repo.GetCurrentBranchName() == repo.GetMasterBranchName() {
+		// repo is already on master
+		return nil
+	}
+	if repo.GetUserVersion() == "uerr" {
+		repo.CheckoutMaster()
+		return nil
+	}
+	if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+		// skip other checks for readonly repos
+		repo.CheckoutMaster()
+		return nil
+	}
+	/*
+		if repo.GetUserVersion() != repo.GetDevelVersion() {
+			// don't switch branches if the user branch has uncommitted patches
+			return nil
+		}
+		if repo.GetDevelVersion() != repo.GetMasterVersion() {
+			// don't switch braches if the devel branch does not match master (needs merge)
+			return nil
+		}
+	*/
+	repo.CheckoutMaster()
+	return nil
+}
+
+// trys to figure out if there is still something to update
+func doAllCheckoutMaster() error {
+	now := time.Now()
+	me.forge.RillFuncError(rillCheckoutMaster)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+
+	total, count, nope, err := IsEverythingOnMaster()
+	log.Printf("Master branch check. %d total repos. (%d ok) (%d not on master branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
+	if err != nil {
+		// display all repos not on master
+		me.found = new(gitpb.Repos)
+		all := me.forge.Repos.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
+				me.found.AppendByGoPath(repo)
+			}
+		}
+		me.forge.PrintHumanTable(me.found)
+		log.Printf("There are %d repos that are NOT on the master branch\n", me.found.Len())
+		return err
+	}
+	return nil
+}
+
+// shared this with the GUI and the command line?
+func doCheckoutShared() error {
+	if me.argvCheckoutUser {
+		// log.Info("Starting git checkout user")
+		if argv.Force {
+			log.Info("going to force create user branches")
+			if err := makeUserBranches(); err != nil {
+				return err
+			}
+		}
+		// this uses rill and is super fast
+		doAllCheckoutUser()
+		return nil
+	}
+
+	if me.argvCheckoutDevel {
+		// log.Info("Starting git checkout devel")
+		if argv.Force {
+			log.Info("going to force create devel branches")
+			makeDevelBranches()
+		}
+		// this uses rill and is super fast
+		doAllCheckoutDevel()
+		return nil
+	}
+
+	if me.argvCheckoutMaster {
+		log.Info("Starting git checkout master")
+		doAllCheckoutMaster()
+		return nil
+	}
+	log.Info("Forge didn't know what branches to checkout")
+	return nil
+}
+
+// trys to figure out if there is still something to update
+// todo: redo this logic as it is terrible
 
 func doCheckout() error {
 	if argv.Checkout.User != nil {
-		start := time.Now()
-		err := me.forge.DoAllCheckoutUser(argv.Force)
-		dur := time.Since(start)
-		log.Printf("Checked out %d user braches in %s\n", me.forge.Repos.Len(), shell.FormatDuration(dur))
-		if err != nil {
-			badExit(err)
-		}
-		okExit("")
+		me.argvCheckoutUser = true
 	}
 
 	if argv.Checkout.Devel != nil {
-		// setForgeMode(forgepb.ForgeMode_DEVEL)
-		if err := me.forge.DoAllCheckoutDevelNew(argv.Force); err != nil {
-			badExit(err)
-		}
-		okExit("")
+		me.argvCheckoutDevel = true
 	}
 
 	if argv.Checkout.Master != nil {
-		setForgeMode(forgepb.ForgeMode_MASTER) // disable "normal" mode if set
-
-		if err := me.forge.DoAllCheckoutMaster(); err != nil {
-			badExit(err)
-		}
-		okExit("")
+		me.argvCheckoutMaster = true
+	}
+	if err := doCheckoutShared(); err != nil {
+		badExit(err)
+	}
+	okExit("")
+	return nil
+}
+
+func makeDevelBranches() error {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		branch := repo.GetDevelBranchName()
+		if repo.Exists(filepath.Join(".git/refs/heads", branch)) {
+			continue
+		}
+		if repo.Exists(filepath.Join(".git/refs/remotes/origin", branch)) {
+			cmd := []string{"git", "checkout", branch}
+			repo.RunVerbose(cmd)
+			continue
+		}
+		cmd := []string{"git", "branch", branch}
+		repo.RunVerbose(cmd)
+		cmd = []string{"git", "checkout", branch}
+		repo.RunVerbose(cmd)
+	}
+	return nil
+}
+
+func makeUserBranches() error {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		branch := repo.GetUserBranchName()
+		if repo.Exists(filepath.Join(".git/refs/heads", branch)) {
+			continue
+		}
+		if repo.Exists(filepath.Join(".git/refs/remotes/origin", branch)) {
+			cmd := []string{"git", "checkout", branch}
+			repo.RunVerbose(cmd)
+			continue
+		}
+		cmd := []string{"git", "branch", branch}
+		repo.RunVerbose(cmd)
+		cmd = []string{"git", "checkout", branch}
+		repo.RunVerbose(cmd)
 	}
-	badExit(fmt.Errorf("did not specify what branch to checkout"))
 	return nil
 }

doClean.go

@@ -6,160 +6,129 @@ package main
 import (
 	"fmt"
 	"path/filepath"
-	"time"
 
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-func checkRemoteBranches(repo *gitpb.Repo) error {
-	if err := repo.ReloadCheck(); err != nil {
-		log.Info("need to reload", repo.FullPath)
+var ErrorReposHasLocalBranches error = fmt.Errorf("repo still has local branches")
+var ErrorMergeBranch error = fmt.Errorf("trunk has things not in the branch")
+var ErrorMergeTrunk error = fmt.Errorf("branch has things not in trunk")
+
+func doClean() error {
+	if argv.Clean.Pub != nil {
+		if err := doCleanPub(); err != nil {
+			badExit(err)
+		}
+		log.Info("finished attempt at cleaning devel branches")
+		return nil
 	}
-	if repo.VerifyRemoteAndLocalBranches(repo.GetDevelBranchName()) {
-	} else {
-		return log.Errorf("remote devel is out of sync with local: todo: git pull or git fetch")
+	if argv.Clean.Devel != nil {
+		if err := doCleanDevel(); err != nil {
+			badExit(err)
+		}
+		log.Info("finished attempt at cleaning devel branches")
+		return nil
 	}
-	if repo.VerifyRemoteAndLocalBranches(repo.GetMasterBranchName()) {
-	} else {
-		return log.Errorf("remote master is out of sync with local: todo: git pull or git fetch")
+	if argv.Clean.User != nil {
+		if err := doCleanUser(); err != nil {
+			log.Info(err)
+			okExit("")
+		}
+		return nil
 	}
 	return nil
 }
 
-// reverts all repos back to the original master branches
-// automatically deletes local devel and user branches
-func doClean() error {
-	setForgeMode(forgepb.ForgeMode_CLEAN)
-
-	if argv.Clean.Verify != nil {
-		stats := me.forge.RillRepos(checkRemoteBranches)
-		for path, stat := range stats {
-			if stat.Err == nil {
-				continue
-			}
-			dur := stat.End.Sub(stat.Start)
-			if dur > time.Second {
-				log.Infof("%s checkRemoteBranches() took a long time (%s) (err=%v)\n", path, shell.FormatDuration(dur), stat.Err)
-			}
+func doCleanUser() error {
+	if _, count, _, err := IsEverythingOnMaster(); err != nil {
+		if count == 0 {
+			log.Info("No repos are on the master branch")
+			return nil
 		}
-		// log.Infof("%-60s, %-60s %v %s\n", stat.Start, stat.End.String(), dur, path)
-		// log.Infof("%-30v %s %v\n", dur, path, stat.Err)
-		return nil
+		log.Info("Not all repos are on the master branch")
+		// return err
 	}
 
-	// fix this to work, then delete all the other options for "forge clean'
-	if err := me.forge.DoAllCheckoutMaster(); err != nil {
-		// badExit(err)
-	}
+	var anyerr error
 
 	all := me.forge.Repos.SortByFullPath()
 	for all.Scan() {
 		repo := all.Next()
-		if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
-			continue
-		}
-		if repo.IsDirty() {
-			continue
-		}
-
-		// when publishing, clean out the details of that if it's still there
-		if repo.GetTargetVersion() != "" {
-			repo.SetTargetVersion("")
-			configSave = true
-		}
-
-		// try to delete user
-		if err := doRepoCleanUser(repo); err != nil {
+		if err := doCleanUserRepo(repo); err != nil {
 			log.Info(repo.GetGoPath(), err)
+			anyerr = err
 		}
-
-		// try to delete devel
-		doRepoCleanDevel(repo)
 	}
+	return anyerr
+}
 
-	found := gitpb.NewRepos()
+/*
+func doesLocalBranchExist(repo *gitpb.Repo, branch string) bool {
+	return repo.Exists(filepath.Join(".git/refs/heads", branch))
+}
+*/
 
-	total := 0
-	// find all repos that aren't "clean"
-	all = me.forge.Repos.SortByFullPath()
+func doCleanDevel() error {
+	var total int
+	var count int
+	all := me.forge.Repos.SortByFullPath()
 	for all.Scan() {
 		repo := all.Next()
 		total += 1
-
-		// find repos not on master branch
+		// devel := repo.GetDevelBranchName()
+		if repo.GetDevelVersion() == "derr" {
+			// already deleted
+			return nil
+		}
+		/*
+			if !doesLocalBranchExist(repo, devel) {
+				if argv.Verbose {
+					log.Info("local branch was already deleted:", repo.GetGoPath())
+				}
+				continue
+			}
+		*/
 		if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
-			found.AppendByFullPath(repo)
+			log.Info("Repo not on master branch:", repo.GetGoPath())
 			continue
 		}
-
-		// find dirty repos
 		if repo.IsDirty() {
-			found.AppendByFullPath(repo)
+			log.Info("Repo is dirty:", repo.GetGoPath())
 			continue
 		}
-
-		// find repos that still have a local user branch
-		if repo.IsLocalBranch(repo.GetUserBranchName()) {
-			found.AppendByFullPath(repo)
-			continue
-		}
-
-		// find repos that still have a local devel branch
-		if repo.IsLocalBranch(repo.GetDevelBranchName()) {
-			found.AppendByFullPath(repo)
-			continue
+		count += 1
+		if err := justDeleteTheDevelBranchAlready(repo); err != nil {
+			log.Info("justDeleteTheDevel() err", repo.GetGoPath(), err)
 		}
 	}
-
-	// display all the repos that aren't clean to the user
-	log.Printf("\n") // padding for now
-	if argv.Verbose {
-		me.forge.PrintHumanTableDirty(found)
-	} else {
-		me.forge.PrintHumanTable(found)
-	}
-	log.Printf("\n") // padding for now
-
-	var hmm int
-	hmm = found.Len()
-	if hmm == 0 {
-		log.Printf("%d repos are not clean\n", hmm)
-	} else {
-		log.Info("All repos are clean", total, hmm)
-	}
+	log.Info("")
+	log.Printf("attempted cleaning %d devel branches of %d total branches\n", count, total)
 	return nil
 }
 
 /*
-	func doesLocalBranchExist(repo *gitpb.Repo, branch string) bool {
-		return repo.Exists(filepath.Join(".git/refs/heads", branch))
+func checkhashes(repo *gitpb.Repo, hashes []string, refpath string) ([]string, error) {
+	if !repo.Exists(refpath) {
+		return hashes, nil
 	}
-*/
-func doRepoCleanDevel(repo *gitpb.Repo) error {
-	if !repo.IsLocalBranch(repo.GetDevelBranchName()) {
-		// there is no local branch named 'devel'
-		return nil
+	r, err := repo.RunStrict([]string{"cat", refpath})
+	if err != nil {
+		return hashes, err
 	}
-
-	if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
-		return log.Errorf("%s not on master branch:", repo.GetFullPath())
+	newhash := r.Stdout[0]
+	for _, hash := range hashes {
+		if newhash != hash {
+			return hashes, fmt.Errorf("%s hash broke %s %s", repo.GetGoPath(), newhash, hash)
+		}
 	}
-	if repo.IsDirty() {
-		return log.Errorf("%s is dirty:", repo.GetFullPath())
-	}
-	if err := justDeleteTheDevelBranchAlready(repo); err != nil {
-		log.Info("justDeleteTheDevel() err", repo.GetGoPath(), err)
-		configSave = true
-		return err
-	}
-	return nil
+	hashes = append(hashes, newhash)
+	return hashes, nil
 }
+*/
 
-// removes all local user branches
-func doRepoCleanUser(repo *gitpb.Repo) error {
+// removes all local branches
+func doCleanUserRepo(repo *gitpb.Repo) error {
 	if repo.IsDirty() {
 		return nil
 	}
@@ -167,48 +136,41 @@ func doRepoCleanUser(repo *gitpb.Repo) error {
 	bruser := repo.GetUserBranchName()
 	brdevel := repo.GetDevelBranchName()
 
+	if repo.GetUserVersion() == "uerr" {
+		// already deleted
+		return nil
+	}
+	log.Info("trying", bruser, repo.GetUserVersion())
+
 	if repo.IsBranchRemote(bruser) {
 		log.Info("forge is designed to always have local only user branches", bruser)
 		return fmt.Errorf("forge is designed to always have local only user branches")
 	}
 
-	if !repo.IsLocalBranch(bruser) {
-		// there is no local user branch
-		return nil
+	b1 := repo.CountDiffObjects(bruser, brdevel) // should be zero
+	if b1 == 0 {
+		cmd := []string{"git", "branch", "-D", bruser}
+		log.Info("USER IS IN DEVEL", repo.GetGoPath(), cmd)
+		err := repo.RunVerbose(cmd)
+		return err
 	}
 
-	// will you loose work if you delete your user branch?
-	// if DevelBranchExists()
-	//	then if UserBranchCommits exist in DevelBranch
-	//		DeleteUserBranch is safe
-	if repo.IsLocalBranch(brdevel) {
-		b1 := repo.CountDiffObjects(bruser, "refs/heads/"+brdevel) // should be zero
-		if b1 == 0 {
-			// every user branch exists in devel. delete user branch
-			cmd := []string{"git", "branch", "-D", bruser}
-			// log.Info("USER IS IN DEVEL", repo.GetGoPath(), cmd)
-			_, err := repo.RunVerboseOnError(cmd)
-			return err
+	return fmt.Errorf("%s branch has things not in %s count=%d", bruser, brdevel, b1)
+}
+
+func doCleanPub() error {
+	total := 0
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if repo.GetTargetVersion() != "" {
+			repo.SetTargetVersion("")
+			configSave = true
+			total += 1
 		}
 	}
-
-	brmaster := repo.GetMasterBranchName()
-
-	// will you loose work if you delete your user branch?
-	// if master branch exists()
-	//	then if all user commits exist in master
-	//		delete user branch is safe
-	if repo.IsLocalBranch(brmaster) {
-		b1 := repo.CountDiffObjects(bruser, "refs/heads/"+brmaster) // should be zero
-		if b1 == 0 {
-			cmd := []string{"git", "branch", "-D", bruser}
-			// log.Info("USER IS IN DEVEL", repo.GetGoPath(), cmd)
-			_, err := repo.RunVerboseOnError(cmd)
-			return err
-		}
-	}
-
-	return fmt.Errorf("%s branch has unique commits", bruser)
+	log.Printf("clearing %d total repos\n", total)
+	return nil
 }
 
 // if you call this, there is no going back. no checks anymore. nothing
@@ -229,8 +191,8 @@ func justDeleteTheDevelBranchAlready(repo *gitpb.Repo) error {
 		b1 := repo.CountDiffObjects(branch, remote) // should be zero
 		if b1 == 0 {
 			cmd := []string{"git", "branch", "-D", repo.GetDevelBranchName()}
-			// log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
-			_, err := repo.RunVerboseOnError(cmd)
+			log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
+			err := repo.RunVerbose(cmd)
 			return err
 		}
 		cmd := []string{"git", "push"}
@@ -241,32 +203,15 @@ func justDeleteTheDevelBranchAlready(repo *gitpb.Repo) error {
 
 	// remote doesn't exist, check against master
 	master := repo.GetMasterBranchName()
-	b1 := repo.CountDiffObjects(branch, "refs/heads/"+master) // should be zero
+	b1 := repo.CountDiffObjects(branch, master) // should be zero
 	if b1 == 0 {
 		cmd := []string{"git", "branch", "-D", repo.GetDevelBranchName()}
-		// log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
-		_, err := repo.RunVerboseOnError(cmd)
+		log.Info("DEVEL IS IN REMOTE", repo.GetGoPath(), cmd)
+		err := repo.RunVerbose(cmd)
 		return err
 	}
 	cmd := []string{"git", "merge something somehow"}
-	log.Info("devel local, remote and master branches are wrong", repo.GetGoPath(), cmd, b1)
+	log.Info("DEVEL LOCAL NEEDS GIT MERGE TO MASTER", repo.GetGoPath(), cmd, b1)
 	// _, err := repo.RunVerbose(cmd)
 	return nil
 }
-
-func doGitReset() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			// log.Info("is readonly", repo.GetGoPath())
-			if repo.CheckDirty() {
-				log.Info("is readonly and dirty", repo.GetGoPath())
-				cmd := []string{"git", "reset", "--hard"}
-				repo.RunRealtime(cmd)
-			}
-		} else {
-			// log.Info("is not readonly", repo.GetGoPath())
-		}
-	}
-}

doCommit.go

@@ -6,43 +6,37 @@ package main
 import (
 	"os"
 
-	"go.wit.com/lib/config"
 	"go.wit.com/lib/gui/shell"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-func doCommit() error {
+func doCommit() {
 	if argv.All {
-		found := me.forge.CheckDirty()
-		var newpatches bool
-		for repo := range found.IterAll() {
+		log.Info("do a commit everywhere")
+		doCheckDirtyAndConfigSave()
+		found := findDirty()
+		all := found.All()
+		for all.Scan() {
+			repo := all.Next()
 			log.Info("do a commit on repo", repo.GetGoPath())
 			if err := doCommitRepo(repo); err != nil {
 				badExit(err)
 			}
-			newpatches = true
-			repo.CheckDirty()
-		}
-		if newpatches {
-			config.SetChanged("repos", true)
-			return doPatchSubmit()
 		}
 		okExit("")
 	}
 
-	repo := findCurrentPwdRepoOrDie()
-
-	if !repo.CheckDirty() {
-		okExit(log.Sprintf("this repo %s is not dirty.\n\n--all    # commit all changes in all repos", repo.GetFullPath()))
-	} else {
-		log.Info("repo is dirty", repo.GetFullPath())
+	pwd, _ := os.Getwd()
+	repo := me.forge.Repos.FindByFullPath(pwd)
+	if repo == nil {
+		log.Info("todo: forge doesn't know how to work here yet")
+		okExit("")
 	}
 
 	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-		found := new(gitpb.Repos)
-		found.Append(repo)
-		me.forge.PrintHumanTable(found)
+		me.found.Append(repo)
+		me.forge.PrintHumanTable(me.found)
 		log.Info("")
 		log.Info("wrong branch. Can not commit on", repo.GetCurrentBranchName())
 		log.Info("")
@@ -63,15 +57,13 @@ func doCommit() error {
 	if err := shell.ExecCheck([]string{"git", "commit", "--all"}); err != nil {
 		badExit(err)
 	}
-
-	return doPatchSubmit()
+	log.Info("git commit ok. forge done")
 }
 
 func doCommitRepo(repo *gitpb.Repo) error {
 	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-		found := new(gitpb.Repos)
-		found.Append(repo)
-		me.forge.PrintHumanTable(found)
+		me.found.Append(repo)
+		me.forge.PrintHumanTable(me.found)
 		log.Info("")
 		log.Info("wrong branch. Can not commit on", repo.GetCurrentBranchName())
 		log.Info("")
@@ -91,7 +83,6 @@ func doCommitRepo(repo *gitpb.Repo) error {
 	}
 
 	if err := shell.ExecCheck([]string{"git", "commit", "--all"}); err != nil {
-		shell.ExecCheck([]string{"git", "reset"})
 		return err
 	}
 	log.Info("git commit ok. forge done")

doConfig.go

@@ -21,16 +21,13 @@ func doConfig() {
 		log.Info("todo")
 		okExit("")
 	}
-
-	/*
-		if argv.Config.Register != "" {
-			if err := doRegister(argv.Config.Register); err == nil {
-				okExit("attempting to register " + argv.Config.Register)
-			} else {
-				badExit(err)
-			}
+	if argv.Config.Register != "" {
+		if err := doRegister(argv.Config.Register); err == nil {
+			okExit("attempting to register " + argv.Config.Register)
+		} else {
+			badExit(err)
 		}
-	*/
+	}
 
 	// try to add, then save config and exit
 	if argv.Config.Add != nil {
@@ -54,8 +51,6 @@ func doConfig() {
 		os.Exit(0)
 	}
 
-	log.Info("config.PathLock =", me.forge.Config.PathLock)
-
 	me.forge.ConfigPrintTable()
 	okExit("")
 }

doDirty.go

@@ -3,14 +3,62 @@
 
 package main
 
+import (
+	"time"
+
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
 func doDirty() {
-	found := me.forge.CheckDirty()
-	if found.Len() == 0 {
-		return
-	}
+	findAll() // select all the repos
+	doCheckDirtyAndConfigSave()
+	found := findDirty()
 	if argv.Verbose {
 		me.forge.PrintHumanTableDirty(found)
 	} else {
 		me.forge.PrintHumanTable(found)
 	}
 }
+
+func straightCheckDirty() int {
+	var count int
+	// var total int
+	// now := time.Now()
+	all := me.found.All()
+	for all.Scan() {
+		repo := all.Next()
+		// total += 1
+		if repo.IsDirty() {
+			count += 1
+		}
+	}
+	// log.Printf("rill dirty check (%d dirty repos) (%d total repos) took:%s\n", count, total, shell.FormatDuration(time.Since(now)))
+	return count
+}
+
+func doCheckDirty(repo *gitpb.Repo) error {
+	repo.CheckDirty()
+	// reset these in here for now
+	if repo.GetTargetVersion() != "" {
+		repo.TargetVersion = ""
+		me.forge.SetConfigSave(true)
+	}
+	return nil
+}
+
+func doCheckDirtyAndConfigSave() {
+	start := straightCheckDirty()
+
+	now := time.Now()
+	me.forge.RillFuncError(doCheckDirty)
+	end := straightCheckDirty()
+	log.Printf("dirty check (%d dirty repos) (%d total repos) took:%s\n", end, me.found.Len(), shell.FormatDuration(time.Since(now)))
+
+	if start != end {
+		// todo: use internal forgepb configsave flag. should work?
+		me.forge.SetConfigSave(true)
+		me.forge.ConfigSave()
+	}
+}

doFind.go

@@ -1,198 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-import (
-	"go.wit.com/lib/protobuf/gitpb"
-)
-
-// this populates a slice of protobuf records representing each git repo
-// var found []*gitpb.Repo
-//
-// so, it makes a subset of repos that are then used performing actions on
-//
-// by default, it adds every repo
-
-func doFind() *gitpb.Repos {
-	if argv.List == nil {
-		return findAll()
-	}
-
-	if argv.List.Mine {
-		return findMine()
-	}
-
-	if argv.List.Dirty {
-		return me.forge.FindDirty()
-	}
-
-	return findAll()
-}
-
-func (f *FindCmd) findRepos() *gitpb.Repos {
-	if f == nil {
-		return findMine()
-	}
-
-	if f.All {
-		return findAll()
-	}
-
-	if f.Private {
-		return findPrivate()
-	}
-
-	if f.Mine {
-		return findMine()
-	}
-
-	if f.Favorites {
-		return findFavorites()
-	}
-
-	if f.Dirty {
-		return me.forge.FindDirty()
-	}
-
-	if f.User {
-		return findUser()
-	}
-
-	return findAll()
-}
-
-func findPrivate() *gitpb.Repos {
-	found := gitpb.NewRepos()
-	for repo := range me.forge.Repos.IterByFullPath() {
-		if me.forge.Config.IsPrivate(repo.GetGoPath()) {
-			found.AppendByFullPath(repo)
-		}
-	}
-
-	return found
-}
-
-// finds repos that are writable
-func findMine() *gitpb.Repos {
-	found := gitpb.NewRepos()
-
-	// log.Printf("get mine %s\n", me.forge.GetGoSrc())
-	for repo := range me.forge.Repos.IterByFullPath() {
-
-		if me.forge.Config.IsWritable(repo.GetGoPath()) {
-			found.AppendByFullPath(repo)
-		}
-	}
-	return found
-}
-
-// finds repos the user has marked as favorites in the forge .config
-func findFavorites() *gitpb.Repos {
-	found := gitpb.NewRepos()
-
-	// log.Printf("get favorites %s\n", me.forge.GetGoSrc())
-	for repo := range me.forge.Repos.IterByFullPath() {
-
-		if me.forge.Config.IsFavorite(repo.GetGoPath()) {
-			found.AppendByFullPath(repo)
-		}
-	}
-	return found
-}
-
-func findAll() *gitpb.Repos {
-	found := gitpb.NewRepos()
-	for repo := range me.forge.Repos.IterByFullPath() {
-		found.AppendByFullPath(repo)
-	}
-	return found
-}
-
-func find50() *gitpb.Repos {
-	count := 0
-	found := gitpb.NewRepos()
-	for repo := range me.forge.Repos.IterByFullPath() {
-		found.AppendByFullPath(repo)
-		if count > 50 {
-			return found
-		}
-		count += 1
-	}
-	return found
-}
-
-func findUser() *gitpb.Repos {
-	found := gitpb.NewRepos()
-
-	for repo := range me.forge.Repos.IterByFullPath() {
-		if repo.GetCurrentBranchName() == repo.GetUserBranchName() {
-			found.AppendByFullPath(repo)
-		}
-	}
-	return found
-}
-
-func findPublishable() *gitpb.Repos {
-	found := gitpb.NewRepos()
-
-	for repo := range me.forge.Repos.IterByFullPath() {
-		if repo.GetTargetVersion() == "" {
-			continue
-		}
-		found.AppendByFullPath(repo)
-	}
-	return found
-}
-
-func findReposWithPatches() *gitpb.Repos {
-	found := gitpb.NewRepos()
-
-	for repo := range me.forge.Repos.IterByFullPath() {
-		if repo.GetTargetVersion() != "" {
-			// add everything that has a target version set
-			found.AppendByFullPath(repo)
-			continue
-		}
-		if repo.IsDirty() {
-			// always add dirty branches
-			found.AppendByFullPath(repo)
-			continue
-		}
-		if repo.GetUserVersion() == "" || repo.GetUserVersion() == "uerr" {
-			// skip anything without a user branch
-			continue
-		}
-		if repo.GetUserVersion() != repo.GetDevelVersion() {
-			found.AppendByFullPath(repo)
-			continue
-		}
-
-		// show anything that differs between 'devel' & 'master' branches
-		if repo.GetDevelVersion() != repo.GetMasterVersion() {
-			// this repo.State code isn't great, but it got me here quickly
-			// I'll defend my code by saying it's faster for me if I do dumb things
-			// sometimes and fix them later. Probably some employee will have to
-			// fix this. if that is the case I owe you lunch. or stock options
-			if repo.State == "DEVEL behind MASTER" {
-				// log.Info("repo state", repo.FullPath, repo.State)
-				continue
-			}
-			found.AppendByFullPath(repo)
-			continue
-		}
-
-		// ignore read-only repos for checks below here
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			continue
-		}
-
-		// this is an old test to see if the current 'last tag' is accurate and should be removed
-		if repo.GetLastTag() != repo.GetMasterVersion() {
-			found.AppendByFullPath(repo)
-			repo.FindLastTag()
-			continue
-		}
-	}
-	return found
-}

doGui.go

@@ -11,46 +11,105 @@ import (
 	"time"
 
 	"go.wit.com/gui"
+	"go.wit.com/lib/debugger"
 	"go.wit.com/lib/gadgets"
 	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
+func debug() {
+	time.Sleep(2 * time.Second)
+	for {
+		var found *gitpb.Repos
+		now := time.Now()
+		tmp := fmt.Sprintf("All (%d)", me.forge.Repos.Len())
+		me.repoAllB.SetLabel(tmp)
+
+		found = findMergeToDevel()
+		tmp = fmt.Sprintf("needs merge to devel (%d)", found.Len())
+		me.repoDevelMergeB.SetLabel(tmp)
+
+		found = gitpb.NewRepos()
+		all := me.forge.Repos.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+				continue
+			}
+
+			found.AppendByGoPath(repo)
+
+		}
+		tmp = fmt.Sprintf("writable (%d)", found.Len())
+		me.repoWritableB.SetLabel(tmp)
+
+		doCheckDirtyAndConfigSave()
+		found = findDirty()
+		tmp = fmt.Sprintf("dirty (%d)", found.Len())
+		me.repoDirtyB.SetLabel(tmp)
+
+		log.Printf("finished a forge scan here in (%s)\n", shell.FormatDuration(time.Since(now)))
+		time.Sleep(90 * time.Second)
+
+	}
+}
+
 func doGui() {
-	win := gadgets.NewGenericWindow("Forge: A federated git development tool by WIT.COM", "Current Settings")
-	win.Custom = func() {
+	if me.forge.Config.GetDefaultGui() == "" {
+		me.forge.Config.DefaultGui = "gocui"
+		me.forge.ConfigSave()
+	}
+	me.myGui = gui.New()
+	me.myGui.InitEmbed(resources)
+	me.myGui.SetAppDefaultPlugin(me.forge.Config.DefaultGui) // sets the default GUI plugin to use
+	me.myGui.Default()
+
+	mainWindow := gadgets.RawBasicWindow("Forge: (this kinda works sometimes)")
+	mainWindow.Make()
+	mainWindow.Show()
+	mainWindow.Custom = func() {
 		log.Warn("MAIN WINDOW CLOSE")
-		okExit("")
+		now := time.Now()
+		count := me.forge.RillReload()
+		log.Info("Repo Reload count =", count)
+		if count != 0 {
+			me.forge.ConfigSave()
+		}
+		log.Printf("rill repos.Reload() took (%s)\n", shell.FormatDuration(time.Since(now)))
+		os.Exit(0)
 	}
 
-	grid := win.Group.RawGrid()
-	if me.forge.Config.GetPathLock() {
-		me.goSrcPwd = gadgets.NewOneLiner(grid, "Working Directory")
-		me.goSrcPwd.SetText(me.forge.Config.ReposDir)
-	} else {
-		me.goSrcEdit = gadgets.NewBasicEntry(grid, "Working Directory")
-		me.goSrcEdit.SetText(me.forge.Config.ReposDir)
-		me.goSrcEdit.Custom = func() {
-			log.Info("updating text to", me.goSrcEdit.String())
-		}
-	}
-	lockpath := grid.NewCheckbox("Lock").SetChecked(me.forge.Config.PathLock)
-	lockpath.Custom = func() {
-		if lockpath.IsChecked() {
-			log.Info("lock working directory")
-			me.forge.Config.PathLock = true
-		} else {
-			log.Info("unlock working directory")
-			me.forge.Config.PathLock = false
-		}
-		me.forge.Config.ConfigSave()
-		okExit("you must restart forge after changing the Path Lock")
-	}
+	drawWindow(mainWindow)
 
+	// sits here forever
+	debug()
+
+}
+
+func drawWindow(win *gadgets.BasicWindow) {
+	box := win.Box()
+
+	vbox := box.NewVerticalBox("BOX2")
+
+	group1 := vbox.NewGroup("Forge Settings")
+	grid := group1.NewGrid("buildOptions", 0, 0)
+
+	// me.autoWorkingPwd = gadgets.NewOneLiner(grid, "working directory (pwd)")
+	me.goSrcPwd = gadgets.NewOneLiner(grid, "repo src home")
+	grid.NewLabel("")
+	var howtoWin *genericWindow
+	me.demoB = grid.NewButton("Howto", func() {
+		if howtoWin != nil {
+			howtoWin.Toggle()
+			return
+		}
+		howtoWin = makeHowtoWin()
+	})
 	grid.NextRow()
 
+	me.goSrcPwd.SetText(me.forge.GetGoSrc())
+
 	// use ENV GIT_AUTHOR
 	me.gitAuthor = gadgets.NewOneLiner(grid, "Git Author")
 	grid.NextRow()
@@ -63,82 +122,232 @@ func doGui() {
 		me.gitAuthor.SetText(author)
 	}
 
+	// select the branch you want to test, build and develop against
+	// this lets you select your user branch, but, when you are happy
+	// you can merge everything into the devel branch and make sure it actually
+	// works. Then, when that is good, merge and version everything in master
+	me.setBranchB = grid.NewButton("git checkout", func() {
+		win.Disable()
+		defer win.Enable()
+
+		if me.autoCreateBranches.Checked() {
+			argv.Force = true
+		} else {
+			argv.Force = false
+		}
+
+		// do the checkout
+		if err := doCheckoutShared(); err != nil {
+			log.Info("checkout error:", err)
+		} else {
+			log.Info("checkout was ok")
+		}
+	})
+
+	/*
+		me.setBranchB = grid.NewButton("git repos", func() {
+			t := me.forge.Repos.NewTable()
+			fp := t.AddFullPath("Full Path")
+			fp.Custom( func() {
+				log.Info("this is the full path")
+			})
+			t.AddMasterVersion("master version")
+
+			t.Show()
+		})
+	*/
+
+	me.newBranch = grid.NewDropdown()
+	me.newBranch.AddText("master")
+	me.newBranch.AddText("devel")
+	me.newBranch.AddText(me.forge.Config.GetUsername())
+	me.newBranch.SetText(me.forge.Config.GetUsername())
+	me.argvCheckoutUser = true
+	me.newBranch.Custom = func() {
+		// toggle global values shared by the command line and the gui for doCheckout()
+		me.argvCheckoutUser = false
+		me.argvCheckoutDevel = false
+		me.argvCheckoutMaster = false
+		switch me.newBranch.String() {
+		case "master":
+			me.argvCheckoutMaster = true
+		case "devel":
+			me.argvCheckoutDevel = true
+		default:
+			me.argvCheckoutUser = true
+		}
+		log.Info("forged changed to default:", me.newBranch.String())
+	}
+
+	// checking this will automatically make the branches off of devel
+	me.autoCreateBranches = grid.NewCheckbox("auto create branches").SetChecked(true)
 	grid.NextRow()
 
-	gridM := win.Stack.RawGrid()
+	group2 := vbox.NewGroup("Repos")
+	grid = group2.RawGrid()
 
-	var insertWin *gadgets.GenericWindow
-	s := fmt.Sprintf("Repos (%d)", me.forge.Repos.Len())
-	me.reposWinB = gridM.NewButton(s, func() {
-		// if the window exists, just toggle it open or closed
-		if insertWin != nil {
-			insertWin.Toggle()
-			return
-		}
+	me.repoDirtyB = grid.NewButton("dirty", func() {
+		doCheckDirtyAndConfigSave()
+		found := findDirty()
+		_, box := makeStandardReposWindow("dirty repos", found)
+		hbox := box.Box().Horizontal()
+		hbox.NewButton("commit all", func() {
+			all := found.SortByFullPath()
+			for all.Scan() {
+				repo := all.Next()
+				log.Info("do commit here on", repo.GetGoPath())
+			}
+			log.Info("TODO: fix this")
+			log.Info("run 'forge commit --all'")
+		})
 
-		insertWin = makeReposWinNew()
 	})
 
-	var patchesWin *stdPatchTableWin
-	var patchButton *gui.Node
-	patchButton = gridM.NewButton("Your patches", func() {
-		if patchesWin != nil {
-			patchesWin.Toggle()
-			return
-		}
-		if !isPatchingSafe() {
-			patchButton.SetLabel("not safe yet")
-			return
-		}
-		// patchesWin = makePatchesWin(me.forge.Patchsets)
-		notdone := new(forgepb.Patches)
-
-		all := me.forge.Patchsets.All()
+	me.repoWritableB = grid.NewButton("writable", func() {
+		me.found = new(gitpb.Repos)
+		all := me.forge.Repos.SortByFullPath()
 		for all.Scan() {
-			pset := all.Next()
-			if pset.State == "DONE" {
-				// skip old patchsets
+			repo := all.Next()
+			if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
 				continue
 			}
-			AddAllPatches(notdone, pset, false)
-			// AddNotDonePatches(notdone, pset, false)
-		}
-		notdone.PrintTable()
 
-		patchesWin = makePatchesWin(notdone)
+			me.found.AppendByGoPath(repo)
+
+		}
+		makeStandardReposWindow("Repos that you have write access to", me.found)
 	})
 
-	var pubWin *gadgets.GenericWindow
-	gridM.NewButton("Publish", func() {
-		if pubWin != nil {
-			pubWin.Toggle()
-			return
+	me.repoAllB = grid.NewButton("All", func() {
+		me.found = new(gitpb.Repos)
+		all := me.forge.Repos.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			me.found.AppendByGoPath(repo)
+
 		}
-		pubWin = makePublishWindow()
+		makeStandardReposWindow("All repos", me.found)
 	})
 
-	var oldWin *gadgets.GenericWindow
-	gridM.NewButton("old", func() {
-		if oldWin != nil {
-			oldWin.Toggle()
+	me.repoDevelMergeB = grid.NewButton("merge", func() {
+		found := findMergeToDevel()
+		makeStandardReposWindow("repos to merge from user to devel", found)
+	})
+	var problemsWin *repoProblemsWindow
+	grid.NewButton("Repo Problems", func() {
+		if problemsWin != nil {
+			problemsWin.Toggle()
 			return
 		}
-		oldWin = makeOldStuff()
+		problemsWin = makeRepoProblemsWindow()
+	})
+	grid.NextRow()
+
+	/*
+		group2 = vbox.NewGroup("Repos with problems")
+		grid = group2.RawGrid()
+
+		grid.NewButton("devel is behind master", func() {
+			log.Info("not done yet")
+		})
+
+		grid.NewButton("user branch is remote", func() {
+			log.Info("not done yet")
+		})
+
+		grid.NewButton("unknown branches", func() {
+			log.Info("not done yet")
+		})
+		grid.NextRow()
+
+		grid.NewButton("remote devel != local devel", func() {
+			log.Info("not done yet")
+		})
+
+		grid.NewButton("remote master != local master", func() {
+			log.Info("not done yet")
+		})
+	*/
+
+	group2 = vbox.NewGroup("Merge")
+	grid = group2.RawGrid()
+
+	grid.NewButton("merge to devel", func() {
+		win.Disable()
+		defer win.Enable()
+
+		mergeUserToDevel(me.autoCreateBranches.Checked())
+	})
+
+	grid.NewButton("merge to master", func() {
+		win.Disable()
+		defer win.Enable()
+
+		mergeDevelToMaster(me.autoCreateBranches.Checked())
+	})
+
+	grid.NewButton("merge all", func() {
+		win.Disable()
+		defer win.Enable()
+
+		me.argvCheckoutUser = false
+		me.argvCheckoutDevel = true
+		me.argvCheckoutMaster = false
+		if err := doCheckoutShared(); err != nil {
+			log.Info("checkout error:", err)
+		} else {
+			log.Info("checkout was ok")
+		}
+
+		mergeUserToDevel(me.autoCreateBranches.Checked())
+
+		me.argvCheckoutUser = false
+		me.argvCheckoutDevel = false
+		me.argvCheckoutMaster = true
+		if err := doCheckoutShared(); err != nil {
+			log.Info("checkout error:", err)
+		} else {
+			log.Info("checkout was ok")
+		}
+
+		mergeDevelToMaster(me.autoCreateBranches.Checked())
+	})
+
+	group3 := vbox.NewGroup("work in progress")
+	grid = group3.RawGrid()
+
+	grid.NewButton("forge ConfigSave()", func() {
+		me.forge.ConfigSave()
+	})
+
+	grid.NewButton("debugger()", func() {
+		debugger.DebugWindow()
+	})
+
+	var patchWin *patchesWindow
+
+	grid.NewButton("Patches Window", func() {
+		if patchWin != nil {
+			patchWin.Toggle()
+			return
+		}
+		patchWin = new(patchesWindow)
+		patchWin.initWindow()
+		patchWin.Show()
 	})
 }
 
 // this is the magic that generates a window directly from the protocol buffer
 func makeStandardReposGrid(pb *gitpb.Repos) *gitpb.ReposTable {
 	t := pb.NewTable("testDirty")
-	t.NewUuid()
 	sf := t.AddStringFunc("repo", func(r *gitpb.Repo) string {
-		return r.GetNamespace()
+		return r.GetGoPath()
 	})
 	// t.Custom = func() {
 	// 	log.Info("close grid?")
 	// }
 	sf.Custom = func(r *gitpb.Repo) {
-		log.Info("do button click on", r.GetNamespace())
+		log.Info("do button click on", r.GetGoPath())
 	}
 	t.AddTimeFunc("age", func(repo *gitpb.Repo) time.Time {
 		return repo.NewestTime()
@@ -171,10 +380,13 @@ func makeStandardReposWindow(title string, pb *gitpb.Repos) (*gitpb.ReposTable,
 func findMergeToDevel() *gitpb.Repos {
 	found := gitpb.NewRepos()
 
-	for repo := range me.forge.Repos.IterByFullPath() {
-		// this sees if user has patches for devel. If it does, add it to found
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+
+		// this sees if user has patches for devel. If it does, add it to me.found
 		if repo.CountDiffObjects(repo.GetUserBranchName(), repo.GetDevelBranchName()) > 0 {
-			found.AppendByFullPath(repo)
+			found.AppendByGoPath(repo)
 		}
 	}
 	now := time.Now()
@@ -185,19 +397,17 @@ func findMergeToDevel() *gitpb.Repos {
 	// me.forge.PrintHumanTable(found)
 
 	// check for merges from devel
-	total, count, nope, _ := me.forge.IsEverythingOnDevel()
+	total, count, nope, _ := IsEverythingOnDevel()
 	log.Printf("devel branch check. %d total repos. (%d ok) (%d not on devel branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
 	return found
 }
-
-func findMergeToMaster() *gitpb.Repos {
-	found := new(gitpb.Repos)
+func findMergeToMaster() {
+	me.found = new(gitpb.Repos)
 
 	all := me.forge.Repos.SortByFullPath()
 	for all.Scan() {
 		repo := all.Next()
-
-		if me.forge.Config.IsReadOnly(repo.GetNamespace()) {
+		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
 			continue
 		}
 		/*
@@ -205,7 +415,7 @@ func findMergeToMaster() *gitpb.Repos {
 				continue
 			}
 			if repo.GetMasterVersion() != repo.GetDevelVersion() {
-				me.found.AppendByFullPath(repo)
+				me.found.AppendByGoPath(repo)
 				continue
 			}
 		*/
@@ -215,39 +425,38 @@ func findMergeToMaster() *gitpb.Repos {
 			// everything is normal
 		} else {
 			repo.State = "DEVEL < MASTER"
-			log.Info("SERIOUS ERROR. DEVEL BRANCH IS BEHIND MASTER", repo.GetNamespace())
+			log.Info("SERIOUS ERROR. DEVEL BRANCH IS BEHIND MASTER", repo.GetGoPath())
 		}
 
 		// this sees if devel has patches for master. If it does, add it to me.found
 		if repo.CountDiffObjects(repo.GetDevelBranchName(), repo.GetMasterBranchName()) > 0 {
-			found.AppendByFullPath(repo)
+			me.found.AppendByGoPath(repo)
 		}
 	}
 	now := time.Now()
-	if found.Len() == 0 {
+	if me.found.Len() == 0 {
 		log.Info("nothing to merge with master")
-		return found
+		return
 	}
-	me.forge.PrintHumanTable(found)
+	me.forge.PrintHumanTable(me.found)
 
 	// check for merges from devel
-	total, count, nope, _ := me.forge.IsEverythingOnMaster()
+	total, count, nope, _ := IsEverythingOnMaster()
 	log.Printf("Master branch check. %d total repos. (%d ok) (%d not on master branch) (%s)\n", total, count, nope, shell.FormatDuration(time.Since(now)))
 
-	return found
 }
 
 func mergeDevelToMaster(doit bool) {
-	found := findMergeToMaster()
+	findMergeToMaster()
 
 	if !doit {
 		return
 	}
 
-	all := found.SortByFullPath()
+	all := me.found.SortByFullPath()
 	for all.Scan() {
 		repo := all.Next()
-		log.Info("repo:", repo.GetNamespace())
+		log.Info("repo:", repo.GetGoPath())
 		if result, err := repo.MergeToMaster(); err == nil {
 			log.Warn("THINGS SEEM OK", repo.GetFullPath())
 			for _, line := range result.Stdout {
@@ -298,10 +507,10 @@ func mergeUserToDevel(doit bool) {
 
 		b1 := repo.CountDiffObjects(bruser, brdevel) // should be zero
 		if b1 == 0 {
-			// log.Info("User is already merged into Devel", repo.GetNamespace(), cmd)
+			// log.Info("User is already merged into Devel", repo.GetGoPath(), cmd)
 			return
 		}
-		log.Info("merging user into devel repo:", repo.GetNamespace())
+		log.Info("merging user into devel repo:", repo.GetGoPath())
 		if result, err := repo.MergeToDevel(); err == nil {
 			log.Warn("THINGS SEEM OK", repo.GetFullPath())
 			for _, line := range result.Stdout {
@@ -329,34 +538,3 @@ func mergeUserToDevel(doit bool) {
 	}
 	me.forge.ConfigSave()
 }
-
-// old things before they are removed, deprecated, fixed, etc
-func makeOldStuff() *gadgets.GenericWindow {
-	oldWin := gadgets.NewGenericWindow("old code", "old code on it's way out")
-
-	grid := oldWin.Group.RawGrid()
-
-	// var reposWin *gadgets.GenericWindow
-	var reposWin *stdReposTableWin
-	grid.NewButton("Fix Repos", func() {
-		if reposWin != nil {
-			reposWin.Toggle()
-			return
-		}
-		reposWin = makeReposWin()
-	})
-
-	var howtoWin *gadgets.GenericWindow
-	grid.NewButton("Tutorial", func() {
-		if howtoWin != nil {
-			howtoWin.Toggle()
-			return
-		}
-		howtoWin = makeHowtoWin()
-	})
-
-	grid.NextRow()
-	grid.NewLabel("")
-
-	return oldWin
-}

doMerge.go

@@ -1,168 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-import (
-	"time"
-
-	"go.wit.com/lib/config"
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func doMerge() error {
-	if argv.All == true {
-		start := time.Now()
-		repos, err := doMergeDevel()
-		dur := time.Since(start)
-		if err != nil {
-			badExit(err)
-		}
-		log.Printf("Merged %d devel branches in %s\n", repos.Len(), shell.FormatDuration(dur))
-
-		start = time.Now()
-		repos, err = doMergeMaster()
-		dur = time.Since(start)
-		if err != nil {
-			badExit(err)
-		}
-		log.Printf("Merged %d master branches in %s\n", repos.Len(), shell.FormatDuration(dur))
-		okExit("")
-	}
-	if argv.Merge.Devel != nil {
-		start := time.Now()
-		repos, err := doMergeDevel()
-		dur := time.Since(start)
-		if err != nil {
-			badExit(err)
-		}
-		log.Printf("Merged %d devel branches in %s\n", repos.Len(), shell.FormatDuration(dur))
-		okExit("")
-	}
-	if argv.Merge.Master != nil {
-		start := time.Now()
-		repos, err := doMergeMaster()
-		dur := time.Since(start)
-		if err != nil {
-			badExit(err)
-		}
-		log.Printf("Merged %d master branches in %s\n", repos.Len(), shell.FormatDuration(dur))
-		okExit("")
-	}
-	repo := findCurrentPwdRepoOrDie()
-	if err := repoMergeToDevel(repo); err != nil {
-		badRepoExit(repo, err)
-	}
-	return nil
-}
-
-func doMergeReport() *forgepb.Patches {
-	found := forgepb.NewPatches()
-	for repo := range me.forge.Repos.IterAll() {
-		if repo.GetDevelVersion() == repo.GetMasterVersion() {
-			continue
-		}
-		tmp := log.Sprintf("%s..%s", repo.GetMasterVersion(), repo.GetDevelVersion())
-		r, err := repo.RunStrict([]string{"git", "log", "--pretty=format:%H", tmp})
-		_ = err
-		for i, line := range r.Stdout {
-			log.Info(i, line, repo.FullPath)
-		}
-	}
-	return found
-}
-
-func doMergeDevel() (*gitpb.Repos, error) {
-	var err error
-	done := gitpb.NewRepos()
-	found := findMergeToDevel()
-	for repo := range found.IterAll() {
-		if repo.CheckDirty() {
-			log.Info("repo is dirty", repo.GetFullPath())
-			continue
-		}
-		log.Infof("%s starting git merge\n", repo.FullPath)
-		if repo.CheckoutDevel() {
-			log.Info("checkout devel failed", repo.GetGoPath())
-			err = log.Errorf("checkout devel failed")
-			badExit(err)
-		}
-		// hash differences when merging user into devel branch
-		out := repo.GetBranchDifferences(repo.GetDevelBranchName(), repo.GetUserBranchName())
-		for i, hash := range out {
-			log.Info("MERGE HASH FROM USER TO DEVEL", i, hash)
-		}
-		if _, err := repo.MergeToDevel(); err != nil {
-			log.Info("merge from user failed", repo.GetGoPath(), err)
-			err = log.Errorf("merge from user failed")
-			// log.Info(strings.Join(r.Stdout, "\n"))
-			// log.Info(strings.Join(r.Stderr, "\n"))
-			badExit(err)
-		}
-		done.Append(repo)
-		config.SetChanged("repos", true)
-	}
-	return done, err
-}
-
-func repoMergeToDevel(repo *gitpb.Repo) error {
-	if repo.CheckDirty() {
-		return log.Errorf("can not merge. repo is dirty")
-	}
-	log.Infof("%s starting git merge\n", repo.FullPath)
-	if repo.CheckoutDevel() {
-		log.Info("checkout devel failed", repo.GetGoPath())
-		err := log.Errorf("checkout devel failed")
-		badExit(err)
-	}
-	// hash differences when merging user into devel branch
-	out := repo.GetBranchDifferences(repo.GetDevelBranchName(), repo.GetUserBranchName())
-	for i, hash := range out {
-		log.Info("MERGE HASH FROM USER TO DEVEL", i, hash)
-	}
-	if _, err := repo.MergeToDevel(); err != nil {
-		log.Info("merge from user failed", repo.GetGoPath(), err)
-		// err := log.Errorf("merge from user failed")
-		// log.Info(strings.Join(r.Stdout, "\n"))
-		// log.Info(strings.Join(r.Stderr, "\n"))
-		badExit(err)
-	}
-	config.SetChanged("repos", true)
-	return nil
-}
-
-func doMergeMaster() (*gitpb.Repos, error) {
-	var err error
-	setForgeMode(forgepb.ForgeMode_MASTER)
-
-	done := gitpb.NewRepos()
-	found := findMergeToMaster()
-	for repo := range found.IterAll() {
-		if repo.CheckDirty() {
-			log.Info("repo is dirty", repo.GetGoPath())
-			continue
-		}
-
-		log.Info("Starting merge on", repo.GetGoPath())
-		if repo.CheckoutMaster() {
-			log.Info("checkout devel failed", repo.GetGoPath())
-			err = log.Errorf("checkout devel failed")
-			badExit(err)
-		}
-
-		if _, err := repo.MergeToMaster(); err != nil {
-			log.Info("merge from user failed", repo.GetGoPath(), err)
-			err = log.Errorf("merge from user failed")
-			// log.Info(strings.Join(r.Stdout, "\n"))
-			// log.Info(strings.Join(r.Stderr, "\n"))
-			badExit(err)
-		}
-
-		done.Append(repo)
-		config.SetChanged("repos", true)
-	}
-	return done, err
-}

doNormal.go

@@ -1,112 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// checks that repos are in a "normal" state
-
-import (
-	"path/filepath"
-	"strings"
-	"time"
-
-	"go.wit.com/lib/config"
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func doNormal() bool {
-	me.forge.CheckDirtyQuiet()
-
-	var count int
-	stats := me.forge.RillRepos(checkNormalRepoState)
-	for path, stat := range stats {
-		dur := stat.End.Sub(stat.Start)
-		if dur > 10*time.Second {
-			log.Infof("%s checkNormalRepoState() took a long time (%s)\n", path, shell.FormatDuration(dur))
-		}
-		if stat.Err == nil {
-			continue
-		}
-		// log.Infof("%-60s, %-60s %v %s\n", stat.Start, stat.End.String(), dur, path)
-		// log.Infof("%-30v %s %v\n", dur, path, stat.Err)
-		// log.Info("got path", path, stat.Err)
-		count += 1
-	}
-	if count > 0 {
-		log.Info("Some repos are not in a 'normal' state. error count =", count)
-		log.Info("TODO: list the repos here. forge patch repos?")
-		dumpWorkRepos()
-		config.SetChanged("repos", true)
-		return false
-	}
-	return true
-}
-
-// 99% of the time, the repos during development should be on your user branch.
-// error out if it's not
-// this checks to see if a devel and user branch exist
-// this needs to run each time in case repos were added manually by the user
-// this also verifies that
-func checkNormalRepoState(repo *gitpb.Repo) error {
-	var err error
-	tmp := filepath.Join(me.forge.Config.ReposDir, repo.GetNamespace())
-	if tmp != repo.FullPath {
-		log.Infof("%s != %s\n", repo.FullPath, tmp)
-		if strings.HasPrefix(repo.FullPath, me.forge.Config.ReposDir) {
-			tmp = strings.TrimPrefix(repo.FullPath, me.forge.Config.ReposDir)
-			tmp = strings.Trim(tmp, "/")
-			repo.Namespace = tmp
-			err = log.Errorf("namespace set to filepath")
-		}
-	} else {
-		// log.Infof("%s == %s\n", repo.FullPath, tmp)
-	}
-
-	tmp = strings.Trim(repo.Namespace, "/")
-	if tmp != repo.Namespace {
-		err = log.Errorf("junk in ns %s", repo.Namespace)
-		repo.Namespace = tmp
-	}
-
-	if repo.GetMasterBranchName() == "" {
-		me.forge.VerifyBranchNames(repo)
-		log.Info("ABNORMAL: master branch name was blank in", repo.GetFullPath())
-	}
-	if repo.GetMasterBranchName() == "" {
-		me.forge.VerifyBranchNames(repo)
-		err = log.Errorf("master branch name blank")
-	}
-	if repo.GetDevelBranchName() == "" {
-		me.forge.VerifyBranchNames(repo)
-		err = log.Errorf("devel branch name blank")
-	}
-	if repo.GetUserBranchName() == "" {
-		me.forge.VerifyBranchNames(repo)
-		err = log.Errorf("user branch name blank")
-	}
-	if repo.GetGoPath() == repo.GetNamespace() {
-		// log.Info(repo.FullPath, "gopath == namespace", repo.GetGoPath(), repo.GetNamespace())
-	} else {
-		log.Info(repo.FullPath, "gopath != namespace", repo.GetGoPath(), repo.GetNamespace())
-	}
-	repo.MakeLocalDevelBranch()
-
-	repo.VerifyRemoteAndLocalBranches(repo.GetDevelBranchName())
-	repo.VerifyRemoteAndLocalBranches(repo.GetMasterBranchName())
-
-	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-		log.Infof("changing to user(%s) branch: %s\n", repo.GetUserBranchName(), repo.FullPath)
-		repo.CheckoutUser()
-		repo.ReloadCheck()
-		err = log.Errorf("now on user branch")
-	}
-
-	if me.forge.Config.IsReadOnly(repo.GetGoPath()) != repo.GetReadOnly() {
-		repo.ReadOnly = me.forge.Config.IsReadOnly(repo.GetGoPath())
-		log.Info("damnit", repo.FullPath)
-		err = log.Errorf("readonly bit wrong")
-	}
-	return err
-}

doPatch.go

@@ -4,210 +4,96 @@
 package main
 
 import (
+	"os"
 	"path/filepath"
 
-	"go.wit.com/lib/fhelp"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/log"
 )
 
-func doPatchInit() {
-	if me.forge.Patchsets != nil {
-		if me.forge.Patchsets.Len() == 0 {
-			// log.Info("IGNORE: patches are empty")
-		} else {
-			log.Info("IGNORE: patches already initalized len =", me.forge.Patchsets.Len())
-		}
-	}
-	if err := me.forge.LoadPatchsets(); err != nil {
-		log.Info("patches failed to open", err)
-		if err := me.forge.SavePatchsets(); err != nil {
-			log.Warn("savePatchsets() failed", err)
-		}
-	}
-}
-
-func isPatchingSafe() bool {
-	if me.forge.Config.Mode == forgepb.ForgeMode_NORMAL {
-		return true
-	}
-	log.Info("This patch command is not safe to run now")
-	log.Info("you must reset the state of your git repositories. Run:")
-	log.Info("")
-	log.Info("forge normal")
-	log.Info("")
-	return false
-}
-
-// submit's current working patches
-func doPatchSubmit() error {
-	pset, err := me.forge.MakeDevelPatchSet("testing")
-	if err != nil {
-		return err
-	}
-	if pset.Patches == nil {
-		log.Info("pset.Patches == nil")
-		return err
-	}
-	if pset.Patches.Len() == 0 {
-		log.Info("did not find any patches")
-		return nil
-	}
-	pset.PrintTable()
-	_, _, err = pset.HttpPost(myServer(), "new")
-	return err
-}
-
 func doPatch() error {
-	if argv.Patch.Repos != nil {
-		dumpWorkRepos()
+	if argv.Patch.Submit != "" {
+		_, err := me.forge.SubmitDevelPatchSet(argv.Patch.Submit)
+		if err != nil {
+			return err
+		}
 		return nil
 	}
 
-	if argv.Patch.Submit != nil {
-		return doPatchSubmit()
-	}
-
-	if !isPatchingSafe() {
-		return log.Errorf("not safe to work on patches")
-	}
-
 	if argv.Patch.Get != nil {
-		psets := forgepb.NewSets()
-		newpb, _, _ := psets.HttpPostVerbose(myServer(), "get")
-		newpb.PrintTable()
-		me.forge.Patchsets = newpb
-		me.forge.SavePatchsets()
-		return nil
-	}
-
-	if argv.Patch.Check != nil {
-		/*
-			old := findExpired()
-			// old.PrintTable()
-			for p := range old.IterAll() {
-				log.Info("patch", p.Filename, p.Namespace)
-			}
-			newpb, err := old.HttpPostVerbose(myServer(), "check")
-			if err != nil {
-				return err
-			}
-			newpb.PrintTable()
-		*/
-		log.Info("do something here to find patches merged to devel")
-		doMergeReport()
-		return nil
+		return doPatchGet()
 	}
 
 	if argv.Patch.List != nil {
-		var changed bool
-		newpatches := new(forgepb.Set)
-		newpatches.Patches = forgepb.NewPatches()
-		for pset := range me.forge.Patchsets.IterAll() {
-			pset.PrintTable()
-			for patch := range pset.Patches.IterAll() {
-				changed = true
-				if patch.NewHash == "" || patch.NewHash == "na" {
-					if newpatches.Patches.AppendByPatchId(patch) {
-						log.Info("patchId added here", patch.PatchId)
-					} else {
-						log.Info("patchId already here", patch.PatchId)
-					}
-				} else {
-					if err := setNewCommitHash(patch); err != nil {
-						log.Infof("%s bad check on patch failure %v\n", patch.Filename, err)
-						return err
-					}
-					log.Info("newhash set already here", patch.PatchId, patch.NewHash)
-				}
-			}
-		}
-		if changed {
-			if err := me.forge.SavePatchsets(); err != nil {
-				log.Warn("savePatchsets() failed", err)
-			}
-		}
-		log.Info("NEW PATCHES TABLE")
-		newpatches.PrintTable()
-		for patch := range newpatches.Patches.IterAll() {
-			if err := setNewCommitHash(patch); err == nil {
-				log.Info("newhash set already here", patch.PatchId, patch.NewHash)
-				continue
-			}
-			log.Infof("%s is new\n", patch.Filename)
-			repo := me.forge.FindByGoPath(patch.Namespace)
-			if repo == nil {
-				log.Info("\tCould not find namespace:", patch.Namespace)
-				continue
-			}
-			if fhelp.QuestionUser("apply this patch?") {
-				newhash, err := applyAndTrackPatch(repo, patch)
-				log.Info("apply results:", newhash, err)
-			}
-		}
-		return nil
-		/*
-			if newpatches.Len() != 0 {
-				for patch := range newpatches.IterAll() {
-					log.Info("new patch:", patch.CommitHash, patch.NewHash, patch.Filename)
-					repo := me.forge.FindByGoPath(patch.Namespace)
-					if repo == nil {
-						log.Info("\tCould not find namespace:", patch.Namespace)
-						continue
-					}
-				}
-				return log.Errorf("patches need to be applied")
-			}
-
-			// return doPatchList()
-			applied := findApplied()
-			if applied == nil || applied.Len() == 0 {
-				log.Info("no patches have been appled to the devel branch yet")
-				return nil
-			}
-			// for patch := range applied.IterAll() {
-			// 	log.Info("SEND APPLIED: newhash:", patch.NewHash, "commithash:", patch.CommitHash, "patch", patch.Namespace)
-			// }
-			newpb, _, err := applied.HttpPostVerbose(myServer(), "applied")
-			if err != nil {
-				return err
-			}
-			newpb.PrintTable()
-			return nil
-		*/
+		return doPatchList()
 	}
 
-	// if nothing, show patches & dirty repos
-	me.forge.Patchsets.PrintTable()
-	dumpWorkRepos()
-	return nil
-}
-
-// Shows repos that are:
-//   - git dirty repos
-//   - repos with 'user' branch patches not in 'devel' branch
-//   - repos with awaiting master branch verions
-//
-// return true if any are found
-func dumpWorkRepos() bool {
-	// always run dirty first
-	me.forge.CheckDirtyQuiet()
-
 	// if no option is given to patch, list out the
 	// repos that have patches ready in them
-	found := findReposWithPatches()
-	if found.Len() == 0 {
-		log.Info("you currently have no repos with patches")
-		return false
-	} else {
-		me.forge.PrintHumanTable(found)
+	findReposWithPatches()
+	if me.found.Len() == 0 {
+		log.Info("you currently have no patches in your user branches")
+		return nil
 	}
-	return true
+	me.forge.PrintHumanTable(me.found)
+	return nil
+}
+
+func doPatchList() error {
+	psets, err := openPatchsets()
+	if err != nil {
+		log.Info("Open Patchsets failed", err)
+		return err
+	}
+	log.Info("got psets len", len(psets.Patchsets))
+	all := psets.SortByName()
+	for all.Scan() {
+		pset := all.Next()
+		// log.Info("pset name =", pset.Name)
+		dumpPatchset(pset)
+	}
+	return nil
+}
+
+func savePatchsets(psets *forgepb.Patchsets) error {
+	data, err := psets.Marshal()
+	if err != nil {
+		log.Info("protobuf.Marshal() failed:", err)
+		return err
+	}
+	fullpath := filepath.Join(me.forge.GetConfigDir(), "patchsets.pb")
+	var pfile *os.File
+	pfile, err = os.OpenFile(fullpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		log.Info("Patchsets save failed:", err, fullpath)
+		return err
+	}
+	pfile.Write(data)
+	pfile.Close()
+	return nil
+}
+
+func openPatchsets() (*forgepb.Patchsets, error) {
+	fullpath := filepath.Join(me.forge.GetConfigDir(), "patchsets.pb")
+	data, err := os.ReadFile(fullpath)
+	if err != nil {
+		log.Info("Patchsets open failed:", err, fullpath)
+		return nil, err
+	}
+
+	psets := new(forgepb.Patchsets)
+	err = psets.Unmarshal(data)
+	if err != nil {
+		log.Info("Unmarshal patchsets failed", err)
+		return nil, err
+	}
+	return psets, nil
 }
 
 // returns bad if patches can not be applied
 // logic is not great here but it was a first pass
-func dumpPatchset(pset *forgepb.Set) bool {
+func dumpPatchset(pset *forgepb.Patchset) bool {
+
 	// don't even bother to continue if we already know it's broken
 	if pset.State == "BROKEN" {
 		log.Printf("Patchset Name: %-24s Author: %s <%s> IS BAD\n", pset.Name, pset.GetGitAuthorName(), pset.GetGitAuthorEmail())
@@ -216,6 +102,13 @@ func dumpPatchset(pset *forgepb.Set) bool {
 		log.Printf("Patchset Name: %-24s Author: %s <%s> IS GOOD\n", pset.Name, pset.GetGitAuthorName(), pset.GetGitAuthorEmail())
 	}
 
+	/*
+		log.Info("applyPatches() State", pset.State)
+		log.Info("applyPatches() COMMENT", pset.Comment)
+		log.Info("applyPatches() Branch Name", pset.GetStartBranchName())
+		log.Info("applyPatches() Start Hash", pset.GetStartBranchHash())
+	*/
+
 	var count int
 	var bad int
 	all := pset.Patches.SortByFilename()
@@ -246,12 +139,12 @@ func IsValidPatch(p *forgepb.Patch) bool {
 		log.Info("can not apply patch! repo not found", basepath, filename)
 		return false
 	}
-	if repo.ActualDevelHash() != p.StartHash {
+	if repo.DevelHash() != p.StartHash {
 		log.Info("can not apply patch! devel hash mismatch", basepath, filename)
 		return false
 	}
-	if repo.ActualDevelHash() == p.StartHash {
-		log.Info("local devel hash:", repo.ActualDevelHash(), "matches patch hash", p.StartHash, "and can be applied")
+	if repo.DevelHash() == p.StartHash {
+		log.Info("local devel hash:", repo.DevelHash(), "matches patch hash", p.StartHash, "and can be applied")
 	}
 	log.Info("start:", p.StartHash, "end:", p.CommitHash, "file:", basepath, filename, "devel version", repo.GetDevelVersion())
 	for _, line := range p.Files {
@@ -259,3 +152,25 @@ func IsValidPatch(p *forgepb.Patch) bool {
 	}
 	return true
 }
+
+func doPatchGet() error {
+	psets, err := me.forge.GetPatchesets()
+	if err != nil {
+		log.Info("Get Patchsets failed", err)
+		return err
+	}
+	log.Info("Got Patchsets ok", psets.Uuid)
+
+	log.Info("got psets len", len(psets.Patchsets))
+	all := psets.SortByName()
+	for all.Scan() {
+		pset := all.Next()
+		// log.Info("pset name =", pset.Name)
+		dumpPatchset(pset)
+	}
+
+	if err := savePatchsets(psets); err != nil {
+		return err
+	}
+	return nil
+}

doPull.go

@@ -7,58 +7,10 @@ import (
 	"time"
 
 	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-// is every repo on the devel branch?
-func doPull() error {
-	if argv.Pull.Check != nil {
-		// stats := me.forge.RillFuncError(rillPull)
-		log.Info("TODO: actually git pull here? this is a bad idea. stopping.")
-		submit := gitpb.NewRepos()
-		for repo := range me.forge.Repos.IterByFullPath() {
-			newrepo := new(gitpb.Repo)
-			newrepo.MasterHash = repo.MasterHash
-			newrepo.DevelHash = repo.DevelHash
-			newrepo.Namespace = repo.Namespace
-			newrepo.URL = repo.URL
-			submit.Append(newrepo)
-		}
-		updatepb, regPB, err := submit.HttpPost(myServer(), "check")
-		if regPB == nil || err != nil {
-			log.Info("regPB==nil or err:", err)
-			return nil
-		}
-		log.Infof("pull check %s pb.Len()=%d client.Len()=%d server.Len()=%d err=%v\n", regPB.URL, updatepb.Len(), regPB.ClientDataLen, regPB.ServerDataLen, err)
-		return nil
-	}
-
-	// below this, you must not be in 'normal' mode
-	if me.forge.Config.Mode == forgepb.ForgeMode_NORMAL {
-		log.Info("you must check out the devel or master branches")
-		return nil
-	}
-
-	if argv.Force == true {
-		now := time.Now()
-		stats := me.forge.RillFuncError(rillPull)
-		count := me.forge.RillReload()
-		if count != 0 {
-			me.forge.ConfigSave()
-		}
-
-		total, count, nope, _ := me.forge.IsEverythingOnMaster()
-		log.Printf("Master branch check. %d total repos. (%d git pulled) (%d not on master branch) (%s) git pull total=FIXME%d\n", total, count, nope, shell.FormatDuration(time.Since(now)), len(stats))
-		return nil
-	}
-
-	log.Info("do a pull check here?")
-	return nil
-
-}
-
 func rillPull(repo *gitpb.Repo) error {
 	if repo.IsDirty() {
 		// never do dirty repos
@@ -88,7 +40,47 @@ func rillPull(repo *gitpb.Repo) error {
 	return nil
 }
 
+// is every repo on the devel branch?
+
+func doGitPullNew() {
+	now := time.Now()
+	pullcount := me.forge.RillFuncError(rillPull)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+
+	total, count, nope, _ := IsEverythingOnMaster()
+	log.Printf("Master branch check. %d total repos. (%d git pulled) (%d not on master branch) (%s) git pull total=%d\n", total, count, nope, shell.FormatDuration(time.Since(now)), pullcount)
+}
+
 /*
+func doGitPull() {
+	allerr := me.found.RillGitPull(40, 5)
+
+	all := me.found.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		result := allerr[repo]
+		if result.Error == gitpb.ErrorGitPullOnDirty {
+			log.Info("skip git pull. repo is dirty", repo.GetGoPath())
+			continue
+		}
+		if result.Error == gitpb.ErrorGitPullOnLocal {
+			log.Info("skip git pull. local branch ", repo.GetGoPath())
+			continue
+		}
+		if result.Exit == 0 {
+			continue
+		}
+
+		log.Info("git pull error:", repo.GetGoPath(), result.Error)
+		log.Info("git pull error:", repo.GetGoPath(), result.Stdout)
+	}
+
+}
+*/
+
 // git fetch origin master:master
 func rillFetchMaster(repo *gitpb.Repo) error {
 	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
@@ -108,4 +100,3 @@ func doGitFetch() {
 		me.forge.ConfigSave()
 	}
 }
-*/

doSync.go

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// trys to figure out if there is still something to update
-
-/*
-func doSync() error {
-	if argv.Pull.Sync.Clean != nil {
-		return doSyncClean()
-	}
-	if argv.Pull.Sync.User != nil {
-		return doSyncUser()
-	}
-
-	return fmt.Errorf("nothing to do")
-}
-
-func doSyncClean() error {
-	log.Printf("todo: fix this?")
-	return nil
-}
-
-func doSyncUser() error {
-	me.forge.ConfigRill(10, 20)
-	if allerr := me.forge.RillRepos(syncDevelBranch); len(allerr) != 0 {
-		log.Info("RillFunc() failed", allerr)
-		return fmt.Errorf("Rill doSyncUser() error count = %d", len(allerr))
-	} else {
-		log.Info("Rill syncDevelBranch() ok count =", len(allerr))
-	}
-
-	argv.Force = true
-	if err := doAllCheckoutUser(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func syncDevelBranch(repo *gitpb.Repo) error {
-	branch := repo.GetDevelBranchName()
-	if repo.Exists(filepath.Join(".git/refs/heads", branch)) {
-		return nil
-	}
-	if repo.Exists(filepath.Join(".git/refs/remotes/origin", branch)) {
-		cmd := []string{"git", "checkout", branch}
-		err := repo.RunVerbose(cmd)
-		return err
-	}
-	cmd := []string{"git", "branch", branch}
-	repo.RunVerbose(cmd)
-	cmd = []string{"git", "checkout", branch}
-	err := repo.RunVerbose(cmd)
-	return err
-}
-
-func syncDevelBranches() error {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		branch := repo.GetDevelBranchName()
-		if repo.Exists(filepath.Join(".git/refs/heads", branch)) {
-			continue
-		}
-		if repo.Exists(filepath.Join(".git/refs/remotes/origin", branch)) {
-			cmd := []string{"git", "checkout", branch}
-			repo.RunVerbose(cmd)
-			continue
-		}
-		cmd := []string{"git", "branch", branch}
-		repo.RunVerbose(cmd)
-		cmd = []string{"git", "checkout", branch}
-		repo.RunVerbose(cmd)
-	}
-	return nil
-}
-*/

doTag.go

@@ -1,125 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// checks that repos are in a "normal" state
-
-import (
-	"os"
-	"path/filepath"
-	"time"
-
-	"go.wit.com/lib/fhelp"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func FindRepoByFullPath(wd string) *gitpb.Repo {
-	for repo := range me.forge.Repos.IterAll() {
-		if repo.FullPath == wd {
-			return repo
-		}
-	}
-	return nil
-}
-
-func findCurrentPwdRepoOrDie() *gitpb.Repo {
-	wd, err := os.Getwd()
-	repo := FindRepoByFullPath(wd)
-	if repo == nil {
-		log.Info("Could not find repo:", wd)
-		badExit(err)
-	}
-	return repo
-}
-
-func doTag() error {
-	wd, _ := os.Getwd()
-	if argv.Tag.List != nil {
-		repo := findCurrentPwdRepoOrDie()
-
-		tagTablePB := makeTagTablePB(repo, repo.Tags)
-		// tbox := win.Bottom.Box().SetProgName("TBOX")
-		// t.SetParent(tbox)
-		tagTablePB.MakeTable()
-		tagTablePB.PrintTable()
-		log.Info("list tags here", repo.Namespace)
-		return nil
-	}
-
-	if argv.Tag.Delete != "" {
-		repo := FindRepoByFullPath(wd)
-		if repo == nil {
-			log.Info("Could not find repo:", wd)
-			return nil
-		}
-
-		// check if the git tag already exists somehow
-		/*
-			if !repo.LocalTagExists(testtag) {
-				log.Info("Tag", testtag, "does not exist")
-				return log.Errorf("%s TAG DOES NOT EXIST %s", repo.FullPath, testtag)
-			}
-		*/
-		testtag := argv.Tag.Delete
-		if !argv.Force {
-			if !fhelp.QuestionUser(log.Sprintf("delete tag '%s'?", testtag)) {
-				return nil
-			}
-		}
-		log.Info("Delete tag here", testtag)
-
-		// delete local and remote tag
-		repo.RunVerbose([]string{"git", "tag", "--delete", testtag})
-		repo.RunVerbose([]string{"git", "push", "--delete", "origin", testtag})
-		return nil
-	}
-
-	log.Info("do other tag stuff here")
-	return nil
-}
-
-func makeTagTablePB(repo *gitpb.Repo, pb *gitpb.GitTags) *gitpb.GitTagsTable {
-	t := pb.NewTable("tagList")
-	t.NewUuid()
-
-	col := t.AddHash()
-	col.Width = 12
-
-	col = t.AddStringFunc("bashash", func(tag *gitpb.GitTag) string {
-		_, base := filepath.Split(tag.Refname)
-		cmd, err := repo.RunStrict([]string{"git", "log", "-1", base, "--format=%H"})
-		if err != nil {
-			return "err"
-		}
-		if len(cmd.Stdout) == 0 {
-			return ""
-		}
-		return cmd.Stdout[0]
-	})
-	col.Width = 12
-
-	col = t.AddTimeFunc("ctime", func(tag *gitpb.GitTag) time.Time {
-		// todo
-		return tag.Creatordate.AsTime()
-	})
-	col.Width = 4
-
-	col = t.AddTimeFunc("age", func(repo *gitpb.GitTag) time.Time {
-		// todo
-		return time.Now()
-	})
-	col.Width = 4
-
-	col = t.AddStringFunc("Ref Name", func(r *gitpb.GitTag) string {
-		_, ref := filepath.Split(r.GetRefname())
-		return ref
-	})
-	col.Width = 16
-
-	col = t.AddSubject()
-	col.Width = -1
-
-	return t
-}

doc.go

@@ -1,41 +0,0 @@
-/*
-forge -- a tool to manage lots of git repos. forge includes a GUI and TUI.
-
-	forge only executes the 'git' command. Everything it does, you can run by hand with 'git'.
-
-Options:
-
-	--debugger             open the debugger window
-	--logger               open the log.* control window
-	--gui GUI              select the plugin (andlabs,gocui,etc)
-	--gui-verbose          enable all logging
-	--bash                 generate bash completion
-	--bash                 generate bash completion
-	--connect CONNECT      forge url
-	--all                  git commit --all
-	--build BUILD          build a repo
-	--install INSTALL      install a repo
-	--forge-rebuild        download and rebuild forge
-	--force                try to strong arm things
-	--verbose              show more output
-	--help, -h             display this help and exit
-	--version              display version and exit
-
-Commands:
-
-	help                   New to forge? This is for you.'
-	checkout               switch branches using 'git checkout'
-	clean                  start over at the beginning
-	commit                 'git commit' but errors out if on wrong branch
-	config                 show your .config/forge/ settings
-	dirty                  show dirty git repos
-	fetch                  run 'git fetch master'
-	gui                    open the gui
-	list                   print a table of the current repos
-	merge                  merge branches
-	normal                 set every repo to the default state for software development
-	patch                  make patchsets
-	pull                   run 'git pull'
-	tag                    manage git tags
-*/
-package main

exit.go

@@ -6,28 +6,27 @@ package main
 import (
 	"os"
 
-	"go.wit.com/gui"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
 func okExit(thing string) {
-	gui.UnloadToolkits()
-	if configSave {
-		me.forge.SetConfigSave(configSave)
-	}
 	if thing != "" {
 		log.Info("forge exit:", thing, "ok")
 	}
+	if configSave {
+		me.forge.SetConfigSave(configSave)
+	}
+	// log.Info("Finished go-clean on", check.GetGoPath(), "ok")
 	me.forge.Exit()
 }
 
 func badExit(err error) {
-	log.Info("forge failed: ", err, me.forge.Config.ReposDir)
+	log.Info("forge failed: ", err, me.forge.GetGoSrc())
 	os.Exit(-1)
 }
 
 func badRepoExit(repo *gitpb.Repo, err error) {
-	log.Printf("%s FAILED: %v\n", repo.GetNamespace(), err)
+	log.Printf("forge failed on %s with %v\n", repo.GetGoPath(), err)
 	os.Exit(-1)
 }

find.go

@@ -0,0 +1,167 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"go.wit.com/lib/protobuf/gitpb"
+)
+
+// this populates a slice of protobuf records representing each git repo
+// var me.found []*gitpb.Repo
+//
+// so, it makes a subset of repos that are then used performing actions on
+//
+// by default, it adds every repo
+
+func (f *FindCmd) findRepos() *gitpb.Repos {
+	if f == nil {
+		findMine()
+		return me.found
+	}
+
+	if f.All {
+		findAll()
+		return me.found
+	}
+
+	if f.Private {
+		findPrivate()
+		return me.found
+	}
+
+	if f.Mine {
+		findMine()
+		return me.found
+	}
+
+	if f.Favorites {
+		findFavorites()
+		return me.found
+	}
+
+	if f.Dirty {
+		return findDirty()
+	}
+
+	if f.User {
+		findUser()
+		return me.found
+	}
+
+	findAll()
+	return me.found
+}
+
+func findPrivate() {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+
+		if me.forge.Config.IsPrivate(repo.GetGoPath()) {
+			me.found.AppendByGoPath(repo)
+		}
+	}
+}
+
+// finds repos that are writable
+func findMine() {
+	// log.Printf("get mine %s\n", me.forge.GetGoSrc())
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if me.forge.Config.IsWritable(repo.GetGoPath()) {
+			me.found.AppendByGoPath(repo)
+		}
+	}
+}
+
+// finds repos the user has marked as favorites in the forge .config
+func findFavorites() {
+	// log.Printf("get favorites %s\n", me.forge.GetGoSrc())
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if me.forge.Config.IsFavorite(repo.GetGoPath()) {
+			me.found.AppendByGoPath(repo)
+		}
+	}
+}
+
+// finds repos that git is reporting as dirty
+func findDirty() *gitpb.Repos {
+	found := gitpb.NewRepos()
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		var repo *gitpb.Repo
+		repo = all.Next()
+		if repo.IsDirty() {
+			found.AppendByGoPath(repo)
+		}
+	}
+	return found
+}
+
+func findAll() {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		me.found.AppendByGoPath(repo)
+	}
+}
+
+func findUser() {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if repo.GetCurrentBranchName() == repo.GetUserBranchName() {
+			me.found.AppendByGoPath(repo)
+		}
+	}
+}
+
+func findPublishable() {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if repo.GetTargetVersion() == "" {
+			continue
+		}
+		me.found.AppendByGoPath(repo)
+	}
+}
+
+func findReposWithPatches() {
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if repo.GetTargetVersion() != "" {
+			// add everything that has a target version set
+			me.found.AppendByGoPath(repo)
+			continue
+		}
+		if repo.IsDirty() {
+			// always add dirty branches
+			me.found.AppendByGoPath(repo)
+			continue
+		}
+		if repo.GetUserVersion() == "" || repo.GetUserVersion() == "uerr" {
+			// skip anything without a user branch
+			continue
+		}
+		if repo.GetUserVersion() != repo.GetDevelVersion() {
+			me.found.AppendByGoPath(repo)
+			continue
+		}
+
+		// this is an old test to see if the current 'last tag' is accurate and should be removed
+		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+			continue
+		}
+		if repo.GetLastTag() != repo.GetMasterVersion() {
+			me.found.AppendByGoPath(repo)
+			repo.FindLastTag()
+			continue
+		}
+	}
+}

helperPatches.go

@@ -1,340 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"strings"
-
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func makeReposTablePB(pb *gitpb.Repos) *gitpb.ReposTable {
-	t := pb.NewTable("quickListRepos")
-	t.NewUuid()
-
-	sf := t.AddStringFunc("Namespace", func(r *gitpb.Repo) string {
-		return r.GetNamespace()
-	})
-	sf.Width = 16
-
-	userVer := t.AddStringFunc("user", func(repo *gitpb.Repo) string {
-		ver := repo.GetUserVersion()
-		return ver
-	})
-	userVer.Width = 4
-	return t
-}
-
-/*
-type stdPatchsetTableWin struct {
-	sync.Mutex
-	win    *gadgets.GenericWindow  // the machines gui window
-	box    *gui.Node               // the machines gui parent box widget
-	TB     *forgepb.SetsTable // the gui table buffer
-	update bool                    // if the window should be updated
-}
-
-func (w *stdPatchsetTableWin) Toggle() {
-	if w == nil {
-		return
-	}
-	if w.win == nil {
-		return
-	}
-	w.win.Toggle()
-}
-*/
-
-/*
-	etimef := func(e *forgepb.Set) string {
-		etime := e.Etime.AsTime()
-		s := etime.Format("2006/01/02 15:04")
-		if strings.HasPrefix(s, "1970/") {
-			// just show a blank if it's not set
-			return ""
-		}
-		return s
-	}
-	t.AddStringFunc("etime", etimef)
-*/
-
-/*
-	ctimef := func(p *forgepb.Set) string {
-		ctime := p.Ctime.AsTime()
-		return ctime.Format("2006/01/02 15:04")
-	}
-}
-*/
-
-func setPatchsetState(p *forgepb.Set) {
-	var bad bool
-	var good bool
-	var done bool = true
-
-	all := p.Patches.All()
-	for all.Scan() {
-		patch := all.Next()
-		// log.Info("patch:", patch.StartHash, patch.CommitHash, patch.Namespace, patch.Filename)
-		repo := me.forge.FindByGoPath(patch.Namespace)
-		if repo == nil {
-			log.Info("could not find repo", patch.Namespace)
-			bad = true
-			continue
-		}
-		if _, err := repo.GetHashName(patch.CommitHash); err == nil {
-			// this patch has been applied
-			patch.Applied = true
-			done = true
-			continue
-		}
-		if name, err := repo.GetHashName(patch.StartHash); err == nil {
-			// it might be possible to apply this patch
-			log.Info("patch may be good:", patch.Namespace, name, patch.CommitHash, patch.Filename)
-			good = true
-		} else {
-			// probably screwed up git trees
-			log.Info("patch with unknown origin:", patch.Namespace, name, err, patch.CommitHash, patch.Filename)
-			bad = true
-		}
-	}
-	if bad {
-		p.State = "BAD"
-		return
-	}
-	if good {
-		p.State = "TRY"
-		return
-	}
-	if done {
-		p.State = "DONE"
-		return
-	}
-}
-
-func cleanSubject(line string) string {
-	// Regular expression to remove "Subject:" and "[PATCH...]" patterns
-	re := regexp.MustCompile(`(?i)^Subject:\s*(\[\s*PATCH[^\]]*\]\s*)?`)
-	cleaned := re.ReplaceAllString(line, "")
-	return strings.TrimSpace(cleaned)
-}
-
-// jcarr@framebook:~/go/src/go.wit.com/lib/protobuf/forgepb$ git branch --contains 4a27e7702b9b975b066ec9d2ee7ac932d86552e3
-// * jcarr
-// jcarr@framebook:~/go/src/go.wit.com/lib/protobuf/forgepb$ git merge-base --is-ancestor "4a27e7702b9b975b066ec9d2ee7ac932d86552e3" "devel" ; echo $?
-// 1
-// jcarr@framebook:~/go/src/go.wit.com/lib/protobuf/forgepb$ git merge-base --is-ancestor "4a27e7702b9b975b066ec9d2ee7ac932d86552e3" "jcarr" ; echo $?
-// 0
-
-func findCommitByHash(hash string, subject string) (string, error) {
-	cmd := exec.Command("git", "log", "--pretty=format:%H %s")
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	err := cmd.Run()
-	if err != nil {
-		return "", err
-	}
-
-	lines := strings.Split(out.String(), "\n")
-	for _, line := range lines {
-		if strings.Contains(strings.ToLower(line), strings.ToLower(subject)) {
-			return strings.Fields(line)[0], nil // return the commit hash
-		}
-		if strings.Fields(line)[0] == hash {
-			return "", fmt.Errorf("start commit found: %s", hash)
-		}
-	}
-	return "", fmt.Errorf("no commit found for subject: %s", subject)
-}
-
-func findCommitBySubject(subject string) (string, error) {
-	cmd := exec.Command("git", "log", "--pretty=format:%H %s", "--grep="+subject, "-i")
-	var out bytes.Buffer
-	cmd.Stdout = &out
-	err := cmd.Run()
-	if err != nil {
-		return "", err
-	}
-
-	lines := strings.Split(out.String(), "\n")
-	for _, line := range lines {
-		if strings.Contains(strings.ToLower(line), strings.ToLower(subject)) {
-			return strings.Fields(line)[0], nil // return the commit hash
-		}
-	}
-	return "", fmt.Errorf("no commit found for subject: %s", subject)
-}
-
-// returns true if PB changed
-func setNewCommitHash(patch *forgepb.Patch) error {
-	repo := me.forge.FindByGoPath(patch.Namespace)
-	if repo == nil {
-		return log.Errorf("could not find repo %s", patch.Namespace)
-	}
-
-	comment := cleanSubject(patch.Comment)
-
-	os.Chdir(repo.GetFullPath())
-	newhash, err := findCommitBySubject(comment)
-	if err != nil {
-		return log.Errorf("patch: not found hash: %s %s %s %s %v", patch.CommitHash, patch.Namespace, comment, newhash, err)
-	}
-
-	patchId, err := repo.FindPatchId(newhash)
-	if err != nil {
-		return err
-	}
-
-	patch.PatchId = patchId
-	patch.NewHash = newhash
-
-	log.Info("patch: found hash:", patch.CommitHash, newhash, patch.Namespace, comment)
-	return nil
-}
-
-func AddAllPatches(notdone *forgepb.Patches, pset *forgepb.Set, full bool) {
-	for patch := range pset.Patches.IterAll() {
-		comment := cleanSubject(patch.Comment)
-
-		if found := notdone.FindByCommitHash(patch.CommitHash); found != nil {
-			log.Info("duplicate commit hash", patch.Namespace, "patch:", patch.NewHash, "commithash:", patch.CommitHash, comment)
-			// continue
-		}
-
-		// log.Info("adding patch:", patch.Namespace, patch.CommitHash, comment, newhash)
-		notdone.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-	}
-}
-
-func AddNotDonePatches(notdone *forgepb.Patches, pset *forgepb.Set, full bool) {
-	for patch := range pset.Patches.IterAll() {
-		comment := cleanSubject(patch.Comment)
-
-		if found := notdone.FindByCommitHash(patch.CommitHash); found != nil {
-			log.Info("duplicate notdone", patch.Namespace, "patch:", patch.NewHash, "commithash:", patch.CommitHash, comment)
-			continue
-		}
-
-		repo := me.forge.FindByGoPath(patch.Namespace)
-		if repo == nil {
-			log.Info("could not find repo", patch.Namespace)
-			if full {
-				notdone.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-			}
-			continue
-		}
-
-		if patch.NewHash != "" {
-			log.Info("already applied patch", patch.Namespace, ": newhash:", patch.NewHash, "commithash:", patch.CommitHash, comment)
-			continue
-		}
-		os.Chdir(repo.GetFullPath())
-		newhash, err := findCommitByHash(patch.StartHash, comment)
-		if err != nil {
-			// this patch has not been applied yet
-			log.Info("patch: not found hash:", patch.Namespace, patch.CommitHash, comment, err)
-			notdone.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-			continue
-		}
-
-		newhash, err = findCommitBySubject(comment)
-		if err == nil {
-			patch.NewHash = newhash
-			log.Info("patch: found hash:", patch.Namespace, "commit patch", patch.CommitHash, "new hash", newhash, "start hash", patch.StartHash, comment)
-			continue
-		}
-
-		// this patch has not been applied yet
-		log.Info("patch: not found hash:", patch.Namespace, patch.CommitHash, comment, newhash, err)
-		notdone.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-	}
-}
-
-func findExpired() *forgepb.Patches {
-	var pset *forgepb.Patches
-	for found := range me.forge.Patchsets.IterAll() {
-		if found.Name == "forge auto commit" {
-			pset = found.Patches
-		}
-	}
-
-	if pset == nil {
-		log.Info("failed to find 'forge auto commit'")
-		return forgepb.NewPatches()
-	}
-
-	found := forgepb.NewPatches()
-
-	for patch := range pset.IterAll() {
-		comment := cleanSubject(patch.Comment)
-
-		repo := me.forge.FindByGoPath(patch.Namespace)
-		if repo == nil {
-			log.Info("could not find repo", patch.Namespace)
-			continue
-		}
-
-		if patch.NewHash != "" {
-			log.Info("already applied patch", patch.Namespace, ": newhash:", patch.NewHash, "commithash:", patch.CommitHash, comment)
-			found.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-			continue
-		}
-		os.Chdir(repo.GetFullPath())
-		_, err := findCommitByHash(patch.StartHash, comment)
-		if err == nil {
-			log.Info("found   applied patch", patch.Namespace, ": newhash:", patch.NewHash, "commithash:", patch.CommitHash, comment)
-			found.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-			continue
-		}
-		/*
-
-			newhash, err = findCommitBySubject(comment)
-			if err == nil {
-				patch.NewHash = newhash
-				log.Info("patch: found hash:", patch.Namespace, "commit patch", patch.CommitHash, "new hash", newhash, "start hash", patch.StartHash, comment)
-				found.AppendByCommitHash(patch) // double check to ensure the commit hash isn't added twice
-				continue
-			}
-		*/
-	}
-
-	return found
-}
-
-func findApplied() *forgepb.Patches {
-	var pset *forgepb.Patches
-	for found := range me.forge.Patchsets.IterAll() {
-		if found.Name == "forge auto commit" {
-			pset = found.Patches
-		}
-	}
-
-	if pset == nil {
-		log.Info("failed to find 'forge auto commit'")
-		return pset
-	}
-
-	found := forgepb.NewPatches()
-
-	for patch := range pset.IterAll() {
-		cmd := []string{"git", "merge-base", "--is-ancestor", patch.NewHash, "devel"}
-		repo := me.forge.Repos.FindByNamespace(patch.Namespace)
-		_, err := repo.RunStrict(cmd)
-		if err != nil {
-			// log.Info("NOT APPLIED", patch.Namespace, result, err)
-			// log.Info("NOT APPLIED newhash:", patch.NewHash, "commithash:", patch.CommitHash, "patch", patch.Namespace)
-		} else {
-			// log.Info("APPLIED newhash:", patch.NewHash, "commithash:", patch.CommitHash, "patch", patch.Namespace)
-			found.Append(patch)
-		}
-	}
-
-	return found
-}

main.go

@@ -7,9 +7,11 @@ package main
 
 import (
 	"embed"
+	"os"
 	"strings"
 
-	"go.wit.com/lib/gui/prep"
+	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/gui"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
@@ -41,18 +43,30 @@ func getVersion(repo *gitpb.Repo, name string) string {
 
 func main() {
 	me = new(mainType)
-	me.myGui = prep.Gui()       // prepares the GUI package for go-args
-	me.auto = prep.Bash3(&argv) // this line should be:  prep.Bash(&argv)
+	gui.InitArg()
+	me.pp = arg.MustParse(&argv)
 
-	// me.auto = prep.Bash3(argv.DoAutoComplete, &argv) // this line should be:  prep.Bash(&argv)
-	// arg.MustParse(&argv)                                      // these three lines are becoming terrible syntax
-	// me.auto = prep.MustParse(&argv)          // try to make this work?
+	if argv.Bash {
+		argv.doBash()
+		os.Exit(0)
+	}
+	if len(argv.BashAuto) != 0 {
+		argv.doBashAuto()
+		os.Exit(0)
+	}
+	me.urlbase = argv.URL
+	if me.urlbase == "" {
+		me.urlbase = "https://go.wit.com/"
+	}
+	if os.Getenv("FORGE_URL") != "" {
+		me.urlbase = os.Getenv("FORGE_URL")
+		log.Info("got forge url", me.urlbase)
+	}
+	me.urlbase = strings.Trim(me.urlbase, "/") // track down why trailing '/' makes http POST not work
 
-	me.forge = forgepb.Init() // init forge.pb
-	me.forge.ScanRepoDir()    // looks for new dirs, checks existing repos for changes
-
-	// initialize patches
-	doPatchInit()
+	// load the ~/.config/forge/ config
+	me.forge = forgepb.Init()
+	me.found = new(gitpb.Repos)
 
 	// first find the repos or gopaths to operate on
 	if argv.Config != nil {
@@ -65,11 +79,6 @@ func main() {
 		okExit("")
 	}
 
-	if argv.BuildForge {
-		buildForge()
-		okExit("")
-	}
-
 	if argv.Checkout != nil {
 		if err := doCheckout(); err != nil {
 			badExit(err)
@@ -92,6 +101,17 @@ func main() {
 	}
 
 	if argv.Clean != nil {
+		if argv.Clean.Repo != "" {
+			log.Info("only looking at repo:", argv.Clean.Repo)
+			okExit("")
+		}
+
+		if argv.Clean.GitReset != nil {
+			findAll() // select all the repos
+			doGitReset()
+			okExit("reset")
+		}
+
 		if err := doClean(); err != nil {
 			badExit(err)
 		}
@@ -99,81 +119,42 @@ func main() {
 		okExit("")
 	}
 
-	if argv.Help != nil {
-		doHelp()
-		okExit("")
-	}
-
 	if argv.Dirty != nil {
 		doDirty()
 		okExit("")
 	}
 
-	if argv.Tag != nil {
-		doTag()
-		okExit("")
-	}
-
-	if argv.Normal != nil {
-		if argv.Normal.On != nil {
-			if me.forge.Config.Mode == forgepb.ForgeMode_NORMAL {
-				log.Info("you are already in the normal state")
-				okExit("")
+	if argv.Show != "" {
+		repo := me.forge.FindByGoPath(argv.Show)
+		me.forge.HumanPrintRepo(repo)
+		// newt := repo.Times.LastUpdate.AsTime()
+		// oldt := repo.Times.MtimeHead.AsTime()
+		if repo.Times.LastUpdate == nil {
+			log.Info("SHOULD RUN Reload() here")
+			repo.Reload()
+			me.forge.HumanPrintRepo(repo)
+		} else {
+			if repo.Times.LastUpdate.Seconds < repo.Times.MtimeHead.Seconds {
+				log.Info("SHOULD RUN Reload() here")
 			}
-			setForgeMode(forgepb.ForgeMode_NORMAL)
-			log.Info("normal mode on")
-			okExit("")
-		}
-
-		if argv.Normal.Off != nil {
-			if me.forge.Config.Mode != forgepb.ForgeMode_NORMAL {
-				log.Info("you were aleady not in the normal state")
-				okExit("")
-			}
-			setForgeMode(forgepb.ForgeMode_DEVEL)
-			log.Info("normal mode off")
-			okExit("")
-		}
-
-		if doNormal() {
-			log.Infof("all %d repos are on your user branch. It is safe to write code now.\n", me.forge.Repos.Len())
-			if me.forge.Config.Mode != forgepb.ForgeMode_NORMAL {
-				log.Infof("Forge has set the mode to 'Normal'\n")
-				setForgeMode(forgepb.ForgeMode_NORMAL)
-			}
-			okExit("")
 		}
 		okExit("")
 	}
 
-	// if you are in "normal" mode, always run normal every time to catch accidental errors
-	// for example, if you accidentally changed branches from your user branch
-	if me.forge.Config.Mode == forgepb.ForgeMode_NORMAL {
-		if doNormal() {
-			log.Infof("all your %d repos are in a normal stete for development\n", me.forge.Repos.Len())
-		}
-	}
-
-	if argv.Merge != nil {
-		if err := doMerge(); err != nil {
-			badExit(err)
-		}
+	if argv.GitFetch != nil {
+		doGitFetch()
 		okExit("")
 	}
 
-	if argv.Pull != nil {
-		doPull()
+	if argv.GitPull != nil {
+		doGitPullNew()
 		okExit("")
 	}
 
 	if argv.List != nil {
 		found := argv.List.findRepos()
 		// print out the repos
-		if argv.List.Full {
-			me.forge.PrintHumanTableFull(found)
-		} else {
-			me.forge.PrintHumanTable(found)
-		}
+		me.forge.PrintHumanTable(found)
 		okExit("")
 	}
 
@@ -181,50 +162,29 @@ func main() {
 		if err := doPatch(); err != nil {
 			badExit(err)
 		}
+		okExit("patch list")
+	}
+
+	// todo: redo this logic using forgepb
+	if configSave {
+		me.forge.ConfigSave()
+		configSave = false
+	}
+
+	// if the user doesn't want to open the GUI and
+	// nothing else was specified to be done,
+	// then just list the table to stdout
+	if gui.NoGui() {
+		me.forge.PrintHumanTable(me.found)
 		okExit("")
 	}
 
 	// open the gui unless the user performed some other
 	// basically, if you run just 'forge' it should open the GUI
 
-	if argv.Gui != nil {
-		// if opening the GUI, always check git for dirty repos
-		me.forge.CheckDirty()
-
-		me.myGui.Start() // loads the GUI toolkit
-		doGui()          // start making our forge GUI
-		debug()          // sits here forever
-	}
-	// got to the end with nothing to do (?)
-	if dumpWorkRepos() {
-		// found some repos at least
-	} else {
-		// every repo is in a really clean state. no extra files anywhere
-		// no dirty repos, no repos that need to be published
-		// nothing different between user and master branch version. not common
-		log.Info("All of your git repositories appear to be in perfect shape")
-	}
-	okExit("")
-}
-
-// keep this small
-func doHelp() {
-	log.Info("")
-	log.Info("forge -h       : to see the available options")
-	log.Info("forge --bash   : will create a bash autocomplete file")
-	log.Info("forge          : with no arguements, forge tries to load a GO GUI plugin")
-	log.Info("               : there are two GUI plugins. terminal & GTK")
-	log.Info("")
-	log.Info("forge list     : shows a table of all your repos")
-	log.Info("forge checkout : checks out all your repos to the same branch")
-	log.Info("               : the default is your user branch")
-	log.Info("forge clean    : reverts all repos to the master branch")
-	log.Info("forge dirty    : show all repos git reports as dirty")
-	log.Info("")
-	okExit("")
-}
-
-func doHelpPatches() {
-	log.Info("TODO: ?")
+	// if opening the GUI, always check git for dirty repos
+	findAll() // select all the repos
+	doCheckDirtyAndConfigSave()
+	doGui()
 	okExit("")
 }

structs.go

@@ -4,10 +4,11 @@
 package main
 
 import (
+	"go.wit.com/dev/alexflint/arg"
 	"go.wit.com/gui"
 	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
 )
 
 var me *mainType
@@ -20,32 +21,63 @@ func (b *mainType) Enable() {
 	b.mainbox.Enable()
 }
 
-// returns the server to connect to
-func myServer() string {
-	return me.forge.GetForgeURL()
-}
-
 // this app's variables
 type mainType struct {
-	// pp         *arg.Parser    // for parsing the command line args.  Yay to alexflint!
-	auto       *prep.Auto     // more experiments for bash handling
+	pp         *arg.Parser    // for parsing the command line args.  Yay to alexf lint!
 	forge      *forgepb.Forge // for holding the forge protobuf files
-	myGui      *prep.GuiPrep  // for initializing the GUI toolkits
+	myGui      *gui.Node      // the gui toolkit handle
+	found      *gitpb.Repos   // stores the list of repos to process things on
 	foundPaths []string       // stores gopaths to act on (when doing go-clone)
 	configSave bool           // if the config file should be saved after finishing
 	urlbase    string         // base URL
 
-	mainWindow *gadgets.BasicWindow
-	mainbox    *gui.Node           // the main box. enable/disable this
-	autoDryRun *gui.Node           // checkbox for --dry-run
-	goSrcPwd   *gadgets.OneLiner   // what is being used as primary directory for your work
-	goSrcEdit  *gadgets.BasicEntry // what is being used as primary directory for your work
-	gitAuthor  *gadgets.OneLiner   // ENV GIT_AUTHOR NAME and EMAIL
+	// our view of the repositories
+	// patchWin *patchesWindow
 
-	// these hold the branches that the user can switch all the repositories to them
-	reposWinB       *gui.Node // button that opens the repos window
+	mainWindow *gadgets.BasicWindow
+
+	// the main box. enable/disable this
+	mainbox *gui.Node
+
+	// the window from the /lib/gui/gowit package
+	// lw *gadgets.BasicWindow
+
+	// #### Sorting options for the repolist
+	// autoHidePerfect  *gui.Node
+	// autoHideReadOnly *gui.Node
+
+	// checkbox for --dry-run
+	autoDryRun *gui.Node
+
+	// checkbox to enable intermittent scanning
+	// if checked, it will check all your repos for changes
+	autoScanReposCB *gui.Node
+
+	// what is being used as primary directory for your work
+	goSrcPwd *gadgets.OneLiner
+
+	// ENV GIT_AUTHOR NAME and EMAIL
+	gitAuthor *gadgets.OneLiner
+
+	// displays a summary of all the repos
+	// has total dirty, total read-only
+	// total patches, etc
+	// summary *patchSummary
+
+	// when switch to user or devel branches, autocreate them
+	autoCreateBranches *gui.Node
+
+	// these hold the branches that the user can switch all
+	// the repositories to them
+	newBranch       *gui.Node // deprecate?
+	setBranchB      *gui.Node // deprecate?
 	repoAllB        *gui.Node // "all" repos button
 	repoDirtyB      *gui.Node // "dirty" repos button
 	repoDevelMergeB *gui.Node // "merge to devel" repos button
 	repoWritableB   *gui.Node // "what repos are writable" repos button
+	demoB           *gui.Node // opens the demo
+
+	argvCheckoutUser   bool // shared between the GUI and the command line tools
+	argvCheckoutDevel  bool // shared between the GUI and the command line tools
+	argvCheckoutMaster bool // shared between the GUI and the command line tools
 }

windowForgePatchsets.go

@@ -0,0 +1,291 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+// this is the "main" patch window. The first one
+// then you can dig down and examine the patchsets and the files
+
+import (
+	"fmt"
+	"strconv"
+
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+
+	"go.wit.com/gui"
+)
+
+type patchesWindow struct {
+	win        *gadgets.BasicWindow // the patches window
+	stack      *gui.Node            // the top box set as vertical
+	grid       *gui.Node            // the list of available patches
+	reason     *gadgets.BasicEntry  // the name of the patchset
+	submitB    *gui.Node            // the submit patchet button
+	psetgrid   *gui.Node            // the list of each patchset
+	totalOL    *gadgets.OneLiner
+	dirtyOL    *gadgets.OneLiner
+	readonlyOL *gadgets.OneLiner
+	rw         *gadgets.OneLiner
+	// checkB     *gui.Node
+}
+
+func (r *patchesWindow) Hidden() bool {
+	return r.win.Hidden()
+}
+
+func (r *patchesWindow) Toggle() {
+	if r.Hidden() {
+		r.Show()
+	} else {
+		r.Hide()
+	}
+}
+
+func (r *patchesWindow) Show() {
+	r.win.Show()
+}
+
+func (r *patchesWindow) Hide() {
+	r.win.Hide()
+}
+
+// you can only have one of these
+func (r *patchesWindow) initWindow() {
+	r.win = gadgets.RawBasicWindow("Forge Patchesets")
+	r.win.Make()
+
+	r.stack = r.win.Box().NewBox("bw vbox", false)
+	// me.reposwin.Draw()
+	r.win.Custom = func() {
+		log.Warn("Patchset Window close. setting hidden=true")
+		// sets the hidden flag to false so Toggle() works
+		r.win.Hide()
+	}
+
+	r.grid = r.stack.RawGrid()
+	r.submitPatchesBox()
+
+	// update the stats about the repos and patches
+	r.Update()
+}
+
+func (r *patchesWindow) submitPatchesBox() {
+	// s := new(patchSummary)
+	group1 := r.stack.NewGroup("Repo Summary")
+	grid := group1.RawGrid()
+
+	// make the header table for repo stats
+	r.totalOL = gadgets.NewOneLiner(grid, "Total")
+	grid.NewButton("reset user branches", func() {
+		resetUserBranchesWindow()
+	})
+
+	grid.NextRow()
+	r.dirtyOL = gadgets.NewOneLiner(grid, "dirty")
+	grid.NextRow()
+	r.readonlyOL = gadgets.NewOneLiner(grid, "read-only")
+	grid.NextRow()
+	r.rw = gadgets.NewOneLiner(grid, "r/w")
+	grid.NextRow()
+
+	// now, make the 'widget group' and the buttons at the bottom of the window
+	group1 = r.stack.NewGroup("Patchset Create")
+	grid = group1.RawGrid()
+
+	grid.NewButton("show current patches", func() {
+		r.Update()
+		pset, err := me.forge.MakeDevelPatchSet("current patches")
+		if err != nil {
+			log.Info("patchset creation failed", err)
+			return
+		}
+		if pset == nil {
+			log.Info("you have no current patches")
+			return
+		}
+		win := makePatchWindow(pset)
+		win.Show()
+	})
+
+	r.reason = gadgets.NewBasicEntry(grid, "Patchset name:")
+	r.reason.Custom = func() {
+		if r.reason.String() != "" {
+			log.Info("Forge: enable submit")
+			r.submitB.Enable()
+		} else {
+			log.Info("Forge: disable submit")
+			r.submitB.Disable()
+		}
+	}
+	r.submitB = grid.NewButton("Submit", func() {
+		if r.submitB.IsEnabled() {
+			log.Info("submit button is enabled")
+		} else {
+			log.Info("submit button is disabled. BAD GUI TOOLKIT ERROR")
+			return
+		}
+		pset, err := me.forge.SubmitDevelPatchSet(r.reason.String())
+		if err != nil {
+			log.Info(err)
+			return
+		}
+		r.addPatchsetNew(pset)
+	})
+
+	psets, err := openPatchsets()
+	if err != nil {
+		log.Info("Open Patchsets failed", err)
+	}
+
+	grid.NewButton("Update Patchset List", func() {
+		psets, err = me.forge.GetPatchesets()
+		if err != nil {
+			log.Info("Get Patchsets failed", err)
+			return
+		}
+		savePatchsets(psets)
+
+		log.Info("got psets len", len(psets.Patchsets))
+		all := psets.SortByName()
+		for all.Scan() {
+			pset := all.Next()
+			r.addPatchsetNew(pset)
+		}
+	})
+
+	// disables the submit button until the user enters a name
+	r.submitB.Disable()
+	grid.NextRow()
+
+	g := r.stack.NewGroup("Patchset List")
+	// add the grid
+	r.psetgrid = g.RawGrid()
+
+	// will look in ~/.config/forge for an existing patchset file
+	// attempt to read in patchsets saved on disk
+
+	if psets != nil {
+		log.Info("got psets len", len(psets.Patchsets))
+		all := psets.SortByName()
+		for all.Scan() {
+			pset := all.Next()
+			// log.Info("pset name =", pset.Name)
+			r.addPatchsetNew(pset)
+		}
+	}
+}
+
+func (r *patchesWindow) addPatchsetNew(pset *forgepb.Patchset) {
+	var win *patchWindow
+	r.psetgrid.NewButton("View", func() {
+		// has the window already been created?
+		if win != nil {
+			win.Toggle()
+			return
+		}
+
+		win = makePatchWindow(pset)
+		win.Show()
+	})
+	r.psetgrid.NewLabel(pset.Name)
+	r.psetgrid.NewLabel(pset.Comment)
+	r.psetgrid.NewLabel(pset.GitAuthorName)
+	r.psetgrid.NewLabel(pset.Uuid)
+
+	ctime := pset.Ctime.AsTime()
+	stime := ctime.UTC().Format("2006-01-02_15:04:05_UTC")
+	r.psetgrid.NewLabel(stime)
+	if pset.State == "BROKEN" {
+		r.psetgrid.NewLabel("Bad")
+	} else {
+		r.psetgrid.NewLabel("Good")
+	}
+
+	r.psetgrid.NextRow()
+}
+
+// will update this from the current state of the protobuf
+func (r *patchesWindow) Update() {
+	var total, dirty, readonly, rw int
+
+	// figure out the totals
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		total += 1
+		if repo.IsDirty() {
+			dirty += 1
+		}
+		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+			readonly += 1
+		} else {
+			rw += 1
+		}
+	}
+
+	// send the values to the GUI toolkit
+	r.totalOL.SetText(strconv.Itoa(total) + " repos")
+	r.dirtyOL.SetText(strconv.Itoa(dirty) + " repos")
+	r.readonlyOL.SetText(strconv.Itoa(readonly) + " repos")
+	r.rw.SetText(fmt.Sprintf("%d repos", rw))
+}
+
+func resetUserBranchesWindow() {
+	found := gitpb.NewRepos()
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		uname := repo.GetUserBranchName()
+		dname := repo.GetDevelBranchName()
+		if repo.GetCurrentBranchName() == uname {
+			log.Info("Repo is on the user branch. Can't delete it.", repo.GetGoPath())
+			continue
+		}
+		b1 := repo.CountDiffObjects(uname, dname)
+		b2 := repo.CountDiffObjects(dname, uname)
+		log.Info("user vs devel count", b1, b2)
+		if b1 == 0 && b2 == 0 {
+			cmd := []string{"git", "branch", "-D", uname}
+			log.Info(repo.GetGoPath(), cmd)
+			repo.RunVerbose(cmd)
+			repo.Reload()
+			continue
+		}
+		found.Append(repo)
+
+	}
+
+	win := gadgets.RawBasicWindow("reset user branches")
+	win.Make()
+	win.Show()
+	win.Custom = func() {
+		// sets the hidden flag to false so Toggle() works
+		win.Hide()
+	}
+	box := win.Box().NewBox("bw vbox", false)
+
+	group := box.NewGroup("test buttons")
+	hbox := group.Box().Horizontal()
+	hbox.NewButton("force delete user branch", func() {
+		win.Disable()
+		defer win.Enable()
+		all := found.SortByFullPath()
+		for all.Scan() {
+			repo := all.Next()
+			brname := repo.GetUserBranchName()
+			cmd := []string{"git", "branch", "-D", brname}
+			log.Info(repo.GetGoPath(), cmd)
+			repo.RunVerbose(cmd)
+			repo.Reload()
+		}
+		me.forge.SetConfigSave(true)
+		me.forge.ConfigSave()
+	})
+
+	t := makeStandardReposGrid(found)
+	t.SetParent(box)
+	t.ShowTable()
+}

windowFound.go

@@ -0,0 +1,103 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+// shows a window of the 'found' repos
+
+import (
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+
+	"go.wit.com/gui"
+)
+
+type foundWindow struct {
+	win        *gadgets.BasicWindow // the patches window
+	stack      *gui.Node            // the top box set as vertical
+	grid       *gui.Node            // the list of available patches
+	reason     *gadgets.BasicEntry  // the name of the patchset
+	submitB    *gui.Node            // the submit patchet button
+	psetgrid   *gui.Node            // the list of each patchset
+	totalOL    *gadgets.OneLiner
+	dirtyOL    *gadgets.OneLiner
+	readonlyOL *gadgets.OneLiner
+	rw         *gadgets.OneLiner
+	// checkB     *gui.Node
+}
+
+func (r *foundWindow) Hidden() bool {
+	return r.win.Hidden()
+}
+
+func (r *foundWindow) Toggle() {
+	if r.Hidden() {
+		r.Show()
+	} else {
+		r.Hide()
+	}
+}
+
+func (r *foundWindow) Show() {
+	r.win.Show()
+}
+
+func (r *foundWindow) Hide() {
+	r.win.Hide()
+}
+
+// you can only have one of these
+func (r *foundWindow) initWindow() {
+	r.win = gadgets.RawBasicWindow("Found Repos")
+	r.win.Make()
+
+	r.stack = r.win.Box().NewBox("bw vbox", false)
+	// me.reposwin.Draw()
+	r.win.Custom = func() {
+		log.Warn("Found Window close. setting hidden=true")
+		// sets the hidden flag to false so Toggle() works
+		r.win.Hide()
+	}
+	group1 := r.stack.NewGroup("Repo Summary")
+	group1.NewButton("dirty", func() {
+		log.Info("find dirty here")
+		found := findDirty()
+		me.forge.PrintHumanTable(found)
+	})
+	group1.NewButton("all", func() {
+		log.Info("find all here")
+		me.found = new(gitpb.Repos)
+		findAll()
+		me.forge.PrintHumanTable(me.found)
+	})
+
+	r.grid = r.stack.RawGrid()
+
+	group1.NewButton("show", func() {
+		r.listRepos()
+	})
+}
+
+func (r *foundWindow) listRepos() {
+	all := me.found.All()
+	for all.Scan() {
+		repo := all.Next()
+		r.addRepo(repo)
+	}
+}
+
+func (r *foundWindow) addRepo(repo *gitpb.Repo) {
+	r.grid.NewButton("View", func() {
+	})
+	r.grid.NewLabel(repo.GetGoPath())
+	r.grid.NewLabel(repo.GetMasterVersion())
+	r.grid.NewLabel(repo.GetDevelVersion())
+	r.grid.NewLabel(repo.GetUserVersion())
+	r.grid.NewLabel(repo.GetCurrentBranchName())
+	r.grid.NextRow()
+}
+
+// will update this from the current state of the protobuf
+func (r *foundWindow) Update() {
+}

windowGeneric.go

@@ -0,0 +1,92 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/log"
+
+	"go.wit.com/gui"
+)
+
+type genericWindow struct {
+	win   *gadgets.BasicWindow // the window widget itself
+	box   *gui.Node            // the top box of the repolist window
+	group *gui.Node            // the default group
+}
+
+func (r *genericWindow) Hidden() bool {
+	if r == nil {
+		return true
+	}
+	if r.win == nil {
+		return true
+	}
+	return r.win.Hidden()
+}
+
+func (r *genericWindow) Toggle() {
+	if r.Hidden() {
+		r.Show()
+	} else {
+		r.Hide()
+	}
+}
+
+func (r *genericWindow) Show() {
+	if r == nil {
+		return
+	}
+	if r.win == nil {
+		return
+	}
+	r.win.Show()
+}
+
+func (r *genericWindow) Hide() {
+	if r == nil {
+		return
+	}
+	if r.win == nil {
+		return
+	}
+	r.win.Hide()
+}
+
+func (r *genericWindow) Disable() {
+	if r == nil {
+		return
+	}
+	if r.box == nil {
+		return
+	}
+	r.box.Disable()
+}
+
+func (r *genericWindow) Enable() {
+	if r == nil {
+		return
+	}
+	if r.box == nil {
+		return
+	}
+	r.box.Enable()
+}
+
+func initGenericWindow(title string, grouptxt string) *genericWindow {
+	gw := new(genericWindow)
+	gw.win = gadgets.RawBasicWindow(title)
+	gw.win.Make()
+
+	gw.box = gw.win.Box().Vertical() // a vertical box (like a stack of books)
+	gw.win.Custom = func() {
+		log.Warn("Found Window close. setting hidden=true")
+		// sets the hidden flag to false so Toggle() works
+		gw.win.Hide()
+	}
+	gw.group = gw.box.NewGroup(grouptxt)
+	gw.Show()
+
+	return gw
+}

windowHowto.go

@@ -6,22 +6,19 @@ package main
 // An app to submit patches for the 30 GO GUI repos
 
 import (
-	"os"
-
 	"go.wit.com/lib/fhelp"
-	"go.wit.com/lib/gadgets"
 	"go.wit.com/lib/gui/shell"
 	"go.wit.com/log"
 )
 
-func makeHowtoWin() *gadgets.GenericWindow {
-	howtoWin := gadgets.NewGenericWindow("Howto", "forge -- a GUI tool for git repostories")
+func makeHowtoWin() *genericWindow {
+	howtoWin := initGenericWindow("Howto", "forge -- a GUI tool for git repostories")
 	tmp := `A good way to see how forge works is to download forge
 
 	This will 'git clone' a few things (~50 repos):
 	`
-	howtoWin.Group.NewLabel(tmp)
-	grid := howtoWin.Group.RawGrid()
+	howtoWin.group.NewLabel(tmp)
+	grid := howtoWin.group.RawGrid()
 	grid.NewLabel("forge")
 	grid.NewLabel("the sources for forge")
 	grid.NextRow()
@@ -41,78 +38,64 @@ func makeHowtoWin() *gadgets.GenericWindow {
 	grid.NewLabel("") // a stupid way to add padding
 	grid.NextRow()
 
-	// howtoWin.Group.NewLabel("Working dir: " + me.forge.Config.ReposDir)
+	howtoWin.group.NewLabel("Working dir: " + me.forge.GetGoSrc())
+	grid = howtoWin.group.RawGrid()
+	grid.NewButton("Download", func() {
+		howtoWin.Disable()
+		defer howtoWin.Enable()
+		log.Info("download here")
+		if path, err := fhelp.CheckCmd("go-clone"); err != nil {
+			log.Info("go-clone missing", path, err)
+			cmd := []string{"go", "install", "go.wit.com/apps/go-clone@latest"}
+			shell.RunRealtime(cmd)
+		}
+		if _, err := fhelp.CheckCmd("autogenpb"); err != nil {
+			cmd := []string{"go", "install", "go.wit.com/apps/autogenpb@latest"}
+			shell.RunRealtime(cmd)
+		}
+		if _, err := fhelp.CheckCmd("go-mod-clean"); err != nil {
+			cmd := []string{"go", "install", "go.wit.com/apps/go-mod-clean@latest"}
+			shell.RunRealtime(cmd)
+		}
+		if path, err := fhelp.CheckCmd("go-clone"); err != nil {
+			log.Info("can't prep build. you probably need ~/go/bin in your PATH", path, err)
+			return
+		}
+		var basecmd []string
+		var cmd []string
+		if me.forge.IsGoWork() {
+			log.Info("NOT GO WORK")
+			basecmd = []string{"go-clone", "--work", "--recursive"}
+		} else {
+			log.Info("IS GO WORK")
+			basecmd = []string{"go-clone", "--recursive"}
+		}
+		// log.Info("Running:", cmd)
+		// shell.RunRealtime(cmd)
 
-	grid = howtoWin.Group.RawGrid()
-	grid.NewButton("Download into "+me.forge.Config.ReposDir, func() {
-		howtoWin.Disable()
-		defer howtoWin.Enable()
-		downloadForge()
-	})
-	grid.NewButton("Build forge & GUI GO plugins", func() {
-		howtoWin.Disable()
-		defer howtoWin.Enable()
-		buildForge()
+		cmd = append(basecmd, "go.wit.com/apps/go-mod-clean")
+		log.Info("Running:", cmd)
+		shell.RunRealtime(cmd)
+
+		cmd = append(basecmd, "go.wit.com/apps/forge")
+		log.Info("Running:", cmd)
+		shell.RunRealtime(cmd)
+
+		cmd = append(basecmd, "go.wit.com/toolkits/gocui")
+		log.Info("Running:", cmd)
+		shell.RunRealtime(cmd)
+
+		cmd = append(basecmd, "go.wit.com/toolkits/andlabs")
+		log.Info("Running:", cmd)
+		shell.RunRealtime(cmd)
+
+		// should, after go-clone, be able to go build
+		/*
+			repo := me.forge.FindByGoPath("go.wit.com/lib/proto/forgepb")
+			if repo != nil {
+				repo.RunVerbose([]string{"autogenpb"})
+			}
+		*/
 	})
 	return howtoWin
 }
-
-func downloadForge() {
-	log.Info("download here")
-	if path, err := fhelp.CheckCmd("go-clone"); err != nil {
-		log.Info("go-clone missing", path, err)
-		cmd := []string{"go", "install", "go.wit.com/apps/go-clone@latest"}
-		shell.RunRealtime(cmd)
-	}
-	if _, err := fhelp.CheckCmd("autogenpb"); err != nil {
-		cmd := []string{"go", "install", "go.wit.com/apps/autogenpb@latest"}
-		shell.RunRealtime(cmd)
-	}
-	if _, err := fhelp.CheckCmd("go-mod-clean"); err != nil {
-		cmd := []string{"go", "install", "go.wit.com/apps/go-mod-clean@latest"}
-		shell.RunRealtime(cmd)
-	}
-	if path, err := fhelp.CheckCmd("go-clone"); err != nil {
-		log.Info("can't prep build. you probably need ~/go/bin in your PATH", path, err)
-		return
-	}
-	var basecmd []string
-	var cmd []string
-	if me.forge.IsGoWork() {
-		log.Info("Using go.work directory")
-		basecmd = []string{"go-clone", "--work", "--recursive"}
-	} else {
-		basecmd = []string{"go-clone", "--recursive"}
-	}
-	// log.Info("Running:", cmd)
-	// shell.RunRealtime(cmd)
-
-	cmd = append(basecmd, "go.wit.com/apps/go-mod-clean")
-	log.Info("Running:", cmd)
-	shell.RunRealtime(cmd)
-	os.Exit(-1)
-
-	cmd = append(basecmd, "go.wit.com/apps/forge")
-	log.Info("Running:", cmd)
-	shell.RunRealtime(cmd)
-
-	cmd = append(basecmd, "go.wit.com/toolkits/gocui")
-	log.Info("Running:", cmd)
-	shell.RunRealtime(cmd)
-
-	cmd = append(basecmd, "go.wit.com/toolkits/andlabs")
-	log.Info("Running:", cmd)
-	shell.RunRealtime(cmd)
-
-	// should, after go-clone, be able to go build
-	/*
-		repo := me.forge.FindByGoPath("go.wit.com/lib/proto/forgepb")
-		if repo != nil {
-			repo.RunVerbose([]string{"autogenpb"})
-		}
-	*/
-}
-
-func buildForge() {
-	log.Info("buildForge() not done yet")
-}

windowPatches.go

@@ -1,217 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync"
-
-	"go.wit.com/gui"
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-type stdPatchTableWin struct {
-	sync.Mutex
-	win    *gadgets.GenericWindow // the machines gui window
-	box    *gui.Node              // the machines gui parent box widget
-	TB     *forgepb.PatchesTable  // the gui table buffer
-	update bool                   // if the window should be updated
-}
-
-func (w *stdPatchTableWin) Toggle() {
-	if w == nil {
-		return
-	}
-	if w.win == nil {
-		return
-	}
-	w.win.Toggle()
-}
-
-func makePatchesWin(patches *forgepb.Patches) *stdPatchTableWin {
-	dwin := new(stdPatchTableWin)
-	dwin.win = gadgets.NewGenericWindow("current patches", "patching options")
-	dwin.win.Custom = func() {
-		log.Info("test delete window here")
-		dwin.win.Hide()
-		// dwin = nil
-	}
-	grid := dwin.win.Group.RawGrid()
-
-	grid.NewLabel(fmt.Sprintf("%d", patches.Len()))
-	grid.NewLabel(fmt.Sprintf("total patches"))
-	grid.NextRow()
-
-	repomap := make(map[string]int)
-	all := patches.All()
-	for all.Scan() {
-		patch := all.Next()
-		repomap[patch.Namespace] += 1
-	}
-	grid.NewLabel(fmt.Sprintf("%d", len(repomap)))
-	grid.NewLabel(fmt.Sprintf("total repos"))
-	grid.NextRow()
-
-	grid.NewButton("Apply All", func() {
-		var count int
-		all := patches.SortByFilename()
-		for all.Scan() {
-			p := all.Next()
-			applyPatchNew(p)
-		}
-		log.Info("ALL PATCHES WORKED! count =", count)
-	})
-
-	// make a box at the bottom of the window for the protobuf table
-	dwin.box = dwin.win.Bottom.Box().SetProgName("TBOX")
-
-	if patches != nil {
-		dwin.doPatchesTable(patches)
-	}
-
-	return dwin
-}
-
-func applyPatchNew(p *forgepb.Patch) error {
-	rn := p.Namespace
-	repo := me.forge.FindByGoPath(rn)
-	if repo == nil {
-		log.Info("Could not figure out repo path", rn)
-		return log.Errorf("%s namespace?\n", rn)
-	}
-	if _, err := applyAndTrackPatch(repo, p); err != nil {
-		cmd := []string{"git", "am", "--abort"}
-		err := repo.RunVerbose(cmd)
-		log.Info("warn user of git am error", err)
-		return err
-	}
-	return nil
-}
-
-func (dwin *stdPatchTableWin) doPatchesTable(currentPatches *forgepb.Patches) {
-	dwin.Lock()
-	defer dwin.Unlock()
-	if dwin.TB != nil {
-		dwin.TB.Delete()
-		dwin.TB = nil
-	}
-
-	// display the protobuf
-	dwin.TB = AddPatchesPB(dwin.box, currentPatches)
-	f := func(p *forgepb.Patch) {
-		log.Info("do something with patch", p.Filename)
-	}
-	dwin.TB.Custom(f)
-}
-
-// used by the PB table
-func applyPatchLabel(p *forgepb.Patch) string {
-	rn := p.Namespace
-	if repo := me.forge.FindByGoPath(rn); repo == nil {
-		// log.Info("Could not figure out repo path", rn)
-		return ""
-	}
-	if p.NewHash == "" {
-		return "git am"
-	}
-	return "done"
-}
-
-func applyPatchClick(p *forgepb.Patch) {
-	if err := applyPatchNew(p); err != nil {
-		log.Info("git am failed on file", p.Filename, "with error", err)
-		return
-	}
-	log.Info("ran: git am", p.Filename, "ok")
-}
-
-// define what rows to have in the protobuf table
-func AddPatchesPB(tbox *gui.Node, pb *forgepb.Patches) *forgepb.PatchesTable {
-	t := pb.NewTable("PatchesPB")
-	t.NewUuid()
-	t.SetParent(tbox)
-
-	gitam := t.AddButtonFunc("apply", applyPatchLabel)
-	gitam.Custom = applyPatchClick
-
-	t.AddCommitHash()
-	t.AddNamespace()
-	// t.AddFilename()
-	t.AddStringFunc("file", func(p *forgepb.Patch) string {
-		_, fname := filepath.Split(p.Filename)
-		return fname
-	})
-	t.AddCommitHash()
-
-	t.ShowTable()
-	return t
-}
-
-func applyPatch(repo *gitpb.Repo, filename string) error {
-	cmd := []string{"git", "am", filename}
-	err := repo.RunVerbose(cmd)
-	return err
-}
-
-func savePatch(p *forgepb.Patch) (string, error) {
-	_, filen := filepath.Split(p.Filename)
-	tmpname := filepath.Join("/tmp", filen)
-	log.Info("saving as", tmpname, p.Filename)
-	raw, err := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	if err != nil {
-		return "", err
-	}
-	raw.Write(p.Data)
-	raw.Close()
-
-	return tmpname, nil
-}
-
-func applyAndTrackPatch(repo *gitpb.Repo, p *forgepb.Patch) (string, error) {
-	_, filen := filepath.Split(p.Filename)
-	tmpname := filepath.Join("/tmp", filen)
-	log.Info("saving as", tmpname, p.Filename)
-	raw, err := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	if err != nil {
-		return "", err
-	}
-	raw.Write(p.Data)
-	raw.Close()
-
-	cmd := []string{"git", "am", tmpname}
-	err = repo.RunVerbose(cmd)
-	if err != nil {
-		log.Info("git am failed. run 'git am --abort' here")
-		return "", log.Errorf("git am failed")
-	}
-
-	log.Info("Try to find hash value now")
-
-	p.NewHash = "fixme applyAndTrack"
-	if setNewHash(p, p.NewHash) {
-		log.Info("setting NewHash worked", p.NewHash)
-	}
-	me.forge.SavePatchsets()
-
-	return p.NewHash, log.Errorf("did not lookup new hash")
-}
-
-func setNewHash(p *forgepb.Patch, hash string) bool {
-	for pset := range me.forge.Patchsets.IterAll() {
-		for patch := range pset.Patches.IterAll() {
-			if patch.CommitHash == hash {
-				patch.NewHash = hash
-				log.Info("found patch in repo")
-				me.forge.SavePatchsets()
-				return true
-			}
-		}
-	}
-	return false
-}

windowPatchset.go

@@ -0,0 +1,281 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+
+	"go.wit.com/gui"
+)
+
+type patchWindow struct {
+	once  sync.Once            // only init() the window once
+	win   *gadgets.BasicWindow // the patches window
+	stack *gui.Node            // the top box set as vertical
+	shelf *gui.Node            // the first box in the stack, set as horizontal
+	grid  *gui.Node            // the list of available patches
+	// summary *patchSummary        // summary of current patches
+	setgrid *gui.Node         // the list of each patchset
+	pset    *forgepb.Patchset // the patchset in question
+}
+
+// todo: autogenerate these or make them standared 'gui' package functions
+// make this an go interface somehow
+
+// is the window hidden right now?
+func (w *patchWindow) Hidden() bool {
+	return w.win.Hidden()
+}
+
+// switches between the window being visable or hidden on the desktop
+func (w *patchWindow) Toggle() {
+	if w.Hidden() {
+		w.Show()
+	} else {
+		w.Hide()
+	}
+}
+
+// hides the window completely
+func (w *patchWindow) Show() {
+	w.win.Show()
+}
+
+func (w *patchWindow) Hide() {
+	w.win.Hide()
+}
+
+// should be the first box/widget in the window
+// greys out the window to the user
+func (w *patchWindow) Disable() {
+	w.stack.Disable()
+}
+
+func (w *patchWindow) Enable() {
+	w.stack.Enable()
+}
+
+// you can only have one of these
+func makePatchWindow(pset *forgepb.Patchset) *patchWindow {
+	pw := new(patchWindow)
+
+	// sync.Once()
+	pw.win = gadgets.RawBasicWindow("Patcheset for " + pset.Name + " (" + pset.Comment + ")")
+	pw.win.Make()
+
+	pw.stack = pw.win.Box().NewBox("bw vbox", false)
+	// me.reposwin.Draw()
+	pw.win.Custom = func() {
+		// sets the hidden flag to false so Toggle() works
+		pw.win.Hide()
+	}
+
+	grid := pw.stack.NewGrid("", 0, 0)
+
+	grid.NewLabel("Patchset Details:")
+	grid.NewLabel(pset.GitAuthorName)
+	grid.NewLabel(pset.GitAuthorEmail)
+	grid.NewLabel("start branch: " + pset.StartBranchName)
+	grid.NewLabel(pset.StartBranchHash)
+	grid.NewLabel("end branch: " + pset.EndBranchName)
+	grid.NewLabel(pset.EndBranchHash)
+	grid.NewButton("Apply All", func() {
+		var count int
+		all := pset.Patches.SortByFilename()
+		for all.Scan() {
+			p := all.Next()
+			rn := p.RepoNamespace
+			repo := me.forge.FindByGoPath(rn)
+			if repo == nil {
+				log.Info("Could not figure out repo path", rn)
+				return
+			}
+			filename, err := savePatch(p)
+			if err != nil {
+				log.Info("savePatch() failed", err)
+				return
+			}
+			count += 1
+			if err := applyPatch(repo, filename); err != nil {
+				log.Info("warn user of git am error", err)
+				return
+			}
+		}
+		log.Info("ALL PATCHES WORKED! count =", count)
+	})
+	grid.NextRow()
+
+	g := pw.stack.NewGroup("PatchSet List")
+
+	// make a grid to put the list of git repos that have patches
+	// in this particular patchset
+	grid = g.NewGrid("", 0, 0)
+	grid.NewLabel("repo")
+	grid.NewLabel("patch name")
+	grid.NewLabel("Applied in current branch?")
+	grid.NewLabel("start hash")
+	grid.NewLabel("")
+	/*
+		grid.NewButton("Extract", func() {
+			if err := savePatchset(pset); err != nil {
+				log.Info("Save err:", err)
+				return
+			}
+		})
+			grid.NewButton("Apply with git am", func() {
+				if _, _, _, err := IsEverythingOnUser(); err != nil {
+					log.Info("You can only apply patches to the user branch")
+					return
+				}
+				if IsAnythingDirty() {
+					log.Info("You can't apply patches when repos are dirty")
+					me.forge.PrintHumanTable(me.found)
+					return
+				}
+				if argv.Force {
+					applyPatchset(pset)
+				}
+			})
+	*/
+	grid.NextRow()
+
+	// add the patches to the grid
+	pw.addPatchset(grid, pset)
+	return pw
+}
+
+func (r *patchWindow) addPatchset(grid *gui.Node, pset *forgepb.Patchset) {
+	/*
+		repomap := make(map[*gitpb.Repo][]*forgepb.Patch)
+		repohash := make(map[*gitpb.Repo]string)
+
+		// sort patches by repo namespace
+		all := pset.Patches.SortByFilename()
+		for all.Scan() {
+			p := all.Next()
+			s := p.RepoNamespace
+			repo := me.forge.FindByGoPath(s)
+			if repo == nil {
+				log.Info("Could not figure out repo path", s)
+				continue
+			}
+			repomap[repo] = append(repomap[repo], p)
+			repohash[repo] = p.StartHash
+		}
+	*/
+
+	all := pset.Patches.SortByFilename()
+	for all.Scan() {
+		p := all.Next()
+		// for repo, patches := range repomap {
+		rn := p.RepoNamespace
+		repo := me.forge.FindByGoPath(rn)
+		if repo == nil {
+			log.Info("Could not figure out repo path", rn)
+			rn += " bad repo"
+		}
+		log.Info("Adding patches for", rn)
+		grid.NewLabel(rn)
+
+		/*
+			for i, p := range patches {
+				log.Info(i, p.Filename)
+				grid.NewLabel(p.Comment)
+				grid.NewLabel("in current branch?")
+				break
+			}
+		*/
+		// hash := repohash[repo]
+		grid.NewLabel(p.StartHash)
+		grid.NewLabel(p.Filename)
+
+		if repo == nil {
+			continue
+		}
+		// var win *repoPatchWindow
+		grid.NewButton("apply", func() {
+			filename, _ := savePatch(p)
+			if err := applyPatch(repo, filename); err != nil {
+				log.Info("warn user of git am error", err)
+			}
+			// win = makeRepoPatchWindow(repo, p)
+			// win.Show()
+		})
+		grid.NewCheckbox("").SetChecked(true)
+		grid.NewCheckbox("").SetChecked(true)
+		grid.NewButton("save patch to /tmp", func() {
+			savePatch(p)
+			// for _, pat := range patches {
+			// }
+		})
+		/*
+			grid.NewButton("view hash", func() {
+				cmd := []string{"git", "whatchanged", hash}
+				log.Info(repo.GetFullPath(), cmd)
+			})
+			grid.NewButton("git am", func() {
+				cmd := []string{"git", "whatchanged", hash}
+				log.Info(repo.GetFullPath(), cmd)
+			})
+		*/
+		grid.NextRow()
+	}
+}
+
+func applyPatch(repo *gitpb.Repo, filename string) error {
+	cmd := []string{"git", "am", filename}
+	err := repo.RunVerbose(cmd)
+	return err
+}
+
+func savePatch(p *forgepb.Patch) (string, error) {
+	_, filen := filepath.Split(p.Filename)
+	tmpname := filepath.Join("/tmp", filen)
+	log.Info("saving as", tmpname, p.Filename)
+	raw, err := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return "", err
+	}
+	raw.Write(p.Data)
+	raw.Close()
+
+	return tmpname, nil
+}
+
+// saves the patches in ~/.config/forge/currentpatches/
+func savePatchset(pset *forgepb.Patchset) error {
+	log.Info("savePatches() NAME", pset.Name)
+	log.Info("savePatches() COMMENT", pset.Comment)
+	log.Info("savePatches() GIT_AUTHOR_NAME", pset.GetGitAuthorName())
+	log.Info("savePatches() GIT_AUTHOR_EMAIL", pset.GetGitAuthorEmail())
+	log.Info("savePatches() Branch Name", pset.GetStartBranchName())
+	log.Info("savePatches() Start Hash", pset.GetStartBranchHash())
+
+	var count int
+	var bad int
+	var lasterr error
+	all := pset.Patches.SortByFilename()
+	for all.Scan() {
+		p := all.Next()
+		basedir := filepath.Join(os.Getenv("FORGE_CONFIG"), "currentpatches")
+		if fullname, err := savePatchFile(p, basedir); err != nil {
+			log.Info(fullname, "save failed", err)
+			bad += 1
+			lasterr = err
+		}
+		count += 1
+	}
+	log.Info("pset has", count, "total patches, ", bad, "bad save patches")
+	if bad == 0 {
+		return lasterr
+	}
+	return nil
+}

windowPublish.go

@@ -1,42 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// An app to submit patches for the 30 GO GUI repos
-
-import (
-	"go.wit.com/lib/gadgets"
-)
-
-// Publish Window
-func makePublishWindow() *gadgets.GenericWindow {
-	pubWin := gadgets.NewGenericWindow("publish code", "tasks for merging, versioning and publishing code")
-
-	grid := pubWin.Group.RawGrid()
-
-	grid.NewButton("merge all patches to master", func() {
-		/*
-			pubWin.Disable()
-			defer pubWin.Enable()
-
-			if err := doAllCheckoutDevel(); err != nil {
-				log.Info("checkout error:", err)
-			} else {
-				log.Info("checkout was ok")
-			}
-
-			mergeUserToDevel(true)
-
-			if err := doAllCheckoutMaster(); err != nil {
-				log.Info("checkout error:", err)
-			} else {
-				log.Info("checkout was ok")
-			}
-
-			mergeDevelToMaster(true)
-		*/
-	})
-
-	return pubWin
-}

windowRepoProblems.go

@@ -0,0 +1,271 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"sync"
+
+	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+
+	"go.wit.com/gui"
+)
+
+type repoProblemsWindow struct {
+	once  sync.Once            // only init() the window once
+	win   *gadgets.BasicWindow // the patches window
+	stack *gui.Node            // the top box set as vertical
+	shelf *gui.Node            // the first box in the stack, set as horizontal
+	grid  *gui.Node            // the list of available patches
+	// summary *patchSummary        // summary of current patches
+	setgrid *gui.Node         // the list of each patchset
+	pset    *forgepb.Patchset // the patchset in question
+}
+
+// todo: autogenerate these or make them standared 'gui' package functions
+// make this an go interface somehow
+
+// is the window hidden right now?
+func (w *repoProblemsWindow) Hidden() bool {
+	return w.win.Hidden()
+}
+
+// switches between the window being visable or hidden on the desktop
+func (w *repoProblemsWindow) Toggle() {
+	if w.Hidden() {
+		w.Show()
+	} else {
+		w.Hide()
+	}
+}
+
+// hides the window completely
+func (w *repoProblemsWindow) Show() {
+	w.win.Show()
+}
+
+func (w *repoProblemsWindow) Hide() {
+	w.win.Hide()
+}
+
+// should be the first box/widget in the window
+// greys out the window to the user
+func (w *repoProblemsWindow) Disable() {
+	w.stack.Disable()
+}
+
+func (w *repoProblemsWindow) Enable() {
+	w.stack.Enable()
+}
+
+// you can only have one of these
+func makeRepoProblemsWindow() *repoProblemsWindow {
+	pw := new(repoProblemsWindow)
+
+	// sync.Once()
+	pw.win = gadgets.RawBasicWindow("Potential Repo Problems")
+	pw.win.Make()
+	pw.win.Show()
+
+	pw.stack = pw.win.Box().NewBox("bw vbox", false)
+	pw.win.Custom = func() {
+		// sets the hidden flag to false so Toggle() works
+		pw.win.Hide()
+	}
+	pw.stack.NewGroup("things (these don't work yet)")
+
+	grid := pw.stack.RawGrid()
+	var found *gitpb.Repos
+	var txt string
+
+	found = develBehindMasterProblem()
+	txt = fmt.Sprintf("devel is behind master (%d)", found.Len())
+	grid.NewButton(txt, func() {
+		win := gadgets.RawBasicWindow("devel branches that are out of sync with master")
+		win.Make()
+		win.Show()
+		win.Custom = func() {
+			// sets the hidden flag to false so Toggle() works
+			win.Hide()
+		}
+		box := win.Box().NewBox("bw vbox", false)
+
+		found := develBehindMasterProblem()
+		group := box.NewGroup("test buttons")
+		hbox := group.Box().Horizontal()
+		hbox.NewButton("git merge master devel", func() {
+			all := found.SortByFullPath()
+			for all.Scan() {
+				repo := all.Next()
+				mname := repo.GetMasterBranchName()
+				dname := repo.GetDevelBranchName()
+				if dname != repo.GetCurrentBranchName() {
+					log.Info("Repo is not on the devel branch", repo.GetGoPath())
+				}
+				cmd := []string{"git", "merge", mname}
+				log.Info(repo.GetGoPath(), cmd)
+				repo.RunVerbose(cmd)
+			}
+		})
+		hbox.NewButton("test", func() {
+		})
+
+		t := makeStandardReposGrid(found)
+		t.SetParent(box)
+		t.ShowTable()
+	})
+
+	found = remoteUserBranchProblem()
+	txt = fmt.Sprintf("user branch is remote (%d)", found.Len())
+	grid.NewButton(txt, func() {
+		win := gadgets.RawBasicWindow("repos that seem to have remote user branches")
+		win.Make()
+		win.Show()
+		win.Custom = func() {
+			// sets the hidden flag to false so Toggle() works
+			win.Hide()
+		}
+		box := win.Box().NewBox("bw vbox", false)
+
+		found := remoteUserBranchProblem()
+		group := box.NewGroup("test buttons")
+		hbox := group.Box().Horizontal()
+		hbox.NewButton("git branch delete", func() {
+			win.Disable()
+			defer win.Enable()
+			all := found.SortByFullPath()
+			for all.Scan() {
+				repo := all.Next()
+				brname := repo.GetUserBranchName()
+				// git push origin --delete jcarr
+				os.Setenv("GIT_TERMINAL_PROMPT", "0")
+				cmd := []string{"git", "push", "origin", "--delete", brname}
+				log.Info("You may want to run:", repo.GetGoPath(), cmd)
+				repo.RunVerbose(cmd)
+				os.Unsetenv("GIT_TERMINAL_PROMPT")
+
+				// git branch --delete --remote origin/jcarr
+				cmd = []string{"git", "branch", "--delete", "--remote", "origin/" + brname}
+				log.Info(repo.GetGoPath(), cmd)
+				repo.RunVerbose(cmd)
+				repo.Reload()
+			}
+			me.forge.SetConfigSave(true)
+			me.forge.ConfigSave()
+		})
+
+		t := makeStandardReposGrid(found)
+		t.SetParent(box)
+		t.ShowTable()
+	})
+
+	grid.NewButton("unknown branches", func() {
+		log.Info("not done yet")
+	})
+	grid.NextRow()
+
+	found = develRemoteProblem()
+	txt = fmt.Sprintf("remote devel != local devel (%d)", found.Len())
+	grid.NewButton(txt, func() {
+		found := develRemoteProblem()
+		makeStandardReposWindow(txt, found)
+	})
+
+	found = masterRemoteProblem()
+	txt = fmt.Sprintf("remote master != local master (%d)", found.Len())
+	grid.NewButton(txt, func() {
+		found := masterRemoteProblem()
+		makeStandardReposWindow(txt, found)
+	})
+	grid.NextRow()
+
+	return pw
+}
+
+func develBehindMasterProblem() *gitpb.Repos {
+	log.Info("not done yet")
+	found := new(gitpb.Repos)
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		if repo.GetDevelVersion() == repo.GetMasterVersion() {
+			continue
+		}
+		found.AppendByGoPath(repo)
+
+	}
+	return found
+}
+
+func remoteUserBranchProblem() *gitpb.Repos {
+	found := new(gitpb.Repos)
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		username := repo.GetUserBranchName()
+		if repo.IsBranchRemote(username) {
+			found.AppendByGoPath(repo)
+		}
+
+	}
+	return found
+}
+
+func develRemoteProblem() *gitpb.Repos {
+	found := new(gitpb.Repos)
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		brname := repo.GetDevelBranchName()
+		if !repo.IsBranchRemote(brname) {
+			// log.Info("repo does not have remote devel branch", repo.GetGoPath())
+			continue
+		}
+		lhash := repo.GetLocalHash(brname)
+		rhash := repo.GetRemoteHash(brname)
+		// log.Info(lhash, rhash, repo.GetGoPath())
+		if lhash == "" || rhash == "" {
+			// something is wrong if either of these are blank
+			found.AppendByGoPath(repo)
+			continue
+		}
+		if lhash == rhash {
+			continue
+		}
+		found.AppendByGoPath(repo)
+
+	}
+	return found
+}
+
+func masterRemoteProblem() *gitpb.Repos {
+	found := new(gitpb.Repos)
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		brname := repo.GetMasterBranchName()
+		if !repo.IsBranchRemote(brname) {
+			// log.Info("repo does not have remote devel branch", repo.GetGoPath())
+			continue
+		}
+		lhash := repo.GetLocalHash(brname)
+		rhash := repo.GetRemoteHash(brname)
+		// log.Info(lhash, rhash, repo.GetGoPath())
+		if lhash == "" || rhash == "" {
+			// something is wrong if either of these are blank
+			found.AppendByGoPath(repo)
+			continue
+		}
+		if lhash == rhash {
+			continue
+		}
+		found.AppendByGoPath(repo)
+
+	}
+	return found
+}

windowReposFix.go

@@ -1,393 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// An app to submit patches for the 30 GO GUI repos
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"go.wit.com/lib/debugger"
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func makeReposWin() *stdReposTableWin {
-	rwin := new(stdReposTableWin)
-	win := gadgets.NewGenericWindow("find errors and try to fix them", "types of errors of some sort or another")
-	rwin.win = win
-	grid := win.Group.RawGrid()
-
-	// win.Top.NewGroup("misc (works in progress)")
-
-	// grid = win.Top.RawGrid()
-	grid = win.Group.RawGrid()
-	var found *gitpb.Repos
-	var txt string
-
-	found = develBehindMasterProblem()
-	txt = fmt.Sprintf("devel is behind master (%d)", found.Len())
-	grid.NewButton(txt, func() {
-		win := gadgets.RawBasicWindow("devel branches that are out of sync with master")
-		win.Make()
-		win.Show()
-		win.Custom = func() {
-			// sets the hidden flag to false so Toggle() works
-			win.Hide()
-		}
-		box := win.Box().NewBox("bw vbox", false)
-
-		found := develBehindMasterProblem()
-		group := box.NewGroup("test buttons")
-		hbox := group.Box().Horizontal()
-		hbox.NewButton("git merge master devel", func() {
-			all := found.SortByFullPath()
-			for all.Scan() {
-				repo := all.Next()
-				mname := repo.GetMasterBranchName()
-				dname := repo.GetDevelBranchName()
-				if dname != repo.GetCurrentBranchName() {
-					log.Info("Repo is not on the devel branch", repo.GetGoPath())
-				}
-				cmd := []string{"git", "merge", mname}
-				log.Info(repo.GetGoPath(), cmd)
-				repo.RunVerbose(cmd)
-			}
-		})
-		hbox.NewButton("test", func() {
-		})
-
-		t := makeDevelBehindMaster(found)
-		t.SetParent(box)
-		t.ShowTable()
-	})
-
-	found = remoteUserBranchProblem()
-	txt = fmt.Sprintf("user branch is remote (%d)", found.Len())
-	grid.NewButton(txt, func() {
-		win := gadgets.RawBasicWindow("repos that seem to have remote user branches")
-		win.Make()
-		win.Show()
-		win.Custom = func() {
-			// sets the hidden flag to false so Toggle() works
-			win.Hide()
-		}
-		box := win.Box().NewBox("bw vbox", false)
-
-		found := remoteUserBranchProblem()
-		group := box.NewGroup("test buttons")
-		hbox := group.Box().Horizontal()
-		hbox.NewButton("git branch delete", func() {
-			win.Disable()
-			defer win.Enable()
-			all := found.SortByFullPath()
-			for all.Scan() {
-				repo := all.Next()
-				brname := repo.GetUserBranchName()
-				// git push origin --delete jcarr
-				os.Setenv("GIT_TERMINAL_PROMPT", "0")
-				cmd := []string{"git", "push", "origin", "--delete", brname}
-				log.Info("You may want to run:", repo.GetGoPath(), cmd)
-				repo.RunVerbose(cmd)
-				os.Unsetenv("GIT_TERMINAL_PROMPT")
-
-				// git branch --delete --remote origin/jcarr
-				cmd = []string{"git", "branch", "--delete", "--remote", "origin/" + brname}
-				log.Info(repo.GetGoPath(), cmd)
-				repo.RunVerbose(cmd)
-				repo.ReloadCheck()
-			}
-			me.forge.SetConfigSave(true)
-			me.forge.ConfigSave()
-		})
-
-		t := makeStandardReposGrid(found)
-		t.SetParent(box)
-		t.ShowTable()
-	})
-
-	rwin.boxTB = win.Bottom.Box()
-
-	grid.NextRow()
-
-	found = develRemoteProblem()
-	txt = fmt.Sprintf("remote devel != local devel (%d)", found.Len())
-	grid.NewButton(txt, func() {
-		found := develRemoteProblem()
-		makeStandardReposWindow(txt, found)
-	})
-
-	found = masterRemoteProblem()
-	txt = fmt.Sprintf("remote master != local master (%d)", found.Len())
-	grid.NewButton(txt, func() {
-		found := masterRemoteProblem()
-		makeStandardReposWindow(txt, found)
-	})
-	grid.NextRow()
-
-	makeHackModeWindow(rwin)
-	return rwin
-}
-
-// table of devel errors behind master
-func makeDevelBehindMaster(pb *gitpb.Repos) *gitpb.ReposTable {
-	t := pb.NewTable("testDirty")
-	t.NewUuid()
-	sf := t.AddStringFunc("repo", func(r *gitpb.Repo) string {
-		return r.GetGoPath()
-	})
-	sf.Custom = func(r *gitpb.Repo) {
-		log.Info("merge master into devel here", r.GetGoPath())
-	}
-	t.AddTimeFunc("age", func(repo *gitpb.Repo) time.Time {
-		return repo.NewestTime()
-	})
-	t.AddMasterVersion()
-	t.AddDevelVersion()
-	t.AddState()
-	return t
-}
-
-// default window for active running droplets
-func (rwin *stdReposTableWin) doReposTable(pb *gitpb.Repos) {
-	rwin.Lock()
-	defer rwin.Unlock()
-	if rwin.TB != nil {
-		rwin.TB.Delete()
-		rwin.TB = nil
-	}
-
-	rwin.pb = pb
-
-	t := makeStandardReposGrid(pb)
-	t.SetParent(rwin.boxTB)
-	t.ShowTable()
-	rwin.TB = t
-}
-
-func makeHackModeWindow(stdwin *stdReposTableWin) {
-	group := stdwin.win.Top.NewGroup("This is a work in progress")
-	grid := group.RawGrid()
-	grid.NewButton("git pull", func() {
-		log.Info("todo: run git pull on each repo")
-	})
-
-	me.repoDevelMergeB = grid.NewButton("merge", func() {
-		found := findMergeToDevel()
-		_, box := makeStandardReposWindow("repos to merge from user to devel", found)
-		hbox := box.Box().Horizontal()
-		hbox.NewButton("merge all", func() {
-			stdwin.win.Disable()
-			defer stdwin.win.Enable()
-			all := found.SortByFullPath()
-			for all.Scan() {
-				repo := all.Next()
-				if repo.CheckDirty() {
-					log.Info("repo is dirty", repo.GetGoPath())
-					continue
-				}
-				log.Info("Starting merge on", repo.GetGoPath())
-				if repo.CheckoutDevel() {
-					log.Info("checkout devel failed", repo.GetGoPath())
-					return
-				}
-				if _, err := repo.MergeToDevel(); err != nil {
-					log.Info("merge from user failed", repo.GetGoPath(), err)
-					// log.Info(strings.Join(r.Stdout, "\n"))
-					// log.Info(strings.Join(r.Stderr, "\n"))
-					return
-				}
-				if repo.CheckoutMaster() {
-					log.Info("checkout master failed", repo.GetGoPath())
-					return
-				}
-				if _, err := repo.MergeToMaster(); err != nil {
-					log.Info("merge from devel failed", repo.GetGoPath(), err)
-					return
-				}
-
-			}
-		})
-	})
-	grid.NextRow()
-
-	group2 := stdwin.win.Top.NewGroup("Merge")
-	grid = group2.RawGrid()
-
-	/*
-		grid.NewButton("merge to devel", func() {
-			stdwin.win.Disable()
-			defer stdwin.win.Enable()
-
-			mergeUserToDevel(true)
-		})
-
-		grid.NewButton("merge to master", func() {
-			stdwin.win.Disable()
-			defer stdwin.win.Enable()
-
-			mergeDevelToMaster(true)
-		})
-
-		grid.NewButton("merge all", func() {
-			stdwin.win.Disable()
-			defer stdwin.win.Enable()
-
-			if err := doAllCheckoutDevel(); err != nil {
-				log.Info("checkout error:", err)
-			} else {
-				log.Info("checkout was ok")
-			}
-
-			mergeUserToDevel(true)
-
-			if err := doAllCheckoutMaster(); err != nil {
-				log.Info("checkout error:", err)
-			} else {
-				log.Info("checkout was ok")
-			}
-
-			mergeDevelToMaster(true)
-		})
-	*/
-
-	grid.NewButton("show dirty repos on win.Bottom", func() {
-		log.Info("try to show dirty repos on bottom")
-		found := me.forge.FindDirty()
-		stdwin.doReposTable(found)
-	})
-
-	group3 := stdwin.win.Top.NewGroup("work in progress")
-	grid = group3.RawGrid()
-
-	grid.NewButton("forge ConfigSave()", func() {
-		me.forge.ConfigSave()
-	})
-
-	grid.NewButton("debugger()", func() {
-		debugger.DebugWindow()
-	})
-}
-
-func develBehindMasterProblem() *gitpb.Repos {
-	found := new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if repo.GetDevelVersion() == repo.GetMasterVersion() {
-			continue
-		}
-		found.AppendByFullPath(repo)
-
-	}
-	return found
-}
-
-func remoteUserBranchProblem() *gitpb.Repos {
-	found := new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		username := repo.GetUserBranchName()
-		if repo.IsBranchRemote(username) {
-			found.AppendByFullPath(repo)
-		}
-
-	}
-	return found
-}
-
-func develRemoteProblem() *gitpb.Repos {
-	found := new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		brname := repo.GetDevelBranchName()
-		if !repo.IsBranchRemote(brname) {
-			// log.Info("repo does not have remote devel branch", repo.GetGoPath())
-			continue
-		}
-		lhash := repo.GetLocalHash(brname)
-		rhash := repo.GetRemoteHash(brname)
-		// log.Info(lhash, rhash, repo.GetGoPath())
-		if lhash == "" || rhash == "" {
-			// something is wrong if either of these are blank
-			found.AppendByFullPath(repo)
-			continue
-		}
-		if lhash == rhash {
-			continue
-		}
-		found.AppendByFullPath(repo)
-
-	}
-	return found
-}
-
-func masterRemoteProblem() *gitpb.Repos {
-	found := new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		brname := repo.GetMasterBranchName()
-		if !repo.IsBranchRemote(brname) {
-			// log.Info("repo does not have remote devel branch", repo.GetGoPath())
-			continue
-		}
-		lhash := repo.GetLocalHash(brname)
-		rhash := repo.GetRemoteHash(brname)
-		// log.Info(lhash, rhash, repo.GetGoPath())
-		if lhash == "" || rhash == "" {
-			// something is wrong if either of these are blank
-			found.AppendByFullPath(repo)
-			continue
-		}
-		if lhash == rhash {
-			continue
-		}
-		found.AppendByFullPath(repo)
-
-	}
-	return found
-}
-
-func makeWritableWindow(pb *gitpb.Repos) (*gadgets.GenericWindow, *gitpb.ReposTable) {
-	win := gadgets.NewGenericWindow("Repos You have write access to", "Configure")
-	t := pb.NewTable("testForgeRepos")
-	t.NewUuid()
-
-	grid := win.Group.RawGrid()
-	grid.NewButton("git pull", func() {
-		log.Info("todo: run git pull on each repo")
-	})
-
-	/*
-		grid.NewButton("do repos.ReScan()", func() {
-			t.Update()
-		})
-	*/
-
-	tbox := win.Bottom.Box()
-	t.SetParent(tbox)
-
-	sf := t.AddStringFunc("repo", func(r *gitpb.Repo) string {
-		return r.GetGoPath()
-	})
-	sf.Custom = func(r *gitpb.Repo) {
-		log.Info("do button click on", r.GetGoPath())
-	}
-	t.AddTimeFunc("age", func(repo *gitpb.Repo) time.Time {
-		return repo.NewestTime()
-	})
-	t.AddMasterVersion()
-	t.AddDevelVersion()
-	t.AddUserVersion()
-	t.AddCurrentBranchName()
-	t.AddState()
-	t.ShowTable()
-	return win, t
-}

windowReposNew.go

@@ -1,185 +0,0 @@
-// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
-// Use of this source code is governed by the GPL 3.0
-
-package main
-
-// An app to submit patches for the 30 GO GUI repos
-
-import (
-	"sync"
-	"time"
-
-	"go.wit.com/gui"
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-type stdReposTableWin struct {
-	sync.Mutex
-	win    *gadgets.GenericWindow // the machines gui window
-	boxTB  *gui.Node              // the machines gui parent box widget
-	TB     *gitpb.ReposTable      // the gui table buffer
-	pb     *gitpb.Repos           // the current repos protobuf
-	update bool                   // if the window should be updated
-}
-
-func (w *stdReposTableWin) Toggle() {
-	if w == nil {
-		return
-	}
-	if w.win == nil {
-		return
-	}
-	w.win.Toggle()
-}
-
-func makeWindowForPB() *gadgets.GenericWindow {
-	win := gadgets.NewGenericWindow("Forge Repos Protobuf View", "Display Git Repositories")
-
-	return win
-}
-
-func makeReposWinNew() *gadgets.GenericWindow {
-	insertWin := makeWindowForPB()
-	insertWin.Win.Custom = func() {
-		log.Info("test delete window here")
-	}
-	grid := insertWin.Group.RawGrid()
-
-	var t *gitpb.ReposTable
-	grid.NewButton("dirty", func() {
-		if t != nil {
-			t.Delete()
-			t = nil
-		}
-		found := me.forge.FindDirty()
-
-		// display the protobuf
-		t = addWindowPB(insertWin, found)
-		f := func(repo *gitpb.Repo) {
-			log.Info("got to ReposTable.Custom() id =", repo.GetGoPath(), repo.GetCurrentVersion())
-		}
-		t.Custom(f)
-		log.Info("table has uuid", t.GetUuid())
-	})
-
-	grid.NewButton("to publish", func() {
-		if t != nil {
-			t.Delete()
-			t = nil
-		}
-		found := findReposWithPatches()
-		me.forge.PrintHumanTable(found)
-
-		// make the window for the first time
-		t = addWindowPB(insertWin, found)
-		f := func(repo *gitpb.Repo) {
-			log.Info("got to ReposTable.Custom() id =", repo.GetGoPath(), repo.GetCurrentVersion())
-		}
-		t.Custom(f)
-		log.Info("table has uuid", t.GetUuid())
-	})
-
-	grid.NewButton("favorites", func() {
-		if t != nil {
-			t.Delete()
-			t = nil
-		}
-		found := new(gitpb.Repos)
-		all := me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			if !me.forge.Config.IsFavorite(repo.GetGoPath()) {
-				continue
-			}
-			found.AppendByFullPath(repo)
-		}
-
-		// make the window for the first time
-		t = addWindowPB(insertWin, found)
-		f := func(repo *gitpb.Repo) {
-			log.Info("got to ReposTable.Custom() id =", repo.GetGoPath(), repo.GetCurrentVersion())
-		}
-		t.Custom(f)
-		log.Info("table has uuid", t.GetUuid())
-	})
-
-	grid.NewButton("writeable", func() {
-		if t != nil {
-			t.Delete()
-			t = nil
-		}
-		found := new(gitpb.Repos)
-		all := me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-				continue
-			}
-			found.AppendByFullPath(repo)
-		}
-
-		// make the window for the first time
-		t = addWindowPB(insertWin, found)
-		f := func(repo *gitpb.Repo) {
-			log.Info("got to ReposTable.Custom() id =", repo.GetGoPath(), repo.GetCurrentVersion())
-		}
-		t.Custom(f)
-		log.Info("table has uuid", t.GetUuid())
-	})
-
-	grid.NewButton("all", func() {
-		if t != nil {
-			t.Delete()
-			t = nil
-		}
-		found := new(gitpb.Repos)
-		all := me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			found.AppendByFullPath(repo)
-
-		}
-		// display the protobuf
-		t = addWindowPB(insertWin, found)
-		f := func(repo *gitpb.Repo) {
-			log.Info("got to ReposTable.Custom() id =", repo.GetGoPath(), repo.GetCurrentVersion())
-		}
-		t.Custom(f)
-		log.Info("table has uuid", t.GetUuid())
-	})
-
-	return insertWin
-}
-
-func addWindowPB(win *gadgets.GenericWindow, pb *gitpb.Repos) *gitpb.ReposTable {
-	t := pb.NewTable("testForgeRepos")
-	t.NewUuid()
-	tbox := win.Bottom.Box().SetProgName("TBOX")
-	t.SetParent(tbox)
-
-	sf := t.AddStringFunc("repo", func(r *gitpb.Repo) string {
-		return r.GetGoPath()
-	})
-	sf.Custom = func(r *gitpb.Repo) {
-		log.Info("do button click on", r.GetGoPath())
-	}
-	t.AddTimeFunc("age", func(repo *gitpb.Repo) time.Time {
-		return repo.NewestTime()
-	})
-	t.AddMasterVersion()
-	// hmm := t.AddMasterVersion()
-	// hmm.SetTitle("Master")
-	t.AddDevelVersion()
-	t.AddUserVersion()
-	t.AddCurrentBranchName()
-	t.AddState()
-	f := func(repo *gitpb.Repo) string {
-		log.Info("repo =", repo.GetGoPath(), repo.GetCurrentVersion())
-		return repo.GetGoPath()
-	}
-	t.AddButtonFunc("cur version", f)
-	t.ShowTable()
-	return t
-}

windowViewRepoPatches.go

@@ -21,8 +21,8 @@ type repoPatchWindow struct {
 	shelf *gui.Node            // the first box in the stack, set as horizontal
 	grid  *gui.Node            // the list of available patches
 	// summary *patchSummary        // summary of current patches
-	setgrid *gui.Node    // the list of each patchset
-	pset    *forgepb.Set // the patchset in question
+	setgrid *gui.Node         // the list of each patchset
+	pset    *forgepb.Patchset // the patchset in question
 }
 
 // todo: autogenerate these or make them standared 'gui' package functions
@@ -109,7 +109,7 @@ func makeRepoPatchWindow(repo *gitpb.Repo, fset []*forgepb.Patch) *repoPatchWind
 	return pw
 }
 
-func (r *repoPatchWindow) addPatchset(grid *gui.Node, pset *forgepb.Set) {
+func (r *repoPatchWindow) addPatchset(grid *gui.Node, pset *forgepb.Patchset) {
 	repomap := make(map[*gitpb.Repo][]*forgepb.Patch)
 	repohash := make(map[*gitpb.Repo]string)
 
@@ -117,7 +117,7 @@ func (r *repoPatchWindow) addPatchset(grid *gui.Node, pset *forgepb.Set) {
 	all := pset.Patches.SortByFilename()
 	for all.Scan() {
 		p := all.Next()
-		s := p.Namespace
+		s := p.RepoNamespace
 		repo := me.forge.FindByGoPath(s)
 		if repo == nil {
 			log.Info("COULD NOT FIND", s)