careermate 0.0.8 → 0.0.10

package/packages/core/src/jobsearch.ts

@@ -2,44 +2,36 @@
  * 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.
- *  - 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).
+ * CareerMate is local-first: only the search keyword leaves the machine. Stored
+ * profile, résumé, application, and document data are never sent to providers.
+ * Provider endpoints are unofficial and therefore validated at runtime; a shape
+ * change degrades only that provider instead of silently returning corrupt rows.
  */
 
+import { z } from 'zod';
+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 type ProviderStatus = 'healthy' | 'degraded' | 'unavailable';
+
 export interface ProviderOutcome {
   source: string;
+  label: string;
   ok: boolean;
+  status: ProviderStatus;
   count: number;
+  checked_at: string;
   error?: string;
 }
 
@@ -50,25 +42,20 @@ export interface JobSearchResponse {
 }
 
 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 =
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36';
+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> {
+async function getJson(url: string, timeoutMs: number): Promise<unknown> {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
   try {
@@ -77,6 +64,8 @@ async function getJson(url: string, timeoutMs: number): Promise<any> {
       signal: ctrl.signal,
     });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const type = res.headers.get('content-type') ?? '';
+    if (!type.includes('json')) throw new Error(`unexpected content-type: ${type || 'unknown'}`);
     return await res.json();
   } finally {
     clearTimeout(timer);
@@ -89,7 +78,41 @@ interface Provider {
   search(query: string, limit: number, timeoutMs: number): Promise<JobSearchResult[]>;
 }
 
-/** Wanted (wanted.co.kr) — public v4 jobs JSON, no auth. IT/startup roles. */
+const wantedSchema = z.object({
+  data: z.array(
+    z.object({
+      id: z.union([z.string(), z.number()]),
+      position: z.string().min(1),
+      company: z.object({ name: z.string().min(1) }),
+      annual_from: z.number().nullable().optional(),
+      annual_to: z.number().nullable().optional(),
+      due_time: z.string().nullable().optional(),
+      address: z
+        .object({ location: z.string().optional(), full_location: z.string().optional() })
+        .nullable()
+        .optional(),
+    }).passthrough(),
+  ),
+}).passthrough();
+
+const jumpitSchema = z.object({
+  result: z.object({
+    positions: z.array(
+      z.object({
+        id: z.union([z.string(), z.number()]),
+        companyName: z.string().min(1),
+        title: z.string().min(1),
+        locations: z.array(z.string()).optional(),
+        newcomer: z.boolean().optional(),
+        minCareer: z.number().nullable().optional(),
+        maxCareer: z.number().nullable().optional(),
+        techStacks: z.array(z.string()).optional(),
+        closedAt: z.string().nullable().optional(),
+      }).passthrough(),
+    ),
+  }).passthrough(),
+}).passthrough();
+
 const wanted: Provider = {
   id: 'wanted',
   label: '원티드',
@@ -97,81 +120,103 @@ const wanted: Provider = {
     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 j = wantedSchema.parse(await getJson(url, timeoutMs));
+    return j.data.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 ?? '',
+        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,
+        location: r.address?.location ?? r.address?.full_location,
         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) => ({
+    const j = jumpitSchema.parse(await getJson(url, timeoutMs));
+    return j.result.positions.slice(0, limit).map((p) => ({
       source: 'jumpit',
-      company: p.companyName ?? '',
-      position: p.title ?? '',
+      company: p.companyName,
+      position: p.title,
       url: `https://www.jumpit.co.kr/position/${p.id}`,
-      location: Array.isArray(p.locations) ? p.locations[0] : undefined,
+      location: p.locations?.[0],
       experience: p.newcomer
         ? '신입'
         : p.minCareer != null
           ? `${p.minCareer}~${p.maxCareer ?? p.minCareer}년`
           : undefined,
-      keywords: Array.isArray(p.techStacks) ? p.techStacks : undefined,
+      keywords: p.techStacks,
       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.
- */
+function providerError(e: unknown): { status: ProviderStatus; error: string } {
+  if (e instanceof z.ZodError) {
+    const first = e.issues[0];
+    return {
+      status: 'degraded',
+      error: `provider response changed${first ? ` (${first.path.join('.') || 'root'})` : ''}`,
+    };
+  }
+  const message = e instanceof Error ? e.message : String(e);
+  return { status: 'unavailable', error: message };
+}
+
 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 timeoutMs = Math.min(30_000, Math.max(1_000, opts.timeoutMs ?? 10_000));
   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[] }> => {
+      const checked_at = new Date().toISOString();
       try {
         const results = await p.search(q, limit, timeoutMs);
-        return { outcome: { source: p.id, ok: true, count: results.length }, results };
+        return {
+          outcome: {
+            source: p.id,
+            label: p.label,
+            ok: true,
+            status: 'healthy',
+            count: results.length,
+            checked_at,
+          },
+          results,
+        };
       } catch (e) {
+        const failure = providerError(e);
         return {
-          outcome: { source: p.id, ok: false, count: 0, error: e instanceof Error ? e.message : String(e) },
+          outcome: {
+            source: p.id,
+            label: p.label,
+            ok: false,
+            status: failure.status,
+            count: 0,
+            checked_at,
+            error: failure.error,
+          },
           results: [],
         };
       }

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/reuse-insights.ts

@@ -0,0 +1,126 @@
+import { coverLetterRepo, experienceRepo, projectRepo, jobRepo } from '@careermate/db';
+
+export interface ReuseReference {
+  kind: 'experience' | 'project';
+  entity_id: string;
+  label: string;
+  cover_letters: Array<{ id: string; title: string; job_id: string | null; company: string | null; position: string | null }>;
+  reuse_count: number;
+}
+
+export interface DiffLine {
+  type: 'equal' | 'add' | 'remove';
+  text: string;
+}
+
+function containsNormalized(content: string, needle: string): boolean {
+  const normalize = (s: string) => s.toLowerCase().replace(/\s+/g, ' ').trim();
+  const n = normalize(needle);
+  return n.length >= 2 && normalize(content).includes(n);
+}
+
+export function getExperienceReuseMap(): ReuseReference[] {
+  const letters = coverLetterRepo.list().map((letter) => coverLetterRepo.get(letter.id, true)!).filter(Boolean);
+  const jobs = new Map(jobRepo.list().map((job) => [job.id, job]));
+  const refs: ReuseReference[] = [];
+
+  for (const exp of experienceRepo.list()) {
+    const needles = [exp.company, exp.role].filter((v): v is string => !!v && v.trim().length >= 2);
+    const matches = letters.filter((letter) => {
+      const body = letter.current_content ?? '';
+      return needles.some((needle) => containsNormalized(body, needle));
+    });
+    refs.push({
+      kind: 'experience',
+      entity_id: exp.id,
+      label: [exp.company, exp.role].filter(Boolean).join(' · '),
+      cover_letters: matches.map((letter) => {
+        const job = letter.job_id ? jobs.get(letter.job_id) : null;
+        return {
+          id: letter.id,
+          title: letter.title,
+          job_id: letter.job_id,
+          company: job?.company ?? null,
+          position: job?.position ?? null,
+        };
+      }),
+      reuse_count: matches.length,
+    });
+  }
+
+  for (const project of projectRepo.list()) {
+    const matches = letters.filter((letter) => containsNormalized(letter.current_content ?? '', project.name));
+    refs.push({
+      kind: 'project',
+      entity_id: project.id,
+      label: project.name,
+      cover_letters: matches.map((letter) => {
+        const job = letter.job_id ? jobs.get(letter.job_id) : null;
+        return {
+          id: letter.id,
+          title: letter.title,
+          job_id: letter.job_id,
+          company: job?.company ?? null,
+          position: job?.position ?? null,
+        };
+      }),
+      reuse_count: matches.length,
+    });
+  }
+
+  return refs.sort((a, b) => b.reuse_count - a.reuse_count || a.label.localeCompare(b.label));
+}
+
+export function diffText(before: string, after: string): DiffLine[] {
+  const a = before.replace(/\r\n/g, '\n').split('\n');
+  const b = after.replace(/\r\n/g, '\n').split('\n');
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const dp = Array.from({ length: rows }, () => new Uint32Array(cols));
+
+  for (let i = a.length - 1; i >= 0; i--) {
+    for (let j = b.length - 1; j >= 0; j--) {
+      dp[i]![j] = a[i] === b[j] ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
+    }
+  }
+
+  const result: DiffLine[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      result.push({ type: 'equal', text: a[i]! });
+      i++;
+      j++;
+    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
+      result.push({ type: 'remove', text: a[i]! });
+      i++;
+    } else {
+      result.push({ type: 'add', text: b[j]! });
+      j++;
+    }
+  }
+  while (i < a.length) result.push({ type: 'remove', text: a[i++]! });
+  while (j < b.length) result.push({ type: 'add', text: b[j++]! });
+  return result;
+}
+
+export function diffCoverLetterVersions(coverLetterId: string, beforeVersionId: string, afterVersionId: string) {
+  const letter = coverLetterRepo.get(coverLetterId, true);
+  if (!letter?.versions) return null;
+  const before = letter.versions.find((version) => version.id === beforeVersionId);
+  const after = letter.versions.find((version) => version.id === afterVersionId);
+  if (!before || !after) return null;
+  const lines = diffText(before.content, after.content);
+  return {
+    cover_letter_id: coverLetterId,
+    before: { id: before.id, version_no: before.version_no, source: before.source, created_at: before.created_at },
+    after: { id: after.id, version_no: after.version_no, source: after.source, created_at: after.created_at },
+    summary: {
+      added: lines.filter((line) => line.type === 'add').length,
+      removed: lines.filter((line) => line.type === 'remove').length,
+      unchanged: lines.filter((line) => line.type === 'equal').length,
+    },
+    lines,
+  };
+}

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,
@@ -350,6 +351,7 @@ export function updateApplicationStatus(
   status: ApplicationStatus,
   note?: string,
   submission?: ApplicationSubmission,
+  rejectedStage?: RejectedStage,
 ): StatusChangeResult {
   const job = jobRepo.get(jobId);
   if (!job) throw notFound('공고를 찾을 수 없습니다.');
@@ -358,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);
@@ -407,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),
     });