@hasna/microservices 0.0.15 → 0.0.17

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

@@ -1,89 +0,0 @@
-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

@@ -1,80 +0,0 @@
-/**
- * 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

@@ -1,206 +0,0 @@
-/**
- * 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 };