From 06d385edf9edc5e1008a84f69243a48646d8cf34 Mon Sep 17 00:00:00 2001 From: Kevin Glynn Date: Sat, 2 May 2026 17:24:27 -0400 Subject: [PATCH] feat(linear): add type mappings for decision, spike, story, milestone (#3651) Fix-merged for release prep: preserved the contributor Linear type mappings and added exact-only matching to avoid story false positives such as history. Auto-merge after CI. --- internal/linear/mapping.go | 32 ++++++++++++++++++++++- internal/linear/mapping_test.go | 46 +++++++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+), 1 deletion(-) diff --git a/internal/linear/mapping.go b/internal/linear/mapping.go index 04c281a52..d41f63425 100644 --- a/internal/linear/mapping.go +++ b/internal/linear/mapping.go @@ -177,6 +177,10 @@ func DefaultMappingConfig() *MappingConfig { "chore": "chore", "maintenance": "chore", "task": "task", + "decision": "decision", + "spike": "spike", + "story": "story", + "milestone": "milestone", }, // Linear relation types to Beads dependency types RelationMap: map[string]string{ @@ -458,8 +462,12 @@ func LabelToIssueType(labels *Labels, config *MappingConfig) types.IssueType { return ParseIssueType(issueType) } - // Check if label contains any mapped keyword + // Check if label contains any broad legacy keyword. New issue types are + // exact-only to avoid labels like "history" being inferred as "story". for keyword, issueType := range config.LabelTypeMap { + if !allowsSubstringLabelType(keyword, issueType) { + continue + } if strings.Contains(labelName, keyword) { return ParseIssueType(issueType) } @@ -469,6 +477,20 @@ func LabelToIssueType(labels *Labels, config *MappingConfig) types.IssueType { return types.TypeTask // Default } +func allowsSubstringLabelType(keyword, issueType string) bool { + switch keyword { + case "decision", "spike", "story", "milestone": + return false + } + + switch ParseIssueType(issueType) { + case types.TypeDecision, types.TypeSpike, types.TypeStory, types.TypeMilestone: + return false + default: + return true + } +} + // ParseIssueType converts an issue type string to types.IssueType. func ParseIssueType(s string) types.IssueType { switch strings.ToLower(s) { @@ -482,6 +504,14 @@ func ParseIssueType(s string) types.IssueType { return types.TypeEpic case "chore": return types.TypeChore + case "decision": + return types.TypeDecision + case "spike": + return types.TypeSpike + case "story": + return types.TypeStory + case "milestone": + return types.TypeMilestone default: return types.TypeTask } diff --git a/internal/linear/mapping_test.go b/internal/linear/mapping_test.go index 71b322d56..9c4a3fd87 100644 --- a/internal/linear/mapping_test.go +++ b/internal/linear/mapping_test.go @@ -173,6 +173,18 @@ func TestDefaultMappingConfig(t *testing.T) { if config.LabelTypeMap["feature"] != "feature" { t.Errorf("LabelTypeMap[feature] = %s, want feature", config.LabelTypeMap["feature"]) } + if config.LabelTypeMap["decision"] != "decision" { + t.Errorf("LabelTypeMap[decision] = %s, want decision", config.LabelTypeMap["decision"]) + } + if config.LabelTypeMap["spike"] != "spike" { + t.Errorf("LabelTypeMap[spike] = %s, want spike", config.LabelTypeMap["spike"]) + } + if config.LabelTypeMap["story"] != "story" { + t.Errorf("LabelTypeMap[story] = %s, want story", config.LabelTypeMap["story"]) + } + if config.LabelTypeMap["milestone"] != "milestone" { + t.Errorf("LabelTypeMap[milestone] = %s, want milestone", config.LabelTypeMap["milestone"]) + } // Check relation mappings if config.RelationMap["blocks"] != "blocks" { @@ -312,8 +324,17 @@ func TestLabelToIssueType(t *testing.T) { {&Labels{Nodes: []Label{{Name: "feature"}}}, types.TypeFeature}, {&Labels{Nodes: []Label{{Name: "epic"}}}, types.TypeEpic}, {&Labels{Nodes: []Label{{Name: "chore"}}}, types.TypeChore}, + {&Labels{Nodes: []Label{{Name: "decision"}}}, types.TypeDecision}, + {&Labels{Nodes: []Label{{Name: "spike"}}}, types.TypeSpike}, + {&Labels{Nodes: []Label{{Name: "story"}}}, types.TypeStory}, + {&Labels{Nodes: []Label{{Name: "milestone"}}}, types.TypeMilestone}, {&Labels{Nodes: []Label{{Name: "random"}, {Name: "bug"}}}, types.TypeBug}, {&Labels{Nodes: []Label{{Name: "contains-bug-keyword"}}}, types.TypeBug}, + {&Labels{Nodes: []Label{{Name: "history"}}}, types.TypeTask}, + {&Labels{Nodes: []Label{{Name: "decision-log"}}}, types.TypeTask}, + {&Labels{Nodes: []Label{{Name: "spike-detector"}}}, types.TypeTask}, + {&Labels{Nodes: []Label{{Name: "storytime"}}}, types.TypeTask}, + {&Labels{Nodes: []Label{{Name: "pre-milestone"}}}, types.TypeTask}, } for _, tt := range tests { @@ -324,6 +345,27 @@ func TestLabelToIssueType(t *testing.T) { } } +func TestLabelToIssueTypeCustomStoryAliasIsExactOnly(t *testing.T) { + config := DefaultMappingConfig() + config.LabelTypeMap["user-story"] = "story" + + tests := []struct { + label string + want types.IssueType + }{ + {"user-story", types.TypeStory}, + {"backend-user-story", types.TypeTask}, + } + + for _, tt := range tests { + labels := &Labels{Nodes: []Label{{Name: tt.label}}} + got := LabelToIssueType(labels, config) + if got != tt.want { + t.Errorf("LabelToIssueType(%q) = %v, want %v", tt.label, got, tt.want) + } + } +} + func TestParseIssueType(t *testing.T) { tests := []struct { input string @@ -335,6 +377,10 @@ func TestParseIssueType(t *testing.T) { {"task", types.TypeTask}, {"epic", types.TypeEpic}, {"chore", types.TypeChore}, + {"decision", types.TypeDecision}, + {"spike", types.TypeSpike}, + {"story", types.TypeStory}, + {"milestone", types.TypeMilestone}, {"unknown", types.TypeTask}, // Default }