@jsonresume/jobs 0.7.0

package/src/tui/StatusBar.js

@@ -0,0 +1,108 @@
+import { Box, Text } from 'ink';
+import { h } from './h.js';
+
+const KEYS = {
+  list: [
+    ['jk', 'nav'],
+    ['enter', 'open'],
+    ['i', '⭐'],
+    ['x', '📨'],
+    ['m', '?'],
+    ['p', '✗'],
+    ['v', 'select'],
+    ['space', 'AI'],
+    ['f', 'filter'],
+    ['/', 'search'],
+    ['e', 'export'],
+    ['?', 'help'],
+    ['q', 'quit'],
+  ],
+  detail: [
+    ['jk', 'nav'],
+    ['JK', 'scroll detail'],
+    ['i', '⭐'],
+    ['x', '📨'],
+    ['m', '?'],
+    ['p', '✗'],
+    ['o', 'open'],
+    ['space', 'AI'],
+    ['esc', 'back'],
+    ['q', 'close'],
+  ],
+  filters: [
+    ['jk', 'nav'],
+    ['enter', 'edit'],
+    ['a', 'add'],
+    ['d', 'delete'],
+    ['esc', 'close'],
+  ],
+  searches: [
+    ['jk', 'nav'],
+    ['enter', 'switch'],
+    ['n', 'new'],
+    ['d', 'delete'],
+    ['esc', 'close'],
+  ],
+  ai: [['esc', 'dismiss']],
+  help: [['?/esc', 'close']],
+};
+
+export default function StatusBar({
+  view,
+  jobCount,
+  totalCount,
+  loading,
+  reranking,
+  error,
+  aiEnabled,
+  searchName,
+  toast,
+}) {
+  const keys = KEYS[view] || KEYS.list;
+
+  const keyElements = keys.map(([key, label], i) =>
+    h(
+      Box,
+      { key: i, marginRight: 1 },
+      h(Text, { bold: true, color: 'cyan' }, key),
+      h(Text, { dimColor: true }, `:${label}`)
+    )
+  );
+
+  return h(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'single',
+      borderColor: 'gray',
+      paddingX: 1,
+      marginTop: 0,
+    },
+    toast
+      ? h(
+          Box,
+          { justifyContent: 'space-between' },
+          toast,
+          h(
+            Box,
+            { gap: 1 },
+            h(Text, { dimColor: true }, `${jobCount}/${totalCount} jobs`)
+          )
+        )
+      : h(
+          Box,
+          { justifyContent: 'space-between' },
+          h(Box, { flexWrap: 'wrap', gap: 0 }, ...keyElements),
+          h(
+            Box,
+            { gap: 1 },
+            loading ? h(Text, { color: 'yellow' }, '⏳') : null,
+            reranking ? h(Text, { color: 'magenta' }, '🧠 reranking…') : null,
+            h(Text, { dimColor: true }, `${jobCount}/${totalCount} jobs`),
+            searchName ? h(Text, { color: 'magenta' }, '🔍') : null,
+            aiEnabled ? null : h(Text, { color: 'gray' }, '(no AI)')
+          )
+        ),
+    error ? h(Text, { color: 'red' }, `Error: ${error}`) : null
+  );
+}

package/src/tui/Toast.js

@@ -0,0 +1,56 @@
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { h } from './h.js';
+
+const ICONS = {
+  interested: '⭐',
+  applied: '📨',
+  maybe: '❓',
+  not_interested: '✗',
+  dismissed: '👁',
+  success: '✓',
+  error: '✗',
+  info: 'ℹ',
+  export: '📄',
+};
+
+const COLORS = {
+  interested: 'green',
+  applied: 'cyan',
+  maybe: 'yellow',
+  not_interested: 'red',
+  dismissed: 'gray',
+  success: 'green',
+  error: 'red',
+  info: 'blue',
+  export: 'green',
+};
+
+export function useToast(timeout = 2500) {
+  const [toast, setToast] = useState(null);
+
+  useEffect(() => {
+    if (!toast) return;
+    const timer = setTimeout(() => setToast(null), timeout);
+    return () => clearTimeout(timer);
+  }, [toast, timeout]);
+
+  const show = (message, type = 'info') => {
+    setToast({ message, type, time: Date.now() });
+  };
+
+  return { toast, show };
+}
+
+export default function Toast({ toast }) {
+  if (!toast) return null;
+
+  const icon = ICONS[toast.type] || ICONS.info;
+  const color = COLORS[toast.type] || 'blue';
+
+  return h(
+    Box,
+    { paddingX: 1 },
+    h(Text, { color, bold: true }, `${icon} ${toast.message}`)
+  );
+}

package/src/tui/h.js

@@ -0,0 +1,2 @@
+import React from 'react';
+export const h = React.createElement;

package/src/tui/useAI.js

@@ -0,0 +1,107 @@
+import { useState, useCallback } from 'react';
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+
+export function useAI(resume) {
+  const [text, setText] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const hasKey = Boolean(process.env.OPENAI_API_KEY);
+
+  const summarizeJob = useCallback(
+    async (job) => {
+      if (!hasKey) {
+        setError('Set OPENAI_API_KEY to enable AI features');
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      setText('');
+      try {
+        const resumeText = [
+          resume?.basics?.label,
+          resume?.basics?.summary,
+          ...(resume?.skills || []).map(
+            (s) => `${s.name}: ${(s.keywords || []).join(', ')}`
+          ),
+        ]
+          .filter(Boolean)
+          .join('\n');
+
+        const jobText = [
+          `Title: ${job.title}`,
+          `Company: ${job.company}`,
+          `Salary: ${job.salary || 'Not listed'}`,
+          `Remote: ${job.remote || 'Not specified'}`,
+          `Description: ${job.description || ''}`,
+          `Skills: ${(job.skills || []).map((s) => s.name).join(', ')}`,
+        ].join('\n');
+
+        const { text: result } = await generateText({
+          model: openai('gpt-4o-mini'),
+          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.',
+          prompt: `Resume:\n${resumeText}\n\nJob:\n${jobText}`,
+          maxTokens: 400,
+        });
+        setText(result);
+      } catch (err) {
+        setError(err.message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [resume, hasKey]
+  );
+
+  const batchReview = useCallback(
+    async (jobs) => {
+      if (!hasKey) {
+        setError('Set OPENAI_API_KEY to enable AI features');
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      setText('');
+      try {
+        const resumeText = [resume?.basics?.label, resume?.basics?.summary]
+          .filter(Boolean)
+          .join('\n');
+
+        const jobsList = jobs
+          .slice(0, 15)
+          .map(
+            (j, i) =>
+              `${i + 1}. [${j.similarity}] ${j.title} at ${j.company} | ${
+                j.salary || 'no salary'
+              } | ${j.remote || 'no remote info'}`
+          )
+          .join('\n');
+
+        const { text: result } = await generateText({
+          model: openai('gpt-4o-mini'),
+          system:
+            'You are a career advisor. Rank these jobs by fit for the candidate. For each, give a 1-line verdict. Be direct.',
+          prompt: `Resume:\n${resumeText}\n\nJobs:\n${jobsList}`,
+          maxTokens: 600,
+        });
+        setText(result);
+      } catch (err) {
+        setError(err.message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [resume, hasKey]
+  );
+
+  return {
+    text,
+    loading,
+    error,
+    hasKey,
+    summarizeJob,
+    batchReview,
+    clear: () => setText(''),
+  };
+}

package/src/tui/useJobs.js

@@ -0,0 +1,168 @@
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { getCached, setCache, updateCachedJob } from '../cache.js';
+
+export function useJobs(api, activeFilters, tab, searchId) {
+  const [allJobs, setAllJobs] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [reranking, setReranking] = useState(false);
+  const [error, setError] = useState(null);
+  const rerankAbort = useRef(null);
+
+  // Build API params from active filters array
+  const params = useMemo(() => {
+    const p = { top: 100, days: 30 };
+    if (searchId) p.searchId = searchId;
+    for (const f of activeFilters || []) {
+      if (f.type === 'days') p.days = Number(f.value) || 30;
+      if (f.type === 'remote') p.remote = true;
+      if (f.type === 'minSalary') p.minSalary = Number(f.value) || 0;
+      if (f.type === 'search') p.search = f.value || '';
+    }
+    return p;
+  }, [activeFilters, searchId]);
+
+  const paramsKey = JSON.stringify(params);
+
+  const fetchJobs = useCallback(
+    async (force) => {
+      // Cancel any pending rerank
+      if (rerankAbort.current) {
+        rerankAbort.current.cancelled = true;
+        rerankAbort.current = null;
+      }
+
+      setLoading(true);
+      setReranking(false);
+      setError(null);
+
+      if (!force) {
+        // Check for reranked cache first, then plain cache
+        const cachedReranked = getCached({ ...params, rerank: true });
+        if (cachedReranked) {
+          setAllJobs(cachedReranked);
+          setLoading(false);
+          return;
+        }
+        const cached = getCached(params);
+        if (cached) {
+          setAllJobs(cached);
+          setLoading(false);
+          // Still kick off rerank in background if eligible
+          if (searchId) {
+            startRerank(cached);
+          }
+          return;
+        }
+      }
+
+      try {
+        // Pass 1: fast fetch without reranking
+        const { jobs: data } = await api.fetchJobs({
+          ...params,
+          rerank: false,
+        });
+        const result = data || [];
+        setCache(params, result);
+        setAllJobs(result);
+        setLoading(false);
+
+        // Pass 2: rerank in background if using a custom search
+        if (searchId && result.length > 0) {
+          startRerank(result);
+        }
+      } catch (err) {
+        setError(err.message);
+        setLoading(false);
+      }
+    },
+    [api, paramsKey]
+  );
+
+  function startRerank(currentJobs) {
+    const token = { cancelled: false };
+    rerankAbort.current = token;
+    setReranking(true);
+
+    api
+      .fetchJobs({ ...params, rerank: true })
+      .then(({ jobs: reranked }) => {
+        if (token.cancelled) return;
+        const result = reranked || [];
+        setCache({ ...params, rerank: true }, result);
+        // Merge rerank data into existing jobs (preserve any local state changes)
+        setAllJobs((prev) => {
+          const stateMap = {};
+          prev.forEach((j) => {
+            if (j.state) stateMap[j.id] = j.state;
+          });
+          return result.map((j) => ({
+            ...j,
+            state: stateMap[j.id] || j.state,
+          }));
+        });
+      })
+      .catch(() => {})
+      .finally(() => {
+        if (!token.cancelled) setReranking(false);
+      });
+  }
+
+  useEffect(() => {
+    fetchJobs(false);
+  }, [fetchJobs]);
+
+  // Filter by tab (job state) + client-side filters
+  const jobs = useMemo(() => {
+    let filtered = allJobs;
+
+    for (const f of activeFilters || []) {
+      if (f.type === 'remote') {
+        filtered = filtered.filter(
+          (j) => j.remote === 'Full' || /remote/i.test(j.location || '')
+        );
+      }
+      if (f.type === 'minSalary' && f.value) {
+        filtered = filtered.filter(
+          (j) => !j.salary_usd || j.salary_usd >= Number(f.value) * 1000
+        );
+      }
+      if (f.type === 'search' && f.value) {
+        const q = f.value.toLowerCase();
+        filtered = filtered.filter((j) =>
+          JSON.stringify(j).toLowerCase().includes(q)
+        );
+      }
+    }
+
+    if (tab === 'interested')
+      return filtered.filter((j) => j.state === 'interested');
+    if (tab === 'applied') return filtered.filter((j) => j.state === 'applied');
+    if (tab === 'maybe') return filtered.filter((j) => j.state === 'maybe');
+    if (tab === 'passed')
+      return filtered.filter((j) => j.state === 'not_interested');
+    // "All" tab: hide passed and dismissed jobs
+    return filtered.filter(
+      (j) => j.state !== 'not_interested' && j.state !== 'dismissed'
+    );
+  }, [allJobs, activeFilters, tab]);
+
+  const markJob = useCallback(
+    async (id, state, feedback) => {
+      setAllJobs((prev) =>
+        prev.map((j) => (j.id === id ? { ...j, state } : j))
+      );
+      updateCachedJob(params, id, { state });
+      updateCachedJob({ ...params, rerank: true }, id, { state });
+      try {
+        await api.markJob(id, state, feedback);
+      } catch {
+        fetchJobs(false);
+      }
+    },
+    [api, fetchJobs, paramsKey]
+  );
+
+  const forceRefresh = useCallback(() => fetchJobs(true), [fetchJobs]);
+
+  return { jobs, allJobs, loading, reranking, error, markJob, forceRefresh };
+}

package/src/tui/useSearches.js

@@ -0,0 +1,56 @@
+import { useState, useEffect, useCallback } from 'react';
+
+export function useSearches(api) {
+  const [searches, setSearches] = useState([]);
+  const [loading, setLoading] = useState(false);
+
+  const fetch = useCallback(async () => {
+    setLoading(true);
+    try {
+      const { searches: data } = await api.listSearches();
+      setSearches(data || []);
+    } catch {
+      // Silently fail — searches are optional
+    } finally {
+      setLoading(false);
+    }
+  }, [api]);
+
+  useEffect(() => {
+    fetch();
+  }, [fetch]);
+
+  const create = useCallback(
+    async (name, prompt) => {
+      try {
+        const { search } = await api.createSearch(name, prompt);
+        setSearches((prev) => [search, ...prev]);
+        return search;
+      } catch (err) {
+        throw err;
+      }
+    },
+    [api]
+  );
+
+  const remove = useCallback(
+    async (id) => {
+      try {
+        await api.deleteSearch(id);
+        setSearches((prev) => prev.filter((s) => s.id !== id));
+      } catch {}
+    },
+    [api]
+  );
+
+  const updateFilters = useCallback(
+    async (id, filters) => {
+      try {
+        await api.updateSearch(id, { filters });
+      } catch {}
+    },
+    [api]
+  );
+
+  return { searches, loading, create, remove, updateFilters, refetch: fetch };
+}