Merge pull request #15 from codeGROOVE-dev/others

more API refactoring work

Author: tstromberg

README.md

@@ -5,9 +5,9 @@ Go library for fetching pull request data from GitHub, GitLab, and Gitea/Codeber
 ## Quick Start
 
 ```go
-import "github.com/codeGROOVE-dev/prx/pkg/prx"
+import "github.com/codeGROOVE-dev/prx/pkg/pr"
 
-data, err := prx.Fetch(ctx, "https://github.com/golang/go/pull/12345")
+data, err := pr.Fetch(ctx, "https://github.com/golang/go/pull/12345")
 // Works with: GitHub, GitLab, Codeberg, self-hosted instances
 ```
 Auto-detects platform and resolves authentication from `GITHUB_TOKEN`/`GITLAB_TOKEN`/`GITEA_TOKEN` or CLI tools (`gh`, `glab`, `tea`, `berg`).
@@ -21,7 +21,7 @@ import (
 )
 
 platform := github.NewPlatform(token)
-client := prx.NewClientWithPlatform(platform)
+client := prx.NewClient(platform)
 data, err := client.PullRequest(ctx, "owner", "repo", 123)
 ```
 

cmd/prx/main.go

@@ -18,7 +18,6 @@ import (
 	"github.com/codeGROOVE-dev/prx/pkg/prx/gitea"
 	"github.com/codeGROOVE-dev/prx/pkg/prx/github"
 	"github.com/codeGROOVE-dev/prx/pkg/prx/gitlab"
-	"github.com/codeGROOVE-dev/prx/pkg/prx/types"
 )
 
 var (
@@ -60,7 +59,7 @@ func run() error {
 
 	prURL := flag.Arg(0)
 
-	parsed, err := types.ParseURL(prURL)
+	parsed, err := prx.ParseURL(prURL)
 	if err != nil {
 		return fmt.Errorf("invalid PR URL: %w", err)
 	}
@@ -75,7 +74,7 @@ func run() error {
 	token, err := resolver.Resolve(ctx, platform, parsed.Host)
 	// Authentication is optional for public repos on GitLab/Gitea/Codeberg
 	// Only GitHub strictly requires authentication for most API calls
-	tokenOptional := parsed.Platform != types.PlatformGitHub
+	tokenOptional := parsed.Platform != prx.PlatformGitHub
 
 	if err != nil && !tokenOptional {
 		return fmt.Errorf("authentication failed: %w", err)
@@ -90,13 +89,13 @@ func run() error {
 	}
 
 	// Create platform-specific client
-	var prxPlatform types.Platform
+	var prxPlatform prx.Platform
 	switch parsed.Platform {
-	case types.PlatformGitHub:
+	case prx.PlatformGitHub:
 		prxPlatform = github.NewPlatform(tokenValue)
-	case types.PlatformGitLab:
+	case prx.PlatformGitLab:
 		prxPlatform = gitlab.NewPlatform(tokenValue, gitlab.WithBaseURL("https://"+parsed.Host))
-	case types.PlatformCodeberg:
+	case prx.PlatformCodeberg:
 		prxPlatform = gitea.NewCodebergPlatform(tokenValue)
 	default:
 		// Self-hosted Gitea
@@ -109,10 +108,10 @@ func run() error {
 		opts = append(opts, prx.WithLogger(slog.Default()))
 	}
 	if *noCache {
-		opts = append(opts, prx.WithCacheStore(null.New[string, types.PullRequestData]()))
+		opts = append(opts, prx.WithCacheStore(null.New[string, prx.PullRequestData]()))
 	}
 
-	client := prx.NewClientWithPlatform(prxPlatform, opts...)
+	client := prx.NewClient(prxPlatform, opts...)
 	data, err := client.PullRequestWithReferenceTime(ctx, parsed.Owner, parsed.Repo, parsed.Number, referenceTime)
 	if err != nil {
 		return fmt.Errorf("failed to fetch PR data: %w", err)

cmd/prx_compare/main.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/codeGROOVE-dev/prx/pkg/prx"
 	"github.com/codeGROOVE-dev/prx/pkg/prx/github"
-	"github.com/codeGROOVE-dev/prx/pkg/prx/types"
 )
 
 const (
@@ -40,15 +39,15 @@ func main() {
 
 	// Both now use GraphQL, but we'll compare two fetches to ensure consistency
 	fmt.Println("Fetching first time...")
-	restClient := prx.NewClientWithPlatform(github.NewPlatform(token))
+	restClient := prx.NewClient(github.NewPlatform(token))
 	restData, err := restClient.PullRequest(context.TODO(), owner, repo, prNumber)
 	if err != nil {
 		log.Fatalf("First fetch failed: %v", err)
 	}
 
 	// Fetch again to compare consistency
 	fmt.Println("Fetching second time...")
-	graphqlClient := prx.NewClientWithPlatform(github.NewPlatform(token))
+	graphqlClient := prx.NewClient(github.NewPlatform(token))
 	graphqlData, err := graphqlClient.PullRequest(context.TODO(), owner, repo, prNumber)
 	if err != nil {
 		log.Fatalf("Second fetch failed: %v", err)
@@ -64,7 +63,7 @@ func main() {
 	fmt.Println("\nFull data saved to rest_output.json and graphql_output.json")
 }
 
-func comparePullRequestData(rest, graphql *types.PullRequestData) {
+func comparePullRequestData(rest, graphql *prx.PullRequestData) {
 	// Compare PullRequest fields
 	fmt.Println("=== Pull Request Metadata ===")
 	comparePullRequest(&rest.PullRequest, &graphql.PullRequest)
@@ -74,7 +73,7 @@ func comparePullRequestData(rest, graphql *types.PullRequestData) {
 	compareEvents(rest.Events, graphql.Events)
 }
 
-func comparePullRequest(rest, graphql *types.PullRequest) {
+func comparePullRequest(rest, graphql *prx.PullRequest) {
 	differences, matches := compareFields(rest, graphql)
 
 	if len(differences) > 0 {
@@ -87,7 +86,7 @@ func comparePullRequest(rest, graphql *types.PullRequest) {
 	fmt.Printf("\nMatching fields: %s\n", strings.Join(matches, ", "))
 }
 
-func compareFields(rest, graphql *types.PullRequest) (differences, matches []string) {
+func compareFields(rest, graphql *prx.PullRequest) (differences, matches []string) {
 	restVal := reflect.ValueOf(*rest)
 	graphqlVal := reflect.ValueOf(*graphql)
 	restType := restVal.Type()
@@ -132,7 +131,7 @@ func comparePointerField(name string, restField, graphqlField reflect.Value) str
 	return ""
 }
 
-func compareCheckSummary(rest, graphql *types.PullRequest) {
+func compareCheckSummary(rest, graphql *prx.PullRequest) {
 	if rest.CheckSummary == nil || graphql.CheckSummary == nil {
 		return
 	}
@@ -150,7 +149,7 @@ func compareCheckSummary(rest, graphql *types.PullRequest) {
 	compareCheckSummaryMaps(rest.CheckSummary, graphql.CheckSummary)
 }
 
-func compareCheckSummaryMaps(rest, graphql *types.CheckSummary) {
+func compareCheckSummaryMaps(rest, graphql *prx.CheckSummary) {
 	compareSummaryMap("Success", rest.Success, graphql.Success)
 	compareSummaryMap("Failing", rest.Failing, graphql.Failing)
 	compareSummaryMap("Pending", rest.Pending, graphql.Pending)
@@ -187,7 +186,7 @@ func compareStatusMaps(rest, graphql map[string]string) {
 	}
 }
 
-func compareEvents(restEvents, graphqlEvents []types.Event) {
+func compareEvents(restEvents, graphqlEvents []prx.Event) {
 	// Count events by type
 	restCounts := countEventsByType(restEvents)
 	graphqlCounts := countEventsByType(graphqlEvents)
@@ -295,23 +294,23 @@ func compareEvents(restEvents, graphqlEvents []types.Event) {
 	}
 }
 
-func countEventsByType(events []types.Event) map[string]int {
+func countEventsByType(events []prx.Event) map[string]int {
 	counts := make(map[string]int)
 	for i := range events {
 		counts[events[i].Kind]++
 	}
 	return counts
 }
 
-func groupEventsByType(events []types.Event) map[string][]types.Event {
-	grouped := make(map[string][]types.Event)
+func groupEventsByType(events []prx.Event) map[string][]prx.Event {
+	grouped := make(map[string][]prx.Event)
 	for i := range events {
 		grouped[events[i].Kind] = append(grouped[events[i].Kind], events[i])
 	}
 	return grouped
 }
 
-func extractWriteAccess(events []types.Event) map[string]int {
+func extractWriteAccess(events []prx.Event) map[string]int {
 	access := make(map[string]int)
 	for i := range events {
 		e := &events[i]
@@ -325,7 +324,7 @@ func extractWriteAccess(events []types.Event) map[string]int {
 	return access
 }
 
-func extractBots(events []types.Event) map[string]bool {
+func extractBots(events []prx.Event) map[string]bool {
 	bots := make(map[string]bool)
 	for i := range events {
 		e := &events[i]

pkg/prx/auth/auth_test.go

@@ -490,3 +490,177 @@ func TestResolver_ResolveGitea_TeaConfig(t *testing.T) {
 		t.Errorf("Source = %v, want %v", token.Source, TokenSourceConfig)
 	}
 }
+
+func TestResolver_ResolveGitHub_NoToken(t *testing.T) {
+	// Clear all env vars
+	os.Unsetenv("GITHUB_TOKEN")
+	os.Unsetenv("GH_TOKEN")
+
+	// Set PATH to empty to ensure gh CLI is not available
+	oldPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", oldPath)
+	os.Setenv("PATH", "")
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitHub(context.Background())
+	if err == nil {
+		t.Error("Expected error when no GitHub token available")
+	}
+}
+
+func TestResolver_ResolveGitLab_NoToken(t *testing.T) {
+	// Clear all env vars
+	os.Unsetenv("GITLAB_TOKEN")
+	os.Unsetenv("GL_TOKEN")
+
+	// Set PATH to empty to ensure glab CLI is not available
+	oldPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", oldPath)
+	os.Setenv("PATH", "")
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitLab(context.Background(), "")
+	if err == nil {
+		t.Error("Expected error when no GitLab token available")
+	}
+}
+
+func TestResolver_ResolveGitHub_EmptyEnvVar(t *testing.T) {
+	// Set env var to empty string
+	t.Setenv("GITHUB_TOKEN", "")
+	t.Setenv("GH_TOKEN", "")
+
+	// Set PATH to empty to ensure gh CLI is not available
+	oldPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", oldPath)
+	os.Setenv("PATH", "")
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitHub(context.Background())
+	if err == nil {
+		t.Error("Expected error when GitHub token env var is empty")
+	}
+}
+
+func TestResolver_ResolveGitLab_EmptyEnvVar(t *testing.T) {
+	// Set env var to empty string
+	t.Setenv("GITLAB_TOKEN", "")
+	t.Setenv("GL_TOKEN", "")
+
+	// Set PATH to empty to ensure glab CLI is not available
+	oldPath := os.Getenv("PATH")
+	defer os.Setenv("PATH", oldPath)
+	os.Setenv("PATH", "")
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitLab(context.Background(), "gitlab.com")
+	if err == nil {
+		t.Error("Expected error when GitLab token env var is empty")
+	}
+}
+
+func TestResolver_ResolveGitea_EmptyEnvVar(t *testing.T) {
+	// Set env vars to empty strings
+	t.Setenv("CODEBERG_TOKEN", "")
+	t.Setenv("GITEA_TOKEN", "")
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitea(context.Background(), "codeberg.org")
+	if err == nil {
+		t.Error("Expected error when Gitea token env var is empty")
+	}
+}
+
+func TestResolver_ResolveGitLab_CLISuccess(t *testing.T) {
+	// Clear env vars to force CLI path
+	os.Unsetenv("GITLAB_TOKEN")
+	os.Unsetenv("GL_TOKEN")
+
+	// Create a mock glab command that returns a token
+	tempDir := t.TempDir()
+	glabScript := filepath.Join(tempDir, "glab")
+	scriptContent := `#!/bin/sh
+echo "glpat_cli_token"
+`
+	if err := os.WriteFile(glabScript, []byte(scriptContent), 0o755); err != nil {
+		t.Fatalf("Failed to create mock glab script: %v", err)
+	}
+
+	// Prepend our temp dir to PATH
+	oldPath := os.Getenv("PATH")
+	t.Setenv("PATH", tempDir+":"+oldPath)
+
+	resolver := NewResolver()
+	token, err := resolver.ResolveGitLab(context.Background(), "gitlab.com")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+		return
+	}
+
+	if token.Value != "glpat_cli_token" {
+		t.Errorf("Token = %q, want %q", token.Value, "glpat_cli_token")
+	}
+	if token.Source != TokenSourceCLI {
+		t.Errorf("Source = %v, want %v", token.Source, TokenSourceCLI)
+	}
+}
+
+func TestResolver_ResolveGitHub_CLISuccess(t *testing.T) {
+	// Clear env vars to force CLI path
+	os.Unsetenv("GITHUB_TOKEN")
+	os.Unsetenv("GH_TOKEN")
+
+	// Create a mock gh command that returns a token
+	tempDir := t.TempDir()
+	ghScript := filepath.Join(tempDir, "gh")
+	scriptContent := `#!/bin/sh
+echo "ghp_cli_token"
+`
+	if err := os.WriteFile(ghScript, []byte(scriptContent), 0o755); err != nil {
+		t.Fatalf("Failed to create mock gh script: %v", err)
+	}
+
+	// Prepend our temp dir to PATH
+	oldPath := os.Getenv("PATH")
+	t.Setenv("PATH", tempDir+":"+oldPath)
+
+	resolver := NewResolver()
+	token, err := resolver.ResolveGitHub(context.Background())
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+		return
+	}
+
+	if token.Value != "ghp_cli_token" {
+		t.Errorf("Token = %q, want %q", token.Value, "ghp_cli_token")
+	}
+	if token.Source != TokenSourceCLI {
+		t.Errorf("Source = %v, want %v", token.Source, TokenSourceCLI)
+	}
+}
+
+func TestResolver_ResolveGitLab_CLIEmptyToken(t *testing.T) {
+	// Clear env vars to force CLI path
+	os.Unsetenv("GITLAB_TOKEN")
+	os.Unsetenv("GL_TOKEN")
+
+	// Create a mock glab command that returns empty
+	tempDir := t.TempDir()
+	glabScript := filepath.Join(tempDir, "glab")
+	scriptContent := `#!/bin/sh
+echo ""
+`
+	if err := os.WriteFile(glabScript, []byte(scriptContent), 0o755); err != nil {
+		t.Fatalf("Failed to create mock glab script: %v", err)
+	}
+
+	// Prepend our temp dir to PATH
+	oldPath := os.Getenv("PATH")
+	t.Setenv("PATH", tempDir+":"+oldPath)
+
+	resolver := NewResolver()
+	_, err := resolver.ResolveGitLab(context.Background(), "gitlab.com")
+	if err == nil {
+		t.Error("Expected error when glab returns empty token")
+	}
+}