phase 1 completed

Author: algospider

docs/TROUBLESHOOTING.md

@@ -12,6 +12,8 @@ Fix:
 2. Choose `Memory cache` or `Persistent store`
 3. Preload the current GitHub token into Git
 
+Git Genius now repeats this guidance automatically after failed HTTPS pushes.
+
 If the issue continues:
 
 - run `Tools -> Doctor`
@@ -63,6 +65,20 @@ Fix:
 
 Git Genius can initialize the directory as a Git repo during setup.
 
+## First push does not happen
+
+Possible causes:
+
+- the repo still has no commit
+- there are no files to include in the first commit
+- the branch exists locally but has never been published
+
+Fix:
+
+1. Create at least one file if the repo is empty
+2. Run `Daily Git Operations -> Push changes`
+3. If auth fails, configure `Tools -> Git Auth / Credential Helper`
+
 ## GitHub repo checks fail
 
 Possible causes:

docs/WORKFLOWS.md

@@ -17,17 +17,21 @@ Use this when the current directory is a new project or when the repo has not be
 6. Optionally create the GitHub repository
 7. Optionally do the first commit and push
 
+Brand-new repos are now called out directly in the context panel so the first run is harder to miss.
+
 ## Recommended Daily Flow
 
 1. Review the context panel
-2. Run `Daily Git Operations -> Git status`
-3. Run `Smart Pull` if you may be behind the remote and have local edits
-4. Edit files outside Git Genius
-5. Run `Push changes`
+2. Check the ahead/behind line when it is shown
+3. Run `Daily Git Operations -> Git status`
+4. Run `Smart Pull` if you may be behind the remote and have local edits
+5. Edit files outside Git Genius
+6. Run `Push changes`
 
 Why this order:
 
 - `Status` helps you inspect what changed
+- the context panel can show whether the current branch is ahead of or behind the fetched remote ref
 - `Smart Pull` reduces pull failures caused by local edits
 - `Push changes` stages, commits, and pushes in one guided step
 

genius

@@ -88,3 +88,33 @@ func TestSaveSkipsRepoConfigOutsideGitRepo(t *testing.T) {
 		t.Fatalf("expected state to keep active workdir, got %v", recent)
 	}
 }
+
+func TestRecentWorkDirsReordersWhenSwitchingProjects(t *testing.T) {
+	home := t.TempDir()
+	repoA := t.TempDir()
+	repoB := t.TempDir()
+
+	if err := os.MkdirAll(filepath.Join(repoA, ".git"), 0o755); err != nil {
+		t.Fatalf("mkdir repoA .git: %v", err)
+	}
+	if err := os.MkdirAll(filepath.Join(repoB, ".git"), 0o755); err != nil {
+		t.Fatalf("mkdir repoB .git: %v", err)
+	}
+
+	t.Setenv("HOME", home)
+
+	Save(Config{WorkDir: repoA})
+	Save(Config{WorkDir: repoB})
+	Save(Config{WorkDir: repoA})
+
+	recent := RecentWorkDirs()
+	if len(recent) < 2 {
+		t.Fatalf("expected at least two recent directories, got %v", recent)
+	}
+	if recent[0] != repoA || recent[1] != repoB {
+		t.Fatalf("unexpected recent workdir order: %v", recent)
+	}
+	if got := preferredWorkDir(); got != repoA {
+		t.Fatalf("preferredWorkDir = %q want %q", got, repoA)
+	}
+}

git-genius

@@ -1,6 +1,7 @@
 package gitops
 
 import (
+	"fmt"
 	"strings"
 
 	"git-genius/internal/config"
@@ -66,13 +67,14 @@ func Status() bool {
 }
 
 func Push(msg string) bool {
-
 	if !system.EnsureGitRepo() {
 		return false
 	}
 
 	ensureSafeDirectory()
 	cfg := config.Load()
+	stateBefore := InspectRepoState()
+	createdCommit := false
 
 	// ---------- FIRST COMMIT ----------
 	if !hasAnyCommit() {
@@ -95,10 +97,25 @@ func Push(msg string) bool {
 			return false
 		}
 
+		stagedNames, err := system.GitOutput("diff", "--cached", "--name-only")
+		if err != nil {
+			ui.Error("Failed to inspect staged files")
+			return false
+		}
+		if stagedNames == "" {
+			ui.Warn("This repository has no files to commit yet")
+			ui.Info("Create at least one file, then run Push changes again")
+			if cfg.Remote != "" {
+				ui.Info("Your remote can stay configured now; the first push just needs a real commit")
+			}
+			return false
+		}
+
 		if err := system.RunGit("commit", "-m", msg); err != nil {
 			ui.Error("Initial commit failed")
 			return false
 		}
+		createdCommit = true
 	} else if isWorkingTreeDirty() {
 		// ---------- NORMAL COMMIT ----------
 		if msg == "" {
@@ -116,6 +133,7 @@ func Push(msg string) bool {
 			ui.Error("Commit failed")
 			return false
 		}
+		createdCommit = true
 	} else {
 		ui.Info("No local file changes detected")
 		ui.Info("Attempting to push any existing local commits")
@@ -144,17 +162,22 @@ func Push(msg string) bool {
 		return false
 	}
 
+	if stateBefore.NeedsFirstPush || (!createdCommit && stateBefore.HasCommits && !stateBefore.RemoteTrackingSeen) {
+		ui.Info("This looks like the first push for " + cfg.Remote + "/" + branch)
+	}
+
 	// ---------- PUSH ----------
-	if err := system.RunGitWithRemote(cfg.Remote, "push", "-u", cfg.Remote, branch); err != nil {
+	stderr, err := system.RunGitWithRemoteBuffered(cfg.Remote, "push", "-u", cfg.Remote, branch)
+	if err != nil {
 		ui.Error("Push failed")
-		if !system.HasGitCredentialHelper() {
-			ui.Info("Run Tools -> Git Auth / Credential Helper to reduce repeated HTTPS auth prompts")
-		}
+		printPushFailureSummary(cfg.Remote, branch, stderr)
 		ui.Info("Run Doctor if the problem persists")
 		return false
 	}
 
-	ui.Success("Changes pushed successfully")
+	cfg.FirstPushDone = true
+	config.Save(cfg)
+	printPushSuccessSummary(cfg.Remote, branch, stateBefore, createdCommit)
 	return true
 }
 
@@ -194,13 +217,17 @@ func Pull() bool {
 		}
 	}
 
+	stateBefore := InspectRepoState()
+	headBefore, _ := system.GitOutput("rev-parse", "HEAD")
+
 	if err := system.RunGitWithRemote(cfg.Remote, "pull", cfg.Remote, branch); err != nil {
 		ui.Error("Pull failed")
 		ui.Info("Try Smart Pull or run Doctor for more guidance")
 		return false
 	}
 
-	ui.Success("Pull completed")
+	headAfter, _ := system.GitOutput("rev-parse", "HEAD")
+	printPullSuccessSummary(cfg.Remote, branch, stateBefore, headBefore != "" && headBefore != headAfter)
 	return true
 }
 
@@ -226,3 +253,68 @@ func Fetch() bool {
 	ui.Success("Fetched all remotes")
 	return true
 }
+
+func printPushSuccessSummary(remote, branch string, before RepoState, createdCommit bool) {
+	after := InspectRepoState()
+
+	ui.Header("Push Summary")
+	ui.Success("Remote : " + remote)
+	ui.Success("Branch : " + branch)
+
+	switch {
+	case !before.HasCommits && createdCommit:
+		ui.Success("Created the first commit and published the branch")
+	case before.NeedsFirstPush:
+		ui.Success("Published this branch to the remote for the first time")
+	case before.HasAheadBehind && before.Ahead > 0:
+		ui.Success(fmt.Sprintf("Published %d local commit(s)", before.Ahead))
+	case createdCommit:
+		ui.Success("Created a new commit and pushed it")
+	default:
+		ui.Info("Remote branch was already up to date before this push")
+	}
+
+	if after.HasAheadBehind {
+		ui.Info("Ahead/Behind : " + after.AheadBehindSummary())
+	}
+}
+
+func printPushFailureSummary(remote, branch, stderr string) {
+	ui.Header("Push Summary")
+	ui.Error("Remote : " + remote)
+	ui.Error("Branch : " + branch)
+
+	if system.RemoteUsesHTTPS(remote) {
+		ui.Info("HTTPS remote detected")
+		ui.Info("Run Tools -> Git Auth / Credential Helper and preload the current GitHub token into Git")
+		ui.Info("Check that the token still has repo access to this repository")
+		if !system.HasGitCredentialHelper() {
+			ui.Info("No Git credential helper is configured yet")
+		}
+	}
+
+	if strings.Contains(strings.ToLower(stderr), "repository not found") {
+		ui.Info("Verify the remote URL and GitHub owner/repository in Setup or Create / Link GitHub Repository")
+	}
+}
+
+func printPullSuccessSummary(remote, branch string, before RepoState, headChanged bool) {
+	after := InspectRepoState()
+
+	ui.Header("Pull Summary")
+	ui.Success("Remote : " + remote)
+	ui.Success("Branch : " + branch)
+
+	switch {
+	case before.HasAheadBehind && before.Behind > 0:
+		ui.Success(fmt.Sprintf("Integrated %d remote commit(s)", before.Behind))
+	case headChanged:
+		ui.Success("Local branch moved forward")
+	default:
+		ui.Info("Local branch was already up to date")
+	}
+
+	if after.HasAheadBehind {
+		ui.Info("Ahead/Behind : " + after.AheadBehindSummary())
+	}
+}

internal/config/config_test.go

@@ -0,0 +1,62 @@
+package gitops
+
+import (
+	"fmt"
+
+	"git-genius/internal/config"
+	"git-genius/internal/system"
+)
+
+type RepoState struct {
+	Branch             string
+	Remote             string
+	HasCommits         bool
+	WorkingTreeDirty   bool
+	RemoteConfigured   bool
+	RemoteTrackingSeen bool
+	Ahead              int
+	Behind             int
+	HasAheadBehind     bool
+	FirstRun           bool
+	NeedsFirstPush     bool
+}
+
+func InspectRepoState() RepoState {
+	cfg := config.Load()
+
+	state := RepoState{
+		Branch:           CurrentBranch(),
+		Remote:           cfg.Remote,
+		HasCommits:       hasAnyCommit(),
+		WorkingTreeDirty: isWorkingTreeDirty(),
+		FirstRun:         !config.HasProjectConfig(cfg.GetWorkDir()) && !config.HasHistoryForWorkDir(cfg.GetWorkDir()),
+	}
+
+	if state.Branch == "-" || state.Branch == "" {
+		state.Branch = cfg.Branch
+	}
+
+	if state.Remote != "" && system.HasRemote(state.Remote) {
+		state.RemoteConfigured = true
+	}
+
+	if state.Branch != "" && state.RemoteConfigured && system.HasRemoteTrackingBranch(state.Remote, state.Branch) {
+		state.RemoteTrackingSeen = true
+		ahead, behind, err := system.AheadBehind(state.Branch, state.Remote+"/"+state.Branch)
+		if err == nil {
+			state.Ahead = ahead
+			state.Behind = behind
+			state.HasAheadBehind = true
+		}
+	}
+
+	state.NeedsFirstPush = state.HasCommits && state.RemoteConfigured && state.Branch != "" && !state.RemoteTrackingSeen
+	return state
+}
+
+func (s RepoState) AheadBehindSummary() string {
+	if !s.HasAheadBehind {
+		return ""
+	}
+	return fmt.Sprintf("%d ahead / %d behind", s.Ahead, s.Behind)
+}