careermate 0.0.8 → 0.0.9

package/packages/db/src/repositories.ts

@@ -21,11 +21,14 @@ import {
   type CoverLetterVersionRecord,
   type JobInput,
   type JobRecord,
+  type OfferInput,
+  type OfferRecord,
   type FitAnalysisInput,
   type FitAnalysisRecord,
   type ApplicationInput,
   type ApplicationRecord,
   type ApplicationStatus,
+  type RejectedStage,
   type InterviewPrepInput,
   type InterviewPrepRecord,
   type ActivityRecord,
@@ -659,6 +662,9 @@ function mapJob(r: any): JobRecord {
     company_overview: r.company_overview ?? null,
     talent_profile: r.talent_profile ?? null,
     core_values: fromJson(r.core_values, []),
+    reputation: r.reputation ?? null,
+    questions: fromJson(r.questions, []),
+    schedule: fromJson(r.schedule, []),
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -691,7 +697,7 @@ export const jobRepo = {
     if (existing) {
       const m = { ...existing, ...input } as JobRecord;
       db.prepare(
-        `UPDATE jobs SET company=?,position=?,url=?,location=?,employment_type=?,description=?,requirements=?,keywords=?,deadline=?,source=?,company_overview=?,talent_profile=?,core_values=?,updated_at=? WHERE id=?`,
+        `UPDATE jobs SET company=?,position=?,url=?,location=?,employment_type=?,description=?,requirements=?,keywords=?,deadline=?,source=?,company_overview=?,talent_profile=?,core_values=?,reputation=?,questions=?,schedule=?,updated_at=? WHERE id=?`,
       ).run(
         m.company,
         m.position,
@@ -706,6 +712,12 @@ export const jobRepo = {
         m.company_overview ?? null,
         m.talent_profile ?? null,
         toJson(m.core_values ?? []),
+        m.reputation ?? null,
+        // questions omitted from input → m keeps existing.questions (preserved);
+        // provided → replaced. Same merge semantics as the other JSON fields.
+        toJson(m.questions ?? []),
+        // schedule follows the same preserve-on-omit merge (v11 전형 일정).
+        toJson(m.schedule ?? []),
         ts,
         existing.id,
       );
@@ -713,8 +725,8 @@ export const jobRepo = {
     }
     const newJobId = id ?? newId('job_');
     db.prepare(
-      `INSERT INTO jobs (id,company,position,url,location,employment_type,description,requirements,keywords,deadline,source,company_overview,talent_profile,core_values,created_at,updated_at)
-       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+      `INSERT INTO jobs (id,company,position,url,location,employment_type,description,requirements,keywords,deadline,source,company_overview,talent_profile,core_values,reputation,questions,schedule,created_at,updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
     ).run(
       newJobId,
       input.company,
@@ -730,6 +742,9 @@ export const jobRepo = {
       input.company_overview ?? null,
       input.talent_profile ?? null,
       toJson(input.core_values ?? []),
+      input.reputation ?? null,
+      toJson(input.questions ?? []),
+      toJson(input.schedule ?? []),
       ts,
       ts,
     );
@@ -744,6 +759,9 @@ export const jobRepo = {
       db.prepare(`DELETE FROM applications WHERE job_id=?`).run(id);
       db.prepare(`DELETE FROM interview_preps WHERE job_id=?`).run(id);
       db.prepare(`DELETE FROM application_timeline_events WHERE job_id=?`).run(id);
+      // offers has ON DELETE CASCADE, but delete explicitly like the siblings above
+      // (consistent pattern + safe even if PRAGMA foreign_keys is ever off).
+      db.prepare(`DELETE FROM offers WHERE job_id=?`).run(id);
       return db.prepare(`DELETE FROM jobs WHERE id=?`).run(id).changes > 0;
     });
   },
@@ -827,6 +845,8 @@ function mapApplication(r: any): ApplicationRecord {
     cover_letter_id: r.cover_letter_id,
     applied_at: r.applied_at,
     notes: r.notes,
+    // 탈락 회고: 탈락이 아니거나 미기록이면 NULL(v10 이전 DB는 컬럼이 없어 undefined → null 정규화).
+    rejected_stage: r.rejected_stage ?? null,
     created_at: r.created_at,
     updated_at: r.updated_at,
   };
@@ -869,25 +889,39 @@ export const applicationRepo = {
     // A status change through upsert must respect the same lifecycle gate as setStatus.
     if (input.status && input.status !== app.status) assertStatusTransition(app.status, input.status);
     const m = { ...app, ...input } as ApplicationRecord;
+    // rejected_stage is only meaningful while status is 'rejected' (same invariant as
+    // setStatus): clear it on any transition back out, preserve it when staying
+    // rejected. ApplicationInput carries no rejected_stage, so m keeps the stored value.
+    const rejectedStageValue = m.status === 'rejected' ? m.rejected_stage ?? null : null;
     getDb()
       .prepare(
-        `UPDATE applications SET status=?,resume_id=?,cover_letter_id=?,applied_at=?,notes=?,updated_at=? WHERE id=?`,
+        `UPDATE applications SET status=?,resume_id=?,cover_letter_id=?,applied_at=?,notes=?,rejected_stage=?,updated_at=? WHERE id=?`,
       )
       // Coerce undefined → null: node:sqlite rejects undefined bindings, and a
       // caller that spreads explicit `undefined` fields (e.g. updateApplicationStatus
       // with a doc-less submission) would otherwise crash here mid-write.
-      .run(m.status, m.resume_id ?? null, m.cover_letter_id ?? null, m.applied_at ?? null, m.notes ?? null, now(), app.id);
+      .run(m.status, m.resume_id ?? null, m.cover_letter_id ?? null, m.applied_at ?? null, m.notes ?? null, rejectedStageValue, now(), app.id);
     return this.get(app.id)!;
   },
-  setStatus(jobId: string, status: ApplicationStatus, note?: string): ApplicationRecord {
+  setStatus(
+    jobId: string,
+    status: ApplicationStatus,
+    note?: string,
+    rejectedStage?: RejectedStage,
+  ): ApplicationRecord {
     const app = this.ensure(jobId);
     assertStatusTransition(app.status, status);
     const appliedAt =
       status === 'applied' && !app.applied_at ? now() : app.applied_at;
     const notes = note ? [app.notes, note].filter(Boolean).join('\n') : app.notes;
+    // 탈락 회고: 'rejected'일 때만 단계를 저장한다. 명시 값이 오면 갱신하고, 없으면 기존 값을
+    // 보존해(같은 rejected에 메모만 추가하는 등) 이미 남긴 회고를 지우지 않는다. rejected에서 다른
+    // 상태로 되살아나면 NULL로 초기화한다(정합성 — 탈락이 아닌데 단계가 남아 있으면 안 됨).
+    const rejectedStageValue =
+      status === 'rejected' ? rejectedStage ?? app.rejected_stage ?? null : null;
     getDb()
-      .prepare(`UPDATE applications SET status=?, applied_at=?, notes=?, updated_at=? WHERE id=?`)
-      .run(status, appliedAt, notes, now(), app.id);
+      .prepare(`UPDATE applications SET status=?, applied_at=?, notes=?, rejected_stage=?, updated_at=? WHERE id=?`)
+      .run(status, appliedAt, notes, rejectedStageValue, now(), app.id);
     return this.get(app.id)!;
   },
 };
@@ -1035,6 +1069,102 @@ export const timelineRepo = {
   },
 };
 
+/* -------------------------------------------------------------------- Offers */
+
+function mapOffer(r: any): OfferRecord {
+  const base = r.base_salary ?? null;
+  const bonus = r.bonus_amount ?? null;
+  const welfare = r.welfare_amount ?? null;
+  // Annual cash estimate = base + bonus + welfare (signing is one-time → excluded).
+  // null when no numeric cash piece was provided (can't estimate).
+  const hasAny = base != null || bonus != null || welfare != null;
+  const total = hasAny ? (base ?? 0) + (bonus ?? 0) + (welfare ?? 0) : null;
+  return {
+    id: r.id,
+    job_id: r.job_id,
+    offer_status: r.offer_status ?? 'open',
+    base_salary: base,
+    bonus_amount: bonus,
+    welfare_amount: welfare,
+    signing_amount: r.signing_amount ?? null,
+    equity_note: r.equity_note ?? null,
+    comp_note: r.comp_note ?? null,
+    work_arrangement: r.work_arrangement ?? null,
+    contract_type: r.contract_type ?? null,
+    accept_deadline: r.accept_deadline ?? null,
+    ai_score: r.ai_score ?? null,
+    verdict: r.verdict ?? null,
+    notes: r.notes ?? null,
+    total_comp_annual_est: total,
+    created_at: r.created_at,
+    updated_at: r.updated_at,
+  };
+}
+
+export const offerRepo = {
+  getByJob(jobId: string): OfferRecord | null {
+    const r = getDb().prepare(`SELECT * FROM offers WHERE job_id=?`).get(jobId);
+    return r ? mapOffer(r) : null;
+  },
+  list(): OfferRecord[] {
+    return (getDb().prepare(`SELECT * FROM offers ORDER BY ai_score IS NULL, ai_score DESC, updated_at DESC`).all() as any[]).map(mapOffer);
+  },
+  /** Upsert by job_id (one offer per job). Missing fields are preserved on update (partial-safe). */
+  save(input: OfferInput): OfferRecord {
+    const db = getDb();
+    const existing = this.getByJob(input.job_id);
+    const ts = now();
+    const n = (v: number | undefined, prev: number | null | undefined) => (v ?? prev ?? null);
+    const s = (v: string | undefined, prev: string | null | undefined) => (v ?? prev ?? null);
+    if (existing) {
+      db.prepare(
+        `UPDATE offers SET offer_status=?,base_salary=?,bonus_amount=?,welfare_amount=?,signing_amount=?,equity_note=?,comp_note=?,work_arrangement=?,contract_type=?,accept_deadline=?,ai_score=?,verdict=?,notes=?,updated_at=? WHERE id=?`,
+      ).run(
+        input.offer_status ?? existing.offer_status,
+        n(input.base_salary, existing.base_salary),
+        n(input.bonus_amount, existing.bonus_amount),
+        n(input.welfare_amount, existing.welfare_amount),
+        n(input.signing_amount, existing.signing_amount),
+        s(input.equity_note, existing.equity_note),
+        s(input.comp_note, existing.comp_note),
+        s(input.work_arrangement, existing.work_arrangement),
+        s(input.contract_type, existing.contract_type),
+        s(input.accept_deadline, existing.accept_deadline),
+        n(input.ai_score, existing.ai_score),
+        s(input.verdict, existing.verdict),
+        s(input.notes, existing.notes),
+        ts,
+        existing.id,
+      );
+      return this.getByJob(input.job_id)!;
+    }
+    const id = newId('ofr_');
+    db.prepare(
+      `INSERT INTO offers (id,job_id,offer_status,base_salary,bonus_amount,welfare_amount,signing_amount,equity_note,comp_note,work_arrangement,contract_type,accept_deadline,ai_score,verdict,notes,created_at,updated_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+    ).run(
+      id,
+      input.job_id,
+      input.offer_status ?? 'open',
+      input.base_salary ?? null,
+      input.bonus_amount ?? null,
+      input.welfare_amount ?? null,
+      input.signing_amount ?? null,
+      input.equity_note ?? null,
+      input.comp_note ?? null,
+      input.work_arrangement ?? null,
+      input.contract_type ?? null,
+      input.accept_deadline ?? null,
+      input.ai_score ?? null,
+      input.verdict ?? null,
+      input.notes ?? null,
+      ts,
+      ts,
+    );
+    return this.getByJob(input.job_id)!;
+  },
+};
+
 /* ------------------------------------------------------------------ Counts */
 
 /**
@@ -1058,6 +1188,7 @@ export function getEntityCounts(): Record<string, number> {
     'applications',
     'interview_preps',
     'application_timeline_events',
+    'offers',
   ]);
   const c = (t: string): number => {
     if (!ALLOWED_TABLES.has(t)) throw new Error(`getEntityCounts: 허용되지 않은 테이블 이름: ${t}`);
@@ -1074,5 +1205,6 @@ export function getEntityCounts(): Record<string, number> {
     applications: c('applications'),
     interview_preps: c('interview_preps'),
     application_timeline_events: c('application_timeline_events'),
+    offers: c('offers'),
   };
 }

package/packages/db/src/schema.ts

@@ -5,6 +5,16 @@
  * in `_meta`. Applying is idempotent and safe to run on every process start, so
  * both the web server and the MCP server can call `migrate()` on boot and share
  * the same database file without coordination.
+ *
+ * Crash safety (this DB is the user's only copy):
+ *  - Each migration runs in its own transaction and `schema_version` is stamped
+ *    inside that same transaction, so a step either fully applies (including its
+ *    version bump) or fully rolls back — a process death mid-upgrade can never
+ *    leave "applied but unrecorded" work that re-throws on the next boot.
+ *  - `ALTER TABLE … ADD COLUMN` statements are skipped when the column already
+ *    exists (SQLite has no IF NOT EXISTS for columns), so a DB damaged by the
+ *    pre-hardening runner self-heals instead of crash-looping on boot.
+ *  - A DB stamped by a NEWER CareerMate is left untouched (never stamped down).
  */
 import type { DatabaseSync } from 'node:sqlite';
 
@@ -329,6 +339,67 @@ export const MIGRATIONS: string[] = [
   `
   ALTER TABLE interview_preps ADD COLUMN debrief TEXT NOT NULL DEFAULT '{}';
   `,
+
+  // v7 — offer comparison (한국 총보상 필드) + company reputation research field on jobs.
+  // offers: one per job (UNIQUE job_id, mirrors interview_preps). Cash pieces are numeric (만원) so
+  // the server can deterministically sum an annual estimate; equity/other stay free-text (comp is
+  // messy). ai_score/verdict are written by the connected AI at save time (no LLM here) and rendered
+  // by the dashboard, so it never needs to call an LLM. jobs.reputation: AI-researched company
+  // reputation summary (same pattern as company_overview) — feeds offer verdicts + offer-evaluation.
+  `
+  CREATE TABLE IF NOT EXISTS offers (
+    id TEXT PRIMARY KEY,
+    job_id TEXT NOT NULL UNIQUE REFERENCES jobs(id) ON DELETE CASCADE,
+    base_salary INTEGER,
+    bonus_amount INTEGER,
+    welfare_amount INTEGER,
+    signing_amount INTEGER,
+    equity_note TEXT,
+    comp_note TEXT,
+    work_arrangement TEXT,
+    contract_type TEXT,
+    accept_deadline TEXT,
+    ai_score INTEGER,
+    verdict TEXT,
+    notes TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_offers_job ON offers(job_id);
+  ALTER TABLE jobs ADD COLUMN reputation TEXT;
+  `,
+
+  // v8 — offer lifecycle status. 지원 상태(전형 깔때기 = 회사의 프로세스)와 직교하는
+  // "내 응답" 축: open(진행)/accepted(수락)/declined(거절). declined여도 행을 지우지
+  // 않는다 — 조건(연봉·처우) 히스토리는 다음 협상의 자산이라, 대시보드가 접힌
+  // '지난 오퍼'로 강등해 보여줄 뿐이다. Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE offers ADD COLUMN offer_status TEXT NOT NULL DEFAULT 'open';
+  `,
+
+  // v9 — 한국 문항형 자소서: 회사가 지정한 문항·글자수를 공고에 구조화 보관. 한국 자소서는
+  // 회사별 문항형(항목·글자수 제한)이 지배적이라, AI가 문항별로 답변을 쓰고 글자수를 점검할 때
+  // 참조할 원본을 공고 옆에 둔다(별도 엔티티가 아니라 job 컨텍스트에 함께 실린다). JSON 배열을
+  // TEXT에 저장(다른 JSON 필드와 동일). Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE jobs ADD COLUMN questions TEXT NOT NULL DEFAULT '[]';
+  `,
+
+  // v10 — 탈락 회고: 어느 전형 단계에서 떨어졌는지 자가 기록. 탈락 사유를 고지하는 기업은 6%뿐이고
+  // 지원자 83%가 알고 싶어하므로, 이 자가 기록이 "서류는 붙는데 면접에서 떨어진다" 같은 패턴을 로컬
+  // 데이터로 드러내는 유일한 신호다. 탈락이 아니거나 미기록이면 NULL. Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE applications ADD COLUMN rejected_stage TEXT;
+  `,
+
+  // v11 — 전형 일정: 서류마감→인적성·AI역검→1·2차 면접→발표로 이어지는 단계별 날짜를 공고에
+  // 구조화 보관. 일정을 jobs에 두는 이유: 서류마감(deadline)이 이미 jobs에 있고, save_job_posting
+  // 업서트를 그대로 재사용해 도구 신설 없이 갱신할 수 있다. 면접초대 메일·발표 공지를 사용자가
+  // 붙여넣으면 AI가 날짜를 추출해 저장하고, 서버가 D-day·같은 날짜 충돌을 결정론으로 계산한다.
+  // JSON 배열을 TEXT에 저장(다른 JSON 필드와 동일). Additive ALTER (runner가 멱등 처리).
+  `
+  ALTER TABLE jobs ADD COLUMN schedule TEXT NOT NULL DEFAULT '[]';
+  `,
 ];
 
 export function migrate(db: DatabaseSync): { from: number; to: number } {
@@ -338,16 +409,77 @@ export function migrate(db: DatabaseSync): { from: number; to: number } {
     | undefined;
   const from = row ? Number(row.value) : 0;
 
+  // DB stamped by a newer CareerMate than this code: leave it alone. Stamping it
+  // back down would make the newer app re-run migrations it already applied.
+  if (from >= MIGRATIONS.length) return { from, to: from };
+
   for (let v = from; v < MIGRATIONS.length; v++) {
-    db.exec(MIGRATIONS[v]!);
+    applyMigration(db, v);
+  }
+  return { from, to: MIGRATIONS.length };
+}
+
+function stampVersion(db: DatabaseSync, version: number): void {
+  db.prepare(
+    `INSERT INTO _meta (key, value) VALUES ('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+  ).run(String(version));
+}
+
+function columnExists(db: DatabaseSync, table: string, column: string): boolean {
+  const rows = db
+    .prepare(`PRAGMA table_info("${table.replaceAll('"', '""')}")`)
+    .all() as Array<{ name: string }>;
+  return rows.some((r) => r.name === column);
+}
+
+// Migrations that manage their own BEGIN/COMMIT, by zero-based index into MIGRATIONS.
+// Only v2 (index 1) does: its FK rebuild toggles PRAGMA foreign_keys, a no-op inside
+// an open transaction, so the runner must NOT wrap it. Register any future
+// self-transactional migration here (a plain `sql.includes('BEGIN;')` sniff would
+// misfire if a normal migration ever contained the substring, e.g. in a comment).
+const SELF_TRANSACTIONAL_MIGRATIONS = new Set<number>([1]);
+
+// Style contract for column-adding migrations: every `ALTER TABLE <t> ADD COLUMN <c>
+// …;` MUST be a single statement on its own line so this regex can find it and the
+// idempotent-runner can drop it when the column already exists. A multi-column or
+// inline-with-other-DDL ALTER would slip past skipExistingColumns and crash a
+// partial-migration re-run. scripts/test-migrate.ts guards this with a count check
+// (loose ALTER…ADD COLUMN scan === strict per-line matches). Keep new ALTERs one-per-line.
+const ALTER_ADD_COLUMN_RE = /^[ \t]*ALTER TABLE\s+(\w+)\s+ADD COLUMN\s+(\w+)[^;]*;[ \t]*$/gm;
+export { ALTER_ADD_COLUMN_RE };
+
+/** Drop ADD COLUMN statements whose column already exists (idempotent re-run). */
+function skipExistingColumns(db: DatabaseSync, sql: string): string {
+  return sql.replace(ALTER_ADD_COLUMN_RE, (stmt, table: string, column: string) =>
+    columnExists(db, table, column) ? '' : stmt,
+  );
+}
+
+function applyMigration(db: DatabaseSync, v: number): void {
+  const sql = MIGRATIONS[v]!;
+
+  if (SELF_TRANSACTIONAL_MIGRATIONS.has(v)) {
+    // Self-transactional migration (v2 toggles PRAGMA foreign_keys, which is a
+    // no-op inside an open transaction, so it must manage BEGIN/COMMIT itself).
+    // Stamp right after; if the process dies in the tiny window between the two
+    // statements, re-running the rebuild is safe (it copies the data again).
+    db.exec(sql);
+    stampVersion(db, v + 1);
+    return;
   }
 
-  const to = MIGRATIONS.length;
-  if (to !== from) {
-    db.prepare(
-      `INSERT INTO _meta (key, value) VALUES ('schema_version', ?)
-       ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
-    ).run(String(to));
+  db.exec('BEGIN');
+  try {
+    db.exec(skipExistingColumns(db, sql));
+    stampVersion(db, v + 1);
+    db.exec('COMMIT');
+  } catch (err) {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      /* surface the original error */
+    }
+    throw err;
   }
-  return { from, to };
 }

package/packages/mcp-tools/src/result.ts

@@ -22,6 +22,15 @@ export interface ToolDef {
   inputSchema: ZodRawShape;
   /** Hint flags for clients (readOnly tools don't mutate). */
   readOnly?: boolean;
+  /**
+   * Tool reaches outside the user's machine (job-board fetch, npm registry).
+   * Must be honest — the privacy story depends on these hints being true.
+   */
+  openWorld?: boolean;
+  /** Irreversible effect (hard delete, package update). Default: non-destructive upsert. */
+  destructive?: boolean;
+  /** Repeating the same call with the same args has no additional effect (documented upserts). */
+  idempotent?: boolean;
   handler: (args: any) => ToolResult | Promise<ToolResult>;
 }