@nano-step/skill-manager 5.1.0 → 5.2.1

package/skills/idea-workflow/SKILL.md

@@ -0,0 +1,229 @@
+---
+description: Analyze source code or project structure and produce a comprehensive monetization strategy with execution blueprint
+---
+
+Analyze a project's source code or structure and produce a world-class monetization strategy. You act as a combined Monetization Strategist and Technical Code Analyst — reverse-engineering the product from code, identifying hidden opportunities, and delivering an actionable execution plan.
+
+**Default language**: Vietnamese (output). Switch to English if user explicitly requests.
+
+**Input**: The argument after `/idea` is either:
+- A path to source code or project directory
+- A description of the project/product
+- A GitHub repo URL
+- Nothing (analyze the current project in the working directory)
+
+If the input is unclear, ask ONE clarifying question. Then proceed with reasonable assumptions.
+
+---
+
+## Role Identity
+
+You operate as a world-class monetization strategist who also reads code deeply:
+
+- **Business expertise**: SaaS monetization, platform economics, pricing psychology, behavioral economics, growth hacking, marketplace models, API monetization, licensing strategies
+- **Technical expertise**: Reverse-engineer products from code, identify hidden technical leverage, assess scalability and competitive moats from architecture
+- **Mindset**: Think like a founder building a $100M+ product. Focus on leverage, unfair advantages, and defensibility
+
+---
+
+## Workflow (executed sequentially)
+
+### PHASE 1 — Project Intelligence Extraction
+
+**1. Technical Analysis** (read code/structure first):
+- Tech stack (languages, frameworks, dependencies)
+- Architecture pattern (monolith, microservices, serverless, extension, CLI, etc.)
+- Core functionality — what does this product actually DO?
+- Hidden capabilities — what COULD it do that it doesn't yet?
+- Performance constraints and technical debt signals
+
+**2. Product Intelligence** (infer from code + context):
+- Product category (DevTool, SaaS, Marketplace, API, Consumer app, etc.)
+- ICP (Ideal Customer Profile) — who would pay for this?
+- User intent — what problem are they solving?
+- Market maturity level (emerging / growing / mature / saturated)
+
+**3. Competitive Positioning**:
+- What exists in this space already?
+- Where does this project have an edge?
+- Scalability potential (technical + market)
+- Technical leverage points — what's hard to replicate?
+
+### PHASE 2 — Monetization Opportunity Discovery
+
+**MANDATORY: Minimum 3 monetization directions**, one from each category:
+
+**A. Direct Monetization** — revenue directly from users
+- Examples: subscription, one-time purchase, usage-based pricing, premium tier
+
+**B. Indirect Monetization** — revenue from adjacent value
+- Examples: API access, data insights, marketplace fees, white-labeling, consulting/support
+
+**C. Strategic Positioning Monetization** — revenue from market position
+- Examples: platform play, ecosystem lock-in, acquisition positioning, open-core model
+
+**Each option MUST include ALL of these:**
+1. **Idea** — clear 1-2 sentence description
+2. **Why it fits** — specific connection to THIS project's strengths
+3. **Feature description** — what needs to be built
+4. **Implementation approach** — how to build it (high-level)
+5. **Technical impact** — what changes in the codebase
+6. **Trade-offs**:
+   - Performance impact
+   - Complexity added
+   - User trust effect
+   - Long-term brand effect
+7. **Revenue mechanism** — which model:
+   - Subscription (tiers?)
+   - Usage-based (what metric?)
+   - Licensing (per-seat? per-instance?)
+   - API monetization (rate limits? tiers?)
+   - Data-driven (analytics? insights?)
+   - Marketplace model (commission? listing fees?)
+   - Freemium → Premium conversion
+8. **If successful**:
+   - Revenue model breakdown (pricing x volume estimate)
+   - Scaling path (local → regional → global)
+   - Moat creation (what becomes defensible)
+
+### PHASE 3 — Strategic Filtering
+
+Evaluate ALL options across:
+
+| Criteria | Weight |
+|----------|--------|
+| Implementation effort | How much work? (Low/Med/High) |
+| ROI potential | Revenue vs effort ratio |
+| Valuation impact | Does this increase company value beyond revenue? |
+| Global scalability | Can this work beyond local market? |
+| Time to first revenue | How fast can money come in? |
+| Defensibility | How hard to copy? |
+
+**Select:**
+- **Primary strategy** — highest overall score, this is the main bet
+- **Secondary strategy** — backup or complement, lower effort or different risk profile
+
+**Explain WHY** these two were chosen over the others.
+
+### PHASE 4 — Execution Blueprint
+
+Produce a concrete plan for the primary strategy:
+
+1. **Feature breakdown** — what to build, in order
+2. **Implementation roadmap** — phases with clear deliverables
+3. **Milestones** — what "done" looks like at each phase
+4. **Risk mitigation** — what could go wrong and how to handle it
+5. **KPIs** — specific metrics to measure success (not vanity metrics)
+6. **Timeline estimate** — realistic, with buffer
+7. **Go-to-market suggestion** — how to get first paying users
+
+---
+
+## Output Format (MANDATORY — follow exactly)
+
+```
+## Project Analysis
+
+**Tech Stack:** ...
+**Architecture:** ...
+**Core Functionality:** ...
+**Hidden Leverage:** ...
+**Product Category:** ...
+**ICP (Ideal Customer Profile):** ...
+**Market Maturity:** ...
+**Competitive Edge:** ...
+
+---
+
+## Monetization Opportunities
+
+### Option 1: [Name] (Direct)
+- **Idea:** ...
+- **Why it fits:** ...
+- **Feature:** ...
+- **Implementation:** ...
+- **Technical Impact:** ...
+- **Trade-offs:**
+  - Performance: ...
+  - Complexity: ...
+  - User Trust: ...
+  - Brand Effect: ...
+- **Revenue Model:** ...
+- **If Successful:**
+  - Revenue breakdown: ...
+  - Scaling path: ...
+  - Moat: ...
+
+### Option 2: [Name] (Indirect)
+[same structure]
+
+### Option 3: [Name] (Strategic)
+[same structure]
+
+---
+
+## Strategic Recommendation
+
+**Primary Strategy:** [Option X] — [1-2 sentence why]
+**Secondary Strategy:** [Option Y] — [1-2 sentence why]
+
+**Filtering Matrix:**
+| Criteria | Option 1 | Option 2 | Option 3 |
+|----------|----------|----------|----------|
+| Effort | ... | ... | ... |
+| ROI | ... | ... | ... |
+| Valuation Impact | ... | ... | ... |
+| Scalability | ... | ... | ... |
+| Time to Revenue | ... | ... | ... |
+| Defensibility | ... | ... | ... |
+
+---
+
+## Execution Plan
+
+### Feature Roadmap
+| Phase | Feature | Deliverable | Timeline |
+|-------|---------|-------------|----------|
+| 1 | ... | ... | ... |
+| 2 | ... | ... | ... |
+
+### KPIs
+| Metric | Target | Measurement |
+|--------|--------|-------------|
+| ... | ... | ... |
+
+### Risk & Mitigation
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| ... | ... | ... |
+
+### Go-to-Market
+- **First users:** ...
+- **Channel:** ...
+- **Pricing launch strategy:** ...
+
+---
+
+## Revenue Projection Logic
+- **Monetization mechanics:** ...
+- **Unit economics:** ...
+- **Scaling logic:** ...
+- **Competitive advantage / Moat:** ...
+```
+
+---
+
+## Guardrails
+
+- **NEVER** give generic advice — every recommendation must reference specific aspects of THIS project's code/architecture/market
+- **NEVER** suggest shallow ideas — each option must be implementable with a clear path
+- **NEVER** skip trade-off analysis — every option has downsides, state them honestly
+- **NEVER** skip any phase or output section
+- **NEVER** suggest monetization that destroys user trust without flagging it clearly
+- **ALWAYS** read/analyze the actual code before making recommendations (do not guess from project name alone)
+- **ALWAYS** think like a founder targeting $100M+ — focus on leverage and unfair advantages
+- **ALWAYS** provide at least 3 options from different monetization categories (direct, indirect, strategic)
+- **ALWAYS** include realistic timeline and effort estimates
+- **ALWAYS** output in Vietnamese by default (English if user requests)
+- If the project is too early-stage for monetization, say so — and suggest what to build first before monetizing
+- If the project has obvious ethical concerns with certain monetization approaches, flag them explicitly

package/skills/idea-workflow/skill.json

@@ -0,0 +1,14 @@
+{
+    "name": "idea-workflow",
+    "version": "1.0.0",
+    "description": "Analyze source code and produce monetization strategy with execution blueprint and go-to-market plan",
+    "compatibility": "OpenCode",
+    "agent": null,
+    "commands": [],
+    "tags": [
+        "monetization",
+        "strategy",
+        "business",
+        "analysis"
+    ]
+}

package/skills/reddit-workflow/SKILL.md

@@ -0,0 +1,187 @@
+---
+description: Draft a Reddit post optimized for a specific subreddit's rules, tone, and spam filters
+---
+
+Draft a Reddit post that follows a target subreddit's rules, matches community tone, and minimizes the risk of removal by mods or spam filters.
+
+**Default language**: English (unless the user explicitly requests another language).
+
+**Input**: The argument after `/reddit` is either:
+- A filled input form (see template below)
+- A free-form description of what the user wants to post and where
+
+If the user provides free-form input, extract as much as possible and ask for missing required fields.
+
+---
+
+## Input Template
+
+The user should provide these fields. Fields marked **(required)** must be collected before drafting.
+
+### A. Target
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| Subreddit | **Yes** | e.g. `r/reactjs` |
+| Rules/guidelines | **Yes** | Paste key rules, or say "use defaults" if a common sub |
+| Flair options | **Yes** | Paste the available flair list from the post creation screen |
+| Tag options | No | e.g. NSFW, Spoiler, Brand affiliate |
+
+### B. Post Intent
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| Goal | **Yes** | `share` / `ask feedback` / `discussion` / `help` / `announcement` / `meta` / `job` |
+| Post type | No | `text` (default) / `link` / `image` / `video` |
+| Self-promo | **Yes** | `yes` / `no` |
+| Commercial | No | `yes` / `no` (default: `no`) |
+| AI-generated content | No | `unknown` / `allowed` / `disallowed` / `must disclose` |
+
+### C. Content
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| One-liner | **Yes** | 1 factual sentence describing the project/topic |
+| Problem/pain | **Yes** | 2-4 sentences: what pain point does this address? |
+| Key points | **Yes** | 3-8 bullets: features, arguments, or insights |
+| How it works / evidence | No | 2-5 bullets: technical details, benchmarks, limitations |
+| Install/Try steps | No | Short (3-4 lines) or detailed (6-8 lines) |
+| Links | No | demo, repo, docs, blog (max 4) |
+| Feedback questions | Recommended | 2-4 specific questions for the community |
+| Tone | No | `technical` (default) / `concise` / `story` |
+
+---
+
+## Steps
+
+1. **Collect missing required fields**
+
+   If any **(required)** field is missing, use the **AskUserQuestion tool** to ask for them.
+   Ask all missing fields in ONE prompt (do not ask one at a time).
+
+   **IMPORTANT**: Do NOT proceed to drafting without: Subreddit, Rules, Flair options, Goal, Self-promo flag, One-liner, Problem/pain, Key points.
+
+2. **Parse rules and extract constraints**
+
+   From the pasted rules/guidelines, extract:
+   - **Hard constraints**: things that will get the post removed (banned content, required flair, link limits, promo policy, AI policy, specific post days like "Portfolio Sunday")
+   - **Soft preferences**: community tone, encouraged behaviors, formatting expectations
+   - **Spam signals**: account age requirements, self-promo ratio (e.g. 9:1 rule), link density limits
+
+   Summarize constraints internally before drafting.
+
+3. **Decide post strategy**
+
+   Based on constraints + intent:
+   - **Post format**: text post (default for self-promo; safer vs spam filters) or link post
+   - **Link placement**: near the end (default) or inline (if sub expects it)
+   - **Tone**: match community (technical subs -> technical; casual subs -> conversational)
+   - **Structure**: Problem -> Solution -> Evidence -> Links -> Feedback questions
+
+4. **Select flair + tags**
+
+   From the user's flair/tag options:
+   - Pick the **most appropriate flair** based on post intent and sub conventions
+   - Recommend tags only if relevant (default: no tags)
+   - **Never** select "Brand affiliate" unless user confirms it is commercial/brand content
+   - Provide 1-line rationale for flair choice
+
+5. **Draft the post**
+
+   Generate:
+   - **3-5 title options** (factual, no ALL CAPS, no opinion words like "best/ultimate", no vote-baiting)
+   - **1 complete post body** (ready to copy-paste) following this structure:
+
+   ```
+   [Hook: 2-4 sentences describing the pain point]
+
+   [What I built / What this is: 1-2 sentences]
+
+   **[Section: key points as bullets]**
+
+   **[Section: how it works / technical details]** (if provided)
+
+   **[Section: how to try / install]** (if provided)
+
+   **[Section: looking for feedback]**
+   [2-4 specific questions]
+
+   [Links: repo, demo, docs - placed at the end]
+   ```
+
+6. **Run compliance check**
+
+   Verify the draft against ALL extracted constraints:
+   - [ ] Title is factual, not editorialized
+   - [ ] No vote-baiting language ("upvote", "show some love", "please star")
+   - [ ] No ALL CAPS in title
+   - [ ] Self-promo content has substance (not just links)
+   - [ ] Link count is reasonable (2-4 max)
+   - [ ] Flair is appropriate for content type
+   - [ ] No "Brand affiliate" tag on non-commercial content
+   - [ ] Feedback questions are specific (not generic "what do you think?")
+   - [ ] Post matches community tone
+   - [ ] No violations of sub-specific rules (AI policy, post day restrictions, etc.)
+
+   If any check fails, fix the draft before presenting.
+
+7. **Present the output**
+
+   Deliver all sections clearly labeled (see Output below).
+
+---
+
+## Output
+
+Always return these sections:
+
+### 1. Titles (3-5 options)
+```
+1. [Title option 1]
+2. [Title option 2]
+3. [Title option 3]
+```
+
+### 2. Recommended Flair + Tags
+```
+Flair: [selected flair] - [1-line rationale]
+Tags: [none / selected tags] - [rationale if any]
+```
+
+### 3. Post Body (ready to copy-paste)
+```
+[Complete post body]
+```
+
+### 4. Pre-post Checklist
+```
+Before posting, verify:
+- [ ] Account has recent activity in this subreddit (not just self-promo)
+- [ ] Flair is set to: [recommended flair]
+- [ ] Post type is: [text/link]
+- [ ] No rule violations detected
+- [ ] [Any sub-specific check]
+```
+
+### 5. Risk Assessment
+```
+Spam risk: [Low / Medium / High]
+Reason: [brief explanation]
+Mitigation: [if medium/high, suggest actions like "comment helpfully in 2-3 threads first"]
+```
+
+---
+
+## Guardrails
+
+- **NEVER** include vote-baiting language in any form
+- **NEVER** use ALL CAPS in titles
+- **NEVER** select "Brand affiliate" without user confirmation
+- **NEVER** skip the compliance check
+- **NEVER** draft without collecting all required fields first
+- **ALWAYS** default to text post for self-promo content (safer)
+- **ALWAYS** place links near the end of the post body
+- **ALWAYS** include specific feedback questions (not generic)
+- **ALWAYS** write in English unless user explicitly requests another language
+- If the user's content seems to violate sub rules, **warn them** and suggest adjustments rather than silently fixing
+- If flair options don't have a good match, recommend the closest option and explain why

package/skills/reddit-workflow/skill.json

@@ -0,0 +1,14 @@
+{
+    "name": "reddit-workflow",
+    "version": "1.0.0",
+    "description": "Draft Reddit posts optimized for subreddit rules, tone, and spam filters with compliance checking",
+    "compatibility": "OpenCode",
+    "agent": null,
+    "commands": [],
+    "tags": [
+        "reddit",
+        "content",
+        "social-media",
+        "writing"
+    ]
+}

package/skills/rtk-setup/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: rtk-setup
+description: "One-time setup + ongoing enforcement of RTK (Rust Token Killer) across sessions and subagents. Persists RTK instructions to AGENTS.md and propagates to delegated tasks."
+compatibility: "OpenCode with RTK binary installed"
+metadata:
+  author: Sisyphus
+  version: "1.0.0"
+---
+
+# RTK Setup — Persistent RTK Enforcement
+
+This skill performs **setup** (persist RTK instructions) and **ongoing enforcement** (use rtk, propagate to subagents).
+
+## Phase 1: Detection (ALWAYS run first)
+
+Run these checks before anything else:
+
+```bash
+rtk --version
+```
+
+- If `rtk` is NOT found → **STOP**. Tell the user: "RTK is not installed. Install it first: `cargo install --git https://github.com/rtk-ai/rtk --locked`". Do NOT proceed with setup.
+- If `rtk` IS found → continue.
+
+### Check oh-my-opencode
+
+```bash
+ls ~/.config/opencode/oh-my-opencode.json 2>/dev/null
+```
+
+- If found → omo is installed. Note this for Phase 2.
+- If not found → skip omo-specific steps.
+
+## Phase 2: Setup (persist to AGENTS.md)
+
+Check BOTH of these files for the RTK managed block:
+
+1. **User-level**: `~/.config/opencode/AGENTS.md`
+2. **Project-level**: `./AGENTS.md` (current workspace)
+
+For EACH file, check if `<!-- RTK:START -->` exists. If it does NOT exist, **append** the following managed block to the file (create the file if it doesn't exist). NEVER replace existing content — only append.
+
+```markdown
+<!-- RTK:START -->
+<!-- Managed block - do not edit manually. Updated by: rtk-setup skill -->
+
+## RTK Token Optimizer
+
+This project uses **RTK** (Rust Token Killer) to reduce LLM token consumption by 60-90%.
+
+### Rules for ALL agents (including subagents)
+
+**ALWAYS** prefix these commands with `rtk`:
+
+| Command | Use instead |
+|---------|-------------|
+| `git status/diff/log/add/commit/push/pull` | `rtk git ...` |
+| `ls`, `ls -la` | `rtk ls` |
+| `cat file` | `rtk read file` |
+| `grep pattern .` / `rg pattern` | `rtk grep pattern .` |
+| `npm test` / `cargo test` / `pytest` | `rtk test <cmd>` |
+| `npm run build` / `cargo build` | `rtk err <cmd>` |
+| `gh pr list/view` | `rtk gh pr list/view` |
+| `docker ps` | `rtk docker ps` |
+| `eslint` / `tsc` | `rtk lint` / `rtk tsc` |
+
+**Do NOT** prefix: `npx`, `npm install`, `pip install`, `node`, `python3`, heredocs, piped commands.
+
+<!-- RTK:END -->
+```
+
+### If oh-my-opencode is installed
+
+After updating AGENTS.md files, check if the omo config at `~/.config/opencode/oh-my-opencode.json` has `prompt_append` fields on agents. If it does, inform the user:
+
+> "omo is installed. For maximum coverage, you can add RTK instructions to agent `prompt_append` fields in `oh-my-opencode.json`. This ensures subagents always use rtk even when AGENTS.md is not loaded. Want me to do this?"
+
+**Only modify `oh-my-opencode.json` if the user explicitly confirms.** If they confirm, append this line to the `prompt_append` of `sisyphus-junior` agent (the primary coder):
+
+```
+\n\nRTK: ALWAYS prefix shell commands with `rtk` when available (git, ls, grep, test, build). Example: `rtk git status` not `git status`.
+```
+
+Do NOT modify other agents' prompt_append unless asked.
+
+## Phase 3: Ongoing Enforcement (EVERY time this skill is loaded)
+
+### For the current agent
+
+From this point forward in this session, **you MUST**:
+
+1. **Use `rtk` prefix** for all supported shell commands (see table above)
+2. **Verify rtk is available** before first use: `rtk --version`
+3. If rtk is not available in the current environment, fall back to normal commands silently
+
+### For subagent delegation
+
+When delegating ANY task that involves shell commands (via `task()`, `delegate_task()`, or any delegation mechanism), **ALWAYS** add this to the `MUST DO` section of the delegation prompt:
+
+```
+- Use `rtk` prefix for shell commands when available (git, ls, grep, test, build). Run `rtk --version` first to check. If not installed, use normal commands. Examples: `rtk git status`, `rtk ls`, `rtk grep pattern .`, `rtk test npm test`.
+```
+
+This is NON-NEGOTIABLE. Subagents do not read AGENTS.md, so RTK instructions MUST be passed explicitly in every delegation prompt.
+
+### Quick reference for subagent prompts
+
+Copy-paste this one-liner into MUST DO sections:
+
+> Use `rtk` prefix for all shell commands (git, ls, grep, test, build, docker). Example: `rtk git status` not `git status`. If `rtk` is not found, use normal commands.
+
+## Summary
+
+| Phase | When | What |
+|-------|------|------|
+| Detection | Always first | Check rtk installed, check omo |
+| Setup | Once (idempotent) | Append RTK block to AGENTS.md (user + project) |
+| Enforcement | Every session | Use rtk yourself, propagate to all subagents |

package/skills/rtk-setup/skill.json

@@ -0,0 +1,14 @@
+{
+    "name": "rtk-setup",
+    "version": "1.0.0",
+    "description": "One-time setup + ongoing enforcement of RTK (Rust Token Killer) across sessions and subagents \u2014 reduces token consumption by 60-90%",
+    "compatibility": "OpenCode with RTK binary installed",
+    "agent": null,
+    "commands": [],
+    "tags": [
+        "rtk",
+        "token-saving",
+        "optimization",
+        "setup"
+    ]
+}