Skill Seekers

CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

🎯 Project Overview

Skill Seekers is a Python tool that converts documentation websites, GitHub repositories, and PDFs into LLM skills. It supports 4 platforms: Claude AI, Google Gemini, OpenAI ChatGPT, and Generic Markdown.

Current Version: v2.9.0 Python Version: 3.10+ required Status: Production-ready, published on PyPI Website: https://skillseekersweb.com/ - Browse configs, share, and access documentation

⚡ Quick Command Reference (Most Used)

First time setup:

pip install -e .  # REQUIRED before running tests or CLI

Running tests (NEVER skip - user requirement):

pytest tests/ -v  # All tests
pytest tests/test_scraper_features.py -v  # Single file
pytest tests/ --cov=src/skill_seekers --cov-report=html  # With coverage

Code quality checks (matches CI):

ruff check src/ tests/  # Lint
ruff format src/ tests/  # Format
mypy src/skill_seekers  # Type check

Common workflows:

# Documentation scraping
skill-seekers scrape --config configs/react.json

# GitHub analysis
skill-seekers github --repo facebook/react

# Local codebase analysis
skill-seekers analyze --directory . --comprehensive

# Package for all platforms
skill-seekers package output/react/ --target claude
skill-seekers package output/react/ --target gemini

🏗️ Architecture

Core Design Pattern: Platform Adaptors

The codebase uses the Strategy Pattern with a factory method to support multiple LLM platforms:

src/skill_seekers/cli/adaptors/
├── __init__.py          # Factory: get_adaptor(target)
├── base_adaptor.py      # Abstract base class
├── claude_adaptor.py    # Claude AI (ZIP + YAML)
├── gemini_adaptor.py    # Google Gemini (tar.gz)
├── openai_adaptor.py    # OpenAI ChatGPT (ZIP + Vector Store)
└── markdown_adaptor.py  # Generic Markdown (ZIP)

Key Methods:

• package(skill_dir, output_path) - Platform-specific packaging
• upload(package_path, api_key) - Platform-specific upload
• enhance(skill_dir, mode) - AI enhancement with platform-specific models

Data Flow (5 Phases)

1. Scrape Phase (doc_scraper.py:scrape_all())

   • BFS traversal from base_url
   • Output: output/{name}_data/pages/*.json

2. Build Phase (doc_scraper.py:build_skill())

   • Load pages → Categorize → Extract patterns
   • Output: output/{name}/SKILL.md + references/*.md

3. Enhancement Phase (optional, enhance_skill_local.py)

   • LLM analyzes references → Rewrites SKILL.md
   • Platform-specific models (Sonnet 4, Gemini 2.0, GPT-4o)

4. Package Phase (package_skill.py → adaptor)

   • Platform adaptor packages in appropriate format
   • Output: .zip or .tar.gz

5. Upload Phase (optional, upload_skill.py → adaptor)

   • Upload via platform API

File Structure (src/ layout)

src/skill_seekers/
├── cli/                              # CLI tools
│   ├── main.py                       # Git-style CLI dispatcher
│   ├── doc_scraper.py                # Main scraper (~790 lines)
│   ├── github_scraper.py             # GitHub repo analysis
│   ├── pdf_scraper.py                # PDF extraction
│   ├── unified_scraper.py            # Multi-source scraping
│   ├── codebase_scraper.py           # Local codebase analysis (C2.x)
│   ├── unified_codebase_analyzer.py  # Three-stream GitHub+local analyzer
│   ├── enhance_skill_local.py        # AI enhancement (LOCAL mode)
│   ├── enhance_status.py             # Enhancement status monitoring
│   ├── package_skill.py              # Skill packager
│   ├── upload_skill.py               # Upload to platforms
│   ├── install_skill.py              # Complete workflow automation
│   ├── install_agent.py              # Install to AI agent directories
│   ├── pattern_recognizer.py         # C3.1 Design pattern detection
│   ├── test_example_extractor.py     # C3.2 Test example extraction
│   ├── how_to_guide_builder.py       # C3.3 How-to guide generation
│   ├── config_extractor.py           # C3.4 Configuration extraction
│   ├── generate_router.py            # C3.5 Router skill generation
│   ├── code_analyzer.py              # Multi-language code analysis
│   ├── api_reference_builder.py      # API documentation builder
│   ├── dependency_analyzer.py        # Dependency graph analysis
│   ├── signal_flow_analyzer.py       # C3.10 Signal flow analysis (Godot)
│   └── adaptors/                     # Platform adaptor architecture
│       ├── __init__.py
│       ├── base_adaptor.py
│       ├── claude_adaptor.py
│       ├── gemini_adaptor.py
│       ├── openai_adaptor.py
│       └── markdown_adaptor.py
└── mcp/                              # MCP server integration
    ├── server.py                     # FastMCP server (stdio + HTTP)
    └── tools/                        # 18 MCP tool implementations

🛠️ Development Commands

Setup

# Install in editable mode (required before tests due to src/ layout)
pip install -e .

# Install with all platform dependencies
pip install -e ".[all-llms]"

# Install specific platforms
pip install -e ".[gemini]"   # Google Gemini
pip install -e ".[openai]"   # OpenAI ChatGPT

Running Tests

CRITICAL: Never skip tests - User requires all tests to pass before commits.

# All tests (must run pip install -e . first!)
pytest tests/ -v

# Specific test file
pytest tests/test_scraper_features.py -v

# Multi-platform tests
pytest tests/test_install_multiplatform.py -v

# With coverage
pytest tests/ --cov=src/skill_seekers --cov-report=term --cov-report=html

# Single test
pytest tests/test_scraper_features.py::test_detect_language -v

# MCP server tests
pytest tests/test_mcp_fastmcp.py -v

Test Architecture:

• 46 test files covering all features
• CI Matrix: Ubuntu + macOS, Python 3.10-3.13
• 700+ tests passing
• Must run pip install -e . before tests (src/ layout requirement)

Building & Publishing

# Build package (using uv - recommended)
uv build

# Or using build
python -m build

# Publish to PyPI
uv publish

# Or using twine
python -m twine upload dist/*

Testing CLI Commands

# Test configuration wizard (NEW: v2.7.0)
skill-seekers config --show                          # Show current configuration
skill-seekers config --github                        # GitHub token setup
skill-seekers config --test                          # Test connections

# Test resume functionality (NEW: v2.7.0)
skill-seekers resume --list                          # List resumable jobs
skill-seekers resume --clean                         # Clean up old jobs

# Test GitHub scraping with profiles (NEW: v2.7.0)
skill-seekers github --repo facebook/react --profile personal    # Use specific profile
skill-seekers github --repo owner/repo --non-interactive         # CI/CD mode

# Test scraping (dry run)
skill-seekers scrape --config configs/react.json --dry-run

# Test codebase analysis (C2.x features)
skill-seekers analyze --directory . --output output/codebase/

# Test pattern detection (C3.1)
skill-seekers patterns --file src/skill_seekers/cli/code_analyzer.py

# Test how-to guide generation (C3.3)
skill-seekers how-to-guides output/test_examples.json --output output/guides/

# Test enhancement status monitoring
skill-seekers enhance-status output/react/ --watch

# Test multi-platform packaging
skill-seekers package output/react/ --target gemini --dry-run

# Test MCP server (stdio mode)
python -m skill_seekers.mcp.server_fastmcp

# Test MCP server (HTTP mode)
python -m skill_seekers.mcp.server_fastmcp --transport http --port 8765

🔧 Key Implementation Details

CLI Architecture (Git-style)

Entry point: src/skill_seekers/cli/main.py

The unified CLI modifies sys.argv and calls existing main() functions to maintain backward compatibility:

# Example: skill-seekers scrape --config react.json
# Transforms to: doc_scraper.main() with modified sys.argv

Subcommands: scrape, github, pdf, unified, codebase, enhance, enhance-status, package, upload, estimate, install, install-agent, patterns, how-to-guides

Recent Additions:

• codebase - Local codebase analysis without GitHub API (C2.x + C3.x features)
• enhance-status - Monitor background/daemon enhancement processes
• patterns - Detect design patterns in code (C3.1)
• how-to-guides - Generate educational guides from tests (C3.3)

Platform Adaptor Usage

from skill_seekers.cli.adaptors import get_adaptor

# Get platform-specific adaptor
adaptor = get_adaptor('gemini')  # or 'claude', 'openai', 'markdown'

# Package skill
adaptor.package(skill_dir='output/react/', output_path='output/')

# Upload to platform
adaptor.upload(
    package_path='output/react-gemini.tar.gz',
    api_key=os.getenv('GOOGLE_API_KEY')
)

# AI enhancement
adaptor.enhance(skill_dir='output/react/', mode='api')

C3.x Codebase Analysis Features

The project has comprehensive codebase analysis capabilities (C3.1-C3.8):

C3.1 Design Pattern Detection (pattern_recognizer.py):

• Detects 10 common patterns: Singleton, Factory, Observer, Strategy, Decorator, Builder, Adapter, Command, Template Method, Chain of Responsibility
• Supports 9 languages: Python, JavaScript, TypeScript, C++, C, C#, Go, Rust, Java
• Three detection levels: surface (fast), deep (balanced), full (thorough)
• 87% precision, 80% recall on real-world projects

C3.2 Test Example Extraction (test_example_extractor.py):

• Extracts real usage examples from test files
• Categories: instantiation, method_call, config, setup, workflow
• AST-based for Python, regex-based for 8 other languages
• Quality filtering with confidence scoring

C3.3 How-To Guide Generation (how_to_guide_builder.py):

• Transforms test workflows into educational guides
• 5 AI enhancements: step descriptions, troubleshooting, prerequisites, next steps, use cases
• Dual-mode AI: API (fast) or LOCAL (free with Claude Code Max)
• 4 grouping strategies: AI tutorial group, file path, test name, complexity

C3.4 Configuration Pattern Extraction (config_extractor.py):

• Extracts configuration patterns from codebases
• Identifies config files, env vars, CLI arguments
• AI enhancement for better organization

C3.5 Architectural Overview (generate_router.py):

• Generates comprehensive ARCHITECTURE.md files
• Router skill generation for large documentation
• Quality improvements: 6.5/10 → 8.5/10 (+31%)
• Integrates GitHub metadata, issues, labels

C3.6 AI Enhancement (Claude API integration):

• Enhances C3.1-C3.5 with AI-powered insights
• Pattern explanations and improvement suggestions
• Test example context and best practices
• Guide enhancement with troubleshooting and prerequisites

C3.7 Architectural Pattern Detection (architectural_pattern_detector.py):

• Detects 8 architectural patterns (MVC, MVVM, MVP, Repository, etc.)
• Framework detection (Django, Flask, Spring, React, Angular, etc.)
• Multi-file analysis with directory structure patterns
• Evidence-based detection with confidence scoring

C3.8 Standalone Codebase Scraper (codebase_scraper.py):

# Quick analysis (1-2 min, basic features only)
skill-seekers analyze --directory /path/to/repo --quick

# Comprehensive analysis (20-60 min, all features + AI)
skill-seekers analyze --directory . --comprehensive

# With AI enhancement (auto-detects API or LOCAL)
skill-seekers analyze --directory . --enhance

# Granular AI enhancement control (NEW)
skill-seekers analyze --directory . --enhance-level 1  # SKILL.md only
skill-seekers analyze --directory . --enhance-level 2  # + Architecture + Config + Docs
skill-seekers analyze --directory . --enhance-level 3  # Full enhancement (all features)

# Disable specific features
skill-seekers analyze --directory . --skip-patterns --skip-how-to-guides

• Generates 300+ line standalone SKILL.md files from codebases
• All C3.x features integrated (patterns, tests, guides, config, architecture, docs)
• Complete codebase analysis without documentation scraping
• NEW: Granular AI enhancement control with --enhance-level (0-3)

C3.9 Project Documentation Extraction (codebase_scraper.py):

• Extracts and categorizes all markdown files from the project
• Auto-detects categories: overview, architecture, guides, workflows, features, etc.
• Integrates documentation into SKILL.md with summaries
• AI enhancement (level 2+) adds topic extraction and cross-references
• Controlled by depth: surface=raw copy, deep=parse+summarize, full=AI-enhanced
• Default ON, use --skip-docs to disable

C3.10 Signal Flow Analysis for Godot Projects (signal_flow_analyzer.py):

• Complete signal flow analysis system for event-driven Godot architectures
• Signal declaration extraction (detects signal keyword declarations)
• Connection mapping (tracks .connect() calls with targets and methods)
• Emission tracking (finds .emit() and emit_signal() calls)
• Real-world metrics: 208 signals, 634 connections, 298 emissions in test project
• Signal density metrics (signals per file)
• Event chain detection (signals triggering other signals)
• Signal pattern detection:
  • EventBus Pattern (0.90 confidence): Centralized signal hub in autoload
  • Observer Pattern (0.85 confidence): Multi-observer signals (3+ listeners)
  • Event Chains (0.80 confidence): Cascading signal propagation
• Signal-based how-to guides (C3.10.1):
  • AI-generated step-by-step usage guides (Connect → Emit → Handle)
  • Real code examples from project
  • Common usage locations
  • Parameter documentation
• Outputs: signal_flow.json, signal_flow.mmd (Mermaid diagram), signal_reference.md, signal_how_to_guides.md
• Comprehensive Godot 4.x support:
  • GDScript (.gd), Scene files (.tscn), Resources (.tres), Shaders (.gdshader)
  • GDScript test extraction (GUT, gdUnit4, WAT frameworks)
  • 396 test cases extracted in test project
  • Framework detection (Unity, Unreal, Godot)

Key Architecture Decision (BREAKING in v2.5.2):

• Changed from opt-in (--build-*) to opt-out (--skip-*) flags
• All analysis features now ON by default for maximum value
• Backward compatibility warnings for deprecated flags

Smart Categorization Algorithm

Located in doc_scraper.py:smart_categorize():

• Scores pages against category keywords
• 3 points for URL match, 2 for title, 1 for content
• Threshold of 2+ for categorization
• Auto-infers categories from URL segments if none provided
• Falls back to "other" category

Language Detection

Located in doc_scraper.py:detect_language():

1. CSS class attributes (language-*, lang-*)
2. Heuristics (keywords like def, const, func)

Configuration File Structure

Configs (configs/*.json) define scraping behavior:

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

🧪 Testing Guidelines

Test Coverage Requirements

• Core features: 100% coverage required
• Platform adaptors: Each platform has dedicated tests
• MCP tools: All 18 tools must be tested
• Integration tests: End-to-end workflows

Test Markers (from pytest.ini_options)

The project uses pytest markers to categorize tests:

# Run only fast unit tests (default)
pytest tests/ -v

# Include slow tests (>5 seconds)
pytest tests/ -v -m slow

# Run integration tests (requires external services)
pytest tests/ -v -m integration

# Run end-to-end tests (resource-intensive, creates files)
pytest tests/ -v -m e2e

# Run tests requiring virtual environment setup
pytest tests/ -v -m venv

# Run bootstrap feature tests
pytest tests/ -v -m bootstrap

# Skip slow and integration tests (fastest)
pytest tests/ -v -m "not slow and not integration"

Test Execution Strategy

By default, only fast tests run. Use markers to control test execution:

# Default: Only fast tests (skip slow/integration/e2e)
pytest tests/ -v

# Include slow tests (>5 seconds)
pytest tests/ -v -m slow

# Include integration tests (requires external services)
pytest tests/ -v -m integration

# Include resource-intensive e2e tests (creates files)
pytest tests/ -v -m e2e

# Run ONLY fast tests (explicit)
pytest tests/ -v -m "not slow and not integration and not e2e"

# Run everything (CI does this)
pytest tests/ -v -m ""

When to use which:

• Local development: Default (fast tests only) - pytest tests/ -v
• Pre-commit: Fast tests - pytest tests/ -v
• Before PR: Include slow + integration - pytest tests/ -v -m "not e2e"
• CI validation: All tests run automatically

Key Test Files

• test_scraper_features.py - Core scraping functionality
• test_mcp_server.py - MCP integration (18 tools)
• test_mcp_fastmcp.py - FastMCP framework
• test_unified.py - Multi-source scraping
• test_github_scraper.py - GitHub analysis
• test_pdf_scraper.py - PDF extraction
• test_install_multiplatform.py - Multi-platform packaging
• test_integration.py - End-to-end workflows
• test_install_skill.py - One-command install
• test_install_agent.py - AI agent installation
• conftest.py - Test configuration (checks package installation)

🌐 Environment Variables

# Claude AI / Compatible APIs
# Option 1: Official Anthropic API (default)
export ANTHROPIC_API_KEY=sk-ant-...

# Option 2: GLM-4.7 Claude-compatible API (or any compatible endpoint)
export ANTHROPIC_API_KEY=your-api-key
export ANTHROPIC_BASE_URL=https://glm-4-7-endpoint.com/v1

# Google Gemini (optional)
export GOOGLE_API_KEY=AIza...

# OpenAI ChatGPT (optional)
export OPENAI_API_KEY=sk-...

# GitHub (for higher rate limits)
export GITHUB_TOKEN=ghp_...

# Private config repositories (optional)
export GITLAB_TOKEN=glpat-...
export GITEA_TOKEN=...
export BITBUCKET_TOKEN=...

All AI enhancement features respect these settings:

• enhance_skill.py - API mode SKILL.md enhancement
• ai_enhancer.py - C3.1/C3.2 pattern and test example enhancement
• guide_enhancer.py - C3.3 guide enhancement
• config_enhancer.py - C3.4 configuration enhancement
• adaptors/claude.py - Claude platform adaptor enhancement

Note: Setting ANTHROPIC_BASE_URL allows you to use any Claude-compatible API endpoint, such as GLM-4.7 (智谱 AI).

📦 Package Structure (pyproject.toml)

Entry Points

[project.scripts]
# Main unified CLI
skill-seekers = "skill_seekers.cli.main:main"

# Individual tool entry points
skill-seekers-config = "skill_seekers.cli.config_command:main"                # NEW: v2.7.0 Configuration wizard
skill-seekers-resume = "skill_seekers.cli.resume_command:main"                # NEW: v2.7.0 Resume interrupted jobs
skill-seekers-scrape = "skill_seekers.cli.doc_scraper:main"
skill-seekers-github = "skill_seekers.cli.github_scraper:main"
skill-seekers-pdf = "skill_seekers.cli.pdf_scraper:main"
skill-seekers-unified = "skill_seekers.cli.unified_scraper:main"
skill-seekers-codebase = "skill_seekers.cli.codebase_scraper:main"           # NEW: C2.x
skill-seekers-enhance = "skill_seekers.cli.enhance_skill_local:main"
skill-seekers-enhance-status = "skill_seekers.cli.enhance_status:main"       # NEW: Status monitoring
skill-seekers-package = "skill_seekers.cli.package_skill:main"
skill-seekers-upload = "skill_seekers.cli.upload_skill:main"
skill-seekers-estimate = "skill_seekers.cli.estimate_pages:main"
skill-seekers-install = "skill_seekers.cli.install_skill:main"
skill-seekers-install-agent = "skill_seekers.cli.install_agent:main"
skill-seekers-patterns = "skill_seekers.cli.pattern_recognizer:main"         # NEW: C3.1
skill-seekers-how-to-guides = "skill_seekers.cli.how_to_guide_builder:main" # NEW: C3.3

Optional Dependencies

[project.optional-dependencies]
gemini = ["google-generativeai>=0.8.0"]
openai = ["openai>=1.0.0"]
all-llms = ["google-generativeai>=0.8.0", "openai>=1.0.0"]

[dependency-groups]  # PEP 735 (replaces tool.uv.dev-dependencies)
dev = [
    "pytest>=8.4.2",
    "pytest-asyncio>=0.24.0",
    "pytest-cov>=7.0.0",
    "coverage>=7.11.0",
]

Note: Project uses PEP 735 dependency-groups instead of deprecated tool.uv.dev-dependencies.

🚨 Critical Development Notes

Must Run Before Tests

# REQUIRED: Install package before running tests
pip install -e .

# Why: src/ layout requires package installation
# Without this, imports will fail

Never Skip Tests

Per user instructions in ~/.claude/CLAUDE.md:

• "never skipp any test. always make sure all test pass"
• All 700+ tests must pass before commits
• Run full test suite: pytest tests/ -v

Platform-Specific Dependencies

Platform dependencies are optional:

# Install only what you need
pip install skill-seekers[gemini]  # Gemini support
pip install skill-seekers[openai]  # OpenAI support
pip install skill-seekers[all-llms]  # All platforms

AI Enhancement Modes

AI enhancement transforms basic skills (2-3/10) into production-ready skills (8-9/10). Two modes available:

API Mode (default if ANTHROPIC_API_KEY is set):

• Direct Claude API calls (fast, efficient)
• Cost: ~$0.15-$0.30 per skill
• Perfect for CI/CD automation
• Requires: export ANTHROPIC_API_KEY=sk-ant-...

LOCAL Mode (fallback if no API key):

• Uses Claude Code CLI (your existing Max plan)
• Free! No API charges
• 4 execution modes:
  • Headless (default): Foreground, waits for completion
  • Background (--background): Returns immediately
  • Daemon (--daemon): Fully detached with nohup
  • Terminal (--interactive-enhancement): Opens new terminal (macOS)
• Status monitoring: skill-seekers enhance-status output/react/ --watch
• Timeout configuration: --timeout 300 (seconds)

Force Mode (default ON since v2.5.2):

• Skip all confirmations automatically
• Perfect for CI/CD, batch processing
• Use --no-force to enable prompts if needed

# API mode (if ANTHROPIC_API_KEY is set)
skill-seekers enhance output/react/

# LOCAL mode (no API key needed)
skill-seekers enhance output/react/ --mode LOCAL

# Background with status monitoring
skill-seekers enhance output/react/ --background
skill-seekers enhance-status output/react/ --watch

# Force mode OFF (enable prompts)
skill-seekers enhance output/react/ --no-force

See docs/ENHANCEMENT_MODES.md for detailed documentation.

Git Workflow

• Main branch: main
• Current branch: development
• Always create feature branches from development
• Feature branch naming: feature/{task-id}-{description} or feature/{category}

CI/CD Pipeline

The project has GitHub Actions workflows in .github/workflows/:

tests.yml - Runs on every push and PR to main or development:

1. Lint Job (Python 3.12, Ubuntu):

   • ruff check src/ tests/ - Code linting with GitHub annotations
   • ruff format --check src/ tests/ - Format validation
   • mypy src/skill_seekers - Type checking (continue-on-error)

2. Test Job (Matrix):

   • OS: Ubuntu + macOS
   • Python: 3.10, 3.11, 3.12
   • Exclusions: macOS + Python 3.10 (speed optimization)
   • Steps:
     • Install dependencies + pip install -e .
     • Run CLI tests (scraper, config, integration)
     • Run MCP server tests
     • Generate coverage report → Upload to Codecov

3. Summary Job - Single status check for branch protection

   • Ensures both lint and test jobs succeed
   • Provides single "All Checks Complete" status

release.yml - Triggers on version tags (e.g., v2.9.0):

• Builds package with uv build
• Publishes to PyPI with uv publish
• Creates GitHub release

Local Pre-Commit Validation

Run the same checks as CI before pushing:

# 1. Code quality (matches lint job)
ruff check src/ tests/
ruff format --check src/ tests/
mypy src/skill_seekers

# 2. Tests (matches test job)
pip install -e .
pytest tests/ -v --cov=src/skill_seekers --cov-report=term

# 3. If all pass, you're good to push!
git push origin feature/my-feature

Branch Protection Rules:

• main: Requires tests + 1 review, only maintainers merge
• development: Requires tests to pass, default target for PRs

🚨 Common Pitfalls & Solutions

1. Import Errors

Problem: ModuleNotFoundError: No module named 'skill_seekers'

Solution: Must install package first due to src/ layout

pip install -e .

Why: The src/ layout prevents imports from repo root. Package must be installed.

2. Tests Fail with "No module named..."

Problem: Package not installed in test environment

Solution: CI runs pip install -e . before tests - do the same locally

pip install -e .
pytest tests/ -v

3. Platform-Specific Dependencies Not Found

Problem: ModuleNotFoundError: No module named 'google.generativeai'

Solution: Install platform-specific dependencies

pip install -e ".[gemini]"   # For Gemini
pip install -e ".[openai]"   # For OpenAI
pip install -e ".[all-llms]" # For all platforms

4. Git Branch Confusion

Problem: PR targets main instead of development

Solution: Always create PRs targeting development branch

git checkout development
git pull upstream development
git checkout -b feature/my-feature
# ... make changes ...
git push origin feature/my-feature
# Create PR: feature/my-feature → development

Important: See CONTRIBUTING.md for complete branch workflow.

5. Tests Pass Locally But Fail in CI

Problem: Different Python version or missing dependency

Solution: Test with multiple Python versions locally

# CI tests: Python 3.10, 3.11, 3.12 on Ubuntu + macOS
# Use pyenv or docker to test locally:
pyenv install 3.10.13 3.11.7 3.12.1

pyenv local 3.10.13
pip install -e . && pytest tests/ -v

pyenv local 3.11.7
pip install -e . && pytest tests/ -v

pyenv local 3.12.1
pip install -e . && pytest tests/ -v

6. Enhancement Not Working

Problem: AI enhancement fails or hangs

Solutions:

# 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 enhancement status for background jobs
skill-seekers enhance-status output/react/ --watch

7. Rate Limit Errors from GitHub

Problem: 403 Forbidden from GitHub API

Solutions:

# Check current rate limit
curl -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/rate_limit

# Configure multiple GitHub profiles (recommended)
skill-seekers config --github

# Use specific profile
skill-seekers github --repo owner/repo --profile work

# Test all configured tokens
skill-seekers config --test

🔌 MCP Integration

MCP Server (18 Tools)

Transport modes:

• stdio: Claude Code, VS Code + Cline
• HTTP: Cursor, Windsurf, IntelliJ IDEA

Core Tools (9):

1. list_configs - List preset configurations
2. generate_config - Generate config from docs URL
3. validate_config - Validate config structure
4. estimate_pages - Estimate page count
5. scrape_docs - Scrape documentation
6. package_skill - Package to .zip (supports --target)
7. upload_skill - Upload to platform (supports --target)
8. enhance_skill - AI enhancement with platform support
9. install_skill - Complete workflow automation

Extended Tools (9): 10. scrape_github - GitHub repository analysis 11. scrape_pdf - PDF extraction 12. unified_scrape - Multi-source scraping 13. merge_sources - Merge docs + code 14. detect_conflicts - Find discrepancies 15. split_config - Split large configs 16. generate_router - Generate router skills 17. add_config_source - Register git repos 18. fetch_config - Fetch configs from git

Starting MCP Server

# 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

📋 Common Workflows

Adding a New Platform

1. Create adaptor in src/skill_seekers/cli/adaptors/{platform}_adaptor.py
2. Inherit from BaseAdaptor
3. Implement package(), upload(), enhance() methods
4. Add to factory in adaptors/__init__.py
5. Add optional dependency to pyproject.toml
6. Add tests in tests/test_install_multiplatform.py

Adding a New Feature

1. Implement in appropriate CLI module
2. Add entry point to pyproject.toml if needed
3. Add tests in tests/test_{feature}.py
4. Run full test suite: pytest tests/ -v
5. Update CHANGELOG.md
6. Commit only when all tests pass

Debugging Common Issues

Import Errors:

# Always ensure package is installed first
pip install -e .

# Verify installation
python -c "import skill_seekers; print(skill_seekers.__version__)"

Rate Limit Issues:

# Check current GitHub rate limit status
curl -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/rate_limit

# Configure multiple GitHub profiles
skill-seekers config --github

# Test your tokens
skill-seekers config --test

Enhancement Not Working:

# Check if API key is set
echo $ANTHROPIC_API_KEY

# Try LOCAL mode instead (uses Claude Code Max)
skill-seekers enhance output/react/ --mode LOCAL

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

Test Failures:

# Run specific failing test with verbose output
pytest tests/test_file.py::test_name -vv

# Run with print statements visible
pytest tests/test_file.py -s

# Run with coverage to see what's not tested
pytest tests/test_file.py --cov=src/skill_seekers --cov-report=term-missing

# Run only unit tests (skip slow integration tests)
pytest tests/ -v -m "not slow and not integration"

Config Issues:

# Validate config structure
skill-seekers-validate configs/myconfig.json

# Show current configuration
skill-seekers config --show

# Estimate pages before scraping
skill-seekers estimate configs/myconfig.json

🎯 Where to Make Changes

This section helps you quickly locate the right files when implementing common changes.

Adding a New CLI Command

Files to modify:

1. Create command file: src/skill_seekers/cli/my_command.py

   def main():
       """Entry point for my-command."""
       # Implementation
   

2. Add entry point: pyproject.toml

   [project.scripts]
   skill-seekers-my-command = "skill_seekers.cli.my_command:main"
   

3. Update unified CLI: src/skill_seekers/cli/main.py

   • Add subcommand handler to dispatcher

4. Add tests: tests/test_my_command.py

   • Test main functionality
   • Test CLI argument parsing
   • Test error cases

5. Update docs: CHANGELOG.md + README.md (if user-facing)

Adding a New Platform Adaptor

Files to modify:

1. Create adaptor: src/skill_seekers/cli/adaptors/my_platform_adaptor.py

   from .base_adaptor import BaseAdaptor
   
   class MyPlatformAdaptor(BaseAdaptor):
       def package(self, skill_dir, output_path):
           # Platform-specific packaging
   
       def upload(self, package_path, api_key):
           # Platform-specific upload
   
       def enhance(self, skill_dir, mode):
           # Platform-specific AI enhancement
   

2. Register in factory: src/skill_seekers/cli/adaptors/__init__.py

   def get_adaptor(target):
       adaptors = {
           'claude': ClaudeAdaptor,
           'gemini': GeminiAdaptor,
           'openai': OpenAIAdaptor,
           'markdown': MarkdownAdaptor,
           'myplatform': MyPlatformAdaptor,  # ADD THIS
       }
   

3. Add optional dependency: pyproject.toml

   [project.optional-dependencies]
   myplatform = ["myplatform-sdk>=1.0.0"]
   

4. Add tests: tests/test_adaptors/test_my_platform_adaptor.py

5. Update README: Add to platform comparison table

Adding a New Config Preset

Files to modify:

1. Create config: configs/my_framework.json

   {
     "name": "my_framework",
     "base_url": "https://docs.myframework.com/",
     "selectors": {...},
     "categories": {...}
   }
   

2. Test locally:

   # Estimate first
   skill-seekers estimate configs/my_framework.json
   
   # Test scrape (small sample)
   skill-seekers scrape --config configs/my_framework.json --max-pages 50
   

3. Add to README: Update presets table in README.md

4. Submit to website: (Optional) Submit to SkillSeekersWeb.com

Modifying Core Scraping Logic

Key files by feature:

Always add tests when modifying core logic!

Adding MCP Tools

Files to modify:

1. Add tool function: src/skill_seekers/mcp/tools/{category}_tools.py

2. Register tool: src/skill_seekers/mcp/server.py

   @mcp.tool()
   def my_new_tool(param: str) -> str:
       """Tool description."""
       # Implementation
   

3. Add tests: tests/test_mcp_fastmcp.py

4. Update count: README.md (currently 18 tools)

📚 Key Code Locations

Documentation Scraper (src/skill_seekers/cli/doc_scraper.py):

• is_valid_url() - URL validation
• extract_content() - Content extraction
• detect_language() - Code language detection
• extract_patterns() - Pattern extraction
• smart_categorize() - Smart categorization
• infer_categories() - Category inference
• generate_quick_reference() - Quick reference generation
• create_enhanced_skill_md() - SKILL.md generation
• scrape_all() - Main scraping loop
• main() - Entry point

Codebase Analysis (src/skill_seekers/cli/):

• codebase_scraper.py - Main CLI for local codebase analysis
• code_analyzer.py - Multi-language AST parsing (9 languages)
• api_reference_builder.py - API documentation generation
• dependency_analyzer.py - NetworkX-based dependency graphs
• pattern_recognizer.py - C3.1 design pattern detection
• test_example_extractor.py - C3.2 test example extraction
• how_to_guide_builder.py - C3.3 guide generation
• config_extractor.py - C3.4 configuration extraction
• generate_router.py - C3.5 router skill generation
• signal_flow_analyzer.py - C3.10 signal flow analysis (Godot projects)
• unified_codebase_analyzer.py - Three-stream GitHub+local analyzer

AI Enhancement (src/skill_seekers/cli/):

• enhance_skill_local.py - LOCAL mode enhancement (4 execution modes)
• enhance_skill.py - API mode enhancement
• enhance_status.py - Status monitoring for background processes
• ai_enhancer.py - Shared AI enhancement logic
• guide_enhancer.py - C3.3 guide AI enhancement
• config_enhancer.py - C3.4 config AI enhancement

Platform Adaptors (src/skill_seekers/cli/adaptors/):

• __init__.py - Factory function
• base_adaptor.py - Abstract base class
• claude_adaptor.py - Claude AI implementation
• gemini_adaptor.py - Google Gemini implementation
• openai_adaptor.py - OpenAI ChatGPT implementation
• markdown_adaptor.py - Generic Markdown implementation

MCP Server (src/skill_seekers/mcp/):

• server.py - FastMCP-based server
• tools/ - 18 MCP tool implementations

Configuration & Rate Limit Management (NEW: v2.7.0 - src/skill_seekers/cli/):

• config_manager.py - Multi-token configuration system (~490 lines)
  • ConfigManager class - Singleton pattern for global config access
  • add_github_profile() - Add GitHub profile with token and strategy
  • get_github_token() - Smart fallback chain (CLI → Env → Config → Prompt)
  • get_next_profile() - Profile switching for rate limit handling
  • save_progress() / load_progress() - Job resumption support
  • cleanup_old_progress() - Auto-cleanup of old jobs (7 days default)
• config_command.py - Interactive configuration wizard (~400 lines)
  • main_menu() - 7-option main menu with navigation
  • github_token_menu() - GitHub profile management
  • add_github_profile() - Guided token setup with browser integration
  • api_keys_menu() - API key configuration for Claude/Gemini/OpenAI
  • test_connections() - Connection testing for tokens and API keys
• rate_limit_handler.py - Smart rate limit detection and handling (~450 lines)
  • RateLimitHandler class - Strategy pattern for rate limit handling
  • check_upfront() - Upfront rate limit check before starting
  • check_response() - Real-time detection from API responses
  • handle_rate_limit() - Execute strategy (prompt/wait/switch/fail)
  • try_switch_profile() - Automatic profile switching
  • wait_for_reset() - Countdown timer with live progress
  • show_countdown_timer() - Live terminal countdown display
• resume_command.py - Resume interrupted scraping jobs (~150 lines)
  • list_resumable_jobs() - Display all jobs with progress details
  • resume_job() - Resume from saved checkpoint
  • clean_old_jobs() - Cleanup old progress files

GitHub Integration (Modified for v2.7.0 - src/skill_seekers/cli/):

• github_fetcher.py - Integrated rate limit handler
  • Constructor now accepts interactive and profile_name parameters
  • fetch() - Added upfront rate limit check
  • All API calls check responses for rate limits
  • Raises RateLimitError when rate limit cannot be handled
• github_scraper.py - Added CLI flags
  • --non-interactive flag for CI/CD mode (fail fast)
  • --profile flag to select GitHub profile from config
  • Config supports interactive and github_profile keys

🎯 Project-Specific Best Practices

1. Always use platform adaptors - Never hardcode platform-specific logic
2. Test all platforms - Changes must work for all 4 platforms
3. Maintain backward compatibility - Legacy configs must still work
4. Document API changes - Update CHANGELOG.md for every release
5. Keep dependencies optional - Platform-specific deps are optional
6. Use src/ layout - Proper package structure with pip install -e .
7. Run tests before commits - Per user instructions, never skip tests

🐛 Debugging Tips

Enable Verbose Logging

# Set environment variable for debug output
export SKILL_SEEKERS_DEBUG=1
skill-seekers scrape --config configs/react.json

Test Single Function/Module

Run Python modules directly for debugging:

# Run modules with --help to see options
python -m skill_seekers.cli.doc_scraper --help
python -m skill

…(truncated)