jobcrawl 0.1.0

package/test/unit/detect-provider.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect } from "vitest";
+import { detectProvider } from "../../src/core/detect-provider.js";
+
+describe("detectProvider", () => {
+  describe("URL-based detection", () => {
+    it("detects Greenhouse from boards.greenhouse.io URL", () => {
+      const result = detectProvider("", "https://boards.greenhouse.io/acme");
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("detects Greenhouse from job-boards.greenhouse.io URL", () => {
+      const result = detectProvider(
+        "",
+        "https://job-boards.greenhouse.io/stripe"
+      );
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "stripe" });
+    });
+
+    it("extracts first path segment as token, ignoring deeper paths", () => {
+      const result = detectProvider(
+        "",
+        "https://boards.greenhouse.io/acme/jobs/12345"
+      );
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("detects Lever from jobs.lever.co URL", () => {
+      const result = detectProvider("", "https://jobs.lever.co/figma");
+      expect(result).toEqual({ provider: "lever", boardToken: "figma" });
+    });
+
+    it("detects Ashby from jobs.ashbyhq.com URL", () => {
+      const result = detectProvider("", "https://jobs.ashbyhq.com/ramp");
+      expect(result).toEqual({ provider: "ashby", boardToken: "ramp" });
+    });
+
+    it("detects Workday from myworkdayjobs.com URL", () => {
+      const result = detectProvider(
+        "",
+        "https://netflix.wd5.myworkdayjobs.com/jobs"
+      );
+      expect(result).toEqual({ provider: "workday", boardToken: "netflix" });
+    });
+
+    it("detects BambooHR from bamboohr.com URL", () => {
+      const result = detectProvider(
+        "",
+        "https://acme.bamboohr.com/careers"
+      );
+      expect(result).toEqual({ provider: "bamboohr", boardToken: "acme" });
+    });
+
+    it("returns unknown for workatastartup.com (YC is an aggregator, not a provider)", () => {
+      const result = detectProvider(
+        "",
+        "https://www.workatastartup.com/jobs"
+      );
+      expect(result).toEqual({ provider: "unknown", boardToken: null });
+    });
+
+    it("returns unknown for unrecognized URLs", () => {
+      const result = detectProvider("", "https://example.com/careers");
+      expect(result).toEqual({ provider: "unknown", boardToken: null });
+    });
+  });
+
+  describe("HTML-based detection", () => {
+    it("detects Greenhouse iframe embed", () => {
+      const html = `<iframe src="https://boards.greenhouse.io/acme/jobs"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("does not detect job-boards.greenhouse.io iframe (hostname mismatch in extractTokenFromUrl)", () => {
+      // extractTokenFromUrl checks against "boards.greenhouse.io" but iframe has "job-boards.greenhouse.io"
+      const html = `<iframe src="https://job-boards.greenhouse.io/stripe"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "unknown", boardToken: null });
+    });
+
+    it("detects Greenhouse API embed script", () => {
+      const html = `<script src="https://api.greenhouse.io/v1/boards/acme/embed/job_board"></script>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("detects Greenhouse grnhse_app div with board_token setting", () => {
+      const html = `
+        <div id="grnhse_app"></div>
+        <script>Grnhse.Settings.board_token = "mycompany";</script>
+      `;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({
+        provider: "greenhouse",
+        boardToken: "mycompany",
+      });
+    });
+
+    it("detects Greenhouse grnhse_app div with embed script for= param", () => {
+      const html = `
+        <div id="grnhse_app"></div>
+        <script src="https://boards.greenhouse.io/embed/job_board/js?for=acme"></script>
+      `;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("detects Lever iframe embed", () => {
+      const html = `<iframe src="https://jobs.lever.co/figma"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "lever", boardToken: "figma" });
+    });
+
+    it("detects Lever data-lever attribute", () => {
+      const html = `<div data-lever-company="figma" data-lever-widget="jobs"></div>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "lever", boardToken: "figma" });
+    });
+
+    it("detects Ashby iframe embed", () => {
+      const html = `<iframe src="https://jobs.ashbyhq.com/ramp"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "ashby", boardToken: "ramp" });
+    });
+
+    it("detects Ashby embed script with data attribute", () => {
+      const html = `<script src="https://jobs.ashbyhq.com/embed.js" data-ashby-job-board-id="ramp"></script>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "ashby", boardToken: "ramp" });
+    });
+
+    it("detects Workday iframe embed", () => {
+      const html = `<iframe src="https://netflix.wd5.myworkdayjobs.com/en-US/jobs"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "workday", boardToken: "netflix" });
+    });
+
+    it("detects BambooHR iframe embed", () => {
+      const html = `<iframe src="https://acme.bamboohr.com/careers/list"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "bamboohr", boardToken: "acme" });
+    });
+
+    it("returns unknown when no ATS signatures found", () => {
+      const html = `<html><body><h1>Jobs</h1><p>We're hiring!</p></body></html>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "unknown", boardToken: null });
+    });
+
+    it("URL detection takes priority over HTML detection", () => {
+      const html = `<iframe src="https://jobs.lever.co/other"></iframe>`;
+      const result = detectProvider(
+        html,
+        "https://boards.greenhouse.io/acme"
+      );
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+
+    it("handles protocol-relative iframe src (//)", () => {
+      const html = `<iframe src="//boards.greenhouse.io/acme"></iframe>`;
+      const result = detectProvider(html, "https://example.com/careers");
+      expect(result).toEqual({ provider: "greenhouse", boardToken: "acme" });
+    });
+  });
+});

package/test/unit/events.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { bus } from "../../src/events.js";
+
+describe("TypedEventBus", () => {
+  beforeEach(() => {
+    bus.removeAllListeners();
+  });
+
+  it("emits and receives events", () => {
+    const received: { total: number }[] = [];
+    bus.on("crawl:start", (payload) => received.push(payload));
+
+    bus.emit("crawl:start", { total: 5 });
+
+    expect(received).toHaveLength(1);
+    expect(received[0]).toEqual({ total: 5 });
+  });
+
+  it("supports multiple listeners for same event", () => {
+    let count = 0;
+    bus.on("crawl:start", () => count++);
+    bus.on("crawl:start", () => count++);
+
+    bus.emit("crawl:start", { total: 1 });
+
+    expect(count).toBe(2);
+  });
+
+  it("only notifies listeners of the emitted event", () => {
+    let startCalled = false;
+    let doneCalled = false;
+    bus.on("crawl:start", () => (startCalled = true));
+    bus.on("crawl:complete", () => (doneCalled = true));
+
+    bus.emit("crawl:start", { total: 1 });
+
+    expect(startCalled).toBe(true);
+    expect(doneCalled).toBe(false);
+  });
+
+  it("removes specific listener with off()", () => {
+    let count = 0;
+    const handler = () => count++;
+
+    bus.on("crawl:start", handler);
+    bus.emit("crawl:start", { total: 1 });
+    expect(count).toBe(1);
+
+    bus.off("crawl:start", handler);
+    bus.emit("crawl:start", { total: 2 });
+    expect(count).toBe(1); // not called again
+  });
+
+  it("removeAllListeners() clears everything", () => {
+    let called = false;
+    bus.on("crawl:start", () => (called = true));
+    bus.on("crawl:complete", () => (called = true));
+
+    bus.removeAllListeners();
+
+    bus.emit("crawl:start", { total: 1 });
+    bus.emit("crawl:complete", {
+      totalJobs: 0,
+      totalMatched: 0,
+      totalUrls: 0,
+      failedUrls: 0,
+    });
+
+    expect(called).toBe(false);
+  });
+
+  it("passes typed payloads correctly", () => {
+    let payload: {
+      urlId: string;
+      company: string;
+      matched: number;
+      total: number;
+    } | null = null;
+    bus.on("url:done", (p) => (payload = p));
+
+    bus.emit("url:done", {
+      urlId: "u_abc12",
+      company: "Acme",
+      matched: 5,
+      total: 10,
+    });
+
+    expect(payload).toEqual({
+      urlId: "u_abc12",
+      company: "Acme",
+      matched: 5,
+      total: 10,
+    });
+  });
+
+  it("handles error events", () => {
+    let errorMsg = "";
+    bus.on("error", (p) => (errorMsg = p.message));
+
+    bus.emit("error", { message: "something went wrong" });
+
+    expect(errorMsg).toBe("something went wrong");
+  });
+});

package/test/unit/format-output.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect } from "vitest";
+import { formatOutput } from "../../src/core/format-output.js";
+import type { Job } from "../../src/types/index.js";
+
+function makeJob(overrides: Partial<Job> = {}): Job {
+  return {
+    id: "abc123",
+    title: "Software Engineer",
+    company: "Acme Corp",
+    location: "San Francisco, CA",
+    workMode: "onsite",
+    department: "Engineering",
+    url: "https://example.com/jobs/1",
+    sourceUrl: "https://example.com/careers",
+    provider: "greenhouse",
+    description: null,
+    postedAt: "2026-01-15T00:00:00.000Z",
+    extractedAt: "2026-01-20T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+describe("formatOutput", () => {
+  const jobs = [
+    makeJob(),
+    makeJob({
+      id: "def456",
+      title: "Product Designer",
+      company: "Startup Inc",
+      location: null,
+      department: null,
+      workMode: "remote",
+      url: "https://example.com/jobs/2",
+      postedAt: null,
+    }),
+  ];
+
+  describe("json", () => {
+    it("returns pretty-printed JSON", () => {
+      const result = formatOutput(jobs, "json");
+      const parsed = JSON.parse(result);
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].title).toBe("Software Engineer");
+      expect(parsed[1].title).toBe("Product Designer");
+    });
+
+    it("returns empty array JSON for no jobs", () => {
+      const result = formatOutput([], "json");
+      expect(JSON.parse(result)).toEqual([]);
+    });
+  });
+
+  describe("table", () => {
+    it("returns formatted table with headers", () => {
+      const result = formatOutput(jobs, "table");
+      const lines = result.split("\n");
+      expect(lines[0]).toContain("Company");
+      expect(lines[0]).toContain("Title");
+      expect(lines[0]).toContain("Location");
+      expect(lines[0]).toContain("Department");
+      expect(lines[0]).toContain("URL");
+      // separator line
+      expect(lines[1]).toMatch(/^-+/);
+      // data rows
+      expect(lines[2]).toContain("Acme Corp");
+      expect(lines[3]).toContain("Startup Inc");
+    });
+
+    it("shows dashes for null values", () => {
+      const result = formatOutput(jobs, "table");
+      const lines = result.split("\n");
+      // Second job has null location and department
+      expect(lines[3]).toContain("-");
+    });
+
+    it("returns message for empty jobs", () => {
+      const result = formatOutput([], "table");
+      expect(result).toBe("No matching jobs found.");
+    });
+  });
+
+  describe("csv", () => {
+    it("includes header row", () => {
+      const result = formatOutput(jobs, "csv");
+      const lines = result.split("\n");
+      expect(lines[0]).toBe(
+        "company,title,location,department,workMode,url,postedAt"
+      );
+    });
+
+    it("outputs correct data rows", () => {
+      const result = formatOutput(jobs, "csv");
+      const lines = result.split("\n");
+      expect(lines).toHaveLength(3); // header + 2 rows
+      expect(lines[1]).toContain("Acme Corp");
+      expect(lines[1]).toContain("Software Engineer");
+    });
+
+    it("escapes values containing commas", () => {
+      const jobsWithComma = [
+        makeJob({ company: "Acme, Inc" }),
+      ];
+      const result = formatOutput(jobsWithComma, "csv");
+      const lines = result.split("\n");
+      expect(lines[1]).toContain('"Acme, Inc"');
+    });
+
+    it("escapes values containing double quotes", () => {
+      const jobsWithQuote = [
+        makeJob({ title: 'Senior "Staff" Engineer' }),
+      ];
+      const result = formatOutput(jobsWithQuote, "csv");
+      const lines = result.split("\n");
+      expect(lines[1]).toContain('"Senior ""Staff"" Engineer"');
+    });
+
+    it("escapes values containing newlines", () => {
+      const jobsWithNewline = [
+        makeJob({ company: "Line1\nLine2" }),
+      ];
+      const result = formatOutput(jobsWithNewline, "csv");
+      expect(result).toContain('"Line1\nLine2"');
+    });
+
+    it("uses empty string for null values", () => {
+      const result = formatOutput(
+        [makeJob({ location: null, department: null, postedAt: null })],
+        "csv"
+      );
+      const lines = result.split("\n");
+      const fields = lines[1].split(",");
+      // location (index 2), department (index 3) should be empty
+      expect(fields[2]).toBe("");
+      expect(fields[3]).toBe("");
+    });
+  });
+
+  describe("markdown", () => {
+    it("returns markdown table with headers", () => {
+      const result = formatOutput(jobs, "markdown");
+      const lines = result.split("\n");
+      expect(lines[0]).toBe("| Company | Title | Location | Department |");
+      expect(lines[1]).toBe("| --- | --- | --- | --- |");
+    });
+
+    it("wraps title in link", () => {
+      const result = formatOutput(jobs, "markdown");
+      expect(result).toContain(
+        "[Software Engineer](https://example.com/jobs/1)"
+      );
+    });
+
+    it("shows dashes for null values", () => {
+      const result = formatOutput(jobs, "markdown");
+      const lines = result.split("\n");
+      // Second job row has null location and department
+      expect(lines[3]).toContain("| - |");
+    });
+
+    it("returns message for empty jobs", () => {
+      const result = formatOutput([], "markdown");
+      expect(result).toBe("No matching jobs found.");
+    });
+  });
+});

package/test/unit/match-jobs.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect } from "vitest";
+import { matchJobs } from "../../src/core/match-jobs.js";
+import type { Job, SearchCriteria } from "../../src/types/index.js";
+
+function makeJob(overrides: Partial<Job> = {}): Job {
+  return {
+    id: "abc123",
+    title: "Software Engineer",
+    company: "Acme",
+    location: "San Francisco, CA",
+    workMode: "onsite",
+    department: "Engineering",
+    url: "https://example.com/jobs/1",
+    sourceUrl: "https://example.com/careers",
+    provider: "greenhouse",
+    description: null,
+    postedAt: null,
+    extractedAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function emptyCriteria(overrides: Partial<SearchCriteria> = {}): SearchCriteria {
+  return {
+    keywords: [],
+    excludeKeywords: [],
+    location: null,
+    workMode: null,
+    departments: null,
+    role: null,
+    roleType: null,
+    jobType: null,
+    minExperience: null,
+    companyStage: null,
+    industry: null,
+    companySize: null,
+    hasSalary: null,
+    hasEquity: null,
+    hasInterviewProcess: null,
+    visaSponsorship: null,
+    ...overrides,
+  };
+}
+
+describe("matchJobs", () => {
+  const jobs = [
+    makeJob({ title: "Software Engineer", department: "Engineering" }),
+    makeJob({
+      title: "Senior Product Designer",
+      department: "Design",
+      location: "Remote",
+      workMode: "remote",
+    }),
+    makeJob({
+      title: "Data Scientist",
+      department: "Data",
+      location: "New York, NY",
+    }),
+    makeJob({
+      title: "Engineering Manager",
+      department: "Engineering",
+      location: null,
+      workMode: null,
+    }),
+  ];
+
+  it("returns all jobs when no criteria specified", () => {
+    const result = matchJobs(jobs, emptyCriteria());
+    expect(result).toHaveLength(4);
+  });
+
+  describe("keyword matching", () => {
+    it("filters by keyword in title (case-insensitive)", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ keywords: ["engineer"] })
+      );
+      expect(result).toHaveLength(2);
+      expect(result.map((j) => j.title)).toEqual([
+        "Software Engineer",
+        "Engineering Manager",
+      ]);
+    });
+
+    it("matches any keyword (OR logic)", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ keywords: ["designer", "scientist"] })
+      );
+      expect(result).toHaveLength(2);
+    });
+
+    it("is case-insensitive", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ keywords: ["SOFTWARE"] })
+      );
+      expect(result).toHaveLength(1);
+      expect(result[0].title).toBe("Software Engineer");
+    });
+  });
+
+  describe("exclude keywords", () => {
+    it("excludes jobs matching exclude keywords", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ excludeKeywords: ["manager"] })
+      );
+      expect(result).toHaveLength(3);
+      expect(result.every((j) => !j.title.includes("Manager"))).toBe(true);
+    });
+
+    it("exclude is case-insensitive", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ excludeKeywords: ["SENIOR"] })
+      );
+      expect(result).toHaveLength(3);
+    });
+
+    it("applies both keywords and excludeKeywords together", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({
+          keywords: ["engineer"],
+          excludeKeywords: ["manager"],
+        })
+      );
+      expect(result).toHaveLength(1);
+      expect(result[0].title).toBe("Software Engineer");
+    });
+  });
+
+  describe("location matching", () => {
+    it("filters by location substring", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ location: "San Francisco" })
+      );
+      expect(result).toHaveLength(2); // SF job + null-location job
+    });
+
+    it("includes jobs with null location (doesn't exclude for missing data)", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ location: "Tokyo" })
+      );
+      // Only the null-location job passes (null is included)
+      expect(result).toHaveLength(1);
+      expect(result[0].location).toBeNull();
+    });
+
+    it("is case-insensitive", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ location: "new york" })
+      );
+      expect(result).toHaveLength(2); // NY job + null-location job
+    });
+  });
+
+  describe("work mode matching", () => {
+    it("filters by work mode", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ workMode: ["remote"] })
+      );
+      expect(result).toHaveLength(2); // remote job + null-workMode job
+    });
+
+    it("includes jobs with null workMode", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ workMode: ["hybrid"] })
+      );
+      // Only null-workMode job passes
+      expect(result).toHaveLength(1);
+      expect(result[0].workMode).toBeNull();
+    });
+
+    it("matches multiple work modes (OR logic)", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ workMode: ["remote", "onsite"] })
+      );
+      // remote (1) + onsite (default in 2 jobs) + null passes through (1) = 4
+      expect(result).toHaveLength(4);
+    });
+  });
+
+  describe("department matching", () => {
+    it("filters by department substring", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ departments: ["engineering"] })
+      );
+      // "Software Engineer" (Engineering) + "Engineering Manager" (Engineering) = 2
+      // No null-dept jobs in the test data
+      expect(result).toHaveLength(2);
+    });
+
+    it("includes jobs with null department", () => {
+      const nullDeptJobs = [
+        makeJob({ department: null }),
+        makeJob({ department: "Sales" }),
+      ];
+      const result = matchJobs(
+        nullDeptJobs,
+        emptyCriteria({ departments: ["Engineering"] })
+      );
+      expect(result).toHaveLength(1);
+      expect(result[0].department).toBeNull();
+    });
+
+    it("matches any department (OR logic)", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({ departments: ["engineering", "design"] })
+      );
+      // Eng (2) + Design (1) = 3 (no null-dept jobs in test data)
+      expect(result).toHaveLength(3);
+    });
+  });
+
+  describe("combined criteria", () => {
+    it("applies all criteria as AND filters", () => {
+      const result = matchJobs(
+        jobs,
+        emptyCriteria({
+          keywords: ["engineer"],
+          location: "San Francisco",
+          workMode: ["onsite"],
+          departments: ["engineering"],
+        })
+      );
+      // "Software Engineer" matches all. "Engineering Manager" also matches:
+      // keyword "engineer" in "Engineering Manager", null location passes,
+      // null workMode passes, dept "Engineering" matches.
+      expect(result).toHaveLength(2);
+      expect(result.map((j) => j.title)).toContain("Software Engineer");
+      expect(result.map((j) => j.title)).toContain("Engineering Manager");
+    });
+  });
+
+  it("returns empty array when no jobs match", () => {
+    const result = matchJobs(
+      jobs,
+      emptyCriteria({ keywords: ["nonexistent"] })
+    );
+    expect(result).toHaveLength(0);
+  });
+
+  it("handles empty jobs array", () => {
+    const result = matchJobs([], emptyCriteria({ keywords: ["engineer"] }));
+    expect(result).toHaveLength(0);
+  });
+});