opencode-skills-collection 4.0.69 → 4.0.70

package/bundled-skills/monte-carlo-asset-health/SKILL.md

@@ -1,6 +1,6 @@
 ---
+description: Curated upstream guidance for Monte Carlo Asset Health; use when the workflow matches the user goal.
 name: monte-carlo-asset-health
-description: Check the health of a data table/asset using Monte Carlo. Activates on "how is table X", "check health of X", "is X healthy", "status of X", "check on X table", or any health/status question about a data asset.
 risk: critical
 source: https://github.com/monte-carlo-data/mc-agent-toolkit/tree/main/skills/asset-health
 source_repo: monte-carlo-data/mc-agent-toolkit
@@ -9,6 +9,9 @@ date_added: 2026-07-01
 license: Apache-2.0
 license_source: https://github.com/monte-carlo-data/mc-agent-toolkit/blob/main/LICENSE
 ---
+## When to Use
+
+- Use when the user goal matches this upstream workflow.
 
 # Monte Carlo Asset Health Skill
 
@@ -193,6 +196,14 @@ Only include recommendations derivable from collected data:
 - Active alerts that need acknowledgment or investigation
 - Do NOT recommend specific monitor types — that is outside this skill's scope
 
+
+## Examples
+
+```text
+User: Apply this skill to my current task.
+Assistant: Follow the workflow in this skill, cite limitations, and ask before risky steps.
+```
+
 ## Limitations
 
 - Use this skill only when the task clearly matches its upstream source and local project context.

package/bundled-skills/monte-carlo-context-detection/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: monte-carlo-context-detection
+description: Route data-related requests to the right Monte Carlo skill or workflow.
+  USE WHEN alerts, incidents, data broken, stale, coverage gaps, data quality, or
+  any ambiguous data observability request.
+when_to_use: 'Invoke for ambiguous or incomplete data-observability requests that
+  don''t clearly name a specific skill.
+
+  Example triggers: "something is wrong with my data", "I have alerts firing", "check
+  my pipelines", "what should I monitor?", "my data looks off".
+
+
+  CRITICAL on vague first turns: ALWAYS ask 1–3 targeted clarifying questions FIRST
+  (what symptom? which table/warehouse? when did it start?). Do NOT call Monte Carlo
+  MCP tools (get_alerts, search, get_table, etc.) on turn 1 until the user has named
+  a specific table, warehouse, or alert. Calling tools prematurely on a vague prompt
+  wastes turns and frustrates the user.
+
+
+  Do NOT invoke when the user''s intent clearly matches a single existing skill (e.g.
+  "check health of orders table" → asset-health; "create a volume monitor on X" →
+  monitoring-advisor).
+
+  '
+bucket: Agent-routing
+version: 1.0.0
+source_repo: monte-carlo-data/mc-agent-toolkit
+source_type: community
+source: community
+date_added: '2026-09-21'
+risk: unknown
+---
+## When to Use
+- Use when this upstream workflow matches the user's stated goal.
+- Use when the task requires the procedures documented in this skill.
+
+# Monte Carlo Context Detection
+
+This skill determines which Monte Carlo skill or workflow best fits the user's current context. It activates reactively for ambiguous or multi-step data-related messages, gathers signals, and routes to the right skill or workflow.
+
+> **Monte Carlo tool routing (required):** Always call Monte Carlo MCP tools through this plugin's
+> bundled server, whose fully-qualified tool names are
+> `mcp__plugin_mc-agent-toolkit_monte-carlo-mcp__<tool>` (e.g.
+> `mcp__plugin_mc-agent-toolkit_monte-carlo-mcp__get_alerts`). Bare tool names used in this skill
+> (`get_alerts`, `search`, `get_table`, …) refer to that bundled server. If the session also has a
+> separately-configured `monte-carlo-mcp` server, do **not** route to it — it may point at a
+> different endpoint or credentials.
+
+Reference file for signal definitions: `references/signal-definitions.md` (relative to this file). Read it before routing.
+
+## When to activate this skill
+
+This skill is activated by the CLAUDE.md routing table when:
+
+- The user's message relates to data quality, alerts, incidents, coverage, or Monte Carlo — but doesn't clearly match a single skill in the routing table
+- The user's intent is ambiguous or could span multiple skills
+- The user asks a broad question like "help me with my data" or "what's going on?"
+
+## When NOT to activate this skill
+
+- A skill or workflow is already active in the conversation — the active skill owns the conversation, do not intercept
+- The user's message clearly matches a single skill in the CLAUDE.md routing table — route directly, no need for context detection
+- The user is editing a dbt model — defer to the `prevent` skill which auto-activates via hooks
+- The user's message is not data-related at all
+
+---
+
+## Workflow: Reactive Routing
+
+This skill is purely reactive — it activates for ambiguous or multi-step data-related messages and routes them.
+
+Follow these steps in order.
+
+### Step 0: Fast-path clear intent (stop early if matched)
+
+Before doing anything else, check whether the user's message unambiguously matches a single existing skill. If so, **skip the rest of this workflow** and immediately load that skill — do NOT read `references/signal-definitions.md`, do NOT make API probes.
+
+| Clear user intent | Skill to load immediately |
+|---|---|
+| "Check health of [named table]" / "status of [named table]" | `../asset-health/SKILL.md` |
+| "Create a [monitor type] on [named table]" | `../monitoring-advisor/SKILL.md` |
+| "Investigate alert on [named table]" / "why is [named table] stale/broken?" | `../incident-response/SKILL.md` |
+| "What should I monitor?" / "where are my coverage gaps?" | `../proactive-monitoring/SKILL.md` |
+| "Instrument my agent" / "set up Monte Carlo tracing on [named framework] agent" / "setting up an agent" | `../instrument-agent/SKILL.md` |
+
+Context-detection is for **ambiguous** requests only. If the request is clear, routing through this skill wastes turns and tokens.
+
+If no clear match, proceed to Step 1.
+
+### Step 1: Categorize intent
+
+Read `references/signal-definitions.md` for the full signal catalog. Determine which category the user's message falls into:
+
+| Category | Signals | Example messages |
+|----------|---------|-----------------|
+| **Specific asset** | User mentions a table name, or has a `.sql` model file open in their IDE | "what's wrong with stg_payments?", "check this table" |
+| **Active incident** | Keywords: alert, broken, stale, failing, incident, triage, wrong data | "I have alerts firing", "data looks wrong", "something broke" |
+| **Coverage/monitoring** | Keywords: monitor, coverage, gaps, unmonitored, what should I watch | "what should I monitor?", "where are my gaps?" |
+| **Agent instrumentation** | Keywords: instrument, set up tracing, set up Monte Carlo tracing, setting up an agent. Often mentions an AI framework (LangChain, LangGraph, OpenAI, Anthropic, CrewAI, Bedrock, SageMaker, Vertex AI) | "instrument my agent", "set up MC tracing on my LangGraph agent", "setting up an agent" |
+| **General/exploratory** | No clear category, broad question | "help me with data quality", "what can Monte Carlo do?" |
+
+### Step 2: Gather scope (only if needed)
+
+- **Specific asset known** (from file context or user mention) → proceed to Step 3
+- **Active incident, no scope** → ask: "Want me to check recent alerts? Any specific time range or severity?"
+- **Coverage/monitoring, no scope** → ask: "Which warehouse should I look at, or should I check across all?"
+- **General/exploratory** → present the categories: "I can help with: (1) investigating active alerts or data issues, (2) analyzing monitoring coverage and creating monitors, or (3) checking the health of specific tables. What are you looking for?"
+
+### Step 3: Scoped API probe (when scope is available)
+
+Only make API calls when you have enough context to scope them:
+
+- **Specific asset** → call `get_alerts` with the table's MCON or name filter, and `get_monitors` for that table
+- **Active incident with scope** → call `get_alerts` with the user's time range / severity filters
+- **Coverage/monitoring** → skip API probe, route directly to proactive monitoring workflow (it handles its own API calls)
+- **If MCP tool calls fail** (auth not configured) → skip API, fall back to conversation intent alone
+
+**Always scope MCP calls tightly.** Unscoped `get_alerts`, `search`, or `get_monitors` on large accounts can return hundreds of results, overflow the tool-result token limit, spill to disk, and force expensive chunk reads — burning user tokens and risking workflow failure. Minimum scoping:
+
+- `get_alerts` → time filter (`created_after`, default last 7 days) + at least one of `warehouse`, `table_names`, `severity`
+- `search` → needed to resolve a table name to its MCON (`get_table` requires MCON). ALWAYS pass `limit` (e.g. 5), the table name as `query`, and filter by `warehouse_uuid` or `database`/`schema`. `warehouse_types` alone ("snowflake") matches thousands of tables. Disambiguation rules when multiple matches return:
+  1. If the user named a warehouse (e.g. "analytics-snowflake") → auto-pick the match whose `warehouse_display_name` matches and proceed. Do NOT stop to ask.
+  2. If the user named a database/schema → auto-pick the match in that database/schema.
+  3. If one match is flagged `is_key_asset: true` and others aren't → auto-pick the key asset.
+  4. Only ask the user to disambiguate when none of the above resolve it.
+- `get_monitors` → always filter by `mcons` (table MCON) or `warehouse_uuid`
+
+If you don't have enough scope, ask the user before calling.
+
+### Step 4: Route
+
+Based on the combined signals from Steps 1-3:
+
+| Combined signals | Confidence | Action |
+|-----------------|------------|--------|
+| Active alerts found + incident intent | High | **Auto-activate** incident response workflow: read and follow `../incident-response/SKILL.md` |
+| Coverage intent + data project detected | High | **Auto-activate** proactive monitoring workflow: read and follow `../proactive-monitoring/SKILL.md` |
+| User asks to create a specific monitor (type + table known) | High | **Auto-activate** monitoring-advisor: read and follow `../monitoring-advisor/SKILL.md` |
+| Table mentioned + "health" / "status" / "check" intent | High | **Auto-activate** asset-health: read and follow `../asset-health/SKILL.md` |
+| Agent instrumentation intent (instrument / set up tracing / setting up an agent) + Python codebase context | High | **Auto-activate** instrument-agent: read and follow `../instrument-agent/SKILL.md` |
+| Ambiguous or conflicting signals | Low | **Suggest** options and wait for user to choose |
+
+**High confidence = auto-activate.** Load the target skill's SKILL.md and begin executing it immediately. Do not ask for confirmation.
+
+**Low confidence = suggest.** Present 2-3 options with brief descriptions and let the user choose. Example:
+
+> "Based on what you've described, I can:
+> 1. **Investigate alerts** — triage and fix active data issues (incident response workflow)
+> 2. **Improve monitoring** — find coverage gaps and create monitors (proactive monitoring workflow)
+>
+> Which would be most helpful?"
+
+### Prevent guardrail
+
+If the user is **actively editing** a dbt model file (making code changes, not just viewing or asking about it) and the `prevent` skill's hooks are active, do NOT route to any other skill. Instead respond:
+
+> "The prevent skill will automatically handle impact assessment for dbt model changes via its pre-edit hooks. No additional routing needed."
+
+
+## Examples
+
+```text
+User: Apply this skill to my current task.
+Assistant: Follow the workflow in this skill, cite limitations, and ask before risky steps.
+```
+
+## Limitations
+
+- Imported upstream skill; verify credentials, permissions, and safety boundaries before execution.
+- Does not replace environment-specific validation, testing, or maintainer review.

package/bundled-skills/monte-carlo-context-detection/references/signal-definitions.md

@@ -0,0 +1,46 @@
+# Signal Definitions
+
+This file documents each signal used by the context detection skill, its source,
+reliability, and what it maps to. Update this file when adding a new skill or
+workflow to the routing system.
+
+## Workspace Signals (detected via file system)
+
+| Signal | Detection method | Reliability | Meaning |
+|--------|-----------------|-------------|---------|
+| `dbt_project.yml` exists | Glob from workspace root | High | This is a dbt project — `prevent` skill is relevant for model edits |
+| `montecarlo.yml` exists | Glob from workspace root | High | Monte Carlo monitors-as-code is configured — monitoring skills are relevant |
+| User has a `.sql` model file open | IDE context / file path in conversation | High | Specific table context available — extract table name from filename |
+
+## Conversation Signals (detected from user message)
+
+| Signal | Keywords / patterns | Maps to |
+|--------|-------------------|---------|
+| Incident intent | "alert", "broken", "stale", "failing", "incident", "triage", "wrong data", "data issue" | Incident response workflow |
+| Coverage intent | "monitor", "coverage", "gaps", "unmonitored", "what should I watch", "what should I monitor" | Proactive monitoring workflow |
+| Specific monitor creation | "create a monitor", "add a freshness check", "set up validation" + specific table | monitoring-advisor (direct) |
+| Table health | "health", "status", "check on", "how is table X" + specific table | asset-health (direct) |
+| Storage/cost | "cost", "storage", "unused tables", "zombie tables" | storage-cost-analysis (direct) |
+| Performance | "slow", "performance", "expensive query", "pipeline taking long" | performance-diagnosis (direct) |
+| Validation notebook | "validation notebook", "generate validation", "compare baseline" | generate-validation-notebook (direct) |
+| Push ingestion | "push ingestion", "metadata collector", "lineage collector" | push-ingestion (direct) |
+| Agent instrumentation | "instrument my agent", "instrument", "set up tracing", "set up Monte Carlo tracing", "setting up an agent", "add MC tracing" | instrument-agent (direct) |
+| Agent alert / trace investigation | "agent alert", "eval score drop", "agent trace", "agent conversation", "why is my agent failing" | troubleshoot-agent-traces (direct) |
+| Agent reinforcement / fix | "fix my agent", "reinforce my agent", "improve my agent's health", "what should I fix in my agent", "open a PR for my agent" | reinforce-agent (direct) |
+
+## API Signals (detected via scoped MCP tool calls)
+
+These signals are only gathered when a specific table or scope is known. Never
+call these without scope.
+
+| Signal | MCP tool call | What it returns | Maps to |
+|--------|--------------|-----------------|---------|
+| Active alerts on table | `get_alerts` with table filter | Unresolved alerts for the specific table | Incident response workflow (if alerts found) |
+| Monitor coverage on table | `get_monitors` with table MCON | Existing monitors for the table | Informs whether to suggest coverage analysis |
+
+## Routing Priority
+
+1. **Prevent guardrail** — If user is editing a dbt model, `prevent` owns the session. Do not route.
+2. **Active skill** — If a skill or workflow is already active, do not re-route. The active skill owns the conversation.
+3. **High-confidence match** — Auto-activate the matched skill/workflow.
+4. **Low-confidence match** — Suggest options, let user choose.

package/bundled-skills/remotion-captions/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: remotion-captions
+description: Transcribing, displaying and animating captions
+version: 4.0.526
+source_repo: remotion-dev/skills
+source_type: official
+source: remotion-dev
+date_added: '2026-09-21'
+risk: unknown
+---
+## When to Use
+- Use when this upstream workflow matches the user's stated goal.
+- Use when the task requires the procedures documented in this skill.
+
+All captions must be processed in JSON. The captions must use the [`Caption`](https://www.remotion.dev/docs/captions/caption.md) type which is the following:
+
+```ts
+import type { Caption } from "@remotion/captions";
+```
+
+This is the definition:
+
+```ts
+type Caption = {
+  text: string;
+  startMs: number;
+  endMs: number;
+  timestampMs: number | null;
+  confidence: number | null;
+  pageBreakAfter?: boolean;
+};
+```
+
+## Generating captions
+
+To transcribe video and audio files to generate captions, load the [transcribe-captions.md file for more instructions.
+
+## Displaying captions
+
+To display captions in your video, load the [display-captions.md file for more instructions.
+
+## Importing captions
+
+To import captions from a .srt file, load the [import-srt-captions.md file for more instructions.
+
+
+## Examples
+
+```text
+User: Apply this skill to my current task.
+Assistant: Follow the workflow in this skill, cite limitations, and ask before risky steps.
+```
+
+## Limitations
+
+- Imported upstream skill; verify credentials, permissions, and safety boundaries before execution.
+- Does not replace environment-specific validation, testing, or maintainer review.

package/bundled-skills/remotion-captions/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: '/remotion-captions'
+  short_description: 'Transcribe, display, and animate captions'
+  icon_small: './assets/remotion-icon.svg'
+  icon_large: './assets/remotion-icon.svg'
+  brand_color: '#0B84F3'
+  default_prompt: '$remotion-captions: Transcribe my video and display captions'

package/bundled-skills/remotion-captions/assets/remotion-icon.svg

@@ -0,0 +1,4 @@
+<svg width="100" height="100" viewBox="20 30 363 363" xmlns="http://www.w3.org/2000/svg">
+<title>Remotion</title>
+<path d="M148.332 92.9015C143.307 93.1742 139.259 93.9713 135.179 95.5236C133.144 96.2893 129.809 97.957 127.973 99.1108C120.295 103.925 114.443 111.162 111.391 119.584C110.782 121.252 109.136 126.57 108.076 130.23C101.018 154.7 97.0112 181.456 96.1511 209.776C96.0148 214.286 96.0148 225.026 96.1511 229.463C96.728 248.237 98.5216 265.187 101.773 282.472C103.095 289.468 105.213 298.866 106.44 303.135C108.947 311.809 114.065 319.193 121.344 324.605C126.221 328.234 131.759 330.668 137.895 331.863C140.853 332.44 144.755 332.702 147.629 332.514C151.604 332.251 159.491 331.192 165.9 330.049C194.786 324.899 221.469 315.679 245.666 302.485C260.99 294.125 274.09 285.074 286.729 274.092C299.326 263.163 310.066 251.405 319.516 238.21C321.708 235.158 322.81 233.375 323.911 231.131C326.743 225.341 328.075 219.583 328.064 213.143C328.064 207.143 326.932 201.815 324.488 196.361C323.313 193.728 322.191 191.84 319.674 188.253C310.402 175.048 300.112 163.542 287.568 152.361C268.122 135.034 245.026 120.822 219.235 110.302C213.644 108.026 208.138 106.022 201.509 103.851C187.475 99.2681 170.106 95.2929 155.411 93.3105C153.104 92.9959 149.968 92.8176 148.332 92.9015Z" fill="#0B84F3"/>
+</svg>

package/bundled-skills/remotion-captions/display-captions.md

@@ -0,0 +1,190 @@
+---
+name: display-captions
+description: Displaying captions in Remotion with TikTok-style pages and word highlighting
+metadata:
+  tags: captions, subtitles, display, tiktok, highlight
+---
+
+# Displaying captions in Remotion
+
+This guide explains how to display captions in Remotion, assuming you already have captions in the [`Caption`](https://www.remotion.dev/docs/captions/caption) format.
+
+## Prerequisites
+
+Read [Transcribing audio](transcribe-captions.md) for how to generate captions.
+
+First, the [`@remotion/captions`](https://www.remotion.dev/docs/captions) package needs to be installed.
+If it is not installed, use the following command:
+
+```bash
+npx remotion add @remotion/captions
+```
+
+## Fetching captions
+
+First, fetch your captions JSON file. Use [`useDelayRender()`](https://www.remotion.dev/docs/use-delay-render) to hold the render until the captions are loaded:
+
+```tsx
+import { useState, useEffect, useCallback } from "react";
+import { AbsoluteFill, staticFile, useDelayRender } from "remotion";
+import type { Caption } from "@remotion/captions";
+
+export const MyComponent: React.FC = () => {
+  const [captions, setCaptions] = useState<Caption[] | null>(null);
+  const { delayRender, continueRender, cancelRender } = useDelayRender();
+  const [handle] = useState(() => delayRender());
+
+  const fetchCaptions = useCallback(async () => {
+    try {
+      // Assuming captions.json is in the public/ folder.
+      const response = await fetch(staticFile("captions123.json"));
+      const data = await response.json();
+      setCaptions(data);
+      continueRender(handle);
+    } catch (e) {
+      cancelRender(e);
+    }
+  }, [continueRender, cancelRender, handle]);
+
+  useEffect(() => {
+    fetchCaptions();
+  }, [fetchCaptions]);
+
+  if (!captions) {
+    return null;
+  }
+
+  return (
+    <AbsoluteFill>
+      {/* Render captions here */}
+    </AbsoluteFill>
+  );
+};
+```
+
+## Creating pages
+
+Use `createTikTokStyleCaptions()` to group captions into pages. The `combineTokensWithinMilliseconds` option controls how many words appear at once:
+
+```tsx
+import { useMemo } from "react";
+import { createTikTokStyleCaptions } from "@remotion/captions";
+import type { Caption } from "@remotion/captions";
+
+// How often captions should switch (in milliseconds)
+// Higher values = more words per page
+// Lower values = fewer words (more word-by-word)
+const SWITCH_CAPTIONS_EVERY_MS = 1200;
+
+const { pages } = useMemo(() => {
+  return createTikTokStyleCaptions({
+    captions,
+    combineTokensWithinMilliseconds: SWITCH_CAPTIONS_EVERY_MS,
+  });
+}, [captions]);
+```
+
+If a caption has `pageBreakAfter: true`, the current page ends after that caption and the next caption starts a new page.
+
+## Rendering with Sequences
+
+Map over the pages and render each one in a `<Sequence>`. Calculate the start frame and duration from the page timing:
+
+```tsx
+import { Sequence, useVideoConfig, AbsoluteFill } from "remotion";
+import type { TikTokPage } from "@remotion/captions";
+
+const CaptionedContent: React.FC = () => {
+  const { fps } = useVideoConfig();
+
+  return (
+    <AbsoluteFill>
+      {pages.map((page, index) => {
+        const nextPage = pages[index + 1] ?? null;
+        const startFrame = (page.startMs / 1000) * fps;
+        const endFrame = Math.min(
+          nextPage ? (nextPage.startMs / 1000) * fps : Infinity,
+          startFrame + (SWITCH_CAPTIONS_EVERY_MS / 1000) * fps,
+        );
+        const durationInFrames = endFrame - startFrame;
+
+        if (durationInFrames <= 0) {
+          return null;
+        }
+
+        return (
+          <Sequence
+            key={index}
+            from={startFrame}
+            durationInFrames={durationInFrames}
+          >
+            <CaptionPage page={page} />
+          </Sequence>
+        );
+      })}
+    </AbsoluteFill>
+  );
+};
+```
+
+## White-space preservation
+
+The captions are whitespace sensitive. You should include spaces in the `text` field before each word. Use `whiteSpace: "pre"` to preserve the whitespace in the captions.
+
+## Separate component for captions
+
+Put captioning logic in a separate component.  
+Make a new file for it.
+
+## Word highlighting
+
+A caption page contains `tokens` which you can use to highlight the currently spoken word:
+
+```tsx
+import { AbsoluteFill, useCurrentFrame, useVideoConfig } from "remotion";
+import type { TikTokPage } from "@remotion/captions";
+
+const HIGHLIGHT_COLOR = "#39E508";
+
+const CaptionPage: React.FC<{ page: TikTokPage }> = ({ page }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+
+  // Current time relative to the start of the sequence
+  const currentTimeMs = (frame / fps) * 1000;
+  // Convert to absolute time by adding the page start
+  const absoluteTimeMs = page.startMs + currentTimeMs;
+
+  return (
+    <AbsoluteFill style={{ justifyContent: "center", alignItems: "center" }}>
+      <div style={{ fontSize: 80, fontWeight: "bold", whiteSpace: "pre" }}>
+        {page.tokens.map((token, tokenIndex) => {
+          const isActive =
+            token.fromMs <= absoluteTimeMs && token.toMs > absoluteTimeMs;
+
+          return (
+            <span
+              key={`${token.fromMs}-${tokenIndex}`}
+              style={{ color: isActive ? HIGHLIGHT_COLOR : "white" }}
+            >
+              {token.text}
+            </span>
+          );
+        })}
+      </div>
+    </AbsoluteFill>
+  );
+};
+```
+
+## Display captions alongside video content
+
+By default, put the captions alongside the video content, so the captions are in sync.  
+For each video, make a new captions JSON file.
+
+```tsx
+<AbsoluteFill>
+  <Video src={staticFile("video.mp4")} />
+  <CaptionPage page={page} />
+</AbsoluteFill>
+```

package/bundled-skills/remotion-captions/import-srt-captions.md

@@ -0,0 +1,73 @@
+---
+name: import-srt-captions
+description: Importing .srt subtitle files into Remotion using @remotion/captions
+metadata:
+  tags: captions, subtitles, srt, import, parse
+---
+
+# Importing .srt subtitles into Remotion
+
+If you have an existing `.srt` subtitle file, you can import it into Remotion using `parseSrt()` from `@remotion/captions`.
+
+If you don't have a .srt file, read [Transcribing audio](transcribe-captions.md) for how to generate captions instead.
+
+## Prerequisites
+
+First, the @remotion/captions package needs to be installed.
+If it is not installed, use the following command:
+
+```bash
+npx remotion add @remotion/captions # If project uses npm
+bunx remotion add @remotion/captions # If project uses bun
+yarn remotion add @remotion/captions # If project uses yarn
+pnpm exec remotion add @remotion/captions # If project uses pnpm
+```
+
+## Reading an .srt file
+
+Use `staticFile()` to reference an `.srt` file in your `public` folder, then fetch and parse it:
+
+```tsx
+import { useState, useEffect, useCallback } from "react";
+import { AbsoluteFill, staticFile, useDelayRender } from "remotion";
+import { parseSrt } from "@remotion/captions";
+import type { Caption } from "@remotion/captions";
+
+export const MyComponent: React.FC = () => {
+  const [captions, setCaptions] = useState<Caption[] | null>(null);
+  const { delayRender, continueRender, cancelRender } = useDelayRender();
+  const [handle] = useState(() => delayRender());
+
+  const fetchCaptions = useCallback(async () => {
+    try {
+      const response = await fetch(staticFile("subtitles.srt"));
+      const text = await response.text();
+      const { captions: parsed } = parseSrt({ input: text });
+      setCaptions(parsed);
+      continueRender(handle);
+    } catch (e) {
+      cancelRender(e);
+    }
+  }, [continueRender, cancelRender, handle]);
+
+  useEffect(() => {
+    fetchCaptions();
+  }, [fetchCaptions]);
+
+  if (!captions) {
+    return null;
+  }
+
+  return (
+    <AbsoluteFill>
+      {/* Use captions here */}
+    </AbsoluteFill>
+  );
+};
+```
+
+Remote URLs are also supported - you can `fetch()` a remote file via URL instead of using `staticFile()`.
+
+## Using imported captions
+
+Once parsed, the captions are in the `Caption` format and can be used with all `@remotion/captions` utilities.

package/bundled-skills/remotion-captions/transcribe-captions.md

@@ -0,0 +1,70 @@
+---
+name: transcribe-captions
+description: Transcribing audio to generate captions in Remotion
+metadata:
+  tags: captions, transcribe, whisper, audio, speech-to-text
+---
+
+# Transcribing audio
+
+To transcribe audio to generate captions in Remotion, you can use the [`transcribe()`](https://www.remotion.dev/docs/install-whisper-cpp/transcribe) function from the [`@remotion/install-whisper-cpp`](https://www.remotion.dev/docs/install-whisper-cpp) package.
+
+## Prerequisites
+
+First, the @remotion/install-whisper-cpp package needs to be installed.
+If it is not installed, use the following command:
+
+```bash
+npx remotion add @remotion/install-whisper-cpp
+```
+
+## Transcribing
+
+Make a Node.js script to download Whisper.cpp and a model, and transcribe the audio.
+
+```ts
+import path from "path";
+import {
+  downloadWhisperModel,
+  installWhisperCpp,
+  transcribe,
+  toCaptions,
+} from "@remotion/install-whisper-cpp";
+import fs from "fs";
+
+const to = path.join(process.cwd(), "whisper.cpp");
+
+await installWhisperCpp({
+  to,
+  version: "1.5.5",
+});
+
+await downloadWhisperModel({
+  model: "medium.en",
+  folder: to,
+});
+
+// Convert the audio to a 16KHz wav file first if needed:
+// import {execSync} from 'child_process';
+// execSync('ffmpeg -i /path/to/audio.mp4 -ar 16000 /path/to/audio.wav -y');
+
+const whisperCppOutput = await transcribe({
+  model: "medium.en",
+  whisperPath: to,
+  whisperCppVersion: "1.5.5",
+  inputPath: "/path/to/audio123.wav",
+  tokenLevelTimestamps: true,
+});
+
+// Optional: Apply our recommended postprocessing
+const { captions } = toCaptions({
+  whisperCppOutput,
+});
+
+// Write it to the public/ folder so it can be fetched from Remotion
+fs.writeFileSync("captions123.json", JSON.stringify(captions, null, 2));
+```
+
+Transcribe each clip individually and create multiple JSON files.
+
+See [Displaying captions](display-captions.md) for how to display the captions in Remotion.