thejoker.msk/iris-context
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(git): git doesnt show branch suggesstion properly

Browse Source
This commit is contained in:
verse91
2026-05-10 02:40:07 +07:00
parent 9c1c7749b0
commit 0ec946f408
4 changed files with 313 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/nightly.yml
+1 -1
View File
@@ -64,7 +64,7 @@ jobs:
tag_name: nightly
name: ${{ steps.version.outputs.version }}
body: |
🌙 **Nightly build** — `${{ steps.version.outputs.version }}`
🌙 **Nightly build** - `${{ steps.version.outputs.version }}`
auto-built from commit `${{ github.sha }}`
commands/core/spec.go
+1 -1
View File
@@ -45,7 +45,7 @@ func Register(s *Spec) {
Registry[s.Name] = s
}
// ResetRegistry clears all registered specs — use in tests only
// ResetRegistry clears all registered specs - use in tests only
func ResetRegistry() {
Registry = make(map[string]*Spec)
}
commands/dev/git.go
+84 -42
View File
@@ -9,16 +9,20 @@ import (
)
// GitRemoteGenerator suggests git remotes
func GitRemoteGenerator(tokens []string, prefix string, partial string) []core.Suggestion {
return getGitResults(prefix, "remote")
func GitRemoteGenerator(tokens []string, prefix string, _ string) []core.Suggestion {
return getGitResults(tokens, prefix, "remote")
}
// GitStashGenerator suggests git stashes
func GitStashGenerator(tokens []string, prefix string, partial string) []core.Suggestion {
return getGitResults(prefix, "stash", "list", "--format=%gd: %gs")
func GitStashGenerator(tokens []string, prefix string, _ string) []core.Suggestion {
return getGitResults(tokens, prefix, "stash", "list", "--format=%gd: %gs")
}
func getGitResults(prefix string, args ...string) []core.Suggestion {
func getGitResults(tokens []string, _ string, args ...string) []core.Suggestion {
return getGitResultsFiltered(tokens, "_", false, args...)
}
func getGitResultsFiltered(tokens []string, _ string, localOnly bool, args ...string) []core.Suggestion {
cwd := core.GetCWD()
cmd := exec.CommandContext(context.Background(), "git", args...)
cmd.Dir = cwd
@@ -28,9 +32,7 @@ func getGitResults(prefix string, args ...string) []core.Suggestion {
}
activeBranch := ""
switch args[0] {
case "branch":
// Try to find the current active branch to filter it out later
if args[0] == "branch" {
activeCmd := exec.CommandContext(context.Background(), "git", "rev-parse", "--abbrev-ref", "HEAD")
activeCmd.Dir = cwd
if activeOut, err := activeCmd.Output(); err == nil {
@@ -38,24 +40,52 @@ func getGitResults(prefix string, args ...string) []core.Suggestion {
}
}
seen := make(map[string]bool)
lines := strings.Split(string(out), "\n")
var results []core.Suggestion
for _, line := range lines {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "*") { // skip active branch marker if any
line = strings.TrimSpace(strings.TrimPrefix(line, "*"))
}
if line == "" || line == activeBranch {
if line == "" {
continue
}
// handle remote branches that look like "remotes/origin/main"
line = strings.TrimPrefix(line, "remotes/")
isRemote := strings.HasPrefix(line, "remotes/")
// skip remote tracking branches if localOnly mode
if localOnly && isRemote {
continue
}
// strip remotes/ prefix to get the usable form: origin/main
if isRemote {
line = strings.TrimPrefix(line, "remotes/")
}
// only skip active branch for checkout/switch commands
isCheckoutOrSwitch := false
if len(tokens) > 1 && (tokens[1] == "checkout" || tokens[1] == "switch") {
isCheckoutOrSwitch = true
}
if isCheckoutOrSwitch {
if line == activeBranch || line == "origin/"+activeBranch {
continue
}
}
// dedup: origin/dev and dev would both appear with -a; skip if already seen the short name
shortName := line
if idx := strings.Index(line, "/"); isRemote && idx != -1 {
shortName = line[idx+1:] // "origin/dev" → "dev"
}
if seen[shortName] {
continue
}
seen[shortName] = true
suggestionCmd := line
suggestionDesc := args[0]
// for stash list, the format is "stash@{0}: message"
if args[0] == "stash" {
parts := strings.SplitN(line, ": ", 2)
if len(parts) == 2 {
@@ -65,15 +95,16 @@ func getGitResults(prefix string, args ...string) []core.Suggestion {
}
results = append(results, core.Suggestion{
Cmd: prefix + " " + suggestionCmd,
Cmd: suggestionCmd,
Desc: suggestionDesc,
})
}
return results
}
// GitBranchGenerator suggests git branches
func GitBranchGenerator(tokens []string, prefix string, partial string) []core.Suggestion {
// GitBranchGenerator suggests git branches (local + remote, deduped)
func GitBranchGenerator(tokens []string, prefix string, _ string) []core.Suggestion {
// check if we are in "create" mode (-b or -B or -c)
isCreateMode := false
for _, t := range tokens {
@@ -87,35 +118,46 @@ func GitBranchGenerator(tokens []string, prefix string, partial string) []core.S
return nil
}
return getGitResults(prefix, "branch", "-a", "--format=%(refname:short)")
return getGitResults(tokens, prefix, "branch", "-a", "--format=%(refname:short)")
}
// GitPushPullGenerator suggests remotes for the first arg, and branches for the second
func GitPushPullGenerator(tokens []string, prefix string, partial string) []core.Suggestion {
// Filter out flags to find positional arguments
args := []string{}
for i := 1; i < len(tokens); i++ {
t := tokens[i]
if t != "" && !strings.HasPrefix(t, "-") {
args = append(args, t)
// gitLocalBranchGenerator is like GitBranchGenerator but only local branches
// used for push/pull where remote tracking branches cause duplicates
func gitLocalBranchGenerator(tokens []string, prefix string, _ string) []core.Suggestion {
isCreateMode := false
for _, t := range tokens {
if t == "-b" || t == "-B" || t == "-c" || t == "-C" {
isCreateMode = true
break
}
}
if isCreateMode {
return nil
}
return getGitResultsFiltered(tokens, prefix, true, "branch", "-a", "--format=%(refname:short)")
}
// args[0] is subcommand (push/pull)
// args[1] should be remote
// args[2] should be branch
// If we only have subcommand, suggest remotes
if len(args) == 1 {
func GitPushPullGenerator(tokens []string, prefix string, partial string) []core.Suggestion {
// count completed positional args (not flags, not the partial being typed)
// tokens[0] = "git", tokens[1] = "push"/"pull", so start at 2
// exclude tokens[len-1] because that's the partial being typed
pArgs := []string{}
for i := 2; i < len(tokens)-1; i++ {
t := tokens[i]
if t == "" || strings.HasPrefix(t, "-") {
continue
}
pArgs = append(pArgs, t)
}
// no remote confirmed yet, suggest remotes
if len(pArgs) == 0 {
return GitRemoteGenerator(tokens, prefix, partial)
}
// If we have subcommand + remote, suggest branches
if len(args) == 2 {
return GitBranchGenerator(tokens, prefix, partial)
}
return nil
// remote is set, suggest local branches only (no duplicates with origin/xxx)
return gitLocalBranchGenerator(tokens, prefix, partial)
}
func init() {
@@ -279,7 +321,7 @@ func init() {
{
Name: "tag",
Description: "manage tags",
Generator: func(tokens []string, prefix string, partial string) []core.Suggestion { return getGitResults(prefix, "tag", "-l") },
Generator: func(tokens []string, prefix string, partial string) []core.Suggestion { return getGitResults(tokens, prefix, "tag", "-l") },
Options: []core.Option{
{Name: "-a", Description: "annotated tag"},
{Name: "-d", Description: "delete tag"},
tests/dev/git_test.go
+227 -86
View File
@@ -12,42 +12,101 @@ import (
_ "github.com/versenilvis/iris/commands/dev"
)
func TestGitSuggestions(t *testing.T) {
// Setup a real git repo in temp dir for testing branch generators
tmp := t.TempDir()
oldWd, _ := os.Getwd()
_ = os.Chdir(tmp)
defer func() { _ = os.Chdir(oldWd) }()
// setupGitRepo creates a real git repo in a temp dir with:
// - local branches: main (HEAD), dev, feature/login, stable
// - remote branches: origin/main, origin/dev (written directly to .git/refs)
// - a tag: v1.0
// - a stash entry
func setupGitRepo(t *testing.T) (tmp string, cleanup func()) {
t.Helper()
tmp = t.TempDir()
ctx := context.Background()
// Initialize git repo
_ = exec.CommandContext(ctx, "git", "init").Run()
_ = exec.CommandContext(ctx, "git", "config", "user.email", "iris-test@example.com").Run() // this is for ci/cd
_ = exec.CommandContext(ctx, "git", "config", "user.name", "Iris Test").Run() // this is for ci/cd
run := func(args ...string) {
t.Helper()
out, err := exec.CommandContext(ctx, args[0], args[1:]...).CombinedOutput()
if err != nil {
t.Logf("git cmd %v: %s", args, out)
}
}
_ = os.WriteFile(filepath.Join(tmp, "file.go"), []byte("package main"), 0644)
_ = exec.CommandContext(ctx, "git", "add", ".").Run()
_ = exec.CommandContext(ctx, "git", "commit", "-m", "initial").Run()
run("git", "-C", tmp, "init", "--initial-branch=main")
// Create branches
_ = exec.CommandContext(ctx, "git", "branch", "feature/login").Run()
_ = exec.CommandContext(ctx, "git", "branch", "dev").Run()
_ = exec.CommandContext(ctx, "git", "tag", "v1.0").Run()
// use fallback for older git that doesn't support --initial-branch
if _, err := os.Stat(filepath.Join(tmp, ".git", "refs", "heads", "main")); err != nil {
run("git", "-C", tmp, "init")
}
// Setup stash
_ = os.WriteFile(filepath.Join(tmp, "dirty.go"), []byte("dirty"), 0644)
_ = exec.CommandContext(ctx, "git", "add", ".").Run()
_ = exec.CommandContext(ctx, "git", "stash").Run()
run("git", "-C", tmp, "config", "user.email", "iris-test@example.com") // this is for ci/cd
run("git", "-C", tmp, "config", "user.name", "Iris Test") // this is for ci/cd
// initial commit so branches can be created
if err := os.WriteFile(filepath.Join(tmp, "file.go"), []byte("package main"), 0644); err != nil {
t.Fatal(err)
}
run("git", "-C", tmp, "add", ".")
run("git", "-C", tmp, "commit", "-m", "initial")
// local branches (incl. slash branch to test tokenization)
run("git", "-C", tmp, "branch", "dev")
run("git", "-C", tmp, "branch", "stable")
run("git", "-C", tmp, "branch", "feature/login")
// tag
run("git", "-C", tmp, "tag", "v1.0")
// add a real remote in config
run("git", "-C", tmp, "remote", "add", "origin", "https://github.com/versenilvis/iris.git")
// write fake remote refs directly (no need for actual remote server)
for _, ref := range []string{"main", "dev"} {
dir := filepath.Join(tmp, ".git", "refs", "remotes", "origin")
if err := os.MkdirAll(dir, 0755); err != nil {
t.Fatal(err)
}
// point them to the same commit as HEAD for simplicity
headBytes, err := os.ReadFile(filepath.Join(tmp, ".git", "refs", "heads", "main"))
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, ref), headBytes, 0644); err != nil {
t.Fatal(err)
}
}
// stash entry
if err := os.WriteFile(filepath.Join(tmp, "dirty.go"), []byte("dirty"), 0644); err != nil {
t.Fatal(err)
}
run("git", "-C", tmp, "add", ".")
run("git", "-C", tmp, "stash")
// chdir into repo so generators can run git commands
oldWd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
if err := os.Chdir(tmp); err != nil {
t.Fatal(err)
}
cleanup = func() { _ = os.Chdir(oldWd) }
return tmp, cleanup
}
func TestGitSuggestions(t *testing.T) {
tmp, cleanup := setupGitRepo(t)
defer cleanup()
t.Run("git top-level", func(t *testing.T) {
res := core.Lookup("git ")
if len(res) < 10 {
t.Errorf("Expected many git subcommands, got %d", len(res))
t.Errorf("expected many git subcommands, got %d", len(res))
}
})
t.Run("git tag -d show tags", func(t *testing.T) {
t.Run("tag -d shows tags", func(t *testing.T) {
res := core.Lookup("git tag -d ")
found := false
for _, r := range res {
@@ -56,12 +115,11 @@ func TestGitSuggestions(t *testing.T) {
}
}
if !found {
t.Error("git tag -d should suggest existing tags")
t.Error("git tag -d should suggest v1.0")
}
})
t.Run("git push HEAD options", func(t *testing.T) {
// git push origin HEAD --force -> should show --force
t.Run("push HEAD options", func(t *testing.T) {
res := core.Lookup("git push origin HEAD --")
found := false
for _, r := range res {
@@ -74,8 +132,7 @@ func TestGitSuggestions(t *testing.T) {
}
})
t.Run("git push upstream options", func(t *testing.T) {
// git push -u origin -> show branches
t.Run("push -u origin suggests branches", func(t *testing.T) {
res := core.Lookup("git push -u origin ")
found := false
for _, r := range res {
@@ -84,15 +141,152 @@ func TestGitSuggestions(t *testing.T) {
}
}
if !found {
t.Error("git push -u origin should suggest branches")
t.Errorf("git push -u origin should suggest branches, got: %v", res)
}
})
t.Run("git reset options", func(t *testing.T) {
// git reset --soft origin/main -> should be accepted (just testing lookup doesn't crash)
_ = core.Lookup("git reset --soft origin/main ")
t.Run("push origin suggests active branch", func(t *testing.T) {
ctx := context.Background()
out, err := exec.CommandContext(ctx, "git", "rev-parse", "--abbrev-ref", "HEAD").Output()
if err != nil {
t.Skip("can't determine HEAD branch")
}
activeBranch := strings.TrimSpace(string(out))
res := core.Lookup("git push origin ")
found := false
for _, r := range res {
parts := strings.Fields(r.Cmd)
if len(parts) > 0 && parts[len(parts)-1] == activeBranch {
found = true
break
}
}
if !found {
t.Errorf("git push origin should suggest active branch '%s'", activeBranch)
}
})
// git reset HEAD -> show files
t.Run("push origin no duplicate branches", func(t *testing.T) {
res := core.Lookup("git push origin ")
seen := make(map[string]int)
for _, r := range res {
parts := strings.Fields(r.Cmd)
if len(parts) == 0 {
continue
}
branch := parts[len(parts)-1]
seen[branch]++
if seen[branch] > 1 {
t.Errorf("duplicate branch suggestion: %s", branch)
}
}
})
t.Run("branch with slash is suggested correctly", func(t *testing.T) {
res := core.Lookup("git checkout ")
found := false
for _, r := range res {
if strings.Contains(r.Cmd, "feature/login") {
found = true
}
}
if !found {
t.Error("git checkout should suggest 'feature/login'")
}
})
t.Run("remote branches suggested for push", func(t *testing.T) {
res := core.Lookup("git push origin ")
cmdStr := ""
for _, r := range res {
cmdStr += r.Cmd + " "
}
// should have at least dev or main from branch list
if !strings.Contains(cmdStr, "dev") && !strings.Contains(cmdStr, "main") {
t.Errorf("git push origin should suggest local branches, got: %s", cmdStr)
}
})
t.Run("active branch not suggested for checkout", func(t *testing.T) {
// find actual active branch
ctx := context.Background()
out, err := exec.CommandContext(ctx, "git", "rev-parse", "--abbrev-ref", "HEAD").Output()
if err != nil {
t.Skip("can't determine HEAD branch")
}
activeBranch := strings.TrimSpace(string(out))
res := core.Lookup("git checkout ")
for _, r := range res {
// the suggestion should not contain the active branch as a standalone word
parts := strings.Fields(r.Cmd)
for _, p := range parts {
if p == activeBranch {
t.Errorf("git checkout should not suggest active branch '%s', got: %s", activeBranch, r.Cmd)
}
}
}
})
t.Run("checkout -b no suggest", func(t *testing.T) {
res := core.Lookup("git checkout -b ")
for _, r := range res {
if strings.Contains(r.Cmd, "dev") {
t.Error("git checkout -b should not suggest existing branches")
}
}
})
t.Run("switch -c no suggest", func(t *testing.T) {
res := core.Lookup("git switch -c ")
for _, r := range res {
if strings.Contains(r.Cmd, "dev") {
t.Error("git switch -c should not suggest existing branches")
}
}
})
t.Run("stash variants suggest entries", func(t *testing.T) {
for _, cmd := range []string{"apply", "drop", "pop"} {
res := core.Lookup("git stash " + cmd + " ")
found := false
for _, r := range res {
if strings.Contains(r.Cmd, "stash@{0}") {
found = true
}
}
if !found {
t.Errorf("git stash %s should suggest stash@{0}", cmd)
}
}
})
t.Run("remote subcommands suggest remotes", func(t *testing.T) {
for _, cmd := range []string{"remove", "rename", "set-url"} {
res := core.Lookup("git remote " + cmd + " ")
found := false
for _, r := range res {
// origin is our fake remote
if strings.Contains(r.Cmd, "origin") {
found = true
}
}
if !found {
t.Errorf("git remote %s should suggest origin", cmd)
}
}
})
t.Run("not a git repo no crash", func(t *testing.T) {
emptyDir := t.TempDir()
_ = os.Chdir(emptyDir)
defer func() { _ = os.Chdir(tmp) }()
_ = core.Lookup("git status ")
})
t.Run("reset options", func(t *testing.T) {
_ = core.Lookup("git reset --soft origin/main ")
res := core.Lookup("git reset HEAD ")
found := false
for _, r := range res {
@@ -104,57 +298,4 @@ func TestGitSuggestions(t *testing.T) {
t.Error("git reset HEAD should suggest file.go")
}
})
t.Run("git checkout -b no suggest", func(t *testing.T) {
// git checkout -b -> should NOT suggest branches
res := core.Lookup("git checkout -b ")
for _, r := range res {
if strings.Contains(r.Cmd, "dev") {
t.Error("git checkout -b should not suggest existing branches")
}
}
})
t.Run("git switch -c no suggest", func(t *testing.T) {
res := core.Lookup("git switch -c ")
for _, r := range res {
if strings.Contains(r.Cmd, "dev") {
t.Error("git switch -c should not suggest existing branches")
}
}
})
t.Run("stash entries", func(t *testing.T) {
res := core.Lookup("git stash pop ")
found := false
for _, r := range res {
if strings.Contains(r.Cmd, "stash@{0}") {
found = true
}
}
if !found {
t.Error("git stash pop should suggest stash@{0}")
}
})
t.Run("not a git repo", func(t *testing.T) {
emptyDir := t.TempDir()
_ = os.Chdir(emptyDir)
// Should not crash
_ = core.Lookup("git status ")
_ = os.Chdir(tmp)
})
t.Run("active branch filter", func(t *testing.T) {
// find current branch
out, _ := exec.CommandContext(ctx, "git", "rev-parse", "--abbrev-ref", "HEAD").Output()
current := strings.TrimSpace(string(out))
res := core.Lookup("git checkout ")
for _, r := range res {
if strings.Contains(r.Cmd, current) && !strings.Contains(r.Cmd, "remotes/") {
t.Errorf("Should not suggest active branch '%s'", current)
}
}
})
}