beads/cmd/bd/duplicates.go
coffeegoddd☕️✨ e13bc5638f more commands
2026-07-20 14:41:07 -07:00

452 lines
14 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package main
import (
"fmt"
"regexp"
"strings"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/ui"
)
var duplicatesCmd = &cobra.Command{
Use: "duplicates",
GroupID: "deps",
Short: "Find and optionally merge duplicate issues",
Long: `Find issues with identical content (title, description, design, acceptance criteria).
Groups issues by content hash and reports duplicates with suggested merge targets.
The merge target is chosen by:
1. Reference count (most referenced issue wins)
2. Lexicographically smallest ID if reference counts are equal
Only groups issues with matching status (open with open, closed with closed).
Example:
bd duplicates # Show all duplicate groups
bd duplicates --auto-merge # Automatically merge all duplicates
bd duplicates --dry-run # Show what would be merged`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, _ []string) error {
evt := metrics.NewCommandEvent("duplicates")
defer func() {
if c := metrics.Global(); c != nil {
c.CloseEventAndAdd(evt)
}
}()
autoMerge, _ := cmd.Flags().GetBool("auto-merge")
dryRun, _ := cmd.Flags().GetBool("dry-run")
if usesProxiedServer() {
return runDuplicatesProxiedServer(rootCtx, autoMerge, dryRun)
}
if autoMerge && !dryRun {
CheckReadonly("duplicates --auto-merge")
}
ctx := rootCtx
allIssues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
return HandleError("fetching issues: %v", err)
}
duplicateGroups := findDuplicateGroups(openIssuesOf(allIssues))
if len(duplicateGroups) == 0 {
return outputNoDuplicates()
}
refCounts := countReferences(allIssues)
depCounts, _ := store.GetDependencyCounts(ctx, collectDuplicateGroupIDs(duplicateGroups))
structuralScores := buildStructuralScores(duplicateGroups, depCounts)
var mergeResults []map[string]interface{}
if autoMerge && !dryRun {
mergeResults = executeDuplicateMerges(duplicateGroups, refCounts, structuralScores)
commandDidWrite.Store(true)
}
return outputDuplicates(duplicateGroups, refCounts, structuralScores, autoMerge, dryRun, mergeResults)
},
}
func openIssuesOf(allIssues []*types.Issue) []*types.Issue {
openIssues := make([]*types.Issue, 0, len(allIssues))
for _, issue := range allIssues {
if issue.Status != types.StatusClosed {
openIssues = append(openIssues, issue)
}
}
return openIssues
}
func collectDuplicateGroupIDs(groups [][]*types.Issue) []string {
var ids []string
for _, group := range groups {
for _, issue := range group {
ids = append(ids, issue.ID)
}
}
return ids
}
func outputNoDuplicates() error {
if !jsonOutput {
fmt.Println("No duplicates found!")
return nil
}
return outputJSON(map[string]interface{}{
"duplicate_groups": 0,
"groups": []interface{}{},
})
}
func executeDuplicateMerges(duplicateGroups [][]*types.Issue, refCounts map[string]int, structuralScores map[string]*issueScore) []map[string]interface{} {
var mergeResults []map[string]interface{}
for _, group := range duplicateGroups {
target := chooseMergeTarget(group, refCounts, structuralScores)
sources := make([]string, 0, len(group)-1)
for _, issue := range group {
if issue.ID != target.ID {
sources = append(sources, issue.ID)
}
}
mergeResults = append(mergeResults, performMerge(target.ID, sources))
}
return mergeResults
}
func outputDuplicates(duplicateGroups [][]*types.Issue, refCounts map[string]int, structuralScores map[string]*issueScore, autoMerge, dryRun bool, mergeResults []map[string]interface{}) error {
var mergeCommands []string
for _, group := range duplicateGroups {
target := chooseMergeTarget(group, refCounts, structuralScores)
sources := make([]string, 0, len(group)-1)
for _, issue := range group {
if issue.ID != target.ID {
sources = append(sources, issue.ID)
}
}
cmd := fmt.Sprintf("# Duplicate: %s (same content as %s)\n# Suggested action: bd close %s && bd dep add %s %s --type related",
strings.Join(sources, " "),
target.ID,
strings.Join(sources, " "),
strings.Join(sources, " "),
target.ID)
mergeCommands = append(mergeCommands, cmd)
}
if jsonOutput {
output := map[string]interface{}{
"duplicate_groups": len(duplicateGroups),
"groups": formatDuplicateGroupsJSON(duplicateGroups, refCounts, structuralScores),
}
if autoMerge || dryRun {
output["merge_commands"] = mergeCommands
if autoMerge && !dryRun {
output["merge_results"] = mergeResults
}
}
return outputJSON(output)
}
fmt.Printf("%s Found %d duplicate group(s):\n\n", ui.RenderWarn("🔍"), len(duplicateGroups))
for i, group := range duplicateGroups {
target := chooseMergeTarget(group, refCounts, structuralScores)
fmt.Printf("%s Group %d: %s\n", ui.RenderAccent("━━"), i+1, group[0].Title)
for _, issue := range group {
refs := refCounts[issue.ID]
weight := 0
if score, ok := structuralScores[issue.ID]; ok {
weight = score.dependentCount*3 + score.dependsOnCount
}
marker := " "
if issue.ID == target.ID {
marker = ui.RenderPass("→ ")
}
fmt.Printf("%s%s (%s, P%d, weight=%d, %d refs)\n",
marker, issue.ID, issue.Status, issue.Priority, weight, refs)
}
sources := make([]string, 0, len(group)-1)
for _, issue := range group {
if issue.ID != target.ID {
sources = append(sources, issue.ID)
}
}
fmt.Printf(" %s Duplicate: %s (same content as %s)\n", ui.RenderAccent("Note:"), strings.Join(sources, " "), target.ID)
fmt.Printf(" %s bd close %s && bd dep add %s %s --type related\n\n",
ui.RenderAccent("Suggested:"), strings.Join(sources, " "), strings.Join(sources, " "), target.ID)
}
if autoMerge {
if dryRun {
fmt.Printf("%s Dry run - would execute %d merge(s)\n", ui.RenderWarn("⚠"), len(mergeCommands))
} else {
fmt.Printf("%s Merged %d group(s)\n", ui.RenderPass("✓"), len(mergeCommands))
}
} else {
fmt.Printf("%s Run with --auto-merge to execute all suggested merges\n", ui.RenderAccent("💡"))
}
return nil
}
func init() {
duplicatesCmd.Flags().Bool("auto-merge", false, "Automatically merge all duplicates")
duplicatesCmd.Flags().Bool("dry-run", false, "Show what would be merged without making changes")
rootCmd.AddCommand(duplicatesCmd)
}
// contentKey represents the fields we use to identify duplicate issues
type contentKey struct {
title string
description string
design string
acceptanceCriteria string
status string // Only group issues with same status
}
// findDuplicateGroups groups issues by content hash
func findDuplicateGroups(issues []*types.Issue) [][]*types.Issue {
groups := make(map[contentKey][]*types.Issue)
for _, issue := range issues {
key := contentKey{
title: issue.Title,
description: issue.Description,
design: issue.Design,
acceptanceCriteria: issue.AcceptanceCriteria,
status: string(issue.Status),
}
groups[key] = append(groups[key], issue)
}
// Filter to only groups with duplicates
var duplicates [][]*types.Issue
for _, group := range groups {
if len(group) > 1 {
duplicates = append(duplicates, group)
}
}
return duplicates
}
// issueScore captures all factors used to choose which duplicate to keep
type issueScore struct {
dependentCount int // Issues that depend on this one (children, blocked-by) - highest priority
dependsOnCount int // Issues this one depends on
textRefs int // Text mentions in other issues' descriptions/notes
}
// countReferences counts how many times each issue is referenced in text fields
func countReferences(issues []*types.Issue) map[string]int {
counts := make(map[string]int)
idPattern := regexp.MustCompile(`\b[a-zA-Z][-a-zA-Z0-9]*-\d+\b`)
for _, issue := range issues {
// Search in all text fields
textFields := []string{
issue.Description,
issue.Design,
issue.AcceptanceCriteria,
issue.Notes,
}
for _, text := range textFields {
matches := idPattern.FindAllString(text, -1)
for _, match := range matches {
counts[match]++
}
}
}
return counts
}
func buildStructuralScores(groups [][]*types.Issue, depCounts map[string]*types.DependencyCounts) map[string]*issueScore {
scores := make(map[string]*issueScore)
for _, group := range groups {
for _, issue := range group {
scores[issue.ID] = &issueScore{}
}
}
for id, counts := range depCounts {
if score, ok := scores[id]; ok {
score.dependentCount = counts.DependentCount
score.dependsOnCount = counts.DependencyCount
}
}
return scores
}
// chooseMergeTarget selects the best issue to merge into
// Priority order:
// 1. Highest structural weight - most connected issue wins
// Dependents (children) are weighted 3× more than depends-on references
// because discarding an issue with children orphans them (catastrophic),
// while losing a depends-on link is recoverable.
// 2. Highest text reference count (mentions in descriptions/notes)
// 3. Lexicographically smallest ID (stable tiebreaker)
func chooseMergeTarget(group []*types.Issue, refCounts map[string]int, structuralScores map[string]*issueScore) *types.Issue {
if len(group) == 0 {
return nil
}
getScore := func(id string) (int, int) {
weight := 0
if score, ok := structuralScores[id]; ok {
// Dependents (children that would be orphaned) count 3× more than
// depends-on references (which survive closure as links).
weight = score.dependentCount*3 + score.dependsOnCount
}
textRefs := refCounts[id]
return weight, textRefs
}
target := group[0]
targetWeight, targetRefs := getScore(target.ID)
for _, issue := range group[1:] {
issueWeight, issueRefs := getScore(issue.ID)
// Compare by structural weight first (dependents + dependencies)
if issueWeight > targetWeight {
target = issue
targetWeight, targetRefs = issueWeight, issueRefs
continue
}
if issueWeight < targetWeight {
continue
}
// Equal weight - compare by text references
if issueRefs > targetRefs {
target = issue
targetWeight, targetRefs = issueWeight, issueRefs
continue
}
if issueRefs < targetRefs {
continue
}
// Equal on both - use lexicographically smallest ID as tiebreaker
if issue.ID < target.ID {
target = issue
targetWeight, targetRefs = issueWeight, issueRefs
}
}
return target
}
// formatDuplicateGroupsJSON formats duplicate groups for JSON output
func formatDuplicateGroupsJSON(groups [][]*types.Issue, refCounts map[string]int, structuralScores map[string]*issueScore) []map[string]interface{} {
var result []map[string]interface{}
for _, group := range groups {
target := chooseMergeTarget(group, refCounts, structuralScores)
issues := make([]map[string]interface{}, len(group))
for i, issue := range group {
dependents := 0
dependencies := 0
if score, ok := structuralScores[issue.ID]; ok {
dependents = score.dependentCount
dependencies = score.dependsOnCount
}
issues[i] = map[string]interface{}{
"id": issue.ID,
"title": issue.Title,
"status": issue.Status,
"priority": issue.Priority,
"references": refCounts[issue.ID],
"dependents": dependents,
"dependencies": dependencies,
"weight": dependents*3 + dependencies,
"is_merge_target": issue.ID == target.ID,
}
}
sources := make([]string, 0, len(group)-1)
for _, issue := range group {
if issue.ID != target.ID {
sources = append(sources, issue.ID)
}
}
result = append(result, map[string]interface{}{
"title": group[0].Title,
"issues": issues,
"suggested_target": target.ID,
"suggested_sources": sources,
"suggested_action": fmt.Sprintf("bd close %s && bd dep add %s %s --type related", strings.Join(sources, " "), strings.Join(sources, " "), target.ID),
"note": fmt.Sprintf("Duplicate: %s (same content as %s)", strings.Join(sources, " "), target.ID),
})
}
return result
}
// performMerge executes the merge operation:
// 1. Re-parents children of source issues to the target (prevents orphaning)
// 2. Closes all source issues with a reason indicating they are duplicates
// 3. Links each source to the target with a "related" dependency
// Returns a map with the merge result for JSON output
func performMerge(targetID string, sourceIDs []string) map[string]interface{} {
ctx := rootCtx
result := map[string]interface{}{
"target": targetID,
"sources": sourceIDs,
"closed": []string{},
"linked": []string{},
"reparented": []string{},
"errors": []string{},
}
closedIDs := []string{}
linkedIDs := []string{}
reparentedIDs := []string{}
errors := []string{}
for _, sourceID := range sourceIDs {
// Re-parent children before closing to prevent orphaning.
// Get dependents with metadata to find parent-child relationships.
dependents, err := store.GetDependentsWithMetadata(ctx, sourceID)
if err == nil {
for _, dep := range dependents {
if dep.DependencyType != types.DepParentChild {
continue
}
childID := dep.Issue.ID
// Remove old parent-child link
if err := store.RemoveDependency(ctx, childID, sourceID, getActor()); err != nil {
errors = append(errors, fmt.Sprintf("failed to remove parent link %s→%s: %v", childID, sourceID, err))
continue
}
// Add new parent-child link to target
newDep := &types.Dependency{
IssueID: childID,
DependsOnID: targetID,
Type: types.DepParentChild,
}
if err := store.AddDependency(ctx, newDep, getActor()); err != nil {
errors = append(errors, fmt.Sprintf("failed to reparent %s to %s: %v", childID, targetID, err))
continue
}
reparentedIDs = append(reparentedIDs, childID)
}
}
// Close the duplicate issue
reason := fmt.Sprintf("Duplicate of %s", targetID)
if err := store.CloseIssue(ctx, sourceID, reason, actor, ""); err != nil {
errors = append(errors, fmt.Sprintf("failed to close %s: %v", sourceID, err))
continue
}
closedIDs = append(closedIDs, sourceID)
// Add dependency linking source to target
dep := &types.Dependency{
IssueID: sourceID,
DependsOnID: targetID,
Type: types.DependencyType("related"),
}
if err := store.AddDependency(ctx, dep, getActor()); err != nil {
errors = append(errors, fmt.Sprintf("failed to link %s to %s: %v", sourceID, targetID, err))
continue
}
linkedIDs = append(linkedIDs, sourceID)
}
result["closed"] = closedIDs
result["linked"] = linkedIDs
result["reparented"] = reparentedIDs
result["errors"] = errors
return result
}