From 9eabb29ba2faf17ff35780bebee2d6f4d4eb42ba Mon Sep 17 00:00:00 2001 From: Willie Date: Tue, 3 Mar 2026 02:51:12 +0800 Subject: [PATCH] feat(audit): add CompiledRule type with ListRules and PatternSummary Introduce rules_list.go with exported types and functions for listing all audit rules with their enable/disable status and source layer (builtin/global/project). Includes PatternSummary for grouped stats and UniquePatterns for pattern enumeration. Disabled rules appear in listings with Enabled=false so UIs can display toggle state. --- internal/audit/rules_list.go | 202 ++++++++++++++++++++++++++++++ internal/audit/rules_list_test.go | 83 ++++++++++++ 2 files changed, 285 insertions(+) create mode 100644 internal/audit/rules_list.go create mode 100644 internal/audit/rules_list_test.go diff --git a/internal/audit/rules_list.go b/internal/audit/rules_list.go new file mode 100644 index 000000000..478a0f1a1 --- /dev/null +++ b/internal/audit/rules_list.go @@ -0,0 +1,202 @@ +package audit + +import ( + "path/filepath" + "sort" +) + +// CompiledRule is the public view of a rule for listing/display. +type CompiledRule struct { + ID string `json:"id"` + Severity string `json:"severity"` + Pattern string `json:"pattern"` + Message string `json:"message"` + Regex string `json:"regex"` + Exclude string `json:"exclude,omitempty"` + Enabled bool `json:"enabled"` + Source string `json:"source"` // "builtin", "global", "project" +} + +// PatternGroup summarizes rules grouped by pattern name. +type PatternGroup struct { + Pattern string `json:"pattern"` + Total int `json:"total"` + Enabled int `json:"enabled"` + Disabled int `json:"disabled"` + MaxSeverity string `json:"maxSeverity"` +} + +// ListRules returns all rules (builtin + global overrides) with enable/disable status. +// Disabled rules are included with Enabled=false. +func ListRules() ([]CompiledRule, error) { + base := builtinYAML() + globalUser, err := loadUserRules(globalAuditRulesPath()) + if err != nil { + return nil, err + } + return buildCompiledList(base, globalUser, nil) +} + +// ListRulesWithProject returns all rules (builtin + global + project overrides) +// with enable/disable status. +func ListRulesWithProject(projectRoot string) ([]CompiledRule, error) { + base := builtinYAML() + globalUser, err := loadUserRules(globalAuditRulesPath()) + if err != nil { + return nil, err + } + projectPath := filepath.Join(projectRoot, ".skillshare", "audit-rules.yaml") + projectUser, err := loadUserRules(projectPath) + if err != nil { + return nil, err + } + return buildCompiledList(base, globalUser, projectUser) +} + +// buildCompiledList merges base, global user, and project user rule layers +// and produces the full listing. Disabled rules are included with Enabled=false. +func buildCompiledList(base, globalUser, projectUser []yamlRule) ([]CompiledRule, error) { + // Track which IDs are overridden at each layer. + globalOverrides := indexByID(globalUser) + projectOverrides := indexByID(projectUser) + + // Track pattern-level directives at each layer. + globalPatternOverrides := patternLevelSet(globalUser) + projectPatternOverrides := patternLevelSet(projectUser) + + // Merge layers: base → global → project + merged := base + if globalUser != nil { + merged = mergeYAMLRules(merged, globalUser) + } + if projectUser != nil { + merged = mergeYAMLRules(merged, projectUser) + } + + var result []CompiledRule + for _, yr := range merged { + // Skip pattern-level directives — they're not real rules. + if isPatternLevel(yr) { + continue + } + + enabled := yr.Enabled == nil || *yr.Enabled + sev := yr.Severity + if s, err := NormalizeSeverity(sev); err == nil { + sev = s + } + + source := determineSource(yr.ID, yr.Pattern, globalOverrides, projectOverrides, + globalPatternOverrides, projectPatternOverrides) + + result = append(result, CompiledRule{ + ID: yr.ID, + Severity: sev, + Pattern: yr.Pattern, + Message: yr.Message, + Regex: yr.Regex, + Exclude: yr.Exclude, + Enabled: enabled, + Source: source, + }) + } + return result, nil +} + +// determineSource returns the source layer for a rule. +func determineSource(id, pattern string, + globalIDs, projectIDs map[string]bool, + globalPatterns, projectPatterns map[string]bool, +) string { + // Project-level ID override takes precedence. + if projectIDs[id] { + return "project" + } + // Project-level pattern override. + if projectPatterns[pattern] { + return "project" + } + // Global-level ID override. + if globalIDs[id] { + return "global" + } + // Global-level pattern override. + if globalPatterns[pattern] { + return "global" + } + return "builtin" +} + +// indexByID returns a set of rule IDs present in a yamlRule slice (non-pattern-level only). +func indexByID(rules []yamlRule) map[string]bool { + m := make(map[string]bool) + for _, r := range rules { + if !isPatternLevel(r) && r.ID != "" { + m[r.ID] = true + } + } + return m +} + +// patternLevelSet returns the set of pattern names targeted by pattern-level directives. +func patternLevelSet(rules []yamlRule) map[string]bool { + m := make(map[string]bool) + for _, r := range rules { + if isPatternLevel(r) { + m[r.Pattern] = true + } + } + return m +} + +// PatternSummary groups rules by pattern and returns summary stats. +// Sorted by severity (most severe first), then by pattern name. +func PatternSummary(rules []CompiledRule) []PatternGroup { + groups := make(map[string]*PatternGroup) + for _, r := range rules { + g, ok := groups[r.Pattern] + if !ok { + g = &PatternGroup{Pattern: r.Pattern, MaxSeverity: r.Severity} + groups[r.Pattern] = g + } + g.Total++ + if r.Enabled { + g.Enabled++ + } else { + g.Disabled++ + } + if SeverityRank(r.Severity) < SeverityRank(g.MaxSeverity) { + g.MaxSeverity = r.Severity + } + } + + result := make([]PatternGroup, 0, len(groups)) + for _, g := range groups { + result = append(result, *g) + } + sort.Slice(result, func(i, j int) bool { + ri := SeverityRank(result[i].MaxSeverity) + rj := SeverityRank(result[j].MaxSeverity) + if ri != rj { + return ri < rj + } + return result[i].Pattern < result[j].Pattern + }) + return result +} + +// UniquePatterns returns a sorted list of distinct pattern names from builtin rules. +func UniquePatterns() []string { + seen := make(map[string]bool) + for _, yr := range builtinYAML() { + if yr.Pattern != "" { + seen[yr.Pattern] = true + } + } + result := make([]string, 0, len(seen)) + for p := range seen { + result = append(result, p) + } + sort.Strings(result) + return result +} diff --git a/internal/audit/rules_list_test.go b/internal/audit/rules_list_test.go new file mode 100644 index 000000000..401bf8da6 --- /dev/null +++ b/internal/audit/rules_list_test.go @@ -0,0 +1,83 @@ +package audit + +import ( + "os" + "path/filepath" + "testing" +) + +func TestListRules_ReturnsAllBuiltin(t *testing.T) { + resetForTest() + os.Setenv("SKILLSHARE_CONFIG", filepath.Join(t.TempDir(), "config.yaml")) + defer os.Unsetenv("SKILLSHARE_CONFIG") + + rules, err := ListRules() + if err != nil { + t.Fatalf("ListRules: %v", err) + } + if len(rules) == 0 { + t.Fatal("expected rules, got 0") + } + for _, r := range rules { + if !r.Enabled { + t.Fatalf("rule %s should be enabled", r.ID) + } + if r.Source != "builtin" { + t.Fatalf("rule %s should be builtin, got %s", r.ID, r.Source) + } + } +} + +func TestListRules_WithDisabledRule(t *testing.T) { + resetForTest() + dir := t.TempDir() + os.Setenv("SKILLSHARE_CONFIG", filepath.Join(dir, "config.yaml")) + defer os.Unsetenv("SKILLSHARE_CONFIG") + + rulesYAML := "rules:\n - id: prompt-injection-0\n enabled: false\n" + os.WriteFile(filepath.Join(dir, "audit-rules.yaml"), []byte(rulesYAML), 0644) + + rules, err := ListRules() + if err != nil { + t.Fatalf("ListRules: %v", err) + } + found := false + for _, r := range rules { + if r.ID == "prompt-injection-0" { + found = true + if r.Enabled { + t.Fatal("prompt-injection-0 should be disabled") + } + if r.Source != "global" { + t.Fatalf("expected source=global, got %s", r.Source) + } + } + } + if !found { + t.Fatal("prompt-injection-0 not found in list") + } +} + +func TestListRules_PatternGroups(t *testing.T) { + resetForTest() + os.Setenv("SKILLSHARE_CONFIG", filepath.Join(t.TempDir(), "config.yaml")) + defer os.Unsetenv("SKILLSHARE_CONFIG") + + rules, err := ListRules() + if err != nil { + t.Fatalf("ListRules: %v", err) + } + patterns := PatternSummary(rules) + if len(patterns) == 0 { + t.Fatal("expected pattern groups") + } + var caCount int + for _, p := range patterns { + if p.Pattern == "credential-access" { + caCount = p.Total + } + } + if caCount < 50 { + t.Fatalf("credential-access should have 50+ rules, got %d", caCount) + } +}