@jsonresume/jobs 0.14.0 → 0.14.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2026 JSON Resume contributors
+
+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/bin/cli.js

@@ -120,7 +120,7 @@ async function cmdSearch() {
   const params = new URLSearchParams();
   const topArg = parseInt(getArg('--top')) || 20;
   params.set('top', String(Math.min(Math.max(1, topArg), 100)));
-  params.set('days', String(parseInt(getArg('--days')) || 30));
+  params.set('days', String(parseInt(getArg('--days')) || 90));
   if (hasFlag('--remote')) params.set('remote', 'true');
   const minSalary = parseInt(getArg('--min-salary'));
   if (minSalary > 0) params.set('min_salary', String(minSalary));
@@ -340,7 +340,7 @@ COMMANDS
 
 SEARCH OPTIONS
   --top N                           Number of results (default: 20, max: 100)
-  --days N                          How far back to look (default: 30)
+  --days N                          How far back to look (default: 90)
   --remote                          Remote jobs only
   --min-salary N                    Minimum salary in thousands (e.g. 150)
   --search TERM                     Keyword filter (searches title, company, skills)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonresume/jobs",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "type": "module",
   "description": "Search Hacker News jobs matched against your JSON Resume",
   "bin": {
@@ -43,5 +43,12 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.6"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/src/api.js

@@ -59,6 +59,13 @@ export function createApiClient({ baseUrl, apiKey }) {
       }),
     deleteSearch: (id) => request(`/searches/${id}`, { method: 'DELETE' }),
 
+    // Enrichment
+    enrichJob: (id, enriched) =>
+      request(`/jobs/${id}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ enriched }),
+      }),
+
     // Dossiers
     fetchDossier: (id) => request(`/jobs/${id}/dossier`),
     saveDossier: (id, content) =>

package/src/formatters.js

@@ -4,10 +4,62 @@ export function formatSalary(salary, salaryUsd) {
   return '—';
 }
 
+/**
+ * Defensive location normalizer for job records.
+ *
+ * The registry API serves `job.location` straight from the parsed
+ * `gpt_content`, whose canonical shape is an OBJECT
+ * (`{ address, postalCode, city, region, countryCode }`, see the
+ * extraction schema in apps/registry/scripts/jobs/job-parser/jobSchema.js).
+ * Remote status is a SEPARATE field (`job.remote` → 'Full' | 'Hybrid' | 'None').
+ *
+ * Historic rows may still carry `location` as a plain string, so this
+ * normalizer accepts strings, objects, or nullish input and always returns a
+ * stable shape:
+ *   { city, region, countryCode, display, remote }
+ * where `remote` is a boolean derived from either the separate `remote`
+ * field or a "remote" hint inside a string location.
+ *
+ * @param {Object|string|null} job - a job record, or a bare location value.
+ * @returns {{city:string|null, region:string|null, countryCode:string|null, display:string|null, remote:boolean}}
+ */
+export function normalizeLocation(job) {
+  // Allow passing either a full job record or a bare location value.
+  const isJobRecord = job && typeof job === 'object' && 'location' in job;
+  const loc = isJobRecord ? job.location : job;
+  const remoteField = isJobRecord ? job.remote : undefined;
+
+  let city = null;
+  let region = null;
+  let countryCode = null;
+  let display = null;
+  let stringRemote = false;
+
+  if (typeof loc === 'string') {
+    const trimmed = loc.trim();
+    display = trimmed || null;
+    stringRemote = /remote/i.test(trimmed);
+  } else if (loc && typeof loc === 'object') {
+    city = loc.city || null;
+    region = loc.region || null;
+    countryCode = loc.countryCode || null;
+    const parts = [city, region, countryCode].filter(Boolean);
+    display = parts.length ? parts.join(', ') : null;
+  }
+
+  // Mirror the server-side remote filter (matchingHelpers.js), which treats
+  // only fully-remote roles as "remote" (j.remote === 'Full'). For historic
+  // string locations with no separate `remote` field, fall back to the
+  // "remote" hint in the location text.
+  const remote = remoteField === 'Full' || stringRemote;
+
+  return { city, region, countryCode, display, remote };
+}
+
 export function formatLocation(loc, remote) {
+  const norm = normalizeLocation(loc);
   const parts = [];
-  if (loc?.city) parts.push(loc.city);
-  if (loc?.countryCode) parts.push(loc.countryCode);
+  if (norm.display) parts.push(norm.display);
   if (remote) parts.push(`(${remote})`);
   return parts.join(', ') || '—';
 }
@@ -39,6 +91,18 @@ export function truncate(str, len) {
   return str.length > len ? str.slice(0, len - 1) + '…' : str;
 }
 
+export function formatAge(postedAt) {
+  if (!postedAt) return '';
+  const days = Math.floor(
+    (Date.now() - new Date(postedAt).getTime()) / 86400000
+  );
+  if (days === 0) return 'today';
+  if (days === 1) return '1d ago';
+  if (days < 7) return `${days}d ago`;
+  if (days < 30) return `${Math.floor(days / 7)}w ago`;
+  return `${Math.floor(days / 30)}mo ago`;
+}
+
 export function stateLabel(state) {
   const labels = {
     interested: 'Interested',

package/src/formatters.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeLocation, formatLocation } from './formatters.js';
+
+describe('normalizeLocation', () => {
+  it('normalizes the canonical object location shape', () => {
+    const job = {
+      location: { city: 'Berlin', region: 'BE', countryCode: 'DE' },
+      remote: 'None',
+    };
+    const norm = normalizeLocation(job);
+    expect(norm).toEqual({
+      city: 'Berlin',
+      region: 'BE',
+      countryCode: 'DE',
+      display: 'Berlin, BE, DE',
+      remote: false,
+    });
+  });
+
+  it('builds display from whichever object fields are present', () => {
+    expect(normalizeLocation({ location: { city: 'Seattle' } }).display).toBe(
+      'Seattle'
+    );
+    expect(normalizeLocation({ location: { countryCode: 'US' } }).display).toBe(
+      'US'
+    );
+    expect(normalizeLocation({ location: {} }).display).toBeNull();
+  });
+
+  it('handles a historic plain-string location', () => {
+    const norm = normalizeLocation({ location: 'San Francisco, CA' });
+    expect(norm.display).toBe('San Francisco, CA');
+    expect(norm.city).toBeNull();
+    expect(norm.remote).toBe(false);
+  });
+
+  it('detects "remote" inside a string location (historic rows)', () => {
+    expect(normalizeLocation({ location: 'Remote (US)' }).remote).toBe(true);
+    expect(normalizeLocation({ location: 'Fully remote' }).remote).toBe(true);
+    expect(normalizeLocation({ location: 'remote' }).remote).toBe(true);
+  });
+
+  it('uses the separate remote field for object locations', () => {
+    expect(
+      normalizeLocation({ location: { city: 'NYC' }, remote: 'Full' }).remote
+    ).toBe(true);
+    expect(
+      normalizeLocation({ location: { city: 'NYC' }, remote: 'Hybrid' }).remote
+    ).toBe(false);
+    expect(
+      normalizeLocation({ location: { city: 'NYC' }, remote: 'None' }).remote
+    ).toBe(false);
+  });
+
+  it('does NOT match remote on an object location (regression guard)', () => {
+    // The old `/remote/i.test(j.location || '')` stringified objects to
+    // "[object Object]" and never matched — but an object whose city happened
+    // to contain "remote" should not flip the flag either.
+    const job = { location: { city: 'Remoteville' }, remote: 'None' };
+    expect(normalizeLocation(job).remote).toBe(false);
+  });
+
+  it('handles null / undefined / empty location', () => {
+    expect(normalizeLocation({ location: null })).toEqual({
+      city: null,
+      region: null,
+      countryCode: null,
+      display: null,
+      remote: false,
+    });
+    expect(normalizeLocation({ location: undefined }).display).toBeNull();
+    expect(normalizeLocation({ location: '' }).display).toBeNull();
+    expect(normalizeLocation(null).display).toBeNull();
+    expect(normalizeLocation(undefined).remote).toBe(false);
+  });
+
+  it('accepts a bare location value (not wrapped in a job)', () => {
+    expect(
+      normalizeLocation({ city: 'Austin', countryCode: 'US' }).display
+    ).toBe('Austin, US');
+    expect(normalizeLocation('Remote').remote).toBe(true);
+  });
+
+  it('trims whitespace from string locations', () => {
+    expect(normalizeLocation({ location: '  London  ' }).display).toBe(
+      'London'
+    );
+    expect(normalizeLocation({ location: '   ' }).display).toBeNull();
+  });
+});
+
+describe('formatLocation', () => {
+  it('formats object locations with an explicit remote suffix', () => {
+    expect(formatLocation({ city: 'Berlin', countryCode: 'DE' }, 'Full')).toBe(
+      'Berlin, DE, (Full)'
+    );
+  });
+
+  it('formats string locations', () => {
+    expect(formatLocation('San Francisco, CA')).toBe('San Francisco, CA');
+  });
+
+  it('falls back to an em dash when empty', () => {
+    expect(formatLocation(null)).toBe('—');
+    expect(formatLocation({})).toBe('—');
+  });
+});