opencode-skills-collection 3.0.49 → 3.0.51

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

@@ -0,0 +1,286 @@
+---
+name: typescript
+description: "Language-specific super-code guidelines for typescript."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# TypeScript / JavaScript: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Array & Object Operations](#arrays)
+2. [Destructuring & Spread](#destructuring)
+3. [Async / Promises](#async)
+4. [Functions & Closures](#functions)
+5. [TypeScript Types](#types)
+6. [React (if applicable)](#react)
+7. [Anti-patterns specific to TS/JS](#antipatterns)
+
+---
+
+## 1. Array & Object Operations {#arrays}
+
+```ts
+// ❌ Imperative push loop
+const result: string[] = []
+for (const item of items) {
+    if (item.active) result.push(item.name.toUpperCase())
+}
+
+// ✅
+const result = items.filter(i => i.active).map(i => i.name.toUpperCase())
+```
+
+```ts
+// ❌ Manual reduce for sum
+let total = 0
+for (const o of orders) total += o.amount
+
+// ✅
+const total = orders.reduce((sum, o) => sum + o.amount, 0)
+```
+
+```ts
+// ❌ Manual object copy + override
+const updated = Object.assign({}, user)
+updated.name = "Alice"
+
+// ✅
+const updated = { ...user, name: "Alice" }
+```
+
+```ts
+// ❌ Existence check before property access
+const city = user.address ? user.address.city : undefined
+
+// ✅
+const city = user.address?.city
+```
+
+---
+
+## 2. Destructuring & Spread {#destructuring}
+
+```ts
+// ❌ Separate variable assignments
+const name = user.name
+const age = user.age
+
+// ✅
+const { name, age } = user
+```
+
+```ts
+// ❌ Index access for array elements
+const first = arr[0]
+const second = arr[1]
+
+// ✅
+const [first, second] = arr
+```
+
+```ts
+// ❌ Merging arrays with concat
+const merged = a.concat(b).concat(c)
+
+// ✅
+const merged = [...a, ...b, ...c]
+```
+
+```ts
+// ❌ Omitting a key by delete (mutates)
+const copy = { ...obj }
+delete copy.password
+
+// ✅ — destructure to omit
+const { password, ...safe } = obj
+```
+
+---
+
+## 3. Async / Promises {#async}
+
+```ts
+// ❌ Promise chain when async/await is cleaner
+fetchUser(id)
+    .then(user => fetchOrders(user.id))
+    .then(orders => process(orders))
+    .catch(handleError)
+
+// ✅
+try {
+    const user = await fetchUser(id)
+    const orders = await fetchOrders(user.id)
+    process(orders)
+} catch (e) {
+    handleError(e)
+}
+```
+
+```ts
+// ❌ Sequential awaits for independent operations
+const user = await fetchUser(id)
+const config = await fetchConfig()
+
+// ✅ — run in parallel
+const [user, config] = await Promise.all([fetchUser(id), fetchConfig()])
+```
+
+```ts
+// ❌ Wrapping already-async function in new Promise
+const result = await new Promise((resolve) => {
+    someAsyncFn().then(resolve)
+})
+
+// ✅
+const result = await someAsyncFn()
+```
+
+**Don't `await` inside a `.map()` without `Promise.all` — it sequences what should be parallel.**
+
+---
+
+## 4. Functions & Closures {#functions}
+
+```ts
+// ❌ Arrow function with unnecessary block body
+const double = (x: number) => { return x * 2 }
+
+// ✅
+const double = (x: number) => x * 2
+```
+
+```ts
+// ❌ Default parameter with if-guard
+function greet(name?: string) {
+    if (!name) name = "World"
+    return `Hello, ${name}`
+}
+
+// ✅
+function greet(name = "World") {
+    return `Hello, ${name}`
+}
+```
+
+```ts
+// ❌ IIFE for no reason in module scope
+;(function() {
+    const x = compute()
+    doSomething(x)
+})()
+
+// ✅ — just top-level statements in a module
+const x = compute()
+doSomething(x)
+```
+
+---
+
+## 5. TypeScript Types {#types}
+
+```ts
+// ❌ Explicit return type when inference is obvious
+function add(a: number, b: number): number {
+    return a + b
+}
+
+// ✅ — let TS infer simple return types
+function add(a: number, b: number) {
+    return a + b
+}
+```
+
+```ts
+// ❌ any
+function process(data: any) { ... }
+
+// ✅ — use unknown + type guard, or a proper type/generic
+function process<T extends Record<string, unknown>>(data: T) { ... }
+```
+
+```ts
+// ❌ Redundant interface for single-use inline shape
+interface UserNameProps { name: string }
+function UserName({ name }: UserNameProps) { ... }
+
+// ✅ — inline for single-use
+function UserName({ name }: { name: string }) { ... }
+// Extract interface when reused in 2+ places
+```
+
+```ts
+// ❌ Type assertion (as) to silence a real type error
+const el = document.getElementById("app") as HTMLDivElement
+el.innerText = "hi" // crashes if el is null
+
+// ✅
+const el = document.getElementById("app")
+if (!(el instanceof HTMLDivElement)) throw new Error("Missing #app")
+el.innerText = "hi"
+```
+
+**Prefer `type` for unions/intersections/aliases; `interface` for extensible object shapes.**
+
+---
+
+## 6. React (if applicable) {#react}
+
+```tsx
+// ❌ Effect for derived state
+const [doubled, setDoubled] = useState(0)
+useEffect(() => { setDoubled(count * 2) }, [count])
+
+// ✅ — compute during render
+const doubled = count * 2
+```
+
+```tsx
+// ❌ useCallback everywhere by default
+const handler = useCallback(() => doSomething(id), [id])
+
+// ✅ — only when passed to memoized child or used as effect dep
+// Otherwise: const handler = () => doSomething(id)
+```
+
+```tsx
+// ❌ Passing object literal as prop (new reference each render)
+<Component config={{ debug: true }} />
+
+// ✅
+const config = useMemo(() => ({ debug: true }), [])
+<Component config={config} />
+// Or if truly static: define outside component
+const CONFIG = { debug: true }
+```
+
+```tsx
+// ❌ Index as key in list that can reorder/filter
+items.map((item, i) => <Row key={i} {...item} />)
+
+// ✅
+items.map(item => <Row key={item.id} {...item} />)
+```
+
+---
+
+## 7. Anti-patterns specific to TS/JS {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| `== null` (loose) | `=== null` or `?? / ?.` |
+| `typeof x === "undefined"` | `x === undefined` or `x == null` (when both null/undefined ok) |
+| `!!x` when boolean coercion is implied | `Boolean(x)` for clarity, or just `x` in conditionals |
+| `var` | `const` by default, `let` when reassigned |
+| `for...in` on arrays | `for...of` or array methods |
+| String template literal with no interpolation | plain string `'...'` |
+| `console.log` left in production code | remove or use a logger |
+| `Object.keys(obj).forEach(...)` | `for (const [k, v] of Object.entries(obj))` |
+| Nested ternaries beyond 2 levels | if/else or early return |
+| `try { ... } catch (e) {}` (silent swallow) | log or rethrow |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.

package/bundled-skills/web-media-getter/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: web-media-getter
+description: "One query across free image / video / GIF APIs (stock + historical/archival + GIF engines), returning normalized, license-tagged results with optional top-K download + attribution sidecar. The retrieval peer to local semantic search and generative media."
+risk: safe
+source: community
+source_type: community
+source_repo: connerkward/web-media-getter-skill
+date_added: "2026-06-16"
+author: Conner K Ward
+license: MIT
+tags:
+  - media
+  - images
+  - video
+  - gif
+  - stock
+  - archival
+  - attribution
+tools:
+  - claude-code
+  - antigravity
+  - cursor
+  - gemini-cli
+  - codex-cli
+---
+## When to Use
+
+Use when a task needs a REAL or ARCHIVAL photo / clip (hero, texture, reference, historical footage) or a reaction / animated GIF, rather than a generated one — fan out across free image/video/GIF sources in one query and download license-tagged results.
+
+_Source: [connerkward/web-media-getter-skill](https://github.com/connerkward/web-media-getter-skill) (MIT)._
+
+# web-media
+
+Query many free image/video sources in one fan-out, get a normalized result list,
+optionally download top-K with an attribution sidecar. Zero-dep stdlib script.
+
+**Script:** `webmedia.py` (in this dir). **Keys:** `PEXELS_API_KEY`, `PIXABAY_API_KEY`
+in `central/.env` (optional — the 5 no-key sources work without them).
+
+## Sources
+
+| Source | Key? | Best for | Media |
+|--------|------|----------|-------|
+| openverse | none | CC web images (Flickr, museums) | image |
+| wikimedia | none | factual / historical / landmark photos | image |
+| internetarchive | none | **historical/archival** images + films | image, video |
+| loc | none | historical US prints/photos | image |
+| nasa | none | space imagery + video | image, video |
+| pexels | free key | modern stock photos + **short video clips** | image, video |
+| pixabay | free key | modern photos/illustrations + **short clips** | image, video |
+| klipy | free key | **GIFs** — recommended (free, unlimited, Tenor drop-in) | gif |
+| giphy | free key | **GIFs** — biggest library (prod key needs approval) | gif |
+
+GIF sources fire only with `--type gif`. Keys: `KLIPY_API_KEY`, `GIPHY_API_KEY`
+in `central/.env`. (tenor adapter removed — Google EOL'd the API 2026-06-30.)
+**klipy** is the one to get (free + unlimited);
+its adapter is **unverified — assumes Tenor-compatible** request/response;
+verify against docs.klipy.com when you key it. `webmedia.py "shrug" --type gif --count 6 --json`
+
+## Usage
+
+```bash
+webmedia.py "1950s street scene" --type image --count 8 --json
+webmedia.py "rocket launch" --type video --source nasa,internetarchive
+webmedia.py "car factory 1930s" --source all --download --out /tmp/cars
+```
+
+- `--source all` (default) | `nokey` (no-key only) | comma list (`wikimedia,pexels`)
+- `--type image|video` · `--count N` · `--json` · `--download --out DIR`
+- `--download` fetches each result's direct media URL and writes `attribution.json`
+  (source, author, license, url, page_url) alongside the files.
+
+## Record schema
+
+`{source, title, url, thumb, dl, page_url, author, license, w, h, type}` —
+`dl` is the directly-downloadable media URL (None when only a page exists).
+
+## The video caveat (important)
+
+Archival sources (Internet Archive, Europeana, LoC) host **whole films/documentaries**,
+not single shots. So:
+- **Modern single clip** → `pexels` / `pixabay` (born as short clips, direct MP4). Done.
+- **Historical single shot** → retrieve the IA film here, then extract the shot:
+  - **Twelve Labs** Marengo search (free 600 min) — pass the IA public MP4 URL, get a
+    timestamped moment for "car on assembly line", clip with ffmpeg. Semantic, cheap.
+  - or **PySceneDetect** (free, local) to cut the film into shots, then rank keyframes
+    with CLIP via the `muser` skill. Fully offline.
+
+## Audio: freesound + audio QA
+
+`webmedia.py` is image/video. For **sound effects** (real, CC-licensed) and for
+**judging audio** (since Claude can't hear), two sibling scripts live in
+`central/scripts/`:
+
+- **`freesound-fetch.py "<query>" [count] [max_sec] [out_dir]`** — searches freesound.org
+  and downloads short hq-mp3 previews. Prints one JSON line per file with
+  `license`/`user` for attribution. Key: `FREESOUND_API_KEY` in `central/.env`
+  (token-based read; full originals would need OAuth — previews suffice for SFX).
+- **`audio-judge.py <file> "<target>"`** — sends the clip to OpenAI `gpt-audio`
+  (audio-native) and returns JSON `{heard, score, matches, suggestion}`, enabling a
+  generate/fetch → judge → iterate loop. Auto-sources a real `sk-` `OPENAI_API_KEY`
+  from `.env` (ignores a local `lm-studio` stub env var). Pads sub-2s clips so the
+  speech-tuned model doesn't refuse. **Caveat:** it reliably *describes* audio and
+  filters obvious mismatches, but it is NOT a trustworthy judge of subjective qualities
+  like "grating" — it labels nearly any beep "sharp/high-pitched". Use it to cull, not
+  to make the final aesthetic call; confirm by ear.
+
+## Where this fits
+
+This is the **internet-retrieval** capability — peer to `muser` (local semantic search)
+and `fal` (generate). A future `media` router would fan out across all three and rank
+candidates by relevance (CLIP), handing aesthetic spreads to `lookdev`. Don't build that
+router until the model demonstrably mis-routes without it.
+
+## Limitations
+
+- Results depend on third-party API availability, quotas, credentials, and license metadata quality.
+- License tags and attribution fields must still be reviewed before commercial or public use.
+- Relevance ranking can find plausible assets, but final aesthetic fit, brand safety, and audio suitability require human inspection.

package/bundled-skills/youtube-seo-optimizer/SKILL.md

@@ -133,11 +133,11 @@ How · Why · What · Best · Full · Real · Free · New · Step-by-Step · Com
 
 ## Tags Strategy
 
-Use for every mode that includes tags (A-F). Generate 15-20 tags using this mix:
+Use for long-form modes (A-D) that include tags. Generate 14-19 tags using this mix. For short-form (E-F), see the Shorts section for the 5-8 tag rule.
 
 | Type | Count | Rule |
 |---|---|---|
-| Exact match primary keyword | 2 | Must match Step 1 target keyword exactly |
+| Exact match primary keyword | 1 | Must match Step 1 target keyword exactly |
 | Broad topic | 3-4 | 1-2 word umbrella terms |
 | Long-tail (3-5 words) | 5-6 | Pulled from Step 1 research |
 | Question-based | 2 | "how to [topic]", "what is [topic]" |
@@ -311,7 +311,7 @@ Character count: [N]/70
 5. [secondary keyword from Step 1 research]
 
 ⑤ TAGS
-[tag1], [tag2], [tag3] ... [tag15-20 total]
+[tag1], [tag2], [tag3] ... [tag14-19 total]
 Total character count: [N]/500
 
 ⑥ HASHTAGS
@@ -399,7 +399,7 @@ Chapters in description: Yes / No
 Links/CTA present: Yes / No
 
 TAGS ANALYSIS
-Count: [N] (ideal: 15-20)
+Count: [N] (ideal: 14-19)
 Tag type coverage: [which of 7 types are missing]
 
 HASHTAG ANALYSIS
@@ -429,7 +429,7 @@ Character count: [N]/70
 [Full 3-block description]
 
 ④ REWRITTEN TAGS
-[15-20 tags across all 7 types]
+[14-19 tags across all 7 types]
 
 ⑤ REWRITTEN HASHTAGS
 #Tag1 #Tag2 #Tag3 #Tag4 #Tag5 [#Tag6 #Tag7 optional]
@@ -507,7 +507,7 @@ Character count: [N]/70
 5. [show name + topic]
 
 ⑤ TAGS
-[tag1], [tag2] ... [tag15-20 — include show + guest name]
+[tag1], [tag2] ... [tag14-19 — include show + guest name]
 Total: [N]/500
 
 ⑥ HASHTAGS
@@ -605,7 +605,7 @@ Timestamps present: Yes / No
 Platform links present: Yes / No
 
 TAGS ANALYSIS
-Count: [N] (ideal: 15-20)
+Count: [N] (ideal: 14-19)
 Show / guest name as tags: Yes / No
 
 TOPICS / TIMESTAMPS ANALYSIS
@@ -628,7 +628,7 @@ Character count: [N]/70
 [3-block structure, guest bio in Block 2, platform links in Block 3]
 
 ④ REWRITTEN TAGS
-[15-20 tags including show + guest name]
+[14-19 tags including show + guest name]
 
 ⑤ REWRITTEN HASHTAGS
 #Tag1 #Tag2 #Tag3 #Tag4 #Tag5 [#Tag6 #Tag7 optional]
@@ -866,7 +866,7 @@ Then run the Quality Checklist below.
 - [ ] Hashtags on final line only
 
 ### Tags & Hashtags
-- [ ] 15-20 tags, under 500 chars, all 7 types represented
+- [ ] 14-19 tags, under 500 chars, all 7 types represented
 - [ ] No hashtag symbols in the tags field
 - [ ] 5-8 hashtags (3-5 for short-form), CamelCase, strongest 3 first
 - [ ] Hashtag set differs from recent uploads

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "3.0.49",
+  "version": "3.0.51",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",