careermate 0.1.0

package/packages/core/src/services.ts

@@ -0,0 +1,146 @@
+/**
+ * Application services — the write-side use-cases shared by the HTTP API and the
+ * MCP server. Centralizing them here guarantees both interfaces behave
+ * identically and that every meaningful change is recorded in the activity feed.
+ *
+ * PRIVACY RULE: activity summaries and logs may reference titles, companies and
+ * positions, but MUST NEVER contain résumé or cover-letter body text.
+ */
+import {
+  type JobInput,
+  type JobRecord,
+  type FitAnalysisInput,
+  type FitAnalysisRecord,
+  type CoverLetterVersionInput,
+  type ApplicationStatus,
+  type ApplicationRecord,
+  type InterviewPrepInput,
+  type InterviewPrepRecord,
+  type DocumentInput,
+  type DocumentRecord,
+  type ProfileInput,
+  type ProfileRecord,
+  APPLICATION_STATUS_LABELS,
+  INTERVIEW_UNLOCK_STATUSES,
+} from '@careermate/shared';
+import {
+  jobRepo,
+  fitRepo,
+  coverLetterRepo,
+  applicationRepo,
+  interviewRepo,
+  documentRepo,
+  profileRepo,
+  activityRepo,
+} from '@careermate/db';
+
+/* ----------------------------------------------------------------- Profile */
+
+export function saveProfile(input: ProfileInput): ProfileRecord {
+  const p = profileRepo.save(input);
+  activityRepo.log('profile_updated', `프로필을 ${p.name ? `(${p.name}) ` : ''}저장했습니다.`, 'profile', p.id);
+  return p;
+}
+
+/* ---------------------------------------------------------------- Resumes */
+
+export function addResume(input: Omit<DocumentInput, 'kind'> & { kind?: DocumentInput['kind'] }): DocumentRecord {
+  const doc = documentRepo.add({ ...input, kind: input.kind ?? 'resume' });
+  activityRepo.log('resume_added', `${doc.title} 문서를 추가했습니다.`, 'document', doc.id);
+  return doc;
+}
+
+/* -------------------------------------------------------------------- Jobs */
+
+/** Save (or update) a posting and make sure an application row tracks it. */
+export function saveJobPosting(input: JobInput, id?: string): { job: JobRecord; application: ApplicationRecord } {
+  const job = jobRepo.upsert(input, id);
+  const application = applicationRepo.ensure(job.id, 'draft');
+  activityRepo.log('job_saved', `${job.company} · ${job.position} 공고를 저장했습니다.`, 'job', job.id);
+  return { job, application };
+}
+
+/* ------------------------------------------------------------ Fit analysis */
+
+export function saveFitAnalysis(input: FitAnalysisInput): FitAnalysisRecord {
+  const job = jobRepo.get(input.job_id);
+  if (!job) throw new Error(`공고를 찾을 수 없습니다: ${input.job_id}. 먼저 save_job_posting으로 공고를 저장하세요.`);
+  applicationRepo.ensure(job.id, 'draft');
+  const fit = fitRepo.save(input);
+  const scoreText = fit.score != null ? ` (적합도 ${fit.score}점)` : '';
+  activityRepo.log('fit_analysis_saved', `${job.company} · ${job.position} 적합도 분석을 저장했습니다${scoreText}.`, 'fit_analysis', fit.id);
+  return fit;
+}
+
+/* ----------------------------------------------------------- Cover letters */
+
+export function saveCoverLetterVersion(input: CoverLetterVersionInput) {
+  const { coverLetter, version } = coverLetterRepo.addVersion({
+    cover_letter_id: input.cover_letter_id,
+    title: input.title,
+    job_id: input.job_id ?? null,
+    content: input.content,
+    note: input.note,
+    source: input.source ?? 'ai',
+    set_current: input.set_current,
+  });
+  // Link the application to this cover letter when tied to a job.
+  if (coverLetter.job_id) {
+    const app = applicationRepo.getByJob(coverLetter.job_id);
+    if (app && !app.cover_letter_id) {
+      applicationRepo.upsert({ job_id: coverLetter.job_id, cover_letter_id: coverLetter.id });
+    }
+  }
+  activityRepo.log(
+    'cover_letter_version_saved',
+    `${coverLetter.title} 자기소개서 v${version.version_no}를 저장했습니다.`,
+    'cover_letter',
+    coverLetter.id,
+  );
+  return { coverLetter, version };
+}
+
+/* ------------------------------------------------- Application status flow */
+
+export interface StatusChangeResult {
+  application: ApplicationRecord;
+  job: JobRecord | null;
+  interview_unlocked: boolean;
+  hint: string | null;
+}
+
+export function updateApplicationStatus(
+  jobId: string,
+  status: ApplicationStatus,
+  note?: string,
+): StatusChangeResult {
+  const job = jobRepo.get(jobId);
+  if (!job) throw new Error(`공고를 찾을 수 없습니다: ${jobId}`);
+  const application = applicationRepo.setStatus(jobId, status, note);
+  activityRepo.log(
+    'application_status_changed',
+    `${job.company} · ${job.position} 상태를 '${APPLICATION_STATUS_LABELS[status]}'(으)로 변경했습니다.`,
+    'application',
+    application.id,
+  );
+
+  const interview_unlocked = INTERVIEW_UNLOCK_STATUSES.includes(status);
+  const hasPrep = !!interviewRepo.getByJob(jobId);
+  const hint =
+    interview_unlocked && !hasPrep
+      ? '서류 단계를 통과했어요. 이 공고 기준으로 예상 면접 질문과 1분 자기소개를 준비할까요? (save_interview_prep)'
+      : null;
+
+  return { application, job, interview_unlocked, hint };
+}
+
+/* --------------------------------------------------------- Interview prep */
+
+export function saveInterviewPrep(input: InterviewPrepInput): InterviewPrepRecord {
+  const job = jobRepo.get(input.job_id);
+  if (!job) throw new Error(`공고를 찾을 수 없습니다: ${input.job_id}`);
+  applicationRepo.ensure(job.id);
+  const prep = interviewRepo.save(input);
+  activityRepo.log('interview_prep_saved', `${job.company} · ${job.position} 면접 준비 자료를 저장했습니다.`, 'interview_prep', prep.id);
+  return prep;
+}

package/packages/core/src/summary.ts

@@ -0,0 +1,104 @@
+/**
+ * Home dashboard summary + recent activity. Read-only aggregation that answers
+ * "what should I do right now?" at a glance.
+ */
+import {
+  type ApplicationStatus,
+  APPLICATION_STATUS_LABELS,
+  INTERVIEW_UNLOCK_STATUSES,
+  type JobRecord,
+  type ApplicationRecord,
+  type CoverLetterRecord,
+  type ActivityRecord,
+} from '@careermate/shared';
+import {
+  jobRepo,
+  applicationRepo,
+  coverLetterRepo,
+  interviewRepo,
+  fitRepo,
+  activityRepo,
+} from '@careermate/db';
+import { getOnboardingStatus } from './onboarding.ts';
+
+export interface JobWithMeta extends JobRecord {
+  status: ApplicationStatus;
+  status_label: string;
+  fit_score: number | null;
+}
+
+export interface HomeSummary {
+  onboarding: ReturnType<typeof getOnboardingStatus>;
+  counts: {
+    jobs: number;
+    active_applications: number;
+    cover_letters: number;
+    interview_pending: number;
+  };
+  status_breakdown: { status: ApplicationStatus; label: string; count: number }[];
+  recent_jobs: JobWithMeta[];
+  in_progress: { application: ApplicationRecord; job: JobRecord | null; status_label: string }[];
+  recent_cover_letters: CoverLetterRecord[];
+  interview_todo: { job: JobRecord; status_label: string }[];
+  recent_activity: ActivityRecord[];
+}
+
+const ACTIVE: ApplicationStatus[] = ['draft', 'planned', 'applied', 'document_passed', 'interview'];
+
+export function jobWithMeta(job: JobRecord): JobWithMeta {
+  const app = applicationRepo.getByJob(job.id);
+  const fit = fitRepo.getByJob(job.id);
+  const status = app?.status ?? 'draft';
+  return { ...job, status, status_label: APPLICATION_STATUS_LABELS[status], fit_score: fit?.score ?? null };
+}
+
+export function getHomeSummary(): HomeSummary {
+  const onboarding = getOnboardingStatus();
+  const jobs = jobRepo.list();
+  const applications = applicationRepo.list();
+  const coverLetters = coverLetterRepo.list();
+
+  const status_breakdown = (Object.keys(APPLICATION_STATUS_LABELS) as ApplicationStatus[]).map((status) => ({
+    status,
+    label: APPLICATION_STATUS_LABELS[status],
+    count: applications.filter((a) => a.status === status).length,
+  }));
+
+  const active = applications.filter((a) => ACTIVE.includes(a.status));
+
+  // Interview to-do: passed-to-interview stages without saved prep yet.
+  const interview_todo = applications
+    .filter((a) => INTERVIEW_UNLOCK_STATUSES.includes(a.status) && !interviewRepo.getByJob(a.job_id))
+    .map((a) => {
+      const job = jobRepo.get(a.job_id);
+      return job ? { job, status_label: APPLICATION_STATUS_LABELS[a.status] } : null;
+    })
+    .filter((x): x is { job: JobRecord; status_label: string } => x !== null);
+
+  return {
+    onboarding,
+    counts: {
+      jobs: jobs.length,
+      active_applications: active.length,
+      cover_letters: coverLetters.length,
+      interview_pending: interview_todo.length,
+    },
+    status_breakdown,
+    recent_jobs: jobs.slice(0, 6).map(jobWithMeta),
+    in_progress: active.slice(0, 6).map((application) => {
+      const job = jobRepo.get(application.job_id);
+      return {
+        application,
+        job,
+        status_label: APPLICATION_STATUS_LABELS[application.status],
+      };
+    }),
+    recent_cover_letters: coverLetters.slice(0, 5),
+    interview_todo,
+    recent_activity: activityRepo.recent(10),
+  };
+}
+
+export function listRecentActivity(limit = 20): ActivityRecord[] {
+  return activityRepo.recent(limit);
+}

package/packages/db/src/connection.ts

@@ -0,0 +1,46 @@
+/**
+ * Single shared DatabaseSync connection.
+ *
+ * Both the web server and the MCP server import this. SQLite with WAL handles
+ * the two-process concurrency (dashboard editing + AI writing) cleanly.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { getDbPath } from './paths.ts';
+import { migrate } from './schema.ts';
+
+let _db: DatabaseSync | null = null;
+
+export function getDb(): DatabaseSync {
+  if (_db) return _db;
+  const db = new DatabaseSync(getDbPath());
+  db.exec('PRAGMA journal_mode = WAL;');
+  db.exec('PRAGMA foreign_keys = ON;');
+  db.exec('PRAGMA busy_timeout = 5000;');
+  migrate(db);
+  _db = db;
+  return db;
+}
+
+export function closeDb(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+
+/** Helpers for the JSON-text columns. */
+export function toJson(value: unknown): string {
+  return JSON.stringify(value ?? null);
+}
+
+export function fromJson<T>(text: string | null | undefined, fallback: T): T {
+  if (text == null || text === '') return fallback;
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export const toBit = (b: boolean | undefined | null): number => (b ? 1 : 0);
+export const fromBit = (n: number | null | undefined): boolean => Number(n) === 1;

package/packages/db/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * @careermate/db — SQLite persistence (built on Node's flag-free `node:sqlite`,
+ * so there is no native module to compile). Exposes a shared connection,
+ * migrations, and one repository object per entity.
+ */
+export * from './paths.ts';
+export * from './runtime.ts';
+export * from './connection.ts';
+export { migrate, MIGRATIONS } from './schema.ts';
+export {
+  profileRepo,
+  experienceRepo,
+  projectRepo,
+  skillRepo,
+  documentRepo,
+  coverLetterRepo,
+  jobRepo,
+  fitRepo,
+  applicationRepo,
+  interviewRepo,
+  activityRepo,
+} from './repositories.ts';

package/packages/db/src/paths.ts

@@ -0,0 +1,41 @@
+/**
+ * Resolves where CareerMate keeps its local data. Everything is on the user's
+ * machine — no cloud, no external transfer. The location is overridable so power
+ * users can relocate it and the Settings page can display it.
+ *
+ * Priority:
+ *   1. CAREERMATE_DATA_DIR env var (absolute path)
+ *   2. ~/.careermate            (default)
+ */
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export function getDataDir(): string {
+  const override = process.env.CAREERMATE_DATA_DIR?.trim();
+  const dir = override && override.length > 0 ? override : path.join(os.homedir(), '.careermate');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getDbPath(): string {
+  return path.join(getDataDir(), 'careermate.sqlite');
+}
+
+export function getExportsDir(): string {
+  const dir = path.join(getDataDir(), 'exports');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getUploadsDir(): string {
+  const dir = path.join(getDataDir(), 'uploads');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getBackupsDir(): string {
+  const dir = path.join(getDataDir(), 'backups');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}