jobcrawl 0.1.0

package/dist/core/browser.js

@@ -0,0 +1,196 @@
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+const execFile = promisify(execFileCb);
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class BrowserNotAvailableError extends Error {
+    constructor() {
+        super("agent-browser is not installed. Install with: npm i -g agent-browser");
+        this.name = "BrowserNotAvailableError";
+    }
+}
+// ---------------------------------------------------------------------------
+// Binary resolution (cached)
+// ---------------------------------------------------------------------------
+let cachedBin = null;
+async function resolveBin() {
+    if (cachedBin)
+        return cachedBin;
+    // 1. Local node_modules
+    const local = join(process.cwd(), "node_modules", ".bin", "agent-browser");
+    if (existsSync(local)) {
+        cachedBin = local;
+        return local;
+    }
+    // 2. Global — check if it's on PATH
+    try {
+        await execFile("agent-browser", ["--version"], { timeout: 5000 });
+        cachedBin = "agent-browser";
+        return "agent-browser";
+    }
+    catch {
+        throw new BrowserNotAvailableError();
+    }
+}
+// ---------------------------------------------------------------------------
+// BrowserSession
+// ---------------------------------------------------------------------------
+const DEFAULT_NETWORK_TIMEOUT = 120_000; // 2 min for network-dependent commands
+export class BrowserSession {
+    name;
+    opened = false;
+    networkTimeout;
+    constructor(opts) {
+        const id = createHash("sha256")
+            .update(`${Date.now()}:${Math.random()}`)
+            .digest("hex")
+            .slice(0, 8);
+        this.name = `jc-${id}`;
+        this.networkTimeout = opts?.networkTimeout ?? DEFAULT_NETWORK_TIMEOUT;
+    }
+    /** Run a local DOM command (no timeout). */
+    async run(...args) {
+        const bin = await resolveBin();
+        const { stdout } = await execFile(bin, ["--session", this.name, ...args], { maxBuffer: 20 * 1024 * 1024 });
+        return stdout.trimEnd();
+    }
+    /** Run a network-dependent command (open, wait) with a timeout. */
+    async runNetwork(...args) {
+        const bin = await resolveBin();
+        const { stdout } = await execFile(bin, ["--session", this.name, ...args], { timeout: this.networkTimeout, maxBuffer: 20 * 1024 * 1024 });
+        return stdout.trimEnd();
+    }
+    async open(url) {
+        await this.runNetwork("open", url);
+        await this.runNetwork("wait", "--load", "networkidle");
+        this.opened = true;
+    }
+    async getHtml() {
+        return this.run("eval", "document.documentElement.outerHTML");
+    }
+    async getUrl() {
+        return this.run("get", "url");
+    }
+    async clickByText(text) {
+        await this.run("find", "text", text, "click", "--exact");
+    }
+    /**
+     * Find an element by its exact text content, walk up `level` ancestors,
+     * and click that parent. Uses eval with base64 to avoid shell quoting.
+     */
+    async clickNthParent(text, level) {
+        const js = `(() => {
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+      let node;
+      while (node = walker.nextNode()) {
+        if (node.textContent.trim() === ${JSON.stringify(text)}) {
+          let target = node.parentElement;
+          for (let i = 0; i < ${level} && target && target.parentElement; i++) {
+            target = target.parentElement;
+          }
+          if (target) { target.click(); return "clicked"; }
+        }
+      }
+      return "not found";
+    })()`;
+        await this.run("eval", "-b", Buffer.from(js).toString("base64"));
+    }
+    async back() {
+        await this.run("back");
+    }
+    async close() {
+        if (!this.opened)
+            return;
+        try {
+            await this.run("close");
+        }
+        catch {
+            // Best-effort cleanup
+        }
+        this.opened = false;
+    }
+}
+// ---------------------------------------------------------------------------
+// resolveJobUrls — click each job card to capture individual URLs
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_BUBBLE_LEVELS = 5;
+/**
+ * Try clicking at various DOM levels to find which one navigates.
+ * Returns the level that worked (0 = direct text, 1-N = Nth parent),
+ * or -1 if nothing navigated.
+ */
+async function probeClickLevel(title, listingUrl, session, maxLevels) {
+    // Level 0: direct text click
+    try {
+        await session.clickByText(title);
+        await delay(800);
+        const url = await session.getUrl();
+        if (url !== listingUrl)
+            return 0;
+    }
+    catch {
+        // Element not found by text — continue to parent probing
+    }
+    // Levels 1-N: walk up parent elements
+    for (let level = 1; level <= maxLevels; level++) {
+        try {
+            await session.clickNthParent(title, level);
+            await delay(800);
+            const url = await session.getUrl();
+            if (url !== listingUrl)
+                return level;
+        }
+        catch {
+            continue;
+        }
+    }
+    return -1;
+}
+export async function resolveJobUrls(jobs, listingUrl, session, opts) {
+    const maxLevels = opts?.maxBubbleLevels ?? DEFAULT_MAX_BUBBLE_LEVELS;
+    const resolved = [...jobs];
+    const candidates = resolved.filter((j) => j.url === listingUrl);
+    if (candidates.length === 0)
+        return resolved;
+    // Probe the first job to discover which click level causes navigation
+    const probeJob = candidates[0];
+    const level = await probeClickLevel(probeJob.title, listingUrl, session, maxLevels);
+    if (level === -1) {
+        // No click level navigated — this page doesn't link to individual jobs
+        return resolved;
+    }
+    // Capture the URL from the probe click
+    const probeUrl = await session.getUrl();
+    const probeIdx = resolved.indexOf(probeJob);
+    resolved[probeIdx] = { ...probeJob, url: probeUrl };
+    await session.open(listingUrl);
+    // Apply the discovered level to remaining jobs
+    for (let i = 0; i < resolved.length; i++) {
+        const job = resolved[i];
+        if (job.url !== listingUrl)
+            continue; // already resolved or different URL
+        try {
+            if (level === 0) {
+                await session.clickByText(job.title);
+            }
+            else {
+                await session.clickNthParent(job.title, level);
+            }
+            await delay(800);
+            const afterUrl = await session.getUrl();
+            if (afterUrl !== listingUrl) {
+                resolved[i] = { ...job, url: afterUrl };
+                await session.open(listingUrl);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return resolved;
+}

package/dist/core/cache.d.ts

@@ -0,0 +1,13 @@
+import type { Provider } from "../types/index.js";
+interface CacheEntry {
+    provider: Provider;
+    discoveredAt: string;
+}
+interface ProviderCache {
+    version: 1;
+    entries: Record<string, CacheEntry>;
+}
+export declare function loadCache(): Promise<ProviderCache>;
+export declare function getCachedProvider(slug: string): Promise<Provider | null>;
+export declare function setCachedProvider(slug: string, provider: Provider): Promise<void>;
+export {};

package/dist/core/cache.js

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CACHE_FILE = join(homedir(), ".jobcrawl", "cache.json");
+function emptyCache() {
+    return { version: 1, entries: {} };
+}
+export async function loadCache() {
+    if (!existsSync(CACHE_FILE))
+        return emptyCache();
+    try {
+        const raw = await readFile(CACHE_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1)
+            return emptyCache();
+        return parsed;
+    }
+    catch {
+        return emptyCache();
+    }
+}
+export async function getCachedProvider(slug) {
+    const cache = await loadCache();
+    const entry = cache.entries[slug];
+    if (!entry)
+        return null;
+    // 7-day TTL
+    const age = Date.now() - new Date(entry.discoveredAt).getTime();
+    if (age > 7 * 24 * 60 * 60 * 1000)
+        return null;
+    return entry.provider;
+}
+export async function setCachedProvider(slug, provider) {
+    const cache = await loadCache();
+    cache.entries[slug] = {
+        provider,
+        discoveredAt: new Date().toISOString(),
+    };
+    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2) + "\n");
+}

package/dist/core/detect-provider.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderDetection } from "../types/index.js";
+/**
+ * Detect ATS provider from HTML content and URL.
+ * Checks for iframes, embed scripts, and DOM signatures.
+ * Extracts board token/slug for API calls when possible.
+ */
+export declare function detectProvider(html: string, url: string): ProviderDetection;

package/dist/core/detect-provider.js

@@ -0,0 +1,125 @@
+/**
+ * Detect ATS provider from HTML content and URL.
+ * Checks for iframes, embed scripts, and DOM signatures.
+ * Extracts board token/slug for API calls when possible.
+ */
+export function detectProvider(html, url) {
+    // 1. URL pattern matching (direct ATS board URLs)
+    const urlMatch = detectFromUrl(url);
+    if (urlMatch.provider !== "unknown")
+        return urlMatch;
+    // 2. HTML signature detection (embedded ATS on custom domains)
+    return detectFromHtml(html);
+}
+function detectFromUrl(url) {
+    const u = new URL(url);
+    // Greenhouse: boards.greenhouse.io/{token} or job-boards.greenhouse.io/{token}
+    if (u.hostname === "boards.greenhouse.io" ||
+        u.hostname === "job-boards.greenhouse.io") {
+        const token = u.pathname.split("/").filter(Boolean)[0];
+        if (token)
+            return { provider: "greenhouse", boardToken: token };
+    }
+    // Lever: jobs.lever.co/{company}
+    if (u.hostname === "jobs.lever.co") {
+        const company = u.pathname.split("/").filter(Boolean)[0];
+        if (company)
+            return { provider: "lever", boardToken: company };
+    }
+    // Ashby: jobs.ashbyhq.com/{company}
+    if (u.hostname === "jobs.ashbyhq.com") {
+        const company = u.pathname.split("/").filter(Boolean)[0];
+        if (company)
+            return { provider: "ashby", boardToken: company };
+    }
+    // Workday: {company}.wd{n}.myworkdayjobs.com
+    if (u.hostname.includes(".myworkdayjobs.com")) {
+        const tenant = u.hostname.split(".")[0];
+        if (tenant)
+            return { provider: "workday", boardToken: tenant };
+    }
+    // BambooHR: {company}.bamboohr.com
+    if (u.hostname.includes(".bamboohr.com")) {
+        const company = u.hostname.split(".")[0];
+        if (company)
+            return { provider: "bamboohr", boardToken: company };
+    }
+    return { provider: "unknown", boardToken: null };
+}
+function detectFromHtml(html) {
+    // Greenhouse embed: <div id="grnhse_app"> or greenhouse embed script
+    const greenhouseIframe = html.match(/iframe[^>]+src=["']([^"']*(?:boards|job-boards)\.greenhouse\.io[^"']*)/i);
+    if (greenhouseIframe) {
+        const token = extractTokenFromUrl(greenhouseIframe[1], "boards.greenhouse.io");
+        if (token)
+            return { provider: "greenhouse", boardToken: token };
+    }
+    const greenhouseEmbed = html.match(/src=["'][^"']*api\.greenhouse\.io\/v1\/boards\/([^/"']+)/i);
+    if (greenhouseEmbed) {
+        return { provider: "greenhouse", boardToken: greenhouseEmbed[1] };
+    }
+    if (html.includes('id="grnhse_app"') || html.includes("id='grnhse_app'")) {
+        // Look for the greenhouse board token in embed script
+        const tokenMatch = html.match(/Grnhse\.Settings\.board_token\s*=\s*["']([^"']+)/);
+        if (tokenMatch) {
+            return { provider: "greenhouse", boardToken: tokenMatch[1] };
+        }
+        const scriptSrc = html.match(/src=["'][^"']*(?:boards|job-boards)\.greenhouse\.io\/embed\/job_board\/js\?for=([^"'&]+)/i);
+        if (scriptSrc) {
+            return { provider: "greenhouse", boardToken: scriptSrc[1] };
+        }
+    }
+    // Lever embed
+    const leverIframe = html.match(/iframe[^>]+src=["']([^"']*jobs\.lever\.co[^"']*)/i);
+    if (leverIframe) {
+        const token = extractTokenFromUrl(leverIframe[1], "jobs.lever.co");
+        if (token)
+            return { provider: "lever", boardToken: token };
+    }
+    if (html.includes("data-lever-")) {
+        const leverCompany = html.match(/data-lever-company=["']([^"']+)/i);
+        if (leverCompany) {
+            return { provider: "lever", boardToken: leverCompany[1] };
+        }
+    }
+    // Ashby embed
+    const ashbyIframe = html.match(/iframe[^>]+src=["']([^"']*jobs\.ashbyhq\.com[^"']*)/i);
+    if (ashbyIframe) {
+        const token = extractTokenFromUrl(ashbyIframe[1], "jobs.ashbyhq.com");
+        if (token)
+            return { provider: "ashby", boardToken: token };
+    }
+    // Ashby embed script pattern
+    const ashbyScript = html.match(/src=["'][^"']*ashbyhq\.com\/[^"']*["'][^>]*data-ashby-job-board-id=["']([^"']+)/i);
+    if (ashbyScript) {
+        return { provider: "ashby", boardToken: ashbyScript[1] };
+    }
+    // Workday embed
+    const workdayIframe = html.match(/iframe[^>]+src=["']([^"']*\.myworkdayjobs\.com[^"']*)/i);
+    if (workdayIframe) {
+        const tenant = workdayIframe[1].match(/\/\/([^.]+)\.wd\d+\.myworkdayjobs/);
+        if (tenant)
+            return { provider: "workday", boardToken: tenant[1] };
+    }
+    // BambooHR embed
+    const bambooIframe = html.match(/iframe[^>]+src=["']([^"']*\.bamboohr\.com[^"']*)/i);
+    if (bambooIframe) {
+        const company = bambooIframe[1].match(/\/\/([^.]+)\.bamboohr\.com/);
+        if (company)
+            return { provider: "bamboohr", boardToken: company[1] };
+    }
+    return { provider: "unknown", boardToken: null };
+}
+function extractTokenFromUrl(iframeSrc, hostname) {
+    try {
+        const url = new URL(iframeSrc.startsWith("//") ? `https:${iframeSrc}` : iframeSrc);
+        if (url.hostname === hostname) {
+            const parts = url.pathname.split("/").filter(Boolean);
+            return parts[0] || null;
+        }
+    }
+    catch {
+        // Invalid URL
+    }
+    return null;
+}

package/dist/core/discover-careers.d.ts

@@ -0,0 +1,18 @@
+export interface DiscoverResult {
+    company: string;
+    url: string | null;
+    verified: boolean;
+    error: string | null;
+}
+/**
+ * Discover the career page URL for a company.
+ *
+ * Strategy (in order):
+ * 1. Web search (DDG) + LLM to pick the best URL
+ * 2. Heuristic URL guessing ({company}.com/careers) + HTTP HEAD check
+ */
+export declare function discoverCareerPage(company: string): Promise<DiscoverResult>;
+/**
+ * Verify that a discovered URL is a real career page.
+ */
+export declare function verifyCareerPage(url: string): Promise<boolean>;

package/dist/core/discover-careers.js

@@ -0,0 +1,92 @@
+import { webSearch, guessCareerUrls, } from "../utils/google-search.js";
+import { askClaude } from "../utils/llm.js";
+import { probePage } from "./fetch-page.js";
+/**
+ * Discover the career page URL for a company.
+ *
+ * Strategy (in order):
+ * 1. Web search (DDG) + LLM to pick the best URL
+ * 2. Heuristic URL guessing ({company}.com/careers) + HTTP HEAD check
+ */
+export async function discoverCareerPage(company) {
+    try {
+        // Strategy 1: Web search + LLM
+        const results = await webSearch(`"${company}" careers jobs`);
+        if (results.length > 0) {
+            const url = await pickCareerUrl(company, results);
+            if (url) {
+                return { company, url, verified: false, error: null };
+            }
+        }
+        // Strategy 2: Heuristic URL guessing
+        const guessed = await guessCareerUrls(company);
+        if (guessed.length > 0) {
+            return {
+                company,
+                url: guessed[0].url,
+                verified: false,
+                error: null,
+            };
+        }
+        return {
+            company,
+            url: null,
+            verified: false,
+            error: "Could not find career page",
+        };
+    }
+    catch (err) {
+        return {
+            company,
+            url: null,
+            verified: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/**
+ * Verify that a discovered URL is a real career page.
+ */
+export async function verifyCareerPage(url) {
+    try {
+        const { html } = await probePage(url);
+        const lower = html.toLowerCase();
+        const signals = [
+            "careers",
+            "jobs",
+            "openings",
+            "positions",
+            "join our team",
+            "join us",
+            "we're hiring",
+            "open roles",
+            "apply now",
+            "job-boards.greenhouse.io",
+            "boards.greenhouse.io",
+            "jobs.lever.co",
+            "jobs.ashbyhq.com",
+            "grnhse_app",
+        ];
+        const matchCount = signals.filter((s) => lower.includes(s)).length;
+        return matchCount >= 2;
+    }
+    catch {
+        return false;
+    }
+}
+async function pickCareerUrl(company, results) {
+    const formatted = results
+        .map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`)
+        .join("\n\n");
+    const prompt = `Given these search results for "${company} careers", return ONLY the URL of their official careers/jobs page. Not individual job postings or third-party job boards (Indeed, LinkedIn, Glassdoor).
+
+Search results:
+${formatted}
+
+Respond with ONLY the URL, nothing else. If you can't determine it, respond with "null".`;
+    const response = await askClaude(prompt);
+    const urlMatch = response.match(/https?:\/\/[^\s"'<>]+/);
+    if (urlMatch)
+        return urlMatch[0];
+    return null;
+}

package/dist/core/extract-jobs.d.ts

@@ -0,0 +1,14 @@
+import type { Job, Provider, Aggregator, SearchCriteria } from "../types/index.js";
+/**
+ * Extract jobs via ATS JSON API. Used when provider + boardToken are known.
+ * Criteria is passed through so providers can apply server-side filtering.
+ */
+export declare function extractViaApi(provider: Provider, boardToken: string, sourceUrl: string, criteria: SearchCriteria, saveRaw?: boolean): Promise<Job[]>;
+/**
+ * Extract jobs via aggregator. Aggregators search across multiple companies.
+ */
+export declare function extractViaAggregator(aggregator: Aggregator, criteria: SearchCriteria, saveRaw?: boolean): Promise<Job[]>;
+/**
+ * Extract jobs from rendered HTML. Used when no ATS API is available.
+ */
+export declare function extractFromHtml(html: string, sourceUrl: string): Job[];

package/dist/core/extract-jobs.js

@@ -0,0 +1,36 @@
+import { extractGreenhouseJobs } from "./providers/greenhouse.js";
+import { extractAshbyJobs } from "./providers/ashby.js";
+import { extractLeverJobs } from "./providers/lever.js";
+import { extractYcJobs } from "./aggregators/yc.js";
+import { extractGenericJobs } from "./providers/generic.js";
+/**
+ * Extract jobs via ATS JSON API. Used when provider + boardToken are known.
+ * Criteria is passed through so providers can apply server-side filtering.
+ */
+export async function extractViaApi(provider, boardToken, sourceUrl, criteria, saveRaw = false) {
+    switch (provider) {
+        case "greenhouse":
+            return extractGreenhouseJobs(boardToken, sourceUrl, criteria, saveRaw);
+        case "ashby":
+            return extractAshbyJobs(boardToken, sourceUrl, criteria, saveRaw);
+        case "lever":
+            return extractLeverJobs(boardToken, sourceUrl, criteria, saveRaw);
+        default:
+            throw new Error(`No API extractor for provider "${provider}"`);
+    }
+}
+/**
+ * Extract jobs via aggregator. Aggregators search across multiple companies.
+ */
+export async function extractViaAggregator(aggregator, criteria, saveRaw = false) {
+    switch (aggregator) {
+        case "yc":
+            return extractYcJobs("https://workatastartup.com", criteria, saveRaw);
+    }
+}
+/**
+ * Extract jobs from rendered HTML. Used when no ATS API is available.
+ */
+export function extractFromHtml(html, sourceUrl) {
+    return extractGenericJobs(html, sourceUrl);
+}

package/dist/core/fetch-page.d.ts

@@ -0,0 +1,11 @@
+import type { FetchResult } from "../types/index.js";
+/**
+ * Quick HTTP probe — simple GET, no browser.
+ * Enough to detect ATS signals in static HTML.
+ */
+export declare function probePage(url: string): Promise<FetchResult>;
+/**
+ * Full JS rendering via agent-browser.
+ * Falls back to probePage when agent-browser is not installed.
+ */
+export declare function renderPage(url: string): Promise<FetchResult>;

package/dist/core/fetch-page.js

@@ -0,0 +1,39 @@
+import { BrowserSession, BrowserNotAvailableError } from "./browser.js";
+/**
+ * Quick HTTP probe — simple GET, no browser.
+ * Enough to detect ATS signals in static HTML.
+ */
+export async function probePage(url) {
+    const response = await fetch(url, {
+        headers: {
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+        },
+        redirect: "follow",
+    });
+    const html = await response.text();
+    return { html, finalUrl: response.url };
+}
+/**
+ * Full JS rendering via agent-browser.
+ * Falls back to probePage when agent-browser is not installed.
+ */
+export async function renderPage(url) {
+    const session = new BrowserSession();
+    try {
+        await session.open(url);
+        const [html, finalUrl] = await Promise.all([
+            session.getHtml(),
+            session.getUrl(),
+        ]);
+        return { html, finalUrl };
+    }
+    catch (err) {
+        if (err instanceof BrowserNotAvailableError) {
+            return probePage(url);
+        }
+        throw err;
+    }
+    finally {
+        await session.close();
+    }
+}

package/dist/core/format-output.d.ts

@@ -0,0 +1,2 @@
+import type { Job, OutputFormat } from "../types/index.js";
+export declare function formatOutput(jobs: Job[], format: OutputFormat): string;

package/dist/core/format-output.js

@@ -0,0 +1,59 @@
+export function formatOutput(jobs, format) {
+    switch (format) {
+        case "json":
+            return JSON.stringify(jobs, null, 2);
+        case "table":
+            return formatTable(jobs);
+        case "csv":
+            return formatCsv(jobs);
+        case "markdown":
+            return formatMarkdown(jobs);
+    }
+}
+function formatTable(jobs) {
+    if (jobs.length === 0)
+        return "No matching jobs found.";
+    const headers = ["Company", "Title", "Location", "Department", "URL"];
+    const rows = jobs.map((j) => [
+        j.company,
+        j.title,
+        j.location ?? "-",
+        j.department ?? "-",
+        j.url,
+    ]);
+    // Calculate column widths
+    const widths = headers.map((h, i) => Math.min(50, Math.max(h.length, ...rows.map((r) => r[i].length))));
+    const separator = widths.map((w) => "-".repeat(w)).join(" | ");
+    const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join(" | ");
+    const bodyLines = rows.map((row) => row.map((cell, i) => cell.slice(0, widths[i]).padEnd(widths[i])).join(" | "));
+    return [headerLine, separator, ...bodyLines].join("\n");
+}
+function formatCsv(jobs) {
+    const headers = "company,title,location,department,workMode,url,postedAt";
+    const rows = jobs.map((j) => [
+        csvEscape(j.company),
+        csvEscape(j.title),
+        csvEscape(j.location ?? ""),
+        csvEscape(j.department ?? ""),
+        csvEscape(j.workMode ?? ""),
+        csvEscape(j.url),
+        csvEscape(j.postedAt ?? ""),
+    ].join(","));
+    return [headers, ...rows].join("\n");
+}
+function csvEscape(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+function formatMarkdown(jobs) {
+    if (jobs.length === 0)
+        return "No matching jobs found.";
+    const lines = [
+        "| Company | Title | Location | Department |",
+        "| --- | --- | --- | --- |",
+        ...jobs.map((j) => `| ${j.company} | [${j.title}](${j.url}) | ${j.location ?? "-"} | ${j.department ?? "-"} |`),
+    ];
+    return lines.join("\n");
+}

package/dist/core/match-jobs.d.ts

@@ -0,0 +1,6 @@
+import type { Job, SearchCriteria } from "../types/index.js";
+/**
+ * Filter jobs against search criteria. Case-insensitive substring matching.
+ * Jobs with null fields are included (don't exclude for missing data).
+ */
+export declare function matchJobs(jobs: Job[], criteria: SearchCriteria): Job[];