resume_vaulte

KO | EN

gitlite — search

#ai #llm #rust #linux #docker #macos #nodejs #java #kubernetes #awesome-list #vue #pytorch #security #mcp

(★ 25)

No description available.

resume_vaulte Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Resumimi <sub>简历喵喵</sub>

*One vault for every version of you.*

**Version-control your resumes in your own private GitHub repo, and run the
AI on your own API key.** A local-first desktop app that treats a resume
like source: LaTeX with live compile, git-style checkpoints, and a full
history you own — synced to a repo only you can read, rewritten by whichever
model you decide to pay for.

[![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Windows-1d1d1f?style=flat)](https://github.com/rayxie666/resume_vaulte)
[![Tauri 2](https://img.shields.io/badge/Tauri-2-24C8D8?style=flat&logo=tauri&logoColor=white)](https://tauri.app/)
[![React 19](https://img.shields.io/badge/React-19-61DAFB?style=flat&logo=react&logoColor=black)](https://react.dev/)
[![License: MIT](https://img.shields.io/badge/license-MIT-3da639?style=flat)](https://raw.githubusercontent.com/rayxie666/resume_vaulte/main/)
[![Release](https://img.shields.io/github/v/release/rayxie666/resume_vaulte?style=flat&color=b08d4a)](https://github.com/rayxie666/resume_vaulte/releases)

</div>

## Download

Grab the latest **macOS** (`.dmg`) or **Windows** (`.exe` / `.msi`) installer
from the **[Releases page →](https://github.com/rayxie666/resume_vaulte/releases/latest)**.

The installers are unsigned, so the OS warns on first launch: macOS Gatekeeper
→ right-click the app → **Open**; Windows SmartScreen → **More info → Run
anyway**. To build from source instead, see [Quick start](#quick-start).

## Contents

- [Download](#download)
- [✨ Features](#-features)
- [Quick start](#quick-start)
- [Requirements](#requirements)
- [Windows](#windows)
- [GitHub sync](#github-sync)
- [AI providers (bring your own key)](#ai-providers-bring-your-own-key)
- [Attachments (LaTeX images / extra files)](#attachments-latex-images--extra-files)
- [Where data lives](#where-data-lives)
- [Building a release `.app` / `.dmg`](#building-a-release-app--dmg)
- [Troubleshooting](#troubleshooting)
- [Architecture](#architecture)
- [Bundled fonts](#bundled-fonts)
- [License](#license)

## ✨ Features

### 🗂 Organize by role family

A category is a *kind* of job you're chasing — "Operations", "Backend" —
not a single application. A Google posting and a TikTok posting for the
same kind of role live side by side inside it, each as its own version
with its own job description.

### 📄 Every version, one glance

Versions show up as cards with live PDF thumbnails, so "the one with the
infra bullet points" is something you see, not something you remember. Each
card shows the posting it targets, its score, and when you last touched it.
The category keeps a family-wide job description as the default for versions
that aren't aimed at one specific posting.

### ⚡ Type LaTeX, watch the PDF

Edit on the left, and the compiled page settles onto the light table on the
right a moment later. No save button mashing, no terminal — Tectonic compiles
in the background as you type.

### 📥 Bring an existing resume

Already have a PDF or a Word doc you'd rather not retype? Hit **Add a
resume → From an existing PDF / Word**. The app extracts the text
locally, asks the configured AI provider to rewrite it as
`resume.cls`-flavored LaTeX, and shows you a side-by-side preview
(source on the left, Tectonic-compiled PDF on the right) before
anything lands in the vault. **Use this version** to adopt it as a new
LaTeX version; **Retry** asks the model to take another swing.

The same "+" button also covers **Start from a blank LaTeX** (the old
empty-template flow) and **Archive a PDF only** (store as-is, not
editable). One entry, one chooser, no more guessing which of three
cards to click.

### 🎯 Tailor to a job link

Paste a job posting's URL. The app fetches the page, has the AI pull out the
role, the hard requirements and the keywords, then rewrites a copy of a
resume you pick — reordering sections, reframing bullets in the posting's own
vocabulary, compressing what's irrelevant. It never invents experience: the
rewrite closes with a note saying what it changed, why, and **which
requirements it found no evidence for** in your resume. The result is
compile-checked before you adopt it, and lands as a new version beside the
resume it was built from.

### ✦ Rewrite with an expert eye

Select a flabby bullet and ask the built-in AI assistant for a sharper one —
the suggestion arrives as an in-place diff you can accept or reject, tuned to
the job description you saved on the category.

### 🕰 Checkpoint, diff, restore

Never lose a good paragraph again. Snapshot a version whenever it feels right,
leave yourself a note, and diff or restore any earlier state later.

### ☁️ Your resume history, in your own repo

Point the app at a private GitHub repo and your whole vault becomes a
directory of `.tex` files with real commit history — every checkpoint pushes
itself, and edits made elsewhere pull back in. It's your repo, your account,
your data: no service in the middle, nothing to subscribe to, nothing that
disappears if this project does. Wipe your laptop, reinstall, reconnect —
the vault comes back whole, with its history intact.

### 🔑 Bring your own model

There is no bundled AI and no account to create. You paste an API key from a
provider you already pay for, and switch models whenever you like — a cheap
one for scoring every draft, a strong one for the rewrite that matters.

| Provider | Notes |
|---|---|
| **Anthropic** | Opus / Sonnet / Haiku |
| **OpenAI** | GPT-4o, GPT-4o mini, o1 |
| **DeepSeek** | cheapest per run; the default pick for bulk scoring |
| **Moonshot / Kimi** | moonshot-v1 8k–128k, Kimi k1.5 |
| **Any OpenAI-compatible endpoint** | your own base URL + model name — local llama.cpp, vLLM, a gateway, whatever answers the API |
| **Claude Code CLI** | already installed? use it, no key needed |

The key is stored on your machine and is sent to exactly one place: the
provider you chose. Every AI action is opt-in and labelled, so nothing calls
out — or costs you anything — unless you ask it to.

### 🖼 Assets that just compile

`\includegraphics{logo.png}` works the way you'd hope: attach the file once
and every compile of that version can see it — synced to GitHub along with
everything else.

### 🌗 Dark-first, light-ready

A midnight-letterpress dark theme for late-night editing, a clean paper-white
one for daylight — both follow the system automatically.

## Quick start

```bash
# 0. verify prerequisites (Node ≥ 20, Rust ≥ 1.78, Xcode CLT, git) — details in Requirements below

# 1. clone
git clone git@github.com:rayxie666/resume_vaulte.git
cd resume_vaulte

# 2. install JS deps (Vite, React, Tauri JS plugins, pdfjs, jsdiff)
npm install

# 3. launch in dev mode — opens a native window, hot-reload for frontend,
# auto-rebuild for Rust on change
npm run tauri dev
```

<details>
<summary>Verify prerequisites — all four must print a version</summary>

```bash
node --version    # ≥ 20
cargo --version   # ≥ 1.78  (missing? see Requirements below, then `source ~/.cargo/env`)
cc --version      # Xcode CLT
git --version
```

</details>

First Rust build is slow (~1-3 min, downloads ~100 crates). Subsequent dev
launches are seconds.

## Requirements

You'll need these installed before running the app:

| Tool                                   | Purpose                                     | macOS install                    |
| -------------------------------------- | ------------------------------------------- | -------------------------------- |
| **Node.js ≥ 20**                       | Vite dev server, npm scripts                | `brew install node`              |
| **Rust (stable, ≥ 1.78)**              | Tauri backend                               | `curl -sSf https://sh.rustup.rs \| sh -s -- -y` |
| **Xcode Command Line Tools**           | C linker / SDK for Tauri builds             | `xcode-select --install`         |
| **Tectonic** _(only for LaTeX preview)_ | Single-binary LaTeX engine, auto-fetches packages | `brew install tectonic`     |
| **git ≥ 2.30** _(only for GitHub sync)_ | Runs `git clone/commit/push` from Rust     | already on macOS via Xcode CLT   |

The app degrades gracefully if Tectonic or git are missing — LaTeX preview /
GitHub sync just stop working, the rest still does.

> **Note on Rust**: after installing via rustup, `cargo` lives in
> `~/.cargo/bin`, which is only added to `PATH` for **new** shells (rustup
> appends `. "$HOME/.cargo/env"` to your shell profile). In the terminal you
> ran the installer from, run `source "$HOME/.cargo/env"` first — otherwise
> `tauri dev` fails with a confusing `failed to run 'cargo metadata'` error
> (see [Troubleshooting](#troubleshooting)).

## Windows

Resumimi runs on Windows 10/11 (x64). Install these, then the build and
run commands are identical to macOS (`npm install && npm run tauri dev`):

| Tool | Install |
| --- | --- |
| **Node.js ≥ 20** | <https://nodejs.org/> or `winget install OpenJS.NodeJS.LTS` |
| **Rust (stable ≥ 1.78)** | <https://rustup.rs/> — pick the `x86_64-pc-windows-msvc` host |
| **MSVC Build Tools** | Visual Studio Installer → "Desktop development with C++" |
| **WebView2 Runtime** | Built into Windows 11; on Windows 10 run `winget install Microsoft.EdgeWebView2Runtime` |
| **Git for Windows** _(only for GitHub sync)_ | `winget install Git.Git` |
| **Tectonic** _(only for LaTeX preview)_ | `winget install --id TectonicProject.Tectonic`, or download from <https://tectonic-typesetting.github.io/> |

The app finds `tectonic`, `git`, and the Claude Code CLI on your `PATH` (with
the usual winget/scoop/npm install locations as fallbacks), and stores its data
under `%APPDATA%\com.zheruixie.resumevault\`.

The release installers are **unsigned**, so SmartScreen warns on first launch.
Click **More info → Run anyway**, or right-click the installer → **Properties**
→ tick **Unblock**. Code signing is planned but not yet in place.

## GitHub sync

In the app: **Settings (⚙)** → **GitHub Sync**.

1. Create a private repo (e.g. `rayxie666/resume_vaulte_data`).
2. Generate a fine-grained PAT at
   <https://github.com/settings/personal-access-tokens> with:
   - Resource owner: yourself
   - Repository access: only the vault repo
   - Permissions → **Contents: Read and Write**
3. Paste URL + PAT in the app, pick a branch (defaults to `main`), Connect.
4. Hit **Sync now** for a full snapshot, or toggle **Auto-push on checkpoint** to
   push every snapshot you save in the LaTeX editor.

Repo layout the app writes:

```
vault.json                       # top-level index of categories
README.md
assets/
  _meta.json                     # name → { mime, size, updated_at }
  logo.png                       # attachment bytes, filename = identity
categories/
  1-google-swe/
    _meta.json                   # category info (name, JD, icon, color, notes)
    1-polished.tex               # latex source
    1-polished.json              # version metadata
    2-imported.pdf               # imported binary
    2-imported.json
  3-bytedance-sre/
    ...
```

Each checkpoint commits with message `v<seq> <name> (<category>): <note>`, so
the `git log` of any `.tex` file is exactly its checkpoint history.

The PAT is stored only in `localStorage` and never leaves your machine except
as part of the `https://x-access-token:TOKEN@github.com/...` URL Tauri's git
process uses internally. Compile logs redact the token to `***`.

## AI providers (bring your own key)

In the app: **Settings (⚙)** → **AI**.

Pick a provider, paste a key, pick a model. That's the whole setup — there is
no account for this app and no bundled quota.

| Provider | Base URL | Where to get a key |
|---|---|---|
| Anthropic | `https://api.anthropic.com` | <https://console.anthropic.com/settings/keys> |
| OpenAI | `https://api.openai.com/v1` | <https://platform.openai.com/api-keys> |
| DeepSeek | `https://api.deepseek.com` | <https://platform.deepseek.com/api_keys> |
| Moonshot / Kimi | `https://api.moonshot.cn/v1` | <https://platform.moonshot.cn/console/api-keys> |
| Custom | anything OpenAI-compatible | your own gateway / local server |
| Claude Code CLI | — | none; uses the `claude` binary on your `PATH` |

**Switching models** is a dropdown, not a reinstall. Each provider ships a
short curated list, and "Custom" lets you type any model id the endpoint
accepts. A practical split: something cheap (DeepSeek) for scoring every
draft, something strong (Opus / o1) for the tailoring rewrite you'll actually
send.

**What gets sent where.** The key lives in the app's local storage on your
machine and goes to exactly one host: the provider you picked. Resume text
and job descriptions are sent to that provider when *you* trigger an AI
action — scoring, rewriting, importing, tailoring. Nothing is sent in the
background, and no telemetry goes anywhere. Every button that spends tokens
says so.

**Cost, honestly.** A scoring pass runs about $0.001 on DeepSeek and about
$0.08 on Claude Opus; a full JD-tailoring run is two calls. Results are
cached per (resume, JD) pair, so re-opening a version you've already scored
costs nothing.

## Attachments (LaTeX images / extra files)

LaTeX templates that use `\includegraphics{logo.png}` or other external assets
won't compile out of the box — Tectonic runs in a fresh temp directory and
needs the files alongside `main.tex`. The app handles this via a per-version
**Attachments** panel:

1. Open a LaTeX version → click **Attachments** in the editor toolbar.
2. Add PNG/JPG/PDF/EPS files (max 5 MB each, 30 MB total per compile).
3. The file's base name is what `\includegraphics{...}` references, e.g. an
   uploaded `bytedance.png` is reachable as `\includegraphics{bytedance.png}`.
4. Preview recompiles automatically; assets are written to the temp dir each
   time and removed after.

Attachments live in the SQLite vault (global `assets` table, base64-encoded)
and are linked to versions via `resume_version_assets`. When GitHub sync is
connected they are pushed to `assets/<name>` in the repo (with an
`assets/_meta.json` index) and restored on pull, including the
version↔attachment links.

The Rust side rejects illegal names (`..`, slashes, dotfiles) and oversized
files with a clear hint in the compile log.

## Where data lives

```
~/Library/Application Support/com.zheruixie.resumevault/
├── vault.db                  # SQLite: categories, versions, checkpoints
├── pdfs/                     # imported PDF files (referenced by file_path)
├── last-compile.log          # most recent Tectonic invocation (for debugging)
└── github_repo/              # working tree of your synced GitHub repo (if connected)
```

Delete that folder to nuke the app's state completely.

## Building a release `.app` / `.dmg`

```bash
npm run tauri build
```

Outputs (per the OS you build on):

```
src-tauri/target/release/bundle/
├── macos/  dmg/                    # macOS: resumimi.app, *_aarch64.dmg
├── msi/                            # Windows: resumimi_<version>_x64_en-US.msi
└── nsis/                           # Windows: resumimi_<version>_x64-setup.exe
```

On Windows both installers double-click to install; the app lands in the Start
menu with the bundled icon. SmartScreen warning → see [Windows](#windows).

The macOS binary is unsigned. On first launch Gatekeeper will block it:

- **Finder** → right-click `resumimi.app` → **Open** → **Open**
- Or: `xattr -dr com.apple.quarantine resumimi.app`

To sign + notarize for distribution, set up Apple Developer credentials and
follow [Tauri's macOS signing guide](https://tauri.app/v2/distribute/sign/macos/).

Prebuilt artifacts: see [Releases](https://github.com/rayxie666/resume_vaulte/releases).

## Troubleshooting

**`failed to run 'cargo metadata' ... No such file or directory (os error 2)`**
when running `npm run tauri dev` — Tauri can't find `cargo` on your `PATH`.
Either Rust isn't installed (see [Requirements](#requirements)), or it was just
installed and the current shell hasn't picked it up yet:

```bash
source "$HOME/.cargo/env"   # fix the current shell
cargo --version             # should now print a version
```

New terminals get it automatically via your shell profile.

**Gatekeeper blocks the built `.app`** — see
[Building a release](#building-a-release-app--dmg) above; the binary is
unsigned.

**`tectonic not found`** (shown in the LaTeX preview pane) — the Tectonic
engine isn't installed. Fix:

```bash
brew install tectonic                                  # macOS
winget install --id TectonicProject.Tectonic           # Windows
```

Then restart the app (a running instance won't pick up the new binary). The
first compile is slow: Tectonic downloads LaTeX packages on demand and caches
them (`~/Library/Caches/Tectonic` on macOS,
`%LOCALAPPDATA%\TectonicProject\Tectonic` on Windows).

**`[plugin:vite:import-analysis] Failed to resolve import "three" from "src/pet/catScene.ts"`**
— the 3D pet companion depends on `three` (declared in `package.json`) but
`node_modules/three` is missing. Happens after pulling a commit that added the
dep without re-running install. Fix:

```bash
npm install
```

Then restart `npm run tauri dev`. Same recipe for any other "Failed to resolve
import" pointing at a dep that already lives in `package.json`.

**Import-resume: the PDF preview is empty / "no extractable text"** — the
source PDF is a scanned image (no embedded text layer). OCR is not
shipped yet. Open the PDF in another tool first (`pdftotext`, macOS
Preview's Copy text, or a Word save-as-text round-trip) and paste the
output into a blank LaTeX version instead.

**Import-resume: "Argument of `\name` has an extra `}`" in the preview
log** — historically the AI placed `\name{}` / `\address{}` inside
`\begin{document}`, where resume.cls's `\printname` hook reads them too
early. The current build lifts those calls into the preamble
automatically; if you still hit this, you're on an older build —
upgrade and retry.

**Import-resume: "The AI did not produce a LaTeX resume"** — the active
AI provider returned an acknowledgment ("Done." / "No pending tasks.")
instead of source. Most often this is Claude Code CLI mode in agent
mode. Switch to a direct API key (Claude / OpenAI / DeepSeek / Kimi) in
**Settings → AI** and retry.

## Architecture

For contributors — how the codebase is laid out and why.

### Project layout

```
resumimi/
├── src/                        # React frontend (Vite + TS)
│   ├── App.tsx                 # state, navigation, data loading — no surfaces
│   ├── views/                  # one file per surface (Home, Category, VersionDetail, Settings)
│   ├── components/             # shared pieces (NavBar, cards, ledger, primitives)
│   ├── styles/                 # App.css is an @import manifest over these
│   ├── jd.ts                   # resolves a version's effective JD (version → category)
│   ├── jdFetch.ts              # job-posting URL → readable page text
│   ├── jdTailor.ts             # JD extraction + whole-document tailoring
│   ├── TailorModal.tsx         # the JD-link wizard
│   ├── HistoryPanel.tsx        # checkpoint diff/restore
│   ├── Dialogs.tsx             # prompt/confirm modals (WKWebView blocks window.prompt)
│   ├── db.ts                   # tauri-plugin-sql wrapper
│   ├── github.ts               # vault → file-tree serializer + git invokes
│   ├── latexCompile.ts         # invoke Rust compile_latex
│   ├── importToLatex.ts        # 2-stage AI pipeline: extracted text → resume.cls LaTeX
│   ├── ImportPreviewModal.tsx  # side-by-side preview (.tex / compiled PDF) for imports
│   ├── ai.ts                   # provider config, system prompt, invoke wrappers
│   ├── thumbnail.ts            # PDF.js → dataURL for cards
│   ├── useThumbnail.ts         # cached, queued thumbnail hook
│   ├── i18n.ts                 # en/zh translation context
│   └── ...
├── src-tauri/                  # Rust backend
│   ├── src/
│   │   ├── lib.rs              # app entry, plugin + command registration, SQL migrations
│   │   ├── latex.rs            # tectonic invocation, log capture
│   │   ├── import.rs           # extract_pdf_text / extract_docx_text commands
│   │   ├── fetch.rs            # fetch_url — job-posting pages for the tailor flow
│   │   ├── ai.rs               # ai_complete + claude_code_run handlers
│   │   ├── resume_cls.rs       # bundled LaTeX class for the default template
│   │   └── git.rs              # git clone / commit / push wrappers
│   ├── Cargo.toml
│   └── tauri.conf.json         # window config, identifier
├── package.json
└── README.md
```

### Development notes

- **Hot reload**: edits to `src/` reload instantly via Vite HMR; edits to
  `src-tauri/` trigger a Cargo rebuild and Tauri restart.
- **Native dialogs (alert/prompt/confirm)** are blocked by WKWebView. Use the
  React modal system in `src/Dialogs.tsx`.
- **SQL migrations** are append-only in `src-tauri/src/lib.rs`. Bump the
  `version` and add a `Migration { ... }` entry. They run once per install on
  startup.
- **PDF.js worker** is bundled via `?worker` import (see `src/thumbnail.ts`) to
  avoid Tauri custom-protocol Worker loading issues.
- **Concurrency**: thumbnail rendering uses a 2-job queue (`src/useThumbnail.ts`)
  to avoid pinning the CPU when 10 PDF cards mount at once.

### Tech stack

- [Tauri 2](https://tauri.app/) — desktop wrapper, ~10 MB Rust binary
- [React 19](https://react.dev/) + [TypeScript](https://www.typescriptlang.org/) — frontend
- [Vite 7](https://vitejs.dev/) — dev server / bundler
- [tauri-plugin-sql](https://github.com/tauri-apps/plugins-workspace) — SQLite
- [tauri-plugin-fs](https://github.com/tauri-apps/plugins-workspace) / [-dialog](https://github.com/tauri-apps/plugins-workspace) — file I/O
- [Tectonic](https://tectonic-typesetting.github.io/) — LaTeX → PDF
- [PDF.js](https://mozilla.github.io/pdf.js/) — first-page thumbnails
- [jsdiff](https://github.com/kpdecker/jsdiff) — checkpoint diff rendering
- [pdf-extract](https://crates.io/crates/pdf-extract) — pure-Rust PDF text extraction (resume import)
- [zip](https://crates.io/crates/zip) — pure-Rust DOCX (= zip) reader for resume import

## Bundled fonts

The macOS app bundle ships three FontAwesome 5 Free OTFs
(`src-tauri/resources/fonts/`) and copies them into Tectonic's working
directory at compile time via the `OSFONTDIR` env var. This lets
`\usepackage{fontawesome5}` work out of the box on machines that don't have the
fonts installed system-wide. The fonts are licensed under
[SIL OFL 1.1](https://scripts.sil.org/OFL); see `LICENSE.txt` in the fonts
folder.

## Credits

- Pet cat sprites: [Lumi-arta/desktop_cat](https://github.com/Lumi-arta/desktop_cat) (a.k.a. 月薪喵), MIT. See `src/pet/assets/cat/CREDIT.txt`.

## License

MIT (app code).
FontAwesome 5 Free fonts under SIL OFL 1.1 (see `src-tauri/resources/fonts/LICENSE.txt`).

resume_vaulte

resume_vaulte Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

resume_vaulte

resume_vaulte Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README