@opendirectory.dev/skills 0.1.40 → 0.1.41

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()