Files
skillshare/internal/install/install.go
T
Willie f2017a35aa feat: fix tracked repo discovery, improve naming, and unify project list
Sync discovery (DiscoverSourceSkills) was skipping all hidden directories
via utils.IsHidden(), causing skills inside .curated/ and .system/ (like
openai/skills) to be invisible after install. Now only .git is skipped,
matching the install-time discovery that was already fixed in 8ec5306.

Tracked repo naming now uses owner-repo format (e.g., _openai-skills
instead of _skills) via new Source.TrackName() method, preventing
collisions between repos that share the same basename.

Project-mode `list` command now uses recursive DiscoverSourceSkills()
instead of shallow os.ReadDir(), aligning with global list and web UI
behavior so tracked repo skills are visible everywhere.

Also includes CHANGELOG for v0.11.0, README updates, docs improvements,
and minor UI nav reorder.
2026-02-10 03:13:21 +08:00

879 lines
25 KiB
Go

package install
import (
"bytes"
"context"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"skillshare/internal/audit"
)
// InstallOptions configures the install behavior
type InstallOptions struct {
Name string // Override skill name
Force bool // Overwrite existing
DryRun bool // Preview only
Update bool // Update existing installation
Track bool // Install as tracked repository (preserves .git)
Skills []string // Select specific skills from multi-skill repo (comma-separated)
All bool // Install all discovered skills without prompting
Yes bool // Auto-accept all prompts (equivalent to --all for multi-skill repos)
}
// ShouldInstallAll returns true if all discovered skills should be installed without prompting.
func (o InstallOptions) ShouldInstallAll() bool { return o.All || o.Yes }
// HasSkillFilter returns true if specific skills were requested via --skill flag.
func (o InstallOptions) HasSkillFilter() bool { return len(o.Skills) > 0 }
// InstallResult reports the outcome of an installation
type InstallResult struct {
SkillName string
SkillPath string
Source string
Action string // "cloned", "copied", "updated", "skipped"
Warnings []string
}
// SkillInfo represents a discovered skill in a repository
type SkillInfo struct {
Name string // Skill name (directory name)
Path string // Relative path from repo root
}
// DiscoveryResult contains discovered skills from a repository
type DiscoveryResult struct {
RepoPath string // Temp directory where repo was cloned
Skills []SkillInfo // Discovered skills
Source *Source // Original source
}
// Install executes the installation from source to destination
func Install(source *Source, destPath string, opts InstallOptions) (*InstallResult, error) {
result := &InstallResult{
SkillName: source.Name,
Source: source.Raw,
}
// Check if destination exists
destInfo, destErr := os.Stat(destPath)
destExists := destErr == nil
if destExists {
if opts.Update {
return handleUpdate(source, destPath, result, opts)
}
if !opts.Force {
return nil, fmt.Errorf("skill '%s' already exists. To overwrite:\n skillshare install %s --force", source.Name, source.Raw)
}
// Force mode: remove existing
if !opts.DryRun {
if err := os.RemoveAll(destPath); err != nil {
return nil, fmt.Errorf("failed to remove existing skill: %w", err)
}
}
} else if destInfo != nil && !destInfo.IsDir() {
return nil, fmt.Errorf("destination exists but is not a directory")
}
result.SkillPath = destPath
// Execute installation based on source type
switch source.Type {
case SourceTypeLocalPath:
return installFromLocal(source, destPath, result, opts)
case SourceTypeGitHub, SourceTypeGitHTTPS, SourceTypeGitSSH:
return installFromGit(source, destPath, result, opts)
default:
return nil, fmt.Errorf("unsupported source type: %s", source.Type)
}
}
func installFromLocal(source *Source, destPath string, result *InstallResult, opts InstallOptions) (*InstallResult, error) {
// Verify source exists
srcInfo, err := os.Stat(source.Path)
if err != nil {
if os.IsNotExist(err) {
return nil, fmt.Errorf("source path does not exist: %s", source.Path)
}
return nil, fmt.Errorf("cannot access source path: %w", err)
}
if !srcInfo.IsDir() {
return nil, fmt.Errorf("source path is not a directory: %s", source.Path)
}
if opts.DryRun {
result.Action = "would copy"
return result, nil
}
// Copy directory
if err := copyDir(source.Path, destPath); err != nil {
return nil, fmt.Errorf("failed to copy skill: %w", err)
}
// Security audit
if err := auditInstalledSkill(destPath, result, opts.Force); err != nil {
return nil, err
}
// Write metadata
meta := NewMetaFromSource(source)
if err := WriteMeta(destPath, meta); err != nil {
result.Warnings = append(result.Warnings, fmt.Sprintf("failed to write metadata: %v", err))
}
// Check for SKILL.md
checkSkillFile(destPath, result)
result.Action = "copied"
return result, nil
}
func installFromGit(source *Source, destPath string, result *InstallResult, opts InstallOptions) (*InstallResult, error) {
// Check if git is available
if !isGitInstalled() {
return nil, fmt.Errorf("git is not installed or not in PATH")
}
// If subdir is specified, install directly
if source.HasSubdir() {
return installFromGitSubdir(source, destPath, result, opts)
}
// No subdir specified - this should be handled by DiscoverFromGit first
// If we get here, treat it as "install entire repo as one skill"
if opts.DryRun {
result.Action = "would clone"
return result, nil
}
// Clone the repository
if err := cloneRepo(source.CloneURL, destPath, true); err != nil {
return nil, fmt.Errorf("failed to clone repository: %w", err)
}
// Write metadata
meta := NewMetaFromSource(source)
// Try to get the commit hash
if hash, err := getGitCommit(destPath); err == nil {
meta.Version = hash
}
if err := WriteMeta(destPath, meta); err != nil {
result.Warnings = append(result.Warnings, fmt.Sprintf("failed to write metadata: %v", err))
}
// Check for SKILL.md
checkSkillFile(destPath, result)
result.Action = "cloned"
return result, nil
}
// DiscoverFromGit clones a repo and discovers available skills
func DiscoverFromGit(source *Source) (*DiscoveryResult, error) {
if !isGitInstalled() {
return nil, fmt.Errorf("git is not installed or not in PATH")
}
// Clone to temp directory
tempDir, err := os.MkdirTemp("", "skillshare-discover-*")
if err != nil {
return nil, fmt.Errorf("failed to create temp directory: %w", err)
}
repoPath := filepath.Join(tempDir, "repo")
if err := cloneRepo(source.CloneURL, repoPath, true); err != nil {
os.RemoveAll(tempDir)
return nil, fmt.Errorf("failed to clone repository: %w", err)
}
// Discover skills (include root to support single-skill-at-root repos)
skills := discoverSkills(repoPath, true)
// Fix root skill name: temp dir gives random name, use source.Name instead
for i := range skills {
if skills[i].Path == "." {
skills[i].Name = source.Name
break
}
}
return &DiscoveryResult{
RepoPath: tempDir,
Skills: skills,
Source: source,
}, nil
}
// discoverSkills finds directories containing SKILL.md
// If includeRoot is true, root-level SKILL.md is also included (with Path=".")
func discoverSkills(repoPath string, includeRoot bool) []SkillInfo {
var skills []SkillInfo
filepath.Walk(repoPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return nil
}
// Skip .git directory
if info.IsDir() && info.Name() == ".git" {
return filepath.SkipDir
}
// Check if this is a SKILL.md file
if !info.IsDir() && info.Name() == "SKILL.md" {
skillDir := filepath.Dir(path)
relPath, _ := filepath.Rel(repoPath, skillDir)
// Handle root level SKILL.md
if relPath == "." {
if includeRoot {
skills = append(skills, SkillInfo{
Name: filepath.Base(repoPath),
Path: ".",
})
}
} else {
skills = append(skills, SkillInfo{
Name: filepath.Base(skillDir),
Path: relPath,
})
}
}
return nil
})
return skills
}
// DiscoverFromGitSubdir clones a repo and discovers skills within a subdirectory
// Unlike DiscoverFromGit, this includes root-level SKILL.md of the subdir
func DiscoverFromGitSubdir(source *Source) (*DiscoveryResult, error) {
if !isGitInstalled() {
return nil, fmt.Errorf("git is not installed or not in PATH")
}
if !source.HasSubdir() {
return nil, fmt.Errorf("source has no subdirectory specified")
}
// Clone to temp directory
tempDir, err := os.MkdirTemp("", "skillshare-discover-*")
if err != nil {
return nil, fmt.Errorf("failed to create temp directory: %w", err)
}
repoPath := filepath.Join(tempDir, "repo")
if err := cloneRepo(source.CloneURL, repoPath, true); err != nil {
os.RemoveAll(tempDir)
return nil, fmt.Errorf("failed to clone repository: %w", err)
}
// Verify subdirectory exists
subdirPath := filepath.Join(repoPath, source.Subdir)
info, err := os.Stat(subdirPath)
if err != nil {
os.RemoveAll(tempDir)
if os.IsNotExist(err) {
return nil, fmt.Errorf("subdirectory '%s' does not exist in repository", source.Subdir)
}
return nil, fmt.Errorf("cannot access subdirectory: %w", err)
}
if !info.IsDir() {
os.RemoveAll(tempDir)
return nil, fmt.Errorf("'%s' is not a directory", source.Subdir)
}
// Discover skills within the subdirectory (include root)
skills := discoverSkills(subdirPath, true)
return &DiscoveryResult{
RepoPath: tempDir,
Skills: skills,
Source: source,
}, nil
}
// CleanupDiscovery removes the temporary directory from discovery
func CleanupDiscovery(result *DiscoveryResult) {
if result != nil && result.RepoPath != "" {
os.RemoveAll(result.RepoPath)
}
}
// InstallFromDiscovery installs a skill from a discovered repository
func InstallFromDiscovery(discovery *DiscoveryResult, skill SkillInfo, destPath string, opts InstallOptions) (*InstallResult, error) {
// Build full source path
// For subdir discovery, skill.Path is relative to the subdir
// For whole-repo discovery, skill.Path is relative to repo root
var fullSource string
var fullSubdir string
if skill.Path == "." {
// Root skill of a subdir discovery
fullSource = discovery.Source.Raw
fullSubdir = discovery.Source.Subdir
} else if discovery.Source.HasSubdir() {
// Nested skill within subdir discovery
fullSource = discovery.Source.Raw + "/" + skill.Path
fullSubdir = filepath.Join(discovery.Source.Subdir, skill.Path)
} else {
// Whole-repo discovery
fullSource = discovery.Source.Raw + "/" + skill.Path
fullSubdir = skill.Path
}
result := &InstallResult{
SkillName: skill.Name,
Source: fullSource,
}
// Check if destination exists
if _, err := os.Stat(destPath); err == nil {
if !opts.Force {
return nil, fmt.Errorf("already exists. To overwrite:\n skillshare install %s --force", fullSource)
}
if !opts.DryRun {
if err := os.RemoveAll(destPath); err != nil {
return nil, fmt.Errorf("failed to remove existing skill: %w", err)
}
}
}
result.SkillPath = destPath
if opts.DryRun {
result.Action = "would install"
return result, nil
}
// Determine source path in temp repo
var srcPath string
if discovery.Source.HasSubdir() {
// Subdir discovery: paths are relative to the subdir
if skill.Path == "." {
srcPath = filepath.Join(discovery.RepoPath, "repo", discovery.Source.Subdir)
} else {
srcPath = filepath.Join(discovery.RepoPath, "repo", discovery.Source.Subdir, skill.Path)
}
} else {
// Whole-repo discovery: paths are relative to repo root
srcPath = filepath.Join(discovery.RepoPath, "repo", skill.Path)
}
if err := copyDir(srcPath, destPath); err != nil {
return nil, fmt.Errorf("failed to copy skill: %w", err)
}
// Security audit
if err := auditInstalledSkill(destPath, result, opts.Force); err != nil {
return nil, err
}
// Write metadata
source := &Source{
Type: discovery.Source.Type,
Raw: fullSource,
CloneURL: discovery.Source.CloneURL,
Subdir: fullSubdir,
Name: skill.Name,
}
meta := NewMetaFromSource(source)
if hash, err := getGitCommit(filepath.Join(discovery.RepoPath, "repo")); err == nil {
meta.Version = hash
}
if err := WriteMeta(destPath, meta); err != nil {
result.Warnings = append(result.Warnings, fmt.Sprintf("failed to write metadata: %v", err))
}
result.Action = "installed"
return result, nil
}
func installFromGitSubdir(source *Source, destPath string, result *InstallResult, opts InstallOptions) (*InstallResult, error) {
if opts.DryRun {
result.Action = "would clone and extract"
return result, nil
}
// Clone to temp directory
tempDir, err := os.MkdirTemp("", "skillshare-install-*")
if err != nil {
return nil, fmt.Errorf("failed to create temp directory: %w", err)
}
defer os.RemoveAll(tempDir)
tempRepoPath := filepath.Join(tempDir, "repo")
if err := cloneRepo(source.CloneURL, tempRepoPath, true); err != nil {
return nil, fmt.Errorf("failed to clone repository: %w", err)
}
// Verify subdirectory exists
subdirPath := filepath.Join(tempRepoPath, source.Subdir)
info, err := os.Stat(subdirPath)
if err != nil {
if os.IsNotExist(err) {
return nil, fmt.Errorf("subdirectory '%s' does not exist in repository", source.Subdir)
}
return nil, fmt.Errorf("cannot access subdirectory: %w", err)
}
if !info.IsDir() {
return nil, fmt.Errorf("'%s' is not a directory", source.Subdir)
}
// Copy subdirectory to destination
if err := copyDir(subdirPath, destPath); err != nil {
return nil, fmt.Errorf("failed to copy skill: %w", err)
}
// Security audit
if err := auditInstalledSkill(destPath, result, opts.Force); err != nil {
return nil, err
}
// Write metadata
meta := NewMetaFromSource(source)
// Try to get the commit hash from temp repo
if hash, err := getGitCommit(tempRepoPath); err == nil {
meta.Version = hash
}
if err := WriteMeta(destPath, meta); err != nil {
result.Warnings = append(result.Warnings, fmt.Sprintf("failed to write metadata: %v", err))
}
// Check for SKILL.md
checkSkillFile(destPath, result)
result.Action = "cloned and extracted"
return result, nil
}
func handleUpdate(source *Source, destPath string, result *InstallResult, opts InstallOptions) (*InstallResult, error) {
result.SkillPath = destPath
// For git repos without subdir, try git pull
if source.IsGit() && !source.HasSubdir() && isGitRepo(destPath) {
if opts.DryRun {
result.Action = "would update (git pull)"
return result, nil
}
if err := gitPull(destPath); err != nil {
return nil, fmt.Errorf("failed to update: %w", err)
}
// Update metadata timestamp
meta, _ := ReadMeta(destPath)
if meta != nil {
if hash, err := getGitCommit(destPath); err == nil {
meta.Version = hash
}
WriteMeta(destPath, meta)
}
result.Action = "updated"
return result, nil
}
// For other cases (e.g., git with subdir), reinstall automatically
// --update implies willingness to reinstall when git pull is not possible
if opts.DryRun {
result.Action = "would reinstall from source"
return result, nil
}
// Safe update: install to temp first, then swap
tempDir, err := os.MkdirTemp("", "skillshare-update-*")
if err != nil {
return nil, fmt.Errorf("failed to create temp directory: %w", err)
}
defer os.RemoveAll(tempDir)
tempDest := filepath.Join(tempDir, "skill")
// Install to temp location first
_, err = Install(source, tempDest, InstallOptions{
Name: opts.Name,
Force: true,
DryRun: false,
Update: false,
})
if err != nil {
// Installation failed - original skill is preserved
return nil, err
}
// Installation succeeded - now safe to remove original and move new
if err := os.RemoveAll(destPath); err != nil {
return nil, fmt.Errorf("failed to remove existing skill: %w", err)
}
if err := os.Rename(tempDest, destPath); err != nil {
// Rename failed (possibly cross-device), try copy instead
if err := copyDir(tempDest, destPath); err != nil {
return nil, fmt.Errorf("failed to move updated skill: %w", err)
}
}
result.Action = "reinstalled"
return result, nil
}
// checkSkillFile adds a warning if SKILL.md is not found
func checkSkillFile(skillPath string, result *InstallResult) {
skillFile := filepath.Join(skillPath, "SKILL.md")
if _, err := os.Stat(skillFile); os.IsNotExist(err) {
result.Warnings = append(result.Warnings, "no SKILL.md found in skill directory")
}
}
// auditInstalledSkill scans the installed skill for security threats.
// If CRITICAL findings are detected and force is false, it removes the skill
// directory and returns an error. HIGH/MEDIUM findings are appended as warnings.
func auditInstalledSkill(destPath string, result *InstallResult, force bool) error {
scanResult, err := audit.ScanSkill(destPath)
if err != nil {
// Non-fatal: warn but don't block
result.Warnings = append(result.Warnings, fmt.Sprintf("audit scan error: %v", err))
return nil
}
if len(scanResult.Findings) == 0 {
return nil
}
// Build warning messages for all findings (include snippet for context)
for _, f := range scanResult.Findings {
msg := fmt.Sprintf("audit %s: %s (%s:%d)", f.Severity, f.Message, f.File, f.Line)
if f.Snippet != "" {
msg += fmt.Sprintf("\n %q", f.Snippet)
}
result.Warnings = append(result.Warnings, msg)
}
// CRITICAL findings block installation unless --force
if scanResult.HasCritical() && !force {
os.RemoveAll(destPath)
var details []string
for _, f := range scanResult.Findings {
if f.Severity == audit.SeverityCritical {
detail := fmt.Sprintf(" %s: %s (%s:%d)", f.Severity, f.Message, f.File, f.Line)
if f.Snippet != "" {
detail += fmt.Sprintf("\n %q", f.Snippet)
}
details = append(details, detail)
}
}
return fmt.Errorf("security audit failed — critical threats detected:\n%s\n\nUse --force to override", strings.Join(details, "\n"))
}
return nil
}
// isGitInstalled checks if git command is available
func isGitInstalled() bool {
_, err := exec.LookPath("git")
return err == nil
}
// IsGitRepo checks if path is a git repository
func IsGitRepo(path string) bool {
gitDir := filepath.Join(path, ".git")
info, err := os.Stat(gitDir)
return err == nil && info.IsDir()
}
// isGitRepo is an alias for IsGitRepo (for internal use)
func isGitRepo(path string) bool {
return IsGitRepo(path)
}
// gitCommandTimeout is the maximum time for a git network operation.
const gitCommandTimeout = 60 * time.Second
// gitCommand creates an exec.Cmd for git with GIT_TERMINAL_PROMPT=0
// to prevent interactive credential prompts that hang CLI spinners and web UI.
func gitCommand(ctx context.Context, args ...string) *exec.Cmd {
cmd := exec.CommandContext(ctx, "git", args...)
cmd.Env = append(os.Environ(),
"GIT_TERMINAL_PROMPT=0",
"GIT_ASKPASS=",
"SSH_ASKPASS=",
)
return cmd
}
// runGitCommand runs a git command with timeout, captures stderr for error messages.
func runGitCommand(args []string, dir string) error {
ctx, cancel := context.WithTimeout(context.Background(), gitCommandTimeout)
defer cancel()
cmd := gitCommand(ctx, args...)
if dir != "" {
cmd.Dir = dir
}
var stderr bytes.Buffer
cmd.Stderr = &stderr
err := cmd.Run()
if err != nil {
return wrapGitError(stderr.String(), err)
}
return nil
}
// wrapGitError inspects stderr output to produce actionable error messages.
func wrapGitError(stderr string, err error) error {
s := strings.TrimSpace(stderr)
if strings.Contains(s, "Authentication failed") ||
strings.Contains(s, "could not read Username") ||
strings.Contains(s, "terminal prompts disabled") {
return fmt.Errorf("authentication required — for private repos use SSH URL:\n git@<host>:<owner>/<repo>.git\n %s", s)
}
if s != "" {
return fmt.Errorf("%s", s)
}
return err
}
// cloneRepo performs a git clone (quiet mode for cleaner output)
func cloneRepo(url, destPath string, shallow bool) error {
args := []string{"clone", "--quiet"}
if shallow {
args = append(args, "--depth", "1")
}
args = append(args, url, destPath)
return runGitCommand(args, "")
}
// gitPull performs a git pull (quiet mode)
func gitPull(repoPath string) error {
return runGitCommand([]string{"pull", "--quiet"}, repoPath)
}
// getGitCommit returns the current HEAD commit hash
func getGitCommit(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
cmd.Dir = repoPath
output, err := cmd.Output()
if err != nil {
return "", err
}
return string(output[:len(output)-1]), nil // Remove trailing newline
}
// copyDir copies a directory recursively
func copyDir(src, dst string) error {
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, _ := filepath.Rel(src, path)
dstPath := filepath.Join(dst, relPath)
// Skip .git directory
if info.IsDir() && info.Name() == ".git" {
return filepath.SkipDir
}
if info.IsDir() {
return os.MkdirAll(dstPath, info.Mode())
}
return copyFile(path, dstPath)
})
}
// copyFile copies a single file
func copyFile(src, dst string) error {
srcFile, err := os.Open(src)
if err != nil {
return err
}
defer srcFile.Close()
srcInfo, err := srcFile.Stat()
if err != nil {
return err
}
dstFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, srcInfo.Mode())
if err != nil {
return err
}
defer dstFile.Close()
_, err = io.Copy(dstFile, srcFile)
return err
}
// TrackedRepoResult reports the outcome of a tracked repo installation
type TrackedRepoResult struct {
RepoName string // Name of the tracked repo (e.g., "_team-skills")
RepoPath string // Full path to the repo
SkillCount int // Number of skills discovered
Skills []string // Names of discovered skills
Action string // "cloned", "updated", "skipped"
Warnings []string
}
// InstallTrackedRepo clones a git repository as a tracked repo.
// The repo is cloned to @<repo-name>/ and preserves .git for updates.
func InstallTrackedRepo(source *Source, sourceDir string, opts InstallOptions) (*TrackedRepoResult, error) {
if !source.IsGit() {
return nil, fmt.Errorf("--track requires a git repository source")
}
// Determine repo name: opts.Name > TrackName (owner-repo) > source.Name
repoName := opts.Name
if repoName == "" {
repoName = source.TrackName()
}
if repoName == "" {
repoName = source.Name
}
// Prefix with _ to indicate tracked repo (avoid double prefix if user already added _)
trackedName := repoName
if !strings.HasPrefix(repoName, "_") {
trackedName = "_" + repoName
}
destPath := filepath.Join(sourceDir, trackedName)
result := &TrackedRepoResult{
RepoName: trackedName,
RepoPath: destPath,
}
// Check if already exists
if _, err := os.Stat(destPath); err == nil {
if opts.Update {
return updateTrackedRepo(destPath, result, opts)
}
if !opts.Force {
return nil, fmt.Errorf("tracked repo '%s' already exists. To overwrite:\n skillshare install %s --track --force", trackedName, source.Raw)
}
// Force mode - remove existing
if !opts.DryRun {
if err := os.RemoveAll(destPath); err != nil {
return nil, fmt.Errorf("failed to remove existing repo: %w", err)
}
}
}
if opts.DryRun {
result.Action = "would clone"
return result, nil
}
// Clone the repository (full clone, not shallow, to support updates)
if err := cloneRepoFull(source.CloneURL, destPath); err != nil {
return nil, fmt.Errorf("failed to clone repository: %w", err)
}
// Discover skills in the cloned repo (exclude root for tracked repos)
skills := discoverSkills(destPath, false)
result.SkillCount = len(skills)
for _, skill := range skills {
result.Skills = append(result.Skills, skill.Name)
}
if len(skills) == 0 {
result.Warnings = append(result.Warnings, "no SKILL.md files found in repository")
}
// Auto-add to .gitignore to prevent committing tracked repo contents
if err := UpdateGitIgnore(sourceDir, trackedName); err != nil {
result.Warnings = append(result.Warnings, fmt.Sprintf("failed to update .gitignore: %v", err))
}
result.Action = "cloned"
return result, nil
}
// updateTrackedRepo performs git pull on an existing tracked repo
func updateTrackedRepo(repoPath string, result *TrackedRepoResult, opts InstallOptions) (*TrackedRepoResult, error) {
if !isGitRepo(repoPath) {
return nil, fmt.Errorf("'%s' is not a git repository", repoPath)
}
if opts.DryRun {
result.Action = "would update (git pull)"
return result, nil
}
if err := gitPull(repoPath); err != nil {
return nil, fmt.Errorf("failed to update: %w", err)
}
// Re-discover skills (exclude root for tracked repos)
skills := discoverSkills(repoPath, false)
result.SkillCount = len(skills)
for _, skill := range skills {
result.Skills = append(result.Skills, skill.Name)
}
result.Action = "updated"
return result, nil
}
// cloneRepoFull performs a full git clone (quiet mode for cleaner output)
func cloneRepoFull(url, destPath string) error {
return runGitCommand([]string{"clone", "--quiet", url, destPath}, "")
}
// GetUpdatableSkills returns skill names that have metadata with a remote source
func GetUpdatableSkills(sourceDir string) ([]string, error) {
entries, err := os.ReadDir(sourceDir)
if err != nil {
return nil, err
}
var skills []string
for _, entry := range entries {
// Skip tracked repos (start with _) and non-directories
if !entry.IsDir() || (len(entry.Name()) > 0 && entry.Name()[0] == '_') {
continue
}
skillPath := filepath.Join(sourceDir, entry.Name())
meta, err := ReadMeta(skillPath)
if err != nil || meta == nil || meta.Source == "" {
continue // No metadata or no source, skip
}
skills = append(skills, entry.Name())
}
return skills, nil
}
// GetTrackedRepos returns a list of tracked repositories in the source directory
func GetTrackedRepos(sourceDir string) ([]string, error) {
entries, err := os.ReadDir(sourceDir)
if err != nil {
return nil, err
}
var repos []string
for _, entry := range entries {
if entry.IsDir() && len(entry.Name()) > 0 && entry.Name()[0] == '_' {
// Verify it's actually a git repo
gitDir := filepath.Join(sourceDir, entry.Name(), ".git")
if _, err := os.Stat(gitDir); err == nil {
repos = append(repos, entry.Name())
}
}
}
return repos, nil
}