How fastrepl/hyprnote works
Project Type and Purpose
• Hyprnote is a local‐first, full‐stack meeting AI notepad with both a web app and a desktop Tauri client.
• It comprises:
– A browser‐based frontend (apps/app) written in Solid/TypeScript/Vite.
– A desktop client (apps/desktop) built with React/TypeScript + Tauri (Rust) for native integrations.
– A Rust backend/server (apps/app/server) offering REST/OpenAPI endpoints.
– A suite of Rust “crates” providing core functionality (audio I/O, AEC, STT, LLM inference, data models, database access).
– A plugin system (plugins/…) enabling extensibility at runtime.
– A collection of UI extensions (extensions/…) rendered in the frontend.
– A client SDK (packages/client), utility libraries (packages/utils, packages/ui), and documentation site (apps/docs).
File Structure for Architectural Patterns
• Top‐level “apps”: separates Web, Desktop, Docs, CLI, demo scripts.
• “crates/”: modular Rust libraries—audio pipelines (audio‐utils, aec, stt, whisper), ML inference (llama, pyannote), data storage (db‐core, db‐user), plugins (nango, slack, stripe, listener, etc.).
• “plugins/”: Tauri plugin crates plus JS bindings—each exposes commands/events to the desktop host.
• “extensions/”: React widget packages that the user can install in Hyprnote.
• “packages/”: shared TypeScript libraries (client SDK, TipTap editor wrapper, UI primitives).
README for Architectural Insights
• Emphasizes offline AI (Whisper & Llama) and plugin/extension framework.
• Mentions listener plugin providing SessionEvent streams via a Channel abstraction.
• References OpenAPI spec (openapi.gen.json) under apps/app/server/openapi.gen.json.
Main Components & Their Interactions
a. Frontends:
– Web UI (apps/app/src)—connects via HTTP/WebSocket to the Rust server.
– Desktop UI (apps/desktop/src)—runs in Tauri, communicates with Rust backend (src-tauri) via Tauri commands and event channels.
b. Backend/API:
– Rust server (apps/app/server/src) implements OpenAPI endpoints, orchestrates crates for audio capture, transcription, summarization.
– Plugins loaded via Tauri’s plugin system (plugins/*), each exposing commands (e.g., listener.subscribe).
c. Core Services/Libraries:
– Audio ingestion & processing (crates/listener, crates/audio, crates/aec, crates/diart).
– STT & ML inference (crates/stt, crates/whisper, crates/llama, crates/pyannote).
– Data persistence (crates/db-core + crates/db-user), backed by a local SQLite or Turso.
– Business logic (session summarization, template rendering via crates/template).
d. External Services (optional):
– Nango connector for third‑party integrations.
– Stripe/Lago for billing.
– Slack, calendar APIs.
Architectural Patterns & Design Principles
• Modular plugin architecture (microkernel): host (Tauri) loads plugins at runtime.
• Shared core logic in reusable Rust crates.
• Clear separation of concerns: UI ↔ API ↔ domain libraries ↔ storage.
• Local‐first data (embedded DB) with optional sync connectors.
Relationships & Flows
• Frontend → HTTP/WebSocket → Rust Server → Crates → DB/Models
• Desktop UI ↔ Tauri API ↔ Plugins → Native OS / Audio I/O / File System
• Plugins ↔ Core Crates (for STT, storage, network)
• Extensions loaded in UI ↔ SDK ↔ Commands channel to plugins
Detail Without Overthinking
• Break out each major crate group (audio, inference, db, template).
• Similar plugins visually, but list a few representative names (listener, auth, s3).
• That frontends share the same API and core crates via SDK / OpenAPI.
• Local model dependencies separately from external integrations.