@opendirectory.dev/skills 0.1.43 → 0.1.45

package/skills/oss-launch-kit/scripts/run.py

@@ -0,0 +1,41 @@
+"""CLI entrypoint for oss-launch-kit.
+
+This orchestrates GitHub repo fetching, brief building, and full launch-kit generation.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from build_product_brief import build_product_brief
+from fetch_repo_context import fetch_repo_context
+from generate_assets import render_full_launch_kit_markdown
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Generate a coordinated OSS launch strategy and readiness report from a GitHub repo.")
+    parser.add_argument("--repo-url", required=True, help="Public GitHub repository URL")
+    parser.add_argument("--output", default="launch-kit.md", help="Output Markdown file path")
+    return parser
+
+
+def run(repo_url: str) -> tuple[dict, dict, str]:
+    repo_context = fetch_repo_context(repo_url)
+    brief = build_product_brief(repo_context)
+    markdown = render_full_launch_kit_markdown(brief)
+    return repo_context, brief, markdown
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    _, _, markdown = run(args.repo_url)
+    output_path = Path(args.output)
+    output_path.write_text(markdown, encoding="utf-8")
+    print(f"Wrote {output_path}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/oss-launch-kit/scripts/test_logic.py

@@ -0,0 +1,99 @@
+import unittest
+import sys
+from pathlib import Path
+
+# Add the scripts directory to sys.path
+sys.path.append(str(Path(__file__).parent))
+
+from build_product_brief import build_product_brief
+from generate_assets import render_full_launch_kit_markdown
+
+class TestOSSLaunchKitLogic(unittest.TestCase):
+    def test_low_readiness_handling(self):
+        # Mock repo context for a very weak repo
+        low_context = {
+            "name": "octocat/Hello-World",
+            "description": "My first repository on GitHub!",
+            "stars": 2,
+            "readme_text": "Hello World!",
+            "language": "HTML",
+            "license": None,
+            "confidence": "low"
+        }
+        
+        brief = build_product_brief(low_context)
+        self.assertEqual(brief["launch_readiness"]["score"], "low")
+        self.assertTrue(len(brief["launch_readiness"]["fix_plan"]) > 0)
+        
+        markdown = render_full_launch_kit_markdown(brief)
+        
+        # Assertions for low readiness output
+        self.assertIn("Project Maturity**: LOW", markdown)
+        self.assertIn("> [!CAUTION]", markdown)
+        self.assertIn("This project is not launch-ready yet", markdown)
+        self.assertIn("## Launch Readiness Fix Plan", markdown)
+        
+        # High friction sections and full checklist should be absent
+        self.assertNotIn("### [Show HN]", markdown)
+        self.assertNotIn("### [Product Hunt]", markdown)
+        self.assertNotIn("## Coordinated Launch Timeline", markdown)
+        self.assertNotIn("## Channel Strategy & Positioning", markdown)
+
+    def test_medium_readiness_handling(self):
+        # Mock repo context for a medium tool
+        medium_context = {
+            "full_name": "user/medium-tool",
+            "description": "A tool that does something useful",
+            "stars": 25,
+            "readme_text": "# Medium Tool\n\n## install\nnpm install medium-tool\n\n## usage\nmedium-tool --help\n\n## license\nMIT\n\n" + "Word " * 200, # > 1000 chars
+            "language": "JavaScript",
+            "license": "MIT",
+            "confidence": "medium"
+        }
+        
+        brief = build_product_brief(medium_context)
+        self.assertEqual(brief["launch_readiness"]["score"], "medium")
+        
+        markdown = render_full_launch_kit_markdown(brief)
+        
+        # Assertions for medium readiness output
+        self.assertIn("Project Maturity**: MEDIUM", markdown)
+        self.assertIn("## Soft Launch Strategy", markdown)
+        self.assertIn("## Launch Readiness Fix Plan", markdown)
+        self.assertIn("## Coordinated Launch Timeline", markdown)
+        self.assertIn("Step 1: Soft Launch", markdown)
+        self.assertIn("## Suggested Skills (Post-Fix)", markdown)
+        
+        # Should still have handoffs but in the Post-Fix section
+        self.assertIn("use `producthunt-launch-kit`", markdown)
+
+    def test_high_readiness_handling(self):
+        # Mock repo context for a strong tool
+        high_context = {
+            "full_name": "cli/cli",
+            "description": "GitHub’s official command line tool helps developers solve github workflow issues",
+            "stars": 35000,
+            "readme_text": "# GitHub CLI\n\n## Quickstart\nbrew install gh\n\n## Usage\ngh issue list\n\n## License\nMIT\n\n## Contributing\nSee CONTRIBUTING.md\n\n## Demo\nVisit https://cli.github.com for a demo.\n\n" + "Long description about why this tool is amazing. " * 50,
+            "language": "Go",
+            "license": "MIT",
+            "confidence": "high"
+        }
+        
+        brief = build_product_brief(high_context)
+        self.assertEqual(brief["launch_readiness"]["score"], "high")
+        
+        markdown = render_full_launch_kit_markdown(brief)
+        
+        # Assertions for high readiness output
+        self.assertIn("Project Maturity**: HIGH", markdown)
+        self.assertIn("## Coordinated Launch Timeline", markdown)
+        self.assertIn("- [ ] Day 1: Show HN", markdown)
+        self.assertIn("## Channel Strategy & Positioning", markdown)
+        self.assertIn("### [Show HN] - Fit: HIGH", markdown)
+        # cli/cli is a tool so PH is low, which is fine
+        self.assertIn("### [Twitter/X]", markdown)
+        self.assertNotIn("> [!CAUTION]", markdown)
+        self.assertNotIn("## Soft Launch Strategy", markdown)
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/pricing-finder/.env.example

@@ -0,0 +1,15 @@
+# pricing-finder -- environment variables
+# All keys are OPTIONAL. The skill runs for free without any keys.
+# Install free dependencies first: pip install -r requirements.txt
+
+# Optional: Tavily API key
+# Upgrades web search quality over DuckDuckGo.
+# Get it at: https://app.tavily.com
+# Free tier: 1000 credits/month
+# TAVILY_API_KEY=your_tavily_api_key_here
+
+# Optional: Firecrawl API key
+# Upgrades pricing page fetching for JS-heavy sites.
+# Get it at: https://firecrawl.dev
+# Free tier: 500 credits/month
+# FIRECRAWL_API_KEY=your_firecrawl_api_key_here

package/skills/pricing-finder/README.md

@@ -0,0 +1,142 @@
+# pricing-finder
+
+Tell it what your product is (URL or description). It finds 5 competitors globally, fetches their actual pricing pages, and returns a complete pricing intelligence report: the dominant pricing model in your space, a benchmark price table, feature gate analysis, a competitive positioning map, and a concrete recommended pricing strategy for your product.
+
+**Zero API keys required.** Runs entirely on free pip dependencies.
+
+## Install
+
+```bash
+npx "@opendirectory.dev/skills" install pricing-finder --target claude
+```
+
+### Video Tutorial
+Watch this quick video to see how it's done:
+
+https://github.com/user-attachments/assets/ee98a1b5-ebc4-452f-bbfb-c434f2935067
+
+### Step 1: Download the skill from GitHub
+1. Copy the URL of this specific skill folder from your browser's address bar.
+2. Go to [download-directory.github.io](https://download-directory.github.io/).
+3. Paste the URL and click **Enter** to download.
+
+### Step 2: Install the Skill in Claude
+1. Open your **Claude desktop app**.
+2. Go to the sidebar on the left side and click on the **Customize** section.
+3. Click on the **Skills** tab, then click on the **+** (plus) icon button to create a new skill.
+4. Choose the option to **Upload a skill**, and drag and drop the `.zip` file (or you can extract it and drop the folder, both work).
+
+> **Note:** For some skills (like `position-me`), the `SKILL.md` file might be located inside a subfolder. Always make sure you are uploading the specific folder that contains the `SKILL.md` file!
+
+## Setup
+
+```bash
+# Install free Python dependencies (required)
+pip install ddgs requests beautifulsoup4 html2text
+```
+
+No API keys needed. Optionally add keys to `.env` for better quality:
+
+```bash
+cp .env.example .env
+# Uncomment TAVILY_API_KEY or FIRECRAWL_API_KEY if you have them
+```
+
+## Usage
+
+```
+Find pricing benchmarks for my startup: https://yourstartup.com
+```
+
+Or paste a description if you don't have a live URL:
+
+```
+Find pricing benchmarks. We build [what you do] for [who]. [Stage], [geography].
+```
+
+## What It Does
+
+1. Fetches your product page to understand what you're building
+2. Analyzes your product: category, differentiators, ICP
+3. Discovers 5 competitors in your space via DuckDuckGo search
+4. **Asks you to confirm the competitor list** before fetching any data
+5. Fetches each competitor's pricing page (3-tier fallback: direct fetch → Google cache → search snippet)
+6. Extracts structured pricing data: tiers, prices, limits, feature gates
+7. Analyzes patterns across all 5 competitors
+8. Maps competitive positioning and identifies underserved gaps
+9. Recommends a concrete pricing strategy for your product
+
+## Output
+
+A pricing intel report saved to `docs/pricing-intel/[product-slug]-[date].md` containing:
+
+- **Pricing Model Analysis** -- dominant model in your space (per-seat / flat-rate / usage-based / freemium) and why
+- **Price Point Benchmark Table** -- every competitor's tiers with exact prices, free tier, free trial
+- **Market ranges** -- entry tier median, mid tier median, enterprise floor
+- **Feature Gate Analysis** -- what's always free, what's always paid, what varies
+- **Competitive Positioning Map** -- who owns cheap+simple, middle market, enterprise, and where the gap is
+- **Recommended Pricing Strategy** -- model, entry price, mid price, top price, free tier decision, annual discount, what to gate behind paid
+
+## Cost
+
+**$0.00.** Entirely free using pip dependencies.
+
+Optional API upgrades:
+- Tavily API (free tier: 1000 credits/month) -- better search results
+- Firecrawl API (free tier: 500 credits/month) -- better JS-heavy page rendering
+
+## Zero-Hallucination Policy
+
+Every price in the output traces to fetched pricing page content or a search snippet. "Contact Sales" is recorded exactly -- never estimated. Fields that could not be sourced are labeled "not found in page data." Low-quality data (search snippets) is explicitly flagged so you know which competitors to verify manually.
+
+## How Pricing Page Fetching Works
+
+The script tries three methods per competitor, in order:
+
+1. **Direct fetch** (`requests` + `beautifulsoup4` + `html2text`) -- works for most pricing pages since companies make them SEO-friendly and server-rendered
+2. **Google cache** -- fallback for recently-changed pages or soft blocks
+3. **Search snippet** -- last resort; marks data quality as "low" in the output
+
+If you have a Firecrawl API key, it replaces step 1 with a fully JS-rendered fetch.
+
+## Project Structure
+
+```
+pricing-finder/
+├── SKILL.md                        -- 10-step workflow for Claude Code
+├── README.md                       -- this file
+├── .env.example                    -- optional API key template
+├── requirements.txt                -- free pip dependencies
+├── scripts/
+│   └── research.py                 -- two-phase data collector
+├── evals/
+│   └── evals.json                  -- 5 test cases
+└── references/
+    ├── pricing-models.md           -- per-seat, flat, usage, freemium definitions + signals
+    ├── extraction-guide.md         -- how to read a pricing page
+    └── positioning-guide.md        -- how to map competitors and find gaps
+```
+
+## Standalone Script Usage
+
+```bash
+# Phase 1: competitor discovery
+python3 scripts/research.py \
+    --phase discover \
+    --product-analysis /tmp/pf-product-analysis.json \
+    --output /tmp/pf-competitors-raw.json
+
+# Phase 2: fetch pricing pages
+python3 scripts/research.py \
+    --phase fetch-pricing \
+    --competitors /tmp/pf-competitors-confirmed.json \
+    --output /tmp/pf-pricing-raw.json
+
+# With optional API key upgrades
+python3 scripts/research.py \
+    --phase fetch-pricing \
+    --competitors /tmp/pf-competitors-confirmed.json \
+    --firecrawl-key "$FIRECRAWL_API_KEY" \
+    --tavily-key "$TAVILY_API_KEY" \
+    --output /tmp/pf-pricing-raw.json
+```