six-degrees 0.4.7 → 0.4.9

package/.next/standalone/lib/linkedin-export.js

@@ -6,6 +6,10 @@
 //
 //   people     per profile: when you last messaged, who wrote last, how many
 //              messages (1:1 conversations only). Never a message's text.
+//   conversations  per conversation: who's in it, when it was last active, who
+//              wrote last, how many messages. The text itself only when you turn
+//              on Keep my messages, and then in a file of its own
+//              (app/api/social/messages).
 //   chapters   your jobs (Positions.csv) and the connections made in each
 //   posts      your posts (Shares.csv) and the connections that came the week after
 //   invites    requests to and from you (Invitations.csv), when the export has them
@@ -49,14 +53,29 @@ export function exportDate(s) {
 
 const urlKey = (u) => keyFor({ profile_url: u });
 
+/** You, in messages.csv: the sender in the most conversations. */
+function selfOf(rows = []) {
+  const senders = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    if (!senders.has(from)) senders.set(from, new Set());
+    senders.get(from).add(id);
+  }
+  let self = null;
+  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
+  return self;
+}
+
 /**
  * From messages.csv, per person (by profile): { last, lastFromThem, total, recent }.
  * `self` is you: the sender in the most conversations. Only 1:1 conversations
  * count; group threads say little about one relationship. No text is read.
  */
 export function messageStats(rows = []) {
+  const self = selfOf(rows);
   const convos = new Map();
-  const senders = new Map();
   for (const r of rows) {
     const from = urlKey(r['sender profile url']);
     const id = r['conversation id'];
@@ -69,11 +88,7 @@ export function messageStats(rows = []) {
     c.people.add(from);
     to.forEach((p) => c.people.add(p));
     c.msgs.push({ from, t });
-    if (!senders.has(from)) senders.set(from, new Set());
-    senders.get(from).add(id);
   }
-  let self = null;
-  for (const [who, ids] of senders) if (!self || ids.size > senders.get(self).size) self = who;
   let asOf = 0;
   const people = new Map();
   for (const c of convos.values()) {
@@ -96,6 +111,104 @@ export function messageStats(rows = []) {
   return { self, asOf: asOf || null, people };
 }
 
+/**
+ * Every conversation in messages.csv you're part of, one record each:
+ * { id, title, people, group, messages: [{ t, fromMe, text }] }, messages oldest
+ * first. `people` is everyone but you, by profile key; more than one makes it a
+ * group. You are found the way messageStats finds you. The words (the subject,
+ * when there is one, then the message) are read only with keepText: without it
+ * a message is a date and who sent it, and the title (a group's name) is left
+ * out too.
+ */
+export function buildConversations(rows = [], { keepText = false } = {}) {
+  const self = selfOf(rows);
+  const convos = new Map();
+  for (const r of rows) {
+    const from = urlKey(r['sender profile url']);
+    const id = r['conversation id'];
+    if (!id || !from) continue;
+    const t = exportDate(r.date);
+    if (t == null) continue;
+    if (!convos.has(id)) convos.set(id, { id, title: '', everyone: new Set(), messages: [] });
+    const c = convos.get(id);
+    c.everyone.add(from);
+    String(r['recipient profile urls'] || '').split(/[,;\s]+/).filter(Boolean).forEach((u) => c.everyone.add(urlKey(u)));
+    const m = { t, fromMe: from === self };
+    if (keepText) {
+      m.text = [r.subject, r.content].map((x) => String(x || '').trim()).filter(Boolean).join('\n\n');
+      if (!c.title && r['conversation title']) c.title = String(r['conversation title']).trim();
+    }
+    c.messages.push(m);
+  }
+  const conversations = [];
+  for (const c of convos.values()) {
+    if (!c.everyone.has(self)) continue;
+    const people = [...c.everyone].filter((p) => p && p !== self).sort();
+    if (!people.length) continue;
+    c.messages.sort((a, b) => a.t - b.t);
+    const out = { id: c.id, people, group: people.length > 1, messages: c.messages };
+    if (keepText) out.title = c.title;
+    conversations.push(out);
+  }
+  return { self, conversations };
+}
+
+/** What the Conversations list keeps of one conversation, never any words: { id, people, group, last, lastFromThem, count }. */
+export function conversationSummary(c) {
+  const last = c.messages[c.messages.length - 1];
+  return {
+    id: c.id,
+    people: c.people,
+    group: c.group,
+    last: last ? last.t : null,
+    lastFromThem: last ? !last.fromMe : null,
+    count: c.messages.length,
+  };
+}
+
+/**
+ * The Conversations list: the export's conversations with what the live sync
+ * adds (unread, the thread's link, and a newer last message), plus a
+ * conversation for each person the sync found and the export doesn't have yet
+ * (id `live:<key>`, count unknown).
+ */
+export function conversationList(list = [], live = {}) {
+  const out = (Array.isArray(list) ? list : []).map((c) => ({ ...c, unread: null, threadUrl: null }));
+  const oneToOne = new Map();
+  for (const c of out) {
+    if (c.group || c.people?.length !== 1) continue;
+    const had = oneToOne.get(c.people[0]);
+    if (!had || (c.last || 0) > (had.last || 0)) oneToOne.set(c.people[0], c);
+  }
+  for (const [key, v] of Object.entries(live || {})) {
+    if (!v || typeof v !== 'object') continue;
+    let c = oneToOne.get(key);
+    if (!c) {
+      c = { id: `live:${key}`, people: [key], group: false, last: null, lastFromThem: null, count: null, unread: null, threadUrl: null };
+      out.push(c);
+      oneToOne.set(key, c);
+    }
+    if (v.last && (!c.last || v.last > c.last)) {
+      c.last = v.last;
+      if (typeof v.lastFromThem === 'boolean') c.lastFromThem = v.lastFromThem;
+    }
+    c.unread = Number.isFinite(v.unread) ? v.unread : c.unread;
+    c.threadUrl = v.threadUrl || c.threadUrl;
+  }
+  return out;
+}
+
+/**
+ * The order the Conversations list shows: waiting on you (they wrote last, one
+ * to one) first, then your S and A tier people, then the most recent.
+ * `tierOf(conversation)` gives its best tier.
+ */
+export function sortConversations(list = [], tierOf = () => null) {
+  const waiting = (c) => (!c.group && c.lastFromThem === true ? 0 : 1);
+  const tier = (c) => ({ S: 0, A: 1 }[tierOf(c)] ?? 2);
+  return [...list].sort((a, b) => waiting(a) - waiting(b) || tier(a) - tier(b) || (b.last || 0) - (a.last || 0));
+}
+
 /** Warm (in the last 30 days, or 3+ in 90), cool (within a year), dormant (longer ago), or never. */
 export function warmthOf(stat, asOf) {
   if (!stat || !stat.total) return 'never';
@@ -154,3 +267,60 @@ export function invitationSplit(rows = []) {
   }
   return { incoming, outgoing, total: incoming + outgoing };
 }
+
+const nameKey = (s) => String(s || '').split(',')[0].normalize('NFD').replace(/[̀-ͯ]/g, '')
+  .toLowerCase().replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+const THREAD_LINK = /^https:\/\/www\.linkedin\.com\/messaging\/[\w\-/%=.]*$/;
+
+/** A link to a LinkedIn messaging thread, or null: nothing else is ever put behind "Open on LinkedIn". */
+export function threadLink(u) {
+  const v = String(u || '').trim();
+  return THREAD_LINK.test(v) ? v : null;
+}
+
+/** A message the live sync read, as it's kept: { t, fromMe, text }, or null. */
+function previewOf(p) {
+  if (!p || typeof p !== 'object') return null;
+  const t = Number(p.t) || null;
+  const text = typeof p.text === 'string' ? p.text.slice(0, 20000) : null;
+  if (!t && !text) return null;
+  return { t, fromMe: p.fromMe === true, text };
+}
+
+/**
+ * The live messages sync's people, matched to your connections. LinkedIn's
+ * messaging gives a member link (/in/ACoA…) your connections list doesn't have,
+ * so a person is matched by their link when it's the same, otherwise by their
+ * name when exactly one connection has it. Only the match is kept, never the
+ * name. Returns { live: { connectionKey: { last, unread, threadUrl,
+ * lastFromThem, preview } }, unmatched }; the caller decides whether the
+ * preview's words are kept.
+ */
+export function matchLive(incoming = {}, connections = []) {
+  const byUrl = new Map();
+  const byName = new Map();
+  for (const c of connections) {
+    const key = keyFor(c);
+    byUrl.set(key, key);
+    const n = nameKey(c.name);
+    if (n) byName.set(n, byName.has(n) ? null : key);   // null: two people share it
+  }
+  const live = {};
+  let unmatched = 0;
+  for (const [url, v] of Object.entries(incoming || {})) {
+    if (!v || typeof v !== 'object') continue;
+    const key = byUrl.get(keyFor({ profile_url: url })) || byName.get(nameKey(v.name)) || null;
+    if (!key) { unmatched += 1; continue; }
+    const last = Number(v.last) || null;
+    if (live[key] && (live[key].last || 0) >= (last || 0)) continue;
+    live[key] = {
+      last,
+      unread: Number.isFinite(Number(v.unread)) && v.unread !== null ? Number(v.unread) : null,
+      threadUrl: threadLink(v.threadUrl),
+      lastFromThem: typeof v.lastFromThem === 'boolean' ? v.lastFromThem : null,
+      preview: previewOf(v.preview),
+    };
+  }
+  return { live, unmatched };
+}

package/.next/standalone/lib/scoring.js

@@ -58,6 +58,31 @@
 //    themselves are tables, fingerprinted below.)
 export const SCORING_VERSION = 6;
 
+/**
+ * A function of one piece of text, remembered: the same text gets the answer
+ * it got the first time, without the work again. Reading a headline or a
+ * company name runs hundreds of patterns (every name on the curated list and
+ * the public dataset is tried against it), and a network hands over the same
+ * text again and again: everyone at a company writes its name, and a page
+ * groups, links and filters the same people several times over. At 30,000
+ * people each of those passes took seconds, and Paths 10 to 20 to open.
+ *
+ * Only for a function whose answer depends on nothing but the text, and whose
+ * answer nobody changes afterwards (readRoles hands out copies for that). It
+ * keeps up to `max` answers and drops the oldest first, so it can't grow
+ * without end on a server that stays up for weeks.
+ */
+export function rememberByText(read, max = 100000) {
+  const answers = new Map();
+  return (text) => {
+    if (answers.has(text)) return answers.get(text);
+    const answer = read(text);
+    if (answers.size >= max) answers.delete(answers.keys().next().value);
+    answers.set(text, answer);
+    return answer;
+  };
+}
+
 // ── title ────────────────────────────────────────────────────────────────────
 
 export const LEVELS = {
@@ -1008,8 +1033,16 @@ function heldAfterComma(part) {
  * An audience of their own is a role of its own (`audience`), with no company.
  */
 export function readRoles(headline = '', role = '') {
+  // Copies, since rolesWithCompanies fills in a role's company on what it gets.
+  return rolesIn(String(headline || role || '')).map((r) => ({ ...r, title: { ...r.title } }));
+}
+
+// Only the text is read (the headline, else the role), so each is read once.
+const rolesIn = rememberByText(readRolesOf);
+
+function readRolesOf(text) {
   const out = [];
-  const parts = headlineParts(headline || role);
+  const parts = headlineParts(text);
   let last = null;   // the last role a title gave: { role, i, rank }
   let retiredNext = false;   // a lone "Retired" before any role: the next one's
   for (const [i, raw] of parts.entries()) {
@@ -2033,6 +2066,14 @@ const PLATFORMS = new Set(['tech', 'media', 'entertainment']);
 
 /** A company name as people write it → one clean, canonical name (or null). */
 export function cleanCompany(raw) {
+  return cleanNameOf(String(raw || ''));
+}
+
+// Read once per name: everyone at a company writes it, and each read tries the
+// whole curated list and public dataset against it.
+const cleanNameOf = rememberByText(readCompanyName);
+
+function readCompanyName(raw) {
   // NFKC first: styled letters ("𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁") and full-width punctuation ("｜")
   // become plain ones. Private-use glyphs go with the emoji: the Apple logo
   // () after "Apple" used to leave it unread.

package/.next/standalone/lib/social-store.js

@@ -0,0 +1,73 @@
+// Where the Social tab keeps what it knows, per profile, in the data folder:
+//
+//   social-<profile>.json           numbers and dates (app/api/social): who you
+//                                   messaged, when, who wrote last, the list of
+//                                   conversations. Never any words.
+//   social-messages-<profile>.json  the messages themselves, only while Keep my
+//                                   messages is on (app/api/social/messages).
+//
+// Two files so that turning Keep my messages off, or Forget it, deletes the
+// words by deleting one file, and so the everyday file the Galaxy and the
+// Social tab read stays small however many messages there are. Neither is in
+// "Save a copy of my network": that carries an allow-list of files
+// (lib/data-folder.js TRAVELLING_FILES) and these aren't on it.
+
+import { readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { dataDir } from './db-client';
+import { resolveProfile } from './profile';
+
+// The last messages file read, while it's unchanged (readMessages).
+const cache = { file: null, mtimeMs: 0, size: 0, data: null };
+
+/** The Social tab's files for the profile in use, or null before there is one. */
+export function socialFiles() {
+  const me = resolveProfile({ create: false });
+  if (!me?.id || !/^[\w-]+$/.test(String(me.id))) return null;
+  const dir = dataDir();
+  const messages = path.join(dir, `social-messages-${me.id}.json`);
+  return {
+    profileId: me.id,
+    social: path.join(dir, `social-${me.id}.json`),
+    messages,
+    // An import's messages arrive in parts (each request stays under the 10 MB
+    // middleware reads); they gather here and replace `messages` at the end.
+    incoming: `${messages}.incoming`,
+  };
+}
+
+export function readJson(file, fallback = null) {
+  try { return JSON.parse(readFileSync(file, 'utf8')) ?? fallback; } catch { return fallback; }
+}
+
+/** Written whole or not at all: a crash mid-write never leaves half a file. */
+export function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(value));
+  renameSync(tmp, file);
+  if (cache.file === file) cache.file = null;
+}
+
+/** The kept messages and their live-sync previews, or empty ones. */
+export function readMessages(file) {
+  // Kept in memory while the file is unchanged: a long history is read once,
+  // not on every page of a thread or every letter typed in the search box.
+  let st;
+  try { st = statSync(file); } catch { return { threads: {}, previews: {} }; }
+  if (cache.file === file && cache.mtimeMs === st.mtimeMs && cache.size === st.size) return cache.data;
+  const raw = readJson(file, {});
+  const data = {
+    threads: raw?.threads && typeof raw.threads === 'object' ? raw.threads : {},
+    previews: raw?.previews && typeof raw.previews === 'object' ? raw.previews : {},
+  };
+  Object.assign(cache, { file, mtimeMs: st.mtimeMs, size: st.size, data });
+  return data;
+}
+
+/** The messages gone: the kept file and any import still arriving. */
+export function deleteMessages(files) {
+  if (!files) return;
+  rmSync(files.messages, { force: true });
+  rmSync(files.incoming, { force: true });
+  cache.file = null;
+}

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "six-degrees",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "six-degrees",
-      "version": "0.4.7",
+      "version": "0.4.9",
       "license": "MIT",
       "os": [
         "darwin",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",