[daily-compiler-quality] Daily Compiler Quality Report - 2026-04-27

[github-actions[bot]]

🔍 Compiler Code Quality Analysis Report

Analysis Date: 2026-04-27
Files Analyzed: compiler.go, compiler_jobs.go, compiler_yaml.go
Commit Hash: 2a7999c5
Overall Status: ⚠️ Some files need attention (1 of 3 files below quality threshold)

---

Executive Summary

Today's analysis covered three core compiler files totaling 2,457 lines of Go code. All three files demonstrate strong testing practices and clean Go idioms, but two files (compiler_jobs.go and compiler_yaml.go) exceed the 800-line guideline and contain functions significantly larger than the 50-line ideal. The standout concern is buildCustomJobs in compiler_jobs.go at 351 lines — the largest function identified in the codebase to date — and generatePrompt in compiler_yaml.go at 236 lines.

Error handling quality varies: compiler_jobs.go leads with 26 proper fmt.Errorf %w wraps, while compiler.go uses a custom formatCompilerError helper inconsistently, and compiler_yaml.go has only 4 wraps for 937 lines. Test coverage is excellent across all three files, with compiler_jobs.go achieving an outstanding 3.3× test-to-source ratio.

---

Files Analyzed Today

📁 Detailed File Analysis

1. compiler.go — Score: 77/100 ✅

Rating: Good | Size: 525 lines | Functions: 8

Dimension	Score	Notes
Structure & Organization	18/25	Clear entry points, but 2 functions >100 lines
Readability	14/20	generateAndValidateYAML (121 lines), CompileWorkflowData (123 lines)
Error Handling	14/20	Custom formatCompilerError used inconsistently; no fmt.Errorf %w
Testing & Maintainability	18/20	922 test lines vs 525 source (1.75×); both exported funcs have godoc
Patterns & Best Practices	13/15	Clean Go idioms, good separation of concerns
Total	77/100	Good

✅ Strengths

• Both exported functions (CompileWorkflow, CompileWorkflowData) have clear godoc comments
• Good test-to-source ratio (1.75×)
• Clean entry point design separating file-based vs. data-based compilation
• No TODOs or FIXMEs

⚠️ Issues

1. generateAndValidateYAML is 121 lines (lines 119–240) — validation, YAML generation, and multiple post-generation checks are all interleaved
2. CompileWorkflowData is 123 lines (lines 373–496) — orchestrates many phases without delegation
3. Inconsistent error wrapping: uses formatCompilerError in some paths but bare return err in others — no fmt.Errorf %w usage at all

💡 Recommendations

• Split generateAndValidateYAML into: validateYAMLSchema, applyRuntimeValidations, validateFirewallConfig
• Split CompileWorkflowData into preparation and execution phases
• Adopt fmt.Errorf("context: %w", err) in non-formatCompilerError paths for consistency

---

2. compiler_jobs.go — Score: 73/100 ⚠️

Rating: Acceptable | Size: 995 lines | Functions: 20

Dimension	Score	Notes
Structure & Organization	12/25	995 lines exceeds guideline; buildCustomJobs is 351 lines
Readability	11/20	buildCustomJobs (351 lines), buildJobs (78 lines)
Error Handling	18/20	Excellent — 26× fmt.Errorf %w wrapping
Testing & Maintainability	19/20	Outstanding — 3309 test lines vs 995 source (3.3×)
Patterns & Best Practices	13/15	Good helper pattern for job dependency checks
Total	73/100	Acceptable

✅ Strengths

• Best error handling of the three files: 26 occurrences of fmt.Errorf %w with context
• Exceptional test coverage: 3309 test lines for 995 source lines (3.3×)
• Good pattern of small, focused helper functions (jobDependsOnPreActivation, jobDependsOnActivation, jobDependsOnAgent)
• No TODOs or FIXMEs

⚠️ Issues

1. buildCustomJobs is 351 lines (lines 488–839) — this is the largest function found in the analysis and is a significant maintainability risk
2. File size 995 lines exceeds the 800-line guideline
3. buildJobs is 78 lines (lines 181–259) — could benefit from extraction

💡 Recommendations

• Extract buildCustomJobs into dedicated helpers or a new compiler_custom_jobs.go file
• Create focused sub-functions: validateCustomJobDependencies, compileCustomJobStep, applyCustomJobPermissions
• buildJobs could delegate activation job building to further reduce its size

---

3. compiler_yaml.go — Score: 69/100 ⚠️

Rating: Acceptable | Size: 937 lines | Functions: 16

Dimension	Score	Notes
Structure & Organization	14/25	937 lines; 3 functions >100 lines
Readability	11/20	generatePrompt (236 lines), generateWorkflowHeader (175 lines), generateCreateAwInfo (148 lines)
Error Handling	14/20	Only 4× fmt.Errorf %w for 937 lines; many raw return err paths
Testing & Maintainability	17/20	1440 test lines vs 937 source (1.54×); good comment density (24%)
Patterns & Best Practices	13/15	Good YAML generation pipeline; clean strings.Builder usage
Total	69/100	Acceptable

✅ Strengths

• High comment density (229 comment lines = 24%) — best of the three files
• Good test coverage (1440 test lines, 1.54× ratio)
• Clear pipeline: header → body → prompt → steps
• Well-structured chunk splitting logic (splitContentIntoChunks)

⚠️ Issues

1. generatePrompt is 236 lines (lines 407–643) — largest YAML-related function; contains engine-specific branching
2. generateWorkflowHeader is 175 lines (lines 83–258)
3. generateCreateAwInfo is 148 lines (lines 685–833)
4. File exceeds 800-line guideline at 937 lines
5. Sparse error wrapping: only 4 fmt.Errorf %w uses; generateOutputCollectionStep and several other functions return raw errors

💡 Recommendations

• Split generatePrompt by engine: generateCopilotPrompt, generateClaudePrompt into a compiler_yaml_prompt.go
• Extract header sections from generateWorkflowHeader into helpers: generateWorkflowTriggers, generateGlobalEnv
• Improve fmt.Errorf %w adoption in generateOutputCollectionStep and generateYAML error paths

---

Overall Statistics

Metric	Value
Files Analyzed	3
Average Score	73/100
Files Meeting Threshold (≥75)	1/3 (33%)
Total Lines Analyzed	2,457
Total Test Lines	5,671
Combined Test Ratio	2.31×

Quality Score Distribution

Rating	Count	Files
Excellent (90–100)	0	—
Good (75–89)	1	compiler.go
Acceptable (60–74)	2	compiler_jobs.go, compiler_yaml.go
Needs Work (40–59)	0	—
Poor (<40)	0	—

Common Patterns

✅ Strengths Across All Files

• Zero TODOs/FIXMEs — clean codebase
• Strong test coverage (average 2.3× ratio)
• Consistent Go idioms and naming conventions
• Good comment density

⚠️ Common Issues

• Oversized functions: 5 functions exceed 100 lines across the 3 files
• File size: 2 of 3 files exceed the 800-line guideline
• Inconsistent error wrapping: ranges from 26× (compiler_jobs.go) to 0× fmt.Errorf %w (compiler.go)

---

Actionable Recommendations

High Priority

1. Refactor buildCustomJobs in compiler_jobs.go (351 lines)

   • Extract into 3–4 focused helper functions or a new compiler_custom_jobs.go
   • This is the highest-risk function for maintainability

2. Split generatePrompt in compiler_yaml.go (236 lines)

   • Create engine-specific prompt generators in a dedicated file
   • Estimated effort: 2–3 hours

Medium Priority

3. Improve error wrapping in compiler.go

   • Add fmt.Errorf %w in non-formatCompilerError paths
   • Estimated effort: 30 minutes

4. Reduce function sizes in compiler.go

   • generateAndValidateYAML (121 lines) and CompileWorkflowData (123 lines)
   • Extract phase-specific validation helpers

Low Priority

5. Improve error wrapping in compiler_yaml.go
   • Only 4 fmt.Errorf %w uses for 937 lines
   • Focus on generateOutputCollectionStep first

---

💾 Cache & Rotation Summary

Cache: /tmp/gh-aw/cache-memory/compiler-quality/

File	Status	Score
compiler.go	✅ Analyzed today	77/100
compiler_jobs.go	✅ Analyzed today	73/100
compiler_yaml.go	✅ Analyzed today	69/100
compiler_orchestrator.go	⏳ Queued	—
compiler_safe_outputs.go	⏳ Queued	—
compiler_safe_outputs_config.go	⏳ Queued	—
compiler_safe_outputs_job.go	⏳ Queued	—
compiler_yaml_main_job.go	⏳ Queued	—

Next analysis (scheduled): compiler_safe_outputs.go, compiler_safe_outputs_job.go, compiler_yaml_main_job.go

---

Conclusion

The compiler codebase demonstrates solid fundamentals — excellent test coverage, zero technical debt markers, and consistent Go conventions. The primary concern is function size: five functions across these three files exceed 100 lines, with buildCustomJobs at 351 lines being a standout risk. The two files below the quality threshold (73 and 69/100) would benefit most from targeted refactoring of their largest functions.

Key Takeaways:

• ✅ Outstanding test discipline (2.3× average ratio)
• ✅ Zero TODOs/FIXMEs — clean working state
• ⚠️ Large functions are the primary quality risk
• ⚠️ Error wrapping inconsistency across files

References:

• §25021090720

Generated by Daily Compiler Quality Check · ● 1.3M · ◷

• expires on Apr 28, 2026, 9:49 PM UTC

[github-actions[bot]]

This discussion has been marked as outdated by Daily Compiler Quality Check.

A newer discussion is available at Discussion #28991.