beads/cmd/bd/rules.go
matt wilkie f443df1f2a
fix: resolve CI failures from flock, version bump, and lint (#2981)
* fix: resolve CI failures from flock, version bump, and lint

Three categories of CI failure on main after the v1.0.0 release:

1. rules.go lint/format: Fix gofmt alignment, errcheck on tw.Flush(),
   gosec G304 (add nosec comment), gosec G306 (use 0o600 perms).

2. doctor_test.go version tracking: The 'slightly outdated version'
   test used 0.55.0 which now has a major version diff from 1.0.0,
   correctly triggering a warning. Update expected status to match.

3. Embedded Dolt concurrent tests: The exclusive flock from #2571
   causes concurrent bd processes to fail with 'one writer at a time'.
   Update 58 concurrent test files to tolerate this expected error
   while still failing on unexpected errors and panics.

Amp-Thread-ID: https://ampcode.com/threads/T-019d5386-b41e-7138-bc81-6ea331b80760
Co-authored-by: Amp <amp@ampcode.com>

* fix: concurrent test post-conditions tolerate flock contention

With exclusive flock (commit 543e1943), only some workers can acquire
the lock in concurrent tests. Update post-conditions in 5 tests to:
- Only verify side effects from workers that succeeded (r.err == nil)
- Require at least 1 worker succeeds (fail if all hit flock)
- Log success/failure counts for visibility
- Still verify correct behavior for successful operations

Tests fixed:
- TestEmbeddedCloseConcurrent: remove Fatalf on failures, skip total count check
- TestEmbeddedDeferConcurrent: only check deferred status for successful workers
- TestEmbeddedUndeferConcurrent: only check open status for successful workers
- TestEmbeddedReopenConcurrent: only check open status for successful workers
- TestEmbeddedPromoteCLIConcurrent: only check permanent for successful workers

Amp-Thread-ID: https://ampcode.com/threads/T-019d5386-b41e-7138-bc81-6ea331b80760
Co-authored-by: Amp <amp@ampcode.com>
Amp-Thread-ID: https://ampcode.com/threads/T-019d5386-b41e-7138-bc81-6ea331b80760
Co-authored-by: Amp <amp@ampcode.com>

---------

Co-authored-by: Amp <amp@ampcode.com>
2026-04-03 07:27:00 -07:00

899 lines
23 KiB
Go

package main
import (
"fmt"
"os"
"path/filepath"
"regexp"
"sort"
"strings"
"text/tabwriter"
"unicode"
"github.com/spf13/cobra"
)
// --- Types ---
// RuleFile represents a parsed .claude/rules/*.md file.
type RuleFile struct {
Path string `json:"path"`
Name string `json:"name"`
Title string `json:"title"`
DoLines []string `json:"do_lines"`
DontLines []string `json:"dont_lines"`
Body string `json:"body,omitempty"`
Keywords []string `json:"keywords"`
Tokens int `json:"tokens"`
}
// ContradictionReport describes a tension between two rules.
type ContradictionReport struct {
RuleA string `json:"rule_a"`
RuleB string `json:"rule_b"`
Tension string `json:"tension"`
DoLineA string `json:"do_line_a"`
DontLineB string `json:"dont_line_b"`
ScopeScore float64 `json:"scope_score"`
}
// MergeCandidate represents a group of rules that could be combined.
type MergeCandidate struct {
GroupLabel string `json:"group_label"`
Rules []string `json:"rules"`
Score float64 `json:"score"`
}
// AuditResult is the full output of `bd rules audit`.
type AuditResult struct {
TotalRules int `json:"total_rules"`
TokenEstimate int `json:"token_estimate"`
Contradictions []ContradictionReport `json:"contradictions"`
MergeCandidates []MergeCandidate `json:"merge_candidates"`
Rules []RuleFile `json:"rules,omitempty"`
}
// --- Stop Words ---
var stopWords = map[string]bool{
"the": true, "a": true, "is": true, "to": true, "for": true,
"and": true, "or": true, "in": true, "of": true, "it": true,
"that": true, "this": true, "with": true, "be": true, "not": true,
"do": true, "don't": true, "use": true, "when": true, "before": true,
"after": true, "should": true, "must": true, "always": true, "never": true,
"an": true, "are": true, "as": true, "at": true, "by": true,
"from": true, "has": true, "have": true, "if": true, "on": true,
"was": true, "were": true, "will": true, "you": true, "your": true,
}
// --- Antonym Pairs ---
// antonymPairs maps words to their antonyms for contradiction detection.
var antonymPairs = map[string][]string{
"block": {"proceed", "parallel"},
"proceed": {"block"},
"parallel": {"block"},
"verbose": {"minimize", "concise"},
"minimize": {"verbose"},
"concise": {"verbose"},
"spawn": {"reuse"},
"reuse": {"spawn"},
"wait": {"skip"},
"skip": {"wait"},
"log": {"suppress"},
"suppress": {"log"},
}
// --- Regex Patterns ---
var (
headingRe = regexp.MustCompile(`(?m)^#\s+(.+)`)
doRe = regexp.MustCompile(`(?i)^\*\*Do:?\*\*:?\s*(.*)`)
dontRe = regexp.MustCompile(`(?i)^\*\*Don'?t:?\*\*:?\s*(.*)`)
)
// --- Core Functions ---
// ParseRuleFile reads a .md file and extracts structured rule data.
func ParseRuleFile(path string) (RuleFile, error) {
// #nosec G304 -- path comes from controlled filepath.Join of user-specified rules directory
data, err := os.ReadFile(path)
if err != nil {
return RuleFile{}, fmt.Errorf("read rule file %s: %w", path, err)
}
content := string(data)
name := strings.TrimSuffix(filepath.Base(path), ".md")
rf := RuleFile{
Path: path,
Name: name,
Body: content,
// Rough token estimate: 1 token ~ 4 chars
Tokens: len(content) / 4,
}
// Extract title from first heading
if m := headingRe.FindStringSubmatch(content); len(m) > 1 {
rf.Title = strings.TrimSpace(m[1])
} else {
rf.Title = name
}
// Extract Do and Don't blocks
rf.DoLines, rf.DontLines = extractAllDirectives(content)
// Extract keywords from Do/Don't lines first, fallback to body
allDirectives := append(rf.DoLines, rf.DontLines...)
if len(allDirectives) > 0 {
rf.Keywords = ExtractKeywords(allDirectives)
} else {
rf.Keywords = ExtractKeywords([]string{content})
}
return rf, nil
}
// extractAllDirectives parses Do and Don't blocks from rule content.
// Don't patterns are checked first to avoid false matches (since "Don't" contains "Do").
func extractAllDirectives(content string) (doLines, dontLines []string) {
lines := strings.Split(content, "\n")
// blockType: 0=none, 1=do, 2=dont
blockType := 0
for _, line := range lines {
trimmed := strings.TrimSpace(line)
// Check Don't first (it contains "Do", so must be checked before Do)
if m := dontRe.FindStringSubmatch(line); len(m) > 1 {
blockType = 2
text := strings.TrimSpace(m[1])
if text != "" {
dontLines = append(dontLines, text)
}
continue
}
if m := doRe.FindStringSubmatch(line); len(m) > 1 {
blockType = 1
text := strings.TrimSpace(m[1])
if text != "" {
doLines = append(doLines, text)
}
continue
}
if blockType != 0 {
// Continuation: line starts with - or is non-empty non-heading text
if strings.HasPrefix(trimmed, "-") || (strings.HasPrefix(trimmed, "*") && !strings.HasPrefix(trimmed, "**")) {
// Strip leading bullet
text := strings.TrimLeft(trimmed, "-* ")
if text != "" {
if blockType == 1 {
doLines = append(doLines, text)
} else {
dontLines = append(dontLines, text)
}
}
} else if trimmed == "" || strings.HasPrefix(trimmed, "#") || strings.HasPrefix(trimmed, "**") {
// End of block
blockType = 0
} else {
// Plain continuation text
if blockType == 1 {
doLines = append(doLines, trimmed)
} else {
dontLines = append(dontLines, trimmed)
}
}
}
}
return doLines, dontLines
}
// ExtractKeywords tokenizes lines, removes stop words, lowercases, and deduplicates.
func ExtractKeywords(lines []string) []string {
seen := make(map[string]bool)
var keywords []string
for _, line := range lines {
words := tokenizeWords(line)
for _, w := range words {
w = strings.ToLower(w)
if len(w) < 2 {
continue
}
if stopWords[w] {
continue
}
if !seen[w] {
seen[w] = true
keywords = append(keywords, w)
}
}
}
sort.Strings(keywords)
return keywords
}
// tokenize splits text into words, stripping punctuation.
func tokenizeWords(s string) []string {
return strings.FieldsFunc(s, func(r rune) bool {
return !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != '\''
})
}
// JaccardSimilarity computes keyword overlap between two keyword sets.
func JaccardSimilarity(a, b []string) float64 {
if len(a) == 0 && len(b) == 0 {
return 0.0
}
setA := make(map[string]bool, len(a))
for _, w := range a {
setA[w] = true
}
setB := make(map[string]bool, len(b))
for _, w := range b {
setB[w] = true
}
intersection := 0
for w := range setA {
if setB[w] {
intersection++
}
}
union := len(setA)
for w := range setB {
if !setA[w] {
union++
}
}
if union == 0 {
return 0.0
}
return float64(intersection) / float64(union)
}
// DetectContradictions finds opposing directives across rule pairs.
// Two rules contradict when they share scope (jaccard >= scopeThreshold)
// and have opposing directives (same verb in Do vs Don't, or antonym pairs).
func DetectContradictions(rules []RuleFile, scopeThreshold float64) []ContradictionReport {
var reports []ContradictionReport
for i := 0; i < len(rules); i++ {
for j := i + 1; j < len(rules); j++ {
a, b := rules[i], rules[j]
score := JaccardSimilarity(a.Keywords, b.Keywords)
if score < scopeThreshold {
continue
}
// Check for direct contradictions: verb in A's Do appears in B's Don't
if c := findDirectContradiction(a, b, score); c != nil {
reports = append(reports, *c)
continue
}
// Check reverse direction
if c := findDirectContradiction(b, a, score); c != nil {
// Swap labels since we checked b->a
c.RuleA, c.RuleB = a.Name+".md", b.Name+".md"
reports = append(reports, *c)
continue
}
// Check for antonym pair contradictions in Do vs Do
if c := findAntonymContradiction(a, b, score); c != nil {
reports = append(reports, *c)
}
}
}
return reports
}
// findDirectContradiction checks if a verb from A's Do appears in B's Don't.
func findDirectContradiction(a, b RuleFile, scopeScore float64) *ContradictionReport {
aDoWords := extractActionWords(a.DoLines)
bDontWords := extractActionWords(b.DontLines)
for word, doLine := range aDoWords {
if dontLine, ok := bDontWords[word]; ok {
tension := truncateTension(
fmt.Sprintf("%q vs %q", summarizeLine(doLine), summarizeLine(dontLine)),
)
return &ContradictionReport{
RuleA: a.Name + ".md",
RuleB: b.Name + ".md",
Tension: tension,
DoLineA: doLine,
DontLineB: dontLine,
ScopeScore: scopeScore,
}
}
}
return nil
}
// findAntonymContradiction checks if A's Do words have antonyms in B's Do words.
func findAntonymContradiction(a, b RuleFile, scopeScore float64) *ContradictionReport {
aDoWords := extractActionWords(a.DoLines)
bDoWords := extractActionWords(b.DoLines)
for wordA, lineA := range aDoWords {
antonyms, ok := antonymPairs[wordA]
if !ok {
continue
}
for _, ant := range antonyms {
if lineB, ok := bDoWords[ant]; ok {
tension := truncateTension(
fmt.Sprintf("%q vs %q", summarizeLine(lineA), summarizeLine(lineB)),
)
return &ContradictionReport{
RuleA: a.Name + ".md",
RuleB: b.Name + ".md",
Tension: tension,
DoLineA: lineA,
DontLineB: lineB,
ScopeScore: scopeScore,
}
}
}
}
return nil
}
// extractActionWords returns a map of lowercase action words to their source line.
func extractActionWords(lines []string) map[string]string {
result := make(map[string]string)
for _, line := range lines {
words := tokenizeWords(line)
for _, w := range words {
w = strings.ToLower(w)
if len(w) >= 2 && !stopWords[w] {
if _, exists := result[w]; !exists {
result[w] = line
}
}
}
}
return result
}
// summarizeLine truncates a line for display in tension descriptions.
func summarizeLine(line string) string {
if len(line) > 40 {
return line[:37] + "..."
}
return line
}
// truncateTension ensures tension string fits in a table cell.
func truncateTension(s string) string {
if len(s) > 60 {
return s[:57] + "..."
}
return s
}
// FindMergeCandidates groups rules by keyword overlap using single-linkage clustering.
func FindMergeCandidates(rules []RuleFile, threshold float64) []MergeCandidate {
n := len(rules)
if n < 2 {
return nil
}
// Build adjacency: which pairs exceed the threshold
type pair struct {
i, j int
score float64
}
var pairs []pair
for i := 0; i < n; i++ {
for j := i + 1; j < n; j++ {
score := JaccardSimilarity(rules[i].Keywords, rules[j].Keywords)
if score >= threshold {
pairs = append(pairs, pair{i, j, score})
}
}
}
if len(pairs) == 0 {
return nil
}
// Union-Find for single-linkage clustering
parent := make([]int, n)
for i := range parent {
parent[i] = i
}
var find func(int) int
find = func(x int) int {
if parent[x] != x {
parent[x] = find(parent[x])
}
return parent[x]
}
union := func(x, y int) {
px, py := find(x), find(y)
if px != py {
parent[px] = py
}
}
for _, p := range pairs {
union(p.i, p.j)
}
// Collect groups
groups := make(map[int][]int)
for i := 0; i < n; i++ {
root := find(i)
groups[root] = append(groups[root], i)
}
// Build merge candidates (only groups with 2+ members)
var candidates []MergeCandidate
for _, members := range groups {
if len(members) < 2 {
continue
}
// Compute average pairwise score
var totalScore float64
var pairCount int
for mi := 0; mi < len(members); mi++ {
for mj := mi + 1; mj < len(members); mj++ {
totalScore += JaccardSimilarity(rules[members[mi]].Keywords, rules[members[mj]].Keywords)
pairCount++
}
}
avgScore := 0.0
if pairCount > 0 {
avgScore = totalScore / float64(pairCount)
}
// Collect rule names
var ruleNames []string
for _, idx := range members {
ruleNames = append(ruleNames, rules[idx].Name+".md")
}
sort.Strings(ruleNames)
// Find most frequent keyword for group label
label := findGroupLabel(rules, members)
candidates = append(candidates, MergeCandidate{
GroupLabel: label,
Rules: ruleNames,
Score: roundTo2(avgScore),
})
}
// Sort by score descending
sort.Slice(candidates, func(i, j int) bool {
return candidates[i].Score > candidates[j].Score
})
return candidates
}
// findGroupLabel finds the most common keyword across a group of rules.
func findGroupLabel(rules []RuleFile, indices []int) string {
freq := make(map[string]int)
for _, idx := range indices {
for _, kw := range rules[idx].Keywords {
freq[kw]++
}
}
bestWord := "rules"
bestCount := 0
for w, c := range freq {
if c > bestCount || (c == bestCount && w < bestWord) {
bestWord = w
bestCount = c
}
}
return bestWord
}
// roundTo2 rounds a float to 2 decimal places.
func roundTo2(f float64) float64 {
return float64(int(f*100+0.5)) / 100
}
// CompactRules merges a group of rules into a single composite markdown file.
func CompactRules(rules []RuleFile, groupLabel string) (string, error) {
if len(rules) == 0 {
return "", fmt.Errorf("no rules to compact")
}
// Collect and deduplicate Do/Don't lines
seenDo := make(map[string]bool)
seenDont := make(map[string]bool)
var doLines, dontLines []string
for _, r := range rules {
for _, line := range r.DoLines {
trimmed := strings.TrimSpace(line)
if trimmed != "" && !seenDo[trimmed] {
seenDo[trimmed] = true
doLines = append(doLines, trimmed)
}
}
for _, line := range r.DontLines {
trimmed := strings.TrimSpace(line)
if trimmed != "" && !seenDont[trimmed] {
seenDont[trimmed] = true
dontLines = append(dontLines, trimmed)
}
}
}
// Build composite
var sb strings.Builder
sb.WriteString("# ")
sb.WriteString(titleCase(groupLabel))
sb.WriteString("\n")
if len(doLines) > 0 {
sb.WriteString("**Do:** ")
sb.WriteString(strings.Join(doLines, ". "))
sb.WriteString("\n")
}
if len(dontLines) > 0 {
sb.WriteString("**Don't:** ")
sb.WriteString(strings.Join(dontLines, ". "))
sb.WriteString("\n")
}
// Source attribution
var sourceNames []string
for _, r := range rules {
sourceNames = append(sourceNames, r.Name+".md")
}
sb.WriteString("\nSource rules: ")
sb.WriteString(strings.Join(sourceNames, ", "))
sb.WriteString("\n")
return sb.String(), nil
}
// RunAudit is the top-level orchestrator for `bd rules audit`.
func RunAudit(rulesDir string, threshold float64) (*AuditResult, error) {
entries, err := os.ReadDir(rulesDir)
if err != nil {
if os.IsNotExist(err) {
return &AuditResult{}, nil
}
return nil, fmt.Errorf("read rules directory: %w", err)
}
var rules []RuleFile
totalTokens := 0
for _, entry := range entries {
if entry.IsDir() {
continue
}
if !strings.HasSuffix(entry.Name(), ".md") {
continue
}
path := filepath.Join(rulesDir, entry.Name())
rf, err := ParseRuleFile(path)
if err != nil {
// Skip files that can't be parsed
fmt.Fprintf(os.Stderr, "Warning: skipping %s: %v\n", entry.Name(), err)
continue
}
rules = append(rules, rf)
totalTokens += rf.Tokens
}
result := &AuditResult{
TotalRules: len(rules),
TokenEstimate: totalTokens,
}
if len(rules) < 2 {
result.Contradictions = []ContradictionReport{}
result.MergeCandidates = []MergeCandidate{}
result.Rules = rules
return result, nil
}
result.Contradictions = DetectContradictions(rules, 0.3)
result.MergeCandidates = FindMergeCandidates(rules, threshold)
result.Rules = rules
if result.Contradictions == nil {
result.Contradictions = []ContradictionReport{}
}
if result.MergeCandidates == nil {
result.MergeCandidates = []MergeCandidate{}
}
return result, nil
}
// --- Cobra Commands ---
var rulesCmd = &cobra.Command{
Use: "rules",
Short: "Audit and compact Claude rules",
GroupID: "maint",
}
var rulesAuditCmd = &cobra.Command{
Use: "audit",
Short: "Scan rules for contradictions and merge opportunities",
Run: runRulesAudit,
}
var rulesCompactCmd = &cobra.Command{
Use: "compact",
Short: "Merge related rules into composites",
Run: runRulesCompact,
}
func init() {
// Audit command flags
rulesAuditCmd.Flags().String("path", ".claude/rules/", "Path to rules directory")
rulesAuditCmd.Flags().Float64("threshold", 0.6, "Jaccard similarity threshold")
// Compact command flags
rulesCompactCmd.Flags().String("path", ".claude/rules/", "Path to rules directory")
rulesCompactCmd.Flags().StringSlice("group", nil, "Rule names to merge")
rulesCompactCmd.Flags().Bool("auto", false, "Apply audit suggestions")
rulesCompactCmd.Flags().Bool("dry-run", false, "Preview without applying")
// Register subcommands
rulesCmd.AddCommand(rulesAuditCmd)
rulesCmd.AddCommand(rulesCompactCmd)
rootCmd.AddCommand(rulesCmd)
}
func runRulesAudit(cmd *cobra.Command, args []string) {
rulesPath, _ := cmd.Flags().GetString("path")
threshold, _ := cmd.Flags().GetFloat64("threshold")
result, err := RunAudit(rulesPath, threshold)
if err != nil {
FatalErrorRespectJSON("rules audit failed: %v", err)
}
if jsonOutput {
outputJSON(result)
return
}
// Human-readable output
fmt.Printf("Rules Audit — %s\n", rulesPath)
fmt.Println(strings.Repeat("=", 60))
fmt.Println()
fmt.Println("Summary:")
fmt.Printf(" Total rules: %d\n", result.TotalRules)
fmt.Printf(" Token estimate: ~%d\n", result.TokenEstimate)
fmt.Printf(" Contradictions: %d\n", len(result.Contradictions))
mergeRuleCount := 0
for _, mc := range result.MergeCandidates {
mergeRuleCount += len(mc.Rules)
}
if len(result.MergeCandidates) > 0 {
fmt.Printf(" Merge candidates: %d groups (%d rules)\n",
len(result.MergeCandidates), mergeRuleCount)
} else {
fmt.Println(" Merge candidates: 0")
}
fmt.Println()
// Contradictions table
if len(result.Contradictions) > 0 {
fmt.Println("Contradictions:")
tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
fmt.Fprintf(tw, " Rule A\tRule B\tTension\n")
fmt.Fprintf(tw, " ------\t------\t-------\n")
for _, c := range result.Contradictions {
fmt.Fprintf(tw, " %s\t%s\t%s\n", c.RuleA, c.RuleB, c.Tension)
}
_ = tw.Flush()
fmt.Println()
}
// Merge candidates
if len(result.MergeCandidates) > 0 {
fmt.Printf("Merge Candidates (similarity > %.2f):\n", threshold)
for i, mc := range result.MergeCandidates {
fmt.Printf(" Group %d — %q (score: %.2f)\n", i+1, mc.GroupLabel, mc.Score)
for _, r := range mc.Rules {
fmt.Printf(" → %s\n", r)
}
suggested := strings.ReplaceAll(mc.GroupLabel, " ", "-") + ".md"
fmt.Printf(" Suggested: merge into %s\n\n", suggested)
}
fmt.Printf("Run `bd rules compact --auto` to apply suggested merges.\n")
}
}
func runRulesCompact(cmd *cobra.Command, args []string) {
CheckReadonly("rules compact")
rulesPath, _ := cmd.Flags().GetString("path")
groupNames, _ := cmd.Flags().GetStringSlice("group")
autoMode, _ := cmd.Flags().GetBool("auto")
dryRun, _ := cmd.Flags().GetBool("dry-run")
if !autoMode && len(groupNames) == 0 {
FatalErrorRespectJSON("specify --group <rule1,rule2,...> or --auto")
}
if autoMode {
// Run audit to get merge candidates
result, err := RunAudit(rulesPath, 0.6)
if err != nil {
FatalErrorRespectJSON("audit for auto-compact failed: %v", err)
}
if len(result.MergeCandidates) == 0 {
if jsonOutput {
outputJSON(map[string]string{"status": "no merge candidates found"})
} else {
fmt.Println("No merge candidates found.")
}
return
}
type compactResult struct {
Group string `json:"group"`
Output string `json:"output"`
Rules int `json:"rules_merged"`
Applied bool `json:"applied"`
}
var results []compactResult
for _, mc := range result.MergeCandidates {
// Parse the actual rule files for this group
var groupRules []RuleFile
for _, ruleName := range mc.Rules {
path := filepath.Join(rulesPath, ruleName)
rf, err := ParseRuleFile(path)
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: skipping %s: %v\n", ruleName, err)
continue
}
groupRules = append(groupRules, rf)
}
merged, err := CompactRules(groupRules, mc.GroupLabel)
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: compact group %q failed: %v\n", mc.GroupLabel, err)
continue
}
applied := false
if !dryRun {
outName := strings.ReplaceAll(mc.GroupLabel, " ", "-") + ".md"
outPath := filepath.Join(rulesPath, outName)
if err := os.WriteFile(outPath, []byte(merged), 0o600); err != nil {
fmt.Fprintf(os.Stderr, "Error writing %s: %v\n", outPath, err)
continue
}
// Delete source files
for _, ruleName := range mc.Rules {
srcPath := filepath.Join(rulesPath, ruleName)
_ = os.Remove(srcPath)
}
applied = true
}
results = append(results, compactResult{
Group: mc.GroupLabel,
Output: merged,
Rules: len(groupRules),
Applied: applied,
})
if !jsonOutput {
if dryRun {
fmt.Printf("Preview merge → %s.md:\n", mc.GroupLabel)
} else {
fmt.Printf("Merged → %s.md:\n", mc.GroupLabel)
}
fmt.Println(strings.Repeat("─", 40))
fmt.Print(merged)
fmt.Println(strings.Repeat("─", 40))
fmt.Println()
}
}
if jsonOutput {
outputJSON(results)
}
return
}
// Manual --group mode
var groupRules []RuleFile
for _, name := range groupNames {
if !strings.HasSuffix(name, ".md") {
name = name + ".md"
}
path := filepath.Join(rulesPath, name)
rf, err := ParseRuleFile(path)
if err != nil {
FatalErrorRespectJSON("cannot read rule %s: %v", name, err)
}
groupRules = append(groupRules, rf)
}
if len(groupRules) < 2 {
FatalErrorRespectJSON("need at least 2 rules to merge")
}
label := findGroupLabel(groupRules, makeRange(len(groupRules)))
merged, err := CompactRules(groupRules, label)
if err != nil {
FatalErrorRespectJSON("compact failed: %v", err)
}
if jsonOutput {
outputJSON(map[string]interface{}{
"group": label,
"output": merged,
"rules": len(groupRules),
"dry_run": dryRun,
})
return
}
outName := strings.ReplaceAll(label, " ", "-") + ".md"
if dryRun {
fmt.Printf("Preview merge → %s:\n", outName)
} else {
fmt.Printf("Merged → %s:\n", outName)
}
fmt.Println(strings.Repeat("─", 40))
fmt.Print(merged)
fmt.Println(strings.Repeat("─", 40))
if !dryRun {
outPath := filepath.Join(rulesPath, outName)
if err := os.WriteFile(outPath, []byte(merged), 0o600); err != nil {
FatalErrorRespectJSON("write merged file: %v", err)
}
for _, rf := range groupRules {
_ = os.Remove(rf.Path)
}
fmt.Printf("\nCreated %s, deleted %d source files.\n", outName, len(groupRules))
}
}
// titleCase capitalizes the first letter of each word.
func titleCase(s string) string {
words := strings.Fields(s)
for i, w := range words {
if len(w) > 0 {
words[i] = strings.ToUpper(w[:1]) + w[1:]
}
}
return strings.Join(words, " ")
}
// makeRange returns a slice [0, 1, ..., n-1].
func makeRange(n int) []int {
r := make([]int, n)
for i := range r {
r[i] = i
}
return r
}