chore: bump version to v0.8.0

Author: yeasy

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.0] - 2026-01-19
+
+### Added
+- **SkillHub Integration**: Added support for searching and installing skills from [SkillHub.club](https://www.skillhub.club).
+- **Slug Resolution**: intelligent resolution of SkillHub slugs to GitHub install URLs.
+
 ## [0.7.6] - 2026-01-19
 
 ### Changed

README.md

@@ -132,6 +132,7 @@ ASK comes pre-configured with trusted sources:
 | **MATLAB** | Official [matlab/skills](https://github.com/matlab/skills) |
 | **OpenAI** | Official [openai/skills](https://github.com/openai/skills) |
 | **Superpowers** | [obra/superpowers](https://github.com/obra/superpowers) core library |
+| **SkillHub** | [SkillHub.club](https://www.skillhub.club) |
 | **Vercel** | [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills) AI SDK skills |
 
 ## 📂 Installation Layout

cmd/install.go

@@ -14,6 +14,7 @@ import (
 	"github.com/yeasy/ask/internal/github"
 	"github.com/yeasy/ask/internal/repository"
 	"github.com/yeasy/ask/internal/skill"
+	"github.com/yeasy/ask/internal/skillhub"
 )
 
 // installCmd represents the install command
@@ -268,11 +269,66 @@ func installSingleSkill(input string, global bool, agents []string) error {
 		} else {
 			// It's a URL (e.g., https://github.com/xxx.git)
 			repoURL = input
+			if !strings.HasSuffix(repoURL, ".git") && !strings.HasPrefix(input, "http") {
+				// It might be a SkillHub slug (no standard user/repo format easily distinguishable from just a name,
+				// but usually slugs are kebab-case).
+				// We can try to resolve it via SkillHub if it doesn't look like a URL.
+				// However, `input` here in this block is usually "http..." because of `isURL` check?
+				// Wait, `isURL` is true for http/git prefix.
+			}
 			urlParts := strings.Split(strings.TrimSuffix(repoURL, ".git"), "/")
 			skillName = urlParts[len(urlParts)-1]
 		}
 	}
 
+	// SkillHub Slug Resolution
+	// If it wasn't a valid GitHub URL and resolved to just a "name" or if we want to support direct slug install:
+	// "ask skill install madappgang-claude-code-python"
+	// This falls into the "else" of "check if input matches configured repository name" in the caller `Run` loop?
+	// The `Run` loop checks configured repos. If not found, it passes `input` directly to `installSingleSkill`.
+	// So `installSingleSkill` receives "madappgang-claude-code-python".
+	// It goes to `else { Check if it's a direct URL or shorthand }`.
+	// `isURL` = false.
+	// `parts := strings.Split(input, "/")` -> len=1.
+	// So it falls to `else { Standard install: owner/repo }` ? NO.
+	// The code assumes input is "owner/repo" if it splits to 2?
+	// Wait, let's look at `installSingleSkill` logic again.
+
+	/*
+		if !isURL {
+			parts := strings.Split(input, "/")
+			if len(parts) > 2 {
+				// subdir
+			} else {
+				// owner/repo
+				repoURL = "https://github.com/" + input
+			}
+		}
+	*/
+
+	// If input is "slug", `parts` has len 1.
+	// The code `else { owner/repo }` logic (lines 262-267) assumes `len(parts) <= 2` handles owner/repo.
+	// But if `len(parts) == 1`, `repoURL` becomes `https://github.com/slug`.
+	// This is valid for GitHub user profile or org, but not a repo.
+
+	// We need to inject logic: if it looks like a slug (and not owner/repo), try SkillHub resolve.
+	// Or try SkillHub resolve if GitHub check fails?
+	// Doing it optimistically: if `strings.Contains(input, "/")` is false, it might be a slug.
+
+	if !strings.Contains(input, "/") && !strings.HasPrefix(input, "http") && !strings.HasPrefix(input, "git") {
+		// Try resolving as SkillHub slug
+		client := skillhub.NewClient()
+		if resolved, err := client.Resolve(input); err == nil {
+			fmt.Printf("Resolved SkillHub slug '%s' to '%s'\n", input, resolved)
+			// Recursive call or set variables?
+			// URL found (e.g. https://github.com/owner/repo#...)
+			// Recursing is easiest to handle the new URL format (which might be a tree URL).
+			return installSingleSkill(resolved, global, agents)
+		}
+		// If resolve fails, we proceed (it might be a local directory or something, though `ask` doesn't strictly support local paths yet in this function).
+		// Or it falls through to be treated as `github.com/input` which will fail.
+	}
+
 	// Use branch from version if not set from URL parsing
 	if branch == "" && version != "" {
 		branch = version

cmd/root.go

@@ -45,7 +45,7 @@ the Agent ecosystem.`,
 	// Uncomment the following line if your bare application
 	// has an action associated with it:
 	// Run: func(cmd *cobra.Command, args []string) { },
-	Version: "0.7.6",
+	Version: "0.8.0",
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.

cmd/search.go

@@ -9,6 +9,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/yeasy/ask/internal/config"
 	"github.com/yeasy/ask/internal/github"
+	"github.com/yeasy/ask/internal/repository"
 	"github.com/yeasy/ask/internal/ui"
 )
 
@@ -90,6 +91,8 @@ You can provide an optional keyword to filter results (e.g. 'browser', 'python')
 							repos = filtered
 						}
 					}
+				case "skillhub":
+					repos, err = repository.FetchSkillsFromSkillHub(keyword, "")
 				}
 
 				// Set source name for each repo

docs/skill-sources.md

@@ -17,6 +17,7 @@ ASK comes with six pre-configured sources:
 | **OpenAI** | Official | `openai` | OpenAI Official Skills |
 | **MATLAB** | Official | `matlab` | MATLAB Official Skills |
 | **Composio** | Community | `composio` | Awesome Claude Skills |
+| **SkillHub** | Service | `skills` | SkillHub.club Search Service |
 
 ---
 

internal/config/config.go

@@ -166,6 +166,11 @@ func DefaultConfig() Config {
 				Type: "dir",
 				URL:  "vercel-labs/agent-skills",
 			},
+			{
+				Name: "skillhub",
+				Type: "skillhub",
+				URL:  "skills",
+			},
 		},
 	}
 }

internal/repository/fetch.go

@@ -10,6 +10,7 @@ import (
 	"github.com/yeasy/ask/internal/git"
 	"github.com/yeasy/ask/internal/github"
 	"github.com/yeasy/ask/internal/skill"
+	"github.com/yeasy/ask/internal/skillhub"
 )
 
 // FetchSkills returns a list of skills available in the given repository
@@ -29,10 +30,11 @@ func FetchSkills(repo config.Repo) ([]github.Repository, error) {
 			return github.SearchDir(owner, name, path)
 		}
 		return nil, fmt.Errorf("invalid repository URL format: %s", repo.URL)
+	case "skillhub":
+		return FetchSkillsFromSkillHub("", "")
 	default:
 		return nil, fmt.Errorf("unknown repository type: %s", repo.Type)
 	}
-	}
 }
 
 // FetchSkillsViaGit clones a repo and discovers skills locally (no API needed)
@@ -113,3 +115,29 @@ func FetchSkillsViaGit(repo config.Repo) ([]github.Repository, error) {
 
 	return skills, nil
 }
+
+// FetchSkillsFromSkillHub searches SkillHub and converts results to internal format
+func FetchSkillsFromSkillHub(query string, category string) ([]github.Repository, error) {
+	client := skillhub.NewClient()
+	skills, err := client.Search(query)
+	if err != nil {
+		return nil, err
+	}
+
+	var repos []github.Repository
+	for _, s := range skills {
+		desc := s.Description
+		// Use slug as the install argument for now.
+		// Install command needs to detect if it's a slug and resolve it.
+		repo := github.Repository{
+			Name:            s.Name,
+			FullName:        s.Slug, // Storing slug in FullName for easier access
+			Description:     desc,
+			HTMLURL:         s.Slug, // Using Slug as the "URL" that install command receives
+			StargazersCount: s.Stars,
+			Source:          "skillhub",
+		}
+		repos = append(repos, repo)
+	}
+	return repos, nil
+}

internal/skillhub/client.go

@@ -0,0 +1,119 @@
+package skillhub
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// SearchURL is the endpoint for quick search
+const SearchURL = "https://www.skillhub.club/api/search/quick"
+
+// Skill represents a skill from SkillHub search
+type Skill struct {
+	ID          string   `json:"id"`
+	Name        string   `json:"name"`
+	Slug        string   `json:"slug"`
+	Description string   `json:"description"`
+	Category    string   `json:"category"`
+	Author      string   `json:"author"`
+	Stars       int      `json:"github_stars"`
+	Tags        []string `json:"tags"`
+}
+
+type searchResponse struct {
+	Skills []Skill `json:"skills"`
+}
+
+// Client handles interaction with SkillHub
+type Client struct {
+	HTTPClient *http.Client
+}
+
+// NewClient creates a new SkillHub client
+func NewClient() *Client {
+	return &Client{
+		HTTPClient: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+// Search searches for skills on SkillHub
+func (c *Client) Search(query string) ([]Skill, error) {
+	// If query is empty, use a generic term or handle differently,
+	// but the API seems to require a query param or returns empty.
+	// For "list all", perhaps we need the catalog API, but that requires auth.
+	// Let's rely on search for now.
+	if query == "" {
+		query = "agent" // default search term if none provided?
+	}
+
+	u, err := url.Parse(SearchURL)
+	if err != nil {
+		return nil, err
+	}
+	q := u.Query()
+	q.Set("q", query)
+	q.Set("limit", "50") // Fetch up to 50
+	u.RawQuery = q.Encode()
+
+	resp, err := c.HTTPClient.Get(u.String())
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("SkillHub API returned status: %d", resp.StatusCode)
+	}
+
+	var result searchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	return result.Skills, nil
+}
+
+// Resolve fetches the GitHub URL for a given skill slug
+func (c *Client) Resolve(slug string) (string, error) {
+	skillURL := fmt.Sprintf("https://www.skillhub.club/skills/%s", slug)
+	resp, err := c.HTTPClient.Get(skillURL)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("failed to fetch skill page: %d", resp.StatusCode)
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	// Look for GitHub link in the page content
+	// Use regex or string searching.
+	// We confirmed with curl that it appears as href="https://github.com/..."
+	// A simple regex:
+	re := regexp.MustCompile(`href="(https://github\.com/[^"]+)"`)
+	matches := re.FindStringSubmatch(string(body))
+
+	if len(matches) > 1 {
+		rawURL := matches[1]
+		// clean fragments (e.g. #plugins...)
+		if idx := strings.Index(rawURL, "#"); idx != -1 {
+			rawURL = rawURL[:idx]
+		}
+		return rawURL, nil
+	}
+
+	return "", fmt.Errorf("GitHub URL not found for skill: %s", slug)
+}

internal/skillhub/client_live_test.go

@@ -0,0 +1,39 @@
+package skillhub_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/yeasy/ask/internal/skillhub"
+)
+
+func TestSkillHubLive(t *testing.T) {
+	client := skillhub.NewClient()
+
+	// Test Search
+	fmt.Println("Searching for 'python'...")
+	skills, err := client.Search("python")
+	if err != nil {
+		t.Fatalf("Search failed: %v", err)
+	}
+	if len(skills) == 0 {
+		t.Fatal("No skills found for 'python'")
+	}
+	fmt.Printf("Found %d skills. First: %s (Slug: %s)\n", len(skills), skills[0].Name, skills[0].Slug)
+
+	// Test Resolve
+	slug := skills[0].Slug
+	fmt.Printf("Resolving slug '%s'...\n", slug)
+	url, err := client.Resolve(slug)
+	if err != nil {
+		t.Fatalf("Resolve failed: %v", err)
+	}
+	fmt.Printf("Resolved URL: %s\n", url)
+	if url == "" {
+		t.Fatal("Resolved URL is empty")
+	}
+	if strings.Contains(url, "#") {
+		t.Fatalf("Resolved URL should not contain fragment: %s", url)
+	}
+}