@hasna/microservices 0.0.3 → 0.0.5

package/microservices/microservice-hiring/src/db/migrations.ts

@@ -0,0 +1,89 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "initial_schema",
+    sql: `
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        department TEXT,
+        location TEXT,
+        type TEXT NOT NULL DEFAULT 'full-time' CHECK (type IN ('full-time', 'part-time', 'contract')),
+        status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'closed', 'paused')),
+        description TEXT,
+        requirements TEXT NOT NULL DEFAULT '[]',
+        salary_range TEXT,
+        posted_at TEXT,
+        closed_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS applicants (
+        id TEXT PRIMARY KEY,
+        job_id TEXT NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        email TEXT,
+        phone TEXT,
+        resume_url TEXT,
+        status TEXT NOT NULL DEFAULT 'applied' CHECK (status IN ('applied', 'screening', 'interviewing', 'offered', 'hired', 'rejected')),
+        stage TEXT,
+        rating INTEGER,
+        notes TEXT,
+        source TEXT,
+        applied_at TEXT NOT NULL DEFAULT (datetime('now')),
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS interviews (
+        id TEXT PRIMARY KEY,
+        applicant_id TEXT NOT NULL REFERENCES applicants(id) ON DELETE CASCADE,
+        interviewer TEXT,
+        scheduled_at TEXT,
+        duration_min INTEGER,
+        type TEXT NOT NULL DEFAULT 'phone' CHECK (type IN ('phone', 'video', 'onsite')),
+        status TEXT NOT NULL DEFAULT 'scheduled' CHECK (status IN ('scheduled', 'completed', 'canceled')),
+        feedback TEXT,
+        rating INTEGER,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+      CREATE INDEX IF NOT EXISTS idx_jobs_department ON jobs(department);
+      CREATE INDEX IF NOT EXISTS idx_applicants_job_id ON applicants(job_id);
+      CREATE INDEX IF NOT EXISTS idx_applicants_status ON applicants(status);
+      CREATE INDEX IF NOT EXISTS idx_applicants_email ON applicants(email);
+      CREATE INDEX IF NOT EXISTS idx_interviews_applicant_id ON interviews(applicant_id);
+      CREATE INDEX IF NOT EXISTS idx_interviews_status ON interviews(status);
+    `,
+  },
+  {
+    id: 2,
+    name: "add_job_templates",
+    sql: `
+      CREATE TABLE IF NOT EXISTS job_templates (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        title TEXT NOT NULL,
+        department TEXT,
+        location TEXT,
+        type TEXT NOT NULL DEFAULT 'full-time' CHECK (type IN ('full-time', 'part-time', 'contract')),
+        description TEXT,
+        requirements TEXT NOT NULL DEFAULT '[]',
+        salary_range TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_job_templates_name ON job_templates(name);
+    `,
+  },
+];

package/microservices/microservice-hiring/src/index.ts

@@ -0,0 +1,80 @@
+/**
+ * microservice-hiring — Applicant tracking and recruitment microservice
+ */
+
+export {
+  createJob,
+  getJob,
+  listJobs,
+  updateJob,
+  closeJob,
+  deleteJob,
+  type Job,
+  type CreateJobInput,
+  type UpdateJobInput,
+  type ListJobsOptions,
+} from "./db/hiring.js";
+
+export {
+  createApplicant,
+  getApplicant,
+  listApplicants,
+  updateApplicant,
+  advanceApplicant,
+  rejectApplicant,
+  deleteApplicant,
+  searchApplicants,
+  listByStage,
+  getPipeline,
+  getHiringStats,
+  type Applicant,
+  type CreateApplicantInput,
+  type UpdateApplicantInput,
+  type ListApplicantsOptions,
+  type PipelineEntry,
+  type HiringStats,
+} from "./db/hiring.js";
+
+export {
+  createInterview,
+  getInterview,
+  listInterviews,
+  updateInterview,
+  addInterviewFeedback,
+  deleteInterview,
+  type Interview,
+  type CreateInterviewInput,
+  type UpdateInterviewInput,
+  type ListInterviewsOptions,
+} from "./db/hiring.js";
+
+export {
+  bulkImportApplicants,
+  generateOffer,
+  getHiringForecast,
+  submitStructuredFeedback,
+  bulkReject,
+  getReferralStats,
+  saveJobAsTemplate,
+  getJobTemplate,
+  getJobTemplateByName,
+  listJobTemplates,
+  createJobFromTemplate,
+  deleteJobTemplate,
+  type BulkImportResult,
+  type OfferDetails,
+  type HiringForecast,
+  type StructuredFeedback,
+  type BulkRejectResult,
+  type ReferralStats,
+  type JobTemplate,
+} from "./db/hiring.js";
+
+export {
+  scoreApplicant,
+  rankApplicants,
+  type ScoreResult,
+  type RankEntry,
+} from "./lib/scoring.js";
+
+export { getDatabase, closeDatabase } from "./db/database.js";

package/microservices/microservice-hiring/src/lib/scoring.ts

@@ -0,0 +1,206 @@
+/**
+ * AI resume scoring — uses OpenAI or Anthropic to evaluate applicant fit
+ */
+
+import { getApplicant, getJob, updateApplicant } from "../db/hiring.js";
+import type { Applicant, Job } from "../db/hiring.js";
+
+export interface ScoreResult {
+  match_pct: number;
+  strengths: string[];
+  gaps: string[];
+  recommendation: string;
+}
+
+export interface RankEntry {
+  applicant: Applicant;
+  score: ScoreResult;
+}
+
+// ---- Provider abstraction ----
+
+async function callAI(prompt: string): Promise<string> {
+  // Try Anthropic first, then OpenAI
+  const anthropicKey = process.env["ANTHROPIC_API_KEY"];
+  const openaiKey = process.env["OPENAI_API_KEY"];
+
+  if (anthropicKey) {
+    return callAnthropic(anthropicKey, prompt);
+  }
+  if (openaiKey) {
+    return callOpenAI(openaiKey, prompt);
+  }
+
+  throw new Error(
+    "No AI API key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable."
+  );
+}
+
+async function callAnthropic(apiKey: string, prompt: string): Promise<string> {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 1024,
+      messages: [{ role: "user", content: prompt }],
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    content: Array<{ type: string; text: string }>;
+  };
+  return data.content[0]?.text || "";
+}
+
+async function callOpenAI(apiKey: string, prompt: string): Promise<string> {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 1024,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`OpenAI API error ${response.status}: ${text}`);
+  }
+
+  const data = (await response.json()) as {
+    choices: Array<{ message: { content: string } }>;
+  };
+  return data.choices[0]?.message?.content || "";
+}
+
+// ---- Scoring ----
+
+function buildScoringPrompt(job: Job, applicant: Applicant): string {
+  const requirements = job.requirements.length
+    ? job.requirements.join(", ")
+    : "No specific requirements listed";
+
+  const applicantInfo = [
+    `Name: ${applicant.name}`,
+    applicant.resume_url ? `Resume: ${applicant.resume_url}` : null,
+    applicant.notes ? `Notes/Summary: ${applicant.notes}` : null,
+    applicant.source ? `Source: ${applicant.source}` : null,
+    applicant.stage ? `Current stage: ${applicant.stage}` : null,
+    Object.keys(applicant.metadata).length > 0
+      ? `Additional info: ${JSON.stringify(applicant.metadata)}`
+      : null,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return `You are an expert hiring evaluator. Analyze this applicant against the job requirements and return a JSON assessment.
+
+JOB:
+Title: ${job.title}
+Department: ${job.department || "N/A"}
+Description: ${job.description || "N/A"}
+Requirements: ${requirements}
+Salary Range: ${job.salary_range || "N/A"}
+
+APPLICANT:
+${applicantInfo}
+
+Return ONLY a valid JSON object (no markdown, no code fences) with this exact structure:
+{
+  "match_pct": <number 0-100>,
+  "strengths": ["strength1", "strength2"],
+  "gaps": ["gap1", "gap2"],
+  "recommendation": "<hire/strong_hire/no_hire/maybe> — brief explanation"
+}`;
+}
+
+function parseScoreResponse(text: string): ScoreResult {
+  // Strip markdown code fences if present
+  let cleaned = text.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+  }
+
+  try {
+    const parsed = JSON.parse(cleaned);
+    return {
+      match_pct: Math.max(0, Math.min(100, Number(parsed.match_pct) || 0)),
+      strengths: Array.isArray(parsed.strengths) ? parsed.strengths : [],
+      gaps: Array.isArray(parsed.gaps) ? parsed.gaps : [],
+      recommendation: String(parsed.recommendation || "Unable to determine"),
+    };
+  } catch {
+    return {
+      match_pct: 0,
+      strengths: [],
+      gaps: [],
+      recommendation: `AI response could not be parsed: ${text.slice(0, 200)}`,
+    };
+  }
+}
+
+export async function scoreApplicant(applicantId: string): Promise<ScoreResult> {
+  const applicant = getApplicant(applicantId);
+  if (!applicant) throw new Error(`Applicant '${applicantId}' not found`);
+
+  const job = getJob(applicant.job_id);
+  if (!job) throw new Error(`Job '${applicant.job_id}' not found`);
+
+  const prompt = buildScoringPrompt(job, applicant);
+  const response = await callAI(prompt);
+  const score = parseScoreResponse(response);
+
+  // Store in applicant metadata
+  const metadata = { ...applicant.metadata, ai_score: score, scored_at: new Date().toISOString() };
+  updateApplicant(applicantId, { metadata });
+
+  return score;
+}
+
+export async function rankApplicants(jobId: string): Promise<RankEntry[]> {
+  const job = getJob(jobId);
+  if (!job) throw new Error(`Job '${jobId}' not found`);
+
+  const applicants = (await import("../db/hiring.js")).listApplicants({ job_id: jobId });
+
+  const results: RankEntry[] = [];
+
+  for (const applicant of applicants) {
+    // Use cached score if available and recent (less than 24h old)
+    const cached = applicant.metadata?.ai_score as ScoreResult | undefined;
+    const cachedAt = applicant.metadata?.scored_at as string | undefined;
+    const isFresh =
+      cachedAt && Date.now() - new Date(cachedAt).getTime() < 24 * 60 * 60 * 1000;
+
+    if (cached && isFresh) {
+      results.push({ applicant, score: cached });
+    } else {
+      const score = await scoreApplicant(applicant.id);
+      // Re-fetch to get updated metadata
+      const updated = getApplicant(applicant.id)!;
+      results.push({ applicant: updated, score });
+    }
+  }
+
+  // Sort by match_pct descending
+  results.sort((a, b) => b.score.match_pct - a.score.match_pct);
+
+  return results;
+}
+
+// Exported for testing
+export { buildScoringPrompt, parseScoreResponse, callAI };