calibrcv 1.0.0

package/src/lib/latex-compiler.js

@@ -0,0 +1,125 @@
+import { PDFDocument } from 'pdf-lib';
+import { execSync } from 'child_process';
+import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { validateLatex } from './latex-escape.js';
+
+/**
+ * Compile LaTeX source to PDF.
+ * Tries: tectonic -> pdflatex -> latexmk+xelatex -> fallback (source only).
+ *
+ * @param {string} latexSource - Complete LaTeX document source.
+ * @returns {Promise<{ pdfBuffer: Buffer|null, pageCount: number, compilationMethod: string, latexSource: string, error?: string }>}
+ */
+export async function compileLaTeX(latexSource) {
+  const validation = validateLatex(latexSource);
+  if (!validation.valid) {
+    return {
+      pdfBuffer: null,
+      pageCount: 0,
+      compilationMethod: 'none',
+      latexSource,
+      error: `LaTeX validation failed: ${validation.errors.join('; ')}`,
+    };
+  }
+
+  const jobId = randomUUID().slice(0, 8);
+  const tmpDir = join('/tmp', `calibrcv-${jobId}`);
+  const env = { ...process.env, PATH: `${process.env.PATH}:/Library/TeX/texbin:/usr/local/bin` };
+
+  try {
+    if (!existsSync(tmpDir)) {
+      mkdirSync(tmpDir, { recursive: true });
+    }
+
+    const texPath = join(tmpDir, 'resume.tex');
+    const pdfPath = join(tmpDir, 'resume.pdf');
+    writeFileSync(texPath, latexSource, 'utf-8');
+
+    // Strategy 1: tectonic
+    try {
+      execSync(`tectonic "${texPath}" --outdir "${tmpDir}" 2>&1`, {
+        timeout: 30000, stdio: 'pipe', env,
+      });
+      if (existsSync(pdfPath)) {
+        const pdfBuffer = readFileSync(pdfPath);
+        const pageCount = await countPages(pdfBuffer);
+        cleanup(tmpDir);
+        return { pdfBuffer, pageCount, compilationMethod: 'tectonic', latexSource };
+      }
+    } catch (_) { /* try next */ }
+
+    // Strategy 2: pdflatex
+    try {
+      execSync(
+        `cd "${tmpDir}" && pdflatex -interaction=nonstopmode -halt-on-error resume.tex 2>&1`,
+        { timeout: 30000, stdio: 'pipe', env }
+      );
+      if (existsSync(pdfPath)) {
+        const pdfBuffer = readFileSync(pdfPath);
+        const pageCount = await countPages(pdfBuffer);
+        cleanup(tmpDir);
+        return { pdfBuffer, pageCount, compilationMethod: 'pdflatex', latexSource };
+      }
+    } catch (_) { /* try next */ }
+
+    // Strategy 3: latexmk + xelatex
+    try {
+      execSync(
+        `cd "${tmpDir}" && latexmk -xelatex -interaction=nonstopmode -halt-on-error resume.tex 2>&1`,
+        { timeout: 45000, stdio: 'pipe', env }
+      );
+      if (existsSync(pdfPath)) {
+        const pdfBuffer = readFileSync(pdfPath);
+        const pageCount = await countPages(pdfBuffer);
+        cleanup(tmpDir);
+        return { pdfBuffer, pageCount, compilationMethod: 'xelatex', latexSource };
+      }
+    } catch (_) { /* try next */ }
+
+    // Strategy 4: Fallback
+    cleanup(tmpDir);
+    return {
+      pdfBuffer: null,
+      pageCount: 0,
+      compilationMethod: 'none',
+      latexSource,
+      error: 'No LaTeX compiler found. Install tectonic (brew install tectonic) or texlive. Your .tex source has been saved.',
+    };
+
+  } catch (err) {
+    cleanup(tmpDir);
+    return {
+      pdfBuffer: null,
+      pageCount: 0,
+      compilationMethod: 'none',
+      latexSource,
+      error: `Compilation error: ${err.message}`,
+    };
+  }
+}
+
+/**
+ * Count pages in a PDF buffer.
+ */
+export async function countPages(pdfBuffer) {
+  try {
+    const pdfDoc = await PDFDocument.load(pdfBuffer);
+    return pdfDoc.getPageCount();
+  } catch (_) {
+    return 1;
+  }
+}
+
+function cleanup(dirPath) {
+  try {
+    const files = ['resume.tex', 'resume.pdf', 'resume.aux', 'resume.log',
+                   'resume.out', 'resume.fls', 'resume.fdb_latexmk', 'resume.xdv',
+                   'resume.synctex.gz'];
+    for (const f of files) {
+      const fp = join(dirPath, f);
+      if (existsSync(fp)) unlinkSync(fp);
+    }
+  } catch (_) { /* non-critical */ }
+}

package/src/lib/latex-escape.js

@@ -0,0 +1,58 @@
+/**
+ * Escape special LaTeX characters in text content.
+ * @param {string} text - Raw text to escape.
+ * @returns {string} LaTeX-safe text.
+ */
+export function escapeLatex(text) {
+  if (!text || typeof text !== 'string') return '';
+
+  return text
+    .replace(/\\/g, '\\textbackslash{}')
+    .replace(/&/g, '\\&')
+    .replace(/%/g, '\\%')
+    .replace(/\$/g, '\\$')
+    .replace(/#/g, '\\#')
+    .replace(/_/g, '\\_')
+    .replace(/\{/g, '\\{')
+    .replace(/\}/g, '\\}')
+    .replace(/~/g, '\\textasciitilde{}')
+    .replace(/\^/g, '\\textasciicircum{}')
+    .replace(/>/g, '$>$')
+    .replace(/</g, '$<$')
+    .replace(/—/g, ';')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201C\u201D]/g, '"');
+}
+
+/**
+ * Validate that a LaTeX source string is structurally valid.
+ * @param {string} latexSource
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateLatex(latexSource) {
+  const errors = [];
+
+  if (!latexSource || typeof latexSource !== 'string') {
+    return { valid: false, errors: ['LaTeX source is empty or not a string'] };
+  }
+
+  const trimmed = latexSource.trim();
+
+  if (!trimmed.startsWith('\\documentclass')) {
+    errors.push('Missing \\documentclass at start');
+  }
+  if (!trimmed.endsWith('\\end{document}')) {
+    errors.push('Missing \\end{document} at end');
+  }
+  if (!trimmed.includes('\\begin{document}')) {
+    errors.push('Missing \\begin{document}');
+  }
+  if (!trimmed.includes('\\pdfgentounicode=1')) {
+    errors.push('Missing \\pdfgentounicode=1');
+  }
+  if (/—/.test(trimmed)) {
+    errors.push('Contains em dashes which break LaTeX compilation');
+  }
+
+  return { valid: errors.length === 0, errors };
+}

package/src/lib/page-loop.js

@@ -0,0 +1,99 @@
+import { buildTrimPrompt } from '../prompts/trim.js';
+import { validateLatex } from './latex-escape.js';
+
+const MAX_ITERATIONS = 6;
+
+/**
+ * Agentic 1-page enforcement loop.
+ * Compiles LaTeX, checks page count, iteratively trims until it fits on 1 page.
+ *
+ * @param {string} latexCode - Initial LaTeX source.
+ * @param {string} targetSector - Target industry sector.
+ * @param {Function} callAI - The AI router function.
+ * @param {Function} compileFn - LaTeX compilation function.
+ * @param {Function} [onProgress] - Optional progress callback.
+ * @returns {Promise<{ latexCode: string, pdfBuffer: Buffer|null, pageCount: number, iterations: number, warning?: string }>}
+ */
+export async function enforceOnePage(latexCode, targetSector, callAI, compileFn, onProgress = null) {
+  let currentLatex = latexCode;
+  let lastResult = null;
+
+  for (let iteration = 0; iteration <= MAX_ITERATIONS; iteration++) {
+    if (onProgress) {
+      onProgress({ iteration, pageCount: null, stage: 'compiling' });
+    }
+
+    const result = await compileFn(currentLatex);
+    lastResult = result;
+
+    if (!result.pdfBuffer) {
+      return {
+        latexCode: currentLatex,
+        pdfBuffer: null,
+        pageCount: 0,
+        iterations: iteration,
+        warning: `Compilation failed: ${result.error}`,
+      };
+    }
+
+    if (onProgress) {
+      onProgress({ iteration, pageCount: result.pageCount, stage: 'checking' });
+    }
+
+    if (result.pageCount === 1) {
+      return {
+        latexCode: currentLatex,
+        pdfBuffer: result.pdfBuffer,
+        pageCount: 1,
+        iterations: iteration,
+      };
+    }
+
+    if (iteration >= MAX_ITERATIONS) {
+      return {
+        latexCode: currentLatex,
+        pdfBuffer: result.pdfBuffer,
+        pageCount: result.pageCount,
+        iterations: iteration,
+        warning: `Could not fit to 1 page after ${MAX_ITERATIONS} attempts. Current: ${result.pageCount} pages`,
+      };
+    }
+
+    if (onProgress) {
+      onProgress({ iteration: iteration + 1, pageCount: result.pageCount, stage: 'trimming' });
+    }
+
+    try {
+      let trimmedLatex = await callAI(
+        buildTrimPrompt(targetSector, result.pageCount, iteration + 1),
+        `Current LaTeX:\n${currentLatex}`,
+        { responseFormat: 'text', taskName: `trim-iteration-${iteration + 1}` }
+      );
+
+      let cleaned = trimmedLatex.trim();
+      if (cleaned.startsWith('```')) {
+        cleaned = cleaned
+          .replace(/^```(?:latex|tex)?\n?/m, '')
+          .replace(/\n?```$/m, '')
+          .trim();
+      }
+
+      const validation = validateLatex(cleaned);
+      if (!validation.valid) {
+        continue;
+      }
+
+      currentLatex = cleaned;
+    } catch (_) {
+      // Continue with the current version
+    }
+  }
+
+  return {
+    latexCode: currentLatex,
+    pdfBuffer: lastResult?.pdfBuffer || null,
+    pageCount: lastResult?.pageCount || 0,
+    iterations: MAX_ITERATIONS,
+    warning: 'Exhausted all trim iterations',
+  };
+}

package/src/lib/pdf-extractor.js

@@ -0,0 +1,49 @@
+import pdfParse from 'pdf-parse';
+
+/**
+ * Extract plain text from a PDF buffer.
+ * @param {Buffer} pdfBuffer - Raw PDF file bytes.
+ * @returns {Promise<{ text: string, pages: number, info: object }>}
+ */
+export async function extractTextFromPDF(pdfBuffer) {
+  if (!pdfBuffer || pdfBuffer.length === 0) {
+    throw new PDFExtractionError('Empty PDF buffer provided');
+  }
+
+  try {
+    const data = await pdfParse(pdfBuffer, { max: 10 });
+    const text = data.text?.trim() || '';
+
+    if (text.length < 50) {
+      throw new PDFExtractionError(
+        'PDF appears to contain very little text. It may be image-based or scanned. ' +
+        'Please use a text-based PDF for best results.'
+      );
+    }
+
+    return {
+      text,
+      pages: data.numpages || 1,
+      info: {
+        title: data.info?.Title || null,
+        author: data.info?.Author || null,
+        creator: data.info?.Creator || null,
+      },
+    };
+  } catch (err) {
+    if (err instanceof PDFExtractionError) throw err;
+
+    if (err.message?.includes('encrypted') || err.message?.includes('password')) {
+      throw new PDFExtractionError('This PDF is password-protected. Please use an unprotected version.');
+    }
+
+    throw new PDFExtractionError(`Failed to parse PDF: ${err.message}`);
+  }
+}
+
+export class PDFExtractionError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'PDFExtractionError';
+  }
+}

package/src/pipeline/orchestrator.js

@@ -0,0 +1,197 @@
+import EventEmitter from 'events';
+import { callAI, parseJSONSafely } from '../lib/ai-router.js';
+import { extractTextFromPDF } from '../lib/pdf-extractor.js';
+import { buildAnalyzePrompt } from '../prompts/analyze.js';
+import { buildSynthesizePrompt } from '../prompts/synthesize.js';
+import { buildLatexPrompt } from '../prompts/latex.js';
+import { buildTailorPrompt } from '../prompts/tailor.js';
+import { enforceOnePage } from '../lib/page-loop.js';
+import { compileLaTeX } from '../lib/latex-compiler.js';
+import { atsScorer } from '../lib/ats-scorer.js';
+import { writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+/**
+ * ResumePipeline: orchestrates the full resume build.
+ * Refactored for CLI: no Supabase, no SSE, writes to local disk.
+ */
+export class ResumePipeline extends EventEmitter {
+
+  constructor() {
+    super();
+    this.state = 'idle';
+  }
+
+  setState(state, message, progress) {
+    this.state = state;
+    this.emit('progress', { state, message, progress });
+  }
+
+  /**
+   * Run the full resume build pipeline.
+   *
+   * @param {object} params
+   * @param {Buffer} params.pdfBuffer - Raw PDF file bytes.
+   * @param {string} params.targetSector - Target industry sector.
+   * @param {Array|null} [params.enrichmentAnswers] - Answers from enrichment interview.
+   * @param {string|null} [params.resumeText] - Pre-extracted resume text.
+   * @param {object|null} [params.analysis] - Pre-computed analysis.
+   * @param {string|null} [params.jobDescription] - Job description text for tailoring.
+   * @param {string|null} [params.outputPath] - Where to write the PDF.
+   * @returns {Promise<object>}
+   */
+  async run({
+    pdfBuffer,
+    targetSector,
+    enrichmentAnswers = null,
+    resumeText = null,
+    analysis = null,
+    jobDescription = null,
+    outputPath = null,
+  }) {
+    try {
+      // STAGE 1: Parse PDF
+      let text = resumeText;
+      if (!text) {
+        this.setState('parsing', 'Extracting resume content...', 5);
+        const extracted = await extractTextFromPDF(pdfBuffer);
+        text = extracted.text;
+      }
+
+      // STAGE 2: Analyze
+      let analysisResult = analysis;
+      if (!analysisResult) {
+        this.setState('analyzing', 'Analyzing your profile...', 15);
+        const raw = await callAI(
+          buildAnalyzePrompt(targetSector),
+          `Resume text:\n${text}`,
+          { responseFormat: 'json', taskName: 'analyze' }
+        );
+        analysisResult = parseJSONSafely(raw);
+      }
+
+      // STAGE 3: Enrichment Gate
+      if (!enrichmentAnswers) {
+        this.setState('enriching', 'Waiting for your answers...', 25);
+        return {
+          requiresEnrichment: true,
+          questions: analysisResult.follow_up_questions,
+          analysis: analysisResult,
+          resumeText: text,
+        };
+      }
+
+      // STAGE 4: Synthesize Content
+      this.setState('synthesizing', 'Rewriting with CalibrCV rules...', 45);
+      const enrichmentContext = enrichmentAnswers
+        .map(a => `Q: ${a.question}\nA: ${a.answer}`)
+        .join('\n\n');
+
+      const synthesisRaw = await callAI(
+        buildSynthesizePrompt(targetSector),
+        `Original resume:\n${text}\n\nEnrichment answers:\n${enrichmentContext}`,
+        { responseFormat: 'json', taskName: 'synthesize' }
+      );
+      let resumeJSON = parseJSONSafely(synthesisRaw);
+
+      // STAGE 4b: Tailor (optional)
+      if (jobDescription) {
+        this.setState('tailoring', 'Tailoring for the target role...', 50);
+        const tailorRaw = await callAI(
+          buildTailorPrompt(
+            resumeJSON.experience?.[0]?.title || 'Target Role',
+            'Target Company'
+          ),
+          `Master resume JSON:\n${JSON.stringify(resumeJSON, null, 2)}\n\nJob description:\n${jobDescription}`,
+          { responseFormat: 'json', taskName: 'tailor' }
+        );
+        resumeJSON = parseJSONSafely(tailorRaw);
+      }
+
+      // STAGE 5: Generate LaTeX
+      this.setState('generating_latex', 'Engineering your layout...', 60);
+      let latexRaw = await callAI(
+        buildLatexPrompt(),
+        `Resume JSON:\n${JSON.stringify(resumeJSON, null, 2)}`,
+        { responseFormat: 'text', taskName: 'generate-latex' }
+      );
+
+      if (latexRaw.trim().startsWith('```')) {
+        latexRaw = latexRaw
+          .replace(/^```(?:latex|tex)?\n?/m, '')
+          .replace(/\n?```$/m, '')
+          .trim();
+      }
+
+      if (!latexRaw.trim().startsWith('\\documentclass')) {
+        latexRaw = await callAI(
+          buildLatexPrompt(),
+          `IMPORTANT: Return ONLY raw LaTeX starting with \\documentclass.\n\nResume JSON:\n${JSON.stringify(resumeJSON, null, 2)}`,
+          { responseFormat: 'text', taskName: 'generate-latex-retry' }
+        );
+        if (latexRaw.trim().startsWith('```')) {
+          latexRaw = latexRaw
+            .replace(/^```(?:latex|tex)?\n?/m, '')
+            .replace(/\n?```$/m, '')
+            .trim();
+        }
+        if (!latexRaw.trim().startsWith('\\documentclass')) {
+          throw new Error('AI returned invalid LaTeX after 2 attempts');
+        }
+      }
+
+      // STAGE 6+7: Compile + 1-page Enforcement
+      this.setState('compiling', 'Compiling to PDF...', 70);
+      const { latexCode, pdfBuffer: compiledPDF, pageCount, iterations, warning } =
+        await enforceOnePage(
+          latexRaw,
+          targetSector,
+          callAI,
+          compileLaTeX,
+          (progress) => {
+            if (progress.stage === 'trimming') {
+              this.setState('trimming',
+                `Fitting to one page (attempt ${progress.iteration}/6)...`,
+                70 + (progress.iteration * 3));
+            } else if (progress.stage === 'checking') {
+              this.setState('checking_pages', 'Verifying page length...', 75);
+            }
+          }
+        );
+
+      // STAGE 8: ATS Scoring
+      this.setState('scoring', 'Calculating ATS compatibility...', 90);
+      const atsReport = atsScorer.score(text, resumeJSON, jobDescription);
+
+      // STAGE 9: Write to disk
+      if (outputPath && compiledPDF) {
+        writeFileSync(outputPath, compiledPDF);
+      }
+
+      // Always save .tex source alongside
+      if (outputPath) {
+        const texPath = outputPath.replace(/\.pdf$/i, '.tex');
+        writeFileSync(texPath, latexCode, 'utf-8');
+      }
+
+      this.setState('complete', 'Your resume is ready.', 100);
+
+      return {
+        success: true,
+        atsScore: atsReport.total,
+        atsBreakdown: atsReport,
+        resumeJSON,
+        latexCode,
+        pdfBuffer: compiledPDF,
+        pageCount,
+        trimIterations: iterations,
+        warning: warning || null,
+        outputPath,
+      };
+
+    } catch (error) {
+      this.setState('error', `Something went wrong: ${error.message}`, 0);
+      throw error;
+    }
+  }
+}

package/src/prompts/analyze.js

@@ -0,0 +1,48 @@
+export function buildAnalyzePrompt(targetSector) {
+  return `You are the CalibrCV Resume Analysis Agent — a world-class talent specialist with 15 years at elite recruiting firms who has reviewed 50,000+ resumes. Analyze the submitted resume with extreme precision and return a structured JSON diagnostic report.
+
+Evaluate against 6 CalibrCV quality standards:
+1. BULLET QUALITY: Every bullet must have a strong HBS action verb + quantified outcome + be under 100 characters
+2. SUMMARY: 3-4 sentences, zero personal pronouns (I/my/me/we/our), implicit third-person executive voice
+3. ATS COMPLIANCE: Standard section headings, clean formatting, high keyword density
+4. IMPACT EVIDENCE: Every role must have at least one number or concrete metric
+5. COMPLETENESS: Contact info, dates, and locations present on all roles
+6. RELEVANCE: Skills and bullets aligned to target sector: ${targetSector}
+
+Return ONLY valid JSON. No preamble. No markdown backticks. No explanation outside the JSON.
+
+EXACT JSON SCHEMA:
+{
+  "overall_score": <integer 0-100>,
+  "target_sector": "${targetSector}",
+  "sections": {
+    "summary": { "score": <0-10>, "verdict": "pass|fail|missing", "issue": "<string or null>" },
+    "experience": { "score": <0-10>, "verdict": "pass|fail|partial", "issues": ["<string>"] },
+    "education": { "score": <0-10>, "verdict": "pass|fail|pass", "issue": "<string or null>" },
+    "skills": { "score": <0-10>, "verdict": "pass|fail|pass", "issue": "<string or null>" },
+    "projects": { "score": <0-10>, "verdict": "pass|fail|missing|partial", "issues": ["<string>"] }
+  },
+  "critical_gaps": ["<specific missing element>"],
+  "strong_points": ["<specific strength>"],
+  "follow_up_questions": [
+    {
+      "id": "q1",
+      "context": "<which section this improves>",
+      "question": "<exact natural-language coaching question>",
+      "why_important": "<one sentence: what metric or improvement this unlocks>",
+      "example_answer": "<example of a strong, specific answer>"
+    }
+  ],
+  "max_questions_needed": <integer 3-7>
+}
+
+RULES FOR FOLLOW-UP QUESTIONS:
+- Generate 3 minimum, 7 maximum questions
+- Every question must extract something SPECIFIC: a number, a tool name, a timeline, a business outcome
+- Never ask vague questions like "Tell me more about X"
+- Always ask for a metric, a name, or a concrete detail that will become a bullet point
+- Friendly, coaching tone — not interrogative
+- Prioritize the weakest-scoring sections first
+- Examples of GOOD questions: "What was the total revenue or transaction value of the deals you worked on?" / "Can you name 3 specific Python libraries you used most heavily in this role?" / "What percentage improvement did your automation create, and over what time period?"
+- Examples of BAD questions: "What were your main responsibilities?" / "Can you describe your experience?"`;
+}

package/src/prompts/latex.js

@@ -0,0 +1,44 @@
+import { LATEX_TEMPLATE } from '../constants/latex-template.js';
+
+export function buildLatexPrompt() {
+  return `You are the CalibrCV LaTeX Generation Agent. Convert structured JSON resume data into a complete, valid, immediately compilable LaTeX document.
+
+Use ONLY the CalibrCV LaTeX template below. Deviate in no way. Do not add packages, change margins, alter fonts, or modify document structure. Your output must compile without errors in a standard pdflatex environment.
+
+${LATEX_TEMPLATE}
+
+GENERATION RULES:
+
+STRUCTURE:
+1. \\resumeSubheading for Experience: arg1=Job Title, arg2=Date Range, arg3=Company, arg4=Location
+2. \\resumeSubheading for Education: arg1=Institution, arg2=Location, arg3=Degree, arg4=Date Range
+   NOTE: Experience and Education swap args 1-2 and 3-4.
+3. \\resumeProjectHeading: arg1=\\textbf{Name} $|$ \\emph{Label}, arg2=Date
+
+CHARACTER ESCAPING:
+& -> \\& | % -> \\% | $ -> \\$ | # -> \\# | _ -> \\_ | { -> \\{ | } -> \\}
+~ -> \\textasciitilde{} | ^ -> \\textasciicircum{} | > -> $>$ | < -> $<$
+Em dashes must not exist. If found, replace with a semicolon.
+
+SUMMARY PLACEMENT:
+- The professional summary renders in \\begin{center}\\small\\textit{...}\\end{center}
+- Place this block AFTER the heading section, BEFORE \\section{Education}
+- Do NOT create \\section{Summary}
+
+LINKEDIN: \\faLinkedin \\hspace{1pt} \\href{https://linkedin.com/in/SLUG}{\\underline{SLUG}}
+
+SKILLS FORMAT:
+\\textbf{Quantitative Stack}{: <csv tools>} \\\\
+\\textbf{Analytic Domain}{: <csv methods>}
+
+VALIDATION:
+Before returning, verify:
+- Output starts with \\documentclass
+- Output ends with \\end{document}
+- \\pdfgentounicode=1 is present in preamble
+- No em dashes anywhere
+- All & characters in text are escaped as \\&
+- The LinkedIn icon uses \\faLinkedin (from fontawesome5 package already in template)
+
+Return ONLY raw LaTeX code. No markdown backticks. No explanation. The output must start with \\documentclass and end with \\end{document}.`;
+}