A secure, privacy-first desktop application for peptide protocol tracking, dose logging, and research management.

PepTrack is a macOS-first desktop application built with Rust, Tauri, and Vue 3, featuring military-grade encryption, local AI integration, and comprehensive backup capabilities. All data stays local and encrypted—no cloud dependency required.

• Protocol Management - Create and manage peptide protocols with detailed tracking
• Dose Logging - Complete dose tracking with calendar views and history
• Supplier & Inventory - Track suppliers, manage vial inventory with expiry dates and batch tracking
• Literature Search - Integrated search across PubMed, OpenAlex, and Crossref APIs with automatic peptide filtering
• Local AI Summaries - Generate research summaries using local Codex CLI (GPT-5) or Claude CLI with peptide-specific context
• AI-Powered Risk Matrix Analysis - Multi-paper safety analysis extracting critical risks, moderate concerns, and study limitations
• AI-Powered Protocol Recommender - Get science-backed protocol recommendations from research papers
• Comprehensive Backup System:
  • Manual and scheduled automatic backups (hourly/daily/weekly)
  • Google Drive OAuth integration for cloud backups
  • Google Calendar integration for dose schedules
  • Backup compression, preview, and restore functionality
  • Automatic cleanup with configurable retention policies
• Desktop Notifications - Configurable notifications for backup events
• Enterprise-Grade Security:
  • ChaCha20-Poly1305 envelope encryption for all data
  • macOS Keychain integration for encryption keys
  • Automatic key migration from file-based storage
  • Zero telemetry or tracking

• Enhanced Dashboard - Comprehensive analytics with multiple visualization widgets:
  • 📅 Dose Calendar Heatmap - GitHub-style 365-day adherence visualization with streak tracking
  • 📊 Protocol Progress Tracker - Circular progress rings showing protocol completion and milestones
  • 💰 Cost Analysis Dashboard - Supplier comparison, spending analytics, and optimization tips
  • 📋 Recent Activity Timeline - Chronological feed of all user actions with date grouping
• Global Search - Lightning-fast search across all data (Cmd+K or Cmd+P)
• Keyboard Shortcuts - Power user shortcuts for navigation and actions:
  • Press ? to view all available shortcuts
  • 1-8 for quick tab navigation
  • Cmd+K for global search
  • Tab-specific shortcuts for common actions
• Quick Actions FAB - Floating action button for one-click access to common tasks
• Onboarding Flow - Interactive 8-step guided tour for new users
• Dark Mode - Full dark mode support with toggle in settings
• Empty States - Beautiful, actionable empty states throughout the app
• Loading Skeletons - Smooth loading animations for better perceived performance

graph TB
    subgraph "Frontend Layer"
        Vue[Vue 3 SPA<br/>TypeScript + Vite]
        Pinia[Pinia State Management<br/>5 Stores]
        Components[Vue Components<br/>30+ Components]
    end

    subgraph "Tauri Bridge"
        IPC[Tauri IPC Layer<br/>~40 Commands]
        Plugins[Tauri Plugins<br/>Log, Notification, Dialog]
    end

    subgraph "Backend Layer"
        Commands[Command Handlers<br/>11 Modules]
        AppState[Application State<br/>Storage + AI Client]
    end

    subgraph "Core Libraries"
        Core[peptrack-core<br/>Storage + Encryption]
        LocalAI[peptrack-local-ai<br/>CLI Orchestrator]
        Literature[peptrack-literature<br/>API Fetchers]
    end

    subgraph "Data & External"
        SQLite[(SQLite Database<br/>Encrypted)]
        Keychain[macOS Keychain<br/>Key Storage]
        APIs[External APIs<br/>PubMed, OpenAlex,<br/>Crossref, Google Drive]
    end

    Vue --> Pinia
    Pinia --> Components
    Components --> IPC
    IPC --> Commands
    Commands --> AppState
    AppState --> Core
    AppState --> LocalAI
    Commands --> Literature
    Core --> SQLite
    Core --> Keychain
    Literature --> APIs
    Commands --> APIs

sequenceDiagram
    participant User
    participant Vue as Vue Component
    participant Store as Pinia Store
    participant IPC as Tauri IPC
    participant Cmd as Command Handler
    participant Core as Core Library
    participant DB as SQLite (Encrypted)

    User->>Vue: Create Protocol
    Vue->>Store: createProtocol(payload)
    Store->>Store: Optimistic Update
    Store->>IPC: invoke("save_protocol")
    IPC->>Cmd: save_protocol(payload)
    Cmd->>Core: upsert_protocol(data)
    Core->>Core: Encrypt with ChaCha20
    Core->>DB: INSERT encrypted blob
    DB-->>Core: Success
    Core-->>Cmd: Return protocol
    Cmd-->>IPC: Return protocol
    IPC-->>Store: Protocol created
    Store->>Vue: Update UI
    Vue->>User: Show success toast

    Note over Store,Vue: On error: rollback<br/>optimistic update

flowchart LR
    A[Raw Data<br/>JSON] --> B[Serialize to String]
    B --> C[Generate Random<br/>12-byte Nonce]
    C --> D[Get 32-byte Key<br/>from Keychain]
    D --> E[ChaCha20-Poly1305<br/>Encrypt]
    E --> F[Prepend Nonce<br/>to Ciphertext]
    F --> G[Store as BLOB<br/>in SQLite]

    G --> H[Read BLOB<br/>from SQLite]
    H --> I[Extract Nonce<br/>first 12 bytes]
    I --> J[Get Key<br/>from Keychain]
    J --> K[ChaCha20-Poly1305<br/>Decrypt]
    K --> L[Deserialize<br/>from String]
    L --> M[Rust Struct<br/>Decrypted Data]

    style E fill:#ff6b6b
    style K fill:#51cf66

• PubMed - Biomedical literature database
• OpenAlex - Scholarly works catalog
• Crossref - DOI metadata service
• Google Drive - OAuth 2.0 cloud backup

PepTrack/
├── frontend/                      # Vue 3 + Vite SPA
│   ├── src/
│   │   ├── App.vue               # Main application
│   │   ├── components/           # 30+ Vue components
│   │   │   ├── Dashboard.vue            # Enhanced dashboard with analytics
│   │   │   ├── DoseCalendarHeatmap.vue  # 365-day adherence heatmap
│   │   │   ├── ProtocolProgressTracker.vue # Protocol progress rings
│   │   │   ├── CostAnalysisDashboard.vue   # Cost analytics & tips
│   │   │   ├── RecentActivityTimeline.vue  # Activity feed
│   │   │   ├── GlobalSearch.vue            # Global search (Cmd+K)
│   │   │   ├── KeyboardShortcutsHelp.vue   # Shortcuts help (?)
│   │   │   ├── OnboardingFlow.vue          # 8-step guided tour
│   │   │   ├── QuickActionsFAB.vue         # Floating action button
│   │   │   ├── EmptyState.vue              # Reusable empty states
│   │   │   ├── LoadingSkeleton.vue         # Loading animations
│   │   │   └── ... (20+ more components)
│   │   ├── stores/               # 5 Pinia stores
│   │   ├── composables/          # Vue composables
│   │   ├── api/                  # Tauri IPC wrappers
│   │   └── utils/                # Helper functions
│   ├── package.json              # Node dependencies
│   └── vitest.config.ts          # Test configuration
│
├── src-tauri/                     # Tauri application shell
│   ├── src/
│   │   ├── lib.rs               # App initialization
│   │   ├── state.rs             # AppState bootstrap
│   │   └── commands/            # 11 IPC command modules
│   │       ├── protocols.rs     # Protocol CRUD
│   │       ├── doses.rs         # Dose logging
│   │       ├── suppliers.rs     # Supplier & inventory
│   │       ├── ai.rs            # AI summarization
│   │       ├── literature.rs    # Literature search
│   │       ├── backup.rs        # Manual backups
│   │       ├── restore.rs       # Restore functionality
│   │       ├── scheduler_v2.rs  # Scheduled backups
│   │       └── drive.rs         # Google Drive OAuth
│   ├── Cargo.toml               # Rust dependencies
│   └── tauri.conf.json          # Tauri configuration
│
├── crates/                        # Rust library crates
│   ├── core/                     # Core functionality
│   │   └── src/
│   │       ├── db.rs            # SQLite StorageManager
│   │       ├── models.rs        # Domain types
│   │       ├── encryption.rs    # ChaCha20-Poly1305
│   │       ├── keychain.rs      # macOS Keychain
│   │       └── backup_encryption.rs
│   │
│   ├── local-ai/                 # Local AI integration
│   │   └── src/
│   │       └── lib.rs           # Codex/Claude orchestrator
│   │
│   └── literature/               # Literature APIs
│       └── src/
│           ├── pubmed.rs        # PubMed integration
│           ├── openalex.rs      # OpenAlex integration
│           └── crossref.rs      # Crossref integration
│
├── docs/                         # Technical documentation
│   ├── ARCHITECTURE.md          # Detailed architecture guide
│   ├── future_self.md           # Developer onboarding
│   └── ai_assistant_persona.md  # AI collaboration guide
│
├── README.md                     # This file
├── SETUP.md                      # User setup guide
├── TESTING.md                    # Testing scenarios
└── Cargo.toml                    # Workspace manifest

1. Rust Toolchain

   rustup default 1.91.1
   rustup component add rustfmt clippy
   cargo install tauri-cli --version 2.9.4

2. Node.js (≥ 22)

   node -v  # Should be 22+

3. Optional: AI CLIs (for summarization features)

   # Option 1: Codex CLI (recommended)
   npm install -g codex-cli
   
   # Option 2: Claude CLI (fallback)
   curl https://code.claude.com/install.sh | bash

1. Clone the repository

   git clone https://github.com/your-username/PepTrack.git
   cd PepTrack

2. Install frontend dependencies

   cd frontend
   npm install
   cd ..

3. Run in development mode

   cargo tauri dev

# Format code
cargo fmt

# Lint with clippy
cargo clippy --workspace --all-targets

# Run Rust tests
cargo test --workspace

# Build frontend
cd frontend && npm run build

# Run frontend tests
cd frontend && npm run test -- --run

# Build production release
cargo tauri build

• Location: ~/Library/Application Support/PepTrack/
• Database: peptrack.sqlite (encrypted)
• Encryption Keys: Stored in macOS Keychain (primary) or peptrack.key (fallback)

• Algorithm: ChaCha20-Poly1305 (AEAD)
• Key Size: 32 bytes (256-bit)
• Nonce: 12 bytes, randomly generated per record
• Key Storage: macOS Keychain with automatic migration from file-based storage

• ✅ All data encrypted at rest
• ✅ No telemetry or analytics
• ✅ No cloud sync without explicit user action
• ✅ No data leaves your computer except:
  • Research searches to PubMed/OpenAlex/Crossref (search queries only)
  • AI summaries to your local CLI (your credentials)
  • Google Drive backups to YOUR Google Drive (optional, user-initiated)

• SETUP.md - Complete setup guide for optional features
• TESTING.md - Comprehensive testing scenarios
• docs/ARCHITECTURE.md - Detailed architecture documentation
• docs/future_self.md - Developer onboarding guide

• ✅ Protocol management with full CRUD operations
• ✅ Dose logging with calendar views
• ✅ Supplier & inventory management
• ✅ Literature search (PubMed, OpenAlex, Crossref)
• ✅ Local AI summarization (Codex/Claude)
• ✅ AI-powered protocol recommender
• ✅ Manual and scheduled backups
• ✅ Google Drive OAuth integration
• ✅ Google Calendar integration
• ✅ macOS Keychain integration
• ✅ Desktop notifications
• ✅ Comprehensive error handling
• ✅ Enhanced dashboard with analytics widgets
• ✅ Dose calendar heatmap (365-day visualization)
• ✅ Protocol progress tracker
• ✅ Cost analysis dashboard
• ✅ Recent activity timeline
• ✅ Global search (Cmd+K)
• ✅ Keyboard shortcuts system
• ✅ Quick Actions FAB
• ✅ Onboarding flow
• ✅ Dark mode support
• ✅ Empty states and loading skeletons

• Background reminders for dose schedules
• Vial expiry notifications

• Cloud restore (restore directly from Google Drive)
• Multi-cloud support (Dropbox, OneDrive)
• Backup encryption with user-managed passwords
• Data export (CSV/JSON)
• Mobile companion app

1. Read docs/future_self.md for environment setup
2. Check TESTING.md for testing requirements
3. Follow the coding standards in docs/ai_assistant_persona.md

• Rust: Follow Rust 2021 edition best practices, use anyhow for errors
• Vue/TypeScript: Use Composition API, 2-space indent, PascalCase components
• Testing: All new features require tests
• Documentation: Update relevant docs with any changes

[Add your license here]

Built with:

• Tauri - Desktop app framework
• Vue.js - Progressive JavaScript framework
• Rust - Systems programming language
• Pinia - Vue state management

PepTrack - Your peptides, your data, your control. 🧪