A journaling CLI for developers that builds career intelligence over time.
Your work is documented. You aren't.
Jira knows what you shipped. Your PRs know what you changed. Neither knows why
you chose it, what you were worried about, or what you were trying to become —
the part your review and your next interview actually run on.
Paper is where that goes. Write a line a day in the terminal you already have
open; get standup notes tomorrow morning and a coach that knows your work.
---
## Install
```bash
npm install -g @rewrlution/paper-cli
paper # answer four questions, write your first entry
```
Journaling is free and works offline forever — no account, no API key, nothing
to configure. The AI features (follow-ups, recap, coach) run on
Paper's servers:
```bash
paper auth register # 14 days free, no card
```
**You never supply an API key.** Model access comes with your account.
## Commands
**Write**
```bash
paper # guided entry — AI asks 2-3 follow-up questions, then saves
paper add # open $EDITOR, save
paper edit # reopen today's entry
paper log "..." # quick one-liner append
paper show # read today's (or any) entry
paper list # browse past entries, open one
paper stats # streak, word count, the heatmap
```
**Review**
```bash
paper recap # last 7 days as standup notes, copied to your clipboard
paper recap --since monday # from last Monday
paper recap --since yesterday # yesterday only — the daily standup
paper recap --days 14 # any window
```
Recap is ephemeral: it drafts notes you paste and throw away, and never writes
to your career record.
**Career**
```bash
paper career # what Paper knows about you, and which journals say so
paper career import # read an old resume or LinkedIn export into your history
paper career refresh # fold new journals in — proposes wins, you confirm each one
paper career edit # fix anything by hand — roles, dates, bullets, contact
paper coach # coaching conversation — knows your career and your goal
paper coach history # reopen a past conversation — read it, or keep talking
```
**Resumes**
```bash
paper resume # browse every resume you've written, newest first
paper resume new # a resume from everything Paper knows
paper resume new --for # a one-pager aimed at that job posting
paper resume edit # reopen one to polish it, and re-render its PDF
```
Your career record is the master; a resume is a render of it. Anything true
about you is `paper career`; anything you send someone is `paper resume`.
**Account & sync (optional)**
```bash
paper auth register # create a Paper account — 14 days free, no card
paper auth login # log in on another device
paper auth status # who you are, and what your plan allows
paper sync # push journals + profile up, pull other devices down
paper subscribe # move to a paid plan when the trial ends
paper auth logout
```
**Setup**
```bash
paper import # bring in existing notes as journals (see below)
paper config set editor nvim
paper setup # re-run onboarding
```
---
## How it works
You write daily. `paper recap` drafts standup notes from a window of entries and
copies them to your clipboard — ephemeral, nothing is kept. `paper career refresh`
is the durable path: it reads new journals, proposes wins, and folds in only the
ones you confirm. Confirmed wins live in `career.json`, each citing the journals
it came from.
`paper coach` reads that record, so a session opens already knowing your goal
and your recent work. Corrections you make during review ("gyroscope is part of
code-video, not its own project") are saved to the record's notes, so every
future output gets them right — without re-asking.
**Storage:** plain-text files under your OS data directory
(`~/Library/Application Support/paper` on macOS, `~/.local/share/paper` on
Linux):
| File | What it is |
|---|---|
| `journals/YYYYMMDD.md` | your words — immutable, never edited by AI |
| `bio.json` | your level, company, and goal — the four things `paper setup` asks |
| `career.json` | what Paper learned about you, and which journals say so (you confirm it) |
| `resumes/-/v.{md,pdf}` | every resume, and every version of it — nothing is overwritten |
| `coach/.jsonl` | saved coach conversations, appended as you talk |
---
## Importing existing notes
Already have a folder of daily notes — from Obsidian, another journaling app, or
just markdown files you've kept yourself? Point `paper import` at it and each
file becomes a journal entry.
Always start with `--dry-run`. It writes nothing and shows you exactly what
would be imported:
```bash
paper import --dry-run
```
Run the same command without `--dry-run` when the list looks right.
**Which files get picked up**
```
your-notes-folder/ ← the folder you point paper at
├── 20260701.md ✓ imported as July 1
├── 2026-07-02.md ✓ imported as July 2
├── 2026-07-03.txt ✓ .txt works too
├── monday.md ✓ imported — but dated by when you last
│ edited the file, not by its name
├── ideas.md ✓ same — every .md and .txt comes along
├── empty.md ✗ skipped, nothing in it
├── screenshot.png ✗ skipped, only .md and .txt are read
├── notes.pdf ✗ skipped
└── archive/ ✗ skipped — subfolders are never opened
└── 20250104.md ✗ not imported
```
**How paper dates each entry**
It checks four things, in order, and uses the first one it finds:
1. `20260727` at the start of the filename
2. `2026-07-27` at the start of the filename
3. A `date:` field in the file's frontmatter
4. The file's last-modified time
That last rule is a catch-all: a file with no date anywhere still gets imported,
filed under whenever you last edited it. So point paper at the folder that
actually holds your entries — a whole notes vault will bring everything along.
The dry run shows you before a single file is written.
**If a date already exists**
Paper stops and asks before touching anything. You can skip those days, append
the imported text below what's already there, or overwrite. Decide up front with
`--on-conflict skip`, `append`, or `overwrite`.
Wiki-links (`[[like this]]`) come through as plain text — nothing breaks, but
they won't resolve. Embedded images and attachments aren't copied.
---
## Sync (multi-device)
Write it once, have it everywhere. Journals, profile, and coach conversations
follow you to every machine you log in from — so a new device already knows who
you are, and Paper never asks you the same question twice.
```bash
paper auth register # or `paper auth login` on the second machine
paper sync
```
That's it — sync runs against Paper's hosted API, and there's nothing to
configure. Synced content is encrypted at rest.
---
## Support
Stuck, hit a bug, or need your plan changed by hand? Email rewrlution@gmail.com.
