@timurtekb/tekjobs 0.27.1 → 0.29.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-Byee80qa.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DzGgV6NF.css">
+    <script type="module" crossorigin src="/assets/index-DvWnsMvq.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DsgnBEaA.css">
   </head>
   <body>
     <div id="root"></div>

package/app/server/index.mjs

@@ -9,6 +9,7 @@ import * as letter from './cover-letter.mjs';
 import * as tailored from './tailored-resume.mjs';
 import * as mail from './mail-check.mjs';
 import * as people from './people.mjs';
+import * as linkedin from './linkedin-import.mjs';
 
 const PORT = Number(process.env.PORT || 8787);
 const DIST = fileURLToPath(new URL('../dist', import.meta.url));
@@ -34,6 +35,10 @@ const routes = [
   ['GET', /^\/api\/jobs\/([^/]+)\/people$/, (m) => people.peopleOf(decodeURIComponent(m[1]))],
   ['GET', /^\/api\/jobs\/([^/]+)$/, (m) => store.getJob(decodeURIComponent(m[1]))],
   // People: one note per person under People/, linked from the job notes they are on.
+  ['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, writeSnippets: b.writeSnippets !== false, dry: !!b.dry }); }],
   ['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

@@ -0,0 +1,118 @@
+// The LinkedIn import: reads the export in place (scraper/linkedin.mjs) and writes only into the profile folder:
+// the index the app answers "who do I know there" from, People notes for the recruiters and hiring managers who
+// wrote lately, and your saved form answers into the copy panel. Re-running is safe: people are recognised, not
+// duplicated; log lines already present are not appended again; snippets already there are left alone.
+import fs from 'node:fs';
+import path from 'node:path';
+import { P, DATA_DIR } from '../../scraper/config.mjs';
+import { readExport, buildIndex, peopleCandidates, snippetSuggestions, warmPaths, companyKey } from '../../scraper/linkedin.mjs';
+import * as people from './people.mjs';
+import * as store from './store.mjs';
+
+const isoDay = (d = new Date()) => d.toISOString().slice(0, 10);
+const daysAgo = (n) => isoDay(new Date(Date.now() - n * 864e5));
+
+// ---------- the index ----------
+let cached = { mtime: 0, index: null };
+/** The last import's index, or null before the first import. Re-read when the file changes. */
+export function loadIndex() {
+  try {
+    const mtime = fs.statSync(P.linkedin).mtimeMs;
+    if (mtime !== cached.mtime) cached = { mtime, index: JSON.parse(fs.readFileSync(P.linkedin, 'utf8')) };
+    return cached.index;
+  } catch { return null; }
+}
+
+/** Who you know at a company, from the index; an empty answer before any import. */
+export function connectionsAt(company) {
+  const index = loadIndex();
+  if (!index) return { company, count: 0, people: [], imported: null };
+  return { ...warmPaths(index, company), imported: index.built };
+}
+
+/** What the last import left behind, for the People page: when, from what, and the counts. */
+export function status() {
+  const index = loadIndex();
+  if (!index) return { imported: null };
+  return { imported: index.built, since: index.since, source: index.source, counts: index.counts, self: index.self };
+}
+
+// ---------- choosing ----------
+/** The candidates an import writes as People by default: the ones whose title says recruiter or hiring manager. */
+function chosen(candidates, { roles, everyone }) {
+  return candidates.filter((c) => everyone ? c.count > 0 : roles.includes(c.role));
+}
+
+/** Everything an import would do, without doing it. */
+export function preview(source, { since = daysAgo(90), roles = ['recruiter', 'hiring-manager'], everyone = false } = {}) {
+  const ex = readExport(source);
+  const index = buildIndex(ex, { since });
+  const candidates = peopleCandidates(index, { since });
+  const picked = chosen(candidates, { roles, everyone });
+  const existing = store.getSnippets().items;
+  const snippets = snippetSuggestions(index, existing);
+  const jobs = store.listJobs();
+  const jobKeys = new Map(jobs.map((j) => [companyKey(j.company), j]));
+  const withNotes = picked.filter((c) => c.company && jobKeys.has(companyKey(c.company)));
+  const seenCompany = new Set();
+  const knownAt = jobs.filter((j) => { const k = companyKey(j.company); return k && !seenCompany.has(k) && seenCompany.add(k); }).map((j) => ({ company: j.company, count: warmPaths(index, j.company).count })).filter((j) => j.count > 0).sort((a, b) => b.count - a.count);
+  return {
+    source: ex.source, kind: ex.kind, files: ex.files, since, self: index.self, counts: index.counts,
+    people: { candidates: candidates.length, chosen: picked.length, onJobNotes: withNotes.length, sample: picked.slice(0, 12).map((c) => ({ name: c.name, role: c.role, company: c.company, title: c.title, last: c.last, messages: c.count })) },
+    snippets: { new: snippets.length, sample: snippets.slice(0, 8).map((s) => s.label) },
+    warmPaths: { jobsWithConnections: knownAt.length, top: knownAt.slice(0, 10) },
+    applicationsSince: index.applications.filter((a) => a.date >= since).length,
+    savedJobsSince: index.savedJobs.filter((s) => s.date >= since).length,
+  };
+}
+
+// ---------- writing ----------
+/**
+ * Run the import. Writes the index, then (unless told not to) People notes with their LinkedIn log and a link to
+ * any open job note at their company, then the copy-panel suggestions. `dry` does everything but write.
+ */
+export function runImport(source, { since = daysAgo(90), roles = ['recruiter', 'hiring-manager'], everyone = false, writePeople = true, writeSnippets = true, dry = false } = {}) {
+  const ex = readExport(source);
+  const index = buildIndex(ex, { since });
+  const summary = { source: ex.source, since, self: index.self, counts: index.counts, dry, indexPath: P.linkedin, people: { created: 0, recognised: 0, attached: 0, skipped: 0, logged: 0 }, snippets: { added: 0 } };
+
+  if (!dry) { fs.mkdirSync(DATA_DIR, { recursive: true }); fs.writeFileSync(P.linkedin, JSON.stringify(index, null, 1)); cached = { mtime: 0, index: null }; }
+
+  if (writePeople) {
+    const candidates = peopleCandidates(index, { since });
+    const picked = chosen(candidates, { roles, everyone });
+    summary.people.skipped = candidates.length - picked.length;
+    const jobs = store.listJobs().filter((j) => j.status !== 'closed' && j.status !== 'rejected' && j.status !== 'passed');
+    for (const c of picked) {
+      if (dry) { summary.people.created++; continue; }
+      const before = people.findPerson({ name: c.name, company: c.company });
+      const person = people.createPerson({ name: c.name, role: c.role, company: c.company, links: c.url, about: `${c.title ? c.title + (c.company ? ` at ${c.company}` : '') + '. ' : ''}From the LinkedIn import: ${c.count} message${c.count === 1 ? '' : 's'} between ${c.first} and ${c.last}.` });
+      summary.people[before ? 'recognised' : 'created']++;
+      const text = fs.readFileSync(person.path, 'utf8');
+      for (const l of c.log) {
+        const line = `- ${l.date} (${l.via}): ${l.text}`;
+        if (text.includes(line.slice(0, 80))) continue;
+        people.logContact(person.id, { date: l.date, via: l.via, text: l.text });
+        summary.people.logged++;
+      }
+      if (c.company) {
+        const key = companyKey(c.company);
+        for (const j of jobs.filter((j) => companyKey(j.company) === key)) {
+          // List rows carry no file path; the full read does.
+          const note = fs.readFileSync(store.getJob(j.id).path, 'utf8');
+          if (note.includes(`[[People/${person.id}`)) continue;
+          people.attachPerson(j.id, person.id, { role: c.role, context: `LinkedIn, ${c.last}` });
+          summary.people.attached++;
+        }
+      }
+    }
+  }
+
+  if (writeSnippets) {
+    const existing = store.getSnippets().items;
+    const add = snippetSuggestions(index, existing);
+    summary.snippets.added = add.length;
+    if (add.length && !dry) store.saveSnippets([...existing, ...add]);
+  }
+  return summary;
+}

package/app/server/mcp.mjs

@@ -7,11 +7,14 @@ import * as letter from './cover-letter.mjs';
 import * as tailored from './tailored-resume.mjs';
 import * as mail from './mail-check.mjs';
 import * as people from './people.mjs';
+import * as linkedin from './linkedin-import.mjs';
 
 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), and their saved application answers into the copy panel. 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' }, writeSnippets: { 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'] } },
   { name: 'log_contact', description: "Append a dated line to a person's Log (a call, a reply, a note to self) and move their last contact forward. Nothing is sent.", inputSchema: { type: 'object', properties: { personId: { type: 'string' }, text: { type: 'string' }, date: { type: 'string', description: 'YYYY-MM-DD, default today.' } }, required: ['personId', 'text'] } },
@@ -94,6 +97,8 @@ 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, writeSnippets: a.writeSnippets !== false, dry: !!a.dry });
+    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 });
     case 'log_contact': return people.logContact(a.personId, { date: a.date, via: 'mcp', text: a.text });

package/cli.mjs

@@ -34,6 +34,9 @@ const HELP = `tekjobs — a local job-search machine
                                          run the scan and the mail read every morning: creates the Windows task
                                          (07:30 by default), or prints the crontab or launchd line for macOS and
                                          Linux; --print shows the command without installing anything
+  tekjobs import linkedin <zip|folder>   your LinkedIn data export into the search: who you know at each
+                                         company, the recruiters who wrote, your saved form answers
+                                         [--since YYYY-MM-DD] [--everyone] [--no-people] [--no-snippets] [--preview] [--dry]
   tekjobs serve                          the app + API on http://127.0.0.1:8787
   tekjobs mcp                            the MCP server on stdio (Claude Code, Codex, Cursor, Claude Desktop)
 
@@ -151,6 +154,20 @@ async function main() {
     if (dry) console.log('\nNothing written. Run without --dry to apply.');
     return;
   }
+  if (cmd === 'import' && rest[0] === 'linkedin') {
+    const source = rest.slice(1).find((x) => !x.startsWith('--'));
+    if (!source) return console.error('Usage: tekjobs import linkedin <path to the export zip or unpacked folder> [--since YYYY-MM-DD] [--everyone] [--no-people] [--no-snippets] [--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'), writeSnippets: !rest.includes('--no-snippets'), dry: rest.includes('--dry') };
+    if (rest.includes('--preview')) return console.log(JSON.stringify(li.preview(source, o), null, 2));
+    const s = li.runImport(source, o);
+    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)`);
+    console.log(`  Copy panel: ${s.snippets.added} answers added under "From LinkedIn"`);
+    if (!s.dry) console.log(`  Index: ${s.indexPath}. Job notes now show who you know at each company.`);
+    return;
+  }
   if (cmd === 'serve') return run(process.execPath, [path.join(ROOT, 'app', 'server', 'index.mjs')]);
   if (cmd === 'mcp') return run(process.execPath, [path.join(ROOT, 'app', 'server', 'mcp.mjs')]);
   console.error(`unknown command "${cmd}"\n`); console.log(HELP); process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurtekb/tekjobs",
-  "version": "0.27.1",
+  "version": "0.29.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",

package/scraper/config.mjs

@@ -58,6 +58,8 @@ export const P = {
   runsLog: path.join(DATA_DIR, 'runs.log'),
   // What each board and feed did the last time the scan tried it (scraper/health.mjs).
   health: path.join(DATA_DIR, 'board-health.json'),
+  // The index the LinkedIn import builds: connections by company, threads by person (scraper/linkedin.mjs).
+  linkedin: path.join(DATA_DIR, 'linkedin.json'),
 };
 
 export const ALL_ATS = ['greenhouse', 'lever', 'ashby', 'workday', 'rippling', 'smartrecruiters', 'workable', 'bamboohr', 'breezy', 'personio', 'teamtailor', 'eightfold', 'atlassian', 'github', 'spotify', 'amazon', 'google', 'apple'];

package/scraper/linkedin.mjs

@@ -0,0 +1,207 @@
+// Reading a LinkedIn data export (the "larger archive" from linkedin.com/mypreferences/d/download-my-data),
+// as a zip or an unpacked folder, into the few things a job search can use: who you know at which company,
+// who has written to you lately, the answers you have typed into application forms, what you applied to and
+// saved. Nothing here writes; app/server/linkedin-import.mjs does, into the profile folder only. The archive
+// is read in place and never copied. Files this module does not name (ads, reactions, searches, phone numbers,
+// birth date, addresses) are never opened.
+import fs from 'node:fs';
+import path from 'node:path';
+import { openZip } from './zip.mjs';
+
+// ---------------- csv ----------------
+/** RFC-4180-ish: quoted cells with commas, quotes and newlines inside; CRLF or LF. */
+export function parseCsv(text) {
+  const rows = []; let row = [], cell = '', q = false;
+  const s = String(text).replace(/^/, '');
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q) { if (c === '"') { if (s[i + 1] === '"') { cell += '"'; i++; } else q = false; } else cell += c; }
+    else if (c === '"') q = true;
+    else if (c === ',') { row.push(cell); cell = ''; }
+    else if (c === '\n') { row.push(cell.replace(/\r$/, '')); rows.push(row); row = []; cell = ''; }
+    else cell += c;
+  }
+  if (cell !== '' || row.length) { row.push(cell.replace(/\r$/, '')); rows.push(row); }
+  return rows.filter((r) => r.some((c) => String(c).trim() !== ''));
+}
+
+/** Rows as objects keyed by the header. Connections.csv opens with a three-line note before its header. */
+export function table(text) {
+  let s = String(text).replace(/^/, '');
+  if (/^Notes?:/i.test(s)) s = s.replace(/^[\s\S]*?\n\n/, '');
+  const rows = parseCsv(s);
+  if (!rows.length) return [];
+  const [head, ...data] = rows;
+  const keys = head.map((h) => h.trim());
+  return data.map((r) => Object.fromEntries(keys.map((k, i) => [k, (r[i] ?? '').trim()])));
+}
+
+// ---------------- names ----------------
+const SUFFIX = /\b(inc|incorporated|llc|ltd|limited|corp|corporation|co|company|plc|gmbh|ag|sa|bv|technologies|technology|labs|group|holdings|the)\b/g;
+/** "Northwind Traders, Inc." and "northwind traders" meet in the middle. */
+export function companyKey(name = '') {
+  const base = String(name).toLowerCase().replace(/\.(com|io|ai|co|jobs|org|net|dev|app)\b/g, ' ').replace(/&/g, ' and ').replace(/[^a-z0-9]+/g, ' ').replace(/\s+/g, ' ').trim();
+  const stripped = base.replace(SUFFIX, ' ').replace(/\s+/g, ' ').trim();
+  // "Group O" must not become "o": when the suffix rule eats the name, keep the name.
+  return stripped.length >= 3 ? stripped : base;
+}
+/** Two keys name the same company when equal, or when one is the other's first word(s) ("amazon", "amazon web services"). */
+export function sameCompany(a, b) {
+  if (!a || !b) return false;
+  if (a === b) return true;
+  const [s, l] = a.length <= b.length ? [a, b] : [b, a];
+  return s.length >= 4 && l.startsWith(s + ' ');
+}
+const RECRUITER = /recruit|talent|sourc|people (partner|ops|operations)|staffing|head ?hunter|acquisition/i;
+const HIRING = /hiring manager|engineering manager|head of|director|vp\b|vice president|cto|chief|founder|lead\b|manager/i;
+export function roleGuess(title = '') {
+  if (RECRUITER.test(title)) return 'recruiter';
+  if (HIRING.test(title)) return 'hiring-manager';
+  return 'other';
+}
+
+// ---------------- reading ----------------
+const WANT = {
+  connections: ['Connections.csv'],
+  messages: ['messages.csv'],
+  invitations: ['Invitations.csv'],
+  applications: [/^Jobs\/Job Applications(_\d+)?\.csv$/],
+  savedJobs: [/^Jobs\/Saved Jobs(_\d+)?\.csv$/],
+  preferences: ['Jobs/Job Seeker Preferences.csv'],
+  answers: ['Jobs/Job Applicant Saved Answers.csv', /^Job Applicant Saved Screening Question Responses(_\d+)?\.csv$/],
+  profile: ['Profile.csv'],
+  positions: ['Positions.csv'],
+  skills: ['Skills.csv'],
+};
+
+/** Open a zip or a folder; returns a reader with the export's file names and a text reader. */
+export function openExport(source) {
+  const p = path.resolve(source);
+  if (!fs.existsSync(p)) throw Object.assign(new Error(`No such file or folder: ${p}`), { status: 400 });
+  if (fs.statSync(p).isDirectory()) {
+    const names = [];
+    const walk = (dir, rel = '') => { for (const f of fs.readdirSync(dir)) { const full = path.join(dir, f); const r = rel ? `${rel}/${f}` : f; if (fs.statSync(full).isDirectory()) walk(full, r); else names.push(r); } };
+    walk(p);
+    // A folder that holds the export inside one top-level directory (as some unzippers make) still works.
+    const prefix = names.includes('Connections.csv') ? '' : (names.find((n) => n.endsWith('/Connections.csv')) || '').replace(/Connections\.csv$/, '');
+    return { source: p, kind: 'folder', names: names.filter((n) => n.startsWith(prefix)).map((n) => n.slice(prefix.length)), readText: (n) => fs.readFileSync(path.join(p, prefix + n), 'utf8') };
+  }
+  const zip = openZip(p);
+  const prefix = zip.has('Connections.csv') ? '' : (zip.names.find((n) => n.endsWith('/Connections.csv')) || '').replace(/Connections\.csv$/, '');
+  return { source: p, kind: 'zip', names: zip.names.filter((n) => n.startsWith(prefix)).map((n) => n.slice(prefix.length)), readText: (n) => zip.readText(prefix + n) };
+}
+
+const matches = (name, pats) => pats.some((q) => (q instanceof RegExp ? q.test(name) : q === name));
+
+/** The export's useful tables, each as an array of row objects; missing files give empty tables. */
+export function readExport(source) {
+  const ex = openExport(source);
+  if (!ex.names.some((n) => matches(n, WANT.connections)) && !ex.names.some((n) => matches(n, WANT.messages))) {
+    throw Object.assign(new Error(`${ex.source} does not look like a LinkedIn data export: no Connections.csv or messages.csv. Request the larger archive at linkedin.com/mypreferences/d/download-my-data.`), { status: 400 });
+  }
+  const out = { source: ex.source, kind: ex.kind, files: [] };
+  for (const [key, pats] of Object.entries(WANT)) {
+    const names = ex.names.filter((n) => matches(n, pats)).sort();
+    out.files.push(...names);
+    out[key] = names.flatMap((n) => table(ex.readText(n)));
+  }
+  return out;
+}
+
+// ---------------- the index ----------------
+// LinkedIn writes dates in the member's local time ("9/15/26, 8:03 PM", "22 Sep 2026") and messages in UTC; the
+// calendar day is taken in this machine's zone, so an evening application does not slip to the next day.
+const day = (s) => { const t = new Date(String(s || '').replace(/ (AM|PM)$/i, ' $1')); if (isNaN(t.getTime())) return ''; const p = (n) => String(n).padStart(2, '0'); return `${t.getFullYear()}-${p(t.getMonth() + 1)}-${p(t.getDate())}`; };
+const fullName = (r) => `${r['First Name'] || ''} ${r['Last Name'] || ''}`.replace(/\s+/g, ' ').trim();
+const clip = (s, n) => { const t = String(s || '').replace(/\s+/g, ' ').trim(); return t.length > n ? t.slice(0, n - 1) + '…' : t; };
+
+/**
+ * Everything the app needs later, in one JSON the size of a small spreadsheet: connections with a company key,
+ * conversations and invitations since `since`, applications, saved jobs, the saved form answers. Message text is
+ * kept only for messages since `since`, clipped, so the file stays about your search and not your history.
+ */
+export function buildIndex(ex, { since = '', now = new Date() } = {}) {
+  const self = ex.profile?.[0] ? fullName(ex.profile[0]) : '';
+  const selfKey = self.toLowerCase();
+  const connections = (ex.connections || []).filter((r) => fullName(r)).map((r) => ({
+    name: fullName(r), url: r.URL || '', email: r['Email Address'] || '', company: r.Company || '', companyKey: companyKey(r.Company), title: r.Position || '', connectedOn: day(r['Connected On']),
+  }));
+  const byUrl = new Map(connections.filter((c) => c.url).map((c) => [c.url.replace(/\/$/, ''), c]));
+  const byName = new Map(connections.map((c) => [c.name.toLowerCase(), c]));
+  const look = (name, url) => byUrl.get(String(url || '').replace(/\/$/, '')) || byName.get(String(name || '').toLowerCase()) || null;
+
+  const recent = (d) => !since || (d && d >= since);
+  const convs = new Map();
+  for (const m of ex.messages || []) {
+    const d = day(m.DATE);
+    if (!recent(d)) continue;
+    const id = m['CONVERSATION ID'] || `${m.FROM}|${m.TO}`;
+    const c = convs.get(id) || { id, title: m['CONVERSATION TITLE'] || '', with: new Map(), first: d, last: d, count: 0, messages: [] };
+    c.count++; if (d < c.first) c.first = d; if (d > c.last) c.last = d;
+    const from = String(m.FROM || '').trim(), fromUrl = String(m['SENDER PROFILE URL'] || '').trim();
+    const outgoing = selfKey && from.toLowerCase() === selfKey;
+    if (!outgoing && from) c.with.set(fromUrl || from, { name: from, url: fromUrl });
+    for (const [n, u] of String(m.TO || '').split(',').map((t, i) => [t.trim(), (String(m['RECIPIENT PROFILE URLS'] || '').split(',')[i] || '').trim()])) { if (n && (!selfKey || n.toLowerCase() !== selfKey)) c.with.set(u || n, { name: n, url: u }); }
+    c.messages.push({ date: d, from, outgoing, subject: clip(m.SUBJECT, 120), text: clip(m.CONTENT, 240) });
+    convs.set(id, c);
+  }
+  const threads = [...convs.values()].map((c) => ({ ...c, with: [...c.with.values()].map((w) => ({ ...w, ...(look(w.name, w.url) ? { company: look(w.name, w.url).company, title: look(w.name, w.url).title } : {}) })), messages: c.messages.sort((a, b) => a.date.localeCompare(b.date)) })).sort((a, b) => b.last.localeCompare(a.last));
+
+  const invitations = (ex.invitations || []).map((r) => ({ from: r.From || '', to: r.To || '', sentAt: day(r['Sent At']), direction: r.Direction || '', message: clip(r.Message, 240), url: r.Direction === 'INCOMING' ? (r.inviterProfileUrl || '') : (r.inviteeProfileUrl || '') })).filter((i) => recent(i.sentAt));
+  const applications = (ex.applications || []).map((r) => ({ date: day(r['Application Date']), company: r['Company Name'] || '', companyKey: companyKey(r['Company Name']), title: r['Job Title'] || '', url: r['Job Url'] || '', resume: r['Resume Name'] || '' })).filter((a) => a.date).sort((a, b) => b.date.localeCompare(a.date));
+  const savedJobs = (ex.savedJobs || []).map((r) => ({ date: day(r['Saved Date']), company: r['Company Name'] || '', title: r['Job Title'] || '', url: r['Job Url'] || '' })).filter((s) => s.date).sort((a, b) => b.date.localeCompare(a.date));
+  const seenQ = new Set();
+  const answers = (ex.answers || []).map((r) => ({ question: String(r.Question || '').trim(), answer: String(r.Answer || '').trim() })).filter((a) => a.question && a.answer && !seenQ.has(a.question.toLowerCase()) && seenQ.add(a.question.toLowerCase()));
+  const pref = ex.preferences?.[0] || {};
+  const preferences = pref ? { locations: pref.Locations || '', industries: pref.Industries || '', companySize: pref['Company Employee Count'] || '', jobTypes: pref['Preferred Job Types'] || '', titles: pref['Job Titles'] || '', openToRecruiters: pref['Open To Recruiters'] || '', dreamCompanies: pref['Dream Companies'] || '', startTime: pref['Preferred Start Time Range'] || '' } : {};
+
+  return {
+    built: now.toISOString(), since, source: ex.source, self,
+    counts: { connections: connections.length, threads: threads.length, invitations: invitations.length, applications: applications.length, savedJobs: savedJobs.length, answers: answers.length },
+    connections, threads, invitations, applications, savedJobs, answers, preferences,
+  };
+}
+
+// ---------------- questions the app asks the index ----------------
+/** The connections at one company, by key equality or containment either way ("Vanta" and "Vanta Inc"). */
+export function warmPaths(index, company) {
+  const k = companyKey(company);
+  if (!k || !index?.connections) return { company, count: 0, people: [] };
+  const people = index.connections.filter((c) => sameCompany(c.companyKey, k)).sort((a, b) => (roleGuess(a.title) === 'recruiter' ? -1 : 0) - (roleGuess(b.title) === 'recruiter' ? -1 : 0) || b.connectedOn.localeCompare(a.connectedOn));
+  return { company, count: people.length, people: people.map((c) => ({ name: c.name, title: c.title, url: c.url, connectedOn: c.connectedOn, role: roleGuess(c.title) })) };
+}
+
+/**
+ * Who has written to you lately, one entry per person, with what their connection record says they do.
+ * These become People notes when the import is asked to write them.
+ */
+export function peopleCandidates(index, { since = index?.since || '' } = {}) {
+  const out = new Map();
+  const add = (w, date, via, gist) => {
+    if (!w.name || (index.self && w.name.toLowerCase() === index.self.toLowerCase())) return;
+    const key = (w.url || w.name).toLowerCase();
+    const c = out.get(key) || { name: w.name, url: w.url || '', company: w.company || '', title: w.title || '', role: roleGuess(w.title), first: date, last: date, count: 0, log: [] };
+    c.count++; if (date && (!c.first || date < c.first)) c.first = date; if (date && date > c.last) c.last = date;
+    if (gist) c.log.push({ date, via, text: gist });
+    if (!c.company && w.company) { c.company = w.company; c.title = w.title || c.title; c.role = roleGuess(c.title); }
+    out.set(key, c);
+  };
+  for (const t of index.threads || []) {
+    if (since && t.last < since) continue;
+    for (const w of t.with) for (const m of t.messages) if (!m.outgoing && m.from === w.name) add(w, m.date, 'linkedin message', m.subject ? `${m.subject}: ${m.text}` : m.text);
+  }
+  for (const i of index.invitations || []) {
+    if (since && i.sentAt < since) continue;
+    const who = i.direction === 'INCOMING' ? { name: i.from, url: i.url } : { name: i.to, url: i.url };
+    const rec = (index.connections || []).find((c) => (who.url && c.url === who.url) || c.name.toLowerCase() === who.name.toLowerCase());
+    add({ ...who, company: rec?.company, title: rec?.title }, i.sentAt, i.direction === 'INCOMING' ? 'linkedin invitation received' : 'linkedin invitation sent', i.message);
+  }
+  return [...out.values()].map((c) => ({ ...c, log: c.log.sort((a, b) => a.date.localeCompare(b.date)).slice(-8) })).sort((a, b) => b.last.localeCompare(a.last));
+}
+
+/** Saved form answers as copy-panel items, minus labels the panel already has. */
+export function snippetSuggestions(index, existing = []) {
+  const have = new Set(existing.map((s) => String(s.label || '').toLowerCase()));
+  const label = (q) => clip(q.replace(/[?:]+$/, ''), 60);
+  return (index.answers || []).filter((a) => !/^(yes|no|y|n)$/i.test(a.answer)).map((a) => ({ group: 'From LinkedIn', label: label(a.question), value: a.answer })).filter((s) => !have.has(s.label.toLowerCase()));
+}

package/scraper/zip.mjs

@@ -0,0 +1,41 @@
+// A small reader for ordinary zip files (stored or deflated entries, no encryption, under 4 GB), enough to read
+// a LinkedIn data export in place without unpacking it or adding a dependency.
+import fs from 'node:fs';
+import zlib from 'node:zlib';
+
+const EOCD = 0x06054b50, CENTRAL = 0x02014b50, LOCAL = 0x04034b50;
+
+/** The entries of a zip file: name, sizes, and a reader for each. */
+export function openZip(file) {
+  const buf = fs.readFileSync(file);
+  // The end-of-central-directory record is in the last 64 KB (its comment can push it back from the end).
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65557); i--) { if (buf.readUInt32LE(i) === EOCD) { eocd = i; break; } }
+  if (eocd < 0) throw new Error(`${file} is not a zip file`);
+  const count = buf.readUInt16LE(eocd + 10);
+  let p = buf.readUInt32LE(eocd + 16);
+  const entries = new Map();
+  for (let i = 0; i < count; i++) {
+    if (buf.readUInt32LE(p) !== CENTRAL) throw new Error(`${file}: bad central directory`);
+    const method = buf.readUInt16LE(p + 10);
+    const compressed = buf.readUInt32LE(p + 20);
+    const size = buf.readUInt32LE(p + 24);
+    const nameLen = buf.readUInt16LE(p + 28), extraLen = buf.readUInt16LE(p + 30), commentLen = buf.readUInt16LE(p + 32);
+    const offset = buf.readUInt32LE(p + 42);
+    // Some Windows archivers write backslashes in entry names; the zip standard, and LinkedIn, use slashes.
+    const name = buf.toString('utf8', p + 46, p + 46 + nameLen).replace(/\\/g, '/');
+    entries.set(name, { name, method, compressed, size, offset });
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  const read = (name) => {
+    const e = entries.get(name);
+    if (!e) throw new Error(`${name} is not in ${file}`);
+    if (buf.readUInt32LE(e.offset) !== LOCAL) throw new Error(`${file}: bad local header for ${name}`);
+    const start = e.offset + 30 + buf.readUInt16LE(e.offset + 26) + buf.readUInt16LE(e.offset + 28);
+    const raw = buf.subarray(start, start + e.compressed);
+    if (e.method === 0) return Buffer.from(raw);
+    if (e.method === 8) return zlib.inflateRawSync(raw);
+    throw new Error(`${name}: compression method ${e.method} is not supported`);
+  };
+  return { names: [...entries.keys()], has: (n) => entries.has(n), read, readText: (n) => read(n).toString('utf8') };
+}