chore: import upstream snapshot with attribution
Test Vector Database Adaptors / Test MCP Vector DB Tools (push) Has been cancelled
Tests / Code Quality (Ruff & Mypy) (push) Has been cancelled
Tests / Fast Unit Tests (parallel) (macos-latest, 3.11) (push) Has been cancelled
Tests / Fast Unit Tests (parallel) (macos-latest, 3.12) (push) Has been cancelled
Tests / Tests (push) Has been cancelled
Docker Publish / Build and Push Docker Images (map[description:Skill Seekers CLI - Convert documentation to AI skills dockerfile:Dockerfile name:skill-seekers]) (push) Has been cancelled
Docker Publish / Build and Push Docker Images (map[description:Skill Seekers MCP Server - 25 tools for AI assistants dockerfile:Dockerfile.mcp name:skill-seekers-mcp]) (push) Has been cancelled
Docker Publish / Test Docker Images (push) Has been cancelled
Tests / Fast Unit Tests (parallel) (ubuntu-latest, 3.10) (push) Has been cancelled
Tests / Fast Unit Tests (parallel) (ubuntu-latest, 3.11) (push) Has been cancelled
Tests / Fast Unit Tests (parallel) (ubuntu-latest, 3.12) (push) Has been cancelled
Tests / Serial / Integration / E2E Tests (push) Has been cancelled
Tests / MCP Server Tests (push) Has been cancelled
Test Vector Database Adaptors / Test chroma Adaptor (push) Has been cancelled
Test Vector Database Adaptors / Test faiss Adaptor (push) Has been cancelled
Test Vector Database Adaptors / Test qdrant Adaptor (push) Has been cancelled
Test Vector Database Adaptors / Test weaviate Adaptor (push) Has been cancelled

This commit is contained in:
wehub-resource-sync
2026-07-13 12:46:28 +08:00
commit 2cab53bc94
2985 changed files with 1288070 additions and 0 deletions
+339
View File
@@ -0,0 +1,339 @@
# Installation Guide
> **Skill Seekers v3.6.0**
Get Skill Seekers installed and running in under 5 minutes.
---
## System Requirements
| Requirement | Minimum | Recommended |
|-------------|---------|-------------|
| **Python** | 3.10 | 3.11 or 3.12 |
| **RAM** | 4 GB | 8 GB+ |
| **Disk** | 500 MB | 2 GB+ |
| **OS** | Linux, macOS, Windows (WSL) | Linux, macOS |
---
## Quick Install
### Option 1: pip (Recommended)
```bash
# Basic installation
pip install skill-seekers
# With all platform support
pip install skill-seekers[all-llms]
# Verify installation
skill-seekers --version
```
### Option 2: pipx (Isolated)
```bash
# Install pipx if not available
pip install pipx
pipx ensurepath
# Install skill-seekers
pipx install skill-seekers[all-llms]
```
### Option 3: Development (from source)
```bash
# Clone repository
git clone https://github.com/yusufkaraaslan/Skill_Seekers.git
cd Skill_Seekers
# Install in editable mode
pip install -e ".[all-llms,dev]"
# Verify
skill-seekers --version
```
---
## Installation Options
### Minimal Install
Just the core functionality:
```bash
pip install skill-seekers
```
**Includes:**
- Documentation scraping
- Basic packaging
- Local enhancement (Claude Code)
### Full Install
All features and platforms:
```bash
pip install skill-seekers[all-llms]
```
**Includes:**
- Claude AI support
- Google Gemini support
- OpenAI ChatGPT support
- MiniMax AI support
- All vector databases
- MCP server
- Cloud storage (S3, GCS, Azure)
### Custom Install
Install only what you need:
```bash
# Specific platform only
pip install skill-seekers[gemini] # Google Gemini
pip install skill-seekers[openai] # OpenAI
pip install skill-seekers[minimax] # MiniMax AI
pip install skill-seekers[chroma] # ChromaDB
# Multiple extras
pip install skill-seekers[gemini,openai,chroma]
# Development
pip install skill-seekers[dev]
```
---
## Available Extras
| Extra | Description | Install Command |
|-------|-------------|-----------------|
| `gemini` | Google Gemini support | `pip install skill-seekers[gemini]` |
| `openai` | OpenAI ChatGPT support | `pip install skill-seekers[openai]` |
| `minimax` | MiniMax AI support | `pip install skill-seekers[minimax]` |
| `mcp` | MCP server | `pip install skill-seekers[mcp]` |
| `chroma` | ChromaDB export | `pip install skill-seekers[chroma]` |
| `weaviate` | Weaviate export | `pip install skill-seekers[weaviate]` |
| `qdrant` | Qdrant export | `pip install skill-seekers[qdrant]` |
| `faiss` | FAISS export | `pip install skill-seekers[faiss]` |
| `s3` | AWS S3 storage | `pip install skill-seekers[s3]` |
| `gcs` | Google Cloud Storage | `pip install skill-seekers[gcs]` |
| `azure` | Azure Blob Storage | `pip install skill-seekers[azure]` |
| `embedding` | Embedding server | `pip install skill-seekers[embedding]` |
| `video` | YouTube/video transcript extraction | `pip install skill-seekers[video]` |
| `video-full` | + Whisper transcription, scene detection | `pip install skill-seekers[video-full]` |
| `jupyter` | Jupyter Notebook extraction | `pip install skill-seekers[jupyter]` |
| `asciidoc` | AsciiDoc document processing | `pip install skill-seekers[asciidoc]` |
| `pptx` | PowerPoint presentation extraction | `pip install skill-seekers[pptx]` |
| `rss` | RSS/Atom feed extraction | `pip install skill-seekers[rss]` |
| `confluence` | Confluence wiki extraction | `pip install skill-seekers[confluence]` |
| `notion` | Notion workspace extraction | `pip install skill-seekers[notion]` |
| `chat` | Slack/Discord export extraction | `pip install skill-seekers[chat]` |
| `all-llms` | All LLM platforms | `pip install skill-seekers[all-llms]` |
| `all` | Everything | `pip install skill-seekers[all]` |
| `dev` | Development tools | `pip install skill-seekers[dev]` |
> **Video visual deps:** After installing `skill-seekers[video-full]`, run `skill-seekers create --setup` to auto-detect your GPU (NVIDIA/AMD/CPU) and install the correct PyTorch variant + easyocr.
---
## Post-Installation Setup
### 1. Configure API Keys (Optional)
For AI enhancement and uploads:
```bash
# Interactive configuration wizard
skill-seekers config
# Or set environment variables
export ANTHROPIC_API_KEY=sk-ant-...
export GITHUB_TOKEN=ghp_...
```
### 2. Verify Installation
```bash
# Check version
skill-seekers --version
# See all commands
skill-seekers --help
# Test configuration
skill-seekers config --test
```
### 3. Quick Test
```bash
# List available presets
skill-seekers estimate --all
# Do a dry run
skill-seekers create https://docs.python.org/3/ --dry-run
```
---
## Platform-Specific Notes
### macOS
```bash
# Using Homebrew Python
brew install python@3.12
pip3.12 install skill-seekers[all-llms]
# Or with pyenv
pyenv install 3.12
pyenv global 3.12
pip install skill-seekers[all-llms]
```
### Linux (Ubuntu/Debian)
```bash
# Install Python and pip
sudo apt update
sudo apt install python3-pip python3-venv
# Install skill-seekers
pip3 install skill-seekers[all-llms]
# Make available system-wide
sudo ln -s ~/.local/bin/skill-seekers /usr/local/bin/
```
### Windows
**Recommended:** Use WSL2
```powershell
# Or use Windows directly (PowerShell)
python -m pip install skill-seekers[all-llms]
# Add to PATH if needed
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:APPDATA\Python\Python312\Scripts", "User")
```
### Docker
```bash
# Pull image
docker pull skillseekers/skill-seekers:latest
# Run
docker run -it --rm \
-e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
-v $(pwd)/output:/output \
skillseekers/skill-seekers \
skill-seekers create https://docs.react.dev/
```
---
## Troubleshooting
### "command not found: skill-seekers"
```bash
# Add pip bin to PATH
export PATH="$HOME/.local/bin:$PATH"
# Or reinstall with --user
pip install --user --force-reinstall skill-seekers
```
### Permission denied
```bash
# Don't use sudo with pip
# Instead:
pip install --user skill-seekers
# Or use a virtual environment
python3 -m venv venv
source venv/bin/activate
pip install skill-seekers[all-llms]
```
### Import errors
```bash
# For development installs, ensure editable mode
pip install -e .
# Check installation
python -c "import skill_seekers; print(skill_seekers.__version__)"
```
### Version conflicts
```bash
# Use virtual environment
python3 -m venv skill-seekers-env
source skill-seekers-env/bin/activate
pip install skill-seekers[all-llms]
```
---
## Upgrade
```bash
# Upgrade to latest
pip install --upgrade skill-seekers
# Upgrade with all extras
pip install --upgrade skill-seekers[all-llms]
# Check current version
skill-seekers --version
# See what's new
pip show skill-seekers
```
---
## Uninstall
```bash
pip uninstall skill-seekers
# Clean up config (optional)
rm -rf ~/.config/skill-seekers/
rm -rf ~/.cache/skill-seekers/
```
---
## Next Steps
- [Quick Start Guide](02-quick-start.md) - Create your first skill in 3 commands
- [Your First Skill](03-your-first-skill.md) - Complete walkthrough
---
## Getting Help
```bash
# Command help
skill-seekers --help
skill-seekers create --help
# Documentation
# https://github.com/yusufkaraaslan/Skill_Seekers/tree/main/docs
# Issues
# https://github.com/yusufkaraaslan/Skill_Seekers/issues
```
+383
View File
@@ -0,0 +1,383 @@
# Quick Start Guide
> **Skill Seekers v3.6.0**
> **Create your first skill in 3 commands**
---
## The 3 Commands
```bash
# 1. Install Skill Seekers
pip install skill-seekers
# 2. Create a skill from any source
skill-seekers create https://docs.django.com/
# 3. Package it for your AI platform
skill-seekers package output/django --target claude
```
**That's it!** You now have `output/django-claude.zip` ready to upload.
---
## What You Can Create From
The `create` command auto-detects your source:
| Source Type | Example Command |
|-------------|-----------------|
| **Documentation** | `skill-seekers create https://docs.react.dev/` |
| **GitHub Repo** | `skill-seekers create facebook/react` |
| **Local Code** | `skill-seekers create ./my-project` |
| **PDF File** | `skill-seekers create manual.pdf` |
| **Word Document** | `skill-seekers create report.docx` |
| **EPUB Book** | `skill-seekers create book.epub` |
| **Video** | `skill-seekers create https://youtube.com/watch?v=...` |
| **Jupyter Notebook** | `skill-seekers create analysis.ipynb` |
| **Local HTML (file)** | `skill-seekers create page.html` |
| **Local HTML (directory)** | `skill-seekers create ./mirror_output/site/` |
| **OpenAPI Spec** | `skill-seekers create api-spec.yaml` |
| **AsciiDoc** | `skill-seekers create guide.adoc` |
| **PowerPoint** | `skill-seekers create slides.pptx` |
| **RSS/Atom Feed** | `skill-seekers create feed.rss` |
| **Man Page** | `skill-seekers create grep.1` |
| **Confluence** | `skill-seekers create --space-key DEV` |
| **Notion** | `skill-seekers create --database-id abc123` |
| **Slack/Discord** | `skill-seekers create --chat-export-path slack-export/` |
| **Config File** | `skill-seekers create configs/custom.json` |
For an existing project where you don't know yet which frameworks you need skills for, use `skill-seekers scan <dir>` — it AI-detects the stack and emits one config per framework. See [Scan a project](05-scan-a-project.md).
---
## Examples by Source
### Documentation Website
```bash
# React documentation
skill-seekers create https://react.dev/
skill-seekers package output/react --target claude
# Django documentation
skill-seekers create https://docs.djangoproject.com/
skill-seekers package output/django --target claude
```
### GitHub Repository
```bash
# React source code
skill-seekers create facebook/react
skill-seekers package output/react --target claude
# Your own repo
skill-seekers create yourusername/yourrepo
skill-seekers package output/yourrepo --target claude
```
### Local Project
```bash
# Your codebase
skill-seekers create ./my-project
skill-seekers package output/my-project --target claude
# Specific directory
cd ~/projects/my-api
skill-seekers create .
skill-seekers package output/my-api --target claude
```
### PDF Document
```bash
# Technical manual
skill-seekers create manual.pdf --name product-docs
skill-seekers package output/product-docs --target claude
# Research paper
skill-seekers create paper.pdf --name research
skill-seekers package output/research --target claude
```
### Video
```bash
# YouTube video transcript
skill-seekers create https://www.youtube.com/watch?v=dQw4w9WgXcQ --name tutorial
skill-seekers package output/tutorial --target claude
```
### Jupyter Notebook
```bash
# Data science notebook
skill-seekers create analysis.ipynb --name ml-analysis
skill-seekers package output/ml-analysis --target claude
```
### PowerPoint / Word / EPUB
```bash
# PowerPoint slides
skill-seekers create presentation.pptx --name quarterly-review
# Word document
skill-seekers create spec.docx --name api-spec
# EPUB book
skill-seekers create rust-book.epub --name rust-guide
```
### Confluence / Notion / Slack
```bash
# Confluence wiki space
skill-seekers create --space-key DEV --name team-docs
# Notion workspace
skill-seekers create --database-id abc123 --name product-wiki
# Slack/Discord export
skill-seekers create --chat-export-path slack-export/ --name team-chat
```
---
## Common Options
### Specify a Name
```bash
skill-seekers create https://docs.example.com/ --name my-docs
```
### Add Description
```bash
skill-seekers create facebook/react --description "React source code analysis"
```
### Dry Run (Preview)
```bash
skill-seekers create https://docs.react.dev/ --dry-run
```
### Skip Enhancement (Faster)
```bash
skill-seekers create https://docs.react.dev/ --enhance-level 0
```
### Use a Preset
```bash
# Quick analysis (1-2 min)
skill-seekers create ./my-project --preset quick
# Comprehensive analysis (20-60 min)
skill-seekers create ./my-project --preset comprehensive
```
---
## Package for Different Platforms
### Claude AI (Default)
```bash
skill-seekers package output/my-skill/
# Creates: output/my-skill-claude.zip
```
### Google Gemini
```bash
skill-seekers package output/my-skill/ --target gemini
# Creates: output/my-skill-gemini.tar.gz
```
### OpenAI ChatGPT
```bash
skill-seekers package output/my-skill/ --target openai
# Creates: output/my-skill-openai.zip
```
### LangChain
```bash
skill-seekers package output/my-skill/ --target langchain
# Creates: output/my-skill-langchain/ directory
```
### Multiple Platforms
```bash
for platform in claude gemini openai; do
skill-seekers package output/my-skill/ --target $platform
done
```
---
## Upload to Platform
### Upload to Claude
```bash
export ANTHROPIC_API_KEY=sk-ant-...
skill-seekers upload output/my-skill-claude.zip --target claude
```
### Upload to Gemini
```bash
export GOOGLE_API_KEY=AIza...
skill-seekers upload output/my-skill-gemini.tar.gz --target gemini
```
### Auto-Upload After Package
```bash
export ANTHROPIC_API_KEY=sk-ant-...
skill-seekers package output/my-skill/ --target claude --upload
```
---
## Complete One-Command Workflow
Use `install` for everything in one step:
```bash
# Complete: scrape → enhance → package → upload
export ANTHROPIC_API_KEY=sk-ant-...
skill-seekers install --config react --target claude
# Skip upload
skill-seekers install --config react --target claude --no-upload
```
---
## Output Structure
After running `create`, you'll have:
```
output/
├── django/ # The skill
│ ├── SKILL.md # Main skill file
│ ├── references/ # Organized documentation
│ │ ├── index.md
│ │ ├── getting_started.md
│ │ └── api_reference.md
│ └── .skill-seekers/ # Metadata
└── django-claude.zip # Packaged skill (after package)
```
---
## Time Estimates
| Source Type | Size | Time |
|-------------|------|------|
| Small docs (< 50 pages) | ~10 MB | 2-5 min |
| Medium docs (50-200 pages) | ~50 MB | 10-20 min |
| Large docs (200-500 pages) | ~200 MB | 30-60 min |
| GitHub repo (< 1000 files) | varies | 5-15 min |
| Local project | varies | 2-10 min |
| PDF (< 100 pages) | ~5 MB | 1-3 min |
*Times include scraping + enhancement (level 2). Use `--enhance-level 0` to skip enhancement.*
---
## Quick Tips
### Test First with Dry Run
```bash
skill-seekers create https://docs.example.com/ --dry-run
```
### Use Presets for Faster Results
```bash
# Quick mode for testing
skill-seekers create https://docs.react.dev/ --preset quick
```
### Skip Enhancement for Speed
```bash
skill-seekers create https://docs.react.dev/ --enhance-level 0
skill-seekers enhance output/react/ # Enhance later
```
### Check Available Configs
```bash
skill-seekers estimate --all
```
### Resume Interrupted Jobs
```bash
skill-seekers resume --list
skill-seekers resume <job-id>
```
---
## Next Steps
- [Your First Skill](03-your-first-skill.md) - Complete walkthrough
- [Core Concepts](../user-guide/01-core-concepts.md) - Understand how it works
- [Scraping Guide](../user-guide/02-scraping.md) - All scraping options
---
## Troubleshooting
### "command not found"
```bash
# Add to PATH
export PATH="$HOME/.local/bin:$PATH"
```
### "No module named 'skill_seekers'"
```bash
# Reinstall
pip install --force-reinstall skill-seekers
```
### Scraping too slow
```bash
# Use async mode
skill-seekers create https://docs.react.dev/ --async --workers 5
```
### Out of memory
```bash
# Use streaming mode
skill-seekers package output/large-skill/ --streaming
```
---
## See Also
- [Installation Guide](01-installation.md) - Detailed installation
- [CLI Reference](../reference/CLI_REFERENCE.md) - All commands
- [Config Format](../reference/CONFIG_FORMAT.md) - Custom configurations
+396
View File
@@ -0,0 +1,396 @@
# Your First Skill - Complete Walkthrough
> **Skill Seekers v3.6.0**
> **Step-by-step guide to creating your first skill**
---
## What We'll Build
A skill from the **Django documentation** that you can use with Claude AI.
**Time required:** ~15-20 minutes
**Result:** A comprehensive Django skill with ~400 lines of structured documentation
---
## Prerequisites
```bash
# Ensure skill-seekers is installed
skill-seekers --version
# Should output: skill-seekers 3.6.0
```
---
## Step 1: Choose Your Source
For this walkthrough, we'll use Django documentation. You can use any of these:
```bash
# Option A: Django docs (what we'll use)
https://docs.djangoproject.com/
# Option B: React docs
https://react.dev/
# Option C: Your own project
./my-project
# Option D: GitHub repo
facebook/react
```
---
## Step 2: Preview with Dry Run
Before scraping, let's preview what will happen:
```bash
skill-seekers create https://docs.djangoproject.com/ --dry-run
```
**Expected output:**
```
🔍 Dry Run Preview
==================
Source: https://docs.djangoproject.com/
Type: Documentation website
Estimated pages: ~400
Estimated time: 15-20 minutes
Will create:
- output/django/
- output/django/SKILL.md
- output/django/references/
Configuration:
Rate limit: 0.5s
Max pages: 500
Enhancement: Level 2
✅ Preview complete. Run without --dry-run to execute.
```
This shows you exactly what will happen without actually scraping.
---
## Step 3: Create the Skill
Now let's actually create it:
```bash
skill-seekers create https://docs.djangoproject.com/ --name django
```
**What happens:**
1. **Detection** - Recognizes as documentation website
2. **Crawling** - Discovers pages starting from the base URL
3. **Scraping** - Downloads and extracts content (~5-10 min)
4. **Processing** - Organizes into categories
5. **Enhancement** - AI improves SKILL.md quality (~60 sec)
**Progress output:**
```
🚀 Creating skill: django
📍 Source: https://docs.djangoproject.com/
📋 Type: Documentation
⏳ Phase 1/5: Detecting source type...
✅ Detected: Documentation website
⏳ Phase 2/5: Discovering pages...
✅ Discovered: 387 pages
⏳ Phase 3/5: Scraping content...
Progress: [████████████████████░░░░░] 320/387 pages (83%)
Rate: 1.8 pages/sec | ETA: 37 seconds
⏳ Phase 4/5: Processing and categorizing...
✅ Categories: getting_started, models, views, templates, forms, admin, security
⏳ Phase 5/5: AI enhancement (Level 2)...
✅ SKILL.md enhanced: 423 lines
🎉 Skill created successfully!
Location: output/django/
SKILL.md: 423 lines
References: 7 categories, 42 files
⏱️ Total time: 12 minutes 34 seconds
```
---
## Step 4: Explore the Output
Let's see what was created:
```bash
ls -la output/django/
```
**Output:**
```
output/django/
├── .skill-seekers/ # Metadata
│ └── manifest.json
├── SKILL.md # Main skill file ⭐
├── references/ # Organized docs
│ ├── index.md
│ ├── getting_started.md
│ ├── models.md
│ ├── views.md
│ ├── templates.md
│ ├── forms.md
│ ├── admin.md
│ └── security.md
└── assets/ # Images (if any)
```
### View SKILL.md
```bash
head -50 output/django/SKILL.md
```
**You'll see:**
```markdown
# Django Skill
## Overview
Django is a high-level Python web framework that encourages rapid development
and clean, pragmatic design...
## Quick Reference
### Create a Project
```bash
django-admin startproject mysite
```
### Create an App
```bash
python manage.py startapp myapp
```
## Categories
- [Getting Started](#getting-started)
- [Models](#models)
- [Views](#views)
- [Templates](#templates)
- [Forms](#forms)
- [Admin](#admin)
- [Security](#security)
...
```
### Check References
```bash
ls output/django/references/
cat output/django/references/models.md | head -30
```
---
## Step 5: Package for Claude
Now package it for Claude AI:
```bash
skill-seekers package output/django/ --target claude
```
**Output:**
```
📦 Packaging skill: django
🎯 Target: Claude AI
✅ Validated: SKILL.md (423 lines)
✅ Packaged: output/django-claude.zip
📊 Size: 245 KB
Next steps:
1. Upload to Claude: skill-seekers upload output/django-claude.zip
2. Or manually: Use "Create Skill" in Claude Code
```
---
## Step 6: Upload to Claude
### Option A: Auto-Upload
```bash
export ANTHROPIC_API_KEY=sk-ant-...
skill-seekers upload output/django-claude.zip --target claude
```
### Option B: Manual Upload
1. Open [Claude Code](https://claude.ai/code) or Claude Desktop
2. Go to "Skills" or "Projects"
3. Click "Create Skill" or "Upload"
4. Select `output/django-claude.zip`
---
## Step 7: Use Your Skill
Once uploaded, you can ask Claude:
```
"How do I create a Django model with foreign keys?"
"Show me how to use class-based views"
"What's the best way to handle forms in Django?"
"Explain Django's ORM query optimization"
```
Claude will use your skill to provide accurate, contextual answers.
---
## Alternative: Skip Enhancement for Speed
If you want faster results (no AI enhancement):
```bash
# Create without enhancement
skill-seekers create https://docs.djangoproject.com/ --name django --enhance-level 0
# Package
skill-seekers package output/django/ --target claude
# Enhances later if needed
skill-seekers enhance output/django/
```
---
## Alternative: Use a Preset Config
Instead of auto-detection, use a preset:
```bash
# See available presets
skill-seekers estimate --all
# Use Django preset
skill-seekers create --config django
skill-seekers package output/django/ --target claude
```
---
## What You Learned
**Create** - `skill-seekers create <source>` auto-detects and scrapes
**Dry Run** - `--dry-run` previews without executing
**Enhancement** - AI automatically improves SKILL.md quality
**Package** - `skill-seekers package <dir> --target <platform>`
**Upload** - Direct upload or manual import
---
## Common Variations
### GitHub Repository
```bash
skill-seekers create facebook/react --name react
skill-seekers package output/react/ --target claude
```
### Local Project
```bash
cd ~/projects/my-api
skill-seekers create . --name my-api
skill-seekers package output/my-api/ --target claude
```
### PDF Document
```bash
skill-seekers create manual.pdf --name docs
skill-seekers package output/docs/ --target claude
```
### Multi-Platform
```bash
# Create once
skill-seekers create https://docs.djangoproject.com/ --name django
# Package for multiple platforms
skill-seekers package output/django/ --target claude
skill-seekers package output/django/ --target gemini
skill-seekers package output/django/ --target openai
# Upload to each
skill-seekers upload output/django-claude.zip --target claude
skill-seekers upload output/django-gemini.tar.gz --target gemini
```
---
## Troubleshooting
### Scraping Interrupted
```bash
# Resume from checkpoint
skill-seekers resume --list
skill-seekers resume <job-id>
```
### Too Many Pages
```bash
# Limit pages
skill-seekers create https://docs.djangoproject.com/ --max-pages 100
```
### Wrong Content Extracted
```bash
# Use custom config with selectors
cat > configs/django.json << 'EOF'
{
"name": "django",
"base_url": "https://docs.djangoproject.com/",
"selectors": {
"main_content": "#docs-content"
}
}
EOF
skill-seekers create --config configs/django.json
```
---
## Next Steps
- [Next Steps](04-next-steps.md) - Where to go from here
- [Core Concepts](../user-guide/01-core-concepts.md) - Understand the system
- [Scraping Guide](../user-guide/02-scraping.md) - Advanced scraping options
- [Enhancement Guide](../user-guide/03-enhancement.md) - AI enhancement deep dive
---
## Summary
| Step | Command | Time |
|------|---------|------|
| 1 | `skill-seekers create https://docs.djangoproject.com/` | ~15 min |
| 2 | `skill-seekers package output/django/ --target claude` | ~5 sec |
| 3 | `skill-seekers upload output/django-claude.zip` | ~10 sec |
**Total:** ~15 minutes to a production-ready AI skill! 🎉
+331
View File
@@ -0,0 +1,331 @@
# Next Steps
> **Skill Seekers v3.6.0**
> **Where to go after creating your first skill**
---
## You've Created Your First Skill! 🎉
Now what? Here's your roadmap to becoming a Skill Seekers power user.
---
## Immediate Next Steps
### 1. Try Different Sources
You've done documentation. Now try:
```bash
# GitHub repository
skill-seekers create facebook/react --name react
# Local project
skill-seekers create ./my-project --name my-project
# PDF document
skill-seekers create manual.pdf --name manual
```
### 2. Package for Multiple Platforms
Your skill works everywhere:
```bash
# Create once
skill-seekers create https://docs.djangoproject.com/ --name django
# Package for all platforms
for platform in claude gemini openai langchain; do
skill-seekers package output/django/ --target $platform
done
```
### 3. Scan an entire project (AI-driven)
Bootstrap a full knowledge base for a real project in one command — see
[Scan a project](05-scan-a-project.md):
```bash
skill-seekers scan ./my-react-app --out ./configs/scanned/
# Emits one config per detected framework + my-react-app-codebase.json
```
### 4. Explore Enhancement Workflows
```bash
# See available workflows
skill-seekers workflows list
# Apply security-focused analysis
skill-seekers create ./my-project --enhance-workflow security-focus
# Chain multiple workflows
skill-seekers create ./my-project \
--enhance-workflow security-focus \
--enhance-workflow api-documentation
```
---
## Learning Path
### Beginner (You Are Here)
✅ Created your first skill
⬜ Try different source types
⬜ Package for multiple platforms
⬜ Use preset configs
**Resources:**
- [Core Concepts](../user-guide/01-core-concepts.md)
- [Scraping Guide](../user-guide/02-scraping.md)
- [Packaging Guide](../user-guide/04-packaging.md)
### Intermediate
⬜ Custom configurations
⬜ Multi-source scraping
⬜ Enhancement workflows
⬜ Vector database export
⬜ MCP server setup
**Resources:**
- [Config Format](../reference/CONFIG_FORMAT.md)
- [Enhancement Guide](../user-guide/03-enhancement.md)
- [Advanced: Multi-Source](../advanced/multi-source.md)
- [Advanced: MCP Server](../advanced/mcp-server.md)
### Advanced
⬜ Custom workflow creation
⬜ Integration with CI/CD
⬜ API programmatic usage
⬜ Contributing to project
**Resources:**
- [Advanced: Custom Workflows](../advanced/custom-workflows.md)
- [MCP Reference](../reference/MCP_REFERENCE.md)
- [API Reference](../advanced/api-reference.md)
- [Contributing Guide](../../CONTRIBUTING.md)
---
## Common Use Cases
### Use Case 1: Team Documentation
**Goal:** Create skills for all your team's frameworks
```bash
# Create a script
for framework in django react vue fastapi; do
echo "Processing $framework..."
skill-seekers install --config $framework --target claude
done
```
### Use Case 2: GitHub Repository Analysis
**Goal:** Analyze your codebase for AI assistance
```bash
# Analyze your repo
skill-seekers create your-org/your-repo --preset comprehensive
# Install to Cursor for coding assistance
skill-seekers install-agent output/your-repo/ --agent cursor
```
### Use Case 3: RAG Pipeline
**Goal:** Feed documentation into vector database
```bash
# Create skill
skill-seekers create https://docs.djangoproject.com/ --name django
# Export to ChromaDB
skill-seekers package output/django/ --target chroma
# Or export directly
export_to_chroma(skill_directory="output/django/")
```
### Use Case 4: Documentation Monitoring
**Goal:** Keep skills up-to-date automatically
```bash
# Check for changes
skill-seekers update output/django/ --check-changes
# Update if changed
skill-seekers update output/django/
```
---
## By Interest Area
### For AI Skill Builders
Building skills for Claude, Gemini, or ChatGPT?
**Learn:**
- Enhancement workflows for better quality
- Multi-source combining for comprehensive skills
- Quality scoring before upload
**Commands:**
```bash
skill-seekers quality output/my-skill/ --report
skill-seekers create ./my-project --enhance-workflow architecture-comprehensive
```
### For RAG Engineers
Building retrieval-augmented generation systems?
**Learn:**
- Vector database exports (Chroma, Weaviate, Qdrant, FAISS)
- Chunking strategies
- Embedding integration
**Commands:**
```bash
skill-seekers package output/my-skill/ --target chroma
skill-seekers package output/my-skill/ --target weaviate
skill-seekers package output/my-skill/ --target langchain
```
### For AI Coding Assistant Users
Using Cursor, Windsurf, Cline, Roo, Aider, Bolt, Kilo, Continue, or Kimi Code?
**Learn:**
- Local codebase analysis
- Agent installation
- Pattern detection
**Commands:**
```bash
skill-seekers create ./my-project --preset comprehensive
skill-seekers install-agent output/my-project/ --agent cursor
```
### For DevOps/SRE
Automating documentation workflows?
**Learn:**
- CI/CD integration
- MCP server setup
- Config sources
**Commands:**
```bash
# Start MCP server
skill-seekers-mcp --transport http --port 8765
```
Config sources are managed through the MCP tools (`add_config_source`,
`list_config_sources`, `remove_config_source`) — ask your agent, e.g.
"Add my-org https://github.com/my-org/configs as a config source".
---
## Recommended Reading Order
### Quick Reference (5 minutes each)
1. [CLI Reference](../reference/CLI_REFERENCE.md) - All commands
2. [Config Format](../reference/CONFIG_FORMAT.md) - JSON specification
3. [Environment Variables](../reference/ENVIRONMENT_VARIABLES.md) - Settings
### User Guides (10-15 minutes each)
1. [Core Concepts](../user-guide/01-core-concepts.md) - How it works
2. [Scraping Guide](../user-guide/02-scraping.md) - Source options
3. [Enhancement Guide](../user-guide/03-enhancement.md) - AI options
4. [Workflows Guide](../user-guide/05-workflows.md) - Preset workflows
5. [Troubleshooting](../user-guide/06-troubleshooting.md) - Common issues
### Advanced Topics (20+ minutes each)
1. [Multi-Source Scraping](../advanced/multi-source.md)
2. [MCP Server Setup](../advanced/mcp-server.md)
3. [Custom Workflows](../advanced/custom-workflows.md)
4. [API Reference](../advanced/api-reference.md)
---
## Join the Community
### Get Help
- **GitHub Issues:** https://github.com/yusufkaraaslan/Skill_Seekers/issues
- **Discussions:** Share use cases and get advice
- **Discord:** [Link in README]
### Contribute
- **Bug reports:** Help improve the project
- **Feature requests:** Suggest new capabilities
- **Documentation:** Improve these docs
- **Code:** Submit PRs
See [Contributing Guide](../../CONTRIBUTING.md)
### Stay Updated
- **Watch** the GitHub repository
- **Star** the project
- **Follow** on Twitter: @_yUSyUS_
---
## Quick Command Reference
```bash
# Core workflow
skill-seekers create <source> # Create skill
skill-seekers package <dir> --target <p> # Package
skill-seekers upload <file> --target <p> # Upload
# Analysis
skill-seekers scan <dir> # Local codebase
skill-seekers create <owner/repo> # GitHub repo
skill-seekers create --pdf <file> # PDF
# Utilities
skill-seekers estimate <config> # Page estimation
skill-seekers quality <dir> # Quality check
skill-seekers resume # Resume job
skill-seekers workflows list # List workflows
# MCP server
skill-seekers-mcp # Start MCP server
```
---
## Remember
- **Start simple** - Use `create` with defaults
- **Dry run first** - Use `--dry-run` to preview
- **Iterate** - Enhance, package, test, repeat
- **Share** - Package for multiple platforms
- **Automate** - Use `install` for one-command workflows
---
## You're Ready!
Go build something amazing. The documentation is your oyster. 🦪
```bash
# Your next skill awaits
skill-seekers create <your-source-here>
```
+183
View File
@@ -0,0 +1,183 @@
# Scan an entire project (AI-driven)
`skill-seekers scan` is the fastest way to bootstrap a knowledge base for a
real codebase. Instead of running `create` once per framework, point `scan`
at a project directory and an AI agent figures out the tech stack for you.
## What it does
1. **Collects signals** from the project root with per-kind byte budgets
(24 KB manifests / 6 KB README / 6 KB CI / 28 KB source samples — total
64 KB capped so no single fat file crowds others out):
- **~50 manifest types**: `package.json`, `pyproject.toml`, `Pipfile`,
`environment.yml`, `Cargo.toml`, `go.mod`, `Gemfile`, `build.gradle`,
`pom.xml`, `composer.json`, `mix.exs`, `flake.nix`, `deno.json`,
`deps.edn`, `dune-project`, `BUILD.bazel`, `project.godot`, …
- README, Dockerfile, docker-compose, GitHub Actions, GitLab CI, Makefile
- First 2 KB of each sampled source file (across `src/`, `lib/`, `app/`,
`cmd/`, `crates/`, `packages/`, `apps/`, `services/`, `backend/`,
`frontend/`, plus root-level files for Django / flat-layout Python)
- The git remote URL
2. **AI detector** classifies the signals — returns the frameworks,
libraries, tools and services the project actually uses (with
versions, ecosystems, and confidence scores). Canonical-name resolver
handles CJK + European-language suffixes ("Godot 引擎" → `godot`,
"React フレームワーク" → `react`).
3. **Resolves each detection** in order:
- **Out-dir cache** — if `<out_dir>/<slug>.json` already exists from a
prior scan, reuse it (just re-stamps `metadata.detected_version`,
preserves any manual edits)
- **Local repo / user dir** — `./configs/<name>.json` then
`~/.config/skill-seekers/configs/<name>.json`
- **Community API** — `https://api.skillseekersweb.com/api/configs/<name>`
- **AI generation** — last resort, subject to `--max-ai-generations` cap
4. **AI-generates** a fresh config for unmapped detections (capped at
`--max-ai-generations` to prevent monorepo surprise bills), validated
against the unified schema and the registry name regex. With
`--probe-urls`, HEAD-checks the URLs and re-prompts on 4xx/5xx.
5. **Always emits `<project>-codebase.json`** — a `type: "local"` config
pointed at your project root, so you get a skill about *your* code
alongside the framework skills.
6. **Archives stale configs**: a framework that disappears from detections
is MOVED (not deleted — your hand edits are preserved) to
`out_dir/.archived/<UTC-timestamp>/`.
7. **Optional async publish** (opt-in): for each freshly AI-generated
config, you're asked whether to submit it back to the community
registry. Pre-checks `GITHUB_TOKEN`. Searches for existing open issues
first (idempotency — no duplicate submissions on re-runs). Retries
transient failures with backoff.
## Workflow
```bash
# Step 1 — scan
skill-seekers scan ./my-react-app --out ./configs/scanned/
# Step 2 — review what was emitted, edit if needed
ls ./configs/scanned/
# react.json
# typescript.json
# vite.json
# tailwind.json
# jest.json
# my-react-app-codebase.json
# Step 3 — build skills from the configs you actually want
skill-seekers create ./configs/scanned/react.json
skill-seekers create ./configs/scanned/my-react-app-codebase.json
```
## Re-scanning
Run `scan` again with the same `--out` and it diffs against the prior
results — reporting **added** packages, **version bumps**, and **removed**
packages. Removed configs are MOVED to `.archived/<UTC-timestamp>/`
(never deleted) so manual edits aren't lost. Use this in CI to keep
your skills aligned with the project's actual dependencies.
```bash
skill-seekers scan ./my-react-app --out ./configs/scanned/
# Diff vs previous scan:
# + added prisma
# ↻ updated react 18.2.0 → 18.3.1
# - removed moment
# 📦 Archived 1 stale config(s) → 2026-05-25T14-30-00Z/
```
The `.archived/` directory grows on each cleanup pass. Auto-prune
isn't applied — `rm -rf out_dir/.archived/` whenever you're confident
you don't need the old versions.
## Stale config cleanup (archive)
`out_dir/.archived/<UTC-timestamp>/` contains every config that
disappeared from detections during a re-scan. The move-not-delete
policy means a user-edited config never gets silently lost:
```bash
ls out_dir/.archived/
# 2026-05-25T14-30-00Z/ ← scan removed `moment`
# 2026-05-26T09-15-22Z/ ← scan removed `aws-sdk-v2`
```
To clean up: `rm -rf out_dir/.archived/`. Or keep them as a history
of which dependencies you've dropped.
## Cost control on monorepos
A project with 30 unmapped detections would trigger 30 AI generation
calls (up to 2 retries each, so 60 LLM hits). `--max-ai-generations`
caps this. The first N unmapped detections get AI-generated; the rest
are listed in the report as `unresolved` for you to inspect manually:
```bash
# Cap to 5 AI generations
skill-seekers scan ./my-monorepo --max-ai-generations 5
# Or preview cost first without firing any AI generation
skill-seekers scan ./my-monorepo --dry-run --verbose
# 🔍 DRY RUN — no files written, no AI generation invoked.
# Configs:
# ✅ 12 resolved (from local / user / API)
# 🤖 18 AI-generated (preview — would invoke AI)
# 📂 1 codebase config
```
## URL probing (catch AI hallucinations)
The AI sometimes invents plausible-looking but invalid `base_url`s for
niche libraries. `--probe-urls` HEAD-checks every URL in each generated
config; on 4xx/5xx, re-prompts the AI with feedback. If still unreachable
after the retry, stamps `metadata._url_unverified` so you see what to fix:
```bash
skill-seekers scan ./my-project --probe-urls
```
Adds 5-10 seconds per AI-generated config. Worth it on production scans.
## Flags
| Flag | Default | Purpose |
|---|---|---|
| `--out <dir>` | `./configs/scanned/` | Where to write emitted configs |
| `--no-fetch` | off | Skip the skillseekersweb.com API fallback during resolution |
| `--no-generate` | off | Skip AI generation for unmapped detections (offline / faster) |
| `--no-publish-prompt` | off | Suppress the interactive "Submit to community registry?" prompt (CI-friendly) |
| `--agent <name>` | `claude` (or `$SKILL_SEEKER_AGENT`) | LOCAL agent for non-API mode |
| `--min-confidence <0-1>` | `0.4` | Drop AI detections below this confidence |
| `--max-ai-generations <N>` | `10` | Cap AI generation count. Pass `0` to disable. Prevents surprise bills on monorepos. |
| `--dry-run` | off | Preview what scan would emit without writing or invoking AI |
| `--probe-urls` | off | HEAD-check AI-generated URLs; re-prompt on 4xx/5xx; stamp `_url_unverified` on confirmed-bad URLs |
| `--verbose`, `-v` | off | Show each detection with its evidence + INFO-level logging |
## When to use `scan` vs `create`
- **`scan <dir>`** — you have a project and want to know *what skills it
needs*. Bootstraps a directory of configs.
- **`create <source>`** — you already know what you want a skill *for*
(a URL, repo, PDF, or config). Builds one skill at a time.
`scan` produces configs; `create` consumes them. You'll typically run
`scan` once per project, then `create` on a handful of the emitted
configs.
## Privacy note
`scan` sends a bounded excerpt (~64 KB total) of your manifests, README,
CI configs, and **first 2 KB of each sampled source file** to the
configured AI agent. The whole-file sampling means actual source code
is in the prompt — small chunks, not full files, but it is your code.
If you don't want **any** AI call:
- `skill-seekers scan ./path --no-fetch --no-generate` — still calls the
AI **detector** to identify frameworks; only skips the network/AI
paths for individual config generation. Not fully local.
- `skill-seekers create ./path --enhance-level 0` — runs the local
codebase analysis layer (deterministic; no AI), and skips the
enhancement layer entirely. This is the fully-local flow.
The earlier docs implied `create ./path` was AI-free by default; it
isn't — the default enhancement level (2) sends content to the AI.
`--enhance-level 0` is the switch that keeps everything local.