Skip to content
CAI
Software that uses CAICheck a score

srbhr/Resume-Matcher

48.9

Weak · 16 November 2026

59.1k

lines of production code

TypeScript

with Python

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

AI-powered resume enrichment wizard with interactive Q&A and preview

Users can now initiate an AI-driven enrichment process for their resumes via a new modal wizard. The flow begins with automatic analysis, followed by an interactive Q&A step where users provide context for specific experiences or projects. Once questions are answered, the system generates enhancements that are displayed in a preview step, allowing users to review the proposed changes (highlighting new bullet points) and apply them or cancel. The wizard includes robust state management to handle loading, errors, and refresh failures, ensuring the user's progress is preserved and recoverable.

apps/frontend/components/enrichment · high confidence

ATS Score Breakdown and Resume Diff Preview UI

The Tailor interface now includes an ATS Score Card component that visualizes the overall resume score along with sub-scores for keyword match, skills coverage, and section completeness, while also listing missing and injectable keywords alongside actionable recommendations. Additionally, a new Diff Preview Modal has been added to display detailed changes between the current resume and the tailored version, grouping modifications by field type (such as skills, experience, and education) and providing a summary of added/removed items and high-risk changes, complete with a confirmation flow that tracks elapsed time. Also in this area: 6 commits (2 fixes) modifying apps/frontend; ATS Score Card re-skin and Diff Preview modal migration to Swiss UI.

apps/frontend/components/tailor · medium confidence · unverified

Add application tracker page with Kanban board

A new tracker page has been added at the /tracker route, providing a full-viewport layout that displays a Kanban board component. The page includes a navigation link back to the dashboard and applies a subtle grid background pattern to the canvas area.

apps/frontend/app/(default)/tracker · high confidence

Add cover letter print page with PDF-ready layout and i18n support

Users can now generate a print-optimized cover letter via a new page at /print/cover-letter/\[id\]. The page fetches the cover letter text and personal contact details from the resume API, renders them in a standard letter format (A4 or US Letter, configurable via query params), and supports internationalization for the current date and empty-state messaging. This provides a dedicated, styled view suitable for PDF generation.

apps/frontend/app/print/cover-letter · high confidence

Add support for French, Korean, Portuguese, Spanish, Chinese, and Japanese languages

The frontend application now supports seven languages (English, Spanish, Chinese, Japanese, Portuguese, French, and Korean) for both the user interface and AI content generation. Users can select their preferred language from the available options, which are identified by their native names and corresponding flags.

apps/frontend/i18n · high confidence

Added Swiss Guard linting and first-load performance reporting scripts

Two new Node.js scripts have been added to the frontend build tooling to enforce design system standards and track performance. The \swiss-guard\ script scans \app/\ and \components/\ directories for violations of the new Swiss design system rules, such as banning raw colors, gradients, and Lucide icons (replacing them with Phosphor), and enforces square corners and specific shadow tokens. It maintains a shrinking allowlist to prevent regression. The \first-load-report\ script analyzes the Next.js build output to print a table of first-load JavaScript bundle sizes (gzip and raw) per route, helping developers monitor bundle growth.

apps/frontend/scripts · high confidence

Added language settings and centralized status caching contexts

The frontend now includes a LanguageContext that allows users to configure both UI and content languages, persisting preferences to localStorage and syncing content language with the backend API, while also ensuring the document's language attribute is updated for accessibility. Additionally, a StatusCacheContext has been introduced to manage system status data, featuring optimistic updates for counters (resumes, jobs, improvements), a master resume flag, and periodic background checks for LLM health every 30 minutes. Also in this area: 9 commits (3 fixes) modifying apps/frontend; New WebGL background effects and block-dissolve navigation transition.

apps/frontend/lib/context · medium confidence · unverified

Adds internationalization support with translations for seven languages

The frontend now includes a new internationalization (i18n) system that allows the user interface to be displayed in multiple languages. This change introduces a React hook (useTranslations) and utility functions to dynamically load and apply translations based on the user's selected language. The system currently supports English, Spanish, Chinese, Japanese, Portuguese (Brazil), French, and Korean, with messages loaded from static JSON files. Users can now interact with the application in their preferred language, with the UI text updating automatically when the language setting is changed.

apps/frontend/lib/i18n · high confidence

Backend v1.3.0: Local LLM providers, encrypted key storage, and robust data layer

The backend application is updated to version 1.3.0, introducing a local Claude Code CLI provider that allows AI operations without an API key, alongside a ChatGPT plan inference provider. API keys are now securely stored using Fernet encryption in the database rather than plaintext configuration files. The data layer has been replaced with a robust SQLAlchemy implementation supporting both SQLite and optional PostgreSQL backends, featuring atomic configuration saves, a shared config cache, and a new host guard middleware to prevent DNS rebinding attacks.

apps/backend/app · high confidence

Frontend application initialization and configuration scaffolding

The frontend application has been initialized as a Next.js project using the App Router, React 19, and TypeScript. This change introduces the core configuration scaffolding, including environment variable templates for API and timeout settings, and integrates Oxlint and Oxfmt for code quality and formatting. It also establishes the testing infrastructure with Vitest and jsdom, and configures the development server to proxy API requests to a configurable backend origin.

apps/frontend · high confidence

Initialize Next.js root layout with optimized CJK font support

The frontend application now uses a Next.js root layout that configures Google Fonts for Latin text (Geist, Space Grotesk) and specifically optimizes CJK (Chinese, Japanese, Korean) rendering. To prevent large, render-blocking font downloads for users who do not need CJK characters, the layout disables preloading for Noto Sans SC, KR, and JP while ensuring correct fallback ordering for resume content. This change establishes the base typography and metadata for the 'Resume Matcher' application.

apps/frontend/app · high confidence

Initialize default layout with global providers and home page

The frontend application now establishes a default layout structure that wraps all routes in a hierarchy of context providers: StatusCacheProvider, LanguageProvider, ResumePreviewProvider, and LocalizedErrorBoundary. This wiring ensures that status caching, internationalization, resume preview state, and error handling are available throughout the application. The root page now renders the Hero component as the initial view.

apps/frontend/app/(default) · high confidence

Introduce ChatGPT plan-based authentication and application tracker

The backend now supports signing in with a ChatGPT plan via the official OpenAI flow (PKCE, loopback callback, encrypted credential storage) to enable plan-based usage. Additionally, a Kanban-style application tracker has been added, allowing users to manage job applications with status updates, notes, and bulk actions.

rm-backend · high confidence

Introduce MCP server for deterministic resume matching tools

The backend now exposes a Model Context Protocol (MCP) server that provides a suite of deterministic tools for resume matching, including creating, tailoring, verifying, and exporting resumes. This server allows external agents to interact with the Resume Matcher logic via a CLI or standard MCP connections, featuring tools for parsing, scoring, and PDF generation, with clear annotations distinguishing read-only, additive, and destructive operations.

_apps/backend/app/mcp\server · high confidence

Introduce Tailor page for resume-job matching with prompt selection and diff preview

Users can now access the new Tailor page to tailor a master resume for a specific job description. This feature allows dynamic selection of prompt configurations (loaded from the backend), displays an elapsed timer during long operations, and provides a diff preview modal to review changes before confirming the improvement. The page also handles master resume selection, validates LLM configuration status, and manages error states such as expired previews or missing diffs.

apps/frontend/app/(default)/tailor · high confidence

Introduce application tracker with Kanban board and bulk management

Adds a new frontend component suite for tracking job applications, featuring a Kanban board with drag-and-drop reordering (using dnd-kit), bulk selection, and status management. Users can manually add applications, view detailed card modals with job descriptions and notes, and manage column visibility. The implementation includes a bulk action bar for moving or deleting selected items, a confirmation dialog for destructive actions, and support for reduced motion preferences.

apps/frontend/components/tracker · high confidence

Introduce centralized Settings page with LLM, API key, and feature management

The application now includes a dedicated Settings page that consolidates configuration for LLM providers (including OpenAI, Azure Foundry, Groq, and others), API key management, and feature toggles for cover letters, outreach, and interview prep. Users can test connections, view health checks, manage custom prompts, and handle sensitive data via API key clearing and database reset options, all within a single interface.

apps/frontend/app/(default)/settings · high confidence

Introduce centralized frontend API client and typed service modules

The frontend now uses a unified API client (\apps/frontend/lib/api/client.ts\) that standardizes fetch calls, handles absolute vs. relative URL resolution (including SSR internal origin routing), and enforces a configurable request timeout (default 240s, bounded 30s–30min) with clear timeout and abort error handling. This client powers new typed service modules for resume management (\resume.ts\), the adaptive resume wizard (\resume-wizard.ts\), AI-powered resume enrichment and regeneration (\enrichment.ts\), LLM configuration and health checks (\config.ts\), and application tracking (\tracker.ts\), providing a consistent, type-safe interface for all backend interactions.

apps/frontend/lib/api · high confidence

Introduce dedicated API routers for application tracking, configuration, enrichment, and resume wizard

The backend now exposes a structured set of API endpoints organized into distinct routers. The Application Tracker router provides Kanban-style management for job applications, including listing, creating, updating, and bulk-deleting cards. The Configuration router manages LLM settings, API keys, and feature prompts, with specific validation for providers requiring a base URL. The Enrichment router enables AI-driven resume analysis, enhancement, and regeneration of experience or project details. The Resume Wizard router supports an adaptive, one-question-at-a-time flow for creating master resumes. Additionally, new routers handle job description uploads, health checks, and core resume management operations like upload, improvement, and PDF generation.

apps/backend/app/routers · high confidence

Introduce deterministic ATS parse-check for resume validation

A new deterministic parse-check service has been added to the backend to validate resume files (PDF and DOCX) and rendered PDFs against extraction, layout, and content criteria. The service extracts text and layout data, runs checks for issues like garbled glyphs, multi-column layouts, and missing text layers, and performs a round-trip verification to ensure structured resume data (contact info, entries, and field orders) survives extraction intact. This allows users and the system to detect parsing failures or data loss before finalizing a resume.

_apps/backend/app/services/ats\parse · high confidence

Introduce one-question-at-a-time resume wizard with live preview

The resume wizard now guides users through a single-question-at-a-time flow, replacing the previous multi-section picker. A new live preview panel updates in real-time as answers are provided, displaying personal info, work experience, projects, education, and skills (with AI-inferred skills highlighted). The wizard includes draft auto-save, recovery from storage failures, and an AI signal indicating when the user has enough content to finalize, while gating creation on having a name.

apps/frontend/components/resume-wizard · high confidence

Introduce resume creation wizard and upload dialog with retry support

The dashboard now presents a choice between uploading an existing resume or using a new wizard to create one, via the MasterResumeChoiceDialog. The ResumeUploadDialog handles file uploads and, crucially, keeps the dialog open if parsing fails, allowing users to retry processing or delete the failed resume without losing context. Additionally, the dashboard displays every master resume track with a default badge to clarify which resume is currently active.

apps/frontend/components/dashboard · high confidence

Introduce resume dashboard and wizard entry points

The application now includes a main dashboard page at /dashboard that manages master resumes (upload, delete, retry, set default) and displays tailored resumes with job snippets, alongside a new /resume-wizard route that serves as the entry point for the resume creation flow.

apps/frontend/app/(default)/dashboard · high confidence

Introduces Swiss International Style UI component library

The frontend now ships a new set of accessible, server-safe UI primitives (Alert, BrandIcon, Button, Card, ConfirmDialog, Dialog, Dropdown, EmptyState, Input, Label, LinkDialog, PageFrame, PageHeader, PanelHeader, RetroTabs, and RichTextEditor) that implement the Swiss International Style design system. These components provide consistent styling (square corners, hard shadows, monospace labels), robust keyboard navigation, and ARIA compliance, replacing ad-hoc implementations with a unified, token-based foundation for the application's interface.

apps/frontend/components/ui · high confidence

Introduction of centralized Pydantic schema definitions

The backend now exposes a unified module for request and response models, consolidating Pydantic schemas for resume management, ATS scoring, interview preparation, API key configuration, and application tracking into a single importable package.

apps/backend/app/schemas · high confidence

MCP tools module restructured with new resume and application management capabilities

The MCP tools have been reorganized into individual modules and categorized by operation type (read-only, additive, destructive) to improve clarity and safety. This change introduces new tools for managing job applications (create\_application, update\_application, list\_applications) and enhances resume handling with tailored resume workflows (save\_tailored\_resume, tailor\_and\_verify, validate\_tailored\_resume, recalculate\_ats\_score). It also adds robust verification and parsing capabilities (verify\_resume, parse\_check\_resume, parse\_check\_file) and improves data integrity by ensuring explicit nulls are preserved in updates and that stored resume data is validated against the current schema.

_apps/backend/app/mcp\server/tools · high confidence

New Home Hero and Dashboard Swiss Grid layouts

The home page now features a new Hero component with a block-dissolve transition to the dashboard, while the dashboard utilizes a new Swiss Grid layout with container-query-based responsive tiles, a slim community link strip, and footer links to the queue, tracker, and settings pages.

apps/frontend/components/home · high confidence

New Queue Management Page for Resume Processing

A new Queue page has been added to the application, allowing users to manage job processing for their master resumes. This interface supports adding jobs to a queue, viewing their status (pending, processing, completed, failed), and clearing specific or all jobs. It includes features like automatic detection of job details (role, company, job ID) from the job description, configurable cooldown intervals between requests (0-60 seconds), and robust error handling with user feedback for loading states and action failures. The page also integrates with the system's LLM and agent configuration status.

apps/frontend/app/(default)/queue · high confidence

New WebGL visual effects: Pixel Beams and Retro Bitrate

Two new WebGL shader effects are now available in the frontend's effects library. Pixel Beams renders a dithered plasma pattern with wave distortion, using the Swiss palette (Canvas and Steel colors) to create a quiet background texture. Retro Bitrate generates a mosaic of grey and faded-blue blocks driven by simplex noise and linear gradients, also adhering to the Swiss palette, with the intensity of blue blocks controlled by an active/idle level parameter. Both effects share common GLSL utilities for precision, Bayer dithering, and mirror edge modes.

apps/frontend/lib/effects/shaders · high confidence

New backend configuration and development scaffolding files

The backend now ships with a comprehensive \.env.example\ file that documents all supported LLM providers (including OpenAI, Anthropic, Azure AI Foundry, Ollama, and the new Claude Code CLI and ChatGPT plan providers), server settings, and optional PostgreSQL database configuration. A simplified \.env.sample\ is also provided for quick setup. Additionally, a \.gitignore\ file has been added to prevent committing sensitive data (API keys, database files, uploads) and development artifacts, while a \.python-version\ file pins the runtime to Python 3.13. A \CLAUDE.md\ file provides detailed architectural context, module maps, and development guidelines for the backend.

apps/backend · high confidence

New backend services for resume parsing, improvement, tailoring, and auxiliary generation

The backend now exposes a suite of new business-logic services in \apps/backend/app/services\ to handle the full resume lifecycle. The \parser\ service extracts structured data from uploaded documents (PDF, DOCX, etc.) with bounded resource usage. The \improver\ service applies LLM-driven, diff-based resume enhancements with strict path whitelisting and prompt-injection sanitization. The \refiner\ service performs multi-pass keyword injection, AI phrase removal, and master-alignment validation to ensure grounded content. The \tailor\ pipeline (comprising \bullet\_scoring\, \bullet\_selector\, and \page\_fit\) scores resume bullets for job relevance, deterministically selects the best bullets, and trims content to fit a single page using real print-pipeline measurements. Additionally, new services generate cover letters, cold outreach messages, resume titles, and interview preparation materials, all supporting custom user-defined prompts and multiple output languages. Also in this area: 6 commits (4 fixes) fixing apps/backend; 8 commits (3 fixes) modifying apps/backend; Parser robustness, ATS date parsing, and CV page-limit mode; Resume parsing, ATS scoring, and tailoring improvements; Background queue for resume tailoring with batch support and metadata parsing; and 1 more.

apps/backend/app/services · medium confidence · unverified

New background effects and route transition overlay

Added a new effects system in the frontend that provides two WebGL-based background visuals—Pixel Beams (a subtle grey dot pattern) and Retro Bitrate (pixelated blocks that intensify during AI processing)—along with a Block Dissolve overlay for the Home to Dashboard navigation. These effects are fixed to the viewport, respect user accessibility preferences (reduced motion), and are dynamically loaded to avoid impacting initial page performance.

apps/frontend/components/effects · high confidence

The application now includes a dedicated configuration for community and support links (GitHub, Discord, sponsors) and a new module for handling PDF page dimensions. This module provides standard A4 and Letter sizes, along with utility functions to convert between millimeters and pixels and calculate printable content areas, which supports more accurate resume preview rendering.

apps/frontend/lib/constants · high confidence

New database migration and copy scripts for SQLite and PostgreSQL

Added operational scripts to manage data persistence transitions: \migrate\_tinydb\_to\_sqlite.py\ performs an idempotent one-time import from the legacy TinyDB storage into SQLite (handling master-resume conflicts and preserving primary keys), while \copy\_sqlite\_to\_postgres.py\ provides a safe, snapshot-based mechanism to copy existing SQLite data into a PostgreSQL target specified by \DATABASE\_URL\, refusing to overwrite non-empty targets. These scripts allow users to upgrade their local data store or migrate to a production-grade database without losing resumes, jobs, or improvements.

apps/backend/app/scripts · high confidence

New frontend utility libraries for date formatting, motion, theming, and class management

This change introduces four new utility modules in the frontend library: \format-date.ts\ provides a locale-aware date formatter that correctly handles YYYY-MM-DD strings as local calendar dates and caches \Intl.DateTimeFormat\ instances for performance; \motion.ts\ defines a consistent set of animation constants (durations, easings, springs) for UI transitions; \theme-color.ts\ exports the canonical canvas color for browser UI theming; and \utils.ts\ adds a \cn\ helper for merging Tailwind CSS classes and a \formatDateRange\ function that normalizes date ranges for ATS compatibility. These utilities support the broader UI and design system updates by providing shared, reusable logic for common frontend tasks.

apps/frontend/lib · high confidence

New frontend utility library for resume builder features

This change introduces a comprehensive set of new utility modules in \apps/frontend/lib/utils\ that power core resume builder capabilities. It adds robust local draft storage for both resumes and attachments with expiry and clock-skew handling, and implements a hardened resume normalization pipeline to clean and validate data before saving or rendering. The builder now supports dynamic section management, including the creation, duplication, and reordering of custom sections and description points, with styles kept in sync. User-facing improvements include personalized PDF download filenames (incorporating name and company), a new HTML sanitizer using \isomorphic-dompurify\, and a keyword-matching utility for job-description comparison. Additionally, it provides UI helpers for tracker column visibility management, preview error translation, and localized default section metadata.

apps/frontend/lib/utils · high confidence

New hooks for AI resume enrichment and file upload reliability

The frontend now includes \use-enrichment-wizard.ts\ and \use-regenerate-wizard.ts\ to manage the state and logic for AI-powered resume enrichment and regeneration flows, handling steps like analysis, question answering, and previewing generated content. Additionally, \use-file-upload.ts\ provides a robust file upload mechanism with drag-and-drop support, concurrency control via ref counting, and the ability to recover saved resumes from failed HTTP responses. A new \use-operation-owner.ts\ hook is introduced to ensure state consistency and prevent race conditions by tracking operation ownership and invalidating stale async results.

apps/frontend/hooks · high confidence

New locale parity check and Docker smoke test scripts

Added \scripts/check\_locale\_parity.py\ to validate that all frontend locale JSON files structurally match the English reference file (\en.json\), catching missing keys and type mismatches (e.g., object vs. string) that previously caused \next build\ failures. Also added \scripts/docker-smoke.sh\, a one-command script to build the Docker image, run the application in an isolated container, and verify backend and frontend health, with support for custom mirrors and ports.

scripts · high confidence

New opt-in agentic end-to-end monitor for Resume-Matcher

Developers can now run an on-demand, opt-in end-to-end monitor that drives the real Resume-Matcher application, captures a self-contained evidence bundle, and provides an AI-agent skill to judge the results. Enabled by setting the \RM\_E2E\_MONITOR=1\ environment variable, the monitor boots isolated backend and frontend subprocesses, pre-seeds a dedicated SQLite database, tailors a master resume against bundled job descriptions, scores the output using deterministic structural checks, and uses an LLM to evaluate truthfulness and relevance. The resulting evidence bundle includes flow traces, scores, rendered PDFs, and a baseline diff to detect regressions, while sensitive diagnostics are kept in owner-only log files to protect credentials.

_apps/backend/e2e\monitor · high confidence

New print route for rendering resumes with customizable templates and layout options

A new page route at \app/print/resumes/\[id\]\ has been added to handle resume printing. This route fetches resume data (supporting both processed and raw draft formats via a draft token) and renders it using the \Resume\ component. Users can now customize the output by passing search parameters for template selection (e.g., swiss-single, modern, latex), page size (A4, Letter), margins, spacing, font families, accent colors, and language localization. The implementation includes robust error handling for missing drafts and data parsing issues, ensuring a stable print experience.

apps/frontend/app/print/resumes · high confidence

New resume builder capabilities: custom sections, AI generation, and job-matching tools

The Resume Builder now supports creating custom sections (text blocks, item lists, and string lists) via a new dialog, and allows AI regeneration of experience, projects, and skills with a dedicated selection wizard. A new Job Description (JD) comparison view highlights resume keywords against job requirements, while a split-screen editor and preview for cover letters and outreach messages have been added. Additionally, an interview preparation view generates role-fit analysis, suggested questions, and skill-gap insights, and a generic draggable list component enables reordering of items within sections. Also in this area: 3 commits (2 fixes) fixing apps/frontend; 3 commits (1 fix) modifying apps/frontend; 9 commits (3 fixes) modifying apps/frontend; Builder UI fixes and new template thumbnails; Builder UI realignment and accessibility improvements; and 1 more.

apps/frontend/components/builder · medium confidence · unverified

New resume builder form components for personal info, experience, education, and more

The builder now includes dedicated form components for editing resume sections: PersonalInfoForm, ExperienceForm, EducationForm, ProjectsForm, SummaryForm, AdditionalForm, and generic templates (GenericItemForm, GenericListForm, GenericTextForm). These forms enable users to add, edit, duplicate, and reorder entries (e.g., jobs, schools, projects) and manage description points with style toggles (bullets vs. plain text). List-type fields (skills, languages, certifications, awards) use newline-separated textareas that preserve Enter key newlines during editing. Experience, education, and project entries support drag-and-drop reordering via SortableItemList, and rich text editing is lazy-loaded to improve initial bundle size.

apps/frontend/components/builder/forms · high confidence

New resume builder page with agent mode support

A new builder page has been added at the /builder route that renders the ResumeBuilder component. The page integrates with the application's status cache to detect whether agent mode is enabled, passing this state as a boolean prop to the builder component to adjust its behavior accordingly.

apps/frontend/app/(default)/builder · high confidence

New resume template settings and font configuration types

The frontend now includes a dedicated type definition for resume template settings, introducing support for new template variants (modern, modern-two-column, latex, clean, vivid) and granular customization controls including accent colors, spacing levels, and font families. It also establishes CJK font fallback stacks to ensure correct character rendering across Chinese, Japanese, and Korean locales, and adds TypeScript declarations for dynamic Lucide icon imports.

apps/frontend/lib/types · high confidence

New resume templates and dynamic section support

The resume builder now offers six new visual templates—Clean, Modern, Modern Two-Column, LaTeX, Swiss Single-Column, and Vivid—each with distinct layouts, typography, and accent color handling. These templates support dynamic, user-defined sections (text, item lists, and string lists) via the new DynamicResumeSection component, allowing users to add custom content beyond the standard resume fields. Additionally, description points can now be rendered as plain text without bullet markers, and the builder filters out empty entries to prevent blank lines in the final output. Also in this area: 3 commits (1 fix) modifying apps/frontend; 9 commits (3 fixes) modifying apps/frontend; New resume templates and improved PDF pagination.

apps/frontend/components/resume · medium confidence · unverified

New shared UI components and context providers for the frontend

This change introduces several new reusable components and context providers in the common UI layer. It adds a CommunityLinks component that renders localized support and community links (GitHub, Discord, etc.) with variant-specific layouts, and a DefaultBadge for marking the master resume. It also introduces an LlmSetupAlert for warning users when LLM configuration is missing, and a robust ErrorBoundary with a LocalizedErrorBoundary variant to catch React errors and display a user-friendly fallback UI. Additionally, it provides a MotionProvider for lazy-loaded, reduced-motion-aware animations, and a ResumePreviewContext to manage and share resume improvement data (including ATS scores and diffs) across the application.

apps/frontend/components/common · high confidence

New visual effects: Block Dissolve transition and Pixel Beams background

The frontend now includes two new visual effects. A Block Dissolve transition replaces the standard navigation when moving from the Home page to the Dashboard, featuring a grid of blocks that vanish in a randomized order with soft edges. Additionally, a new Pixel Beams background effect is available, displaying diagonal beams with streaks traveling across a Bayer-matrix grid; this effect is controlled via a settings toggle and is designed to be atmospheric rather than highly animated. Both effects are implemented with performance optimizations, including caching of grid calculations and WebGL runners that respect reduced-motion preferences and device pixel ratio limits.

apps/frontend/lib/effects · high confidence

Resume viewer page with processing status, retry, and deletion capabilities

The new resume viewer page at /resumes/\[id\] allows users to view processed or raw resume data, track processing status (pending, processing, ready, failed), and retry failed processing attempts. It supports deleting resumes, renaming them, setting a default master resume, and duplicating resumes. The page handles loading states, errors, and provides a localized UI for these operations.

apps/frontend/app/(default)/resumes · high confidence

Running header with name and page numbers on multi-page PDFs

Multi-page resume PDFs now display a running header in the top-right corner of every page except the first, showing the resume name followed by the current page and total page count (e.g., "Name · 2 / 3"). This is implemented via CSS @page rules injected by the new running-header module, ensuring the header is hidden on the first page while remaining visible on subsequent pages.

apps/frontend/lib/print · high confidence

WYSIWYG paginated resume preview with PDF-accurate page breaks

The resume builder now displays a paginated preview that mirrors the PDF output, ensuring what you see is what you get. This change introduces a new pagination system in the preview component that calculates page breaks using the same rules as the PDF generator: it keeps entries together, prevents orphaned section headers, and respects specific line-break constraints. Users can now zoom in and out, toggle margin guides, and see accurate page counts in the preview pane, with the default zoom set to 85% to fit the panel width.

apps/frontend/components/preview · high confidence

Behavioural changes

7 commits (2 fixes) modifying apps/frontend/components/settings

A change to existing behaviour in apps/frontend/components/settings — 7 commits (2 fixs), 3 files: “fix(settings): disable Save while ChatGPT is not connected, with a hint (\#1042 review)”; “feat(settings): pick the Claude Code model; confirm subscription provider risk”; “feat(settings): About section with the app version and the community links”; and 4 more (refs \#1042).

apps/frontend/components/settings · medium confidence · unverified

Adopts Swiss International Style design system with print-optimized CSS

The global stylesheet has been rewritten to implement a 'Swiss International' visual identity, replacing ad-hoc colors and shadows with a unified design token system (e.g., Hyper Blue primary, Canvas background, solid offset shadows). This change enforces a light-only theme by removing the previous dark mode mappings and standardizes typography to Geist Sans and Space Grotesk. Additionally, specific print styles have been added to ensure resumes and cover letters render correctly as PDFs, hiding UI chrome and forcing a clean, black-and-white layout.

apps/frontend/app/(default)/css · high confidence

Centralized LLM prompt templates with AI enrichment, regeneration, and anti-AI phrasing controls

The backend now stores all LLM prompt templates in a dedicated \apps/backend/app/prompts\ package, introducing new capabilities for resume enrichment (identifying weak descriptions and generating targeted questions), AI-powered regeneration of experience, project, and skill sections based on user feedback, and a multi-pass refinement process that actively removes AI-sounding buzzwords and em-dashes to ensure content sounds human. The system also enforces truthful JD-keyword incorporation by default, preserves entry identity and date precision during parsing and tailoring, and validates that custom cover-letter and outreach prompts contain required placeholders to prevent runtime errors.

apps/backend/app/prompts · high confidence

Frontend version and codename configuration introduced

A new configuration file has been added to the frontend application to define the current version as 1.3 with the codename 'Crescendolls' and the app name 'Resume Matcher'. This change provides a centralized source for version metadata, exposing a helper function to generate a formatted version string (e.g., 'Resume Matcher v1.3 (Crescendolls)') for display or logging purposes.

apps/frontend/lib/config · high confidence

Local pre-push gate replaces PR-triggered CI

The repository now uses a local \pre-push\ git hook to validate changes before pushing, replacing the previous PR-triggered GitHub Actions workflow. This local gate runs the backend test suite (via \uv run pytest\), checks frontend locale parity, and executes frontend tests (via \vitest\) and type-checking (via \tsc --noEmit\) when Node is available. This approach prevents CI runs on external contributor PRs while ensuring that \main\ and \dev\ branches remain green by catching failures locally before they are pushed.

.githooks · high confidence

Resume templates now use a CSS token system for consistent styling and print accuracy

The resume styling layer has been refactored to use a shared CSS token system (\_tokens.css) and CSS Modules, introducing a standardized design language across all templates (Clean, Deedy, LaTeX, Modern, Vivid, Swiss). This change ensures consistent typography, spacing, and color usage while specifically addressing PDF export issues: it fixes CJK character coverage by including Noto Sans Mono, prevents ATS parsing errors by replacing small-caps with uppercase text, and ensures skill tag commas appear in the PDF text layer. Users will see more reliable print layouts and better compatibility with applicant tracking systems across all resume templates.

apps/frontend/components/resume/styles · high confidence

Rewritten Docker startup script with improved configuration and signal handling

The docker/start.sh script has been completely rewritten to support a single-port deployment architecture, where the frontend serves on port 3000 and proxies API requests to the backend on port 8000. The new script introduces robust signal handling for graceful shutdowns, ensuring both frontend and backend processes are terminated cleanly upon receiving SIGTERM, SIGINT, or SIGQUIT. It also implements a secure environment variable loading mechanism that supports both direct variables and \*\FILE secret mounts, while carefully avoiding the export of empty LLM\\* variables that could override backend defaults. Additionally, the script now includes configurable log levels for both the application and LiteLLM, with a specific warning when LOG\_LLM is set to DEBUG to prevent accidental exposure of API keys in plaintext logs.

docker · high confidence

Test coverage

Added eval harness for resume tailoring quality; Added service-level tests for bullet scoring and resume improvement; Established backend test infrastructure with isolated fixtures and network guards; Expanded frontend test coverage for core features and components; Expanded unit test coverage for backend resume processing and AI integration; New integration test suite for backend services.

Dependencies

Initialize frontend and backend dependency manifests

The project now includes explicit dependency definitions for both the frontend and backend applications. The frontend (apps/frontend) is initialized with Next.js 16.3.3, React 19.2.4, Tailwind CSS 4, and Tiptap 3.20.0, along with specific overrides for undici, postcss, and sharp. The backend (apps/backend) is defined via pyproject.toml and requirements.txt, specifying FastAPI 0.128.4, SQLAlchemy 2.0.36, cryptography 50.0.0, litellm 1.86.2, and markitdown with DOCX support.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 48 → 49 (+0.6)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 65 → 57 (-8.1)
  • Architecture 90 → 90 (+0.0)
  • Maturity 67 → 67 (+0.1)
  • Readiness 35 → 28 (-6.8)
  • Security 46 → 72 (+25.9)
  • Accessibility 81 → 90 (+8.5)
  • Performance 100 → 100 (+0.0)

Resolved (29)

  • Duplicated block (14 lines × 2) (apps/backend/app/services/improver.py)
  • Duplicated block (16–17 lines × 2) (apps/backend/app/routers/enrichment.py)
  • Duplicated block (17 lines × 2) (apps/backend/app/services/improver.py)
  • Duplicated block (18 lines × 2) (apps/backend/app/routers/resumes.py)
  • Duplicated block (32 lines × 2) (apps/backend/app/routers/enrichment.py)
  • Duplicated block (38 lines × 2) (apps/backend/app/services/improver.py)
  • Duplicated block (46 lines × 2) (apps/backend/app/routers/enrichment.py)
  • Duplicated block (6 lines × 2) (apps/backend/app/services/refiner.py)
  • Duplicated block (7 lines × 2) (apps/backend/app/services/refiner.py)
  • Hotspot: apps/backend/app/mcp_server/tools/verify_resume.py (apps/backend/app/mcp_server/tools/verify_resume.py)
  • Hotspot: apps/backend/e2e_monitor/servers.py (apps/backend/e2e_monitor/servers.py)
  • Hotspot: apps/frontend/components/builder/regenerate-dialog.tsx (apps/frontend/components/builder/regenerate-dialog.tsx)
  • Hotspot: apps/frontend/components/ui/retro-tabs.tsx (apps/frontend/components/ui/retro-tabs.tsx)
  • No ADRs found
  • Outdated: litellm
  • Outdated: markitdown
  • Outdated: playwright
  • Outdated: psycopg
  • Outdated: python-multipart
  • Outdated: sqlalchemy
  • …and 9 more

New (29)

  • AWS access key ID with no secret key beside it (Images/logo.png:Zone.Identifier)
  • AWS access key ID with no secret key beside it (Images/rm_logo.png:Zone.Identifier)
  • AWS access key ID with no secret key beside it (Images/rmlogo.png:Zone.Identifier)
  • AWS access key ID with no secret key beside it (Progress/NAIVE RESUME MATCHER.jpg:Zone.Identifier)
  • AWS access key ID with no secret key beside it (Progress/NAIVE RESUME MATCHER.png:Zone.Identifier)
  • Banned license: psycopg-binary
  • Edited copies of one member (3 members, 63+ corresponding lines) (apps/backend/app/routers/resumes.py)
  • Edited copy of a member (12 corresponding lines) (apps/backend/app/database.py)
  • Edited copy of a member (14 corresponding lines) (apps/backend/app/services/improver.py)
  • Edited copy of a member (19 corresponding lines) (apps/backend/app/database.py)
  • Edited copy of a member (26 corresponding lines) (apps/backend/app/services/keyword_forcing.py)
  • Edited copy of a member (29 corresponding lines) (apps/backend/app/routers/enrichment.py)
  • Edited copy of a member (43 corresponding lines) (apps/backend/app/services/cover_letter.py)
  • Edited copy of a member (5 corresponding lines) (apps/backend/app/chatgpt_inference.py)
  • Edited copy of a member (53 corresponding lines) (apps/backend/app/routers/resumes.py)
  • Edited copy of a member (8 corresponding lines) (apps/backend/app/chatgpt_inference.py)
  • Edited copy of a member (9 corresponding lines) (apps/backend/app/database.py)
  • FunctionTooLong: follow-up-panel.FollowUpPanel (apps/frontend/components/tracker/follow-up-panel.tsx)
  • Hotspot: apps/frontend/components/tracker/follow-up-panel.tsx (apps/frontend/components/tracker/follow-up-panel.tsx)
  • Mock-dominated test: moves an Applied card to No Response (apps/frontend/tests/tracker-follow-up.test.tsx)
  • …and 9 more

Changes since last survey

  • 61 commits — 30 feature/other, 31 fixes

By area

  • apps/backend — 28 commits
  • (repo) — 16 commits
  • apps/frontend — 12 commits
  • (root) — 5 commits

Notable commits

  • fix: Merge branch 'fix/pdf-print-page-status' into dev
  • fix: Merge branch 'fix/pdf-print-page-status' into dev
  • fix: Merge pull request #1082 from srbhr/fix/pdf-print-page-status
  • fix: Merge pull request #1084 from srbhr/fix/pdf-browser-sandbox
  • fix: Merge pull request #1095 from srbhr/fix/two-column-pdf-break
  • fix: Merge pull request #1096 from srbhr/fix/1094-short-entry-test-and-sonner
  • fix: fix(docker): install a hash-pinned, 3-day-old dependency set
  • fix: fix(docker): render PDFs with Debian's patched Chromium, not Playwright's
  • fix: fix(pdf): bound the filter's fetches by the render deadline; log real failures
  • fix: fix(pdf): close the redirect and WebSocket gaps in the origin filter
  • fix: fix(pdf): fail fast when the print URL returns an HTTP error
  • fix: fix(pdf): keep the readiness diagnostic on the threaded fallback
  • fix: fix(pdf): render in sandboxed system Chrome and load only the print origin
  • fix: fix(pdf): space template flex columns with gap, not item margins
  • fix: fix(skills): don't re-add a skill that already sits in a labeled line
  • fix: fix(skills): keep bare-label groups intact; templates own their rendering
  • fix: fix(tailoring): keep "---" skill rows through every AI rewrite
  • fix: fix(ui): a toaster chunk that fails to load can't crash the app shell
  • fix: fix(ui): build the toast buttons from buttonClass
  • fix: fix: PDF gap after Summary; translate the preview page indicator
  • …and 41 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

srbhr/Resume-Matcher was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 16 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit e2a32b6823bb7f5996cafdf007b6ba6f0efd8f98 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.73+preprod-52de90b74216.