@bgicli/bgicli 2.2.8 → 2.2.10

package/data/skills/openai-vercel-deploy/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: vercel-deploy
+description: Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".
+---
+
+# Vercel Deploy
+
+Deploy any project to Vercel instantly. **Always deploy as preview** (not production) unless the user explicitly asks for production.
+
+## Prerequisites
+
+- Check whether the Vercel CLI is installed **without** escalated permissions (for example, `command -v vercel`).
+- Only escalate the actual deploy command if sandboxing blocks the deployment network calls (`sandbox_permissions=require_escalated`).
+- The deployment might take a few minutes. Use appropriate timeout values.
+
+## Quick Start
+
+1. Check whether the Vercel CLI is installed (no escalation for this check):
+
+```bash
+command -v vercel
+```
+
+2. If `vercel` is installed, run this (with a 10 minute timeout):
+```bash
+vercel deploy [path] -y
+```
+
+**Important:** Use a 10 minute (600000ms) timeout for the deploy command since builds can take a while.
+
+3. If `vercel` is not installed, or if the CLI fails with "No existing credentials found", use the fallback method below.
+
+## Fallback (No Auth)
+
+If CLI fails with auth error, use the deploy script:
+
+```bash
+skill_dir="<path-to-skill>"
+
+# Deploy current directory
+bash "$skill_dir/scripts/deploy.sh"
+
+# Deploy specific project
+bash "$skill_dir/scripts/deploy.sh" /path/to/project
+
+# Deploy existing tarball
+bash "$skill_dir/scripts/deploy.sh" /path/to/project.tgz
+```
+
+The script handles framework detection, packaging, and deployment. It waits for the build to complete and returns JSON with `previewUrl` and `claimUrl`.
+
+**Tell the user:** "Your deployment is ready at [previewUrl]. Claim it at [claimUrl] to manage your deployment."
+
+## Production Deploys
+
+Only if user explicitly asks:
+```bash
+vercel deploy [path] --prod -y
+```
+
+## Output
+
+Show the user the deployment URL. For fallback deployments, also show the claim URL.
+
+**Do not** curl or fetch the deployed URL to verify it works. Just return the link.
+
+## Troubleshooting
+
+### Escalated Network Access
+
+If deployment fails due to network issues (timeouts, DNS errors, connection resets), rerun the actual deploy command with escalated permissions (use `sandbox_permissions=require_escalated`). Do not escalate the `command -v vercel` installation check. The deploy requires escalated network access when sandbox networking blocks outbound requests.
+
+Example guidance to the user:
+
+```
+The deploy needs escalated network access to deploy to Vercel. I can rerun the command with escalated permissions—want me to proceed?
+```

package/data/skills/openai-yeet/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: "yeet"
+description: "Use only when the user explicitly asks to stage, commit, push, and open a GitHub pull request in one flow using the GitHub CLI (`gh`)."
+---
+
+## Prerequisites
+
+- Require GitHub CLI `gh`. Check `gh --version`. If missing, ask the user to install `gh` and stop.
+- Require authenticated `gh` session. Run `gh auth status`. If not authenticated, ask the user to run `gh auth login` (and re-run `gh auth status`) before continuing.
+
+## Naming conventions
+
+- Branch: `codex/{description}` when starting from main/master/default.
+- Commit: `{description}` (terse).
+- PR title: `[codex] {description}` summarizing the full diff.
+
+## Workflow
+
+- If on main/master/default, create a branch: `git checkout -b "codex/{description}"`
+- Otherwise stay on the current branch.
+- Confirm status, then stage everything: `git status -sb` then `git add -A`.
+- Commit tersely with the description: `git commit -m "{description}"`
+- Run checks if not already. If checks fail due to missing deps/tools, install dependencies and rerun once.
+- Push with tracking: `git push -u origin $(git branch --show-current)`
+- If git push fails due to workflow auth errors, pull from master and retry the push.
+- Open a PR and edit title/body to reflect the description and the deltas: `GH_PROMPT_DISABLED=1 GIT_TERMINAL_PROMPT=0 gh pr create --draft --fill --head $(git branch --show-current)`
+- Write the PR description to a temp file with real newlines (e.g. pr-body.md ... EOF) and run pr-body.md to avoid \\n-escaped markdown.
+- PR description (markdown) must be detailed prose covering the issue, the cause and effect on users, the root cause, the fix, and any tests or checks used to validate.

package/data/skills/pennylane/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: pennylane
+description: Hardware-agnostic quantum ML framework with automatic differentiation. Use when training quantum circuits via gradients, building hybrid quantum-classical models, or needing device portability across IBM/Google/Rigetti/IonQ. Best for variational algorithms (VQE, QAOA), quantum neural networks, and integration with PyTorch/JAX/TensorFlow. For hardware-specific optimizations use qiskit (IBM) or cirq (Google); for open quantum systems use qutip.
+license: Apache-2.0 license
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# PennyLane
+
+## Overview
+
+PennyLane is a quantum computing library that enables training quantum computers like neural networks. It provides automatic differentiation of quantum circuits, device-independent programming, and seamless integration with classical machine learning frameworks.
+
+## Installation
+
+Install using uv:
+
+```bash
+uv pip install pennylane
+```
+
+For quantum hardware access, install device plugins:
+
+```bash
+# IBM Quantum
+uv pip install pennylane-qiskit
+
+# Amazon Braket
+uv pip install amazon-braket-pennylane-plugin
+
+# Google Cirq
+uv pip install pennylane-cirq
+
+# Rigetti Forest
+uv pip install pennylane-rigetti
+
+# IonQ
+uv pip install pennylane-ionq
+```
+
+## Quick Start
+
+Build a quantum circuit and optimize its parameters:
+
+```python
+import pennylane as qml
+from pennylane import numpy as np
+
+# Create device
+dev = qml.device('default.qubit', wires=2)
+
+# Define quantum circuit
+@qml.qnode(dev)
+def circuit(params):
+    qml.RX(params[0], wires=0)
+    qml.RY(params[1], wires=1)
+    qml.CNOT(wires=[0, 1])
+    return qml.expval(qml.PauliZ(0))
+
+# Optimize parameters
+opt = qml.GradientDescentOptimizer(stepsize=0.1)
+params = np.array([0.1, 0.2], requires_grad=True)
+
+for i in range(100):
+    params = opt.step(circuit, params)
+```
+
+## Core Capabilities
+
+### 1. Quantum Circuit Construction
+
+Build circuits with gates, measurements, and state preparation. See `references/quantum_circuits.md` for:
+- Single and multi-qubit gates
+- Controlled operations and conditional logic
+- Mid-circuit measurements and adaptive circuits
+- Various measurement types (expectation, probability, samples)
+- Circuit inspection and debugging
+
+### 2. Quantum Machine Learning
+
+Create hybrid quantum-classical models. See `references/quantum_ml.md` for:
+- Integration with PyTorch, JAX, TensorFlow
+- Quantum neural networks and variational classifiers
+- Data encoding strategies (angle, amplitude, basis, IQP)
+- Training hybrid models with backpropagation
+- Transfer learning with quantum circuits
+
+### 3. Quantum Chemistry
+
+Simulate molecules and compute ground state energies. See `references/quantum_chemistry.md` for:
+- Molecular Hamiltonian generation
+- Variational Quantum Eigensolver (VQE)
+- UCCSD ansatz for chemistry
+- Geometry optimization and dissociation curves
+- Molecular property calculations
+
+### 4. Device Management
+
+Execute on simulators or quantum hardware. See `references/devices_backends.md` for:
+- Built-in simulators (default.qubit, lightning.qubit, default.mixed)
+- Hardware plugins (IBM, Amazon Braket, Google, Rigetti, IonQ)
+- Device selection and configuration
+- Performance optimization and caching
+- GPU acceleration and JIT compilation
+
+### 5. Optimization
+
+Train quantum circuits with various optimizers. See `references/optimization.md` for:
+- Built-in optimizers (Adam, gradient descent, momentum, RMSProp)
+- Gradient computation methods (backprop, parameter-shift, adjoint)
+- Variational algorithms (VQE, QAOA)
+- Training strategies (learning rate schedules, mini-batches)
+- Handling barren plateaus and local minima
+
+### 6. Advanced Features
+
+Leverage templates, transforms, and compilation. See `references/advanced_features.md` for:
+- Circuit templates and layers
+- Transforms and circuit optimization
+- Pulse-level programming
+- Catalyst JIT compilation
+- Noise models and error mitigation
+- Resource estimation
+
+## Common Workflows
+
+### Train a Variational Classifier
+
+```python
+# 1. Define ansatz
+@qml.qnode(dev)
+def classifier(x, weights):
+    # Encode data
+    qml.AngleEmbedding(x, wires=range(4))
+
+    # Variational layers
+    qml.StronglyEntanglingLayers(weights, wires=range(4))
+
+    return qml.expval(qml.PauliZ(0))
+
+# 2. Train
+opt = qml.AdamOptimizer(stepsize=0.01)
+weights = np.random.random((3, 4, 3))  # 3 layers, 4 wires
+
+for epoch in range(100):
+    for x, y in zip(X_train, y_train):
+        weights = opt.step(lambda w: (classifier(x, w) - y)**2, weights)
+```
+
+### Run VQE for Molecular Ground State
+
+```python
+from pennylane import qchem
+
+# 1. Build Hamiltonian
+symbols = ['H', 'H']
+coords = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.74])
+H, n_qubits = qchem.molecular_hamiltonian(symbols, coords)
+
+# 2. Define ansatz
+@qml.qnode(dev)
+def vqe_circuit(params):
+    qml.BasisState(qchem.hf_state(2, n_qubits), wires=range(n_qubits))
+    qml.UCCSD(params, wires=range(n_qubits))
+    return qml.expval(H)
+
+# 3. Optimize
+opt = qml.AdamOptimizer(stepsize=0.1)
+params = np.zeros(10, requires_grad=True)
+
+for i in range(100):
+    params, energy = opt.step_and_cost(vqe_circuit, params)
+    print(f"Step {i}: Energy = {energy:.6f} Ha")
+```
+
+### Switch Between Devices
+
+```python
+# Same circuit, different backends
+circuit_def = lambda dev: qml.qnode(dev)(circuit_function)
+
+# Test on simulator
+dev_sim = qml.device('default.qubit', wires=4)
+result_sim = circuit_def(dev_sim)(params)
+
+# Run on quantum hardware
+dev_hw = qml.device('qiskit.ibmq', wires=4, backend='ibmq_manila')
+result_hw = circuit_def(dev_hw)(params)
+```
+
+## Detailed Documentation
+
+For comprehensive coverage of specific topics, consult the reference files:
+
+- **Getting started**: `references/getting_started.md` - Installation, basic concepts, first steps
+- **Quantum circuits**: `references/quantum_circuits.md` - Gates, measurements, circuit patterns
+- **Quantum ML**: `references/quantum_ml.md` - Hybrid models, framework integration, QNNs
+- **Quantum chemistry**: `references/quantum_chemistry.md` - VQE, molecular Hamiltonians, chemistry workflows
+- **Devices**: `references/devices_backends.md` - Simulators, hardware plugins, device configuration
+- **Optimization**: `references/optimization.md` - Optimizers, gradients, variational algorithms
+- **Advanced**: `references/advanced_features.md` - Templates, transforms, JIT compilation, noise
+
+## Best Practices
+
+1. **Start with simulators** - Test on `default.qubit` before deploying to hardware
+2. **Use parameter-shift for hardware** - Backpropagation only works on simulators
+3. **Choose appropriate encodings** - Match data encoding to problem structure
+4. **Initialize carefully** - Use small random values to avoid barren plateaus
+5. **Monitor gradients** - Check for vanishing gradients in deep circuits
+6. **Cache devices** - Reuse device objects to reduce initialization overhead
+7. **Profile circuits** - Use `qml.specs()` to analyze circuit complexity
+8. **Test locally** - Validate on simulators before submitting to hardware
+9. **Use templates** - Leverage built-in templates for common circuit patterns
+10. **Compile when possible** - Use Catalyst JIT for performance-critical code
+
+## Resources
+
+- Official documentation: https://docs.pennylane.ai
+- Codebook (tutorials): https://pennylane.ai/codebook
+- QML demonstrations: https://pennylane.ai/qml/demonstrations
+- Community forum: https://discuss.pennylane.ai
+- GitHub: https://github.com/PennyLaneAI/pennylane
+