@opendirectory.dev/skills 0.1.40 → 0.1.42

package/skills/vc-curated-match/scripts/match_vcs.py

@@ -0,0 +1,127 @@
+import json
+import os
+from typing import List, Dict, Tuple
+
+def load_funds(data_path: str) -> List[Dict]:
+    """Load data/vc_funds.json"""
+    if not os.path.exists(data_path):
+        raise FileNotFoundError(f"Dataset not found at {data_path}")
+    with open(data_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def score_fund(fund: Dict, product_context: Dict) -> Tuple[int, List[str]]:
+    """Score a single fund based on overlap with product context."""
+    score = 0
+    
+    # 1. Tag Overlap (max 60 points)
+    fund_tags = fund.get("industry_tags", [])
+    extracted_tags = product_context.get("extracted_tags", [])
+    if not extracted_tags:
+        extracted_tags = ["Generalist"]
+        
+    tag_points = 0
+    matched_tags = []
+    
+    for tag in extracted_tags:
+        if tag in fund_tags:
+            if tag == "Generalist":
+                tag_points += 5
+            else:
+                tag_points += 20
+            matched_tags.append(tag)
+            
+    tag_points = min(tag_points, 60)
+    score += tag_points
+    
+    # 2. Stage Match (max 20 points)
+    stage_points = 0
+    stage_hint = product_context.get("stage_hint")
+    fund_stages = fund.get("stage_focus", [])
+    
+    STAGE_ORDER = {"Pre-seed": 0, "Seed": 1, "Series A": 2, "Growth": 3}
+    
+    if not stage_hint:
+        stage_points = 10
+    elif not fund_stages:
+        pass # skip stage scoring
+    else:
+        if stage_hint in fund_stages:
+            stage_points = 20
+        else:
+            is_adjacent = False
+            if stage_hint in STAGE_ORDER:
+                hint_idx = STAGE_ORDER[stage_hint]
+                for f_stage in fund_stages:
+                    if f_stage in STAGE_ORDER and abs(STAGE_ORDER[f_stage] - hint_idx) == 1:
+                        is_adjacent = True
+                        break
+            if is_adjacent:
+                stage_points = 10
+
+    score += stage_points
+    
+    # 3. Geography Match (max 20 points)
+    geo_points = 0
+    geo_hint = product_context.get("geography_hint")
+    fund_geo = fund.get("geography_focus", [])
+    if not fund_geo:
+        fund_geo = ["Global"]
+        
+    if not geo_hint or geo_hint == "Global":
+        geo_points = 10
+    elif fund_geo == ["India"] and geo_hint == "US":
+        geo_points = 0
+    elif geo_hint in fund_geo:
+        geo_points = 20
+    elif "Global" in fund_geo:
+        geo_points = 15
+        
+    score += geo_points
+    
+    # 4. Final Penalties
+    # Heuristic 1: India-only funds in US searches penalty
+    if geo_hint == "US" and "India" in fund_geo and "US" not in fund_geo and "Global" not in fund_geo:
+        score = max(0, score - 30)
+        
+    # Heuristic 2: Primary focus mismatch 
+    if fund_tags and extracted_tags:
+        if fund_tags[0] not in extracted_tags and tag_points <= 20:
+            score = max(0, score - 15)
+    
+    return score, matched_tags
+
+def get_confidence_tier(score: int) -> str:
+    """Return High/Medium/Low based on score."""
+    if score >= 70:
+        return "High"
+    if score >= 40:
+        return "Medium"
+    return "Low"
+
+def match_vcs(product_context: Dict, data_path: str = "data/vc_funds.json") -> List[Dict]:
+    """Score all funds and return prioritized matches."""
+    funds = load_funds(data_path)
+    scored_funds = []
+    
+    for fund in funds:
+        score, matched_tags = score_fund(fund, product_context)
+        scored_funds.append({
+            "fund": fund,
+            "score": score,
+            "confidence": get_confidence_tier(score),
+            "matched_tags": matched_tags
+        })
+        
+    scored_funds.sort(key=lambda x: (-x["score"], x["fund"].get("fund_name", "")))
+    
+    if all(f["score"] == 0 for f in scored_funds):
+        generalists = [f for f in funds if "Generalist" in f.get("industry_tags", [])][:5]
+        return [{
+            "fund": g,
+            "score": 0,
+            "confidence": "Low",
+            "matched_tags": ["Generalist"],
+            "warning": "No strong matches found. Showing generalist funds only."
+        } for g in generalists]
+        
+    return scored_funds[:10]

package/skills/vc-curated-match/scripts/run.py

@@ -0,0 +1,82 @@
+import argparse
+import sys
+import os
+
+# Import the core pipeline components
+from fetch_product_context import get_product_context
+from match_vcs import match_vcs
+from generate_report import generate_report
+
+def main():
+    parser = argparse.ArgumentParser(description="vc-curated-match: Algorithmically identify relevant VCs based on product context.")
+    
+    parser.add_argument("--description", required=True, help="Product description string.")
+    parser.add_argument("--url", required=True, help="Product homepage or GitHub URL.")
+    parser.add_argument("--stage", default=None, help="Optional startup stage hint.")
+    parser.add_argument("--geography", default=None, help="Optional target geography (Defaults to Global inference).")
+    parser.add_argument("--output", default="vc-matches.md", help="Output file path (Defaults to vc-matches.md).")
+
+    args = parser.parse_args()
+
+    # Validation
+    if not args.description or not args.description.strip():
+        print("Error: --description must not be empty or whitespace only.", file=sys.stderr)
+        sys.exit(1)
+        
+    if not args.url or not args.url.strip():
+        print("Error: --url must not be empty.", file=sys.stderr)
+        sys.exit(1)
+
+    # Validate dataset existence per requirements
+    data_path = os.path.join(os.path.dirname(__file__), "..", "data", "vc_funds.json")
+    if not os.path.exists(data_path):
+        print("Error: data/vc_funds.json not found. Make sure you are running from the skill root directory.", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        stage_input = args.stage.strip() if args.stage else None
+        if stage_input and stage_input.lower() == "pre-seed":
+            stage_input = "Pre-seed"
+        elif stage_input:
+            stage_input = stage_input.capitalize()
+
+        # 1. Fetch Product Context
+        product_context = get_product_context(
+            description=args.description.strip(),
+            url=args.url.strip(),
+            stage=stage_input,
+            geography=args.geography.strip() if args.geography else None
+        )
+        
+        # 2. Match VCs
+        matches = match_vcs(product_context, data_path=data_path)
+        
+        # 3. Generate Report
+        report_str = generate_report(matches, product_context)
+        
+        # Ensure output directory exists and write
+        output_dir = os.path.dirname(os.path.abspath(args.output))
+        if output_dir:
+            os.makedirs(output_dir, exist_ok=True)
+            
+        try:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(report_str)
+        except IOError:
+            print(f"Error: Could not write to {args.output}.", file=sys.stderr)
+            sys.exit(1)
+            
+        # 4. Generate Summary Console Print
+        high = sum(1 for m in matches if m.get("confidence") == "High")
+        medium = sum(1 for m in matches if m.get("confidence") == "Medium")
+        low = sum(1 for m in matches if m.get("confidence") == "Low")
+        
+        print(f"Done. Report saved to {args.output}")
+        print(f"Found {len(matches)} matches: {high} High, {medium} Medium, {low} Low confidence")
+
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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

@@ -1,10 +1,6 @@
 # vc-finder: Environment Variables
 # ===================================
-# Gemini and Tavily are required. Firecrawl is recommended.
-
-# Required: Google Gemini API key for product analysis and VC synthesis
-# Get it: aistudio.google.com > Get API key
-GEMINI_API_KEY=your_gemini_api_key_here
+# Tavily is required. Firecrawl is recommended.
 
 # Required: Tavily API key for VC investment research (Track A and Track B searches)
 # Get it: app.tavily.com > API Keys

package/skills/vc-finder/README.md

@@ -30,29 +30,32 @@ https://github.com/user-attachments/assets/ee98a1b5-ebc4-452f-bbfb-c434f2935067
 
 - Fetches the product URL via Firecrawl (handles JS-rendered SPAs) or Tavily extract as fallback
 - Detects funding stage from CTA signals on the page (waitlist, free trial, pricing, sales CTAs)
-- Uses Gemini to map a 3-level industry taxonomy (L1 > L2 > L3) and identify 5 comparable funded companies
+- Maps a 3-level industry taxonomy (L1 > L2 > L3) from the product page
+- **Curated pre-match (Step 5b):** Scores product against a verified dataset of 25 VC funds (sourced from fund websites) -- instant zero-hallucination matches with no Tavily credits consumed
+- **Discovers comparable companies:** Curated portfolio companies from matched funds + Tavily live search for L3-niche specifics
 - Track A: 5 Tavily searches to find who invested in each comparable company
 - Track B: 3 Tavily searches to find VCs who publish investment theses about this specific niche
-- Gemini synthesizes and ranks all found VCs by stage fit and space fit (1-10 scores)
+- Synthesizes and ranks all found VCs -- curated matches labeled "verified", Tavily matches labeled by track
 - Produces top 5 deep-dives with fund overview, portfolio evidence, how-to-approach, and outreach hook
 - Generates 3 product-specific outreach hooks (not generic advice)
 - Saves output to `docs/vc-intel/[product]-[date].md`
 
+**Zero-hallucination guarantee:** Every VC name, fund detail, check size, portfolio company, and thesis source in the output must trace to either (a) the curated `data/vc_funds.json` dataset (sourced from fund websites) or (b) a specific Tavily search result. The AI does not draw from training knowledge for any factual claim.
+
 ## Requirements
 
 | Requirement | Purpose | How to Set Up |
 |---|---|---|
-| Gemini API key | Product analysis and VC synthesis | aistudio.google.com, Get API key |
 | Tavily API key | VC investment research (Track A and Track B) | app.tavily.com, free tier: 1000 credits/month |
-| Firecrawl API key | Fetching JS-rendered product pages | firecrawl.dev, free tier: 500 credits/month |
+| Firecrawl API key | Fetching JS-rendered product pages (optional) | firecrawl.dev, free tier: 500 credits/month |
 
-Gemini and Tavily are required. Firecrawl is recommended -- without it, Tavily extract is used as fallback (may miss JS-rendered content).
+Tavily is required. Firecrawl is recommended -- without it, Tavily extract is used as fallback (may miss JS-rendered content).
 
 ## Setup
 
 ```bash
 cp .env.example .env
-# Add GEMINI_API_KEY and TAVILY_API_KEY (required)
+# Add TAVILY_API_KEY (required)
 # Add FIRECRAWL_API_KEY (recommended)
 ```
 
@@ -90,9 +93,9 @@ Each run produces:
 ## Cost per Run
 
 - Firecrawl: ~$0.001 per fetch
-- Tavily: 8 searches at ~$0.01 each = ~$0.08
-- Gemini: 2 calls at ~$0.015 each = ~$0.03
-- Total: ~$0.12 per run
+- Tavily: 10 searches at ~$0.01 each = ~$0.10 (2 comparable discovery + 5 Track A + 3 Track B)
+- Curated pre-match (Step 5b): $0.00 -- local scoring against `data/vc_funds.json`, no API calls
+- Total: ~$0.10 per run
 
 ## Project Structure
 
@@ -101,6 +104,10 @@ vc-finder/
 ├── SKILL.md
 ├── README.md
 ├── .env.example
+├── data/
+│   └── vc_funds.json          (25 verified funds, sourced from fund websites)
+├── scripts/
+│   └── match_funds.py         (standalone scoring script for testing)
 ├── evals/
 │   └── evals.json
 └── references/