feat: Workday tenant passthrough + case-insensitive registry routing

- CLI --workday-tenant/-env/-site flags; infers ats=workday, fail-fast
  on incomplete triple, clear bad-triple error, --help URL hint
- fetchJobs: optional config param; explicit --ats branch consults
  registry for config + canonical slug (fixes explicit --ats workday
  returning [] and SmartRecruiters registry-miss routing)
- registry: case-insensitive slug match, returns canonical casing
  (fixes findAtsBySlug null for PascalCase SmartRecruiters slugs)
- tests: +6 (registry case-insensitive, fetchJobs passthrough/
  precedence/canonical routing); 130/130 green
- bump 0.6.0 (root only; MCP parity deferred to fast-follow)

Author: prPMDev

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jd-intel",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Fetch and normalize job descriptions across every major ATS (Greenhouse, Lever, Ashby, Workday, and more) — for your AI assistant, no copy-paste.",
   "type": "module",
   "main": "src/index.js",

src/cli.js

@@ -23,7 +23,7 @@ async function main() {
         const idx = args.indexOf(flag);
         return idx >= 0 ? args[idx + 1] : undefined;
       };
-      const ats = getArg('--ats');
+      let ats = getArg('--ats');
       const titleFilter = getArg('--title-filter');
       const filter = getArg('--filter');
       const postedWithinRaw = getArg('--posted-within-days');
@@ -35,6 +35,28 @@ async function main() {
       const limitRaw = getArg('--limit');
       const limit = limitRaw !== undefined ? Number(limitRaw) : undefined;
 
+      // Workday is keyed by a {tenant, env, site} triple, not a slug.
+      // Supplying it here makes a Workday board reachable without a
+      // registry entry; presence of the flags infers --ats workday.
+      const wdTenant = getArg('--workday-tenant');
+      const wdEnv = getArg('--workday-env');
+      const wdSite = getArg('--workday-site');
+      let config;
+      if (wdTenant || wdEnv || wdSite) {
+        if (!wdTenant || !wdEnv || !wdSite) {
+          console.error('Workday needs all three: --workday-tenant, --workday-env, --workday-site.');
+          console.error('Find them in the careers URL: https://{tenant}.{env}.myworkdayjobs.com/{site}');
+          console.error('e.g. https://expedia.wd108.myworkdayjobs.com/search  ->  --workday-tenant expedia --workday-env wd108 --workday-site search');
+          process.exit(1);
+        }
+        if (ats && ats !== 'workday') {
+          console.error(`--ats ${ats} conflicts with the --workday-* flags (workday is inferred). Drop one.`);
+          process.exit(1);
+        }
+        config = { tenant: wdTenant, env: wdEnv, site: wdSite };
+        ats = 'workday';
+      }
+
       const parts = [];
       if (titleFilter) parts.push(`title: ${titleFilter}`);
       if (filter) parts.push(`topic: ${filter}`);
@@ -43,10 +65,23 @@ async function main() {
       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,
-      });
+      const atsLabel = config
+        ? ` (workday: ${config.tenant}/${config.env}/${config.site})`
+        : ats ? ` (${ats})` : ' (auto-detect)';
+      console.log(`Fetching jobs from ${company}${atsLabel}${suffix}...`);
+      let jobs;
+      try {
+        jobs = await fetchJobs({
+          company, ats, config, titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit,
+        });
+      } catch (err) {
+        if (config) {
+          console.error(`Could not reach that Workday board (${config.tenant}/${config.env}/${config.site}): ${err.message}`);
+          console.error('Verify the triple against the careers URL: https://{tenant}.{env}.myworkdayjobs.com/{site}');
+          process.exit(1);
+        }
+        throw err;
+      }
       console.log(`Found ${jobs.length} jobs\n`);
 
       for (const job of jobs.slice(0, 20)) {
@@ -115,9 +150,15 @@ Fetch options:
   --ats <platform>                Skip auto-detect. One of: greenhouse, lever,
                                   ashby, smartrecruiters, teamtailor, recruitee,
                                   workday. Omit to auto-detect (registry-backed).
-                                  Workday is registry-only: fetch it by company
-                                  slug and let auto-detect route it, not via
-                                  --ats workday.
+  --workday-tenant T              Workday is keyed by a {tenant, env, site}
+  --workday-env wdN               triple, not a slug. Registered Workday
+  --workday-site S                companies work via auto-detect or --ats
+                                  workday; for any other Workday board pass
+                                  all three, read from the careers URL
+                                  https://{tenant}.{env}.myworkdayjobs.com/{site}
+                                  e.g. https://expedia.wd108.myworkdayjobs.com/search
+                                  -> --workday-tenant expedia --workday-env wd108
+                                     --workday-site search
   --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
@@ -137,6 +178,7 @@ Examples:
   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 fetch expedia --workday-tenant expedia --workday-env wd108 --workday-site search
   jd-intel detect figma
   jd-intel registry search fintech`);
   }

src/index.js

@@ -16,6 +16,7 @@ import { applyFilters } from './filters.js';
  * @param {Object} options
  * @param {string} options.company - Company slug or name
  * @param {string} [options.ats] - Specific ATS platform. If omitted, auto-detects.
+ * @param {object} [options.config] - Adapter-specific config (e.g. Workday {tenant, env, site}). Bypasses the registry; the only way to reach a Workday company not in the registry.
  * @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.
@@ -27,6 +28,7 @@ import { applyFilters } from './filters.js';
 export async function fetchJobs({
   company,
   ats,
+  config,
   titleFilter,
   filter,
   postedWithinDays,
@@ -49,16 +51,33 @@ export async function fetchJobs({
   if (ats) {
     const adapter = ADAPTERS[ats];
     if (!adapter) throw new Error(`Unknown ATS: ${ats}. Supported: ${ATS_NAMES.join(', ')}`);
-    jobs = await adapter.fetch(slug, { filterContext });
+    // Explicit ATS: an explicitly passed config wins (the only path that
+    // can reach a Workday company not in the registry). With no explicit
+    // config, fall back to the registry so config-keyed adapters
+    // (Workday) and canonically-cased registry slugs (SmartRecruiters
+    // "Visa") also work on the explicit path, not just under auto-detect.
+    let fetchSlug = slug;
+    let cfg = config;
+    let companyName;
+    if (!cfg) {
+      const hit = await findEntryBySlug(slug);
+      if (hit && hit.ats === ats) {
+        fetchSlug = hit.entry.slug;
+        cfg = hit.entry.config;
+        companyName = hit.entry.name;
+      }
+    }
+    jobs = await adapter.fetch(fetchSlug, { config: cfg, companyName, filterContext });
   } else {
     // Consult registry first — if we know which ATS this company uses,
     // skip probing the others (saves API calls, clearer error semantics).
-    // The full entry is needed so adapter-specific config (e.g. the
-    // Workday {tenant,env,site} triple) reaches the adapter.
+    // The registry entry carries the canonical slug (so the adapter is
+    // called with the ATS's own casing, e.g. SmartRecruiters "Visa") and
+    // any adapter-specific config (the Workday {tenant,env,site} triple).
     const hit = await findEntryBySlug(slug);
     if (hit) {
-      jobs = await ADAPTERS[hit.ats].fetch(slug, {
-        config: hit.entry.config,
+      jobs = await ADAPTERS[hit.ats].fetch(hit.entry.slug, {
+        config: config || hit.entry.config,
         companyName: hit.entry.name,
         filterContext,
       });

src/registry.js

@@ -58,14 +58,21 @@ export async function searchRegistry(query) {
   return results;
 }
 
+// Slug match is case/punctuation-insensitive: registry slugs are stored
+// in each ATS's canonical form (SmartRecruiters uses PascalCase, e.g.
+// "Visa"), but callers pass a lowercased/alnum-stripped slug. Comparing
+// normalized forms keeps registry-first routing working for those.
+const normSlug = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, '');
+
 /**
  * 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();
+  const key = normSlug(slug);
   for (const [ats, companies] of Object.entries(all)) {
-    if (companies.some(c => c.slug === slug)) return ats;
+    if (companies.some(c => normSlug(c.slug) === key)) return ats;
   }
   return null;
 }
@@ -81,8 +88,9 @@ export async function findAtsBySlug(slug) {
  */
 export async function findEntryBySlug(slug) {
   const all = await loadRegistry();
+  const key = normSlug(slug);
   for (const [ats, companies] of Object.entries(all)) {
-    const entry = companies.find(c => c.slug === slug);
+    const entry = companies.find(c => normSlug(c.slug) === key);
     if (entry) return { ats, entry };
   }
   return null;

test/fetch-jobs.test.js

@@ -0,0 +1,95 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { fetchJobs } from '../src/index.js';
+
+/**
+ * fetchJobs routing: explicit-ATS config passthrough (Workday reachable
+ * without a registry entry), registry fallback on the explicit path,
+ * config-over-registry precedence, and canonical-cased slug routing for
+ * case-sensitive registries (SmartRecruiters). Mocks global fetch
+ * (auto-restored per test by t.mock.method).
+ */
+
+const WD_LIST = {
+  total: 1,
+  jobPostings: [
+    { title: 'Product Manager', externalPath: '/job/Remote/PM_R1', locationsText: 'Remote', postedOn: 'Posted Today' },
+  ],
+};
+const WD_DETAIL = { jobPostingInfo: { jobDescription: '<p>Build.</p>', startDate: '2026-05-01', location: 'Remote' } };
+
+function workdayMock(t) {
+  const calls = { urls: [] };
+  t.mock.method(global, 'fetch', async (url) => {
+    calls.urls.push(String(url));
+    if (String(url).endsWith('/jobs')) return { ok: true, status: 200, json: async () => WD_LIST };
+    return { ok: true, status: 200, json: async () => WD_DETAIL };
+  });
+  return calls;
+}
+
+describe('fetchJobs — Workday config passthrough', () => {
+  test('explicit ats=workday + config reaches the adapter with that triple', async (t) => {
+    const calls = workdayMock(t);
+    const jobs = await fetchJobs({
+      company: 'expedia',
+      ats: 'workday',
+      config: { tenant: 'expedia', env: 'wd108', site: 'search' },
+    });
+    assert.equal(jobs.length, 1);
+    assert.equal(jobs[0].title, 'Product Manager');
+    assert.ok(
+      calls.urls.includes('https://expedia.wd108.myworkdayjobs.com/wday/cxs/expedia/search/jobs'),
+      `expected the passthrough triple in the list URL, got: ${calls.urls[0]}`
+    );
+  });
+
+  test('explicit ats=workday with NO config falls back to registry config', async (t) => {
+    const calls = workdayMock(t);
+    const jobs = await fetchJobs({ company: 'cisco', ats: 'workday' });
+    assert.equal(jobs.length, 1);
+    assert.ok(
+      calls.urls.includes('https://cisco.wd5.myworkdayjobs.com/wday/cxs/cisco/Cisco_Careers/jobs'),
+      `expected registry-fallback triple, got: ${calls.urls[0]}`
+    );
+  });
+
+  test('explicit config overrides the registry entry', async (t) => {
+    const calls = workdayMock(t);
+    await fetchJobs({
+      company: 'cisco',
+      ats: 'workday',
+      config: { tenant: 'override', env: 'wd99', site: 'OverrideSite' },
+    });
+    assert.ok(
+      calls.urls.some(u => u.startsWith('https://override.wd99.myworkdayjobs.com/')),
+      `expected explicit config to win, got: ${calls.urls[0]}`
+    );
+    assert.ok(
+      !calls.urls.some(u => u.includes('cisco.wd5')),
+      'registry config must not be used when explicit config is given'
+    );
+  });
+});
+
+describe('fetchJobs — canonical-cased registry slug routing', () => {
+  test('auto-detect routes a PascalCase SmartRecruiters slug from lowercased input', async (t) => {
+    const calls = { urls: [] };
+    t.mock.method(global, 'fetch', async (url) => {
+      calls.urls.push(String(url));
+      return { ok: true, status: 200, json: async () => ({ content: [], totalFound: 0 }) };
+    });
+    const jobs = await fetchJobs({ company: 'visa' }); // no ats -> registry-routed
+    assert.deepEqual(jobs, []);
+    // Routed via the registry to a single adapter using the canonical
+    // 'Visa' (not lowercased 'visa', not 7-adapter discovery probing).
+    assert.ok(
+      calls.urls.length > 0 && calls.urls.every(u => u.includes('api.smartrecruiters.com')),
+      `expected only SmartRecruiters calls (registry-routed), got: ${calls.urls.join(', ')}`
+    );
+    assert.ok(
+      calls.urls.some(u => u.includes('/v1/companies/Visa/postings')),
+      `expected canonical 'Visa' in the URL, got: ${calls.urls[0]}`
+    );
+  });
+});

test/registry.test.js

@@ -75,6 +75,14 @@ describe('findAtsBySlug', () => {
     assert.equal(await findAtsBySlug('plaid'), 'lever');
   });
 
+  test('matches case-insensitively (PascalCase SmartRecruiters slug)', async () => {
+    // Registry stores "Visa"; callers pass a lowercased/stripped slug.
+    // Pre-fix this returned null and every SR company missed registry
+    // routing (fell through to slow 7-adapter discovery probing).
+    assert.equal(await findAtsBySlug('visa'), 'smartrecruiters');
+    assert.equal(await findAtsBySlug('VISA'), 'smartrecruiters');
+  });
+
   test('returns null for unknown slug', async () => {
     const ats = await findAtsBySlug('zzzz-nonexistent-slug-zzzz');
     assert.equal(ats, null);
@@ -98,6 +106,13 @@ describe('findEntryBySlug', () => {
     assert.equal(hit.entry.slug, 'stripe');
   });
 
+  test('resolves a PascalCase slug from lowercase and returns canonical casing', async () => {
+    const hit = await findEntryBySlug('visa');
+    assert.ok(hit, 'Visa should resolve from "visa"');
+    assert.equal(hit.ats, 'smartrecruiters');
+    assert.equal(hit.entry.slug, 'Visa'); // canonical, not the lowercased input
+  });
+
   test('returns null for unknown slug', async () => {
     const hit = await findEntryBySlug('zzzz-nonexistent-slug-zzzz');
     assert.equal(hit, null);