@veyralabs/skills 0.4.0 → 0.5.0

package/README.md

@@ -1,10 +1,14 @@
 # VeyraSkills
 
-Skills for Claude Code and other AI coding agents. Each skill is a plain text file that teaches your agent a specialized workflow — naming, branding, website cloning, and more.
+![8 skills](https://img.shields.io/badge/skills-8-blue) ![npm](https://img.shields.io/npm/v/@veyralabs/skills) ![license](https://img.shields.io/badge/license-MIT-green)
+
+Skills for Claude Code and other AI coding agents. Each skill is a plain text file that teaches your agent a specialized workflow - naming, branding, website cloning, Shopify development, and more.
 
 ```bash
 npx @veyralabs/skills install naming-suite
 npx @veyralabs/skills install webcloner
+npx @veyralabs/skills install shopify-suite
+npx @veyralabs/skills install venture-suite
 ```
 
 Or install everything at once:
@@ -30,6 +34,25 @@ Four skills for naming products, auditing brands, mapping competitors, and build
 
 Works best in sequence: run `competitornames` to understand the landscape, then `domainforge` to generate names that stand out from it.
 
+### shopify-suite
+
+Two skills covering the full Shopify stack - one for developers building themes and apps, one for merchants auditing and optimizing stores.
+
+| Skill | What it does |
+|-------|-------------|
+| [shopify-dev](./skills/shopify-suite/shopify-dev/SKILL.md) | Shopify development across all layers: Liquid themes, JSON templates, app development with Remix, Storefront and Admin API, CLI workflows, checkout extensions, Hydrogen. Fetches live Shopify documentation via Context7 before answering version-sensitive questions |
+| [shopify-store](./skills/shopify-suite/shopify-store/SKILL.md) | Store audit and optimization. Works in two modes: Mode A uses shopify-mcp to read real store data (products, orders, apps, metafields); Mode B uses public extraction when MCP is not available. Audits 6 dimensions: catalog health, collection architecture, navigation, SEO, app stack, conversion signals |
+
+### venture-suite
+
+Research a startup or SaaS idea before building. Collects evidence from HN, Reddit, GitHub, and web searches - no API keys required.
+
+| Skill | What it does |
+|-------|-------------|
+| [venture-analyst](./skills/venture-suite/venture-analyst/SKILL.md) | Four-phase idea validation: problem discovery (evidence from real sources), competitor intelligence (pricing, gaps, weaknesses), validation experiments (Mom Test, fake door, concierge MVP), and a Bull/Bear/Judge verdict with confidence score |
+
+Includes Python scripts for zero-key data collection and auto-detection of available enhancements (SearXNG via Docker, optional API keys). All methodology references included: Lean Startup, Customer Development, Mom Test, Blue Ocean Strategy, Traction.
+
 ### webcloner
 
 Clone any landing page, marketing site, portfolio, or ecommerce storefront into a pixel-accurate Next.js replica.
@@ -51,6 +74,11 @@ Works for landings, marketing sites, portfolios, and ecommerce product pages. No
 ```bash
 npx @veyralabs/skills install naming-suite
 npx @veyralabs/skills install webcloner
+npx @veyralabs/skills install shopify-suite
+npx @veyralabs/skills install shopify-dev
+npx @veyralabs/skills install shopify-store
+npx @veyralabs/skills install venture-suite
+npx @veyralabs/skills install venture-analyst
 npx @veyralabs/skills install domainforge
 ```
 
@@ -109,14 +137,14 @@ npx @veyralabs/skills install domainforge
 ## Coming soon
 
 **brand-suite**
-- `brandvoice` — tone of voice guide generator
-- `brandpositioning` — positioning statement and competitive differentiation
-- `taglineforge` — tagline generation with scoring
+- `brandvoice` - tone of voice guide generator
+- `brandpositioning` - positioning statement and competitive differentiation
+- `taglineforge` - tagline generation with scoring
 
 **gtm-suite**
-- `icp` — Ideal Customer Profile builder
-- `pricingstrategy` — pricing model analysis
-- `gtmplan` — go-to-market plan generator
+- `icp` - Ideal Customer Profile builder
+- `pricingstrategy` - pricing model analysis
+- `gtmplan` - go-to-market plan generator
 
 ---
 
@@ -126,6 +154,11 @@ Each skill is also published as a standalone npm package if you only want one:
 
 - `@veyralabs/naming-suite`
 - `@veyralabs/webcloner`
+- `@veyralabs/shopify-suite`
+- `@veyralabs/shopify-dev`
+- `@veyralabs/shopify-store`
+- `@veyralabs/venture-suite`
+- `@veyralabs/venture-analyst`
 
 ---
 

package/bin/cli.js

@@ -4,10 +4,18 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execFileSync } = require('child_process');
 
 const SKILLS_DIR   = path.join(__dirname, '..', 'skills');
 const COMMANDS_DIR = path.join(__dirname, '..', 'commands');
 
+// pip packages required per skill
+const SKILL_PIP_DEPS = {
+  'shopify-store':    ['scrapling'],
+  'webcloner':        ['scrapling'],
+  'venture-analyst':  ['scrapling', 'ddgs', 'trendspyg', 'requests'],
+};
+
 const AGENT_PATHS = {
   claude:    { local: '.claude/skills',             global: '.claude/skills' },
   cursor:    { local: '.cursor/skills',             global: '.cursor/skills' },
@@ -78,6 +86,31 @@ function copySkill(name, skillPath, dest) {
   console.log(`  ✓ ${name}`);
 }
 
+function installPipDeps(skillNames) {
+  const pkgs = [...new Set(skillNames.flatMap(n => SKILL_PIP_DEPS[n] || []))];
+  if (pkgs.length === 0) return;
+
+  let pip = null;
+  for (const cmd of ['pip3', 'pip']) {
+    try { execFileSync(cmd, ['--version'], { stdio: 'ignore' }); pip = cmd; break; } catch {}
+  }
+
+  if (!pip) {
+    console.log(`  ⚠ Python pip not found. Install manually: pip install ${pkgs.join(' ')}`);
+    return;
+  }
+
+  for (const pkg of pkgs) {
+    try {
+      console.log(`  Installing Python dependency: ${pkg}...`);
+      execFileSync(pip, ['install', pkg, '-q'], { stdio: 'inherit' });
+      console.log(`  ✓ ${pkg}`);
+    } catch {
+      console.log(`  ⚠ Failed to install ${pkg}. Run: ${pip} install ${pkg}`);
+    }
+  }
+}
+
 // Copy slash commands — Claude Code only (.claude/commands/)
 function copyCommands(agent, isGlobal) {
   if (agent !== 'claude') return;
@@ -170,6 +203,7 @@ if (command === 'install') {
   console.log(`\nInstalling into ${dest} [${agent}/${scope}]\n`);
   toInstall.forEach(name => copySkill(name, skills[name], dest));
   copyCommands(agent, isGlobal);
+  installPipDeps(toInstall);
   console.log('\nDone. Restart your agent to activate skills.\n');
   process.exit(0);
 }

package/commands/venture-analyst.md

@@ -0,0 +1,16 @@
+Activate the venture-analyst skill. Task: $ARGUMENTS
+
+Read the full skill at skills/venture-suite/venture-analyst/SKILL.md before doing anything else.
+
+Then run the 4 phases in order:
+
+1. Problem Discovery - collect evidence from HN, Reddit, GitHub, trends using scripts/sources.py
+2. Competitor Intelligence - map the landscape using scripts/scraper.py and sources
+3. Validation Experiments - generate prioritized experiments using scripts/experiments.py
+4. Verdict - Bull case, Bear case, Judge verdict using the scoring system in SKILL.md
+
+Start by detecting environment enhancements silently (scripts/enhance_detect.py) and use the best available search method without asking the user for any API keys.
+
+If the user did not specify the idea clearly, ask one question: "What's the idea, and who is it for?"
+
+Output the full verdict using templates/verdict.md as structure.

package/install.sh

@@ -114,6 +114,38 @@ check_deps() {
   fi
 }
 
+# Skills that require Python packages: skill_name -> pip packages (space-separated)
+declare -A SKILL_PIP_DEPS=(
+  ["shopify-store"]="scrapling"
+  ["webcloner"]="scrapling"
+  ["venture-analyst"]="scrapling ddgs trendspyg requests"
+)
+
+install_pip_deps() {
+  local skill="$1"
+  local pkgs="${SKILL_PIP_DEPS[$skill]:-}"
+  [[ -z "$pkgs" ]] && return
+
+  local pip=""
+  for cmd in pip3 pip; do
+    command -v "$cmd" &>/dev/null && pip="$cmd" && break
+  done
+
+  if [[ -z "$pip" ]]; then
+    echo "  Warning: pip not found. Install manually: pip install $pkgs"
+    return
+  fi
+
+  for pkg in $pkgs; do
+    echo "  Installing Python dependency: $pkg..."
+    if "$pip" install "$pkg" -q; then
+      echo "  ✓ $pkg"
+    else
+      echo "  Warning: failed to install $pkg. Run: $pip install $pkg"
+    fi
+  done
+}
+
 install_skill() {
   local skill="$1"
   local dest_dir="$2"
@@ -236,11 +268,15 @@ main() {
   if [[ -n "$SKILL_NAME" ]]; then
     echo "Installing '$SKILL_NAME' → $dest/"
     install_skill "$SKILL_NAME" "$dest"
+    install_pip_deps "$SKILL_NAME"
     echo ""
     echo "Done. ${dest}/${SKILL_NAME}/ is ready."
   else
     echo "Installing all skills → $dest/"
     install_all "$dest"
+    for skill in "${!SKILL_PIP_DEPS[@]}"; do
+      install_pip_deps "$skill"
+    done
     echo ""
     echo "Done. All skills installed to ${dest}/"
   fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veyralabs/skills",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "VeyraSkills — A curated collection of Claude Code skills for founders, developers and AI builders",
   "bin": {
     "veyraskills": "bin/cli.js"
@@ -35,7 +35,11 @@
     "shopify-theme",
     "shopify-app",
     "shopify-audit",
-    "ecommerce"
+    "ecommerce",
+    "startup-validation",
+    "market-research",
+    "idea-validation",
+    "lean-startup"
   ],
   "author": "VeyraLabs <hello@veyralabs.com>",
   "license": "MIT",

package/skills/venture-suite/venture-analyst/SKILL.md

@@ -0,0 +1,269 @@
+---
+name: venture-analyst
+description: Startup and SaaS idea validation. Researches market evidence, maps competitors, scores viability, and generates concrete validation experiments. Zero API keys required.
+---
+
+# Venture Analyst
+
+Research a startup or SaaS idea and determine if it's worth building. No fluff — real evidence from real sources.
+
+## What this does
+
+Four phases, each producing structured output:
+
+1. **Problem Discovery** - Find evidence the problem actually exists (Reddit, HN, GitHub issues)
+2. **Competitor Intelligence** - Map the landscape, find gaps, extract pricing signals
+3. **Validation Experiments** - Generate 3 prioritized experiments to test demand before building
+4. **Verdict** - Bull/Bear/Judge debate producing a final recommendation with confidence score
+
+## How to use
+
+Describe your idea. Include:
+- What it does (one sentence)
+- Who it's for (target customer)
+- What problem it solves
+
+Optional: budget for experiments, market type (B2C/B2B), known competitors.
+
+## Phase 1 — Problem Discovery
+
+**Goal:** Find evidence the problem is real and people talk about it unprompted.
+
+Use `scripts/sources.py` to collect evidence:
+
+```python
+from scripts.sources import search_hn, search_hn_comments, search_reddit, search_github_issues, get_trends
+
+# HN: find discussions, Show HN, Ask HN about the problem space
+hn_stories = search_hn(query, limit=20)
+hn_comments = search_hn_comments(query, min_points=3, limit=30)
+
+# Reddit: find complaints, questions, "is there a tool for X" posts
+reddit_posts = search_reddit(query, limit=25, timeframe="year")
+
+# GitHub: find feature requests and pain in related tools
+gh_issues = search_github_issues(query, limit=20)
+
+# Trends: is interest rising or declining?
+trend_data = get_trends(keyword)
+```
+
+**Synthesize findings:**
+
+Look for these signals (strongest first):
+- People spending money on bad solutions (evidence of willingness to pay)
+- Recurring complaints with no good answer
+- "Is there a tool that does X?" posts with many upvotes
+- GitHub issues with many reactions and no resolution
+- Rising trend line
+
+Red flags:
+- Zero discussion anywhere — not even a complaint
+- Problem exists but nobody's tried to solve it (often means it's not painful enough)
+- Only a few power users care, not a broad market
+
+**Output format:**
+```
+## Problem Evidence
+
+**Evidence Score:** [0-100] (use calculate_evidence_score())
+**Trend:** [rising/stable/declining/no_data]
+
+### What people say (direct quotes preferred)
+- [Source] "[quote or paraphrase]" — [upvotes/reactions]
+
+### Pain signals
+- [description of signal + source count]
+
+### Gaps found
+- [what existing solutions miss]
+```
+
+## Phase 2 — Competitor Intelligence
+
+**Goal:** Map who's already solving this. Find pricing, positioning gaps, weak points.
+
+```python
+from scripts.scraper import scrape_competitor
+from scripts.sources import search_github_repos, search_web
+
+# Find competitors via web and GitHub
+repos = search_github_repos(f"{idea} tool", limit=8)
+web_results = search_web(f"{idea} software alternatives", limit=8)
+
+# Scrape each competitor's pricing + positioning
+for url in competitor_urls:
+    data = scrape_competitor(url)
+    # data has: title, tagline, description, pricing, features, tech_stack
+```
+
+**Competitive map structure:**
+```
+| Name | Pricing | Target | Weakness | Stars |
+|------|---------|--------|----------|-------|
+| X    | $49/mo  | SMBs   | No API   | 2.1k  |
+```
+
+**Gaps to look for:**
+- Price ceiling: is there a tier missing?
+- Audience gap: power users vs beginners vs enterprise
+- Feature gap: what do G2/Reddit reviews complain about?
+- Distribution gap: who's not in a specific channel?
+
+**G2 reviews (when Playwright available):**
+```python
+from scripts.scraper import scrape_g2_reviews
+reviews = scrape_g2_reviews("https://www.g2.com/products/[product]/reviews")
+# Check for recurring "cons" patterns
+```
+
+**Output format:**
+```
+## Competitor Map
+
+### Direct competitors
+[table]
+
+### Indirect / adjacent
+[list with one-line descriptions]
+
+### Market gaps
+- Gap 1: [description + evidence]
+- Gap 2: [description + evidence]
+
+### Pricing landscape
+- Range: [$X - $Y/month]
+- Free tier pattern: [present/absent]
+- Typical model: [seat/flat/usage]
+```
+
+## Phase 3 — Validation Experiments
+
+**Goal:** Before writing code, find out if people will actually pay.
+
+```python
+from scripts.experiments import generate_experiments, format_experiment_output
+
+experiments = generate_experiments(
+    idea=idea,
+    target_customer=target,
+    market_type="b2b",  # or "b2c"
+    competition_level="medium",  # low/medium/high
+    budget="zero",  # zero / low / medium
+)
+
+print(format_experiment_output(experiments, idea))
+```
+
+Always present experiments in priority order. Cheapest + highest-signal first.
+
+**Mom Test enforcement** — when helping design interviews or outreach:
+- See `references/mom-test.md` for good vs bad questions
+- Detect and flag future-hypothetical questions ("would you use X?")
+- Replace with past-behavior questions ("how do you currently handle X?")
+
+## Phase 4 — Verdict
+
+**Goal:** Simulate a debate between Bull, Bear, and Judge. Reach a conclusion.
+
+### Bull case (write this first)
+- Strongest evidence for building it
+- Market timing arguments
+- Why this team / why now
+- Best-case scenario with numbers
+
+### Bear case (steelman the opposition)
+- Strongest evidence AGAINST
+- Why existing solutions might be good enough
+- Market risks, timing risks, competition risks
+- Why it might fail even if the problem is real
+
+### Judge verdict
+Read both cases. Apply these criteria:
+
+| Signal | Weight |
+|--------|--------|
+| Evidence score > 60 | +2 |
+| Trend = rising | +1 |
+| Competitors have clear weakness | +1 |
+| No dominant player (>50% market) | +1 |
+| B2B with willingness-to-pay signals | +1 |
+| Price ceiling exists | +1 |
+| Evidence score < 30 | -3 |
+| Trend = declining | -2 |
+| 1+ competitor with >100k users + free tier | -2 |
+| Problem is niche (<10k potential users) | -1 |
+
+**Verdict output:**
+```
+## Verdict
+
+**Recommendation:** [BUILD / VALIDATE FIRST / AVOID]
+**Confidence:** [High / Medium / Low]
+**Score:** [+N or -N]
+
+### Judge's reasoning
+[2-3 sentences. Direct. No hedging.]
+
+### If BUILD: suggested starting point
+[Specific first step. Not generic advice.]
+
+### If VALIDATE FIRST: critical unknown
+[The one thing that must be proven before spending time.]
+
+### If AVOID: core problem
+[Why specifically this fails. What would have to change.]
+```
+
+## Enhancement detection
+
+Run at session start to unlock better sources:
+
+```python
+from scripts.enhance_detect import detect_level, ensure_searxng, best_search
+
+env = detect_level()
+# Returns: docker, searxng, veyrascrape_mcp, github_token, exa_key, tavily_key, groq_key
+
+# If Docker available, auto-launch SearXNG for better web search
+if env["docker"] and not env["searxng"]:
+    ensure_searxng()  # silent, no user prompt
+
+# Use best available search
+results = best_search(query, env, limit=10)
+```
+
+**Level 1 (always works):** HN + Reddit + GitHub + ddgs + trendspyg
+**Level 2 (auto, no keys):** + SearXNG via Docker (if Docker installed)
+**Level 3 (optional keys):** + Exa, Tavily, GitHub authenticated, VeyraScrape MCP
+
+Never ask the user to set up API keys. Auto-detect and use what's available.
+
+## Evidence Score interpretation
+
+From `calculate_evidence_score()` in `sources.py`:
+
+| Score | Meaning |
+|-------|---------|
+| 0-20  | Weak - barely any signal. Rethink or pivot problem framing |
+| 21-40 | Thin - some signal but not convincing |
+| 41-60 | Moderate - proceed to competitor research |
+| 61-80 | Strong - real problem, real people care |
+| 81-100 | Very strong - validated pain, move to experiments immediately |
+
+## Methodology references
+
+- `references/lean-startup.md` - validated learning, MVP types, pivot signals
+- `references/customer-dev.md` - Steve Blank's 4 steps, problem interview structure
+- `references/mom-test.md` - good vs bad interview questions
+- `references/blue-ocean.md` - Value Curve, ERRC Grid, finding uncontested space
+- `references/traction.md` - 19 acquisition channels, Bullseye framework
+
+## Output principles
+
+1. Lead with evidence, not opinions
+2. Quote real sources (HN post, Reddit thread, GitHub issue)
+3. Be specific about numbers (upvotes, stars, $prices)
+4. Separate fact from inference clearly
+5. Bull/Bear before Verdict — don't skip the debate
+6. Verdict must commit to a recommendation — no "it depends" without specifics

package/skills/venture-suite/venture-analyst/references/blue-ocean.md

@@ -0,0 +1,130 @@
+# Blue Ocean Strategy Reference
+
+W. Chan Kim & Renee Mauborgne, "Blue Ocean Strategy" (2005, updated 2015).
+
+## Core concept
+
+**Red Ocean:** existing market space. Competitors fight over same customers. Bloody from competition.
+**Blue Ocean:** new market space. Create demand, not fight for it.
+
+The goal: don't compete where everyone else is. Find (or create) a space where there's no direct competition.
+
+This is not about being "different" for its own sake. It's about finding where existing solutions fail enough customers that a new approach can win without fighting incumbents.
+
+## Value Innovation
+
+The foundation of blue ocean strategy. The simultaneous pursuit of:
+- **Differentiation** (more value for customers) AND
+- **Low cost** (lower cost to deliver)
+
+Most companies choose one. Blue ocean does both by eliminating or reducing what the industry assumes is necessary.
+
+Key: value innovation redefines what value means — it doesn't just add more features.
+
+## Value Curve
+
+A visual tool. X-axis: factors the industry competes on. Y-axis: level of investment/offering.
+
+Draw your value curve vs competitors:
+1. List all factors the industry competes on (price, features, quality, support, speed, etc.)
+2. Score each player 1-10 on each factor
+3. Connect the dots — that's the value curve
+
+**What to look for:**
+- Where are all competitors converging? (where you can differentiate)
+- Where is investment high but customers don't care? (where you can eliminate/reduce)
+- What do customers want that nobody offers? (where you can create/raise)
+
+**Signs of a blue ocean opportunity:**
+- Your curve looks completely different from competitors
+- You're investing in factors they don't even measure
+- You're not competing on any factor they compete on
+
+## ERRC Grid
+
+The strategic tool for creating a new value curve.
+
+| Action | Question | Why |
+|--------|----------|-----|
+| **Eliminate** | Which factors the industry takes for granted can be eliminated? | Remove cost + complexity customers don't value |
+| **Reduce** | Which factors should be reduced well below the industry standard? | Stop over-delivering where it doesn't matter |
+| **Raise** | Which factors should be raised well above the industry standard? | Solve what customers complain about |
+| **Create** | Which factors should be created that the industry has never offered? | Add new value that opens new demand |
+
+**How to use it for venture analysis:**
+
+Look at the competitor landscape from Phase 2. Fill the ERRC grid:
+- What do all competitors force customers to deal with? (Eliminate candidates)
+- Where are they all investing heavily but customers complain anyway? (Reduce candidates)
+- What do all G2/Reddit reviews say is missing? (Raise or Create candidates)
+
+## Three tiers of non-customers
+
+Incumbents focus on existing customers. Blue ocean looks at non-customers:
+
+**Tier 1 — "Soon-to-be" non-customers**
+On the edge of the market. Use existing solutions but reluctantly. Would switch if something better existed.
+- Find them: people who use tools but post complaints
+- Signal: "I use X but I hate Y"
+
+**Tier 2 — "Refusing" non-customers**
+Consciously choose not to use existing solutions. Have the problem but handle it differently.
+- Find them: "I could use X but I just [workaround] instead"
+- Signal: "I tried X but gave up because..."
+
+**Tier 3 — "Unexplored" non-customers**
+Never considered as customers. In other markets or segments entirely.
+- Find them: unexpected users of adjacent tools
+- Signal: people solving your problem with tools not built for it
+
+## Red vs Blue Ocean signals in research
+
+When analyzing a market, these signals matter:
+
+### Red Ocean signals (hard fight ahead)
+- 5+ competitors with similar positioning and pricing
+- Dominant player with >50% market share
+- Feature comparison tables are the main marketing tool
+- Price is primary differentiator
+- High churn across all players (no moat)
+- Reddit/HN: "X vs Y vs Z" comparison posts everywhere
+
+### Blue Ocean signals (opportunity)
+- People solve the problem with spreadsheets or manual processes
+- Niche community uses a tool far outside its intended purpose
+- The "best" solution is widely criticized for the same thing
+- Large group adjacent to current market who never adopted it
+- Incumbents focused on enterprise; SMB underserved (or vice versa)
+- Technology shift makes old assumptions invalid (mobile, AI, etc.)
+
+## Applying Blue Ocean to competitive analysis
+
+In Phase 2, after mapping competitors, ask:
+
+1. **Which axis can you ignore entirely?**
+   - E.g., all competitors compete on features — can you win on simplicity instead?
+
+2. **What do customers actually use vs what they pay for?**
+   - If pricing is based on features but customers only use 20% of them, price simplicity
+
+3. **What's the "tax" on using existing solutions?**
+   - Setup time, training required, integrations needed, contracts, support tickets
+   - Eliminate the tax
+
+4. **Who's locked out of the market?**
+   - High price, high complexity, enterprise-only contracts
+   - If you can serve them, they're Tier 2/3 non-customers
+
+## Value Curve template
+
+```
+Factor          | Competitor A | Competitor B | Our position
+----------------|-------------|-------------|-------------
+Price           | High        | Medium      | ?
+Ease of setup   | Hard        | Hard        | ?
+Feature breadth | Wide        | Wide        | ?
+Support         | Good        | Poor        | ?
+[key factor]    | ...         | ...         | ?
+```
+
+A good blue ocean position looks different from all others — not just slightly better.