diff --git a/.claude/skills/skill-recommender/SKILL.md b/.claude/skills/skill-recommender/SKILL.md new file mode 100644 index 0000000..f56e64d --- /dev/null +++ b/.claude/skills/skill-recommender/SKILL.md @@ -0,0 +1,49 @@ +--- +name: skill-recommender +description: Analyze current project's tech stack and recommend relevant skills, plugins, agents, and MCP servers from the plum ecosystem data +triggers: + - recommend skills + - what plugins should I use + - suggest tools + - find relevant skills + - what should I install + - discover plugins + - recommend plugins + - what tools should I use +--- + +# Skill Recommender + +Analyze the current project's tech stack and recommend relevant ecosystem tools. + +## Instructions + +1. Determine the target directory. Default to the current working directory unless the user specifies a different path. + +2. Run the recommender script: + ```bash + python3 scripts/ecosystem/recommend.py [TARGET_DIR] --markdown + ``` + + **Flags:** + - `--markdown` — Pre-formatted markdown tables (default for this skill) + - `--top N` — Show more results per category (default: 5). Use `--top 10` if the user asks for more. + - `--exclude-no-install` — Only show entries with install commands. Use when the user asks "what should I install" or wants actionable results. + - `--min-score N` — Adjust score threshold (default: 35). Lower to 20 for broader results. + - `--pretty` — Pretty-print JSON (use instead of `--markdown` if you need to parse the output programmatically) + +3. Present the markdown output directly to the user. The script handles formatting, grouping, and deduplication. + +4. Tags prefixed with `~` in the output are inferred from descriptions (not explicit in the ecosystem data). Mention this if the user asks about tag accuracy. + +5. After the tables, add a brief "You might also like" section with 1-2 contextual suggestions based on the stack (e.g., "Since you're using BubbleTea, check out the Charm ecosystem tools" or "Consider adding a CI/CD plugin for your GitHub Actions workflow"). + +6. If the script fails, fall back to reading the ecosystem JSON files directly from `ecosystem/` and match entries that share at least one tag with the project's detected stack. Do not recommend entries with zero tag overlap. + +## Notes + +- Zero external dependencies (Python stdlib only) +- Scoring: 70% relevance (bidirectional tag match, geometric mean) + 30% popularity (log-scaled with recency boost) +- Hard gate: entries with zero matching tags (explicit or inferred) are excluded +- Deduplication: same repo across sources is shown once (highest score wins) +- Default: top 5 per category, minimum score 35 diff --git a/.gitignore b/.gitignore index 360edcf..be43658 100644 --- a/.gitignore +++ b/.gitignore @@ -38,3 +38,6 @@ docs/tmp # Local MCP server config (may contain secrets) .mcp.json + +# Python cache +__pycache__/ diff --git a/docs/handoff/2026-02-15-unified-facets-handoff.md b/docs/handoff/2026-02-15-unified-facets-handoff.md new file mode 100644 index 0000000..94776fe --- /dev/null +++ b/docs/handoff/2026-02-15-unified-facets-handoff.md @@ -0,0 +1,193 @@ +# Unified Facets & Quick Actions Handoff + +**Date:** 2026-02-15 +**Branch:** `feature/unified-facets-and-quick-actions` +**Status:** Feature complete, needs merge to `main` + cleanup + +--- + +## Context + +Plum is a TUI plugin manager for Claude Code. This branch implements a comprehensive UX overhaul: unified facets (combined filter/sort tabs) and a context-aware quick action menu (Space key overlay). It builds on top of the TUI UX improvements already merged to main (marketplace autocomplete, dynamic filters — PR #9). + +## Key Documents + +| Document | Location | Purpose | +|----------|----------|---------| +| Implementation Log | `docs/buzzminson/2026-02-04-tui-ux-improvements-tasks-5-11.md` | Full implementation details, timeline, decisions | +| Previous Handoff | `docs/handoff/2026-01-15-cli-commands-handoff.md` | Prior CLI commands feature (for format reference) | + +--- + +## What's Done (3 commits ahead of `main`) + +### Commit 1: `4db6259` — feat: implement unified facets and quick action menu +The core feature. ~1000 lines added across 7 files. + +### Commit 2: `51523a5` — refactor: maximus code review fixes +Post-review cleanup: division-by-zero guards on empty facets, URL validation before `exec.Command`, consolidated facet cycling with `cycleFacet()` helper, extracted marketplace filtering helpers, removed duplicate utilities. + +### Commit 3: `b920b64` — fix: same-name plugins from different marketplaces +Changed dedup key from plugin name to `plugin@marketplace`, so plugins with the same name from different sources both appear. + +### Features Implemented + +**Unified Facets Model:** +- Plugin list facets: `All | Discover | Ready | Installed ║ ↑Name | ↑Updated | ↑Stars` +- Marketplace list facets: `↑Plugins | ↑Stars | ↑Name | ↑Updated` +- Tab/Shift+Tab cycles through all facets (filters AND sorts) +- Visual `║` separator between filter and sort sections + +**Quick Action Menu (Space key):** +- Context-aware overlay with keyboard shortcut hints +- Plugin List: [m] Browse Marketplaces, [f] Filter by Marketplace, [s] Sort, [v] Toggle View, [u] Refresh +- Plugin Detail (Discoverable): [i] 2-Step Install, [m] Marketplace, [p] Plugin, [g] GitHub, [l] Link +- Plugin Detail (Installed): [o] Open Local, [p] Copy Path, [g] GitHub, [l] Link +- Marketplace List: [Enter] View, [f] Show Plugins, [i] Copy Install, [g] GitHub + +**2-Step Install Copy (i key):** +- On discoverable plugins, copies formatted multi-step install commands to clipboard + +**Marketplace Picker Enhancement (Shift+F):** +- Alternative trigger for `@` marketplace autocomplete from the plugin list + +**Same-Name Plugin Fix:** +- `internal/config/config.go` — dedup key changed from `pluginName` to `pluginName@marketplaceName` + +### Files Changed (vs `main`) + +| File | Lines | What Changed | +|------|-------|-------------| +| `internal/ui/quick_menu.go` | +281 (new) | Complete quick menu system | +| `internal/ui/model.go` | +418/-341 | Facet types, navigation methods, sort logic | +| `internal/ui/view.go` | +228/-66 | Unified facet rendering, quick menu overlay | +| `internal/ui/update.go` | +182/-90 | Space/Shift+F/i key handlers, quick menu keys | +| `internal/ui/marketplace_view.go` | +61/-34 | Facet-based sort tab rendering | +| `internal/ui/help_view.go` | +17/-17 | Updated help text for new shortcuts | +| `internal/config/config.go` | +37/-37 | Plugin dedup fix (name@marketplace) | +| `docs/buzzminson/...` | +307 (new) | Implementation log | + +--- + +## Current State (verified 2026-02-15) + +| Check | Status | +|-------|--------| +| `go build ./cmd/plum` | Passes | +| `go test ./...` | All pass (8 packages) | +| `golangci-lint run` | 1 pre-existing warning only (gocyclo on `handleListKeys`, complexity 45 > 40) | +| Branch pushed to origin | Up to date | +| PR open | No PR created yet | + +### Uncommitted Local Changes + +1. **`.gitignore`** — Added `.mcp.json` entry (local MCP server config). This is a good change, should be committed. +2. **`cmd/debug-plugins/`** — A debug utility for listing loaded plugins and checking dedup. Used during the same-name bug fix. Can be committed if useful for debugging, or removed. + +--- + +## What Needs to Be Done + +### Required: Merge to Main + +1. **Decide on uncommitted files:** + - Commit `.gitignore` change (recommended — keeps `.mcp.json` out of repo) + - Either commit `cmd/debug-plugins/` as a dev tool or delete it +2. **Create PR** from `feature/unified-facets-and-quick-actions` → `main` +3. **Merge PR** + +### Recommended: Known Issues to Address + +1. **`handleListKeys` complexity (gocyclo 45 > 40):** + - Pre-existing but getting worse as features are added + - Refactor into sub-handlers: `handleListNavigation()`, `handleListActions()`, `handleListInput()` + - This would bring each handler well under the 40 threshold + +2. **Plugin sort modes `↑Updated` and `↑Stars` are stubs:** + - `applyPluginSort()` in `model.go:543-551` currently sorts ALL modes by name only + - Need `UpdatedAt` and `Stars` fields on `plugin.Plugin` struct + - Populate from marketplace manifest or GitHub API + - Then implement real sort comparisons + +3. **Quick menu doesn't dim background:** + - `renderQuickMenuOverlay()` receives `baseView` but ignores it (`_ = baseView`) + - Menu renders centered but the underlying view is not dimmed/blurred + - Would need line-by-line overlay composition for proper overlay effect + +### Optional: Future Enhancements (from backlog) + +4. Marketplace filter facets (All | Installed | Cached | Available) +5. Integration tests for facet navigation and quick menu +6. README update with animated GIF demos of new features +7. Quick action icons/emojis for visual distinction + +--- + +## Architecture Notes + +### Facets System + +``` +Facet struct { + Type FacetType // FacetFilter or FacetSort + DisplayName string // e.g. "All", "↑Name" + FilterMode FilterMode // For filter facets + SortMode PluginSortMode // For plugin sort facets + MarketplaceSort MarketplaceSortMode // For marketplace sort facets + IsActive bool +} +``` + +- `GetPluginFacets()` returns 7 facets (4 filters + 3 sorts) +- `GetMarketplaceFacets()` returns 4 sort facets +- `cycleFacet(direction)` handles Tab/Shift+Tab navigation +- Filters and sorts are independent — you can filter AND sort simultaneously + +### Quick Menu System + +- `ViewQuickMenu` state overlays on top of `quickMenuPreviousView` +- `GetQuickActionsForView()` dispatches based on what view the menu was opened from +- `ExecuteQuickMenuAction()` synthesizes a `tea.KeyMsg` to reuse existing key handlers +- Direct letter key presses in the menu execute immediately (no need to navigate + Enter) + +### Plugin Dedup (config.go) + +``` +// Before (bug): plugins deduped by name → same-name plugins from different marketplaces hidden +seenPluginNames[mp.Name] + +// After (fix): deduped by full qualified name → both shown +seenPluginFullNames[mp.Name + "@" + marketplaceName] +``` + +--- + +## Pre-Push Checklist + +Always run before pushing: +```bash +golangci-lint run --timeout=5m +go test ./... +go build -o ./plum ./cmd/plum +``` + +--- + +## Quick Start for Buzzminson + +```bash +# You're already on the right branch +git status + +# Verify everything still builds and passes +go test ./... && go build -o ./plum ./cmd/plum + +# Run the TUI to manually test features +./plum + +# Key things to test: +# - Tab through facets in plugin list (should see filters ║ sorts) +# - Space to open quick menu in any view +# - Shift+F to open marketplace picker +# - 'i' on a discoverable plugin detail to copy 2-step install +``` diff --git a/docs/plans/2026-02-15-skill-recommender-v2-design.md b/docs/plans/2026-02-15-skill-recommender-v2-design.md new file mode 100644 index 0000000..74f9d2c --- /dev/null +++ b/docs/plans/2026-02-15-skill-recommender-v2-design.md @@ -0,0 +1,118 @@ +# Skill Recommender v2 Design + +**Date:** 2026-02-15 +**Status:** Approved +**Branch:** feature/ecosystem-discovery + +## Problem + +The v1 skill recommender produces noisy results: +- Items match on single generic tags like "backend" (supabase in skills-leaderboard) +- High-popularity items score above threshold with zero tag overlap +- Duplicate entries appear across categories (e.g., everything-claude-code in plugins + skills) +- Ecosystem JSONs lack language/framework tags, limiting match quality for non-JS/React stacks +- No markdown output mode — Claude must parse JSON and reformat every time + +## Decisions + +- **Approach:** Comprehensive pass — extract scoring engine, enrich data, add features +- **Deduplication:** Keep highest-scoring entry only, annotate with `also_found_in` +- **Tag enrichment:** Curate JSONs manually + add lightweight keyword inference as fallback +- **Hard gate:** Items with zero matching tags (explicit or inferred) are excluded regardless of score + +## Design + +### 1. Scoring Engine (`scripts/ecosystem/scorer.py`) + +New module with a multi-stage pipeline: + +**Stage 1 — Tag matching (80% of relevance)** +- Bidirectional overlap: item tags ∩ stack tags +- Geometric mean of (overlap/item_tags) and (overlap/stack_tags) +- Prevents single-generic-tag matches from scoring high + +**Stage 2 — Keyword inference (20% of relevance)** +- Curated `KEYWORD_TAG_MAP` maps description keywords → tags +- e.g., "terminal" → "terminal", "golang" → "go", "react native" → "react-native" +- Inferred tags count at 50% weight vs explicit tags +- Shown separately in output as `inferred_tags` + +**Stage 3 — Popularity normalization** +- Log-scale within each source (unchanged) +- Recency boost: entries updated in past 3 months get 10% bump + +**Stage 4 — Deduplication** +- Key on `owner/name` (lowercased) +- Keep entry with highest final score +- Annotate with `also_found_in: [source_keys]` + +**Final formula:** `(relevance * 0.7) + (popularity * 0.3)` + +**Hard gate:** Zero matching tags (explicit + inferred) → excluded. + +### 2. Ecosystem Data Enrichment + +Curate tags across all 5 JSON files: + +| File | Focus | +|------|-------| +| `skills-leaderboard.json` | Add missing language tags, `development`/`general` for universal skills | +| `plugins.json` | Add `cli`, `github`, `development` where applicable | +| `agents.json` | Add `python`, `typescript`, `sdk`, `terminal` where applicable | +| `skills.json` | Add `go`, `python`, `php`, `tui` to domain-specific entries | +| `mcp-servers.json` | Add `slack`, `git`, `filesystem` to specialized servers | + +Rules: +- Only factually accurate tags based on description/name +- Lowercase, hyphenated format +- Max 2-3 additions per entry +- Prefer tags matching `detect_stack.py` output + +### 3. New Features for `recommend.py` + +**`--markdown` flag** +- Pre-formatted markdown tables grouped by category +- Columns: Name, Score, Popularity, Matching Tags, Install Command + +**`--exclude-no-install` flag** +- Filters entries where `install_cmd` is null + +**`--json` flag (default)** +- Current behavior, explicit for clarity + +**Updated defaults:** +- `--min-score` raised from 15 → 20 +- Hard gate applied automatically + +**Dedup in output:** +- Applied automatically +- `also_found_in` array on deduplicated entries + +### 4. SKILL.md Updates + +- Use `--markdown` by default +- Document `--exclude-no-install` for actionable-only queries +- Update fallback instructions (require tag match when reading JSONs directly) +- Add `--top 10` suggestion for expanded results + +## Files Changed + +| File | Action | +|------|--------| +| `scripts/ecosystem/scorer.py` | **New** — Multi-stage scoring engine | +| `scripts/ecosystem/recommend.py` | **Modified** — Import scorer, add flags, raise min-score | +| `scripts/ecosystem/detect_stack.py` | **No changes** | +| `ecosystem/skills-leaderboard.json` | **Modified** — Tag enrichment | +| `ecosystem/plugins.json` | **Modified** — Tag enrichment | +| `ecosystem/agents.json` | **Modified** — Tag enrichment | +| `ecosystem/skills.json` | **Modified** — Tag enrichment | +| `ecosystem/mcp-servers.json` | **Modified** — Tag enrichment | +| `.claude/skills/skill-recommender/SKILL.md` | **Modified** — Use new flags | + +## Success Criteria + +- Running against plum repo: skills_leaderboard returns 0 results (no relevant skills exist for Go/TUI in that dataset) rather than false positives +- No entries with empty `matching_tags` + empty `inferred_tags` appear in output +- No duplicate owner/name entries across categories +- `--markdown` produces clean, copy-pasteable tables +- `--exclude-no-install` filters curated lists correctly diff --git a/docs/plans/2026-02-15-skill-recommender-v2-plan.md b/docs/plans/2026-02-15-skill-recommender-v2-plan.md new file mode 100644 index 0000000..411bac0 --- /dev/null +++ b/docs/plans/2026-02-15-skill-recommender-v2-plan.md @@ -0,0 +1,656 @@ +# Skill Recommender v2 Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Improve the skill recommender with a proper scoring engine, ecosystem data enrichment, deduplication, and markdown output. + +**Architecture:** Extract scoring logic into `scripts/ecosystem/scorer.py` with a 4-stage pipeline (tag matching, keyword inference, popularity normalization, deduplication). Refactor `recommend.py` to use the scorer and add `--markdown`/`--exclude-no-install` flags. Enrich all 5 ecosystem JSONs with missing language/framework tags. + +**Tech Stack:** Python 3 (stdlib only), JSON + +--- + +### Task 1: Create the scoring engine module + +**Files:** +- Create: `scripts/ecosystem/scorer.py` + +**Step 1: Create `scorer.py` with constants and keyword map** + +Create `scripts/ecosystem/scorer.py` with: + +```python +#!/usr/bin/env python3 +"""Multi-stage scoring engine for ecosystem recommendations. + +4-stage pipeline: +1. Tag matching (bidirectional, geometric mean) +2. Keyword inference (description → inferred tags) +3. Popularity normalization (log-scale + recency) +4. Deduplication (owner/name key, keep highest) +""" + +import math +from datetime import datetime, timedelta + +# Weights +RELEVANCE_WEIGHT = 0.7 +POPULARITY_WEIGHT = 0.3 +TAG_MATCH_WEIGHT = 0.8 +KEYWORD_INFER_WEIGHT = 0.2 +INFERRED_TAG_DISCOUNT = 0.5 # Inferred tags count at 50% vs explicit +RECENCY_MONTHS = 3 +RECENCY_BOOST = 0.10 # 10% boost for recent entries + +# Maps description/name keywords to inferred tags. +# Keys are lowercase substrings to search for in text. +# Values are lists of tags to infer. +KEYWORD_TAG_MAP = { + "golang": ["go"], + "go module": ["go"], + "go.mod": ["go"], + " go ": ["go"], + "python": ["python"], + "typescript": ["typescript"], + "javascript": ["javascript"], + "node.js": ["nodejs", "javascript"], + "nodejs": ["nodejs", "javascript"], + "rust": ["rust"], + "ruby": ["ruby"], + "java ": ["java"], + "kotlin": ["kotlin"], + "swift": ["swift"], + "php": ["php"], + "c++": ["cpp"], + "react": ["react", "frontend"], + "react native": ["react-native", "mobile"], + "next.js": ["nextjs", "react", "frontend"], + "nextjs": ["nextjs", "react", "frontend"], + "vue": ["vue", "frontend"], + "nuxt": ["nuxt", "vue", "frontend"], + "svelte": ["svelte", "frontend"], + "angular": ["angular", "frontend"], + "remotion": ["remotion", "video"], + "terminal": ["terminal"], + "tui": ["tui", "terminal"], + "command line": ["cli"], + "command-line": ["cli"], + " cli ": ["cli"], + "cli tool": ["cli"], + "docker": ["docker", "containerization"], + "kubernetes": ["kubernetes", "infrastructure"], + "terraform": ["terraform", "infrastructure"], + "github action": ["github-actions", "ci-cd"], + "ci/cd": ["ci-cd"], + "ci-cd": ["ci-cd"], + "database": ["database"], + "postgresql": ["postgresql", "database"], + "postgres": ["postgresql", "database"], + "mongodb": ["mongodb", "database"], + "redis": ["redis", "database"], + "api": ["api"], + "rest api": ["api", "backend"], + "graphql": ["graphql", "api"], + "grpc": ["grpc", "api"], + "authentication": ["authentication", "security"], + "oauth": ["oauth", "authentication", "security"], + "machine learning": ["ml", "ai"], + "deep learning": ["ml", "ai"], + "llm": ["llm", "ai"], + "testing": ["testing"], + "unit test": ["testing"], + "e2e": ["testing", "e2e"], + "browser automation": ["browser", "automation"], + "web scraping": ["scraping", "automation"], + "slack": ["slack"], + "git ": ["git"], + "markdown": ["markdown"], + "pdf": ["pdf", "document"], + "document": ["document"], + "design": ["design"], + "ui/ux": ["design", "ui"], + "accessibility": ["accessibility"], + "seo": ["seo"], + "marketing": ["marketing"], + "deployment": ["deployment"], + "serverless": ["serverless", "cloud"], + "aws": ["aws", "cloud"], + "azure": ["azure", "cloud"], + "gcp": ["gcp", "cloud"], + "cloudflare": ["cloudflare"], + "vercel": ["vercel"], + "supabase": ["supabase", "database"], + "firebase": ["firebase", "backend"], +} +``` + +**Step 2: Add the 4 scoring functions** + +Append to `scorer.py`: + +```python +def infer_tags(item): + """Stage 2: Infer tags from item description and name. + + Returns set of inferred tag strings. + """ + text = " " + (item.get("description", "") + " " + item.get("name", "")).lower() + " " + inferred = set() + for keyword, tags in KEYWORD_TAG_MAP.items(): + if keyword in text: + inferred.update(tags) + # Remove tags that are already explicit on the item + explicit = set(t.lower() for t in item.get("tags", [])) + return inferred - explicit + + +def compute_tag_score(item_tags, stack_tags, inferred_tags=None): + """Stage 1: Bidirectional tag matching with geometric mean. + + Args: + item_tags: set of lowercase tags from the ecosystem entry + stack_tags: set of lowercase tags from the detected stack + inferred_tags: set of inferred tags (counted at 50% weight) + + Returns: + (score 0-100, list of matching explicit tags, list of matching inferred tags) + """ + if not item_tags and not inferred_tags: + return 0.0, [], [] + + # Explicit tag overlap + explicit_overlap = item_tags & stack_tags + # Inferred tag overlap (discounted) + inferred_overlap = (inferred_tags & stack_tags) if inferred_tags else set() + + # Weighted overlap count: explicit=1.0, inferred=0.5 + weighted_overlap = len(explicit_overlap) + len(inferred_overlap) * INFERRED_TAG_DISCOUNT + + if weighted_overlap == 0: + return 0.0, [], [] + + # Total tags considered (explicit + inferred at discount) + total_item_tags = len(item_tags) + len(inferred_tags or set()) * INFERRED_TAG_DISCOUNT + total_stack_tags = len(stack_tags) + + if total_item_tags == 0 or total_stack_tags == 0: + return 0.0, [], [] + + # Bidirectional: how much of item matches stack AND how much of stack matches item + item_ratio = weighted_overlap / total_item_tags + stack_ratio = weighted_overlap / total_stack_tags + + # Geometric mean prevents single-tag matches from scoring high + geo_mean = math.sqrt(item_ratio * stack_ratio) + score = geo_mean * 100 + + return score, sorted(explicit_overlap), sorted(inferred_overlap) + + +def normalize_popularity(items, pop_field, last_updated_str=None): + """Stage 3: Log-scale popularity with optional recency boost. + + Mutates items in-place, adding '_pop_norm' field. + + Args: + items: list of ecosystem entry dicts + pop_field: key name for the popularity metric (e.g., 'stars', 'installs') + last_updated_str: ISO date string from the source file's last_updated field + """ + values = [item.get(pop_field, 0) for item in items] + max_val = max(values) if values else 0 + + # Determine if source data is recent (within RECENCY_MONTHS) + is_recent = False + if last_updated_str: + try: + last_updated = datetime.strptime(last_updated_str, "%Y-%m-%d") + cutoff = datetime.now() - timedelta(days=RECENCY_MONTHS * 30) + is_recent = last_updated >= cutoff + except ValueError: + pass + + for item in items: + raw = item.get(pop_field, 0) + if max_val > 0: + norm = math.log1p(raw) / math.log1p(max_val) * 100 + else: + norm = 0.0 + + if is_recent: + norm = min(norm * (1 + RECENCY_BOOST), 100.0) + + item["_pop_norm"] = norm + + return items + + +def deduplicate(all_scored): + """Stage 4: Deduplicate across sources, keep highest score. + + Args: + all_scored: list of dicts, each with 'owner', 'name', 'score', 'source', plus all other fields + + Returns: + list of deduplicated dicts, highest-score entry kept, with 'also_found_in' added where applicable + """ + seen = {} # key: "owner/name" -> best entry dict + source_tracker = {} # key: "owner/name" -> list of source labels + + for entry in all_scored: + key = f"{entry['owner']}/{entry['name']}".lower() + + if key not in source_tracker: + source_tracker[key] = [] + source_tracker[key].append(entry["source"]) + + if key not in seen or entry["score"] > seen[key]["score"]: + seen[key] = entry + + # Annotate with also_found_in + result = [] + for key, entry in seen.items(): + sources = source_tracker[key] + if len(sources) > 1: + entry["also_found_in"] = sorted(set(s for s in sources if s != entry["source"])) + result.append(entry) + + return result + + +def score_item(item, stack_tags, pop_field): + """Run the full scoring pipeline on a single item. + + Args: + item: ecosystem entry dict + stack_tags: set of lowercase tags from detected stack + + Returns: + (final_score, matching_tags, inferred_tags) or None if excluded by hard gate + """ + item_tags = set(t.lower() for t in item.get("tags", [])) + inferred = infer_tags(item) + + # Stage 1+2: Tag score (explicit + inferred) + tag_score, matching_explicit, matching_inferred = compute_tag_score( + item_tags, stack_tags, inferred + ) + + # Hard gate: must have at least one matching tag (explicit or inferred) + if not matching_explicit and not matching_inferred: + return None + + # Relevance = tag matching only (keyword inference is baked into tag inference) + relevance = tag_score + + # Stage 3: Popularity (already normalized on item as _pop_norm) + pop_score = item.get("_pop_norm", 0) + + # Final score + final_score = (relevance * RELEVANCE_WEIGHT) + (pop_score * POPULARITY_WEIGHT) + + return final_score, matching_explicit, matching_inferred +``` + +**Step 3: Run a quick syntax check** + +Run: `python3 -c "import scripts.ecosystem.scorer; print('OK')" 2>&1 || python3 scripts/ecosystem/scorer.py` + +Expected: No syntax errors (module has no `__main__` block, so just verifying it imports) + +**Step 4: Commit** + +```bash +git add scripts/ecosystem/scorer.py +git commit -m "feat: add multi-stage scoring engine for ecosystem recommendations" +``` + +--- + +### Task 2: Refactor recommend.py to use scorer + +**Files:** +- Modify: `scripts/ecosystem/recommend.py` + +**Step 1: Replace scoring logic with scorer imports** + +Rewrite `recommend.py` to: +- Remove inline scoring functions (`_compute_relevance`, `_build_keywords`, `_normalize_popularity`) +- Import from `scorer`: `score_item`, `normalize_popularity`, `deduplicate`, `infer_tags` +- Keep `_load_json` and `_format_entry` (but update `_format_entry` to include `inferred_tags` and `also_found_in`) +- Update `recommend()` to: + 1. Build `stack_tags` set from profile (languages + tags + frameworks, all lowercased) + 2. For each source: normalize popularity, score each item via `score_item()`, collect results + 3. Flatten all scored items, run `deduplicate()` + 4. Re-group by source, sort by score, apply top_n +- Raise `DEFAULT_MIN_SCORE` from 15 to 20 + +**Step 2: Add new CLI flags** + +Add to argparse: +- `--markdown` flag: calls a new `_format_markdown(result)` function +- `--exclude-no-install` flag: filters entries where `install_cmd` is missing +- `--json` flag: explicit JSON mode (default) +- Output format group: `--json` | `--markdown` (mutually exclusive) + +**Step 3: Implement `_format_markdown(result)`** + +New function that outputs: + +``` +## Stack Profile + +**Languages:** Go, Python +**Frameworks:** bubbletea, cobra, lipgloss +**Tags:** cli, tui, terminal, ci-cd, ... + +## Top Skills (skills.sh) + +| Name | Score | Installs | Tags | Install | +|------|-------|----------|------|---------| +| ... | ... | ... | ... | `cmd` | + +## Plugins + +| Name | Score | Stars | Tags | Install | +|------|-------|-------|------|---------| +... +``` + +Category label mapping: +- `skills_leaderboard` → "Top Skills (skills.sh)" +- `plugins` → "Plugins" +- `agents` → "Agents" +- `skills` → "Skill Repositories" +- `mcp_servers` → "MCP Servers" + +Only print categories with results. + +**Step 4: Update `_format_entry` to include new fields** + +Add `inferred_tags` list and conditional `also_found_in` list to the entry dict. + +**Step 5: Test JSON output** + +Run: `python3 scripts/ecosystem/recommend.py . --pretty` + +Expected: +- `total_matches` likely lower than v1 (hard gate filters noise) +- No entries with both `matching_tags: []` and `inferred_tags: []` +- No duplicate `owner/name` across categories + +**Step 6: Test markdown output** + +Run: `python3 scripts/ecosystem/recommend.py . --markdown` + +Expected: Clean markdown tables with headers, no empty categories. + +**Step 7: Test exclude-no-install flag** + +Run: `python3 scripts/ecosystem/recommend.py . --markdown --exclude-no-install` + +Expected: Only entries with install commands appear. + +**Step 8: Test error case** + +Run: `python3 scripts/ecosystem/recommend.py /nonexistent --pretty` + +Expected: `{"error": "Not a directory: /nonexistent"}` + +**Step 9: Commit** + +```bash +git add scripts/ecosystem/recommend.py +git commit -m "feat: refactor recommend.py to use scorer engine, add markdown and filter flags" +``` + +--- + +### Task 3: Enrich ecosystem JSON tags — skills-leaderboard.json + +**Files:** +- Modify: `ecosystem/skills-leaderboard.json` + +**Step 1: Add language/framework tags to each entry** + +Apply these specific tag additions (only adding, never removing existing tags): + +| Entry | Add Tags | +|-------|----------| +| `find-skills` | `"meta"` (already has it via category) — no change needed | +| `vercel-react-best-practices` | `"javascript"`, `"typescript"` | +| `web-design-guidelines` | `"css"`, `"frontend"` | +| `remotion-best-practices` | `"javascript"`, `"typescript"`, `"react"` | +| `frontend-design` | `"css"`, `"frontend"` | +| `vercel-composition-patterns` | `"javascript"`, `"typescript"` | +| `agent-browser` | `"web"`, `"javascript"` | +| `skill-creator` | `"development"`, `"meta"` | +| `browser-use` | `"web"`, `"javascript"` | +| `vercel-react-native-skills` | `"javascript"`, `"typescript"` | +| `ui-ux-pro-max` | `"css"`, `"frontend"` | +| `audit-website` | `"web"` | +| `brainstorming` | `"development"`, `"general"` | +| `seo-audit` | `"web"` | +| `supabase-postgres-best-practices` | `"sql"` | +| `pdf` | `"python"` | +| `copywriting` | `"general"`, `"content"` | +| `pptx` | `"python"` | +| `next-best-practices` | `"javascript"`, `"typescript"`, `"react"` | +| `better-auth-best-practices` | `"web"`, `"backend"` | +| `docx` | `"python"` | +| `agent-tools` | `"development"` | +| `xlsx` | `"python"` | +| `systematic-debugging` | `"development"`, `"general"` | +| `marketing-psychology` | `"general"` | + +**Step 2: Verify JSON is valid** + +Run: `python3 -c "import json; json.load(open('ecosystem/skills-leaderboard.json')); print('valid')"` + +**Step 3: Commit** + +```bash +git add ecosystem/skills-leaderboard.json +git commit -m "chore: enrich skills-leaderboard.json with language and domain tags" +``` + +--- + +### Task 4: Enrich ecosystem JSON tags — plugins.json + +**Files:** +- Modify: `ecosystem/plugins.json` + +**Step 1: Add tags** + +| Entry | Add Tags | +|-------|----------| +| `claude-code` (anthropics) | `"development"` | +| `everything-claude-code` | `"development"`, `"testing"` | +| `awesome-claude-code` (hesreallyhim) | `"development"` | +| `claude-plugins-official` | `"development"` | +| `claude-code-action` | `"github-actions"` | +| `gmickel-claude-marketplace` | `"development"` | +| `awesome-claude-code-plugins` | `"development"` | +| `claude-code-plugin-template` | `"template"`, `"development"` | +| `cc-marketplace-boilerplate` | `"development"` | +| `claude-starter-kit` | `"development"` | +| `ai-coding-project-boilerplate` | `"development"` | +| `ralph-loop-setup` | `"development"`, `"testing"` | +| `flow-next-opencode` | `"development"` | + +**Step 2: Verify JSON** + +Run: `python3 -c "import json; json.load(open('ecosystem/plugins.json')); print('valid')"` + +**Step 3: Commit** + +```bash +git add ecosystem/plugins.json +git commit -m "chore: enrich plugins.json with development and domain tags" +``` + +--- + +### Task 5: Enrich ecosystem JSON tags — agents.json + +**Files:** +- Modify: `ecosystem/agents.json` + +**Step 1: Add tags** + +| Entry | Add Tags | +|-------|----------| +| `anthropic-cookbook` | `"python"`, `"development"` | +| `agents` (wshobson) | `"development"` | +| `SuperClaude_Framework` | `"development"` | +| `claude-quickstarts` | `"development"`, `"python"` | +| `claude-flow` | `"development"` | +| `awesome-claude-code-subagents` | `"development"` | +| `claude-squad` | `"go"`, `"cli"` | +| `claude-agent-sdk-python` | — already has `"python"` | +| `awesome-claude-agents` (vijaythecoder) | `"development"` | +| `claude-agent-sdk-typescript` | — already has `"typescript"` | + +**Step 2: Verify JSON** + +Run: `python3 -c "import json; json.load(open('ecosystem/agents.json')); print('valid')"` + +**Step 3: Commit** + +```bash +git add ecosystem/agents.json +git commit -m "chore: enrich agents.json with language and development tags" +``` + +--- + +### Task 6: Enrich ecosystem JSON tags — skills.json + +**Files:** +- Modify: `ecosystem/skills.json` + +**Step 1: Add tags** + +| Entry | Add Tags | +|-------|----------| +| `skills` (anthropics) | `"python"`, `"development"` | +| `everything-claude-code` (affaan-m) | `"development"`, `"testing"` | +| `awesome-claude-skills` (ComposioHQ) | `"development"` | +| `agents` (wshobson) | `"development"` | +| `awesome-claude-skills` (travisvn) | `"development"` | +| `awesome-agent-skills` (VoltAgent) | `"development"`, `"multi-platform"` | +| `awesome-claude-skills` (BehiSecc) | `"development"` | +| `claude-skills` (alirezarezvani) | `"development"` | +| `claude-code-skills` (daymade) | `"development"` | +| `claude-code-skill-factory` | `"development"` | +| `claude-code-marketplace` (netresearch) | — already has `"typo3"`, `"php"` | +| `claude-marketplace` (dashed) | `"cli"`, `"development"` | + +**Step 2: Verify JSON** + +Run: `python3 -c "import json; json.load(open('ecosystem/skills.json')); print('valid')"` + +**Step 3: Commit** + +```bash +git add ecosystem/skills.json +git commit -m "chore: enrich skills.json with language and development tags" +``` + +--- + +### Task 7: Enrich ecosystem JSON tags — mcp-servers.json + +**Files:** +- Modify: `ecosystem/mcp-servers.json` + +**Step 1: Add tags** + +| Entry | Add Tags | +|-------|----------| +| `servers` (modelcontextprotocol) | `"git"`, `"filesystem"`, `"development"` | +| `registry` (modelcontextprotocol) | `"development"` | +| `slack-mcp-server` (korotovsky) | — already has `"slack"` | +| `slack-mcp-server` (jtalk22) | — already has `"slack"` | +| `claude-code-slack-bot` | — already has `"slack"` | +| `MCPJungle` | `"development"`, `"docker"` | +| `metamcp` | `"development"` | + +**Step 2: Verify JSON** + +Run: `python3 -c "import json; json.load(open('ecosystem/mcp-servers.json')); print('valid')"` + +**Step 3: Commit** + +```bash +git add ecosystem/mcp-servers.json +git commit -m "chore: enrich mcp-servers.json with development and domain tags" +``` + +--- + +### Task 8: Update SKILL.md + +**Files:** +- Modify: `.claude/skills/skill-recommender/SKILL.md` + +**Step 1: Update the skill instructions** + +Replace the content with updated instructions that: +- Use `--markdown` by default instead of `--pretty` +- Document `--exclude-no-install` for "what should I install" queries +- Mention `--top 10` for more results +- Update fallback instructions to require tag match +- Update the Notes section with new min-score default of 20 + +**Step 2: Commit** + +```bash +git add .claude/skills/skill-recommender/SKILL.md +git commit -m "feat: update SKILL.md to use markdown output and document new flags" +``` + +--- + +### Task 9: End-to-end verification + +**Step 1: Test against plum repo (Go/TUI/CLI stack)** + +Run: `python3 scripts/ecosystem/recommend.py . --markdown` + +Verify: +- No false positives in skills_leaderboard (supabase should NOT appear — only matched on generic "backend") +- `claude-squad` should appear (has "terminal" tag + now "go", "cli" tags) +- No duplicate entries across categories +- Markdown tables are clean and readable + +**Step 2: Test JSON output still works** + +Run: `python3 scripts/ecosystem/recommend.py . --pretty` + +Verify: Valid JSON, entries have `matching_tags` and `inferred_tags` fields. + +**Step 3: Test exclude-no-install** + +Run: `python3 scripts/ecosystem/recommend.py . --markdown --exclude-no-install` + +Verify: Only entries with install commands shown. + +**Step 4: Test error handling** + +Run: `python3 scripts/ecosystem/recommend.py /nonexistent` + +Verify: Returns JSON error without traceback. + +**Step 5: Compare v1 vs v2 match counts** + +Run: `python3 scripts/ecosystem/recommend.py . --pretty | python3 -c "import sys,json; d=json.load(sys.stdin); print('Total:', d['total_matches']); [print(f' {k}: {len(v)}') for k,v in d['recommendations'].items()]"` + +Verify: Lower total than v1's 16 matches, with higher precision (every match has tag overlap). + +**Step 6: Push all changes** + +```bash +git push +``` diff --git a/ecosystem/README.md b/ecosystem/README.md new file mode 100644 index 0000000..b2777eb --- /dev/null +++ b/ecosystem/README.md @@ -0,0 +1,155 @@ +# Plum Ecosystem Knowledge Base + +**Purpose**: Machine-readable reference maps of the Claude Code ecosystem for intelligent skill/plugin recommendations and automated discovery. + +## 📁 Directory Structure + +``` +ecosystem/ +├── README.md # This file +├── metadata.json # Stats, last updated, totals +├── plugins.json # Plugin repository index +├── agents.json # Agent repository index +├── skills.json # Skills repository index +├── skills-leaderboard.json # Top skills from skills.sh +├── mcp-servers.json # MCP server index +├── marketplaces.json # Marketplace directory +└── research/ # Detailed research reports + ├── 2026-02-15-claude-code-ecosystem-discovery.md + └── 2026-02-15-claude-skills-ecosystem.md +``` + +## 🎯 Purpose + +This directory serves as a **living knowledge base** that: + +1. **Enables Fast Queries**: Agents can query compact JSON files instead of reading 500+ line markdown docs +2. **Powers Recommendations**: Context-aware skill/plugin suggestions based on current repo +3. **Stays Current**: Periodic updates via `ecosystem-update` skill +4. **Reduces Context**: Only load what you need (filter by tags, category, popularity) + +## 📊 JSON Schema + +All JSON files follow consistent patterns: + +### Common Fields +- `name` - Repository/skill name +- `owner` - GitHub owner or organization +- `stars` / `installs` - Popularity metric +- `category` - Type/classification +- `tags` - Filterable keywords +- `description` - Brief purpose +- `url` - Link to resource +- `install_cmd` - Quick install command + +### Example Entry +```json +{ + "name": "find-skills", + "owner": "vercel-labs", + "repo": "vercel-labs/skills", + "installs": 231100, + "category": "meta", + "tags": ["discovery", "essential"], + "description": "Skill discovery and management", + "install_cmd": "npx skillsadd vercel-labs/skills/find-skills" +} +``` + +## 🔍 Usage Examples + +### For Agents/Skills + +**Recommend React skills:** +```python +import json + +with open('ecosystem/skills-leaderboard.json') as f: + data = json.load(f) + react_skills = [s for s in data['skills'] if 'react' in s['tags']] + top_5 = sorted(react_skills, key=lambda x: x['installs'], reverse=True)[:5] +``` + +**Find popular plugins:** +```python +with open('ecosystem/plugins.json') as f: + data = json.load(f) + popular = [p for p in data['repositories'] if p['stars'] > 10000] +``` + +**Get MCP servers by category:** +```python +with open('ecosystem/mcp-servers.json') as f: + data = json.load(f) + slack_servers = [s for s in data['servers'] if 'slack' in s['tags']] +``` + +### For Humans + +Read detailed analysis in `research/` directory: +- Full context and insights +- Ecosystem trends and patterns +- Strategic recommendations + +## 🔄 Updating Data + +### Manual Update +Run the ecosystem update skill: +```bash +# Future: once skill is built +/ecosystem-update +``` + +### What Gets Updated +- New repositories discovered via GitHub search +- Star counts refreshed for existing entries +- skills.sh leaderboard rankings +- Metadata timestamps and totals + +### Update Frequency +- **Recommended**: Weekly +- **Minimum**: Monthly +- **After Major Events**: New Anthropic releases, hackathons, etc. + +## 📋 Data Sources + +All data sourced from: +- **GitHub Search API** - Repository discovery +- **skills.sh** - Skill installation rankings +- **Official Docs** - Anthropic documentation +- **Community Resources** - Awesome lists, marketplaces + +## 🎓 File Descriptions + +| File | Purpose | Entries | +|------|---------|---------| +| `metadata.json` | Stats, timestamps, totals | 1 object | +| `plugins.json` | Plugin repositories | 50+ repos | +| `agents.json` | Agent/subagent repos | 30+ repos | +| `skills.json` | Skill collections | 24+ repos | +| `skills-leaderboard.json` | Top skills by installs | 25+ skills | +| `mcp-servers.json` | MCP server collections | 15+ collections | +| `marketplaces.json` | Marketplace directories | 10+ marketplaces | + +## 🏗️ Future Enhancements + +- [ ] Tag taxonomy (standardize tags across files) +- [ ] Compatibility matrix (which skills work with which frameworks) +- [ ] Historical trends (track star growth over time) +- [ ] Quality scores (combine stars, installs, recency) +- [ ] Dependency graphs (skill prerequisites) +- [ ] Auto-detection scripts (detect tech stack from repo) + +## 📝 Contributing + +When adding new entries: +1. Follow the schema consistently +2. Include all required fields +3. Sort by popularity (stars/installs descending) +4. Update metadata.json totals +5. Add research notes to `research/` if needed + +--- + +**Last Updated**: 2026-02-15 +**Maintained By**: Plum ecosystem update workflows diff --git a/ecosystem/agents.json b/ecosystem/agents.json new file mode 100644 index 0000000..47ddfc2 --- /dev/null +++ b/ecosystem/agents.json @@ -0,0 +1,336 @@ +{ + "last_updated": "2026-02-15", + "total_repos": 30, + "repositories": [ + { + "name": "anthropic-cookbook", + "owner": "anthropics", + "url": "https://github.com/anthropics/anthropic-cookbook", + "stars": 32900, + "category": "official", + "type": "examples", + "tags": ["official", "cookbook", "patterns", "reference", "python", "development"], + "description": "Reference implementations for building effective agents", + "install_cmd": null + }, + { + "name": "agents", + "owner": "wshobson", + "url": "https://github.com/wshobson/agents", + "stars": 28600, + "category": "community", + "type": "framework", + "tags": ["multi-agent", "orchestration", "comprehensive", "112-agents", "development"], + "description": "112 specialized agents, 73 plugins, 146 skills, granular architecture", + "install_cmd": "/plugin install wshobson/agents" + }, + { + "name": "SuperClaude_Framework", + "owner": "SuperClaude-Org", + "url": "https://github.com/SuperClaude-Org/SuperClaude_Framework", + "stars": 20800, + "category": "community", + "type": "framework", + "tags": ["meta-programming", "30-commands", "16-agents", "modes", "development"], + "description": "Meta-programming config - 30 commands, 16 agents, 7 modes, 2-3x faster", + "install_cmd": "/plugin install SuperClaude-Org/SuperClaude_Framework" + }, + { + "name": "claude-quickstarts", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-quickstarts", + "stars": 14000, + "category": "official", + "type": "templates", + "tags": ["official", "production-ready", "quickstart", "development", "python"], + "description": "Production-ready project templates for autonomous agents", + "install_cmd": null + }, + { + "name": "claude-flow", + "owner": "ruvnet", + "url": "https://github.com/ruvnet/claude-flow", + "stars": 14100, + "category": "community", + "type": "orchestration", + "tags": ["swarms", "60-agents", "vector-memory", "coordination", "development"], + "description": "60+ agents in coordinated swarms with persistent vector memory", + "install_cmd": "/plugin install ruvnet/claude-flow" + }, + { + "name": "awesome-claude-code-subagents", + "owner": "VoltAgent", + "url": "https://github.com/VoltAgent/awesome-claude-code-subagents", + "stars": 10500, + "category": "community", + "type": "collection", + "tags": ["100-subagents", "specialized", "curated", "development"], + "description": "100+ specialized subagents across 10 major categories", + "install_cmd": null + }, + { + "name": "claude-squad", + "owner": "smtg-ai", + "url": "https://github.com/smtg-ai/claude-squad", + "stars": 6000, + "category": "community", + "type": "terminal", + "tags": ["multi-agent", "terminal", "workspaces", "manager", "go", "cli"], + "description": "Terminal manager for multiple AI agents with isolated workspaces", + "install_cmd": null + }, + { + "name": "claude-agent-sdk-python", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-agent-sdk-python", + "stars": 4800, + "category": "official", + "type": "sdk", + "tags": ["official", "python", "sdk", "agentic"], + "description": "Official Python SDK for building agentic applications", + "install_cmd": null + }, + { + "name": "awesome-claude-agents", + "owner": "vijaythecoder", + "url": "https://github.com/vijaythecoder/awesome-claude-agents", + "stars": 3800, + "category": "community", + "type": "collection", + "tags": ["24-agents", "orchestration", "specialized", "development"], + "description": "24 specialized agents with automatic stack detection", + "install_cmd": null + }, + { + "name": "claude-agent-sdk-typescript", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-agent-sdk-typescript", + "stars": 795, + "category": "official", + "type": "sdk", + "tags": ["official", "typescript", "sdk", "nodejs"], + "description": "Official TypeScript/Node.js SDK, used by 597 projects", + "install_cmd": null + }, + { + "name": "claude-code-by-agents", + "owner": "baryhuang", + "url": "https://github.com/baryhuang/claude-code-by-agents", + "stars": 773, + "category": "community", + "type": "orchestration", + "tags": ["multi-agent", "desktop-app", "api", "coordination"], + "description": "Desktop app and API for multi-agent coordination via @mentions", + "install_cmd": null + }, + { + "name": "awesome-claude-agents", + "owner": "rahulvrane", + "url": "https://github.com/rahulvrane/awesome-claude-agents", + "stars": 283, + "category": "community", + "type": "collection", + "tags": ["plug-and-play", "frameworks", "recipes"], + "description": "Community-driven collection of plug-and-play agents", + "install_cmd": null + }, + { + "name": "claude-007-agents", + "owner": "avivl", + "url": "https://github.com/avivl/claude-007-agents", + "stars": 237, + "category": "community", + "type": "framework", + "tags": ["14-categories", "orchestration", "bootstrap"], + "description": "Unified orchestration with intelligent bootstrap system", + "install_cmd": "/plugin install avivl/claude-007-agents" + }, + { + "name": "claude-code-teams-mcp", + "owner": "cs50victor", + "url": "https://github.com/cs50victor/claude-code-teams-mcp", + "stars": 164, + "category": "community", + "type": "mcp", + "tags": ["mcp", "teams", "protocol", "standalone"], + "description": "MCP server for agent teams protocol as standalone service", + "install_cmd": null + }, + { + "name": "claude-user-memory", + "owner": "VAMFI", + "url": "https://github.com/VAMFI/claude-user-memory", + "stars": 146, + "category": "community", + "type": "framework", + "tags": ["9-agents", "research-first", "tdd", "knowledge-graph"], + "description": "9 agents with Research→Plan→Implement, 4.8-5.5x faster dev", + "install_cmd": "/plugin install VAMFI/claude-user-memory" + }, + { + "name": "agents-claude-code", + "owner": "lodetomasi", + "url": "https://github.com/lodetomasi/agents-claude-code", + "stars": 112, + "category": "community", + "type": "collection", + "tags": ["100-agents", "hyper-specialized", "multi-model"], + "description": "100 hyper-specialized agents optimized with appropriate Claude models", + "install_cmd": "/plugin install lodetomasi/agents-claude-code" + }, + { + "name": "claude-agent-framework", + "owner": "ciscoittech", + "url": "https://github.com/ciscoittech/claude-agent-framework", + "stars": 8, + "category": "community", + "type": "framework", + "tags": ["97-percent-reduction", "3-6x-faster", "automated-setup"], + "description": "97% context reduction, 3-6x faster execution, 2-minute setup", + "install_cmd": "/plugin install ciscoittech/claude-agent-framework" + }, + { + "name": "claude-agents", + "owner": "gabrielmaialva33", + "url": "https://github.com/gabrielmaialva33/claude-agents", + "stars": 3, + "category": "community", + "type": "collection", + "tags": ["34-agents", "tech-stacks", "auto-detection"], + "description": "34+ specialized agents with automatic tech stack detection", + "install_cmd": "/plugin install gabrielmaialva33/claude-agents" + }, + { + "name": "claude-agent-sdk-demos", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-agent-sdk-demos", + "stars": 0, + "category": "official", + "type": "demos", + "tags": ["official", "multi-agent", "research"], + "description": "Multi-agent research system with coordinated subagents", + "install_cmd": null + }, + { + "name": "oh-my-claudecode", + "owner": "Yeachan-Heo", + "url": "https://github.com/Yeachan-Heo/oh-my-claudecode", + "stars": 0, + "category": "community", + "type": "orchestration", + "tags": ["teams-first", "multi-agent"], + "description": "Teams-first multi-agent orchestration", + "install_cmd": null + }, + { + "name": "multi-agent-shogun", + "owner": "yohey-w", + "url": "https://github.com/yohey-w/multi-agent-shogun", + "stars": 0, + "category": "community", + "type": "orchestration", + "tags": ["samurai", "tmux", "hierarchy"], + "description": "Samurai-inspired hierarchy with tmux orchestration", + "install_cmd": null + }, + { + "name": "agent-orchestrator-template", + "owner": "shintaro-sprech", + "url": "https://github.com/shintaro-sprech/agent-orchestrator-template", + "stars": 0, + "category": "community", + "type": "template", + "tags": ["self-evolving", "dynamic", "template"], + "description": "Self-evolving agent management creating agents dynamically", + "install_cmd": null + }, + { + "name": "claude-subagent-system", + "owner": "cemigo114", + "url": "https://github.com/cemigo114/claude-subagent-system", + "stars": 0, + "category": "community", + "type": "framework", + "tags": ["production-ready", "lifecycle", "auto-generation"], + "description": "Production-ready system auto-generating specialized sub-agents", + "install_cmd": null + }, + { + "name": "claude-sub-agent", + "owner": "zhsama", + "url": "https://github.com/zhsama/claude-sub-agent", + "stars": 0, + "category": "community", + "type": "workflow", + "tags": ["ai-driven", "pipeline", "experts"], + "description": "AI-driven development pipeline with specialized experts", + "install_cmd": null + }, + { + "name": "claude-code-sub-agent-collective", + "owner": "vanzan01", + "url": "https://github.com/vanzan01/claude-code-sub-agent-collective", + "stars": 0, + "category": "community", + "type": "research", + "tags": ["context-engineering", "collective", "hub-and-spoke"], + "description": "Context engineering research with hub-and-spoke coordination", + "install_cmd": null + }, + { + "name": "claude-code-sub-agents", + "owner": "lst97", + "url": "https://github.com/lst97/claude-code-sub-agents", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["domain-experts", "full-stack", "auto-invoked"], + "description": "Domain-expert subagents auto-invoked by context analysis", + "install_cmd": null + }, + { + "name": "dream-team", + "owner": "drbscl", + "url": "https://github.com/drbscl/dream-team", + "stars": 0, + "category": "community", + "type": "plugin", + "tags": ["plugin", "teams", "specialized"], + "description": "Plugin orchestrating teams of specialized agents", + "install_cmd": "/plugin install drbscl/dream-team" + }, + { + "name": "claude-code-agents", + "owner": "vizra-ai", + "url": "https://github.com/vizra-ai/claude-code-agents", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["59-agents", "workflow"], + "description": "59 specialized agents supercharging development workflow", + "install_cmd": null + }, + { + "name": "myclaude", + "owner": "cexll", + "url": "https://github.com/cexll/myclaude", + "stars": 0, + "category": "community", + "type": "orchestration", + "tags": ["multi-platform", "codex", "gemini", "opencode"], + "description": "Multi-agent orchestration supporting Claude Code, Codex, Gemini", + "install_cmd": null + }, + { + "name": "claude_code_setup", + "owner": "mkXultra", + "url": "https://github.com/mkXultra/claude_code_setup", + "stars": 0, + "category": "community", + "type": "workflow", + "tags": ["mcp", "collaborative", "parallel"], + "description": "Workflows enabling collaborative parallel work via MCP", + "install_cmd": null + } + ] +} diff --git a/ecosystem/marketplaces.json b/ecosystem/marketplaces.json new file mode 100644 index 0000000..b5d920a --- /dev/null +++ b/ecosystem/marketplaces.json @@ -0,0 +1,126 @@ +{ + "last_updated": "2026-02-15", + "total_marketplaces": 12, + "web_directories": [ + { + "name": "Claude Code Marketplaces", + "url": "https://claudemarketplaces.com/", + "category": "directory", + "tags": ["directory", "5-star-minimum"], + "description": "Directory of Claude Code plugin marketplaces - only 5+ star marketplaces included", + "quality_threshold": "5 GitHub stars minimum" + }, + { + "name": "Build with Claude", + "url": "https://www.buildwithclaude.com/marketplaces", + "category": "directory", + "tags": ["directory", "marketplaces"], + "description": "Plugin Marketplaces directory" + }, + { + "name": "Claude Code Marketplace", + "url": "https://claudecodemarketplace.com/", + "category": "directory", + "tags": ["directory", "plugins"], + "description": "Claude Code Plugins directory" + }, + { + "name": "AI Templates", + "url": "https://www.aitmpl.com/", + "category": "templates", + "tags": ["templates", "development"], + "description": "Claude Code Templates - Supercharge AI-Powered Development" + }, + { + "name": "Awesome Claude", + "url": "https://awesomeclaude.ai/awesome-claude-code", + "category": "directory", + "tags": ["visual", "resources"], + "description": "Visual directory of Awesome Claude Code resources" + }, + { + "name": "ClaudeLog", + "url": "https://claudelog.com/claude-code-mcps/awesome-claude-code/", + "category": "directory", + "tags": ["mcps", "directory"], + "description": "Awesome Claude Code MCPs directory" + }, + { + "name": "skills.sh", + "url": "https://skills.sh/", + "category": "skills", + "tags": ["skills", "leaderboard", "official", "59k-skills"], + "description": "Official skills leaderboard tracking 59,375+ skills - launched Jan 20, 2026" + }, + { + "name": "SkillsMP", + "url": "https://skillsmp.com/", + "category": "skills", + "tags": ["skills", "marketplace", "87k-skills", "cross-platform"], + "description": "Agent Skills Marketplace with 87,000+ skills - Claude, Codex, ChatGPT compatible" + } + ], + "github_marketplaces": [ + { + "name": "claude-plugins-official", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-plugins-official", + "stars": 7500, + "category": "official", + "tags": ["official", "anthropic", "verified"], + "description": "Official Anthropic-managed directory - automatically available in Claude Code", + "install_cmd": null, + "auto_available": true + }, + { + "name": "gmickel-claude-marketplace", + "owner": "gmickel", + "url": "https://github.com/gmickel/gmickel-claude-marketplace", + "stars": 482, + "category": "community", + "tags": ["flow-next", "ralph", "autonomous"], + "description": "Flow-Next, Ralph autonomous mode, multi-model review gates", + "install_cmd": "/plugin marketplace add gmickel/gmickel-claude-marketplace" + }, + { + "name": "superpowers-marketplace", + "owner": "obra", + "url": "https://github.com/obra/superpowers-marketplace", + "stars": 99, + "category": "community", + "tags": ["curated", "skills-framework"], + "description": "Curated marketplace - agentic skills framework", + "install_cmd": "/plugin marketplace add obra/superpowers-marketplace" + }, + { + "name": "claude-code-marketplace", + "owner": "netresearch", + "url": "https://github.com/netresearch/claude-code-marketplace", + "stars": 0, + "category": "community", + "tags": ["catalog", "indexing"], + "description": "Curated catalog indexing individual repositories", + "install_cmd": "/plugin marketplace add netresearch/claude-code-marketplace" + }, + { + "name": "claude-code-marketplace", + "owner": "ivan-magda", + "url": "https://github.com/ivan-magda/claude-code-marketplace", + "stars": 0, + "category": "personal", + "tags": ["personal", "curated"], + "description": "Personal curated plugin collection", + "install_cmd": "/plugin marketplace add ivan-magda/claude-code-marketplace" + }, + { + "name": "cc-marketplace", + "owner": "ananddtyagi", + "url": "https://github.com/ananddtyagi/cc-marketplace", + "stars": 0, + "category": "community", + "tags": ["marketplace"], + "description": "Marketplace repo for Claude Code plugins", + "install_cmd": "/plugin marketplace add ananddtyagi/cc-marketplace" + } + ] +} diff --git a/ecosystem/mcp-servers.json b/ecosystem/mcp-servers.json new file mode 100644 index 0000000..a0c3fd5 --- /dev/null +++ b/ecosystem/mcp-servers.json @@ -0,0 +1,200 @@ +{ + "last_updated": "2026-02-15", + "total_servers_tracked": 410, + "combined_stars": 500000, + "total_categories": 34, + "collections": [ + { + "name": "servers", + "owner": "modelcontextprotocol", + "url": "https://github.com/modelcontextprotocol/servers", + "stars": 0, + "category": "official", + "type": "reference", + "tags": ["official", "mcp", "reference-implementations", "git", "filesystem", "development"], + "description": "Official MCP reference implementations - Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking, Time", + "install_cmd": null + }, + { + "name": "registry", + "owner": "modelcontextprotocol", + "url": "https://github.com/modelcontextprotocol/registry", + "stars": 0, + "category": "official", + "type": "registry", + "tags": ["official", "registry", "community-driven", "development"], + "description": "Community-driven registry service for MCP servers - like an app store", + "install_cmd": null + }, + { + "name": "best-of-mcp-servers", + "owner": "tolkonepiu", + "url": "https://github.com/tolkonepiu/best-of-mcp-servers", + "stars": 0, + "category": "community", + "type": "ranked-list", + "tags": ["410-servers", "500k-stars", "34-categories", "ranked", "weekly-updates"], + "description": "Ranked list of 410 MCP servers with 500K total stars, updated weekly with quality scores", + "install_cmd": null + }, + { + "name": "awesome-mcp-servers", + "owner": "wong2", + "url": "https://github.com/wong2/awesome-mcp-servers", + "stars": 3600, + "category": "community", + "type": "curated-list", + "tags": ["curated", "standardized"], + "description": "Curated list of MCP servers with standardized implementations", + "install_cmd": null + }, + { + "name": "awesome-mcp-servers", + "owner": "punkpeye", + "url": "https://github.com/punkpeye/awesome-mcp-servers", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["collection"], + "description": "Collection of MCP servers", + "install_cmd": null + }, + { + "name": "awesome-mcp-servers", + "owner": "habitoai", + "url": "https://github.com/habitoai/awesome-mcp-servers", + "stars": 0, + "category": "community", + "type": "curated-list", + "tags": ["curated", "external-data"], + "description": "Curated list enabling AI models to connect with external data sources", + "install_cmd": null + }, + { + "name": "awesome-mcp-servers", + "owner": "appcypher", + "url": "https://github.com/appcypher/awesome-mcp-servers", + "stars": 0, + "category": "community", + "type": "awesome-list", + "tags": ["awesome", "curated"], + "description": "Awesome MCP Servers curated list", + "install_cmd": null + }, + { + "name": "mcp-star", + "owner": "yzfly", + "url": "https://github.com/yzfly/mcp-star", + "stars": 0, + "category": "community", + "type": "curated", + "tags": ["high-quality", "curated"], + "description": "Curated collection of high-quality MCP servers", + "install_cmd": null + }, + { + "name": "MCPJungle", + "owner": "mcpjungle", + "url": "https://github.com/mcpjungle/MCPJungle", + "stars": 0, + "category": "infrastructure", + "type": "registry-gateway", + "tags": ["self-hosted", "enterprise", "registry", "proxy", "unified-gateway", "development", "docker"], + "description": "Self-hosted MCP registry and proxy for enterprise - unified gateway at /mcp endpoint", + "install_cmd": null + }, + { + "name": "metamcp", + "owner": "metatool-ai", + "url": "https://github.com/metatool-ai/metamcp", + "stars": 0, + "category": "infrastructure", + "type": "middleware", + "tags": ["middleware", "aggregator", "orchestrator", "docker", "gui", "development"], + "description": "All-in-one MCP middleware with GUI - groups servers, unified endpoints (SSE, HTTP, OpenAPI), auth, inspection", + "install_cmd": null + }, + { + "name": "slack-mcp-server", + "owner": "korotovsky", + "url": "https://github.com/korotovsky/slack-mcp-server", + "stars": 0, + "category": "specialized", + "type": "integration", + "tags": ["slack", "no-permissions", "apps-support", "govslack"], + "description": "Most powerful Slack MCP server - no permission requirements, Apps support, GovSlack, smart history", + "install_cmd": null + }, + { + "name": "slack-mcp-server", + "owner": "jtalk22", + "url": "https://github.com/jtalk22/slack-mcp-server", + "stars": 0, + "category": "specialized", + "type": "integration", + "tags": ["slack", "no-oauth", "no-admin", "dms", "channels"], + "description": "Full Slack access - DMs, channels, search. No OAuth, no admin approval", + "install_cmd": null + }, + { + "name": "claude-code-slack-bot", + "owner": "mpociot", + "url": "https://github.com/mpociot/claude-code-slack-bot", + "stars": 0, + "category": "specialized", + "type": "integration", + "tags": ["slack", "local", "bot"], + "description": "Connect local Claude Code agent with Slack", + "install_cmd": null + }, + { + "name": "ModelContextProtocol.Servers", + "owner": "AI-App", + "url": "https://github.com/AI-App/ModelContextProtocol.Servers", + "stars": 0, + "category": "alternative", + "type": "implementation", + "tags": ["alternative-implementation"], + "description": "Alternative MCP servers implementation", + "install_cmd": null + }, + { + "name": "modelcontextprotocol-servers", + "owner": "riza-io", + "url": "https://github.com/riza-io/modelcontextprotocol-servers", + "stars": 0, + "category": "alternative", + "type": "implementation", + "tags": ["alternative-implementation"], + "description": "Alternative MCP servers implementation", + "install_cmd": null + } + ], + "web_directories": [ + { + "name": "Awesome MCP Servers", + "url": "https://mcpservers.org/", + "description": "Web directory for discovering MCP servers" + }, + { + "name": "MCP Server Finder", + "url": "https://www.mcpserverfinder.com/", + "description": "Search and discovery tool for MCP servers" + }, + { + "name": "Claude FA.ST", + "url": "https://claudefa.st/blog/tools/mcp-extensions/best-addons", + "description": "50+ Best MCP Servers for Claude Code in 2026" + }, + { + "name": "MCP Market", + "url": "https://mcpmarket.com/leaderboards", + "description": "Top 100 MCP Servers Leaderboard" + }, + { + "name": "PulseMCP", + "url": "https://www.pulsemcp.com/", + "description": "Directory and discovery platform for MCP servers" + } + ] +} diff --git a/ecosystem/metadata.json b/ecosystem/metadata.json new file mode 100644 index 0000000..730a0e6 --- /dev/null +++ b/ecosystem/metadata.json @@ -0,0 +1,22 @@ +{ + "last_updated": "2026-02-15T18:30:00Z", + "last_run_by": "manual research", + "stats": { + "total_plugin_repos": 50, + "total_agent_repos": 30, + "total_skill_repos": 24, + "total_skills_tracked": 59375, + "total_mcp_servers": 410, + "total_marketplaces": 10, + "combined_github_stars": 500000 + }, + "update_frequency": "weekly", + "next_scheduled_update": "2026-02-22", + "sources": [ + "GitHub Search API", + "skills.sh leaderboard", + "Anthropic documentation", + "Community awesome lists" + ], + "version": "1.0.0" +} diff --git a/ecosystem/plugins.json b/ecosystem/plugins.json new file mode 100644 index 0000000..1af5cb9 --- /dev/null +++ b/ecosystem/plugins.json @@ -0,0 +1,281 @@ +{ + "last_updated": "2026-02-15", + "total_repos": 30, + "repositories": [ + { + "name": "claude-code", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-code", + "stars": 66800, + "category": "official", + "type": "core", + "tags": ["cli", "main", "anthropic", "development"], + "description": "Main Claude Code repository - agentic coding tool", + "install_cmd": null + }, + { + "name": "everything-claude-code", + "owner": "affaan-m", + "url": "https://github.com/affaan-m/everything-claude-code", + "stars": 39500, + "category": "community", + "type": "collection", + "tags": ["agents", "skills", "hooks", "comprehensive", "hackathon-winner", "development", "testing"], + "description": "Complete config collection - 912 tests, 98% coverage, hackathon winner", + "install_cmd": "/plugin install affaan-m/everything-claude-code" + }, + { + "name": "awesome-claude-code", + "owner": "hesreallyhim", + "url": "https://github.com/hesreallyhim/awesome-claude-code", + "stars": 21600, + "category": "community", + "type": "awesome-list", + "tags": ["curated", "comprehensive", "resources", "development"], + "description": "Comprehensive curated collection of slash commands, workflows, resources", + "install_cmd": null + }, + { + "name": "claude-plugins-official", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-plugins-official", + "stars": 7500, + "category": "official", + "type": "marketplace", + "tags": ["official", "anthropic", "marketplace", "development"], + "description": "Official Anthropic-managed plugin directory", + "install_cmd": null + }, + { + "name": "claude-code-action", + "owner": "anthropics", + "url": "https://github.com/anthropics/claude-code-action", + "stars": 5700, + "category": "official", + "type": "ci-cd", + "tags": ["github-action", "ci-cd", "official", "github-actions"], + "description": "Official GitHub Action for Claude Code CI/CD integration", + "install_cmd": null + }, + { + "name": "gmickel-claude-marketplace", + "owner": "gmickel", + "url": "https://github.com/gmickel/gmickel-claude-marketplace", + "stars": 482, + "category": "community", + "type": "marketplace", + "tags": ["flow-next", "ralph", "autonomous", "multi-model", "development"], + "description": "Flow-Next workflows, Ralph autonomous mode, multi-model review gates", + "install_cmd": "/plugin marketplace add gmickel/gmickel-claude-marketplace" + }, + { + "name": "awesome-claude-code-plugins", + "owner": "ccplugins", + "url": "https://github.com/ccplugins/awesome-claude-code-plugins", + "stars": 434, + "category": "community", + "type": "awesome-list", + "tags": ["curated", "commands", "subagents", "mcp", "development"], + "description": "Curated list of slash commands, subagents, MCP servers, hooks", + "install_cmd": null + }, + { + "name": "superpowers-marketplace", + "owner": "obra", + "url": "https://github.com/obra/superpowers-marketplace", + "stars": 99, + "category": "community", + "type": "marketplace", + "tags": ["curated", "skills", "framework"], + "description": "Curated plugin marketplace with 20+ skills", + "install_cmd": "/plugin marketplace add obra/superpowers-marketplace" + }, + { + "name": "claude-code-plugin-template", + "owner": "ivan-magda", + "url": "https://github.com/ivan-magda/claude-code-plugin-template", + "stars": 0, + "category": "development", + "type": "template", + "tags": ["template", "scaffolding", "ci-cd", "development"], + "description": "GitHub template for creating plugins with CI/CD workflows", + "install_cmd": null + }, + { + "name": "cc-marketplace-boilerplate", + "owner": "halans", + "url": "https://github.com/halans/cc-marketplace-boilerplate", + "stars": 0, + "category": "development", + "type": "template", + "tags": ["boilerplate", "template", "starter", "development"], + "description": "Minimal boilerplate for creating and distributing plugins", + "install_cmd": null + }, + { + "name": "claude-starter-kit", + "owner": "serpro69", + "url": "https://github.com/serpro69/claude-starter-kit", + "stars": 0, + "category": "development", + "type": "starter", + "tags": ["mcp", "skills", "complete-setup", "development"], + "description": "Complete starter with MCP servers, skills, agents, commands", + "install_cmd": null + }, + { + "name": "ai-coding-project-boilerplate", + "owner": "shinpr", + "url": "https://github.com/shinpr/ai-coding-project-boilerplate", + "stars": 0, + "category": "development", + "type": "boilerplate", + "tags": ["typescript", "production-ready", "agents", "development"], + "description": "Production-ready TypeScript boilerplate with specialized agents", + "install_cmd": null + }, + { + "name": "ralph-loop-setup", + "owner": "MarioGiancini", + "url": "https://github.com/MarioGiancini/ralph-loop-setup", + "stars": 0, + "category": "autonomous", + "type": "workflow", + "tags": ["ralph", "autonomous", "tdd", "loops", "development", "testing"], + "description": "Autonomous TDD workflows with multi-model review gates", + "install_cmd": "/plugin install MarioGiancini/ralph-loop-setup" + }, + { + "name": "flow-next-opencode", + "owner": "gmickel", + "url": "https://github.com/gmickel/flow-next-opencode", + "stars": 0, + "category": "autonomous", + "type": "workflow", + "tags": ["flow-next", "plan-first", "autonomous", "development"], + "description": "Plan-first workflows, overnight coding, context re-anchoring", + "install_cmd": null + }, + { + "name": "claude-code-marketplace", + "owner": "netresearch", + "url": "https://github.com/netresearch/claude-code-marketplace", + "stars": 0, + "category": "community", + "type": "marketplace", + "tags": ["catalog", "skills", "indexing"], + "description": "Curated catalog indexing individual skill repositories", + "install_cmd": "/plugin marketplace add netresearch/claude-code-marketplace" + }, + { + "name": "claude-code-marketplace", + "owner": "ivan-magda", + "url": "https://github.com/ivan-magda/claude-code-marketplace", + "stars": 0, + "category": "community", + "type": "marketplace", + "tags": ["personal", "curated"], + "description": "Personal curated plugin collection", + "install_cmd": "/plugin marketplace add ivan-magda/claude-code-marketplace" + }, + { + "name": "cc-marketplace", + "owner": "ananddtyagi", + "url": "https://github.com/ananddtyagi/cc-marketplace", + "stars": 0, + "category": "community", + "type": "marketplace", + "tags": ["marketplace"], + "description": "Marketplace repo for Claude Code plugins", + "install_cmd": "/plugin marketplace add ananddtyagi/cc-marketplace" + }, + { + "name": "awesome-claude-plugins", + "owner": "quemsah", + "url": "https://github.com/quemsah/awesome-claude-plugins", + "stars": 0, + "category": "community", + "type": "tracking", + "tags": ["automated", "metrics", "tracking"], + "description": "Automated tracking of 4,961 repositories with n8n workflows", + "install_cmd": null + }, + { + "name": "awesome-claude-code", + "owner": "jqueryscript", + "url": "https://github.com/jqueryscript/awesome-claude-code", + "stars": 0, + "category": "community", + "type": "awesome-list", + "tags": ["curated", "tools", "ide-integrations"], + "description": "Curated list of tools, IDE integrations, frameworks", + "install_cmd": null + }, + { + "name": "awesome-claude-code", + "owner": "LangGPT", + "url": "https://github.com/LangGPT/awesome-claude-code", + "stars": 0, + "category": "community", + "type": "awesome-list", + "tags": ["curated", "projects", "prompts"], + "description": "Resources, projects, prompts, agents, commands", + "install_cmd": null + }, + { + "name": "claude-plugins", + "owner": "sgaunet", + "url": "https://github.com/sgaunet/claude-plugins", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["agents", "skills", "commands"], + "description": "Specialized plugins for enhanced development workflow", + "install_cmd": null + }, + { + "name": "cc-plugins", + "owner": "yanmxa", + "url": "https://github.com/yanmxa/cc-plugins", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["automation", "lazy-dev"], + "description": "Plugins for lazy developers - automate and capture workflows", + "install_cmd": null + }, + { + "name": "CCPlugins", + "owner": "brennercruvinel", + "url": "https://github.com/brennercruvinel/CCPlugins", + "stars": 0, + "category": "community", + "type": "collection", + "tags": ["time-saving", "framework"], + "description": "Time-saving framework for development", + "install_cmd": null + }, + { + "name": "awesome-claude-plugins", + "owner": "ComposioHQ", + "url": "https://github.com/ComposioHQ/awesome-claude-plugins", + "stars": 0, + "category": "community", + "type": "awesome-list", + "tags": ["commands", "agents", "hooks", "mcp"], + "description": "Curated list extending Claude Code with custom components", + "install_cmd": null + }, + { + "name": "my-claude-code-setup", + "owner": "centminmod", + "url": "https://github.com/centminmod/my-claude-code-setup", + "stars": 0, + "category": "community", + "type": "starter", + "tags": ["template", "memory-bank", "configuration"], + "description": "Shared starter template and CLAUDE.md memory bank", + "install_cmd": null + } + ] +} diff --git a/ecosystem/research/2026-02-15-claude-code-ecosystem-discovery.md b/ecosystem/research/2026-02-15-claude-code-ecosystem-discovery.md new file mode 100644 index 0000000..b236dc2 --- /dev/null +++ b/ecosystem/research/2026-02-15-claude-code-ecosystem-discovery.md @@ -0,0 +1,541 @@ +# Claude Code Ecosystem Discovery + +**Date:** 2026-02-15 +**Purpose:** Comprehensive survey of the Claude Code plugins and marketplace ecosystem on GitHub + +## Claude Code Plugins & Marketplaces + +### Official Anthropic Repositories + +- **[anthropics/claude-code](https://github.com/anthropics/claude-code)** (⭐ 66.8k) - Main Claude Code repository. An agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows through natural language commands. + +- **[anthropics/claude-plugins-official](https://github.com/anthropics/claude-plugins-official)** (⭐ 7.5k) - Official, Anthropic-managed directory of high quality Claude Code Plugins. The official marketplace that is automatically available when you start Claude Code. + +- **[anthropics/claude-code-action](https://github.com/anthropics/claude-code-action)** (⭐ 5.7k) - Official GitHub Action for Claude Code integration, enabling CI/CD workflows with Claude Code. + +### Community Awesome Lists + +- **[hesreallyhim/awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)** (⭐ 21.6k) - Comprehensive curated collection of slash commands, CLAUDE.md files, CLI tools, workflows, and productivity resources designed to enhance Claude Code development workflows. Includes resources like Claude Hub for AI-powered code assistance. + +- **[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)** (⭐ 39.5k) - Complete Claude Code configuration collection with agents, skills, hooks, commands, rules, and MCPs. Battle-tested configs from an Anthropic hackathon winner (Cerebral Valley x Anthropic, Feb 2026). Contains 912 tests, 98% coverage, and 102 static analysis rules. Can be installed as a Claude Code plugin. + +- **[quemsah/awesome-claude-plugins](https://github.com/quemsah/awesome-claude-plugins)** - Automated collection of Claude Code plugin adoption metrics across GitHub repositories using n8n workflows. Tracks and compiles data on plugin adoption. Last updated February 13, 2026 with 4,961 total repositories indexed. + +- **[ccplugins/awesome-claude-code-plugins](https://github.com/ccplugins/awesome-claude-code-plugins)** (⭐ 434) - Curated list of slash commands, subagents, MCP servers, and hooks for Claude Code. Well-maintained central collection of Claude Code plugins and extensions. + +- **[jqueryscript/awesome-claude-code](https://github.com/jqueryscript/awesome-claude-code)** - Curated list of awesome tools, IDE integrations, frameworks, and other resources for developers working with Anthropic's Claude Code. + +- **[LangGPT/awesome-claude-code](https://github.com/LangGPT/awesome-claude-code)** - Awesome Claude Code Resources, Projects, Prompts, Agents, Commands - everything about Claude Code (by 云中江树). + +### Community Marketplaces + +- **[obra/superpowers-marketplace](https://github.com/obra/superpowers-marketplace)** (⭐ 99) - Curated Claude Code plugin marketplace. Describes itself as "An agentic skills framework & software development methodology that works." + +- **[netresearch/claude-code-marketplace](https://github.com/netresearch/claude-code-marketplace)** - Curated Agent Skills collection for AI-assisted development, for Claude Code and other AI agents by Netresearch. Serves as a curated catalog where Claude Code reads the marketplace.json file. + +- **[ivan-magda/claude-code-marketplace](https://github.com/ivan-magda/claude-code-marketplace)** - Personally curated and maintained collection of Claude Code plugins (formerly "claude-superpowers"). + +- **[ananddtyagi/cc-marketplace](https://github.com/ananddtyagi/cc-marketplace)** - Marketplace repo for Claude Code Plugins. + +- **[gmickel/gmickel-claude-marketplace](https://github.com/gmickel/gmickel-claude-marketplace)** (⭐ 482) - Claude Code plugins for reliable AI coding. Features Flow-Next (plan-first workflows), Ralph autonomous mode (overnight coding with fresh context), multi-model review gates via RepoPrompt/Codex, re-anchoring to prevent drift, and receipt-based gating. + +### Plugin Development Templates & Boilerplates + +- **[ivan-magda/claude-code-plugin-template](https://github.com/ivan-magda/claude-code-plugin-template)** - GitHub template for creating Claude Code plugin marketplaces. Includes plugin scaffolding, validation commands, hooks, skills, agents, and CI/CD workflows. Ready-to-use toolkit for teams distributing Claude Code plugins. + +- **[halans/cc-marketplace-boilerplate](https://github.com/halans/cc-marketplace-boilerplate)** - A Claude Code Marketplace Boilerplate template project, including a starter plugin with an agent, commands, hooks, and skills. Minimal boilerplate for creating and distributing Claude Code plugins via marketplace. + +- **[serpro69/claude-starter-kit](https://github.com/serpro69/claude-starter-kit)** - Starter template repo for all your Claude Code needs: configs, skills, agents, and more. Ships with MCP servers, development-related skills, task orchestration tooling, hooks, and slash commands — all configured and wired together. + +- **[shinpr/ai-coding-project-boilerplate](https://github.com/shinpr/ai-coding-project-boilerplate)** - Production-ready TypeScript boilerplate for Claude Code with specialized AI agents. Engineered to maximize AI coding productivity while maintaining human-level code quality. + +### Specialized Plugin Collections + +- **[sgaunet/claude-plugins](https://github.com/sgaunet/claude-plugins)** - A curated collection of specialized Claude Code plugins designed to enhance development workflow with intelligent agents, skills, and commands. + +- **[cbrake/claude-plugins](https://github.com/cbrake/claude-plugins)** - Claude Code Plugins for development. + +- **[yanmxa/cc-plugins](https://github.com/yanmxa/cc-plugins)** - Claude Code plugins for lazy developers (in a good way) - automate and capture workflows to reclaim your time. + +- **[brennercruvinel/CCPlugins](https://github.com/brennercruvinel/CCPlugins)** - Best Claude Code framework that actually saves time. Built by a dev tired of typing "please act like a senior engineer" in every conversation. + +- **[ComposioHQ/awesome-claude-plugins](https://github.com/ComposioHQ/awesome-claude-plugins)** - A curated list of Plugins that let you extend Claude Code with custom commands, agents, hooks, and MCP servers through the plugin system. + +- **[centminmod/my-claude-code-setup](https://github.com/centminmod/my-claude-code-setup)** - Shared starter template configuration and CLAUDE.md memory bank system for Claude Code. + +### Skills & Commands + +- **[BehiSecc/awesome-claude-skills](https://github.com/BehiSecc/awesome-claude-skills)** - A curated list of Claude Skills. + +- **[ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills)** - A curated list of awesome Claude Skills, resources, and tools for customizing Claude AI workflows. + +- **[travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills)** - A curated list of awesome Claude Skills, resources, and tools for customizing Claude AI workflows — particularly Claude Code. + +- **[abubakarsiddik31/claude-skills-collection](https://github.com/abubakarsiddik31/claude-skills-collection)** - A curated collection of official and community-built Claude Skills – extend Anthropic's Claude with powerful, modular capabilities for productivity, creativity, coding, and more. + +### Autonomous & Advanced Workflows + +- **[MarioGiancini/ralph-loop-setup](https://github.com/MarioGiancini/ralph-loop-setup)** - Claude Code plugin for installing autonomous TDD workflows (Ralph loops) into any project. Ralph is an autonomous harness that loops over tasks with multi-model review gates. + +- **[gmickel/flow-next-opencode](https://github.com/gmickel/flow-next-opencode)** - OpenCode port of Flow-Next: plan-first workflows, Ralph autonomous mode (overnight coding with fresh context), multi-model review gates via Codex, re-anchoring to prevent drift, receipt-based gating. + +## Model Context Protocol (MCP) Ecosystem + +### Official MCP Repositories + +- **[modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers)** - Official Model Context Protocol Servers repository. Collection of reference implementations for the Model Context Protocol (MCP), including references to community-built servers and additional resources. Reference servers include: Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking, and Time. + +- **[modelcontextprotocol/registry](https://github.com/modelcontextprotocol/registry)** - A community driven registry service for Model Context Protocol (MCP) servers. Provides MCP clients with a list of MCP servers, like an app store. + +### MCP Server Collections + +- **[wong2/awesome-mcp-servers](https://github.com/wong2/awesome-mcp-servers)** (⭐ 3.6k) - A curated list of Model Context Protocol (MCP) servers, which are tools that enable AI models to interact with various external services and resources through standardized implementations. + +- **[tolkonepiu/best-of-mcp-servers](https://github.com/tolkonepiu/best-of-mcp-servers)** - A ranked list of MCP servers, updated weekly. Contains 410 awesome MCP servers with a total of 500K stars grouped into 34 categories. All projects are ranked by a project-quality score calculated from various metrics automatically collected from GitHub and package managers. + +- **[punkpeye/awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)** - A collection of MCP servers. + +- **[habitoai/awesome-mcp-servers](https://github.com/habitoai/awesome-mcp-servers)** - A curated list of Model Context Protocol (MCP) servers and tools. Discover and explore various MCP implementations that enable AI models to connect with external data sources and tools. + +- **[appcypher/awesome-mcp-servers](https://github.com/appcypher/awesome-mcp-servers)** - Awesome MCP Servers - A curated list of Model Context Protocol servers. + +- **[yzfly/mcp-star](https://github.com/yzfly/mcp-star)** - Curated collection of high-quality Model Context Protocol (MCP) servers. + +### MCP Registries & Gateways + +- **[mcpjungle/MCPJungle](https://github.com/mcpjungle/MCPJungle)** - Self-hosted MCP Registry and Proxy for enterprise AI Agents. Uses Client-Server architecture where the MCPJungle server manages all registered MCP servers and provides a unified MCP gateway for AI Agents to discover and call tools. The gateway runs over streamable HTTP transport accessible at the /mcp endpoint. + +- **[metatool-ai/metamcp](https://github.com/metatool-ai/metamcp)** - MetaMCP is the one unified middleware MCP server that manages your MCP connections with GUI. All-in-one MCP aggregator/orchestrator/middleware & gateway packaged for Docker. Groups multiple MCP servers into namespaces, exposes unified endpoints (SSE, Streamable HTTP, OpenAPI), and supports middlewares, auth (API-Key & OIDC), and inspection tools. + +### Specialized MCP Servers + +- **[korotovsky/slack-mcp-server](https://github.com/korotovsky/slack-mcp-server)** - The most powerful MCP Slack Server with no permission requirements, Apps support, GovSlack, DMs, Group DMs, and smart history fetch logic. + +- **[jtalk22/slack-mcp-server](https://github.com/jtalk22/slack-mcp-server)** - Full Slack access for Claude - DMs, channels, search. No OAuth. No admin approval. Just works. + +- **[mpociot/claude-code-slack-bot](https://github.com/mpociot/claude-code-slack-bot)** - Connect your local Claude Code agent with Slack. + +### MCP Implementation Alternatives + +- **[AI-App/ModelContextProtocol.Servers](https://github.com/AI-App/ModelContextProtocol.Servers)** - Model Context Protocol Servers (alternative implementation). + +- **[riza-io/modelcontextprotocol-servers](https://github.com/riza-io/modelcontextprotocol-servers)** - Model Context Protocol Servers (alternative implementation). + +## Discovery Resources & Directories + +- **[Claude Code Marketplaces](https://claudemarketplaces.com/)** - Directory of Claude Code plugin marketplaces. Only marketplaces with 5 or more GitHub stars are included, ensuring listed marketplaces have demonstrated community interest and reliability. + +- **[Awesome MCP Servers](https://mcpservers.org/)** - Web directory for discovering MCP servers. + +- **[MCP Server Finder](https://www.mcpserverfinder.com/)** - Search and discovery tool for MCP servers. + +- **[Awesome Claude](https://awesomeclaude.ai/awesome-claude-code)** - Visual directory of Awesome Claude Code resources. + +- **[ClaudeLog](https://claudelog.com/claude-code-mcps/awesome-claude-code/)** - Awesome Claude Code MCPs directory. + +- **[Claude FA.ST](https://claudefa.st/blog/tools/mcp-extensions/best-addons)** - 50+ Best MCP Servers for Claude Code in 2026. + +- **[MCP Market](https://mcpmarket.com/leaderboards)** - Top 100 MCP Servers Leaderboard. + +- **[PulseMCP](https://www.pulsemcp.com/)** - Directory and discovery platform for MCP servers. + +- **[Build with Claude](https://www.buildwithclaude.com/marketplaces)** - Plugin Marketplaces directory. + +- **[Claude Code Marketplace](https://claudecodemarketplace.com/)** - Claude Code Plugins directory. + +- **[AI Templates](https://www.aitmpl.com/)** - Claude Code Templates - Supercharge Your AI-Powered Development. + +## Key Insights + +### Ecosystem Maturity +The Claude Code ecosystem has experienced rapid growth, with the main repository (anthropics/claude-code) reaching 66.8k stars and numerous community-driven projects emerging. The ecosystem features both official Anthropic resources and a vibrant community creating plugins, marketplaces, and tooling. + +### Plugin Distribution +Plugins can be distributed through: +1. **Official Marketplace** (claude-plugins-official) - Anthropic-managed, automatically available +2. **Community Marketplaces** - Git repositories with `.claude-plugin/marketplace.json` +3. **Individual Repositories** - Direct installation via GitHub URLs + +### Quality Standards +The ecosystem has developed quality standards: +- Marketplace directory listings require minimum 5 GitHub stars +- Anthropic provides "Verified" badges for reviewed plugins +- Community projects showcase test coverage and quality metrics (e.g., everything-claude-code with 98% coverage) + +### MCP Integration +Model Context Protocol (MCP) has become a standard integration layer, with: +- 410+ MCP servers catalogued +- Multiple registry/gateway solutions (MCPJungle, MetaMCP) +- Official reference implementations and community variations +- Specialized servers for popular tools (GitHub, Slack, Filesystem, etc.) + +### Development Tools +The ecosystem provides comprehensive development resources: +- Multiple plugin templates and boilerplates +- Starter kits with pre-configured environments +- Validation and CI/CD workflows +- Testing frameworks and quality tooling + +### Autonomous Workflows +Advanced patterns emerging: +- Ralph loops for autonomous overnight coding +- Multi-model review gates +- Plan-first workflows (Flow-Next) +- Context re-anchoring to prevent drift +- Receipt-based gating for quality control + +### Community Organization +The "awesome" list pattern has been widely adopted: +- Multiple curated collections (21.6k+ stars for hesreallyhim/awesome-claude-code) +- Automated tracking of adoption metrics +- Category-based organization +- Ranked lists with quality scores + +## Agent Skills Ecosystem (skills.sh) + +### Overview + +The Agent Skills ecosystem has experienced explosive growth since the official launch on October 16, 2025, and the subsequent release of **skills.sh** on January 20, 2026. Within six hours of skills.sh's announcement, the top skill had accumulated 20,900 installs. As of February 2026, the ecosystem tracks **59,375+ total skills** across multiple categories, with the leading skill (find-skills) reaching **231,100 installations**. + +Skills function as "folders of instructions, scripts, and resources that Claude loads dynamically to improve performance on specialized tasks," effectively serving as npm-style packages for AI agent capabilities. The ecosystem supports 20+ AI platforms including Claude Code, Cursor, Codex, Antigravity, Gemini CLI, and GitHub Copilot. + +**Installation**: `npx skillsadd ` + +### Top Skills from skills.sh + +The following skills represent the highest-performing entries by installation count from the [skills.sh leaderboard](https://skills.sh/): + +#### Tier 1: 100K+ Installations + +1. **[find-skills](https://github.com/vercel-labs/skills)** (231,100 installs) - Locates and discovers available skills within the ecosystem. Essential meta-skill for skill discovery and management. + +2. **[vercel-react-best-practices](https://github.com/vercel-labs/agent-skills)** (133,600 installs) - Guides on optimal React patterns and conventions from the Vercel engineering team. + +3. **[web-design-guidelines](https://github.com/vercel-labs/agent-skills)** (100,600 installs) - Standards for web design implementation covering layout, typography, color theory, and accessibility. + +#### Tier 2: 50K-100K Installations + +4. **[remotion-best-practices](https://github.com/remotion-dev/skills)** (91,400 installs) - Practices for video creation with the Remotion framework, enabling programmatic video generation. + +5. **[frontend-design](https://github.com/anthropics/skills)** (70,000 installs) - Official Anthropic skill teaching Claude to avoid generic aesthetics and make bold, intentional design decisions. + +#### Tier 3: 25K-50K Installations + +6. **[vercel-composition-patterns](https://github.com/vercel-labs/agent-skills)** (40,900 installs) - Component composition methodologies for React and Next.js applications. + +7. **[agent-browser](https://github.com/vercel-labs/agent-browser)** (36,600 installs) - Browser automation and interaction capabilities for web scraping and testing. + +8. **[skill-creator](https://github.com/anthropics/skills)** (34,500 installs) - Official Anthropic interactive tool guiding developers through building new skills with Q&A workflow. + +9. **[browser-use](https://github.com/browser-use/browser-use)** (30,100 installs) - Browser functionality utilization framework for web automation tasks. + +10. **[vercel-react-native-skills](https://github.com/vercel-labs/agent-skills)** (29,500 installs) - React Native development guidance covering mobile-specific patterns. + +11. **[ui-ux-pro-max](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill)** (26,000 installs) - Advanced UI/UX design methodologies with emphasis on modern design systems. + +#### Tier 4: 10K-25K Installations + +12. **[audit-website](https://github.com/squirrelscan/skills)** (20,200 installs) - Website analysis and quality assessment for performance, accessibility, and SEO. + +13. **[brainstorming](https://github.com/obra/superpowers)** (19,900 installs) - Part of obra's superpowers collection; provides ideation and creative problem-solving support. + +14. **[seo-audit](https://github.com/coreyhaines31/marketingskills)** (19,000 installs) - Search engine optimization analysis and recommendations. + +15. **[supabase-postgres-best-practices](https://github.com/supabase/agent-skills)** (17,800 installs) - PostgreSQL and Supabase optimization guidance from the Supabase team. + +16. **[pdf](https://github.com/anthropics/skills)** (14,900 installs) - Official Anthropic production-ready skill for comprehensive PDF document processing (extract text/tables, merge, split, handle forms). + +17. **[copywriting](https://github.com/coreyhaines31/marketingskills)** (13,900 installs) - Marketing copy and content creation following proven frameworks. + +18. **[pptx](https://github.com/anthropics/skills)** (12,300 installs) - Official Anthropic skill for creating, editing, and analyzing PowerPoint presentations with layouts, templates, and charts. + +19. **[next-best-practices](https://github.com/vercel-labs/next-skills)** (12,200 installs) - Next.js framework optimization patterns from the Vercel team. + +20. **[better-auth-best-practices](https://github.com/better-auth/skills)** (11,600 installs) - Authentication implementation guidance covering OAuth, JWT, session management. + +21. **[docx](https://github.com/anthropics/skills)** (11,400 installs) - Official Anthropic skill for Word document creation and manipulation with tracked changes, comments, and formatting. + +22. **[agent-tools](https://github.com/inference-sh-0/skills)** (11,300 installs) - Utility tools for general agent functionality and workflow automation. + +23. **[xlsx](https://github.com/anthropics/skills)** (11,300 installs) - Official Anthropic spreadsheet creation and processing with formulas, formatting, and data analysis. + +24. **[systematic-debugging](https://github.com/obra/superpowers)** (11,000 installs) - Part of obra's superpowers; methodical problem diagnosis techniques using TDD and systematic approaches. + +25. **[marketing-psychology](https://github.com/coreyhaines31/marketingskills)** (10,600 installs) - Psychological principles in marketing strategy covering persuasion, decision-making, and user behavior. + +### Major Skill Repository Collections + +#### Official Anthropic Skills +**Repository**: [anthropics/skills](https://github.com/anthropics/skills) +**Stars**: 70,000 | **Forks**: 7,100 | **Language**: Python (91.3%) + +The authoritative source for Claude skills, containing production-ready document skills (docx, pdf, pptx, xlsx), creative tools (algorithmic-art, canvas-design, slack-gif-creator), development utilities (frontend-design, web-artifacts-builder, mcp-builder, webapp-testing), and communication skills (brand-guidelines, internal-comms). + +**Installation**: `/plugin marketplace add anthropics/skills` + +#### Awesome Claude Skills (Community Curated) +**Repository**: [travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) +**Stars**: 7,100 | **Forks**: 495 | **Created**: October 16, 2025 + +Comprehensive curated list featuring obra/superpowers (20+ battle-tested skills), ios-simulator-skill, ffuf-web-fuzzing, playwright-skill, claude-d3js-skill, claude-scientific-skills, web-asset-generator, loki-mode (37 agents across 6 swarms), and Trail of Bits Security Skills. + +#### SecondSky Production-Ready Collection +**Repository**: [secondsky/claude-skills](https://github.com/secondsky/claude-skills) +**Stars**: 51 | **Version**: 3.2.0 (Feb 7, 2026) | **Language**: TypeScript (62.6%) + +Comprehensive collection of **167 production-ready skills** across 18 categories: Tooling (28), Frontend (25), Cloudflare (21), AI Integration (20), Web & Mobile (17). Features auto-discovery system where Claude Code automatically identifies relevant installed skills. + +**Technical Constraint**: Claude Code enforces 15,000-character limit for skill descriptions; can increase to ~30,000 via environment variables. + +#### Alireza Rezvani's Professional Skills +**Repository**: [alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills) + +Collection of **53 production-ready skill packages** focused on business functions: Marketing Skills (6), C-Level Advisory (2), Product Team (5), Project Management (6), plus Engineering, Finance, Business Growth, and QA/Regulatory skills (34+). + +Supports three installation methods: Claude Code native plugins, OpenAI Codex, universal cross-platform installer (9+ AI agents). + +#### VoltAgent Awesome Agent Skills +**Repository**: [VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills) +**Stars**: 7,100 | **Forks**: 545 | **License**: MIT + +Curated collection of **380+ skills** compatible with Claude Code, Codex, Antigravity, Gemini CLI, Cursor, and other AI assistants. Features official team skills from Vercel (React, Next.js, web design), Cloudflare (Workers, Durable Objects), Trail of Bits (security analysis), Hugging Face (ML workflows), and Microsoft (Azure SDK). + +### Skills Ecosystem Analysis + +**Growth Metrics**: +- **Launch**: October 16, 2025 (official skills announcement) +- **Skills.sh Launch**: January 20, 2026 +- **6-hour milestone**: Top skill reached 20,900 installs +- **Current total**: 59,375+ skills tracked +- **Top skill installs**: 231,100 (find-skills) + +**Dominant Publishers**: +1. **Vercel Labs** - React, Next.js, web design leadership +2. **Anthropic** - Official document processing, creative tools, development utilities +3. **Community Collections** - obra/superpowers, secondsky, alirezarezvani +4. **Enterprise Teams** - Cloudflare, Supabase, Microsoft, Hugging Face, Trail of Bits + +**Skill Categories by Popularity**: +1. Framework Best Practices (React, Next.js, Vue) - Highest install counts +2. Document Processing (PDF, DOCX, PPTX, XLSX) - Essential productivity tools +3. Design & UX - Web design, UI/UX, frontend patterns +4. Marketing & Content - SEO, copywriting, analytics +5. Development Tools - Browser automation, testing, debugging +6. Security & Analysis - Static analysis, vulnerability detection +7. Cloud Infrastructure - Cloudflare, Azure, deployment management +8. AI/ML Workflows - Model training, dataset management + +**Quality Considerations**: +- No centralized quality control mechanism +- Ranking primarily based on install count +- Anyone can create and distribute skills via GitHub +- Community curation through "awesome" lists provides filtering + +### Technical Specifications + +**Skill Structure** - Every skill requires a `SKILL.md` file with YAML frontmatter: + +```yaml +--- +name: my-skill-name +description: A clear description of what this skill does and when to use it +--- + +# My Skill Name + +[Instructions that Claude will follow] + +## Examples +- Example usage 1 + +## Guidelines +- Guideline 1 +``` + +**Required Fields**: `name` (unique identifier), `description` (complete description) + +**Character Limits**: +- Default: 15,000 characters for skill descriptions in Claude Code system prompt +- Configurable: Can increase to ~30,000 characters via environment variables +- Implication: Not all skills in large collections may be simultaneously active + +### Future Considerations for Plum + +Given Plum's focus on plugin management for Claude Code, the skills ecosystem presents several opportunities: + +1. **Skill Discovery Integration**: Plum could integrate skills.sh API for in-TUI skill browsing +2. **Bulk Skill Management**: Handle large skill collections (100+ skills) with smart loading +3. **Skill Dependency Resolution**: Track skill compatibility and dependencies +4. **Character Budget Optimization**: Help users manage the 15K character limit intelligently +5. **Quality Signals**: Surface community ratings, GitHub stars, install counts +6. **Skill Composition**: Enable users to create custom skill bundles for specific workflows + +## Sources + +### Plugin & Marketplace Sources +- [Anthropic Claude Code](https://github.com/anthropics/claude-code) +- [Anthropic Official Plugins](https://github.com/anthropics/claude-plugins-official) +- [Hesreallyhim Awesome Claude Code](https://github.com/hesreallyhim/awesome-claude-code) +- [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) +- [Awesome MCP Servers](https://github.com/wong2/awesome-mcp-servers) +- [Best of MCP Servers](https://github.com/tolkonepiu/best-of-mcp-servers) +- [Model Context Protocol Servers](https://github.com/modelcontextprotocol/servers) +- [Claude Code Marketplaces Directory](https://claudemarketplaces.com/) +- [MCP Servers.org](https://mcpservers.org/) +- [Claude Code Documentation](https://code.claude.com/docs/en/discover-plugins) +- [Anthropic Plugin Announcement](https://www.anthropic.com/news/claude-code-plugins) +- [Medium: Claude Code Plugin Ecosystem](https://medium.com/the-context-layer/claude-code-plugin-ecosystem-what-developers-need-to-know-about-the-latest-anthropic-release-55fb7a2b5aae) +- [Skywork AI: Claude Code Plugin Ecosystem](https://skywork.ai/blog/claude-code-plugin-ecosystem-what-is-available-now/) + +### Skills Ecosystem Sources +- [skills.sh](https://skills.sh/) - Official skills leaderboard and directory +- [Vercel Skills Changelog](https://vercel.com/changelog/introducing-skills-the-open-agent-skills-ecosystem) +- [Dev Genius: Vercel Skills Launch Analysis](https://blog.devgenius.io/vercel-just-launched-skills-sh-and-it-already-has-20k-installs-c07e6da7e29e) +- [Claude Code Skills Documentation](https://code.claude.com/docs/en/skills) +- [GitHub: travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) +- [GitHub: anthropics/skills](https://github.com/anthropics/skills) +- [GitHub: secondsky/claude-skills](https://github.com/secondsky/claude-skills) +- [GitHub: alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills) +- [GitHub: VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills) +- [GitHub: ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) +- [Skills.sh Review (2026)](https://vibecoding.app/blog/skills-sh-review) +- [Anthropic Engineering Blog](https://anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) +- [Agent Skills Standard](http://agentskills.io) + +## Claude Agents & Subagents + +### Official Anthropic Repositories + +- **[claude-agent-sdk-python](https://github.com/anthropics/claude-agent-sdk-python)** (⭐ 4.8k) - Official Python SDK for building agentic applications with Claude Code. Enables interaction with Claude's coding assistant through simple query interfaces and advanced bidirectional clients. Features custom tools as in-process MCP servers, hooks for controlling Claude's actions, and built-in CLI bundled automatically. + +- **[claude-agent-sdk-typescript](https://github.com/anthropics/claude-agent-sdk-typescript)** (⭐ 795) - Official TypeScript/Node.js SDK for programmatically building AI agents with Claude Code's capabilities. Create autonomous agents that can understand codebases, edit files, run commands, and execute complex workflows. Used by 597 projects. + +- **[claude-quickstarts](https://github.com/anthropics/claude-quickstarts)** (⭐ 14k) - Collection of production-ready projects to help developers quickly build deployable applications using the Claude API. Includes customer support agents, financial data analysts, computer use demos, browser automation tools, and autonomous coding agents with git-based progress tracking. + +- **[anthropic-cookbook](https://github.com/anthropics/anthropic-cookbook)** (⭐ 32.9k) - Collection of notebooks and recipes showcasing effective ways to use Claude. Includes reference implementations for "Building Effective Agents" with example minimal implementations of common agent workflows, sub-agents patterns, multimodal capabilities, and advanced techniques. + +- **[claude-agent-sdk-demos](https://github.com/anthropics/claude-agent-sdk-demos)** - Multi-agent research system demonstrating coordinated specialized subagents for research and comprehensive report generation. + +### Major Agent Collections & Frameworks + +- **[agents (wshobson)](https://github.com/wshobson/agents)** (⭐ 28.6k) - Comprehensive system for intelligent automation and multi-agent orchestration for Claude Code. Features 73 focused plugins across 24 categories, 112 specialized AI agents, 146 agent skills for progressive knowledge disclosure, 16 workflow orchestrators for complex multi-agent tasks, and 79 development tools. Granular architecture loads only specific agents per plugin for minimal token usage. + +- **[SuperClaude_Framework](https://github.com/SuperClaude-Org/SuperClaude_Framework)** (⭐ 20.8k) - Meta-programming configuration system that enhances Claude Code with structured development capabilities. Provides 30 slash commands covering complete development lifecycle, 16 specialized AI agents, 7 behavioral modes, and optional MCP server integrations for 2-3x faster execution and 30-50% fewer tokens. + +- **[claude-flow](https://github.com/ruvnet/claude-flow)** (⭐ 14.1k) - Leading agent orchestration platform for Claude enabling deployment of 60+ specialized AI agents in coordinated swarms with self-learning capabilities. Features multi-agent coordination with queen-led hierarchies, consensus algorithms (Raft, Byzantine, Gossip), persistent vector memory with 150x-12,500x faster retrieval, and intelligent task routing. + +- **[awesome-claude-code-subagents](https://github.com/VoltAgent/awesome-claude-code-subagents)** (⭐ 10.5k) - Definitive collection of 100+ specialized Claude Code subagents designed for specific development tasks. Spans 10 major categories including core development, language specialists, infrastructure, quality & security, data & AI, developer experience, specialized domains, business & product, meta orchestration, and research & analysis. + +- **[claude-squad](https://github.com/smtg-ai/claude-squad)** (⭐ 6k) - Terminal application for managing multiple AI terminal agents like Claude Code, Aider, Codex, OpenCode, and Amp in isolated workspaces. Enables simultaneous work on multiple tasks with background task completion, centralized instance management, change review capabilities, and isolated git workspaces. + +- **[awesome-claude-agents (vijaythecoder)](https://github.com/vijaythecoder/awesome-claude-agents)** (⭐ 3.8k) - Orchestrated team of 24 specialized AI agents organized into Orchestrators (3 agents), Framework Specialists (13 agents), Universal Experts (4 agents), and Core Team (4 agents). Features automatic stack detection and intelligent agent routing. + +- **[claude-code-by-agents](https://github.com/baryhuang/claude-code-by-agents)** (⭐ 773) - Desktop app and API for multi-agent Claude Code orchestration enabling coordination of local and remote agents through @mentions. Functions as extension to Claude Code for distributed, coordinated development tasks. + +- **[awesome-claude-agents (rahulvrane)](https://github.com/rahulvrane/awesome-claude-agents)** (⭐ 283) - Community-driven collection cataloging plug-and-play agents, agent frameworks, and orchestration recipes. Documents specialized AI "teammates" defined using Markdown and YAML files for delegating complex development tasks. + +- **[claude-007-agents](https://github.com/avivl/claude-007-agents)** (⭐ 237) - Unified AI agent orchestration system featuring specialized agents across 14 categories with advanced coordination intelligence, resilience engineering, and structured logging. Includes intelligent bootstrap system for automatic codebase analysis and agent configuration. + +- **[claude-code-teams-mcp](https://github.com/cs50victor/claude-code-teams-mcp)** (⭐ 164) - MCP server implementation making Claude Code's agent teams protocol available to any MCP client. Reimplements shared task lists, inter-agent messaging, and tmux-based agent spawning as standalone service. + +- **[claude-user-memory](https://github.com/VAMFI/claude-user-memory)** (⭐ 146) - Autonomous agent substrate for Claude Code CLI implementing research-first development approach. Orchestrates 9 specialized agents with Research → Plan → Implement workflow, TDD enforcement, persistent knowledge graph, and claims 4.8-5.5x faster development cycles. + +- **[agents-claude-code](https://github.com/lodetomasi/agents-claude-code)** (⭐ 112) - Collection of 100 hyper-specialized AI agents transforming Claude into personal tech army with experts in React, AWS, Kubernetes, ML, Security, and more. Each agent optimized with appropriate Claude model (Opus/Sonnet/Haiku) for cost efficiency. + +### Specialized Agent Frameworks + +- **[claude-agent-framework](https://github.com/ciscoittech/claude-agent-framework)** (⭐ 8) - Complete framework for building intelligent multi-agent development systems with 97% context reduction and 3-6x faster execution through parallel agents. Automated setup transforms any project into AI-powered system in ~2 minutes. + +- **[claude-agents (gabrielmaialva33)](https://github.com/gabrielmaialva33/claude-agents)** (⭐ 3) - Collection of 34+ specialized AI agents for building artificial development teams across multiple technology stacks. Features automatic technology stack detection and agent configuration. + +### Related Community Projects + +- **[oh-my-claudecode](https://github.com/Yeachan-Heo/oh-my-claudecode)** - Teams-first multi-agent orchestration for Claude Code. + +- **[multi-agent-shogun](https://github.com/yohey-w/multi-agent-shogun)** - Samurai-inspired multi-agent system orchestrating parallel AI tasks via tmux with shogun → karo → ashigaru hierarchy. + +- **[agent-orchestrator-template](https://github.com/shintaro-sprech/agent-orchestrator-template)** - Self-evolving sub-agent management system dynamically creating and integrating agents based on task requirements. + +- **[claude-subagent-system](https://github.com/cemigo114/claude-subagent-system)** - Production-ready Claude Code system automatically generating specialized sub-agents for product development lifecycle stages. + +- **[claude-sub-agent](https://github.com/zhsama/claude-sub-agent)** - AI-driven development workflow system creating multi-agent development pipeline with specialized experts. + +- **[claude-code-sub-agent-collective](https://github.com/vanzan01/claude-code-sub-agent-collective)** - Context engineering research project functioning as collective with hub-and-spoke coordination. + +- **[claude-code-sub-agents](https://github.com/lst97/claude-code-sub-agents)** - Collection of domain-expert subagents for full-stack development, automatically invoked based on context analysis. + +- **[dream-team](https://github.com/drbscl/dream-team)** - Claude Code plugin orchestrating teams of specialized agents for complex development tasks. + +- **[claude-code-agents](https://github.com/vizra-ai/claude-code-agents)** - 59 specialized AI agents that supercharge development workflow. + +- **[myclaude](https://github.com/cexll/myclaude)** - Multi-agent orchestration workflow supporting Claude Code, Codex, Gemini, and OpenCode. + +- **[claude_code_setup](https://github.com/mkXultra/claude_code_setup)** - Workflows and scripts enabling multiple AI agents to work collaboratively through MCP, orchestrating parallel tasks with shared discoveries and automatic iteration. + +- **[clawd-skills](https://github.com/justbecauselabs/clawd-skills)** - Claude Code skills for working with Clawdbot, an AI agent framework bridging messaging platforms (WhatsApp, Telegram, Discord, Slack) with AI coding agents. + +- **[claude-php-agent](https://github.com/claude-php/claude-php-agent)** - Claude PHP Agents Framework including full Model Context Protocol (MCP) server exposing agent capabilities to MCP clients. + +### Community Resources + +- **[Claude Code Swarm Orchestration Skill](https://gist.github.com/kieranklaassen/4f2aba89594a4aea4ad64d753984b2ea)** - Complete guide to multi-agent coordination with TeammateTool, Task system, and all patterns. + +- **[Claude Code Multi-Agent Orchestration System](https://gist.github.com/kieranklaassen/d2b35569be2c7f1412c64861a219d51f)** - Comprehensive orchestration system documentation. + +- **[The Complete Guide to Building Agents with the Anthropic Agent SDK](https://gist.github.com/dabit3/93a5afe8171753d0dbfd41c80033171d)** - Complete guide for building agents with official SDK. + +### Key Agent Ecosystem Observations + +#### Architecture Patterns + +Several dominant patterns have emerged: + +1. **Agent Collections** - Curated sets of specialized agents for different domains (frontend, backend, DevOps, security) +2. **Orchestration Frameworks** - Systems for coordinating multiple agents working together on complex tasks +3. **Multi-Agent Workflows** - Research → Plan → Implement pipelines with specialized agents at each stage +4. **MCP-Based Systems** - Using Model Context Protocol for agent communication and coordination +5. **Granular Plugin Architecture** - Loading only specific agents per plugin to minimize token usage + +#### Performance Claims + +Many frameworks claim significant performance improvements: +- 97% context reduction (claude-agent-framework) +- 3-6x faster execution through parallelization +- 4.8-5.5x faster development cycles (claude-user-memory) +- 2-3x faster execution with MCP integration (SuperClaude) + +#### Technology Coverage + +The ecosystem provides comprehensive coverage across: +- **Frontend**: React, Vue, Angular, Next.js +- **Backend**: Node.js, Python, Django, Laravel, Rails +- **Infrastructure**: AWS, GCP, Azure, Kubernetes, Docker +- **Databases**: PostgreSQL, MongoDB, Redis +- **Languages**: Python, TypeScript/JavaScript, Go, Rust, Java, PHP +- **Specialized**: ML/AI, Security, Blockchain, Game Development + +#### Token Efficiency Focus + +A major focus across projects is token efficiency through: +- Progressive knowledge disclosure +- Loading agents on-demand based on context +- Granular plugin architecture +- Persistent knowledge graphs across sessions + + +### Agent Ecosystem Sources + +- [Claude Agent SDK Python](https://github.com/anthropics/claude-agent-sdk-python) +- [Claude Agent SDK TypeScript](https://github.com/anthropics/claude-agent-sdk-typescript) +- [Claude Quickstarts](https://github.com/anthropics/claude-quickstarts) +- [Anthropic Cookbook - Building Effective Agents](https://github.com/anthropics/anthropic-cookbook/tree/main/patterns/agents) +- [Agents by wshobson](https://github.com/wshobson/agents) +- [SuperClaude Framework](https://github.com/SuperClaude-Org/SuperClaude_Framework) +- [Claude Flow](https://github.com/ruvnet/claude-flow) +- [Awesome Claude Code Subagents](https://github.com/VoltAgent/awesome-claude-code-subagents) +- [Claude Squad](https://github.com/smtg-ai/claude-squad) +- [Awesome Claude Agents (vijaythecoder)](https://github.com/vijaythecoder/awesome-claude-agents) +- [Claude Code by Agents](https://github.com/baryhuang/claude-code-by-agents) +- [Claude Code Teams MCP](https://github.com/cs50victor/claude-code-teams-mcp) +- [Claude User Memory](https://github.com/VAMFI/claude-user-memory) +- [Claude Agent Framework](https://github.com/ciscoittech/claude-agent-framework) diff --git a/ecosystem/research/2026-02-15-claude-skills-ecosystem.md b/ecosystem/research/2026-02-15-claude-skills-ecosystem.md new file mode 100644 index 0000000..4973888 --- /dev/null +++ b/ecosystem/research/2026-02-15-claude-skills-ecosystem.md @@ -0,0 +1,209 @@ +# Claude Skills Ecosystem Research + +**Date:** 2026-02-15 +**Purpose:** Comprehensive survey of Claude Skills repositories and the broader AI agent skills ecosystem on GitHub +**Methodology:** GitHub and web search across multiple query patterns including "Claude skills", "Claude Code skills", "anthropic skill", and related terms + +--- + +## Claude Skills + +A curated collection of notable GitHub repositories related to Claude Skills, Claude Code, and the broader AI agent skills ecosystem. Repositories are ordered by star count (popularity metric). + +### Official Anthropic Resources + +- **[anthropics/skills](https://github.com/anthropics/skills)** (⭐ 70,000) - Anthropic's official implementation of skills for Claude. Contains working skill examples, the Agent Skills specification, and skill templates. Demonstrates capabilities ranging from creative applications (art, music, design) to technical tasks (testing web apps, MCP server generation) to enterprise workflows (communications, branding). Source-available production skills for document creation/editing (DOCX, PDF, PPTX, XLSX). + +- **[anthropics/claude-plugins-official](https://github.com/anthropics/claude-plugins-official)** (⭐ 7,500) - Official, Anthropic-managed directory of high quality Claude Code Plugins. Contains both internal plugins (developed by Anthropic) and external plugins (third-party from partners and community). Provides standardized plugin structure and installation via `/plugin install` commands. + +### Major Community Collections + +- **[affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)** (⭐ 46,200) - Complete Claude Code configuration collection featuring agents, skills, hooks, commands, rules, and MCPs. Battle-tested configs from an Anthropic hackathon winner (February 2026). Includes 13 agents, 37 skills, and 31 commands supporting multiple programming languages (TypeScript, Python, Go, Java, C++, Rust) with continuous learning systems, security auditing tools, and multi-agent orchestration. + +- **[ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills)** (⭐ 34,900) - A comprehensive collection of Claude Skills integrations and extensions covering hundreds of automation directories for various services and platforms—from productivity tools like Asana and Notion to payment processors like Stripe and data analysis platforms. + +- **[wshobson/agents](https://github.com/wshobson/agents)** (⭐ 28,600) - Intelligent automation and multi-agent orchestration for Claude Code. Combines 112 specialized AI agents, 16 multi-agent workflow orchestrators, 146 agent skills, and 79 development tools organized into 73 focused plugins. Enables intelligent automation across software development domains through granular, composable plugin architecture. + +- **[travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills)** (⭐ 7,100) - A curated list of awesome Claude Skills, resources, and tools for customizing Claude AI workflows—particularly Claude Code. Comprehensive guide documenting both official Anthropic skills and community-created skills across categories including document manipulation, design and creative tools, development utilities, and communication aids. Features getting started guides, best practices, and security considerations. + +- **[VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills)** (⭐ 7,100) - Claude Code Skills and 300+ agent skills from official dev teams (Anthropic, Google, Vercel, Cloudflare, Stripe, Hugging Face, Microsoft) and the community. Compatible with Codex, Antigravity, Gemini CLI, Cursor and other AI coding platforms. Curated compilation covering diverse domains including web development, security analysis, ML operations, document processing, and cloud infrastructure management. + +- **[BehiSecc/awesome-claude-skills](https://github.com/BehiSecc/awesome-claude-skills)** (⭐ 5,800) - A curated list of Claude Skills organized across 12+ categories including document handling, development tools, data analysis, scientific research, writing, learning, media, health, collaboration, security, and automation. Functions as a discovery and reference resource for extending Claude's capabilities. + +### Specialized Skill Collections + +- **[alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills)** (⭐ 1,800) - A collection of Skills for Claude Code and Claude AI for real-world usage. Includes 53 modular, production-ready expertise packages organized across marketing, product management, C-level advisory, project management, engineering, and regulatory/quality assurance. Each skill combines comprehensive documentation, Python-based analysis tools (87+ CLI utilities), curated knowledge bases, and ready-to-use templates. Documented ROI improvements of 40% time savings and 30% quality enhancements. + +- **[daymade/claude-code-skills](https://github.com/daymade/claude-code-skills)** (⭐ 580) - Professional Claude Code skills marketplace featuring 37 production-ready skills for enhanced development workflows. Enables developers to accomplish specialized tasks including GitHub operations, document conversion, diagram generation, UI design system extraction, presentation creation, and various automation workflows. Emphasizes the `skill-creator` meta-skill for building custom extensions. + +- **[obra/superpowers-marketplace](https://github.com/obra/superpowers-marketplace)** (⭐ 486) - Curated Claude Code plugin marketplace featuring the core Superpowers plugin (20+ skills and planning commands), Elements of Style (writing guidance), and Claude Code development toolkit. Users add via `/plugin marketplace add obra/superpowers-marketplace`. + +- **[alirezarezvani/claude-code-skill-factory](https://github.com/alirezarezvani/claude-code-skill-factory)** (⭐ 499) - Powerful open-source toolkit for building and deploying production-ready Claude Skills, Code Agents, custom Slash Commands, and LLM Prompts at scale. Features 5 interactive guide agents, 10 slash commands, and 9 pre-built production skills. Streamlines AI agent development through guided workflows and automation. Cross-platform compatible (Claude AI, Claude Code, API) with interoperability bridge to OpenAI's Codex CLI. + +- **[abubakarsiddik31/claude-skills-collection](https://github.com/abubakarsiddik31/claude-skills-collection)** (⭐ 434) - A curated collection of official and community-built Claude Skills extending Claude AI with powerful, modular capabilities for productivity, creativity, coding, and more. Organizes skills across 11 categories including document manipulation, creative design, development tools, data analysis, scientific research, writing, learning, media handling, collaboration, security testing, and automation utilities. + +- **[mhattingpete/claude-skills-marketplace](https://github.com/mhattingpete/claude-skills-marketplace)** (⭐ 357) - Curated marketplace of Claude Code plugins for software engineering workflows including git operations, testing, code review, visual documentation generation, and code manipulation. Features execution runtime enabling local Python code execution with API access, achieving 90-99% token savings for bulk operations. + +- **[K-Dense-AI/claude-skills-mcp](https://github.com/K-Dense-AI/claude-skills-mcp)** (⭐ 315) - MCP (Model Context Protocol) server enabling AI assistants to search and retrieve Claude Agent Skills using vector embeddings. Brings Anthropic's Skills framework to multiple AI platforms (Cursor, Codex, GPT-5, Gemini, etc.). Two-package architecture with lightweight frontend (~15 MB) launching instantly and heavier backend (~250 MB) containing vector search functionality. + +- **[FrancyJGLisboa/agent-skill-creator](https://github.com/FrancyJGLisboa/agent-skill-creator)** (⭐ 265) - Meta-skill that teaches Claude Code to create complete agents with Claude Skills in a fully autonomous way. Transforms repetitive workflows into intelligent, self-improving agents without manual coding. Follows structured 6-phase methodology (discovery, design, architecture, detection, implementation, testing). + +- **[karanb192/awesome-claude-skills](https://github.com/karanb192/awesome-claude-skills)** (⭐ 107) - The definitive collection of 50+ verified Awesome Claude Skills for Claude Code, Claude.ai, and API. Focuses on verified, community-driven skills for TDD, debugging, git workflows, document processing, and more. Emphasizes practical implementation with clear categorization. + +- **[levnikolaevich/claude-code-skills](https://github.com/levnikolaevich/claude-code-skills)** (⭐ 89) - Production-ready skills covering the full delivery workflow from research and discovery to epic planning, task breakdown, implementation, testing, code review, and quality gates. Features 102 coordinated skills across two plugins: full-development-workflow-skills (70 skills) and claude-code-bootstrap (32 skills). Uses Orchestrator-Worker architectural pattern for complete development cycles. + +- **[netresearch/claude-code-marketplace](https://github.com/netresearch/claude-code-marketplace)** (⭐ 20) - Curated collection of Agentic Skills for TYPO3 development, PHP modernization, and technical documentation workflows. Functions as a catalog marketplace indexing individual skill repositories, enabling Claude Code and compatible AI agents to discover domain-specific capabilities. Supports cross-agent compatibility (Claude Code, Cursor, GitHub Copilot, Windsurf). + +- **[meetrais/claude-agent-skills](https://github.com/meetrais/claude-agent-skills)** (⭐ 9) - Repository for Anthropic Claude Skills examples demonstrating how to use Claude's Skills API with both default skills (document generation) and custom skills (extensible functionality). Includes git-analyzer example showcasing intelligent skill selection and comprehensive file handling. + +- **[dashed/claude-marketplace](https://github.com/dashed/claude-marketplace)** (⭐ 7) - A local marketplace for personal Claude Code skills and plugins. Curated collection of Agent Skills including version control tools (git-absorb, git-chain), terminal automation (tmux, zellij), development workflows (conventional-commits), and browser automation (playwright). + +--- + +## Key Ecosystem Platforms + +### SkillsMP Marketplace + +- **[SkillsMP](https://skillsmp.com/)** - Agent Skills Marketplace featuring 87,000+ Claude Code skills (as of January 2026). Cross-platform marketplace compatible with Claude, Codex, and ChatGPT. Community-driven platform for discovering and sharing agent skills. + +### Official Documentation Resources + +- **[Agent Skills Overview](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview)** - Official Claude API documentation for Agent Skills +- **[Claude Code Skills Docs](https://code.claude.com/docs/en/skills)** - Official Claude Code documentation for extending with skills +- **[The Complete Guide to Building Skills for Claude](https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf)** - Comprehensive PDF guide from Anthropic +- **[Agent Skills Standard](https://agentskills.io)** - Information about the open Agent Skills standard adopted by Microsoft, OpenAI, Atlassian, and Figma +- **[What are Skills? | Claude Help Center](https://support.claude.com/en/articles/12512176-what-are-skills)** - Official help documentation +- **[Skills for Organizations](https://claude.com/blog/organization-skills-and-directory)** - Blog post about enterprise features and skills directory + +--- + +## Ecosystem Analysis + +### Maturity Assessment + +The Claude Skills ecosystem has experienced explosive growth since the official Skills announcement in October 2025. The official Anthropic repository has reached 70,000 stars, and community-created repositories collectively contain tens of thousands of skills. The ecosystem demonstrates significant maturity with: + +- **Official Support**: Anthropic maintains comprehensive documentation, official skill examples, and a curated plugin directory +- **Open Standard**: The Agent Skills framework was released as an open standard, with major tech companies (Microsoft, OpenAI, Atlassian, Figma) adopting the technology +- **Cross-Platform Compatibility**: Many skill collections support multiple AI coding platforms (Cursor, Codex, Gemini CLI, GitHub Copilot, Windsurf) +- **Enterprise Features**: Team and Enterprise plans support centralized skill provisioning and management + +### Repository Categories + +Repositories fall into several distinct categories: + +1. **Curated Awesome Lists** - Comprehensive directories organizing and linking to skills across categories (travisvn, ComposioHQ, BehiSecc, VoltAgent) +2. **Production Skill Collections** - Battle-tested skills ready for immediate deployment (affaan-m, alirezarezvani, wshobson) +3. **Specialized Marketplaces** - Domain-specific or workflow-specific skill collections (mhattingpete, netresearch, obra) +4. **Skill Creation Tools** - Meta-skills and toolkits for building custom skills (alirezarezvani/skill-factory, FrancyJGLisboa) +5. **Infrastructure Tools** - MCP servers and discovery platforms (K-Dense-AI, SkillsMP) +6. **Official Resources** - Anthropic-maintained repositories and documentation + +### Key Trends + +1. **Skill Composability**: Claude automatically identifies which skills are needed and coordinates their use +2. **Token Efficiency**: Code execution patterns achieving 90-99% token reduction for bulk operations +3. **Multi-Agent Orchestration**: Larger collections feature orchestrator-worker patterns for complex workflows +4. **Domain Expertise Packaging**: Skills distill hundreds of hours of domain expertise into actionable frameworks +5. **Developer Experience**: Focus on interactive builders, templates, and guided workflows for creating custom skills +6. **Community Growth**: Repository crossing 20,000 stars on GitHub with tens of thousands of community-created and shared skills + +### Skill Structure + +Skills are simple to create - just a folder with a SKILL.md file containing: + +- **YAML frontmatter** with name and description fields +- **Markdown content** with instructions, examples, and guidelines that Claude will follow +- **Optional bundled resources** including: + - Scripts (executable code in Python/Bash/etc.) + - References (documentation) + - Assets (files used in output) + +### Distribution Patterns + +Skills can be distributed through multiple channels: + +1. **Official Skills Directory** - Anthropic-curated skills from partners like Notion, Canva, Figma, Atlassian +2. **Plugin Marketplaces** - Community-maintained collections installable via `/plugin marketplace add` +3. **Direct Installation** - Individual skills from GitHub repositories +4. **SkillsMP** - Large-scale community marketplace with 87,000+ skills +5. **Enterprise Provisioning** - Centralized deployment for Team/Enterprise plans + +--- + +## Potential for Plum Integration + +Several repositories and patterns are particularly relevant for Plum's plugin marketplace architecture: + +### Relevant Patterns + +- **obra/superpowers-marketplace** - Demonstrates curated marketplace pattern compatible with Plum's design philosophy +- **netresearch/claude-code-marketplace** - Shows catalog marketplace approach that indexes individual skill repositories +- **K-Dense-AI/claude-skills-mcp** - Vector search approach for skill discovery could enhance Plum's search and filtering capabilities +- **Official plugins structure** - Standardized format with plugin.json metadata, commands/, agents/, skills/ directories + +### Key Learnings + +1. **Quality Curation**: Successful marketplaces focus on quality over quantity with verification processes +2. **Standardized Format**: Consistent structure (SKILL.md, plugin.json) enables tooling and automation +3. **Composability**: Skills that work together through intelligent coordination provide better UX +4. **Discovery**: Vector search and semantic discovery improve findability in large collections +5. **Cross-Platform Support**: Open standards enable skills to work across multiple AI platforms +6. **Documentation**: Comprehensive guides and examples accelerate adoption and skill creation + +### Opportunities for Plum + +1. **Skill Discovery Enhancement**: Implement vector-based semantic search similar to claude-skills-mcp +2. **Quality Metrics**: Develop verification badges and quality scores for marketplace plugins +3. **Skill Templates**: Provide interactive builders and templates for creating new skills +4. **Cross-Marketplace Support**: Enable importing skills from popular marketplaces (obra, SkillsMP) +5. **Enterprise Features**: Support centralized provisioning and management for team installations +6. **Analytics**: Track skill usage, effectiveness, and community ratings + +--- + +## Sources + +This research utilized the following primary sources: + +### GitHub Repositories + +- [GitHub - anthropics/skills](https://github.com/anthropics/skills) +- [GitHub - travisvn/awesome-claude-skills](https://github.com/travisvn/awesome-claude-skills) +- [GitHub - ComposioHQ/awesome-claude-skills](https://github.com/ComposioHQ/awesome-claude-skills) +- [GitHub - affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) +- [GitHub - wshobson/agents](https://github.com/wshobson/agents) +- [GitHub - VoltAgent/awesome-agent-skills](https://github.com/VoltAgent/awesome-agent-skills) +- [GitHub - BehiSecc/awesome-claude-skills](https://github.com/BehiSecc/awesome-claude-skills) +- [GitHub - alirezarezvani/claude-skills](https://github.com/alirezarezvani/claude-skills) +- [GitHub - daymade/claude-code-skills](https://github.com/daymade/claude-code-skills) +- [GitHub - obra/superpowers-marketplace](https://github.com/obra/superpowers-marketplace) +- [GitHub - alirezarezvani/claude-code-skill-factory](https://github.com/alirezarezvani/claude-code-skill-factory) +- [GitHub - K-Dense-AI/claude-skills-mcp](https://github.com/K-Dense-AI/claude-skills-mcp) +- [GitHub - FrancyJGLisboa/agent-skill-creator](https://github.com/FrancyJGLisboa/agent-skill-creator) +- [GitHub - netresearch/claude-code-marketplace](https://github.com/netresearch/claude-code-marketplace) +- [GitHub - anthropics/claude-plugins-official](https://github.com/anthropics/claude-plugins-official) + +### Official Documentation + +- [What are Skills? | Claude Help Center](https://support.claude.com/en/articles/12512176-what-are-skills) +- [Agent Skills - Claude API Docs](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) +- [Agent Skills - Claude Code](https://code.claude.com/docs/en/skills) +- [The Complete Guide to Building Skills for Claude](https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf) +- [Introducing Agent Skills | Claude](https://www.anthropic.com/news/skills) +- [Equipping agents for the real world with Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) +- [Skills for organizations, partners, the ecosystem | Claude](https://claude.com/blog/organization-skills-and-directory) + +### Community Resources + +- [Agent Skills Marketplace - SkillsMP](https://skillsmp.com/) +- [Agent Skills Standard](https://agentskills.io) +- [25+ Agent Skills Registries & Community Collections (2026)](https://medium.com/@frulouis/25-top-claude-agent-skills-registries-community-collections-you-should-know-2025-52aab45c877d) +- [SkillsMP: This 87,427+ Claude Code Skills Directory](https://medium.com/ai-software-engineer/skillsmp-this-87-427-claude-code-skills-directory-just-exploded-but-with-one-annoying-problem-ec4af66b78cb) +- [Claude Skills: The Complete Guide to AI Agent Capabilities in 2026](https://vertu.com/lifestyle/claude-skills-the-complete-guide-to-ai-agent-capabilities-in-2026/) + +### Industry News + +- [Anthropic Introduces Skills for Custom Claude Tasks - InfoQ](https://www.infoq.com/news/2025/10/anthropic-claude-skills/) +- [Anthropic launches enterprise 'Agent Skills' | VentureBeat](https://venturebeat.com/ai/anthropic-launches-enterprise-agent-skills-and-opens-the-standard) +- [GitHub repository offers more than 50 customizable Claude Skills](https://the-decoder.com/github-repository-offers-more-than-50-customizable-claude-skills/) diff --git a/ecosystem/skills-leaderboard.json b/ecosystem/skills-leaderboard.json new file mode 100644 index 0000000..240a66b --- /dev/null +++ b/ecosystem/skills-leaderboard.json @@ -0,0 +1,283 @@ +{ + "last_updated": "2026-02-15", + "source": "skills.sh", + "source_url": "https://skills.sh/", + "total_skills_ecosystem": 59375, + "skills": [ + { + "rank": 1, + "name": "find-skills", + "installs": 231100, + "owner": "vercel-labs", + "repo": "vercel-labs/skills", + "category": "meta", + "tags": ["discovery", "essential", "skill-management"], + "description": "Locates and discovers available skills within the ecosystem", + "install_cmd": "npx skillsadd vercel-labs/skills/find-skills" + }, + { + "rank": 2, + "name": "vercel-react-best-practices", + "installs": 133600, + "owner": "vercel-labs", + "repo": "vercel-labs/agent-skills", + "category": "framework", + "tags": ["react", "frontend", "vercel", "best-practices", "javascript", "typescript"], + "description": "React patterns and conventions from Vercel engineering team", + "install_cmd": "npx skillsadd vercel-labs/agent-skills/vercel-react-best-practices" + }, + { + "rank": 3, + "name": "web-design-guidelines", + "installs": 100600, + "owner": "vercel-labs", + "repo": "vercel-labs/agent-skills", + "category": "design", + "tags": ["design", "web", "ui", "accessibility", "css", "frontend"], + "description": "Web design standards covering layout, typography, color theory, accessibility", + "install_cmd": "npx skillsadd vercel-labs/agent-skills/web-design-guidelines" + }, + { + "rank": 4, + "name": "remotion-best-practices", + "installs": 91400, + "owner": "remotion-dev", + "repo": "remotion-dev/skills", + "category": "creative", + "tags": ["video", "remotion", "creative", "programmatic", "javascript", "typescript", "react"], + "description": "Video creation with Remotion framework, programmatic video generation", + "install_cmd": "npx skillsadd remotion-dev/skills/remotion-best-practices" + }, + { + "rank": 5, + "name": "frontend-design", + "installs": 70000, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "design", + "tags": ["design", "frontend", "official", "anthropic", "css"], + "description": "Official Anthropic skill for bold, intentional design decisions", + "install_cmd": "npx skillsadd anthropics/skills/frontend-design" + }, + { + "rank": 6, + "name": "vercel-composition-patterns", + "installs": 40900, + "owner": "vercel-labs", + "repo": "vercel-labs/agent-skills", + "category": "framework", + "tags": ["react", "nextjs", "composition", "patterns", "javascript", "typescript"], + "description": "Component composition methodologies for React and Next.js", + "install_cmd": "npx skillsadd vercel-labs/agent-skills/vercel-composition-patterns" + }, + { + "rank": 7, + "name": "agent-browser", + "installs": 36600, + "owner": "vercel-labs", + "repo": "vercel-labs/agent-browser", + "category": "automation", + "tags": ["browser", "automation", "testing", "scraping", "web", "javascript"], + "description": "Browser automation and interaction for web scraping and testing", + "install_cmd": "npx skillsadd vercel-labs/agent-browser" + }, + { + "rank": 8, + "name": "skill-creator", + "installs": 34500, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "meta", + "tags": ["skill-creation", "builder", "official", "interactive", "development", "meta"], + "description": "Official Anthropic interactive tool for building new skills", + "install_cmd": "npx skillsadd anthropics/skills/skill-creator" + }, + { + "rank": 9, + "name": "browser-use", + "installs": 30100, + "owner": "browser-use", + "repo": "browser-use/browser-use", + "category": "automation", + "tags": ["browser", "automation", "framework", "web", "javascript"], + "description": "Browser functionality framework for web automation tasks", + "install_cmd": "npx skillsadd browser-use/browser-use" + }, + { + "rank": 10, + "name": "vercel-react-native-skills", + "installs": 29500, + "owner": "vercel-labs", + "repo": "vercel-labs/agent-skills", + "category": "mobile", + "tags": ["react-native", "mobile", "vercel", "javascript", "typescript"], + "description": "React Native development guidance for mobile-specific patterns", + "install_cmd": "npx skillsadd vercel-labs/agent-skills/vercel-react-native-skills" + }, + { + "rank": 11, + "name": "ui-ux-pro-max", + "installs": 26000, + "owner": "nextlevelbuilder", + "repo": "nextlevelbuilder/ui-ux-pro-max-skill", + "category": "design", + "tags": ["ui", "ux", "design-systems", "advanced", "css", "frontend"], + "description": "Advanced UI/UX design methodologies with modern design systems", + "install_cmd": "npx skillsadd nextlevelbuilder/ui-ux-pro-max-skill" + }, + { + "rank": 12, + "name": "audit-website", + "installs": 20200, + "owner": "squirrelscan", + "repo": "squirrelscan/skills", + "category": "analysis", + "tags": ["audit", "performance", "accessibility", "seo", "web"], + "description": "Website analysis for performance, accessibility, and SEO", + "install_cmd": "npx skillsadd squirrelscan/skills/audit-website" + }, + { + "rank": 13, + "name": "brainstorming", + "installs": 19900, + "owner": "obra", + "repo": "obra/superpowers", + "category": "productivity", + "tags": ["ideation", "creative", "problem-solving", "development", "general"], + "description": "Ideation and creative problem-solving support", + "install_cmd": "npx skillsadd obra/superpowers/brainstorming" + }, + { + "rank": 14, + "name": "seo-audit", + "installs": 19000, + "owner": "coreyhaines31", + "repo": "coreyhaines31/marketingskills", + "category": "marketing", + "tags": ["seo", "optimization", "marketing", "web"], + "description": "Search engine optimization analysis and recommendations", + "install_cmd": "npx skillsadd coreyhaines31/marketingskills/seo-audit" + }, + { + "rank": 15, + "name": "supabase-postgres-best-practices", + "installs": 17800, + "owner": "supabase", + "repo": "supabase/agent-skills", + "category": "database", + "tags": ["supabase", "postgresql", "database", "backend", "sql"], + "description": "PostgreSQL and Supabase optimization from Supabase team", + "install_cmd": "npx skillsadd supabase/agent-skills/supabase-postgres-best-practices" + }, + { + "rank": 16, + "name": "pdf", + "installs": 14900, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "document", + "tags": ["pdf", "document", "official", "processing", "python"], + "description": "Official PDF processing - extract, merge, split, forms", + "install_cmd": "npx skillsadd anthropics/skills/pdf" + }, + { + "rank": 17, + "name": "copywriting", + "installs": 13900, + "owner": "coreyhaines31", + "repo": "coreyhaines31/marketingskills", + "category": "marketing", + "tags": ["copywriting", "content", "marketing", "general"], + "description": "Marketing copy and content creation with proven frameworks", + "install_cmd": "npx skillsadd coreyhaines31/marketingskills/copywriting" + }, + { + "rank": 18, + "name": "pptx", + "installs": 12300, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "document", + "tags": ["powerpoint", "presentation", "official", "document", "python"], + "description": "Official PowerPoint creation with layouts, templates, charts", + "install_cmd": "npx skillsadd anthropics/skills/pptx" + }, + { + "rank": 19, + "name": "next-best-practices", + "installs": 12200, + "owner": "vercel-labs", + "repo": "vercel-labs/next-skills", + "category": "framework", + "tags": ["nextjs", "vercel", "framework", "best-practices", "javascript", "typescript", "react"], + "description": "Next.js framework optimization patterns from Vercel", + "install_cmd": "npx skillsadd vercel-labs/next-skills/next-best-practices" + }, + { + "rank": 20, + "name": "better-auth-best-practices", + "installs": 11600, + "owner": "better-auth", + "repo": "better-auth/skills", + "category": "security", + "tags": ["authentication", "security", "oauth", "jwt", "web", "backend"], + "description": "Authentication implementation - OAuth, JWT, session management", + "install_cmd": "npx skillsadd better-auth/skills/better-auth-best-practices" + }, + { + "rank": 21, + "name": "docx", + "installs": 11400, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "document", + "tags": ["word", "document", "official", "processing", "python"], + "description": "Official Word document creation with tracked changes and formatting", + "install_cmd": "npx skillsadd anthropics/skills/docx" + }, + { + "rank": 22, + "name": "agent-tools", + "installs": 11300, + "owner": "inference-sh-0", + "repo": "inference-sh-0/skills", + "category": "utility", + "tags": ["tools", "automation", "workflow", "development"], + "description": "Utility tools for agent functionality and workflow automation", + "install_cmd": "npx skillsadd inference-sh-0/skills/agent-tools" + }, + { + "rank": 23, + "name": "xlsx", + "installs": 11300, + "owner": "anthropics", + "repo": "anthropics/skills", + "category": "document", + "tags": ["excel", "spreadsheet", "official", "data", "python"], + "description": "Official spreadsheet creation with formulas and data analysis", + "install_cmd": "npx skillsadd anthropics/skills/xlsx" + }, + { + "rank": 24, + "name": "systematic-debugging", + "installs": 11000, + "owner": "obra", + "repo": "obra/superpowers", + "category": "development", + "tags": ["debugging", "tdd", "problem-solving", "development", "general"], + "description": "Methodical problem diagnosis with TDD approaches", + "install_cmd": "npx skillsadd obra/superpowers/systematic-debugging" + }, + { + "rank": 25, + "name": "marketing-psychology", + "installs": 10600, + "owner": "coreyhaines31", + "repo": "coreyhaines31/marketingskills", + "category": "marketing", + "tags": ["marketing", "psychology", "persuasion", "general"], + "description": "Psychological principles in marketing and user behavior", + "install_cmd": "npx skillsadd coreyhaines31/marketingskills/marketing-psychology" + } + ] +} diff --git a/ecosystem/skills.json b/ecosystem/skills.json new file mode 100644 index 0000000..a385bea --- /dev/null +++ b/ecosystem/skills.json @@ -0,0 +1,240 @@ +{ + "last_updated": "2026-02-15", + "total_repos": 24, + "repositories": [ + { + "name": "skills", + "owner": "anthropics", + "url": "https://github.com/anthropics/skills", + "stars": 70000, + "forks": 7100, + "category": "official", + "type": "production", + "tags": ["official", "anthropic", "production-ready", "document-processing", "python", "development"], + "description": "Official Anthropic skills - production-ready document skills (PDF, DOCX, PPTX, XLSX), creative tools, development utilities", + "install_cmd": "/plugin marketplace add anthropics/skills" + }, + { + "name": "everything-claude-code", + "owner": "affaan-m", + "url": "https://github.com/affaan-m/everything-claude-code", + "stars": 46200, + "category": "community", + "type": "comprehensive", + "tags": ["hackathon-winner", "37-skills", "comprehensive", "battle-tested", "development", "testing"], + "description": "Complete config collection with 37 skills - hackathon winner, 98% test coverage", + "install_cmd": "/plugin install affaan-m/everything-claude-code" + }, + { + "name": "awesome-claude-skills", + "owner": "ComposioHQ", + "url": "https://github.com/ComposioHQ/awesome-claude-skills", + "stars": 34900, + "category": "community", + "type": "integrations", + "tags": ["integrations", "automation", "comprehensive", "development"], + "description": "Comprehensive integrations collection covering hundreds of services", + "install_cmd": null + }, + { + "name": "agents", + "owner": "wshobson", + "url": "https://github.com/wshobson/agents", + "stars": 28600, + "category": "community", + "type": "framework", + "tags": ["146-skills", "progressive-disclosure", "granular", "development"], + "description": "146 agent skills with progressive knowledge disclosure", + "install_cmd": "/plugin install wshobson/agents" + }, + { + "name": "awesome-claude-skills", + "owner": "travisvn", + "url": "https://github.com/travisvn/awesome-claude-skills", + "stars": 7100, + "forks": 495, + "category": "community", + "type": "curated-list", + "tags": ["curated", "best-practices", "comprehensive-guide", "development"], + "description": "Curated list with best practices, getting started guides, security considerations", + "install_cmd": null + }, + { + "name": "awesome-agent-skills", + "owner": "VoltAgent", + "url": "https://github.com/VoltAgent/awesome-agent-skills", + "stars": 7100, + "forks": 545, + "category": "community", + "type": "cross-platform", + "tags": ["380-skills", "cross-platform", "official-teams", "development", "multi-platform"], + "description": "380+ skills from official teams (Vercel, Cloudflare, Microsoft, Hugging Face)", + "install_cmd": null + }, + { + "name": "awesome-claude-skills", + "owner": "BehiSecc", + "url": "https://github.com/BehiSecc/awesome-claude-skills", + "stars": 5800, + "category": "community", + "type": "curated-list", + "tags": ["12-categories", "curated", "organized", "development"], + "description": "Curated list across 12+ categories including document handling, security, automation", + "install_cmd": null + }, + { + "name": "claude-skills", + "owner": "alirezarezvani", + "url": "https://github.com/alirezarezvani/claude-skills", + "stars": 1800, + "category": "community", + "type": "business", + "tags": ["53-skills", "business", "roi-focused", "production-ready", "development"], + "description": "53 business-focused skills with 40% time savings, 30% quality improvements", + "install_cmd": null + }, + { + "name": "claude-code-skills", + "owner": "daymade", + "url": "https://github.com/daymade/claude-code-skills", + "stars": 580, + "category": "community", + "type": "marketplace", + "tags": ["37-skills", "professional", "specialized", "development"], + "description": "Professional marketplace with 37 production-ready skills", + "install_cmd": null + }, + { + "name": "claude-code-skill-factory", + "owner": "alirezarezvani", + "url": "https://github.com/alirezarezvani/claude-code-skill-factory", + "stars": 499, + "category": "development", + "type": "toolkit", + "tags": ["builder", "toolkit", "cross-platform", "production", "development"], + "description": "Toolkit for building production-ready skills at scale - 5 guide agents, 10 commands", + "install_cmd": "/plugin install alirezarezvani/claude-code-skill-factory" + }, + { + "name": "superpowers-marketplace", + "owner": "obra", + "url": "https://github.com/obra/superpowers-marketplace", + "stars": 486, + "category": "community", + "type": "marketplace", + "tags": ["20-skills", "curated", "planning"], + "description": "Curated marketplace with 20+ core skills and planning commands", + "install_cmd": "/plugin marketplace add obra/superpowers-marketplace" + }, + { + "name": "claude-skills-collection", + "owner": "abubakarsiddik31", + "url": "https://github.com/abubakarsiddik31/claude-skills-collection", + "stars": 434, + "category": "community", + "type": "collection", + "tags": ["11-categories", "official-and-community", "modular"], + "description": "Official and community skills across 11 categories - productivity, creativity, coding", + "install_cmd": null + }, + { + "name": "claude-skills-marketplace", + "owner": "mhattingpete", + "url": "https://github.com/mhattingpete/claude-skills-marketplace", + "stars": 357, + "category": "community", + "type": "marketplace", + "tags": ["engineering-workflows", "execution-runtime", "90-99-percent-savings"], + "description": "Engineering workflows with execution runtime achieving 90-99% token savings", + "install_cmd": "/plugin marketplace add mhattingpete/claude-skills-marketplace" + }, + { + "name": "claude-skills-mcp", + "owner": "K-Dense-AI", + "url": "https://github.com/K-Dense-AI/claude-skills-mcp", + "stars": 315, + "category": "infrastructure", + "type": "mcp", + "tags": ["vector-search", "mcp", "cross-platform", "discovery"], + "description": "MCP server for vector-based skill search across multiple AI platforms", + "install_cmd": null + }, + { + "name": "agent-skill-creator", + "owner": "FrancyJGLisboa", + "url": "https://github.com/FrancyJGLisboa/agent-skill-creator", + "stars": 265, + "category": "development", + "type": "meta-skill", + "tags": ["meta-skill", "autonomous", "6-phase", "builder"], + "description": "Meta-skill for autonomous agent creation via 6-phase methodology", + "install_cmd": null + }, + { + "name": "awesome-claude-skills", + "owner": "karanb192", + "url": "https://github.com/karanb192/awesome-claude-skills", + "stars": 107, + "category": "community", + "type": "verified", + "tags": ["50-skills", "verified", "tdd", "git-workflows"], + "description": "50+ verified skills for TDD, debugging, git workflows, document processing", + "install_cmd": null + }, + { + "name": "claude-code-skills", + "owner": "levnikolaevich", + "url": "https://github.com/levnikolaevich/claude-code-skills", + "stars": 89, + "category": "community", + "type": "workflow", + "tags": ["102-skills", "full-delivery", "orchestrator-worker"], + "description": "102 skills covering full delivery workflow with Orchestrator-Worker pattern", + "install_cmd": null + }, + { + "name": "claude-skills", + "owner": "secondsky", + "url": "https://github.com/secondsky/claude-skills", + "stars": 51, + "category": "community", + "type": "comprehensive", + "tags": ["167-skills", "18-categories", "auto-discovery", "production"], + "description": "167 production-ready skills across 18 categories with auto-discovery", + "install_cmd": null + }, + { + "name": "claude-code-marketplace", + "owner": "netresearch", + "url": "https://github.com/netresearch/claude-code-marketplace", + "stars": 20, + "category": "community", + "type": "domain-specific", + "tags": ["typo3", "php", "documentation", "catalog"], + "description": "TYPO3 development, PHP modernization, technical documentation workflows", + "install_cmd": "/plugin marketplace add netresearch/claude-code-marketplace" + }, + { + "name": "claude-agent-skills", + "owner": "meetrais", + "url": "https://github.com/meetrais/claude-agent-skills", + "stars": 9, + "category": "community", + "type": "examples", + "tags": ["examples", "api", "custom-skills"], + "description": "Examples demonstrating Skills API with default and custom skills", + "install_cmd": null + }, + { + "name": "claude-marketplace", + "owner": "dashed", + "url": "https://github.com/dashed/claude-marketplace", + "stars": 7, + "category": "personal", + "type": "local", + "tags": ["local", "personal", "git-tools", "terminal", "cli", "development"], + "description": "Local marketplace for personal skills - git tools, terminal automation, browser automation", + "install_cmd": "/plugin marketplace add dashed/claude-marketplace" + } + ] +} diff --git a/scripts/ecosystem/detect_stack.py b/scripts/ecosystem/detect_stack.py new file mode 100755 index 0000000..98eb048 --- /dev/null +++ b/scripts/ecosystem/detect_stack.py @@ -0,0 +1,295 @@ +#!/usr/bin/env python3 +"""Detect the tech stack of a project directory. + +Zero external dependencies - stdlib only. +Outputs JSON dict with languages, tags, frameworks, config_files_found, has_claude_code. +""" + +import json +import os +import sys +from collections import Counter +from pathlib import Path + +SKIP_DIRS = { + ".git", "node_modules", "vendor", "venv", ".venv", "dist", "build", + "__pycache__", "target", ".next", ".nuxt", "coverage", ".tox", + "env", ".env", ".mypy_cache", ".pytest_cache", "eggs", "*.egg-info", +} + +MAX_DEPTH = 3 + +# Maps indicator files to (language, [tags]) +INDICATOR_MAP = { + "go.mod": ("go", ["go", "backend"]), + "go.sum": ("go", ["go"]), + "package.json": ("javascript", ["javascript", "nodejs"]), + "tsconfig.json": ("typescript", ["typescript"]), + "Cargo.toml": ("rust", ["rust"]), + "pyproject.toml": ("python", ["python"]), + "requirements.txt": ("python", ["python"]), + "setup.py": ("python", ["python"]), + "Pipfile": ("python", ["python", "pipenv"]), + "Gemfile": ("ruby", ["ruby"]), + "pom.xml": ("java", ["java", "maven"]), + "build.gradle": ("java", ["java", "gradle"]), + "build.gradle.kts": ("kotlin", ["kotlin", "gradle"]), + "CMakeLists.txt": ("cpp", ["cpp", "cmake"]), + "Makefile": (None, ["make"]), + "Dockerfile": (None, ["docker", "containerization"]), + "docker-compose.yml": (None, ["docker", "containerization"]), + "docker-compose.yaml": (None, ["docker", "containerization"]), + ".dockerignore": (None, ["docker"]), + "terraform.tf": (None, ["terraform", "infrastructure"]), + "main.tf": (None, ["terraform", "infrastructure"]), + "serverless.yml": (None, ["serverless", "cloud"]), + "fly.toml": (None, ["fly-io", "deployment"]), + "vercel.json": (None, ["vercel", "deployment"]), + "netlify.toml": (None, ["netlify", "deployment"]), + "CLAUDE.md": (None, ["claude-code"]), + ".claude": (None, ["claude-code"]), +} + +# Check for directories as indicators +DIR_INDICATORS = { + ".github/workflows": ["ci-cd", "github-actions"], + ".github": ["github"], + ".circleci": ["ci-cd", "circleci"], +} + +# Extension to language mapping +EXT_LANG_MAP = { + ".go": "go", + ".py": "python", + ".js": "javascript", + ".ts": "typescript", + ".tsx": "typescript", + ".jsx": "javascript", + ".rs": "rust", + ".rb": "ruby", + ".java": "java", + ".kt": "kotlin", + ".cpp": "cpp", + ".c": "c", + ".cs": "csharp", + ".swift":"swift", + ".lua": "lua", + ".php": "php", + ".ex": "elixir", + ".exs": "elixir", + ".zig": "zig", +} + +# Dependency patterns: (dep_substring, [tags]) +GO_DEP_PATTERNS = [ + ("github.com/charmbracelet/bubbletea", ["bubbletea", "tui", "terminal"]), + ("github.com/charmbracelet/lipgloss", ["lipgloss", "tui", "terminal"]), + ("github.com/charmbracelet/bubbles", ["bubbles", "tui", "terminal"]), + ("github.com/charmbracelet/glamour", ["glamour", "tui", "markdown"]), + ("github.com/charmbracelet/huh", ["huh", "tui", "forms"]), + ("github.com/spf13/cobra", ["cobra", "cli"]), + ("github.com/spf13/viper", ["viper", "config"]), + ("github.com/urfave/cli", ["urfave-cli", "cli"]), + ("github.com/gin-gonic/gin", ["gin", "web", "api"]), + ("github.com/gofiber/fiber", ["fiber", "web", "api"]), + ("github.com/labstack/echo", ["echo", "web", "api"]), + ("github.com/gorilla/mux", ["gorilla", "web", "api"]), + ("gorm.io/gorm", ["gorm", "database", "orm"]), + ("github.com/jmoiron/sqlx", ["sqlx", "database"]), + ("google.golang.org/grpc", ["grpc", "api"]), + ("google.golang.org/protobuf", ["protobuf", "api"]), +] + +NPM_DEP_PATTERNS = [ + ("react", ["react", "frontend"]), + ("next", ["nextjs", "react", "frontend", "fullstack"]), + ("vue", ["vue", "frontend"]), + ("nuxt", ["nuxt", "vue", "frontend", "fullstack"]), + ("svelte", ["svelte", "frontend"]), + ("angular", ["angular", "frontend"]), + ("remotion", ["remotion", "video", "creative"]), + ("express", ["express", "backend", "api"]), + ("fastify", ["fastify", "backend", "api"]), + ("tailwindcss", ["tailwind", "css", "design"]), + ("prisma", ["prisma", "database", "orm"]), + ("drizzle-orm", ["drizzle", "database", "orm"]), + ("supabase", ["supabase", "database", "backend"]), + ("firebase", ["firebase", "backend"]), + ("electron", ["electron", "desktop"]), + ("expo", ["expo", "react-native", "mobile"]), + ("react-native", ["react-native", "mobile"]), + ("three", ["threejs", "3d", "creative"]), + ("typescript", ["typescript"]), + ("jest", ["jest", "testing"]), + ("vitest", ["vitest", "testing"]), + ("playwright", ["playwright", "testing", "e2e"]), + ("cypress", ["cypress", "testing", "e2e"]), + ("storybook", ["storybook", "design", "components"]), +] + +PYTHON_DEP_PATTERNS = [ + ("django", ["django", "web", "fullstack"]), + ("flask", ["flask", "web", "api"]), + ("fastapi", ["fastapi", "api", "backend"]), + ("sqlalchemy", ["sqlalchemy", "database", "orm"]), + ("pytest", ["pytest", "testing"]), + ("celery", ["celery", "async", "tasks"]), + ("pydantic", ["pydantic", "validation"]), + ("torch", ["pytorch", "ml", "ai"]), + ("tensorflow", ["tensorflow", "ml", "ai"]), + ("transformers", ["huggingface", "ml", "ai", "nlp"]), + ("langchain", ["langchain", "ai", "llm"]), + ("anthropic", ["anthropic", "ai", "claude"]), + ("openai", ["openai", "ai", "llm"]), + ("scrapy", ["scrapy", "scraping"]), + ("streamlit", ["streamlit", "dashboard", "data"]), + ("pandas", ["pandas", "data"]), + ("numpy", ["numpy", "data", "scientific"]), +] + + +def _should_skip(name): + return name in SKIP_DIRS or name.startswith(".") + + +def _walk_limited(root, max_depth): + """Walk directory tree up to max_depth levels.""" + root = Path(root) + for item in root.iterdir(): + try: + if item.is_file(): + yield item, 0 + elif item.is_dir() and not _should_skip(item.name): + if max_depth > 0: + for sub_item, depth in _walk_limited(item, max_depth - 1): + yield sub_item, depth + 1 + except PermissionError: + continue + + +def _parse_go_mod(path): + """Extract tags from go.mod require block.""" + tags = set() + frameworks = [] + try: + text = Path(path).read_text(errors="ignore") + for dep_str, dep_tags in GO_DEP_PATTERNS: + if dep_str in text: + tags.update(dep_tags) + frameworks.append(dep_str.split("/")[-1]) + except (OSError, IOError): + pass + return tags, frameworks + + +def _parse_package_json(path): + """Extract tags from package.json dependencies.""" + tags = set() + frameworks = [] + try: + data = json.loads(Path(path).read_text(errors="ignore")) + all_deps = set() + for key in ("dependencies", "devDependencies", "peerDependencies"): + all_deps.update(data.get(key, {}).keys()) + + for dep_name, dep_tags in NPM_DEP_PATTERNS: + # Check for exact match or scoped package + if dep_name in all_deps or any(d.endswith("/" + dep_name) for d in all_deps): + tags.update(dep_tags) + frameworks.append(dep_name) + except (OSError, IOError, json.JSONDecodeError): + pass + return tags, frameworks + + +def _parse_python_deps(path): + """Extract tags from requirements.txt or pyproject.toml.""" + tags = set() + frameworks = [] + try: + text = Path(path).read_text(errors="ignore").lower() + for dep_name, dep_tags in PYTHON_DEP_PATTERNS: + if dep_name in text: + tags.update(dep_tags) + frameworks.append(dep_name) + except (OSError, IOError): + pass + return tags, frameworks + + +def detect_stack(target_dir): + """Detect the tech stack of the given directory. + + Returns dict with languages, tags, frameworks, config_files_found, has_claude_code. + """ + target = Path(target_dir).resolve() + if not target.is_dir(): + return {"error": f"Not a directory: {target}"} + + languages = set() + tags = set() + frameworks = [] + config_files = [] + ext_counts = Counter() + + # Phase 1: Indicator files (root level) + for name, (lang, file_tags) in INDICATOR_MAP.items(): + indicator_path = target / name + if indicator_path.exists(): + config_files.append(name) + if lang: + languages.add(lang) + tags.update(file_tags) + + # Check directory indicators + for dir_path, dir_tags in DIR_INDICATORS.items(): + if (target / dir_path).is_dir(): + config_files.append(dir_path) + tags.update(dir_tags) + + # Phase 2: Dependency parsing + go_mod = target / "go.mod" + if go_mod.exists(): + dep_tags, dep_frameworks = _parse_go_mod(go_mod) + tags.update(dep_tags) + frameworks.extend(dep_frameworks) + + pkg_json = target / "package.json" + if pkg_json.exists(): + dep_tags, dep_frameworks = _parse_package_json(pkg_json) + tags.update(dep_tags) + frameworks.extend(dep_frameworks) + + for pyfile in ("requirements.txt", "pyproject.toml", "Pipfile"): + pypath = target / pyfile + if pypath.exists(): + dep_tags, dep_frameworks = _parse_python_deps(pypath) + tags.update(dep_tags) + frameworks.extend(dep_frameworks) + + # Phase 3: Extension counting (fallback language signal) + for item, _depth in _walk_limited(target, MAX_DEPTH): + ext = item.suffix.lower() + if ext in EXT_LANG_MAP: + ext_counts[ext] += 1 + + for ext, count in ext_counts.most_common(): + if count >= 2: + languages.add(EXT_LANG_MAP[ext]) + + # Derive additional tags from languages + has_claude = "claude-code" in tags or (target / ".claude").is_dir() or (target / "CLAUDE.md").exists() + + return { + "languages": sorted(languages), + "tags": sorted(tags), + "frameworks": sorted(set(frameworks)), + "config_files_found": sorted(config_files), + "has_claude_code": has_claude, + } + + +if __name__ == "__main__": + target = sys.argv[1] if len(sys.argv) > 1 else "." + result = detect_stack(target) + print(json.dumps(result, indent=2)) diff --git a/scripts/ecosystem/recommend.py b/scripts/ecosystem/recommend.py new file mode 100755 index 0000000..d9f95d7 --- /dev/null +++ b/scripts/ecosystem/recommend.py @@ -0,0 +1,254 @@ +#!/usr/bin/env python3 +"""Recommend ecosystem skills, plugins, agents, and MCP servers for a project. + +Analyzes the project's tech stack and scores entries from ecosystem JSON files +using the multi-stage scorer engine (scorer.py). + +Zero external dependencies - stdlib only. + +Usage: + python3 scripts/ecosystem/recommend.py [TARGET_DIR] [--top N] [--min-score N] [--pretty] + python3 scripts/ecosystem/recommend.py [TARGET_DIR] --markdown [--exclude-no-install] +""" + +import json +from pathlib import Path + +from scorer import score_item, normalize_popularity, deduplicate + +# Resolve ecosystem dir relative to this script: ../../ecosystem/ +SCRIPT_DIR = Path(__file__).resolve().parent +ECOSYSTEM_DIR = SCRIPT_DIR.parent.parent / "ecosystem" + +# Source file config: (filename, items_key, popularity_field, output_key) +SOURCES = [ + ("skills-leaderboard.json", "skills", "installs", "skills_leaderboard"), + ("plugins.json", "repositories", "stars", "plugins"), + ("agents.json", "repositories", "stars", "agents"), + ("skills.json", "repositories", "stars", "skills"), + ("mcp-servers.json", "collections", "stars", "mcp_servers"), +] + +DEFAULT_TOP = 5 +DEFAULT_MIN_SCORE = 35 + +# Category label mapping for markdown output +CATEGORY_LABELS = { + "skills_leaderboard": "Top Skills (skills.sh)", + "plugins": "Plugins", + "agents": "Agents", + "skills": "Skill Repositories", + "mcp_servers": "MCP Servers", +} + + +def _load_json(filepath): + """Load a JSON file, return empty dict on failure.""" + try: + return json.loads(Path(filepath).read_text(errors="ignore")) + except (OSError, json.JSONDecodeError): + return {} + + +def _format_entry(item, score, matching_tags, inferred_tags, pop_field, source_label): + """Format a scored item into the output structure.""" + entry = { + "name": item.get("name", ""), + "owner": item.get("owner", ""), + "description": item.get("description", ""), + "score": round(score, 1), + "matching_tags": matching_tags, + "inferred_tags": inferred_tags, + "popularity_metric": {pop_field: item.get(pop_field, 0)}, + "source": source_label, + } + install = item.get("install_cmd") + if install: + entry["install_cmd"] = install + url = item.get("url") or item.get("repo") + if url: + entry["url"] = url + return entry + + +def _format_markdown(result): + """Render the recommendation result as markdown tables.""" + lines = [] + + # Stack profile header + profile = result.get("stack_profile", {}) + lines.append("## Stack Profile") + lines.append("") + lines.append(f"**Languages:** {', '.join(profile.get('languages', [])) or 'none'}") + lines.append(f"**Frameworks:** {', '.join(profile.get('frameworks', [])) or 'none'}") + lines.append(f"**Tags:** {', '.join(profile.get('tags', [])) or 'none'}") + lines.append("") + + recommendations = result.get("recommendations", {}) + + # Iterate sources in order to maintain consistent output + for _filename, _items_key, pop_field, output_key in SOURCES: + entries = recommendations.get(output_key) + if not entries: + continue + + label = CATEGORY_LABELS.get(output_key, output_key) + pop_col = pop_field.capitalize() + + lines.append(f"## {label}") + lines.append("") + lines.append(f"| Name | Score | {pop_col} | Tags | Install |") + lines.append("|------|-------|" + "-" * (len(pop_col) + 2) + "|------|---------|") + + for entry in entries: + name = entry.get("name", "") + score = entry.get("score", 0) + + # Get popularity value + pop_metric = entry.get("popularity_metric", {}) + pop_val = pop_metric.get(pop_field, 0) + pop_str = f"{pop_val:,}" + + # Build tags column: matching + inferred (prefixed with ~) + tag_parts = list(entry.get("matching_tags", [])) + for t in entry.get("inferred_tags", []): + tag_parts.append(f"~{t}") + tags_str = ", ".join(tag_parts) if tag_parts else "-" + + # Install column + install_cmd = entry.get("install_cmd") + install_str = f"`{install_cmd}`" if install_cmd else "-" + + lines.append(f"| {name} | {score} | {pop_str} | {tags_str} | {install_str} |") + + lines.append("") + + if not recommendations: + lines.append("*No recommendations found above the score threshold.*") + lines.append("") + + return "\n".join(lines) + + +def recommend(target_dir, top_n=DEFAULT_TOP, min_score=DEFAULT_MIN_SCORE, + exclude_no_install=False): + """Run recommendation engine on the target directory. + + Returns structured JSON-serializable dict. + """ + # Import detect_stack from same package + from detect_stack import detect_stack + + stack_profile = detect_stack(target_dir) + if "error" in stack_profile: + return {"error": stack_profile["error"]} + + # Build stack_tags set: languages + tags + frameworks, all lowercased + stack_tags = set() + for val in stack_profile.get("languages", []): + stack_tags.add(val.lower()) + for val in stack_profile.get("tags", []): + stack_tags.add(val.lower()) + for val in stack_profile.get("frameworks", []): + stack_tags.add(val.lower()) + + # Collect all scored entries across all sources + all_scored = [] + + for filename, items_key, pop_field, output_key in SOURCES: + filepath = ECOSYSTEM_DIR / filename + data = _load_json(filepath) + items = data.get(items_key, []) + + if not items: + continue + + # Get last_updated from the source data for recency boost + last_updated = data.get("last_updated") + + # Stage 3: normalize popularity with recency + normalize_popularity(items, pop_field, last_updated) + + # Stage 1+2+combined: score each item + for item in items: + result = score_item(item, stack_tags, pop_field) + if result is None: + continue + + final_score, matching_tags, inferred_tags = result + + if final_score >= min_score: + entry = _format_entry( + item, final_score, matching_tags, inferred_tags, + pop_field, output_key, + ) + all_scored.append(entry) + + # Stage 4: deduplicate across all sources + deduplicated = deduplicate(all_scored) + + # Apply --exclude-no-install filter AFTER dedup but BEFORE grouping + if exclude_no_install: + deduplicated = [e for e in deduplicated if e.get("install_cmd")] + + # Re-group by source, sort by score, apply top_n per category + recommendations = {} + total_matches = 0 + + for entry in deduplicated: + source = entry.get("source", "") + recommendations.setdefault(source, []).append(entry) + + for source in recommendations: + recommendations[source].sort(key=lambda e: e.get("score", 0), reverse=True) + recommendations[source] = recommendations[source][:top_n] + total_matches += len(recommendations[source]) + + return { + "target_dir": str(Path(target_dir).resolve()), + "stack_profile": { + "languages": stack_profile["languages"], + "tags": stack_profile["tags"], + "frameworks": stack_profile["frameworks"], + }, + "recommendations": recommendations, + "total_matches": total_matches, + } + + +def main(): + import argparse + + parser = argparse.ArgumentParser(description="Recommend ecosystem tools for a project") + parser.add_argument("target_dir", nargs="?", default=".", help="Project directory to analyze") + parser.add_argument("--top", type=int, default=DEFAULT_TOP, + help=f"Top N per category (default: {DEFAULT_TOP})") + parser.add_argument("--min-score", type=int, default=DEFAULT_MIN_SCORE, + help=f"Minimum score threshold (default: {DEFAULT_MIN_SCORE})") + parser.add_argument("--exclude-no-install", action="store_true", + help="Filter out entries without an install command") + + # Output format: JSON by default, --markdown for tables + parser.add_argument("--markdown", action="store_true", + help="Output as formatted markdown tables (default: JSON)") + + parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output") + + args = parser.parse_args() + + result = recommend( + args.target_dir, + top_n=args.top, + min_score=args.min_score, + exclude_no_install=args.exclude_no_install, + ) + + if args.markdown: + print(_format_markdown(result)) + else: + indent = 2 if args.pretty else None + print(json.dumps(result, indent=indent)) + + +if __name__ == "__main__": + main() diff --git a/scripts/ecosystem/scorer.py b/scripts/ecosystem/scorer.py new file mode 100644 index 0000000..7378bd0 --- /dev/null +++ b/scripts/ecosystem/scorer.py @@ -0,0 +1,321 @@ +#!/usr/bin/env python3 +"""Multi-stage scoring engine for ecosystem recommendations. + +Pipeline stages: + 1. Tag matching (80% of relevance) — bidirectional geometric-mean overlap + 2. Keyword inference (20% of relevance) — curated map, 50% weight discount + 3. Popularity normalization — log-scale per source, recency boost + 4. Deduplication — key on owner/name, keep highest score + +Zero external dependencies — stdlib only. +""" + +import math +import re +from datetime import datetime, timedelta + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- + +RELEVANCE_WEIGHT = 0.7 +POPULARITY_WEIGHT = 0.3 +INFERRED_TAG_DISCOUNT = 0.5 # inferred tags count at half weight +RECENCY_MONTHS = 3 +RECENCY_BOOST = 0.10 + +# --------------------------------------------------------------------------- +# Keyword → tag map (description keywords → canonical tags) +# --------------------------------------------------------------------------- + +# Each entry is (regex_pattern_string, canonical_tag). +# Short/ambiguous words use \b word boundaries to prevent substring matches. +KEYWORD_TAG_MAP: list[tuple[str, str]] = [ + # Languages — short words need \b boundaries + (r"golang", "go"), + (r"\bgo\b", "go"), + (r"python", "python"), + (r"typescript", "typescript"), + (r"javascript", "javascript"), + (r"nodejs", "nodejs"), + (r"node\.js", "nodejs"), + (r"\trust\b", "rust"), + (r"\bruby\b", "ruby"), + (r"\bjava\b", "java"), + (r"kotlin", "kotlin"), + (r"\bswift\b", "swift"), + (r"\bphp\b", "php"), + (r"c\+\+", "cpp"), + (r"\bcpp\b", "cpp"), + + # Frameworks — check multi-word patterns before shorter ones + (r"react[- ]native", "react-native"), + (r"\breact\b", "react"), + (r"next\.js", "nextjs"), + (r"nextjs", "nextjs"), + (r"\bvue\b", "vue"), + (r"\bnuxt\b", "nuxt"), + (r"svelte", "svelte"), + (r"angular", "angular"), + (r"remotion", "remotion"), + + # Domains — terminal / CLI + (r"terminal", "terminal"), + (r"\btui\b", "tui"), + (r"\bcli\b", "cli"), + + # Containers / infra + (r"docker", "docker"), + (r"kubernetes", "kubernetes"), + (r"\bk8s\b", "kubernetes"), + (r"terraform", "terraform"), + (r"github[- ]actions?", "github-actions"), + (r"ci/?cd", "ci-cd"), + (r"\bci\b.*\bcd\b", "ci-cd"), + + # Databases + (r"database", "database"), + (r"postgresql", "postgresql"), + (r"postgres", "postgresql"), + (r"mongodb", "mongodb"), + (r"\bmongo\b", "mongodb"), + (r"\bredis\b", "redis"), + + # API + (r"\bapi\b", "api"), + (r"graphql", "graphql"), + (r"\bgrpc\b", "grpc"), + + # Auth + (r"authentication", "authentication"), + (r"\boauth\b", "oauth"), + (r"\bauth\b", "authentication"), + + # ML / AI + (r"machine[- ]learning", "machine-learning"), + (r"\bllm\b", "llm"), + + # Testing + (r"testing", "testing"), + (r"\be2e\b", "e2e"), + (r"end[- ]to[- ]end", "e2e"), + (r"browser[- ]automation", "browser-automation"), + + # Misc tooling / services + (r"\bslack\b", "slack"), + (r"\bgit\b", "git"), + (r"markdown", "markdown"), + (r"\bpdf\b", "pdf"), + (r"document", "document"), + (r"\bdesign\b", "design"), + (r"ui/?ux", "ui-ux"), + (r"accessibility", "accessibility"), + (r"\bseo\b", "seo"), + (r"marketing", "marketing"), + (r"deployment", "deployment"), + (r"serverless", "serverless"), + (r"\baws\b", "aws"), + (r"\bazure\b", "azure"), + (r"\bgcp\b", "gcp"), + (r"cloudflare", "cloudflare"), + (r"\bvercel\b", "vercel"), + (r"supabase", "supabase"), + (r"firebase", "firebase"), +] + +# Pre-compile for performance +_COMPILED_KEYWORDS: list[tuple[re.Pattern, str]] = [ + (re.compile(pattern, re.IGNORECASE), tag) + for pattern, tag in KEYWORD_TAG_MAP +] + + +# --------------------------------------------------------------------------- +# Stage 1+2 — tag matching & keyword inference +# --------------------------------------------------------------------------- + +def infer_tags(item: dict) -> set[str]: + """Return inferred tags from item description/name that are NOT already + in the item's explicit tags.""" + explicit = {t.lower() for t in item.get("tags", [])} + text = ( + (item.get("description", "") or "") + + " " + + (item.get("name", "") or "") + ) + + inferred: set[str] = set() + for pattern, tag in _COMPILED_KEYWORDS: + if tag not in explicit and pattern.search(text): + inferred.add(tag) + + # Avoid overly broad inference: if "react" is inferred but text contains + # "react native" / "react-native", prefer the more specific tag. + if "react" in inferred and "react-native" in inferred: + inferred.discard("react") + + return inferred + + +def compute_tag_score( + item_tags: set[str], + stack_tags: set[str], + inferred_tags: set[str] | None = None, +) -> tuple[float, list[str], list[str]]: + """Compute a tag-match score (0-100). + + Uses the geometric mean of two ratios: + coverage = overlap / len(item_all_tags) + precision = overlap / len(stack_tags) + + Inferred tags contribute at ``INFERRED_TAG_DISCOUNT`` (50%) weight. + + Returns (score, matching_explicit, matching_inferred). + """ + if inferred_tags is None: + inferred_tags = set() + + stack_lower = {t.lower() for t in stack_tags} + explicit_lower = {t.lower() for t in item_tags} + inferred_lower = {t.lower() for t in inferred_tags} + + matching_explicit = sorted(explicit_lower & stack_lower) + matching_inferred = sorted(inferred_lower & stack_lower) + + if not stack_lower: + return (0.0, matching_explicit, matching_inferred) + + # Effective overlap: explicit matches count 1, inferred matches count 0.5 + effective_overlap = len(matching_explicit) + len(matching_inferred) * INFERRED_TAG_DISCOUNT + + if effective_overlap == 0: + return (0.0, matching_explicit, matching_inferred) + + # Effective item-tag count (explicit full, inferred discounted) + effective_item_count = len(explicit_lower) + len(inferred_lower) * INFERRED_TAG_DISCOUNT + + if effective_item_count == 0: + return (0.0, matching_explicit, matching_inferred) + + coverage = effective_overlap / effective_item_count + precision = effective_overlap / len(stack_lower) + + # Geometric mean — sqrt(coverage * precision) clamped to [0, 1] + geo = math.sqrt(coverage * precision) + score = min(geo * 100, 100.0) + + return (score, matching_explicit, matching_inferred) + + +# --------------------------------------------------------------------------- +# Stage 3 — popularity normalization +# --------------------------------------------------------------------------- + +def normalize_popularity( + items: list[dict], + pop_field: str, + last_updated_str: str | None = None, +) -> list[dict]: + """Mutate *items* to add ``_pop_norm`` (0-100, log-scale). + + If *last_updated_str* is an ISO date within ``RECENCY_MONTHS`` months of + today, each item receives a ``RECENCY_BOOST`` bump (capped at 100). + """ + values = [item.get(pop_field, 0) for item in items] + max_val = max(values) if values else 0 + + # Determine recency boost applicability + recency_applicable = False + if last_updated_str: + try: + last_updated = datetime.strptime(last_updated_str, "%Y-%m-%d") + cutoff = datetime.now() - timedelta(days=RECENCY_MONTHS * 30) + recency_applicable = last_updated >= cutoff + except (ValueError, TypeError): + pass + + for item in items: + raw = item.get(pop_field, 0) + if max_val > 0: + norm = math.log1p(raw) / math.log1p(max_val) * 100 + else: + norm = 0.0 + + if recency_applicable: + norm = min(norm * (1 + RECENCY_BOOST), 100.0) + + item["_pop_norm"] = norm + + return items + + +# --------------------------------------------------------------------------- +# Stage 4 — deduplication +# --------------------------------------------------------------------------- + +def deduplicate(all_scored: list[dict]) -> list[dict]: + """Deduplicate entries keyed on ``owner/name`` (lowercased). + + Keeps the entry with the highest ``score``. Adds an ``also_found_in`` + list noting other source keys where the entry appeared. + """ + best: dict[str, dict] = {} # key → best entry + sources: dict[str, list[str]] = {} # key → [all source keys] + + for entry in all_scored: + owner = (entry.get("owner") or "").lower().strip() + name = (entry.get("name") or "").lower().strip() + key = f"{owner}/{name}" + + source_key = entry.get("source", "") + sources.setdefault(key, []).append(source_key) + + existing = best.get(key) + if existing is None or entry.get("score", 0) > existing.get("score", 0): + best[key] = entry + + result: list[dict] = [] + for key, entry in best.items(): + other_sources = [s for s in sources[key] if s != entry.get("source", "")] + if other_sources: + entry["also_found_in"] = sorted(set(other_sources)) + result.append(entry) + + # Preserve descending-score order + result.sort(key=lambda e: e.get("score", 0), reverse=True) + return result + + +# --------------------------------------------------------------------------- +# Combined scorer +# --------------------------------------------------------------------------- + +def score_item( + item: dict, + stack_tags: set[str], + pop_field: str, +) -> tuple[float, list[str], list[str]] | None: + """Score a single ecosystem item against the user's stack. + + Returns ``(final_score, matching_explicit, matching_inferred)`` or + ``None`` if the item has zero matching tags (hard gate). + + Assumes ``normalize_popularity`` has already been called on the item's + batch so that ``_pop_norm`` is present. + """ + explicit_tags = {t.lower() for t in item.get("tags", [])} + inferred = infer_tags(item) + + tag_score, matching_explicit, matching_inferred = compute_tag_score( + explicit_tags, stack_tags, inferred, + ) + + # Hard gate: no matches at all → exclude + if not matching_explicit and not matching_inferred: + return None + + pop_score = item.get("_pop_norm", 0) + + final_score = (tag_score * RELEVANCE_WEIGHT) + (pop_score * POPULARITY_WEIGHT) + + return (round(final_score, 2), matching_explicit, matching_inferred) diff --git a/scripts/ecosystem/test_scorer.py b/scripts/ecosystem/test_scorer.py new file mode 100644 index 0000000..7c6eba8 --- /dev/null +++ b/scripts/ecosystem/test_scorer.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +"""Tests for the ecosystem scorer module.""" + +import unittest + +from scorer import ( + infer_tags, + compute_tag_score, + normalize_popularity, + deduplicate, + score_item, +) + + +class TestInferTags(unittest.TestCase): + """Test keyword inference with word boundary matching.""" + + def test_go_not_inferred_from_django(self): + """'go' should NOT match inside 'Django'.""" + item = {"description": "Django rest framework", "tags": []} + tags = infer_tags(item) + self.assertNotIn("go", tags) + + def test_go_inferred_from_golang(self): + item = {"description": "Golang web framework", "tags": []} + tags = infer_tags(item) + self.assertIn("go", tags) + + def test_go_inferred_standalone(self): + item = {"description": "A go library for HTTP", "tags": []} + tags = infer_tags(item) + self.assertIn("go", tags) + + def test_go_not_inferred_from_cargo(self): + item = {"description": "Cargo build system", "tags": []} + tags = infer_tags(item) + self.assertNotIn("go", tags) + + def test_java_not_inferred_from_javascript(self): + item = {"description": "JavaScript framework", "tags": []} + tags = infer_tags(item) + self.assertNotIn("java", tags) + self.assertIn("javascript", tags) + + def test_git_not_inferred_from_digital(self): + item = {"description": "Digital transformation tools", "tags": []} + tags = infer_tags(item) + self.assertNotIn("git", tags) + + def test_git_inferred_standalone(self): + item = {"description": "Git tools for automation", "tags": []} + tags = infer_tags(item) + self.assertIn("git", tags) + + def test_auth_not_inferred_from_author(self): + item = {"description": "Author biography tool", "tags": []} + tags = infer_tags(item) + self.assertNotIn("authentication", tags) + + def test_auth_inferred_standalone(self): + item = {"description": "Auth middleware for Express", "tags": []} + tags = infer_tags(item) + self.assertIn("authentication", tags) + + def test_react_native_removes_react(self): + """When both react and react-native match, react should be removed.""" + item = {"description": "React Native mobile development", "tags": []} + tags = infer_tags(item) + self.assertIn("react-native", tags) + self.assertNotIn("react", tags) + + def test_react_without_native_stays(self): + item = {"description": "React component library", "tags": []} + tags = infer_tags(item) + self.assertIn("react", tags) + self.assertNotIn("react-native", tags) + + def test_skip_already_explicit(self): + """Tags already in explicit tags should not be inferred.""" + item = {"description": "Python testing framework", "tags": ["python"]} + tags = infer_tags(item) + self.assertNotIn("python", tags) + self.assertIn("testing", tags) + + def test_cli_inferred(self): + item = {"description": "CLI tool for deployment", "tags": []} + tags = infer_tags(item) + self.assertIn("cli", tags) + self.assertIn("deployment", tags) + + def test_rust_not_inferred_from_trust(self): + item = {"description": "Trust verification system", "tags": []} + tags = infer_tags(item) + self.assertNotIn("rust", tags) + + def test_api_not_inferred_from_capital(self): + """'api' should match case-insensitively.""" + item = {"description": "REST API endpoints", "tags": []} + tags = infer_tags(item) + self.assertIn("api", tags) + + def test_github_actions_variants(self): + item = {"description": "GitHub Action for CI/CD", "tags": []} + tags = infer_tags(item) + self.assertIn("github-actions", tags) + self.assertIn("ci-cd", tags) + + +class TestComputeTagScore(unittest.TestCase): + """Test the geometric mean tag scoring.""" + + def test_perfect_overlap(self): + """All item tags match all stack tags → high score.""" + score, explicit, inferred = compute_tag_score( + {"go", "cli"}, {"go", "cli"}, + ) + self.assertGreater(score, 90) + self.assertEqual(sorted(explicit), ["cli", "go"]) + + def test_no_overlap(self): + score, explicit, inferred = compute_tag_score( + {"python", "django"}, {"go", "cli"}, + ) + self.assertEqual(score, 0.0) + self.assertEqual(explicit, []) + + def test_partial_overlap(self): + score, explicit, inferred = compute_tag_score( + {"go", "cli", "tui", "terminal"}, {"go", "cli"}, + ) + self.assertGreater(score, 0) + self.assertLess(score, 100) + + def test_inferred_tags_discounted(self): + """Inferred tags should contribute less than explicit.""" + score_explicit, _, _ = compute_tag_score( + {"go", "cli"}, {"go", "cli"}, + ) + score_inferred, _, _ = compute_tag_score( + set(), {"go", "cli"}, inferred_tags={"go", "cli"}, + ) + self.assertGreater(score_explicit, score_inferred) + + def test_empty_stack(self): + score, _, _ = compute_tag_score({"go"}, set()) + self.assertEqual(score, 0.0) + + +class TestNormalizePopularity(unittest.TestCase): + """Test log-scale popularity normalization.""" + + def test_highest_gets_100(self): + items = [{"stars": 1000}, {"stars": 100}, {"stars": 10}] + normalize_popularity(items, "stars") + self.assertAlmostEqual(items[0]["_pop_norm"], 100.0, places=1) + self.assertGreater(items[1]["_pop_norm"], items[2]["_pop_norm"]) + + def test_zero_stays_zero(self): + items = [{"stars": 100}, {"stars": 0}] + normalize_popularity(items, "stars") + self.assertEqual(items[1]["_pop_norm"], 0.0) + + def test_recency_boost(self): + # Use two items so the non-max item shows the boost (max caps at 100) + items = [{"stars": 1000}, {"stars": 50}] + normalize_popularity(items, "stars", "2026-02-15") + boosted = items[1]["_pop_norm"] + + items2 = [{"stars": 1000}, {"stars": 50}] + normalize_popularity(items2, "stars", "2024-01-01") + unboosted = items2[1]["_pop_norm"] + + self.assertGreater(boosted, unboosted) + + +class TestDeduplicate(unittest.TestCase): + """Test cross-source deduplication.""" + + def test_keeps_highest_score(self): + entries = [ + {"owner": "foo", "name": "bar", "score": 50, "source": "plugins"}, + {"owner": "foo", "name": "bar", "score": 80, "source": "agents"}, + ] + result = deduplicate(entries) + self.assertEqual(len(result), 1) + self.assertEqual(result[0]["score"], 80) + self.assertEqual(result[0]["source"], "agents") + + def test_also_found_in(self): + entries = [ + {"owner": "foo", "name": "bar", "score": 80, "source": "agents"}, + {"owner": "foo", "name": "bar", "score": 50, "source": "plugins"}, + ] + result = deduplicate(entries) + self.assertEqual(result[0]["also_found_in"], ["plugins"]) + + def test_no_duplicates(self): + entries = [ + {"owner": "a", "name": "x", "score": 80, "source": "agents"}, + {"owner": "b", "name": "y", "score": 50, "source": "plugins"}, + ] + result = deduplicate(entries) + self.assertEqual(len(result), 2) + + def test_case_insensitive_keys(self): + entries = [ + {"owner": "Foo", "name": "Bar", "score": 80, "source": "agents"}, + {"owner": "foo", "name": "bar", "score": 50, "source": "plugins"}, + ] + result = deduplicate(entries) + self.assertEqual(len(result), 1) + + +class TestScoreItem(unittest.TestCase): + """Test the combined scoring function.""" + + def test_hard_gate_zero_tags(self): + """Items with zero matching tags should return None.""" + item = {"tags": ["python", "django"], "description": "Django web", "_pop_norm": 50} + result = score_item(item, {"go", "cli"}, "stars") + self.assertIsNone(result) + + def test_matching_item_scores(self): + item = {"tags": ["go", "cli", "tui"], "description": "Terminal UI", "_pop_norm": 75} + result = score_item(item, {"go", "cli", "tui"}, "stars") + self.assertIsNotNone(result) + score, explicit, inferred = result + self.assertGreater(score, 0) + self.assertIn("go", explicit) + + +if __name__ == "__main__": + unittest.main()