@jsonresume/jobs 0.14.1 → 0.14.2

package/src/tui/claudeDossier.js

@@ -0,0 +1,97 @@
+/**
+ * Spawn the Claude Code CLI to generate a research dossier and stream its
+ * output. Isolated from React so the spawn/stream/lifecycle logic can be
+ * reasoned about (and replaced) independently of the hook state.
+ */
+
+import { createDossierStream } from './dossierStream.js';
+
+// Locate the `claude` binary. Throws if not installed.
+export async function resolveClaudePath() {
+  const { execSync } = await import('child_process');
+  return execSync('which claude', { encoding: 'utf-8' }).trim();
+}
+
+// Env for nested claude sessions — drop the markers that block nesting.
+export function nestedClaudeEnv(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_ENTRYPOINT;
+  delete env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+  return env;
+}
+
+export const CLAUDE_ARGS_PREFIX = [
+  '--print',
+  '--output-format',
+  'stream-json',
+  '--verbose',
+  '--allowedTools',
+  'WebSearch',
+  'WebFetch',
+  '--',
+];
+
+/**
+ * Spawn claude with the prompt, stream parsed text through onText, and resolve
+ * with the final result string once the process closes.
+ *
+ * @param {object} opts
+ * @param {string} opts.claudePath  resolved path to the claude binary
+ * @param {string} opts.prompt      dossier prompt
+ * @param {(text:string)=>void} opts.onText  called with composed visible text
+ * @param {(child:any)=>void} opts.onChild   receives the spawned child process
+ * @param {(child:any)=>void} [opts.onEnd]   called when the process closes/errors
+ * @returns {Promise<string>} final result text
+ */
+export async function runClaudeDossier({
+  claudePath,
+  prompt,
+  onText,
+  onChild,
+  onEnd,
+}) {
+  const { spawn } = await import('child_process');
+  const env = nestedClaudeEnv();
+
+  const child = spawn(claudePath, [...CLAUDE_ARGS_PREFIX, prompt], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env,
+  });
+  onChild?.(child);
+
+  const stream = createDossierStream(onText);
+  let buffer = '';
+
+  child.stdout.on('data', (chunk) => {
+    buffer += chunk.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+    for (const line of lines) {
+      stream.processLine(line);
+    }
+  });
+
+  child.stderr.on('data', () => {});
+
+  await new Promise((resolve, reject) => {
+    child.on('close', (code) => {
+      onEnd?.(child);
+      // Process any remaining buffered partial line.
+      if (buffer.trim()) stream.processLine(buffer);
+      if (code === 0) {
+        resolve();
+      } else if (code !== null) {
+        reject(new Error(`Claude exited with code ${code}`));
+      } else {
+        resolve(); // killed
+      }
+    });
+    child.on('error', (err) => {
+      onEnd?.(child);
+      reject(err);
+    });
+  });
+
+  return stream.getResult();
+}

package/src/tui/claudeDossier.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { nestedClaudeEnv, CLAUDE_ARGS_PREFIX } from './claudeDossier.js';
+
+describe('nestedClaudeEnv', () => {
+  it('drops claude-nesting markers but keeps other vars', () => {
+    const env = nestedClaudeEnv({
+      PATH: '/usr/bin',
+      CLAUDECODE: '1',
+      CLAUDE_CODE_ENTRYPOINT: 'cli',
+      CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: 'x',
+      OPENAI_API_KEY: 'sk',
+    });
+    expect(env.PATH).toBe('/usr/bin');
+    expect(env.OPENAI_API_KEY).toBe('sk');
+    expect(env.CLAUDECODE).toBeUndefined();
+    expect(env.CLAUDE_CODE_ENTRYPOINT).toBeUndefined();
+    expect(env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS).toBeUndefined();
+  });
+
+  it('does not mutate the source env', () => {
+    const src = { CLAUDECODE: '1' };
+    nestedClaudeEnv(src);
+    expect(src.CLAUDECODE).toBe('1');
+  });
+});
+
+describe('CLAUDE_ARGS_PREFIX', () => {
+  it('requests stream-json with web tools and ends with the arg separator', () => {
+    expect(CLAUDE_ARGS_PREFIX).toEqual([
+      '--print',
+      '--output-format',
+      'stream-json',
+      '--verbose',
+      '--allowedTools',
+      'WebSearch',
+      'WebFetch',
+      '--',
+    ]);
+  });
+});

package/src/tui/dossierCache.js

@@ -0,0 +1,26 @@
+/**
+ * Pure operations over the in-memory dossier cache Map.
+ * Map shape: jobId → { text, done, loading }.
+ * Kept separate from the hook so the status/seed logic is unit-testable.
+ */
+
+// Map an entry to a job-list icon status.
+export function dossierStatus(cache, jobId) {
+  const entry = cache.get(jobId);
+  if (!entry) return null;
+  if (entry.loading) return 'generating';
+  if (entry.done) return 'done';
+  return null;
+}
+
+// Seed cache from server-side has_dossier flags. Returns true if anything changed.
+export function seedDossierFlags(cache, jobs) {
+  let changed = false;
+  for (const job of jobs) {
+    if (job.has_dossier && !cache.has(job.id)) {
+      cache.set(job.id, { text: '', done: true, loading: false });
+      changed = true;
+    }
+  }
+  return changed;
+}

package/src/tui/dossierCache.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { dossierStatus, seedDossierFlags } from './dossierCache.js';
+
+describe('dossierStatus', () => {
+  it('returns null for unknown jobs', () => {
+    expect(dossierStatus(new Map(), 'x')).toBeNull();
+  });
+  it('returns generating while loading', () => {
+    const m = new Map([['1', { loading: true, done: false }]]);
+    expect(dossierStatus(m, '1')).toBe('generating');
+  });
+  it('returns done when finished', () => {
+    const m = new Map([['1', { loading: false, done: true }]]);
+    expect(dossierStatus(m, '1')).toBe('done');
+  });
+  it('returns null for a started-but-not-loading-or-done entry', () => {
+    const m = new Map([['1', { loading: false, done: false }]]);
+    expect(dossierStatus(m, '1')).toBeNull();
+  });
+});
+
+describe('seedDossierFlags', () => {
+  it('adds done entries for jobs flagged has_dossier', () => {
+    const m = new Map();
+    const changed = seedDossierFlags(m, [
+      { id: '1', has_dossier: true },
+      { id: '2', has_dossier: false },
+    ]);
+    expect(changed).toBe(true);
+    expect(m.get('1')).toEqual({ text: '', done: true, loading: false });
+    expect(m.has('2')).toBe(false);
+  });
+
+  it('does not overwrite existing entries and reports no change', () => {
+    const m = new Map([['1', { text: 'keep', done: true, loading: false }]]);
+    const changed = seedDossierFlags(m, [{ id: '1', has_dossier: true }]);
+    expect(changed).toBe(false);
+    expect(m.get('1').text).toBe('keep');
+  });
+});

package/src/tui/dossierPrompt.js

@@ -0,0 +1,80 @@
+/**
+ * The full research-dossier prompt sent to the Claude CLI.
+ * Kept in its own module since it is a large, self-contained instruction blob.
+ */
+
+export function buildDossierPrompt(resumeText, jobText) {
+  return `You are a job search research assistant. A candidate is considering applying to this role. Do thorough research and produce a comprehensive dossier.
+
+## Candidate Resume
+${resumeText}
+
+## Job Posting
+${jobText}
+
+## Your Task
+
+Research everything you can and produce a complete dossier covering:
+
+### 1. Compensation Context
+- Market rate for this role/level/location
+- How the listed salary compares
+- Negotiation leverage points
+
+### 2. AI Engineering Culture
+- Does the company use or encourage AI coding tools (Copilot, Claude Code, Cursor, agentic workflows)?
+- Any public statements, blog posts, or job descriptions mentioning AI-assisted development?
+- Is the engineering culture likely to embrace engineers who ship faster using AI tools, or is there resistance?
+- Look for signals: do they mention "AI-native", "agentic", "LLM-augmented" workflows, or similar?
+- Are there concerns about AI tool usage (IP policies, code review friction, etc.)?
+- Rating: AI-Forward / AI-Friendly / Neutral / Unknown / AI-Resistant
+
+### 3. Company Deep Dive
+- What the company does, their products/services
+- Funding stage, size, recent news
+- Tech stack and engineering culture
+- Leadership team
+- Employee sentiment and Glassdoor/Blind highlights
+- Any red flags or concerns
+
+### 4. Role Analysis
+- What you'd actually be doing day-to-day
+- Team context — who you'd work with
+- Growth trajectory for this role
+- How this role fits into the company's current priorities
+
+### 5. Fit Assessment
+- Matching skills and experience (be specific, reference the candidate's actual background)
+- Skill gaps to acknowledge or address
+- Adjacent experience that transfers
+- Overall fit rating: Strong / Good / Stretch
+
+### 6. Cover Letter Talking Points
+- 5-7 specific bullet points to mention, each referencing the candidate's real experience
+- What angle to take (technical depth? leadership? domain expertise?)
+- What to emphasize vs. downplay
+
+### 7. Contact Info
+- Email addresses from the posting
+- Who posted (HN username from the URL if available)
+- Best way to reach out
+
+### 8. Interview Prep
+- Questions they'll likely ask for this role
+- Questions the candidate should ask
+- Topics to research before interviewing
+
+Be thorough, specific, and opinionated. Reference the candidate's actual experience when making recommendations.
+
+### IMPORTANT: Structured Data Block
+At the very end of your response, output a JSON code block tagged \`\`\`enrichment with corrected/discovered job metadata. Only include fields where you found better data than what's in the posting. This helps improve the job database:
+\`\`\`enrichment
+{
+  "salary": "$X - $Y" or null if unknown,
+  "remote": "Full" | "Hybrid" | "None" | null,
+  "location": { "city": "...", "countryCode": "XX", "region": "..." } or null,
+  "experience": "Junior" | "Mid" | "Senior" | "Staff" | "Lead" | null,
+  "type": "Full-time" | "Contract" | "Part-time" | null
+}
+\`\`\``;
+}

package/src/tui/dossierStream.js

@@ -0,0 +1,48 @@
+/**
+ * Parser for the Claude CLI `--output-format stream-json` output.
+ *
+ * Each call to processLine() consumes one NDJSON line, updates internal state
+ * (the latest assistant text plus a tool-activity status line) and invokes
+ * onText with the composed visible text. getResult() returns the final text.
+ */
+
+import { statusLineForTool, composeDossierText } from './aiHelpers.js';
+
+export function createDossierStream(onText) {
+  let finalResult = '';
+  let statusLine = '';
+
+  function processLine(line) {
+    if (!line.trim()) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      // Not valid JSON, skip
+      return;
+    }
+
+    if (event.type === 'assistant') {
+      const content = event.message?.content || [];
+      for (const block of content) {
+        if (block.type === 'text' && block.text) {
+          finalResult = block.text;
+          onText(composeDossierText(statusLine, finalResult));
+        } else if (block.type === 'tool_use') {
+          statusLine = statusLineForTool(block);
+          onText(composeDossierText(statusLine, finalResult));
+        }
+      }
+    }
+
+    if (event.type === 'result' && event.result) {
+      finalResult = event.result;
+      onText(finalResult);
+    }
+  }
+
+  return {
+    processLine,
+    getResult: () => finalResult,
+  };
+}

package/src/tui/dossierStream.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createDossierStream } from './dossierStream.js';
+
+function lines(...objs) {
+  return objs.map((o) => JSON.stringify(o));
+}
+
+describe('createDossierStream', () => {
+  it('ignores blank and non-JSON lines', () => {
+    const onText = vi.fn();
+    const s = createDossierStream(onText);
+    s.processLine('');
+    s.processLine('   ');
+    s.processLine('not json {');
+    expect(onText).not.toHaveBeenCalled();
+    expect(s.getResult()).toBe('');
+  });
+
+  it('captures assistant text blocks as the running result', () => {
+    const onText = vi.fn();
+    const s = createDossierStream(onText);
+    const [line] = lines({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'Hello world' }] },
+    });
+    s.processLine(line);
+    expect(onText).toHaveBeenLastCalledWith('Hello world');
+    expect(s.getResult()).toBe('Hello world');
+  });
+
+  it('prefixes a tool status line before existing result text', () => {
+    const onText = vi.fn();
+    const s = createDossierStream(onText);
+    const [textLine, toolLine] = lines(
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Body' }] },
+      },
+      {
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'tool_use', name: 'WebSearch', input: { query: 'q' } },
+          ],
+        },
+      }
+    );
+    s.processLine(textLine);
+    s.processLine(toolLine);
+    expect(onText).toHaveBeenLastCalledWith('🔍 WebSearch: q\n\nBody');
+  });
+
+  it('shows the status line alone when no result text yet', () => {
+    const onText = vi.fn();
+    const s = createDossierStream(onText);
+    const [toolLine] = lines({
+      type: 'assistant',
+      message: {
+        content: [{ type: 'tool_use', name: 'WebFetch', input: { url: 'u' } }],
+      },
+    });
+    s.processLine(toolLine);
+    expect(onText).toHaveBeenLastCalledWith('🔍 WebFetch: u');
+  });
+
+  it('overrides result with the final result event', () => {
+    const onText = vi.fn();
+    const s = createDossierStream(onText);
+    const [textLine, resultLine] = lines(
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'partial' }] },
+      },
+      { type: 'result', result: 'FINAL ANSWER' }
+    );
+    s.processLine(textLine);
+    s.processLine(resultLine);
+    expect(s.getResult()).toBe('FINAL ANSWER');
+    expect(onText).toHaveBeenLastCalledWith('FINAL ANSWER');
+  });
+});

package/src/tui/gptReview.js

@@ -0,0 +1,47 @@
+/**
+ * GPT-backed review actions (job fit summary + batch ranking).
+ * Pure async functions: build the prompt, call the model, return the text.
+ * The hook layers loading/error state on top.
+ */
+
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import {
+  buildSummaryResumeText,
+  buildSummaryJobText,
+  buildBatchJobsList,
+} from './aiHelpers.js';
+
+const SUMMARY_SYSTEM =
+  'You are a career advisor. Given a job posting and resume, provide a concise fit analysis in 4-5 bullet points. Cover: why it fits, skill gaps, salary assessment, and remote compatibility. Be direct and opinionated.';
+
+const BATCH_SYSTEM =
+  'You are a career advisor. Rank these jobs by fit for the candidate. For each, give a 1-line verdict. Be direct.';
+
+// Single-job fit analysis.
+export async function runJobSummary(resume, job) {
+  const resumeText = buildSummaryResumeText(resume);
+  const jobText = buildSummaryJobText(job);
+  const { text } = await generateText({
+    model: openai('gpt-4o-mini'),
+    system: SUMMARY_SYSTEM,
+    prompt: `Resume:\n${resumeText}\n\nJob:\n${jobText}`,
+    maxTokens: 400,
+  });
+  return text;
+}
+
+// Ranked verdicts across a batch of jobs.
+export async function runBatchReview(resume, jobs) {
+  const resumeText = [resume?.basics?.label, resume?.basics?.summary]
+    .filter(Boolean)
+    .join('\n');
+  const jobsList = buildBatchJobsList(jobs);
+  const { text } = await generateText({
+    model: openai('gpt-4o-mini'),
+    system: BATCH_SYSTEM,
+    prompt: `Resume:\n${resumeText}\n\nJobs:\n${jobsList}`,
+    maxTokens: 600,
+  });
+  return text;
+}

package/src/tui/jobFilters.js

@@ -0,0 +1,69 @@
+/**
+ * Pure tab/count/filter logic for the TUI App.
+ * Extracted so the categorization rules can be unit-tested without Ink.
+ */
+
+export const TABS = [
+  'all',
+  'new',
+  'reviewed',
+  'interested',
+  'applied',
+  'maybe',
+  'passed',
+];
+
+export const TAB_LABELS = {
+  all: 'All',
+  new: 'New',
+  reviewed: 'Reviewed',
+  interested: 'Interested',
+  applied: 'Applied',
+  maybe: 'Maybe',
+  passed: 'Passed',
+};
+
+// Next/previous tab id with wraparound.
+export function nextTab(tab, dir = 1) {
+  const idx = TABS.indexOf(tab);
+  return TABS[(idx + dir + TABS.length) % TABS.length];
+}
+
+// Free-text filter over the visible job fields.
+export function filterJobsByQuery(jobs, query) {
+  if (!query) return jobs;
+  const q = query.toLowerCase();
+  return jobs.filter((j) => {
+    const fields = [
+      j.title,
+      j.company,
+      j.description,
+      j.remote,
+      j.location?.city,
+      j.location?.countryCode,
+      ...(j.skills || []).map((s) => s.name || s),
+    ];
+    return fields.some((f) => f && String(f).toLowerCase().includes(q));
+  });
+}
+
+// Per-tab counts for the header. getDossierStatus(jobId) → 'done'|'generating'|null
+export function computeCounts(allJobs, getDossierStatus) {
+  return {
+    all: allJobs.length,
+    new: allJobs.filter(
+      (j) =>
+        !j.state &&
+        !j.has_dossier &&
+        getDossierStatus(j.id) !== 'done' &&
+        getDossierStatus(j.id) !== 'generating'
+    ).length,
+    reviewed: allJobs.filter(
+      (j) => (j.has_dossier || getDossierStatus(j.id) === 'done') && !j.state
+    ).length,
+    interested: allJobs.filter((j) => j.state === 'interested').length,
+    applied: allJobs.filter((j) => j.state === 'applied').length,
+    maybe: allJobs.filter((j) => j.state === 'maybe').length,
+    passed: allJobs.filter((j) => j.state === 'not_interested').length,
+  };
+}

package/src/tui/jobFilters.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import {
+  TABS,
+  nextTab,
+  filterJobsByQuery,
+  computeCounts,
+} from './jobFilters.js';
+
+describe('nextTab', () => {
+  it('cycles forward with wraparound', () => {
+    expect(nextTab('all', 1)).toBe('new');
+    expect(nextTab(TABS[TABS.length - 1], 1)).toBe('all');
+  });
+  it('cycles backward with wraparound', () => {
+    expect(nextTab('all', -1)).toBe(TABS[TABS.length - 1]);
+    expect(nextTab('new', -1)).toBe('all');
+  });
+});
+
+describe('filterJobsByQuery', () => {
+  const jobs = [
+    { id: 1, title: 'React Dev', company: 'Acme', skills: [{ name: 'React' }] },
+    { id: 2, title: 'Go Dev', company: 'Globex', skills: ['Golang'] },
+    {
+      id: 3,
+      title: 'Designer',
+      company: 'Initech',
+      location: { city: 'Berlin', countryCode: 'DE' },
+    },
+  ];
+
+  it('returns all jobs when query is empty', () => {
+    expect(filterJobsByQuery(jobs, '')).toBe(jobs);
+  });
+  it('matches title case-insensitively', () => {
+    expect(filterJobsByQuery(jobs, 'react').map((j) => j.id)).toEqual([1]);
+  });
+  it('matches object skills by name and string skills directly', () => {
+    expect(filterJobsByQuery(jobs, 'golang').map((j) => j.id)).toEqual([2]);
+    expect(filterJobsByQuery(jobs, 'React').map((j) => j.id)).toEqual([1]);
+  });
+  it('matches nested location fields (city and countryCode)', () => {
+    expect(filterJobsByQuery(jobs, 'berlin').map((j) => j.id)).toEqual([3]);
+    // countryCode 'DE' — use a non-substring-of-titles probe to isolate it
+    const onlyHasCountry = [{ id: 7, location: { countryCode: 'NL' } }];
+    expect(filterJobsByQuery(onlyHasCountry, 'nl').map((j) => j.id)).toEqual([
+      7,
+    ]);
+  });
+});
+
+describe('computeCounts', () => {
+  const none = () => null;
+  it('counts all, states, new and reviewed', () => {
+    const allJobs = [
+      { id: 1 }, // new
+      { id: 2, state: 'interested' },
+      { id: 3, state: 'applied' },
+      { id: 4, state: 'maybe' },
+      { id: 5, state: 'not_interested' },
+      { id: 6, has_dossier: true }, // reviewed (no state)
+    ];
+    const c = computeCounts(allJobs, none);
+    expect(c.all).toBe(6);
+    expect(c.new).toBe(1);
+    expect(c.reviewed).toBe(1);
+    expect(c.interested).toBe(1);
+    expect(c.applied).toBe(1);
+    expect(c.maybe).toBe(1);
+    expect(c.passed).toBe(1);
+  });
+
+  it('treats a generating/done dossier status as not-new', () => {
+    const allJobs = [{ id: 1 }, { id: 2 }];
+    const status = (id) => (id === 1 ? 'generating' : 'done');
+    const c = computeCounts(allJobs, status);
+    expect(c.new).toBe(0);
+    expect(c.reviewed).toBe(1); // id 2 done + no state
+  });
+});