Skip to content

GitHub Source Ingestion User Guide

Discover and import Claude artifacts directly from GitHub repositories. This guide walks you through adding GitHub sources, understanding scan results, and managing your artifact imports.

Table of Contents

Overview

What is GitHub Source Ingestion?

GitHub source ingestion lets you automatically discover Claude artifacts (skills, commands, agents, MCP servers, and hooks) from any GitHub repository. Instead of manually tracking artifacts across different repositories, SkillMeat scans your GitHub sources and catalogs them in one place.

All artifact types are fully indexed for search, allowing you to quickly find skills, commands, agents, hooks, and MCP servers across your entire catalog.

This is especially useful for: - Team repositories: Centrally manage all Claude artifacts your team creates - Public collections: Import artifacts from open-source projects - Monitoring upstream changes: Stay updated when repository maintainers release new versions - Building custom collections: Gather artifacts from multiple sources into one organized catalog

Why Use GitHub Source Ingestion?

Automation: Automatic artifact discovery means you don't need to manually add each artifact individually.

Version Tracking: Keep track of when artifacts were updated and manage versions directly from GitHub.

Quality Assessment: See confidence scores for detected artifacts, helping you verify detection accuracy.

Flexible Organization: Override automatic detection with custom paths if your repository has non-standard layouts.

Supported Artifact Types

The ingestion feature detects and indexes all artifact types for search: - Skills: Claude skills and domain-specific functionality - Commands: CLI-style commands and utilities - Agents: Complex multi-step agents and workflows - MCP Servers: Model Context Protocol servers for extended capabilities - Hooks: Lifecycle hooks and event handlers

All artifact types support both directory-based (e.g., skills/canvas/ with SKILL.md inside) and file-based (e.g., commands/doc-generate.md) patterns.

Getting Started

Prerequisites

  1. SkillMeat installed: Ensure you have SkillMeat running (CLI or web interface)
  2. SkillMeat account: Signed in and authenticated
  3. GitHub repository access:
  4. Public repositories: No authentication required
  5. Private repositories: GitHub Personal Access Token (PAT) recommended

Via Web Interface:

  1. Open SkillMeat web UI (http://localhost:3000)
  2. Click "Marketplace" in the sidebar
  3. Click the "Sources" tab (or navigate to /marketplace/sources)

Via CLI (Coming soon): 

skillmeat marketplace sources list
skillmeat marketplace sources add <repository-url>

You'll see either your existing GitHub sources or an empty state with an "Add Source" button.

Adding a GitHub Source

The add source process follows a 4-step wizard. You can complete it in just a few minutes.

Step 1: Enter Repository Information

When you click the "Add Source" button, a modal opens with Step 1.

Fill in the following fields:

GitHub Repository URL (required): - Enter the full URL: https://github.com/owner/repository - Example: https://github.com/anthropics/anthropic-cookbook - The URL must be a valid GitHub repository - You'll see a checkmark (✓) when the URL is valid

Branch/Tag/SHA (required): - Dropdown selector to choose which branch to scan - Default: main (the repository's default branch) - You can also specify: - Specific branches: develop, staging, etc. - Tags: Version tags like v1.0.0 - Commit SHAs: abc1234567def890

Root Directory Hint (optional): - Narrows the scan to a specific subdirectory - Useful for monorepos with artifacts in subdirectories - Example: /src/artifacts or /skills - Leave blank to scan the entire repository

Personal Access Token (optional but recommended): - Required for private repositories - Recommended for public repositories (higher rate limits) - How to create one: 1. Go to GitHub Settings → Developer settings → Personal access tokens 2. Click "Generate new token (classic)" 3. Select at least repo and read:org scopes 4. Copy and paste the token in the field - The token input masks the value with dots for security

Review the validation status: When all required fields are valid, the "Next" button becomes enabled.

Screenshot placeholder: [Screenshot: Add Source Modal - Step 1: Repository Information]

Step 2: Review Scan Preview

After clicking "Next," SkillMeat scans the repository. This can take 10-60 seconds depending on repository size.

During the scan: - Progress bar shows scan progress (0-100%) - Status displays "Scanning anthropics/quickstarts..." - All buttons are disabled until scanning completes

After the scan completes, you'll see:

Detected Artifacts Summary: - Total count: "Detected Artifacts (15 total)" - Breakdown by type: - Skills (12) - Commands (3) - Agents (0) - etc.

Confidence Indicators: - High confidence (>80%): Green checkmark (✓) - Medium confidence (50-80%): Yellow warning (⚠) - Low confidence (<50%): Gray question mark (?)

Collapsible Lists: - Each artifact type shows first 3 artifacts - Click "[Show All Artifacts]" to expand and see all detected items

Confidence Information Box: - Explains that low confidence artifacts may need verification - Suggests using Step 3 manual override if needed

Navigation Options: - [← Back] - Go back to edit repository information - [Skip] - Skip manual catalog (proceed with auto-detected artifacts) - [Continue →] - Proceed to optional manual catalog configuration

Screenshot placeholder: [Screenshot: Add Source Modal - Step 2: Scan Preview with Detected Artifacts]

Step 3: Manual Catalog Override (Optional)

This step is optional. Most users can skip this step and use automatic detection.

When to use this step: - Your repository has non-standard artifact locations - Confidence scores are too low for auto-detected artifacts - You want to add custom artifact paths not detected automatically - You want to explicitly control which detected paths to include

In this step, you can:

View detected paths by artifact type: - Tabs or dropdown to filter by: Skills, Commands, Agents, MCP, Hooks - For each type, see a list of detected artifact files/paths - Checkboxes allow you to include or exclude individual paths

Add custom paths: - "Add Custom Path" button lets you manually specify artifact locations - Input fields for artifact type and file path - Useful for: - Artifacts that weren't auto-detected - Non-standard repository structures - Specific files you want to treat as artifacts

Remove detected paths: - Click the "×" button next to any path to exclude it from the catalog

Confidence indicators: - Green (✓): High confidence auto-detected - Yellow (⚠): Medium confidence, review recommended - Custom entries: Show as added by you

Navigation Options: - [← Back] - Go back to scan preview - [Skip] - Skip manual catalog and use auto-detected artifacts - [Continue →] - Proceed to review step with your customizations

Screenshot placeholder: [Screenshot: Add Source Modal - Step 3: Manual Catalog Override]

Step 4: Review & Create

This final step shows a summary of what will be created.

Review section displays:

Repository Details: - Repository: anthropics/quickstarts - Branch: main - Root Directory: / (or your specified subdirectory) - Authentication: ✓ Token provided (if you added a PAT)

Artifacts to Catalog: - Skills: 12 artifacts - Commands: 3 artifacts - Agents: 0 artifacts - MCP Servers: 0 artifacts - Hooks: 0 artifacts - Total: 15 artifacts

Status: - "✓ Ready to create source" indicates all validations passed

Navigation Options: - [← Back] - Go back to review settings - [Create Source] - Create the GitHub source and begin cataloging

After clicking "Create Source": - Modal closes - Toast notification appears: "GitHub source created successfully" - You're returned to the marketplace sources list - Your new source appears in the list with status "scanning"

Screenshot placeholder: [Screenshot: Add Source Modal - Step 4: Review & Create]

Understanding Scan Results

After a source is created, SkillMeat displays artifacts with several status indicators.

Artifact Detection Confidence Scores

Each detected artifact has a confidence score (0-100%) showing how confident SkillMeat is that it correctly identified the artifact.

High Confidence (>80%): - Green checkmark (✓) - Clearly recognized artifact structure - Safe to import without review

Medium Confidence (50-80%): - Yellow warning (⚠) - Likely an artifact but some ambiguity - Review before importing recommended

Low Confidence (<50%): - Gray question mark (?) - May or may not be an artifact - Should review or use manual override

Why confidence varies: - Clear naming conventions increase confidence - Complete metadata increases confidence - Non-standard file paths lower confidence - Missing documentation lowers confidence

Status Meanings

Artifacts show one of four statuses:

New: - Green outline badge - Artifact detected in upstream but not yet in your collection - You haven't imported this artifact yet - Action: Click "Import" to add to collection

Updated: - Blue outline badge - Upstream version is newer than your collection version - Changes detected since last import - Action: Click "Import" to update to latest version

Imported: - Green solid badge with checkmark - Already in your collection - Status remains "imported" until upstream changes - Action: Click "Re-import" to import again (overwrites current version)

Removed: - Gray outline badge - Was in upstream previously but no longer exists - Detected in last scan but now gone - Action: Can be manually removed from catalog

Manual Catalog Override

When to Use Manual Override

Most repositories have clear artifact structures that auto-detection handles well. Use manual override when:

  1. Non-standard structure: Artifacts in unusual directory layouts
  2. Low confidence results: Too many artifacts scored below 50%
  3. Selective imports: Only want certain artifacts from a large repository
  4. Custom naming: Artifacts don't follow standard naming conventions

How to Specify Custom Paths

During source creation:

In Step 3 (Manual Catalog Override), specify paths:

  1. Select artifact type from dropdown: Skills, Commands, Agents, MCP Servers, or Hooks
  2. Enter the file path: /path/to/artifact.md or src/skills/my-skill/
  3. Click "+ Add Custom Path"
  4. Repeat for each custom path
  5. Proceed to Step 4

Example configurations:

Artifact Type: Skills
Custom Paths:
  - /src/skills/document-analysis.md
  - /src/skills/code-review.md
  - /features/data-processor/skill.md

Artifact Type: Commands
Custom Paths:
  - /cli-commands/git-helper.md
  - /tools/file-operations.md

After source creation:

You can edit paths by: 1. Going to the source detail page 2. Clicking the "Edit Catalog" button 3. Adding, removing, or modifying paths 4. Triggering a rescan to refresh results

Single Artifact Mode

What is Single Artifact Mode?

Some GitHub repositories ARE themselves an artifact rather than containing multiple artifacts. For example, a repository with a SKILL.md file at the root, where the entire repository represents a single skill. SkillMeat's automatic detection may not recognize these edge cases because it expects artifacts to be in subdirectories.

Single Artifact Mode lets you explicitly tell SkillMeat to treat the entire repository (or root directory hint) as one artifact of a specific type.

When to Use Single Artifact Mode

Use this mode when:

  1. Repository IS the artifact: The entire repo is a single skill, command, agent, etc.
  2. Artifact files at root level: SKILL.md, COMMAND.md, or similar files are at the repository root
  3. Non-standard structure: Detection heuristics don't recognize your artifact layout
  4. Quick manual import: You know exactly what type of artifact it is and want to skip detection

How to Enable Single Artifact Mode

When adding a new GitHub source:

  1. Click "Add Source" to open the wizard
  2. Enter your repository URL and other settings as normal
  3. In the Settings section, toggle "Treat as single artifact"
  4. When enabled, an Artifact Type dropdown appears
  5. Select the appropriate type: Skill, Command, Agent, MCP Server, or Hook
  6. Complete the wizard and create the source

What happens: - SkillMeat skips automatic artifact detection - Creates a single artifact entry for the entire repository (or root_hint directory if specified) - Sets the artifact confidence score to 100% (manual specification) - The artifact name is derived from the repository name (or the last path component of root_hint)

Example Use Cases

Example 1: Single skill repository 

Repository: https://github.com/user/my-awesome-skill
Structure:
├── SKILL.md
├── templates/
│   └── template.md
└── examples/
    └── example.md
Enable Single Artifact Mode and select "Skill" - the entire repo becomes one skill artifact.

Example 2: Root directory hint with single artifact 

Repository: https://github.com/user/monorepo
Root Hint: /tools/my-command
Structure:
└── tools/
    └── my-command/
        ├── COMMAND.md
        └── scripts/
Enable Single Artifact Mode with Root Hint /tools/my-command and select "Command" - only that subdirectory becomes the artifact.

Viewing Single Artifact Mode Status

Sources created with Single Artifact Mode show: - A single artifact in the catalog with 100% confidence - The artifact type you specified during creation - The source settings indicate single artifact mode is enabled

You can view and modify this setting by editing the source.

Importing Artifacts

Once you've reviewed the scan results and are satisfied with the artifact list, you can import them to your collection.

Selecting Artifacts to Import

Individual import: - Click "Import" button on any artifact card - Artifact status changes to "Imported" - Added to your collection

Bulk import: - Use checkboxes on artifact cards to select multiple - Click "Import Selected" button at bottom of page - All selected artifacts imported at once

Filter before importing: - Use the filter bar to narrow artifact list - Example: "Show only New artifacts" to import only new ones - Then bulk select and import

Conflict Resolution

If an artifact already exists in your collection, you'll see options for handling conflicts:

Merge (recommended): - Replaces your current version with upstream version - Use when you want to update to latest - Loses any local modifications

Fork: - Keeps both versions - Upstream artifact gets a new name (e.g., "skill-name-upstream") - Use when you have local modifications worth keeping

Skip: - Doesn't import - Keeps your current version unchanged - Use when you have a customized local version

Ask per conflict: - Prompts you for each conflicting artifact - Choose merge, fork, or skip on a case-by-case basis - Most thorough but slower

Verifying Import Success

After importing, verify the artifacts are in your collection:

  1. Go to Collections section
  2. Search for the imported artifact name
  3. Verify version and metadata match upstream
  4. Test the artifact if it's executable (skill, command, etc.)

Rescanning Sources

GitHub repositories change over time. Rescan your sources periodically to discover new artifacts or updates.

When to Rescan

Automatically: - SkillMeat rescans sources periodically (configurable interval) - Default: Once per 24 hours

Manually trigger a rescan: - On source card: Click "Rescan" button - On source detail page: Click "Rescan" button - Via CLI: skillmeat marketplace sources rescan <source-id>

What Happens During Rescan

  1. Scan initiated: Source status changes to "scanning"
  2. Repository scanned: Searches for artifacts again (all artifact types)
  3. Search index refreshed: Frontmatter and tags updated automatically for all artifacts
  4. Differences detected: Compares with previous results
  5. Results updated: Displays new/updated/removed counts

Interpreting Rescan Results

After rescan completes, view the diff showing:

New artifacts: Added since last scan - Status badge: "New" - Action: Can be imported

Updated artifacts: Existing artifacts changed upstream - Status badge: "Updated" - Action: Can be re-imported to get latest

Removed artifacts: No longer in upstream - Status badge: "Removed" - Action: Can be deleted from your catalog if desired

Unchanged artifacts: No changes since last scan - Status badge: "Imported" - Action: No action needed

Example rescan results: 

Rescan completed for anthropics/quickstarts
New artifacts: 3
Updated artifacts: 5
Removed artifacts: 0
Unchanged: 15

Exporting Sources

What is Export?

Export lets you save your marketplace GitHub sources to a portable YAML file. This is useful for:

  • Backing up your source configurations before making changes
  • Sharing source lists with team members or other SkillMeat instances
  • Migrating sources to a new SkillMeat installation
  • Version control by committing source configurations to a repository
  • Bulk management by editing the YAML file directly and re-importing

How to Export Sources

  1. Go to Marketplace → Sources
  2. Click the three-dot menu button (⋮) in the top-right corner
  3. Select "Export Sources" from the dropdown
  4. The Export Sources dialog opens with a list of all your sources
  5. Configure your export:
  6. Select sources: Use checkboxes to choose which sources to export
  7. Select all: Click "Select All" to export every source at once
  8. Optional fields: Toggle checkboxes to include additional metadata:
    • Tags & Trust Level: Include any tags you've assigned to sources
    • Settings: Include advanced settings like scan schedules and authentication details
  9. Click "Export"
  10. A file named skillmeat-sources-export-YYYY-MM-DD.yaml downloads to your computer

Export File Contents

The exported YAML file contains your sources in a standardized format:

schema_version: 1
exported_at: "2026-03-24T12:00:00.000Z"
source_count: 5
sources:
  - repo_url: "https://github.com/owner/repo"
    ref: "main"
    root_hint: "/"
    description: "My skill collection"
    # Optional fields (when included in export):
    tags: ["official", "verified"]
    trust_level: "verified"
    scan_schedule: "daily"
    auto_scan: true

Field Reference

Field Required Description
repo_url Yes GitHub repository URL (https://github.com/owner/repo)
ref Yes Branch, tag, or commit SHA to scan
root_hint Yes Root directory hint (use "/" to scan entire repo)
description No Human-readable description of the source
tags No Array of tags for organizing sources
trust_level No Trust level: "basic", "verified", or "official"
scan_schedule No Auto-scan interval: "hourly", "daily", "weekly", "manual"
auto_scan No Boolean: true to enable automatic rescans

Importing Sources

What is Import?

Import lets you add sources from an exported YAML file. This is useful for:

  • Restoring sources from a backup after reinstalling SkillMeat
  • Sharing source lists between team members
  • Bulk-adding sources from a curated list
  • Migrating to a new SkillMeat instance
  • Scripting source configuration in code

How to Import Sources

  1. Go to Marketplace → Sources
  2. Click the three-dot menu button (⋮) in the top-right corner
  3. Select "Import Sources" from the dropdown
  4. The Import Sources dialog opens
  5. Choose your source file:
  6. Drag and drop: Drag a .yaml or .yml file into the drop zone
  7. Browse: Click "Browse" to select a file from your computer
  8. The dialog validates the file and shows a preview of sources to be imported
  9. Review the import options:
  10. Skip duplicates: Automatically skip sources that already exist (matched by repository URL, case-insensitive)
  11. Create missing tags: Automatically create any tags referenced in the import file
  12. Click "Import"
  13. A summary shows how many sources were created and how many were skipped

Import Behavior

Duplicate handling: When importing sources, SkillMeat checks if each source already exists by comparing repository URLs (case-insensitive match). If a duplicate is found: - Source is skipped - No duplicate is created - You're shown the count of skipped sources in the summary

Tag creation: If the import file references tags that don't exist in your instance, they're automatically created so sources import with their assigned tags.

Discovery scans: After importing, SkillMeat automatically begins discovery scans for new sources: - Scans are staggered to avoid overloading your system - Each scan takes 10-60 seconds depending on repository size - Check the source cards for scan progress - Artifacts appear in the catalog as scanning completes

Import File Format

You can use exported YAML files or create your own. The file must match this structure:

schema_version: 1
exported_at: "2026-03-24T12:00:00.000Z"
source_count: 3
sources:
  - repo_url: "https://github.com/anthropics/cookbook"
    ref: "main"
    root_hint: "/"
    description: "Anthropic cookbook"

  - repo_url: "https://github.com/user/artifacts"
    ref: "develop"
    root_hint: "/skills"
    description: "Personal skill library"
    tags: ["personal", "experimental"]
    auto_scan: true

  - repo_url: "https://github.com/org/official-sources"
    ref: "v1.0.0"
    root_hint: "/"
    trust_level: "official"
    scan_schedule: "daily"

Notes: - schema_version must be 1 - sources is an array of source objects - Required fields: repo_url, ref, root_hint - Optional fields: description, tags, trust_level, scan_schedule, auto_scan - You can hand-edit this file before importing (useful for bulk updates)

Common Import Scenarios

Scenario 1: Restore from Backup

You have an export file from before you lost your sources:

  1. Click "Import Sources" in the Sources menu
  2. Select your backup export file
  3. All sources restored with their original settings
  4. Discovery scans begin automatically

Scenario 2: Share Team Sources

Your team has curated a list of approved sources:

  1. Team lead exports sources to team-sources.yaml
  2. Commits to shared repository
  3. Each team member imports team-sources.yaml
  4. Everyone has consistent source list
  5. Use "Skip duplicates" if some sources already exist locally

Scenario 3: Migrate to New Instance

Moving to a new SkillMeat installation:

  1. Export all sources from old instance
  2. Download the skillmeat-sources-export-*.yaml file
  3. Install and set up new SkillMeat instance
  4. In new instance, import the export file
  5. All sources with their configurations migrate over

Scenario 4: Bulk-Add from Template

You want to add many public sources at once:

schema_version: 1
exported_at: "2026-03-24T00:00:00.000Z"
source_count: 4
sources:
  - repo_url: "https://github.com/anthropics/cookbook"
    ref: "main"
    root_hint: "/"

  - repo_url: "https://github.com/anthropics/quickstarts"
    ref: "main"
    root_hint: "/"

  - repo_url: "https://github.com/user/skill-library"
    ref: "main"
    root_hint: "/skills"
    tags: ["community"]

  - repo_url: "https://github.com/org/internal-artifacts"
    ref: "develop"
    root_hint: "/"
    trust_level: "verified"

Create this file and import to add all sources at once.

Source Card Badges

Each source card displays three icon-only badges in the top-right corner indicating sync status, trust level, and search indexing state. Hover over any badge to see a tooltip with detailed information about that status.

Badge Types

Badge Icon States Tooltip Shows
Sync Status Clock/Checkmark/Warning Pending, Scanning, Synced, Error Status + last sync timestamp
Trust Level Shield/Star Untrusted, Basic, Verified, Official Trust level + description
Search Index Search icons Disabled, Pending, Active, Deep Search, Default Index status + last indexed timestamp

The badges are icon-only to keep source cards clean. Simply hover over a badge to see full details.

Search Indexing Badge States

Search indexing now covers all artifact types (skills, commands, agents, hooks, MCP servers). When a source is scanned or rescanned, SkillMeat automatically extracts frontmatter metadata from all artifact types and refreshes tags to ensure search results stay current.

  • Disabled (gray SearchX): Indexing explicitly disabled for this source
  • Pending (yellow Search): Indexing enabled but not yet run
  • Active (green SearchCheck): All artifact types indexed; hover shows last indexed time
  • Deep Search (purple Search+): Deep content indexing is active; includes full-text search of artifact contents
  • Default (muted Search): Using global indexing settings

Search Indexing Levels

SkillMeat offers two levels of search indexing, giving you control over the trade-off between search depth and resource usage:

What it indexes: - Artifact name (derived from file/directory path) - Title (from YAML frontmatter) - Description (from YAML frontmatter) - Tags (from YAML frontmatter)

Characteristics: - Lightweight (~850 bytes per artifact) - Fast indexing during scans - Covers most search use cases - Enabled by default when indexing is turned on

This level is sufficient for finding artifacts by name, purpose, or category. Most users should use only this level.

Deep Content Indexing (Advanced)

What it indexes: - Everything from metadata indexing, plus: - Full text content of artifact files (.md, .yaml, .json, .py, .ts, .js, .txt) - Code, documentation, and configuration within artifacts

Characteristics: - Higher storage requirements (varies by artifact size) - Longer indexing time during scans - Enables searching within artifact code and documentation - Disabled by default

When to use deep indexing: - You need to search for specific code patterns or function names - You want to find artifacts based on implementation details - Your workflow involves searching documentation content

How to enable: 1. When adding or editing a source, first enable "Metadata search indexing" 2. A second toggle appears: "Enable deep content indexing" (marked as Advanced) 3. Enable this toggle to index full file contents 4. Save and rescan the source

Note: Deep indexing only runs during batch extraction (sources with 3+ artifacts) and requires cloning the repository. Enable it selectively for sources where you need deeper search capabilities.

Search Results Ranking

When searching for artifacts in the marketplace, results are ranked by relevance based on where your search term was found. This ensures the most relevant matches appear first.

Ranking Priority

Search results are ordered by match location with the following priority:

Priority Field Description
1 (Highest) Title Matches in artifact titles rank highest
2 Description Matches in artifact descriptions
3 Tags Matches in search tags
4 Search Text Matches in concatenated metadata
5 (Lowest) Deep Content Matches in file contents (if deep indexing enabled)

How It Works

  • Title matches first: If you search for "canvas", artifacts with "canvas" in their title appear before those where "canvas" only appears in the description
  • Secondary sorting: When multiple artifacts have the same relevance score, they're sorted by detection confidence score (higher confidence first)
  • Deep matches last: Artifacts matched only through deep content indexing appear after metadata matches, helping you distinguish between artifacts "about" something vs. artifacts that merely "mention" it

Tips for Effective Searches

  • Be specific: Searching for "pdf-converter" will rank exact title matches higher than general mentions
  • Use tags: Tag-based filtering combined with search narrows results effectively
  • Check badges: Look for the "Deep Search" badge on result cards to see if a match came from file content rather than metadata

Example

Searching for "authentication": 1. First: "OAuth Authentication Skill" (title match) 2. Second: "API Gateway" with description "Handles authentication..." (description match) 3. Third: Artifacts tagged with "authentication" (tag match) 4. Last: Artifacts where "authentication" appears only in code comments (deep content match)

Status Chips Explained

Each artifact in the catalog displays a status chip (colored badge) indicating its current state.

Chip Types and Meanings

Status Appearance Meaning Action
New Green outline badge with sparkle icon Artifact detected in upstream, not yet in collection Click "Import"
Updated Blue outline badge with up arrow Upstream has newer version than your collection Click "Import" to update
Imported Green solid badge with checkmark Successfully imported to collection Click "Re-import" to update
Removed Gray outline badge with X icon No longer in upstream repository Delete if no longer needed

Visual Indicators

High Confidence (>80%): - Green checkmark (✓) - Safe to import without further review

Medium Confidence (50-80%): - Yellow triangle warning (⚠) - Review detection before importing

Low Confidence (<50%): - Gray question mark (?) - Verify manually or use custom catalog

Trust Levels

Sources also have trust level indicators:

Basic (Gray shield): - Default for new sources - No special verification performed - Use with normal precautions

Verified (Blue shield with checkmark): - Publisher verified by SkillMeat - Passed security scanning - Safe to import

Official (Purple star): - Official Anthropic source - Guaranteed safe and maintained - Highest level of trust

Troubleshooting & FAQ

"Why aren't my artifacts being detected?"

Possible causes and solutions:

  1. Low confidence scores:
  2. Artifacts may exist but with low confidence
  3. Check all artifacts including low-confidence ones

  4. Consider using manual catalog override

  5. Non-standard file paths:

  6. Repository uses custom directory structure
  7. Use manual catalog override to specify paths

  8. Example: skills in /features/skills/ instead of /skills/

  9. Wrong branch selected:

  10. Artifacts might be on different branch
  11. Try rescanning with different branch selected

  12. Common branches: main, develop, staging

  13. Repository doesn't contain artifacts:

  14. Not all repositories contain Claude artifacts
  15. Repository may be abandoned or migrated
  16. Try different repository if needed

Solution steps: 1. Check scan results for all artifacts (including low confidence) 2. Review file paths in manual catalog step 3. Try different branch or root directory 4. If still not found, check if repository format matches expected structure

"How do I add artifacts from a private repository?"

Steps:

  1. Create GitHub Personal Access Token:
  2. Go to https://github.com/settings/tokens
  3. Click "Generate new token (classic)"
  4. Select scopes: repo, read:org

  5. Copy the generated token (shown only once!)

  6. Add the private repository:

  7. In "Add Source" Step 1, enter repository URL
  8. Paste the PAT in "Personal Access Token" field

  9. Continue with normal add source flow

  10. SkillMeat securely stores the token:

  11. Token not saved in plaintext
  12. Only used for authenticated GitHub API calls
  13. Can be revoked anytime from GitHub settings

"Why is the scan taking so long?"

Expected scan times: - Small repository (< 50 files): 5-10 seconds - Medium repository (50-500 files): 10-30 seconds - Large repository (500+ files): 30-60 seconds

If scan is taking longer than expected:

  1. Check network connectivity: 

    ping github.com
# Should get responses

  2. Verify GitHub API access:

  3. If using PAT, verify token is valid

  4. Check GitHub status: https://www.githubstatus.com/

  5. Cancel and retry:

  6. Close the modal
  7. Try again after a few minutes

  8. Large repositories may need time on GitHub side

  9. Reduce repository scope:

  10. Use "Root Directory Hint" to scan only specific subdirectory
  11. Faster scan on subset of repository

"What if the scan fails or returns an error?"

Common error messages:

"Repository not found": - Check URL is valid: https://github.com/owner/repo - Verify repository is public or you have access - If private, ensure PAT is provided

"Invalid credentials": - PAT is invalid or revoked - Generate new PAT from GitHub settings - Paste new token in the field

"GitHub API rate limited": - Too many API calls in short time - Wait 1 hour and try again - Use PAT for higher rate limits (5000 vs 60 requests/hour)

"Scan timeout": - Repository too large or network slow - Try with root directory hint to scan subset - Check network connectivity - Try again later

To troubleshoot: 1. Note exact error message 2. Check network connectivity 3. Verify credentials (if private repo) 4. Try scanning different repository 5. Contact support if error persists

"I see artifacts marked 'Removed' - what should I do?"

Removed artifacts appear when they existed in a previous scan but no longer exist in the upstream repository.

Options:

  1. Keep in collection:
  2. No action needed
  3. You can still use the artifact locally

  4. It just won't update from upstream

  5. Delete from collection:

  6. Artifact no longer maintained upstream
  7. If you don't use it, delete to reduce clutter

  8. Can always re-import from backup if needed

  9. Check upstream for alternatives:

  10. Scan repository again for similar artifacts
  11. Maintainers might have renamed or moved it
  12. Check repository's changelog or readme

"How do I update artifacts after rescanning?"

After rescan, artifacts marked 'Updated' have newer versions available:

  1. Individual update:
  2. Click "Import" on artifact with "Updated" status
  3. Choose conflict strategy (usually "Merge" to update)

  4. Artifact updated to latest version

  5. Bulk update:

  6. Filter to show only "Updated" artifacts
  7. Select all with checkbox
  8. Click "Import Selected"
  9. Choose conflict strategy once

  10. All updated artifacts get latest version

  11. Selective update:

  12. Some artifacts you want updated, others not
  13. Select only the ones you want
  14. Import selected
  15. Others stay at previous versions

"Can I manage multiple GitHub sources?"

Yes! You can add as many sources as you need:

  • Add multiple repositories from different GitHub users
  • Manage team repositories, personal projects, open-source
  • Each source scanned independently
  • Artifacts from different sources kept separate in catalog

Best practices: - Use descriptive repository names to identify sources - Organize sources by team, project, or purpose - Set up rescans at different intervals if needed - Monitor trust levels for public sources

"What if I accidentally deleted a source?"

Deleted sources: - Remove all artifacts from that source in your catalog - Original repository on GitHub is unaffected - You can re-add the source anytime

To restore: 1. Go to Marketplace → Sources 2. Click "Add Source" 3. Enter the same repository URL 4. SkillMeat rescans and re-catalogs artifacts 5. You can re-import artifacts to collection

"How do I change authentication or root directory after creating a source?"

Edit source settings:

  1. Go to source detail page
  2. Click "Edit" button (pencil icon)
  3. Modify:
  4. Personal Access Token
  5. Root directory hint
  6. Branch/tag (though a rescan is recommended)
  7. Click "Save"
  8. SkillMeat may trigger automatic rescan with new settings

Or delete and recreate: - Delete source (artifacts remain in collection) - Add source again with new settings - Re-import any artifacts that need updating

"Private repository access stopped working"

If previously working private repo access fails:

  1. Check GitHub PAT is still valid:
  2. Go to https://github.com/settings/tokens
  3. Verify your PAT still exists

  4. Check it hasn't expired

  5. Update the PAT in source settings:

  6. Go to source detail page
  7. Click "Edit"
  8. Update the Personal Access Token field

  9. Click "Save"

  10. Generate new PAT if needed:

  11. Old one may be revoked or expired
  12. Generate new token with same scopes

  13. Update in source settings

  14. Verify repository access:

  15. Check you still have access to the repository
  16. User may have removed you from team or organization
  17. Check repository permissions on GitHub

"Rate limiting - what does this mean?"

GitHub has API rate limits:

Without authentication: - 60 requests per hour - Shared across all users on your IP - Limits apply quickly for large repos

With Personal Access Token: - 5000 requests per hour - Per token (individual account) - Much higher for typical use

What triggers rate limiting: - Large repository with many files - Multiple rapid scans - Shared network (office, VPN) with many users

Solutions: - Use Personal Access Token (highest priority) - Wait 1 hour for limit to reset - Scan smaller repositories first - Use root directory hint to limit scan scope

"Can I schedule automatic rescans?"

Automatic rescans: - SkillMeat rescans sources automatically (default: daily) - Can be configured in settings

To configure: 1. Go to Settings → Marketplace 2. Find "Auto-rescan sources" setting 3. Choose interval: every 1 hour, 6 hours, 12 hours, 24 hours, weekly 4. Save

To manually trigger: - Rescan button available on source cards anytime - Doesn't affect automatic schedule

See Also