jd-intel 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# jd-intel
+
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Node.js 18+](https://img.shields.io/badge/node-18%2B-green.svg)](https://nodejs.org)
+[![npm](https://img.shields.io/npm/v/jd-intel.svg)](https://www.npmjs.com/package/jd-intel)
+
+> **Stop pasting job descriptions into AI assistants. Let your AI fetch them directly.**
+
+Full text. Clean structure. Across every major ATS. No copy-paste. No context loss.
+
+---
+
+## Why this exists
+
+Your AI assistant already knows a lot about you. Your resume is in its memory. Your target roles, your past projects, your background. Ready to help the moment you feed it a job description.
+
+So you copy-paste.
+
+A JD from Stripe. Another from Mercury. Six more from your target list. Half have broken HTML. Salary info dies in translation. Links get stripped. And for every role, the dance starts over.
+
+You could wait for the job boards to ship their own MCPs. They'll get there eventually. On their timeline. Filtered through their priorities, not yours. Tied to their query abstractions.
+
+jd-intel skips that wait. Raw JDs, fetched directly by your AI, on your terms. One level below the curated layer.
+
+> "Claude, pull the senior PM role at Stripe and draft a cover letter based on my resume."
+
+Done.
+
+---
+
+## What you can do with it
+
+- Draft cover letters without pasting anything
+- Tailor your resume across ten roles in one conversation
+- Rank openings by fit with your background
+- Scan a whole sector: "Pull PM roles at fintech companies posted this week"
+- Research teams by reading their JDs in bulk
+
+The toolkit fetches. Your AI thinks.
+
+---
+
+## Install
+
+### For Claude Desktop, Cursor, Windsurf users
+
+Add to your MCP config file:
+
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "jd-intel": {
+      "command": "npx",
+      "args": ["-y", "jd-intel-mcp"]
+    }
+  }
+}
+```
+
+Restart your AI client. The tools appear automatically. Ask your AI to fetch any role.
+
+**One-command install (avoids hand-editing the config):**
+```bash
+npx jd-intel-mcp install
+```
+
+### For developers (CLI and library)
+
+```bash
+npm install jd-intel
+```
+
+Or run without installing:
+
+```bash
+npx jd-intel fetch stripe --title-filter "product manager"
+```
+
+Or import as a library:
+
+```js
+import { fetchJobs, registry } from 'jd-intel';
+
+const jobs = await fetchJobs({
+  company: 'ramp',
+  titleFilter: 'engineer',
+  postedWithinDays: 14,
+  limit: 50,
+});
+```
+
+Node.js 18+. No API keys. No configuration.
+
+---
+
+## MCP tools
+
+| Tool | Purpose |
+|------|---------|
+| `fetch_jobs` | Get open roles at a company with filters for role type, topic, location, and recency |
+| `search_registry` | Find companies by name or sector |
+| `detect_ats` | Identify which ATS platform a company uses |
+
+Plus one Resource: `registry://jd-intel/all`. Full company registry, grouped by ATS. Fetched lazily for broad catalog surveys.
+
+---
+
+## What you get back
+
+Every job normalizes to one schema, across every platform:
+
+```json
+{
+  "id": "a1b2c3d4e5f6",
+  "company": "Stripe",
+  "title": "Senior Product Manager, Integrations",
+  "department": "Product",
+  "location": "San Francisco, CA",
+  "locationType": "hybrid",
+  "salary": { "min": 180000, "max": 260000, "currency": "USD" },
+  "description": "Lead strategy for Stripe's integration ecosystem...",
+  "url": "https://boards.greenhouse.io/stripe/jobs/12345",
+  "postedAt": "2026-04-10T14:30:00Z"
+}
+```
+
+No custom parsing per company.
+
+### Data model
+
+| Field | Description |
+|-------|-------------|
+| `title` | Full job title |
+| `company` | Normalized company name |
+| `department` | Team or department (when provided) |
+| `location` | City, state, country, or remote |
+| `locationType` | `remote`, `hybrid`, or `onsite` |
+| `salary` | Min-max range with currency (when available) |
+| `description` | Full JD in clean markdown |
+| `url` | Direct link to the posting |
+| `postedAt` | Publication date (when provided) |
+
+---
+
+## Platforms supported
+
+| Platform | Status | Typical use |
+|----------|--------|-------------|
+| Greenhouse | Shipped | Most widely used ATS in tech |
+| Ashby | Shipped | Growing fast with startups |
+| Lever | Shipped | Common at mid-stage companies |
+| BambooHR | Planned | Mid-market companies |
+| Workday | Planned | Large enterprises |
+
+Adding a new ATS is a single adapter file. See [Contributing](#contributing).
+
+---
+
+## Filters (quick reference)
+
+| Flag | What it matches | Use for |
+|------|-----------------|---------|
+| `--title-filter` | Title only | Role identity (PM, engineer, designer) |
+| `--filter` | Title + department + description | Topic or scope (integrations, growth) |
+| `--posted-within-days` | Recent postings | Recency cuts |
+| `--location-include` | Location contains any keyword | Region targeting |
+| `--location-exclude` | Location contains no keyword | Drop geographic noise |
+| `--limit` | First N results | Cap output size |
+
+All filters AND together. Deep dive on patterns and gotchas: [docs/filters.md](docs/filters.md).
+
+---
+
+## Roadmap
+
+**Shipped**
+- Library, CLI, and MCP server (three surfaces of one toolkit)
+- Greenhouse, Ashby, Lever adapters
+- Title, topic, location, and date filters
+- Salary extraction from JD text
+- Verified company registry (66 companies)
+
+**Next**
+- Anthropic MCP marketplace submission
+- Setup guide with screenshots (non-technical walkthrough)
+- Remote MCP transport (for Claude.ai Custom Connectors)
+
+**Planned**
+- BambooHR and Workday adapters
+- Temporal tracking (when roles open, close, reopen)
+- Change detection
+- Resume-aware fit scoring
+
+---
+
+## Contributing
+
+**Add a company to the registry:** submit a PR to the appropriate file in `registry/`.
+
+**Add an ATS adapter:** new file in `src/adapters/`. One adapter, one file. Follow the pattern of the existing three.
+
+**Request a company:** [open an issue](https://github.com/prPMDev/jd-intel/issues/new). Tell me who's missing.
+
+---
+
+## Built by
+
+**[Prashant R](https://prashantrana.xyz)**. PM who builds. I write about what actually happens at the layer below the AI hype.
+
+- Portfolio and writing: [prashantrana.xyz](https://prashantrana.xyz)
+- [LinkedIn](https://www.linkedin.com/in/prashant-rana)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "jd-intel",
+  "version": "0.1.0",
+  "description": "Fetch and normalize job descriptions across every major ATS (Greenhouse, Lever, Ashby) — for your AI assistant, no copy-paste.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "jd-intel": "src/cli.js"
+  },
+  "files": [
+    "src/",
+    "registry/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "fetch": "node src/cli.js fetch",
+    "search": "node src/cli.js search"
+  },
+  "keywords": [
+    "jobs",
+    "job-description",
+    "ats",
+    "greenhouse",
+    "lever",
+    "ashby",
+    "mcp",
+    "ai",
+    "claude",
+    "hiring",
+    "careers"
+  ],
+  "author": "Prashant R",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prPMDev/jd-intel.git"
+  },
+  "bugs": {
+    "url": "https://github.com/prPMDev/jd-intel/issues"
+  },
+  "homepage": "https://github.com/prPMDev/jd-intel#readme",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/registry/ashby.json

@@ -0,0 +1,16 @@
+[
+  {"slug": "notion",    "name": "Notion",    "sector": "productivity"},
+  {"slug": "linear",    "name": "Linear",    "sector": "developer tools"},
+  {"slug": "ramp",      "name": "Ramp",      "sector": "fintech"},
+  {"slug": "resend",    "name": "Resend",    "sector": "developer tools"},
+  {"slug": "clerk",     "name": "Clerk",     "sector": "developer tools"},
+  {"slug": "railway",   "name": "Railway",   "sector": "developer tools"},
+  {"slug": "drata",     "name": "Drata",     "sector": "security"},
+  {"slug": "watershed", "name": "Watershed", "sector": "climate tech"},
+  {"slug": "persona",   "name": "Persona",   "sector": "identity"},
+  {"slug": "stytch",    "name": "Stytch",    "sector": "identity"},
+  {"slug": "shiftkey",  "name": "ShiftKey",  "sector": "healthcare staffing"},
+  {"slug": "gorgias",   "name": "Gorgias",   "sector": "customer support"},
+  {"slug": "zapier",    "name": "Zapier",    "sector": "integration platform"},
+  {"slug": "clickup",   "name": "ClickUp",   "sector": "productivity"}
+]

package/registry/greenhouse.json

@@ -0,0 +1,47 @@
+[
+  {"slug": "stripe",            "name": "Stripe",            "sector": "fintech"},
+  {"slug": "airbnb",            "name": "Airbnb",            "sector": "travel"},
+  {"slug": "twitch",            "name": "Twitch",            "sector": "media"},
+  {"slug": "pinterest",         "name": "Pinterest",         "sector": "social"},
+  {"slug": "cloudflare",        "name": "Cloudflare",        "sector": "infrastructure"},
+  {"slug": "databricks",        "name": "Databricks",        "sector": "data"},
+  {"slug": "figma",             "name": "Figma",             "sector": "design tools"},
+  {"slug": "airtable",          "name": "Airtable",          "sector": "productivity"},
+  {"slug": "gusto",             "name": "Gusto",             "sector": "hr tech"},
+  {"slug": "brex",              "name": "Brex",              "sector": "fintech"},
+  {"slug": "vercel",            "name": "Vercel",            "sector": "developer tools"},
+  {"slug": "cockroachlabs",     "name": "Cockroach Labs",    "sector": "database"},
+  {"slug": "datadog",           "name": "Datadog",           "sector": "observability"},
+  {"slug": "elastic",           "name": "Elastic",           "sector": "search"},
+  {"slug": "reddit",            "name": "Reddit",            "sector": "social"},
+  {"slug": "squarespace",       "name": "Squarespace",       "sector": "web platform"},
+  {"slug": "toast",             "name": "Toast",             "sector": "restaurant tech"},
+  {"slug": "roku",              "name": "Roku",              "sector": "media"},
+  {"slug": "webflow",           "name": "Webflow",           "sector": "web platform"},
+  {"slug": "mercury",           "name": "Mercury",           "sector": "fintech"},
+  {"slug": "amplitude",         "name": "Amplitude",         "sector": "analytics"},
+  {"slug": "mixpanel",          "name": "Mixpanel",          "sector": "analytics"},
+  {"slug": "expel",             "name": "Expel",             "sector": "security"},
+  {"slug": "calendly",          "name": "Calendly",          "sector": "productivity"},
+  {"slug": "lattice",           "name": "Lattice",           "sector": "hr tech"},
+  {"slug": "samsara",           "name": "Samsara",           "sector": "iot"},
+  {"slug": "twilio",            "name": "Twilio",            "sector": "communications"},
+  {"slug": "pagerduty",         "name": "PagerDuty",         "sector": "devops"},
+  {"slug": "contentful",        "name": "Contentful",        "sector": "cms"},
+  {"slug": "sendbird",          "name": "Sendbird",          "sector": "communications"},
+  {"slug": "workato",           "name": "Workato",           "sector": "integration platform"},
+  {"slug": "merge",             "name": "Merge",             "sector": "integration platform"},
+  {"slug": "pandadoc",          "name": "PandaDoc",          "sector": "sales tech"},
+  {"slug": "fivetran",          "name": "Fivetran",          "sector": "data integration"},
+  {"slug": "securityscorecard", "name": "SecurityScorecard", "sector": "security"},
+  {"slug": "invoca",            "name": "Invoca",            "sector": "marketing tech"},
+  {"slug": "intercom",          "name": "Intercom",          "sector": "customer support"},
+  {"slug": "dialpad",           "name": "Dialpad",           "sector": "communications"},
+  {"slug": "salesloft",         "name": "Salesloft",         "sector": "sales tech"},
+  {"slug": "klaviyo",           "name": "Klaviyo",           "sector": "marketing tech"},
+  {"slug": "cleo",              "name": "Cleo",              "sector": "fintech"},
+  {"slug": "braze",             "name": "Braze",             "sector": "marketing tech"},
+  {"slug": "appsflyer",         "name": "AppsFlyer",         "sector": "marketing tech"},
+  {"slug": "attentive",         "name": "Attentive",         "sector": "marketing tech"},
+  {"slug": "iterable",          "name": "Iterable",          "sector": "marketing tech"}
+]

package/registry/lever.json

@@ -0,0 +1,10 @@
+[
+  {"slug": "olo",       "name": "Olo",      "sector": "restaurant tech"},
+  {"slug": "outreach",  "name": "Outreach", "sector": "sales tech"},
+  {"slug": "whoop",     "name": "WHOOP",    "sector": "wearables"},
+  {"slug": "plaid",     "name": "Plaid",    "sector": "fintech"},
+  {"slug": "clari",     "name": "Clari",    "sector": "sales tech"},
+  {"slug": "netflix",   "name": "Netflix",  "sector": "media"},
+  {"slug": "lever",     "name": "Lever",    "sector": "recruiting tech"},
+  {"slug": "postman",   "name": "Postman",  "sector": "developer tools"}
+]

package/src/adapters/ashby.js

@@ -0,0 +1,137 @@
+import { normalize } from '../normalizer.js';
+
+const API_URL = 'https://jobs.ashbyhq.com/api/non-user-graphql';
+const BOARD_URL = 'https://api.ashbyhq.com/posting-api/job-board';
+
+/**
+ * Fetch all jobs from an Ashby job board.
+ * Public API, no auth required.
+ * Docs: https://developers.ashbyhq.com/docs/public-job-posting-api
+ *
+ * @param {string} slug - Company slug (e.g., 'notion', 'linear')
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchAshby(slug) {
+  // Try the REST API first (simpler, includes compensation)
+  try {
+    const restJobs = await fetchAshbyRest(slug);
+    if (restJobs.length > 0) return restJobs;
+  } catch { /* fall through to GraphQL */ }
+
+  // Fallback: GraphQL API
+  return fetchAshbyGraphQL(slug);
+}
+
+async function fetchAshbyRest(slug) {
+  const url = `${BOARD_URL}/${slug}?includeCompensation=true`;
+  const resp = await fetch(url);
+
+  if (!resp.ok) {
+    if (resp.status === 404) return [];
+    throw new Error(`Ashby REST API error for ${slug}: ${resp.status}`);
+  }
+
+  const data = await resp.json();
+  const jobs = data.jobs || [];
+
+  return jobs.map(job => {
+    const salary = parseAshbyCompensation(job.compensation);
+
+    return normalize({
+      companySlug: slug,
+      company: data.organizationName || slug,
+      title: job.title || '',
+      department: job.departmentName || '',
+      location: job.location || '',
+      description: job.descriptionHtml || job.descriptionPlain || '',
+      url: `https://jobs.ashbyhq.com/${slug}/${job.id}`,
+      postedAt: job.publishedAt || null,
+      salary,
+      metadata: {
+        ashbyId: job.id,
+        employmentType: job.employmentType || '',
+        isRemote: job.isRemote || false,
+        team: job.teamName || '',
+      },
+    }, 'ashby');
+  });
+}
+
+async function fetchAshbyGraphQL(slug) {
+  const query = `{
+    jobBoard {
+      title
+      jobPostings {
+        id
+        title
+        locationName
+        employmentType
+        descriptionHtml
+        publishedDate
+        compensationTierSummary
+      }
+    }
+  }`;
+
+  const resp = await fetch(API_URL, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      operationName: 'ApiJobBoardWithTeams',
+      variables: { organizationHostedJobsPageName: slug },
+      query,
+    }),
+  });
+
+  if (!resp.ok) return [];
+
+  const data = await resp.json();
+  const board = data.data?.jobBoard;
+  if (!board) return [];
+
+  const postings = board.jobPostings || [];
+
+  return postings.map(job => normalize({
+    companySlug: slug,
+    company: board.title || slug,
+    title: job.title || '',
+    department: '',
+    location: job.locationName || '',
+    description: job.descriptionHtml || '',
+    url: `https://jobs.ashbyhq.com/${slug}/${job.id}`,
+    postedAt: job.publishedDate || null,
+    salary: null,
+    metadata: {
+      ashbyId: job.id,
+      employmentType: job.employmentType || '',
+      compensationSummary: job.compensationTierSummary || '',
+    },
+  }, 'ashby'));
+}
+
+function parseAshbyCompensation(comp) {
+  if (!comp) return null;
+  // Ashby compensation can be a string or structured object
+  if (typeof comp === 'string') {
+    const match = comp.match(/\$?([\d,]+)\s*[-–]\s*\$?([\d,]+)/);
+    if (!match) return null;
+    return {
+      min: parseInt(match[1].replace(/,/g, '')),
+      max: parseInt(match[2].replace(/,/g, '')),
+      currency: 'USD',
+    };
+  }
+  if (comp.min && comp.max) {
+    return { min: comp.min, max: comp.max, currency: comp.currency || 'USD' };
+  }
+  return null;
+}
+
+export async function hasAshby(slug) {
+  try {
+    const resp = await fetch(`${BOARD_URL}/${slug}`, { method: 'HEAD' });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}

package/src/adapters/greenhouse.js

@@ -0,0 +1,54 @@
+import { normalize, stripHtml } from '../normalizer.js';
+
+const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
+
+/**
+ * Fetch all jobs from a Greenhouse job board.
+ * Public API, no auth required.
+ * Docs: https://developers.greenhouse.io/job-board.html
+ *
+ * @param {string} slug - Company slug (e.g., 'stripe', 'notion')
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchGreenhouse(slug) {
+  const url = `${BASE_URL}/${slug}/jobs?content=true`;
+  const resp = await fetch(url);
+
+  if (!resp.ok) {
+    if (resp.status === 404) return []; // Company not found or no jobs
+    throw new Error(`Greenhouse API error for ${slug}: ${resp.status}`);
+  }
+
+  const data = await resp.json();
+  const jobs = data.jobs || [];
+
+  return jobs.map(job => normalize({
+    companySlug: slug,
+    company: data.name || slug,
+    title: job.title || '',
+    department: job.departments?.[0]?.name || '',
+    location: job.location?.name || '',
+    description: stripHtml(job.content || ''),
+    url: job.absolute_url || '',
+    postedAt: job.updated_at || null,
+    salary: null, // Greenhouse doesn't expose salary in public API
+    metadata: {
+      greenhouseId: job.id,
+      internal_job_id: job.internal_job_id,
+      departments: job.departments?.map(d => d.name) || [],
+      offices: job.offices?.map(o => o.name) || [],
+    },
+  }, 'greenhouse'));
+}
+
+/**
+ * Check if a company has a Greenhouse board.
+ */
+export async function hasGreenhouse(slug) {
+  try {
+    const resp = await fetch(`${BASE_URL}/${slug}`, { method: 'HEAD' });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}

package/src/adapters/index.js

@@ -0,0 +1,11 @@
+export { fetchGreenhouse, hasGreenhouse } from './greenhouse.js';
+export { fetchLever, hasLever } from './lever.js';
+export { fetchAshby, hasAshby } from './ashby.js';
+
+export const ADAPTERS = {
+  greenhouse: { fetch: (...args) => import('./greenhouse.js').then(m => m.fetchGreenhouse(...args)), has: (...args) => import('./greenhouse.js').then(m => m.hasGreenhouse(...args)) },
+  lever: { fetch: (...args) => import('./lever.js').then(m => m.fetchLever(...args)), has: (...args) => import('./lever.js').then(m => m.hasLever(...args)) },
+  ashby: { fetch: (...args) => import('./ashby.js').then(m => m.fetchAshby(...args)), has: (...args) => import('./ashby.js').then(m => m.hasAshby(...args)) },
+};
+
+export const ATS_NAMES = Object.keys(ADAPTERS);

package/src/adapters/lever.js

@@ -0,0 +1,77 @@
+import { normalize, stripHtml } from '../normalizer.js';
+
+const BASE_URL = 'https://api.lever.co/v0/postings';
+
+/**
+ * Fetch all jobs from a Lever job board.
+ * Public API, no auth required.
+ *
+ * @param {string} slug - Company slug (e.g., 'stripe', 'figma')
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchLever(slug) {
+  const url = `${BASE_URL}/${slug}?mode=json`;
+  const resp = await fetch(url);
+
+  if (!resp.ok) {
+    if (resp.status === 404) return [];
+    throw new Error(`Lever API error for ${slug}: ${resp.status}`);
+  }
+
+  const jobs = await resp.json();
+  if (!Array.isArray(jobs)) return [];
+
+  return jobs.map(job => {
+    const salary = parseLeverSalary(job.categories?.commitment, job.text);
+
+    return normalize({
+      companySlug: slug,
+      // Lever's API doesn't return the company name at the board or job level,
+      // so the slug is the honest fallback. `categories.team` is the team within
+      // the company ("Payments Platform"), not the company itself.
+      company: titleCaseSlug(slug),
+      title: job.text || '',
+      department: job.categories?.department || job.categories?.team || '',
+      location: job.categories?.location || '',
+      description: stripHtml(job.descriptionPlain || job.description || ''),
+      url: job.hostedUrl || '',
+      postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
+      salary,
+      metadata: {
+        leverId: job.id,
+        team: job.categories?.team || '',
+        commitment: job.categories?.commitment || '', // Full-time, Part-time, etc.
+        workplaceType: job.workplaceType || '',
+      },
+    }, 'lever');
+  });
+}
+
+function titleCaseSlug(slug) {
+  if (!slug) return '';
+  // "cockroachlabs" → "Cockroachlabs", "netflix" → "Netflix"
+  // Best-effort display name; users should prefer companySlug for exact matching.
+  return slug.charAt(0).toUpperCase() + slug.slice(1);
+}
+
+function parseLeverSalary(commitment, title) {
+  // Lever doesn't have a salary field, but sometimes it's in the title
+  const match = (title || '').match(/\$[\d,]+\s*[-–]\s*\$[\d,]+/);
+  if (!match) return null;
+  const nums = match[0].match(/[\d,]+/g);
+  if (!nums || nums.length < 2) return null;
+  return {
+    min: parseInt(nums[0].replace(/,/g, '')),
+    max: parseInt(nums[1].replace(/,/g, '')),
+    currency: 'USD',
+  };
+}
+
+export async function hasLever(slug) {
+  try {
+    const resp = await fetch(`${BASE_URL}/${slug}?mode=json`, { method: 'HEAD' });
+    return resp.ok;
+  } catch {
+    return false;
+  }
+}

package/src/cli.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+/**
+ * jd-intel CLI
+ *
+ * Usage:
+ *   jd-intel fetch <company> [--ats greenhouse|lever|ashby] [--filter keyword|pattern]
+ *   jd-intel detect <company>
+ *   jd-intel registry search <query>
+ */
+
+import { fetchJobs } from './index.js';
+import { detectAts, searchRegistry } from './registry.js';
+
+const [,, command, ...args] = process.argv;
+
+async function main() {
+  switch (command) {
+    case 'fetch': {
+      const company = args[0];
+      if (!company) { console.error('Usage: jd-intel fetch <company> [--ats greenhouse|lever|ashby]'); process.exit(1); }
+      const getArg = (flag) => {
+        const idx = args.indexOf(flag);
+        return idx >= 0 ? args[idx + 1] : undefined;
+      };
+      const ats = getArg('--ats');
+      const titleFilter = getArg('--title-filter');
+      const filter = getArg('--filter');
+      const postedWithinRaw = getArg('--posted-within-days');
+      const postedWithinDays = postedWithinRaw !== undefined ? Number(postedWithinRaw) : undefined;
+      const locIncludeRaw = getArg('--location-include');
+      const locationIncludes = locIncludeRaw ? locIncludeRaw.split(',').map(s => s.trim()).filter(Boolean) : undefined;
+      const locExcludeRaw = getArg('--location-exclude');
+      const locationExcludes = locExcludeRaw ? locExcludeRaw.split(',').map(s => s.trim()).filter(Boolean) : undefined;
+      const limitRaw = getArg('--limit');
+      const limit = limitRaw !== undefined ? Number(limitRaw) : undefined;
+
+      const parts = [];
+      if (titleFilter) parts.push(`title: ${titleFilter}`);
+      if (filter) parts.push(`topic: ${filter}`);
+      if (postedWithinDays !== undefined) parts.push(`within ${postedWithinDays}d`);
+      if (locationIncludes) parts.push(`loc+: ${locationIncludes.join('|')}`);
+      if (locationExcludes) parts.push(`loc-: ${locationExcludes.join('|')}`);
+      const suffix = parts.length ? ` [${parts.join(', ')}]` : '';
+
+      console.log(`Fetching jobs from ${company}${ats ? ` (${ats})` : ' (auto-detect)'}${suffix}...`);
+      const jobs = await fetchJobs({
+        company, ats, titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit,
+      });
+      console.log(`Found ${jobs.length} jobs\n`);
+
+      for (const job of jobs.slice(0, 20)) {
+        const salary = job.salary ? ` | $${job.salary.min?.toLocaleString()}-$${job.salary.max?.toLocaleString()}` : '';
+        const loc = job.location ? ` | ${job.location}` : '';
+        const dept = job.department ? ` [${job.department}]` : '';
+        console.log(`  ${job.title}${dept}${loc}${salary}`);
+        console.log(`  ${job.url}`);
+        if (job.description) {
+          const preview = job.description.substring(0, 120).replace(/\n/g, ' ');
+          console.log(`  ${preview}...`);
+        }
+        console.log();
+      }
+
+      if (jobs.length > 20) {
+        console.log(`  ... and ${jobs.length - 20} more. Use --json for full output.`);
+      }
+
+      if (args.includes('--json')) {
+        console.log(JSON.stringify(jobs, null, 2));
+      }
+      break;
+    }
+
+    case 'detect': {
+      const company = args[0];
+      if (!company) { console.error('Usage: jd-intel detect <company>'); process.exit(1); }
+      console.log(`Detecting ATS for ${company}...`);
+      const results = await detectAts(company);
+      if (results.length === 0) {
+        console.log('No ATS board found for this company.');
+      } else {
+        for (const r of results) {
+          console.log(`  Found: ${r.ats} (slug: ${r.slug})`);
+        }
+      }
+      break;
+    }
+
+    case 'registry': {
+      const subcommand = args[0];
+      if (subcommand === 'search') {
+        const query = args.slice(1).join(' ');
+        if (!query) { console.error('Usage: jd-intel registry search <query>'); process.exit(1); }
+        const results = await searchRegistry(query);
+        console.log(`Found ${results.length} companies matching "${query}":\n`);
+        for (const r of results) {
+          console.log(`  ${r.name || r.slug} (${r.ats})${r.sector ? ` — ${r.sector}` : ''}`);
+        }
+      } else {
+        console.error('Usage: jd-intel registry search <query>');
+      }
+      break;
+    }
+
+    default:
+      console.log(`jd-intel — JD intelligence toolkit for your AI assistant.
+
+Usage:
+  jd-intel fetch <company> [options]
+  jd-intel detect <company>
+  jd-intel registry search <query>
+
+Fetch options:
+  --ats greenhouse|lever|ashby    Skip auto-detect
+  --title-filter pattern          Regex matched against TITLE only (role identity)
+  --filter pattern                Regex matched across title, department, description (topic/scope)
+  --posted-within-days N          Only jobs posted in the last N days
+  --location-include "A,B,C"      Keep jobs whose location contains any of these
+  --location-exclude "A,B,C"      Drop jobs whose location contains any of these
+  --limit N                       Cap results (default 100)
+  --json                          Output full JSON
+
+Filter guidance:
+  Use --title-filter for "what KIND of role" (PM, engineer, designer).
+  Use --filter for "what it's ABOUT" (integrations, growth, payments).
+  Both AND together. Avoid --filter "product manager" — description
+  mentions of PMs in other roles' JDs create false positives.
+
+Examples:
+  jd-intel fetch stripe
+  jd-intel fetch stripe --title-filter "product manager" --filter "growth|platform"
+  jd-intel fetch ramp --location-include "United States,US,Remote - US" --location-exclude "London,Dublin"
+  jd-intel fetch notion --ats ashby --title-filter engineer --posted-within-days 14
+  jd-intel detect figma
+  jd-intel registry search fintech`);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/src/filters.js

@@ -0,0 +1,83 @@
+/**
+ * Apply filters to a list of normalized jobs.
+ *
+ * Facts go here (deterministic field matches). Interpretations stay with the
+ * caller — this module does substring matching on structured fields, nothing
+ * semantic.
+ */
+export function applyFilters(jobs, options = {}) {
+  const {
+    titleFilter,
+    filter,
+    postedWithinDays,
+    locationIncludes,
+    locationExcludes,
+    limit = 100,
+  } = options;
+
+  let result = jobs;
+
+  if (titleFilter) {
+    const pattern = new RegExp(titleFilter, 'i');
+    result = result.filter(j => pattern.test(j.title || ''));
+  }
+
+  if (filter) {
+    const pattern = new RegExp(filter, 'i');
+    result = result.filter(j =>
+      pattern.test(j.title || '') ||
+      pattern.test(j.department || '') ||
+      pattern.test(j.description || '')
+    );
+  }
+
+  if (typeof postedWithinDays === 'number') {
+    const cutoff = Date.now() - postedWithinDays * 86400000;
+    result = result.filter(j => {
+      if (!j.postedAt) return false;
+      const posted = new Date(j.postedAt).getTime();
+      return Number.isFinite(posted) && posted >= cutoff;
+    });
+  }
+
+  if (Array.isArray(locationIncludes) && locationIncludes.length > 0) {
+    const matchers = locationIncludes.map(makeLocationMatcher);
+    result = result.filter(j => {
+      const loc = (j.location || '').toLowerCase();
+      return matchers.some(m => m(loc));
+    });
+  }
+
+  if (Array.isArray(locationExcludes) && locationExcludes.length > 0) {
+    const matchers = locationExcludes.map(makeLocationMatcher);
+    result = result.filter(j => {
+      const loc = (j.location || '').toLowerCase();
+      return !matchers.some(m => m(loc));
+    });
+  }
+
+  if (typeof limit === 'number' && result.length > limit) {
+    result = result.slice(0, limit);
+  }
+
+  return result;
+}
+
+/**
+ * Build a matcher for a single location keyword.
+ *
+ * Short tokens (≤4 chars) use word-boundary matching to prevent substring
+ * collisions like "US" matching "Australia", "Brussels", "Belarus", or "UK"
+ * matching "Auckland". Longer tokens use substring matching so phrases like
+ * "United States" can match "United States of America".
+ */
+function makeLocationMatcher(needle) {
+  const lower = (needle || '').toLowerCase().trim();
+  if (!lower) return () => false;
+  if (lower.length <= 4) {
+    const escaped = lower.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`\\b${escaped}\\b`);
+    return (loc) => pattern.test(loc);
+  }
+  return (loc) => loc.includes(lower);
+}

package/src/index.js

@@ -0,0 +1,102 @@
+/**
+ * jd-intel — JD intelligence toolkit: fetch, normalize, and search job descriptions across every major ATS.
+ *
+ * Fetches, normalizes, and enriches job data from public ATS APIs
+ * (Greenhouse, Lever, Ashby) into a unified schema.
+ */
+
+import { ADAPTERS, ATS_NAMES } from './adapters/index.js';
+import { loadRegistry, searchRegistry, detectAts, findAtsBySlug } from './registry.js';
+import { applyFilters } from './filters.js';
+
+/**
+ * Fetch jobs from a company's ATS board.
+ *
+ * @param {Object} options
+ * @param {string} options.company - Company slug or name
+ * @param {string} [options.ats] - Specific ATS platform. If omitted, auto-detects.
+ * @param {string} [options.titleFilter] - Regex matched against title only. Use for role identity ("product manager", "staff engineer").
+ * @param {string} [options.filter] - Regex matched across title, department, description. Use for topic/scope.
+ * @param {number} [options.postedWithinDays] - Only return jobs posted within N days.
+ * @param {string[]} [options.locationIncludes] - Keep jobs whose location contains any of these (case-insensitive).
+ * @param {string[]} [options.locationExcludes] - Drop jobs whose location contains any of these (case-insensitive).
+ * @param {number} [options.limit=100] - Maximum jobs to return after filtering.
+ * @returns {Promise<Array>} Normalized, filtered job objects
+ */
+export async function fetchJobs({
+  company,
+  ats,
+  titleFilter,
+  filter,
+  postedWithinDays,
+  locationIncludes,
+  locationExcludes,
+  limit = 100,
+} = {}) {
+  if (!company) throw new Error('Company slug required');
+
+  // Unified slug normalization: strip all non-alphanumeric (matches detectAts)
+  const slug = company.toLowerCase().replace(/[^a-z0-9]/g, '');
+
+  let jobs;
+  if (ats) {
+    const adapter = ADAPTERS[ats];
+    if (!adapter) throw new Error(`Unknown ATS: ${ats}. Supported: ${ATS_NAMES.join(', ')}`);
+    jobs = await adapter.fetch(slug);
+  } else {
+    // Consult registry first — if we know which ATS this company uses,
+    // skip probing the others (saves API calls, clearer error semantics).
+    const known = await findAtsBySlug(slug);
+    if (known) {
+      jobs = await ADAPTERS[known].fetch(slug);
+    } else {
+      // Discovery mode: company not in registry, probe all adapters
+      const results = await Promise.allSettled(
+        Object.entries(ADAPTERS).map(async ([name, adapter]) => adapter.fetch(slug))
+      );
+      jobs = results
+        .filter(r => r.status === 'fulfilled')
+        .flatMap(r => r.value);
+    }
+  }
+
+  return applyFilters(jobs, { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit });
+}
+
+/**
+ * Search for companies in the registry.
+ */
+export async function search({ keyword, location, ats } = {}) {
+  // For now, search is registry-based. With SQLite store, this becomes a full-text search.
+  if (!keyword) throw new Error('Keyword required');
+  return searchRegistry(keyword);
+}
+
+/**
+ * Detect which ATS platform a company uses (probes each adapter).
+ */
+export { detectAts } from './registry.js';
+
+/**
+ * Look up which ATS a slug belongs to in the registry (cached, no network).
+ * Returns the ATS name ("greenhouse" | "lever" | "ashby") or null if not in registry.
+ */
+export { findAtsBySlug } from './registry.js';
+
+/**
+ * Registry management.
+ */
+export const registry = {
+  load: loadRegistry,
+  search: searchRegistry,
+  detect: detectAts,
+  findAtsBySlug,
+};
+
+// Re-export individual adapters for direct use
+export { fetchGreenhouse } from './adapters/greenhouse.js';
+export { fetchLever } from './adapters/lever.js';
+export { fetchAshby } from './adapters/ashby.js';
+
+// Re-export filter logic for reuse (e.g., by the MCP server)
+export { applyFilters } from './filters.js';

package/src/normalizer.js

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+
+/**
+ * Generate a stable ID for a job posting.
+ */
+export function jobId(company, title, ats) {
+  const raw = `${company}|${title}|${ats}`.toLowerCase().trim();
+  return createHash('md5').update(raw).digest('hex').substring(0, 12);
+}
+
+/**
+ * Normalize a raw ATS job object into the unified schema.
+ */
+export function normalize(raw, ats) {
+  const now = new Date().toISOString();
+  return {
+    id: jobId(raw.company || raw.companySlug, raw.title, ats),
+    company: raw.company || raw.companySlug || '',
+    companySlug: raw.companySlug || '',
+    ats,
+    title: raw.title || '',
+    department: raw.department || '',
+    location: raw.location || '',
+    locationType: detectLocationType(raw.location || ''),
+    salary: raw.salary || extractSalaryFromText(raw.description || ''),
+    description: stripHtml(raw.description || ''),
+    url: raw.url || '',
+    postedAt: raw.postedAt || null,
+    firstSeen: now,
+    lastSeen: now,
+    status: 'open',
+    metadata: raw.metadata || {},
+  };
+}
+
+/**
+ * Detect location type from location string.
+ */
+/**
+ * Extract salary range from job description text.
+ * Matches patterns like: $162,400 - $243,600 or $150K-$200K
+ */
+function extractSalaryFromText(text) {
+  if (!text) return null;
+  // Match: $162,400 - $243,600 (full numbers)
+  const fullMatch = text.match(/\$([\d,]+)\s*[-–]\s*\$([\d,]+)/);
+  if (fullMatch) {
+    return {
+      min: parseInt(fullMatch[1].replace(/,/g, '')),
+      max: parseInt(fullMatch[2].replace(/,/g, '')),
+      currency: 'USD',
+    };
+  }
+  // Match: $150K - $200K (shorthand)
+  const kMatch = text.match(/\$(\d+)[kK]\s*[-–]\s*\$(\d+)[kK]/);
+  if (kMatch) {
+    return {
+      min: parseInt(kMatch[1]) * 1000,
+      max: parseInt(kMatch[2]) * 1000,
+      currency: 'USD',
+    };
+  }
+  return null;
+}
+
+function detectLocationType(location) {
+  const lower = location.toLowerCase();
+  if (/remote/i.test(lower)) return 'remote';
+  if (/hybrid/i.test(lower)) return 'hybrid';
+  if (/on-?site/i.test(lower)) return 'onsite';
+  return location ? 'onsite' : 'unknown';
+}
+
+/**
+ * Strip HTML tags and convert to clean text.
+ */
+export function stripHtml(html) {
+  if (!html) return '';
+  return html
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n\n')
+    .replace(/<\/li>/gi, '\n')
+    .replace(/<li>/gi, '- ')
+    .replace(/<\/h[1-6]>/gi, '\n\n')
+    .replace(/<h[1-6][^>]*>/gi, '## ')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&#\d+;/g, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}

package/src/registry.js

@@ -0,0 +1,88 @@
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REGISTRY_DIR = join(__dirname, '..', 'registry');
+
+let cache = {};
+
+/**
+ * Load company registry for a specific ATS or all ATS platforms.
+ */
+export async function loadRegistry(ats) {
+  if (ats && cache[ats]) return cache[ats];
+
+  if (ats) {
+    try {
+      const data = await readFile(join(REGISTRY_DIR, `${ats}.json`), 'utf-8');
+      cache[ats] = JSON.parse(data);
+      return cache[ats];
+    } catch {
+      return [];
+    }
+  }
+
+  // Load all
+  const all = {};
+  for (const platform of ['greenhouse', 'lever', 'ashby']) {
+    try {
+      const data = await readFile(join(REGISTRY_DIR, `${platform}.json`), 'utf-8');
+      all[platform] = JSON.parse(data);
+      cache[platform] = all[platform];
+    } catch {
+      all[platform] = [];
+    }
+  }
+  return all;
+}
+
+/**
+ * Search registry for companies matching a query.
+ */
+export async function searchRegistry(query) {
+  const all = await loadRegistry();
+  const lower = query.toLowerCase();
+  const results = [];
+
+  for (const [ats, companies] of Object.entries(all)) {
+    for (const company of companies) {
+      const name = (company.name || company.slug || '').toLowerCase();
+      const sector = (company.sector || '').toLowerCase();
+      if (name.includes(lower) || sector.includes(lower)) {
+        results.push({ ...company, ats });
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Look up which ATS a slug belongs to in the registry.
+ * Returns the ATS name (e.g., "greenhouse") or null if not in registry.
+ */
+export async function findAtsBySlug(slug) {
+  const all = await loadRegistry();
+  for (const [ats, companies] of Object.entries(all)) {
+    if (companies.some(c => c.slug === slug)) return ats;
+  }
+  return null;
+}
+
+/**
+ * Auto-detect which ATS a company uses.
+ */
+export async function detectAts(companyName) {
+  const { ADAPTERS } = await import('./adapters/index.js');
+  const slug = companyName.toLowerCase().replace(/[^a-z0-9]/g, '');
+
+  const results = [];
+  const checks = Object.entries(ADAPTERS).map(async ([ats, adapter]) => {
+    const found = await adapter.has(slug);
+    if (found) results.push({ ats, slug });
+  });
+
+  await Promise.allSettled(checks);
+  return results;
+}