apply patches

unfortunately, this was a bad idea. boo
	I wasted lots of time on this. live and learn

.gitignore

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

Makefile

@@ -1,24 +1,52 @@
 VERSION = $(shell git describe --tags)
-BUILDTIME = $(shell date +%Y.%m.%d)
+BUILDTIME = $(shell date +%Y.%m.%d_%H%M)
 
-all:
+# make build     # go build   using your git cloned repos (GO111MODULE=off)
-	make private
+# make install   # go install using your git cloned repos (GO111MODULE=off)
-	@echo "make restart   # remove the repos.pb file"
+# make gocui     # try the ncurses gui plugin
-	@echo "make private   # only the private ones"
+# make andlabs   # try the andlabs gui plugin (uses GTK)
-	@echo "make mine      # just show my repos"
+
-	@echo "make pull      # run git pull on every repo"
+default: install-verbose tag
+
+tag:
+	forge tag list
 
 vet:
 	@GO111MODULE=off go vet
 	@echo this go binary package builds okay
 
-verbose:
+build: goimports vet plugin
-	GO111MODULE=off go build -v -x \
+	GO111MODULE=off go build \
 		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
 
-install: goimports vet
+install: goimports 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}"
+
+install-raw: goimports vet plugin
+	go install \
+		-ldflags "-X main.VERSION=${VERSION} -X main.BUILDTIME=${BUILDTIME} -X gui.GUIVERSION=${VERSION}"
+
+plugin:
+	rm -f resources/*.so
+	# -cp ../../toolkits/gocui/gocui.so resources/
+
+GTK: clean install
+	forge --gui andlabs
+
+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
 
 goimports:
 	reset
@@ -26,55 +54,33 @@ goimports:
 	@# // to globally reset paths:
 	@# // gofmt -w -r '"go.wit.com/gui/gadgets" -> "go.wit.com/lib/gadgets"' *.go
 
-gocui: install
+clean:
-	forge --gui gocui
+	-rm -f forge go.*
+	# -rm -f ~/go/src/repos.pb
+	go-mod-clean purge
 
-redomod-all:
+identify-protobuf:
-	forge --do-RedoGoMod
+	autogenpb --identify ~/go/src/repos.pb
 
-redomod-erase:
+devel:
-	forge --do-RedoGoMod --do-erase
+	forge clean devel --force --verbose
-
-private: install
-	forge --find-private
-
-fix: install
-	forge --fix --find-all
-
-list-all: install
-	forge --find-all
-
-git-reset: install
-	forge --do-git-reset --find-all
-
-readonly: install
-	forge --do-list --find-readonly
-
-config: install
-	forge --config
-
-scan: install
-	forge --do-scan
 
 pull: install
-	forge --do-git-pull
+	FORGE_URL="https://forge.grid.wit.com/" forge pull check
 
-mine: install
+# cloudflare blocks POST due to captcha checks / human detection?
-	forge --find-mine
+# POST must be direct socket. probably for the best anyway
+submit:
+	FORGE_URL="https://forge.grid.wit.com/" forge patch submit "forge auto commit"
 
-gui: install
+commit:
-	forge --do-gui
+	FORGE_URL="https://forge.grid.wit.com/" forge commit --all
 
-patches: install
+check: install
-	forge --do-patches
+	FORGE_URL="https://forge.grid.wit.com/" forge patch check
 
-patches-localhost: install
+doc:
-	forge --do-patches --url "http://localhost:2233/"
+	echo "/*" > doc.go
-
+	forge -h >> doc.go
-patches-list: install
+	echo "*/" >> doc.go
-	forge --list-patches --url "http://localhost:2233/"
+	echo "package main" >> doc.go
-
-restart:
-	reset
-	rm ~/go/src/repos.pb
-	make private

README.md

@@ -0,0 +1,79 @@
+# 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
+
+* Scans directories looking for git repositories
+* The default behavior is to use 3 branches. 'master or main', 'devel', '<username>'
+* shows tags and dirty state
+* 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
+
+```
+# 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)
+
+cd go.wit.com/lib/protobuf/forgepb
+make                                            # autogenpb will make .pb.go, marshal.pb.go and sort.pb.go files
+cd go.wit.com/lib/protobuf/gitpb
+make                                            # autogenpb will make .pb.go, marshal.pb.go and sort.pb.go files
+
+cd go.wit.com/apps/forge
+make                        # this runs GO111MODULE=off go build insuring that your using only your git sources
+
+```
+
+## 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

@@ -0,0 +1,48 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+/*
+// 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())
+}
+*/
+
+/*
+// From 18ee541f89be2e9f9a91c54873da87885e8ffdf5 Mon Sep 17 00:00:00 2001
+// From: Jeff Carr <jcarr@wit.com>
+// Date: Sun, 5 Jan 2025 01:18:47 -0600
+// Subject: [PATCH] 'forge dirty' will find and list only dirty repos
+
+// list patches in jcarr but not in devel
+// git log --format="%H %Subject" jcarr --not devel
+func countCurrentPatches(repo *gitpb.Repo) int {
+	cmd := []string{"git", "log", "--format=\"%H %s\"", "--no-merges", "jcarr", "--not", "devel"}
+	result := repo.Run(cmd)
+	return len(result.Stdout)
+}
+
+func doRegister(newurl string) error {
+	var url string
+	url = me.urlbase + "/register?url=" + newurl
+	body, err := me.forge.HttpPost(url, nil)
+	if err != nil {
+		log.Info("httpPost() failed:", err)
+		return err
+	}
+
+	test := strings.TrimSpace(string(body))
+	for _, line := range strings.Split(test, "\n") {
+		line = strings.TrimSpace(line)
+		log.Info("server returned:", line)
+	}
+	return nil
+}
+*/

argv.go

@@ -1,51 +1,205 @@
+// 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"
+
+	"go.wit.com/lib/gui/prep"
+)
+
 /*
-	this parses the command line arguements
+	this parses the command line arguements using alex flint's go-arg
 */
 
 var argv args
 
 type args struct {
-	Config        bool   `arg:"--config"                             help:"work from your .config/forge/ configuration"`
+	Help       *EmptyCmd    `arg:"subcommand:help"                      help:"New to forge? This is for you.'"`
-	FindAll       bool   `arg:"--find-all"                           help:"select every repo"`
+	Checkout   *CheckoutCmd `arg:"subcommand:checkout"                  help:"switch branches using 'git checkout'"`
-	FindReadOnly  bool   `arg:"--find-readonly"                      help:"include read-only repos"`
+	Clean      *CleanCmd    `arg:"subcommand:clean"                     help:"start over at the beginning"`
-	FindMine      bool   `arg:"--find-mine"                          help:"download private and writeable repos"`
+	Commit     *CommitCmd   `arg:"subcommand:commit"                    help:"'git commit' but errors out if on wrong branch"`
-	FindFavorites bool   `arg:"--find-favorites"                     help:"download repos marked as favorites"`
+	Config     *ConfigCmd   `arg:"subcommand:config"                    help:"show your .config/forge/ settings"`
-	FindPrivate   bool   `arg:"--find-private"                       help:"list private repos in .config/forge/"`
+	Dirty      *DirtyCmd    `arg:"subcommand:dirty"                     help:"show dirty git repos"`
-	DoList        bool   `arg:"--do-list"                            help:"list found repos"`
+	GitFetch   *FindCmd     `arg:"subcommand:fetch"                     help:"run 'git fetch master'"`
-	DoScan        bool   `arg:"--do-scan"                            help:"rescan your repos"`
+	Gui        *EmptyCmd    `arg:"subcommand:gui"                       help:"open the gui"`
-	DoClone       bool   `arg:"--do-clone"                           help:"go-clone things you are missing"`
+	List       *FindCmd     `arg:"subcommand:list"                      help:"print a table of the current repos"`
-	DoForce       bool   `arg:"--do-force"                           help:"force redo go-clone"`
+	Merge      *MergeCmd    `arg:"subcommand:merge"                     help:"merge branches"`
-	DoGitPull     bool   `arg:"--do-git-pull"                        help:"run 'git pull' on all your repos"`
+	Normal     *NormalCmd   `arg:"subcommand:normal"                    help:"set every repo to the default state for software development"`
-	DoGitReset    bool   `arg:"--do-git-reset"                       help:"run 'git reset --hard' on all read-only repos"`
+	Patch      *PatchCmd    `arg:"subcommand:patch"                     help:"make patchsets"`
-	DoBuild       bool   `arg:"--do-build"      default:"true"       help:"also try to build it"`
+	Pull       *PullCmd     `arg:"subcommand:pull"                      help:"run 'git pull'"`
-	DoInstall     bool   `arg:"--do-install"                         help:"try to install every binary package"`
+	Tag        *TagCmd      `arg:"subcommand:tag"                       help:"manage git tags"`
-	DoRedoGoMod   bool   `arg:"--do-RedoGoMod"                       help:"remake all the go.sum and go.mod files"`
+	URL        string       `arg:"--connect"                            help:"forge url"`
-	DoPatchSet    bool   `arg:"--do-patches"                         help:"make patch set"`
+	All        bool         `arg:"--all"                                help:"git commit --all"`
-	ListPatchSet  bool   `arg:"--list-patches"                       help:"make patch set"`
+	Build      string       `arg:"--build"                              help:"build a repo"`
-	DoGui         bool   `arg:"--do-gui"                             help:"test the gui"`
+	Install    string       `arg:"--install"                            help:"install a repo"`
-	DryRun        bool   `arg:"--dry-run"                            help:"show what would be run"`
+	BuildForge bool         `arg:"--forge-rebuild"                      help:"download and rebuild forge"`
-	Fix           bool   `arg:"--fix"                                help:"fix config, save config & exit"`
+	Force      bool         `arg:"--force"                              help:"try to strong arm things"`
-	URL           string `arg:"--url"  default:"http://go.wit.com/"  help:"base url"`
+	Verbose    bool         `arg:"--verbose"                            help:"show more output"`
+}
+
+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"`
+}
+
+type CleanDevelCmd struct {
+	Force bool `arg:"--force"                              help:"try to strong arm things"`
+}
+
+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"`
+}
+
+type ConfigAddCmd struct {
+	Path        string `arg:"--path"                            help:"absolute path of the git repo"`
+	GoPath      string `arg:"--gopath"                          help:"GO path of the git repo"`
+	Directory   bool   `arg:"--directory"    default:"false"    help:"repo is a directory to match against"`
+	ReadOnly    bool   `arg:"--readonly"     default:"false"    help:"repo is readonly"`
+	Writable    bool   `arg:"--writable"     default:"false"    help:"repo is writable"`
+	Favorite    bool   `arg:"--favorite"     default:"false"    help:"forge will always go-clone or git clone this"`
+	Private     bool   `arg:"--private"      default:"false"    help:"repo can not be published"`
+	Interesting bool   `arg:"--interesting"  default:"false"    help:"something you decided was cool"`
+	DebName     string `arg:"--debname"                         help:"the name of the debian package (or rpm, etc)"`
+	Master      string `arg:"--master"                          help:"the git 'master' or 'main' branch name"`
+	Devel       string `arg:"--devel"                           help:"the git devel branch name"`
+	User        string `arg:"--user"                            help:"the git user branch name"`
+}
+
+type ConfigCmd struct {
+	Add      *ConfigAddCmd `arg:"subcommand:add"                      help:"add a config setting"`
+	Fix      *EmptyCmd     `arg:"subcommand:fix"                      help:"fix .config/forge/ and/or repos.pb protobuf file"`
+	List     *EmptyCmd     `arg:"subcommand:list"                     help:"list your config settings"`
 	Delete   string        `arg:"--delete"                            help:"delete this repo"`
+	Register string        `arg:"--register"                          help:"register your git URL (foo.com/mystuff) or (github.com/foo/bar)"`
+}
+
+type CheckoutCmd struct {
+	User   *FindCmd `arg:"subcommand:user"                      help:"git checkout user"`
+	Devel  *FindCmd `arg:"subcommand:devel"                     help:"git checkout devel"`
+	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 {
+}
+
+type FindCmd struct {
+	All       bool `arg:"--all"                           help:"select every repo (the default)"`
+	Mine      bool `arg:"--mine"                          help:"your repos as defined in the forge config"`
+	Favorites bool `arg:"--favorites"                     help:"your repos configured as favorites"`
+	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"`
 }
 
 func (args) Version() string {
-	return "forge " + VERSION + "    Built on " + BUILDTIME
+	return ARGNAME + " " + VERSION + "    Built on " + BUILDTIME
 }
 
 func (a args) Description() string {
 	return `
-forge -- in the spirit of things like sourceforge
+forge -- a tool to manage lots of git repos. forge includes a GUI and TUI.
 
-Examples:
+	forge only executes the 'git' command. Everything it does, you can run by hand with 'git'.
-	forge  --config                              # shows your forge config (~/.config/forge/)
-	forge  --mine                                # find your private and writable repos
-	forge  --favorites                           # find configured as favorites
-
-	forge  --git-pull                            # run 'git pull' in every repo
-	forge  --build --dry-run                     # build every binary package (but just show what would run)
-	forge  --mine --clone                        # clone every package you have in your config file
 `
 }
+
+// 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")
+		}
+	}
+	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)
+}

build

@@ -3,3 +3,6 @@
 # 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

cobol.go

@@ -1,198 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-// ah yes, COBOL. what a throwback. for those that know
-// then you know exactly what is in this file. For those that don't, here it is:
-
-// All this does is output human readable text formatted to be viewable on
-// a console with a fixed with font. AKA: a typerwriter. Which is exactly
-// what COBOL did in the 1970's (60s? notsure) And the 80s.
-
-// So, you want to dump out stuff on the console. Let's see. Something like
-
-/*
-	forge --favorites
-
-	go.wit.com/apps/myapp          v0.2.0     (installed)
-	go.wit.com/lib/somethingfun    v0.0.7     (not downloaded)
-*/
-
-// anyway, you get the idea. This is also called COBOL because it does on
-// thing and truncates every line output to the columns you see with stty -a
-// my monitor is huge, so it's not going to work at 80x24. 160x48 is better
-// actually, I'd predict some of these will probably end up 240 wide
-// long live good eyesight and 4K monitors!
-
-func doCobol() {
-	log.DaemonMode(true)
-
-	// log.Info(standardStart5("gopath", "cur name", "master", "user", "repo type"))
-	log.Info(standardStart8("gopath", "cur name", "target", "master", "devel", "user", "curver", "repo type"))
-	all := me.found.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		verifyPrint(repo)
-	}
-}
-
-func standardStart5(arg1, arg2, arg3, arg4, arg5 string) string {
-	len1 := 40
-	len2 := 12
-	len3 := 12
-	len4 := 16
-	len5 := 8
-	var s string
-	if len(arg1) > len1 {
-		arg1 = arg1[:len1]
-	}
-	s = "%-" + fmt.Sprintf("%d", len1) + "s "
-	if len(arg2) > len2 {
-		arg2 = arg2[:len2]
-	}
-	s += "%-" + fmt.Sprintf("%d", len2) + "s "
-	if len(arg3) > len3 {
-		arg3 = arg3[:len3]
-	}
-	s += "%-" + fmt.Sprintf("%d", len3) + "s "
-	if len(arg4) > len4 {
-		arg4 = arg4[:len4]
-	}
-	s += "%-" + fmt.Sprintf("%d", len4) + "s "
-	if len(arg5) > len5 {
-		arg5 = arg5[:len5]
-	}
-	s += "%-" + fmt.Sprintf("%d", len5) + "s"
-	return fmt.Sprintf(s, arg1, arg2, arg3, arg4, arg5)
-}
-
-func standardStart8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 string) string {
-	len1 := 40
-	len2 := 12
-	len3 := 16
-	len4 := 16
-	len5 := 16
-	len6 := 16
-	len7 := 16
-	len8 := 8
-	var s string
-	if len(arg1) > len1 {
-		arg1 = arg1[:len1]
-	}
-	s = "%-" + fmt.Sprintf("%d", len1) + "s "
-	if len(arg2) > len2 {
-		arg2 = arg2[:len2]
-	}
-	s += "%-" + fmt.Sprintf("%d", len2) + "s "
-	if len(arg3) > len3 {
-		arg3 = arg3[:len3]
-	}
-	s += "%-" + fmt.Sprintf("%d", len3) + "s "
-	if len(arg4) > len4 {
-		arg4 = arg4[:len4]
-	}
-	s += "%-" + fmt.Sprintf("%d", len4) + "s "
-
-	if len(arg5) > len5 {
-		arg5 = arg5[:len5]
-	}
-	s += "%-" + fmt.Sprintf("%d", len5) + "s   "
-
-	if len(arg6) > len6 {
-		arg6 = arg6[:len6]
-	}
-	s += "%-" + fmt.Sprintf("%d", len6) + "s   "
-
-	if len(arg7) > len7 {
-		arg7 = arg7[:len7]
-	}
-	s += "%-" + fmt.Sprintf("%d", len7) + "s  "
-
-	if len(arg8) > len8 {
-		arg8 = arg8[:len8]
-	}
-	s += "%-" + fmt.Sprintf("%d", len8) + "s"
-
-	return fmt.Sprintf(s, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-}
-
-func verifyPrint(repo *gitpb.Repo) {
-	var end string
-	if repo.CheckDirty() {
-		end += "(dirty) "
-	}
-	s := make(map[string]string)
-	if !verify(repo, s) {
-		log.Info("going to delete", repo.GetGoPath())
-		if argv.Fix {
-			me.forge.DeleteByGoPath(repo.GetGoPath())
-			me.forge.Repos.ConfigSave()
-		} else {
-			log.Info("need argv --fix to delete", repo.GetGoPath())
-		}
-	}
-
-	var mhort string = s["mver"]  // master version
-	var dhort string = s["dver"]  // devel version
-	var uhort string = s["uver"]  // user version
-	var thort string = s["tver"]  // target version
-	var chort string = s["cver"]  // current version
-	var cname string = s["cname"] // current branch name git is on now
-
-	// start := fmt.Sprintf("%-40s %-12s %-12s %-12s %-8s", s["gopath"], cname, mhort, uhort, s["rtype"])
-	start := standardStart8(s["gopath"], cname, thort, mhort, dhort, uhort, chort, s["rtype"])
-
-	if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-		end += "(readonly) "
-	}
-
-	log.Info(start, end)
-}
-
-func verify(repo *gitpb.Repo, s map[string]string) bool {
-	s["gopath"] = repo.GetGoPath()
-	s["rtype"] = repo.GetRepoType()
-
-	s["mname"] = repo.GetMasterBranchName()
-	if s["mname"] == "" {
-		log.Info("verify() no master branch name", repo.FullPath)
-		s["mver"] = repo.GetMasterVersion()
-		// return false
-	}
-	s["mver"] = repo.GetMasterVersion()
-
-	s["dname"] = repo.GetDevelBranchName()
-	if s["dname"] == "" {
-		log.Info("verify() no devel branch name", repo.GetGoPath())
-		// return false
-	}
-	s["uname"] = repo.GetUserBranchName()
-	if s["uname"] == "" {
-		log.Info("verify() no user branch name", repo.GetGoPath())
-		// return false
-	}
-	s["cname"] = repo.GetCurrentBranchName()
-
-	s["mver"] = repo.GetMasterVersion()
-	if s["mver"] == "" {
-		log.Info("verify() no master branch name", repo.FullPath, repo.GetMasterBranchName())
-	}
-	s["dver"] = repo.GetDevelVersion()
-	if s["dver"] == "" {
-		log.Info("verify() no devel branch name", repo.GetGoPath(), repo.GetDevelBranchName())
-	}
-	s["uver"] = repo.GetUserVersion()
-	if s["uver"] == "" {
-		log.Info("verify() no user branch name", repo.GetGoPath(), repo.GetUserBranchName())
-	}
-	s["cver"] = repo.GetCurrentBranchVersion()
-	s["tver"] = repo.GetTargetVersion()
-	s["url"] = repo.URL
-
-	return true
-}

config.go

@@ -0,0 +1,36 @@
+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:
+Depends: go-gui-toolkits, autogenpb, go-mod-clean, go-clone
 Recommends: go-clone
 Description: 'forge' an attempt at federated 'git'

debug.go

@@ -0,0 +1,88 @@
+// 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)
+	}
+}

debugger.go

@@ -0,0 +1,20 @@
+package main
+
+/*
+	enables GUI options and the debugger in your application
+*/
+
+import (
+	"go.wit.com/lib/debugger"
+	"go.wit.com/log"
+)
+
+func init() {
+	if debugger.ArgDebug() {
+		log.Info("cmd line --debugger == true")
+		go func() {
+			log.Sleep(2)
+			debugger.DebugWindow()
+		}()
+	}
+}

doBuild.go

@@ -0,0 +1,47 @@
+// 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"
+
+	"go.wit.com/log"
+)
+
+func doBuild() error {
+	v := []string{}
+	if argv.Verbose {
+		v = []string{"-v", "-x"}
+	}
+
+	gopath := argv.Build
+
+	repo := me.forge.FindByGoPath(gopath)
+	if repo == nil {
+		return fmt.Errorf("rep not found: %s", gopath)
+	}
+	if err := me.forge.Build(repo, v); err != nil {
+		log.Warn("Build failed:", repo.GetGoPath(), err)
+		return err
+	}
+	return nil
+}
+
+func doInstall() error {
+	v := []string{}
+	if argv.Verbose {
+		v = []string{"-v", "-x"}
+	}
+
+	gopath := argv.Install
+	repo := me.forge.FindByGoPath(gopath)
+	if repo == nil {
+		return fmt.Errorf("rep not found: %s", gopath)
+	}
+	if err := me.forge.Install(repo, v); err != nil {
+		log.Warn("Install failed", repo.GetGoPath(), err)
+		return err
+	}
+	return nil
+}

doCheckout.go

@@ -0,0 +1,47 @@
+// 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"
+	"time"
+
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/log"
+)
+
+// trys to figure out if there is still something to update
+
+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("")
+	}
+
+	if argv.Checkout.Devel != nil {
+		// setForgeMode(forgepb.ForgeMode_DEVEL)
+		if err := me.forge.DoAllCheckoutDevelNew(argv.Force); err != nil {
+			badExit(err)
+		}
+		okExit("")
+	}
+
+	if argv.Checkout.Master != nil {
+		setForgeMode(forgepb.ForgeMode_MASTER) // disable "normal" mode if set
+
+		if err := me.forge.DoAllCheckoutMaster(); err != nil {
+			badExit(err)
+		}
+		okExit("")
+	}
+	badExit(fmt.Errorf("did not specify what branch to checkout"))
+	return nil
+}

doClean.go

@@ -0,0 +1,272 @@
+// 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"
+	"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)
+	}
+	if repo.VerifyRemoteAndLocalBranches(repo.GetDevelBranchName()) {
+	} else {
+		return log.Errorf("remote devel is out of sync with local: todo: git pull or git fetch")
+	}
+	if repo.VerifyRemoteAndLocalBranches(repo.GetMasterBranchName()) {
+	} else {
+		return log.Errorf("remote master is out of sync with local: todo: git pull or git fetch")
+	}
+	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)
+			}
+		}
+		// 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
+	}
+
+	// fix this to work, then delete all the other options for "forge clean'
+	if err := me.forge.DoAllCheckoutMaster(); err != nil {
+		// badExit(err)
+	}
+
+	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 {
+			log.Info(repo.GetGoPath(), err)
+		}
+
+		// try to delete devel
+		doRepoCleanDevel(repo)
+	}
+
+	found := gitpb.NewRepos()
+
+	total := 0
+	// find all repos that aren't "clean"
+	all = me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		total += 1
+
+		// find repos not on master branch
+		if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
+			found.AppendByFullPath(repo)
+			continue
+		}
+
+		// find dirty repos
+		if repo.IsDirty() {
+			found.AppendByFullPath(repo)
+			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
+		}
+	}
+
+	// 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)
+	}
+	return nil
+}
+
+/*
+	func doesLocalBranchExist(repo *gitpb.Repo, branch string) bool {
+		return repo.Exists(filepath.Join(".git/refs/heads", branch))
+	}
+*/
+func doRepoCleanDevel(repo *gitpb.Repo) error {
+	if !repo.IsLocalBranch(repo.GetDevelBranchName()) {
+		// there is no local branch named 'devel'
+		return nil
+	}
+
+	if repo.GetCurrentBranchName() != repo.GetMasterBranchName() {
+		return log.Errorf("%s not on master branch:", repo.GetFullPath())
+	}
+	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
+}
+
+// removes all local user branches
+func doRepoCleanUser(repo *gitpb.Repo) error {
+	if repo.IsDirty() {
+		return nil
+	}
+
+	bruser := repo.GetUserBranchName()
+	brdevel := repo.GetDevelBranchName()
+
+	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
+	}
+
+	// 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
+		}
+	}
+
+	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)
+}
+
+// if you call this, there is no going back. no checks anymore. nothing
+// it deletes the 'devel' branch. git branch -D "devel". END OF STORY
+func justDeleteTheDevelBranchAlready(repo *gitpb.Repo) error {
+	branch := repo.GetDevelBranchName()
+	remote := filepath.Join("origin", branch)
+
+	if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
+		if repo.IsDevelRemote() {
+			// just make sure the remote & local branches are the same
+			return repo.DeleteLocalDevelBranch()
+		}
+	}
+
+	// check against remote if it exists
+	if repo.IsDevelRemote() {
+		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)
+			return err
+		}
+		cmd := []string{"git", "push"}
+		log.Info("DEVEL LOCAL NEEDS GIT PUSH TO REMOTE", repo.GetGoPath(), cmd)
+		err := repo.RunVerbose(cmd)
+		return err
+	}
+
+	// remote doesn't exist, check against master
+	master := repo.GetMasterBranchName()
+	b1 := repo.CountDiffObjects(branch, "refs/heads/"+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)
+		return err
+	}
+	cmd := []string{"git", "merge something somehow"}
+	log.Info("devel local, remote and master branches are wrong", 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

@@ -0,0 +1,99 @@
+// 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"
+
+	"go.wit.com/lib/config"
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/gitpb"
+	"go.wit.com/log"
+)
+
+func doCommit() error {
+	if argv.All {
+		found := me.forge.CheckDirty()
+		var newpatches bool
+		for repo := range found.IterAll() {
+			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())
+	}
+
+	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
+		found := new(gitpb.Repos)
+		found.Append(repo)
+		me.forge.PrintHumanTable(found)
+		log.Info("")
+		log.Info("wrong branch. Can not commit on", repo.GetCurrentBranchName())
+		log.Info("")
+		okExit("")
+	}
+
+	os.Setenv("LESS", "-XR")
+	if err := shell.Exec([]string{"git", "diff"}); err != nil {
+		badExit(err)
+	}
+
+	if argv.All {
+		if err := shell.ExecCheck([]string{"git", "add", "--all"}); err != nil {
+			badExit(err)
+		}
+	}
+
+	if err := shell.ExecCheck([]string{"git", "commit", "--all"}); err != nil {
+		badExit(err)
+	}
+
+	return doPatchSubmit()
+}
+
+func doCommitRepo(repo *gitpb.Repo) error {
+	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
+		found := new(gitpb.Repos)
+		found.Append(repo)
+		me.forge.PrintHumanTable(found)
+		log.Info("")
+		log.Info("wrong branch. Can not commit on", repo.GetCurrentBranchName())
+		log.Info("")
+		return nil
+	}
+	os.Chdir(repo.GetFullPath())
+
+	os.Setenv("LESS", "-XR")
+	if err := shell.Exec([]string{"git", "diff"}); err != nil {
+		return err
+	}
+
+	if argv.All {
+		if err := shell.ExecCheck([]string{"git", "add", "--all"}); err != nil {
+			return err
+		}
+	}
+
+	if err := shell.ExecCheck([]string{"git", "commit", "--all"}); err != nil {
+		shell.ExecCheck([]string{"git", "reset"})
+		return err
+	}
+	log.Info("git commit ok. forge done")
+	return nil
+}

doCommon.go

@@ -1,73 +0,0 @@
-package main
-
-import (
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func doScan() {
-	me.forge.ScanGoSrc()
-}
-
-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)
-	}
-
-}
-func doGitReset() {
-	if !argv.DoGitReset {
-		return
-	}
-	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 checkoutBranches(repo *gitpb.Repo) error {
-	dname := repo.GetDevelBranchName()
-	if dname == "" {
-		if err := me.forge.MakeDevelBranch(repo); err != nil {
-			log.Info("verify() no devel branch name", repo.GetGoPath())
-			return err
-		}
-		configSave = true
-	}
-	if repo.GetUserBranchName() == "" {
-		if err := me.forge.MakeUserBranch(repo); err != nil {
-			log.Info("verify() no devel branch name", repo.GetGoPath())
-			return err
-		}
-		configSave = true
-	}
-	return nil
-}

doConfig.go

@@ -0,0 +1,75 @@
+// 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"
+
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/log"
+)
+
+func doConfig() {
+	if argv.Config.Delete != "" {
+		me.forge.DeleteByGoPath(argv.Config.Delete)
+		me.forge.SetConfigSave(true)
+		okExit("")
+	}
+
+	if argv.Config.Fix != nil {
+		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)
+			}
+		}
+	*/
+
+	// try to add, then save config and exit
+	if argv.Config.Add != nil {
+		log.Info("going to add a new repo", argv.Config.Add.GoPath)
+		deleteGoPath(me.forge, argv.Config.Add.GoPath)
+		new1 := forgepb.ForgeConfig{
+			GoPath:           argv.Config.Add.GoPath,
+			Writable:         argv.Config.Add.Writable,
+			ReadOnly:         argv.Config.Add.ReadOnly,
+			Private:          argv.Config.Add.Private,
+			Directory:        argv.Config.Add.Directory,
+			Favorite:         argv.Config.Add.Favorite,
+			Interesting:      argv.Config.Add.Interesting,
+			MasterBranchName: argv.Config.Add.Master,
+			DevelBranchName:  argv.Config.Add.Devel,
+			UserBranchName:   argv.Config.Add.User,
+		}
+
+		me.forge.Config.Append(&new1)
+		me.forge.ConfigSave()
+		os.Exit(0)
+	}
+
+	log.Info("config.PathLock =", me.forge.Config.PathLock)
+
+	me.forge.ConfigPrintTable()
+	okExit("")
+}
+
+func deleteGoPath(f *forgepb.Forge, gopath string) bool {
+	var deleted bool = false
+	for {
+		if f.Config.DeleteByGoPath(gopath) {
+			log.Info("deleted ok", gopath)
+			deleted = true
+		} else {
+			log.Info("did not delete", gopath)
+			break
+		}
+	}
+	return deleted
+}

doDirty.go

@@ -0,0 +1,16 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+func doDirty() {
+	found := me.forge.CheckDirty()
+	if found.Len() == 0 {
+		return
+	}
+	if argv.Verbose {
+		me.forge.PrintHumanTableDirty(found)
+	} else {
+		me.forge.PrintHumanTable(found)
+	}
+}

doFind.go

@@ -0,0 +1,198 @@
+// 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

@@ -1,40 +1,362 @@
+// 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/gui"
 	"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 doGui() {
-	me.myGui = gui.New()
+	win := gadgets.NewGenericWindow("Forge: A federated git development tool by WIT.COM", "Current Settings")
-	me.myGui.Default()
+	win.Custom = func() {
+		log.Warn("MAIN WINDOW CLOSE")
+		okExit("")
+	}
 
-	me.mainWindow = gadgets.RawBasicWindow("submit & test patchsets")
+	grid := win.Group.RawGrid()
-	me.mainWindow.Make()
+	if me.forge.Config.GetPathLock() {
-	me.mainWindow.Show()
+		me.goSrcPwd = gadgets.NewOneLiner(grid, "Working Directory")
-	me.mainbox = me.mainWindow.Box()
+		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")
+	}
 
-	// disable the interface while everything is scanned
+	grid.NextRow()
-	me.Disable()
 
-	vbox2 := me.mainbox.NewVerticalBox("BOX2")
+	// use ENV GIT_AUTHOR
-	globalBuildOptions(vbox2)
+	me.gitAuthor = gadgets.NewOneLiner(grid, "Git Author")
-	me.summary = submitPatchesBox(vbox2)
+	grid.NextRow()
 
-	me.repos = makeRepoView()
+	if os.Getenv("GIT_AUTHOR_NAME") == "" {
+		me.gitAuthor.SetText("ENV GIT_AUTHOR_NAME is unset")
+	} else {
+		author := os.Getenv("GIT_AUTHOR_NAME")
+		author += " <" + os.Getenv("GIT_AUTHOR_EMAIL") + ">"
+		me.gitAuthor.SetText(author)
+	}
 
-	// processing is done. update the repo summary box
+	grid.NextRow()
-	me.summary.Update()
 
-	me.Enable()
+	gridM := win.Stack.RawGrid()
 
-	// intermittently scans the status indefinitly
+	var insertWin *gadgets.GenericWindow
-	me.repos.View.Watchdog(func() {
+	s := fmt.Sprintf("Repos (%d)", me.forge.Repos.Len())
-		log.Info("In main()")
+	me.reposWinB = gridM.NewButton(s, func() {
-		// processing is done. update the repo summary box
+		// if the window exists, just toggle it open or closed
-		me.summary.Update()
+		if insertWin != nil {
+			insertWin.Toggle()
+			return
+		}
+
+		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()
+		for all.Scan() {
+			pset := all.Next()
+			if pset.State == "DONE" {
+				// skip old patchsets
+				continue
+			}
+			AddAllPatches(notdone, pset, false)
+			// AddNotDonePatches(notdone, pset, false)
+		}
+		notdone.PrintTable()
+
+		patchesWin = makePatchesWin(notdone)
+	})
+
+	var pubWin *gadgets.GenericWindow
+	gridM.NewButton("Publish", func() {
+		if pubWin != nil {
+			pubWin.Toggle()
+			return
+		}
+		pubWin = makePublishWindow()
+	})
+
+	var oldWin *gadgets.GenericWindow
+	gridM.NewButton("old", func() {
+		if oldWin != nil {
+			oldWin.Toggle()
+			return
+		}
+		oldWin = makeOldStuff()
 	})
 }
+
+// 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()
+	})
+	// t.Custom = func() {
+	// 	log.Info("close grid?")
+	// }
+	sf.Custom = func(r *gitpb.Repo) {
+		log.Info("do button click on", r.GetNamespace())
+	}
+	t.AddTimeFunc("age", func(repo *gitpb.Repo) time.Time {
+		return repo.NewestTime()
+	})
+	t.AddMasterVersion()
+	t.AddDevelVersion()
+	t.AddUserVersion()
+	t.AddCurrentBranchName()
+	t.AddState()
+	return t
+}
+
+// this is the magic that generates a window directly from the protocol buffer
+func makeStandardReposWindow(title string, pb *gitpb.Repos) (*gitpb.ReposTable, *gui.Node) {
+	win := gadgets.RawBasicWindow(title)
+	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)
+
+	t := makeStandardReposGrid(pb)
+	t.SetParent(box)
+	t.ShowTable()
+	return t, box
+}
+
+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
+		if repo.CountDiffObjects(repo.GetUserBranchName(), repo.GetDevelBranchName()) > 0 {
+			found.AppendByFullPath(repo)
+		}
+	}
+	now := time.Now()
+	if found.Len() == 0 {
+		log.Info("nothing to merge with devel")
+		return found
+	}
+	// me.forge.PrintHumanTable(found)
+
+	// check for merges from devel
+	total, count, nope, _ := me.forge.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)
+
+	all := me.forge.Repos.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+
+		if me.forge.Config.IsReadOnly(repo.GetNamespace()) {
+			continue
+		}
+		/*
+			if repo.IsDirty() {
+				continue
+			}
+			if repo.GetMasterVersion() != repo.GetDevelVersion() {
+				me.found.AppendByFullPath(repo)
+				continue
+			}
+		*/
+
+		// this sees if devel is behind master. IT SHOULD NOT BE
+		if repo.CountDiffObjects(repo.GetMasterBranchName(), repo.GetDevelBranchName()) == 0 {
+			// everything is normal
+		} else {
+			repo.State = "DEVEL < MASTER"
+			log.Info("SERIOUS ERROR. DEVEL BRANCH IS BEHIND MASTER", repo.GetNamespace())
+		}
+
+		// 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)
+		}
+	}
+	now := time.Now()
+	if found.Len() == 0 {
+		log.Info("nothing to merge with master")
+		return found
+	}
+	me.forge.PrintHumanTable(found)
+
+	// check for merges from devel
+	total, count, nope, _ := me.forge.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()
+
+	if !doit {
+		return
+	}
+
+	all := found.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		log.Info("repo:", repo.GetNamespace())
+		if result, err := repo.MergeToMaster(); err == nil {
+			log.Warn("THINGS SEEM OK", repo.GetFullPath())
+			for _, line := range result.Stdout {
+				log.Warn("stdout:", line)
+			}
+			for _, line := range result.Stderr {
+				log.Warn("stderr:", line)
+			}
+		} else {
+			log.Warn("THINGS FAILED ", repo.GetFullPath())
+			log.Warn("err", err)
+			if result == nil {
+				break
+			}
+			for _, line := range result.Stdout {
+				log.Warn("stdout:", line)
+			}
+			for _, line := range result.Stderr {
+				log.Warn("stderr:", line)
+			}
+			log.Warn("THINGS FAILED ", repo.GetFullPath())
+			break
+		}
+		me.forge.SetConfigSave(true)
+		// view.Update()
+	}
+	me.forge.ConfigSave()
+}
+
+func mergeUserToDevel(doit bool) {
+	found := findMergeToDevel()
+
+	if !doit {
+		return
+	}
+
+	all := found.SortByFullPath()
+	for all.Scan() {
+		repo := all.Next()
+		bruser := repo.GetUserBranchName()
+		brdevel := repo.GetDevelBranchName()
+
+		if repo.GetUserVersion() == "uerr" {
+			// no user branch
+			return
+		}
+		log.Info("trying", bruser, repo.GetUserVersion())
+
+		b1 := repo.CountDiffObjects(bruser, brdevel) // should be zero
+		if b1 == 0 {
+			// log.Info("User is already merged into Devel", repo.GetNamespace(), cmd)
+			return
+		}
+		log.Info("merging user into devel repo:", repo.GetNamespace())
+		if result, err := repo.MergeToDevel(); err == nil {
+			log.Warn("THINGS SEEM OK", repo.GetFullPath())
+			for _, line := range result.Stdout {
+				log.Warn("stdout:", line)
+			}
+			for _, line := range result.Stderr {
+				log.Warn("stderr:", line)
+			}
+		} else {
+			log.Warn("THINGS FAILED ", repo.GetFullPath())
+			log.Warn("err", err)
+			if result == nil {
+				break
+			}
+			for _, line := range result.Stdout {
+				log.Warn("stdout:", line)
+			}
+			for _, line := range result.Stderr {
+				log.Warn("stderr:", line)
+			}
+			break
+		}
+		me.forge.SetConfigSave(true)
+		// view.Update()
+	}
+	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

@@ -0,0 +1,168 @@
+// 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

@@ -0,0 +1,112 @@
+// 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

@@ -0,0 +1,261 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"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()
+		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
+	}
+
+	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
+		*/
+	}
+
+	// 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)
+	}
+	return true
+}
+
+// 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 {
+	// 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())
+		return false
+	} else {
+		log.Printf("Patchset Name: %-24s Author: %s <%s> IS GOOD\n", pset.Name, pset.GetGitAuthorName(), pset.GetGitAuthorEmail())
+	}
+
+	var count int
+	var bad int
+	all := pset.Patches.SortByFilename()
+	for all.Scan() {
+		p := all.Next()
+		if IsValidPatch(p) {
+			// ok
+		} else {
+			pset.State = "BROKEN"
+			bad += 1
+		}
+		count += 1
+	}
+	log.Info("pset has", count, "total patches, ", bad, "bad patches")
+	if bad == 0 {
+		return true
+	}
+	return false
+}
+
+func IsValidPatch(p *forgepb.Patch) bool {
+	basepath, filename := filepath.Split(p.Filename)
+	repo := me.forge.FindByGoPath(basepath)
+	if argv.Verbose {
+		log.Info("start:", p.StartHash, "end:", p.CommitHash, "file:", basepath, filename, "devel version", repo.GetDevelVersion())
+	}
+	if repo == nil {
+		log.Info("can not apply patch! repo not found", basepath, filename)
+		return false
+	}
+	if repo.ActualDevelHash() != 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")
+	}
+	log.Info("start:", p.StartHash, "end:", p.CommitHash, "file:", basepath, filename, "devel version", repo.GetDevelVersion())
+	for _, line := range p.Files {
+		log.Info("\t", line)
+	}
+	return true
+}

doPull.go

@@ -0,0 +1,111 @@
+// 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/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
+		return nil
+	}
+	t, _ := repo.LastGitPull()
+	if time.Since(t) < time.Minute*10 && !argv.Force {
+		if argv.Verbose {
+			log.Info(repo.GetFullPath(), "git pulled too recently", shell.FormatDuration(time.Since(t)))
+		}
+		return nil
+	}
+	cur := repo.GetCurrentBranchName()
+	if !repo.IsBranchRemote(cur) {
+		if argv.Verbose {
+			log.Info(repo.GetFullPath(), "branch is not remote", cur)
+		}
+		return nil
+	}
+
+	var cmd []string
+	cmd = append(cmd, "git", "pull")
+	err := repo.RunVerbose(cmd)
+	if err != nil {
+		log.Info(repo.GetFullPath(), "git pull err:", err)
+	}
+	return nil
+}
+
+/*
+// git fetch origin master:master
+func rillFetchMaster(repo *gitpb.Repo) error {
+	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
+		// only fetch when branch is on the user branch
+		return nil
+	}
+	branch := repo.GetMasterBranchName()
+	cmd := []string{"git", "fetch", "origin", branch + ":" + branch}
+	err := repo.RunVerbose(cmd)
+	return err
+}
+
+func doGitFetch() {
+	me.forge.RillFuncError(rillFetchMaster)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+}
+*/

doRedoGoMod.go

@@ -1,28 +0,0 @@
-package main
-
-// An app to submit patches for the 30 GO GUI repos
-
-func doRedoGoMod() {
-	// me.forge.RillRedoGoMod()
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if err := repo.ValidGoSum(); err == nil {
-			continue
-		}
-		if err := repo.RunStrict([]string{"go-mod-clean"}); err != nil {
-			badExit(err)
-		}
-	}
-}
-
-func doEraseGoMod() {
-	/*
-		var cmds [][]string
-		cmds = append(cmds, []string{"rm", "-f", "go.mod", "go.sum"})
-		errs := me.forge.RillCmds(me.packs, cmds)
-		foreach x, y := range errs {
-			log.Info("EraseGoMod() error", x.GoPath, y)
-		}
-	*/
-}

doSync.go

@@ -0,0 +1,79 @@
+// 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

@@ -0,0 +1,125 @@
+// 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

@@ -0,0 +1,41 @@
+/*
+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

@@ -1,21 +1,33 @@
+// 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"
 
+	"go.wit.com/gui"
+	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
 func okExit(thing string) {
-	log.Info(thing, "ok")
+	gui.UnloadToolkits()
 	if configSave {
 		me.forge.SetConfigSave(configSave)
 	}
-	// log.Info("Finished go-clean on", check.GetGoPath(), "ok")
+	if thing != "" {
+		log.Info("forge exit:", thing, "ok")
+	}
 	me.forge.Exit()
 }
 
 func badExit(err error) {
-	log.Info("forge failed: ", err, me.forge.GetGoSrc())
+	log.Info("forge failed: ", err, me.forge.Config.ReposDir)
+	os.Exit(-1)
+}
+
+func badRepoExit(repo *gitpb.Repo, err error) {
+	log.Printf("%s FAILED: %v\n", repo.GetNamespace(), err)
 	os.Exit(-1)
 }

findConfig.go

@@ -1,55 +0,0 @@
-package main
-
-import "go.wit.com/log"
-
-// retuns true if nothing was done
-func findConfig() bool {
-	var done bool = false
-	if argv.FindMine {
-		findConfigMine()
-		done = true
-	}
-	if argv.FindAll {
-		findConfigAll()
-		done = true
-	}
-	if !done {
-		findConfigAll()
-		done = true
-	}
-	return done
-}
-
-// finds config repos that are writable
-func findConfigMine() {
-	all := me.forge.Config.SortByGoPath()
-	for all.Scan() {
-		r := all.Next()
-		gopath := r.GoPath
-		if r.GetDirectory() {
-			continue
-		}
-		if me.forge.Config.IsWritable(gopath) {
-			log.Info("mine:", gopath)
-			me.foundPaths = append(me.foundPaths, gopath)
-			continue
-		}
-	}
-}
-
-// get everything in your config
-func findConfigAll() {
-	all := me.forge.Config.SortByGoPath()
-	for all.Scan() {
-		r := all.Next()
-		gopath := r.GoPath
-		if r.GetDirectory() {
-			continue
-		}
-		if me.forge.Config.IsWritable(gopath) {
-			log.Info("mine:", gopath)
-			me.foundPaths = append(me.foundPaths, gopath)
-			continue
-		}
-	}
-}

findRepos.go

@@ -1,92 +0,0 @@
-package main
-
-import (
-	"go.wit.com/log"
-)
-
-func findRepos() bool {
-	var done bool = false
-	if argv.FindAll {
-		findAll()
-		done = true
-	}
-
-	if argv.FindPrivate {
-		findPrivate()
-		done = true
-	}
-
-	if argv.FindMine {
-		findMine()
-		done = true
-	}
-	if argv.FindFavorites {
-		findFavorites()
-		done = true
-	}
-
-	// this is the 'default' behavior when no command line arguments are given
-	// if no argv was set, select repos marked as 'mine'
-	if !done {
-		findMine()
-		done = true
-	}
-	return done
-}
-
-func findPrivate() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsPrivate(repo.GetGoPath()) {
-			me.found.AppendUniqueGoPath(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.AppendUniqueGoPath(repo)
-		}
-	}
-}
-
-// finds repos that are writable
-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.AppendUniqueGoPath(repo)
-		}
-	}
-}
-
-func findAll() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		me.found.AppendUniqueGoPath(repo)
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) && !argv.FindReadOnly {
-			if repo.ReadOnly {
-				continue
-			}
-			log.Info("todo: ConfigSave() readonly flag on repo is wrong", repo.GetGoPath())
-			repo.ReadOnly = true
-			configSave = true
-			continue
-		}
-	}
-	/*
-		if configsave {
-			log.Info("should ConfigSave here")
-			me.forge.Repos.ConfigSave()
-		}
-	*/
-}

globalBuildOptions.go

@@ -1,91 +0,0 @@
-package main
-
-import (
-	"os"
-	"os/user"
-	"path/filepath"
-
-	"go.wit.com/gui"
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/log"
-)
-
-func doesExist(path string) bool {
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			return false
-		}
-	}
-	return true
-}
-
-// only errors on bad errors
-func quickCmd(fullpath string, cmd []string) bool {
-	if me.autoDryRun.Checked() {
-		log.Warn("RUN --dry-run", fullpath, cmd)
-		return false
-	} else {
-		log.Warn("RUN:", fullpath, cmd)
-	}
-
-	result := shell.PathRun(fullpath, cmd)
-	if result.Error != nil {
-		log.Warn("quickCmd() cmd =", cmd)
-		log.Warn("quickCmd() err =", result.Error)
-		log.Warn("quickCmd() b =", result.Exit)
-		log.Warn("quickCmd() output =", result.Stdout)
-		return false
-	} else if result.Exit != 0 {
-		log.Warn("quickCmd() b =", result.Exit)
-		log.Warn("quickCmd() output =", result.Stdout)
-		return true
-	}
-	log.Warn("quickCmd() output = ", result.Stdout)
-	return true
-}
-
-func globalBuildOptions(vbox *gui.Node) {
-	group1 := vbox.NewGroup("Global Build Options")
-	grid := group1.NewGrid("buildOptions", 0, 0)
-
-	// me.autoWorkingPwd = gadgets.NewOneLiner(grid, "working directory (pwd)")
-	me.userHomePwd = gadgets.NewOneLiner(grid, "user home")
-	grid.NextRow()
-	me.goSrcPwd = gadgets.NewOneLiner(grid, "go src home")
-	grid.NextRow()
-
-	usr, _ := user.Current()
-	homeDir, err := os.UserHomeDir()
-	if err != nil {
-		log.Warn("Error getting home directory:", err)
-		homeDir = "/home/autotypist"
-	}
-	me.userHomePwd.SetText(homeDir)
-	srcDir := filepath.Join(homeDir, "go/src")
-	me.goSrcPwd.SetText(srcDir)
-
-	// 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("set current branch to:", func() {
-		targetName := me.newBranch.String()
-		log.Warn("setting all branches to", targetName)
-		loop := me.repos.View.ReposSortByName()
-		for loop.Scan() {
-			repo := loop.Repo()
-			repo.Status.CheckoutBranch(targetName)
-			repo.Scan()
-		}
-	})
-	me.newBranch = grid.NewCombobox()
-	me.newBranch.AddText("master")
-	me.newBranch.AddText("devel")
-	me.newBranch.AddText(usr.Username)
-	me.newBranch.SetText(usr.Username)
-
-	// checking this will automatically make the branches off of devel
-	me.autoCreateBranches = grid.NewCheckbox("create if missing").SetChecked(true)
-	grid.NextRow()
-}

globalDisplayOptions.go

@@ -1,62 +0,0 @@
-package main
-
-import (
-	"go.wit.com/gui"
-	"go.wit.com/lib/gui/repolist"
-	"go.wit.com/log"
-)
-
-func hideFunction(r *repolist.RepoRow) {
-	/*
-		if r.Status.IsDirty() {
-			r.Show()
-			return
-		}
-		if me.autoHideReadOnly.Checked() {
-			if r.Status.ReadOnly() {
-				r.Hide()
-				return
-			}
-		}
-		if me.autoHidePerfect.Checked() {
-			if r.IsPerfect() {
-				r.Hide()
-				return
-			}
-		}
-		r.Show()
-	*/
-}
-
-func globalDisplayOptions(vbox *gui.Node) {
-	group1 := vbox.NewGroup("Global Display Options")
-
-	group1.NewButton("Show Repository Window", func() {
-		// globalDisplaySetRepoState()
-		if me.repos.Hidden() {
-			me.repos.Show()
-		} else {
-			me.repos.Hide()
-		}
-	})
-
-	me.autoHideReadOnly = group1.NewCheckbox("Hide read-only repos").SetChecked(true)
-	me.autoHideReadOnly.Custom = func() {
-		me.repos.View.RegisterHideFunction(hideFunction)
-		me.repos.View.ScanRepositories()
-	}
-
-	me.autoHidePerfect = group1.NewCheckbox("Hide Perfectly clean repos").SetChecked(true)
-	me.autoHidePerfect.Custom = func() {
-		me.repos.View.RegisterHideFunction(hideFunction)
-		me.repos.View.ScanRepositories()
-	}
-	scanbox := group1.Box().Horizontal()
-	me.autoScanReposCB = scanbox.NewCheckbox("auto scan").SetChecked(true)
-
-	scanbox.NewButton("scan now", func() {
-		log.Info("re-scanning repos now")
-		i, s := me.repos.View.ScanRepositories()
-		log.Info("re-scanning repos done", i, s)
-	})
-}

helperPatches.go

@@ -0,0 +1,340 @@
+// 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

@@ -1,11 +1,15 @@
+// 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 (
+	"embed"
 	"strings"
 
-	"go.wit.com/dev/alexflint/arg"
+	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
@@ -15,12 +19,20 @@ import (
 var VERSION string
 var BUILDTIME string
 
+// this optionally can store the GUI plugins
+//
+//go:embed resources/*
+var resources embed.FS
+
+// used for shell auto completion
+var ARGNAME string = "forge"
+
 // using this for now. triggers config save
 var configSave bool
 
 func getVersion(repo *gitpb.Repo, name string) string {
 	cmd := []string{"git", "describe", "--tags", "--always", name}
-	result := repo.RunQuiet(cmd)
+	result, _ := repo.RunQuiet(cmd)
 	output := strings.Join(result.Stdout, "\n")
 	log.Info("cmd =", cmd, output)
 
@@ -29,97 +41,190 @@ func getVersion(repo *gitpb.Repo, name string) string {
 
 func main() {
 	me = new(mainType)
-	me.pp = arg.MustParse(&argv)
+	me.myGui = prep.Gui()       // prepares the GUI package for go-args
-	me.urlbase = argv.URL
+	me.auto = prep.Bash3(&argv) // this line should be:  prep.Bash(&argv)
-	me.urlbase = strings.Trim(me.urlbase, "/") // track down why trailing '/' makes http POST not work
 
-	// load the ~/.config/forge/ config
+	// me.auto = prep.Bash3(argv.DoAutoComplete, &argv) // this line should be:  prep.Bash(&argv)
-	me.forge = forgepb.Init()
+	// arg.MustParse(&argv)                                      // these three lines are becoming terrible syntax
-	me.found = new(gitpb.Repos)
+	// me.auto = prep.MustParse(&argv)          // try to make this work?
 
-	if configSave {
+	me.forge = forgepb.Init() // init forge.pb
-		me.forge.ConfigSave()
+	me.forge.ScanRepoDir()    // looks for new dirs, checks existing repos for changes
-		configSave = false
-	}
 
-	if argv.Delete != "" {
+	// initialize patches
-		me.forge.DeleteByGoPath(argv.Delete)
+	doPatchInit()
-		me.forge.SetConfigSave(true)
-		okExit("")
-	}
-
-	/*
-		// var count int
-		all := me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			verifyPrint(repo)
-		}
-	*/
-
-	if argv.Fix {
-		okExit("")
-	}
 
 	// first find the repos or gopaths to operate on
-	if argv.Config {
+	if argv.Config != nil {
-		if findConfig() {
+		doConfig()
-			me.forge.ConfigPrintTable()
 		okExit("")
 	}
-	} else {
-		findRepos()
-	}
-	// okExit("")
 
-	log.Info("found", me.found.Len(), "repos. found", len(me.foundPaths), "paths from .config/forge")
+	if argv.Commit != nil {
-
+		doCommit()
-	// now, do something to all of them (or just print out a table of them)
+		okExit("")
-	var done bool = false
-	if argv.DoScan {
-		doScan()
-		done = true
 	}
 
-	if argv.DoRedoGoMod {
+	if argv.BuildForge {
-		doRedoGoMod()
+		buildForge()
-		done = true
+		okExit("")
 	}
 
-	if argv.DoGitPull {
+	if argv.Checkout != nil {
-		doGitPull()
+		if err := doCheckout(); err != nil {
-		done = true
+			badExit(err)
+		}
+		okExit("")
 	}
 
-	if argv.DoGitReset {
+	if argv.Build != "" {
-		doGitReset()
+		if err := doBuild(); err != nil {
-		done = true
+			badExit(err)
+		}
+		okExit("")
 	}
 
-	if argv.DoList {
+	if argv.Install != "" {
+		if err := doInstall(); err != nil {
+			badExit(err)
+		}
+		okExit("")
+	}
+
+	if argv.Clean != nil {
+		if err := doClean(); err != nil {
+			badExit(err)
+		}
+		me.forge.ConfigSave()
+		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("")
+			}
+			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)
+		}
+		okExit("")
+	}
+
+	if argv.Pull != nil {
+		doPull()
+		okExit("")
+	}
+
+	if argv.List != nil {
+		found := argv.List.findRepos()
 		// print out the repos
-		doCobol()
+		if argv.List.Full {
-		done = true
+			me.forge.PrintHumanTableFull(found)
+		} else {
+			me.forge.PrintHumanTable(found)
+		}
+		okExit("")
 	}
 
-	if argv.DoPatchSet {
+	if argv.Patch != nil {
-		sendDevelDiff()
+		if err := doPatch(); err != nil {
-		// sendMasterDiff()
+			badExit(err)
-		okExit("patches")
+		}
+		okExit("")
 	}
 
-	if argv.ListPatchSet {
+	// open the gui unless the user performed some other
-		listPatches()
+	// basically, if you run just 'forge' it should open the GUI
-		okExit("patches")
-	}
 
-	// do the gui at the very end
+	if argv.Gui != nil {
-	if argv.DoGui {
+		// if opening the GUI, always check git for dirty repos
-		doGui()
+		me.forge.CheckDirty()
+
+		me.myGui.Start() // loads the GUI toolkit
+		doGui()          // start making our forge GUI
+		debug()          // sits here forever
 	}
-	if !done {
+	// got to the end with nothing to do (?)
-		// if nothing was selected, print out a table of them on STDOUT
+	if dumpWorkRepos() {
-		doCobol()
+		// 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: ?")
+	okExit("")
+}

post.go

@@ -1,50 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"os/user"
-
-	"go.wit.com/log"
-)
-
-func httpPost(url string, data []byte) ([]byte, error) {
-	var err error
-	var req *http.Request
-
-	// data := []byte("some junk")
-	// url := "https://go.wit.com/register/"
-
-	req, err = http.NewRequest(http.MethodPost, url, bytes.NewBuffer(data))
-	log.Info("httpPost() with len", len(data), "url", url)
-
-	usr, _ := user.Current()
-	req.Header.Set("author", usr.Username)
-	hostname, _ := os.Hostname()
-	req.Header.Set("hostname", hostname)
-
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Error(err)
-		return []byte("client.Do(req) error"), err
-	}
-	defer resp.Body.Close()
-	log.Info("httpPost() with len", len(data))
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		log.Error(err)
-		return body, err
-	}
-
-	// test := strings.TrimSpace(string(body))
-	// log.Info("go.wit.com returned body:", test)
-	// if test == "OK" {
-	// 	return body, nil
-	// }
-
-	return body, nil
-}

repoview.go

@@ -1,202 +0,0 @@
-package main
-
-import (
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/gui/repolist"
-	"go.wit.com/log"
-
-	"go.wit.com/gui"
-)
-
-type repoWindow struct {
-	win *gadgets.BasicWindow
-	box *gui.Node
-
-	// the top box of the repolist window
-	topbox *gui.Node
-
-	View *repolist.RepoList
-}
-
-func (r *repoWindow) Hidden() bool {
-	return r.win.Hidden()
-}
-
-func (r *repoWindow) Show() {
-	r.win.Show()
-}
-
-func (r *repoWindow) Hide() {
-	r.win.Hide()
-}
-
-func (r *repoWindow) Disable() {
-	r.box.Disable()
-}
-
-func (r *repoWindow) Enable() {
-	r.box.Enable()
-}
-
-// you can only have one of these
-func makeRepoView() *repoWindow {
-	if me.repos != nil {
-		return me.repos
-	}
-	r := new(repoWindow)
-	r.win = gadgets.RawBasicWindow("All git repositories in ~/go/src/")
-	r.win.Make()
-
-	r.box = r.win.Box().NewBox("bw vbox", false)
-	// me.reposwin.Draw()
-	r.win.Custom = func() {
-		log.Warn("GOT HERE: main() gadgets.NewBasicWindow() close")
-		log.Warn("Should I do something special here?")
-	}
-
-	r.topbox = r.repoMenu()
-
-	r.View = repolist.InitBox(me.forge, r.box)
-	r.View.Enable()
-
-	r.View.ScanRepositories()
-
-	/*
-		r.View = repolist.AutotypistView(r.box)
-
-		showncount := r.View.MirrorShownCount()
-		r.topbox.Append(showncount)
-		duration := r.View.MirrorScanDuration()
-		r.topbox.Append(duration)
-	*/
-	return r
-}
-
-func (r *repoWindow) repoMenu() *gui.Node {
-	// reposbox.SetExpand(false)
-	group1 := r.box.NewGroup("Run on all repos:")
-
-	hbox := group1.Box()
-	// hbox.Horizontal()
-	hbox.Vertical()
-
-	box2 := hbox.Box().Vertical()
-	/*
-		box2.NewButton("merge all user to devel", func() {
-			r.Disable()
-			if !r.mergeAllUserToDevel() {
-				return
-			}
-			r.Enable()
-		})
-
-		box2.NewButton("merge all devel to main", func() {
-			r.Disable()
-			if !r.mergeAllDevelToMain() {
-				return
-			}
-			r.Enable()
-		})
-	*/
-
-	box2.NewButton("merge it all", func() {
-		r.Disable()
-		if !r.mergeAllUserToDevel() {
-			return
-		}
-		if !r.mergeAllDevelToMain() {
-			return
-		}
-		r.Enable()
-	})
-
-	box2.NewButton("show apps", func() {
-		loop := me.repos.View.ReposSortByName()
-		for loop.Scan() {
-			repo := loop.Repo()
-			rtype := repo.Status.RepoType()
-			switch rtype {
-			case "'binary'":
-				// log.Info(repo.Status.Path(), "compile here. Show()")
-				repo.Show()
-			case "'library'":
-				// log.Info(repo.Status.Path(), "library here. Hide()")
-				repo.Hide()
-			default:
-				log.Info(repo.Status.Path(), "unknown type", rtype)
-				// repo.Hide()
-			}
-		}
-	})
-	box2.NewButton("scan now", func() {
-		log.Info("re-scanning now")
-		i, s := me.repos.View.ScanRepositories()
-		log.Info("re-scanning done", i, "repos in", s)
-	})
-
-	return box2
-}
-
-func (r *repoWindow) mergeAllDevelToMain() bool {
-	log.Info("merge all here")
-	loop := me.repos.View.ReposSortByName()
-	for loop.Scan() {
-		repo := loop.Repo()
-		if repo.ReadOnly() {
-			log.Info("skipping readonly", repo.Name(), repo.State())
-			continue
-		}
-		if repo.State() != "merge to main" {
-			log.Info("skipping. not merge to main", repo.Name(), repo.State())
-			continue
-		}
-		if repo.CheckDirty() {
-			log.Info("skipping dirty", repo.Name(), repo.State())
-			continue
-		}
-		log.Info("repo:", repo.Name(), repo.State())
-		repo.NewScan()
-		if repo.Status.MergeDevelToMaster() {
-			log.Warn("THINGS SEEM OK fullAutomation() returned true.")
-		} else {
-			log.Warn("last repo:", repo.Name())
-			log.Warn("THINGS FAILED fullAutomation() returned false")
-			return false
-		}
-		repo.NewScan()
-	}
-	log.Warn("EVERYTHING WORKED")
-	return true
-}
-
-func (r *repoWindow) mergeAllUserToDevel() bool {
-	log.Info("merge all here")
-	loop := me.repos.View.ReposSortByName()
-	for loop.Scan() {
-		repo := loop.Repo()
-		if repo.ReadOnly() {
-			log.Info("skipping readonly", repo.Name(), repo.State())
-			continue
-		}
-		if repo.State() != "merge to devel" {
-			log.Info("skipping. not merge to devel", repo.Name(), repo.State())
-			continue
-		}
-		if repo.CheckDirty() {
-			log.Info("skipping dirty", repo.Name(), repo.State())
-			continue
-		}
-		log.Info("repo:", repo.Name(), repo.State())
-		repo.NewScan()
-		if repo.Status.MergeUserToDevel() {
-			log.Warn("THINGS SEEM OK fullAutomation() returned true.")
-		} else {
-			log.Warn("last repo:", repo.Status.Path())
-			log.Warn("THINGS FAILED fullAutomation() returned false")
-			return false
-		}
-		repo.NewScan()
-	}
-	log.Warn("EVERYTHING WORKED")
-	return true
-}

resources/forge.text

@@ -0,0 +1,22 @@
+# this file is intended to be used to customize settings on what
+# git repos you have write access to. That is, where you can run 'git push'
+#
+# add entries to this using 'forge config'
+
+ForgeConfigs:  {
+  goPath:  "go.wit.com"
+  writable:  true
+  directory:  true
+}
+repos: {
+  goPath: "go.wit.com/apps/zookeeper"
+  debName: "zookeeper-go"
+}
+xterm:  "xterm"
+xtermArgv:  "-bg"
+xtermArgv:  "black"
+xtermArgv:  "-fg"
+xtermArgv:  "white"
+xtermArgv:  "-geometry"
+xtermArgv:  "140x32"
+xtermArgv:  "-e"

send.go

@@ -1,102 +0,0 @@
-// Copyright 2024 WIT.COM Inc Licensed GPL 3.0
-
-package main
-
-import (
-	"strings"
-
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/log"
-)
-
-func sendPatches(pset *forgepb.Patchs) error {
-	var url string
-	url = me.urlbase + "/patchset"
-	msg, err := pset.Marshal()
-	if err != nil {
-		log.Info("proto.Marshal() failed:", err)
-		return err
-	}
-	log.Info("proto.Marshal() msg len", len(msg))
-	body, err := httpPost(url, msg)
-	if err != nil {
-		log.Info("httpPost() failed:", err)
-		return err
-	}
-
-	test := strings.TrimSpace(string(body))
-	// log.Info("virtigo returned body:", test)
-	for _, line := range strings.Split(test, "\n") {
-		log.Info("got back:", line)
-	}
-	return nil
-}
-
-func listPatches() error {
-	var url string
-	url = me.urlbase + "/patchsetlist"
-	body, err := httpPost(url, nil)
-	if err != nil {
-		log.Info("httpPost() failed:", err)
-		return err
-	}
-
-	var last string
-	test := strings.TrimSpace(string(body))
-	for _, line := range strings.Split(test, "\n") {
-		log.Info("patchset:", line)
-		last = strings.TrimSpace(line)
-	}
-	getPatch(last)
-	return nil
-}
-
-func getPatch(pbfile string) error {
-	url := me.urlbase + "/patchsetget?filename=" + pbfile
-	log.Info("getPatch() url", url)
-	body, err := httpPost(url, nil)
-	if err != nil {
-		log.Info("httpPost() failed:", err)
-		return err
-	}
-	log.Info("getPatch() len(body)", len(body))
-	return nil
-}
-
-func sendDevelDiff() {
-	pset, err := me.forge.MakeDevelPatchSet()
-	if err != nil {
-		badExit(err)
-	}
-	if err := sendPatches(pset); err != nil {
-		badExit(err)
-	}
-
-	/*
-		all := pset.SortByFilename()
-		for all.Scan() {
-			p := all.Next()
-			log.Info("read in patch:", p.Filename)
-		}
-		err = me.forge.SendPatchSet(pset)
-		if err != nil {
-			badExit(err)
-		}
-	*/
-}
-
-func sendMasterDiff() {
-	pset, err := me.forge.MakeMasterPatchSet()
-	if err != nil {
-		badExit(err)
-	}
-	all := pset.SortByFilename()
-	for all.Scan() {
-		p := all.Next()
-		log.Info("read in patch:", p.Filename)
-	}
-	err = me.forge.SendPatchSet(pset)
-	if err != nil {
-		badExit(err)
-	}
-}

structs.go

@@ -1,11 +1,13 @@
+// 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/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
@@ -18,54 +20,32 @@ 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 alexf lint!
+	// pp         *arg.Parser    // for parsing the command line args.  Yay to alexflint!
+	auto       *prep.Auto     // more experiments for bash handling
 	forge      *forgepb.Forge // for holding the forge protobuf files
-	myGui      *gui.Node      // the gui toolkit handle
+	myGui      *prep.GuiPrep  // for initializing the GUI toolkits
-	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
 
-	// our view of the repositories
-	repos *repoWindow
-
 	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
 
-	// the main box. enable/disable this
+	// these hold the branches that the user can switch all the repositories to them
-	mainbox *gui.Node
+	reposWinB       *gui.Node // button that opens the repos window
-
+	repoAllB        *gui.Node // "all" repos button
-	// the window from the /lib/gui/gowit package
+	repoDirtyB      *gui.Node // "dirty" repos button
-	lw *gadgets.BasicWindow
+	repoDevelMergeB *gui.Node // "merge to devel" repos button
-
+	repoWritableB   *gui.Node // "what repos are writable" repos button
-	// #### 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 your home dir
-	userHomePwd *gadgets.OneLiner
-
-	// what is being used as ~/go/src
-	goSrcPwd *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
-	setBranchB *gui.Node
 }

subitPatches.go

@@ -1,240 +0,0 @@
-package main
-
-import (
-	"path/filepath"
-	"strconv"
-
-	"go.wit.com/gui"
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/gui/repolist"
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/log"
-)
-
-/*
-type patch struct {
-	ref     string
-	giturl  string
-	comment string
-	rs      *repostatus.RepoStatus
-}
-*/
-
-type patchSummary struct {
-	grid     *gui.Node
-	updateB  *gui.Node
-	docsB    *gui.Node
-	gitPushB *gui.Node
-	gitPullB *gui.Node
-	checkB   *gui.Node
-
-	// stats
-	totalOL            *gadgets.OneLiner
-	totalGoOL          *gadgets.OneLiner
-	dirtyOL            *gadgets.OneLiner
-	readonlyOL         *gadgets.OneLiner
-	totalPatchesOL     *gadgets.OneLiner
-	totalUserRepos     *gui.Node
-	totalDevelRepos    *gui.Node
-	totalMasterRepos   *gui.Node
-	totalUserPatches   *gui.Node
-	totalDevelPatches  *gui.Node
-	totalMasterPatches *gui.Node
-
-	// patch set generation
-	unknownOL      *gadgets.BasicEntry
-	unknownSubmitB *gui.Node
-	reason         *gadgets.BasicEntry
-	submitB        *gui.Node
-	allp           []*repolist.Patch
-}
-
-func submitPatchesBox(box *gui.Node) *patchSummary {
-	s := new(patchSummary)
-	group1 := box.NewGroup("Submit Patches Summary")
-	s.grid = group1.RawGrid()
-
-	s.grid.NewButton("Update Patch Counts", func() {
-		var repocount, patchcount int
-		// broken after move to forge protobuf
-		all := me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			if repo.GetReadOnly() {
-				continue
-			}
-			i, _ := repo.GetMasterPatches()
-			patchcount += i
-			if i > 0 {
-				repocount += 1
-			}
-		}
-		s.totalMasterPatches.SetText(strconv.Itoa(patchcount) + " patches")
-		s.totalMasterRepos.SetText(strconv.Itoa(repocount) + " go repos")
-
-		repocount = 0
-		patchcount = 0
-		// broken after move to forge protobuf
-		all = me.forge.Repos.SortByFullPath()
-		for all.Scan() {
-			repo := all.Next()
-			if repo.GetReadOnly() {
-				continue
-			}
-			i, _ := repo.GetUserPatches()
-			patchcount += i
-			if i > 0 {
-				repocount += 1
-			}
-		}
-		s.totalUserPatches.SetText(strconv.Itoa(patchcount) + " patches")
-		s.totalUserRepos.SetText(strconv.Itoa(repocount) + " go repos")
-	})
-
-	/* this used to be the way and should probably be revisited
-	s.grid.NewButton("Make Patches", func() {
-		for i, p := range s.allp {
-			log.Info(i, p.Ref, p.RS.String())
-		}
-	})
-	*/
-
-	s.grid.NextRow()
-
-	s.totalOL = gadgets.NewOneLiner(s.grid, "Total")
-	s.grid.NextRow()
-
-	s.totalGoOL = gadgets.NewOneLiner(s.grid, "Total GO")
-	s.grid.NextRow()
-
-	s.dirtyOL = gadgets.NewOneLiner(s.grid, "dirty")
-	s.grid.NextRow()
-
-	s.readonlyOL = gadgets.NewOneLiner(s.grid, "read-only")
-	s.grid.NextRow()
-
-	// s.grid = group1.RawGrid()
-	s.grid.NewLabel("")
-	s.grid.NewLabel("")
-	s.grid.NewLabel("user to devel")
-	s.grid.NewLabel("devel to master")
-	s.grid.NewLabel("master to last tag")
-	s.grid.NextRow()
-
-	s.grid.NewLabel("total modified")
-	s.grid.NewLabel("")
-	s.totalUserRepos = s.grid.NewLabel("x go repos")
-	s.totalDevelRepos = s.grid.NewLabel("")
-	s.totalMasterRepos = s.grid.NewLabel("x go repos")
-	s.grid.NextRow()
-
-	s.totalPatchesOL = gadgets.NewOneLiner(s.grid, "total commits")
-	s.totalUserPatches = s.grid.NewLabel("x patches")
-	s.totalDevelPatches = s.grid.NewLabel("")
-	s.totalMasterPatches = s.grid.NewLabel("x patches")
-	s.grid.NextRow()
-
-	s.grid.NewLabel("")
-	s.grid.NewLabel("")
-	s.grid.NewButton("merge from user", func() {
-		log.Info("this should make a patchset of your patches")
-	})
-	s.grid.NewButton("merge from devel", func() {
-		log.Info("this probably should not exist")
-	})
-	s.grid.NextRow()
-
-	group1 = box.NewGroup("Create GUI Patch Set")
-	s.grid = group1.RawGrid()
-	s.reason = gadgets.NewBasicEntry(s.grid, "patch name:")
-	s.reason.Custom = func() {
-		if s.reason.String() != "" {
-			s.submitB.Enable()
-		} else {
-			s.submitB.Disable()
-		}
-	}
-	s.submitB = s.grid.NewButton("Create Patch Set", func() {
-		dirname := "submit-patchset.quilt"
-		patchdir := filepath.Join(me.userHomePwd.String(), dirname)
-		if shell.Exists(patchdir) {
-			log.Info("patchset dir already exists", patchdir)
-			shell.PathRun(me.userHomePwd.String(), []string{"rm", "-rf", dirname})
-		}
-		shell.Mkdir(patchdir)
-		if !shell.Exists(patchdir) {
-			log.Info("something went wrong making", patchdir)
-			return
-		}
-		me.repos.View.MakePatchset(patchdir)
-	})
-	s.submitB = s.grid.NewButton("Submit quilt", func() {
-		log.Info("do a submit here")
-	})
-	// disable these until there are not dirty repos
-	s.reason.Disable()
-	s.submitB.Disable()
-	s.grid.NextRow()
-
-	// s.unknownOL.Disable()
-	// s.unknownSubmitB.Disable()
-	s.grid.NextRow()
-
-	return s
-}
-
-// does not run any commands
-func (s *patchSummary) Update() {
-	var total, totalgo, dirty, readonly int
-	var userT, develT, masterT int
-	// var userP, develP, masterP int
-	// broken after move to forge protobuf
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		total += 1
-		if repo.IsDirty() {
-			dirty += 1
-		}
-		if repo.GetReadOnly() {
-			readonly += 1
-			// don't count these in any further stats
-			continue
-		}
-		// compute which GUI repos are out of sync with master
-		userV := repo.GetUserVersion()
-		develV := repo.GetDevelVersion()
-		masterV := repo.GetMasterVersion()
-		lastV := repo.GetLastTagVersion()
-		if userV != develV {
-			userT += 1
-		}
-		if develV != masterV {
-			log.Info("develV != masterV", develV, masterV, repo.GetGoPath())
-			develT += 1
-		}
-		if masterV != lastV {
-			masterT += 1
-		}
-	}
-	s.totalOL.SetText(strconv.Itoa(total) + " repos")
-	s.totalGoOL.SetText(strconv.Itoa(totalgo) + " repos")
-	s.dirtyOL.SetText(strconv.Itoa(dirty) + " repos")
-	s.readonlyOL.SetText(strconv.Itoa(readonly) + " repos")
-
-	s.totalUserRepos.SetText(strconv.Itoa(userT) + " repos")
-	s.totalDevelRepos.SetText(strconv.Itoa(develT) + " repos")
-	s.totalMasterRepos.SetText(strconv.Itoa(masterT) + " repos")
-
-	if dirty == 0 {
-		s.reason.Enable()
-		s.submitB.Enable()
-		// s.unknownOL.Enable()
-		// s.unknownSubmitB.Enable()
-	} else {
-		s.reason.Disable()
-		s.submitB.Enable()
-		// s.unknownOL.Enable()
-		// s.unknownSubmitB.Enable()
-	}
-}

windowHowto.go

@@ -0,0 +1,118 @@
+// 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 (
+	"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")
+	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()
+	grid.NewLabel("forge")
+	grid.NewLabel("the sources for forge")
+	grid.NextRow()
+
+	grid.NewLabel("autogenpb")
+	grid.NewLabel("generates needed code for working with the protobuf files")
+	grid.NextRow()
+
+	grid.NewLabel("go-clone")
+	grid.NewLabel("recursively 'git clone' dependencies based on go.mod")
+	grid.NextRow()
+
+	grid.NewLabel("the GUI")
+	grid.NewLabel("GO plugins for libcurses and GTK")
+	grid.NextRow()
+
+	grid.NewLabel("") // a stupid way to add padding
+	grid.NextRow()
+
+	// howtoWin.Group.NewLabel("Working dir: " + me.forge.Config.ReposDir)
+
+	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()
+	})
+	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

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

windowPublish.go

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

windowReposFix.go

@@ -0,0 +1,393 @@
+// 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

@@ -0,0 +1,185 @@
+// 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

@@ -0,0 +1,147 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+import (
+	"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 repoPatchWindow 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.Set // 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 *repoPatchWindow) Hidden() bool {
+	return w.win.Hidden()
+}
+
+// switches between the window being visable or hidden on the desktop
+func (w *repoPatchWindow) Toggle() {
+	if w.Hidden() {
+		w.Show()
+	} else {
+		w.Hide()
+	}
+}
+
+// hides the window completely
+func (w *repoPatchWindow) Show() {
+	w.win.Show()
+}
+
+func (w *repoPatchWindow) Hide() {
+	w.win.Hide()
+}
+
+// should be the first box/widget in the window
+// greys out the window to the user
+func (w *repoPatchWindow) Disable() {
+	w.stack.Disable()
+}
+
+func (w *repoPatchWindow) Enable() {
+	w.stack.Enable()
+}
+
+// you can only have one of these
+func makeRepoPatchWindow(repo *gitpb.Repo, fset []*forgepb.Patch) *repoPatchWindow {
+	pw := new(repoPatchWindow)
+
+	// sync.Once()
+	pw.win = gadgets.RawBasicWindow("Patcheset for " + repo.GetGoPath())
+	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(repo.GetGoPath())
+	grid.NewLabel(repo.GetCurrentBranchName())
+
+	g := pw.stack.NewGroup("PatchSet List")
+
+	// make a grid and a header
+	filegrid := g.NewGrid("", 0, 0)
+	filegrid.NewLabel("patch name")
+	filegrid.NewLabel("Applied in current branch?")
+	filegrid.NewLabel("original hash")
+	filegrid.NewLabel("new hash")
+	filegrid.NewButton("git squash", func() {
+	})
+	filegrid.NewButton("git am", func() {
+	})
+	filegrid.NextRow()
+
+	for _, p := range fset {
+		filegrid.NewLabel(p.Comment)
+		filegrid.NewLabel("yes?")
+		filegrid.NewLabel(p.CommitHash)
+		filegrid.NewLabel(p.NewHash)
+		filegrid.NewCheckbox("").SetChecked(true)
+		filegrid.NewCheckbox("").SetChecked(true)
+		filegrid.NextRow()
+	}
+	// add the patches to the grid
+	// pw.addPatchset(filegrid, pset)
+	return pw
+}
+
+func (r *repoPatchWindow) addPatchset(grid *gui.Node, pset *forgepb.Set) {
+	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.Namespace
+		repo := me.forge.FindByGoPath(s)
+		if repo == nil {
+			log.Info("COULD NOT FIND", s)
+			continue
+		}
+		repomap[repo] = append(repomap[repo], p)
+		repohash[repo] = p.StartHash
+	}
+
+	for repo, patches := range repomap {
+		log.Info(repo.GetGoPath())
+		grid.NewLabel(repo.GetGoPath())
+
+		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(hash)
+		grid.NewButton("View", func() {
+			log.Info("todo: show patches for repo", repo.GetGoPath())
+		})
+		grid.NextRow()
+	}
+}