careermate 0.0.7 → 0.0.9

package/packages/core/src/jobsearch.ts

@@ -0,0 +1,190 @@
+/**
+ * Job search import — pull postings from key-free public job-board endpoints by
+ * keyword, so the AI can offer real listings the user can save into CareerMate.
+ *
+ * Scope & boundaries (deliberate):
+ *  - INBOUND only. We fetch publicly visible postings; we send only the search
+ *    keyword, never the user's stored data. (Privacy = no user data leaves; this
+ *    does not violate it.)
+ *  - No WAF bypass, no auth keys. These providers' own frontends call these JSON
+ *    endpoints unauthenticated; a plain fetch suffices. We do NOT bundle a
+ *    scraper/anti-bot evasion (that's the legally dangerous part — see
+ *    .claude/work/research/research_0004). Sites requiring keys (Saramin oapi,
+ *    고용24) or that forbid it in robots.txt (JobKorea search) are excluded here.
+ *  - Honest User-Agent. We identify ourselves as careermate (verified live:
+ *    both providers answer 200 to it), never as a spoofed browser — "no bot
+ *    evasion" must include not lying about who is asking.
+ *  - Read-only w.r.t. the DB. This returns candidates; the AI shows them and the
+ *    user picks which to save via save_job_posting (no auto-dumping into the DB).
+ *
+ * Providers are unofficial public endpoints — if a response shape changes, only
+ * the affected provider's parser needs updating (others keep working).
+ */
+
+import { APP_VERSION } from '@careermate/shared';
+
+export interface JobSearchResult {
+  /** Provider id, e.g. 'wanted' | 'jumpit'. */
+  source: string;
+  company: string;
+  position: string;
+  /** Canonical posting URL the user can open. */
+  url: string;
+  location?: string;
+  /** Required experience, human-readable (e.g. '신입', '5~20년'). */
+  experience?: string;
+  /** Tech stack / tags when the provider exposes them. */
+  keywords?: string[];
+  /** Application deadline as YYYY-MM-DD when known. */
+  deadline?: string;
+  /** Provider-native id (for dedup / detail fetch). */
+  external_id: string;
+}
+
+export interface ProviderOutcome {
+  source: string;
+  ok: boolean;
+  count: number;
+  error?: string;
+}
+
+export interface JobSearchResponse {
+  query: string;
+  results: JobSearchResult[];
+  providers: ProviderOutcome[];
+}
+
+export interface JobSearchOptions {
+  /** Which providers to query. Defaults to all registered. */
+  sources?: string[];
+  /** Max results per provider (1–50). Default 10. */
+  limit?: number;
+  /** Per-request timeout in ms. Default 10000. */
+  timeoutMs?: number;
+}
+
+const UA = `careermate/${APP_VERSION} (+https://careermate.life)`;
+
+/** Slice an ISO timestamp / date string to YYYY-MM-DD; undefined if not a date. */
+function toYmd(v: unknown): string | undefined {
+  if (typeof v !== 'string' || v.length < 10) return undefined;
+  const m = v.match(/^(\d{4}-\d{2}-\d{2})/);
+  return m ? m[1] : undefined;
+}
+
+async function getJson(url: string, timeoutMs: number): Promise<any> {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      headers: { accept: 'application/json', 'user-agent': UA, 'accept-language': 'ko,en;q=0.8' },
+      signal: ctrl.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+interface Provider {
+  id: string;
+  label: string;
+  search(query: string, limit: number, timeoutMs: number): Promise<JobSearchResult[]>;
+}
+
+/** Wanted (wanted.co.kr) — public v4 jobs JSON, no auth. IT/startup roles. */
+const wanted: Provider = {
+  id: 'wanted',
+  label: '원티드',
+  async search(query, limit, timeoutMs) {
+    const url =
+      `https://www.wanted.co.kr/api/v4/jobs?country=kr&locations=all&years=-1` +
+      `&job_sort=job.latest_order&limit=${limit}&offset=0&query=${encodeURIComponent(query)}`;
+    const j = await getJson(url, timeoutMs);
+    const rows: any[] = Array.isArray(j?.data) ? j.data : [];
+    return rows.map((r) => {
+      const annual =
+        r.annual_from || r.annual_to
+          ? `${r.annual_from ?? 0}~${r.annual_to ?? '?'}년`
+          : undefined;
+      return {
+        source: 'wanted',
+        company: r.company?.name ?? '',
+        position: r.position ?? '',
+        url: `https://www.wanted.co.kr/wd/${r.id}`,
+        location: r.address?.location ?? r.address?.full_location ?? undefined,
+        experience: annual,
+        deadline: toYmd(r.due_time),
+        external_id: String(r.id),
+      } as JobSearchResult;
+    });
+  },
+};
+
+/** Jumpit (jumpit.co.kr) — public positions JSON, no auth. Dev roles, tech stacks. */
+const jumpit: Provider = {
+  id: 'jumpit',
+  label: '점핏',
+  async search(query, limit, timeoutMs) {
+    const url =
+      `https://api.jumpit.co.kr/api/positions?sort=rsp_rate&page=1&keyword=${encodeURIComponent(query)}`;
+    const j = await getJson(url, timeoutMs);
+    const rows: any[] = Array.isArray(j?.result?.positions) ? j.result.positions : [];
+    return rows.slice(0, limit).map((p) => ({
+      source: 'jumpit',
+      company: p.companyName ?? '',
+      position: p.title ?? '',
+      url: `https://www.jumpit.co.kr/position/${p.id}`,
+      location: Array.isArray(p.locations) ? p.locations[0] : undefined,
+      experience: p.newcomer
+        ? '신입'
+        : p.minCareer != null
+          ? `${p.minCareer}~${p.maxCareer ?? p.minCareer}년`
+          : undefined,
+      keywords: Array.isArray(p.techStacks) ? p.techStacks : undefined,
+      deadline: toYmd(p.closedAt),
+      external_id: String(p.id),
+    } as JobSearchResult));
+  },
+};
+
+const PROVIDERS: Provider[] = [wanted, jumpit];
+
+/** Registered provider ids (key-free, no WAF bypass). */
+export const JOB_SEARCH_SOURCES = PROVIDERS.map((p) => p.id);
+
+/**
+ * Search key-free public job boards by keyword. Each provider runs independently;
+ * one failing (network/timeout/shape change) does not sink the others. Results
+ * are returned for the AI to present — saving is a separate explicit step.
+ */
+export async function searchJobs(query: string, opts: JobSearchOptions = {}): Promise<JobSearchResponse> {
+  const q = (query ?? '').trim();
+  if (!q) return { query: '', results: [], providers: [] };
+  const limit = Math.min(50, Math.max(1, opts.limit ?? 10));
+  const timeoutMs = opts.timeoutMs ?? 10000;
+  const chosen = opts.sources?.length
+    ? PROVIDERS.filter((p) => opts.sources!.includes(p.id))
+    : PROVIDERS;
+
+  const settled = await Promise.all(
+    chosen.map(async (p): Promise<{ outcome: ProviderOutcome; results: JobSearchResult[] }> => {
+      try {
+        const results = await p.search(q, limit, timeoutMs);
+        return { outcome: { source: p.id, ok: true, count: results.length }, results };
+      } catch (e) {
+        return {
+          outcome: { source: p.id, ok: false, count: 0, error: e instanceof Error ? e.message : String(e) },
+          results: [],
+        };
+      }
+    }),
+  );
+
+  return {
+    query: q,
+    results: settled.flatMap((s) => s.results),
+    providers: settled.map((s) => s.outcome),
+  };
+}

package/packages/core/src/offers.ts

@@ -0,0 +1,41 @@
+/**
+ * Offer comparison use-cases. CareerMate stores offers and a deterministic annual
+ * cash estimate (base+bonus+welfare); the connected AI writes the score/verdict at
+ * save time (no LLM here). compareOffers returns all offers joined with their job,
+ * pre-sorted by the AI's score — the dashboard renders that, and the head-to-head
+ * "which is better" reasoning happens in the AI chat via this same data.
+ */
+import { offerRepo, jobRepo } from '@careermate/db';
+import type { OfferInput, OfferRecord, JobRecord } from '@careermate/shared';
+
+export interface OfferWithJob extends OfferRecord {
+  company: string;
+  position: string;
+}
+
+function withJob(offer: OfferRecord, job: JobRecord | null): OfferWithJob {
+  return { ...offer, company: job?.company ?? '—', position: job?.position ?? '—' };
+}
+
+/** Save/update the offer for a job (one per job). The job must exist first. */
+export function saveOffer(input: OfferInput): OfferWithJob {
+  const job = jobRepo.get(input.job_id);
+  if (!job) throw new Error('공고를 찾을 수 없습니다. 먼저 save_job_posting으로 공고를 저장하세요.');
+  return withJob(offerRepo.save(input), job);
+}
+
+/** The offer for one job (or null). */
+export function getOffer(jobId: string): OfferWithJob | null {
+  const offer = offerRepo.getByJob(jobId);
+  if (!offer) return null;
+  return withJob(offer, jobRepo.get(jobId));
+}
+
+/**
+ * All offers, joined with their job, sorted by the AI's score (desc, null last).
+ * `total_comp_annual_est` on each is the server's deterministic sum — the AI does
+ * the qualitative comparison from this structured data.
+ */
+export function compareOffers(): OfferWithJob[] {
+  return offerRepo.list().map((o) => withJob(o, jobRepo.get(o.job_id)));
+}

package/packages/core/src/services.ts

@@ -14,6 +14,7 @@ import {
   type CoverLetterVersionInput,
   type ApplicationStatus,
   type ApplicationSubmission,
+  type RejectedStage,
   type ApplicationRecord,
   type InterviewPrepInput,
   type InterviewPrepRecord,
@@ -78,6 +79,22 @@ export function collectVerifyCorpus(jobId?: string | null): VerifyCorpus {
   for (const s of skillRepo.list()) {
     structured.push([s.name, s.level, s.years != null ? `${s.years}년` : ''].filter(Boolean).join(' '));
   }
+  // Profile credentials (학점·어학·자격·수상) — so a cited GPA/score (3.8, TOEIC 920)
+  // traces to stored data and isn't hard-blocked as fabricated. Structured-only ⇒ advisory.
+  // Provenance matching is unit-keyed, and a purely numeric score is cited both bare
+  // ("920") and with the 점 counter ("920점"); emit both forms so neither false-fires.
+  const scoreForms = (s?: string): string =>
+    s && /^\d+(\.\d+)?$/.test(s.trim()) ? `${s.trim()} ${s.trim()}점` : (s ?? '');
+  const prof = profileRepo.get();
+  if (prof) {
+    for (const ed of prof.education) {
+      const gpa = ed.gpa ? `학점 ${ed.gpa}${ed.gpa_scale ? `/${ed.gpa_scale}` : ''}` : '';
+      structured.push([ed.school, ed.degree, ed.major, gpa, ed.status].filter(Boolean).join(' '));
+    }
+    for (const c of prof.certifications) structured.push([c.name, c.issuer, scoreForms(c.score)].filter(Boolean).join(' '));
+    for (const l of prof.language_scores) structured.push(`${l.test} ${scoreForms(l.score)}`);
+    for (const a of prof.awards) structured.push([a.title, a.issuer, a.description].filter(Boolean).join(' '));
+  }
   const job = jobId ? jobRepo.get(jobId) : null;
   const jobText = job ? [job.description, ...(job.requirements ?? []), ...(job.keywords ?? [])].filter(Boolean).join('\n') : '';
   return { documents: documents.join('\n'), structured: structured.join('\n'), job: jobText };
@@ -280,7 +297,11 @@ export function saveCoverLetterVersion(input: CoverLetterVersionInput & { force?
   const { coverLetter, version } = coverLetterRepo.addVersion({
     cover_letter_id: input.cover_letter_id,
     title: input.title,
-    job_id: input.job_id ?? null,
+    // Pass job_id through verbatim — do NOT coerce undefined→null here. addVersion
+    // treats `undefined` as "leave the link alone" and `null` as "clear it"; the old
+    // `?? null` wiped a cover letter's job link whenever a new version was saved
+    // without re-specifying job_id (e.g. editing an existing letter).
+    job_id: input.job_id,
     content: input.content,
     note: input.note,
     source: input.source ?? 'ai',
@@ -295,7 +316,9 @@ export function saveCoverLetterVersion(input: CoverLetterVersionInput & { force?
   }
   activityRepo.log(
     'cover_letter_version_saved',
-    `${coverLetter.title} 자기소개서 v${version.version_no}를 저장했습니다.`,
+    // Title already names the document (often ends in "자기소개서") — don't append the
+    // word again or it doubles ("…자기소개서 자기소개서 v2"). Title + version is enough.
+    `${coverLetter.title} v${version.version_no}를 저장했습니다.`,
     'cover_letter',
     coverLetter.id,
   );
@@ -328,6 +351,7 @@ export function updateApplicationStatus(
   status: ApplicationStatus,
   note?: string,
   submission?: ApplicationSubmission,
+  rejectedStage?: RejectedStage,
 ): StatusChangeResult {
   const job = jobRepo.get(jobId);
   if (!job) throw notFound('공고를 찾을 수 없습니다.');
@@ -336,7 +360,7 @@ export function updateApplicationStatus(
   // together: if any write throws (e.g. a bad bind), roll back so we never leave
   // the status changed but the submission/timeline missing.
   const application = tx(() => {
-    let application = applicationRepo.setStatus(jobId, status, note);
+    let application = applicationRepo.setStatus(jobId, status, note, rejectedStage);
     const submittedDocs = (submission?.document_ids ?? [])
       .map((docId) => documentRepo.get(docId))
       .filter((doc): doc is DocumentRecord => !!doc);
@@ -385,6 +409,8 @@ export function updateApplicationStatus(
         status_label: APPLICATION_STATUS_LABELS[status],
         note: note ?? null,
         submission: submissionPayload,
+        // 탈락 회고: rejected로 넘어갈 때 실제 저장된 단계(setStatus가 정합성 처리한 값)를 타임라인에도 남긴다.
+        rejected_stage: application.rejected_stage,
       },
       occurred_at: submittedAtToOccurrence(submittedAt),
     });