From bc01ff1b3e31506a41cf7aef1925fe6496708e30 Mon Sep 17 00:00:00 2001 From: Willie Date: Sat, 26 Sep 2026 21:02:28 +0800 Subject: [PATCH] feat(server): let tracked-repo skills take dashboard targets Setting targets on a skill inside a tracked repo used to be refused, because writing its SKILL.md leaves the clone dirty and `update` then skips the repo (or `--force` throws the setting away). Store those targets in the source's .metadata.json instead, keyed by the skill's path, and apply them at discovery over the frontmatter. The clone stays clean, `update` keeps working, and the setting survives it. Uninstalling a repo or skill drops its entries. Overrides are saved in the same lock section that writes them: every API request reloads the store from disk, so saving after unlocking could lose them, and saving outside the lock raced with other writers. Refs #295 --- internal/install/metadata.go | 8 + internal/install/target_overrides.go | 40 +++++ internal/install/target_overrides_test.go | 32 ++++ internal/server/handler_skills.go | 2 + internal/server/handler_skills_batch.go | 72 ++++++--- internal/server/handler_skills_batch_test.go | 138 ++++++++++++++++++ internal/server/handler_uninstall.go | 3 + .../sync/discover_target_overrides_test.go | 75 ++++++++++ internal/sync/discover_walk.go | 32 ++++ website/docs/reference/filtering.md | 2 + .../current/reference/filtering.md | 2 + .../current/reference/filtering.md | 2 + .../current/reference/filtering.md | 2 + .../current/reference/filtering.md | 2 + 14 files changed, 391 insertions(+), 21 deletions(-) create mode 100644 internal/install/target_overrides.go create mode 100644 internal/install/target_overrides_test.go create mode 100644 internal/sync/discover_target_overrides_test.go diff --git a/internal/install/metadata.go b/internal/install/metadata.go index 5d25c9add..6097f02ca 100644 --- a/internal/install/metadata.go +++ b/internal/install/metadata.go @@ -29,6 +29,11 @@ type MetadataStore struct { // accepted via --force. Kept outside Entries so it survives entry rewrites // and works for tracked repos that have no entry of their own. AuditAccepted map[string][]string `json:"audit_accepted,omitempty"` + // TargetOverrides maps the source-relative path of a skill inside a tracked + // repo to the targets set from the dashboard. Stored here so the repo's + // SKILL.md stays untouched and the clone stays clean for update. An empty + // list means "all targets"; a missing key falls back to the frontmatter. + TargetOverrides map[string][]string `json:"target_overrides,omitempty"` } // MetadataEntry merges the old SkillMeta + RegistryEntry fields. @@ -154,6 +159,9 @@ func (e *MetadataEntry) EffectiveKind() string { // Handles direct key matches, full-path matches (group/name), and group membership. // Works with both legacy basename keys and full-path keys. func (s *MetadataStore) RemoveByNames(names map[string]bool) { + for name := range names { + s.RemoveTargetOverrides(name) + } for _, key := range s.List() { entry := s.Get(key) fullName := KeyToRelPath(key, entry) diff --git a/internal/install/target_overrides.go b/internal/install/target_overrides.go new file mode 100644 index 000000000..8f811df23 --- /dev/null +++ b/internal/install/target_overrides.go @@ -0,0 +1,40 @@ +package install + +import ( + "path/filepath" + "strings" +) + +// SetTargetOverride records the targets for a skill inside a tracked repo, +// keyed by its source-relative path. An empty list is kept as an explicit +// "all targets" override so it still replaces the repo's frontmatter. +func (s *MetadataStore) SetTargetOverride(relPath string, targets []string) { + if s.TargetOverrides == nil { + s.TargetOverrides = make(map[string][]string) + } + if targets == nil { + targets = []string{} + } + s.TargetOverrides[filepath.ToSlash(relPath)] = targets +} + +// RemoveTargetOverrides drops the override for relPath and every skill below +// it, e.g. all skills of a tracked repo when the repo is uninstalled. +func (s *MetadataStore) RemoveTargetOverrides(relPath string) { + relPath = filepath.ToSlash(relPath) + for key := range s.TargetOverrides { + if key == relPath || strings.HasPrefix(key, relPath+"/") { + delete(s.TargetOverrides, key) + } + } +} + +// LoadTargetOverrides reads the target overrides from dir's .metadata.json +// without migrating or rewriting the file. Returns nil when there are none. +func LoadTargetOverrides(dir string) map[string][]string { + store, err := loadMetadataFile(dir) + if err != nil { + return nil + } + return store.TargetOverrides +} diff --git a/internal/install/target_overrides_test.go b/internal/install/target_overrides_test.go new file mode 100644 index 000000000..fd2826afb --- /dev/null +++ b/internal/install/target_overrides_test.go @@ -0,0 +1,32 @@ +package install + +import "testing" + +func TestTargetOverrides_EmptyListSurvivesSave(t *testing.T) { + dir := t.TempDir() + store := NewMetadataStore() + store.SetTargetOverride("_repo/skill", nil) + if err := store.Save(dir); err != nil { + t.Fatal(err) + } + + targets, ok := LoadTargetOverrides(dir)["_repo/skill"] + if !ok || len(targets) != 0 { + t.Errorf("want explicit empty override, got %v (present=%v)", targets, ok) + } +} + +func TestRemoveByNames_RemovesRepoTargetOverrides(t *testing.T) { + store := NewMetadataStore() + store.SetTargetOverride("_repo/skills/a", []string{"claude"}) + store.SetTargetOverride("_repo-other/b", []string{"cursor"}) + + store.RemoveByNames(map[string]bool{"_repo": true}) + + if _, ok := store.TargetOverrides["_repo/skills/a"]; ok { + t.Error("override of the uninstalled repo must be removed") + } + if _, ok := store.TargetOverrides["_repo-other/b"]; !ok { + t.Error("override of a sibling repo with a shared prefix must survive") + } +} diff --git a/internal/server/handler_skills.go b/internal/server/handler_skills.go index cf841f118..079440ea1 100644 --- a/internal/server/handler_skills.go +++ b/internal/server/handler_skills.go @@ -440,6 +440,8 @@ func (s *Server) handleUninstallRepo(w http.ResponseWriter, r *http.Request) { } } + s.skillsStore.RemoveTargetOverrides(repoName) + if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil { log.Printf("warning: failed to save metadata after repo uninstall: %v", err) } diff --git a/internal/server/handler_skills_batch.go b/internal/server/handler_skills_batch.go index 5dd608732..90d4ec71d 100644 --- a/internal/server/handler_skills_batch.go +++ b/internal/server/handler_skills_batch.go @@ -79,6 +79,12 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) { path string } var updatedSkills []updatedSkill + overridden := false + + var values []string + if req.Target != "" { + values = []string{req.Target} + } // Acquire write lock only for the file-write loop. s.mu.Lock() @@ -88,18 +94,22 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) { continue } - // Skip disabled skills and tracked-repo members - if d.Disabled || d.IsInRepo { + // Skip disabled skills + if d.Disabled { skipped++ continue } - skillMDPath := filepath.Join(d.SourcePath, "SKILL.md") - var values []string - if req.Target != "" { - values = []string{req.Target} + // Tracked-repo members keep their SKILL.md untouched so the clone + // stays clean for update; the targets live in .metadata.json. + if d.IsInRepo { + s.skillsStore.SetTargetOverride(relPath, values) + overridden = true + updated++ + continue } + skillMDPath := filepath.Join(d.SourcePath, "SKILL.md") if err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values); err != nil { errors = append(errors, d.FlatName+": "+err.Error()) continue @@ -111,14 +121,22 @@ func (s *Server) handleBatchSetTargets(w http.ResponseWriter, r *http.Request) { }) updated++ } + // Save the overrides before unlocking: every API request reloads skillsStore + // from disk, so an override left unsaved here can be dropped by the next one. + if overridden { + s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck + } s.mu.Unlock() // Recompute file hashes outside the lock so reads aren't blocked. for _, sk := range updatedSkills { s.skillsStore.RefreshHashes(sk.name, sk.path) } + // Save reads TargetOverrides, which other requests write under the lock. if len(updatedSkills) > 0 { + s.mu.Lock() s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck + s.mu.Unlock() } s.writeOpsLog("batch-set-targets", "ok", start, map[string]any{ @@ -172,29 +190,41 @@ func (s *Server) handleSetSkillTargets(w http.ResponseWriter, r *http.Request) { continue } - if d.IsInRepo { - writeError(w, http.StatusBadRequest, "cannot set target on tracked-repo skill; manage targets on the repo instead") - return - } - - skillMDPath := filepath.Join(d.SourcePath, "SKILL.md") var values []string if req.Target != "" { values = []string{req.Target} } - s.mu.Lock() - err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values) - s.mu.Unlock() + if d.IsInRepo { + // Tracked-repo members keep their SKILL.md untouched so the clone + // stays clean for update; the targets live in .metadata.json. + s.mu.Lock() + s.skillsStore.SetTargetOverride(d.RelPath, values) + err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) + s.mu.Unlock() - if err != nil { - writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error()) - return + if err != nil { + writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error()) + return + } + } else { + skillMDPath := filepath.Join(d.SourcePath, "SKILL.md") + + s.mu.Lock() + err := utils.SetFrontmatterList(skillMDPath, "metadata.targets", values) + s.mu.Unlock() + + if err != nil { + writeError(w, http.StatusInternalServerError, "failed to update skill: "+err.Error()) + return + } + + s.skillsStore.RefreshHashes(d.RelPath, d.SourcePath) + s.mu.Lock() + s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck + s.mu.Unlock() } - s.skillsStore.RefreshHashes(d.RelPath, d.SourcePath) - s.skillsStore.Save(s.cfg.EffectiveSkillsSource()) //nolint:errcheck - s.writeOpsLog("set-skill-targets", "ok", start, map[string]any{ "name": name, "target": req.Target, diff --git a/internal/server/handler_skills_batch_test.go b/internal/server/handler_skills_batch_test.go index 40d57d6a1..6f6905cdc 100644 --- a/internal/server/handler_skills_batch_test.go +++ b/internal/server/handler_skills_batch_test.go @@ -9,6 +9,8 @@ import ( "path/filepath" "testing" + "skillshare/internal/install" + ssync "skillshare/internal/sync" "skillshare/internal/utils" ) @@ -274,3 +276,139 @@ func TestHandleSetSkillTargets_NotFound(t *testing.T) { t.Errorf("expected 404, got %d: %s", rr.Code, rr.Body.String()) } } + +// --- Tracked-repo skills --- + +const trackedSkillRel = "_caveman/plugins/caveman/skills/cavecrew" + +// addTrackedRepoSkill creates a committed git repo "_caveman" holding one skill +// whose frontmatter targets cursor. +func addTrackedRepoSkill(t *testing.T, sourceDir string) string { + t.Helper() + repoDir := filepath.Join(sourceDir, "_caveman") + skillDir := filepath.Join(sourceDir, filepath.FromSlash(trackedSkillRel)) + os.MkdirAll(skillDir, 0755) + os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("---\nname: cavecrew\nmetadata:\n targets:\n - cursor\n---\n# cavecrew"), 0644) + initGitRepo(t, repoDir) + return repoDir +} + +// effectiveTargets returns the targets discovery reports for relPath. +func effectiveTargets(t *testing.T, sourceDir, relPath string) []string { + t.Helper() + skills, err := ssync.DiscoverSourceSkillsAll(sourceDir) + if err != nil { + t.Fatalf("discover: %v", err) + } + for _, d := range skills { + if d.RelPath == relPath { + return d.Targets + } + } + t.Fatalf("skill %s not discovered", relPath) + return nil +} + +func setSkillTarget(t *testing.T, s *Server, name, target string) { + t.Helper() + req := httptest.NewRequest(http.MethodPatch, "/api/resources/"+name+"/targets", bytes.NewBufferString(`{"target":"`+target+`"}`)) + req.SetPathValue("name", name) + rr := httptest.NewRecorder() + s.handleSetSkillTargets(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String()) + } +} + +func TestHandleSetSkillTargets_TrackedRepoSkill_OverridesWithoutDirtyingRepo(t *testing.T) { + s, src := newTestServer(t) + repoDir := addTrackedRepoSkill(t, src) + + setSkillTarget(t, s, "cavecrew", "claude") + + if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" { + t.Errorf("expected effective targets [claude], got %v", got) + } + if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 { + t.Errorf("expected clean tracked repo, got:\n%s", out) + } +} + +func TestHandleSetSkillTargets_TrackedRepoSkill_EmptyTargetMeansAll(t *testing.T) { + s, src := newTestServer(t) + addTrackedRepoSkill(t, src) + + setSkillTarget(t, s, "cavecrew", "") + + // Must not fall back to the repo's frontmatter [cursor]. + if got := effectiveTargets(t, src, trackedSkillRel); got != nil { + t.Errorf("expected all targets (nil), got %v", got) + } +} + +func TestHandleBatchSetTargets_TrackedRepoSkills(t *testing.T) { + s, src := newTestServer(t) + repoDir := addTrackedRepoSkill(t, src) + + req := httptest.NewRequest(http.MethodPost, "/api/resources/batch/targets", bytes.NewBufferString(`{"folder":"_caveman","target":"claude"}`)) + rr := httptest.NewRecorder() + s.handler.ServeHTTP(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String()) + } + + var resp batchSetTargetsResponse + if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil { + t.Fatalf("failed to decode response: %v", err) + } + if resp.Updated != 1 || resp.Skipped != 0 { + t.Errorf("expected updated=1 skipped=0, got updated=%d skipped=%d", resp.Updated, resp.Skipped) + } + if got := effectiveTargets(t, src, trackedSkillRel); len(got) != 1 || got[0] != "claude" { + t.Errorf("expected effective targets [claude], got %v", got) + } + if out := runGit(t, repoDir, "status", "--porcelain"); len(out) != 0 { + t.Errorf("expected clean tracked repo, got:\n%s", out) + } +} + +func TestHandleUninstallRepo_RemovesTargetOverrides(t *testing.T) { + s, src := newTestServer(t) + addTrackedRepoSkill(t, src) + setSkillTarget(t, s, "cavecrew", "claude") + s.skillsStore.SetTargetOverride("_other/skill", []string{"cursor"}) + + req := httptest.NewRequest(http.MethodDelete, "/api/repos/_caveman", nil) + req.SetPathValue("name", "_caveman") + rr := httptest.NewRecorder() + s.handleUninstallRepo(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String()) + } + + overrides := install.LoadTargetOverrides(src) + if _, ok := overrides[trackedSkillRel]; ok { + t.Errorf("expected override for %s to be removed, got %v", trackedSkillRel, overrides) + } + if _, ok := overrides["_other/skill"]; !ok { + t.Errorf("expected override of another repo to survive, got %v", overrides) + } +} + +func TestHandleBatchUninstall_RemovesTargetOverrides(t *testing.T) { + s, src := newTestServer(t) + addTrackedRepoSkill(t, src) + setSkillTarget(t, s, "cavecrew", "claude") + + b, _ := json.Marshal(batchUninstallRequest{Names: []string{"_caveman"}, Force: true}) + req := httptest.NewRequest(http.MethodPost, "/api/uninstall", bytes.NewReader(b)) + rr := httptest.NewRecorder() + s.handleBatchUninstall(rr, req) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d: %s", rr.Code, rr.Body.String()) + } + + if overrides := install.LoadTargetOverrides(src); len(overrides) != 0 { + t.Errorf("expected no target overrides after uninstall, got %v", overrides) + } +} diff --git a/internal/server/handler_uninstall.go b/internal/server/handler_uninstall.go index e8ac2f1dd..1f4c4392d 100644 --- a/internal/server/handler_uninstall.go +++ b/internal/server/handler_uninstall.go @@ -305,6 +305,9 @@ func (s *Server) handleBatchUninstallSkills(w http.ResponseWriter, body batchUni s.skillsStore.Remove(name) } } + for rp := range removedPaths { + s.skillsStore.RemoveTargetOverrides(rp) + } if err := s.skillsStore.Save(s.cfg.EffectiveSkillsSource()); err != nil { log.Printf("warning: failed to save metadata: %v", err) diff --git a/internal/sync/discover_target_overrides_test.go b/internal/sync/discover_target_overrides_test.go new file mode 100644 index 000000000..e1c5db73a --- /dev/null +++ b/internal/sync/discover_target_overrides_test.go @@ -0,0 +1,75 @@ +package sync + +import ( + "path/filepath" + "reflect" + "testing" + + "skillshare/internal/install" +) + +// setupTrackedSkills creates a tracked-repo skill and a regular skill, both +// targeting cursor in frontmatter, plus the given overrides in .metadata.json. +func setupTrackedSkills(t *testing.T, overrides map[string][]string) string { + t.Helper() + src := t.TempDir() + fm := "---\nname: s\nmetadata:\n targets:\n - cursor\n---\n# s" + writeSkillMD(t, filepath.Join(src, "_repo", "skills", "tracked"), fm) + writeSkillMD(t, filepath.Join(src, "local"), fm) + if overrides != nil { + store := install.NewMetadataStore() + for rel, targets := range overrides { + store.SetTargetOverride(rel, targets) + } + if err := store.Save(src); err != nil { + t.Fatal(err) + } + } + return src +} + +func discoveredTargets(t *testing.T, src string) map[string][]string { + t.Helper() + skills, err := DiscoverSourceSkills(src) + if err != nil { + t.Fatal(err) + } + got := map[string][]string{} + for _, s := range skills { + got[s.RelPath] = s.Targets + } + return got +} + +func TestDiscover_TargetOverrideReplacesTrackedFrontmatter(t *testing.T) { + src := setupTrackedSkills(t, map[string][]string{"_repo/skills/tracked": {"claude"}}) + + got := discoveredTargets(t, src) + if !reflect.DeepEqual(got["_repo/skills/tracked"], []string{"claude"}) { + t.Errorf("tracked skill: want [claude], got %v", got["_repo/skills/tracked"]) + } +} + +func TestDiscover_EmptyTargetOverrideMeansAllTargets(t *testing.T) { + src := setupTrackedSkills(t, map[string][]string{"_repo/skills/tracked": nil}) + + if got := discoveredTargets(t, src)["_repo/skills/tracked"]; got != nil { + t.Errorf("tracked skill: want nil (all targets), got %v", got) + } +} + +func TestDiscover_NoTargetOverrideUsesFrontmatter(t *testing.T) { + src := setupTrackedSkills(t, nil) + + if got := discoveredTargets(t, src)["_repo/skills/tracked"]; !reflect.DeepEqual(got, []string{"cursor"}) { + t.Errorf("tracked skill: want [cursor], got %v", got) + } +} + +func TestDiscover_TargetOverrideIgnoredForRegularSkill(t *testing.T) { + src := setupTrackedSkills(t, map[string][]string{"local": {"claude"}}) + + if got := discoveredTargets(t, src)["local"]; !reflect.DeepEqual(got, []string{"cursor"}) { + t.Errorf("regular skill: want frontmatter [cursor], got %v", got) + } +} diff --git a/internal/sync/discover_walk.go b/internal/sync/discover_walk.go index ec4f46942..c3d90cceb 100644 --- a/internal/sync/discover_walk.go +++ b/internal/sync/discover_walk.go @@ -9,6 +9,7 @@ import ( "sync" "skillshare/internal/config" + "skillshare/internal/install" "skillshare/internal/skillignore" "skillshare/internal/utils" ) @@ -323,5 +324,36 @@ func discoverSourceSkillsInternal(sourcePath string, opts discoverOptions) ([]Di return nil, nil, nil, fmt.Errorf("failed to walk source directory: %w", err) } + if opts.parseFrontmatter || opts.collectContext { + applyTargetOverrides(skills, walkRoot) + } + return skills, trackedRepos, stats, nil } + +// applyTargetOverrides replaces the frontmatter targets of tracked-repo skills +// with the overrides stored in the source's .metadata.json, so every consumer +// of discovery sees the same effective targets. An empty override means all +// targets. +func applyTargetOverrides(skills []DiscoveredSkill, sourceDir string) { + var overrides map[string][]string + loaded := false + for i := range skills { + if !skills[i].IsInRepo { + continue + } + if !loaded { + overrides = install.LoadTargetOverrides(sourceDir) + loaded = true + } + targets, ok := overrides[skills[i].RelPath] + if !ok { + continue + } + if len(targets) == 0 { + skills[i].Targets = nil + } else { + skills[i].Targets = append([]string(nil), targets...) + } + } +} diff --git a/website/docs/reference/filtering.md b/website/docs/reference/filtering.md index 57dbbf4f0..7d4a2447c 100644 --- a/website/docs/reference/filtering.md +++ b/website/docs/reference/filtering.md @@ -67,6 +67,8 @@ targets: [claude, cursor] **Behavior:** Whitelist — the skill only syncs to the listed targets. Omitting the field means sync to all targets. If both `metadata.targets` and top-level `targets` are present, `metadata.targets` wins. +**Tracked repos:** targets set in the dashboard for a skill inside a tracked repo are stored in the source's `.metadata.json` instead of its SKILL.md, so the clone stays clean and `update` keeps working. That setting takes precedence over the skill's `metadata.targets`. + **Aliases:** Target names support aliases. `claude` matches a target configured as `claude-code`. See [Supported Targets](/docs/reference/targets/supported-targets). 📖 [Skill format — targets field](/docs/understand/skill-format#targets) diff --git a/website/i18n/ja/docusaurus-plugin-content-docs/current/reference/filtering.md b/website/i18n/ja/docusaurus-plugin-content-docs/current/reference/filtering.md index ed6e2eebd..2817b6ff1 100644 --- a/website/i18n/ja/docusaurus-plugin-content-docs/current/reference/filtering.md +++ b/website/i18n/ja/docusaurus-plugin-content-docs/current/reference/filtering.md @@ -77,6 +77,8 @@ targets: [claude, cursor] 省略すると、すべての Target に Sync されます。`metadata.targets` とトップレベルの `targets` の両方が 存在する場合、`metadata.targets` が優先されます。 +**Tracked repo:** dashboard で tracked repo 内の Skill に設定した targets は、その SKILL.md ではなく source の `.metadata.json` に保存される。そのため clone はクリーンなままで、`update` も通常どおり動作する。この設定は Skill の `metadata.targets` より優先される。 + **エイリアス:** Target 名はエイリアスに対応しています。`claude` は `claude-code` として設定された Target に一致します。[対応する Target](/docs/reference/targets/supported-targets) を参照してください。 diff --git a/website/i18n/ko/docusaurus-plugin-content-docs/current/reference/filtering.md b/website/i18n/ko/docusaurus-plugin-content-docs/current/reference/filtering.md index d63ac7c6b..f0242043a 100644 --- a/website/i18n/ko/docusaurus-plugin-content-docs/current/reference/filtering.md +++ b/website/i18n/ko/docusaurus-plugin-content-docs/current/reference/filtering.md @@ -67,6 +67,8 @@ targets: [claude, cursor] **동작:** 화이트리스트 — 해당 Skill은 나열된 Target에만 Sync됩니다. 필드를 생략하면 모든 Target에 Sync됩니다. `metadata.targets`와 최상위 `targets`가 모두 존재하는 경우 `metadata.targets`가 우선합니다. +**Tracked repo:** dashboard에서 tracked repo 안의 skill에 설정한 targets는 해당 SKILL.md가 아니라 source의 `.metadata.json`에 저장됩니다. 그래서 clone은 깨끗하게 유지되고 `update`도 정상적으로 동작합니다. 이 설정은 skill의 `metadata.targets`보다 우선합니다. + **별칭(Alias):** Target 이름은 별칭을 지원합니다. `claude`는 `claude-code`로 설정된 Target과도 일치합니다. [Supported Targets](/docs/reference/targets/supported-targets)를 참고하세요. 📖 [Skill format — targets field](/docs/understand/skill-format#targets) diff --git a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/filtering.md b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/filtering.md index fb0a3d6cb..d2ef3c37f 100644 --- a/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/filtering.md +++ b/website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/reference/filtering.md @@ -67,6 +67,8 @@ targets: [claude, cursor] **行为:** 白名单——该 Skill 只会 sync 到列出的 Target。省略此字段表示 sync 到所有 Target。如果 `metadata.targets` 与顶层 `targets` 同时存在,`metadata.targets` 优先。 +**Tracked repos:** 在 dashboard 中为 tracked repo 内的 skill 设置的 targets 存储在 source 的 `.metadata.json` 中,而不是它的 SKILL.md,因此 clone 保持干净,`update` 也能照常运行。该设置优先于 skill 的 `metadata.targets`。 + **别名:** Target 名称支持别名。`claude` 会匹配配置为 `claude-code` 的 Target。参见 [Supported Targets](/docs/reference/targets/supported-targets)。 📖 [Skill format — targets 字段](/docs/understand/skill-format#targets) diff --git a/website/i18n/zh-Hant/docusaurus-plugin-content-docs/current/reference/filtering.md b/website/i18n/zh-Hant/docusaurus-plugin-content-docs/current/reference/filtering.md index ca0719a0f..fa9f0fc5e 100644 --- a/website/i18n/zh-Hant/docusaurus-plugin-content-docs/current/reference/filtering.md +++ b/website/i18n/zh-Hant/docusaurus-plugin-content-docs/current/reference/filtering.md @@ -67,6 +67,8 @@ targets: [claude, cursor] **行為:** 白名單機制 — 該 skill 只會 sync 到列出的 targets。省略此欄位表示 sync 到所有 targets。若 `metadata.targets` 與頂層的 `targets` 同時存在,以 `metadata.targets` 為準。 +**Tracked repos:** 在 dashboard 為 tracked repo 內的 skill 設定的 targets 會存在 source 的 `.metadata.json`,而不是它的 SKILL.md,因此 clone 保持乾淨,`update` 也能照常運作。這個設定優先於 skill 的 `metadata.targets`。 + **別名:** Target 名稱支援別名。`claude` 會符合設定為 `claude-code` 的 target。參見 [Supported Targets](/docs/reference/targets/supported-targets)。 📖 [Skill format — targets field](/docs/understand/skill-format#targets)