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,43 +1,86 @@
 VERSION = $(shell git describe --tags)
-BUILDTIME = $(shell date +%Y.%m.%d)
+BUILDTIME = $(shell date +%Y.%m.%d_%H%M)
 
-info: install
-	# forge dirty
-	forge examine
+# make build     # go build   using your git cloned repos (GO111MODULE=off)
+# make install   # go install using your git cloned repos (GO111MODULE=off)
+# make gocui     # try the ncurses gui plugin
+# make andlabs   # try the andlabs gui plugin (uses GTK)
+
+default: install-verbose tag
+
+tag:
+	forge tag list
 
 vet:
 	@GO111MODULE=off go vet
 	@echo this go binary package builds okay
 
-verbose:
-	GO111MODULE=off go build -v -x \
+build: goimports vet plugin
+	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
 	goimports -w *.go
 	@# // to globally reset paths:
 	@# // gofmt -w -r '"go.wit.com/gui/gadgets" -> "go.wit.com/lib/gadgets"' *.go
 
-gocui: install
-	forge --gui gocui  >/tmp/forge.log 2>&1
+clean:
+	-rm -f forge go.*
+	# -rm -f ~/go/src/repos.pb
+	go-mod-clean purge
 
-patches-make: install
-	forge --patchset "from makefile 2"
+identify-protobuf:
+	autogenpb --identify ~/go/src/repos.pb
 
-patches-list-2233: install
-	forge --list-patchset --connect "http://go.wit.com:2233/"
+devel:
+	forge clean devel --force --verbose
 
-patches-list: install
-	forge --list-patchset
+pull: install
+	FORGE_URL="https://forge.grid.wit.com/" forge pull check
 
-patches-apply-230233: install
-	forge --apply /tmp/2024.12.27.230233.submitted.pb
+# cloudflare blocks POST due to captcha checks / human detection?
+# POST must be direct socket. probably for the best anyway
+submit:
+	FORGE_URL="https://forge.grid.wit.com/" forge patch submit "forge auto commit"
 
-restart:
-	reset
-	-rm ~/go/src/repos.pb
-	make private
+commit:
+	FORGE_URL="https://forge.grid.wit.com/" forge commit --all
+
+check: install
+	FORGE_URL="https://forge.grid.wit.com/" forge patch check
+
+doc:
+	echo "/*" > doc.go
+	forge -h >> doc.go
+	echo "*/" >> doc.go
+	echo "package main" >> doc.go

README.md

@@ -1,10 +1,79 @@
-forge
+# 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
 
-/usr/share/git-gui/lib/tools/
-.git/config settings for gitgui
-[gui]
-	wmstate = normal
-	geometry = 931x515+450+130 197 234
+* 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

@@ -1,77 +1,21 @@
-// Copyright 2024 WIT.COM Inc Licensed GPL 3.0
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
 
 package main
 
-import (
-	"os"
-	"path/filepath"
-
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-// returns bad if patches can not be applied
-func dumpPatchset(pset *forgepb.Patchset) bool {
-	log.Info("applyPatches() NAME", pset.Name)
-	log.Info("applyPatches() COMMENT", pset.Comment)
-	log.Info("applyPatches() GIT_AUTHOR_NAME", pset.GetGitAuthorName())
-	log.Info("applyPatches() GIT_AUTHOR_EMAIL", pset.GetGitAuthorEmail())
-	log.Info("applyPatches() Branch Name", pset.GetStartBranchName())
-	log.Info("applyPatches() Start Hash", pset.GetStartBranchHash())
-
-	var count int
-	var bad int
-	all := pset.Patches.SortByFilename()
-	for all.Scan() {
-		p := all.Next()
-		if IsValidPatch(p) {
-			// ok
-		} else {
-			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 repo == nil {
-		log.Info("can not apply patch! repo not found", basepath, filename)
-		return false
-	}
-	if repo.DevelHash() != p.StartHash {
-		log.Info("can not apply patch! devel hash mismatch", basepath, filename)
-		return false
-	}
-	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
-}
-
-// re-run git CheckDirty() on everything
-func IsAnythingDirty() bool {
-	me.found = new(gitpb.Repos)
-	findAll() // select all the repos
-	doCheckDirtyAndConfigSave()
-	me.found = new(gitpb.Repos)
-	findDirty()
-	if len(me.found.Repos) == 0 {
-		return false
-	} else {
-		return true
-	}
+/*
+// 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
@@ -85,69 +29,20 @@ func countCurrentPatches(repo *gitpb.Repo) int {
 	return len(result.Stdout)
 }
 
-func applyPatchset(pset *forgepb.Patchset) error {
-	var everythingworked bool = true
-	tmpdir, err := os.MkdirTemp("", "forge")
+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
 	}
-	// log.Info("got to applyPatches() pset", pset)
-	log.Info("applyPatches() NAME", pset.Name)
-	log.Info("applyPatches() COMMENT", pset.Comment)
-	log.Info("applyPatches() GIT_AUTHOR_NAME", pset.GetGitAuthorName())
-	log.Info("applyPatches() GIT_AUTHOR_EMAIL", pset.GetGitAuthorEmail())
-	all := pset.Patches.SortByFilename()
-	for all.Scan() {
-		p := all.Next()
-		// log.Info("pset filename FILENAME IS REAL?", p.Filename, pset.Name, pset.Comment)
-		basepath, filename := filepath.Split(p.Filename)
-		fullpath := filepath.Join(me.forge.GetGoSrc(), basepath)
-		log.Info("pset filename FILENAME IS REAL? fullpath", fullpath)
-		fullTmpdir := filepath.Join(tmpdir, basepath)
-		err := os.MkdirAll(fullTmpdir, os.ModePerm)
-		if err != nil {
-			log.Info("applyPathces() MkdirAll failed for", fullTmpdir)
-			log.Info("applyPathces() MkdirAll failed err", err)
-			everythingworked = false
-			continue
-		}
-		log.Info("pset filename FILENAME IS REAL? tmp fullTmpdir", fullTmpdir)
-		tmpname := filepath.Join(fullTmpdir, filename)
-		raw, _ := os.OpenFile(tmpname, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-		raw.Write(p.Data)
-		raw.Close()
-		cmd := []string{"git", "am", tmpname}
-		result := shell.PathRun(fullpath, cmd)
-		if result.Exit != 0 {
-			log.Info("cmd failed", cmd, result.Exit)
-			everythingworked = false
-		}
-		// until 'git am' works
-		everythingworked = false
+
+	test := strings.TrimSpace(string(body))
+	for _, line := range strings.Split(test, "\n") {
+		line = strings.TrimSpace(line)
+		log.Info("server returned:", line)
 	}
-	if everythingworked {
-		os.RemoveAll(tmpdir) // clean up
-	}
-	log.Info("THIS IS THE END MY FRIEND")
 	return nil
 }
-
-func readPatchFile(pbfile string) (*forgepb.Patchset, error) {
-	bytes, err := os.ReadFile(pbfile)
-	if err != nil {
-		log.Info("readfile error", pbfile, err)
-		return nil, err
-	}
-	return handleBytes(bytes)
-}
-
-func handleBytes(bytes []byte) (*forgepb.Patchset, error) {
-	var pset *forgepb.Patchset
-	pset = new(forgepb.Patchset)
-	err := pset.Unmarshal(bytes)
-	if err != nil {
-		log.Info("Unmarshal failed", err)
-		return nil, err
-	}
-	return pset, nil
-}
+*/

argv.go

@@ -1,8 +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 (
 	"fmt"
 	"os"
+
+	"go.wit.com/lib/gui/prep"
 )
 
 /*
@@ -12,34 +17,75 @@ import (
 var argv args
 
 type args struct {
-	Checkout *CheckoutCmd `arg:"subcommand:checkout"                  help:"switch git branches"`
-	Config   *ConfigCmd   `arg:"subcommand:config"                    help:"show your .config/forge/ settings"`
-	Dirty    *DirtyCmd    `arg:"subcommand:dirty"                     help:"check if your git repos are dirty"`
-	GitReset *EmptyCmd    `arg:"subcommand:hard-reset"                help:"hard reset your user git branches"`
-	List     *FindCmd     `arg:"subcommand:list"                      help:"just show a table of the current state"`
-	Patch    *PatchCmd    `arg:"subcommand:patch"                     help:"examine and make patch sets"`
-	GitPull  *FindCmd     `arg:"subcommand:pull"                      help:"run 'git pull'"`
-	Rescan   *EmptyCmd    `arg:"subcommand:rescan"                    help:"recreate the git protobuf repos.pb file"`
-	Delete   *EmptyCmd    `arg:"subcommand:delete"                    help:"untrack a repo"`
-	Commit   *EmptyCmd    `arg:"subcommand:commit"                    help:"smart 'git commit' (errors out if on wrong branch)"`
-	Examine  *EmptyCmd    `arg:"subcommand:examine"                   help:"examine branches"`
-	URL      string       `arg:"--connect"                            help:"gowebd url"`
-	All      bool         `arg:"--all"                                help:"git commit --all"`
-	Show     string       `arg:"--show"                               help:"show a repo"`
-	Bash     bool         `arg:"--bash"                               help:"generate bash completion"`
-	BashAuto []string     `arg:"--auto-complete"                      help:"does the actual autocompletion"`
-	Force    bool         `arg:"--force"                              help:"try to strong arm things"`
+	Help       *EmptyCmd    `arg:"subcommand:help"                      help:"New to forge? This is for you.'"`
+	Checkout   *CheckoutCmd `arg:"subcommand:checkout"                  help:"switch branches using 'git checkout'"`
+	Clean      *CleanCmd    `arg:"subcommand:clean"                     help:"start over at the beginning"`
+	Commit     *CommitCmd   `arg:"subcommand:commit"                    help:"'git commit' but errors out if on wrong branch"`
+	Config     *ConfigCmd   `arg:"subcommand:config"                    help:"show your .config/forge/ settings"`
+	Dirty      *DirtyCmd    `arg:"subcommand:dirty"                     help:"show dirty git repos"`
+	GitFetch   *FindCmd     `arg:"subcommand:fetch"                     help:"run 'git fetch master'"`
+	Gui        *EmptyCmd    `arg:"subcommand:gui"                       help:"open the gui"`
+	List       *FindCmd     `arg:"subcommand:list"                      help:"print a table of the current repos"`
+	Merge      *MergeCmd    `arg:"subcommand:merge"                     help:"merge branches"`
+	Normal     *NormalCmd   `arg:"subcommand:normal"                    help:"set every repo to the default state for software development"`
+	Patch      *PatchCmd    `arg:"subcommand:patch"                     help:"make patchsets"`
+	Pull       *PullCmd     `arg:"subcommand:pull"                      help:"run 'git pull'"`
+	Tag        *TagCmd      `arg:"subcommand:tag"                       help:"manage git tags"`
+	URL        string       `arg:"--connect"                            help:"forge url"`
+	All        bool         `arg:"--all"                                help:"git commit --all"`
+	Build      string       `arg:"--build"                              help:"build a repo"`
+	Install    string       `arg:"--install"                            help:"install a repo"`
+	BuildForge bool         `arg:"--forge-rebuild"                      help:"download and rebuild forge"`
+	Force      bool         `arg:"--force"                              help:"try to strong arm things"`
+	Verbose    bool         `arg:"--verbose"                            help:"show more output"`
 }
 
 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 {
-	List   *EmptyCmd `arg:"subcommand:list"          help:"list available patches"`
-	Show   *EmptyCmd `arg:"subcommand:show"          help:"show a specific patch"`
-	Submit string    `arg:"--submit"                          help:"name of patchset"`
+	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 {
@@ -51,6 +97,7 @@ type ConfigAddCmd struct {
 	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"`
@@ -70,8 +117,13 @@ type CheckoutCmd struct {
 	Master *FindCmd `arg:"subcommand:master"                    help:"git checkout master"`
 }
 
+type MergeCmd struct {
+	Devel   *FindCmd  `arg:"subcommand:devel"                     help:"merge user to devel"`
+	Master  *FindCmd  `arg:"subcommand:master"                    help:"merge devel to master"`
+	Publish *EmptyCmd `arg:"subcommand:publish"                    help:"increment versions and publish master branch"`
+}
+
 type DirtyCmd struct {
-	Show bool `arg:"--show-files"                         help:"also list every dirty file"`
 }
 
 type FindCmd struct {
@@ -80,6 +132,8 @@ type FindCmd struct {
 	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"`
 }
 
@@ -89,41 +143,63 @@ func (args) Version() string {
 
 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.
 
-	This supports GO projects so far.
-		It will work from ~/go/src or where your go.work file is.
-		Since I mostly use ~/go/src, that has been tested more.
-
-Examples:
-	forge                                        # opens the GUI
-	forge list                                   # show every repo state
-	forge dirty                                  # check for dirty git repos
-	forge pull                                   # run 'git pull' in every repo
-	forge checkout                               # switch git branches
-
-	forge config add --private --path /opt/bob   # add a private repo /opt/bob
-	forge config add --directory --writable \
-		--gopath 'go.wit.com/user/bob'       # directory contains r/w repos
-	forge config add --private --writeable \
-		--gopath 'go.wit.com/user/bob/work'  # a GO repo that can not be published
-
-	`
+	forge only executes the 'git' command. Everything it does, you can run by hand with 'git'.
+`
 }
 
-func (args) doBashHelpDebug() {
-	fmt.Fprintln(os.Stderr, "")
-	fmt.Fprintln(os.Stderr, "hello world")
-	var more string
-	p0 := "0" + argv.BashAuto[0]
-	p1 := "1" + argv.BashAuto[1]
-	p2 := "2" + argv.BashAuto[2]
-	if len(argv.BashAuto[1]) >= 0 {
-		more = "more"
-	} else {
-		more = "less"
+// 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")
+		}
 	}
-	p1a := fmt.Sprintf("1a.%s.%+v.\n", argv.BashAuto[1], len(argv.BashAuto[1]))
-	fmt.Fprintln(os.Stderr, "pull something else", argv.BashAuto, len(argv.BashAuto), p0, p1, p2, p1a, "end", more)
-	fmt.Fprintln(os.Stderr, "")
+	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)
 }

argvAutoshell.go

@@ -1,103 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"os/user"
-)
-
-/*
-	handles shell autocomplete
-*/
-
-// used for shell auto completion
-// var ARGNAME string = "forge" // todo: get this from $0 ?
-
-func (a *EmptyCmd) deleteMatch() {
-	fmt.Println("go.wit.com/lib/gui/repostatus")
-}
-
-func (args) doBashAuto() {
-	argv.doBashHelp()
-	switch argv.BashAuto[0] {
-	case "checkout":
-		usr, _ := user.Current()
-		fmt.Println("user devel master " + usr.Username)
-	case "commit":
-		fmt.Println("--all")
-	case "config":
-		fmt.Println("add fix list delete")
-	case "list":
-		fmt.Println("--all --mine --favorites --private")
-	case "pull":
-		fmt.Println("--all --mine --favorites --private")
-	case "patch":
-		fmt.Println("list --submit show")
-	case "dirty":
-		fmt.Println("--show-files")
-	case "user":
-		fmt.Println("--force")
-	case "devel":
-		fmt.Println("--force")
-	case "master":
-		fmt.Println("--force")
-	case "delete":
-		argv.Delete.deleteMatch()
-	default:
-		if argv.BashAuto[0] == ARGNAME {
-			// list the subcommands here
-			fmt.Println("--bash checkout commit config dirty delete examine hard-reset list patch pull rescan")
-		}
-	}
-	os.Exit(0)
-}
-
-// prints help to STDERR // TODO: move everything below this to go-args
-func (args) doBashHelp() {
-	if argv.BashAuto[1] != "''" {
-		// if this is not blank, then the user has typed something
-		return
-	}
-	if argv.BashAuto[0] != ARGNAME {
-		// if this is not the name of the command, the user already started doing something
-		return
-	}
-	if argv.BashAuto[0] == ARGNAME {
-		me.pp.WriteHelp(os.Stderr)
-		return
-	}
-	fmt.Fprintln(os.Stderr, "")
-	fmt.Fprintln(os.Stderr, "hello world")
-	fmt.Fprintln(os.Stderr, "")
-}
-
-// complete -F forge --bash forge
-func (args) doBash() {
-	fmt.Println("# add this in your bashrc:")
-	fmt.Println("")
-	fmt.Println("# todo: add this to go-arg as a 'hidden' go-arg option --bash")
-	fmt.Println("#")
-	fmt.Println("# todo: make this output work/parse with:")
-	fmt.Println("# complete -C " + ARGNAME + " --bash go")
-	fmt.Println("")
-	fmt.Println("_" + ARGNAME + "_complete()")
-	fmt.Println("{")
-	fmt.Println("	# sets local to this func vars")
-	fmt.Println("	local cur prev all")
-	fmt.Println("	cur=${COMP_WORDS[COMP_CWORD]}")
-	fmt.Println("	prev=${COMP_WORDS[COMP_CWORD-1]}")
-	fmt.Println("	all=${COMP_WORDS[@]}")
-	fmt.Println("")
-	fmt.Println("	# this is where we generate the go-arg output")
-	fmt.Println("        GOARGS=$(" + ARGNAME + " --auto-complete $prev \\'$cur\\' $all)")
-	fmt.Println("")
-	fmt.Println("	# this compares the command line input from the user")
-	fmt.Println("	# to whatever strings we output")
-	fmt.Println("        COMPREPLY=( $(compgen -W \"$GOARGS\" -- $cur) )  # THIS WORKS")
-	fmt.Println("	return 0")
-	fmt.Println("}")
-	fmt.Println("complete -F _" + ARGNAME + "_complete " + ARGNAME)
-	fmt.Println("")
-	fmt.Println("# copy and paste the above into your bash shell should work")
-	os.Exit(0)
-}

build

@@ -3,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

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

@@ -1,98 +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/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-func IsEverythingOnDevel() bool {
-	me.found = new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if repo.GetCurrentBranchName() != repo.GetDevelBranchName() {
-			// log.Info(repo.GetFullPath(), repo.GetCurrentBranchName(), repo.GetDevelBranchName())
-			// add this to the list of "found" repos
-			me.found.AppendByGoPath(repo)
-		}
-	}
-	if len(me.found.Repos) == 0 {
-		return true
-	}
-	return false
-}
+// trys to figure out if there is still something to update
 
-func IsEverythingOnUser() bool {
-	me.found = new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-			me.found.AppendByGoPath(repo)
+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 len(me.found.Repos) == 0 {
-		return true
-	}
-	return false
-}
 
-func doGitReset() {
-	all := me.found.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			// log.Info("is readonly", repo.GetGoPath())
-			if repo.CheckDirty() {
-				log.Info("is readonly and dirty", repo.GetGoPath())
-				cmd := []string{"git", "reset", "--hard"}
-				repo.RunRealtime(cmd)
-			}
-		} else {
-			// log.Info("is not readonly", repo.GetGoPath())
+	if argv.Checkout.Devel != nil {
+		// setForgeMode(forgepb.ForgeMode_DEVEL)
+		if err := me.forge.DoAllCheckoutDevelNew(argv.Force); err != nil {
+			badExit(err)
 		}
+		okExit("")
 	}
-}
 
-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
+	if argv.Checkout.Master != nil {
+		setForgeMode(forgepb.ForgeMode_MASTER) // disable "normal" mode if set
+
+		if err := me.forge.DoAllCheckoutMaster(); err != nil {
+			badExit(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
+		okExit("")
 	}
+	badExit(fmt.Errorf("did not specify what branch to checkout"))
 	return nil
 }
-
-func doAllCheckoutDevel() bool {
-	me.forge.CheckoutDevel()
-	me.forge = forgepb.Init()
-	if !IsEverythingOnDevel() {
-		log.Info("switching to devel branch failed")
-		me.forge.PrintHumanTable(me.found)
-		badExit(nil)
-		return false
-	}
-	return true
-}
-
-func doAllCheckoutUser() bool {
-	me.forge.CheckoutUser()
-	me.forge = forgepb.Init()
-	if !IsEverythingOnUser() {
-		log.Info("switching to user branch failed")
-		me.forge.PrintHumanTable(me.found)
-		return false
-	}
-	return true
-}

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
+}

doConfig.go

@@ -1,3 +1,6 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
 package main
 
 import (
@@ -18,13 +21,16 @@ func doConfig() {
 		log.Info("todo")
 		okExit("")
 	}
-	if argv.Config.Register != "" {
-		if err := doRegister(argv.Config.Register); err == nil {
-			okExit("attempting to register " + argv.Config.Register)
-		} else {
-			badExit(err)
+
+	/*
+		if argv.Config.Register != "" {
+			if err := doRegister(argv.Config.Register); err == nil {
+				okExit("attempting to register " + argv.Config.Register)
+			} else {
+				badExit(err)
+			}
 		}
-	}
+	*/
 
 	// try to add, then save config and exit
 	if argv.Config.Add != nil {
@@ -48,6 +54,8 @@ func doConfig() {
 		os.Exit(0)
 	}
 
+	log.Info("config.PathLock =", me.forge.Config.PathLock)
+
 	me.forge.ConfigPrintTable()
 	okExit("")
 }

doDirty.go

@@ -1,44 +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
 
-import (
-	"time"
-
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
 func doDirty() {
-	findAll() // select all the repos
-	doCheckDirtyAndConfigSave()
-	me.found = new(gitpb.Repos)
-	findDirty()
-	me.forge.PrintHumanTableDirty(me.found)
-}
-
-func doCheckDirtyAndConfigSave() {
-	var count int
-	now := time.Now()
-	// log.Info("before findAll()")
-	all := me.found.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		// log.Info("before isDirty()")
-		dirty := repo.IsDirty()
-		if repo.CheckDirty() {
-			count += 1
-			if me.found.AppendByGoPath(repo) {
-				log.Info("doCheckDirtyAndConfigSave() repo already existed", repo.GetGoPath())
-			}
-			if !dirty {
-				configSave = true
-			}
-		} else {
-			if dirty {
-				configSave = true
-			}
-		}
+	found := me.forge.CheckDirty()
+	if found.Len() == 0 {
+		return
+	}
+	if argv.Verbose {
+		me.forge.PrintHumanTableDirty(found)
+	} else {
+		me.forge.PrintHumanTable(found)
 	}
-	log.Printf("dirty check (%d repos) took:%s\n", count, shell.FormatDuration(time.Since(now)))
-	me.forge.SetConfigSave(configSave)
 }

doExamine.go

@@ -1,94 +0,0 @@
-package main
-
-import (
-	"slices"
-	"time"
-
-	"go.wit.com/lib/gui/shell"
-	"go.wit.com/lib/protobuf/gitpb"
-	"go.wit.com/log"
-)
-
-func doExamine() bool {
-	me.found = new(gitpb.Repos)
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if tag := repo.ExamineBranches(); tag != nil {
-			me.found.AppendByGoPath(repo)
-			// ctime := tag.Creatordate.AsTime()
-			// dur := time.Since(ctime)
-			// log.Printf("UNKNOWN BRANCH %-50s %s %4s %s\n", repo.GetFullPath(), tag.Hash, shell.FormatDuration(dur), tag.Refname)
-			repo.CurrentTag = tag
-		} else {
-			repo.CurrentTag = nil
-		}
-	}
-	if len(me.found.Repos) == 0 {
-		return true
-	}
-	// slices.Reverse(me.found.Repos)
-	slices.SortFunc(me.found.Repos, func(a, b *gitpb.Repo) int {
-		atime := a.CurrentTag.Creatordate.AsTime()
-		btime := b.CurrentTag.Creatordate.AsTime()
-		if atime.Before(btime) {
-			// log.Info("atime vs btime is 0", atime, btime)
-			return 1
-		}
-		// log.Info("atime vs btime is 1", atime, btime)
-		return -1
-	})
-	all = me.found.All()
-	me.found = new(gitpb.Repos)
-	for all.Scan() {
-		repo := all.Next()
-		if isNormal(repo) {
-			continue
-		}
-
-		tag := repo.CurrentTag
-		ctime := tag.Creatordate.AsTime()
-		dur := time.Since(ctime)
-		log.Printf("UNKNOWN BRANCH %-50s %s %4s %s\n", repo.GetFullPath(), tag.Hash, shell.FormatDuration(dur), tag.Refname)
-		showNotDevel(repo)
-
-		me.found.AppendByGoPath(repo)
-	}
-	me.forge.PrintHumanTableDirty(me.found)
-	return false
-}
-
-func isNormal(repo *gitpb.Repo) bool {
-	if repo.IsDirty() {
-		return true
-	}
-	if repo.GetUserVersion() != repo.GetDevelVersion() {
-		return true
-	}
-	return false
-}
-
-func showNotDevel(repo *gitpb.Repo) error {
-	var cmd []string
-	cmd = append(cmd, "git")
-	cmd = append(cmd, "log")
-	cmd = append(cmd, "--format=\"%H\"")
-	cmd = append(cmd, repo.CurrentTag.Hash)
-	cmd = append(cmd, "--not")
-	cmd = append(cmd, "devel")
-	r, err := repo.RunStrictNew(cmd)
-	if err != nil {
-		log.Info("Error", cmd, err)
-		return err
-	}
-	if r == nil {
-		log.Info("Error r == nil", cmd, err)
-		return nil
-	}
-	if len(r.Stdout) != 0 {
-		for i, line := range r.Stdout {
-			log.Info(i, line)
-		}
-	}
-	return nil
-}

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,56 +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/debugger"
 	"go.wit.com/lib/gadgets"
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/forgepb"
+	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-func debug() {
-	log.Info("cmd line --debugger == true")
-	go func() {
-		log.Sleep(3)
-		log.Info("cmd line --debugger == true")
-		log.Info("cmd line --debugger == true")
-		log.Info("cmd line --debugger == true")
-		log.Info("cmd line --debugger == true")
-		debugger.DebugWindow()
-	}()
-}
-
 func doGui() {
-	me.myGui = gui.New()
-	me.myGui.Default()
+	win := gadgets.NewGenericWindow("Forge: A federated git development tool by WIT.COM", "Current Settings")
+	win.Custom = func() {
+		log.Warn("MAIN WINDOW CLOSE")
+		okExit("")
+	}
 
-	// debug()
+	grid := win.Group.RawGrid()
+	if me.forge.Config.GetPathLock() {
+		me.goSrcPwd = gadgets.NewOneLiner(grid, "Working Directory")
+		me.goSrcPwd.SetText(me.forge.Config.ReposDir)
+	} else {
+		me.goSrcEdit = gadgets.NewBasicEntry(grid, "Working Directory")
+		me.goSrcEdit.SetText(me.forge.Config.ReposDir)
+		me.goSrcEdit.Custom = func() {
+			log.Info("updating text to", me.goSrcEdit.String())
+		}
+	}
+	lockpath := grid.NewCheckbox("Lock").SetChecked(me.forge.Config.PathLock)
+	lockpath.Custom = func() {
+		if lockpath.IsChecked() {
+			log.Info("lock working directory")
+			me.forge.Config.PathLock = true
+		} else {
+			log.Info("unlock working directory")
+			me.forge.Config.PathLock = false
+		}
+		me.forge.Config.ConfigSave()
+		okExit("you must restart forge after changing the Path Lock")
+	}
 
-	me.mainWindow = gadgets.RawBasicWindow("Forge: (this doesn't work yet)")
-	me.mainWindow.Make()
-	me.mainWindow.Show()
-	me.mainbox = me.mainWindow.Box()
+	grid.NextRow()
 
-	// disable the interface while everything is scanned
-	me.Disable()
+	// use ENV GIT_AUTHOR
+	me.gitAuthor = gadgets.NewOneLiner(grid, "Git Author")
+	grid.NextRow()
 
-	vbox2 := me.mainbox.NewVerticalBox("BOX2")
-	globalBuildOptions(vbox2)
-	me.summary = submitPatchesBox(vbox2)
+	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)
+	}
 
-	me.repos = makeRepoView()
+	grid.NextRow()
 
-	// processing is done. update the repo summary box
-	me.summary.Update()
-	me.summary.submitB.Disable()
+	gridM := win.Stack.RawGrid()
 
-	me.Enable()
+	var insertWin *gadgets.GenericWindow
+	s := fmt.Sprintf("Repos (%d)", me.forge.Repos.Len())
+	me.reposWinB = gridM.NewButton(s, func() {
+		// if the window exists, just toggle it open or closed
+		if insertWin != nil {
+			insertWin.Toggle()
+			return
+		}
 
-	// intermittently scans the status indefinitly
-	me.repos.View.Watchdog(func() {
-		log.Info("Watchdog in doGui()")
-		// processing is done. update the repo summary box
-		me.summary.Update()
+		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

@@ -1,31 +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"
 )
 
-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
+// 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)
 		}
-		if result.Error == gitpb.ErrorGitPullOnLocal {
-			log.Info("skip git pull. local branch ", repo.GetGoPath())
-			continue
+		updatepb, regPB, err := submit.HttpPost(myServer(), "check")
+		if regPB == nil || err != nil {
+			log.Info("regPB==nil or err:", err)
+			return nil
 		}
-		if result.Exit == 0 {
-			continue
-		}
-
-		log.Info("git pull error:", repo.GetGoPath(), result.Error)
-		log.Info("git pull error:", repo.GetGoPath(), result.Stdout)
+		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()
+	}
+}
+*/

doSubmitPatch.go

@@ -1,13 +0,0 @@
-package main
-
-import (
-	"go.wit.com/log"
-)
-
-func doSubmit(name string) {
-	if err := sendDevelDiff(name); err != nil {
-		log.Info("sending patches failed", err)
-	} else {
-		log.Info("sent patch set ok")
-	}
-}

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,23 +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) {
-	if thing != "" {
-		log.Info("forge exit:", 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)
 }

find.go

@@ -1,100 +0,0 @@
-package main
-
-import (
-	"go.wit.com/lib/protobuf/gitpb"
-)
-
-// this populates a slice of protobuf records representing each git repo
-// var me.found []*gitpb.Repo
-//
-// so, it makes a subset of repos that are then used performing actions on
-//
-// by default, it adds every repo
-
-func (f *FindCmd) findRepos() {
-	if f == nil {
-		findMine()
-		return
-	}
-
-	if f.All {
-		findAll()
-		return
-	}
-
-	if f.Private {
-		findPrivate()
-		return
-	}
-
-	if f.Mine {
-		findMine()
-		return
-	}
-
-	if f.Favorites {
-		findFavorites()
-		return
-	}
-
-	if f.Dirty {
-		findDirty()
-		return
-	}
-
-	findAll()
-}
-
-func findPrivate() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsPrivate(repo.GetGoPath()) {
-			me.found.AppendByGoPath(repo)
-		}
-	}
-}
-
-// finds repos that are writable
-func findMine() {
-	// log.Printf("get mine %s\n", me.forge.GetGoSrc())
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsWritable(repo.GetGoPath()) {
-			me.found.AppendByGoPath(repo)
-		}
-	}
-}
-
-// finds repos the user has marked as favorites in the forge .config
-func findFavorites() {
-	// log.Printf("get favorites %s\n", me.forge.GetGoSrc())
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		if me.forge.Config.IsFavorite(repo.GetGoPath()) {
-			me.found.AppendByGoPath(repo)
-		}
-	}
-}
-
-// finds repos that git is reporting as dirty
-func findDirty() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		var repo *gitpb.Repo
-		repo = all.Next()
-		if repo.IsDirty() {
-			me.found.AppendByGoPath(repo)
-		}
-	}
-}
-
-func findAll() {
-	all := me.forge.Repos.SortByFullPath()
-	for all.Scan() {
-		repo := all.Next()
-		me.found.AppendByGoPath(repo)
-	}
-}

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,14 +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 (
-	"os"
+	"embed"
 	"strings"
 
-	"go.wit.com/dev/alexflint/arg"
-	"go.wit.com/gui"
-	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/gui/prep"
 	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
@@ -18,6 +19,11 @@ 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"
 
@@ -26,7 +32,7 @@ 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)
 
@@ -35,25 +41,18 @@ 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.auto = prep.Bash3(&argv) // this line should be:  prep.Bash(&argv)
 
-	if argv.Bash {
-		argv.doBash()
-		os.Exit(0)
-	}
-	if len(argv.BashAuto) != 0 {
-		argv.doBashAuto()
-		os.Exit(0)
-	}
-	me.urlbase = argv.URL
-	if me.urlbase == "" {
-		me.urlbase = "https://go.wit.com/"
-	}
-	me.urlbase = strings.Trim(me.urlbase, "/") // track down why trailing '/' makes http POST not work
+	// me.auto = prep.Bash3(argv.DoAutoComplete, &argv) // this line should be:  prep.Bash(&argv)
+	// arg.MustParse(&argv)                                      // these three lines are becoming terrible syntax
+	// me.auto = prep.MustParse(&argv)          // try to make this work?
 
-	// load the ~/.config/forge/ config
-	me.forge = forgepb.Init()
-	me.found = new(gitpb.Repos)
+	me.forge = forgepb.Init() // init forge.pb
+	me.forge.ScanRepoDir()    // looks for new dirs, checks existing repos for changes
+
+	// initialize patches
+	doPatchInit()
 
 	// first find the repos or gopaths to operate on
 	if argv.Config != nil {
@@ -62,62 +61,46 @@ func main() {
 	}
 
 	if argv.Commit != nil {
-		pwd, _ := os.Getwd()
-		repo := me.forge.Repos.FindByFullPath(pwd)
-		if repo == nil {
-			log.Info("what branch are you on?: todo: examine this")
-			okExit("")
-		}
-		if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-			me.found.Append(repo)
-			me.forge.PrintHumanTable(me.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 err := shell.ExecCheck([]string{"git", "commit", "--all"}); err != nil {
-			badExit(err)
-		}
-		log.Info("git commit ok. forge done")
+		doCommit()
+		okExit("")
+	}
+
+	if argv.BuildForge {
+		buildForge()
 		okExit("")
 	}
 
 	if argv.Checkout != nil {
-		if argv.Checkout.User != nil {
-			if argv.Force {
-				me.forge.CheckoutUserForce()
-			} else {
-				me.forge.CheckoutUser()
-			}
-			me.forge = forgepb.Init()
-			me.found = new(gitpb.Repos)
-			argv.Checkout.User.findRepos()
-			me.forge.PrintHumanTable(me.found)
-			okExit("")
+		if err := doCheckout(); err != nil {
+			badExit(err)
 		}
+		okExit("")
+	}
 
-		if argv.Checkout.Devel != nil {
-			me.forge.CheckoutDevel()
-			me.forge = forgepb.Init()
-			me.found = new(gitpb.Repos)
-			argv.Checkout.Devel.findRepos()
-			me.forge.PrintHumanTable(me.found)
-			okExit("")
+	if argv.Build != "" {
+		if err := doBuild(); err != nil {
+			badExit(err)
 		}
+		okExit("")
+	}
 
-		if argv.Checkout.Master != nil {
-			me.forge.CheckoutMaster()
-			me.forge = forgepb.Init()
-			me.found = new(gitpb.Repos)
-			argv.Checkout.Master.findRepos()
-			me.forge.PrintHumanTable(me.found)
+	if argv.Install != "" {
+		if err := doInstall(); err != nil {
+			badExit(err)
 		}
-		log.Info("make 'user' the default here?")
+		okExit("")
+	}
+
+	if argv.Clean != nil {
+		if err := doClean(); err != nil {
+			badExit(err)
+		}
+		me.forge.ConfigSave()
+		okExit("")
+	}
+
+	if argv.Help != nil {
+		doHelp()
 		okExit("")
 	}
 
@@ -126,85 +109,122 @@ func main() {
 		okExit("")
 	}
 
-	if argv.Examine != nil {
-		doExamine()
+	if argv.Tag != nil {
+		doTag()
 		okExit("")
 	}
 
-	if argv.Rescan != nil {
-		me.forge.ScanGoSrc()
-		okExit("")
-	}
-
-	if argv.Show != "" {
-		repo := me.forge.FindByGoPath(argv.Show)
-		me.forge.HumanPrintRepo(repo)
-		// newt := repo.Times.LastUpdate.AsTime()
-		// oldt := repo.Times.MtimeHead.AsTime()
-		if repo.Times.LastUpdate == nil {
-			log.Info("SHOULD RUN Reload() here")
-			repo.Reload()
-			me.forge.HumanPrintRepo(repo)
-		} else {
-			if repo.Times.LastUpdate.Seconds < repo.Times.MtimeHead.Seconds {
-				log.Info("SHOULD RUN Reload() here")
+	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("")
 			}
-		}
-		okExit("")
-	}
-
-	if argv.GitPull != nil {
-		argv.GitPull.findRepos()
-		doGitPull()
-		okExit("")
-	}
-
-	if argv.GitReset != nil {
-		findAll() // select all the repos
-		doGitReset()
-		okExit("reset")
-	}
-
-	if argv.List != nil {
-		argv.List.findRepos()
-		// print out the repos
-		me.forge.PrintHumanTable(me.found)
-		okExit("")
-	}
-	if argv.Patch != nil {
-		if argv.Patch.Submit != "" {
-			doSubmit(argv.Patch.Submit)
+			setForgeMode(forgepb.ForgeMode_NORMAL)
+			log.Info("normal mode on")
 			okExit("")
 		}
 
-		if argv.Patch.List != nil {
-			if err := listPatches(); err != nil {
-				badExit(err)
+		if argv.Normal.Off != nil {
+			if me.forge.Config.Mode != forgepb.ForgeMode_NORMAL {
+				log.Info("you were aleady not in the normal state")
+				okExit("")
 			}
-			okExit("patch list")
+			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())
 		}
 	}
 
-	// todo: redo this logic using forgepb
-	if configSave {
-		me.forge.ConfigSave()
-		configSave = false
+	if argv.Merge != nil {
+		if err := doMerge(); err != nil {
+			badExit(err)
+		}
+		okExit("")
 	}
 
-	// if the user doesn't want to open the GUI and
-	// nothing else was specified to be done,
-	// then just list the table to stdout
-	if gui.NoGui() {
-		me.forge.PrintHumanTable(me.found)
+	if argv.Pull != nil {
+		doPull()
+		okExit("")
+	}
+
+	if argv.List != nil {
+		found := argv.List.findRepos()
+		// print out the repos
+		if argv.List.Full {
+			me.forge.PrintHumanTableFull(found)
+		} else {
+			me.forge.PrintHumanTable(found)
+		}
+		okExit("")
+	}
+
+	if argv.Patch != nil {
+		if err := doPatch(); err != nil {
+			badExit(err)
+		}
 		okExit("")
 	}
 
 	// open the gui unless the user performed some other
 	// basically, if you run just 'forge' it should open the GUI
 
-	// if opening the GUI, always check git for dirty repos
-	findAll() // select all the repos
-	doCheckDirtyAndConfigSave()
-	doGui()
+	if argv.Gui != nil {
+		// if opening the GUI, always check git for dirty repos
+		me.forge.CheckDirty()
+
+		me.myGui.Start() // loads the GUI toolkit
+		doGui()          // start making our forge GUI
+		debug()          // sits here forever
+	}
+	// got to the end with nothing to do (?)
+	if dumpWorkRepos() {
+		// found some repos at least
+	} else {
+		// every repo is in a really clean state. no extra files anywhere
+		// no dirty repos, no repos that need to be published
+		// nothing different between user and master branch version. not common
+		log.Info("All of your git repositories appear to be in perfect shape")
+	}
+	okExit("")
+}
+
+// keep this small
+func doHelp() {
+	log.Info("")
+	log.Info("forge -h       : to see the available options")
+	log.Info("forge --bash   : will create a bash autocomplete file")
+	log.Info("forge          : with no arguements, forge tries to load a GO GUI plugin")
+	log.Info("               : there are two GUI plugins. terminal & GTK")
+	log.Info("")
+	log.Info("forge list     : shows a table of all your repos")
+	log.Info("forge checkout : checks out all your repos to the same branch")
+	log.Info("               : the default is your user branch")
+	log.Info("forge clean    : reverts all repos to the master branch")
+	log.Info("forge dirty    : show all repos git reports as dirty")
+	log.Info("")
+	okExit("")
+}
+
+func doHelpPatches() {
+	log.Info("TODO: ?")
 	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
-}

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,157 +0,0 @@
-// Copyright 2024 WIT.COM Inc Licensed GPL 3.0
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/log"
-)
-
-func sendPatches(pset *forgepb.Patchset) 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)
-	}
-	parts := strings.Fields(last)
-	if len(parts) == 0 {
-		return fmt.Errorf("listPatches() there are no patchsets at this time")
-	}
-	getPatch(parts[0])
-	return nil
-}
-
-func lastPatch() string {
-	var url string
-	url = me.urlbase + "/patchsetlist"
-	body, err := httpPost(url, nil)
-	if err != nil {
-		log.Info("httpPost() failed:", err)
-		return ""
-	}
-
-	var last string
-	test := strings.TrimSpace(string(body))
-	for _, line := range strings.Split(test, "\n") {
-		log.Info("patchset:", line)
-		last = strings.TrimSpace(line)
-	}
-	parts := strings.Fields(last)
-	return parts[0]
-}
-
-func doRegister(newurl string) error {
-	var url string
-	url = me.urlbase + "/register?url=" + newurl
-	body, err := 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
-}
-
-func getPatch(pbfile string) (*forgepb.Patchset, 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 nil, err
-	}
-	log.Info("getPatch() len(body)", len(body))
-	var pset *forgepb.Patchset
-	pset = new(forgepb.Patchset)
-	err = pset.Unmarshal(body)
-	if err != nil {
-		log.Info("Unmarshal failed", err)
-		return nil, err
-	}
-	filename := filepath.Join("/tmp", pbfile)
-	f, _ := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	f.Write(body)
-	f.Close()
-	return pset, nil
-}
-
-func sendDevelDiff(name string) error {
-	pset, err := me.forge.MakeDevelPatchSet()
-	if err != nil {
-		return err
-	}
-	pset.Name = name
-	if os.Getenv("GIT_AUTHOR_NAME") == "" {
-		return fmt.Errorf("GIT_AUTHOR_NAME not set")
-	} else {
-		pset.GitAuthorName = os.Getenv("GIT_AUTHOR_NAME")
-	}
-	if os.Getenv("GIT_AUTHOR_EMAIL") == "" {
-		return fmt.Errorf("GIT_AUTHOR_EMAIL not set")
-	} else {
-		pset.GitAuthorEmail = os.Getenv("GIT_AUTHOR_EMAIL")
-	}
-
-	if err := sendPatches(pset); err != nil {
-		return err
-	}
-	return nil
-}
-
-func sendMasterDiff() {
-	pset, err := me.forge.MakeMasterPatchSet()
-	if err != nil {
-		badExit(err)
-	}
-	all := pset.Patches.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,57 +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
-	found      *gitpb.Repos   // stores the list of repos to process things on
+	myGui      *prep.GuiPrep  // for initializing the GUI toolkits
 	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
-	mainbox *gui.Node
-
-	// the window from the /lib/gui/gowit package
-	// lw *gadgets.BasicWindow
-
-	// #### Sorting options for the repolist
-	// autoHidePerfect  *gui.Node
-	// autoHideReadOnly *gui.Node
-
-	// checkbox for --dry-run
-	autoDryRun *gui.Node
-
-	// checkbox to enable intermittent scanning
-	// if checked, it will check all your repos for changes
-	autoScanReposCB *gui.Node
-
-	// what is being used as your home dir
-	userHomePwd *gadgets.OneLiner
-
-	// what is being used as ~/go/src
-	goSrcPwd *gadgets.OneLiner
-
-	// ENV GIT_AUTHOR NAME and EMAIL
-	gitAuthor *gadgets.OneLiner
-
-	// displays a summary of all the repos
-	// has total dirty, total read-only
-	// total patches, etc
-	summary *patchSummary
-
-	// when switch to user or devel branches, autocreate them
-	autoCreateBranches *gui.Node
-
-	// these hold the branches that the user can switch all
-	// the repositories to them
-	newBranch  *gui.Node
-	setBranchB *gui.Node
+	// these hold the branches that the user can switch all the repositories to them
+	reposWinB       *gui.Node // button that opens the repos window
+	repoAllB        *gui.Node // "all" repos button
+	repoDirtyB      *gui.Node // "dirty" repos button
+	repoDevelMergeB *gui.Node // "merge to devel" repos button
+	repoWritableB   *gui.Node // "what repos are writable" repos button
 }

windowApply.go

@@ -1,61 +0,0 @@
-package main
-
-import (
-	"sync"
-
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/log"
-
-	"go.wit.com/gui"
-)
-
-// Shout out to "Go Generics 101" by Tapir Liu. Buy this book!
-
-type Lockable[T any] struct {
-	mu   sync.Mutex
-	data T
-}
-
-func (l *Lockable[T]) Do(f func(*T)) {
-}
-
-func (l *Lockable[T]) Hide() {
-	log.Info("testing:", l)
-}
-
-type applyWindow struct {
-	win *gadgets.BasicWindow
-	box *gui.Node
-
-	// the top box of the repolist window
-	topbox *gui.Node
-}
-
-type C3 = interface {
-	Show()
-	Hide()
-	Hidden() bool
-	Enable()
-	Disable()
-	~*gadgets.BasicWindow | ~*gui.Node
-}
-
-func (r applyWindow) Hidden() bool {
-	return r.win.Hidden()
-}
-
-func (r applyWindow) Show() {
-	r.win.Show()
-}
-
-func (r applyWindow) Hide() {
-	r.win.Hide()
-}
-
-func (r applyWindow) Disable() {
-	r.box.Disable()
-}
-
-func (r applyWindow) Enable() {
-	r.box.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")
+}

windowMain.go

@@ -1,123 +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("Forge Settings")
-	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)
-
-	// use ENV GIT_AUTHOR
-	me.gitAuthor = gadgets.NewOneLiner(grid, "Git Author")
-	grid.NextRow()
-
-	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)
-	}
-
-	// 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)
-		if targetName == "devel" {
-			if !doAllCheckoutDevel() {
-				okExit("")
-			}
-			return
-		}
-		if targetName == "master" {
-			log.Info("Don't know how to set", targetName, "yet")
-			return
-		}
-		// just assume user
-		if targetName == "jcarr" {
-			if doAllCheckoutUser() {
-				return
-			}
-			log.Info("switching to user branches failed")
-			return
-		}
-		/*
-			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()
-}

windowPatches.go

@@ -1,161 +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"
-	"strconv"
+	"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 patchSummary struct {
-	grid               *gui.Node
-	updateB            *gui.Node
-	docsB              *gui.Node
-	gitPushB           *gui.Node
-	gitPullB           *gui.Node
-	checkB             *gui.Node
-	totalOL            *gadgets.OneLiner
-	dirtyOL            *gadgets.OneLiner
-	readonlyOL         *gadgets.OneLiner
-	rw                 *gadgets.OneLiner
-	totalPatchesOL     *gadgets.OneLiner
-	totalUserRepos     *gui.Node
-	totalDevelRepos    *gui.Node
-	totalMasterRepos   *gui.Node
-	totalUserPatches   *gui.Node
-	totalDevelPatches  *gui.Node
-	totalMasterPatches *gui.Node
-	fileCount          *gui.Node
-	unknownOL          *gadgets.BasicEntry
-	unknownSubmitB     *gui.Node
-	reason             *gadgets.BasicEntry
-	submitB            *gui.Node
-	// allp               []*repolist.Patch
+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 submitPatchesBox(box *gui.Node) *patchSummary {
-	s := new(patchSummary)
-	group1 := box.NewGroup("Patch Summary")
-	s.grid = group1.RawGrid()
-
-	s.totalOL = gadgets.NewOneLiner(s.grid, "Total")
-	_ = s.grid.NewLabel("total changes")
-	_ = s.grid.NewLabel("user to devel")
-	s.grid.NextRow()
-
-	s.dirtyOL = gadgets.NewOneLiner(s.grid, "dirty")
-	_ = s.grid.NewLabel("") // skip a column
-	s.totalUserRepos = s.grid.NewLabel("x go repos")
-	s.grid.NextRow()
-
-	s.readonlyOL = gadgets.NewOneLiner(s.grid, "read-only")
-	_ = s.grid.NewLabel("") // skip a column
-	s.totalUserPatches = s.grid.NewLabel("x patches")
-	s.grid.NextRow()
-
-	s.rw = gadgets.NewOneLiner(s.grid, "r/w")
-	_ = s.grid.NewLabel("") // skip a column
-	s.fileCount = s.grid.NewLabel("x files")
-	s.grid.NextRow()
-
-	group1 = box.NewGroup("Submit Patch Set")
-	s.grid = group1.RawGrid()
-	s.reason = gadgets.NewBasicEntry(s.grid, "set name:")
-	s.reason.Custom = func() {
-		if s.reason.String() != "" {
-			s.submitB.Enable()
-		} else {
-			s.submitB.Disable()
-		}
+func (w *stdPatchTableWin) Toggle() {
+	if w == nil {
+		return
 	}
-	s.submitB = s.grid.NewButton("Submit", func() {
-		doSubmit(s.reason.String())
-	})
-
-	s.grid.NewButton("List Patchsets", func() {
-		if err := listPatches(); err != nil {
-			log.Info(err)
-		}
-	})
-
-	s.grid.NewButton("Show Latest Patchset", func() {
-		lastp := lastPatch()
-		pset, err := getPatch(lastp)
-		if err != nil {
-			return
-		}
-
-		if !dumpPatchset(pset) {
-			log.Info("some patches are bad")
-			return
-		}
-		if IsAnythingDirty() {
-			log.Info("You can't apply patches when repos are dirty")
-			me.forge.PrintHumanTable(me.found)
-			return
-		}
-	})
-
-	s.grid.NewButton("Apply Latest Patchset", func() {
-		lastp := lastPatch()
-		pset, err := getPatch(lastp)
-		if err != nil {
-			return
-		}
-		if !IsEverythingOnDevel() {
-			log.Info("You can only apply patches to the devel branch")
-			return
-		}
-		if IsAnythingDirty() {
-			log.Info("You can't apply patches when repos are dirty")
-			me.forge.PrintHumanTable(me.found)
-			return
-		}
-		applyPatchset(pset)
-	})
-
-	s.grid.NewButton("Show Repos", func() {
-		s.Update()
-		if me.repos.Hidden() {
-			me.repos.Show()
-		} else {
-			me.repos.Hide()
-		}
-	})
-
-	// disable these until there are not dirty repos
-	// s.reason.Disable()
-	s.submitB.Disable()
-	s.grid.NextRow()
-
-	return s
+	if w.win == nil {
+		return
+	}
+	w.win.Toggle()
 }
 
-// does not run any commands
-func (s *patchSummary) Update() {
-	var total, dirty, readonly, rw int
-	var userT int // , develT, masterT int
-	// var userP, develP, masterP int
-	// broken after move to forge protobuf
-	all := me.forge.Repos.SortByFullPath()
+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() {
-		repo := all.Next()
-		total += 1
-		if repo.IsDirty() {
-			dirty += 1
+		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)
 		}
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			readonly += 1
-		} else {
-			rw += 1
+		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
+			}
 		}
 	}
-	s.totalOL.SetText(strconv.Itoa(total) + " repos")
-	s.dirtyOL.SetText(strconv.Itoa(dirty) + " repos")
-	s.readonlyOL.SetText(strconv.Itoa(readonly) + " repos")
-	s.rw.SetText(fmt.Sprintf("%d repos", rw))
-
-	s.totalUserRepos.SetText(strconv.Itoa(userT) + " repos")
+	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
+}

windowRepos.go

@@ -1,263 +0,0 @@
-package main
-
-import (
-	"go.wit.com/lib/gadgets"
-	"go.wit.com/lib/gui/repolist"
-	"go.wit.com/lib/protobuf/forgepb"
-	"go.wit.com/lib/protobuf/gitpb"
-	"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()
-	return r
-}
-
-func (r *repoWindow) reInitForge() {
-	// re-read everything
-	me.forge = forgepb.Init()
-	me.found = new(gitpb.Repos)
-	me.repos = makeRepoView()
-	me.repos.Show()
-
-	// update the protobuf pointers
-	loop := me.forge.Repos.All()
-	for loop.Scan() {
-		repo := loop.Next()
-		vrepo := me.repos.View.FindByPath(repo.GetGoPath())
-		if vrepo != nil {
-			vrepo.UpdatePb(repo)
-		}
-	}
-
-	// now update the gui
-	vloop := me.repos.View.ReposSortByName()
-	for vloop.Scan() {
-		var repo *repolist.RepoRow
-		repo = vloop.Repo()
-		repo.NewScan()
-	}
-
-	i, s := me.repos.View.ScanRepositories()
-	log.Info("re-scanning done", i, "repos in", s)
-}
-
-func (r *repoWindow) repoMenu() *gui.Node {
-	// reposbox.SetExpand(false)
-	group1 := r.box.NewGroup("Filter:")
-
-	hbox := group1.Box()
-	// hbox.Horizontal()
-	hbox.Vertical()
-
-	box2 := hbox.Box().Horizontal()
-	/*
-	 */
-
-	dirty := box2.NewCheckbox("dirty")
-	dirty.Custom = func() {
-		log.Info("filter dirty =", dirty.Checked())
-	}
-
-	box2.NewButton("merge user to devel", func() {
-		r.Disable()
-		defer r.Enable()
-		if IsAnythingDirty() {
-			log.Info("You can't apply patches when repos are dirty")
-			me.forge.PrintHumanTable(me.found)
-			return
-		}
-		if !r.mergeAllUserToDevel() {
-			return
-		}
-	})
-
-	box2.NewButton("test master merge", func() {
-		r.Disable()
-		r.mergeAllDevelToMain()
-		// r.reInitForge()
-		r.Enable()
-	})
-
-	box2.NewButton("show apps", func() {
-		loop := me.repos.View.ReposSortByName()
-		for loop.Scan() {
-			var repo *repolist.RepoRow
-			repo = loop.Repo()
-			if repo.IsBinary() {
-				// log.Info(repo.Status.Path(), "compile here. Show()")
-				repo.Show()
-			} else {
-				// log.Info(repo.Status.Path(), "library here. Hide()")
-				repo.Hide()
-			}
-		}
-	})
-	box2.NewButton("re-init forge", func() {
-		log.Info("re-scanning now")
-		r.reInitForge()
-	})
-	box2.NewButton("ConfigSave()", func() {
-		me.forge.ConfigSave()
-	})
-	box2.NewButton("Table()", func() {
-		me.found = new(gitpb.Repos)
-		loop := me.forge.Repos.All()
-		for loop.Scan() {
-			repo := loop.Next()
-			me.found.AppendByGoPath(repo)
-		}
-		me.forge.PrintHumanTable(me.found)
-	})
-
-	return box2
-}
-
-func (r *repoWindow) mergeAllDevelToMain() bool {
-	var count int
-	log.Info("merge all here")
-	loop := me.forge.Repos.All()
-	for loop.Scan() {
-		repo := loop.Next()
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			log.Info("skipping readonly", repo.GetFullPath())
-			continue
-		}
-		if repo.IsDirty() {
-			log.Info("skipping dirty", repo.GetFullPath())
-			continue
-		}
-		if repo.GetDevelVersion() != repo.GetUserVersion() {
-			log.Info("devel and user branch are different", repo.GetFullPath())
-			continue
-		}
-		if repo.GetDevelVersion() == repo.GetMasterVersion() {
-			log.Info("devel and master branch are the same", repo.GetFullPath())
-			continue
-		}
-		count += 1
-		if result, err := repo.MergeDevelToMaster(); err == nil {
-			log.Warn("MERGE WORKED", repo.GetFullPath())
-			repo.Reload()
-			vrepo := me.repos.View.FindByPath(repo.GetGoPath())
-			if vrepo != nil {
-				vrepo.UpdatePb(repo)
-				vrepo.NewScan()
-			}
-			me.forge.SetConfigSave(true)
-			// continue
-			continue
-		} else {
-			log.Warn("THINGS FAILED ", repo.GetFullPath())
-			log.Warn("err", err)
-			for _, line := range result.Stdout {
-				log.Warn("stdout:", line)
-			}
-			for _, line := range result.Stderr {
-				log.Warn("stderr:", line)
-			}
-			return false
-		}
-	}
-	log.Warn("EVERYTHING WORKED count =", count)
-	return true
-}
-
-func (r *repoWindow) mergeAllUserToDevel() bool {
-	log.Info("merge all here")
-	loop := me.forge.Repos.All()
-	for loop.Scan() {
-		repo := loop.Next()
-		if me.forge.Config.IsReadOnly(repo.GetGoPath()) {
-			// log.Info("skipping readonly", repo.GetFullPath())
-			continue
-		}
-		if repo.IsDirty() {
-			log.Info("skipping dirty", repo.GetFullPath())
-			continue
-		}
-		if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-			log.Info("not on user branch", repo.GetFullPath())
-			continue
-		}
-		if repo.GetDevelVersion() == repo.GetUserVersion() {
-			log.Info("devel and user branch are the same", repo.GetFullPath())
-			continue
-		}
-		if result, err := repo.MergeUserToDevel(); err == nil {
-			log.Warn("THINGS SEEM OK", repo.GetFullPath())
-			repo.Reload()
-			vrepo := me.repos.View.FindByPath(repo.GetGoPath())
-			if vrepo != nil {
-				vrepo.UpdatePb(repo)
-				vrepo.NewScan()
-			}
-			me.forge.SetConfigSave(true)
-			continue
-		} else {
-			log.Warn("THINGS FAILED ", repo.GetFullPath())
-			log.Warn("err", err)
-			for _, line := range result.Stdout {
-				log.Warn("stdout:", line)
-			}
-			for _, line := range result.Stderr {
-				log.Warn("stderr:", line)
-			}
-			return false
-		}
-	}
-	log.Warn("EVERYTHING WORKED")
-	return true
-}

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()
+	}
+}