@timurtekb/tekjobs 0.48.0 → 0.50.0

package/app/dist/index.html

@@ -8,7 +8,7 @@
     <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-BAca4QLI.js"></script>
+    <script type="module" crossorigin src="/assets/index-DmICnwI8.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DXU1rm72.css">
   </head>
   <body>

package/app/server/calendar-check.mjs

@@ -0,0 +1,150 @@
+// Calendar check: a read-only pass over the person's Google Calendar for interviews and other events about jobs
+// on their board, through the same local CLI that writes letters and reads mail, with its Google Calendar
+// connector. The run is boxed: only the connector's read tools are allowed and every write tool (create, update,
+// delete, respond) plus Bash/Write/Edit are denied by name, so a run can read a calendar and nothing else.
+//
+// The model finds and extracts; everything after that is ordinary code. Each event is matched to a job note by
+// company, then shown as a proposal. Confirming puts the event's time into the note's "Interview on" field (so
+// the Calendar page and the .ics feed carry it), moves a note that is not yet interviewing to interviewing, and
+// records the event on the note. Nothing is ever written to the calendar.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DATA_DIR } from '../../scraper/config.mjs';
+import { sameCompany } from '../../scraper/linkedin.mjs';
+import * as store from './store.mjs';
+import { runLLM, runnerConfig } from './cover-letter.mjs';
+
+const FILE = path.join(DATA_DIR, 'calendar-check.json');
+const CAL = 'mcp__claude_ai_Google_Calendar__';
+export const READ_TOOLS = ['list_calendars', 'list_events', 'search_events', 'get_event'].map((t) => `${CAL}${t}`);
+export const DENY_TOOLS = ['create_event', 'update_event', 'delete_event', 'respond_to_event', 'suggest_time'].map((t) => `${CAL}${t}`)
+  .concat(['Bash', 'Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'WebFetch', 'WebSearch']);
+export const KINDS = ['interview', 'screen', 'onsite', 'offer-call', 'recruiter-call', 'deadline', 'other'];
+const ACTIVE = new Set(['reviewing', 'applying', 'ready', 'applied', 'interviewing', 'offer']);
+
+function load() { try { return JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { return { lastRun: null, days: null, items: [] }; } }
+function persist(d) { fs.mkdirSync(DATA_DIR, { recursive: true }); fs.writeFileSync(FILE, JSON.stringify(d, null, 2)); }
+
+/** The extraction prompt. The companies are a hint for recognition, not a filter: an interview at a company with no note is still reported. */
+export function prompt({ days = 21, back = 7, companies = [] } = {}) {
+  return `You are checking a job seeker's Google Calendar for events about their job search. Use ONLY the Google Calendar list, search and get tools. Do not create, update, delete or respond to anything.
+
+Look at every event from ${back} days ago to ${days} days ahead, on every calendar list_calendars returns. Report an event when its title, description, location or attendees show it is about a job application: an interview, a phone or video screen, an onsite, a take-home review, a recruiter or hiring-manager call, an offer call, or a deadline for an application. Skip everything else (meetings at the person's current job, personal events, reminders that name no company).
+
+Decide the company from the title, the description, the organiser's or attendees' email domains, or the meeting link. Use the exact start time the event has.
+
+Output ONLY a JSON array, no prose, no code fence, one object per event:
+{"company": "company name", "role": "role title if the event or its description names one, else empty string", "kind": "${KINDS.join('|')}", "start": "YYYY-MM-DD HH:MM in the person's own time zone", "end": "YYYY-MM-DD HH:MM or empty", "summary": "the event title", "gist": "one plain sentence on what it is", "with": "the other people on it by name, comma separated, or empty", "location": "the meeting link or place, or empty", "eventId": "the event id", "calendar": "the calendar's name"}
+
+If nothing matches, output [].${companies.length ? `
+
+The person's own records show applications in flight at these companies (others may exist): ${companies.join(', ')}.` : ''}`;
+}
+
+const WHEN = /^(\d{4}-\d{2}-\d{2})(?:[ T](\d{1,2}):(\d{2}))?/;
+const when = (s) => { const m = String(s || '').trim().match(WHEN); return m ? `${m[1]}${m[2] ? ` ${m[2].padStart(2, '0')}:${m[3]}` : ''}` : ''; };
+
+/** The model's text into clean entries, or an error that says what came back. */
+export function parseOutput(text) {
+  const s = String(text || '');
+  const a = s.indexOf('['), b = s.lastIndexOf(']');
+  if (a < 0 || b < a) throw new Error(`The runner returned no JSON array. It said: ${s.slice(0, 200).replace(/\s+/g, ' ')}`);
+  let arr; try { arr = JSON.parse(s.slice(a, b + 1)); } catch (e) { throw new Error(`The runner's JSON did not parse: ${e.message}`); }
+  if (!Array.isArray(arr)) throw new Error('The runner returned JSON that is not an array.');
+  return arr.filter((m) => m && typeof m === 'object' && m.company && when(m.start)).map((m) => ({
+    id: String(m.eventId || `${m.company}|${m.start}`).trim(), company: String(m.company).trim(), role: String(m.role || '').trim(),
+    kind: KINDS.includes(m.kind) ? m.kind : 'other', start: when(m.start), end: when(m.end), summary: String(m.summary || '').trim().slice(0, 160),
+    gist: String(m.gist || '').trim().slice(0, 300), with: String(m.with || '').trim().slice(0, 200), location: String(m.location || '').trim().slice(0, 300), calendar: String(m.calendar || '').trim().slice(0, 80),
+  }));
+}
+
+const INTERVIEWISH = new Set(['interview', 'screen', 'onsite', 'offer-call']);
+
+/** What confirming an event would do to the note it matched. */
+export function suggestionFor(kind, noteStatus) {
+  if (!noteStatus) return { action: 'none', text: 'No note at this company; the event is noted here only.' };
+  if (kind === 'deadline') return { action: 'deadline', text: 'Puts the date in the note\'s Deadline field.' };
+  if (!INTERVIEWISH.has(kind)) return { action: 'record', text: 'Records the call on the note.' };
+  if (['interviewing', 'offer'].includes(noteStatus)) return { action: 'record', text: 'Records the time in the note\'s Interview on field.' };
+  return { action: 'status', status: 'interviewing', text: 'Moves the note to interviewing and records the time in Interview on.' };
+}
+
+/** Each event matched to the notes: the one note at that company in flight, or a pick among several. */
+export function reconcile(events, notes) {
+  const rank = (n) => (n.status === 'interviewing' || n.status === 'offer' ? 3 : ACTIVE.has(n.status) ? 2 : n.status === 'reviewing' ? 1 : 0);
+  return events.map((e) => {
+    const cands = notes.filter((n) => sameCompany(n.company, e.company)).sort((a, b) => rank(b) - rank(a) || (b.score || 0) - (a.score || 0));
+    const byRole = e.role ? cands.find((n) => n.title.toLowerCase().includes(e.role.toLowerCase()) || e.role.toLowerCase().includes(n.title.toLowerCase())) : null;
+    const note = byRole || (cands.length === 1 || (cands[0] && rank(cands[0]) >= 2) ? cands[0] : null);
+    return {
+      ...e, state: 'pending', match: byRole ? 'role' : note ? 'company' : 'none',
+      noteId: note?.id || '', noteTitle: note?.title || '', noteStatus: note?.status || '',
+      candidates: cands.slice(0, 6).map((n) => ({ id: n.id, title: n.title, status: n.status })),
+      suggestion: suggestionFor(e.kind, note?.status || ''),
+    };
+  }).sort((a, b) => a.start.localeCompare(b.start));
+}
+
+// ---------------- running ----------------
+const run = { running: false, startedAt: null, finishedAt: null, error: '', errorKind: '', days: null, lastOutput: '' };
+export function items() {
+  const d = load();
+  return { ...run, runner: runnerConfig().command, lastRun: d.lastRun, lastDays: d.days, items: d.items || [], pending: (d.items || []).filter((i) => i.state === 'pending') };
+}
+export function start({ days } = {}) {
+  if (run.running) return items();
+  const ahead = Number(days) || 21;
+  Object.assign(run, { running: true, startedAt: new Date().toISOString(), finishedAt: null, error: '', errorKind: '', days: ahead });
+  const notes = store.listJobs();
+  const companies = [...new Set(notes.filter((n) => ACTIVE.has(n.status)).map((n) => n.company))].sort();
+  runLLM(prompt({ days: ahead, companies }), { timeoutMs: 15 * 60 * 1000, extraArgs: ['--allowedTools', ...READ_TOOLS, '--disallowedTools', ...DENY_TOOLS] })
+    .then((text) => {
+      run.lastOutput = String(text).slice(0, 4000);
+      const fresh = reconcile(parseOutput(text), store.listJobs());
+      const cur = load();
+      const known = new Map((cur.items || []).map((i) => [i.id, i]));
+      // An event already confirmed or dismissed keeps that state; a pending one is re-matched against today's notes.
+      const merged = fresh.map((i) => { const k = known.get(i.id); return k && k.state !== 'pending' ? { ...k, ...i, state: k.state, resolved: k.resolved } : i; });
+      for (const k of known.values()) if (!merged.some((i) => i.id === k.id)) merged.push(k);
+      merged.sort((a, b) => (a.start || '').localeCompare(b.start || ''));
+      persist({ lastRun: new Date().toISOString(), days: ahead, items: merged });
+      Object.assign(run, { running: false, finishedAt: new Date().toISOString() });
+    })
+    .catch((e) => Object.assign(run, { running: false, finishedAt: new Date().toISOString(), error: e.message, errorKind: e.kind || 'failed' }));
+  return items();
+}
+
+// ---------------- confirming ----------------
+const fieldEmpty = (id, field) => { try { return !new RegExp(`^- \\*\\*${field}:\\*\\*\\s*\\S`, 'm').test(fs.readFileSync(store.getJob(id).path, 'utf8')); } catch { return false; } };
+const line = (i) => `Calendar, ${i.start}${i.end ? ` to ${i.end.slice(-5)}` : ''} (${i.kind}): ${i.summary || i.gist}${i.with ? `, with ${i.with}` : ''}${i.location ? ` [${i.location}]` : ''}`;
+
+/** The person confirms one event, optionally choosing the note. Writes the time, the status where it applies, and a line on the note. */
+export function confirm(id, { noteId } = {}) {
+  const d = load();
+  const item = (d.items || []).find((i) => i.id === id);
+  if (!item) throw Object.assign(new Error(`No calendar item ${id}`), { status: 404 });
+  const target = noteId || item.noteId;
+  const s = target ? suggestionFor(item.kind, store.getJob(target).status) : suggestionFor(item.kind, '');
+  if (target) {
+    if (s.action === 'status') store.setStatus(target, s.status, 'app');
+    if (s.action === 'deadline') { if (fieldEmpty(target, 'Deadline')) store.saveApplicationDraft(target, { field: 'Deadline', value: item.start.slice(0, 10) }); }
+    else if (INTERVIEWISH.has(item.kind)) {
+      // The latest confirmed interview is the one on the calendar; an earlier round the person wrote by hand gives way to it.
+      const current = (() => { try { return (fs.readFileSync(store.getJob(target).path, 'utf8').match(/^- \*\*Interview on:\*\*\s*(\S.*)$/m) || [])[1] || ''; } catch { return ''; } })();
+      if (!current || item.start > current) store.saveApplicationDraft(target, { field: 'Interview on', value: item.start });
+    }
+    store.addNote(target, line(item), 'app');
+  }
+  const at = new Date().toISOString();
+  item.state = 'confirmed'; item.noteId = target || ''; item.resolved = { at, action: s.action, status: s.status || '' };
+  persist(d);
+  return items();
+}
+export function dismiss(id) {
+  const d = load();
+  const item = (d.items || []).find((i) => i.id === id);
+  if (!item) throw Object.assign(new Error(`No calendar item ${id}`), { status: 404 });
+  item.state = 'dismissed'; item.resolved = { at: new Date().toISOString(), action: 'dismissed' };
+  persist(d);
+  return items();
+}

package/app/server/index.mjs

@@ -10,6 +10,7 @@ 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';
+import * as calcheck from './calendar-check.mjs';
 import { TOOLS } from './mcp.mjs';
 import { buildJournal, renderJournal, writeJournal } from '../../scraper/journal.mjs';
 
@@ -75,6 +76,11 @@ const routes = [
   ['GET', /^\/api\/learned$/, () => store.learned()],
   // The calendar: the dated lines the notes carry. The .ics feed is served outside the JSON routes below.
   ['GET', /^\/api\/calendar$/, () => store.calendar()],
+  // The Google Calendar check: read-only through the local CLI's connector; the person confirms each event.
+  ['GET', /^\/api\/calendar\/items$/, () => calcheck.items()],
+  ['POST', /^\/api\/calendar\/check$/, async (_, __, req) => calcheck.start(await readBody(req))],
+  ['POST', /^\/api\/calendar\/items\/([^/]+)\/confirm$/, async (m, _, req) => calcheck.confirm(decodeURIComponent(m[1]), await readBody(req))],
+  ['POST', /^\/api\/calendar\/items\/([^/]+)\/dismiss$/, (m) => calcheck.dismiss(decodeURIComponent(m[1]))],
   // The day's journal: runs, found, decisions, mail, notes, read from the record. ?date=YYYY-MM-DD for another day.
   ['GET', /^\/api\/journal$/, (_, q) => { const date = q.get('date') || undefined; const j = buildJournal(date); return { ...j, markdown: renderJournal(j) }; }],
   ['POST', /^\/api\/journal$/, async (_, __, req) => { const b = await readBody(req); return writeJournal(b.date || undefined); }],

package/app/server/mcp.mjs

@@ -11,6 +11,7 @@ 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';
+import * as calcheck from './calendar-check.mjs';
 
 // The version a client shows beside the server is the package's, not a constant that goes stale.
 const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version; } catch { return '0.0.0'; } })();
@@ -39,6 +40,8 @@ export const TOOLS = [
   { name: 'summary', description: 'Pipeline counts by status, pay band and kind; last scan; current floor, stretch and score bar.', inputSchema: { type: 'object', properties: {} } },
   { name: 'run_scan', description: 'Start a scan of every board now. It returns at once; the scan runs on its own (it survives this session ending) and takes two to three minutes. Poll scan_status. Pass dry=true to score without writing notes. Pass criteria=<preset name> to score this one run with a named criteria preset instead of the active Search Criteria (see list_criteria_presets). Pass wait=<seconds> (up to 300) to answer only when the scan has finished, for a client that cannot poll between turns; the scan keeps running if the wait ends first.', inputSchema: { type: 'object', properties: { dry: { type: 'boolean' }, criteria: { type: 'string' }, wait: { type: 'number', description: 'seconds to wait for the scan to finish, up to 300; omit to return at once' } } } },
   { name: 'mail_check', description: 'Start a read-only pass over the person\'s mailbox for application updates (confirmations, rejections, interview invitations) through the local CLI\'s Gmail connector, with only the Gmail read tools allowed. Runs in the background for a few minutes; poll mail_items. days: how far back (default: since the last check, or 21 days the first time).', inputSchema: { type: 'object', properties: { days: { type: 'number' } } } },
+  { name: 'calendar_check', description: 'Start a read-only pass over the person\'s Google Calendar for interviews, screens, recruiter calls and deadlines about jobs on their board, through the local CLI\'s Google Calendar connector with only its read tools allowed. Runs in the background for a minute or two; poll calendar_items. days: how far ahead (default 21). Nothing is ever written to the calendar.', inputSchema: { type: 'object', properties: { days: { type: 'number' } } } },
+  { name: 'calendar_items', description: 'The calendar events found so far, each matched to a job note (by role, by company, or none) with what confirming it would do: the time into the note\'s Interview on field, the note to interviewing where it is not yet. Confirming is done by the person in the app; an agent reads these and tells them what is waiting.', inputSchema: { type: 'object', properties: {} } },
   { name: 'mail_items', description: 'The application emails found so far, each matched to a job note (exact role, same company, or none) with what confirming it would do. Confirming is done by the person in the app; an agent can read these and tell them what is waiting.', inputSchema: { type: 'object', properties: {} } },
   { name: 'preview_criteria', description: 'What a proposed criteria JSON would do to the notes that exist, without saving or scanning: how many rise above or fall below the bar, who enters or leaves the top 20, the biggest movers. Covers title terms, recency and pay exactly; description, seniority and location rules need a scan.', inputSchema: { type: 'object', properties: { raw: { type: 'string' } }, required: ['raw'] } },
   { name: 'outcomes', description: 'What the search is producing: the funnel (found, reviewed, shortlisted, applied, interviewing, offer), response rate, median days from discovery to application, applications waiting without a response at 7/14/21 days with the oldest listed, and applied/response counts by source.', inputSchema: { type: 'object', properties: {} } },
@@ -97,6 +100,8 @@ export async function call(name, a = {}) {
     }
     case 'mail_check': return mail.start({ sinceDays: a.days });
     case 'mail_items': return mail.items();
+    case 'calendar_check': return calcheck.start({ days: a.days });
+    case 'calendar_items': return calcheck.items();
     case 'preview_criteria': return store.previewCriteria(a.raw);
     case 'rescore_notes': return store.rescoreNotes({ dry: !!a.dry });
     case 'outcomes': return store.outcomes();

package/cli.mjs

@@ -34,7 +34,7 @@ const HELP = `tekjobs — a local job-search machine
                                          (for location, description or seniority rule changes); notes already
                                          at these weights are left alone
   tekjobs schedule [--time HH:MM] [--print]
-                                         run the scan and the mail read every morning: creates the Windows task
+                                         run the scan, then the read-only mail and calendar passes, 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
@@ -46,6 +46,8 @@ const HELP = `tekjobs — a local job-search machine
   tekjobs down                           stop what \`up\` started
   tekjobs ps                             what \`up\` has running
   tekjobs board <slug> [--from ats] [--move]  where a failed board answers now; --move rewrites the watchlist row
+  tekjobs calendar check [--days N]     read the Google Calendar, through the local CLI's connector with its read tools
+                                         only, for interviews and calls about jobs on the board; confirm each in the app
   tekjobs journal [YYYY-MM-DD] [--write]  the day's journal from the record (runs, found, decisions, mail); --write
                                          puts it at the end of Logs/<date>.md, as every real scan does
   tekjobs serve                          the app + API on http://127.0.0.1:8787, in this terminal
@@ -204,6 +206,22 @@ async function main() {
     if (!s.dry) console.log(`  Index: ${s.indexPath}. Job notes now show who you know at each company.`);
     return;
   }
+  if (cmd === 'calendar') {
+    const cc = await import('./app/server/calendar-check.mjs');
+    if (rest[0] === 'check') {
+      const s = cc.start({ days: Number(opt('--days')) || undefined });
+      console.log(`Reading the calendar through ${s.runner}, ${s.days} days ahead, read tools only. This takes a minute or two.`);
+      while (cc.items().running) await new Promise((r) => setTimeout(r, 3000));
+      const r = cc.items();
+      if (r.error) return console.error(`Calendar check failed (${r.errorKind}): ${r.error}`);
+      console.log(`${r.pending.length} event${r.pending.length === 1 ? '' : 's'} waiting for a decision in the app's Calendar page.`);
+      for (const i of r.pending) console.log(`  ${i.start}  ${i.kind.padEnd(14)} ${i.company} — ${i.summary || i.gist}${i.noteId ? `  → ${i.noteTitle} (${i.noteStatus})` : '  → no note'}`);
+      return;
+    }
+    const r = cc.items();
+    console.log(`${r.pending.length} pending calendar event${r.pending.length === 1 ? '' : 's'}; last read ${r.lastRun || 'never'}. Run: tekjobs calendar check`);
+    return;
+  }
   if (cmd === 'journal') {
     const { buildJournal, renderJournal, writeJournal } = await import('./scraper/journal.mjs');
     const date = rest.find((x) => /^\d{4}-\d{2}-\d{2}$/.test(x));
@@ -317,7 +335,7 @@ function schedule() {
   const printOnly = rest.includes('--print');
   if (process.platform === 'win32') {
     const cmd = `schtasks /Create /F /SC DAILY /ST ${time} /TN "TekJobs Daily Scan" /TR "\\"${path.join(ROOT, 'run.cmd')}\\""`;
-    console.log(`Windows Task Scheduler entry "TekJobs Daily Scan", daily at ${time}, running run.cmd (the scan, then the mail read):\n  ${cmd}`);
+    console.log(`Windows Task Scheduler entry "TekJobs Daily Scan", daily at ${time}, running run.cmd (the scan, then the read-only mail and calendar passes):\n  ${cmd}`);
     if (printOnly) return;
     const r = spawnSync(cmd, { shell: true, encoding: 'utf8' });
     if (r.status === 0) console.log('Installed. See it in Task Scheduler, or remove it with: schtasks /Delete /TN "TekJobs Daily Scan" /F');
@@ -341,5 +359,5 @@ function schedule() {
 EOF
   launchctl load ${plist}`);
   }
-  console.log('\nBoth run run.sh: the scan, then the read-only mail pass, appending to data/runs.log.');
+  console.log('\nBoth run run.sh: the scan, then the read-only mail and calendar passes, appending to data/runs.log.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurtekb/tekjobs",
-  "version": "0.48.0",
+  "version": "0.50.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/run.cmd

@@ -8,3 +8,6 @@ node run.mjs >> data\runs.log 2>&1
 rem Then the mailbox: a read-only pass through the local CLI's Gmail connector, matched to the notes for you to confirm in the app.
 echo ----- mail %date% %time% ----- >> data\runs.log
 node cli.mjs mail >> data\runs.log 2>&1
+rem Then the calendar: a read-only pass through the Google Calendar connector for interviews and calls about jobs on the board, matched to the notes for you to confirm.
+echo ----- calendar %date% %time% ----- >> data\runs.log
+node cli.mjs calendar check >> data\runs.log 2>&1

package/run.sh

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Daily TekJobs scan for cron and launchd: the scan, then the read-only mail pass. `tekjobs schedule` prints
+# Daily TekJobs scan for cron and launchd: the scan, then the read-only mail and calendar passes. `tekjobs schedule` prints
 # the one line that calls this at 07:30; run.cmd is the Windows twin.
 cd "$(dirname "$0")" || exit 1
 export TEKJOBS_RUN_VIA=schedule
@@ -9,4 +9,6 @@ mkdir -p data
   node run.mjs
   echo "----- mail $(date) -----"
   node cli.mjs mail
+  echo "----- calendar $(date) -----"
+  node cli.mjs calendar check
 } >> data/runs.log 2>&1