cue-ai 0.5.0 → 0.7.0

package/resources/skills/skills/rust/cross-compile/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: cross-compile
+description: Use when building a Rust binary for a different target — ARM, musl, Windows, Android — without setting up native toolchains.
+allowed-tools: Bash(cargo:*), Bash(cross:*), Bash(rustup:*), Bash(docker:*)
+---
+
+# cross — zero-fuss cross-compilation
+
+Wraps Docker containers with the right linkers/sysroots so you don't deal with them.
+
+## When to use
+- Static musl binary (deploy to Alpine / scratch container): `cross build --release --target x86_64-unknown-linux-musl`
+- aarch64 (Raspberry Pi, ARM server): `cross build --release --target aarch64-unknown-linux-gnu`
+- Windows from Linux/Mac: `cross build --release --target x86_64-pc-windows-gnu`
+- Test on a non-native target: `cross test --target <triple>`
+- Custom toolchain: `Cross.toml` at repo root to pin image / env vars
+
+## Prerequisites
+- cross (`cargo install cross --git https://github.com/cross-rs/cross`)
+- Docker (or Podman with `CROSS_CONTAINER_ENGINE=podman`)
+- The target installed once: `rustup target add <triple>` (cross handles the rest)
+
+## Notes
+- For `wasm32-unknown-unknown` use cargo directly with `--target` — cross isn't needed.
+- musl builds are larger statically; strip with `strip` or `[profile.release] strip = true`.
+- macOS targets from Linux are NOT supported by cross (licensing). Use a real Mac or GitHub Actions runner.

package/resources/skills/skills/rust/embedded/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: embedded
+description: Use when flashing, debugging, or developing for microcontrollers in Rust (Cortex-M, RISC-V, ESP32). Covers probe-rs, cargo-embed, defmt, embassy async runtime.
+allowed-tools: Bash(cargo:*), Bash(probe-rs:*), Bash(cargo-embed:*), Bash(cargo-binutils:*), Bash(rustup:*)
+---
+
+# Rust embedded — probe-rs + embassy
+
+Modern Rust embedded stack: probe-rs replaces OpenOCD, defmt replaces printf, embassy provides async on bare metal.
+
+## When to use
+- **Target setup** (Cortex-M example): `rustup target add thumbv7em-none-eabihf` (M4F) or `thumbv6m-none-eabi` (M0)
+- **Project layout**: `no_std` binary crate; `[build] target = "thumbv7em-none-eabihf"` in `.cargo/config.toml`
+- **HAL** (Hardware Abstraction Layer): pick per chip — `stm32f4xx-hal`, `rp2040-hal`, `esp-hal`, etc.
+- **Flash + run**: `cargo embed --release` (uses `Embed.toml` config, opens RTT terminal)
+- **Just flash**: `cargo flash --chip STM32F411VETx --release`
+- **Debug**: `probe-rs gdb --chip <name>` then connect with arm-none-eabi-gdb / VSCode probe-rs-debugger
+- **Logging on-device**: `defmt` + `defmt-rtt` — host-side decoded via `defmt-print` (probe-rs integrates it)
+- **Async on bare metal**: `embassy-executor` + `embassy-time` + `embassy-{stm32,rp,esp32}` — proper async without an OS
+- **Binary size analysis**: `cargo size --release` (needs `cargo-binutils` + `llvm-tools-preview`)
+
+## Prerequisites
+- cargo
+- probe-rs CLI (installs `probe-rs`, `cargo-embed`, `cargo-flash`)
+- `rustup component add llvm-tools-preview` + `cargo install cargo-binutils`
+- USB debugger: ST-Link, J-Link, CMSIS-DAP, Black Magic Probe, etc.
+- Linux: udev rules — see https://probe.rs/docs/getting-started/probe-setup/
+
+## Notes
+- `no_std` means no `std::*` — use `core::*` and `alloc::*` (if you opt into an allocator).
+- Panic behavior: declare one — `panic-halt`, `panic-probe`, `panic-rtt-target`. The linker errors if none.
+- Embassy vs RTIC: embassy = async-first, easier; RTIC = priority-based preemptive, deterministic. Pick by problem.
+- For ESP32 (Xtensa or RISC-V), use the `esp-rs` toolchain (espup) — the upstream rustc only covers RISC-V ESP32-C* parts.

package/resources/skills/skills/rust/error-handling/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: error-handling
+description: Use when designing Rust error types — choosing between thiserror (libraries) and anyhow (apps), wrapping foreign errors, returning Result from main.
+allowed-tools: Bash(cargo:*)
+---
+
+# Rust Error Handling
+
+Pick the right tool for the layer.
+
+## When to use
+- **Library crate**: define a typed error with `thiserror::Error` — callers should be able to `match` on variants.
+  ```rust
+  #[derive(thiserror::Error, Debug)]
+  pub enum MyError {
+      #[error("io: {0}")]    Io(#[from] std::io::Error),
+      #[error("bad input")]  BadInput,
+  }
+  ```
+- **Binary / app**: use `anyhow::Result<T>` for fast prototyping and `.context("doing X")` to add breadcrumbs.
+- **main**: return `anyhow::Result<()>` so `?` works at the top level — exit code becomes 1 on Err with a stderr trace.
+- **Propagate, don't `.unwrap()`**: use `?`. Reserve `.unwrap()` / `.expect("invariant: ...")` for things that genuinely cannot happen.
+- **Convert across layers**: `#[from]` in thiserror auto-implements `From`, so `?` upcasts without a `.map_err()`.
+
+## Prerequisites
+- cargo
+- crates: `thiserror`, `anyhow` (add via `cargo add`)
+
+## Notes
+- Don't expose anyhow in a library's public API — it erases type info and hurts downstream `match`-ability. Wrap with thiserror at the boundary.
+- `.expect()` messages should describe the broken invariant ("config loaded before this call"), not just restate the operation.
+- `Result<T, Box<dyn Error + Send + Sync>>` is the stdlib alternative to anyhow when you don't want a dep.

package/resources/skills/skills/rust/just-runner/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: just-runner
+description: Use when authoring or running project task recipes — Rust ecosystem's de-facto replacement for Make. Justfile syntax.
+allowed-tools: Bash(just:*)
+---
+
+# just — sane task runner
+
+Make without the tab/dependency-graph pain. Ubiquitous in Rust repos.
+
+## When to use
+- List recipes: `just` or `just --list`
+- Run a recipe: `just <name>` · pass args: `just test foo`
+- Recipe with deps: `release: test lint` runs test + lint first
+- Set vars: `just <var>=val build`
+- Project-local: `Justfile` at repo root
+- User-local: `~/.justfile` (run with `just -g`)
+
+## Prerequisites
+- just (distro pkg preferred — apt/brew/pacman/dnf all have it)
+
+## Notes
+- Default shell is `sh` on Unix, `cmd` on Windows. Set `set shell := ["bash", "-uc"]` at the top of the Justfile for portable bash semantics.
+- Use `@` prefix to silence the recipe echo (`@cargo test`).
+- For Rust projects, common recipes: `check`, `test`, `lint` (= `cargo clippy --all -- -D warnings`), `fmt`, `ci` (= chain of all of the above).
+- Don't reinvent: if a `Justfile` exists, run those recipes rather than re-typing cargo flags.

package/resources/skills/skills/rust/mdbook/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: mdbook
+description: Use when authoring Rust project documentation as a static site — Rust Book / The Cargo Book / clap docs style.
+allowed-tools: Bash(mdbook:*)
+---
+
+# mdbook
+
+Markdown → static HTML site. The standard for Rust ecosystem long-form docs.
+
+## When to use
+- New book: `mdbook init <dir>` (or in place: `mdbook init`)
+- Dev server with live reload: `mdbook serve --open`
+- Build: `mdbook build` → outputs to `book/`
+- Test code samples in the book compile: `mdbook test`
+- Lint links: `mdbook-linkcheck` (separate preprocessor crate)
+
+## Prerequisites
+- mdbook
+
+## Notes
+- Chapter list lives in `src/SUMMARY.md` — order there controls sidebar order.
+- Code fences default to `rust` and get `mdbook test`'ed when language is `rust` (not `rust,ignore`).
+- For API-reference style docs, prefer `cargo doc` — mdbook is for prose / tutorials.
+- Deploy `book/` directly to GitHub Pages, Netlify, or any static host.

package/resources/skills/skills/rust/napi-rs/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: napi-rs
+description: Use when exposing Rust to Node.js — write a native addon via N-API. The path NextSwc, Parcel, and Prisma's query engine take.
+allowed-tools: Bash(cargo:*), Bash(napi:*), Bash(npm:*), Bash(node:*)
+---
+
+# napi-rs — Rust → Node.js native addons
+
+Stable ABI (N-API), no rebuild on Node version bumps. Cross-platform binaries shipped via per-platform npm packages.
+
+## When to use
+- **Init**: `npx @napi-rs/cli new my-addon` (asks for target platforms, tooling)
+- **Expose a fn**:
+  ```rust
+  use napi_derive::napi;
+  #[napi] fn sum(a: i32, b: i32) -> i32 { a + b }
+  #[napi] async fn read_file(path: String) -> napi::Result<String> { Ok(tokio::fs::read_to_string(path).await?) }
+  ```
+- **Build local**: `napi build --platform --release`
+- **Run JS**: `import { sum } from './index.js'; console.log(sum(2,3));`
+- **Multi-platform release**: GitHub Actions matrix builds per-target binaries; CLI publishes platform-suffixed packages (`@scope/my-addon-linux-x64-gnu`) plus a parent that picks the right one at install time.
+- **TypeScript**: `.d.ts` is auto-generated from `#[napi]` annotations
+
+## Prerequisites
+- cargo
+- Node 16+ and npm/pnpm/yarn
+- `@napi-rs/cli` (npm install -g or via npx)
+
+## Notes
+- Async functions return Promises automatically — no manual `napi::JsFunction` wrapping needed.
+- The N-API surface is small but stable; you don't get full V8 access (use `neon` if you need that, but neon is less stable across Node versions).
+- For pure-JS interop without native addons, look at `wasm-bindgen` + `wasm-pack --target nodejs` — slower but no per-platform binaries.

package/resources/skills/skills/rust/no-std/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: no-std
+description: Use when writing Rust without the standard library — embedded, WASM, kernel, bootloader, or library code that must work in `no_std` consumers.
+allowed-tools: Bash(cargo:*)
+---
+
+# `#![no_std]` — Rust without std
+
+`std` = `core` + `alloc` + OS bindings. Removing std loses heap allocation, threads, file I/O, and networking. You keep types, iterators, slices, traits.
+
+## When to use
+- **Mark the crate**: `#![no_std]` at the top of `lib.rs` or `main.rs`
+- **Use `core::*` and `alloc::*`** instead of `std::*`:
+  ```rust
+  use core::fmt::Write;
+  extern crate alloc;
+  use alloc::{vec::Vec, string::String, boxed::Box};
+  ```
+- **Provide an allocator** (if you want `alloc`): `#[global_allocator] static A: MyAlloc = MyAlloc;` (heap crate per target, e.g. `embedded-alloc` for Cortex-M)
+- **Panic handler**: pick one and add as a dep — `panic-halt`, `panic-abort`, or roll your own `#[panic_handler] fn panic(_: &PanicInfo) -> ! { loop {} }`
+- **Cargo features for std/no-std libraries**:
+  ```toml
+  [features]
+  default = ["std"]
+  std = []
+  ```
+  Then in code: `#![cfg_attr(not(feature = "std"), no_std)]`
+- **Common substitutes**:
+  - `std::collections::HashMap` → `hashbrown::HashMap` (with `alloc`) or fixed-size `heapless::IndexMap`
+  - `std::sync::Mutex` → `spin::Mutex` (spinlock) or `critical-section::Mutex` (interrupt-safe)
+  - `std::format!` → `heapless::String` + `core::fmt::Write` (no allocations)
+  - `std::error::Error` → not in core; use `core::error::Error` (stable 1.81+) or `snafu`/`thiserror-no-std`
+
+## Prerequisites
+- cargo
+- A target without std (or std intentionally excluded): `wasm32-unknown-unknown`, any `thumbv*`, `riscv*-none-elf`
+
+## Notes
+- **Audit deps**: many crates have a `default-features = false` flag that disables std — set it explicitly. `cargo tree -e features` shows where std leaks back in.
+- `heapless` crate provides `Vec<T, N>` and `String<N>` with const-generic capacity — no allocator needed.
+- For libraries published to crates.io, gating `std` behind a feature is the polite default — downstream embedded users will love you.
+- WASM `wasm32-unknown-unknown` has no OS, so `std::fs` / `std::net` / `std::thread` panic at runtime even though they compile. Treat as effectively no_std.

package/resources/skills/skills/rust/property-testing/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: property-testing
+description: Use when testing parsers, serializers, math/algorithms, anything with invariants — generate thousands of inputs and check properties hold. Covers proptest and quickcheck.
+allowed-tools: Bash(cargo:*)
+---
+
+# proptest / quickcheck — property-based testing
+
+Instead of "for these 3 inputs, output is X", you state "for ALL inputs, this property holds" and the framework hunts counter-examples.
+
+## When to use
+- **Setup proptest**: dev-dep `proptest`; test wrapper:
+  ```rust
+  use proptest::prelude::*;
+  proptest! {
+      #[test]
+      fn roundtrip(s in "\\PC*") {
+          let parsed: MyStruct = s.parse().unwrap();
+          prop_assert_eq!(parsed.to_string(), s);
+      }
+  }
+  ```
+- **Common strategies**: `any::<u32>()`, `0..1000usize`, `prop::collection::vec(any::<u8>(), 0..100)`, regex strings `"\\PC*"`
+- **Shrinking**: framework auto-shrinks failing inputs to a minimal counter-example (proptest's killer feature)
+- **Persistent failures**: `proptest-regressions/*.txt` files lock in past failures — commit them
+- **Quickcheck alternative**: simpler API, no shrinking config — `#[quickcheck] fn p(xs: Vec<i32>) -> bool { ... }`
+
+## Prerequisites
+- cargo
+- dev-dep: `proptest` or `quickcheck` + `quickcheck_macros`
+
+## Notes
+- Property tests pair perfectly with `serde` roundtrip (serialize → deserialize → equal?), parsers (parse → display → reparse → equal?), and algorithmic invariants (sort → is sorted, original len, same multiset).
+- Slow (~100ms+ per case × 256 cases). Don't put property tests in tight inner-loop CI; mark with `#[ignore]` and run separately if they get heavy.
+- proptest's regression files are gold — they replay yesterday's bug for free.

package/resources/skills/skills/rust/pyo3/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: pyo3
+description: Use when exposing Rust code to Python — write a CPython extension module in Rust, ship as a wheel via maturin.
+allowed-tools: Bash(cargo:*), Bash(maturin:*), Bash(python:*), Bash(pip:*)
+---
+
+# PyO3 + maturin — Rust → Python
+
+Used by `cryptography`, `polars`, `tokenizers`, `pydantic-core`. The path for "Rust speed in Python".
+
+## When to use
+- **Init**: `maturin new --bindings pyo3 my_ext`
+- **Cargo.toml**:
+  ```toml
+  [lib]
+  crate-type = ["cdylib"]
+  [dependencies]
+  pyo3 = { version = "0.22", features = ["extension-module"] }
+  ```
+- **Expose a fn**:
+  ```rust
+  use pyo3::prelude::*;
+  #[pyfunction] fn sum(a: i64, b: i64) -> i64 { a + b }
+  #[pymodule]   fn my_ext(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(sum, m)?)?; Ok(()) }
+  ```
+- **Develop loop**: `maturin develop --release` installs into the active venv; `import my_ext; my_ext.sum(2,3)`
+- **Build wheel**: `maturin build --release` → `target/wheels/*.whl`
+- **Publish to PyPI**: `maturin publish` (or `maturin upload`)
+- **Async** (call async Rust from Python): `pyo3-asyncio` integrates tokio with Python's asyncio
+
+## Prerequisites
+- cargo
+- Python 3.8+ in a venv (recommended) or system Python
+- maturin (`pipx install maturin`)
+
+## Notes
+- Use a venv — `maturin develop` installs INTO whatever Python is active. Wrong env = wrong wheel installed.
+- For multi-Python-version wheels: `maturin build --release --interpreter python3.10 python3.11 python3.12` or use `cibuildwheel` in CI.
+- GIL handling: `Python::with_gil(|py| ...)` for any PyObject work. Release the GIL during pure Rust compute with `py.allow_threads(|| ...)`.
+- Distribute as `abi3` (stable ABI) via `pyo3 = { features = ["abi3-py38"] }` so ONE wheel covers Python 3.8+.

package/resources/skills/skills/rust/ratatui-tui/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: ratatui-tui
+description: Use when building a Rust terminal UI (TUI) — dashboards, file managers, monitors. Covers ratatui (the standard) + crossterm.
+allowed-tools: Bash(cargo:*)
+---
+
+# ratatui — Rust TUI framework
+
+Successor to `tui-rs`. Powers `bottom`, `gitui`, `atuin`, `oha`, `lazygit`'s Rust clones, etc.
+
+## When to use
+- **Setup**: `ratatui = "0.28"`, `crossterm = "0.28"` (default backend)
+- **Skeleton**:
+  ```rust
+  let mut terminal = ratatui::init();
+  loop {
+      terminal.draw(|f| ui(f, &state))?;
+      if let Event::Key(k) = crossterm::event::read()? { handle(k, &mut state); }
+      if state.should_quit { break; }
+  }
+  ratatui::restore();
+  ```
+- **Widgets**: `Block`, `Paragraph`, `List`, `Table`, `Gauge`, `Chart`, `Tabs`, `Sparkline`, `Canvas`
+- **Layout**: `Layout::new(Direction::Vertical, [Constraint::Length(3), Constraint::Min(0)])`
+- **State**: stateful widgets (`ListState`, `TableState`) — pass `&mut state` to `render_stateful_widget`
+- **Async**: spawn a `tokio` task that pushes events into an mpsc; the render loop selects between input + tick + app events
+
+## Prerequisites
+- cargo
+- crates: `ratatui`, `crossterm`
+
+## Notes
+- Always pair `ratatui::init()` with `ratatui::restore()` — set a panic hook to call `restore()` or your terminal stays in raw mode after a crash.
+- Don't redraw every event — throttle to ~30-60 fps or only on dirty state. Otherwise input latency degrades on slow terminals.
+- For complex apps, look at `tui-realm` (component model) or `cursive` (different paradigm, less popular).
+- Test renders with `ratatui::backend::TestBackend` — captures the buffer for snapshot assertions.

package/resources/skills/skills/rust/release-plz/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: release-plz
+description: Use when automating crates.io releases for a workspace — version bumps, CHANGELOG generation, GitHub Release PRs based on Conventional Commits.
+allowed-tools: Bash(cargo:*), Bash(release-plz:*), Bash(git:*), Bash(gh:*)
+---
+
+# release-plz — automated release PRs
+
+Reads Conventional Commits, bumps versions, generates CHANGELOG.md, opens a release PR. Merge → publishes to crates.io and tags GitHub release.
+
+## When to use
+- **One-time setup**: install + run `release-plz init` at the workspace root
+- **Manual local dry-run**: `release-plz update` (writes Cargo.toml + CHANGELOG.md changes, no push)
+- **GitHub Actions** (the typical path): drop the official workflow at `.github/workflows/release-plz.yml` — needs `CARGO_REGISTRY_TOKEN` secret + a PAT with PR/contents write
+- **Per-crate config**: `release-plz.toml` to tweak version bumps, changelog body templates, dependency-update strategy
+- **Skip a crate**: `[[package]] name = "internal" release = false`
+
+## Prerequisites
+- release-plz CLI
+- Conventional Commit messages (`feat:`, `fix:`, `chore:`, breaking via `!:` or footer `BREAKING CHANGE:`)
+- crates.io account + token
+
+## Notes
+- Replaces `cargo-release` for most workspaces. `cargo-release` is still useful for hand-curated releases.
+- Generated PRs are idempotent — push more commits, the PR updates.
+- For pre-1.0 crates, configure `[workspace] semver-check = false` in release-plz.toml to allow breaking bumps without yanking 1.x rules.
+- Combine with the `commit-message-guard` hook in cue's core profile to enforce Conventional Commits.

package/resources/skills/skills/rust/reqwest/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: reqwest
+description: Use when making HTTP requests from Rust — JSON APIs, file downloads, streaming. Covers reqwest (async), reqwest-middleware for retries, blocking variant, hyper for low-level.
+allowed-tools: Bash(cargo:*)
+---
+
+# reqwest — Rust HTTP client
+
+The default high-level client. Async via tokio; blocking feature flag for sync.
+
+## When to use
+- **Setup**: `reqwest = { version = "0.12", features = ["json", "rustls-tls"] }` (prefer rustls — pure-Rust, no openssl headache)
+- **GET JSON**:
+  ```rust
+  let user: User = reqwest::get(url).await?.json().await?;
+  ```
+- **POST JSON + auth**:
+  ```rust
+  let client = reqwest::Client::new();
+  let res = client.post(url).bearer_auth(token).json(&body).send().await?.error_for_status()?;
+  ```
+- **Streaming download**: `.bytes_stream()` returns a `Stream<Item = Result<Bytes>>`
+- **Multipart upload**: `reqwest::multipart::Form::new().file("field", path).await?`
+- **Reuse the client**: build once, clone everywhere (it's `Arc` internally). Don't `Client::new()` per call.
+- **Retries / circuit-break**: `reqwest-middleware` + `reqwest-retry` for exponential backoff
+- **Blocking**: enable `blocking` feature, use `reqwest::blocking::Client` (good for CLIs without tokio)
+- **Low-level**: drop to `hyper` only when you need raw HTTP/2 frames, custom connectors, or extreme perf
+
+## Prerequisites
+- cargo
+- crates: `reqwest` (+ features), usually `tokio` and `serde_json`
+
+## Notes
+- `.error_for_status()?` turns 4xx/5xx into `Err` — chain after `send()` unless you explicitly handle the body of error responses.
+- For self-signed TLS in dev: `.danger_accept_invalid_certs(true)`. Never in prod.
+- `reqwest::Client` holds a connection pool — don't disable it (pool size defaults are fine).
+- For unit tests: `wiremock` or `mockito` to spin up a fake server; don't mock reqwest itself.

package/resources/skills/skills/rust/sccache/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: sccache
+description: Use when Rust cold builds are slow, CI rebuild times hurt, or switching branches forces full recompiles. Drop-in compiler cache.
+allowed-tools: Bash(cargo:*), Bash(sccache:*)
+---
+
+# sccache
+
+Caches rustc outputs (and gcc/clang). Big wins on CI and branch switching.
+
+## When to use
+- One-shot: `RUSTC_WRAPPER=sccache cargo build`
+- Persistent (project): `.cargo/config.toml` →
+  ```toml
+  [build]
+  rustc-wrapper = "sccache"
+  ```
+- Persistent (shell): `export RUSTC_WRAPPER=sccache` in `~/.bashrc` / `~/.zshrc`
+- Inspect: `sccache --show-stats`
+- Cloud cache backends: `SCCACHE_BUCKET=...` (S3), `SCCACHE_GCS_BUCKET=...`, `SCCACHE_REDIS=...`
+
+## Prerequisites
+- sccache (`cargo install sccache --locked` or distro package)
+
+## Notes
+- Does NOT help with incremental rebuilds in the same workspace — those already work. Wins are cross-branch and cross-machine (CI).
+- Don't enable both sccache and `[profile.dev] incremental = true` cache hits will conflict; sccache works best with incremental disabled in CI.
+- Local-only filesystem cache lives in `~/.cache/sccache`.

package/resources/skills/skills/rust/serde/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: serde
+description: Use when (de)serializing Rust data to JSON, TOML, YAML, MessagePack, etc. Covers derive macros, attributes, custom (de)serializers, common lifetime/Cow gotchas.
+allowed-tools: Bash(cargo:*)
+---
+
+# serde — universal serialization
+
+The Rust ecosystem's standard. Every non-trivial project pulls it in.
+
+## When to use
+- **JSON**: `serde` + `serde_json`. Derive: `#[derive(Serialize, Deserialize)]`
+- **TOML/YAML**: swap `serde_json` for `toml` / `serde_yaml` (or `serde_yml`)
+- **Binary**: `bincode`, `rmp-serde` (MessagePack), `postcard` (no_std)
+- **Field rename**: `#[serde(rename = "fooBar")]` · case style: `#[serde(rename_all = "camelCase")]`
+- **Optional field**: `Option<T>` + `#[serde(skip_serializing_if = "Option::is_none")]`
+- **Default on missing**: `#[serde(default)]` or `#[serde(default = "my_fn")]`
+- **Enum repr**: `#[serde(tag = "type")]` (internally tagged), `#[serde(untagged)]` (try each variant)
+- **Flatten nested**: `#[serde(flatten)]` for `{ "inner": {...} }` → flat shape
+- **Custom (de)serializer per field**: `#[serde(deserialize_with = "path")]`
+
+## Prerequisites
+- cargo
+- crates: `serde = { version = "1", features = ["derive"] }`, plus a format crate
+
+## Notes
+- For zero-copy deserialization, use `&'a str` / `Cow<'a, str>` and add `#[serde(borrow)]` — saves allocs when the source bytes outlive the struct.
+- `#[serde(untagged)]` is convenient but slow (tries each variant); prefer `tag` when possible.
+- `serde_json::Value` is the escape hatch for unknown shapes; downcast to concrete types ASAP for perf and clarity.
+- For numbers from JSON: deserialize into `f64`/`i64` and convert — JSON has no native int/float distinction.

package/resources/skills/skills/rust/snapshot-testing/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: snapshot-testing
+description: Use when testing CLI output, API responses, rendered templates, error messages — anything where the assertion is "output looks like this big chunk of text". Covers cargo-insta.
+allowed-tools: Bash(cargo:*), Bash(cargo-insta:*)
+---
+
+# insta — snapshot testing
+
+Saves the first run's output as a `.snap` file; future runs diff against it. Eliminates dozens of brittle `assert_eq!` lines.
+
+## When to use
+- **In a test**: `insta::assert_snapshot!(rendered)` (plain text) · `assert_debug_snapshot!(value)` (Debug) · `assert_json_snapshot!(value)` (serde Serialize → JSON)
+- **First run + accept**: `cargo insta test --review` — diffs new snaps interactively
+- **Auto-accept (CI bootstrap)**: `INSTA_UPDATE=always cargo test`
+- **Redactions** (mask non-deterministic fields like timestamps/uuids):
+  ```rust
+  insta::assert_json_snapshot!(response, { ".id" => "[id]", ".created_at" => "[ts]" });
+  ```
+- **Inline snapshots** (small values, lives in the test file): `assert_snapshot!(value, @"expected text");`
+
+## Prerequisites
+- cargo
+- crate: `insta`
+- CLI: `cargo-insta` (for `cargo insta review/test`)
+
+## Notes
+- Commit `.snap` files. They ARE the assertion.
+- `cargo insta review` workflow: run tests → see diffs → press `a` to accept or `r` to reject per snapshot.
+- For HTTP API tests, pair with `wiremock`/`mockito` for fixtures and snapshot the response body.
+- Don't snapshot wall-clock timestamps or random IDs — redact them or inject a deterministic clock/RNG.

package/resources/skills/skills/rust/sqlx-cli/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: sqlx-cli
+description: Use when managing database migrations or query caching for a Rust app using sqlx, sea-orm, or diesel.
+allowed-tools: Bash(cargo:*), Bash(sqlx:*), Bash(sea-orm-cli:*), Bash(diesel:*)
+---
+
+# Rust DB Tooling
+
+Migration + ORM CLIs.
+
+## When to use
+- **sqlx** (compile-time-checked queries, no ORM):
+  - Init: `sqlx database create` (uses `DATABASE_URL`)
+  - New migration: `sqlx migrate add <name>` (or `--source migrations/`)
+  - Apply: `sqlx migrate run`
+  - Offline cache (so build doesn't need live DB): `cargo sqlx prepare`
+- **SeaORM** (full async ORM):
+  - Generate entities from DB: `sea-orm-cli generate entity -o src/entity`
+  - Migration: `sea-orm-cli migrate init` then `sea-orm-cli migrate up`
+- **Diesel** (sync, mature, schema-first):
+  - Setup: `diesel setup`
+  - New migration: `diesel migration generate <name>`
+  - Apply: `diesel migration run`
+
+## Prerequisites
+- sqlx-cli (with features matching your DB), sea-orm-cli, or diesel_cli
+- `DATABASE_URL` env var (sqlx, diesel) or a `cli` config (SeaORM)
+- For diesel: `libpq-dev` (postgres) or `libmysqlclient-dev` (mysql) build deps
+
+## Notes
+- sqlx's compile-time check is great but requires either a live DB at build time OR `cargo sqlx prepare` committing `.sqlx/` cache files. Commit them.
+- Don't mix migration systems — pick one per project.
+- For brand-new projects with an async stack, sqlx is the lightest path. SeaORM is the choice when you actually want an ORM. Diesel is sync — fine for CLI tools, awkward in async services.

package/resources/skills/skills/rust/tracing/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: tracing
+description: Use when adding logging, structured logs, spans, or live runtime introspection to a Rust app. Covers tracing, tracing-subscriber, tokio-console, OpenTelemetry.
+allowed-tools: Bash(cargo:*), Bash(tokio-console:*)
+---
+
+# tracing — modern Rust observability
+
+Replaces `log` for new code. Structured + async-aware (spans cross await points).
+
+## When to use
+- **Setup**: `tracing` + `tracing-subscriber`. Init at start of `main`:
+  ```rust
+  tracing_subscriber::fmt()
+      .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+      .init();
+  ```
+- **Emit**: `tracing::{trace, debug, info, warn, error}!("msg {field}", field = value)`
+- **Structured fields**: `info!(user_id = %uuid, count = 5, "request done");`
+- **Spans**: `let _s = tracing::info_span!("op", id = %req_id).entered();` (sync) or `.instrument(span)` on a future (async)
+- **Auto-instrument fns**: `#[tracing::instrument]` macro
+- **JSON logs** (for prod): `tracing_subscriber::fmt().json().init()`
+- **Filter via env**: `RUST_LOG=info,my_crate=debug,hyper=warn`
+- **Runtime introspection**: enable `console-subscriber` + `RUSTFLAGS="--cfg tokio_unstable"`, then run `tokio-console`
+- **OpenTelemetry export**: `tracing-opentelemetry` + `opentelemetry-otlp` for OTLP/Jaeger/Tempo
+
+## Prerequisites
+- cargo
+- crates: `tracing`, `tracing-subscriber`
+- For runtime view: `tokio-console` CLI + `console-subscriber` crate
+
+## Notes
+- `%value` = use Display; `?value` = use Debug; bare `value` = use the trait it implements.
+- Spans propagate across `.await` only if you `.instrument(span)` the future explicitly — otherwise context is lost at the suspend point.
+- Don't `#[instrument]` hot-path fns — span overhead adds up. Reserve for request-level boundaries.
+- For libraries: emit tracing events, don't init a subscriber. Subscriber init is the binary's job.

package/resources/skills/skills/rust/typos-spellcheck/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: typos-spellcheck
+description: Use when spell-checking Rust source, docs, comments — `typos` CLI catches common misspellings without false positives on code identifiers.
+allowed-tools: Bash(typos:*)
+---
+
+# typos — source-code spellcheck
+
+Fast (Rust-written, walks ignoring `.gitignore` + `target/`), accurate (curated dict + identifier-aware).
+
+## When to use
+- **Check current dir**: `typos`
+- **Auto-fix**: `typos --write-changes` (or `-w`)
+- **Specific files**: `typos src/lib.rs README.md`
+- **Diff-only** (CI on PRs): `typos --diff`
+- **Config file** (`typos.toml` or `_typos.toml` at repo root):
+  ```toml
+  [default.extend-words]
+  abbrv = "abbrv"          # allow this spelling
+  [files]
+  extend-exclude = ["vendored/**", "*.snap"]
+  ```
+
+## Prerequisites
+- typos (`cargo install typos-cli --locked` or distro pkg)
+
+## Notes
+- Default dict is curated — false-positive rate is genuinely low. Add false positives to `extend-words` rather than disabling.
+- Use `# typos: ignore line` (or `// typos: ignore line`) to silence one occurrence.
+- Wire as both a pre-commit hook and a CI job; the auto-fix output makes it cheap to keep clean.
+- For prose-only checks (style, grammar), reach for `vale` instead — typos is intentionally narrow.

package/resources/skills/skills/rust/uniffi/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: uniffi
+description: Use when exposing one Rust library to multiple languages (Kotlin/Swift/Python/Ruby) from a single UDL spec. Mozilla's approach; used by Bitwarden, Matrix SDK.
+allowed-tools: Bash(cargo:*), Bash(uniffi-bindgen:*)
+---
+
+# UniFFI — one Rust → many languages
+
+Write the interface once (`.udl` or proc-macro), generate idiomatic Kotlin/Swift/Python/Ruby bindings. Avoids hand-writing JNI/JNA + Swift-C-bridge + ctypes for each platform.
+
+## When to use
+- **Proc-macro flavor** (newer, no .udl file):
+  ```rust
+  #[uniffi::export]
+  pub fn add(a: i32, b: i32) -> i32 { a + b }
+  uniffi::setup_scaffolding!();
+  ```
+  Cargo.toml: `crate-type = ["cdylib", "staticlib"]` + `uniffi` dep + `[build-dependencies] uniffi = { features = ["build"] }`
+- **Generate bindings**:
+  ```sh
+  cargo build --release
+  uniffi-bindgen generate --library target/release/libmylib.so --language kotlin --out-dir out/kotlin
+  uniffi-bindgen generate --library ... --language swift   --out-dir out/swift
+  uniffi-bindgen generate --library ... --language python  --out-dir out/python
+  ```
+- **iOS**: build for `aarch64-apple-ios` + `x86_64-apple-ios-sim` + lipo into XCFramework
+- **Android**: `cargo-ndk` to cross-compile for `aarch64-linux-android` etc.
+
+## Prerequisites
+- cargo
+- uniffi-bindgen CLI (`cargo install uniffi-bindgen`)
+- Per-target toolchains for the languages you generate
+
+## Notes
+- Mature & production-proven (Mozilla, Bitwarden, Matrix SDK ship UniFFI bindings).
+- Type support is opinionated — primitives, strings, Vec, Option, HashMap, custom records/enums. Closures and traits work but with caveats.
+- For one-target FFI (just Python), prefer PyO3 or just Node, prefer napi-rs — UniFFI shines when you need ≥2 targets from one codebase.
+- The proc-macro flavor is now stable; new projects shouldn't use UDL files.