mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
The agent discovery already parsed the `targets` frontmatter list into DiscoveredResource.Targets, but no agent sync path ever applied it, so an agent declared for one tool was still delivered to every agent-capable target. Agents have no shared schema across harnesses, so this gives authors a way to keep a per-tool variant of the same agent without cross-polluting targets. Applied in CLI sync (global and project), the dashboard sync handler, doctor's expected count and the target summary so all views agree. Refs #267
161 lines
4.7 KiB
Go
161 lines
4.7 KiB
Go
package sync
|
|
|
|
import (
|
|
"fmt"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/resource"
|
|
)
|
|
|
|
// 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
|
|
}
|
|
|
|
// FilterAgents filters discovered agents by include/exclude patterns.
|
|
// Agent FlatNames include the .md extension (e.g. "tutor.md"), but filter
|
|
// patterns are matched against the name without extension so users can write
|
|
// intuitive patterns like "tutor" or "team-*" instead of "tutor.md".
|
|
func FilterAgents(agents []resource.DiscoveredResource, include, exclude []string) ([]resource.DiscoveredResource, error) {
|
|
includePatterns, excludePatterns, err := normalizedFilterPatterns(include, exclude)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
filtered := make([]resource.DiscoveredResource, 0, len(agents))
|
|
for _, agent := range agents {
|
|
name := strings.TrimSuffix(agent.FlatName, ".md")
|
|
if shouldSyncFlatName(name, includePatterns, excludePatterns) {
|
|
filtered = append(filtered, agent)
|
|
}
|
|
}
|
|
|
|
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 {
|
|
_, matched := firstMatchingPattern(name, patterns)
|
|
return matched
|
|
}
|
|
|
|
// firstMatchingPattern returns the first pattern that matches name, or ("", false).
|
|
func firstMatchingPattern(name string, patterns []string) (string, bool) {
|
|
for _, pattern := range patterns {
|
|
matched, err := filepath.Match(pattern, name)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if matched {
|
|
return pattern, 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
|
|
}
|
|
|
|
// FilterAgentsByTarget removes agents whose frontmatter targets field does not
|
|
// include the given target name. Agents with nil Targets (no field declared)
|
|
// pass through unconditionally. Mirrors FilterSkillsByTarget.
|
|
func FilterAgentsByTarget(agents []resource.DiscoveredResource, targetName string) []resource.DiscoveredResource {
|
|
filtered := make([]resource.DiscoveredResource, 0, len(agents))
|
|
for _, agent := range agents {
|
|
if agent.Targets == nil {
|
|
filtered = append(filtered, agent)
|
|
continue
|
|
}
|
|
for _, t := range agent.Targets {
|
|
if config.MatchesTargetName(t, targetName) {
|
|
filtered = append(filtered, agent)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return filtered
|
|
}
|