Improve update flow and monorepo sub-repo resolution

- Make update check non-blocking by running it in a background goroutine
  and showing the result from the previous check instantly
- Break ApplyUpdate into PrepareUpdate/DownloadUpdate/VerifyUpdate/ExtractAndInstall
  with step-by-step progress output
- Extract monorepo retry logic into resolveIssuesWithRetry for clarity
- Use os.Getwd and filepath.Rel instead of shelling out to pwd
- Fix pointer receiver on CLIConfig.IsExpired and unused receiver in pat_login_flow

Author: jai-deepsource

cmd/deepsource/main.go

@@ -73,21 +73,24 @@ func mainRun() (exitCode int) {
 func run() int {
 	v.SetBuildInfo(version, Date, buildMode)
 
-	// Check for available updates and notify (skip when running "update" itself)
+	// Notify about available updates from a previous check (instant, disk-only read).
+	// Then kick off a background check for the next invocation.
 	isUpdateCmd := len(os.Args) >= 2 && os.Args[1] == "update"
 	if !isUpdateCmd && update.ShouldCheckForUpdate() {
-		client := &http.Client{Timeout: 3 * time.Second}
-		if err := update.CheckForUpdate(client); err != nil {
-			debug.Log("update: %v", err)
-		}
-
 		state, err := update.ReadUpdateState()
 		if err != nil {
 			debug.Log("update: %v", err)
 		}
 		if state != nil {
-			fmt.Fprintln(os.Stderr, pterm.Yellow(fmt.Sprintf("Update available: v%s, run '%s update' to install.", state.Version, filepath.Base(os.Args[0]))))
+			fmt.Fprintln(os.Stderr, pterm.Yellow(fmt.Sprintf("Update available: v%s → v%s, run '%s update' to install.", version, state.Version, filepath.Base(os.Args[0]))))
 		}
+
+		go func() {
+			client := &http.Client{Timeout: 3 * time.Second}
+			if err := update.CheckForUpdate(client); err != nil {
+				debug.Log("update: %v", err)
+			}
+		}()
 	}
 
 	exitCode := 0

command/auth/login/pat_login_flow.go

@@ -9,7 +9,7 @@ import (
 	"github.com/fatih/color"
 )
 
-func (opts *LoginOptions) startPATLoginFlow(svc *authsvc.Service, cfg *config.CLIConfig, token string) error {
+func (_ *LoginOptions) startPATLoginFlow(svc *authsvc.Service, cfg *config.CLIConfig, token string) error {
 	cfg.Token = token
 
 	viewer, err := svc.GetViewer(context.Background(), cfg)

command/issues/issues.go

@@ -252,36 +252,9 @@ func (opts *IssuesOptions) Run(ctx context.Context, cmd *cobra.Command) error {
 	opts.client = client
 	opts.remote = remote
 
-	issuesList, err := opts.resolveIssues(ctx, client, remote)
+	issuesList, err := opts.resolveIssuesWithRetry(ctx, client, remote)
 	if err != nil {
-		// If the API says this is a monorepo, show a friendly message.
-		if strings.Contains(err.Error(), "This repository is a monorepo") {
-			return fmt.Errorf("This is a monorepo. Use --repo to specify a sub-project.\n\nHint: %s", err.Error())
-		}
-
-		// If we auto-detected a sub-repo path and the exact path wasn't found,
-		// progressively strip the last segment and retry.
-		if strings.Contains(err.Error(), "Repository does not exist") && remote.SubRepoSuffix != "" {
-			parts := strings.Split(remote.SubRepoSuffix, ":")
-			// Try stripping from the end: e.g. a:b:c → a:b → a
-			for len(parts) > 1 {
-				parts = parts[:len(parts)-1]
-				remote.SubRepoSuffix = strings.Join(parts, ":")
-				baseName := strings.SplitN(remote.RepoName, ":", 2)[0]
-				remote.RepoName = baseName + ":" + remote.SubRepoSuffix
-
-				issuesList, err = opts.resolveIssues(ctx, client, remote)
-				if err == nil {
-					break
-				}
-				if !strings.Contains(err.Error(), "Repository does not exist") {
-					return err
-				}
-			}
-		}
-		if err != nil {
-			return err
-		}
+		return err
 	}
 	if issuesList == nil {
 		return nil
@@ -310,6 +283,41 @@ func (opts *IssuesOptions) Run(ctx context.Context, cmd *cobra.Command) error {
 	return nil
 }
 
+// resolveIssuesWithRetry calls resolveIssues and, for monorepos with an
+// auto-detected sub-repo path, progressively strips path segments on
+// "Repository does not exist" errors until a match is found.
+func (opts *IssuesOptions) resolveIssuesWithRetry(ctx context.Context, client *deepsource.Client, remote *vcs.RemoteData) ([]issues.Issue, error) {
+	issuesList, err := opts.resolveIssues(ctx, client, remote)
+	if err == nil {
+		return issuesList, nil
+	}
+
+	if strings.Contains(err.Error(), "This repository is a monorepo") {
+		return nil, fmt.Errorf("This is a monorepo. Use --repo to specify a sub-project.\n\nHint: %s", err.Error())
+	}
+
+	if !strings.Contains(err.Error(), "Repository does not exist") || remote.SubRepoSuffix == "" {
+		return nil, err
+	}
+
+	parts := strings.Split(remote.SubRepoSuffix, ":")
+	for len(parts) > 1 {
+		parts = parts[:len(parts)-1]
+		remote.SubRepoSuffix = strings.Join(parts, ":")
+		baseName := strings.SplitN(remote.RepoName, ":", 2)[0]
+		remote.RepoName = baseName + ":" + remote.SubRepoSuffix
+
+		issuesList, err = opts.resolveIssues(ctx, client, remote)
+		if err == nil {
+			return issuesList, nil
+		}
+		if !strings.Contains(err.Error(), "Repository does not exist") {
+			return nil, err
+		}
+	}
+	return nil, err
+}
+
 func (opts *IssuesOptions) resolveIssues(ctx context.Context, client *deepsource.Client, remote *vcs.RemoteData) ([]issues.Issue, error) {
 	serverFilters := opts.buildServerFilters()
 	prFilters := opts.buildPRFilters()

command/update/update.go

@@ -3,10 +3,12 @@ package update
 import (
 	"fmt"
 	"net/http"
+	"runtime"
 	"time"
 
 	"github.com/deepsourcelabs/cli/buildinfo"
 	"github.com/deepsourcelabs/cli/internal/update"
+	"github.com/pterm/pterm"
 	"github.com/spf13/cobra"
 )
 
@@ -29,7 +31,7 @@ func runUpdate(cmd *cobra.Command) error {
 		return fmt.Errorf("checking for updates: %w", err)
 	}
 
-	state, err := update.ReadUpdateState()
+	state, err := update.PrepareUpdate()
 	if err != nil {
 		return fmt.Errorf("reading update state: %w", err)
 	}
@@ -40,17 +42,25 @@ func runUpdate(cmd *cobra.Command) error {
 		return nil
 	}
 
-	fmt.Fprintf(w, "Updating to v%s...\n", state.Version)
+	fmt.Fprintln(w, pterm.Green("✓")+" Platform: "+runtime.GOOS+"/"+runtime.GOARCH)
+	fmt.Fprintln(w, pterm.Green("✓")+" Version: v"+state.Version)
 
 	applyClient := &http.Client{Timeout: 30 * time.Second}
-	newVer, err := update.ApplyUpdate(applyClient)
+	data, err := update.DownloadUpdate(applyClient, state)
 	if err != nil {
-		return fmt.Errorf("applying update: %w", err)
+		return fmt.Errorf("downloading update: %w", err)
 	}
+	fmt.Fprintln(w, pterm.Green("✓")+" Downloaded")
 
-	if newVer != "" {
-		fmt.Fprintf(w, "Updated to v%s\n", newVer)
+	if err := update.VerifyUpdate(data, state); err != nil {
+		return fmt.Errorf("verifying update: %w", err)
 	}
+	fmt.Fprintln(w, pterm.Green("✓")+" Checksum verified")
+
+	if err := update.ExtractAndInstall(data, state.ArchiveURL); err != nil {
+		return fmt.Errorf("installing update: %w", err)
+	}
+	fmt.Fprintln(w, pterm.Green("✓")+" Installed")
 
 	return nil
 }

config/config.go

@@ -25,7 +25,7 @@ func (cfg *CLIConfig) SetTokenExpiry(str string) {
 	cfg.TokenExpiresIn = t.UTC()
 }
 
-func (cfg CLIConfig) IsExpired() bool {
+func (cfg *CLIConfig) IsExpired() bool {
 	if cfg.TokenExpiresIn.IsZero() {
 		return false
 	}

internal/update/updater.go

@@ -127,50 +127,78 @@ func CheckForUpdate(client *http.Client) error {
 	return writeUpdateState(state)
 }
 
-// ApplyUpdate reads the state file, downloads the archive, verifies, extracts,
-// and replaces the binary. Returns the new version string on success.
-// Clears the state file regardless of outcome so we don't retry broken updates forever.
-func ApplyUpdate(client *http.Client) (string, error) {
+// PrepareUpdate reads and clears the state file, returning the update state.
+// Returns nil if no update is available.
+func PrepareUpdate() (*UpdateState, error) {
 	state, err := ReadUpdateState()
 	if err != nil {
 		clearUpdateState()
-		return "", err
+		return nil, err
 	}
 	if state == nil {
-		return "", nil
+		return nil, nil
 	}
 
 	// Clear state file up front so a failed update doesn't retry forever.
-	// The next run will do a fresh CheckForUpdate instead.
 	clearUpdateState()
+	return state, nil
+}
 
-	debug.Log("update: applying update to v%s", state.Version)
-
-	data, err := downloadFile(client, state.ArchiveURL)
-	if err != nil {
-		return "", err
-	}
+// DownloadUpdate downloads the archive from the state's URL.
+func DownloadUpdate(client *http.Client, state *UpdateState) ([]byte, error) {
+	return downloadFile(client, state.ArchiveURL)
+}
 
-	if err := verifyChecksum(data, state.SHA256); err != nil {
-		return "", err
-	}
+// VerifyUpdate checks the SHA256 checksum of the downloaded data.
+func VerifyUpdate(data []byte, state *UpdateState) error {
+	return verifyChecksum(data, state.SHA256)
+}
 
+// ExtractAndInstall extracts the binary from the archive and replaces the current executable.
+func ExtractAndInstall(data []byte, archiveURL string) error {
 	binaryName := buildinfo.AppName
 	if runtime.GOOS == "windows" {
 		binaryName += ".exe"
 	}
 
 	var binaryData []byte
-	if strings.HasSuffix(state.ArchiveURL, ".zip") {
+	var err error
+	if strings.HasSuffix(archiveURL, ".zip") {
 		binaryData, err = extractFromZip(data, binaryName)
 	} else {
 		binaryData, err = extractFromTarGz(data, binaryName)
 	}
 	if err != nil {
+		return err
+	}
+
+	return replaceBinary(binaryData)
+}
+
+// ApplyUpdate reads the state file, downloads the archive, verifies, extracts,
+// and replaces the binary. Returns the new version string on success.
+// Clears the state file regardless of outcome so we don't retry broken updates forever.
+func ApplyUpdate(client *http.Client) (string, error) {
+	state, err := PrepareUpdate()
+	if err != nil {
+		return "", err
+	}
+	if state == nil {
+		return "", nil
+	}
+
+	debug.Log("update: applying update to v%s", state.Version)
+
+	data, err := DownloadUpdate(client, state)
+	if err != nil {
+		return "", err
+	}
+
+	if err := VerifyUpdate(data, state); err != nil {
 		return "", err
 	}
 
-	if err := replaceBinary(binaryData); err != nil {
+	if err := ExtractAndInstall(data, state.ArchiveURL); err != nil {
 		return "", err
 	}
 

internal/vcs/remotes.go

@@ -3,7 +3,9 @@ package vcs
 import (
 	"fmt"
 	"net/url"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"regexp"
 	"strings"
 
@@ -140,24 +142,22 @@ func detectSubRepoPath() string {
 	}
 	toplevel = strings.TrimSpace(toplevel)
 
-	cwd, err := runCmd("pwd", nil)
+	cwd, err := os.Getwd()
 	if err != nil {
 		return ""
 	}
-	cwd = strings.TrimSpace(cwd)
 
 	if cwd == toplevel {
 		return ""
 	}
 
-	rel := strings.TrimPrefix(cwd, toplevel+"/")
-	if rel == cwd {
-		// cwd is not under toplevel (shouldn't happen)
+	rel, err := filepath.Rel(toplevel, cwd)
+	if err != nil {
 		return ""
 	}
 
 	debug.Log("git: sub-repo relative path %q", rel)
-	return strings.ReplaceAll(rel, "/", ":")
+	return strings.ReplaceAll(rel, string(os.PathSeparator), ":")
 }
 
 func runCmd(command string, args []string) (string, error) {