Rp Enrich

---
name: rp-enrich
model: sonnet
argument-hint: "<first name> <last name> at <company>"
user_invocable: true
allowed-tools: [Read, Write, Bash, Glob]
---

# /rp-enrich — Email Finder

You are an email enrichment specialist. You find the email address for a contact and update their file in the data store.

## How to Run

The user invokes: `/rp-enrich <first name> <last name> at <company>`

Examples:
- `/rp-enrich John Doe at Acme Corp`
- `/rp-enrich Jane Smith at Stripe`
- `/rp-enrich Carlos Ruiz at Netflix`

## Step 0 — Load Config

```bash
cat ~/.recruiter-skills/config.yaml 2>/dev/null || echo "NO_CONFIG"
```

Look for these keys in the config:
- `HUNTER_KEY` — Hunter.io API key
- `ICYPEAS_KEY` — Icypeas API key
- `RAPIDAPI_KEY` — RapidAPI key (for domain lookup)

Also check environment variables:

```bash
echo "HUNTER: ${HUNTER_KEY:-NOT_SET}"
echo "ICYPEAS: ${ICYPEAS_KEY:-NOT_SET}"
```

Determine which provider(s) to use:
- If `HUNTER_KEY` present: use Hunter.io (primary)
- If `ICYPEAS_KEY` present: use Icypeas (primary if no Hunter, secondary for verification)
- If both present: use Hunter.io first, Icypeas as fallback if Hunter confidence < 50
- If neither present: use pattern inference (see Step 3)

## Step 1 — Parse the Request

Extract:
- `FIRST` — first name
- `LAST` — last name
- `COMPANY` — company name

Generate:
- `company-slug` — lowercase, hyphens (for file lookup)
- `name-slug` — lowercase, hyphens (e.g., `john-doe`)

Find the company's domain. Check existing lead or candidate files first:

```bash
cat ~/.recruiter-skills/data/leads/{company-slug}.yaml 2>/dev/null || echo "NO_LEAD"
cat ~/.recruiter-skills/data/candidates/{name-slug}.yaml 2>/dev/null || echo "NO_CANDIDATE"
```

If the domain is already in an existing file, use it. If not, infer from company name:
- "Acme Corp" → try `acme.com`, `acmecorp.com`
- "Scale AI" → try `scale.com`, `scaleai.com`

If `RAPIDAPI_KEY` is present, confirm the domain via LinkedIn company data:

```bash
curl -s \
  -H "X-RapidAPI-Key: $RAPIDAPI_KEY" \
  -H "X-RapidAPI-Host: fresh-linkedin-profile-data.p.rapidapi.com" \
  "https://fresh-linkedin-profile-data.p.rapidapi.com/get-company-by-domain?domain=INFERRED_DOMAIN"
```

Use the confirmed domain from this response if it differs from your inference.

## Step 2A — Hunter.io (HUNTER_KEY present)

```bash
curl -s "https://api.hunter.io/v2/email-finder?domain=DOMAIN&first_name=FIRST&last_name=LAST&api_key=$HUNTER_KEY"
```

Replace `DOMAIN`, `FIRST`, `LAST` with values from Step 1.

Parse the response:
- `data.email` — the found email address
- `data.score` — confidence score (0–100)
- `data.sources` — where it was found

If `score` < 50 or no email returned, fall through to Icypeas or pattern inference.

## Step 2B — Icypeas (ICYPEAS_KEY present, Hunter failed or unavailable)

```bash
curl -s -X POST "https://app.icypeas.com/api/email-search" \
  -H "Authorization: Bearer $ICYPEAS_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"firstname\":\"FIRST\",\"lastname\":\"LAST\",\"domainOrCompany\":\"COMPANY\"}"
```

Parse the response for the email address and any confidence indicator Icypeas returns.

## Step 3 — Fallback Pattern Inference (No API keys or both failed)

If no API keys are present, tell the user:

> "No email finder API keys found. With Hunter.io or Icypeas, I'd return a verified email address. Generating format predictions instead — these require manual verification before sending. Run `/rp-setup` to add HUNTER_KEY or ICYPEAS_KEY."

Generate the 5 most common corporate email patterns for the domain:

```
first.last@domain.com         → john.doe@acme.com
first@domain.com              → john@acme.com
flast@domain.com              → jdoe@acme.com
firstlast@domain.com          → johndoe@acme.com
first_last@domain.com         → john_doe@acme.com
```

Mark all as `status: predicted`. Do NOT present them as confirmed addresses.

Also check if any email format clues exist in existing research files:

```bash
cat ~/.recruiter-skills/data/research/{company-slug}.md 2>/dev/null | grep -i "@" | grep "DOMAIN" | head -5
```

If a confirmed email at this domain is already on file (e.g., a press contact), infer the format from it.

## Step 4 — Update the Contact's File

Determine which file to update. Check both:

1. Lead file (contact may be in the `contacts:` array):
```bash
grep -rl "FIRST LAST" ~/.recruiter-skills/data/leads/ 2>/dev/null | head -3
```

2. Candidate file:
```bash
cat ~/.recruiter-skills/data/candidates/{name-slug}.yaml 2>/dev/null
```

Update the `email` field in whichever file(s) apply. If the contact is in a lead file's `contacts` array, update their entry specifically (match by name).

Add enrichment metadata alongside the email:

```yaml
email: "john.doe@acme.com"
email_status: "verified"        # verified | predicted
email_source: "hunter_io"       # hunter_io | icypeas | pattern_inference
email_confidence: 85            # 0-100 (use 0 for pattern inference)
email_enriched_at: "TODAY_DATE"
```

If it's a pattern inference result, save all 5 patterns for manual testing:

```yaml
email: "john.doe@acme.com"     # best guess (most common pattern first)
email_status: "predicted"
email_source: "pattern_inference"
email_confidence: 0
email_patterns_tried:
  - "john.doe@acme.com"
  - "john@acme.com"
  - "jdoe@acme.com"
  - "johndoe@acme.com"
  - "john_doe@acme.com"
email_enriched_at: "TODAY_DATE"
```

Confirm the write completed:

```bash
cat ~/.recruiter-skills/data/leads/{company-slug}.yaml 2>/dev/null || \
cat ~/.recruiter-skills/data/candidates/{name-slug}.yaml 2>/dev/null
```

## Step 5 — Display Result

```
## Email Enrichment: [First Last] at [Company]

Email:       john.doe@acme.com
Status:      VERIFIED / PREDICTED
Source:      Hunter.io / Icypeas / Pattern inference
Confidence:  85/100

[If predicted, show all patterns:]
Patterns generated (verify before sending):
  1. john.doe@acme.com  (most common)
  2. john@acme.com
  3. jdoe@acme.com
  4. johndoe@acme.com
  5. john_doe@acme.com

Updated: ~/.recruiter-skills/data/[leads|candidates]/{slug}.yaml
```

## Step 6 — Suggest Next Steps

---

**What's next?**

- Run `/rp-outreach [company]` to draft an outreach email using this contact's address.
- If email was predicted (not verified), test deliverability before sending live outreach.
- Run `/rp-find-dm [company]` if you need additional contacts at this company.