opencode-skills-collection 3.1.12 → 3.1.14

package/bundled-skills/azure-servicebus-rust/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: azure-servicebus-rust
+description: 'Azure Service Bus library for Rust. Send and receive messages using queues, topics, and subscriptions. Triggers: "service bus rust", "ServiceBusClient rust", "send message servicebus rust", "receive message servicebus rust", "queue rust messaging", "topic subscription rust".'
+risk: unknown
+source: https://github.com/microsoft/skills/tree/main/.github/plugins/azure-sdk-rust/skills/azure-servicebus-rust
+source_repo: microsoft/skills
+source_type: official
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/microsoft/skills/blob/main/LICENSE
+---
+
+# Azure Service Bus library for Rust
+## When to Use
+
+Use this skill when you need azure Service Bus library for Rust. Send and receive messages using queues, topics, and subscriptions. Triggers: "service bus rust", "ServiceBusClient rust", "send message servicebus rust", "receive message servicebus rust", "queue rust messaging", "topic subscription rust".
+
+
+Client library for Azure Service Bus — enterprise message broker with queues and publish-subscribe topics.
+
+> **⚠️ WARNING:** This crate is in early development and **SHOULD NOT** be used in production. APIs may change without notice.
+
+Use this skill when:
+
+- An app needs to send or receive messages via Azure Service Bus from Rust
+- You need queue-based messaging with competing consumers
+- You need publish-subscribe messaging with topics and subscriptions
+- You need reliable message delivery with completion semantics
+
+> **IMPORTANT:** Only use the official `azure_messaging_servicebus` crate published by the [azure-sdk](https://crates.io/users/azure-sdk) crates.io user. Do NOT use unofficial or community crates. Official crates use underscores in names and none have version 0.21.0.
+
+## Installation
+
+```sh
+cargo add azure_messaging_servicebus azure_identity tokio
+```
+
+> If your code uses `azure_core` types directly, add `azure_core` to `Cargo.toml`. If you only use `azure_messaging_servicebus` re-exports, direct `azure_core` dependency is optional.
+
+## Environment Variables
+
+```bash
+SERVICEBUS_NAMESPACE=<namespace>.servicebus.windows.net # Required — fully qualified namespace
+```
+
+## Key Concepts
+
+| Concept          | Description                                                     |
+| ---------------- | --------------------------------------------------------------- |
+| **Namespace**    | Container for all messaging components                          |
+| **Queue**        | Point-to-point messaging with competing consumers               |
+| **Topic**        | Publish-subscribe messaging — one sender, many subscribers      |
+| **Subscription** | Receives messages from a topic                                  |
+| **Message**      | Package of data and metadata, with completion/abandon semantics |
+
+## Authentication
+
+```rust
+use azure_identity::DeveloperToolsCredential;
+use azure_messaging_servicebus::ServiceBusClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.
+    let credential = DeveloperToolsCredential::new(None)?;
+    let client = ServiceBusClient::builder()
+        .open("your_namespace.servicebus.windows.net", credential.clone())
+        .await?;
+    Ok(())
+}
+```
+
+## Core Workflow
+
+### Send a Message to a Queue
+
+```rust
+use azure_identity::DeveloperToolsCredential;
+use azure_messaging_servicebus::{ServiceBusClient, Message};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let credential = DeveloperToolsCredential::new(None)?;
+    let client = ServiceBusClient::builder()
+        .open("your_namespace.servicebus.windows.net", credential.clone())
+        .await?;
+    let sender = client.create_sender("my_queue", None).await?;
+
+    let message = Message::from("Hello, Service Bus!");
+    sender.send_message(message, None).await?;
+    Ok(())
+}
+```
+
+### Receive Messages from a Queue
+
+```rust
+use azure_identity::DeveloperToolsCredential;
+use azure_messaging_servicebus::ServiceBusClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let credential = DeveloperToolsCredential::new(None)?;
+    let client = ServiceBusClient::builder()
+        .open("your_namespace.servicebus.windows.net", credential.clone())
+        .await?;
+    let receiver = client.create_receiver("my_queue", None).await?;
+
+    let messages = receiver.receive_messages(5, None).await?;
+    for message in messages {
+        println!("Received: {}", message.body_as_string()?);
+        receiver.complete_message(&message, None).await?;
+    }
+    Ok(())
+}
+```
+
+### Send a Message to a Topic
+
+```rust
+let sender = client.create_sender("my_topic", None).await?;
+let message = Message::from("Hello, Topic subscribers!");
+sender.send_message(message, None).await?;
+```
+
+### Receive Messages from a Subscription
+
+```rust
+let receiver = client
+    .create_receiver_for_subscription("my_topic", "my_subscription", None)
+    .await?;
+
+let messages = receiver.receive_messages(5, None).await?;
+for message in messages {
+    println!("Received: {}", message.body_as_string()?);
+    receiver.complete_message(&message, None).await?;
+}
+```
+
+## Message Settlement
+
+| Action     | Purpose                                            |
+| ---------- | -------------------------------------------------- |
+| `complete` | Remove message from queue — processing succeeded   |
+| `abandon`  | Release lock — message becomes available for retry |
+
+Always complete messages after successful processing to prevent redelivery.
+
+## RBAC Roles
+
+For Entra ID auth, assign one of these roles:
+
+| Role                              | Access           |
+| --------------------------------- | ---------------- |
+| `Azure Service Bus Data Sender`   | Send messages    |
+| `Azure Service Bus Data Receiver` | Receive messages |
+| `Azure Service Bus Data Owner`    | Full access      |
+
+## Best Practices
+
+1. **Use `cargo add` to manage dependencies, never edit `Cargo.toml` directly.** Add and remove Rust SDK dependencies with cargo commands instead of manual manifest edits.
+2. **Add `azure_core` only when importing `azure_core` types directly.** If your code imports `azure_core::http::Url`, `azure_core::http::RequestContent`, or `azure_core::error::ErrorKind`, include `azure_core`; otherwise a direct dependency is optional.
+3. **Use `DeveloperToolsCredential`** for local dev, **`ManagedIdentityCredential`** for production — Rust does not provide a single `DefaultAzureCredential` type
+4. **Never hardcode credentials** — use environment variables or managed identity
+5. **Assign RBAC roles** — ensure the identity has appropriate Service Bus data roles
+6. **Always complete messages** — call `complete_message` after processing to remove from queue
+7. **Use topics for fan-out** — when multiple consumers need the same messages, use topics with subscriptions
+8. **This crate is pre-production** — APIs may change; pin your dependency version with cargo commands in your dependency workflow
+
+## Reference Links
+
+| Resource      | Link                                                                                            |
+| ------------- | ----------------------------------------------------------------------------------------------- |
+| API Reference | https://docs.rs/azure_messaging_servicebus/latest/azure_messaging_servicebus                    |
+| crates.io     | https://crates.io/crates/azure_messaging_servicebus                                             |
+| Source Code   | https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/servicebus/azure_messaging_servicebus |
+
+## 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/azure-storage-queue-rust/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: azure-storage-queue-rust
+description: 'Azure Queue Storage library for Rust. Send, receive, and manage queue messages. Triggers: "queue storage rust", "QueueClient rust", "send message rust", "receive messages rust", "QueueServiceClient rust", "queue rust".'
+risk: unknown
+source: https://github.com/microsoft/skills/tree/main/.github/plugins/azure-sdk-rust/skills/azure-storage-queue-rust
+source_repo: microsoft/skills
+source_type: official
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/microsoft/skills/blob/main/LICENSE
+---
+
+# Azure Queue Storage library for Rust
+## When to Use
+
+Use this skill when you need azure Queue Storage library for Rust. Send, receive, and manage queue messages. Triggers: "queue storage rust", "QueueClient rust", "send message rust", "receive messages rust", "QueueServiceClient rust", "queue rust".
+
+
+Client library for Azure Queue Storage — send, receive, and manage queue messages.
+
+Use this skill when:
+
+- An app needs to send or receive messages from Azure Queue Storage in Rust
+- You need to create or manage queues
+- You need to peek, receive, or delete queue messages
+- You need RBAC-based auth for queue operations
+
+> **IMPORTANT:** Only use the official `azure_storage_queue` crate published by the [azure-sdk](https://crates.io/users/azure-sdk) crates.io user. Do NOT use unofficial or community crates. Official crates use underscores in names and none have version 0.21.0.
+
+## Installation
+
+```sh
+cargo add azure_storage_queue azure_identity azure_core tokio
+```
+
+> If your code uses `azure_core` types directly, add `azure_core` to `Cargo.toml`. If you only use `azure_storage_queue` re-exports, direct `azure_core` dependency is optional.
+
+## Environment Variables
+
+```bash
+AZURE_STORAGE_QUEUE_ENDPOINT=https://<account>.queue.core.windows.net/ # Required for all operations
+```
+
+## Authentication
+
+```rust
+use azure_core::http::Url;
+use azure_identity::DeveloperToolsCredential;
+use azure_storage_queue::QueueServiceClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.
+    let credential = DeveloperToolsCredential::new(None)?;
+    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;
+    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;
+
+    // Derive a queue client by name.
+    let queue_client = service_client.queue_client("<queue_name>")?;
+    Ok(())
+}
+```
+
+## Client Types
+
+| Client               | Purpose                               | Access                                   |
+| -------------------- | ------------------------------------- | ---------------------------------------- |
+| `QueueServiceClient` | Account-level operations, list queues | `QueueServiceClient::new()`              |
+| `QueueClient`        | Queue operations, send/receive/delete | `service_client.queue_client("<name>")?` |
+
+## Core Workflow
+
+### Send a Message
+
+```rust
+use azure_core::http::Url;
+use azure_identity::DeveloperToolsCredential;
+use azure_storage_queue::{models::QueueMessage, QueueServiceClient};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let credential = DeveloperToolsCredential::new(None)?;
+    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;
+    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;
+    let queue_client = service_client.queue_client("<queue_name>")?;
+
+    let message = QueueMessage {
+        message_text: Some("hello world".to_string()),
+    };
+    queue_client.send_message(message.try_into()?, None).await?;
+    Ok(())
+}
+```
+
+### Receive Messages
+
+```rust
+use azure_core::http::Url;
+use azure_identity::DeveloperToolsCredential;
+use azure_storage_queue::QueueServiceClient;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let credential = DeveloperToolsCredential::new(None)?;
+    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;
+    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;
+    let queue_client = service_client.queue_client("<queue_name>")?;
+
+    let response = queue_client.receive_messages(None).await?;
+    let messages = response.into_model()?;
+    for msg in messages.items.unwrap_or_default() {
+        println!("{}", msg.message_text.as_deref().unwrap_or("<empty>"));
+    }
+    Ok(())
+}
+```
+
+### Delete a Message
+
+After receiving a message, delete it using the message ID and pop receipt:
+
+```rust
+let response = queue_client.receive_messages(None).await?;
+let messages = response.into_model()?;
+for msg in messages.items.unwrap_or_default() {
+    if let (Some(id), Some(pop_receipt)) = (&msg.message_id, &msg.pop_receipt) {
+        queue_client.delete_message(id, pop_receipt, None).await?;
+    }
+}
+```
+
+### Peek Messages
+
+Peek at messages without removing them from the queue:
+
+```rust
+let response = queue_client.peek_messages(None).await?;
+let messages = response.into_model()?;
+for msg in messages.items.unwrap_or_default() {
+    println!("Peeked: {}", msg.message_text.as_deref().unwrap_or("<empty>"));
+}
+```
+
+## RBAC Roles
+
+For Entra ID auth, assign one of these roles to the identity:
+
+| Role                                   | Access                 |
+| -------------------------------------- | ---------------------- |
+| `Storage Queue Data Reader`            | Read and peek messages |
+| `Storage Queue Data Contributor`       | Read/write messages    |
+| `Storage Queue Data Message Sender`    | Send messages only     |
+| `Storage Queue Data Message Processor` | Receive and delete     |
+
+## Best Practices
+
+1. **Use `cargo add` to manage dependencies, never edit `Cargo.toml` directly.** Add and remove Rust SDK dependencies with cargo commands instead of manual manifest edits.
+2. **Add `azure_core` only when importing `azure_core` types directly.** If your code imports `azure_core::http::Url`, `azure_core::http::RequestContent`, or `azure_core::error::ErrorKind`, include `azure_core`; otherwise a direct dependency is optional.
+3. **Use `DeveloperToolsCredential`** for local dev, **`ManagedIdentityCredential`** for production — Rust does not provide a single `DefaultAzureCredential` type
+4. **Never hardcode credentials** — use environment variables or managed identity
+5. **Assign RBAC roles** — ensure appropriate queue data roles for the identity
+6. **Use `QueueServiceClient` as the entry point** and derive `QueueClient` from it via `queue_client()`
+7. **Delete messages after processing** — use the message ID and pop receipt from `receive_messages`
+8. **Reuse clients** — clients are thread-safe; create once, share across tasks
+
+## Reference Links
+
+| Resource      | Link                                                                                  |
+| ------------- | ------------------------------------------------------------------------------------- |
+| API Reference | https://docs.rs/crate/azure_storage_queue/latest                                      |
+| crates.io     | https://crates.io/crates/azure_storage_queue                                          |
+| Source Code   | https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/storage/azure_storage_queue |
+
+## 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/baseline-ui/SKILL.md

@@ -1,18 +1,22 @@
 ---
 name: baseline-ui
-description: Validates animation durations, enforces typography scale, checks component accessibility, and prevents layout anti-patterns in Tailwind CSS projects. Use when building UI components, reviewing CSS utilities, styling React views, or enforcing design consistency.
+description: Quickly deslop UI code by fixing spacing, hierarchy, typography, and small layout issues. Use when the interface needs a fast cleanup or polish pass.
 risk: unknown
-source: community
+source: https://github.com/ibelick/ui-skills/tree/main/skills/baseline-ui
+source_repo: ibelick/ui-skills
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/ibelick/ui-skills/blob/main/LICENSE
 ---
 
 # Baseline UI
+## When to Use
 
-Enforces an opinionated UI baseline to prevent AI-generated interface slop.
+Use this skill when you need quickly deslop UI code by fixing spacing, hierarchy, typography, and small layout issues. Use when the interface needs a fast cleanup or polish pass.
 
-## When to Use
-- You are building or reviewing Tailwind-based UI and want a strict baseline for accessibility, motion, typography, and layout.
-- The task is to prevent generic or sloppy AI-generated interface decisions before they spread through the codebase.
-- You need concrete UI constraints to apply to a file review or an ongoing frontend implementation.
+
+Enforces an opinionated UI baseline to prevent AI-generated interface slop.
 
 ## How to use
 
@@ -92,6 +96,7 @@ Enforces an opinionated UI baseline to prevent AI-generated interface slop.
 - SHOULD use existing theme or Tailwind CSS color tokens before introducing new ones
 
 ## Limitations
-- Use this skill only when the task clearly matches the scope described above.
-- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
-- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
+
+- 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/before-you-build/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: before-you-build
+description: "Review product risk before coding by checking demand, alternatives, channels, switching costs, and failure signals."
+category: product
+risk: safe
+source: community
+source_repo: bin1874/before-you-build-skill
+source_type: community
+date_added: "2026-07-02"
+author: bin1874
+tags: [product-validation, planning, ai-coding, risk-review]
+tools: [claude, cursor, codex, gemini, antigravity]
+license: "MIT"
+license_source: "https://github.com/bin1874/before-you-build-skill/blob/main/LICENSE"
+---
+
+# Before You Build
+
+## Overview
+
+Before You Build helps an AI coding workflow pause before implementation and check whether the feature, product, or tool is worth building. It focuses on product risk rather than code structure: who needs the thing, what they use today, why they would switch, how distribution works, and what evidence would make the project safer to start.
+
+The upstream project ships a standalone skill repository and an `npx` installer for several coding assistants.
+
+## When to Use This Skill
+
+- Use when a user asks an AI coding assistant to build a new app, feature, internal tool, SaaS, or side project.
+- Use when the idea sounds plausible but the buyer, workflow, distribution path, or switching reason is still vague.
+- Use before writing code so the assistant can turn the request into sharper assumptions, risk checks, and validation steps.
+
+## How It Works
+
+### Step 1: Identify the Build Bet
+
+Restate the product or feature in one concrete sentence. Name the intended user, the job they are trying to finish, and the current workaround or competitor.
+
+### Step 2: Check the Main Risks
+
+Review the idea across demand, workflow fit, willingness to switch, distribution, pricing, data access, and operational burden. Prefer specific doubts over generic brainstorming.
+
+### Step 3: Decide the Next Small Test
+
+Suggest the smallest useful validation step before implementation. This could be a buyer conversation, landing page test, manual concierge workflow, prototype, waitlist, paid pilot, or narrow internal trial.
+
+### Step 4: Continue or Stop
+
+If the risk is acceptable, move into implementation with the assumptions written down. If the risk is high or evidence is weak, recommend a smaller experiment instead of building the full version.
+
+## Examples
+
+### Example 1: SaaS Feature Request
+
+```text
+User: Build a dashboard for AI trend monitoring.
+
+Before coding, check:
+- Which role needs this dashboard every week?
+- What source do they use today?
+- What decision changes because of the dashboard?
+- Would they pay for alerts, reports, or workflow integration?
+- What is the smallest manual report that proves repeat use?
+```
+
+### Example 2: Internal Tool
+
+```text
+User: Build an internal CRM for our small team.
+
+Before coding, check:
+- What breaks in the current spreadsheet or existing CRM?
+- How many people will use it daily?
+- What data must be imported or kept in sync?
+- What process change is required after launch?
+- Can a no-code workflow prove the need first?
+```
+
+## Best Practices
+
+- ✅ Ask for the user, job, current alternative, and switching reason before implementation.
+- ✅ Separate product risk from engineering risk so the team does not solve the wrong problem well.
+- ✅ Recommend small validation steps when the idea has weak demand evidence.
+- ✅ Keep product names, numbers, and claims grounded in what the user provides.
+- ❌ Do not present a generic checklist as proof that an idea is validated.
+- ❌ Do not fabricate market size, revenue, competitor traction, or buyer quotes.
+
+## Limitations
+
+- This skill does not replace customer research, legal review, financial advice, or domain expert review.
+- It cannot prove demand by itself; it helps the assistant surface assumptions and choose a smaller validation step.
+- If the user already has strong evidence and a clear spec, keep the review short and move into implementation.
+
+## Security & Safety Notes
+
+- This skill is safe to run as a planning layer because it does not require credentials, external network access, or file mutation.
+- If paired with an installer or repository fetch, only install from the upstream repository or npm package you trust.
+
+## Common Pitfalls
+
+- **Problem:** The assistant repeats the product pitch instead of challenging the assumptions.
+  **Solution:** Ask for current alternatives, switching triggers, and a validation step before code.
+
+- **Problem:** The review becomes too broad and blocks progress.
+  **Solution:** Pick the riskiest assumption and test only that first.
+
+- **Problem:** The idea is treated as a startup even when it is a small internal workflow.
+  **Solution:** Scale the risk review to the project size and only ask questions that change the build decision.
+
+## Related Skills
+
+- `@saas-mvp-launcher` - Use when moving from validation into MVP planning and launch execution.
+- `@ux-research-methodology` - Use when the next step needs structured user research.

package/bundled-skills/brooks-audit/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: brooks-audit
+description: "Architecture audit that maps module dependencies, checks layering integrity, and flags structural decay across a codebase, drawing on twelve classic engineering books. Triggers when: user asks to audit architecture, review folder/module structure, check for circular imports, understand..."
+risk: unknown
+source: https://github.com/hyhmrright/brooks-lint/tree/main/skills/brooks-audit
+source_repo: hyhmrright/brooks-lint
+source_type: community
+date_added: 2026-07-01
+license: MIT
+license_source: https://github.com/hyhmrright/brooks-lint/blob/main/LICENSE
+---
+
+# Brooks-Lint — Architecture Audit
+## When to Use
+
+Use this skill when you need architecture audit that maps module dependencies, checks layering integrity, and flags structural decay across a codebase, drawing on twelve classic engineering books. Triggers when: user asks to audit architecture, review folder/module structure, check for circular imports, understand...
+
+
+## Setup
+
+1. Read `../_shared/common.md` for the Iron Law, Project Config, Report Template, and Health Score rules
+2. Read `../_shared/source-coverage.md` for book-level coverage, exceptions, and tradeoffs
+3. Read `../_shared/decay-risks.md` for symptom definitions and source attributions
+4. Read `architecture-guide.md` in this directory for the audit framework
+
+## Process
+
+**Onboarding mode:** If the user asks for an onboarding report, codebase tour, or
+"explain this codebase to a new developer", read `onboarding-guide.md` from this
+directory and follow it instead of `architecture-guide.md`. This mode explains rather
+than diagnoses — no Health Score, no Iron Law findings.
+
+**If the user has not specified files or a directory to audit:** apply Auto Scope
+Detection from `../_shared/common.md` to determine the audit scope before proceeding.
+
+1. Gather codebase context and draw the module dependency graph as Mermaid (Steps 0–1 of the guide)
+2. Scan for each decay risk in the order specified (Steps 2–4 of the guide)
+3. Assign node colors in the Mermaid diagram based on findings (red/yellow/green) — after Step 4
+4. Run the Testability Seam Assessment (Step 5 of the guide)
+5. Run the Conway's Law check (Step 6 of the guide)
+6. Output using the Report Template from common.md — Mermaid graph FIRST, then Findings
+
+**Mode line in report:** `Architecture Audit`
+
+## 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.