Files
skillshare/internal/sync/filter.go
T
Willie a29e198725 feat: add target filter CLI, skill-level targets field, and Web UI support
- CLI: `target <name> --add-include/--add-exclude/--remove-include/--remove-exclude`
- SKILL.md `targets` frontmatter restricts sync to specified targets
- Cross-mode matching (e.g. "claude" matches "claude-code" project target)
- Web UI: inline filter editor on Targets page, target badges on Skills pages
- API: PATCH /api/targets/{name} for filter updates
- Fix drift detection in doctor/status/handler to account for skill-level targets
- `check` warns about unknown target names in skill-level targets field
- Docs: update skill-format, target command, configuration, creating-skills
2026-02-15 23:29:30 +08:00

113 lines
3.0 KiB
Go

package sync
import (
"fmt"
"path/filepath"
"strings"
"skillshare/internal/config"
)
// FilterSkills filters discovered skills by include/exclude patterns.
// Matching uses filepath.Match against DiscoveredSkill.FlatName.
func FilterSkills(skills []DiscoveredSkill, include, exclude []string) ([]DiscoveredSkill, error) {
includePatterns, excludePatterns, err := normalizedFilterPatterns(include, exclude)
if err != nil {
return nil, err
}
filtered := make([]DiscoveredSkill, 0, len(skills))
for _, skill := range skills {
if shouldSyncFlatName(skill.FlatName, includePatterns, excludePatterns) {
filtered = append(filtered, skill)
}
}
return filtered, nil
}
// ShouldSyncFlatName returns whether a single flat skill name should be managed
// by the given include/exclude filters.
func ShouldSyncFlatName(flatName string, include, exclude []string) (bool, error) {
includePatterns, excludePatterns, err := normalizedFilterPatterns(include, exclude)
if err != nil {
return false, err
}
return shouldSyncFlatName(flatName, includePatterns, excludePatterns), nil
}
func normalizedFilterPatterns(include, exclude []string) ([]string, []string, error) {
includePatterns, err := normalizePatterns(include)
if err != nil {
return nil, nil, fmt.Errorf("invalid include pattern: %w", err)
}
excludePatterns, err := normalizePatterns(exclude)
if err != nil {
return nil, nil, fmt.Errorf("invalid exclude pattern: %w", err)
}
return includePatterns, excludePatterns, nil
}
func normalizePatterns(patterns []string) ([]string, error) {
if len(patterns) == 0 {
return nil, nil
}
normalized := make([]string, 0, len(patterns))
for _, pattern := range patterns {
p := strings.TrimSpace(pattern)
if p == "" {
continue
}
if _, err := filepath.Match(p, ""); err != nil {
return nil, fmt.Errorf("%q: %w", p, err)
}
normalized = append(normalized, p)
}
return normalized, nil
}
func matchesAnyPattern(name string, patterns []string) bool {
for _, pattern := range patterns {
matched, err := filepath.Match(pattern, name)
if err != nil {
continue
}
if matched {
return true
}
}
return false
}
func shouldSyncFlatName(name string, includePatterns, excludePatterns []string) bool {
if len(includePatterns) > 0 && !matchesAnyPattern(name, includePatterns) {
return false
}
if len(excludePatterns) > 0 && matchesAnyPattern(name, excludePatterns) {
return false
}
return true
}
// FilterSkillsByTarget removes skills whose Targets field does not include
// the given target name. Skills with nil Targets (no field declared) pass
// through unconditionally.
func FilterSkillsByTarget(skills []DiscoveredSkill, targetName string) []DiscoveredSkill {
filtered := make([]DiscoveredSkill, 0, len(skills))
for _, skill := range skills {
if skill.Targets == nil {
filtered = append(filtered, skill)
continue
}
for _, t := range skill.Targets {
if config.MatchesTargetName(t, targetName) {
filtered = append(filtered, skill)
break
}
}
}
return filtered
}