Loading plugin...

skill-seekers · Flowy

README

Skill Seekers

🧠 The data layer for AI systems. Skill Seekers turns documentation sites, GitHub repos, PDFs, videos, notebooks, wikis, and 10+ more source types into structured knowledge assets—ready to power AI Skills (Claude, Gemini, OpenAI), RAG pipelines (LangChain, LlamaIndex, Pinecone), and AI coding assistants (Cursor, Windsurf, Cline) in minutes, not hours.

🌐 Visit SkillSeekersWeb.com - Browse 24+ preset configs, share your configs, and access complete documentation!

📋 View Development Roadmap & Tasks - 134 tasks across 10 categories, pick any to contribute!

🌐 Ecosystem

Skill Seekers is a multi-repo project. Here's where everything lives:

Repository	Description	Links
Skill_Seekers	Core CLI & MCP server (this repo)	PyPI
skillseekersweb	Website & documentation	Live
skill-seekers-configs	Community config repository
skill-seekers-action	GitHub Action for CI/CD
skill-seekers-plugin	Claude Code plugin
homebrew-skill-seekers	Homebrew tap for macOS

Want to contribute? The website and configs repos are great starting points for new contributors!

🧠 The Data Layer for AI Systems

Skill Seekers is the universal preprocessing layer that sits between raw documentation and every AI system that consumes it. Whether you are building Claude skills, a LangChain RAG pipeline, or a Cursor .cursorrules file — the data preparation is identical. You do it once, and export to all targets.

# One command → structured knowledge asset
skill-seekers create https://docs.react.dev/
# or: skill-seekers create facebook/react
# or: skill-seekers create ./my-project

# Export to any AI system
skill-seekers package output/react --target claude      # → Claude AI Skill (ZIP)
skill-seekers package output/react --target langchain   # → LangChain Documents
skill-seekers package output/react --target llama-index # → LlamaIndex TextNodes
skill-seekers package output/react --target cursor      # → .cursorrules
skill-seekers package output/react --target ibm-bob     # → IBM Bob skill directory

What gets built

Output	Target	What it powers
Claude Skill (ZIP + YAML)	`--target claude`	Claude Code, Claude API
Gemini Skill (tar.gz)	`--target gemini`	Google Gemini
OpenAI / Custom GPT (ZIP)	`--target openai`	GPT-4o, custom assistants
LangChain Documents	`--target langchain`	QA chains, agents, retrievers
LlamaIndex TextNodes	`--target llama-index`	Query engines, chat engines
Haystack Documents	`--target haystack`	Enterprise RAG pipelines
Pinecone-ready (Markdown)	`--target markdown`	Vector upsert
ChromaDB / FAISS / Qdrant	`--target chroma/faiss/qdrant`	Local vector DBs
IBM Bob Skill (directory)	`--target ibm-bob`	IBM Bob project/global skills
Cursor `.cursorrules`	`--target markdown` → copy SKILL.md	Cursor IDE `.cursorrules`
Windsurf / Cline / Continue	`--target claude` → copy	VS Code, IntelliJ, Vim

Why it matters

⚡ 99% faster — Days of manual data prep → 15–45 minutes
🎯 AI Skill quality — 500+ line SKILL.md files with examples, patterns, and guides
📊 RAG-ready chunks — Smart chunking preserves code blocks and maintains context
🎬 Videos — Extract code, transcripts, and structured knowledge from YouTube and local videos
🔄 Multi-source — Combine 18 source types (docs, GitHub, PDFs, videos, notebooks, wikis, and more) into one knowledge asset
🌐 One prep, every target — Export the same asset to 21 platforms without re-scraping
✅ Battle-tested — 3,700+ tests, 24+ framework presets, production-ready

🚀 Quick Start (3 Commands)

# 1. Install
pip install skill-seekers

# 2. Create skill from any source
skill-seekers create https://docs.django.com/

# 3. Package for your AI platform
skill-seekers package output/django --target claude

That's it! You now have output/django-claude.zip ready to use.

# Use a different AI agent for enhancement (default: claude)
skill-seekers create https://docs.django.com/ --agent kimi
skill-seekers create https://docs.django.com/ --agent codex
skill-seekers create https://docs.django.com/ --agent-cmd "my-custom-agent run"

🛰️ AI-driven project scan (new)

Point scan at any project and an AI agent reads its manifests, README, Dockerfile/CI and sampled source imports — then emits one config per detected framework plus a <project>-codebase.json for your own code. Pins the detected version so re-running reports bumps:

skill-seekers scan ./my-react-app --out ./configs/scanned/
# → react.json, vite.json, tailwind.json, jest.json, my-react-app-codebase.json

# Then build any of them
skill-seekers create ./configs/scanned/react.json

If a detection has no existing preset, the AI generates a fresh config; on exit you can optionally publish it back to the community registry.

Other Sources (18 Supported)

# GitHub repository
skill-seekers create facebook/react

# Local project
skill-seekers create ./my-project

# PDF document
skill-seekers create manual.pdf

# Word document
skill-seekers create report.docx

# EPUB e-book
skill-seekers create book.epub

# Jupyter Notebook
skill-seekers create notebook.ipynb

# OpenAPI spec
skill-seekers create openapi.yaml

# PowerPoint presentation
skill-seekers create presentation.pptx

# AsciiDoc document
skill-seekers create guide.adoc

# Local HTML file (auto-detected by extension)
skill-seekers create page.html

# Whole directory of HTML files (auto-detected for HTML-dominant dirs)
skill-seekers create ./mirror_output/site/

# Force HTML mode on a mixed/code-heavy directory
skill-seekers create ./repo/ --html-path ./repo/docs/build/html/

# RSS/Atom feed
skill-seekers create feed.rss

# Man page
skill-seekers create curl.1

# Video (YouTube, Vimeo, or local file — requires skill-seekers[video])
skill-seekers create --video-url https://www.youtube.com/watch?v=... --name mytutorial
# First time? Auto-install GPU-aware visual deps:
skill-seekers create --setup

# Confluence wiki
skill-seekers create --space-key TEAM --name wiki

# Notion pages
skill-seekers create --database-id ... --name docs

# Slack/Discord chat export
skill-seekers create --chat-export-path ./slack-export --name team-chat

Export Everywhere

# Package for multiple platforms
for platform in claude gemini openai langchain; do
  skill-seekers package output/django --target $platform
done

What is Skill Seekers?

Skill Seekers is the data layer for AI systems. It transforms 18 source types—documentation websites, GitHub repositories, PDFs, videos, Jupyter Notebooks, Word/EPUB/AsciiDoc documents, OpenAPI specs, PowerPoint presentations, RSS feeds, man pages, Confluence wikis, Notion pages, Slack/Discord exports, and more—into structured knowledge assets for every AI target:

Use Case	What you get	Examples
AI Skills	Comprehensive SKILL.md + references	Claude Code, Gemini, GPT
RAG Pipelines	Chunked documents with rich metadata	LangChain, LlamaIndex, Haystack
Vector Databases	Pre-formatted data ready for upsert	Pinecone, Chroma, Weaviate, FAISS
AI Coding Assistants	Context files your IDE AI reads automatically	Cursor, Windsurf, Cline, Continue.dev

📚 Documentation

I want to...	Read this
Get started quickly	Quick Start - 3 commands to first skill
Understand concepts	Core Concepts - How it works
Scrape sources	Scraping Guide - All source types
Enhance skills	Enhancement Guide - AI enhancement
Export skills	Packaging Guide - Platform export
Look up commands	CLI Reference - All 20 commands
Configure	Config Format - JSON specification
Fix issues	Troubleshooting - Common problems

Complete documentation: docs/README.md

Instead of spending days on manual preprocessing, Skill Seekers:

Ingests — docs, GitHub repos, local codebases, PDFs, videos, notebooks, wikis, and 10+ more source types
Analyzes — deep AST parsing, pattern detection, API extraction
Structures — categorized reference files with metadata
Enhances — AI-powered SKILL.md generation (Claude, Gemini, or local)
Exports — 16 platform-specific formats from one asset

Why Use This?

For AI Skill Builders (Claude, Gemini, OpenAI)

🎯 Production-grade Skills — 500+ line SKILL.md files with code examples, patterns, and guides
🔄 Enhancement Workflows — Apply security-focus, architecture-comprehensive, or custom YAML presets
🎮 Any Domain — Game engines (Godot, Unity), frameworks (React, Django), internal tools
🔧 Teams — Combine internal docs + code into a single source of truth
📚 Quality — AI-enhanced with examples, quick reference, and navigation guidance

For RAG Builders & AI Engineers

🤖 RAG-ready data — Pre-chunked LangChain Documents, LlamaIndex TextNodes, Haystack Documents
🚀 99% faster — Days of preprocessing → 15–45 minutes
📊 Smart metadata — Categories, sources, types → better retrieval accuracy
🔄 Multi-source — Combine docs + GitHub + PDFs + videos in one pipeline
🌐 Platform-agnostic — Export to any vector DB or framework without re-scraping

For AI Coding Assistant Users

💻 Cursor / Windsurf / Cline — Generate .cursorrules / .windsurfrules / .clinerules automatically
🎯 Persistent context — AI "knows" your frameworks without repeated prompting
📚 Always current — Update context in minutes when docs change

Key Features

🌐 Documentation Scraping

✅ Smart SPA Discovery - Three-layer discovery for JavaScript SPA sites (sitemap.xml → llms.txt → headless browser rendering)
✅ llms.txt Support - Automatically detects and uses LLM-ready documentation files (10x faster)
✅ Universal Scraper - Works with ANY documentation website
✅ Smart Categorization - Automatically organizes content by topic
✅ Code Language Detection - Recognizes Python, JavaScript, C++, GDScript, etc.
✅ 24+ Ready-to-Use Presets - Godot, React, Vue, Django, FastAPI, and more

📄 PDF Support

✅ Basic PDF Extraction - Extract text, code, and images from PDF files
✅ OCR for Scanned PDFs - Extract text from scanned documents
✅ Password-Protected PDFs - Handle encrypted PDFs
✅ Table Extraction - Extract complex tables from PDFs
✅ Parallel Processing - 3x faster for large PDFs
✅ Intelligent Caching - 50% faster on re-runs

🎬 Video Extraction

✅ YouTube & Local Videos - Extract transcripts, on-screen code, and structured knowledge from videos
✅ Visual Frame Analysis - OCR extraction from code editors, terminals, slides, and diagrams
✅ GPU Auto-Detection - Automatically installs correct PyTorch build (CUDA/ROCm/MPS/CPU)
✅ AI Enhancement - Two-pass: clean OCR artifacts + generate polished SKILL.md
✅ Time Clipping - Extract specific sections with --start-time and --end-time
✅ Playlist Support - Batch process all videos in a YouTube playlist
✅ Vision API Fallback - Use Claude Vision for low-confidence OCR frames

🐙 GitHub Repository Analysis

✅ Deep Code Analysis - AST parsing for Python, JavaScript, TypeScript, Java, C++, Go
✅ API Extraction - Functions, classes, methods with parameters and types
✅ Repository Metadata - README, file tree, language breakdown, stars/forks
✅ GitHub Issues & PRs - Fetch open/closed issues with labels and milestones
✅ CHANGELOG & Releases - Automatically extract version history
✅ Conflict Detection - Compare documented APIs vs actual code implementation
✅ MCP Integration - Natural language: "Scrape GitHub repo facebook/react"

🔄 Unified Multi-Source Scraping

✅ Combine Multiple Sources - Mix documentation + GitHub + PDF in one skill
✅ Conflict Detection - Automatically finds discrepancies between docs and code
✅ Intelligent Merging - Rule-based or AI-powered conflict resolution
✅ Transparent Reporting - Side-by-side comparison with ⚠️ warnings
✅ Documentation Gap Analysis - Identifies outdated docs and undocumented features
✅ Single Source of Truth - One skill showing both intent (docs) and reality (code)
✅ Backward Compatible - Legacy single-source configs still work

🤖 Multi-LLM Platform Support

✅ 12 LLM Platforms - Claude AI, Google Gemini, OpenAI ChatGPT, MiniMax AI, Generic Markdown, OpenCode, Kimi (Moonshot AI), DeepSeek AI, Qwen (Alibaba), OpenRouter, Together AI, Fireworks AI
✅ Universal Scraping - Same documentation works for all platforms
✅ Platform-Specific Packaging - Optimized formats for each LLM
✅ One-Command Export - --target flag selects platform
✅ Optional Dependencies - Install only what you need
✅ 100% Backward Compatible - Existing Claude workflows unchanged

Platform	Format	Upload	Enhancement	API Key	Custom Endpoint
Claude AI	ZIP + YAML	✅ Auto	✅ Yes	ANTHROPIC_API_KEY	ANTHROPIC_BASE_URL
Google Gemini	tar.gz	✅ Auto	✅ Yes	GOOGLE_API_KEY	-
OpenAI ChatGPT	ZIP + Vector Store	✅ Auto	✅ Yes	OPENAI_API_KEY	-
MiniMax AI	ZIP + Knowledge Files	✅ Auto	✅ Yes	MINIMAX_API_KEY	-
Generic Markdown	ZIP	❌ Manual	❌ No	-	-

# Claude (default - no changes needed!)
skill-seekers package output/react/
skill-seekers upload react.zip

# Google Gemini
pip install skill-seekers[gemini]
skill-seekers package output/react/ --target gemini
skill-seekers upload react-gemini.tar.gz --target gemini

# OpenAI ChatGPT
pip install skill-seekers[openai]
skill-seekers package output/react/ --target openai
skill-seekers upload react-openai.zip --target openai

# MiniMax AI
pip install skill-seekers[minimax]
skill-seekers package output/react/ --target minimax
skill-seekers upload react-minimax.zip --target minimax

# Generic Markdown (universal export)
skill-seekers package output/react/ --target markdown
# Use the markdown files directly in any LLM

The optional AI enhancement step (used by create, scan, and enhance) does not require an Anthropic key. You have three ways to power it:

1. Use a subscription you already pay for — no API credits at all (LOCAL agent mode)

Skill Seekers can shell out to a coding-agent CLI you're already logged into, so enhancement runs on your existing plan instead of metered API tokens:

skill-seekers create <source> --agent codex     # OpenAI Codex CLI → your ChatGPT Plus
skill-seekers create <source> --agent claude    # Claude Code      → your Claude Pro/Max

Supported agents: claude, codex, copilot, opencode, kimi, and custom (pair --agent custom with --agent-cmd "<your-cli> ..." to drive any other tool).

2. Any OpenAI-compatible provider (OpenRouter, Groq, Cerebras, Mistral, NVIDIA NIM, …)

All of these expose an OpenAI-compatible /v1 endpoint. Point Skill Seekers at one with three env vars — it detects OPENAI_API_KEY, and the OpenAI SDK honors OPENAI_BASE_URL automatically:

export OPENAI_API_KEY="<your provider key>"
export OPENAI_BASE_URL="https://openrouter.ai/api/v1"   # provider endpoint (see table)
export OPENAI_MODEL="<a model that provider offers>"     # required — default gpt-4o won't exist elsewhere
skill-seekers create <source>

Provider	`OPENAI_BASE_URL`
OpenRouter	`https://openrouter.ai/api/v1`
Groq	`https://api.groq.com/openai/v1`
Cerebras	`https://api.cerebras.ai/v1`
Mistral	`https://api.mistral.ai/v1`
NVIDIA NIM	`https://integrate.api.nvidia.com/v1`

Provider detection picks the first API-key env var it finds (ANTHROPIC_API_KEY → GOOGLE_API_KEY → OPENAI_API_KEY → MOONSHOT_API_KEY). Set SKILL_SEEKER_PROVIDER to force a specific provider, or make sure the higher-priority keys are unset.

3. Claude-compatible endpoints (e.g. GLM, proxies)

export ANTHROPIC_API_KEY="your-key"
export ANTHROPIC_BASE_URL="https://your-claude-compatible-endpoint/v1"

Google Gemini (GOOGLE_API_KEY) and Kimi/Moonshot (MOONSHOT_API_KEY) are also supported natively. See Environment Variables Reference for the full list, including per-provider model overrides.

Installation:

# Install with Gemini support
pip install skill-seekers[gemini]

# Install with OpenAI support
pip install skill-seekers[openai]

# Install with MiniMax support
pip install skill-seekers[minimax]

# Install with all LLM platforms
pip install skill-seekers[all-llms]

🔗 RAG Framework Integrations

✅ LangChain Documents - Direct export to Document format with page_content + metadata
- Perfect for: QA chains, retrievers, vector stores, agents
- Example: LangChain RAG Pipeline
- Guide: LangChain Integration
✅ LlamaIndex TextNodes - Export to TextNode format with unique IDs + embeddings
- Perfect for: Query engines, chat engines, storage context
- Example: LlamaIndex Query Engine
- Guide: LlamaIndex Integration
✅ Pinecone-Ready Format - Optimized for vector database upsert
- Perfect for: Production vector search, semantic search, hybrid search
- Example: Pinecone Upsert
- Guide: Pinecone Integration

Quick Export:

# LangChain Documents (JSON)
skill-seekers package output/django --target langchain
# → output/django-langchain.json

# LlamaIndex TextNodes (JSON)
skill-seekers package output/django --target llama-index
# → output/django-llama-index.json

# Markdown (Universal)
skill-seekers package output/django --target markdown
# → output/django-markdown/SKILL.md + references/

Complete RAG Pipeline Guide: RAG Pipelines Documentation

🧠 AI Coding Assistant Integrations

Transform any framework documentation into expert coding context for 4+ AI assistants:

✅ Cursor IDE - Generate .cursorrules for AI-powered code suggestions
- Perfect for: Framework-specific code generation, consistent patterns
- Works with: Cursor IDE (VS Code fork)
- Guide: Cursor Integration
- Example: Cursor React Skill
✅ Windsurf - Customize Windsurf's AI assistant context with .windsurfrules
- Perfect for: IDE-native AI assistance, flow-based coding
- Works with: Windsurf IDE by Codeium
- Guide: Windsurf Integration
- Example: Windsurf FastAPI Context
✅ Cline (VS Code) - System prompts + MCP for VS Code agent
- Perfect for: Agentic code generation in VS Code
- Works with: Cline extension for VS Code
- Guide: Cline Integration
- Example: Cline Django Assistant
✅ Continue.dev - Context servers for IDE-agnostic AI
- Perfect for: Multi-IDE environments (VS Code, JetBrains, Vim), custom LLM providers
- Works with: Any IDE with Continue.dev plugin
- Guide: Continue Integration
- Example: Continue Universal Context

Quick Export for AI Coding Tools:

# For any AI coding assistant (Cursor, Windsurf, Cline, Continue.dev)
skill-seekers create --config configs/django.json
skill-seekers package output/django --target claude  # or --target markdown

# Copy to your project (example for Cursor)
cp output/django-claude/SKILL.md my-project/.cursorrules

# Or for Windsurf
cp output/django-claude/SKILL.md my-project/.windsurf/rules/django.md

# Or for Cline
cp output/django-claude/SKILL.md my-project/.clinerules

# Or for Continue.dev (HTTP server)
python examples/continue-dev-universal/context_server.py
# Configure in ~/.continue/config.json

Integration Hub: All AI System Integrations

🌊 Three-Stream GitHub Architecture

✅ Triple-Stream Analysis - Split GitHub repos into Code, Docs, and Insights streams
✅ Unified Codebase Analyzer - Works with GitHub URLs AND local paths
✅ C3.x as Analysis Depth - Choose 'basic' (1-2 min) or 'c3x' (20-60 min) analysis
✅ Enhanced Router Generation - GitHub metadata, README quick start, common issues
✅ Issue Integration - Top problems and solutions from GitHub issues
✅ Smart Routing Keywords - GitHub labels weighted 2x for better topic detection

Three Streams Explained:

Stream 1: Code - Deep C3.x analysis (patterns, examples, guides, configs, architecture)
Stream 2: Docs - Repository documentation (README, CONTRIBUTING, docs/*.md)
Stream 3: Insights - Community knowledge (issues, labels, stars, forks)

from skill_seekers.cli.unified_codebase_analyzer import UnifiedCodebaseAnalyzer

# Analyze GitHub repo with all three streams
analyzer = UnifiedCodebaseAnalyzer()
result = analyzer.analyze(
    source="https://github.com/facebook/react",
    depth="c3x",  # or "basic" for fast analysis
    fetch_github_metadata=True
)

# Access code stream (C3.x analysis)
print(f"Design patterns: {len(result.code_analysis['c3_1_patterns'])}")
print(f"Test examples: {result.code_analysis['c3_2_examples_count']}")

# Access docs stream (repository docs)
print(f"README: {result.github_docs['readme'][:100]}")

# Access insights stream (GitHub metadata)
print(f"Stars: {result.github_insights['metadata']['stars']}")
print(f"Common issues: {len(result.github_insights['common_problems'])}")

See complete documentation: Three-Stream Implementation Summary

🔐 Smart Rate Limit Management & Configuration

✅ Multi-Token Configuration System - Manage multiple GitHub accounts (personal, work, OSS)
- Secure config storage at ~/.config/skill-seekers/config.json (600 permissions)
- Per-profile rate limit strategies: prompt, wait, switch, fail
- Configurable timeout per profile (default: 30 min, prevents indefinite waits)
- Smart fallback chain: CLI arg → Env var → Config file → Prompt
- API key management for Claude, Gemini, OpenAI
✅ Interactive Configuration Wizard - Beautiful terminal UI for easy setup
- Browser integration for token creation (auto-opens GitHub, etc.)
- Token validation and connection testing
- Visual status display with color coding
✅ Intelligent Rate Limit Handler - No more indefinite waits!
- Upfront warning about rate limits (60/hour vs 5000/hour)
- Real-time detection from GitHub API responses
- Live countdown timers with progress
- Automatic profile switching when rate limited
- Four strategies: prompt (ask), wait (countdown), switch (try another), fail (abort)
✅ Resume Capability - Continue interrupted jobs
- Auto-save progress at configurable intervals (default: 60 sec)
- List all resumable jobs with progress details
- Auto-cleanup of old jobs (default: 7 days)
✅ CI/CD Support - Non-interactive mode for automation
- --non-interactive flag fails fast without prompts
- --profile flag to select specific GitHub account
- Clear error messages for pipeline logs

Quick Setup:

# One-time configuration (5 minutes)
skill-seekers config --github

# Use specific profile for private repos
skill-seekers create mycompany/private-repo --profile work

# CI/CD mode (fail fast, no prompts)
skill-seekers create owner/repo --non-interactive

# Resume interrupted job
skill-seekers resume --list
skill-seekers resume github_react_20260117_143022

Rate Limit Strategies Explained:

prompt (default) - Ask what to do when rate limited (wait, switch, setup token, cancel)
wait - Automatically wait with countdown timer (respects timeout)
switch - Automatically try next available profile (for multi-account setups)
fail - Fail immediately with clear error (perfect for CI/CD)

🎯 Bootstrap Skill - Self-Hosting

Generate skill-seekers as a skill to use within your AI agent (Claude Code, Kimi, Codex, etc.):

# Generate the skill
./scripts/bootstrap_skill.sh

# Install to Claude Code
cp -r output/skill-seekers ~/.claude/skills/

What you get:

✅ Complete skill documentation - All CLI commands and usage patterns
✅ CLI command reference - Every tool and its options documented
✅ Quick start examples - Common workflows and best practices
✅ Auto-generated API docs - Code analysis, patterns, and examples

🔐 Private Config Repositories

✅ Git-Based Config Sources - Fetch configs from private/team git repositories
✅ Multi-Source Management - Register unlimited GitHub, GitLab, Bitbucket repos
✅ Team Collaboration - Share custom configs across 3-5 person teams
✅ Enterprise Support - Scale to 500+ developers with priority-based resolution
✅ Secure Authentication - Environment variable tokens (GITHUB_TOKEN, GITLAB_TOKEN)
✅ Intelligent Caching - Clone once, pull updates automatically
✅ Offline Mode - Work with cached configs when offline

🤖 Codebase Analysis (C3.x)

C3.4: Configuration Pattern Extraction with AI Enhancement

✅ 9 Config Formats - JSON, YAML, TOML, ENV, INI, Python, JavaScript, Dockerfile, Docker Compose
✅ 7 Pattern Types - Database, API, logging, cache, email, auth, server configurations
✅ AI Enhancement - Optional dual-mode AI analysis (API + LOCAL)
- Explains what each config does
- Suggests best practices and improvements
- Security analysis - Finds hardcoded secrets, exposed credentials
✅ Auto-Documentation - Generates JSON + Markdown documentation of all configs
✅ MCP Integration - extract_config_patterns tool with enhancement support

C3.3: AI-Enhanced How-To Guides

✅ Comprehensive AI Enhancement - Transforms basic guides into professional tutorials
✅ 5 Automatic Improvements - Step descriptions, troubleshooting, prerequisites, next steps, use cases
✅ Dual-Mode Support - API mode (Claude API) or LOCAL mode (Claude Code CLI)
✅ No API Costs with LOCAL Mode - FREE enhancement using your Claude Code Max plan
✅ Quality Transformation - 75-line templates → 500+ line comprehensive guides

Usage:

# Quick analysis (1-2 min, basic features only)
skill-seekers scan tests/ --quick

# Comprehensive analysis with AI (20-60 min, all features)
skill-seekers scan tests/ --comprehensive

# With AI enhancement
skill-seekers scan tests/ --enhance

Full Documentation: docs/features/HOW_TO_GUIDES.md

🔄 Enhancement Workflow Presets

Reusable YAML-defined enhancement pipelines that control how AI transforms your raw documentation into a polished skill.

✅ 5 Bundled Presets — default, minimal, security-focus, architecture-comprehensive, api-documentation
✅ User-Defined Presets — add custom workflows to ~/.config/skill-seekers/workflows/
✅ Multiple Workflows — chain two or more workflows in one command
✅ Fully Managed CLI — list, inspect, copy, add, remove, and validate workflows

# Apply a single workflow
skill-seekers create ./my-project --enhance-workflow security-focus

# Chain multiple workflows (applied in order)
skill-seekers create ./my-project \
  --enhance-workflow security-focus \
  --enhance-workflow minimal

# Manage presets
skill-seekers workflows list                          # List all (bundled + user)
skill-seekers workflows show security-focus           # Print YAML content
skill-seekers workflows copy security-focus           # Copy to user dir for editing
skill-seekers workflows add ./my-workflow.yaml        # Install a custom preset
skill-seekers workflows remove my-workflow            # Remove a user preset
skill-seekers workflows validate security-focus       # Validate preset structure

# Copy multiple at once
skill-seekers workflows copy security-focus minimal api-documentation

# Add multiple files at once
skill-seekers workflows add ./wf-a.yaml ./wf-b.yaml

# Remove multiple at once
skill-seekers workflows remove my-wf-a my-wf-b

YAML preset format:

name: security-focus
description: "Security-focused review: vulnerabilities, auth, data handling"
version: "1.0"
stages:
  - name: vulnerabilities
    type: custom
    prompt: "Review for OWASP top 10 and common security vulnerabilities..."
  - name: auth-review
    type: custom
    prompt: "Examine authentication and authorisation patterns..."
    uses_history: true

⚡ Performance & Scale

✅ Async Mode - 2-3x faster scraping with async/await (use --async flag)
✅ Large Documentation Support - Handle 10K-40K+ page docs with intelligent splitting
✅ Router/Hub Skills - Intelligent routing to specialized sub-skills
✅ Parallel Scraping - Process multiple skills simultaneously
✅ Checkpoint/Resume - Never lose progress on long scrapes
✅ Caching System - Scrape once, rebuild instantly

🤖 Agent-Agnostic Skill Generation

✅ Multi-Agent Support - Generate skills for Claude, Kimi, Codex, Copilot, OpenCode, or any custom agent via --agent flag
✅ Custom Agent Commands - Use --agent-cmd to specify a custom agent CLI command for enhancement
✅ Universal Flags - --agent and --agent-cmd available on all commands (create, scrape, github, pdf, etc.)

📦 Marketplace Pipeline

✅ Publish to Marketplace - Publish skills to Claude Code plugin marketplace repos
✅ End-to-End Pipeline - From documentation source to published marketplace entry

✅ Quality Assurance

✅ Fully Tested - 3,700+ tests with comprehensive coverage

📦 Installation

# Basic install (documentation scraping, GitHub analysis, PDF, packaging)
pip install skill-seekers

# With all LLM platform support
pip install skill-seekers[all-llms]

# With MCP server
pip install skill-seekers[mcp]

# Everything
pip install skill-seekers[all]

Need help choosing? Run the setup wizard:

skill-seekers-setup

Installation Options

Install	Features
`pip install skill-seekers`	Scraping, GitHub analysis, PDF, all platforms
`pip install skill-seekers[gemini]`	+ Google Gemini support
`pip install skill-seekers[openai]`	+ OpenAI ChatGPT support
`pip install skill-seekers[all-llms]`	+ All LLM platforms
`pip install skill-seekers[mcp]`	+ MCP server for Claude Code, Cursor, etc.
`pip install skill-seekers[video]`	+ YouTube/Vimeo transcript & metadata extraction
`pip install skill-seekers[video-full]`	+ Whisper transcription & visual frame extraction
`pip install skill-seekers[jupyter]`	+ Jupyter Notebook support
`pip install skill-seekers[pptx]`	+ PowerPoint support
`pip install skill-seekers[confluence]`	+ Confluence wiki support
`pip install skill-seekers[notion]`	+ Notion pages support
`pip install skill-seekers[rss]`	+ RSS/Atom feed support
`pip install skill-seekers[chat]`	+ Slack/Discord chat export support
`pip install skill-seekers[asciidoc]`	+ AsciiDoc document support
`pip install skill-seekers[all]`	Everything enabled

Video visual deps (GPU-aware): After installing skill-seekers[video-full], run skill-seekers create --setup to auto-detect your GPU and install the correct PyTorch variant + easyocr. This is the recommended way to install visual extraction dependencies.

🚀 One-Command Install Workflow

The fastest way to go from config to uploaded skill - complete automation:

# Install React skill from official configs (auto-uploads to Claude)
skill-seekers install --config react

# Install from local config file
skill-seekers install --config configs/custom.json

# Install without uploading (package only)
skill-seekers install --config django --no-upload

# Preview workflow without executing
skill-seekers install --config react --dry-run

Time: 20-45 minutes total | Quality: Production-ready (9/10) | Cost: Free

Phases executed:

📥 PHASE 1: Fetch Config (if config name provided)
📖 PHASE 2: Scrape Documentation
✨ PHASE 3: AI Enhancement (MANDATORY - no skip option)
📦 PHASE 4: Package Skill
☁️  PHASE 5: Upload to Claude (optional, requires API key)

Requirements:

ANTHROPIC_API_KEY environment variable (for auto-upload)
Claude Code Max plan (for local AI enhancement), or use --agent to select a different AI agent

📊 Feature Matrix

Skill Seekers supports 12 LLM platforms, 8 RAG/vector targets, 18 source types, and full feature parity across all targets.

Platforms: Claude AI, Google Gemini, OpenAI ChatGPT, MiniMax AI, Generic Markdown, OpenCode, Kimi (Moonshot AI), DeepSeek AI, Qwen (Alibaba), OpenRouter, Together AI, Fireworks AI Source Types: Documentation websites, GitHub repos, PDFs, Word (.docx), EPUB, Video, Local codebases, Jupyter Notebooks, Local HTML, OpenAPI/Swagger, AsciiDoc, PowerPoint (.pptx), RSS/Atom feeds, Man pages, Confluence wikis, Notion pages, Slack/Discord chat exports

See Complete Feature Matrix for detailed platform and feature support.

Quick Platform Comparison

Feature	Claude	Gemini	OpenAI	MiniMax	Markdown
Format	ZIP + YAML	tar.gz	ZIP + Vector	ZIP + Knowledge	ZIP
Upload	✅ API	✅ API	✅ API	✅ API	❌ Manual
Enhancement	✅ Sonnet 4	✅ 2.0 Flash	✅ GPT-4o	✅ M3	❌ None
All Skill Modes	✅	✅	✅	✅	✅

Usage Examples

Documentation Scraping

# Scrape documentation website
skill-seekers create --config configs/react.json

# Quick scrape without config
skill-seekers create https://react.dev --name react

# With async mode (3x faster)
skill-seekers create --config configs/godot.json --async --workers 8

# Use a specific AI agent for enhancement
skill-seekers create --config configs/react.json --agent kimi

PDF Extraction

# Basic PDF extraction
skill-seekers create --pdf docs/manual.pdf --name myskill

# Advanced features
skill-seekers create --pdf docs/manual.pdf --name myskill \
    --extract-tables \        # Extract tables
    --parallel \              # Fast parallel processing
    --workers 8               # Use 8 CPU cores

# Scanned PDFs (requires: pip install pytesseract Pillow)
skill-seekers create --pdf docs/scanned.pdf --name myskill --ocr

Video Extraction

# Install video support
pip install skill-seekers[video]        # Transcripts + metadata
pip install skill-seekers[video-full]   # + Whisper + visual frame extraction

# Auto-detect GPU and install visual deps (PyTorch + easyocr)
skill-seekers create --setup

# Extract from YouTube video
skill-seekers create --video-url https://www.youtube.com/watch?v=dQw4w9WgXcQ --name mytutorial

# Extract from a YouTube playlist
skill-seekers create --video-playlist https://www.youtube.com/playlist?list=... --name myplaylist

# Extract from a local video file
skill-seekers create --video-file recording.mp4 --name myrecording

# Extract with visual frame analysis (requires video-full deps)
skill-seekers create --video-url https://www.youtube.com/watch?v=... --name mytutorial --visual

# With AI enhancement (cleans OCR + generates polished SKILL.md)
skill-seekers create --video-url https://www.youtube.com/watch?v=... --visual --enhance-level 2

# Clip a specific section of a video (supports seconds, MM:SS, HH:MM:SS)
skill-seekers create --video-url https://www.youtube.com/watch?v=... --start-time 1:30 --end-time 5:00

# Use Vision API for low-confidence OCR frames (requires ANTHROPIC_API_KEY)
skill-seekers create --video-url https://www.youtube.com/watch?v=... --visual --vision-ocr

# Re-build skill from previously extracted data (skip download)
skill-seekers create --from-json output/mytutorial/video_data/extracted_data.json --name mytutorial

Full guide: See docs/VIDEO_GUIDE.md for complete CLI reference, visual pipeline details, AI enhancement options, and troubleshooting.

GitHub Repository Analysis

# Basic repository scraping
skill-seekers create facebook/react

# With authentication (higher rate limits)
export GITHUB_TOKEN=ghp_your_token_here
skill-seekers create facebook/react

# Customize what to include
skill-seekers create django/django \
    --include-issues \        # Extract GitHub Issues
    --max-issues 100 \        # Limit issue count
    --include-changelog       # Extract CHANGELOG.md

Unified Multi-Source Scraping

Combine documentation + GitHub + PDF into one unified skill with conflict detection:

# Use existing unified configs
skill-seekers create --config configs/react_unified.json
skill-seekers create --config configs/django_unified.json

# Or create unified config
cat > configs/myframework_unified.json << 'EOF'
{
  "name": "myframework",
  "merge_mode": "rule-based",
  "sources": [
    {
      "type": "documentation",
      "base_url": "https://docs.myframework.com/",
      "max_pages": 200
    },
    {
      "type": "github",
      "repo": "owner/myframework",
      "code_analysis_depth": "surface"
    }
  ]
}
EOF

skill-seekers create --config configs/myframework_unified.json

Conflict Detection automatically finds:

🔴 Missing in code (high): Documented but not implemented
🟡 Missing in docs (medium): Implemented but not documented
⚠️ Signature mismatch: Different parameters/types
ℹ️ Description mismatch: Different explanations

Full Guide: See docs/features/UNIFIED_SCRAPING.md for complete documentation.

Private Config Repositories

Share custom configs across teams using private git repositories:

# Option 1: Using MCP tools (recommended)
# Register your team's private repo
add_config_source(
    name="team",
    git_url="https://github.com/mycompany/skill-configs.git",
    token_env="GITHUB_TOKEN"
)

# Fetch config from team repo
fetch_config(source="team", config_name="internal-api")

Supported Platforms:

GitHub (GITHUB_TOKEN), GitLab (GITLAB_TOKEN), Gitea (GITEA_TOKEN), Bitbucket (BITBUCKET_TOKEN)

Full Guide: See docs/reference/GIT_CONFIG_SOURCES.md for complete documentation.

How It Works

graph LR
    A[Documentation Website] --> B[Skill Seekers]
    B --> C[Scraper]
    B --> D[AI Enhancement]
    B --> E[Packager]
    C --> F[Organized References]
    D --> F
    F --> E
    E --> G[AI Skill .zip]
    G --> H[Upload to AI Platform]

Detect llms.txt - Checks for llms-full.txt, llms.txt, llms-small.txt first (part of Smart SPA Discovery)
Scrape: Extracts all pages from documentation
Categorize: Organizes content into topics (API, guides, tutorials, etc.)
Enhance: AI analyzes docs and creates comprehensive SKILL.md with examples (supports multiple agents via --agent)
Package: Bundles everything into a platform-ready .zip file

Architecture

The system is organized into 8 core modules and 5 utility modules (~200 classes total):

Package Overview

Module	Purpose	Key Classes
CLICore	Git-style command dispatcher	`CLIDispatcher`, `SourceDetector`, `CreateCommand`
Scrapers	18 source-type extractors	`DocToSkillConverter`, `DocumentSkillBuilder` (shared build layer), `UnifiedScraper`
Adaptors	20+ output platform formats	`SkillAdaptor` (ABC), `ClaudeAdaptor`, `LangChainAdaptor`
Analysis	C3.x codebase analysis pipeline	`UnifiedCodebaseAnalyzer`, `PatternRecognizer`, 10 GoF detectors
Enhancement	AI-powered skill improvement via `AgentClient`	`AgentClient`, `AIEnhancer`, `UnifiedEnhancer`, `WorkflowEngine`
Packaging	Package, upload, install skills	`PackageSkill`, `InstallAgent`
MCP	FastMCP server (40 tools)	`SkillSeekerMCPServer`, 10 tool modules
Sync	Doc change detection	`ChangeDetector`, `SyncMonitor`, `Notifier`

Utility modules: Parsers (28 CLI parsers), Storage (S3/GCS/Azure), Embedding (multi-provider vectors), Benchmark (performance), Utilities (16 shared helpers).

Full UML diagrams: docs/UML_ARCHITECTURE.md | StarUML project: docs/UML/skill_seekers.mdj | HTML API reference: docs/UML/html/

📋 Prerequisites

Before you start, make sure you have:

Python 3.10 or higher - Download | Check: python3 --version
Git - Download | Check: git --version
15-30 minutes for first-time setup

First time user? → Start Here: Bulletproof Quick Start Guide 🎯

📤 Uploading Skills to Claude

Once your skill is packaged, you need to upload it to Claude:

Option 1: Automatic Upload (API-based)

# Set your API key (one-time)
export ANTHROPIC_API_KEY=sk-ant-...

# Package and upload automatically
skill-seekers package output/react/ --upload

# OR upload existing .zip
skill-seekers upload output/react.zip

Option 2: Manual Upload (No API Key)

# Package skill
skill-seekers package output/react/
# → Creates output/react.zip

# Then manually upload:
# - Go to https://claude.ai/skills
# - Click "Upload Skill"
# - Select output/react.zip

Option 3: MCP (Claude Code)

In Claude Code, just ask:
"Package and upload the React skill"

🤖 Installing to AI Agents

Skill Seekers can automatically install skills to 19 AI coding agents.

# Install to specific agent
skill-seekers install-agent output/react/ --agent cursor

# Install to IBM Bob (project-local .bob/skills/)
skill-seekers install-agent output/react/ --agent bob

# Install to all agents at once
skill-seekers install-agent output/react/ --agent all

# Preview without installing
skill-seekers install-agent output/react/ --agent cursor --dry-run

Supported Agents

Agent	Path	Type
Claude Code	`~/.claude/skills/`	Global
Cursor	`.cursor/skills/`	Project
VS Code / Copilot	`.github/skills/`	Project
Amp	`~/.amp/skills/`	Global
Goose	`~/.config/goose/skills/`	Global
OpenCode	`~/.opencode/skills/`	Global
Windsurf	`~/.windsurf/skills/`	Global
Roo Code	`.roo/skills/`	Project
Cline	`.cline/skills/`	Project
Aider	`~/.aider/skills/`	Global
Bolt	`.bolt/skills/`	Project
Kilo Code	`.kilo/skills/`	Project
Continue	`~/.continue/skills/`	Global
Kimi Code	`~/.kimi/skills/`	Global
IBM Bob	`.bob/skills/`	Project

🔌 MCP Integration (40 Tools)

Skill Seekers ships an MCP server for use from Claude Code, Cursor, Windsurf, VS Code + Cline, or IntelliJ IDEA.

# stdio mode (Claude Code, VS Code + Cline)
python -m skill_seekers.mcp.server_fastmcp

# HTTP mode (Cursor, Windsurf, IntelliJ)
python -m skill_seekers.mcp.server_fastmcp --transport http --port 8765

# Auto-configure all agents at once
./setup_mcp.sh

All 40 tools available:

Core (9): list_configs, generate_config, validate_config, estimate_pages, scrape_docs, package_skill, upload_skill, enhance_skill, install_skill
Extended (10): scrape_github, scrape_pdf, unified_scrape, merge_sources, detect_conflicts, add_config_source, fetch_config, list_config_sources, remove_config_source, split_config
Vector DB (4): export_to_chroma, export_to_weaviate, export_to_faiss, export_to_qdrant
Cloud (3): cloud_upload, cloud_download, cloud_list

Full Guide: docs/guides/MCP_SETUP.md

⚙️ Configuration

Available Presets (24+)

# List all presets
# skill-seekers list-configs  # Not available in v3.7.0

Category	Presets
Web Frameworks	`react`, `vue`, `angular`, `svelte`, `nextjs`
Python	`django`, `flask`, `fastapi`, `sqlalchemy`, `pytest`
Game Development	`godot`, `pygame`, `unity`
Tools & DevOps	`docker`, `kubernetes`, `terraform`, `ansible`
Unified (Docs + GitHub)	`react-unified`, `vue-unified`, `nextjs-unified`, and more

Creating Your Own Config

# Option 1: Interactive
skill-seekers create --interactive

# Option 2: Copy and edit a preset
cp configs/react.json configs/myframework.json
nano configs/myframework.json
skill-seekers create --config configs/myframework.json

Config File Structure

{
  "name": "myframework",
  "description": "When to use this skill",
  "base_url": "https://docs.myframework.com/",
  "selectors": {
    "main_content": "article",
    "title": "h1",
    "code_blocks": "pre code"
  },
  "url_patterns": {
    "include": ["/docs", "/guide"],
    "exclude": ["/blog", "/about"]
  },
  "categories": {
    "getting_started": ["intro", "quickstart"],
    "api": ["api", "reference"]
  },
  "rate_limit": 0.5,
  "max_pages": 500
}

Where to Store Configs

The tool searches in this order:

Exact path as provided
./configs/ (current directory)
~/.config/skill-seekers/configs/ (user config directory)
SkillSeekersWeb.com API (preset configs)

📊 What Gets Created

output/
├── godot_data/              # Scraped raw data
│   ├── pages/              # JSON files (one per page)
│   └── summary.json        # Overview
│
└── godot/                   # The skill
    ├── SKILL.md            # Enhanced with real examples
    ├── references/         # Categorized docs
    │   ├── index.md
    │   ├── getting_started.md
    │   ├── scripting.md
    │   └── ...
    ├── scripts/            # Empty (add your own)
    └── assets/             # Empty (add your own)

🐛 Troubleshooting

No Content Extracted?

Check your main_content selector
Try: article, main, div[role="main"]

Data Exists But Won't Use It?

# Force re-scrape
rm -rf output/myframework_data/
skill-seekers create --config configs/myframework.json

Categories Not Good?

Edit the config categories section with better keywords.

Want to Update Docs?

# Delete old data and re-scrape
rm -rf output/godot_data/
skill-seekers create --config configs/godot.json

Enhancement Not Working?

# Check if API key is set
echo $ANTHROPIC_API_KEY

# Try LOCAL mode instead (uses Claude Code Max, no API key needed)
skill-seekers enhance output/react/ --mode LOCAL

# Monitor background enhancement status
skill-seekers enhance-status output/react/ --watch

GitHub Rate Limit Issues?

# Set a GitHub token (5000 req/hour vs 60/hour anonymous)
export GITHUB_TOKEN=ghp_your_token_here

# Or configure multiple profiles
skill-seekers config --github

📈 Performance

Task	Time	Notes
Scraping (sync)	15-45 min	First time only, thread-based
Scraping (async)	5-15 min	2-3x faster with `--async` flag
Building	1-3 min	Fast rebuild from cache
Re-building	<1 min	With `--skip-scrape`
Enhancement (LOCAL)	30-60 sec	Uses Claude Code Max
Enhancement (API)	20-40 sec	Requires API key
Video (transcript)	1-3 min	YouTube/local, transcript only
Video (visual)	5-15 min	+ OCR frame extraction
Packaging	5-10 sec	Final .zip creation

🆕 New in v3.6.0

Workflow Presets

Control analysis depth with --preset:

skill-seekers create https://docs.react.dev/ --preset quick      # Fast, surface-level
skill-seekers create https://docs.react.dev/ --preset standard   # Balanced (default)
skill-seekers create https://docs.react.dev/ --preset comprehensive # Deep, exhaustive

Lifecycle Flags

skill-seekers create https://docs.react.dev/ --dry-run    # Preview without scraping
skill-seekers create https://docs.react.dev/ --fresh      # Ignore cache, full re-scrape
skill-seekers create https://docs.react.dev/ --resume     # Resume interrupted job
skill-seekers create https://docs.react.dev/ --skip-scrape # Re-package existing output

Health Check & Utilities

skill-seekers doctor                    # Diagnose installation & environment
skill-seekers sync-config               # Detect config drift
skill-seekers stream <source>           # Streaming ingestion for large docs
skill-seekers update output/react/      # Incremental update
skill-seekers multilang <source>        # Multi-language skill generation
skill-seekers quality output/react/     # Quality report (add --threshold 7 to gate: non-zero exit below 7/10)

RAG Chunking Options (package)

skill-seekers package output/react/ --chunk-for-rag --chunk-tokens 512 --chunk-overlap-tokens 50

Marketplace Publishing

skill-seekers package output/react/ --marketplace --marketplace-category frontend

Additional Optional Dependencies

Extra	Install	Purpose
`browser`	`pip install "skill-seekers[browser]"`	Headless Playwright for SPA sites
`embedding`	`pip install "skill-seekers[embedding]"`	Embedding server support
`s3` / `gcs` / `azure`	`pip install "skill-seekers[s3]"` etc.	Cloud storage upload
`rag-upload`	`pip install "skill-seekers[rag-upload]"`	Combined vector DB upload deps

📚 Documentation

Getting Started

BULLETPROOF_QUICKSTART.md - 🎯 START HERE if you're new!
QUICKSTART.md - Quick start for experienced users
TROUBLESHOOTING.md - Common issues and solutions
docs/archive/legacy/QUICK_REFERENCE.md - One-page cheat sheet

Architecture

docs/UML_ARCHITECTURE.md - UML architecture overview with 14 diagrams
docs/UML/exports/ - PNG diagram exports (package overview + 13 class diagrams)
docs/UML/html/ - Full HTML API reference (all classes, operations, attributes)
docs/UML/skill_seekers.mdj - StarUML project file (open with StarUML)

Guides

docs/reference/LARGE_DOCUMENTATION.md - Handle 10K-40K+ page docs
docs/features/ENHANCEMENT_MODES.md - AI enhancement modes guide
docs/guides/MCP_SETUP.md - MCP integration setup
docs/features/UNIFIED_SCRAPING.md - Multi-source scraping
docs/VIDEO_GUIDE.md - Video extraction guide

Integration Guides

docs/integrations/LANGCHAIN.md - LangChain RAG
docs/integrations/CURSOR.md - Cursor IDE
docs/integrations/WINDSURF.md - Windsurf IDE
docs/integrations/CLINE.md - Cline (VS Code)
docs/integrations/RAG_PIPELINES.md - All RAG pipelines

📝 License

MIT License - see LICENSE file for details

Happy skill building! 🚀

🔒 Security

💛 Sponsors

Atlas Cloud — a full-modal, OpenAI-compatible AI inference platform. Skill Seekers supports it as a packaging/enhancement target via --target atlas with ATLAS_API_KEY.

File tree

1973

yusufkaraaslan/Skill_SeekersView on GitHub ↗

.claude/
  mcp_config.example.json
.codex-plugin/
  plugin.json
.dockerignore
.env.example
.github/
  create_issues.sh
  FUNDING.yml
  ISSUE_TEMPLATE/
    bug_report.md
    documentation.md
    feature_request.md
    mcp_tool.md
  PULL_REQUEST_TEMPLATE.md
  workflows/
    docker-publish.yml
    quality-metrics.yml
    release.yml
    scheduled-updates.yml
    test-vector-dbs.yml
    tests.yml
    vector-db-export.yml
.gitignore
.gitmodules
.mcp.json
.vscode/
  settings.json
AGENTS.md
api/
  __init__.py
  .gitignore
  config_analyzer.py
  main.py
  README.md
  requirements.txt
BULLETPROOF_QUICKSTART.md
CHANGELOG.md
CLAUDE.md
codecov.yml
configs/
  astrovalley_unified.json
  blender-unified.json
  claude-code-unified.json
  claude-code.json
  godot_unified.json
  godot.json
  httpx_comprehensive.json
  medusa-mercurjs.json
  react.json
  unity-addressables.json
  unity-dotween.json
  unity-spine.json
CONTRIBUTING.md
distribution/
  claude-plugin/
    .claude-plugin/
      plugin.json
    .mcp.json
    commands/
      create-skill.md
      install-skill.md
      sync-config.md
    README.md
    skills/
      skill-builder/
        SKILL.md
  github-action/
    action.yml
    README.md
  smithery/
    README.md
docker-compose.yml
Dockerfile
Dockerfile.mcp
docs/
  ARCHITECTURE.md
  BEST_PRACTICES.md
  BUG_AUDIT.md
  DOCKER_DEPLOYMENT.md
  FAQ.md
  KUBERNETES_DEPLOYMENT.md
  PRODUCTION_DEPLOYMENT.md
  README.md
  TROUBLESHOOTING.md
  UML/
    exports/
      00_package_overview.png
      01_cli_core.png
      02_scrapers.png
      03_adaptors.png
      04_analysis.png
      05_enhancement.png
      06_packaging.png
      07_mcp_server.png
      08_sync.png
      09_parsers.png
      10_storage.png
      11_embedding.png
      12_benchmark.png
      13_utilities.png
      14_create_pipeline_sequence.png
      15_github_unified_sequence.png
      16_source_detection_activity.png
      17_mcp_invocation_sequence.png
      18_enhancement_activity.png
      19_runtime_components.png
      20_browser_rendering_sequence.png
    html/
      index.html/
        assets/
          css/
            bootstrap.css
            jquery.bonsai.css
            main.css
          icon-font/
            icons.css
            icons.eot
            icons.html
            icons.ttf
            icons.woff
          img/
            glyphicons-halflings-white.png
            glyphicons-halflings.png
          js/
            bootstrap.js
            imageMapResizer.min.js
            jquery-2.1.0.min.js
            jquery.bonsai.js
            less-1.7.0.min.js
        contents/
          001c2eb31f7c3880775f9ab7ae4d0300.html
          0025564de1473d71f4a6a0503fcdb056.html
          00509100c34315b0f095eb3ccb34b023.html
          007ccbce3f2ec8a3534b719b3f0fca25.html
          00910695df59fa1e85314f6d17e4051f.html
          00b94cf5cf9ebf3c6672e9c21deff7ee.html
          00cb702eeb69e434bafcc1e2b04507b1.html
          00fb8de24d76667858a719d127f22f51.html
          010d7f06abc5890127077ec8d4d1038f.html
          0145e471015eac4d3ed45baa8579cb6b.html
          017fe081f5f76bed1d02586c4bb7f0b9.html
          01d30778d4613da403d3225af832495c.html
          01ff8f1b7d9d7beccdfac55ed1d3017d.html
          020e1bb770a7768e07c0338ecb4bda09.html
          02231b18c56eee1fe00db0b3cc88d3f3.html
          02524d7a310024538b8bf2b5217a0405.html
          0268261b9eda98ff7a999e6589b545c3.html
          0285f49d97b595de19ad3a55a9aa5fac.html
          029322692df61d1c9239a003a4f4947d.html
          02be13f7c985dd6b4b7a23916cf05ae4.html
          02c5b0d5c646f5b2a4735851a1a20a8f.html
          02d026fb13af0923877f41f68fb5585e.html
          02ddacbfe77e6d70d993a01120ddd2ac.html
          02e78bb1d9b10da68dd8d62379086a6e.html
          02f04803adb5c2b766559ee9412753dc.html
          030c139fa6e0d10e86fdb3d57e91149f.html
          0316bf28f31dfcc53a38fff09e04d662.html
          03453c84f468d387ae974dc92ceda0d6.html
          034b43824827421add2453b7695fc9b3.html
          0380ecfd61cacc868ff1d659572725bc.html
          03a572027e9889827df3efe4865d6c04.html
          03a80d0c833ca4ccb7d1214c35c1e1f3.html
          03b3d85c37ae6295a16b15383df9c540.html
          03d20cc75938c4aab55c8ce9feb554c5.html
          03e029aaa80cc56c5487c5172dbf41cc.html
          03ec42466372e6ac1f6317227d6a0563.html
          03f058a533840c37160ba9cbb3005bef.html
          040003573ebaf30612a0b6c775cc3702.html
          0423a6d6ebaedf5e0aa9c0cd98b8bff1.html
          044b5cd04d02bac8cea889cb65106f43.html
          0483a3757c109c28a7230e73efd926a1.html
          0490a212778e5ffa6d79cdf230143138.html
          04be98ec9bb8041fa720700c2ccc1351.html
          04d495ef445aec5ab8fada58f2ad2025.html
          04e0dd3038afc17aadc753ad9b8ffcd2.html
          04e975cb83b23b9c6a67aad0a9f79acf.html
          04f7b9e78182b7d501da5a2a7e9ab415.html
          0502b099c81cd8ec649f26367f0dc00c.html
          0525e1fe146314bf2258c8b421b5b4aa.html
          05266a4a31f3cfbb0093b305667bc937.html
          0551bb6cbac15533f87c5838f117a454.html
          055516bb90ac718f5b8c1c8da847c7b0.html
          0565785c1fa564d4b90864c7c45922e5.html
          0581aae259550c0b2f535f82a27a20d2.html
          05d2236199bcdc97250863d4d250f673.html
          05d2f64f779d9377edddfd01920b899f.html
          05d3258d24905a654413605b5e0974f5.html
          05d369359212eac14ceb7a81753d2e87.html
          05d6ebcd7c258f23a170566a10c631f2.html
          05e160e75f565278ee83d6208b57c04a.html
          068d87025fe2aadb0507fe941fef8c06.html
          06959fa5355b0e6089c1c9f9f7af3aa6.html
          06d8f28dd785295227c8a1d664901ca6.html
          06f8f577e16e7d14c5086f3106796bd7.html
          070148fb11e435ea8f68b1d19cc19db3.html
          071d0d0f0f869f58f3ea4bc2dd916024.html
          073c989581e4b19401094d4e6b51a5b7.html
          07cf2536e7dbcf8d87afb33d4f6b2bdf.html
          07dacffc54f86475400204d093091588.html
          07ddaa4469eef6b224bce1f3f94752ef.html
          07eacff5fbd0a5a70fe3f321c7debba4.html
          08042f3437de69e3a4e3d65f86fde219.html
          081582bfe433eed0e3f57b298ed41f30.html
          08252d0c94f009b38c67287903edcb46.html
          083bd48e3733bd417ab8120d83062ed6.html
          084f65230d8e15d82dca008da5251503.html
          0875b7edc4d8e095b97f5adc19022083.html
          08a42a9cb33085033c589053dbef600c.html
          08a4b7115cae2a5970b962330796c00f.html
          08be6fb667da531dffce499974b3d41e.html
          08c6a1e6dfd23011c9f97fc41749fcbf.html
          08f15a81b2edd5a6cfdd763c99b3e6d9.html
          0904333092b12540d685f51441775d3f.html
          09a413250fe5275c26bd7fafb7a6af9b.html
          09a660aa19e69354745dd6da7ad168d5.html
          09befc42a3401e984c3472d643915c12.html
          09c94c5e380c212e227886b2d7bd34f8.html
          09efe71eec1d050cea48d72ce2e3afc5.html
          0a0f1f352ebda364e54afcee85ff8e31.html
          0a2c3c32f8650cc60d6a251e325931b7.html
          0a628ab23c874b12d2bb7c57f08bacd3.html
          0a8fab81ff1fe4fcf2830088d57a3389.html
          0a97292d8e93749d795ceb9d3a7ea43b.html
          0a98b22d6960a0d5d4b45307cf38a376.html
          0aea6c69f9758e6f7ec260bb3a67fb7d.html
          0af0718934b7c9bf0704b33c6edceb0a.html
          0b13587dd50b418879fcc9d5fb4b0d63.html
          0b2e3d4a9fce6033c27315c1506e1a28.html
          0b3368eb34da708c263183ff1314e1e5.html
          0ba48cfc547154448e9c53149d02ba85.html
          0bd4e8e7709356647d357de05db61d58.html
          0bf25460dca20f004b5c7e9765713ebb.html
          0bf4a6eae08b8881efe05b065e34faf9.html
          0c160ff8f76fbba9a4fa77033ab14dd0.html
          0c19835748910e666b4024ad2c4af1bb.html
          0c50e065455272d0f3e04945a6f664a5.html
          0c6eeccbfdd67aa968a241acce05e20d.html
          0c9e5ca62bc924e5da1379e801442e93.html
          0c9e640b81f484da7afde63d602d539c.html
          0ca567fad7b9d9a27305963eb49265f0.html
          0ca634ac151ac989621cda7dbad8bbb3.html
          0ce998f85652a8a9bcd417c92151f180.html
          0cfde902fa6cc188f0f08edf2bd3ef29.html
          0d01421788d1b29d79573983bfd4caaa.html
          0d14235e77e55ae4ee596bb1eb4c055e.html
          0d1b85060ff7cc969454ac1749edd700.html
          0d650a90204a1dd25dea24fce6f69ed2.html
          0da0ff49bfbd36a16396c2cd7a62b986.html
          0dabb2990f22100d81566f0109ad7389.html
          0e1a6b013283ca18f16dd031d52ab495.html
          0e395d236ae8d376218b062ce6691548.html
          0e49055b2ea91c18f9d50c145f6b0065.html
          0e9b3e70fbb779d118f3feb75efea17b.html
          0eae83fbc2e3eaaf8315f122a5692fa0.html
          0ef2cd6fed7cb2d0466028600e2ff1f2.html
          0f0975f4892715f4a25dd889110d21c2.html
          0f0d72eccee0ef091c4c447e410e0e74.html
          0f14d67760ca6deb4dae7b7d38dc1cd0.html
          0f43fabe86dd7f957b2715cf4ec5acff.html
          0f5cd430c28c59b81e7bdde42b5879a5.html
          0f6fcbea117c51a2843622edb82d45bc.html
          0f770dc4609b7edef4100bdf3c7da9cf.html
          0fb51df235772849702822ad6564bd14.html
          1007964c31ec39afd330c60257d2ddab.html
          104b47e35354ace97825be9e2e305a0f.html
          1083fbd39aa8abaa59ca84522db4c329.html
          109fa302e9f6af1e2bc26aa7a753cd1b.html
          10aceb25f1816142e1f6cd6f583ba60f.html
          10ae53552fd674a8c15ff88684f4f7e8.html
          10ae7246a744d30d9e4442c50682919f.html
          10b08a6d5cf01426a1d15a925ffa2abb.html
          10bb05ff02c44eb4cb7e56e656414409.html
          10ddb05d66e61da66fdd5294e32336db.html
          10e89b885b07c612d0c3e3ad4d3a5c9a.html
          1131ea23ab69d35d15d1c4b9cd8d7259.html
          1151c0a323c804e5dda7d1e6e2dcc5a6.html
          11e1d95f8dfd5e98db160728b2d14f64.html
          1204398e31612f8163e172c7c9d69506.html
          1275a65b66a51f6db9de16fe1df1dc04.html
          12931ba4dfb5230e6930a1d78b1cbfb1.html
          12948c9de9d05fb6f1a89c9a2c49f601.html
          12ca541a28ac30817b08abed5b789b53.html
          12cc48b9085aa2f3e8448f5d6c68d86d.html
          12f781340de55ea5c75d418ab74cf196.html
          12f8523c165ccc233919e066ea39ce59.html
          1339e1301b5e1a6500fc24d2ad8c21e3.html
          133d163d58905e9388b375e4e8a2a931.html
          133e0b7302027f743b0350eae86efc95.html
          136e9c05d710dc4dc71692abb7b4072c.html
          137ad1783cc7f455239915618dcfbbfb.html
          138fdc81880d347a9f7353f299ae298b.html
          13e66ee87e9a12a8405abdd0ae7086ef.html
          14413868c72d0d5dbb4895e5c67c4e3b.html
          14ed62b4bedb9fd3fecedd2603cd2749.html
          1527d9d2b8fd801e023b742b83749728.html
          153daf03c24c25715b2780ca36b33939.html
          1543ca7cf7ffe834417433376a78765d.html
          15616554d6102b01662c73fd5052306e.html
          159dc9839a25bd96de00acbd9b769206.html
          15b01c548fbf787215eefb723dd73d56.html
          15e9103b13f3a783fe6db5bf294e12f8.html
          15ead2572f98388553c1ba03a28e8322.html
          1605dfe3fc5d685694f94105b3e2fa6b.html
          160688b9cc340c7eadebfb391d74e16a.html
          1606fbf6550c23690a7eb89de46e8a5c.html
          160e96fe088fc50abe64342d07fdabe2.html
          162b4a208dbb050db14ab5a412ef284b.html
          1650213ee2ffc9a3cdbac2f940ce34a6.html
          165d33e6e148cdb9786c9a2c90658815.html
          1664443b916c6f148a8c3e41c44f66e4.html
          167558f3be82547e5d04c3d2a8e3fbe7.html
          17096c8b1c91b2c3f3f883dc58ee83af.html
          17123b7b6ae3e80ccdda788e3d5ec287.html
          1750eeac1450db235def25b8916a9123.html
          1760bffa8edf160a10b394c7ed51500b.html
          177bb964f1e06fd25015baf4b333d187.html
          17a1c4794ab2467de72b75901ea2f914.html
          17a6b3d24bf0cd5698d284f3b94d7960.html
          17c9968b2c0a8b79e942213dfe132b00.html
          181083f6a4f72266e539ae1ba17525e2.html
          181289e9fcc05cc1a54df37baff006a7.html
          191233b150b9f02c5b0df1f5314ac6b9.html
          19144b86a3e677ae82857e1785386520.html
          1959ecd67a9f11092cfa0fa76551477a.html
          199c687357538ffcceab91bf2f5a7a8f.html
          19aa5c7cf22d1481600dfdb3a9dd185c.html
          19b266d59e7c2645851867cd937c5d82.html
          19bb9755c13fe616fd937b0ef811861d.html
          19c4071974cfc930ad375a4e44bb346f.html
          19cbc6a831bb997a57d3bfb40ce9b7dc.html
          19d49b05aefad7ee088628a984dc71be.html
          19fafbea28e5d5f773d66b64b077ad83.html
          1a6ca6010dac571b1d1045bb8904a7b2.html
          1aa992524e3baab6fa31dc5a4882bd8f.html
          1acf021a7d5a4e4675e75acdcd9c8fb2.html
          1ad4e805c5d9fef62e91a7fe69ff62de.html
          1b3a9c5f5f5c0dff2ce442439628dc61.html
          1b502cde6ab7eb4f4b89b37b16693eb2.html
          1b575a3d3abb12c553bb74f558756cc2.html
          1b6d0c60cc234dc9cb28cd306d007836.html
          1b84dfb8675aed69043b948bea836c22.html
          1b9aae25d3c3c260af0db476bb7479b0.html
          1bf6f985687b00551aa7c41c540587ad.html
          1c0f1480a88315b39bf99fdb3005775b.html
          1c281349161d02cdbfcd992861b9fc7a.html
          1cd9ca0598c279cc254da8b0b8fc8162.html
          1cee35c9874a55c6ea83c2acd2609358.html
          1d5b7033ee49b0f9ac8bce3d1c3fcba5.html
          1d6f3f444c008ac7088cf8f0335a4add.html
          1d826af1ce33518d0b3c7f406ccb47e8.html
          1da40a6efac2b652728d1d5516dbc700.html
          1dc68e7f211b430d28209226b527206c.html
          1e0799e10f4b614cbc844718c41a9469.html
          1e303aaac065b7802550fb3f15cc8b64.html
          1e68d69de155e4c4815d3ce063a14511.html
          1e812b285a05e5766801ae3a9f9dceeb.html
          1ee8533b6d95a29aa1a8628010b11bfc.html
          1f134fe7a8d24985c2bb689805de76e8.html
          1f180d81f85db347214ae45f4d884838.html
          1f23f34eb1622957c41e488556b1e928.html
          1f33d932613ef4f73e8b271adaa67b88.html
          1f37ad81f15bfb1c7293f4a9367db409.html
          1f49afe6fa2be8730becbe074d550763.html
          1f4a843ab902e8801eb180f24de6d359.html
          1f4e4b7ee724f3a511217ded69b458c1.html
          1f63925b731195133e1da45ff0a9b32e.html
          1f6fa1dbd7ebaf633e35b49b9555bd33.html
          1fa8251942f80a51a2f4fdd5957661ee.html
          1fdec12e919d6e94c4996d066fb65247.html
          200b04a90076abbec97a2c32cdaf18ca.html
          200c5f070762855652e8a9fede4a8fe8.html
          209fae8aefd7aef250a6f5be0f302a96.html
          20acf3b2cfbaab28bb83d6cf4adb4c8a.html
          20b8567bdfffcad686eb964848dd5211.html
          2103768dc1ca580a1bfadaf61935883c.html
          210f221a2b7951e6b923a583e33fa859.html
          21366b6d26099eb84405c27adbed5a75.html
          213e00ea0ddd75982e7e19f614e908c5.html
          2159010c157ed648011788148e598a33.html
          21d85e78074831e8a2b85bd6dc54e6eb.html
          21dc1e872beff2210aa899f2d49a2ce2.html
          220e966f6f4bccb4695fddacc8d74269.html
          226fd91ed0bcb0a9ba367ea5ec0ac3ac.html
          229cdfe921fbf1768b0051820d62184e.html
          22db054d3e8770bdfe26e8b41f934b9b.html
          232cf306625a0263d58b34171fe362e9.html
          234d9448d77cdb4e4d4387ff2ac78284.html
          2362b73658985f8a4e4b8294cf346b57.html
          237a43ba868c6c920d8ce325368f2a1d.html
          23a0768f01ccbabf5487315fd4c555d5.html
          23a6a04d443f04f3187e63da508f7f2a.html
          23ac4f62fe4ed4ce76d7cf65bca3af25.html
          23c1aac26f47869ff00947595b1b3834.html
          23da6cb8091e23fa2793501ee3c6ef83.html
          2433890d6636fdbefd8a0a156e861811.html
          243c1b72a7ee5c112d9261244aa298e0.html
          245f11fc3d0d9a835a368c096c0a02b4.html
          2467f8029a96cc66874251878ca2a63c.html
          24725f22d7d4d3c8b9d839c178fcbccb.html
... 1600 more