opencode-skills-collection 3.0.49 → 3.0.51

package/bundled-skills/schema-markup/SKILL.md

@@ -110,6 +110,17 @@ This is a **diagnostic score**, not a promise of rich results.
 
 ---
 
+### Scoring Guidance per Category
+
+For each of the six scoring categories, allot points within the category's weight band using these anchors:
+
+- **0–15% of band:** Schema describes none of the visible content (e.g. you would mark `description` for a `Recipe` page that has no recipe markup yet).
+- **16–40% of band:** Partial alignment — the schema describes some but not all of the visible content, OR maps to a less-common schema.org type.
+- **41–80% of band:** Strong alignment — the schema describes the bulk of the visible content with a common schema.org type.
+- **81–100% of band:** Exemplary — the schema covers all visible content, uses a Google-supported rich-result type, and includes all required properties.
+
+Sum the per-category scores to compute the Eligibility Index used in §"Eligibility Bands" below.
+
 ### Eligibility Bands (Required)
 
 | Score  | Verdict               | Interpretation                        |

package/bundled-skills/screenstudio-alt/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: screenstudio-alt
+description: "Open-source headless Screen Studio alternative: auto speed-up of idle, auto-zoom on click clusters, keystroke overlay chips, smoothed synthetic cursor, and 9:16 vertical export that follows the action — post-production for screen recordings from the CLI."
+risk: safe
+source: community
+source_type: community
+source_repo: connerkward/screenstudio-alternative-skill
+date_added: "2026-06-16"
+author: Conner K Ward
+license: MIT
+tags:
+  - screen-recording
+  - video
+  - post-production
+  - auto-zoom
+  - vertical-video
+  - ffmpeg
+tools:
+  - claude-code
+  - antigravity
+  - cursor
+  - gemini-cli
+  - codex-cli
+---
+## When to Use
+
+Use when polishing a screen recording / demo video for sharing, when the user mentions Screen Studio, auto-zoom, idle speed-up, or vertical/social video from a screen capture, and for any social-facing demo (vertical output is the default for those).
+
+_Source: [connerkward/screenstudio-alternative-skill](https://github.com/connerkward/screenstudio-alternative-skill) (MIT)._
+
+# screenstudio-alt
+
+The skill's code lives in this directory (`polish.py`, `render.py`, `studio.py`,
+`events-log.swift`, test fixtures, etc.). Published publicly as
+`connerkward/screen-studio-alternative` via the publish-skill skill.
+
+Two components:
+
+- `events-log` (Swift) — capture-side input logger (cursor 60Hz, clicks, keys;
+  drops keys during macOS secure input). Runs ONLY while recording. Needs
+  Accessibility/Input Monitoring for the terminal. **Auto-zoom/keys/cursor need
+  this data at capture time — it cannot be recovered from pixels later.**
+- `polish.py` (Python, ffmpeg + PIL) — the post-production pass:
+
+```bash
+python3 src/polish.py in.mp4 --events in.events.jsonl \
+  --speedup            # compress idle (input-gap ∩ frozen-pixels; animations stay 1x)
+  --zoom               # eased auto-zoom on click clusters (zoompan)
+  --keys               # accumulating keystroke chips (PIL overlays, no drawtext dep)
+  --smooth-cursor      # synthetic eased cursor (best with sck-record --no-cursor)
+  --vertical           # ALSO emit 1080x1920 following the action
+```
+
+`--speedup` works WITHOUT events (freezedetect only) — usable on the whole
+existing dailies corpus.
+
+- `render.py` — **high-quality non-destructive renderer** (preferred): single-pass
+  spring-physics camera over the original high-res frames, LANCZOS into a smaller
+  target (crisp zoom, ~1.3× sharper than the ffmpeg upscale path), 60fps, H + 9:16 V.
+  Tunable `--freq`/`--zeta` (spring), `--fps`, `--target-w`. Takes explicit
+  `--regions [{t0,t1,z,cx,cy}]`. `polish.py` is the older ffmpeg-filter fallback.
+- `studio.py [recording.mp4]` — local web UI, **NLE-style fixed-ruler timeline** (bar =
+  source duration, never rescales → upstream always planted): zoom regions are draggable
+  blocks (move / retime edges / click to add / double-click delete); idle spans are
+  **speed blocks with rate-only editing** — source range locked, rate set via inspector
+  slider on select or right-edge **rate-stretch** drag (FCP retime / Premiere Rate
+  Stretch); rate changes ripple downstream only. Tunable cosine-ease ramp, default zoom,
+  aspect, frame styling. Always-smooth synthetic cursor + click ripple + real recorded
+  click sound (CC0 #735771). Export uses render.py. Free port, local. (Keystroke overlay
+  exists in the engine but is off by default.)
+
+## Easy path
+
+`screencast.sh --demo` (screencast skill) does the whole chain: starts the event
+logger, records, then polishes + emits the 9:16 vertical automatically. Vertical
+is the DEFAULT for social-facing demos.
+
+## Gotchas (learned the hard way, kept here so they're not relearned)
+
+- ffmpeg CANNOT do animated `scale=eval=frame` → `crop` (link reinit wedges crop's
+  per-frame exprs). That's why zoom uses `zoompan` (no `t` var there — use `on/FPS`).
+- This machine's ffmpeg lacks `drawtext`; all text/cursor overlays are PIL-rendered
+  PNGs + `overlay`.
+- Test rig: `make-fixture.py` synthesizes a fake screen recording + ground-truth
+  events.jsonl — validate any change against it before trusting real footage.
+
+## Limitations
+
+- The workflow assumes FFmpeg plus the companion scripts are available locally; it is not a hosted video editor.
+- Polished cursor, click, and keystroke effects depend on event logs captured during recording; missing logs limit what can be reconstructed.
+- Auto-zoom and idle speed-up still need human review for pacing, framing, and platform-specific taste.

package/bundled-skills/super-code/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: super-code
+description: "Standing house style to enforce dense, correct, and idiomatic code on all coding tasks. Minimizes code bloat and agent operation overhead."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+
+# Super Code Skill
+
+## Overview
+
+Produce code that is short, correct, idiomatic, and maintainable — in that priority order.
+This skill addresses two distinct inefficiency types that must be fixed independently:
+
+1. **Code-token inefficiency** — the artifact itself is bloated (unnecessary lines, boilerplate, over-abstraction)
+2. **Generation-token inefficiency** — how the agent operates during a session (full-file rewrites, unrequested files, prose padding before/after changes)
+
+Both matter. Fixing only one is not enough.
+
+## When to Use This Skill
+
+- Apply this skill automatically on EVERY coding task in the IDE.
+- Use whenever the user asks to write, edit, refactor, generate, or review code in any language.
+- This is a standing house style, not an on-demand pass — always apply it.
+
+---
+
+## Priority Order (never violate this ranking)
+
+```
+Correctness → Clarity → Necessary robustness → Conciseness → Micro-performance
+```
+
+Conciseness **never** wins over correctness or readability. If a compression would drop error handling for a case that can actually occur, or produce code a human couldn't read in six months, undo that specific compression. Short bad code is worse than long correct code.
+
+---
+
+## Workflow — apply to every coding task
+
+### Step 1: Commit to minimal correct shape BEFORE writing
+
+Before touching a file, decide:
+- What is the smallest surface area that correctly solves this problem?
+- What does the caller actually need from this function/class/module?
+- Is there a stdlib/framework primitive that already does this?
+
+Write that down mentally (not in a prose block to the user). This is the target shape.
+
+### Step 2: Write using language-idiomatic patterns
+
+Read the relevant reference file for the language in use:
+- Bash/Shell → `bash/SKILL.md`
+- C → `c/SKILL.md`
+- C++ → `cpp/SKILL.md`
+- C# → `csharp/SKILL.md`
+- Dart/Flutter → `dart/SKILL.md`
+- Elixir/Erlang → `elixir/SKILL.md`
+- Go → `go/SKILL.md`
+- Java → `java/SKILL.md`
+- Kotlin/Compose → `kotlin/SKILL.md`
+- PHP → `php/SKILL.md`
+- Python → `python/SKILL.md`
+- Ruby → `ruby/SKILL.md`
+- Rust → `rust/SKILL.md`
+- Scala → `scala/SKILL.md`
+- Swift → `swift/SKILL.md`
+- TypeScript/JavaScript → `typescript/SKILL.md`
+
+Apply idiomatic patterns from that file. They replace verbose imperative code with correct, concise equivalents that are still readable.
+
+### Step 3: Compression pass on your own draft
+
+Before presenting any code, scan it for:
+
+| Anti-pattern | Fix |
+|---|---|
+| Comment restates what code does | Delete comment, or rewrite to say *why* |
+| Single-use helper function/class | Inline it |
+| Stdlib/framework already does this | Replace with the primitive |
+| Defensive handling for impossible case | Remove |
+| Verbose loop replaceable by idiomatic expression | Replace |
+| Logging/print nobody asked for | Remove |
+| Extra config/files/parameters not requested | Remove |
+| Unused import or variable | Remove |
+
+### Step 4: Guardrail check — run this before presenting
+
+Ask yourself (silently):
+- [ ] Did I remove handling for a case that **can** actually happen?
+- [ ] Did I make this harder to read for a human six months from now?
+- [ ] Did I drop correctness or security to save lines?
+
+If yes to any: undo that specific compression and keep the rest.
+
+### Step 5: Present output — generation-token rules
+
+**Always:**
+- Edit files via targeted patches/diffs, not full rewrites, unless the file is new or the change touches >70% of lines
+- Present only what was asked for
+
+**Never:**
+- Generate unrequested files (tests, READMEs, configs, types) unless the user asked
+- Add prose blocks before/after code explaining what you're about to do or just did — just do it
+- Re-explain the user's own requirement back to them before writing
+- Restate what changed in a paragraph after showing the diff — the diff is self-evident
+
+---
+
+## Universal Anti-Pattern Checklist
+
+These apply in every language. The language-specific files extend this list.
+
+### Comments
+- ❌ `// Loop through the list and add each item` → ❌ delete
+- ✅ `// Order matters: process refunds before charges` → ✅ keep (explains *why*)
+- Rule: if the comment could be generated mechanically from reading the code, it adds no value
+
+### Defensive coding
+- Only handle error cases that can actually occur given the call site
+- If the caller guarantees non-null, don't null-check inside the function
+- If a catch block can only log and rethrow, consider removing the try/catch
+
+### Abstractions
+- Don't extract a function for logic used exactly once in one place
+- Don't create a wrapper class around a primitive used only once
+- Threshold: abstraction earns its place when it's used 2+ times OR when it has a meaningful name that genuinely clarifies domain logic
+
+### Scaffolding
+- No placeholder TODOs unless the user asked for a scaffold
+- No `// TODO: add error handling` — either add it or don't
+- No empty catch blocks "just in case"
+- No parameters the current callers don't use
+
+---
+
+## Generation-Token Rules (agentic IDE specific)
+
+These govern how you operate inside the session, not just what you produce:
+
+### File edits
+- Prefer surgical patches: show only the changed lines + minimal context
+- Full file rewrite is acceptable only for: new files, files shorter than ~30 lines, or changes touching >70% of the file
+- Never repeat unchanged portions of a file to "show the full context"
+
+### Unrequested artifacts
+- Do not create test files, README updates, type definition files, config files, or CI scripts unless explicitly requested
+- If you believe a test file would be valuable, offer it in one sentence after the main output — don't generate it unasked
+
+### Prose overhead
+- No "Here's what I'm going to do:" preambles
+- No "I've made the following changes:" postambles (the diff shows this)
+- No "Let me know if you'd like me to..." closers
+- One-line clarification is acceptable if a requirement is genuinely ambiguous; otherwise, make a reasonable choice and note the assumption in a comment inside the code if it matters
+
+---
+
+## Language Reference Files
+
+| Language / Stack | File |
+|---|---|
+| Bash / Shell | `bash/SKILL.md` |
+| C | `c/SKILL.md` |
+| C++ | `cpp/SKILL.md` |
+| C# / .NET | `csharp/SKILL.md` |
+| Dart / Flutter | `dart/SKILL.md` |
+| Elixir / Erlang | `elixir/SKILL.md` |
+| Go | `go/SKILL.md` |
+| Java | `java/SKILL.md` |
+| Kotlin + Compose (Android) | `kotlin/SKILL.md` |
+| PHP | `php/SKILL.md` |
+| Python | `python/SKILL.md` |
+| Ruby | `ruby/SKILL.md` |
+| Rust | `rust/SKILL.md` |
+| Scala | `scala/SKILL.md` |
+| Swift (iOS/macOS) | `swift/SKILL.md` |
+| TypeScript / JavaScript | `typescript/SKILL.md` |
+
+Read the relevant file at Step 2. If the language isn't listed, apply the universal checklist above and use the language's own idioms for loops, error handling, and data transformation.
+
+## Examples
+
+### Example 1: Refactoring a verbose loop
+```java
+// Anti-pattern
+List<String> names = new ArrayList<>();
+for (User u : users) {
+    if (u.isActive()) {
+        names.add(u.getName());
+    }
+}
+// Super-code idiomatic (Java)
+List<String> names = users.stream().filter(User::isActive).map(User::getName).toList();
+```
+
+## Troubleshooting
+
+### Problem: Code is too dense to read
+**Symptoms:** Reviewer complains or logic is unreadable.
+**Solution:** Revert the overly compressed section. Clarity and correctness always win over conciseness.
+
+## Related Skills
+
+- `@karpathy-guidelines` - For behavioral guidelines on surgical changes and simplicity.
+
+## Limitations
+
+- **Language Support:** Language-specific idioms require reference files.
+- **Readability Tradeoffs:** Extreme compression can sometimes harm readability if not careful.

package/bundled-skills/super-code/bash/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: bash
+description: "Language-specific super-code guidelines for bash."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# Bash / Shell: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Quoting & Word Splitting](#quoting)
+2. [Conditionals & Tests](#conditionals)
+3. [Loops & Iteration](#loops)
+4. [Pipes & Process Substitution](#pipes)
+5. [Functions & Return Values](#functions)
+6. [Error Handling](#errors)
+7. [Anti-patterns specific to Bash](#antipatterns)
+
+---
+
+## 1. Quoting & Word Splitting {#quoting}
+
+```bash
+# ❌ Unquoted variable (word splitting + globbing)
+for f in $files; do rm $f; done
+
+# ✅
+for f in "${files[@]}"; do rm -- "$f"; done
+```
+
+```bash
+# ❌ Unquoted command substitution
+path=$(find . -name config)
+cat $path  # breaks on spaces
+
+# ✅
+path="$(find . -name config)"
+cat "$path"
+```
+
+```bash
+# ❌ Using backticks for command substitution
+result=`echo hello`
+
+# ✅ — $() nests cleanly
+result=$(echo hello)
+```
+
+```bash
+# ❌ String comparison without quotes
+if [ $var = "hello" ]; then  # breaks if var is empty or has spaces
+
+# ✅
+if [[ "$var" = "hello" ]]; then
+```
+
+**Rule: double-quote every `$variable` and `$(command)` unless you specifically need splitting.**
+
+---
+
+## 2. Conditionals & Tests {#conditionals}
+
+```bash
+# ❌ Single bracket test (POSIX but fragile)
+if [ -f "$file" -a -r "$file" ]; then
+
+# ✅ — [[ is safer, supports &&/||, no word splitting inside
+if [[ -f "$file" && -r "$file" ]]; then
+```
+
+```bash
+# ❌ Testing command exit status with if [ $? -eq 0 ]
+grep -q pattern file
+if [ $? -eq 0 ]; then echo "found"; fi
+
+# ✅ — test command directly
+if grep -q pattern file; then echo "found"; fi
+```
+
+```bash
+# ❌ String equality with == outside [[
+if [ "$a" == "$b" ]; then  # == not POSIX in [ ]
+
+# ✅
+if [[ "$a" == "$b" ]]; then  # Bash
+# or POSIX:
+if [ "$a" = "$b" ]; then
+```
+
+```bash
+# ❌ Arithmetic with [ ] and string comparison
+if [ "$count" -gt 10 ]; then
+
+# ✅ — (( )) for arithmetic
+if (( count > 10 )); then
+```
+
+---
+
+## 3. Loops & Iteration {#loops}
+
+```bash
+# ❌ Parsing ls output
+for f in $(ls *.txt); do process "$f"; done
+
+# ✅ — glob directly
+for f in *.txt; do
+    [[ -e "$f" ]] || continue  # handle no-match
+    process "$f"
+done
+```
+
+```bash
+# ❌ Reading file line-by-line with for
+for line in $(cat file.txt); do  # splits on words, not lines
+
+# ✅
+while IFS= read -r line; do
+    process "$line"
+done < file.txt
+```
+
+```bash
+# ❌ Seq for counting
+for i in $(seq 1 10); do
+
+# ✅ — brace expansion (Bash)
+for i in {1..10}; do
+# or C-style:
+for (( i = 1; i <= 10; i++ )); do
+```
+
+```bash
+# ❌ Processing command output line-by-line with pipe (subshell trap)
+count=0
+cat file.txt | while read -r line; do
+    (( count++ ))  # count resets after loop — subshell
+done
+echo "$count"  # always 0
+
+# ✅ — redirect, not pipe
+count=0
+while IFS= read -r line; do
+    (( count++ ))
+done < file.txt
+echo "$count"
+```
+
+---
+
+## 4. Pipes & Process Substitution {#pipes}
+
+```bash
+# ❌ Chained grep | grep for AND
+grep "error" log.txt | grep "timeout"
+
+# ✅ — single grep with pattern
+grep -E "error.*timeout|timeout.*error" log.txt
+# or awk for complex logic:
+awk '/error/ && /timeout/' log.txt
+```
+
+```bash
+# ❌ cat + pipe (UUOC — Useless Use of Cat)
+cat file.txt | grep pattern
+
+# ✅
+grep pattern file.txt
+```
+
+```bash
+# ❌ Temp file for diff between commands
+cmd1 > /tmp/a.txt
+cmd2 > /tmp/b.txt
+diff /tmp/a.txt /tmp/b.txt
+rm /tmp/a.txt /tmp/b.txt
+
+# ✅ — process substitution
+diff <(cmd1) <(cmd2)
+```
+
+```bash
+# ❌ Ignoring pipe failures (only last command's exit code)
+false | true
+echo $?  # 0 — false's failure hidden
+
+# ✅
+set -o pipefail
+false | true
+echo $?  # 1
+```
+
+---
+
+## 5. Functions & Return Values {#functions}
+
+```bash
+# ❌ Using return for string values
+get_name() {
+    return "Alice"  # return is for exit codes (0-255)
+}
+
+# ✅ — echo + capture
+get_name() {
+    echo "Alice"
+}
+name=$(get_name)
+```
+
+```bash
+# ❌ Global variables modified inside functions
+result=""
+compute() { result="done"; }
+
+# ✅ — use local, return via stdout
+compute() {
+    local tmp
+    tmp=$(do_work)
+    echo "$tmp"
+}
+result=$(compute)
+```
+
+```bash
+# ❌ Function keyword (not POSIX)
+function my_func {
+
+# ✅
+my_func() {
+```
+
+---
+
+## 6. Error Handling {#errors}
+
+```bash
+# ❌ No error handling — script continues after failure
+cd /some/dir
+rm -rf *  # if cd fails, deletes from wrong directory
+
+# ✅
+set -euo pipefail
+
+cd /some/dir || { echo "cd failed" >&2; exit 1; }
+rm -rf ./*
+```
+
+```bash
+# ❌ No cleanup on exit
+tmpfile=$(mktemp)
+# ... script might exit early, leaving tmpfile
+
+# ✅ — trap for cleanup
+tmpfile=$(mktemp)
+trap 'rm -f "$tmpfile"' EXIT
+```
+
+```bash
+# ❌ Silencing errors blindly
+command 2>/dev/null
+
+# ✅ — redirect only when you know what you're suppressing
+command 2>/dev/null || true  # explicit: we expect and accept failure
+```
+
+**Start every script with `set -euo pipefail`. Remove selectively where needed.**
+
+---
+
+## 7. Anti-patterns specific to Bash {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| Parsing `ls` output | glob: `for f in *.txt` |
+| `cat file \| grep` | `grep pattern file` |
+| Unquoted `$var` | `"$var"` always |
+| `[ ]` for complex tests | `[[ ]]` |
+| Backtick substitution | `$(command)` |
+| `$?` check after command | `if command; then` |
+| `echo` for debug | `printf '%s\n'` (portable) |
+| No `set -euo pipefail` | always set at script top |
+| Temp files without cleanup | `trap 'rm -f "$tmp"' EXIT` |
+| `eval` with user input | avoid; use arrays for dynamic commands |
+| `#!/bin/sh` with Bash features | `#!/usr/bin/env bash` |
+| String math `expr 1 + 1` | `$(( 1 + 1 ))` |
+| `test -z` for number comparison | `(( ))` for arithmetic |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.