opencode-skills-collection 4.1.5 → 4.1.6

package/bundled-skills/supercov/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: supercov
+description: "Measure line, branch and MC/DC coverage of a project's existing tests with the supercov CLI, then write small, focused tests for the code no test reaches."
+category: testing
+risk: critical
+source: https://github.com/supercorp-ai/supercov/tree/main/plugins/supercov/skills/supercov
+source_repo: supercorp-ai/supercov
+source_type: community
+date_added: "2026-10-04"
+author: Supercorp
+tags: [testing, coverage, mcdc, test-generation]
+tools: [claude, cursor, gemini, codex]
+license: MIT
+license_source: https://github.com/supercorp-ai/supercov/blob/main/LICENSE
+---
+
+# Supercov
+
+## Overview
+
+Supercov runs the project's own test command on the user's machine and reports line, branch and MC/DC coverage per test. It changes no source, tests or configuration. This skill uses that report to pick one untested piece of code at a time and write a focused test for it.
+
+It works with JavaScript, TypeScript, Python, Ruby, Rust, Go, Java and Kotlin projects.
+
+## When to Use This Skill
+
+- Use when the user asks to add or improve tests.
+- Use when the user asks which code is untested, or asks to raise coverage.
+- Use when the user asks which file to refactor first and has agreed to a quality check (see "Quality check").
+
+## Preconditions
+
+- Node.js 22 or newer. If it is missing, tell the user. Do not install software without the user's approval.
+- The project's test command, for example `npm test`, `pytest` or `cargo test`. Ask if it is not obvious from the repository.
+- Always run the pinned version, `npx supercov@3.0.4`. The first run downloads that release from npm, so get the user's approval before it.
+
+## How It Works
+
+### Step 1: Measure the suite
+
+Run the full test command under Supercov. Coverage is measured locally and sends nothing over the network.
+
+```bash
+npx supercov@3.0.4 -- npm test
+```
+
+### Step 2: Pick a target
+
+List the untested code, pick one item, and read it in context.
+
+```bash
+npx supercov@3.0.4 runs latest gaps --limit 5
+npx supercov@3.0.4 runs latest file src/session.js
+```
+
+### Step 3: Write one focused test
+
+Write one test for the chosen target. Change only test files unless the user asks otherwise.
+
+### Step 4: Rerun and report
+
+Rerun the command from step 1. Report the test you added and the coverage before and after.
+
+For anything not shown here, `npx supercov@3.0.4 docs <topic>` prints the guide for that version. Topics: `agent-loop`, `quality`, `supported-suites`, `troubleshooting`.
+
+## Examples
+
+### Example 1: Add a test for untested code
+
+```bash
+npx supercov@3.0.4 -- npm test
+npx supercov@3.0.4 runs latest gaps --limit 5
+# add one test for the first gap, then:
+npx supercov@3.0.4 -- npm test
+```
+
+### Example 2: Other languages
+
+```bash
+npx supercov@3.0.4 -- pytest
+npx supercov@3.0.4 -- cargo test
+npx supercov@3.0.4 -- go test ./...
+npx supercov@3.0.4 -- ./gradlew test
+```
+
+## Quality check
+
+`npx supercov@3.0.4 quality` ranks files by code smells, and `npx supercov@3.0.4 quality patch` reports what a change introduced.
+
+- These two commands send the project's source files to TypeSafe's API for analysis. Run them only when the user asked for a quality check, and tell the user before running that their source files will be sent to TypeSafe.
+- They need the user's own `TYPESAFE_API_KEY` in the environment. Never ask the user to paste a key into the conversation, and never create, read or print one.
+- If the key is missing, tell the user the check needs it, then answer from reading the code and say Supercov did not check it.
+
+## Best Practices
+
+- ✅ Measure the full suite first, so the gaps reflect every test.
+- ✅ Add one test per gap and rerun before picking the next.
+- ✅ Report coverage before and after with the numbers Supercov printed.
+- ❌ Don't change application code to raise coverage unless the user asks.
+- ❌ Don't run the quality commands without the user's request and consent.
+
+## Limitations
+
+- Coverage shows which code ran under a test. It does not show that the test checked the result.
+- Supercov measures the suites listed in `npx supercov@3.0.4 docs supported-suites`. Other runners are not measured.
+- The test command runs as the project defines it. If the suite needs services, credentials or network access, those needs still apply.
+- This skill does not replace environment-specific validation, testing, or expert review.
+- Stop and ask for clarification if required inputs, permissions, or safety boundaries are missing.
+
+## Security & Safety Notes
+
+- The skill runs the project's own test command and writes test files in the user's repository. Run it only in a repository the user has authorized, and keep changes to test files unless the user asks otherwise.
+- Supercov writes its run data to a `.supercov` directory in the project. It does not edit source, tests or configuration.
+- `npx supercov@3.0.4` downloads a pinned release from the npm registry. Get the user's approval before the first run. Upgrading the pin needs a new review.
+- Coverage commands make no network requests. Only the quality commands contact a third party, TypeSafe's API, and only with the user's consent and their own key.
+
+## Related Skills
+
+- `@test-driven-development` - Use when the behavior does not exist yet and the test should come first.

package/bundled-skills/turn-this-into-a-thread/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: turn-this-into-a-thread
+description: "Turn a long idea, transcript, article or draft into a Twitter/X thread where every tweet stands alone. Use when someone asks for a thread or to break long writing into tweets."
+category: marketing
+risk: critical
+source: "https://github.com/prateeks367/voicemoat-skills/tree/7623a3effbee426554e8c5df55e77f3479fd0ec0/skills/turn-this-into-a-thread"
+source_repo: prateeks367/voicemoat-skills
+source_type: official
+date_added: "2026-10-04"
+license: MIT
+license_source: "https://github.com/prateeks367/voicemoat-skills/blob/7623a3effbee426554e8c5df55e77f3479fd0ec0/LICENSE"
+author: prateeks367
+tags: [twitter, threads, writing, social-media]
+tools: [claude, cursor, gemini, codex]
+---
+
+# Turn this into a thread
+
+Most threads fail for one of two reasons. Either they are an article chopped
+into tweet-sized pieces, so no individual tweet is worth reading, or they are a
+small idea stretched to eleven tweets because the writer thought longer meant
+better.
+
+A thread works when each tweet would be a decent post on its own, and the order
+makes it better.
+
+## When to Use
+
+- Use when someone asks for a Twitter/X thread.
+- Use when someone asks to break a long idea, transcript, article or rambling draft into tweets.
+- Use when a piece of writing is too long for one post.
+- Do not use it for LinkedIn, which has no threads, and do not pad a small idea into a long thread.
+
+## Step 1: decide whether it should be a thread at all
+
+Ask what the idea actually is, in one sentence.
+
+If the answer is a single point with one piece of support, it is a post. Say so
+and offer to write that instead. A three-tweet thread that should have been one
+tweet loses readers at tweet two and looks like padding.
+
+Threads earn their length when there is a genuine sequence: steps, a story with
+turns, several distinct points under one argument, or a list where each item
+stands alone.
+
+## Step 2: find the spine
+
+Before writing tweets, write the skeleton. One line per beat, in order. Usually
+five to nine beats. If you cannot fill seven without repeating yourself, the
+thread is shorter than you thought, and that is good news.
+
+Check the order does something. If the beats could be shuffled with no loss, it
+is a list, not a thread, and it should be labelled as one so readers know they
+can dip in.
+
+## Step 3: write it
+
+**The first tweet is the whole thread's job interview.** It has to make sense
+alone and promise something specific. Not "a thread on writing" but the actual
+claim. Never open with "A thread 🧵" as the substance; the reader can see it is
+a thread.
+
+**Every following tweet must survive alone.** No tweet should begin with a word
+that only makes sense if you read the last one. Someone will land on tweet
+five, and quoting it should not embarrass them.
+
+**One idea per tweet.** Two ideas in a tweet means one of them is wasted.
+
+**Land it.** The last tweet closes the loop opened by the first. If it ends
+with a call to action, keep it to one, and only if it is honest.
+
+## Step 4: format it properly
+
+Separate each tweet with a line containing only three dashes:
+
+```
+First tweet text.
+
+---
+
+Second tweet text.
+```
+
+That is the separator VoiceMoat uses to chain a thread, and it also just reads
+cleanly if the person is posting by hand.
+
+Number the tweets only if the order is genuinely instructional. Numbering a
+story makes it feel like homework.
+
+## Example
+
+```text
+User: Turn this 1,200-word blog post about how we cut our cloud bill into a
+thread.
+
+Agent:
+1. The idea in one sentence, checked with the user.
+2. The spine: one line per beat, in order, shown before any tweet is written.
+3. The thread, each tweet separated by a line containing only three dashes,
+   with a first tweet that makes the specific claim.
+4. A note if the material only supports five tweets rather than seven.
+```
+
+## Limitations
+
+- Twitter/X only. LinkedIn has no threads.
+- It will not pad a small idea into a long thread. If the idea is one point, it says so and offers a single post instead.
+- It cannot promise reach or engagement.
+- **Optional connector.** The closing section describes a hosted VoiceMoat MCP connector. Nothing above needs it. It needs a paid VoiceMoat plan (Pro or Enterprise) and the user's own sign-in (OAuth, no API keys). When its tools are called, post text and account data are read from or sent to voicemoat.com. Without it, this skill makes no network calls.
+- **Publishing.** `publish_post` and `schedule_post` post to the user's real Twitter/X or LinkedIn account. They return a preview first and only post on a second call that carries a one-time code. Make that second call only after the user has read the preview and said yes.
+
+## What changes when VoiceMoat is connected
+
+- `get_voice_profile` means the thread sounds like your Twitter voice
+  specifically, which in VoiceMoat is a separate trained profile from your
+  LinkedIn one. Threads written in a LinkedIn register are a common and
+  obvious failure.
+- `score_voice_match` scores the drafted thread against that profile.
+- `improve_post` accepts a thread rather than treating it as one long post, so
+  the improvement pass respects the tweet boundaries instead of rewriting
+  across them.
+- `publish_post` posts the thread as a genuinely chained thread, splitting on
+  that three-dash separator and replying each part to the one before, behind a
+  preview and a one-time confirmation. `schedule_post` queues it the same way.
+
+Never make the second call on your own. Show the person the exact preview the
+first call returns and wait for a clear yes before you send the one-time code
+back. Never make both calls in one step.
+
+VoiceMoat is at voicemoat.com. The connector needs the Pro or Enterprise plan.

package/bundled-skills/why-did-this-post-flop/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: why-did-this-post-flop
+description: "Diagnose why one Twitter/X or LinkedIn post underperformed: not seen, seen and skipped, or read and ignored. Use when someone asks why a post did badly or got no engagement."
+category: marketing
+risk: safe
+source: "https://github.com/prateeks367/voicemoat-skills/tree/7623a3effbee426554e8c5df55e77f3479fd0ec0/skills/why-did-this-post-flop"
+source_repo: prateeks367/voicemoat-skills
+source_type: official
+date_added: "2026-10-04"
+license: MIT
+license_source: "https://github.com/prateeks367/voicemoat-skills/blob/7623a3effbee426554e8c5df55e77f3479fd0ec0/LICENSE"
+author: prateeks367
+tags: [linkedin, twitter, analytics, post-review, social-media]
+tools: [claude, cursor, gemini, codex]
+---
+
+# Why did this post flop?
+
+Almost everyone diagnoses this wrong. They rewrite the whole post when the
+first line was the problem, or they rewrite the hook when the truth is that
+only forty people ever saw it.
+
+There are three different failures here and they need different fixes. Separate
+them before saying anything.
+
+## When to Use
+
+- Use when someone asks why a Twitter/X or LinkedIn post did badly.
+- Use when someone asks why nobody engaged with a post.
+- Use when a post they were proud of went nowhere.
+- Use when someone wants one specific post diagnosed.
+- Do not use it to review a whole account, and do not guess at numbers the person has not given you.
+
+## Step 1: get the numbers, or say you cannot do this
+
+Ask for the post text and its impressions, likes or reactions, comments and
+reposts. Both platforms show these to the author.
+
+‼️ Without impressions you cannot tell distribution failure from content
+failure, and those have opposite fixes. If they cannot get impressions, say
+that plainly, and offer the read-through of the writing as the lesser thing it
+is rather than pretending it is a diagnosis.
+
+Also ask what "flopped" means to them. Compared with what? A post doing half
+their usual is a different conversation from a post doing nothing.
+
+## Step 2: find which of the three failures it was
+
+**Few impressions.** The post was barely distributed. The writing is not the
+problem, so rewriting the hook would fix nothing. Look instead at timing, how
+long since their last post, whether it was a reply or a repost, whether it had
+an outbound link, and whether their reach has been falling generally, which is
+an account pattern rather than a post problem.
+
+**Impressions fine, engagement near zero.** People saw it and scrolled. This is
+the first line, or the shape. This is also the most common case and the one
+worth the most work.
+
+**Engagement fine, but not what they wanted.** Likes but no comments, or
+comments but no clicks. The post worked and asked for the wrong thing, or asked
+for nothing.
+
+Name which one it was, and say what it rules out. Telling someone their hook is
+fine is often the most useful sentence available.
+
+## Step 3: only now, look at the writing
+
+If it is the second case, read the first line alone and ask whether it makes
+the next line necessary. Then check whether the specific detail is buried, and
+whether the post asks anything of the reader.
+
+## Step 4: be honest about variance
+
+Sometimes a good post does badly. Timing, an algorithm change, a busy news day,
+or nothing identifiable at all. One post is a sample of one.
+
+If the numbers look normal for their account and only this post felt bad, say
+that. Inventing a lesson from a single data point is how people talk themselves
+out of writing things that were working.
+
+## Step 5: one change, not five
+
+End with a single thing to do differently next time, and say whether you expect
+it to matter a lot or a little. A list of six improvements gets none of them
+applied.
+
+## Example
+
+```text
+User: Why did this LinkedIn post flop? 380 impressions, 6 reactions, 0
+comments. My posts usually get about 2,000 impressions.
+
+Agent:
+1. Names the failure: few impressions, so a distribution problem, not the
+   writing.
+2. Says what that rules out: rewriting the hook would not have fixed it.
+3. Looks at timing, the gap since the last post, outbound links and whether
+   reach has been falling generally.
+4. Ends with one change to try next time and how much it is likely to matter.
+```
+
+## Limitations
+
+- One post at a time. It does not review a whole account.
+- It needs the post's numbers, impressions above all. Without them it can only offer a read-through of the writing and says so.
+- One post is a sample of one. It will not invent a lesson from a single data point.
+- **Optional connector.** The closing section describes a hosted VoiceMoat MCP connector. Nothing above needs it. It needs a paid VoiceMoat plan (Pro or Enterprise) and the user's own sign-in (OAuth, no API keys). When its tools are called, post text and account data are read from or sent to voicemoat.com. Without it, this skill makes no network calls.
+
+## What changes when VoiceMoat is connected
+
+The weakest part above is that everything depends on numbers someone typed in,
+and on their memory of what normal looks like.
+
+- `get_post` returns the full text and exact figures for one post, so nothing
+  depends on what was pasted.
+- `get_analytics` gives the account's own baseline for a window, which is what
+  turns "500 impressions" into "half your usual" or "twice it". Without that
+  baseline the whole diagnosis is guesswork.
+- `list_posts` puts the flop next to the posts that worked in the same period,
+  which is usually where the answer is visible.
+- `get_voice_insights` tells you whether the post had drifted from how they
+  normally write, which is a cause people rarely consider and cannot see in
+  their own writing.
+
+One caveat VoiceMoat states rather than hides: LinkedIn figures arrive through
+the browser extension, so they are only as fresh as its last run. A post that
+looks like it got nothing may simply not have synced yet, and the tools return
+the last sync date so you can tell the difference.
+
+VoiceMoat is at voicemoat.com. The connector needs the Pro or Enterprise plan.

package/bundled-skills/write-in-my-voice/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: write-in-my-voice
+description: "Draft a Twitter/X or LinkedIn post that sounds like the person asking, from posts they already wrote. Use when someone asks for a post or rewrite in their voice, or asks if text sounds like them."
+category: marketing
+risk: critical
+source: "https://github.com/prateeks367/voicemoat-skills/tree/7623a3effbee426554e8c5df55e77f3479fd0ec0/skills/write-in-my-voice"
+source_repo: prateeks367/voicemoat-skills
+source_type: official
+date_added: "2026-10-04"
+license: MIT
+license_source: "https://github.com/prateeks367/voicemoat-skills/blob/7623a3effbee426554e8c5df55e77f3479fd0ec0/LICENSE"
+author: prateeks367
+tags: [linkedin, twitter, writing, voice, social-media]
+tools: [claude, cursor, gemini, codex]
+---
+
+# Write it in my voice
+
+Most AI drafts fail the same way. They are competent and they sound like
+nobody. The fix is not a better prompt, it is having something concrete to
+match against, so this workflow builds that first and then measures the draft
+against it.
+
+Never skip to drafting. A post written before you know how this person writes
+is a guess, and it will read like one.
+
+## When to Use
+
+- Use when someone asks for a Twitter/X or LinkedIn post, a thread, a hook or a rewrite that should sound like them.
+- Use when someone asks whether a piece of text sounds like them.
+- Do not use it for writing that is not going on social media.
+
+## Step 1: get something real to match against
+
+Ask for **five recent posts they wrote themselves**, pasted in. Not their
+favourite posts, and not posts they admire from other people. Ordinary ones.
+
+If they cannot paste posts, ask these four instead and work from the answers:
+
+1. What do you write about, and who reads it?
+2. Do you open with a claim, a story, or a question?
+3. Short and punchy, or a longer build?
+4. What would you never say? Words, phrases, or a whole register.
+
+If they give you neither, say plainly that you can write a decent generic post
+but not one in their voice, and let them choose.
+
+## Step 2: build the sketch, and show it to them
+
+From what you have, write down:
+
+- **Openings.** How the first line earns the second. Claim, story, number,
+  question, contradiction.
+- **Length and shape.** Sentence length, paragraph length, whether they use
+  line breaks as punctuation.
+- **Vocabulary.** Words they reach for. Words they clearly avoid.
+- **Register.** Formal, blunt, warm, dry, self-deprecating.
+- **Never.** Emoji, hashtags, hype words, engagement bait, exclamation marks.
+  Whatever the samples show they do not do.
+
+Show this sketch to the person before you draft, in about six lines. They will
+correct one thing, and that correction is worth more than another three samples.
+
+‼️ Be honest about what it is. A sketch from five posts is a sketch from five
+posts. Do not call it their voice profile and do not imply you have analysed
+their whole history.
+
+## Step 3: draft
+
+Write the post yourself, against the sketch. One draft, not three, unless they
+asked for options.
+
+If they are stuck on an opening, offer three from genuinely different angles:
+contrarian, story, and reframe. Let them pick rather than picking for them.
+
+## Step 4: check it, out loud
+
+Before you hand the draft over, go through the sketch line by line and say what
+matches and what does not. Something like: the opening is a claim, which fits;
+the third sentence is longer than anything in your samples; "leverage" does not
+appear once in five posts and it is in this draft twice.
+
+Then fix what you named. Once. If it is still off after one pass, say what you
+cannot get right and ask them what you are missing, rather than rewriting the
+same post a fourth time and hoping.
+
+Never claim a numeric score. You are comparing against a handful of samples,
+not measuring, and a number would imply a precision you do not have.
+
+## Step 5: hand it over honestly
+
+Give them the post, and one line on what you were unsure about. A draft
+delivered with its weak spot named gets edited. A draft delivered with a
+flourish gets posted and regretted.
+
+## Example
+
+```text
+User: Here are five LinkedIn posts I wrote last month. Draft one about why we
+stopped doing weekly status meetings, in my voice.
+
+Agent:
+1. Voice sketch in six lines: opens with a blunt claim, short paragraphs, dry
+   tone, no emoji or hashtags, never says "excited to share".
+2. Asks whether anything in the sketch is wrong before drafting.
+3. One draft, written against the sketch.
+4. The check, out loud: the opening is a claim (fits); the third paragraph is
+   longer than any sample (trimmed); "leverage" is not in the samples (removed).
+5. One line on what it was unsure about.
+```
+
+## Limitations
+
+- Social posts only. It is not for writing that is not going on Twitter/X or LinkedIn.
+- Without the connector, the voice sketch comes only from what the person pastes. It is a sketch, not a measured profile, and the skill never gives a numeric score.
+- It cannot promise reach or engagement.
+- **Optional connector.** The closing section describes a hosted VoiceMoat MCP connector. Nothing above needs it. It needs a paid VoiceMoat plan (Pro or Enterprise) and the user's own sign-in (OAuth, no API keys). When its tools are called, post text and account data are read from or sent to voicemoat.com. Without it, this skill makes no network calls.
+- **Publishing.** `publish_post` and `schedule_post` post to the user's real Twitter/X or LinkedIn account. They return a preview first and only post on a second call that carries a one-time code. Make that second call only after the user has read the preview and said yes.
+
+## What changes when VoiceMoat is connected
+
+Everything above works with nothing installed. With a VoiceMoat account
+connected, the guesswork in steps 1, 2 and 4 is replaced with real data:
+
+- `get_voice_profile` returns a voice profile trained on your own published
+  posts rather than a sketch from five pasted posts, including the phrases
+  you never use.
+- `score_voice_match` scores the draft from 0 to 100 against that profile and
+  names what is off. That is a measurement, not the read-through in step 4.
+- `get_voice_insights` returns your dominant patterns, hook style and sentence
+  rhythm, and how far your recent posts have drifted from your own baseline.
+- `publish_post` and `schedule_post` put the finished post on Twitter or
+  LinkedIn, behind a preview and a one-time confirmation so nothing goes out
+  that you have not read.
+
+Never make the second call on your own. Show the person the exact preview the
+first call returns and wait for a clear yes before you send the one-time code
+back. Never make both calls in one step.
+
+VoiceMoat is at voicemoat.com. The connector needs the Pro or Enterprise plan.

package/package.json

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