feat: add managed rules and hooks parity

Author: salmonumbrella

cmd/skillshare/backup.go

@@ -372,8 +372,12 @@ func cmdRestore(args []string) error {
 		return err
 	}
 
-	target, exists := cfg.Targets[targetName]
-	if !exists {
+	resolvedTargetName, target, err := resolveConfiguredRestoreTarget(cfg.Targets, targetName)
+	if err != nil {
+		return err
+	}
+	sc := target.SkillsConfig()
+	if sc.Path == "" {
 		return fmt.Errorf("target '%s' not found in config", targetName)
 	}
 
@@ -384,20 +388,18 @@ func cmdRestore(args []string) error {
 	}
 
 	opts := backup.RestoreOptions{Force: force}
-
-	sc := target.SkillsConfig()
 	if dryRun {
 		if fromTimestamp != "" {
-			return previewRestoreFromTimestamp(targetName, sc.Path, fromTimestamp, opts)
+			return previewRestoreFromTimestamp(resolvedTargetName, sc.Path, fromTimestamp, opts)
 		}
-		return previewRestoreFromLatest(targetName, sc.Path, opts)
+		return previewRestoreFromLatest(resolvedTargetName, sc.Path, opts)
 	}
 
 	var restoreErr error
 	if fromTimestamp != "" {
-		restoreErr = restoreFromTimestamp(targetName, sc.Path, fromTimestamp, opts)
+		restoreErr = restoreFromTimestamp(resolvedTargetName, sc.Path, fromTimestamp, opts)
 	} else {
-		restoreErr = restoreFromLatest(targetName, sc.Path, opts)
+		restoreErr = restoreFromLatest(resolvedTargetName, sc.Path, opts)
 	}
 
 	e := oplog.NewEntry("restore", statusFromErr(restoreErr), time.Since(start))
@@ -413,6 +415,22 @@ func cmdRestore(args []string) error {
 	return restoreErr
 }
 
+func resolveConfiguredRestoreTarget(targets map[string]config.TargetConfig, requested string) (string, config.TargetConfig, error) {
+	candidates := make([]string, 0, len(targets))
+	for name := range targets {
+		candidates = append(candidates, name)
+	}
+
+	resolvedName, ok, err := config.ResolveTargetNameCandidate(requested, candidates)
+	if err != nil {
+		return "", config.TargetConfig{}, err
+	}
+	if !ok {
+		return "", config.TargetConfig{}, nil
+	}
+	return resolvedName, targets[resolvedName], nil
+}
+
 // restoreTUIDispatch handles the no-args TUI flow for restore.
 func restoreTUIDispatch(noTUI bool) error {
 	cfg, err := config.Load()

cmd/skillshare/backup_restore_test.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"path/filepath"
+	"testing"
+
+	"skillshare/internal/backup"
+	"skillshare/internal/config"
+)
+
+func TestCmdRestore_AliasRestoresCanonicalLatestBackup(t *testing.T) {
+	home := setupGlobalResourceTestEnv(t)
+	sourceDir := filepath.Join(t.TempDir(), "source")
+	mustAddSkill(t, sourceDir, "alpha")
+
+	cfg := &config.Config{
+		Source: sourceDir,
+		Targets: map[string]config.TargetConfig{
+			"universal": {Path: filepath.Join(home, ".agents", "skills")},
+		},
+	}
+	if err := cfg.Save(); err != nil {
+		t.Fatalf("save config: %v", err)
+	}
+
+	mustWriteFile(t, filepath.Join(backup.BackupDir(), "2025-03-20_18-45-00", "universal", "alpha", "SKILL.md"), "# Alpha\n")
+
+	if err := cmdRestore([]string{"agents", "--force"}); err != nil {
+		t.Fatalf("cmdRestore(alias latest) error = %v", err)
+	}
+
+	assertFileContent(t, filepath.Join(home, ".agents", "skills", "alpha", "SKILL.md"), "# Alpha\n")
+}

cmd/skillshare/collect.go

@@ -82,8 +82,15 @@ func cmdCollect(args []string) error {
 
 	applyModeLabel(mode)
 
+	resources, rest, err := parseResourceFlags(rest, resourceFlagOptions{
+		defaultSelection: resourceSelection{skills: true},
+	})
+	if err != nil {
+		return err
+	}
+
 	if mode == modeProject {
-		err := cmdCollectProject(rest, cwd)
+		err := cmdCollectProject(rest, cwd, resources)
 		logCollectOp(config.ProjectConfigPath(cwd), start, err)
 		return err
 	}
@@ -116,6 +123,20 @@ func cmdCollect(args []string) error {
 		force = true
 	}
 
+	if resources.onlyManaged() {
+		if targetName != "" || collectAll {
+			return fmt.Errorf("target selection is only supported when collecting skills")
+		}
+		if jsonOutput {
+			result, collectErr := collectManagedResources("", resources, dryRun, force)
+			logCollectOp(config.ConfigPath(), start, collectErr)
+			return collectOutputJSON(result, dryRun, start, collectErr)
+		}
+		err := executeManagedCollect("", resources, dryRun, force)
+		logCollectOp(config.ConfigPath(), start, err)
+		return err
+	}
+
 	cfg, err := config.Load()
 	if err != nil {
 		if jsonOutput {
@@ -146,48 +167,83 @@ func cmdCollect(args []string) error {
 		if sp != nil {
 			sp.Success("No local skills found")
 		}
-		if jsonOutput {
-			return collectOutputJSON(nil, dryRun, start, nil)
+		if !resources.includesManaged() {
+			if jsonOutput {
+				return collectOutputJSON(nil, dryRun, start, nil)
+			}
+			return nil
 		}
-		return nil
-	}
-
-	if sp != nil {
+	} else if sp != nil {
 		sp.Success(fmt.Sprintf("Found %d local skill(s)", len(allLocalSkills)))
 		displayLocalSkills(allLocalSkills)
 	}
 
 	if dryRun {
 		if jsonOutput {
-			names := make([]string, len(allLocalSkills))
-			for i, s := range allLocalSkills {
-				names[i] = s.Name
+			var result *sync.PullResult
+			if len(allLocalSkills) > 0 {
+				names := make([]string, len(allLocalSkills))
+				for i, s := range allLocalSkills {
+					names[i] = s.Name
+				}
+				result = &sync.PullResult{Pulled: names, Failed: make(map[string]error)}
+			}
+			if resources.includesManaged() {
+				managedResult, managedErr := collectManagedResources("", resources, true, force)
+				result = mergePullResults(result, managedResult)
+				logCollectOp(config.ConfigPath(), start, managedErr)
+				return collectOutputJSON(result, true, start, managedErr)
 			}
 			logCollectOp(config.ConfigPath(), start, nil)
-			return collectOutputJSON(&sync.PullResult{Pulled: names}, true, start, nil)
+			return collectOutputJSON(result, true, start, nil)
+		}
+		if resources.includesManaged() {
+			err := executeManagedCollect("", resources, true, force)
+			logCollectOp(config.ConfigPath(), start, err)
+			return err
 		}
 		ui.Info("Dry run - no changes made")
 		return nil
 	}
 
 	// Confirm unless --force (JSON implies force)
-	if !force {
+	if !force && len(allLocalSkills) > 0 {
 		if !confirmCollect() {
 			ui.Info("Cancelled")
 			return nil
 		}
 	}
 
 	if jsonOutput {
-		result, collectErr := sync.PullSkills(allLocalSkills, cfg.Source, sync.PullOptions{
-			DryRun: dryRun,
-			Force:  force,
-		})
-		logCollectOp(config.ConfigPath(), start, collectErr)
-		return collectOutputJSON(result, dryRun, start, collectErr)
+		var result *sync.PullResult
+		var collectErr error
+		if len(allLocalSkills) > 0 {
+			result, collectErr = sync.PullSkills(allLocalSkills, cfg.Source, sync.PullOptions{
+				DryRun: dryRun,
+				Force:  force,
+			})
+			collectErr = combineCollectErrors(collectErr, collectResultError(result))
+		}
+		var managedErr error
+		if resources.includesManaged() {
+			var managedResult *sync.PullResult
+			managedResult, managedErr = collectManagedResources("", resources, dryRun, force)
+			result = mergePullResults(result, managedResult)
+		}
+		err = combineCollectErrors(collectErr, managedErr)
+		logCollectOp(config.ConfigPath(), start, err)
+		return collectOutputJSON(result, dryRun, start, err)
 	}
 
-	err = executeCollect(allLocalSkills, cfg.Source, dryRun, force)
+	var collectErr error
+	if len(allLocalSkills) > 0 {
+		collectErr = executeCollect(allLocalSkills, cfg.Source, dryRun, force)
+	}
+	var managedErr error
+	if resources.includesManaged() {
+		managedErr = executeManagedCollect("", resources, dryRun, force)
+	}
+	err = combineCollectErrors(collectErr, managedErr)
 	logCollectOp(config.ConfigPath(), start, err)
 	return err
 }
@@ -261,7 +317,7 @@ func executeCollect(skills []sync.LocalSkillInfo, source string, dryRun, force b
 		showCollectNextSteps(source)
 	}
 
-	return nil
+	return collectResultError(result)
 }
 
 // collectOutputJSON converts a collect result to JSON and writes to stdout.
@@ -290,12 +346,58 @@ func showCollectNextSteps(source string) {
 	ui.Info("Run 'skillshare sync' to distribute to all targets")
 
 	// Check if source has git
+	if strings.TrimSpace(source) == "" {
+		return
+	}
 	gitDir := filepath.Join(source, ".git")
 	if _, err := os.Stat(gitDir); err == nil {
 		ui.Info("Commit changes: cd %s && git add . && git commit", source)
 	}
 }
 
+func mergePullResults(left, right *sync.PullResult) *sync.PullResult {
+	switch {
+	case left == nil:
+		return right
+	case right == nil:
+		return left
+	}
+
+	merged := &sync.PullResult{
+		Pulled:  append(append([]string{}, left.Pulled...), right.Pulled...),
+		Skipped: append(append([]string{}, left.Skipped...), right.Skipped...),
+		Failed:  make(map[string]error, len(left.Failed)+len(right.Failed)),
+	}
+	for name, err := range left.Failed {
+		merged.Failed[name] = err
+	}
+	for name, err := range right.Failed {
+		merged.Failed[name] = err
+	}
+	return merged
+}
+
+func collectResultError(result *sync.PullResult) error {
+	if result == nil || len(result.Failed) == 0 {
+		return nil
+	}
+	return fmt.Errorf("some skills failed to collect")
+}
+
+func combineCollectErrors(errs ...error) error {
+	messages := make([]string, 0, len(errs))
+	for _, err := range errs {
+		if err == nil {
+			continue
+		}
+		messages = append(messages, err.Error())
+	}
+	if len(messages) == 0 {
+		return nil
+	}
+	return fmt.Errorf("%s", strings.Join(messages, "; "))
+}
+
 func printCollectHelp() {
 	fmt.Println(`Usage: skillshare collect [target] [options]
 

cmd/skillshare/collect_project.go

@@ -8,7 +8,7 @@ import (
 	"skillshare/internal/ui"
 )
 
-func cmdCollectProject(args []string, root string) error {
+func cmdCollectProject(args []string, root string, resources resourceSelection) error {
 	dryRun := false
 	force := false
 	collectAll := false
@@ -29,6 +29,13 @@ func cmdCollectProject(args []string, root string) error {
 		}
 	}
 
+	if resources.onlyManaged() {
+		if targetName != "" || collectAll {
+			return fmt.Errorf("target selection is only supported when collecting skills")
+		}
+		return executeManagedCollect(root, resources, dryRun, force)
+	}
+
 	runtime, err := loadProjectRuntime(root)
 	if err != nil {
 		return err
@@ -47,25 +54,42 @@ func cmdCollectProject(args []string, root string) error {
 	allLocalSkills := collectLocalSkills(targets, runtime.sourcePath, "")
 	if len(allLocalSkills) == 0 {
 		sp.Success("No local skills found")
+		if resources.includesManaged() {
+			if dryRun {
+				return executeManagedCollect(root, resources, true, force)
+			}
+			return executeManagedCollect(root, resources, false, force)
+		}
 		return nil
 	}
 	sp.Success(fmt.Sprintf("Found %d local skill(s)", len(allLocalSkills)))
 
 	displayLocalSkills(allLocalSkills)
 
 	if dryRun {
+		if resources.includesManaged() {
+			return executeManagedCollect(root, resources, true, force)
+		}
 		ui.Info("Dry run - no changes made")
 		return nil
 	}
 
-	if !force {
+	if !force && len(allLocalSkills) > 0 {
 		if !confirmCollect() {
 			ui.Info("Cancelled")
 			return nil
 		}
 	}
 
-	return executeCollect(allLocalSkills, runtime.sourcePath, dryRun, force)
+	var collectErr error
+	if len(allLocalSkills) > 0 {
+		collectErr = executeCollect(allLocalSkills, runtime.sourcePath, dryRun, force)
+	}
+	var managedErr error
+	if resources.includesManaged() {
+		managedErr = executeManagedCollect(root, resources, dryRun, force)
+	}
+	return combineCollectErrors(collectErr, managedErr)
 }
 
 func selectCollectProjectTargets(runtime *projectRuntime, targetName string, collectAll bool) (map[string]config.TargetConfig, error) {

cmd/skillshare/init_test.go

@@ -36,6 +36,7 @@ func TestCommitSourceFiles_CommitFailureIsReturned(t *testing.T) {
 	runGit(t, repo, "init")
 	runGit(t, repo, "config", "user.email", "test@example.com")
 	runGit(t, repo, "config", "user.name", "Test User")
+	runGit(t, repo, "config", "core.hooksPath", ".git/hooks")
 
 	hookPath := filepath.Join(repo, ".git", "hooks", "pre-commit")
 	if err := os.WriteFile(hookPath, []byte("#!/bin/sh\nexit 1\n"), 0o755); err != nil {