@timurtekb/tekjobs 0.45.0 → 0.46.0

package/app/dist/index.html

@@ -8,8 +8,8 @@
     <link rel="icon" href="/brand/tekjobs-avatar-192.png" type="image/png" sizes="192x192" />
     <link rel="apple-touch-icon" href="/brand/tekjobs-avatar-192.png" />
     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:wght@500;600&family=Hanken+Grotesk:wght@400;500;600&family=Azeret+Mono:wght@400;500&display=swap" data-zengin="fonts" />
-    <script type="module" crossorigin src="/assets/index-BtNxvOxd.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-pTsHxrh7.css">
+    <script type="module" crossorigin src="/assets/index-V6WTCNu_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dhv_7hBU.css">
   </head>
   <body>
     <div id="root"></div>

package/app/server/index.mjs

@@ -41,7 +41,7 @@ const routes = [
   ['GET', /^\/api\/jobs\/([^/]+)\/connections$/, (m) => linkedin.connectionsAt(store.getJob(decodeURIComponent(m[1])).company)],
   ['GET', /^\/api\/linkedin$/, () => linkedin.status()],
   ['POST', /^\/api\/linkedin\/preview$/, async (_, __, req) => { const b = await readBody(req); return linkedin.preview(b.source, { since: b.since || undefined, everyone: !!b.everyone }); }],
-  ['POST', /^\/api\/linkedin\/import$/, async (_, __, req) => { const b = await readBody(req); return linkedin.runImport(b.source, { since: b.since || undefined, everyone: !!b.everyone, writePeople: b.writePeople !== false, dry: !!b.dry }); }],
+  ['POST', /^\/api\/linkedin\/import$/, async (_, __, req) => { const b = await readBody(req); const r = linkedin.runImport(b.source, { since: b.since || undefined, everyone: !!b.everyone, writePeople: b.writePeople !== false, dry: !!b.dry }); if (b.applications || b.saved) r.jobs = linkedin.importJobs(b.source, { since: b.since || undefined, applications: !!b.applications, saved: !!b.saved, dry: !!b.dry }); return r; }],
   ['GET', /^\/api\/people$/, () => people.listPeople()],
   ['POST', /^\/api\/people$/, async (_, __, req) => { const b = await readBody(req); const p = people.createPerson(b); if (b.jobId) people.attachPerson(b.jobId, p.id, { role: b.role, context: b.context }); return people.getPerson(p.id); }],
   ['GET', /^\/api\/people\/([^/]+)$/, (m) => people.getPerson(decodeURIComponent(m[1]))],

package/app/server/linkedin-import.mjs

@@ -4,10 +4,13 @@
 // appended again.
 import fs from 'node:fs';
 import path from 'node:path';
-import { P, DATA_DIR } from '../../scraper/config.mjs';
-import { readExport, buildIndex, peopleCandidates, warmPaths, companyKey } from '../../scraper/linkedin.mjs';
+import { loadCriteria, P, DATA_DIR } from '../../scraper/config.mjs';
+import { readExport, buildIndex, peopleCandidates, warmPaths, companyKey, sameCompany } from '../../scraper/linkedin.mjs';
 import * as people from './people.mjs';
 import * as store from './store.mjs';
+import { writeJobNote } from '../../scraper/vault.mjs';
+import { scoreJob, normalizeTitle } from '../../scraper/score.mjs';
+import { htmlToText } from '../../scraper/sources.mjs';
 
 const isoDay = (d = new Date()) => d.toISOString().slice(0, 10);
 const daysAgo = (n) => isoDay(new Date(Date.now() - n * 864e5));
@@ -107,3 +110,97 @@ export function runImport(source, { since = daysAgo(90), roles = ['recruiter', '
 
   return summary;
 }
+
+// ---------------- applications and saved jobs, as notes ----------------
+// The export carries the person's own record of where they applied through LinkedIn and what they saved. Opt-in:
+// each becomes a note (or a line on the note that already exists), so the pipeline shows the search they were
+// already running. The posting itself is never fetched; the note carries the LinkedIn link for the person to open.
+const titleKey = (t) => normalizeTitle(t).replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+const sameTitle = (a, b) => { const x = titleKey(a), y = titleKey(b); return !!x && !!y && (x === y || x.includes(y) || y.includes(x)); };
+const hash = (s) => { let h = 5381; for (const ch of String(s)) h = ((h * 33) ^ ch.charCodeAt(0)) >>> 0; return h.toString(16); };
+const noteText = (id) => { try { return fs.readFileSync(store.getJob(id).path, 'utf8'); } catch { return ''; } };
+// Empty or absent: a note written by hand or by an older version may not carry the field at all.
+const appliedOnEmpty = (id) => !/^- \*\*Applied on:\*\*\s*\S/m.test(noteText(id));
+const noteOnce = (id, line) => { if (!noteText(id).includes(line)) store.addNote(id, line, 'linkedin-export'); };
+
+function findNote(jobs, { company, title, url }) {
+  const clean = (u) => String(u || '').split('?')[0].replace(/\/$/, '');
+  const byUrl = url && jobs.find((j) => j.url && clean(j.url) === clean(url));
+  if (byUrl) return byUrl;
+  return jobs.filter((j) => sameCompany(j.company, company)).find((j) => sameTitle(j.title, title)) || null;
+}
+function stubFor(kind, r) {
+  const html = kind === 'application'
+    ? `<p>Applied through LinkedIn on ${r.date}. From the LinkedIn data export: the posting itself was not read, so there is no description or pay here. Open the link for the posting.</p>`
+    : `<p>Saved on LinkedIn on ${r.date}. From the LinkedIn data export: the posting itself was not read. Open the link for the posting.</p>`;
+  const job = {
+    id: `linkedin:${kind}:${hash(`${r.url || ''}|${r.company}|${r.title}|${r.date}`)}`, source: 'linkedin-export', company: r.company, title: r.title || 'Role not named in the export',
+    url: r.url || '', location: '', remote: false, posted: r.date, descriptionHtml: html, foundVia: kind === 'application' ? 'from the LinkedIn export: an application' : 'from the LinkedIn export: a saved job', addedBy: 'linkedin-export',
+  };
+  job.descriptionText = htmlToText(job.descriptionHtml);
+  return job;
+}
+
+/** What importing the applications and saved jobs would touch: per kind, the notes it would mark and the ones it would create. */
+export function planJobs(index, { since = index?.since || '', applications = false, saved = false } = {}) {
+  const jobs = store.listJobs();
+  const recent = (d) => !since || (d && d >= since);
+  const one = (rows, on) => {
+    const out = { matched: [], create: [], skipped: 0 };
+    if (!on) return out;
+    for (const r of rows || []) {
+      if (!recent(r.date) || !r.company) { out.skipped++; continue; }
+      const note = findNote(jobs, r);
+      if (note) out.matched.push({ id: note.id, status: note.status, date: r.date, company: r.company, title: r.title });
+      else out.create.push(r);
+    }
+    return out;
+  };
+  return { since, applications: one(index?.applications, applications), saved: one(index?.savedJobs, saved) };
+}
+
+/**
+ * Applications become notes at "applied" with the date; saved jobs become notes at "reviewing". A note that already
+ * exists gets the line and, for an application, the status and the date if it had none. Re-running changes nothing.
+ * The status is set via "linkedin-export": the person's own record is the evidence, so the human-only rule for agents
+ * does not apply, and the status log says where it came from.
+ */
+export function importJobs(source, { since = daysAgo(90), applications = false, saved = false, dry = false } = {}) {
+  const index = buildIndex(readExport(source), { since });
+  const plan = planJobs(index, { since: index.since, applications, saved });
+  const out = { since: index.since, dry, applications: { matched: 0, marked: 0, created: 0, skipped: plan.applications.skipped }, saved: { matched: 0, created: 0, skipped: plan.saved.skipped } };
+  // A profile with no criteria yet (the import can run before the interview) still gets its notes; they are scored later by a rescore.
+  let criteria; try { criteria = loadCriteria(); } catch { criteria = { titleTerms: {}, titleExclude: [], descTerms: {}, minScore: 0 }; }
+  const advanced = ['applied', 'interviewing', 'offer', 'rejected'];
+  for (const m of plan.applications.matched) {
+    out.applications.matched++;
+    if (dry) continue;
+    if (!advanced.includes(m.status)) { store.setStatus(m.id, 'applied', 'linkedin-export'); out.applications.marked++; }
+    if (appliedOnEmpty(m.id)) store.saveApplicationDraft(m.id, { field: 'Applied on', value: m.date });
+    noteOnce(m.id, `Applied through LinkedIn on ${m.date} (from the LinkedIn export).`);
+  }
+  for (const r of plan.applications.create) {
+    out.applications.created++;
+    if (dry) continue;
+    const job = stubFor('application', r);
+    const id = path.basename(writeJobNote(job, scoreJob(job, criteria), criteria), '.md');
+    store.cacheClear?.();
+    store.setStatus(id, 'applied', 'linkedin-export');
+    if (appliedOnEmpty(id)) store.saveApplicationDraft(id, { field: 'Applied on', value: r.date });
+  }
+  for (const m of plan.saved.matched) {
+    out.saved.matched++;
+    if (dry) continue;
+    noteOnce(m.id, `Saved on LinkedIn on ${m.date} (from the LinkedIn export).`);
+  }
+  for (const r of plan.saved.create) {
+    out.saved.created++;
+    if (dry) continue;
+    const job = stubFor('saved', r);
+    const id = path.basename(writeJobNote(job, scoreJob(job, criteria), criteria), '.md');
+    store.cacheClear?.();
+    store.setStatus(id, 'reviewing', 'linkedin-export');
+  }
+  store.cacheClear?.();
+  return out;
+}

package/app/server/mcp.mjs

@@ -19,7 +19,7 @@ export const TOOLS = [
   { name: 'list_snippets', description: 'The copy panel: the person\'s standard answers for application forms (name, email, phone, links, availability, salary answer, anything they added), grouped, from Profile/Snippets.md. Use these verbatim when drafting form answers; never invent a value that is empty here.', inputSchema: { type: 'object', properties: {} } },
   { name: 'list_people', description: 'The people in the search: recruiters, hiring managers, interviewers and referrals, one note each under People/, with role, company, email, last contact and the job notes they are on. Newest contact first.', inputSchema: { type: 'object', properties: {} } },
   { name: 'get_person', description: 'One person in full: the row plus their About text and dated Log of contacts.', inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
-  { name: 'import_linkedin', description: "Read the person's LinkedIn data export (the larger archive from linkedin.com/mypreferences/d/download-my-data, as a zip or an unpacked folder, given by local path) into the search: an index of who they know at which company (job notes then show connections), People notes for the recruiters and hiring managers who wrote since the date (with the thread as their log, linked to open job notes at that company). The archive is read in place and never copied. dry=true reports without writing; everyone=true also writes senders whose title is not a recruiting or hiring one. Default since: 90 days ago.", inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'Local path to the zip or folder' }, since: { type: 'string', description: 'YYYY-MM-DD' }, everyone: { type: 'boolean' }, writePeople: { type: 'boolean' }, dry: { type: 'boolean' } }, required: ['source'] } },
+  { name: 'import_linkedin', description: "Read the person's LinkedIn data export (the larger archive from linkedin.com/mypreferences/d/download-my-data, as a zip or an unpacked folder, given by local path) into the search: an index of who they know at which company (job notes then show connections), People notes for the recruiters and hiring managers who wrote since the date (with the thread as their log, linked to open job notes at that company). The archive is read in place and never copied. dry=true reports without writing; everyone=true also writes senders whose title is not a recruiting or hiring one. applications=true turns the person's LinkedIn applications since the date into notes at applied with the date (or marks the note that exists); saved=true turns their saved jobs into notes at reviewing. The person's own export is the evidence, so these statuses are allowed here. Default since: 90 days ago.", inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'Local path to the zip or folder' }, since: { type: 'string', description: 'YYYY-MM-DD' }, everyone: { type: 'boolean' }, writePeople: { type: 'boolean' }, applications: { type: 'boolean' }, saved: { type: 'boolean' }, dry: { type: 'boolean' } }, required: ['source'] } },
   { name: 'connections_at', description: "Who the person knows at a company, from the LinkedIn import: name, title, a guessed role (recruiter, hiring-manager, other), profile link, when connected. Empty before the first import (say so and offer import_linkedin). Use it before drafting an application or when a job note is discussed: a warm introduction beats a cold apply.", inputSchema: { type: 'object', properties: { company: { type: 'string' } }, required: ['company'] } },
   { name: 'add_person', description: 'Add a person (or recognise one already there, by email or name and company) and optionally put them on a job note. role: recruiter | hiring-manager | interviewer | referral | other. Give jobId to attach; context is a few words on the thread.', inputSchema: { type: 'object', properties: { name: { type: 'string' }, role: { type: 'string', enum: people.ROLES }, company: { type: 'string' }, email: { type: 'string' }, links: { type: 'string' }, about: { type: 'string' }, jobId: { type: 'string' }, context: { type: 'string' } }, required: ['name'] } },
   { name: 'attach_person', description: 'Put an existing person on a job note (a line under its People section) and the job on their Threads. Idempotent.', inputSchema: { type: 'object', properties: { jobId: { type: 'string' }, personId: { type: 'string' }, role: { type: 'string', enum: people.ROLES }, context: { type: 'string' } }, required: ['jobId', 'personId'] } },
@@ -116,7 +116,11 @@ export async function call(name, a = {}) {
     case 'list_snippets': return store.getSnippets();
     case 'list_people': return people.listPeople();
     case 'get_person': return people.getPerson(a.id);
-    case 'import_linkedin': return linkedin.runImport(a.source, { since: a.since, everyone: !!a.everyone, writePeople: a.writePeople !== false, dry: !!a.dry });
+    case 'import_linkedin': {
+      const r = linkedin.runImport(a.source, { since: a.since, everyone: !!a.everyone, writePeople: a.writePeople !== false, dry: !!a.dry });
+      if (a.applications || a.saved) r.jobs = linkedin.importJobs(a.source, { since: a.since, applications: !!a.applications, saved: !!a.saved, dry: !!a.dry });
+      return r;
+    }
     case 'connections_at': return linkedin.connectionsAt(a.company);
     case 'add_person': { const p = people.createPerson(a); if (a.jobId) people.attachPerson(a.jobId, p.id, { role: a.role, context: a.context }); return people.getPerson(p.id); }
     case 'attach_person': return people.attachPerson(a.jobId, a.personId, { role: a.role, context: a.context });

package/cli.mjs

@@ -40,6 +40,8 @@ const HELP = `tekjobs — a local job-search machine
   tekjobs import linkedin <zip|folder>   your LinkedIn data export into the search: who you know at each
                                          company, and the recruiters who wrote
                                          [--since YYYY-MM-DD] [--everyone] [--no-people] [--preview] [--dry]
+                                         [--applications] your LinkedIn applications as notes at "applied", with the date
+                                         [--saved] your saved jobs as notes at "reviewing"
   tekjobs up [--dev] [--port N]          start the API (and with --dev, Vite) detached: they stay up until \`down\`
   tekjobs down                           stop what \`up\` started
   tekjobs ps                             what \`up\` has running
@@ -182,11 +184,21 @@ async function main() {
     if (!source) return console.error('Usage: tekjobs import linkedin <path to the export zip or unpacked folder> [--since YYYY-MM-DD] [--everyone] [--no-people] [--preview] [--dry]\nRequest the larger archive at https://www.linkedin.com/mypreferences/d/download-my-data');
     const li = await import('./app/server/linkedin-import.mjs');
     const o = { since: opt('--since') || undefined, everyone: rest.includes('--everyone'), writePeople: !rest.includes('--no-people'), dry: rest.includes('--dry') };
-    if (rest.includes('--preview')) return console.log(JSON.stringify(li.preview(source, o), null, 2));
+    const jobsOpt = { since: o.since, applications: rest.includes('--applications'), saved: rest.includes('--saved'), dry: o.dry };
+    if (rest.includes('--preview')) {
+      const p = li.preview(source, o);
+      if (jobsOpt.applications || jobsOpt.saved) p.jobs = li.importJobs(source, { ...jobsOpt, dry: true });
+      return console.log(JSON.stringify(p, null, 2));
+    }
     const s = li.runImport(source, o);
+    const jobs = jobsOpt.applications || jobsOpt.saved ? li.importJobs(source, jobsOpt) : null;
     console.log(`LinkedIn export read from ${s.source}${s.dry ? ' (dry run, nothing written)' : ''}`);
     console.log(`  ${s.counts.connections} connections indexed, ${s.counts.threads} conversations and ${s.counts.invitations} invitations since ${s.since}, ${s.counts.applications} applications, ${s.counts.savedJobs} saved jobs`);
     console.log(`  People: ${s.people.created} created, ${s.people.recognised} already there, ${s.people.attached} put on job notes, ${s.people.logged} log lines; ${s.people.skipped} senders skipped (not recruiters or hiring managers; --everyone includes them)`);
+    if (jobs) {
+      if (jobsOpt.applications) console.log(`  Applications: ${jobs.applications.matched} already had a note (${jobs.applications.marked} moved to applied), ${jobs.applications.created} notes created at applied, ${jobs.applications.skipped} before ${jobs.since} or without a company`);
+      if (jobsOpt.saved) console.log(`  Saved jobs: ${jobs.saved.matched} already had a note, ${jobs.saved.created} notes created at reviewing, ${jobs.saved.skipped} before ${jobs.since} or without a company`);
+    }
     if (!s.dry) console.log(`  Index: ${s.indexPath}. Job notes now show who you know at each company.`);
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurtekb/tekjobs",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "description": "A local-first job-search machine: watches hundreds of company job boards, scores every posting against your profile, and files matches into a folder of markdown notes you own. Bring your own LLM through MCP.",
   "type": "module",
   "license": "MIT",