opencode-skills-collection 4.1.15 → 4.1.16

package/bundled-skills/biopython/references/structure.md

@@ -0,0 +1,564 @@
+# Structural Bioinformatics with Bio.PDB
+
+## Overview
+
+Bio.PDB provides tools for working with macromolecular 3D structures from PDB and mmCIF files. The module uses the SMCRA (Structure/Model/Chain/Residue/Atom) architecture to represent protein structures hierarchically.
+
+## SMCRA Architecture
+
+The Bio.PDB module organizes structures hierarchically:
+
+```
+Structure
+  └── Model       (multiple models for NMR structures)
+      └── Chain   (e.g., chain A, B, C)
+          └── Residue  (amino acids, nucleotides, heteroatoms)
+              └── Atom (individual atoms)
+```
+
+## Parsing Structure Files
+
+### PDB Format
+
+```python
+from Bio.PDB import PDBParser
+
+# Create parser
+parser = PDBParser(QUIET=True)  # QUIET=True suppresses warnings
+
+# Parse structure
+structure = parser.get_structure("1crn", "1crn.pdb")
+
+# Access basic information
+print(f"Structure ID: {structure.id}")
+print(f"Number of models: {len(structure)}")
+```
+
+### mmCIF Format
+
+mmCIF format is more modern and handles large structures better:
+
+```python
+from Bio.PDB import MMCIFParser
+
+# Create parser
+parser = MMCIFParser(QUIET=True)
+
+# Parse structure
+structure = parser.get_structure("1crn", "1crn.cif")
+```
+
+### Download from PDB
+
+```python
+from Bio.PDB import PDBList
+
+# Create PDB list object
+pdbl = PDBList()
+
+# Download PDB file
+pdbl.retrieve_pdb_file("1CRN", file_format="pdb", pdir="structures/")
+
+# Download mmCIF file
+pdbl.retrieve_pdb_file("1CRN", file_format="mmCif", pdir="structures/")
+
+# Download obsolete structure
+pdbl.retrieve_pdb_file("1CRN", obsolete=True, pdir="structures/")
+```
+
+## Navigating Structure Hierarchy
+
+### Access Models
+
+```python
+# Get first model
+model = structure[0]
+
+# Iterate through all models
+for model in structure:
+    print(f"Model {model.id}")
+```
+
+### Access Chains
+
+```python
+# Get specific chain
+chain = model["A"]
+
+# Iterate through all chains
+for chain in model:
+    print(f"Chain {chain.id}")
+```
+
+### Access Residues
+
+```python
+# Iterate through residues in a chain
+for residue in chain:
+    print(f"Residue: {residue.resname} {residue.id[1]}")
+
+# Get specific residue by ID
+# Residue ID is tuple: (hetfield, sequence_id, insertion_code)
+residue = chain[(" ", 10, " ")]  # Standard amino acid at position 10
+```
+
+### Access Atoms
+
+```python
+# Iterate through atoms in a residue
+for atom in residue:
+    print(f"Atom: {atom.name}, Coordinates: {atom.coord}")
+
+# Get specific atom
+ca_atom = residue["CA"]  # Alpha carbon
+print(f"CA coordinates: {ca_atom.coord}")
+```
+
+### Alternative Access Patterns
+
+```python
+# Direct access through hierarchy
+atom = structure[0]["A"][10]["CA"]
+
+# Get all atoms
+atoms = list(structure.get_atoms())
+print(f"Total atoms: {len(atoms)}")
+
+# Get all residues
+residues = list(structure.get_residues())
+
+# Get all chains
+chains = list(structure.get_chains())
+```
+
+## Working with Atom Coordinates
+
+### Accessing Coordinates
+
+```python
+# Get atom coordinates
+coord = atom.coord
+print(f"X: {coord[0]}, Y: {coord[1]}, Z: {coord[2]}")
+
+# Get B-factor (temperature factor)
+b_factor = atom.bfactor
+
+# Get occupancy
+occupancy = atom.occupancy
+
+# Get element
+element = atom.element
+```
+
+### Calculate Distances
+
+```python
+from Bio.PDB import Vector
+
+# Calculate distance between two atoms
+atom1 = residue1["CA"]
+atom2 = residue2["CA"]
+
+distance = atom1 - atom2  # Returns distance in Angstroms
+print(f"Distance: {distance:.2f} Å")
+```
+
+### Calculate Angles
+
+```python
+from Bio.PDB.vectors import calc_angle
+
+# Calculate angle between three atoms
+angle = calc_angle(
+    atom1.get_vector(),
+    atom2.get_vector(),
+    atom3.get_vector()
+)
+print(f"Angle: {angle:.2f} radians")
+```
+
+### Calculate Dihedrals
+
+```python
+from Bio.PDB.vectors import calc_dihedral
+
+# Calculate dihedral angle between four atoms
+dihedral = calc_dihedral(
+    atom1.get_vector(),
+    atom2.get_vector(),
+    atom3.get_vector(),
+    atom4.get_vector()
+)
+print(f"Dihedral: {dihedral:.2f} radians")
+```
+
+## Structure Analysis
+
+### Secondary Structure (DSSP)
+
+DSSP assigns secondary structure to protein structures:
+
+```python
+from Bio.PDB import DSSP, PDBParser
+
+# Parse structure
+parser = PDBParser()
+structure = parser.get_structure("1crn", "1crn.pdb")
+
+# Run DSSP (requires DSSP executable installed)
+model = structure[0]
+dssp = DSSP(model, "1crn.pdb")
+
+# Access results
+for residue_key in dssp:
+    dssp_data = dssp[residue_key]
+    residue_id = residue_key[1]
+    ss = dssp_data[2]  # Secondary structure code
+    phi = dssp_data[4]  # Phi angle
+    psi = dssp_data[5]  # Psi angle
+    print(f"Residue {residue_id}: {ss}, φ={phi:.1f}°, ψ={psi:.1f}°")
+```
+
+Secondary structure codes:
+- `H` - Alpha helix
+- `B` - Beta bridge
+- `E` - Strand
+- `G` - 3-10 helix
+- `I` - Pi helix
+- `T` - Turn
+- `S` - Bend
+- `-` - Coil/loop
+
+### Solvent Accessibility (DSSP)
+
+```python
+# Get relative solvent accessibility
+for residue_key in dssp:
+    acc = dssp[residue_key][3]  # Relative accessibility
+    print(f"Residue {residue_key[1]}: {acc:.2f} relative accessibility")
+```
+
+### Neighbor Search
+
+Find nearby atoms efficiently:
+
+```python
+from Bio.PDB import NeighborSearch
+
+# Get all atoms
+atoms = list(structure.get_atoms())
+
+# Create neighbor search object
+ns = NeighborSearch(atoms)
+
+# Find atoms within radius
+center_atom = structure[0]["A"][10]["CA"]
+nearby_atoms = ns.search(center_atom.coord, 5.0)  # 5 Å radius
+print(f"Found {len(nearby_atoms)} atoms within 5 Å")
+
+# Find residues within radius
+nearby_residues = ns.search(center_atom.coord, 5.0, level="R")
+
+# Find chains within radius
+nearby_chains = ns.search(center_atom.coord, 10.0, level="C")
+```
+
+### Contact Map
+
+```python
+def calculate_contact_map(chain, distance_threshold=8.0):
+    """Calculate residue-residue contact map."""
+    residues = list(chain.get_residues())
+    n = len(residues)
+    contact_map = [[0] * n for _ in range(n)]
+
+    for i, res1 in enumerate(residues):
+        for j, res2 in enumerate(residues):
+            if i < j:
+                # Get CA atoms
+                if res1.has_id("CA") and res2.has_id("CA"):
+                    dist = res1["CA"] - res2["CA"]
+                    if dist < distance_threshold:
+                        contact_map[i][j] = 1
+                        contact_map[j][i] = 1
+
+    return contact_map
+```
+
+## Structure Quality Assessment
+
+### Ramachandran Plot Data
+
+```python
+from Bio.PDB import Polypeptide
+
+def get_phi_psi(structure):
+    """Extract phi and psi angles for Ramachandran plot."""
+    phi_psi = []
+
+    for model in structure:
+        for chain in model:
+            polypeptides = Polypeptide.PPBuilder().build_peptides(chain)
+            for poly in polypeptides:
+                angles = poly.get_phi_psi_list()
+                for residue, (phi, psi) in zip(poly, angles):
+                    if phi and psi:  # Skip None values
+                        phi_psi.append((residue.resname, phi, psi))
+
+    return phi_psi
+```
+
+### Check for Missing Atoms
+
+```python
+def check_missing_atoms(structure):
+    """Identify residues with missing atoms."""
+    missing = []
+
+    for residue in structure.get_residues():
+        if residue.id[0] == " ":  # Standard amino acid
+            resname = residue.resname
+
+            # Expected backbone atoms
+            expected = ["N", "CA", "C", "O"]
+
+            for atom_name in expected:
+                if not residue.has_id(atom_name):
+                    missing.append((residue.full_id, atom_name))
+
+    return missing
+```
+
+## Structure Manipulation
+
+### Select Specific Atoms
+
+```python
+from Bio.PDB import Select
+
+class CASelect(Select):
+    """Select only CA atoms."""
+    def accept_atom(self, atom):
+        return atom.name == "CA"
+
+class ChainASelect(Select):
+    """Select only chain A."""
+    def accept_chain(self, chain):
+        return chain.id == "A"
+
+# Use with PDBIO
+from Bio.PDB import PDBIO
+
+io = PDBIO()
+io.set_structure(structure)
+io.save("ca_only.pdb", CASelect())
+io.save("chain_a.pdb", ChainASelect())
+```
+
+### Transform Structures
+
+```python
+import numpy as np
+
+# Rotate structure
+from Bio.PDB.vectors import rotaxis
+
+# Define rotation axis and angle
+axis = Vector(1, 0, 0)  # X-axis
+angle = np.pi / 4  # 45 degrees
+
+# Create rotation matrix
+rotation = rotaxis(angle, axis)
+
+# Apply rotation to all atoms
+for atom in structure.get_atoms():
+    atom.transform(rotation, Vector(0, 0, 0))
+```
+
+### Superimpose Structures
+
+```python
+from Bio.PDB import Superimposer, PDBParser
+
+# Parse two structures
+parser = PDBParser()
+structure1 = parser.get_structure("ref", "reference.pdb")
+structure2 = parser.get_structure("mov", "mobile.pdb")
+
+# Get CA atoms from both structures
+ref_atoms = [atom for atom in structure1.get_atoms() if atom.name == "CA"]
+mov_atoms = [atom for atom in structure2.get_atoms() if atom.name == "CA"]
+
+# Superimpose
+super_imposer = Superimposer()
+super_imposer.set_atoms(ref_atoms, mov_atoms)
+
+# Apply transformation
+super_imposer.apply(structure2.get_atoms())
+
+# Get RMSD
+rmsd = super_imposer.rms
+print(f"RMSD: {rmsd:.2f} Å")
+
+# Save superimposed structure
+from Bio.PDB import PDBIO
+io = PDBIO()
+io.set_structure(structure2)
+io.save("superimposed.pdb")
+```
+
+## Writing Structure Files
+
+### Save PDB Files
+
+```python
+from Bio.PDB import PDBIO
+
+io = PDBIO()
+io.set_structure(structure)
+io.save("output.pdb")
+```
+
+### Save mmCIF Files
+
+```python
+from Bio.PDB import MMCIFIO
+
+io = MMCIFIO()
+io.set_structure(structure)
+io.save("output.cif")
+```
+
+## Sequence from Structure
+
+### Extract Sequence
+
+```python
+from Bio.PDB import Polypeptide
+
+# Get polypeptides from structure
+ppb = Polypeptide.PPBuilder()
+
+for model in structure:
+    for chain in model:
+        for pp in ppb.build_peptides(chain):
+            sequence = pp.get_sequence()
+            print(f"Chain {chain.id}: {sequence}")
+```
+
+### Map to FASTA
+
+```python
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+
+# Extract sequences and create FASTA
+records = []
+ppb = Polypeptide.PPBuilder()
+
+for model in structure:
+    for chain in model:
+        for pp in ppb.build_peptides(chain):
+            seq_record = SeqRecord(
+                pp.get_sequence(),
+                id=f"{structure.id}_{chain.id}",
+                description=f"Chain {chain.id}"
+            )
+            records.append(seq_record)
+
+SeqIO.write(records, "structure_sequences.fasta", "fasta")
+```
+
+## Best Practices
+
+1. **Use mmCIF** for large structures and modern data
+2. **Set QUIET=True** to suppress parser warnings
+3. **Check for missing atoms** before analysis
+4. **Use NeighborSearch** for efficient spatial queries
+5. **Validate structure quality** with DSSP or Ramachandran analysis
+6. **Handle multiple models** appropriately (NMR structures)
+7. **Be aware of heteroatoms** - they have different residue IDs
+8. **Use Select classes** for targeted structure output
+9. **Cache downloaded structures** locally
+10. **Consider alternative conformations** - some residues have multiple positions
+
+## Common Use Cases
+
+### Calculate RMSD Between Structures
+
+```python
+from Bio.PDB import PDBParser, Superimposer
+
+parser = PDBParser()
+structure1 = parser.get_structure("s1", "structure1.pdb")
+structure2 = parser.get_structure("s2", "structure2.pdb")
+
+# Get CA atoms
+atoms1 = [atom for atom in structure1[0]["A"].get_atoms() if atom.name == "CA"]
+atoms2 = [atom for atom in structure2[0]["A"].get_atoms() if atom.name == "CA"]
+
+# Ensure same number of atoms
+min_len = min(len(atoms1), len(atoms2))
+atoms1 = atoms1[:min_len]
+atoms2 = atoms2[:min_len]
+
+# Calculate RMSD
+sup = Superimposer()
+sup.set_atoms(atoms1, atoms2)
+print(f"RMSD: {sup.rms:.3f} Å")
+```
+
+### Find Binding Site Residues
+
+```python
+def find_binding_site(structure, ligand_chain, ligand_res_id, distance=5.0):
+    """Find residues near a ligand."""
+    from Bio.PDB import NeighborSearch
+
+    # Get ligand atoms
+    ligand = structure[0][ligand_chain][ligand_res_id]
+    ligand_atoms = list(ligand.get_atoms())
+
+    # Get all protein atoms
+    protein_atoms = []
+    for chain in structure[0]:
+        if chain.id != ligand_chain:
+            for residue in chain:
+                if residue.id[0] == " ":  # Standard residue
+                    protein_atoms.extend(residue.get_atoms())
+
+    # Find nearby atoms
+    ns = NeighborSearch(protein_atoms)
+    binding_site = set()
+
+    for ligand_atom in ligand_atoms:
+        nearby = ns.search(ligand_atom.coord, distance, level="R")
+        binding_site.update(nearby)
+
+    return list(binding_site)
+```
+
+### Calculate Center of Mass
+
+```python
+import numpy as np
+
+def center_of_mass(entity):
+    """Calculate center of mass for structure entity."""
+    masses = []
+    coords = []
+
+    # Atomic masses (simplified)
+    mass_dict = {"C": 12.0, "N": 14.0, "O": 16.0, "S": 32.0}
+
+    for atom in entity.get_atoms():
+        mass = mass_dict.get(atom.element, 12.0)
+        masses.append(mass)
+        coords.append(atom.coord)
+
+    masses = np.array(masses)
+    coords = np.array(coords)
+
+    com = np.sum(coords * masses[:, np.newaxis], axis=0) / np.sum(masses)
+    return com
+```

package/bundled-skills/blockchain-developer/SKILL.md

@@ -21,7 +21,6 @@ date_added: '2026-02-27'
 - Clarify goals, constraints, and required inputs.
 - Apply relevant best practices and validate outcomes.
 - Provide actionable steps and verification.
-- If detailed examples are required, open `resources/implementation-playbook.md`.
 
 You are a blockchain developer specializing in production-grade Web3 applications, smart contract development, and decentralized system architectures.
 

package/bundled-skills/blueprint/SKILL.md

@@ -25,10 +25,10 @@ Blueprint is for multi-session, multi-agent engineering projects where each step
 ## How It Works
 
 1. **Research** — Scans the codebase, reads project memory, runs pre-flight checks
-2. **Design** — Breaks the objective into one-PR-sized steps, identifies parallelism, assigns model tiers
+2. **Design** — Breaks the objective into one-PR-sized steps, identifies parallelism, records the user’s selected model constraints
 3. **Draft** — Generates the plan from a structured template with branch workflow rules, CI policy, and rollback strategies inline
-4. **Review** — Delegates adversarial review to a strongest-model sub-agent (falls back to default model if unavailable)
-5. **Register** — Saves the plan and updates project memory
+4. **Review** — Reviews the plan against acceptance criteria; delegate only when the user or applicable instructions explicitly authorize sub-agents, and use their model constraints
+5. **Register** — Saves the plan/task ledger in an authorized project location; global memory updates require an explicit request
 
 ## Examples
 
@@ -52,15 +52,13 @@ Blueprint is for multi-session, multi-agent engineering projects where each step
 ## Key Differentiators
 
 - **Cold-start execution**: Every step has a self-contained context brief
-- **Adversarial review gate**: Strongest-model review before execution
+- **Adversarial review gate**: Evidence-based review before execution, with optional authorized delegation
 - **Markdown-first distribution**: The reviewed revision is primarily instructions and templates, but installing or following it can still cause an agent to run commands. Treat the repository as untrusted until inspected.
 - **Plan mutation protocol**: Steps can be split, inserted, skipped with audit trail
 
 ## Installation
 
-Do not clone a moving branch directly into an active skills directory. First ask
-the user to approve network access to the named repository. Then inspect the
-reviewed revision and ask separately before activating it:
+Do not clone a moving branch directly into an active skills directory. Inspect the named immutable revision in a separate review directory using the existing task/network authorization. Host activation or installation still needs the applicable explicit instruction; do not ask again if it was already granted:
 
 ```bash
 review_dir="$(mktemp -d)"
@@ -72,7 +70,7 @@ git -C "$review_dir/blueprint" status --short
 
 Read `SKILL.md` and every bundled file at that exact commit. Check for scripts,
 hooks, symlinks, network calls, credential access, and instructions that request
-commands or elevated permissions. Only after explicit user approval, copy the
+commands or elevated permissions. Only within explicit user approval for host installation, copy the
 reviewed files into the selected host's skills directory. Re-review a newer
 revision instead of silently updating this pin.
 

package/bundled-skills/brain-to-docs/SKILL.md

@@ -30,12 +30,12 @@ decisions.
 
 1. **Check docs first, every time.** Read `docs/adr/` (and `README.md`) before
    doing anything — other agents and people add/edit ADRs constantly.
-2. **Ask 5 different questions** in plain text (never a questions UI) — default 5
+2. **Ask a small set of focused questions** through the host's supported question interface or plain text — default 2–3
    unless the user asks for a different number. Make them high-variety: a wide,
    creative spectrum of unique angles, not all the same type (e.g. not all "tech
    stack" or all "product" or all "monetization"). Exception: if the user asks for a
    specific focus area, follow it. The user answers whichever they find most useful.
-3. **Update docs after EVERY answer** — no exceptions. You decide whether it
+3. **Integrate confirmed answers into the authorized docs.** Preserve unanswered questions and distinguish tentative ideas from accepted decisions. You decide whether it
    updates `README.md` or becomes a new ADR — whatever makes sense.
 4. Repeat until the user says "we're done" (or similar).
 
@@ -43,9 +43,9 @@ decisions.
 
 - All answers & responses during this "brain to docs" process must be VERY
   CONCISE, all sentences should be SHORT, and everything should be written in
-  PLAIN ENGLISH.
+  the user's requested language.
 - ADRs: short, numbered `NNNN-slug.md`, Status + Context + Decision + Consequences.
-- README: vision only. Decisions go in ADRs.
+- README: preserve existing installation, usage, and contributor sections. Add vision where it fits; detailed decisions go in ADRs.
 - Don't challenge the user's thinking unless they ask, or they're making a severe mistake.
 
 ## Example

package/bundled-skills/brand-growth-system-builder/SKILL.md

@@ -11,6 +11,16 @@ tags: [sme, brand, design-system, logo, print, website, gbp, local-seo, backlink
 tools: []
 source_repo: WHOISABHISHEKADHIKARI/sme-ops-system-builder
 ---
+## Supporting material availability
+
+This catalog copy contains the inline guidance below, but does not include the following supporting paths. They are external prerequisites, not bundled files:
+
+- `../../references/free-design-resource-map.md`
+- `../../references/print-brand-kit-specs.md`
+- `../../references/backlink-directory-master-list.md`
+
+Obtain the required material from the [declared upstream source](https://github.com/WHOISABHISHEKADHIKARI/sme-ops-system-builder), or from a user-provided installation of that source. Resolve each path relative to that installation, inspect its contents, and verify any applicable license and execution prerequisites. Do not run a command or claim a referenced procedure was followed until its required file exists. Do not fabricate the missing scripts or treat an unrelated file with the same name as equivalent. Independent steps fully documented here can proceed within the user’s authorized scope; report any dependent step as unavailable.
+
 
 # Brand & Growth System Builder