[sergo] Sergo Report: Duplicate-Code Detection — 2026-04-25

[github-actions[bot]]

Date: 2026-04-25
Strategy: Duplicate-Code Detection (new exploration)
Success Score: 7/10
Run ID: §24939819634

Executive Summary

Today's Sergo run performed a deep static analysis of pkg/workflow/domains.go — the largest and most complex single file in the workflow package — using Serena's symbol search and pattern-matching tools. Two actionable code-quality issues were discovered and tracked as GitHub issues.

The first finding is a clear-cut duplication: extractOpenCodeProviderFromModel and extractCrushProviderFromModel are byte-for-byte identical functions that serve the same purpose for different engine types. The second finding is a systematic anti-pattern: the same 4-line "map-as-set → sorted slice" idiom is repeated 8 times in the same file, even though the idiomatic Go 1.23+ replacement (slices.Sorted(maps.Keys(...))) is already used elsewhere in the codebase.

No existing open sergo issues cover these patterns, so two new tracking issues were created.

---

Serena Tools Update

Tools Snapshot

• Total Tools Available: 22 (first run — no prior snapshot)
• New Tools Since Last Run: N/A (baseline)
• Removed Tools: N/A
• Modified Tools: N/A

Tool Capabilities Used Today

Tool	Purpose
activate_project	Activated the gh-aw Go project for LSP analysis
get_symbols_overview	Scanned symbol inventories of key files
find_symbol	Retrieved full function bodies for comparison
find_referencing_symbols	Traced callers of suspected-duplicate functions
search_for_pattern	Located all occurrences of map-set and sort patterns
list_dir	Explored package and directory structure

---

Strategy Selection

Cached Reuse Component (50%)

No prior cache — this is run #1. The 50% exploitation slot defaulted to the most universally applicable strategy: symbol-level duplication scan (looking for functions with identical signatures, similar names, or identical bodies).

New Exploration Component (50%)

Novel Approach: Pattern-based idiom detection in the largest file in pkg/workflow/.

• Tools Employed: search_for_pattern with regex for known Go idioms (make(map[string]bool), sort.Strings(, slices.Sorted(maps.Keys)
• Hypothesis: Large, organically-grown files accumulate copy-pasted patterns that pre-date the project's own utility packages
• Target Areas: pkg/workflow/domains.go (the file with the most distinct network-domain functions), pkg/sliceutil/sliceutil.go, pkg/workflow/map_helpers.go, pkg/workflow/agentic_engine.go

Combined Strategy Rationale

Symbol-level search catches structural duplication (identical function bodies); pattern search catches syntactic idiom repetition. Together they cover both "two functions doing the same thing" and "the same boilerplate code repeated N times."

---

Analysis Execution

Codebase Context

• Primary analysis target: pkg/workflow/ (~500+ Go files)
• Secondary: pkg/cli/, pkg/sliceutil/, pkg/actionpins/
• Go version: 1.25 (std maps and slices packages fully available)
• Active linters: modernize, intrange, exptostd, perfsprint, unconvert, and others

Findings Summary

• Total Issues Found: 2
• Critical: 0
• High: 0
• Medium: 2
• Low: 0

---

Detailed Findings

Finding 1 — Duplicate extractProviderFromModel Functions (Medium)

Location: pkg/workflow/domains.go:190–199 and pkg/workflow/domains.go:224–233

extractOpenCodeProviderFromModel and extractCrushProviderFromModel are identical in every respect:

func extractOpenCodeProviderFromModel(model string) string {
	if model == "" { return "copilot" }
	parts := strings.SplitN(model, "/", 2)
	if len(parts) < 2 { return "copilot" }
	return strings.ToLower(parts[0])
}

func extractCrushProviderFromModel(model string) string {  // IDENTICAL
	if model == "" { return "copilot" }
	parts := strings.SplitN(model, "/", 2)
	if len(parts) < 2 { return "copilot" }
	return strings.ToLower(parts[0])
}

Both were likely added independently when OpenCode and Crush engine support was introduced. A single extractProviderFromModel(model string) string should replace both. The test TestExtractProviderFromModel in crush_engine_test.go tests only the Crush variant, leaving the OpenCode function untested for edge cases.

Impact: Future changes (e.g., a different default for a new engine type) must be applied twice and can silently diverge.

Fix: See GitHub issue #aw_dup1.

---

Finding 2 — Repeated Map-to-Sorted-Slice Idiom (Medium)

Location: pkg/workflow/domains.go, 8 occurrences

The following 4-line block appears 8 times across different domain-aggregation functions:

result := make([]string, 0, len(domainMap))
for d := range domainMap {
    result = append(result, d)
}
sort.Strings(result)

The idiomatic Go 1.23+ replacement is already used in this codebase:

• pkg/workflow/compiler_main_job.go:99 — slices.Sorted(maps.Keys(data.Jobs))
• pkg/cli/run_workflow_validation.go:240 — slices.Sorted(maps.Keys(workflowInputs))

The modernize linter (enabled in .golangci.yml) targets exactly this kind of modernization.

Impact: Verbose boilerplate on every new domain-aggregation function. Inconsistent style within the same module.

Fix: See GitHub issue #28492. Add "maps" and "slices" to domains.go imports; replace each 4-line block with slices.Sorted(maps.Keys(domainMap)).

Affected functions in domains.go

Function	Approx. Line
getEcosystemDomains	291
getDomainsFromRuntimes	346
GetAllowedDomains	452
GetBlockedDomains	643
GetAPITargetDomains	799
mergeAPITargetDomains	877
expandAllowedDomains (×2)	956, 983

---

Improvement Tasks Generated

Task 1: Unify extractProviderFromModel

Issue Type: Symbol Duplication

Problem: extractOpenCodeProviderFromModel and extractCrushProviderFromModel in domains.go are identical.

Location: pkg/workflow/domains.go:190–233

Severity: Medium | Affected Files: 2 (domains.go, crush_engine_test.go) | Effort: Small

Before:

func extractOpenCodeProviderFromModel(model string) string { ... }
func extractCrushProviderFromModel(model string) string { ... } // identical

After:

func extractProviderFromModel(model string) string { ... }
// callers: GetOpenCodeDefaultDomains, GetCrushDefaultDomains

Validation:

• go test ./pkg/workflow/... passes
• go build ./pkg/workflow/ passes

---

Task 2: Replace map-to-sorted-slice with slices.Sorted(maps.Keys(...))

Issue Type: Idiom Modernization

Problem: 8 repeated 4-line blocks in domains.go that the modernize linter targets.

Location: pkg/workflow/domains.go (8 sites)

Severity: Medium | Affected Files: 1 | Effort: Small

Before:

result := make([]string, 0, len(domainMap))
for d := range domainMap {
    result = append(result, d)
}
sort.Strings(result)

After:

result := slices.Sorted(maps.Keys(domainMap))

Validation:

• go test ./pkg/workflow/... passes
• golangci-lint run ./pkg/workflow/ shows no new warnings
• "sort" import removed from domains.go if no longer used

---

Success Metrics

This Run

• Findings Generated: 2
• Tasks Created: 2
• Issues Created: 2 (no duplicates skipped — no prior sergo issues matched)
• Success Score: 7/10

Score Reasoning

• Findings Quality (3/4): Both findings are medium-severity, actionable, and located in a frequently-modified file. No critical bugs found.
• Coverage (2/3): Focused on domains.go and key utilities; did not scan pkg/cli/ or pkg/parser/ in depth.
• Task Generation (2/3): Two well-defined tasks, each scoped to a single file with clear before/after.

Cumulative Statistics (Run 1 of N)

• Total Runs: 1
• Total Findings: 2
• Total Tasks: 2
• Average Score: 7.0/10
• Best Strategy: duplicate-code-detection

---

Recommendations

Immediate Actions

1. (Medium) Unify extractOpenCodeProviderFromModel / extractCrushProviderFromModel → single extractProviderFromModel — tracked in issue #aw_dup1
2. (Medium) Replace 8 repeated map-to-sorted-slice blocks in domains.go with slices.Sorted(maps.Keys(...)) — tracked in issue Replace repeated map-to-sorted-slice pattern in domains.go with slices.Sorted(maps.Keys(...)) #28492

Long-term Improvements

• Consider enabling the gocritic linter once golangci-lint v2 bugs are resolved — it would catch similar duplicate/copy-paste patterns automatically
• The sliceutil package's Deduplicate function internally uses map[T]bool; a future modernization could switch to map[T]struct{} for zero-size values, though the benefit is minor

---

Next Run Preview

Suggested Focus Areas

• pkg/workflow/agentic_engine.go — GetAllAgentManifestFolders / GetAllAgentManifestFiles share near-identical logic (collect engine files with deduplication); could share a helper
• pkg/cli/ — context.Background() used inside functions that could accept a caller-provided context for better cancellation propagation
• pkg/workflow/compiler_orchestrator_*.go — phased compilation pipeline; check for error-wrapping consistency across the 5 orchestrator sub-files

Strategy Evolution

• Run 2 should reuse today's duplicate-code-detection strategy (50% exploitation) applied to pkg/cli/ + new strategy targeting context propagation patterns (50% new exploration)

---

References:

• §24939819634

Generated by Sergo - Serena Go Expert · ● 630.9K · ◷

• expires on Apr 26, 2026, 8:34 PM UTC

[github-actions[bot]]

This discussion has been marked as outdated by Sergo - Serena Go Expert.

A newer discussion is available at Discussion #28632.