Files
skillshare/internal/server/handler_uninstall.go
T
Willie 115edf3f24 fix(server): correct project-mode gitignore path + prevent registry prune basename collision
P2-1: handleUninstallRepo and handleBatchUninstall used s.cfg.Source for
gitignore removal, but project-mode installs write to .skillshare/.gitignore
with a "skills/" prefix. Add gitignoreDir() helper that returns the correct
base directory per mode, and prefix entries in project mode.

P2-2: Registry prune used filepath.Base(repoName) to derive the legacy group,
causing sibling nested repos (e.g., org/_team-skills vs dept/_team-skills) to
collide on the same basename. Now uses exact Group match for nested repos and
restricts legacy basename matching to top-level repos only.

Tests added (15 new):
- resolveTrackedRepo: auto _ prefix, nested, already-prefixed, not-found,
  basename fallback
- Registry prune: full-path Group, nested members by prefix, sibling isolation
- Project-mode gitignore: single + batch uninstall
- updateSingle: basename fallback, not-found, regular skill priority
- cleanEmptyParents: multi-level, stops at non-empty, stops at boundary
2026-04-04 17:05:22 +08:00

247 lines
6.4 KiB
Go

package server
import (
"encoding/json"
"fmt"
"log"
"net/http"
"path/filepath"
"strings"
"time"
"skillshare/internal/config"
"skillshare/internal/git"
"skillshare/internal/install"
"skillshare/internal/sync"
"skillshare/internal/trash"
)
type batchUninstallRequest struct {
Names []string `json:"names"`
Force bool `json:"force"`
}
type batchUninstallItemResult struct {
Name string `json:"name"`
Success bool `json:"success"`
MovedToTrash bool `json:"movedToTrash,omitempty"`
Error string `json:"error,omitempty"`
}
type batchUninstallSummary struct {
Succeeded int `json:"succeeded"`
Failed int `json:"failed"`
}
func (s *Server) handleBatchUninstall(w http.ResponseWriter, r *http.Request) {
start := time.Now()
s.mu.Lock()
defer s.mu.Unlock()
var body batchUninstallRequest
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeError(w, http.StatusBadRequest, "invalid JSON body")
return
}
if len(body.Names) == 0 {
writeError(w, http.StatusBadRequest, "names array is required and must not be empty")
return
}
discovered, err := sync.DiscoverSourceSkills(s.cfg.Source)
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
flatNameMap := make(map[string]*sync.DiscoveredSkill, len(discovered))
baseNameMap := make(map[string]*sync.DiscoveredSkill, len(discovered))
for i := range discovered {
flatNameMap[discovered[i].FlatName] = &discovered[i]
baseNameMap[filepath.Base(discovered[i].SourcePath)] = &discovered[i]
}
results := make([]batchUninstallItemResult, 0, len(body.Names))
removedPaths := make(map[string]bool) // exact RelPaths of successfully removed items
var repoEntriesToRemove []string
succeeded, failed := 0, 0
var firstErr string
for _, name := range body.Names {
res := batchUninstallItemResult{Name: name}
if strings.HasPrefix(name, "_") {
repoPath := filepath.Join(s.cfg.Source, name)
if !install.IsGitRepo(repoPath) {
res.Success = false
res.Error = "not a tracked repository: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if dirty, _ := git.IsDirty(repoPath); !body.Force && dirty {
res.Success = false
res.Error = "uncommitted changes (use force to override)"
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if _, err := trash.MoveToTrash(repoPath, name, s.trashBase()); err != nil {
res.Success = false
res.Error = fmt.Sprintf("failed to trash repo: %v", err)
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
repoEntriesToRemove = append(repoEntriesToRemove, name)
removedPaths[name] = true // repo dir name is already the registry path
res.Success = true
res.MovedToTrash = true
results = append(results, res)
succeeded++
continue
}
skill := flatNameMap[name]
if skill == nil {
skill = baseNameMap[name]
}
if skill == nil {
res.Success = false
res.Error = "skill not found: " + name
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
if skill.IsInRepo {
res.Success = false
res.Error = "skill is inside a tracked repo; uninstall the repo instead"
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
baseName := filepath.Base(skill.SourcePath)
if _, err := trash.MoveToTrash(skill.SourcePath, baseName, s.trashBase()); err != nil {
res.Success = false
res.Error = fmt.Sprintf("failed to trash skill: %v", err)
results = append(results, res)
failed++
if firstErr == "" {
firstErr = res.Error
}
continue
}
removedPaths[skill.RelPath] = true // exact path for registry matching
res.Success = true
res.MovedToTrash = true
results = append(results, res)
succeeded++
}
if len(repoEntriesToRemove) > 0 {
gitDir := s.gitignoreDir()
entries := repoEntriesToRemove
if s.IsProjectMode() {
entries = make([]string, len(repoEntriesToRemove))
for i, e := range repoEntriesToRemove {
entries[i] = filepath.Join("skills", e)
}
}
if _, err := install.RemoveFromGitIgnoreBatch(gitDir, entries); err != nil {
log.Printf("warning: failed to clean .gitignore: %v", err)
}
}
if succeeded > 0 {
// removedPaths contains exact RelPaths (e.g. "frontend/vue/vue-best-practices")
// and repo dir names (e.g. "_team-skills"), collected during the uninstall loop.
filtered := make([]config.SkillEntry, 0, len(s.registry.Skills))
for _, entry := range s.registry.Skills {
fullName := entry.FullName()
if removedPaths[fullName] || removedPaths[entry.Name] {
continue
}
// Tracked repos: registry stores group without "_" prefix (e.g., group="team-skills"
// for repo dir "_team-skills"). Reconstruct the prefixed name to match removedPaths.
if entry.Group != "" && removedPaths["_"+entry.Group] {
continue
}
// When a group directory is uninstalled, also remove its member skills
memberOfRemoved := false
for rp := range removedPaths {
if strings.HasPrefix(fullName, rp+"/") {
memberOfRemoved = true
break
}
}
if memberOfRemoved {
continue
}
filtered = append(filtered, entry)
}
s.registry.Skills = filtered
regDir := s.cfg.RegistryDir
if s.IsProjectMode() {
regDir = filepath.Join(s.projectRoot, ".skillshare")
}
if err := s.registry.Save(regDir); err != nil {
log.Printf("warning: failed to save registry: %v", err)
}
if s.IsProjectMode() {
if rErr := config.ReconcileProjectSkills(
s.projectRoot, s.projectCfg, s.registry, s.cfg.Source); rErr != nil {
log.Printf("warning: failed to reconcile project skills config: %v", rErr)
}
} else {
if rErr := config.ReconcileGlobalSkills(s.cfg, s.registry); rErr != nil {
log.Printf("warning: failed to reconcile global skills config: %v", rErr)
}
}
}
status := "ok"
if failed > 0 && succeeded > 0 {
status = "partial"
} else if failed > 0 {
status = "error"
}
s.writeOpsLog("uninstall", status, start, map[string]any{
"names": body.Names,
"force": body.Force,
"scope": "ui",
"count": succeeded,
}, firstErr)
writeJSON(w, map[string]any{
"results": results,
"summary": batchUninstallSummary{
Succeeded: succeeded,
Failed: failed,
},
})
}