@jsonresume/jobs 0.9.0 → 0.11.0

package/src/tui/useAI.js

@@ -1,19 +1,74 @@
-import { useState, useCallback } from 'react';
+import { useState, useCallback, useRef } from 'react';
+import { writeFileSync } from 'fs';
 import { generateText } from 'ai';
 import { openai } from '@ai-sdk/openai';
 
+function buildResumeText(resume) {
+  return [
+    resume?.basics?.name,
+    resume?.basics?.label,
+    resume?.basics?.summary,
+    ...(resume?.skills || []).map(
+      (s) => `${s.name}: ${(s.keywords || []).join(', ')}`
+    ),
+    ...(resume?.work || [])
+      .slice(0, 5)
+      .map(
+        (w) =>
+          `${w.position} at ${w.name}${
+            w.startDate ? ` (${w.startDate})` : ''
+          }: ${w.summary || ''}`
+      ),
+    ...(resume?.projects || [])
+      .slice(0, 3)
+      .map((p) => `Project: ${p.name} — ${p.description || ''}`),
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+function buildJobText(job, rawContent) {
+  return [
+    `Title: ${job.title}`,
+    `Company: ${job.company}`,
+    `Salary: ${job.salary || 'Not listed'}`,
+    `Remote: ${job.remote || 'Not specified'}`,
+    job.experience ? `Experience: ${job.experience}` : '',
+    job.type ? `Type: ${job.type}` : '',
+    job.url ? `HN Post: ${job.url}` : '',
+    `Description: ${job.description || ''}`,
+    `Skills: ${(job.skills || []).map((s) => s.name || s).join(', ')}`,
+    ...(job.qualifications || []).map((q) => `Qualification: ${q}`),
+    ...(job.responsibilities || []).map((r) => `Responsibility: ${r}`),
+    rawContent ? `\nFull original posting:\n${rawContent}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
 export function useAI(resume) {
   const [text, setText] = useState('');
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState(null);
+  const [mode, setMode] = useState('ai'); // 'ai' | 'cover'
   const hasKey = Boolean(process.env.OPENAI_API_KEY);
+  const childRef = useRef(null);
+  const dossierJobId = useRef(null);
+  // Local cache: jobId → { text, done, loading }
+  const dossierCache = useRef(new Map());
+  // Bump to trigger re-renders when dossier status changes
+  const [, setDossierTick] = useState(0);
+  const bumpTick = () => setDossierTick((t) => t + 1);
 
   const summarizeJob = useCallback(
     async (job) => {
       if (!hasKey) {
-        setError('Set OPENAI_API_KEY to enable AI features');
+        setError(
+          'AI requires OPENAI_API_KEY — run: export OPENAI_API_KEY=sk-...'
+        );
         return;
       }
+      setMode('ai');
       setLoading(true);
       setError(null);
       setText('');
@@ -54,12 +109,292 @@ export function useAI(resume) {
     [resume, hasKey]
   );
 
+  const dossier = useCallback(
+    async (job, api) => {
+      const cached = dossierCache.current.get(job.id);
+
+      // If dossier is already loading or loaded for this job, just show it
+      if (cached && (cached.loading || cached.done)) {
+        setMode('cover');
+        setText(cached.text || '');
+        setLoading(cached.loading || false);
+        setError(null);
+        dossierJobId.current = job.id;
+        return;
+      }
+
+      setMode('cover');
+      setError(null);
+      setText('');
+      dossierJobId.current = job.id;
+      dossierCache.current.set(job.id, {
+        text: '',
+        done: false,
+        loading: true,
+      });
+      bumpTick();
+
+      // Helper to update both state and cache
+      // Only updates visible state if this job is still the active dossier
+      const updateText = (val) => {
+        const entry = dossierCache.current.get(job.id);
+        if (entry) entry.text = val;
+        if (dossierJobId.current === job.id) setText(val);
+      };
+
+      // Check server for existing dossier
+      try {
+        const { content } = await api.fetchDossier(job.id);
+        if (content) {
+          updateText(content);
+          dossierCache.current.set(job.id, {
+            text: content,
+            done: true,
+            loading: false,
+          });
+          bumpTick();
+          return;
+        }
+      } catch {
+        /* no cached dossier */
+      }
+
+      // Check if claude CLI is available
+      const { execSync } = await import('child_process');
+      let claudePath;
+      try {
+        claudePath = execSync('which claude', { encoding: 'utf-8' }).trim();
+      } catch {
+        setError(
+          'Claude Code CLI not found. Install it: npm install -g @anthropic-ai/claude-code'
+        );
+        return;
+      }
+
+      // Kill any existing claude process
+      if (childRef.current) {
+        try {
+          childRef.current.kill();
+        } catch {}
+        childRef.current = null;
+      }
+
+      setLoading(true);
+
+      // Fetch resume if not available yet
+      let currentResume = resume;
+      if (!currentResume) {
+        try {
+          const me = await api.fetchMe();
+          currentResume = me.resume;
+        } catch {
+          /* proceed without resume */
+        }
+      }
+
+      // Fetch full job detail for raw content
+      let rawContent = '';
+      try {
+        const detail = await api.fetchJobDetail(job.id);
+        rawContent = detail.raw_content || detail.full_description || '';
+      } catch {}
+
+      const resumeText = buildResumeText(currentResume);
+      const jobText = buildJobText(job, rawContent);
+
+      const prompt = `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. 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
+
+### 2. 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
+
+### 3. 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
+
+### 4. 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
+
+### 5. Contact Info
+- Email addresses from the posting
+- Who posted (HN username from the URL if available)
+- Best way to reach out
+
+### 6. Interview Prep
+- Questions they'll likely ask for this role
+- Questions the candidate should ask
+- Topics to research before interviewing
+
+### 7. Compensation Context
+- Market rate for this role/level/location
+- How the listed salary compares
+- Negotiation leverage points
+
+Be thorough, specific, and opinionated. Reference the candidate's actual experience when making recommendations.`;
+
+      try {
+        const { spawn } = await import('child_process');
+        // Remove CLAUDECODE env var to allow nested claude sessions
+        const env = { ...process.env };
+        delete env.CLAUDECODE;
+        delete env.CLAUDE_CODE_ENTRYPOINT;
+        delete env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS;
+
+        const child = spawn(
+          claudePath,
+          [
+            '--print',
+            '--output-format',
+            'stream-json',
+            '--verbose',
+            '--allowedTools',
+            'WebSearch',
+            'WebFetch',
+            '--',
+            prompt,
+          ],
+          { stdio: ['ignore', 'pipe', 'pipe'], env }
+        );
+        childRef.current = child;
+
+        let finalResult = '';
+        let buffer = '';
+        let statusLine = '';
+
+        function processLine(line) {
+          if (!line.trim()) return;
+          try {
+            const event = JSON.parse(line);
+
+            if (event.type === 'assistant') {
+              // Extract text from assistant message content
+              const content = event.message?.content || [];
+              for (const block of content) {
+                if (block.type === 'text' && block.text) {
+                  finalResult = block.text;
+                  updateText(
+                    statusLine ? `${statusLine}\n\n${finalResult}` : finalResult
+                  );
+                } else if (block.type === 'tool_use') {
+                  // Show what Claude is doing (e.g. WebSearch, WebFetch)
+                  const name = block.name || 'tool';
+                  const input = block.input || {};
+                  if (name === 'WebSearch' || name === 'WebFetch') {
+                    statusLine = `🔍 ${name}: ${
+                      input.query || input.url || ''
+                    }`;
+                  } else {
+                    statusLine = `⚙ Using ${name}…`;
+                  }
+                  updateText(
+                    finalResult ? `${statusLine}\n\n${finalResult}` : statusLine
+                  );
+                }
+              }
+            }
+
+            if (event.type === 'result' && event.result) {
+              finalResult = event.result;
+              updateText(finalResult);
+            }
+          } catch {
+            // Not valid JSON, skip
+          }
+        }
+
+        child.stdout.on('data', (chunk) => {
+          buffer += chunk.toString();
+          // Process complete JSON lines
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            processLine(line);
+          }
+        });
+
+        child.stderr.on('data', () => {});
+
+        await new Promise((resolve, reject) => {
+          child.on('close', (code) => {
+            // Only clear childRef if it's still our process
+            if (childRef.current === child) childRef.current = null;
+            // Process any remaining buffer
+            if (buffer.trim()) 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) => {
+            if (childRef.current === child) childRef.current = null;
+            reject(err);
+          });
+        });
+
+        // Save to server if we got output
+        if (finalResult.trim()) {
+          try {
+            await api.saveDossier(job.id, finalResult);
+          } catch {}
+        }
+      } catch (err) {
+        if (err.message?.includes('exited with code')) {
+          setError(`Claude failed — ${err.message}`);
+        } else if (err.message !== 'killed') {
+          setError(err.message);
+        }
+      } finally {
+        const entry = dossierCache.current.get(job.id);
+        if (entry) {
+          entry.done = true;
+          entry.loading = false;
+        }
+        bumpTick();
+        if (dossierJobId.current === job.id) {
+          childRef.current = null;
+          setLoading(false);
+        }
+      }
+    },
+    [resume]
+  );
+
   const batchReview = useCallback(
     async (jobs) => {
       if (!hasKey) {
-        setError('Set OPENAI_API_KEY to enable AI features');
+        setError(
+          'AI requires OPENAI_API_KEY — run: export OPENAI_API_KEY=sk-...'
+        );
         return;
       }
+      setMode('ai');
       setLoading(true);
       setError(null);
       setText('');
@@ -95,13 +430,61 @@ export function useAI(resume) {
     [resume, hasKey]
   );
 
+  const cancel = useCallback(() => {
+    if (childRef.current) {
+      try {
+        childRef.current.kill();
+      } catch {}
+      childRef.current = null;
+    }
+  }, []);
+
+  const textRef = useRef('');
+  textRef.current = text;
+
+  const exportDossier = useCallback((job) => {
+    // Use visible text state, or fall back to cache
+    const content =
+      textRef.current || dossierCache.current.get(job?.id)?.text || '';
+    if (!content) return null;
+    const company = (job?.company || 'unknown')
+      .replace(/[^a-zA-Z0-9]+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '')
+      .toLowerCase()
+      .slice(0, 50);
+    const filename = `dossier-${company}.md`;
+    writeFileSync(filename, content, 'utf-8');
+    return filename;
+  }, []);
+
+  // Expose dossier status for job list icons
+  // Returns: 'generating' | 'done' | null
+  const getDossierStatus = useCallback((jobId) => {
+    const entry = dossierCache.current.get(jobId);
+    if (!entry) return null;
+    if (entry.loading) return 'generating';
+    if (entry.done) return 'done';
+    return null;
+  }, []);
+
   return {
     text,
     loading,
     error,
     hasKey,
+    mode,
+    hasActiveProcess: Boolean(childRef.current),
+    getDossierStatus,
     summarizeJob,
+    dossier,
     batchReview,
-    clear: () => setText(''),
+    exportDossier,
+    cancel,
+    clear: () => {
+      cancel();
+      setText('');
+      dossierJobId.current = null;
+    },
   };
 }

package/src/tui/useJobs.js

@@ -12,6 +12,7 @@ export function useJobs(api, activeFilters, tab, searchId) {
   const params = useMemo(() => {
     const p = { top: 100, days: 30 };
     if (searchId) p.searchId = searchId;
+    if (api.mode) p.mode = api.mode;
     for (const f of activeFilters || []) {
       if (f.type === 'days') p.days = Number(f.value) || 30;
       if (f.type === 'remote') p.remote = true;
@@ -19,7 +20,7 @@ export function useJobs(api, activeFilters, tab, searchId) {
       if (f.type === 'search') p.search = f.value || '';
     }
     return p;
-  }, [activeFilters, searchId]);
+  }, [activeFilters, searchId, api.mode]);
 
   const paramsKey = JSON.stringify(params);
 

package/src/tui/PreviewPane.js

@@ -1,68 +0,0 @@
-import { Box, Text } from 'ink';
-import { h } from './h.js';
-import { formatSalary, formatLocation, stateIcon } from '../formatters.js';
-
-export default function PreviewPane({ job }) {
-  if (!job) return null;
-
-  const cols = process.stdout.columns || 80;
-  const loc = formatLocation(job.location, job.remote);
-  const sal = formatSalary(job.salary, job.salary_usd);
-  const icon = stateIcon(job.state);
-
-  const skills = job.skills
-    ? job.skills
-        .slice(0, 8)
-        .map((s) => s.name || s)
-        .join(' · ')
-    : null;
-
-  const desc = job.description
-    ? job.description.replace(/\n/g, ' ').slice(0, cols * 2)
-    : null;
-
-  return h(
-    Box,
-    {
-      flexDirection: 'column',
-      borderStyle: 'single',
-      borderColor: 'gray',
-      borderTop: true,
-      borderBottom: false,
-      borderLeft: false,
-      borderRight: false,
-      paddingX: 1,
-    },
-    // Title line
-    h(
-      Box,
-      { gap: 1 },
-      h(Text, { bold: true, color: 'white' }, job.title || '—'),
-      h(Text, { dimColor: true }, 'at'),
-      h(Text, { bold: true, color: 'cyan' }, job.company || '—'),
-      job.state ? h(Text, null, ` ${icon}`) : null
-    ),
-    // Meta line
-    h(
-      Box,
-      { gap: 2 },
-      h(Text, { dimColor: true }, `📍 ${loc}`),
-      h(Text, { dimColor: true }, `💰 ${sal}`),
-      job.experience
-        ? h(Text, { dimColor: true }, `📊 ${job.experience}`)
-        : null,
-      job.url ? h(Text, { color: 'blue', dimColor: true }, 'o:open') : null
-    ),
-    // Skills
-    skills
-      ? h(
-          Box,
-          null,
-          h(Text, { color: 'yellow' }, 'Skills: '),
-          h(Text, { dimColor: true }, skills)
-        )
-      : null,
-    // Description snippet
-    desc ? h(Text, { dimColor: true, wrap: 'truncate-end' }, desc) : null
-  );
-}