beads/internal/github/mapping.go
beads/crew/emma 0cf8666fff feat: add GitHub Issues integration (tracker plugin) (GH#2373)
Implements tracker.IssueTracker and tracker.FieldMapper interfaces for
GitHub Issues, mirroring the existing GitLab integration pattern. Adds
bd github sync/status/repos commands for bidirectional issue sync with
scoped label mapping, pagination, rate-limit handling, and GitHub
Enterprise support.

Co-Authored-By: StefanTrockel <StefanTrockel@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-10 15:53:31 -07:00

228 lines
6.1 KiB
Go

// Package github provides client and data types for the GitHub REST API.
package github
import (
"fmt"
"strings"
"github.com/steveyegge/beads/internal/types"
)
// MappingConfig configures how GitHub fields map to beads fields.
type MappingConfig struct {
PriorityMap map[string]int // priority label value -> beads priority (0-4)
StateMap map[string]string // GitHub state -> beads status
LabelTypeMap map[string]string // type label value -> beads issue type
}
// DefaultMappingConfig returns the default mapping configuration.
// Uses exported mapping constants from types.go as the single source of truth.
func DefaultMappingConfig() *MappingConfig {
// Copy PriorityMapping to avoid external modification
priorityMap := make(map[string]int, len(PriorityMapping))
for k, v := range PriorityMapping {
priorityMap[k] = v
}
// Copy typeMapping to avoid external modification
labelTypeMap := make(map[string]string, len(typeMapping))
for k, v := range typeMapping {
labelTypeMap[k] = v
}
return &MappingConfig{
PriorityMap: priorityMap,
// StateMap maps GitHub states to beads statuses
StateMap: map[string]string{
"open": StatusMapping["open"],
"closed": StatusMapping["closed"],
},
LabelTypeMap: labelTypeMap,
}
}
// priorityFromLabels extracts priority from GitHub labels.
// Returns default priority (2 = medium) if no priority label found.
func priorityFromLabels(labels []string, config *MappingConfig) int {
for _, label := range labels {
prefix, value := parseLabelPrefix(label)
if prefix == "priority" {
if p, ok := config.PriorityMap[strings.ToLower(value)]; ok {
return p
}
}
}
return 2 // Default to medium
}
// statusFromLabelsAndState determines beads status from GitHub labels and state.
// GitHub's closed state takes precedence over status labels.
func statusFromLabelsAndState(labels []string, state string, config *MappingConfig) string {
// Closed state always wins
if state == "closed" {
return "closed"
}
// Check for status label
for _, label := range labels {
prefix, value := parseLabelPrefix(label)
if prefix == "status" {
normalized := strings.ToLower(value)
if normalized == "in_progress" {
return "in_progress"
}
if normalized == "blocked" {
return "blocked"
}
if normalized == "deferred" {
return "deferred"
}
}
}
// Default: map GitHub state to beads status
if s, ok := config.StateMap[state]; ok {
return s
}
return "open"
}
// typeFromLabels extracts issue type from GitHub labels.
// Checks both scoped (type::bug) and bare (bug) labels.
// Returns "task" if no type label found.
func typeFromLabels(labels []string, config *MappingConfig) string {
for _, label := range labels {
prefix, value := parseLabelPrefix(label)
if prefix == "type" {
if t, ok := config.LabelTypeMap[strings.ToLower(value)]; ok {
return t
}
}
// Also check bare labels (no prefix)
if prefix == "" {
if t, ok := config.LabelTypeMap[strings.ToLower(value)]; ok {
return t
}
}
}
return "task" // Default to task
}
// GitHubIssueToBeads converts a GitHub Issue to a beads Issue.
func GitHubIssueToBeads(gh *Issue, config *MappingConfig) *IssueConversion {
htmlURL := gh.HTMLURL
sourceSystem := fmt.Sprintf("github:%s:%d", gh.HTMLURL, gh.Number)
// Use a cleaner source system format if HTMLURL is not available
if htmlURL == "" {
sourceSystem = fmt.Sprintf("github:%d:%d", gh.ID, gh.Number)
}
labelNames := gh.LabelNames()
issue := &types.Issue{
Title: gh.Title,
Description: gh.Body,
ExternalRef: &htmlURL,
SourceSystem: sourceSystem,
IssueType: types.IssueType(typeFromLabels(labelNames, config)),
Priority: priorityFromLabels(labelNames, config),
Status: types.Status(statusFromLabelsAndState(labelNames, gh.State, config)),
Labels: filterNonScopedLabels(labelNames),
}
// Set assignee from GitHub user
if gh.Assignee != nil {
issue.Assignee = gh.Assignee.Login
}
// Set timestamps
if gh.CreatedAt != nil {
issue.CreatedAt = *gh.CreatedAt
}
if gh.UpdatedAt != nil {
issue.UpdatedAt = *gh.UpdatedAt
}
return &IssueConversion{
Issue: issue,
Dependencies: []DependencyInfo{},
}
}
// BeadsIssueToGitHubFields converts a beads Issue to GitHub API update fields.
func BeadsIssueToGitHubFields(issue *types.Issue, config *MappingConfig) map[string]interface{} {
fields := map[string]interface{}{
"title": issue.Title,
"body": issue.Description,
}
// Build labels from type, priority, and status
var labels []string
// Add type label
if issue.IssueType != "" {
labels = append(labels, "type::"+string(issue.IssueType))
}
// Add priority label
priorityLabel := priorityToLabel(issue.Priority)
if priorityLabel != "" {
labels = append(labels, "priority::"+priorityLabel)
}
// Add status label (if not open or closed - those are handled by state)
if issue.Status == types.StatusInProgress {
labels = append(labels, "status::in_progress")
} else if issue.Status == types.StatusBlocked {
labels = append(labels, "status::blocked")
} else if issue.Status == types.StatusDeferred {
labels = append(labels, "status::deferred")
}
// Add any existing non-scoped labels
labels = append(labels, issue.Labels...)
fields["labels"] = labels
// Set state for closed issues
if issue.Status == types.StatusClosed {
fields["state"] = "closed"
} else {
fields["state"] = "open"
}
return fields
}
// priorityToLabel converts beads priority (0-4) to GitHub priority label value.
func priorityToLabel(priority int) string {
switch priority {
case 0:
return "critical"
case 1:
return "high"
case 2:
return "medium"
case 3:
return "low"
case 4:
return "none"
default:
return "medium"
}
}
// filterNonScopedLabels returns only labels without scoped prefixes.
// Removes priority::*, status::*, and type::* labels.
func filterNonScopedLabels(labels []string) []string {
var filtered []string
for _, label := range labels {
prefix, _ := parseLabelPrefix(label)
// Skip scoped labels that we handle specially
if prefix == "priority" || prefix == "status" || prefix == "type" {
continue
}
filtered = append(filtered, label)
}
return filtered
}