opencode-skills-collection 3.1.12 → 3.1.13

package/bundled-skills/graphql-schema/SKILL.md

@@ -0,0 +1,309 @@
+---
+name: graphql-schema
+description: GraphQL queries, mutations, and code generation patterns. Use when creating GraphQL operations, working with Apollo Client, or generating types.
+risk: unknown
+source: https://github.com/ChrisWiles/claude-code-showcase/tree/main/.claude/skills/graphql-schema
+source_repo: ChrisWiles/claude-code-showcase
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/ChrisWiles/claude-code-showcase/blob/main/LICENSE
+---
+
+# GraphQL Schema Patterns
+## When to Use
+
+Use this skill when you need graphQL queries, mutations, and code generation patterns. Use when creating GraphQL operations, working with Apollo Client, or generating types.
+
+
+## Core Rules
+
+1. **NEVER inline `gql` literals** - Create `.gql` files
+2. **ALWAYS run codegen** after creating/modifying `.gql` files
+3. **ALWAYS add `onError` handler** to mutations
+4. **Use generated hooks** - Never write raw Apollo hooks
+
+## File Structure
+
+```
+src/
+├── components/
+│   └── ItemList/
+│       ├── ItemList.tsx
+│       ├── GetItems.gql           # Query definition
+│       └── GetItems.generated.ts  # Auto-generated (don't edit)
+└── graphql/
+    └── mutations/
+        └── CreateItem.gql         # Shared mutations
+```
+
+## Creating a Query
+
+### Step 1: Create .gql file
+
+```graphql
+# src/components/ItemList/GetItems.gql
+query GetItems($limit: Int, $offset: Int) {
+  items(limit: $limit, offset: $offset) {
+    id
+    name
+    description
+    createdAt
+  }
+}
+```
+
+### Step 2: Run codegen
+
+```bash
+npm run gql:typegen
+```
+
+### Step 3: Import and use generated hook
+
+```typescript
+import { useGetItemsQuery } from './GetItems.generated';
+
+const ItemList = () => {
+  const { data, loading, error, refetch } = useGetItemsQuery({
+    variables: { limit: 20, offset: 0 },
+  });
+
+  if (error) return <ErrorState error={error} onRetry={refetch} />;
+  if (loading && !data) return <LoadingSkeleton />;
+  if (!data?.items.length) return <EmptyState />;
+
+  return <List items={data.items} />;
+};
+```
+
+## Creating a Mutation
+
+### Step 1: Create .gql file
+
+```graphql
+# src/graphql/mutations/CreateItem.gql
+mutation CreateItem($input: CreateItemInput!) {
+  createItem(input: $input) {
+    id
+    name
+    description
+  }
+}
+```
+
+### Step 2: Run codegen
+
+```bash
+npm run gql:typegen
+```
+
+### Step 3: Use with REQUIRED error handling
+
+```typescript
+import { useCreateItemMutation } from 'graphql/mutations/CreateItem.generated';
+
+const CreateItemForm = () => {
+  const [createItem, { loading }] = useCreateItemMutation({
+    // Success handling
+    onCompleted: (data) => {
+      toast.success({ title: 'Item created' });
+      navigation.goBack();
+    },
+    // ERROR HANDLING IS REQUIRED
+    onError: (error) => {
+      console.error('createItem failed:', error);
+      toast.error({ title: 'Failed to create item' });
+    },
+    // Cache update
+    update: (cache, { data }) => {
+      if (data?.createItem) {
+        cache.modify({
+          fields: {
+            items: (existing = []) => [...existing, data.createItem],
+          },
+        });
+      }
+    },
+  });
+
+  return (
+    <Button
+      onPress={() => createItem({ variables: { input: formValues } })}
+      isDisabled={!isValid || loading}
+      isLoading={loading}
+    >
+      Create
+    </Button>
+  );
+};
+```
+
+## Mutation UI Requirements
+
+**CRITICAL: Every mutation trigger must:**
+
+1. **Be disabled during mutation** - Prevent double-clicks
+2. **Show loading state** - Visual feedback
+3. **Have onError handler** - User knows it failed
+4. **Show success feedback** - User knows it worked
+
+```typescript
+// CORRECT - Complete mutation pattern
+const [submit, { loading }] = useSubmitMutation({
+  onError: (error) => {
+    console.error('submit failed:', error);
+    toast.error({ title: 'Save failed' });
+  },
+  onCompleted: () => {
+    toast.success({ title: 'Saved' });
+  },
+});
+
+<Button
+  onPress={handleSubmit}
+  isDisabled={!isValid || loading}
+  isLoading={loading}
+>
+  Submit
+</Button>
+```
+
+## Query Options
+
+### Fetch Policies
+
+| Policy | Use When |
+|--------|----------|
+| `cache-first` | Data rarely changes |
+| `cache-and-network` | Want fast + fresh (default) |
+| `network-only` | Always need latest |
+| `no-cache` | Never cache (rare) |
+
+### Common Options
+
+```typescript
+useGetItemsQuery({
+  variables: { id: itemId },
+
+  // Fetch strategy
+  fetchPolicy: 'cache-and-network',
+
+  // Re-render on network status changes
+  notifyOnNetworkStatusChange: true,
+
+  // Skip if condition not met
+  skip: !itemId,
+
+  // Poll for updates
+  pollInterval: 30000,
+});
+```
+
+## Optimistic Updates
+
+For instant UI feedback:
+
+```typescript
+const [toggleFavorite] = useToggleFavoriteMutation({
+  optimisticResponse: {
+    toggleFavorite: {
+      __typename: 'Item',
+      id: itemId,
+      isFavorite: !currentState,
+    },
+  },
+  onError: (error) => {
+    // Rollback happens automatically
+    console.error('toggleFavorite failed:', error);
+    toast.error({ title: 'Failed to update' });
+  },
+});
+```
+
+### When NOT to Use Optimistic Updates
+
+- Operations that can fail validation
+- Operations with server-generated values
+- Destructive operations (delete)
+- Operations affecting other users
+
+## Fragments
+
+For reusable field selections:
+
+```graphql
+# src/graphql/fragments/ItemFields.gql
+fragment ItemFields on Item {
+  id
+  name
+  description
+  createdAt
+  updatedAt
+}
+```
+
+Use in queries:
+
+```graphql
+query GetItems {
+  items {
+    ...ItemFields
+  }
+}
+```
+
+## Anti-Patterns
+
+```typescript
+// WRONG - Inline gql
+const GET_ITEMS = gql`
+  query GetItems { items { id } }
+`;
+
+// CORRECT - Use .gql file + generated hook
+import { useGetItemsQuery } from './GetItems.generated';
+
+
+// WRONG - No error handler
+const [mutate] = useMutation(MUTATION);
+
+// CORRECT - Always handle errors
+const [mutate] = useMutation(MUTATION, {
+  onError: (error) => {
+    console.error('mutation failed:', error);
+    toast.error({ title: 'Operation failed' });
+  },
+});
+
+
+// WRONG - Button not disabled during mutation
+<Button onPress={submit}>Submit</Button>
+
+// CORRECT - Disabled and loading
+<Button onPress={submit} isDisabled={loading} isLoading={loading}>
+  Submit
+</Button>
+```
+
+## Codegen Commands
+
+```bash
+# Generate types from .gql files
+npm run gql:typegen
+
+# Download schema + generate types
+npm run sync-types
+```
+
+## Integration with Other Skills
+
+- **react-ui-patterns**: Loading/error/empty states for queries
+- **testing-patterns**: Mock generated hooks in tests
+- **formik-patterns**: Mutation submission patterns
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream source and local project context.
+- Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
+- Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/hf-mcp/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: hf-mcp
+description: Use Hugging Face Hub via MCP server tools. Search models, datasets, Spaces, papers. Get repo details, fetch documentation, run compute jobs, and use Gradio Spaces as AI tools. Available when connected to the HF MCP server.
+risk: unknown
+source: https://github.com/huggingface/skills/tree/main/hf-mcp/skills/hf-mcp
+source_repo: huggingface/skills
+source_type: official
+date_added: 2026-07-01
+license: Apache-2.0
+license_source: https://github.com/huggingface/skills/blob/main/LICENSE
+---
+
+# Hugging Face MCP Server
+## When to Use
+
+Use this skill when you need use Hugging Face Hub via MCP server tools. Search models, datasets, Spaces, papers. Get repo details, fetch documentation, run compute jobs, and use Gradio Spaces as AI tools. Available when connected to the HF MCP server.
+
+
+Connect AI assistants to the Hugging Face Hub. Setup: https://huggingface.co/settings/mcp
+
+## Use Cases & Examples
+
+### Find the Best Model for a Task
+
+```
+User: "Find the best model for code generation"
+
+1. model_search(task="text-generation", query="code", sort="trendingScore", limit=10)
+2. hub_repo_details(repo_ids=["top-result-id"], include_readme=true)
+```
+
+### Compare Models from Different Providers
+
+```
+User: "Compare Llama vs Qwen for text generation"
+
+1. model_search(author="meta-llama", task="text-generation", sort="downloads", limit=5)
+2. model_search(author="Qwen", task="text-generation", sort="downloads", limit=5)
+3. hub_repo_details(repo_ids=["meta-llama/Llama-3.2-1B", "Qwen/Qwen3-8B"], include_readme=true)
+```
+
+### Find Training Datasets
+
+```
+User: "Find datasets for sentiment analysis in English"
+
+1. dataset_search(query="sentiment", tags=["language:en", "task_categories:text-classification"], sort="downloads")
+2. hub_repo_details(repo_ids=["top-dataset-id"], repo_type="dataset", include_readme=true)
+```
+
+### Discover AI Tools (MCP Spaces)
+
+```
+User: "Find a tool that can remove image backgrounds"
+
+1. space_search(query="background removal", mcp=true)
+2. dynamic_space(operation="view_parameters", space_name="result-space-id")
+3. dynamic_space(operation="invoke", space_name="result-space-id", parameters="{...}")
+```
+
+### Generate Images
+
+```
+User: "Create an image of a robot reading a book"
+
+1. dynamic_space(operation="discover")  # See available tasks
+2. gr1_flux1_schnell_infer(prompt="a robot sitting in a library reading a book, warm lighting, detailed")
+```
+
+### Research a Topic
+
+```
+User: "What are the latest papers on RLHF?"
+
+1. paper_search(query="reinforcement learning from human feedback", results_limit=10)
+2. hub_repo_details(repo_ids=["paper-linked-model"], include_readme=true)  # If paper links to models
+```
+
+### Learn How to Use a Library
+
+```
+User: "How do I fine-tune with LoRA using PEFT?"
+
+1. hf_doc_search(query="LoRA fine-tuning", product="peft")
+2. hf_doc_fetch(doc_url="https://huggingface.co/docs/peft/...")
+```
+
+### Run a Quick GPU Job
+
+```
+User: "Run this Python script on a GPU"
+
+hf_jobs(operation="uv", args={
+  "script": "# /// script\n# dependencies = [\"torch\"]\n# ///\nimport torch\nprint(torch.cuda.is_available())",
+  "flavor": "t4-small"
+})
+```
+
+### Train a Model on Cloud GPU
+
+```
+User: "Run my training script on an A10G"
+
+hf_jobs(operation="run", args={
+  "image": "pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime",
+  "command": ["/bin/sh", "-lc", "pip install transformers trl && python train.py"],
+  "flavor": "a10g-small",
+  "secrets": {"HF_TOKEN": "$HF_TOKEN"}
+})
+```
+
+### Check Job Status
+
+```
+User: "What's happening with my training job?"
+
+1. hf_jobs(operation="ps")
+2. hf_jobs(operation="logs", args={"job_id": "job-xxxxx"})
+```
+
+### Explore What's Trending
+
+```
+User: "What models are trending right now?"
+
+model_search(sort="trendingScore", limit=20)
+```
+
+### Get Model Card Details
+
+```
+User: "Tell me about Mistral-7B"
+
+hub_repo_details(repo_ids=["mistralai/Mistral-7B-v0.1"], include_readme=true)
+```
+
+### Find Quantized Models
+
+```
+User: "Find GGUF versions of Llama 3"
+
+model_search(query="Llama 3 GGUF", sort="downloads", limit=10)
+```
+
+### Use a Gradio Space as a Tool
+
+```
+User: "Transcribe this audio file"
+
+1. space_search(query="speech to text transcription", mcp=true)
+2. dynamic_space(operation="view_parameters", space_name="openai/whisper")
+3. dynamic_space(operation="invoke", space_name="openai/whisper", parameters="{\"audio\": \"...\"}")
+```
+
+### Schedule Recurring Jobs
+
+```
+User: "Run this data sync every day at midnight"
+
+hf_jobs(operation="scheduled uv", args={
+  "script": "...",
+  "cron": "0 0 * * *",
+  "flavor": "cpu-basic"
+})
+```
+
+## Tool Selection Guide
+
+| Goal | Tool |
+|------|------|
+| Find models | `model_search` |
+| Find datasets | `dataset_search` |
+| Find Spaces/apps | `space_search` |
+| Find papers | `paper_search` |
+| Get repo README/details | `hub_repo_details` |
+| Learn library usage | `hf_doc_search` → `hf_doc_fetch` |
+| Run code on GPU/CPU | `hf_jobs` |
+| Use Gradio apps as tools | `dynamic_space` |
+| Generate images | `gr1_flux1_schnell_infer` or `dynamic_space` |
+| Check auth | `hf_whoami` |
+
+## Tips
+
+- Use `sort="trendingScore"` to find what's popular now
+- Use `sort="downloads"` to find battle-tested options
+- Set `mcp=true` in `space_search` to find Spaces usable as tools
+- Use `include_readme=true` in `hub_repo_details` for full model/dataset documentation
+- For jobs accessing private repos, always include `secrets: {"HF_TOKEN": "$HF_TOKEN"}`
+- Use `dynamic_space(operation="discover")` to see all available Space-based tasks
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream product or API scope.
+- Verify commands, API behavior, pricing, quotas, credentials, and deployment effects against current official documentation before making changes.
+- Do not treat generated examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.

package/bundled-skills/hf-mem/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: hf-mem
+description: Hugging Face CLI to estimate the required memory to load Safetensors or GGUF model weights for inference from the Hugging Face Hub
+risk: unknown
+source: https://github.com/huggingface/skills/tree/main/skills/hf-mem
+source_repo: huggingface/skills
+source_type: official
+date_added: 2026-07-01
+license: Apache-2.0
+license_source: https://github.com/huggingface/skills/blob/main/LICENSE
+---
+
+`hf_mem` estimates the required memory for inference, including model weights and an optional KV cache, for Safetensors and GGUF for models on the Hugging Face Hub using HTTP Range requests i.e., without downloading or loading any weights locally.
+
+## When to use?
+
+- User asks how much VRAM or memory a model needs to run
+- User wants to know if a model fits on their GPU or a given instance
+- User references a Hugging Face model ID or URL and asks about inference requirements
+
+## What are the requirements?
+
+- `uv` installed (for `uvx`)
+- `HF_TOKEN` env var or `--hf-token` flag (for gated or private models only)
+
+## How to run?
+
+Run with `--model-id` pointing to the Hugging Face Hub repository which will check that it either contains Safetensors (via `model.safetensors`, `model.safetensors.index.json` if sharded, or `model_index.json` for Diffusers) or GGUF model weights within.
+
+```bash
+uvx hf-mem --model-id <model-id> --json-output
+```
+
+If the repository contains GGUF model weights in multiple precisions / quantizations, the estimations will be on a per-file basis, whereas for inference you won't load all of those but rather only a single precision. This being said, for GGUF you might as well need to provide `--gguf-file` to target the specific file (or path if sharded) you want to run.
+
+```bash
+uvx hf-mem --model-id <model-id> --gguf-file <file-or-path> --json-output
+```
+
+Additionally, `hf-mem` comes with an `--experimental` flag that will also calculate the KV cache memory requirements too, useful for large-language models, meaning it applies to LLMs (`...ForCausalLM`), VLMs (`...ForConditionalGeneration`), and GGUF models.
+
+As per the context window, it will be read from the default or overridden with `--max-model-len` a la vLLM. And, same goes for the KV cache precision, which will default to the model precision unless manually set via `--kv-cache-dtype` a la vLLM too.
+
+For Safetensors use as:
+
+```bash
+uvx hf-mem --model-id <model-id> --experimental [--max-model-len N] [--batch-size N] [--kv-cache-dtype auto|bfloat16|fp8|fp8_ds_mla|fp8_e4m3|fp8_e5m2|fp8_inc] --json-output
+```
+
+And, for GGUF use as:
+
+```bash
+uvx hf-mem --model-id <model-id> --gguf-file <file-or-path> --experimental [--max-model-len N] [--batch-size N] [--kv-cache-dtype auto|F32|F16|Q4_0|Q4_1|Q5_0|Q5_1|Q8_0|Q8_1|Q2_K|Q3_K|Q4_K|Q5_K|Q6_K|Q8_K|IQ2_XXS|IQ2_XS|IQ3_XXS|IQ1_S|IQ4_NL|IQ3_S|IQ2_S|IQ4_XS|I8|I16|I32|I64|F64|IQ1_M|BF16|TQ1_0|TQ2_0|MXFP4] --json-output
+```
+
+## Examples
+
+For Transformers with Safetensors weights:
+
+```bash
+uvx hf-mem --model-id MiniMaxAI/MiniMax-M2 --json-output
+```
+
+For Diffusers with Safetensors weights:
+
+```bash
+uvx hf-mem --model-id Qwen/Qwen-Image --json-output
+```
+
+For Sentence Transformers with Safetensors weights:
+
+```bash
+uvx hf-mem --model-id google/embeddinggemma-300m --json-output
+```
+
+With `--experimental` to include the KV cache estimation for LLMs and VLMs:
+
+```bash
+uvx hf-mem --model-id mistralai/Mistral-7B-v0.1 --experimental --json-output
+```
+
+And, for LLMs or VLMs with GGUF weights:
+
+```bash
+uvx hf-mem --model-id unsloth/Qwen3.5-397B-A17B-GGUF --gguf-file Q4_K_M --experimental --json-output
+```
+
+## Limitations
+
+- Use this skill only when the task clearly matches its upstream product or API scope.
+- Verify commands, API behavior, pricing, quotas, credentials, and deployment effects against current official documentation before making changes.
+- Do not treat generated examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.