Documentation

Getting Started

Everything you need to capture your dev story, generate summaries, and share your work with the world.

Quick Start

Up and running in under 5 minutes.

1 Install the Desktop App

Download the Tauri desktop app for your platform. Terminal Biographer supports Windows, macOS, and Linux.

# Clone the repository
$ git clone https://github.com/dangerous-media/terminal-biographer.git
$ cd terminal-biographer

2 Start the Server

The FastAPI server handles event capture, summarization, and the API. Launch it with one command:

$ python tools/dwl/start_server.py
# Server starts on http://localhost:7749
# PID tracked automatically for restart/stop

💡 Use --restart to restart or --stop to shut down. Use --status to check if the server is running.

3 Open the UI

Launch the Tauri desktop app, or open the web UI directly at http://localhost:7749. You’ll see your daily timeline, capture status, and summary controls.

# Launch the desktop app
$ cd app && cargo tauri dev

Capture Sources

Terminal Biographer watches your workflow from multiple entry points.

Terminal

Shell commands from bash, zsh, PowerShell, and cmd are captured automatically when the capture hook is active. Each command logs the command text, timestamp, working directory, and exit code.

# What gets captured:
event: terminal_command
cmd: “git push origin main”
cwd: “/home/dev/my-project”
timestamp: “2026-04-02T14:32:01Z”

VS Code

File open, save, and close events are tracked via the VS Code extension. We capture file paths and timestamps, not file contents.

AI Chats

Conversations from Claude, ChatGPT, Gemini, and other AI tools can be captured two ways:

Desktop: The capture hook monitors configured AI chat applications and logs conversation excerpts.
Mobile: Use the Android Share Sheet to share any text from any AI app directly into your daily log.

Git

Git commits, branch changes, merges, and pushes are captured via a post-commit hook. Install it in any repository you want to track:

# Install the git hook in a project
$ cp tools/dwl/hooks/post-commit .git/hooks/
$ chmod +x .git/hooks/post-commit

⚙️ You can enable or disable any capture source in the app settings. Nothing is captured until you explicitly configure and activate a hook.

Summaries

Two engines, three formats, zero manual effort.

Template Summarizer (Free)

The default summarizer uses pattern detection and heuristic templates to generate structured summaries. No API calls, no cost, fully offline.

Groups events by source and project
Detects key activities (deployments, bug fixes, refactors)
Generates ops report, blog post, and LinkedIn post formats

# Use the template summarizer (default)
$ DWL_SUMMARIZER=template python -m tools.dwl.summarize –date 2026-04-02

Claude Summarizer (Premium)

The premium tier sends your encrypted events to the Anthropic API, which generates natural-language narratives with personality, technical insight, and storytelling structure.

# Use the Claude summarizer
$ DWL_SUMMARIZER=claude python -m tools.dwl.summarize –date 2026-04-02

Output Formats

Both summarizers produce three formats:

Ops Report — Detailed technical breakdown of your day, suitable for standups and engineering logs.
Blog Post — Narrative-style post with a catchy title, suitable for dev blogs and personal sites.
LinkedIn Post — Concise hook + value + proof + CTA format optimized for social engagement.

Auto-Summarize

By default, Terminal Biographer runs auto-summarization at 23:59 daily. Disable with DWL_AUTO_SUMMARIZE=false in your environment.

Mobile

Your dev log, in your pocket.

Android App

The Android app uses the same unified UI as the desktop app, built with Tauri v2. It connects to your Supabase cloud sync (or local server via LAN) to display your daily timeline, summaries, and share controls.

# Build the Android APK
$ cd app && cargo tauri android build –debug

Share Sheet Receiver

The killer mobile feature: share text from any Android app directly into your daily log. Select text in Claude, ChatGPT, a browser, or a note-taking app, tap “Share”, and choose Terminal Biographer. The content is added to today’s events instantly.

Sync

Mobile and desktop stay in sync via encrypted Supabase cloud sync. Changes propagate within 5 minutes. Both devices use the same encryption passphrase for seamless decryption.

Self-Hosting

Run Terminal Biographer on your own infrastructure.

Requirements

Python 3.10+
pip (package manager)
Optional: Docker for containerized deployment

Setup

# Clone and install dependencies
$ git clone https://github.com/dangerous-media/terminal-biographer.git
$ cd terminal-biographer
$ pip install -r requirements.txt

# Configure environment
$ cp .env.example .env
# Edit .env with your settings:
# DWL_API_KEY=your-secret-key
# DWL_SUMMARIZER=template
# DWL_AUTO_SUMMARIZE=true

# Start the server
$ python tools/dwl/start_server.py

Docker

$ docker build -t terminal-biographer .
$ docker run -p 7749:7749 -v tb-data:/app/logs terminal-biographer

Cloud Sync (Optional)

To enable multi-device sync with your self-hosted setup, you’ll need a Supabase project:

# Add to .env:
DWL_SYNC_ENABLED=true
SUPABASE_URL=https://your-project.supabase.co
SUPABASE_SERVICE_KEY=your-service-key
DWL_SYNC_PASSPHRASE=your-encryption-passphrase

Run the Supabase schema migrations from tools/dwl/sql/ to set up the required tables and RLS policies.

Encryption

How Terminal Biographer keeps your data safe.

AES-256-GCM

Terminal Biographer uses AES-256-GCM (Galois/Counter Mode) for all encryption. This is the same standard used by governments and financial institutions. It provides both confidentiality and integrity verification.

How It Works

Key derivation: Your encryption key is derived from your passphrase using PBKDF2 with a unique salt. This happens entirely on your device.
Encryption at rest: Every event log, summary, and daily digest is encrypted before being written to disk. Files are stored as encrypted JSONL.
Encryption in transit: If cloud sync is enabled, data is encrypted on your device before being sent to Supabase. The server only ever sees ciphertext.
Unique IVs: Each encryption operation uses a random 12-byte initialization vector (IV), ensuring that identical plaintext produces different ciphertext.

Key Management

# Reading encrypted data (Python API)
from tools.dwl.crypto import read_encrypted_jsonl, decrypt_file_content

# Read events from an encrypted JSONL file
events = read_encrypted_jsonl(“logs/events/2026-04-02.jsonl.enc”, key)

# Decrypt a single file
content = decrypt_file_content(“logs/summaries/2026-04-02.json.enc”, key)

⚠️ Important: If you lose your encryption passphrase, your data cannot be recovered. There is no backdoor, no master key, and no recovery mechanism. This is by design. Store your passphrase securely.

Web Crypto API

The browser-based UI uses the Web Crypto API for client-side encryption/decryption. Your passphrase never leaves the browser — all crypto operations happen locally in the WebView.