openings 0.1.29 → 0.1.30

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Find evidence-grounded jobs, including relevant roles you may not have searched for, without accounts or API keys.",
   "author": { "name": "Openings contributors" },
   "license": "MIT",

package/data/companies.json

@@ -108176,5 +108176,28 @@
       "payloadVersion": "capgemini-jobstream:v1",
       "jobCount": 922
     }
+  },
+  "amazon-india": {
+    "name": "Amazon",
+    "ats": "amazon",
+    "token": "IND",
+    "companyDomain": "amazon.jobs",
+    "sourceUrl": "https://www.amazon.jobs/en/search?normalized_country_code%5B%5D=IND",
+    "cohorts": [
+      "IN"
+    ],
+    "discoveredFrom": {
+      "channel": "career_page",
+      "reference": "https://www.amazon.jobs/en/search?normalized_country_code%5B%5D=IND"
+    },
+    "verification": {
+      "checkedAt": "2026-09-11T06:43:09.522600+00:00",
+      "canonicalSourceUrl": "https://www.amazon.jobs/en/search?normalized_country_code%5B%5D=IND",
+      "observedCompanyName": "Amazon",
+      "identityEvidence": "company_site",
+      "contentType": "application/json",
+      "payloadVersion": "amazon-jobs-search:v1",
+      "jobCount": 2368
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "A free, candidate-safe job-search substrate for AI agents",
   "license": "MIT",
   "repository": { "type": "git", "url": "git+https://github.com/abhay-avagama/hiring-agent.git" },

package/src/adzuna-market.ts

@@ -0,0 +1,103 @@
+import { readFile } from "node:fs/promises";
+import { atomicJson } from "./atomic-file.ts";
+
+/**
+ * A rolling 30-day map of who is hiring in a country, built from Adzuna within its search allowance. Each run
+ * samples pages spread evenly across the last day's postings (newest first), so bursts from one employer do not
+ * crowd out the rest, and merges them into a state file keyed by Adzuna's posting id. Jobs are never ingested;
+ * the map only says which employers are hiring, how much, and whether our catalog covers them.
+ */
+export interface MarketEmployer { name: string; postings: number; firstSeen: string; lastSeen: string; cities: Record<string, number>; categories: Record<string, number> }
+export interface MarketState { country: string; updatedAt: string; runs: number; hitsUsed: number; seen: Record<string, { employer: string; created: string }>; employers: Record<string, MarketEmployer> }
+export interface MarketCoverage { employers: number; postings: number; coveredEmployers: number; coveredPostings: number; uncovered: Array<{ name: string; postings: number; cities: string[] }> }
+type Fetch = (url: string, init?: RequestInit) => Promise<Response>;
+
+export async function sampleAdzunaMarket(appId: string, appKey: string, statePath: string, options: { country?: string; maxHits?: number; fetcher?: Fetch; sleep?: (ms: number) => Promise<void>; now?: () => Date; delayMs?: number } = {}): Promise<{ state: MarketState; hits: number; dayTotal: number; newPostings: number; newEmployers: number }> {
+  const fetcher = options.fetcher ?? globalThis.fetch;
+  const sleep = options.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const now = options.now ?? (() => new Date());
+  const country = (options.country ?? "in").toLowerCase();
+  const state: MarketState = await readFile(statePath, "utf8").then((text) => JSON.parse(text) as MarketState).catch(() => ({ country, updatedAt: "", runs: 0, hitsUsed: 0, seen: {}, employers: {} }));
+  const maxHits = Math.max(1, options.maxHits ?? 75);
+  const search = async (page: number) => {
+    const url = new URL(`https://api.adzuna.com/v1/api/jobs/${country}/search/${page}`);
+    for (const [key, value] of Object.entries({ app_id: appId, app_key: appKey, results_per_page: "50", "content-type": "application/json", max_days_old: "1", sort_by: "date" })) url.searchParams.set(key, value);
+    const response = await fetcher(url.href, { signal: AbortSignal.timeout(30_000) });
+    if (response.status === 429) throw new Error("Adzuna allowance reached");
+    if (!response.ok) throw new Error(`Adzuna HTTP ${response.status}`);
+    return await response.json() as { count?: number; results?: Array<Record<string, unknown>> };
+  };
+  let hits = 0; let newPostings = 0; let newEmployers = 0;
+  const absorb = (results: Array<Record<string, unknown>>) => {
+    for (const job of results) {
+      const id = String(job.id ?? ""); if (!id || state.seen[id]) continue;
+      const name = isRecord(job.company) ? String(job.company.display_name ?? "").trim() : "";
+      if (name.length < 2) continue;
+      const key = name.toLowerCase();
+      const created = typeof job.created === "string" ? job.created : now().toISOString();
+      state.seen[id] = { employer: key, created }; newPostings += 1;
+      const employer = state.employers[key] ?? (newEmployers += 1, { name, postings: 0, firstSeen: created, lastSeen: created, cities: {}, categories: {} });
+      employer.postings += 1;
+      if (created > employer.lastSeen) employer.lastSeen = created;
+      const area = isRecord(job.location) && Array.isArray(job.location.area) ? String(job.location.area[job.location.area.length - 1] ?? "") : "";
+      if (area) employer.cities[area] = (employer.cities[area] ?? 0) + 1;
+      const category = isRecord(job.category) ? String(job.category.label ?? "") : "";
+      if (category) employer.categories[category] = (employer.categories[category] ?? 0) + 1;
+      state.employers[key] = employer;
+    }
+  };
+  const first = await search(1); hits += 1; absorb(first.results ?? []);
+  const dayTotal = first.count ?? 0;
+  const pages = Math.max(1, Math.ceil(dayTotal / 50));
+  // Spread the remaining allowance evenly across the day's pages.
+  const picks = new Set<number>();
+  for (let index = 1; index < Math.min(maxHits, pages); index += 1) picks.add(1 + Math.round((index * (pages - 1)) / Math.max(1, Math.min(maxHits, pages) - 1)));
+  picks.delete(1);
+  for (const page of [...picks].sort((left, right) => left - right)) {
+    if (hits >= maxHits) break;
+    await sleep(options.delayMs ?? 2_600); // Adzuna allows 25 searches a minute
+    try { absorb((await search(page)).results ?? []); hits += 1; }
+    catch (error) { hits += 1; if (String(error).includes("allowance")) break; }
+  }
+  // Keep a rolling 30 days: postings older than that drop out of both the dedupe set and the employer counts.
+  const cutoff = new Date(now().getTime() - 30 * 86_400_000).toISOString();
+  for (const [id, entry] of Object.entries(state.seen)) {
+    if (entry.created >= cutoff) continue;
+    delete state.seen[id];
+    const employer = state.employers[entry.employer];
+    if (employer && --employer.postings <= 0) delete state.employers[entry.employer];
+  }
+  state.updatedAt = now().toISOString(); state.runs += 1; state.hitsUsed += hits;
+  await atomicJson(statePath, state);
+  return { state, hits, dayTotal, newPostings, newEmployers };
+}
+
+const STOP = new Set(["the", "inc", "llc", "ltd", "limited", "pvt", "private", "corp", "corporation", "company", "co", "group", "india", "technologies", "technology", "solutions", "services", "global", "international", "plc", "llp", "and", "of", "com"]);
+function keysFor(name: string): string[] {
+  const words = name.toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9 ]+/g, " ").split(/\s+/).filter(Boolean);
+  const core = words.filter((word) => !STOP.has(word));
+  const base = core.length ? core : words;
+  const full = base.join("");
+  // A short whole name (JLL, MSD, ABB) is still a name; only a lone first word needs four letters to avoid false matches.
+  return [...new Set([full, words.join(""), ...(ALIASES[full] ?? []), ...(base[0] && base[0].length >= 4 ? [base[0]] : [])].filter((key) => key.length >= 2))];
+}
+/** Employers our catalog knows under a provider tenant that looks nothing like the name Adzuna shows. */
+const ALIASES: Record<string, string[]> = { pricewaterhousecoopers: ["pwc"], deutschebank: ["db"], standardchartered: ["standard"], spglobal: ["spgi"], jonesianglasalle: ["jll"], merck: ["msd"], johnsonandjohnson: ["jj"], wellsfargo: ["wf"], northropgrumman: ["ngc"] };
+
+/** Which of the market's employers the catalog covers, matched on slugs, names, provider tenants, and company domains. */
+export function marketCoverage(state: MarketState, catalog: Record<string, { name: string; token: string; companyDomain?: string }>, limit = 50): MarketCoverage {
+  const known = new Set<string>();
+  const squash = (value: string) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  for (const [slug, entry] of Object.entries(catalog)) for (const key of [slug, entry.name, entry.token.split("/")[0]!.split(".")[0]!, (entry.companyDomain ?? "").split(".")[0]!]) { const value = squash(key); if (value.length >= 3) known.add(value); }
+  const employers = Object.values(state.employers);
+  const covered = employers.filter((employer) => keysFor(employer.name).some((key) => known.has(key)));
+  const coveredSet = new Set(covered);
+  return {
+    employers: employers.length, postings: employers.reduce((sum, employer) => sum + employer.postings, 0),
+    coveredEmployers: covered.length, coveredPostings: covered.reduce((sum, employer) => sum + employer.postings, 0),
+    uncovered: employers.filter((employer) => !coveredSet.has(employer)).sort((left, right) => right.postings - left.postings).slice(0, limit)
+      .map((employer) => ({ name: employer.name, postings: employer.postings, cities: Object.entries(employer.cities).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([city]) => city) })),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }

package/src/cli.ts

@@ -23,6 +23,7 @@ import { kekaTenantCandidates } from "./keka-tenants.ts";
 import { collectJoobleSignals } from "./jooble-signals.ts";
 import { collectAdzunaSignals } from "./adzuna-signals.ts";
 import { resolveEmployers } from "./employer-resolver.ts";
+import { marketCoverage, sampleAdzunaMarket } from "./adzuna-market.ts";
 import { mergeAttemptedRoundLeads, prepareRecruiteeRoundArtifacts } from "./recruitee-round.ts";
 
 const HELP = `Openings — search public company job boards
@@ -46,6 +47,7 @@ Usage:
   openings sources keka-tenants HOSTS.txt [--output FILE] [--registry FILE] [--concurrency N]
   openings sources jooble-signals [--location PLACE] [--max-pages N] [--output FILE]   (key from JOOBLE_API_KEY)
   openings sources adzuna-signals [--country in] [--max-hits N] [--max-days-old N] [--output FILE]   (ADZUNA_APP_ID and ADZUNA_APP_KEY)
+  openings sources adzuna-market [--country in] [--max-hits 75] [--state FILE] [--catalog FILE]   (daily sample of who is hiring; ADZUNA_APP_ID and ADZUNA_APP_KEY)
   openings sources resolve-employers SIGNALS.json [--catalog FILE] [--registry FILE] [--min-jobs N] [--limit N] [--concurrency N] [--report FILE]
   openings sources prepare-recruitee-round IDENTITIES.json [--catalog FILE] [--artifacts DIR]
   openings sources merge-attempted-round-leads ISOLATED_REGISTRY [--registry FILE]
@@ -137,6 +139,18 @@ export async function run(args: string[]): Promise<number> {
       console.log(JSON.stringify({ ...summary, topSites: sites.slice(0, 15) }, null, 2));
       return 0;
     }
+    if (rest[0] === "adzuna-market") {
+      const args = rest.slice(1);
+      const appId = process.env.ADZUNA_APP_ID; const appKey = process.env.ADZUNA_APP_KEY;
+      if (!appId || !appKey) return fail("sources adzuna-market requires ADZUNA_APP_ID and ADZUNA_APP_KEY in the environment");
+      const value = (flag: string) => { const index = args.indexOf(flag); return index >= 0 ? args[index + 1] : undefined; };
+      const statePath = value("--state") ?? ".openings/adzuna-market.json";
+      const run = await sampleAdzunaMarket(appId, appKey, statePath, { country: value("--country"), maxHits: value("--max-hits") ? Number(value("--max-hits")) : undefined });
+      const catalog = JSON.parse(await readFile(value("--catalog") ?? "data/companies.json", "utf8"));
+      const coverage = marketCoverage(run.state, catalog, 40);
+      console.log(JSON.stringify({ run: { hits: run.hits, postingsInLastDay: run.dayTotal, newPostings: run.newPostings, newEmployers: run.newEmployers, runs: run.state.runs, hitsUsed: run.state.hitsUsed }, market: { employers: coverage.employers, postings: coverage.postings, coveredEmployers: coverage.coveredEmployers, coveredPostings: coverage.coveredPostings, coveredShare: coverage.postings ? Math.round((100 * coverage.coveredPostings) / coverage.postings) : 0 }, uncovered: coverage.uncovered }, null, 2));
+      return 0;
+    }
     if (rest[0] === "resolve-employers") {
       const args = rest.slice(1);
       const signalsPath = args[0];

package/src/common-crawl-discovery.ts

@@ -39,7 +39,7 @@ export interface CommonCrawlDiscoveryReport extends ReportMeta {
 
 const providerPatterns: Record<Ats, string[]> = {
   greenhouse: ["job-boards.greenhouse.io/*", "boards.greenhouse.io/*"], lever: ["jobs.lever.co/*"], ashby: ["jobs.ashbyhq.com/*"], workday: ["*.myworkdayjobs.com/*"], recruitee: ["*.recruitee.com/*"],
-  ...Object.fromEntries(PROVIDERS.map((spec) => [spec.ats, spec.crawlPatterns])) as Record<"smartrecruiters" | "workable" | "breezy" | "freshteam" | "keka" | "zohorecruit" | "accenture" | "infosys" | "capgemini", string[]>,
+  ...Object.fromEntries(PROVIDERS.map((spec) => [spec.ats, spec.crawlPatterns])) as Record<"smartrecruiters" | "workable" | "breezy" | "freshteam" | "keka" | "zohorecruit" | "accenture" | "infosys" | "capgemini" | "amazon", string[]>,
   jobposting: [], // company sites are found by probing seeds, never by URL pattern
 };
 const patterns = Object.values(providerPatterns).flat();

package/src/portals.ts

@@ -117,4 +117,36 @@ const capgemini: ProviderSpec = {
   },
 };
 
-export const PORTALS: ProviderSpec[] = [accenture, infosys, capgemini];
+/** Amazon's public job search (amazon.jobs/en/search.json; robots.txt disallows only /internal). Token is the ISO-3 country code. */
+const amazon: ProviderSpec = {
+  ats: "amazon", label: "Amazon jobs", hosts: ["amazon.jobs"], crawlPatterns: [],
+  resolve(url) { return /(^|\.)amazon\.jobs$/i.test(url.hostname) ? (url.searchParams.get("normalized_country_code[]") ?? null) : null; },
+  canonicalUrl: (token) => `https://www.amazon.jobs/en/search?normalized_country_code%5B%5D=${encodeURIComponent(token)}`,
+  endpoint: (token) => `https://www.amazon.jobs/en/search.json?normalized_country_code%5B%5D=${encodeURIComponent(token)}&result_limit=100&sort=recent&offset=0`,
+  jobsFromBody: (body) => (isRecord(body) ? asRecords(body.jobs) : null),
+  providerName: () => "Amazon",
+  payloadVersion: () => "amazon-jobs-search:v1",
+  async fetchAll(token, get) {
+    const records: Rec[] = [];
+    for (let offset = 0; offset < 10_000; offset += 100) {
+      const reply = await get(`https://www.amazon.jobs/en/search.json?normalized_country_code%5B%5D=${encodeURIComponent(token)}&result_limit=100&sort=recent&offset=${offset}`);
+      const page = amazon.jobsFromBody(reply) ?? [];
+      records.push(...page.map((row) => Object.fromEntries(AMAZON_FIELDS.map((key) => [key, row[key]]))));
+      const total = isRecord(reply) ? Number(reply.hits) : 0;
+      if (page.length < 100 || records.length >= total) break;
+    }
+    return records;
+  },
+  normalize(company, record) {
+    const posted = Date.parse(`${str(record.posted_date)} 00:00:00 UTC`);
+    const description = [plainText(str(record.description_short)), str(record.basic_qualifications) && `Basic qualifications:\n${plainText(str(record.basic_qualifications))}`, str(record.preferred_qualifications) && `Preferred qualifications:\n${plainText(str(record.preferred_qualifications))}`].filter(Boolean).join("\n\n").slice(0, 3_000);
+    const country = str(record.country_code) === "IND" ? "India" : str(record.country_code) === "USA" ? "United States" : str(record.country_code);
+    return job(company, str(record.id_icims) || str(record.id), {
+      title: str(record.title), location: [str(record.city), str(record.state), country].filter(Boolean).join(", "),
+      url: `https://www.amazon.jobs${str(record.job_path)}`, ...(Number.isFinite(posted) ? { updatedAt: iso(posted) } : {}), description,
+    });
+  },
+};
+const AMAZON_FIELDS = ["id", "id_icims", "title", "city", "state", "country_code", "posted_date", "job_path", "description_short", "basic_qualifications", "preferred_qualifications"];
+
+export const PORTALS: ProviderSpec[] = [accenture, infosys, capgemini, amazon];

package/src/types.ts

@@ -1,5 +1,5 @@
 /** ATS boards plus "jobposting": a company's own career site read only through its schema.org JobPosting markup (token = careers URL). */
-export const ALL_PROVIDERS = ["greenhouse", "lever", "ashby", "workday", "recruitee", "smartrecruiters", "workable", "breezy", "freshteam", "keka", "zohorecruit", "jobposting", "accenture", "infosys", "capgemini"] as const;
+export const ALL_PROVIDERS = ["greenhouse", "lever", "ashby", "workday", "recruitee", "smartrecruiters", "workable", "breezy", "freshteam", "keka", "zohorecruit", "jobposting", "accenture", "infosys", "capgemini", "amazon"] as const;
 export type Ats = (typeof ALL_PROVIDERS)[number];
 
 export interface DomainEvidence {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.1.29";
+export const VERSION = "0.1.30";