chore: quick update feat/ver123 at 2025-09-13 12:58:02

Author: kooksee

bootstrap/boot.go

@@ -1,10 +1,13 @@
 package bootstrap
 
 import (
+	"log/slog"
+
 	_ "github.com/adrg/xdg"
 	_ "github.com/charmbracelet/bubbletea"
 	"github.com/pubgo/dix"
 	"github.com/pubgo/funk/config"
+	"github.com/pubgo/funk/log"
 	"github.com/pubgo/funk/recovery"
 	_ "github.com/sashabaranov/go-openai"
 
@@ -22,6 +25,8 @@ import (
 func Main(ver string) {
 	defer recovery.Exit()
 
+	slog.SetDefault(slog.New(log.NewSlog(log.GetLogger("fastcommit"))))
+
 	initConfig()
 
 	var di = dix.New(dix.WithValuesNull())

cmds/fastcommit/cmd.go

@@ -3,7 +3,6 @@ package fastcommit
 import (
 	"context"
 	"fmt"
-	"github.com/yarlson/tap"
 	"os"
 	"sort"
 	"strconv"
@@ -20,6 +19,7 @@ import (
 	"github.com/pubgo/funk/v2/result"
 	"github.com/sashabaranov/go-openai"
 	"github.com/urfave/cli/v3"
+	"github.com/yarlson/tap"
 
 	"github.com/pubgo/fastcommit/cmds/cmdutils"
 	"github.com/pubgo/fastcommit/configs"
@@ -77,14 +77,13 @@ func New(version string) func(params Params) *Command {
 					if errors.Is(err, context.Canceled) {
 						return nil
 					}
-					return err
-				})
 
-				defer func() {
-					if errors.Is(gErr, context.Canceled) {
-						gErr = nil
+					if err.Error() == "signal: interrupt" {
+						return nil
 					}
-				}()
+
+					return err
+				})
 
 				if command.Args().Len() > 0 {
 					log.Error(ctx).Msgf("unknown command:%v", command.Args().Slice())
@@ -99,37 +98,44 @@ func New(version string) func(params Params) *Command {
 
 				cmdutils.LoadConfigAndBranch()
 
-				allTags := utils.GetAllGitTags()
+				allTags := utils.GetAllGitTags(ctx)
 				tagName := "v0.0.1"
 				if len(allTags) > 0 {
 					ver := utils.GetNextReleaseTag(allTags)
 					tagName = "v" + strings.TrimPrefix(ver.Original(), "v")
 				}
 				assert.Exit(os.WriteFile(".version", []byte(tagName), 0644))
 
-				repoPath := assert.Must1(utils.AssertGitRepo())
+				repoPath := assert.Must1(utils.AssertGitRepo(ctx))
 				log.Info().Msg("git repo: " + repoPath)
 
 				//username := strings.TrimSpace(assert.Must1(utils.RunOutput("git", "config", "get", "user.name")))
 
 				if flags.fastCommit {
-					preMsg := strings.TrimSpace(assert.Must1(utils.RunOutput("git", "log", "-1", "--pretty=%B")))
+					preMsg := strings.TrimSpace(assert.Must1(utils.RunOutput(ctx, "git", "log", "-1", "--pretty=%B")))
 					prefixMsg := fmt.Sprintf("chore: quick update %s", cmdutils.GetBranchName())
 					msg := fmt.Sprintf("%s at %s", prefixMsg, time.Now().Format(time.DateTime))
 
-					assert.Must(utils.RunShell("git", "add", "-A"))
+					assert.Must(utils.RunShell(ctx, "git", "add", "-A"))
 					if strings.Contains(preMsg, prefixMsg) {
-						assert.Must(utils.RunShell("git", "commit", "--amend", "--no-edit", "-m", strconv.Quote(msg)))
+						assert.Must(utils.RunShell(ctx, "git", "commit", "--amend", "--no-edit", "-m", strconv.Quote(msg)))
 					} else {
-						assert.Must(utils.RunShell("git", "commit", "-m", strconv.Quote(msg)))
+						assert.Must(utils.RunShell(ctx, "git", "commit", "-m", strconv.Quote(msg)))
 					}
-					assert.Must(utils.RunShell("git", "push", "--force-with-lease", "origin", cmdutils.GetBranchName()))
+
+					s := spinner.New(spinner.CharSets[35], 100*time.Millisecond, func(s *spinner.Spinner) {
+						s.Prefix = "push git message: "
+					})
+					s.Start()
+					result.ErrOf(utils.RunShell(ctx, "git", "push", "--force-with-lease", "origin", cmdutils.GetBranchName())).
+						Log().Must()
+					s.Stop()
 					return
 				}
 
-				assert.Must(utils.RunShell("git", "add", "--update"))
+				assert.Must(utils.RunShell(ctx, "git", "add", "--update"))
 
-				diff := assert.Must1(utils.GetStagedDiff(nil))
+				diff := assert.Must1(utils.GetStagedDiff(ctx))
 				if diff == nil || len(diff.Files) == 0 {
 					return nil
 				}
@@ -172,31 +178,24 @@ func New(version string) func(params Params) *Command {
 				}
 
 				msg := resp.Choices[0].Message.Content
-				msg = tap.Text(ctx, tap.TextOptions{
-					Message:      "git message(update or enter) >> ",
+				msg = strings.TrimSpace(tap.Text(ctx, tap.TextOptions{
+					Message:      "git message(update or enter):",
 					InitialValue: msg,
 					DefaultValue: msg,
 					Placeholder:  "update or enter",
-				})
+				}))
 
 				if msg == "" {
 					return
 				}
 
-				//var p1 = tea.NewProgram(initialTextInputModel(msg))
-				//mm := assert.Must1(p1.Run()).(model2)
-				//if mm.isExit() {
-				//	return nil
-				//}
-
-				//msg = mm.Value()
-				assert.Must(utils.RunShell("git", "commit", "-m", strconv.Quote(msg)))
-				assert.Must(utils.RunShell("git", "push", "origin", cmdutils.GetBranchName()))
+				assert.Must(utils.RunShell(ctx, "git", "commit", "-m", strconv.Quote(msg)))
+				assert.Must(utils.RunShell(ctx, "git", "push", "origin", cmdutils.GetBranchName()))
 				if flags.showPrompt {
 					fmt.Println("\n" + generatePrompt + "\n")
 				}
 				log.Info().Any("usage", resp.Usage).Msg("openai response usage")
-				return nil
+				return
 			},
 		}
 

cmds/fastcommit/ui.go

@@ -2,16 +2,14 @@ package tagcmd
 
 import (
 	"context"
-	"strings"
-	"time"
-
-	"github.com/briandowns/spinner"
 	tea "github.com/charmbracelet/bubbletea"
 	semver "github.com/hashicorp/go-version"
 	"github.com/pubgo/funk/assert"
 	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/recovery"
+	"github.com/pubgo/funk/v2/result"
 	"github.com/urfave/cli/v3"
+	"strings"
 
 	"github.com/pubgo/fastcommit/cmds/cmdutils"
 	"github.com/pubgo/fastcommit/utils"
@@ -25,15 +23,15 @@ func New() *cli.Command {
 			defer recovery.Exit()
 
 			cmdutils.LoadConfigAndBranch()
-			
+
 			var p = tea.NewProgram(initialModel())
 			m := assert.Must1(p.Run()).(model)
 			selected := strings.TrimSpace(m.selected)
 			if selected == "" {
 				return nil
 			}
 
-			tags := utils.GetAllGitTags()
+			tags := utils.GetAllGitTags(ctx)
 			ver := utils.GetNextTag(selected, tags)
 			if selected == envRelease {
 				ver = utils.GetNextReleaseTag(tags)
@@ -52,14 +50,14 @@ func New() *cli.Command {
 				return errors.Errorf("tag name is not valid: %s", tagName)
 			}
 
-			output := utils.GitPushTag(tagName)
+			output := utils.Spin("push tag: ", func() (r result.Result[string]) {
+				return r.WithValue(utils.GitPushTag(ctx, tagName))
+			}).Log().Must()
 			if utils.IsRemoteTagExist(output) {
-				s := spinner.New(spinner.CharSets[35], 100*time.Millisecond, func(s *spinner.Spinner) {
-					s.Prefix = "fetch git tag: "
+				utils.Spin("fetch git tag: ", func() (r result.Result[any]) {
+					utils.GitFetchAll(ctx)
+					return
 				})
-				s.Start()
-				utils.GitFetchAll()
-				s.Stop()
 			}
 
 			return nil

cmds/tagcmd/cmd.go

@@ -2,10 +2,12 @@ package upgradecmd
 
 import (
 	"context"
-	"fmt"
+	"github.com/pubgo/funk/pretty"
+	"github.com/pubgo/funk/v2/result"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"sort"
 
 	"github.com/hashicorp/go-getter"
@@ -14,7 +16,6 @@ import (
 	"github.com/pubgo/funk/assert"
 	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/log"
-	"github.com/pubgo/funk/recovery"
 	"github.com/rs/zerolog"
 	"github.com/samber/lo"
 	"github.com/urfave/cli/v3"
@@ -35,18 +36,24 @@ func New() *cli.Command {
 					releases := assert.Must1(client.List(ctx))
 
 					tt := tablewriter.NewWriter(os.Stdout)
-					tt.Header([]string{"Name", "OS", "Arch", "Size", "Url"})
+					tt.Header([]string{"Name", "Size", "Url"})
 
 					for _, r := range releases {
 						for _, a := range githubclient.GetAssets(r) {
 							if a.IsChecksumFile() {
 								continue
 							}
 
+							if a.OS != runtime.GOOS {
+								continue
+							}
+
+							if a.Arch != runtime.GOARCH {
+								continue
+							}
+
 							assert.Must(tt.Append([]string{
 								a.Name,
-								a.OS,
-								a.Arch,
 								githubclient.GetSizeFormat(a.Size),
 								a.URL,
 							}))
@@ -56,20 +63,22 @@ func New() *cli.Command {
 				},
 			},
 		},
-		Action: func(ctx context.Context, command *cli.Command) error {
-			defer recovery.Exit(func(err error) error {
+		Action: func(ctx context.Context, command *cli.Command) (gErr error) {
+			defer result.Recovery(&gErr, func(err error) error {
 				if errors.Is(err, context.Canceled) {
 					return nil
 				}
-				errors.Debug(err)
+				pretty.Println(err)
 				return err
 			})
 
 			client := githubclient.NewPublicRelease("pubgo", "fastcommit")
 			r := assert.Must1(client.List(ctx))
 
 			assets := githubclient.GetAssetList(r)
-			assets = lo.Filter(assets, func(item githubclient.Asset, index int) bool { return !item.IsChecksumFile() })
+			assets = lo.Filter(assets, func(item githubclient.Asset, index int) bool {
+				return !item.IsChecksumFile() && item.OS == runtime.GOOS && item.Arch == runtime.GOARCH
+			})
 			sort.Slice(assets, func(i, j int) bool {
 				return assert.Must1(version.NewSemver(assets[i].Name)).GreaterThan(lo.Must(version.NewSemver(assets[j].Name)))
 			})
@@ -78,19 +87,24 @@ func New() *cli.Command {
 				assets = assets[:20]
 			}
 
-			result2 := tap.Select[string](context.Background(), tap.SelectOptions[string]{
-				Message: "Which frontend framework do you prefer?",
+			versionName := tap.Select[string](ctx, tap.SelectOptions[string]{
+				Message: "Which version do you prefer?",
 				Options: lo.Map(assets, func(item githubclient.Asset, index int) tap.SelectOption[string] {
 					return tap.SelectOption[string]{
 						Value: item.Name,
-						Label: fmt.Sprintf("%s %s %s", item.Name, item.OS, item.Arch),
+						Label: item.Name,
 					}
 				}),
 			})
-			fmt.Printf("\nYou chose: %s\n", result2)
 
-			asset, ok := lo.Find(assets, func(item githubclient.Asset) bool { return item.Name == result2 })
-			assert.If(!ok, "%s not found", result2)
+			if versionName == "" {
+				return nil
+			}
+
+			log.Info(ctx).Msgf("You chose: %s", versionName)
+
+			asset, ok := lo.Find(assets, func(item githubclient.Asset) bool { return item.Name == versionName })
+			assert.If(!ok, "%s not found", versionName)
 			var downloadURL = asset.URL
 
 			downloadDir := filepath.Join(os.TempDir(), "fastcommit")