@jsonresume/jobs 0.10.0 → 0.12.0

package/src/tui/useAI.js

@@ -1,12 +1,64 @@
-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) => {
@@ -16,6 +68,7 @@ export function useAI(resume) {
         );
         return;
       }
+      setMode('ai');
       setLoading(true);
       setError(null);
       setText('');
@@ -56,6 +109,291 @@ 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. 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.`;
+
+      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) {
@@ -64,6 +402,7 @@ export function useAI(resume) {
         );
         return;
       }
+      setMode('ai');
       setLoading(true);
       setError(null);
       setText('');
@@ -99,13 +438,92 @@ 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;
+  }, []);
+
+  // Seed cache with server-side dossier flags from job list
+  const seedDossierFlags = useCallback((jobs) => {
+    let changed = false;
+    for (const job of jobs) {
+      if (job.has_dossier && !dossierCache.current.has(job.id)) {
+        dossierCache.current.set(job.id, {
+          text: '',
+          done: true,
+          loading: false,
+        });
+        changed = true;
+      }
+    }
+    if (changed) bumpTick();
+  }, []);
+
+  // 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;
+  }, []);
+
+  const regenerateDossier = useCallback(
+    (job, api) => {
+      // Clear cached dossier so dossier() starts fresh
+      dossierCache.current.delete(job.id);
+      cancel();
+      setText('');
+      setError(null);
+      bumpTick();
+      dossier(job, api);
+    },
+    [dossier, cancel]
+  );
+
   return {
     text,
     loading,
     error,
     hasKey,
+    mode,
+    hasActiveProcess: Boolean(childRef.current),
+    getDossierStatus,
+    seedDossierFlags,
     summarizeJob,
+    dossier,
+    regenerateDossier,
     batchReview,
-    clear: () => setText(''),
+    exportDossier,
+    cancel,
+    clear: () => {
+      cancel();
+      setText('');
+      dossierJobId.current = null;
+    },
   };
 }

package/src/tui/useJobs.js

@@ -1,7 +1,7 @@
 import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
 import { getCached, setCache, updateCachedJob } from '../cache.js';
 
-export function useJobs(api, activeFilters, tab, searchId) {
+export function useJobs(api, activeFilters, tab, searchId, getDossierStatus) {
   const [allJobs, setAllJobs] = useState([]);
   const [loading, setLoading] = useState(true);
   const [reranking, setReranking] = useState(false);
@@ -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);
 
@@ -134,6 +135,22 @@ export function useJobs(api, activeFilters, tab, searchId) {
       }
     }
 
+    if (tab === 'new')
+      return filtered.filter(
+        (j) =>
+          !j.state &&
+          !j.has_dossier &&
+          (!getDossierStatus ||
+            (getDossierStatus(j.id) !== 'done' &&
+              getDossierStatus(j.id) !== 'generating'))
+      );
+    if (tab === 'reviewed')
+      return filtered.filter(
+        (j) =>
+          !j.state &&
+          (j.has_dossier ||
+            (getDossierStatus && getDossierStatus(j.id) === 'done'))
+      );
     if (tab === 'interested')
       return filtered.filter((j) => j.state === 'interested');
     if (tab === 'applied') return filtered.filter((j) => j.state === 'applied');
@@ -144,7 +161,7 @@ export function useJobs(api, activeFilters, tab, searchId) {
     return filtered.filter(
       (j) => j.state !== 'not_interested' && j.state !== 'dismissed'
     );
-  }, [allJobs, activeFilters, tab]);
+  }, [allJobs, activeFilters, tab, getDossierStatus]);
 
   const markJob = useCallback(
     async (id, state, feedback) => {