From 8f00fb7e76237d5d812a02cc9099256d56c2d069 Mon Sep 17 00:00:00 2001 From: beads/crew/emma Date: Sat, 14 Feb 2026 17:59:21 -0800 Subject: [PATCH] refactor: wire Jira CLI through SyncEngine, delete duplicated sync code Replace Python-script-based Jira sync with native Go REST API client. Jira CLI now follows same thin pattern as Linear/GitLab: create tracker, create engine, call engine.Sync(). Completes Phase 4 of dolt-y60t. - Implement Jira REST API v3 client (search, get, create, update) - Add ADF (Atlassian Document Format) plain text conversion - Wire Jira tracker IssueTracker methods with real API calls - Complete jiraFieldMapper.IssueToBeads/IssueToTracker - Delete conflict.go (Engine handles conflicts), scripts.go (Python dependency removed), Jira-specific stat types (Engine types used) - Fix engine pull guard: skip locally-modified issues unconditionally, let Phase 2 conflict detection handle them Co-Authored-By: Claude Opus 4.6 Executed-By: beads/crew/emma Rig: beads Role: crew --- cmd/bd/jira.go | 646 ++++++++++------------------------ cmd/bd/jira_test.go | 10 +- internal/jira/client.go | 376 +++++++++++++++++--- internal/jira/conflict.go | 171 --------- internal/jira/fieldmapper.go | 103 +++++- internal/jira/scripts.go | 63 ---- internal/jira/tracker.go | 181 +++++++++- internal/jira/tracker_test.go | 193 +++++++++- internal/jira/types.go | 45 --- internal/jira/types_test.go | 101 ------ internal/tracker/engine.go | 15 +- 11 files changed, 982 insertions(+), 922 deletions(-) delete mode 100644 internal/jira/conflict.go delete mode 100644 internal/jira/scripts.go delete mode 100644 internal/jira/types_test.go diff --git a/cmd/bd/jira.go b/cmd/bd/jira.go index 77d2cd95a..e3b04f5ad 100644 --- a/cmd/bd/jira.go +++ b/cmd/bd/jira.go @@ -1,19 +1,14 @@ package main import ( - "bufio" - "cmp" "context" - "encoding/json" "fmt" "os" - "os/exec" - "slices" "strings" - "time" "github.com/spf13/cobra" "github.com/steveyegge/beads/internal/jira" + "github.com/steveyegge/beads/internal/tracker" "github.com/steveyegge/beads/internal/types" ) @@ -28,7 +23,6 @@ Configuration: bd config set jira.project "PROJ" bd config set jira.api_token "YOUR_TOKEN" bd config set jira.username "your_email@company.com" # For Jira Cloud - bd config set jira.pull_prefix "hippo" # Imported issues get hippo-1, hippo-2, etc. bd config set jira.push_prefix "hippo" # Only push hippo-* issues to Jira bd config set jira.push_prefix "proj1,proj2" # Multiple prefixes (comma-separated) @@ -64,162 +58,7 @@ Examples: bd jira sync --push --create-only # Push new issues only bd jira sync --dry-run # Preview without changes bd jira sync --prefer-local # Bidirectional, local wins`, - Run: func(cmd *cobra.Command, args []string) { - // Flag errors are unlikely but check one to ensure cobra is working - pull, _ := cmd.Flags().GetBool("pull") - push, _ := cmd.Flags().GetBool("push") - dryRun, _ := cmd.Flags().GetBool("dry-run") - preferLocal, _ := cmd.Flags().GetBool("prefer-local") - preferJira, _ := cmd.Flags().GetBool("prefer-jira") - createOnly, _ := cmd.Flags().GetBool("create-only") - updateRefs, _ := cmd.Flags().GetBool("update-refs") - state, _ := cmd.Flags().GetString("state") - - // Block writes in readonly mode (sync modifies data) - if !dryRun { - CheckReadonly("jira sync") - } - - // Validate conflicting flags - if preferLocal && preferJira { - fmt.Fprintf(os.Stderr, "Error: cannot use both --prefer-local and --prefer-jira\n") - os.Exit(1) - } - - // Ensure store is available - if err := ensureStoreActive(); err != nil { - fmt.Fprintf(os.Stderr, "Error: database not available: %v\n", err) - os.Exit(1) - } - - // Ensure we have Jira configuration - if err := validateJiraConfig(); err != nil { - fmt.Fprintf(os.Stderr, "Error: %v\n", err) - os.Exit(1) - } - - // Default mode: bidirectional (pull then push) - if !pull && !push { - pull = true - push = true - } - - ctx := rootCtx - result := &jira.SyncResult{Success: true} - - // Step 1: Pull from Jira - if pull { - if dryRun { - fmt.Println("→ [DRY RUN] Would pull issues from Jira") - } else { - fmt.Println("→ Pulling issues from Jira...") - } - - pullStats, err := doPullFromJira(ctx, dryRun, state) - if err != nil { - result.Success = false - result.Error = err.Error() - if jsonOutput { - outputJSON(result) - } else { - fmt.Fprintf(os.Stderr, "Error pulling from Jira: %v\n", err) - } - os.Exit(1) - } - - result.Stats.Pulled = pullStats.Created + pullStats.Updated - result.Stats.Created += pullStats.Created - result.Stats.Updated += pullStats.Updated - result.Stats.Skipped += pullStats.Skipped - - if !dryRun { - fmt.Printf("✓ Pulled %d issues (%d created, %d updated)\n", - result.Stats.Pulled, pullStats.Created, pullStats.Updated) - } - } - - // Step 2: Handle conflicts (if bidirectional) - if pull && push && !dryRun { - client := newJiraClient(ctx) - conflicts, err := jira.DetectConflicts(ctx, client, store, os.Stderr) - if err != nil { - result.Warnings = append(result.Warnings, fmt.Sprintf("conflict detection failed: %v", err)) - } else if len(conflicts) > 0 { - result.Stats.Conflicts = len(conflicts) - if preferLocal { - fmt.Printf("→ Resolving %d conflicts (preferring local)\n", len(conflicts)) - // Local wins - no action needed, push will overwrite - } else if preferJira { - fmt.Printf("→ Resolving %d conflicts (preferring Jira)\n", len(conflicts)) - // Jira wins - re-import conflicting issues - if err := jira.ReimportConflicts(conflicts, os.Stderr); err != nil { - result.Warnings = append(result.Warnings, fmt.Sprintf("conflict resolution failed: %v", err)) - } - } else { - // Default: timestamp-based (newer wins) - fmt.Printf("→ Resolving %d conflicts (newer wins)\n", len(conflicts)) - if err := jira.ResolveConflictsByTimestamp(conflicts, os.Stderr); err != nil { - result.Warnings = append(result.Warnings, fmt.Sprintf("conflict resolution failed: %v", err)) - } - } - } - } - - // Step 3: Push to Jira - if push { - if dryRun { - fmt.Println("→ [DRY RUN] Would push issues to Jira") - } else { - fmt.Println("→ Pushing issues to Jira...") - } - - pushStats, err := doPushToJira(ctx, dryRun, createOnly, updateRefs) - if err != nil { - result.Success = false - result.Error = err.Error() - if jsonOutput { - outputJSON(result) - } else { - fmt.Fprintf(os.Stderr, "Error pushing to Jira: %v\n", err) - } - os.Exit(1) - } - - result.Stats.Pushed = pushStats.Created + pushStats.Updated - result.Stats.Created += pushStats.Created - result.Stats.Updated += pushStats.Updated - result.Stats.Skipped += pushStats.Skipped - result.Stats.Errors += pushStats.Errors - - if !dryRun { - fmt.Printf("✓ Pushed %d issues (%d created, %d updated)\n", - result.Stats.Pushed, pushStats.Created, pushStats.Updated) - } - } - - // Update last sync timestamp - if !dryRun && result.Success { - result.LastSync = time.Now().Format(time.RFC3339) - if err := store.SetConfig(ctx, "jira.last_sync", result.LastSync); err != nil { - result.Warnings = append(result.Warnings, fmt.Sprintf("failed to update last_sync: %v", err)) - } - } - - // Output result - if jsonOutput { - outputJSON(result) - } else if dryRun { - fmt.Println("\n✓ Dry run complete (no changes made)") - } else { - fmt.Println("\n✓ Jira sync complete") - if len(result.Warnings) > 0 { - fmt.Println("\nWarnings:") - for _, w := range result.Warnings { - fmt.Printf(" - %s\n", w) - } - } - } - }, + Run: runJiraSync, } var jiraStatusCmd = &cobra.Command{ @@ -230,98 +69,16 @@ var jiraStatusCmd = &cobra.Command{ - Configuration status - Number of issues with Jira links - Issues pending push (no external_ref)`, - Run: func(cmd *cobra.Command, args []string) { - ctx := rootCtx - - // Ensure store is available - if err := ensureStoreActive(); err != nil { - fmt.Fprintf(os.Stderr, "Error: %v\n", err) - os.Exit(1) - } - - // Get configuration - jiraURL, _ := store.GetConfig(ctx, "jira.url") - jiraProject, _ := store.GetConfig(ctx, "jira.project") - lastSync, _ := store.GetConfig(ctx, "jira.last_sync") - - // Check if configured - configured := jiraURL != "" && jiraProject != "" - - // Count issues with Jira links - allIssues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) - if err != nil { - fmt.Fprintf(os.Stderr, "Error: %v\n", err) - os.Exit(1) - } - - withJiraRef := 0 - pendingPush := 0 - for _, issue := range allIssues { - if issue.ExternalRef != nil && jira.IsJiraExternalRef(*issue.ExternalRef, jiraURL) { - withJiraRef++ - } else if issue.ExternalRef == nil { - // Only count issues without any external_ref as pending push - pendingPush++ - } - // Issues with non-Jira external_ref are not counted in either category - } - - if jsonOutput { - outputJSON(map[string]interface{}{ - "configured": configured, - "jira_url": jiraURL, - "jira_project": jiraProject, - "last_sync": lastSync, - "total_issues": len(allIssues), - "with_jira_ref": withJiraRef, - "pending_push": pendingPush, - }) - return - } - - fmt.Println("Jira Sync Status") - fmt.Println("================") - fmt.Println() - - if !configured { - fmt.Println("Status: Not configured") - fmt.Println() - fmt.Println("To configure Jira integration:") - fmt.Println(" bd config set jira.url \"https://company.atlassian.net\"") - fmt.Println(" bd config set jira.project \"PROJ\"") - fmt.Println(" bd config set jira.api_token \"YOUR_TOKEN\"") - fmt.Println(" bd config set jira.username \"your@email.com\"") - return - } - - fmt.Printf("Jira URL: %s\n", jiraURL) - fmt.Printf("Project: %s\n", jiraProject) - if lastSync != "" { - fmt.Printf("Last Sync: %s\n", lastSync) - } else { - fmt.Println("Last Sync: Never") - } - fmt.Println() - fmt.Printf("Total Issues: %d\n", len(allIssues)) - fmt.Printf("With Jira: %d\n", withJiraRef) - fmt.Printf("Local Only: %d\n", pendingPush) - - if pendingPush > 0 { - fmt.Println() - fmt.Printf("Run 'bd jira sync --push' to push %d local issue(s) to Jira\n", pendingPush) - } - }, + Run: runJiraStatus, } func init() { - // Sync command flags jiraSyncCmd.Flags().Bool("pull", false, "Pull issues from Jira") jiraSyncCmd.Flags().Bool("push", false, "Push issues to Jira") jiraSyncCmd.Flags().Bool("dry-run", false, "Preview sync without making changes") jiraSyncCmd.Flags().Bool("prefer-local", false, "Prefer local version on conflicts") jiraSyncCmd.Flags().Bool("prefer-jira", false, "Prefer Jira version on conflicts") jiraSyncCmd.Flags().Bool("create-only", false, "Only create new issues, don't update existing") - jiraSyncCmd.Flags().Bool("update-refs", true, "Update external_ref after creating Jira issues") jiraSyncCmd.Flags().String("state", "all", "Issue state to sync: open, closed, all") jiraCmd.AddCommand(jiraSyncCmd) @@ -329,18 +86,200 @@ func init() { rootCmd.AddCommand(jiraCmd) } -// newJiraClient creates a Jira client from the current store configuration. -func newJiraClient(ctx context.Context) *jira.Client { +func runJiraSync(cmd *cobra.Command, args []string) { + pull, _ := cmd.Flags().GetBool("pull") + push, _ := cmd.Flags().GetBool("push") + dryRun, _ := cmd.Flags().GetBool("dry-run") + preferLocal, _ := cmd.Flags().GetBool("prefer-local") + preferJira, _ := cmd.Flags().GetBool("prefer-jira") + createOnly, _ := cmd.Flags().GetBool("create-only") + state, _ := cmd.Flags().GetString("state") + + if !dryRun { + CheckReadonly("jira sync") + } + + if preferLocal && preferJira { + fmt.Fprintf(os.Stderr, "Error: cannot use both --prefer-local and --prefer-jira\n") + os.Exit(1) + } + + if err := ensureStoreActive(); err != nil { + fmt.Fprintf(os.Stderr, "Error: database not available: %v\n", err) + os.Exit(1) + } + + if err := validateJiraConfig(); err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } + + ctx := rootCtx + + // Create and initialize the Jira tracker + jt := &jira.Tracker{} + if err := jt.Init(ctx, store); err != nil { + fmt.Fprintf(os.Stderr, "Error initializing Jira tracker: %v\n", err) + os.Exit(1) + } + + // Create the sync engine + engine := tracker.NewEngine(jt, store, actor) + engine.OnMessage = func(msg string) { fmt.Println(" " + msg) } + engine.OnWarning = func(msg string) { fmt.Fprintf(os.Stderr, "Warning: %s\n", msg) } + + // Set up Jira-specific push hooks (prefix filtering) + engine.PushHooks = buildJiraPushHooks(ctx) + + // Build sync options from CLI flags + opts := tracker.SyncOptions{ + Pull: pull, + Push: push, + DryRun: dryRun, + CreateOnly: createOnly, + State: state, + } + + // Map conflict resolution + if preferLocal { + opts.ConflictResolution = tracker.ConflictLocal + } else if preferJira { + opts.ConflictResolution = tracker.ConflictExternal + } else { + opts.ConflictResolution = tracker.ConflictTimestamp + } + + // Run sync + result, err := engine.Sync(ctx, opts) + if err != nil { + if jsonOutput { + outputJSON(result) + } else { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + } + os.Exit(1) + } + + // Output results + if jsonOutput { + outputJSON(result) + } else if dryRun { + fmt.Println("\n✓ Dry run complete (no changes made)") + } else { + if result.Stats.Pulled > 0 { + fmt.Printf("✓ Pulled %d issues (%d created, %d updated)\n", + result.Stats.Pulled, result.Stats.Created, result.Stats.Updated) + } + if result.Stats.Pushed > 0 { + fmt.Printf("✓ Pushed %d issues\n", result.Stats.Pushed) + } + if result.Stats.Conflicts > 0 { + fmt.Printf("→ Resolved %d conflicts\n", result.Stats.Conflicts) + } + fmt.Println("\n✓ Jira sync complete") + if len(result.Warnings) > 0 { + fmt.Println("\nWarnings:") + for _, w := range result.Warnings { + fmt.Printf(" - %s\n", w) + } + } + } +} + +// buildJiraPushHooks creates PushHooks for Jira-specific push behavior. +func buildJiraPushHooks(ctx context.Context) *tracker.PushHooks { + return &tracker.PushHooks{ + ShouldPush: func(issue *types.Issue) bool { + pushPrefix, _ := store.GetConfig(ctx, "jira.push_prefix") + if pushPrefix == "" { + return true + } + for _, prefix := range strings.Split(pushPrefix, ",") { + prefix = strings.TrimSpace(prefix) + prefix = strings.TrimSuffix(prefix, "-") + if prefix != "" && strings.HasPrefix(issue.ID, prefix+"-") { + return true + } + } + return false + }, + } +} + +func runJiraStatus(cmd *cobra.Command, args []string) { + ctx := rootCtx + + if err := ensureStoreActive(); err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) + } + jiraURL, _ := store.GetConfig(ctx, "jira.url") - apiToken, _ := store.GetConfig(ctx, "jira.api_token") - if apiToken == "" { - apiToken = os.Getenv("JIRA_API_TOKEN") + jiraProject, _ := store.GetConfig(ctx, "jira.project") + lastSync, _ := store.GetConfig(ctx, "jira.last_sync") + + configured := jiraURL != "" && jiraProject != "" + + allIssues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) + if err != nil { + fmt.Fprintf(os.Stderr, "Error: %v\n", err) + os.Exit(1) } - username, _ := store.GetConfig(ctx, "jira.username") - if username == "" { - username = os.Getenv("JIRA_USERNAME") + + withJiraRef := 0 + pendingPush := 0 + for _, issue := range allIssues { + if issue.ExternalRef != nil && jira.IsJiraExternalRef(*issue.ExternalRef, jiraURL) { + withJiraRef++ + } else if issue.ExternalRef == nil { + pendingPush++ + } + } + + if jsonOutput { + outputJSON(map[string]interface{}{ + "configured": configured, + "jira_url": jiraURL, + "jira_project": jiraProject, + "last_sync": lastSync, + "total_issues": len(allIssues), + "with_jira_ref": withJiraRef, + "pending_push": pendingPush, + }) + return + } + + fmt.Println("Jira Sync Status") + fmt.Println("================") + fmt.Println() + + if !configured { + fmt.Println("Status: Not configured") + fmt.Println() + fmt.Println("To configure Jira integration:") + fmt.Println(" bd config set jira.url \"https://company.atlassian.net\"") + fmt.Println(" bd config set jira.project \"PROJ\"") + fmt.Println(" bd config set jira.api_token \"YOUR_TOKEN\"") + fmt.Println(" bd config set jira.username \"your@email.com\"") + return + } + + fmt.Printf("Jira URL: %s\n", jiraURL) + fmt.Printf("Project: %s\n", jiraProject) + if lastSync != "" { + fmt.Printf("Last Sync: %s\n", lastSync) + } else { + fmt.Println("Last Sync: Never") + } + fmt.Println() + fmt.Printf("Total Issues: %d\n", len(allIssues)) + fmt.Printf("With Jira: %d\n", withJiraRef) + fmt.Printf("Local Only: %d\n", pendingPush) + + if pendingPush > 0 { + fmt.Println() + fmt.Printf("Run 'bd jira sync --push' to push %d local issue(s) to Jira\n", pendingPush) } - return jira.NewClient(jiraURL, username, apiToken) } // validateJiraConfig checks that required Jira configuration is present. @@ -360,7 +299,6 @@ func validateJiraConfig() error { return fmt.Errorf("jira.project not configured\nRun: bd config set jira.project \"PROJ\"") } - // Check for API token (from config or env) apiToken, _ := store.GetConfig(ctx, "jira.api_token") if apiToken == "" && os.Getenv("JIRA_API_TOKEN") == "" { return fmt.Errorf("Jira API token not configured\nRun: bd config set jira.api_token \"YOUR_TOKEN\"\nOr: export JIRA_API_TOKEN=YOUR_TOKEN") @@ -368,199 +306,3 @@ func validateJiraConfig() error { return nil } - -// doPullFromJira imports issues from Jira using the Python script. -func doPullFromJira(ctx context.Context, dryRun bool, state string) (*jira.PullStats, error) { - stats := &jira.PullStats{} - - // Find the Python script - scriptPath, err := jira.FindScript("jira2jsonl.py") - if err != nil { - return stats, fmt.Errorf("jira2jsonl.py not found: %w", err) - } - - // Build command - args := []string{scriptPath, "--from-config"} - if state != "" && state != "all" { - args = append(args, "--state", state) - } - - // Add pull prefix if configured - pullPrefix, _ := store.GetConfig(ctx, "jira.pull_prefix") - if pullPrefix != "" { - args = append(args, "--prefix", pullPrefix) - } - - // Run Python script to get JSONL output - cmd := exec.CommandContext(ctx, "python3", args...) - cmd.Stderr = os.Stderr - - output, err := cmd.Output() - if err != nil { - return stats, fmt.Errorf("failed to fetch from Jira: %w", err) - } - - if dryRun { - // Count issues in output - scanner := bufio.NewScanner(strings.NewReader(string(output))) - count := 0 - for scanner.Scan() { - if strings.TrimSpace(scanner.Text()) != "" { - count++ - } - } - fmt.Printf(" Would import %d issues from Jira\n", count) - return stats, nil - } - - // Parse JSONL and import - scanner := bufio.NewScanner(strings.NewReader(string(output))) - var issues []*types.Issue - - for scanner.Scan() { - line := strings.TrimSpace(scanner.Text()) - if line == "" { - continue - } - - var issue types.Issue - if err := json.Unmarshal([]byte(line), &issue); err != nil { - return stats, fmt.Errorf("failed to parse issue JSON: %w", err) - } - issues = append(issues, &issue) - } - - if err := scanner.Err(); err != nil { - return stats, fmt.Errorf("failed to read JSONL: %w", err) - } - - // Import issues using shared logic - opts := ImportOptions{ - DryRun: false, - SkipUpdate: false, - } - - result, err := importIssuesCore(ctx, dbPath, store, issues, opts) - if err != nil { - return stats, fmt.Errorf("import failed: %w", err) - } - - stats.Created = result.Created - stats.Updated = result.Updated - stats.Skipped = result.Skipped - - return stats, nil -} - -// doPushToJira exports issues to Jira using the Python script. -func doPushToJira(ctx context.Context, dryRun bool, createOnly bool, updateRefs bool) (*jira.PushStats, error) { - stats := &jira.PushStats{} - - // Find the Python script - scriptPath, err := jira.FindScript("jsonl2jira.py") - if err != nil { - return stats, fmt.Errorf("jsonl2jira.py not found: %w", err) - } - - // Get all issues - issues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) - if err != nil { - return stats, fmt.Errorf("failed to get issues: %w", err) - } - - // Filter by push prefix if configured - pushPrefixConfig, _ := store.GetConfig(ctx, "jira.push_prefix") - if pushPrefixConfig != "" { - var filteredIssues []*types.Issue - - // Parse comma-separated prefixes, normalize (remove trailing dash) - allowedPrefixes := make(map[string]bool) - for _, prefix := range strings.Split(pushPrefixConfig, ",") { - prefix = strings.TrimSpace(prefix) - prefix = strings.TrimSuffix(prefix, "-") - if prefix != "" { - allowedPrefixes[prefix] = true - } - } - - for _, issue := range issues { - for prefix := range allowedPrefixes { - if strings.HasPrefix(issue.ID, prefix+"-") { - filteredIssues = append(filteredIssues, issue) - break - } - } - } - issues = filteredIssues - } - - // Sort by ID for consistent output - slices.SortFunc(issues, func(a, b *types.Issue) int { - return cmp.Compare(a.ID, b.ID) - }) - - // Generate JSONL for export - var jsonlLines []string - for _, issue := range issues { - data, err := json.Marshal(issue) - if err != nil { - return stats, fmt.Errorf("failed to encode issue %s: %w", issue.ID, err) - } - jsonlLines = append(jsonlLines, string(data)) - } - - jsonlContent := strings.Join(jsonlLines, "\n") - - // Build command - args := []string{scriptPath, "--from-config"} - if dryRun { - args = append(args, "--dry-run") - } - if createOnly { - args = append(args, "--create-only") - } - if updateRefs { - args = append(args, "--update-refs") - } - - cmd := exec.CommandContext(ctx, "python3", args...) - cmd.Stdin = strings.NewReader(jsonlContent) - cmd.Stderr = os.Stderr - - output, err := cmd.Output() - if err != nil { - return stats, fmt.Errorf("failed to push to Jira: %w", err) - } - - // Parse output for statistics and external_ref updates - scanner := bufio.NewScanner(strings.NewReader(string(output))) - for scanner.Scan() { - line := strings.TrimSpace(scanner.Text()) - if line == "" { - continue - } - - // Parse mapping output: {"bd_id": "...", "jira_key": "...", "external_ref": "..."} - var mapping struct { - BDID string `json:"bd_id"` - JiraKey string `json:"jira_key"` - ExternalRef string `json:"external_ref"` - } - if err := json.Unmarshal([]byte(line), &mapping); err == nil && mapping.BDID != "" { - stats.Created++ - - // Update external_ref if requested - if updateRefs && !dryRun && mapping.ExternalRef != "" { - updates := map[string]interface{}{ - "external_ref": mapping.ExternalRef, - } - if err := store.UpdateIssue(ctx, mapping.BDID, updates, actor); err != nil { - fmt.Fprintf(os.Stderr, "Warning: failed to update external_ref for %s: %v\n", mapping.BDID, err) - stats.Errors++ - } - } - } - } - - return stats, nil -} diff --git a/cmd/bd/jira_test.go b/cmd/bd/jira_test.go index de81ce3e7..cdfdfc9c8 100644 --- a/cmd/bd/jira_test.go +++ b/cmd/bd/jira_test.go @@ -3,12 +3,11 @@ package main import ( "testing" - "github.com/steveyegge/beads/internal/jira" + "github.com/steveyegge/beads/internal/tracker" ) func TestJiraSyncStats(t *testing.T) { - // Test that stats struct initializes correctly (uses jira.SyncStats now) - stats := jira.SyncStats{} + stats := tracker.SyncStats{} if stats.Pulled != 0 { t.Errorf("expected Pulled to be 0, got %d", stats.Pulled) @@ -34,10 +33,9 @@ func TestJiraSyncStats(t *testing.T) { } func TestJiraSyncResult(t *testing.T) { - // Test result struct initialization (uses jira.SyncResult now) - result := jira.SyncResult{ + result := tracker.SyncResult{ Success: true, - Stats: jira.SyncStats{ + Stats: tracker.SyncStats{ Created: 5, Updated: 3, }, diff --git a/internal/jira/client.go b/internal/jira/client.go index 39bcba766..320c4d639 100644 --- a/internal/jira/client.go +++ b/internal/jira/client.go @@ -1,16 +1,86 @@ package jira import ( + "bytes" "context" "encoding/base64" "encoding/json" "fmt" "io" "net/http" + "net/url" "strings" "time" ) +// Issue represents a Jira issue from the REST API. +type Issue struct { + ID string `json:"id"` + Key string `json:"key"` + Self string `json:"self"` + Fields IssueFields `json:"fields"` +} + +// IssueFields contains the fields of a Jira issue. +type IssueFields struct { + Summary string `json:"summary"` + Description json.RawMessage `json:"description"` // ADF (Atlassian Document Format) or plain text + Status *StatusField `json:"status"` + Priority *PriorityField `json:"priority"` + IssueType *IssueTypeField `json:"issuetype"` + Project *ProjectField `json:"project"` + Assignee *UserField `json:"assignee"` + Labels []string `json:"labels"` + Created string `json:"created"` + Updated string `json:"updated"` + Resolution *ResolutionField `json:"resolution"` +} + +// StatusField represents a Jira issue status. +type StatusField struct { + ID string `json:"id"` + Name string `json:"name"` +} + +// PriorityField represents a Jira issue priority. +type PriorityField struct { + ID string `json:"id"` + Name string `json:"name"` +} + +// IssueTypeField represents a Jira issue type. +type IssueTypeField struct { + ID string `json:"id"` + Name string `json:"name"` +} + +// ProjectField represents a Jira project. +type ProjectField struct { + ID string `json:"id"` + Key string `json:"key"` +} + +// UserField represents a Jira user. +type UserField struct { + AccountID string `json:"accountId"` + DisplayName string `json:"displayName"` + EmailAddress string `json:"emailAddress"` +} + +// ResolutionField represents a Jira resolution. +type ResolutionField struct { + ID string `json:"id"` + Name string `json:"name"` +} + +// SearchResult represents a Jira JQL search response. +type SearchResult struct { + StartAt int `json:"startAt"` + MaxResults int `json:"maxResults"` + Total int `json:"total"` + Issues []Issue `json:"issues"` +} + // Client provides HTTP access to a Jira instance. type Client struct { URL string @@ -35,50 +105,11 @@ func NewClient(url, username, apiToken string) *Client { func (c *Client) FetchIssueTimestamp(ctx context.Context, jiraKey string) (time.Time, error) { var zero time.Time - if c.URL == "" { - return zero, fmt.Errorf("jira URL not configured") - } - if c.APIToken == "" { - return zero, fmt.Errorf("jira API token not configured") - } + apiURL := fmt.Sprintf("%s/rest/api/3/issue/%s?fields=updated", c.URL, url.PathEscape(jiraKey)) - // Build API URL - use v3 for Jira Cloud (v2 is deprecated) - // Only fetch the 'updated' field to minimize response size - apiURL := fmt.Sprintf("%s/rest/api/3/issue/%s?fields=updated", c.URL, jiraKey) - - req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) + body, err := c.doRequest(ctx, "GET", apiURL, nil) if err != nil { - return zero, fmt.Errorf("failed to create request: %w", err) - } - - // Set authentication header - isCloud := strings.Contains(c.URL, "atlassian.net") - if isCloud && c.Username != "" { - // Jira Cloud: Basic auth with email:api_token - auth := base64.StdEncoding.EncodeToString([]byte(c.Username + ":" + c.APIToken)) - req.Header.Set("Authorization", "Basic "+auth) - } else if c.Username != "" { - // Jira Server with username: Basic auth - auth := base64.StdEncoding.EncodeToString([]byte(c.Username + ":" + c.APIToken)) - req.Header.Set("Authorization", "Basic "+auth) - } else { - // Jira Server without username: Bearer token (PAT) - req.Header.Set("Authorization", "Bearer "+c.APIToken) - } - req.Header.Set("Accept", "application/json") - req.Header.Set("User-Agent", "bd-jira-sync/1.0") - - resp, err := c.HTTPClient.Do(req) - if err != nil { - return zero, fmt.Errorf("failed to fetch issue %s: %w", jiraKey, err) - } - defer func() { - _ = resp.Body.Close() - }() - - if resp.StatusCode != http.StatusOK { - body, _ := io.ReadAll(resp.Body) - return zero, fmt.Errorf("jira API returned %d for issue %s: %s", resp.StatusCode, jiraKey, string(body)) + return zero, fmt.Errorf("fetch issue %s: %w", jiraKey, err) } var result struct { @@ -87,14 +118,269 @@ func (c *Client) FetchIssueTimestamp(ctx context.Context, jiraKey string) (time. } `json:"fields"` } - if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { - return zero, fmt.Errorf("failed to parse Jira response: %w", err) + if err := json.Unmarshal(body, &result); err != nil { + return zero, fmt.Errorf("parse Jira response: %w", err) } updated, err := ParseTimestamp(result.Fields.Updated) if err != nil { - return zero, fmt.Errorf("failed to parse Jira timestamp: %w", err) + return zero, fmt.Errorf("parse Jira timestamp: %w", err) } return updated, nil } + +// searchFields is the default set of fields to request in search/get queries. +const searchFields = "summary,description,status,priority,issuetype,project,assignee,labels,created,updated,resolution" + +// SearchIssues queries Jira using JQL and returns all matching issues, handling pagination. +func (c *Client) SearchIssues(ctx context.Context, jql string) ([]Issue, error) { + var allIssues []Issue + startAt := 0 + maxResults := 100 + + for { + params := url.Values{ + "jql": {jql}, + "fields": {searchFields}, + "startAt": {fmt.Sprintf("%d", startAt)}, + "maxResults": {fmt.Sprintf("%d", maxResults)}, + } + + apiURL := fmt.Sprintf("%s/rest/api/3/search?%s", c.URL, params.Encode()) + + body, err := c.doRequest(ctx, "GET", apiURL, nil) + if err != nil { + return nil, fmt.Errorf("search issues: %w", err) + } + + var result SearchResult + if err := json.Unmarshal(body, &result); err != nil { + return nil, fmt.Errorf("parse search response: %w", err) + } + + allIssues = append(allIssues, result.Issues...) + + if startAt+len(result.Issues) >= result.Total { + break + } + startAt += len(result.Issues) + } + + return allIssues, nil +} + +// GetIssue fetches a single Jira issue by key (e.g., "PROJ-123"). +func (c *Client) GetIssue(ctx context.Context, key string) (*Issue, error) { + apiURL := fmt.Sprintf("%s/rest/api/3/issue/%s?fields=%s", c.URL, url.PathEscape(key), searchFields) + + body, err := c.doRequest(ctx, "GET", apiURL, nil) + if err != nil { + return nil, fmt.Errorf("get issue %s: %w", key, err) + } + + var issue Issue + if err := json.Unmarshal(body, &issue); err != nil { + return nil, fmt.Errorf("parse issue response: %w", err) + } + + return &issue, nil +} + +// CreateIssue creates a new issue in Jira. +// fields should include "project", "summary", "issuetype", and optionally other fields. +func (c *Client) CreateIssue(ctx context.Context, fields map[string]interface{}) (*Issue, error) { + payload := map[string]interface{}{"fields": fields} + data, err := json.Marshal(payload) + if err != nil { + return nil, fmt.Errorf("marshal create request: %w", err) + } + + apiURL := fmt.Sprintf("%s/rest/api/3/issue", c.URL) + + body, err := c.doRequest(ctx, "POST", apiURL, data) + if err != nil { + return nil, fmt.Errorf("create issue: %w", err) + } + + // Create response only returns id, key, self. Fetch the full issue. + var created struct { + ID string `json:"id"` + Key string `json:"key"` + Self string `json:"self"` + } + if err := json.Unmarshal(body, &created); err != nil { + return nil, fmt.Errorf("parse create response: %w", err) + } + + return c.GetIssue(ctx, created.Key) +} + +// UpdateIssue updates an existing Jira issue by key. +func (c *Client) UpdateIssue(ctx context.Context, key string, fields map[string]interface{}) error { + payload := map[string]interface{}{"fields": fields} + data, err := json.Marshal(payload) + if err != nil { + return fmt.Errorf("marshal update request: %w", err) + } + + apiURL := fmt.Sprintf("%s/rest/api/3/issue/%s", c.URL, url.PathEscape(key)) + + _, err = c.doRequest(ctx, "PUT", apiURL, data) + if err != nil { + return fmt.Errorf("update issue %s: %w", key, err) + } + + return nil +} + +// doRequest executes an authenticated HTTP request and returns the response body. +func (c *Client) doRequest(ctx context.Context, method, apiURL string, body []byte) ([]byte, error) { + if c.URL == "" { + return nil, fmt.Errorf("jira URL not configured") + } + if c.APIToken == "" { + return nil, fmt.Errorf("jira API token not configured") + } + + var bodyReader io.Reader + if body != nil { + bodyReader = bytes.NewReader(body) + } + + req, err := http.NewRequestWithContext(ctx, method, apiURL, bodyReader) + if err != nil { + return nil, fmt.Errorf("create request: %w", err) + } + + c.setAuth(req) + req.Header.Set("Accept", "application/json") + req.Header.Set("User-Agent", "bd-jira-sync/1.0") + if body != nil { + req.Header.Set("Content-Type", "application/json") + } + + resp, err := c.HTTPClient.Do(req) + if err != nil { + return nil, err + } + defer func() { _ = resp.Body.Close() }() + + respBody, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("read response: %w", err) + } + + // PUT returns 204 No Content on success + if resp.StatusCode == http.StatusNoContent { + return nil, nil + } + + if resp.StatusCode < 200 || resp.StatusCode >= 300 { + return nil, fmt.Errorf("jira API returned %d: %s", resp.StatusCode, string(respBody)) + } + + return respBody, nil +} + +// setAuth sets the appropriate authentication header on the request. +func (c *Client) setAuth(req *http.Request) { + isCloud := strings.Contains(c.URL, "atlassian.net") + if (isCloud || c.Username != "") && c.Username != "" { + auth := base64.StdEncoding.EncodeToString([]byte(c.Username + ":" + c.APIToken)) + req.Header.Set("Authorization", "Basic "+auth) + } else { + req.Header.Set("Authorization", "Bearer "+c.APIToken) + } +} + +// DescriptionToPlainText extracts plain text from Jira's ADF (Atlassian Document Format). +// Jira v3 API returns descriptions as ADF JSON, not plain text. +func DescriptionToPlainText(raw json.RawMessage) string { + if len(raw) == 0 || string(raw) == "null" { + return "" + } + + // Try to parse as ADF document + var doc struct { + Type string `json:"type"` + Content []struct { + Type string `json:"type"` + Content []struct { + Type string `json:"type"` + Text string `json:"text"` + } `json:"content"` + } `json:"content"` + } + + if err := json.Unmarshal(raw, &doc); err != nil { + // Not JSON - treat as plain text string + var s string + if err := json.Unmarshal(raw, &s); err == nil { + return s + } + return string(raw) + } + + if doc.Type != "doc" { + // Not ADF - try plain string + var s string + if err := json.Unmarshal(raw, &s); err == nil { + return s + } + return string(raw) + } + + // Extract text from ADF nodes + var parts []string + for _, block := range doc.Content { + var line []string + for _, inline := range block.Content { + if inline.Text != "" { + line = append(line, inline.Text) + } + } + if len(line) > 0 { + parts = append(parts, strings.Join(line, "")) + } + } + + return strings.Join(parts, "\n") +} + +// PlainTextToADF converts plain text to Jira's ADF (Atlassian Document Format). +func PlainTextToADF(text string) json.RawMessage { + if text == "" { + return nil + } + + paragraphs := strings.Split(text, "\n") + var content []interface{} + for _, para := range paragraphs { + if para == "" { + content = append(content, map[string]interface{}{ + "type": "paragraph", + "content": []interface{}{}, + }) + continue + } + content = append(content, map[string]interface{}{ + "type": "paragraph", + "content": []interface{}{ + map[string]interface{}{ + "type": "text", + "text": para, + }, + }, + }) + } + + doc := map[string]interface{}{ + "type": "doc", + "version": 1, + "content": content, + } + + data, _ := json.Marshal(doc) + return data +} diff --git a/internal/jira/conflict.go b/internal/jira/conflict.go deleted file mode 100644 index 50600a08e..000000000 --- a/internal/jira/conflict.go +++ /dev/null @@ -1,171 +0,0 @@ -package jira - -import ( - "context" - "fmt" - "io" - "time" - - "github.com/steveyegge/beads/internal/types" -) - -// ConfigGetter provides read access to configuration values. -type ConfigGetter interface { - GetConfig(ctx context.Context, key string) (string, error) -} - -// IssueSearcher provides read access to issues. -type IssueSearcher interface { - SearchIssues(ctx context.Context, query string, filter types.IssueFilter) ([]*types.Issue, error) -} - -// DetectConflicts finds issues that have been modified both locally and in Jira -// since the last sync. It fetches each potentially conflicting issue from Jira -// to compare timestamps. -func DetectConflicts(ctx context.Context, client *Client, store interface { - ConfigGetter - IssueSearcher -}, stderr io.Writer) ([]Conflict, error) { - // Get last sync time - lastSyncStr, _ := store.GetConfig(ctx, "jira.last_sync") - if lastSyncStr == "" { - // No previous sync - no conflicts possible - return nil, nil - } - - lastSync, err := time.Parse(time.RFC3339, lastSyncStr) - if err != nil { - return nil, fmt.Errorf("invalid last_sync timestamp: %w", err) - } - - // Get all issues with Jira refs that were updated since last sync - allIssues, err := store.SearchIssues(ctx, "", types.IssueFilter{}) - if err != nil { - return nil, err - } - - // Get jiraURL for validation - jiraURL, _ := store.GetConfig(ctx, "jira.url") - - var conflicts []Conflict - for _, issue := range allIssues { - if issue.ExternalRef == nil || !IsJiraExternalRef(*issue.ExternalRef, jiraURL) { - continue - } - - // Check if local issue was updated since last sync - if !issue.UpdatedAt.After(lastSync) { - continue - } - - // Local was updated - now check if Jira was also updated - jiraKey := ExtractJiraKey(*issue.ExternalRef) - if jiraKey == "" { - // Can't extract key - treat as potential conflict for safety - conflicts = append(conflicts, Conflict{ - IssueID: issue.ID, - LocalUpdated: issue.UpdatedAt, - JiraExternalRef: *issue.ExternalRef, - }) - continue - } - - // Fetch Jira issue timestamp - jiraUpdated, err := client.FetchIssueTimestamp(ctx, jiraKey) - if err != nil { - // Can't fetch from Jira - log warning and treat as potential conflict - fmt.Fprintf(stderr, "Warning: couldn't fetch Jira issue %s: %v\n", jiraKey, err) - conflicts = append(conflicts, Conflict{ - IssueID: issue.ID, - LocalUpdated: issue.UpdatedAt, - JiraExternalRef: *issue.ExternalRef, - }) - continue - } - - // Only a conflict if Jira was ALSO updated since last sync - if jiraUpdated.After(lastSync) { - conflicts = append(conflicts, Conflict{ - IssueID: issue.ID, - LocalUpdated: issue.UpdatedAt, - JiraUpdated: jiraUpdated, - JiraExternalRef: *issue.ExternalRef, - }) - } - } - - return conflicts, nil -} - -// ReimportConflicts re-imports conflicting issues from Jira (Jira wins). -// NOTE: Full implementation would fetch the complete Jira issue and update local copy. -// Currently shows detailed conflict info for manual review. -func ReimportConflicts(conflicts []Conflict, stderr io.Writer) error { - if len(conflicts) == 0 { - return nil - } - fmt.Fprintf(stderr, "Warning: conflict resolution (--prefer-jira) not fully implemented\n") - fmt.Fprintf(stderr, " %d issue(s) have conflicts - Jira version would win:\n", len(conflicts)) - for _, c := range conflicts { - if !c.JiraUpdated.IsZero() { - fmt.Fprintf(stderr, " - %s (local: %s, jira: %s)\n", - c.IssueID, - c.LocalUpdated.Format(time.RFC3339), - c.JiraUpdated.Format(time.RFC3339)) - } else { - fmt.Fprintf(stderr, " - %s (local: %s, jira: unknown)\n", - c.IssueID, - c.LocalUpdated.Format(time.RFC3339)) - } - } - return nil -} - -// ResolveConflictsByTimestamp resolves conflicts by keeping the newer version. -func ResolveConflictsByTimestamp(conflicts []Conflict, stderr io.Writer) error { - if len(conflicts) == 0 { - return nil - } - - var localWins, jiraWins, unknown int - for _, c := range conflicts { - if c.JiraUpdated.IsZero() { - unknown++ - } else if c.LocalUpdated.After(c.JiraUpdated) { - localWins++ - } else { - jiraWins++ - } - } - - fmt.Fprintf(stderr, "Conflict resolution by timestamp:\n") - fmt.Fprintf(stderr, " Local wins (newer): %d\n", localWins) - fmt.Fprintf(stderr, " Jira wins (newer): %d\n", jiraWins) - if unknown > 0 { - fmt.Fprintf(stderr, " Unknown (couldn't fetch): %d\n", unknown) - } - - // Show details - for _, c := range conflicts { - if c.JiraUpdated.IsZero() { - fmt.Fprintf(stderr, " - %s: local version kept (couldn't fetch Jira timestamp)\n", c.IssueID) - } else if c.LocalUpdated.After(c.JiraUpdated) { - fmt.Fprintf(stderr, " - %s: local wins (local: %s > jira: %s)\n", - c.IssueID, - c.LocalUpdated.Format(time.RFC3339), - c.JiraUpdated.Format(time.RFC3339)) - } else { - fmt.Fprintf(stderr, " - %s: jira wins (jira: %s >= local: %s)\n", - c.IssueID, - c.JiraUpdated.Format(time.RFC3339), - c.LocalUpdated.Format(time.RFC3339)) - } - } - - // NOTE: Full implementation would actually re-import the Jira version for jiraWins issues - if jiraWins > 0 { - fmt.Fprintf(stderr, "Warning: %d issue(s) should be re-imported from Jira (not yet implemented)\n", jiraWins) - } - - return nil -} diff --git a/internal/jira/fieldmapper.go b/internal/jira/fieldmapper.go index 328beae53..43e0a1801 100644 --- a/internal/jira/fieldmapper.go +++ b/internal/jira/fieldmapper.go @@ -1,16 +1,16 @@ package jira import ( + "strings" + "github.com/steveyegge/beads/internal/tracker" "github.com/steveyegge/beads/internal/types" ) // jiraFieldMapper implements tracker.FieldMapper for Jira. -// This is a minimal implementation since Jira sync currently uses the Python script. type jiraFieldMapper struct{} func (m *jiraFieldMapper) PriorityToBeads(trackerPriority interface{}) int { - // Jira priority names: Highest(1), High(2), Medium(3), Low(4), Lowest(5) if name, ok := trackerPriority.(string); ok { switch name { case "Highest": @@ -105,10 +105,101 @@ func (m *jiraFieldMapper) TypeToTracker(beadsType types.IssueType) interface{} { } } -func (m *jiraFieldMapper) IssueToBeads(_ *tracker.TrackerIssue) *tracker.IssueConversion { - return nil +func (m *jiraFieldMapper) IssueToBeads(ti *tracker.TrackerIssue) *tracker.IssueConversion { + ji, ok := ti.Raw.(*Issue) + if !ok || ji == nil { + return nil + } + + issue := &types.Issue{ + Title: ji.Fields.Summary, + Description: DescriptionToPlainText(ji.Fields.Description), + Priority: m.PriorityToBeads(priorityName(ji)), + Status: m.StatusToBeads(statusName(ji)), + IssueType: m.TypeToBeads(typeName(ji)), + } + + if ji.Fields.Assignee != nil { + issue.Owner = ji.Fields.Assignee.DisplayName + } + + if ji.Fields.Labels != nil { + issue.Labels = ji.Fields.Labels + } + + // Set external ref from issue URL + if ji.Self != "" { + ref := extractBrowseURL(ji) + issue.ExternalRef = &ref + } + + return &tracker.IssueConversion{ + Issue: issue, + } } -func (m *jiraFieldMapper) IssueToTracker(_ *types.Issue) map[string]interface{} { - return nil +func (m *jiraFieldMapper) IssueToTracker(issue *types.Issue) map[string]interface{} { + fields := map[string]interface{}{ + "summary": issue.Title, + } + + // Convert description to ADF + if issue.Description != "" { + fields["description"] = PlainTextToADF(issue.Description) + } + + // Set issue type + typeName := m.TypeToTracker(issue.IssueType) + if name, ok := typeName.(string); ok { + fields["issuetype"] = map[string]string{"name": name} + } + + // Set priority + priorityName := m.PriorityToTracker(issue.Priority) + if name, ok := priorityName.(string); ok { + fields["priority"] = map[string]string{"name": name} + } + + // Set labels + if len(issue.Labels) > 0 { + fields["labels"] = issue.Labels + } + + return fields +} + +// Helper functions for safe field extraction from Jira issues. + +func priorityName(ji *Issue) string { + if ji.Fields.Priority != nil { + return ji.Fields.Priority.Name + } + return "" +} + +func statusName(ji *Issue) string { + if ji.Fields.Status != nil { + return ji.Fields.Status.Name + } + return "" +} + +func typeName(ji *Issue) string { + if ji.Fields.IssueType != nil { + return ji.Fields.IssueType.Name + } + return "" +} + +// extractBrowseURL builds the human-readable browse URL from a Jira issue. +// Self is "https://company.atlassian.net/rest/api/3/issue/10001"; +// we need "https://company.atlassian.net/browse/PROJ-123". +func extractBrowseURL(ji *Issue) string { + if ji.Self == "" || ji.Key == "" { + return "" + } + if idx := strings.Index(ji.Self, "/rest/api/"); idx > 0 { + return ji.Self[:idx] + "/browse/" + ji.Key + } + return "" } diff --git a/internal/jira/scripts.go b/internal/jira/scripts.go deleted file mode 100644 index 50ee8f651..000000000 --- a/internal/jira/scripts.go +++ /dev/null @@ -1,63 +0,0 @@ -package jira - -import ( - "fmt" - "os" - "path/filepath" - - "github.com/steveyegge/beads/internal/beads" -) - -// FindScript locates a Jira Python script by name. -func FindScript(name string) (string, error) { - // Check environment variable first (allows users to specify script location) - if envPath := os.Getenv("BD_JIRA_SCRIPT"); envPath != "" { - if _, err := os.Stat(envPath); err == nil { - return envPath, nil - } - return "", fmt.Errorf("BD_JIRA_SCRIPT points to non-existent file: %s", envPath) - } - - // Check common locations - locations := []string{ - // Relative to current working directory - filepath.Join("examples", "jira-import", name), - } - - // Add executable-relative path - if exe, err := os.Executable(); err == nil { - exeDir := filepath.Dir(exe) - locations = append(locations, filepath.Join(exeDir, "examples", "jira-import", name)) - locations = append(locations, filepath.Join(exeDir, "..", "examples", "jira-import", name)) - } - - // Check BEADS_DIR or current .beads location - if beadsDir := beads.FindBeadsDir(); beadsDir != "" { - repoRoot := filepath.Dir(beadsDir) - locations = append(locations, filepath.Join(repoRoot, "examples", "jira-import", name)) - } - - for _, loc := range locations { - if _, err := os.Stat(loc); err == nil { - absPath, err := filepath.Abs(loc) - if err == nil { - return absPath, nil - } - return loc, nil - } - } - - return "", fmt.Errorf(`script not found: %s - -The Jira sync feature requires the Python script from the beads repository. - -To fix this, either: - 1. Set BD_JIRA_SCRIPT to point to the script: - export BD_JIRA_SCRIPT=/path/to/jira2jsonl.py - - 2. Or download it from GitHub: - curl -o jira2jsonl.py https://raw.githubusercontent.com/steveyegge/beads/main/examples/jira-import/jira2jsonl.py - export BD_JIRA_SCRIPT=$PWD/jira2jsonl.py - -Looked in: %v`, name, locations) -} diff --git a/internal/jira/tracker.go b/internal/jira/tracker.go index 76150a3f7..6f33b3d45 100644 --- a/internal/jira/tracker.go +++ b/internal/jira/tracker.go @@ -2,19 +2,15 @@ package jira import ( "context" - "errors" "fmt" "os" + "strings" "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/tracker" "github.com/steveyegge/beads/internal/types" ) -// ErrNotImplemented is returned by Jira tracker methods that are not yet supported. -// Jira pull currently uses a Python script (jira2jsonl.py), not the Go API client. -var ErrNotImplemented = errors.New("not implemented: Jira sync uses Python script (jira2jsonl.py)") - func init() { tracker.Register("jira", func() tracker.IssueTracker { return &Tracker{} @@ -23,9 +19,10 @@ func init() { // Tracker implements tracker.IssueTracker for Jira. type Tracker struct { - client *Client - store storage.Storage - jiraURL string + client *Client + store storage.Storage + jiraURL string + projectKey string } func (t *Tracker) Name() string { return "jira" } @@ -41,6 +38,12 @@ func (t *Tracker) Init(ctx context.Context, store storage.Storage) error { } t.jiraURL = jiraURL + projectKey, err := t.getConfig(ctx, "jira.project", "JIRA_PROJECT") + if err != nil || projectKey == "" { + return fmt.Errorf("Jira project not configured (set jira.project or JIRA_PROJECT)") + } + t.projectKey = projectKey + username, _ := t.getConfig(ctx, "jira.username", "JIRA_USERNAME") apiToken, err := t.getConfig(ctx, "jira.api_token", "JIRA_API_TOKEN") if err != nil || apiToken == "" { @@ -60,20 +63,80 @@ func (t *Tracker) Validate() error { func (t *Tracker) Close() error { return nil } -func (t *Tracker) FetchIssues(_ context.Context, _ tracker.FetchOptions) ([]tracker.TrackerIssue, error) { - return nil, ErrNotImplemented +func (t *Tracker) FetchIssues(ctx context.Context, opts tracker.FetchOptions) ([]tracker.TrackerIssue, error) { + // Build JQL query + jql := fmt.Sprintf("project = %q", t.projectKey) + + // State filter + switch opts.State { + case "open": + jql += " AND statusCategory != Done" + case "closed": + jql += " AND statusCategory = Done" + } + + // Incremental sync + if opts.Since != nil { + jql += fmt.Sprintf(" AND updated >= %q", opts.Since.Format("2006-01-02 15:04")) + } + + jql += " ORDER BY updated DESC" + + issues, err := t.client.SearchIssues(ctx, jql) + if err != nil { + return nil, err + } + + result := make([]tracker.TrackerIssue, 0, len(issues)) + for i := range issues { + result = append(result, jiraToTrackerIssue(&issues[i])) + } + return result, nil } -func (t *Tracker) FetchIssue(_ context.Context, _ string) (*tracker.TrackerIssue, error) { - return nil, ErrNotImplemented +func (t *Tracker) FetchIssue(ctx context.Context, identifier string) (*tracker.TrackerIssue, error) { + issue, err := t.client.GetIssue(ctx, identifier) + if err != nil { + return nil, err + } + if issue == nil { + return nil, nil + } + ti := jiraToTrackerIssue(issue) + return &ti, nil } -func (t *Tracker) CreateIssue(_ context.Context, _ *types.Issue) (*tracker.TrackerIssue, error) { - return nil, ErrNotImplemented +func (t *Tracker) CreateIssue(ctx context.Context, issue *types.Issue) (*tracker.TrackerIssue, error) { + mapper := t.FieldMapper() + fields := mapper.IssueToTracker(issue) + + // Set project + fields["project"] = map[string]string{"key": t.projectKey} + + created, err := t.client.CreateIssue(ctx, fields) + if err != nil { + return nil, err + } + + ti := jiraToTrackerIssue(created) + return &ti, nil } -func (t *Tracker) UpdateIssue(_ context.Context, _ string, _ *types.Issue) (*tracker.TrackerIssue, error) { - return nil, ErrNotImplemented +func (t *Tracker) UpdateIssue(ctx context.Context, externalID string, issue *types.Issue) (*tracker.TrackerIssue, error) { + mapper := t.FieldMapper() + fields := mapper.IssueToTracker(issue) + + if err := t.client.UpdateIssue(ctx, externalID, fields); err != nil { + return nil, err + } + + // Fetch the updated issue to return current state + updated, err := t.client.GetIssue(ctx, externalID) + if err != nil { + return nil, err + } + ti := jiraToTrackerIssue(updated) + return &ti, nil } func (t *Tracker) FieldMapper() tracker.FieldMapper { @@ -105,3 +168,89 @@ func (t *Tracker) getConfig(ctx context.Context, key, envVar string) (string, er } return "", nil } + +// jiraToTrackerIssue converts a Jira API Issue to the generic TrackerIssue format. +func jiraToTrackerIssue(ji *Issue) tracker.TrackerIssue { + ti := tracker.TrackerIssue{ + ID: ji.ID, + Identifier: ji.Key, + URL: ji.Self, + Title: ji.Fields.Summary, + Labels: ji.Fields.Labels, + Raw: ji, + } + + // Description: convert ADF to plain text + ti.Description = DescriptionToPlainText(ji.Fields.Description) + + // Priority + if ji.Fields.Priority != nil { + ti.Priority = jiraPriorityToNumeric(ji.Fields.Priority.Name) + ti.State = ji.Fields.Status // Store for FieldMapper + } + + // State + if ji.Fields.Status != nil { + ti.State = ji.Fields.Status.Name + } + + // Type + if ji.Fields.IssueType != nil { + ti.Type = ji.Fields.IssueType.Name + } + + // Assignee + if ji.Fields.Assignee != nil { + ti.Assignee = ji.Fields.Assignee.DisplayName + ti.AssigneeEmail = ji.Fields.Assignee.EmailAddress + ti.AssigneeID = ji.Fields.Assignee.AccountID + } + + // Timestamps + if t, err := ParseTimestamp(ji.Fields.Created); err == nil { + ti.CreatedAt = t + } + if t, err := ParseTimestamp(ji.Fields.Updated); err == nil { + ti.UpdatedAt = t + } + + // Store Jira-specific metadata + ti.Metadata = map[string]interface{}{ + "source_system": fmt.Sprintf("jira:%s:%s", projectKeyFromIssue(ji), ji.Key), + } + if ji.Fields.IssueType != nil { + ti.Metadata["jira_type"] = ji.Fields.IssueType.Name + } + + return ti +} + +// jiraPriorityToNumeric converts a Jira priority name to a numeric value (0=highest, 4=lowest). +func jiraPriorityToNumeric(name string) int { + switch strings.ToLower(name) { + case "highest": + return 0 + case "high": + return 1 + case "medium": + return 2 + case "low": + return 3 + case "lowest": + return 4 + default: + return 2 + } +} + +// projectKeyFromIssue extracts the project key from a Jira issue. +func projectKeyFromIssue(ji *Issue) string { + if ji.Fields.Project != nil { + return ji.Fields.Project.Key + } + // Fall back to extracting from issue key (e.g., "PROJ-123" → "PROJ") + if idx := strings.LastIndex(ji.Key, "-"); idx > 0 { + return ji.Key[:idx] + } + return "" +} diff --git a/internal/jira/tracker_test.go b/internal/jira/tracker_test.go index ba48382c6..ed36a629f 100644 --- a/internal/jira/tracker_test.go +++ b/internal/jira/tracker_test.go @@ -1,9 +1,12 @@ package jira import ( + "encoding/json" "testing" + "time" "github.com/steveyegge/beads/internal/tracker" + "github.com/steveyegge/beads/internal/types" ) func TestRegistered(t *testing.T) { @@ -69,18 +72,188 @@ func TestBuildExternalRef(t *testing.T) { } } -func TestStubMethodsReturnErrNotImplemented(t *testing.T) { - tr := &Tracker{} - if _, err := tr.FetchIssues(nil, tracker.FetchOptions{}); err != ErrNotImplemented { - t.Errorf("FetchIssues error = %v, want ErrNotImplemented", err) +func TestJiraToTrackerIssue(t *testing.T) { + ji := &Issue{ + ID: "10001", + Key: "PROJ-42", + Self: "https://company.atlassian.net/rest/api/3/issue/10001", + Fields: IssueFields{ + Summary: "Fix login bug", + Description: json.RawMessage(`"A plain text description"`), + Status: &StatusField{ID: "1", Name: "In Progress"}, + Priority: &PriorityField{ID: "2", Name: "High"}, + IssueType: &IssueTypeField{ID: "10001", Name: "Bug"}, + Project: &ProjectField{ID: "10000", Key: "PROJ"}, + Assignee: &UserField{AccountID: "abc123", DisplayName: "Alice", EmailAddress: "alice@example.com"}, + Labels: []string{"backend", "urgent"}, + Created: "2025-01-15T10:30:00.000+0000", + Updated: "2025-01-16T14:20:00.000+0000", + }, } - if _, err := tr.FetchIssue(nil, "X-1"); err != ErrNotImplemented { - t.Errorf("FetchIssue error = %v, want ErrNotImplemented", err) + + ti := jiraToTrackerIssue(ji) + + if ti.ID != "10001" { + t.Errorf("ID = %q, want %q", ti.ID, "10001") } - if _, err := tr.CreateIssue(nil, nil); err != ErrNotImplemented { - t.Errorf("CreateIssue error = %v, want ErrNotImplemented", err) + if ti.Identifier != "PROJ-42" { + t.Errorf("Identifier = %q, want %q", ti.Identifier, "PROJ-42") } - if _, err := tr.UpdateIssue(nil, "", nil); err != ErrNotImplemented { - t.Errorf("UpdateIssue error = %v, want ErrNotImplemented", err) + if ti.Title != "Fix login bug" { + t.Errorf("Title = %q, want %q", ti.Title, "Fix login bug") + } + if ti.Description != "A plain text description" { + t.Errorf("Description = %q, want %q", ti.Description, "A plain text description") + } + if ti.Assignee != "Alice" { + t.Errorf("Assignee = %q, want %q", ti.Assignee, "Alice") + } + if ti.AssigneeEmail != "alice@example.com" { + t.Errorf("AssigneeEmail = %q, want %q", ti.AssigneeEmail, "alice@example.com") + } + if ti.CreatedAt.IsZero() { + t.Error("CreatedAt should not be zero") + } + if ti.UpdatedAt.IsZero() { + t.Error("UpdatedAt should not be zero") + } + if len(ti.Labels) != 2 { + t.Errorf("Labels length = %d, want 2", len(ti.Labels)) + } +} + +func TestDescriptionToPlainText(t *testing.T) { + tests := []struct { + name string + raw json.RawMessage + want string + }{ + {"null", json.RawMessage(`null`), ""}, + {"empty", json.RawMessage(``), ""}, + {"plain string", json.RawMessage(`"hello world"`), "hello world"}, + {"ADF document", json.RawMessage(`{ + "type": "doc", + "content": [ + { + "type": "paragraph", + "content": [ + {"type": "text", "text": "First paragraph"} + ] + }, + { + "type": "paragraph", + "content": [ + {"type": "text", "text": "Second paragraph"} + ] + } + ] + }`), "First paragraph\nSecond paragraph"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := DescriptionToPlainText(tt.raw) + if got != tt.want { + t.Errorf("DescriptionToPlainText() = %q, want %q", got, tt.want) + } + }) + } +} + +func TestPlainTextToADF(t *testing.T) { + adf := PlainTextToADF("Hello\nWorld") + if adf == nil { + t.Fatal("PlainTextToADF returned nil") + } + + var doc struct { + Type string `json:"type"` + Version int `json:"version"` + Content []struct { + Type string `json:"type"` + Content []struct { + Text string `json:"text"` + } `json:"content"` + } `json:"content"` + } + if err := json.Unmarshal(adf, &doc); err != nil { + t.Fatalf("Failed to parse ADF: %v", err) + } + if doc.Type != "doc" { + t.Errorf("doc type = %q, want %q", doc.Type, "doc") + } + if len(doc.Content) != 2 { + t.Fatalf("content length = %d, want 2", len(doc.Content)) + } + if doc.Content[0].Content[0].Text != "Hello" { + t.Errorf("first paragraph text = %q, want %q", doc.Content[0].Content[0].Text, "Hello") + } +} + +func TestFieldMapperIssueToBeads(t *testing.T) { + ji := &Issue{ + ID: "10001", + Key: "PROJ-42", + Self: "https://company.atlassian.net/rest/api/3/issue/10001", + Fields: IssueFields{ + Summary: "Test issue", + Description: json.RawMessage(`"Description text"`), + Status: &StatusField{Name: "In Progress"}, + Priority: &PriorityField{Name: "High"}, + IssueType: &IssueTypeField{Name: "Bug"}, + Assignee: &UserField{DisplayName: "Bob"}, + Labels: []string{"frontend"}, + Created: time.Now().Format(time.RFC3339), + Updated: time.Now().Format(time.RFC3339), + }, + } + + ti := jiraToTrackerIssue(ji) + mapper := &jiraFieldMapper{} + conv := mapper.IssueToBeads(&ti) + + if conv == nil { + t.Fatal("IssueToBeads returned nil") + } + if conv.Issue.Title != "Test issue" { + t.Errorf("Title = %q, want %q", conv.Issue.Title, "Test issue") + } + if conv.Issue.Description != "Description text" { + t.Errorf("Description = %q, want %q", conv.Issue.Description, "Description text") + } + if conv.Issue.Priority != 1 { + t.Errorf("Priority = %d, want 1 (High)", conv.Issue.Priority) + } + if conv.Issue.Owner != "Bob" { + t.Errorf("Owner = %q, want %q", conv.Issue.Owner, "Bob") + } +} + +func TestFieldMapperIssueToTracker(t *testing.T) { + mapper := &jiraFieldMapper{} + + issue := &types.Issue{ + Title: "New feature", + Description: "Feature description", + Priority: 0, + IssueType: types.TypeBug, + Labels: []string{"critical"}, + } + + fields := mapper.IssueToTracker(issue) + + if fields["summary"] != "New feature" { + t.Errorf("summary = %v, want %q", fields["summary"], "New feature") + } + if fields["description"] == nil { + t.Error("description should not be nil") + } + issueType, ok := fields["issuetype"].(map[string]string) + if !ok || issueType["name"] != "Bug" { + t.Errorf("issuetype = %v, want Bug", fields["issuetype"]) + } + priority, ok := fields["priority"].(map[string]string) + if !ok || priority["name"] != "Highest" { + t.Errorf("priority = %v, want Highest", fields["priority"]) } } diff --git a/internal/jira/types.go b/internal/jira/types.go index 771a9c923..fedb042ae 100644 --- a/internal/jira/types.go +++ b/internal/jira/types.go @@ -1,47 +1,2 @@ // Package jira provides client, types, and utilities for Jira integration. package jira - -import "time" - -// SyncStats tracks statistics for a Jira sync operation. -type SyncStats struct { - Pulled int `json:"pulled"` - Pushed int `json:"pushed"` - Created int `json:"created"` - Updated int `json:"updated"` - Skipped int `json:"skipped"` - Errors int `json:"errors"` - Conflicts int `json:"conflicts"` -} - -// SyncResult represents the result of a Jira sync operation. -type SyncResult struct { - Success bool `json:"success"` - Stats SyncStats `json:"stats"` - LastSync string `json:"last_sync,omitempty"` - Error string `json:"error,omitempty"` - Warnings []string `json:"warnings,omitempty"` -} - -// PullStats tracks pull operation statistics. -type PullStats struct { - Created int - Updated int - Skipped int -} - -// PushStats tracks push operation statistics. -type PushStats struct { - Created int - Updated int - Skipped int - Errors int -} - -// Conflict represents a conflict between local and Jira versions. -type Conflict struct { - IssueID string - LocalUpdated time.Time - JiraUpdated time.Time - JiraExternalRef string -} diff --git a/internal/jira/types_test.go b/internal/jira/types_test.go deleted file mode 100644 index 5cb63f819..000000000 --- a/internal/jira/types_test.go +++ /dev/null @@ -1,101 +0,0 @@ -package jira - -import ( - "testing" -) - -func TestSyncStats(t *testing.T) { - stats := SyncStats{} - - if stats.Pulled != 0 { - t.Errorf("expected Pulled to be 0, got %d", stats.Pulled) - } - if stats.Pushed != 0 { - t.Errorf("expected Pushed to be 0, got %d", stats.Pushed) - } - if stats.Created != 0 { - t.Errorf("expected Created to be 0, got %d", stats.Created) - } - if stats.Updated != 0 { - t.Errorf("expected Updated to be 0, got %d", stats.Updated) - } - if stats.Skipped != 0 { - t.Errorf("expected Skipped to be 0, got %d", stats.Skipped) - } - if stats.Errors != 0 { - t.Errorf("expected Errors to be 0, got %d", stats.Errors) - } - if stats.Conflicts != 0 { - t.Errorf("expected Conflicts to be 0, got %d", stats.Conflicts) - } -} - -func TestSyncResult(t *testing.T) { - result := SyncResult{ - Success: true, - Stats: SyncStats{ - Created: 5, - Updated: 3, - }, - LastSync: "2025-01-15T10:30:00Z", - } - - if !result.Success { - t.Error("expected Success to be true") - } - if result.Stats.Created != 5 { - t.Errorf("expected Created to be 5, got %d", result.Stats.Created) - } - if result.Stats.Updated != 3 { - t.Errorf("expected Updated to be 3, got %d", result.Stats.Updated) - } - if result.LastSync != "2025-01-15T10:30:00Z" { - t.Errorf("unexpected LastSync value: %s", result.LastSync) - } - if result.Error != "" { - t.Errorf("expected Error to be empty, got %s", result.Error) - } - if len(result.Warnings) != 0 { - t.Errorf("expected Warnings to be empty, got %v", result.Warnings) - } -} - -func TestPullStats(t *testing.T) { - stats := PullStats{ - Created: 10, - Updated: 5, - Skipped: 2, - } - - if stats.Created != 10 { - t.Errorf("expected Created to be 10, got %d", stats.Created) - } - if stats.Updated != 5 { - t.Errorf("expected Updated to be 5, got %d", stats.Updated) - } - if stats.Skipped != 2 { - t.Errorf("expected Skipped to be 2, got %d", stats.Skipped) - } -} - -func TestPushStats(t *testing.T) { - stats := PushStats{ - Created: 8, - Updated: 4, - Skipped: 1, - Errors: 2, - } - - if stats.Created != 8 { - t.Errorf("expected Created to be 8, got %d", stats.Created) - } - if stats.Updated != 4 { - t.Errorf("expected Updated to be 4, got %d", stats.Updated) - } - if stats.Skipped != 1 { - t.Errorf("expected Skipped to be 1, got %d", stats.Skipped) - } - if stats.Errors != 2 { - t.Errorf("expected Errors to be 2, got %d", stats.Errors) - } -} diff --git a/internal/tracker/engine.go b/internal/tracker/engine.go index c31047bff..a55c58b63 100644 --- a/internal/tracker/engine.go +++ b/internal/tracker/engine.go @@ -280,13 +280,14 @@ func (e *Engine) doPull(ctx context.Context, opts SyncOptions) (*PullStats, erro } if existing != nil { - // Conflict-aware pull: when prefer-local, skip updating issues - // that were locally modified since last sync to preserve local changes. - if opts.ConflictResolution == ConflictLocal && lastSync != nil { - if existing.UpdatedAt.After(*lastSync) { - stats.Skipped++ - continue - } + // Conflict-aware pull: skip updating issues that were locally + // modified since last sync. Conflict detection (Phase 2) will + // handle these per the configured resolution strategy. + // Without this guard, pull silently overwrites local changes + // before conflict detection can compare timestamps. + if lastSync != nil && existing.UpdatedAt.After(*lastSync) { + stats.Skipped++ + continue } // Update existing issue