Auto-detect current branch for issues, metrics, and vulns commands

- Default behavior now resolves the current git branch and fetches
  results from its latest analyzed commit instead of the default branch
- Add --default-branch flag to explicitly query the default branch
- Rename transformers package to codeformatters
- Add aliases, EPSS score, and reference URLs to vulnerability data
- Add report card and updatedAt fields to analysis runs
- Support server-side filtering (source, category, severity) for
  run-scoped issues queries
- Add cmdutil.ResolveLatestRun helper for branch auto-detection
- Make auth login/logout and dashboard commands accept injectable deps
- Add tests for all new behavior including branch auto-detection,
  mutual exclusivity, YAML output, output-file, and empty results

Author: jai-deepsource

command/auth/login/login.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/MakeNowJust/heredoc"
+	"github.com/deepsourcelabs/cli/command/cmddeps"
 	"github.com/deepsourcelabs/cli/config"
 	"github.com/deepsourcelabs/cli/internal/cli/args"
 	"github.com/deepsourcelabs/cli/internal/cli/prompt"
@@ -22,10 +23,16 @@ type LoginOptions struct {
 	HostName     string
 	Interactive  bool
 	PAT          string
+	deps         *cmddeps.Deps
 }
 
 // NewCmdLogin handles the login functionality for the CLI
 func NewCmdLogin() *cobra.Command {
+	return NewCmdLoginWithDeps(nil)
+}
+
+// NewCmdLoginWithDeps creates the login command with injectable dependencies.
+func NewCmdLoginWithDeps(deps *cmddeps.Deps) *cobra.Command {
 	doc := heredoc.Docf(`
 		Log in to DeepSource using the CLI.
 
@@ -44,6 +51,7 @@ func NewCmdLogin() *cobra.Command {
 		TokenExpired: true,
 		User:         "",
 		HostName:     "",
+		deps:         deps,
 	}
 
 	cmd := &cobra.Command{
@@ -66,7 +74,13 @@ func NewCmdLogin() *cobra.Command {
 
 // Run executes the auth command and starts the login flow if not already authenticated
 func (opts *LoginOptions) Run() (err error) {
-	svc := authsvc.NewService(config.DefaultManager())
+	var cfgMgr *config.Manager
+	if opts.deps != nil && opts.deps.ConfigMgr != nil {
+		cfgMgr = opts.deps.ConfigMgr
+	} else {
+		cfgMgr = config.DefaultManager()
+	}
+	svc := authsvc.NewService(cfgMgr)
 	// Fetch config (errors are non-fatal: a zero config just means "not logged in")
 	cfg, err := svc.LoadConfig()
 	if err != nil {

command/auth/login/tests/login_test.go

@@ -0,0 +1,87 @@
+package tests
+
+import (
+	"testing"
+
+	"github.com/deepsourcelabs/cli/command/cmddeps"
+	loginCmd "github.com/deepsourcelabs/cli/command/auth/login"
+	"github.com/deepsourcelabs/cli/internal/testutil"
+)
+
+func TestLoginPATFlow(t *testing.T) {
+	// Empty token → IsExpired() returns true → skips re-auth prompt
+	cfgMgr := testutil.CreateExpiredTestConfigManager(t, "", "deepsource.com", "")
+
+	deps := &cmddeps.Deps{
+		ConfigMgr: cfgMgr,
+	}
+
+	cmd := loginCmd.NewCmdLoginWithDeps(deps)
+	cmd.SetArgs([]string{"--with-token", "dsp_abc123"})
+
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	// Verify token was saved
+	cfg, err := cfgMgr.Load()
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+	if cfg.Token != "dsp_abc123" {
+		t.Errorf("expected token %q, got %q", "dsp_abc123", cfg.Token)
+	}
+	if cfg.Host != "deepsource.com" {
+		t.Errorf("expected host %q, got %q", "deepsource.com", cfg.Host)
+	}
+}
+
+func TestLoginPATWithHostname(t *testing.T) {
+	cfgMgr := testutil.CreateExpiredTestConfigManager(t, "", "deepsource.com", "")
+
+	deps := &cmddeps.Deps{
+		ConfigMgr: cfgMgr,
+	}
+
+	cmd := loginCmd.NewCmdLoginWithDeps(deps)
+	cmd.SetArgs([]string{"--with-token", "dsp_xyz789", "--hostname", "enterprise.example.com"})
+
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	cfg, err := cfgMgr.Load()
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+	if cfg.Token != "dsp_xyz789" {
+		t.Errorf("expected token %q, got %q", "dsp_xyz789", cfg.Token)
+	}
+	if cfg.Host != "enterprise.example.com" {
+		t.Errorf("expected host %q, got %q", "enterprise.example.com", cfg.Host)
+	}
+}
+
+func TestLoginDefaultHostname(t *testing.T) {
+	cfgMgr := testutil.CreateExpiredTestConfigManager(t, "", "deepsource.com", "")
+
+	deps := &cmddeps.Deps{
+		ConfigMgr: cfgMgr,
+	}
+
+	cmd := loginCmd.NewCmdLoginWithDeps(deps)
+	cmd.SetArgs([]string{"--with-token", "dsp_default"})
+
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	cfg, err := cfgMgr.Load()
+	if err != nil {
+		t.Fatalf("failed to load config: %v", err)
+	}
+	// Without --hostname, host defaults to deepsource.com
+	if cfg.Host != "deepsource.com" {
+		t.Errorf("expected host %q, got %q", "deepsource.com", cfg.Host)
+	}
+}

command/auth/logout/logout.go

@@ -3,6 +3,7 @@ package logout
 import (
 	"errors"
 
+	"github.com/deepsourcelabs/cli/command/cmddeps"
 	"github.com/deepsourcelabs/cli/config"
 	"github.com/deepsourcelabs/cli/internal/cli/args"
 	"github.com/deepsourcelabs/cli/internal/cli/prompt"
@@ -12,24 +13,37 @@ import (
 	"github.com/spf13/cobra"
 )
 
-type LogoutOptions struct{}
+type LogoutOptions struct {
+	deps *cmddeps.Deps
+}
 
 // NewCmdLogout handles the logout functionality for the CLI
 func NewCmdLogout() *cobra.Command {
+	return NewCmdLogoutWithDeps(nil)
+}
+
+// NewCmdLogoutWithDeps creates the logout command with injectable dependencies.
+func NewCmdLogoutWithDeps(deps *cmddeps.Deps) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "logout",
 		Short: "Logout of your active DeepSource account",
 		Args:  args.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			opts := LogoutOptions{}
+			opts := LogoutOptions{deps: deps}
 			return opts.Run()
 		},
 	}
 	return cmd
 }
 
 func (opts *LogoutOptions) Run() error {
-	svc := authsvc.NewService(config.DefaultManager())
+	var cfgMgr *config.Manager
+	if opts.deps != nil && opts.deps.ConfigMgr != nil {
+		cfgMgr = opts.deps.ConfigMgr
+	} else {
+		cfgMgr = config.DefaultManager()
+	}
+	svc := authsvc.NewService(cfgMgr)
 	// Fetch config
 	cfg, err := svc.LoadConfig()
 	if err != nil {

command/auth/logout/tests/logout_test.go

@@ -0,0 +1,31 @@
+package tests
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/deepsourcelabs/cli/command/cmddeps"
+	logoutCmd "github.com/deepsourcelabs/cli/command/auth/logout"
+	"github.com/deepsourcelabs/cli/internal/testutil"
+)
+
+func TestLogoutNotLoggedIn(t *testing.T) {
+	// Empty token → user is not logged in
+	cfgMgr := testutil.CreateExpiredTestConfigManager(t, "", "deepsource.com", "")
+
+	deps := &cmddeps.Deps{
+		ConfigMgr: cfgMgr,
+	}
+
+	cmd := logoutCmd.NewCmdLogoutWithDeps(deps)
+	cmd.SetArgs([]string{})
+
+	err := cmd.Execute()
+	if err == nil {
+		t.Fatal("expected error when not logged in, got nil")
+	}
+
+	if !strings.Contains(err.Error(), "not logged into DeepSource") {
+		t.Errorf("expected error to contain %q, got %q", "not logged into DeepSource", err.Error())
+	}
+}

command/cmddeps/deps.go

@@ -16,4 +16,5 @@ type Deps struct {
 	ConfigMgr   *config.Manager
 	Stdout      io.Writer
 	RepoService *reposvc.Service
+	BranchNameFunc func() (string, error)
 }

command/cmdutil/resolve_run.go

@@ -0,0 +1,57 @@
+package cmdutil
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os/exec"
+	"strings"
+
+	"github.com/deepsourcelabs/cli/deepsource"
+	"github.com/deepsourcelabs/cli/internal/vcs"
+)
+
+// ResolveLatestRun finds the latest analysis run for the current git branch.
+// Returns the commitOid of the latest run and the branch name.
+func ResolveLatestRun(
+	ctx context.Context,
+	client *deepsource.Client,
+	remote *vcs.RemoteData,
+	branchNameFunc func() (string, error),
+) (commitOid string, branchName string, err error) {
+	if branchNameFunc != nil {
+		branchName, err = branchNameFunc()
+	} else {
+		branchName, err = getCurrentBranch()
+	}
+	if err != nil {
+		return "", "", fmt.Errorf("failed to detect current branch: %w", err)
+	}
+
+	runs, err := client.GetAnalysisRuns(ctx, remote.Owner, remote.RepoName, remote.VCSProvider, 30)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to fetch analysis runs: %w", err)
+	}
+
+	for _, run := range runs {
+		if run.BranchName == branchName && run.Status == "SUCCESS" {
+			return run.CommitOid, branchName, nil
+		}
+	}
+
+	return "", branchName, fmt.Errorf(
+		"no analysis runs found for branch %q.\nTry: --default-branch, --commit <oid>, or push and analyze this branch first",
+		branchName,
+	)
+}
+
+func getCurrentBranch() (string, error) {
+	cmd := exec.Command("git", "--no-pager", "rev-parse", "--abbrev-ref", "HEAD")
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+	return strings.TrimSuffix(stdout.String(), "\n"), nil
+}

command/flags_test.go

@@ -0,0 +1,100 @@
+package command
+
+import (
+	"testing"
+
+	analysisCmd "github.com/deepsourcelabs/cli/command/analysis"
+	issuesCmd "github.com/deepsourcelabs/cli/command/issues"
+	metricsCmd "github.com/deepsourcelabs/cli/command/metrics"
+	vulnsCmd "github.com/deepsourcelabs/cli/command/vulnerabilities"
+	"github.com/spf13/cobra"
+)
+
+type flagExpectation struct {
+	name         string
+	defaultValue string
+}
+
+func TestFlagDefaults(t *testing.T) {
+	tests := []struct {
+		name      string
+		buildCmd  func() *cobra.Command
+		expected  []flagExpectation
+	}{
+		{
+			name:     "issues",
+			buildCmd: issuesCmd.NewCmdIssues,
+			expected: []flagExpectation{
+				{name: "limit", defaultValue: "30"},
+				{name: "output", defaultValue: "pretty"},
+				{name: "verbose", defaultValue: "false"},
+				{name: "pr", defaultValue: "0"},
+				{name: "commit", defaultValue: ""},
+				{name: "repo", defaultValue: ""},
+				{name: "output-file", defaultValue: ""},
+				{name: "severity", defaultValue: "[]"},
+				{name: "category", defaultValue: "[]"},
+				{name: "analyzer", defaultValue: "[]"},
+				{name: "code", defaultValue: "[]"},
+				{name: "path", defaultValue: "[]"},
+				{name: "source", defaultValue: "[]"},
+				{name: "default-branch", defaultValue: "false"},
+			},
+		},
+		{
+			name:     "metrics",
+			buildCmd: metricsCmd.NewCmdMetrics,
+			expected: []flagExpectation{
+				{name: "limit", defaultValue: "30"},
+				{name: "output", defaultValue: "pretty"},
+				{name: "verbose", defaultValue: "false"},
+				{name: "pr", defaultValue: "0"},
+				{name: "commit", defaultValue: ""},
+				{name: "repo", defaultValue: ""},
+				{name: "output-file", defaultValue: ""},
+			},
+		},
+		{
+			name:     "vulnerabilities",
+			buildCmd: vulnsCmd.NewCmdVulnerabilities,
+			expected: []flagExpectation{
+				{name: "limit", defaultValue: "100"},
+				{name: "output", defaultValue: "pretty"},
+				{name: "verbose", defaultValue: "false"},
+				{name: "pr", defaultValue: "0"},
+				{name: "commit", defaultValue: ""},
+				{name: "repo", defaultValue: ""},
+				{name: "output-file", defaultValue: ""},
+				{name: "severity", defaultValue: "[]"},
+			},
+		},
+		{
+			name:     "analysis",
+			buildCmd: analysisCmd.NewCmdAnalysis,
+			expected: []flagExpectation{
+				{name: "limit", defaultValue: "20"},
+				{name: "output", defaultValue: "pretty"},
+				{name: "commit", defaultValue: ""},
+				{name: "repo", defaultValue: ""},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := tt.buildCmd()
+
+			for _, exp := range tt.expected {
+				flag := cmd.Flags().Lookup(exp.name)
+				if flag == nil {
+					t.Errorf("flag %q not found on command %q", exp.name, tt.name)
+					continue
+				}
+				if flag.DefValue != exp.defaultValue {
+					t.Errorf("flag %q on command %q: expected default %q, got %q",
+						exp.name, tt.name, exp.defaultValue, flag.DefValue)
+				}
+			}
+		})
+	}
+}