opencode-skills-collection 3.0.37 → 3.0.38

package/bundled-skills/linkedin-content-generator/scripts/generate_newsletter.py

@@ -0,0 +1,64 @@
+"""
+generate_newsletter.py — LinkedIn Newsletter Prompt Builder
+
+Usage:
+  python generate_newsletter.py --topic "<topic>" --niche "<niche>" [--title "<title>"] [--length <length>]
+
+Length: short (~700w) | medium (~1200w) | long (~2000w)
+"""
+
+import argparse
+import sys
+import os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+from utils import get_base_prompt_context
+
+LENGTH_GUIDE = {
+    "short":  "~600-800 words. Quick, punchy, skimmable. 2-3 sections max.",
+    "medium": "~1000-1400 words. Balanced depth and readability. 3-4 sections.",
+    "long":   "~1800-2500 words. Deep dive. 4-6 sections with subsections.",
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a LinkedIn Newsletter prompt")
+    parser.add_argument("--topic", required=True)
+    parser.add_argument("--niche", required=True)
+    parser.add_argument("--title", required=False, default="")
+    parser.add_argument("--length", required=False, default="medium", choices=list(LENGTH_GUIDE.keys()))
+
+    args = parser.parse_args()
+
+    length_instruction = LENGTH_GUIDE.get(args.length, LENGTH_GUIDE["medium"])
+    title_line = f"**Newsletter Title**: {args.title}" if args.title else "**Newsletter Title**: Generate a compelling SEO-optimised headline."
+    context = get_base_prompt_context(args.niche, "LinkedIn Newsletter Article")
+
+    prompt = f"""{context}
+
+<TASK>
+Generate a complete LinkedIn Newsletter edition.
+
+**Topic**: {args.topic}
+**Niche**: {args.niche}
+{title_line}
+**Length**: {args.length.upper()} — {length_instruction}
+
+Required structure:
+1. Headline (H1) — catchy, SEO-optimised, keyword-rich
+2. Opening Hook — personal anecdote, surprising statistic, or bold claim (2-3 sentences)
+3. Body Sections (H2 subheadings) — background, insights, examples, data
+4. Key Takeaways — bulleted list (3-5 items)
+5. Action Step — 1 specific thing to do this week
+6. Engagement Question — ask 1 question to spark comments
+
+Formatting: Markdown (H1, H2, H3, bold, bullets). Short paragraphs only.
+Output ONLY the final newsletter. No commentary.
+</TASK>"""
+
+    print(prompt)
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/linkedin-content-generator/scripts/generate_post.py

@@ -0,0 +1,77 @@
+"""
+generate_post.py — LinkedIn Post Prompt Builder
+
+Usage:
+  python generate_post.py --topic "<topic>" --niche "<niche>" [--tone <tone>] [--style <style>]
+
+Tone: professional | storytelling | controversial | educational | motivational
+Style: text-only | list-based | storytelling | data-driven | contrarian
+"""
+
+import argparse
+import sys
+import os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+from utils import get_base_prompt_context
+
+TONE_GUIDE = {
+    "professional":  "Write with authority and expertise. Clear, polished, data-backed where possible.",
+    "storytelling":  "Lead with a personal story or narrative. Make the reader feel something before delivering the insight.",
+    "controversial": "Take a bold, contrarian stance. Challenge the conventional wisdom in the niche. Prepare for debate.",
+    "educational":   "Break down a complex concept simply. Use analogies, numbered steps, or mini-frameworks.",
+    "motivational":  "Inspire and energize. Use strong action verbs. Make the reader feel capable and driven.",
+}
+
+STYLE_GUIDE = {
+    "text-only":   "Write as flowing text paragraphs. No bullet points. Pure conversational prose.",
+    "list-based":  "Structure the core value as a numbered or bulleted list. Maximum 7 items.",
+    "storytelling":"Write as a narrative arc: Setup → Conflict → Resolution → Lesson.",
+    "data-driven": "Anchor every key point with a statistic, study, or concrete example.",
+    "contrarian":  "Start by stating what everyone believes, then flip it. Use 'But here's what they miss:' or similar.",
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a LinkedIn Post prompt")
+    parser.add_argument("--topic", required=True)
+    parser.add_argument("--niche", required=True)
+    parser.add_argument("--tone", required=False, default="professional", choices=list(TONE_GUIDE.keys()))
+    parser.add_argument("--style", required=False, default="list-based", choices=list(STYLE_GUIDE.keys()))
+
+    args = parser.parse_args()
+
+    tone_instruction  = TONE_GUIDE.get(args.tone, TONE_GUIDE["professional"])
+    style_instruction = STYLE_GUIDE.get(args.style, STYLE_GUIDE["list-based"])
+    context = get_base_prompt_context(args.niche, "LinkedIn Text Post")
+
+    prompt = f"""{context}
+
+<TASK>
+Generate a single, ready-to-publish LinkedIn post.
+
+**Topic**: {args.topic}
+**Niche**: {args.niche}
+**Tone**: {tone_instruction}
+**Style**: {style_instruction}
+
+Mandatory output structure:
+1. Hook (2 lines — scroll-stopping)
+2. [blank line]
+3. Body (follow tone + style instructions)
+4. [blank line]
+5. Key Takeaway (1-2 punchy sentences)
+6. [blank line]
+7. CTA (specific, value-driven)
+8. [blank line]
+9. Hashtags (3-5 only)
+
+Output ONLY the final post. No preamble. Ready to paste into LinkedIn.
+</TASK>"""
+
+    print(prompt)
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/linkedin-content-generator/scripts/memory.md

@@ -0,0 +1,49 @@
+# LinkedIn Content Memory
+
+This file is the reinforcement learning database for the LinkedIn Content Skill.
+It is automatically read by every generator script to personalise your content.
+Use `/feedback` to update it. Use `/show-memory` to review it.
+
+---
+
+## 🧠 Core Identity & Tone
+- **Primary Niche:** (Update this — e.g. "AI & Technology", "Marketing", "SaaS")
+- **Tone:** Professional, insightful, concise, and story-driven.
+- **Voice:** First-person. Confident but humble. Write to one person, not an audience.
+- **Formatting Preference:** Short paragraphs (1-2 sentences). Aggressive line breaks. Bullet points over dense paragraphs.
+- **Emojis:** Use sparingly — 2-3 max per post, only where they genuinely add value.
+- **CTA Style:** Specific and value-driven. Never "like and share" — always give a reason.
+
+---
+
+## 🎯 Successful Hooks
+> Add hooks that received high engagement here.
+- (Empty — use `/feedback` to add your first successful hook)
+
+---
+
+## 📈 Top Performing Formats
+> Note which content formats get the best reactions.
+- (Empty — use `/feedback` to log your best performing format)
+
+---
+
+## 🔑 High-Performing Topics
+> Track which topics resonate most with your audience.
+- (Empty — use `/feedback` to log topics that hit well)
+
+---
+
+## 🚫 What to Avoid
+> Patterns, phrases, or formats that underperformed.
+- Avoid cliché openers like "In today's fast-paced world..."
+- Avoid posting without a clear CTA
+- Avoid hashtag stuffing (max 5)
+
+---
+
+## 📝 Positive Feedback Log
+
+### [2026-06-01 21:58] — test-01
+- **What worked:** Great hook!
+- **Tags:** `hook`

package/bundled-skills/linkedin-content-generator/scripts/memory_manager.py

@@ -0,0 +1,134 @@
+"""
+memory_manager.py — Reinforcement Learning Memory Manager for LinkedIn Content Skill.
+Resolves memory.md relative to this script's location (inside .claude/skills/scripts/).
+
+Commands:
+  python memory_manager.py add   --id <id> --feedback <text> [--tags <tags>]
+  python memory_manager.py read
+  python memory_manager.py clear
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+
+# ─── Configuration ────────────────────────────────────────────────────────────
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+MEMORY_FILE = os.path.join(SCRIPT_DIR, "memory.md")
+
+MEMORY_TEMPLATE = """# LinkedIn Content Memory
+
+This file is the reinforcement learning database for the LinkedIn Content Skill.
+It is automatically read by every generator script to personalise your content.
+Use `/feedback` to update it. Use `/show-memory` to review it.
+
+---
+
+## 🧠 Core Identity & Tone
+- **Primary Niche:** (Update this — e.g. "AI & Technology", "Marketing", "SaaS")
+- **Tone:** Professional, insightful, concise, and story-driven.
+- **Voice:** First-person. Confident but humble. Write to one person, not an audience.
+- **Formatting Preference:** Short paragraphs (1-2 sentences). Aggressive line breaks. Bullet points over dense paragraphs.
+- **Emojis:** Use sparingly — 2-3 max per post, only where they genuinely add value.
+- **CTA Style:** Specific and value-driven. Never "like and share" — always give a reason.
+
+---
+
+## 🎯 Successful Hooks
+> Add hooks that received high engagement here.
+- (Empty — use `/feedback` to add your first successful hook)
+
+---
+
+## 📈 Top Performing Formats
+> Note which content formats get the best reactions.
+- (Empty — use `/feedback` to log your best performing format)
+
+---
+
+## 🔑 High-Performing Topics
+> Track which topics resonate most with your audience.
+- (Empty — use `/feedback` to log topics that hit well)
+
+---
+
+## 🚫 What to Avoid
+> Patterns, phrases, or formats that underperformed.
+- Avoid cliché openers like "In today's fast-paced world..."
+- Avoid posting without a clear CTA
+- Avoid hashtag stuffing (max 5)
+
+---
+
+## 📝 Positive Feedback Log
+"""
+
+
+def ensure_memory_exists():
+    if not os.path.exists(MEMORY_FILE):
+        with open(MEMORY_FILE, "w", encoding="utf-8") as f:
+            f.write(MEMORY_TEMPLATE)
+
+
+def read_memory() -> str:
+    ensure_memory_exists()
+    with open(MEMORY_FILE, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def append_feedback(content_id: str, feedback_text: str, tags: str = ""):
+    ensure_memory_exists()
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+    entry = f"\n### [{timestamp}] — {content_id}\n"
+    entry += f"- **What worked:** {feedback_text}\n"
+    if tags:
+        entry += f"- **Tags:** `{tags.strip()}`\n"
+
+    with open(MEMORY_FILE, "a", encoding="utf-8") as f:
+        f.write(entry)
+
+    print(json.dumps({
+        "status": "success",
+        "message": f"✅ Memory updated in {MEMORY_FILE}",
+        "entry_id": content_id,
+        "timestamp": timestamp,
+        "instruction": "This feedback will now be injected into all future content generation prompts."
+    }, indent=2))
+
+
+def clear_memory():
+    with open(MEMORY_FILE, "w", encoding="utf-8") as f:
+        f.write(MEMORY_TEMPLATE)
+    print(json.dumps({
+        "status": "success",
+        "message": "✅ Memory has been cleared and reset to defaults."
+    }, indent=2))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="LinkedIn Content Skill — Memory Manager")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    add_parser = subparsers.add_parser("add", help="Save positive feedback to memory")
+    add_parser.add_argument("--id", required=True)
+    add_parser.add_argument("--feedback", required=True)
+    add_parser.add_argument("--tags", required=False, default="")
+
+    subparsers.add_parser("read", help="Display current memory")
+    subparsers.add_parser("clear", help="Reset memory to defaults")
+
+    args = parser.parse_args()
+
+    if args.command == "add":
+        append_feedback(args.id, args.feedback, args.tags)
+    elif args.command == "read":
+        print(read_memory())
+    elif args.command == "clear":
+        clear_memory()
+
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/linkedin-content-generator/scripts/utils.py

@@ -0,0 +1,96 @@
+"""
+utils.py — Shared prompt-building utilities for the LinkedIn Content Skill.
+Reads the user's reinforcement learning memory from memory.md (same directory)
+and constructs richly engineered system prompts for Claude to consume.
+"""
+
+import os
+import sys
+
+# Always resolve paths relative to THIS script's location (inside scripts/)
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+MEMORY_FILE = os.path.join(SCRIPT_DIR, "memory.md")
+
+# ─── LinkedIn SEO Rules ───────────────────────────────────────────────────────
+
+LINKEDIN_SEO_RULES = """
+## LinkedIn SEO & Content Rules (MANDATORY — Follow Exactly)
+
+### Hook Engineering (Most Critical)
+- Line 1 MUST be a scroll-stopping hook. Use one of these proven formats:
+  a) Bold contrarian statement: "Most LinkedIn advice is wrong. Here's why."
+  b) Surprising statistic: "95% of LinkedIn posts get fewer than 100 views. Here's the 5% secret."
+  c) Provocative question: "What if everything you knew about personal branding was backwards?"
+  d) Personal story opener: "3 years ago, I had 47 LinkedIn followers. Here's what changed."
+- Line 2 MUST create a pattern interrupt — force the reader to click "see more"
+- NEVER start with: "In today's...", "I am excited to...", "Happy to share...", "Thrilled to announce..."
+
+### Content Structure
+- Hook (2 lines, must not trigger "see more" cutoff)
+- [blank line]
+- Context/Problem (2-3 short sentences max)
+- [blank line]
+- Core Value (use numbered lists or bullets — max 7 items)
+- [blank line]
+- Key Takeaway (1-2 punchy sentences)
+- [blank line]
+- Call to Action (1 specific, non-generic CTA)
+- [blank line]
+- Hashtags (3-5 only — mix broad + niche)
+
+### Readability Rules
+- Maximum 2 sentences per paragraph
+- Use line breaks aggressively — white space wins on LinkedIn
+- Bold sparingly, only for truly critical points
+- Sentences: short, punchy, declarative. Vary rhythm.
+- Reading level: Grade 8 or below
+
+### Tone & Voice
+- Write like you're talking to ONE person, not an audience
+- Use "you" and "I" — personal, not corporate
+- Confident, not arrogant. Helpful, not preachy.
+- Zero jargon unless explaining it is the point
+
+### Hashtag Strategy
+- 1 broad hashtag (#AI, #Marketing, #Leadership)
+- 2 niche hashtags (#AIAgents, #ContentMarketing, #StartupLife)
+- 1-2 community hashtags (#LinkedInTips, #PersonalBranding)
+- Total: NEVER more than 5
+"""
+
+
+def read_memory() -> str:
+    """Read and return the full contents of memory.md."""
+    if not os.path.exists(MEMORY_FILE):
+        return "No memory found. Use /feedback to start building personalised memory."
+    with open(MEMORY_FILE, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def get_base_prompt_context(niche: str, content_type: str) -> str:
+    """
+    Build a complete system prompt context for the AI.
+    Injects LinkedIn SEO rules + the user's personal reinforcement learning memory.
+    """
+    memory_context = read_memory()
+
+    prompt = f"""<SYSTEM_INSTRUCTION>
+You are an elite LinkedIn Content Strategist and Copywriter working for a specific user.
+Your task is to generate a world-class {content_type} for the niche: "{niche}".
+
+{LINKEDIN_SEO_RULES}
+
+## User's Personal Memory & Preferences (HIGHEST PRIORITY)
+The following reinforcement learning memory reflects what has worked for this user.
+You MUST prioritize and replicate these patterns in your output:
+
+<MEMORY>
+{memory_context}
+</MEMORY>
+
+If memory contains specific hooks, tones, or formats that worked well — USE THEM as inspiration.
+If memory is empty — default to the SEO rules above and high-performing LinkedIn best practices.
+
+</SYSTEM_INSTRUCTION>"""
+
+    return prompt

package/bundled-skills/permission-manager/README.md

@@ -0,0 +1,22 @@
+# permission-manager
+
+Manage opencode permissions: review always-allow lists, suggest safe read-only commands, configure permission patterns.
+
+## What it does
+
+- Reviews and summarizes currently always-allowed commands
+- Suggests safe read-only commands for auto-approval
+- Adds or removes commands from the allow list in opencode.json
+- Configures skill-level permissions (allow/deny/ask) with wildcard patterns
+- Audits permission configs for security and usability
+
+## When to use
+
+Use this when optimizing opencode's permission settings, reviewing allowed commands, or configuring skill access controls.
+
+## Key capabilities
+
+- **Config review**: Loads `~/.config/opencode/opencode.json` or project-level config
+- **Permission summary**: Identifies currently allowed commands and skill permissions
+- **Safe commands**: Suggests read-only commands (ls*, git status*, git log*, rg, grep, cat, etc.)
+- **Change application**: Edits config to add/remove permission entries, validates JSON

package/bundled-skills/permission-manager/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: permission-manager
+version: 1.0.0
+description: "Manage opencode permissions: review always-allow lists, suggest safe read-only commands, configure permission patterns"
+risk: critical
+source: community
+source_type: community
+source_repo: mskadu/opencode-agent-skills
+license: MIT
+license_source: "https://github.com/mskadu/opencode-agent-skills/blob/main/LICENSE"
+date_added: "2026-06-05"
+---
+
+## What I do
+- Review and summarize currently always-allowed commands
+- Suggest safe read-only commands for auto-approval
+- Add or remove commands from the allow list in opencode.json
+- Configure skill-level permissions (allow/deny/ask) with wildcard patterns
+- Audit permission configs for security and usability
+
+## When to Use
+Use this when optimizing opencode's permission settings, reviewing allowed commands, or configuring skill access controls.
+
+## Workflow Steps
+
+1. **Read current config**: Load `~/.config/opencode/opencode.json` or project-level `opencode.json`
+2. **Summarize permissions**: Identify currently allowed commands and skill permissions
+3. **Suggest additions**: Propose safe read-only commands for auto-allow (see recommended list below)
+4. **Apply changes**: Edit the config to add/remove permission entries
+5. **Validate**: Ensure JSON is valid after changes
+
+Complements opencode's built-in allow/deny/ask permissions by auditing current config and recommending adjustments through conversation.
+
+## Key Rules
+- Never allow commands that modify files, commit, push, or change system state
+- Use wildcards appropriately (e.g., `git status*` not just `git status`)
+- Confirm with user before modifying permission config
+- Distinguish between bash command permissions and skill permissions
+- Keep config organized: group related commands together
+
+## Limitations
+
+- This skill is scoped to opencode permission configuration and should not modify other agent hosts' permission stores.
+- Treat all write-capable command permissions as high-risk; review them manually even when a pattern looks narrow.
+
+## How to trigger me
+
+Use the Task tool with the `permission-manager` subagent type:
+
+```
+/permissions
+```
+
+Or in natural language, ask opencode to "manage opencode permissions" or "review allowed commands".

package/bundled-skills/skill-suggester/README.md

@@ -0,0 +1,14 @@
+# skill-suggester
+
+Scans opencode prompt history for recurring patterns and proposes new skills or command templates.
+
+## What it does
+
+- Reads prompt history from `~/.local/state/opencode/prompt-history*.jsonl`
+- Identifies repeated multi-step workflows that don't have a dedicated skill yet
+- Estimates time savings if each pattern were turned into a skill
+- Provides direct evidence with excerpts from your past prompts
+
+## When to use
+
+Run occasionally (weekly or monthly) to find automation opportunities you didn't know existed. Good for catching workflows that have become routine without you noticing.

package/bundled-skills/skill-suggester/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: skill-suggester
+version: 1.0.0
+description: "Scan prompt history for recurring patterns and unmet needs, then propose new skills or command templates"
+risk: safe
+source: community
+source_type: community
+source_repo: mskadu/opencode-agent-skills
+license: MIT
+license_source: "https://github.com/mskadu/opencode-agent-skills/blob/main/LICENSE"
+date_added: "2026-06-05"
+---
+
+## What I do
+
+Reads your opencode prompt history, finds repeated multi-step workflows, and recommends skill-worthy candidates. Saves you from having the same conversation twice.
+
+## When to Use
+
+Use this skill when the user wants to mine opencode prompt history for repeated workflows, recurring unmet needs, or candidates for new reusable skills.
+
+## How to invoke
+
+Run `/skill skill-suggester` to scan the full history. Optionally pass `--since <date>` (e.g. `--since 2026-05-01`) to limit the window.
+
+## Analysis method
+
+1. Locate prompt history files at `~/.local/state/opencode/prompt-history*.jsonl`
+2. Parse each entry's message content
+3. Score for skill potential by looking for:
+   - **Repetition**: similar phrasing or topic used 3+ times ("scan all repos", "check my inbox")
+   - **Multi-step sequences**: a request that required 5+ tool calls to complete
+   - **Unsupported requests**: things you asked for that don't have a dedicated skill yet
+   - **Workaround patterns**: instructions you give every time instead of a one-shot command
+4. For each candidate, note:
+   - How many times the pattern appeared
+   - How many tool calls it consumed
+   - The estimated time savings if it were a skill
+
+## Output format
+
+```
+## Skill Candidates (last N entries)
+
+### 1. "<candidate name>" (PRIORITY)
+- **Pattern**: <what you keep asking for>
+- **Frequency**: X times in history
+- **Avg complexity**: Y tool calls per instance
+- **Estimated savings**: ~Z minutes/week
+- **Evidence**:
+  - "[excerpt from prompt history]"
+  - "[another excerpt]"
+- **Recommendation**: <create as skill | add as command template | not worth it>
+
+### 2. ...
+```
+
+## Key rules
+
+- Only flag patterns that happen more than twice. One-offs are not skills.
+- Include direct quotes from your past prompts as evidence.
+- Rate each candidate: `high` (clear ROI, use weekly), `medium` (nice to have), `low` (rare but worth noting).
+- If nothing qualifies, say so and explain why.
+- After presenting candidates, ask if you want to create any of them.
+
+## Limitations
+
+- Prompt history can contain sensitive local context; summarize patterns without exposing unnecessary private excerpts.
+- Recommendations are suggestions only and still need human review before creating or publishing a new skill.

package/bundled-skills/smart-git-automation/README.md

@@ -0,0 +1,31 @@
+# smart-git-automation
+
+Intelligently detect and group changes, auto-generate branch names, and streamline the commit/PR workflow.
+
+## What it does
+
+- Intelligently detects and groups related changes
+- Auto-generates descriptive branch names from changes
+- Streamlines workflow: scan → branch → commit → push → PR with fewer prompts
+- Generates commit messages and PR descriptions from changes
+
+## When to use
+
+Use this when you want a faster, smarter git workflow that groups changes logically and reduces manual confirmation overhead.
+
+## Key capabilities
+
+- **Smart grouping**: Runs git status/diff in parallel, groups files by module/directory or related edits
+- **Auto branch names**: Generates `<type>/<short-description>` in kebab-case from dominant change pattern (feature, fix, refactor, docs, test, chore)
+- **Streamlined commit**: Stages grouped files, auto-generates commit message, asks single-word confirmation
+- **Push & PR**: Optional push to remote, then optional PR with auto-generated title/body from changes
+- **Fork handling**: Detects fork remotes and uses correct remote for PR creation
+
+## Rules
+
+- Generate branch names from actual changes, don't ask user to name them
+- Reduce confirmations to single-word answers or single confirmation points
+- Never commit secrets, credentials, or large binaries
+- Check if GitHub repo exists before PR creation
+- Skip PR step if user says "no" at any point
+- If branch already exists with changes, offer to amend or add new commit