pi-skill-search 0.1.0

package/skills/ginkgo-cloud-lab/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: ginkgo-cloud-lab
+description: Submit and manage protocols on Ginkgo Bioworks Cloud Lab (cloud.ginkgo.bio), a web-based interface for autonomous lab execution on Reconfigurable Automation Carts (RACs). Use when the user wants to run cell-free protein expression (validation or optimization), generate fluorescent pixel art, or interact with Ginkgo Cloud Lab services. Covers protocol selection, input preparation, pricing, and ordering workflows.
+---
+
+# Ginkgo Cloud Lab
+
+## Overview
+
+Ginkgo Cloud Lab (https://cloud.ginkgo.bio) provides remote access to Ginkgo Bioworks' autonomous lab infrastructure. Protocols are executed on Reconfigurable Automation Carts (RACs) -- modular units with robotic arms, maglev sample transport, and industrial-grade software spanning 70+ instruments.
+
+The platform also includes **EstiMate**, an AI agent that accepts human-language protocol descriptions and returns feasibility assessments and pricing for custom workflows beyond the listed protocols.
+
+## Available Protocols
+
+### 1. Cell Free Protein Expression Validation
+
+Rapid go/no-go expression screening using reconstituted E. coli CFPS. Submit a FASTA sequence (up to 1800 bp) and receive expression confirmation, baseline titer (mg/L), and initial purity with virtual gel images.
+
+- **Price:** $39/sample | **Turnaround:** 5-10 days | **Status:** Certified
+- **Details:** See (see docs)
+
+### 2. Cell Free Protein Expression Optimization
+
+DoE-based optimization across up to 24 conditions per protein (lysates, temperatures, chaperones, disulfide enhancers, cofactors). Designed for difficult-to-express and membrane proteins.
+
+- **Price:** $199/sample | **Turnaround:** 6-11 days | **Status:** Certified
+- **Details:** See (see docs)
+
+### 3. Fluorescent Pixel Art Generation
+
+Transform a pixel art image (48x48 to 96x96 px, PNG/SVG) into fluorescent bacterial artwork using up to 11 E. coli strains via acoustic dispensing. Delivered as high-res UV photographs.
+
+- **Price:** $25/plate | **Turnaround:** 5-7 days | **Status:** Beta
+- **Details:** See (see docs)
+
+## General Ordering Workflow
+
+1. Select a protocol at https://cloud.ginkgo.bio/protocols
+2. Configure parameters (number of samples/proteins, replicates, plates)
+3. Upload input files (FASTA for protein protocols, PNG/SVG for pixel art)
+4. Add any special requirements in the Additional Details field
+5. Submit and receive a feasibility report and price quote
+
+For protocols not listed above, use the **EstiMate** chat to describe a custom protocol in plain language and receive compatibility assessment and pricing.
+
+## Authentication
+
+Access Ginkgo Cloud Lab at https://cloud.ginkgo.bio. Account creation or institutional access may be required. Contact Ginkgo at cloud@ginkgo.bio for access questions.
+
+## Key Infrastructure
+

package/skills/git-master/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: git-master
+description: Commit and release hygiene for safe version-control work. Use when preparing commits, releases, version bumps, publishing, or validating package installation.
+---
+
+
+# git-master
+
+Use this skill for commit/release hygiene. This skill covers git workflow from local changes to published releases.
+
+## Pre-commit Checklist
+
+Before every commit:
+
+1. Run `git status --short` — understand what changed
+2. Stage only files related to the current task
+3. Review staged diff with `git diff --staged`
+4. Check for unintended changes (generated files, temp files, secrets)
+5. Ensure tests pass locally before committing
+
+## Commit Rules
+
+- **Independent commits**: Each commit should be self-contained and revertible. Don't mix unrelated changes.
+- **Concise messages**: Use imperative mood, 50 chars or less for subject. Add body for context.
+- **Format**: `type(scope): subject` where type is `fix`, `feat`, `chore`, `docs`, `test`, `refactor`
+- **Do not include**: secrets, OTPs, local temp files, `node_modules`, `dist/`, `*.log`, `*.tmp`
+- **Do not push/publish** unless explicitly requested
+- **Verify** before staging large generated files (tarballs, build outputs)
+
+## Commit Message Format
+
+```
+type(scope): short description (50 chars max)
+
+ Longer description if needed. Explain WHY the change was made,
+ not just what changed. Reference issues/PRs if applicable.
+
+Refs: #123
+```
+
+**Examples:**
+```
+fix(live-agent): prevent cross-workspace agent access
+feat(widget): add snapshot cache with 500ms TTL
+docs(skills): add event-log-tracing skill
+chore(tests): add integration test for reconcileAllStaleRuns
+```
+
+## Branch Naming
+
+| Pattern | Use case | Example |
+|---|---|---|
+| `fix/<description>` | Bug fixes | `fix/ghost-run-display` |
+| `feat/<description>` | New features | `feat/skill-templates` |
+| `docs/<description>` | Documentation | `docs/skills-deep-research` |
+| `chore/<description>` | Tooling, CI | `chore/update-ci-node22` |
+| `hotfix/<description>` | Urgent production fixes | `hotfix/secret-leak` |
+
+## Rollback Procedures
+
+### Revert last commit (safe, keeps history)
+```bash
+git revert HEAD
+git push
+```
+
+### Reset to known-good state (rewrites history)
+```bash
+# Soft: keep changes staged
+git reset --soft HEAD~1
+
+# Mixed: keep changes unstaged
+git reset HEAD~1
+
+# Hard: discard all changes (DESTRUCTIVE)
+git reset --hard <commit-hash>
+```
+
+### Checkout single file from a past commit
+```bash
+git checkout <commit-hash> -- path/to/file
+```
+
+### Recover from a bad reset
+```bash

package/skills/glycoengineering/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: glycoengineering
+description: Analyze and engineer protein glycosylation. Scan sequences for N-glycosylation sequons (N-X-S/T), predict O-glycosylation hotspots, and access curated glycoengineering tools (NetOGlyc, GlycoShield, GlycoWorkbench). For glycoprotein engineering, therapeutic antibody optimization, and vaccine design.
+---
+
+# Glycoengineering
+
+## Overview
+
+Glycosylation is the most common and complex post-translational modification (PTM) of proteins, affecting over 50% of all human proteins. Glycans regulate protein folding, stability, immune recognition, receptor interactions, and pharmacokinetics of therapeutic proteins. Glycoengineering involves rational modification of glycosylation patterns for improved therapeutic efficacy, stability, or immune evasion.
+
+**Two major glycosylation types:**
+- **N-glycosylation**: Attached to asparagine (N) in the sequon N-X-[S/T] where X ≠ Proline; occurs in the ER/Golgi
+- **O-glycosylation**: Attached to serine (S) or threonine (T); no strict consensus motif; primarily GalNAc initiation
+
+## When to Use This Skill
+
+Use this skill when:
+
+- **Antibody engineering**: Optimize Fc glycosylation for enhanced ADCC, CDC, or reduced immunogenicity
+- **Therapeutic protein design**: Identify glycosylation sites that affect half-life, stability, or immunogenicity
+- **Vaccine antigen design**: Engineer glycan shields to focus immune responses on conserved epitopes
+- **Biosimilar characterization**: Compare glycan patterns between reference and biosimilar
+- **Drug target analysis**: Does glycosylation affect target engagement for a receptor?
+- **Protein stability**: N-glycans often stabilize proteins; identify sites for stabilizing mutations
+
+## N-Glycosylation Sequon Analysis
+
+### Scanning for N-Glycosylation Sites
+
+N-glycosylation occurs at the sequon **N-X-[S/T]** where X ≠ Proline.
+
+```python
+import re
+from typing import List, Tuple
+
+def find_n_glycosylation_sequons(sequence: str) -> List[dict]:
+    """
+    Scan a protein sequence for canonical N-linked glycosylation sequons.
+    Motif: N-X-[S/T], where X ≠ Proline.
+
+    Args:
+        sequence: Single-letter amino acid sequence
+
+# Example: IgG1 Fc region
+fc_sequence = "APELLGGPSVFLFPPKPKDTLMISRTPEVTCVVVDVSHEDPEVKFNWYVDGVEVHNAKTKPREEQYNSTYRVVSVLTVLHQDWLNGKEYKCKVSNKALPAPIEKTISKAKGQPREPQVYTLPPSREEMTKNQVSLTCLVKGFYPSDIAVEWESNGQPENNYKTTPPVLDSDGSFFLYSKLTVDKSRWQQGNVFSCSVMHEALHNHYTQKSLSLSPGK"
+print(summarize_glycosylation_sites(fc_sequence, "IgG1 Fc"))
+```
+
+### Mutating N-Glycosylation Sites
+
+```python
+def eliminate_glycosite(sequence: str, position: int, replacement: str = "Q") -> str:
+    """
+    Eliminate an N-glycosylation site by substituting Asn → Gln (conservative).
+
+    Args:
+        sequence: Protein sequence
+        position: 1-based position of the Asn to mutate
+        replacement: Amino acid to substitute (default Q = Gln; similar size, not glycosylated)
+
+    Returns:
+        Mutated sequence
+    """
+
+## O-Glycosylation Analysis
+
+### Heuristic O-Glycosylation Hotspot Prediction
+
+```python
+def predict_o_glycosylation_hotspots(
+    sequence: str,
+    window: int = 7,
+    min_st_fraction: float = 0.4,
+    disallow_proline_next: bool = True
+) -> List[dict]:
+    """
+    Heuristic O-glycosylation hotspot scoring based on local S/T density.
+    Not a substitute for NetOGlyc; use as fast baseline.
+
+    Rules:
+    - O-GalNAc glycosylation clusters on Ser/Thr-rich segments
+
+## External Glycoengineering Tools
+
+### 1. NetOGlyc 4.0 (O-glycosylation prediction)
+
+Web service for high-accuracy O-GalNAc site prediction:
+- **URL**: https://services.healthtech.dtu.dk/services/NetOGlyc-4.0/
+- **Input**: FASTA protein sequence
+- **Output**: Per-residue O-glycosylation probability scores
+- **Method**: Neural network trained on experimentally verified O-GalNAc sites
+
+```python
+import requests
+
+def submit_netoglycv4(fasta_sequence: str) -> str:
+    """
+    Submit sequence to NetOGlyc 4.0 web service.
+    Returns the job URL for result retrieval.
+
+# Also: NetNGlyc for N-glycosylation prediction
+# URL: https://services.healthtech.dtu.dk/services/NetNGlyc-1.0/
+```

package/skills/gtars/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: gtars
+description: High-performance toolkit for genomic interval analysis in Rust with Python bindings. Use when working with genomic regions, BED files, coverage tracks, overlap detection, tokenization for ML models, or fragment analysis in computational genomics and machine learning applications.
+---
+
+# Gtars: Genomic Tools and Algorithms in Rust
+
+## Overview
+
+Gtars is a high-performance Rust toolkit for manipulating, analyzing, and processing genomic interval data. It provides specialized tools for overlap detection, coverage analysis, tokenization for machine learning, and reference sequence management.
+
+Use this skill when working with:
+- Genomic interval files (BED format)
+- Overlap detection between genomic regions
+- Coverage track generation (WIG, BigWig)
+- Genomic ML preprocessing and tokenization
+- Fragment analysis in single-cell genomics
+- Reference sequence retrieval and validation
+
+### Rust Library
+
+Add to Cargo.toml for Rust projects:
+
+```toml
+[dependencies]
+gtars = { version = "0.1", features = ["tokenizers", "overlaprs"] }
+```
+
+## Core Capabilities
+
+Gtars is organized into specialized modules, each focused on specific genomic analysis tasks:
+
+### 1. Overlap Detection and IGD Indexing
+
+Efficiently detect overlaps between genomic intervals using the Integrated Genome Database (IGD) data structure.
+
+**When to use:**
+- Finding overlapping regulatory elements
+- Variant annotation
+- Comparing ChIP-seq peaks
+- Identifying shared genomic features
+
+**Quick example:**
+```python
+import gtars
+
+# Build IGD index and query overlaps
+igd = gtars.igd.build_index("regions.bed")
+overlaps = igd.query("chr1", 1000, 2000)
+```
+
+See `(see docs)` for comprehensive overlap detection documentation.
+
+### 2. Coverage Track Generation
+
+Generate coverage tracks from sequencing data with the uniwig module.
+
+**When to use:**
+- ATAC-seq accessibility profiles
+- ChIP-seq coverage visualization
+- RNA-seq read coverage
+- Differential coverage analysis
+
+**Quick example:**
+```bash
+# Generate BigWig coverage track
+gtars uniwig generate --input fragments.bed --output coverage.bw --format bigwig
+```
+
+See `(see docs)` for detailed coverage analysis workflows.
+
+### 3. Genomic Tokenization
+
+Convert genomic regions into discrete tokens for machine learning applications, particularly for deep learning models on genomic data.
+
+**When to use:**
+- Preprocessing for genomic ML models
+- Integration with geniml library
+- Creating position encodings
+- Training transformer models on genomic sequences
+
+**Quick example:**
+```python
+from gtars.tokenizers import TreeTokenizer
+
+tokenizer = TreeTokenizer.from_bed_file("training_regions.bed")
+
+### 4. Reference Sequence Management
+
+Handle reference genome sequences and compute digests following the GA4GH refget protocol.
+
+**When to use:**
+- Validating reference genome integrity
+- Extracting specific genomic sequences
+- Computing sequence digests
+- Cross-reference comparisons
+
+**Quick example:**
+```python
+# Load reference and extract sequences
+store = gtars.RefgetStore.from_fasta("hg38.fa")
+sequence = store.get_subsequence("chr1", 1000, 2000)
+
+

package/skills/hackernews-frontpage/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: hackernews-frontpage
+description: Scrape the Hacker News front page (titles, points, comment counts).
+---
+
+
+# Hacker News front-page scraper
+
+Scrapes the Hacker News (`news.ycombinator.com`) front page and returns the
+top 30 stories as JSON. Each story has its rank, title, link URL, point count,
+and comment count.
+
+## Usage
+
+```
+$ $B skill run hackernews-frontpage
+{
+  "stories": [
+    { "rank": 1, "title": "...", "url": "...", "points": 412, "comments": 87 },
+    ...
+  ],
+  "count": 30
+}
+```
+
+## How it works
+
+1. Navigates to `https://news.ycombinator.com` via the daemon.
+2. Reads the page HTML.
+3. Parses each story row (HN's stable `tr.athing` structure) into a typed
+   `Story` record.
+4. Emits a single JSON document on stdout.
+
+## Why this is the reference skill
+
+`hackernews-frontpage` is the smallest interesting browser-skill: no auth,
+stable HTML, deterministic output, file-fixture-friendly. Every Phase 1
+component (SDK, scoped tokens, three-tier lookup, spawn lifecycle) is
+exercised by `$B skill run hackernews-frontpage` and the bundled
+`script.test.ts`.
+
+When the HN HTML rotates and our selectors break, the test fails against the
+captured fixture before users notice. That's the point.
+
+
+

package/skills/histolab/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: histolab
+description: Lightweight WSI tile extraction and preprocessing. Use for basic slide processing tissue detection, tile extraction, stain normalization for H&E images. Best for simple pipelines, dataset preparation, quick tile-based analysis. For advanced spatial proteomics, multiplexed imaging, or deep learning pipelines use pathml.
+---
+
+# Histolab
+
+## Overview
+
+Histolab is a Python library for processing whole slide images (WSI) in digital pathology. It automates tissue detection, extracts informative tiles from gigapixel images, and prepares datasets for deep learning pipelines. The library handles multiple WSI formats, implements sophisticated tissue segmentation, and provides flexible tile extraction strategies.
+
+## Quick Start
+
+Basic workflow for extracting tiles from a whole slide image:
+
+```python
+from histolab.slide import Slide
+from histolab.tiler import RandomTiler
+
+# Load slide
+slide = Slide("slide.svs", processed_path="output/")
+
+# Configure tiler
+tiler = RandomTiler(
+    tile_size=(512, 512),
+    n_tiles=100,
+    level=0,
+    seed=42
+)
+
+# Preview tile locations
+tiler.locate_tiles(slide, n_tiles=20)
+
+# Extract tiles
+tiler.extract(slide)
+```
+
+## Core Capabilities
+
+### 1. Slide Management
+
+Load, inspect, and work with whole slide images in various formats.
+
+**Common operations:**
+- Loading WSI files (SVS, TIFF, NDPI, etc.)
+- Accessing slide metadata (dimensions, magnification, properties)
+- Generating thumbnails for visualization
+- Working with pyramidal image structures
+- Extracting regions at specific coordinates
+
+**Key classes:** `Slide`
+
+**Reference:** `(see docs)` contains comprehensive documentation on:
+- Slide initialization and configuration
+
+# Load sample data
+prostate_svs, prostate_path = prostate_tissue()
+
+# Initialize slide
+slide = Slide(prostate_path, processed_path="output/")
+
+# Inspect properties
+print(f"Dimensions: {slide.dimensions}")
+print(f"Levels: {slide.levels}")
+print(f"Magnification: {slide.properties.get('openslide.objective-power')}")
+
+# Save thumbnail
+slide.save_thumbnail()
+```
+
+### 2. Tissue Detection and Masks
+
+Automatically identify tissue regions and filter background/artifacts.
+
+**Common operations:**
+- Creating binary tissue masks
+- Detecting largest tissue region
+- Excluding background and artifacts
+- Custom tissue segmentation
+- Removing pen annotations
+
+**Key classes:** `TissueMask`, `BiggestTissueBoxMask`, `BinaryMask`
+
+**Reference:** `(see docs)` contains comprehensive documentation on:
+- TissueMask: Segments all tissue regions using automated filters
+
+# Create tissue mask for all tissue regions
+tissue_mask = TissueMask()
+
+# Visualize mask on slide
+slide.locate_mask(tissue_mask)
+
+# Get mask array
+mask_array = tissue_mask(slide)
+
+# Use largest tissue region (default for most extractors)
+biggest_mask = BiggestTissueBoxMask()
+```

package/skills/how-it-works/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: how-it-works
+description: Explain how claude-mem captures observations, when memory injection kicks in, and where data lives. Use when the user asks "how does claude-mem work?" or "what is this thing doing?".
+---
+
+# How claude-mem works
+
+## What it does
+
+Every Read, Edit, and Bash that Claude makes turns into a compressed observation. Observations get summarized at session end. Relevant ones get auto-injected into future prompts so the next session starts with context from the last one — no re-explaining the codebase, no re-discovering decisions.
+
+## When it kicks in
+
+Memory injection starts on your second session in a project.
+
+The first session in a fresh project seeds memory; subsequent sessions receive auto-injected context for relevant past work. Run `/learn-codebase` if you want to front-load the entire repo into memory in a single pass (~5 minutes, optional).
+
+## Where data lives
+
+Everything stays in ~/.claude-mem on this machine.
+
+Nothing leaves your machine except calls to whichever AI provider you configured for compression (Claude / OpenRouter / Gemini). The SQLite database, vector index, logs, and settings all live under that directory and are removed cleanly on `npx claude-mem uninstall`.
+
+
+

package/skills/hud/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: hud
+description: Configure HUD display options (layout, presets, display elements)
+---
+
+# HUD Skill
+
+Configure the OMC HUD (Heads-Up Display) for the statusline.
+
+Note: All `~/.claude/...` paths in this guide respect `CLAUDE_CONFIG_DIR` when that environment variable is set.
+
+## Quick Commands
+
+| Command | Description |
+|---------|-------------|
+| `hud` | Show current HUD status (auto-setup if needed) |
+| `hud setup` | Install/repair HUD statusline |
+| `hud minimal` | Switch to minimal display |
+| `hud focused` | Switch to focused display (default) |
+| `hud full` | Switch to full display |
+| `hud status` | Show detailed HUD status |
+
+## Auto-Setup
+
+When you run `hud` or `hud setup`, the system will automatically:
+1. Check if `~/.claude/hud/omc-hud.mjs` exists
+2. Check if `statusLine` is configured in `~/.claude/settings.json`
+3. If missing, create the HUD wrapper script and configure settings
+4. Report status and prompt to restart Claude Code if changes were made
+
+**IMPORTANT**: If the argument is `setup` OR if the HUD script doesn't exist at `~/.claude/hud/omc-hud.mjs`, you MUST create the HUD files directly using the instructions below.
+
+### Setup Instructions (Run These Commands)
+
+**Step 1:** Check if setup is needed:
+```bash
+node -e "const p=require('path'),f=require('fs'),d=process.env.CLAUDE_CONFIG_DIR||p.join(require('os').homedir(),'.claude');console.log(f.existsSync(p.join(d,'hud','omc-hud.mjs'))?'EXISTS':'MISSING')"
+```
+
+**Step 2:** Verify the plugin is installed:
+```bash
+node -e "const p=require('path'),f=require('fs'),d=process.env.CLAUDE_CONFIG_DIR||p.join(require('os').homedir(),'.claude'),b=p.join(d,'plugins','cache','omc','oh-my-claudecode');try{const v=f.readdirSync(b).filter(x=>/^\d/.test(x)).sort((a,c)=>a.localeCompare(c,void 0,{numeric:true}));if(v.length===0){console.log('Plugin not installed - run: /plugin install oh-my-claudecode');process.exit()}const l=v[v.length-1],h=p.join(b,l,'dist','hud','index.js');console.log('Version:',l);console.log(f.existsSync(h)?'READY':'NOT_FOUND - try reinstalling: /plugin install oh-my-claudecode')}catch{console.log('Plugin not installed - run: /plugin install oh-my-claudecode')}"
+```
+
+**Step 3:** If omc-hud.mjs is MISSING or argument is `setup`, install the HUD wrapper and its dependency from the canonical template:
+
+```bash
+HUD_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hud"
+mkdir -p "$HUD_DIR/lib"
+cp "${CLAUDE_PLUGIN_ROOT}/scripts/lib/hud-wrapper-template.txt" "$HUD_DIR/omc-hud.mjs"
+cp "${CLAUDE_PLUGIN_ROOT}/scripts/lib/config-dir.mjs" "$HUD_DIR/lib/config-dir.mjs"
+```
+
+**IMPORTANT:** Always copy from the canonical template at `scripts/lib/hud-wrapper-template.txt`. Do NOT write the wrapper content inline — the template is the single source of truth and is guarded by drift tests (`src/__tests__/hud-wrapper-template-sync.test.ts`, `src/__tests__/paths-consistency.test.ts`).
+
+**Step 4:** Make it executable (Unix only, skip on Windows):
+```bash
+node -e "if(process.platform==='win32'){console.log('Skipped (Windows)')}else{require('fs').chmodSync(require('path').join(process.env.CLAUDE_CONFIG_DIR||require('path').join(require('os').homedir(),'.claude'),'hud','omc-hud.mjs'),0o755);console.log('Done')}"
+```
+
+**Step 5:** Update settings.json to use the HUD:
+
+Read `${CLAUDE_CONFIG_DIR:-~/.claude}/settings.json`, then update/add the `statusLine` field.
+
+**IMPORTANT:** Do not use `~` in the command. On Unix, use `$HOME` to keep the path portable across machines. On Windows, use an absolute path because Windows does not expand `~` in shell commands.
+
+If you are on Windows, first determine the correct path:
+```bash
+node -e "const p=require('path').join(require('os').homedir(),'.claude','hud','omc-hud.mjs').split(require('path').sep).join('/');console.log(JSON.stringify(p))"
+```
+
+**IMPORTANT:** The command path MUST use forward slashes on all platforms. Claude Code executes statusLine commands via bash, which interprets backslashes as escape characters and breaks the path.
+
+Then set the `statusLine` field. On Unix it should stay portable and look like:
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hud/omc-hud.mjs"
+  }
+}
+```
+
+On Windows the path uses forward slashes (not backslashes):
+
+