refactor: migrate monolithic crate to Cargo Workspace with Clean Architecture

Transform the single binary crate into a 9-crate workspace monorepo: - Root Cargo.toml as [workspace] manager with resolver = "2" - zesdex-entities: Domain entity types (session, settings, store, message, etc.) - zesdex-utils: Pure utility functions (error, logger, pagination, slug, clipboard) - zesdex-dto: Data Transfer Objects for LLM provider API communication - zesdex-ipc: Unix-socket IPC layer (client/server/framing/protocol) - zesdex-iam: Identity & Access Management (Clean Architecture: domain/application/infrastructure) - zesdex-cms: Content Management (Clean Architecture: domain/application/infrastructure) - zesdex-middleware: HTTP middleware (Auth, CORS, Rate Limiting) - zesdex-libs: Composition root (AppContext, DB init, JWT, Argon2) - zesdex-backend: Main binary entry point + seed/migrate binaries - DevOps: Dockerfile, docker-compose, Nix (flake/shell/default), CI/CD updates - Remove dead root src/ and src-misc/ directories All crate re-exports maintain backward compatibility with original crate::model::*, crate::dto::*, crate::ipc::* module paths. Feature crates enforce strict layer separation: domain -> application -> infrastructure with generic trait-based dependency injection.
2026-07-17 09:08:41 +07:00
parent 86cc412395
commit be0a9582bb
248 changed files with 7901 additions and 1505 deletions
@@ -0,0 +1,67 @@
+//! Adaptive poll-rate event loop: polls faster for IDLE_THRESHOLD_MS
+//! after any activity, then slows down to conserve CPU.
+use std::collections::VecDeque;
+use std::time::{Duration, Instant};
+
+use crate::app::state::runtime::TurnEvent;
+
+const FAST_POLL_MS: u64 = 8;
+const SLOW_POLL_MS: u64 = 100;
+const IDLE_THRESHOLD_MS: u64 = 500;
+
+/// Tracks whether the app has been active vs idle to adjust the TUI poll
+/// rate, balancing responsiveness against CPU usage.
+pub struct EventLoop {
+    last_activity: Instant,
+    fast_poll_until: Option<Instant>,
+}
+
+impl EventLoop {
+    /// Create an `EventLoop` with the current instant as the last activity.
+    pub fn new() -> Self {
+        EventLoop {
+            last_activity: Instant::now(),
+            fast_poll_until: None,
+        }
+    }
+
+    /// Return the appropriate polling delay based on activity state.
+    ///
+    /// Flow: if `fast_poll_until` is set and the deadline hasn't expired,
+    /// return `FAST_POLL_MS`; otherwise return `SLOW_POLL_MS`.
+    pub fn poll_interval(&self) -> Duration {
+        if let Some(fast_until) = self.fast_poll_until {
+            if Instant::now() < fast_until {
+                return Duration::from_millis(FAST_POLL_MS);
+            }
+        }
+        Duration::from_millis(SLOW_POLL_MS)
+    }
+
+    /// Mark the current time as the last activity and arm the fast-poll
+    /// window for the next `IDLE_THRESHOLD_MS`.
+    pub fn mark_active(&mut self) {
+        self.last_activity = Instant::now();
+        self.fast_poll_until = Some(Instant::now() + Duration::from_millis(IDLE_THRESHOLD_MS));
+    }
+
+    /// Return `true` if the app has been idle for more than `IDLE_THRESHOLD_MS`.
+    pub fn is_idle(&self) -> bool {
+        self.last_activity.elapsed().as_millis() as u64 > IDLE_THRESHOLD_MS
+    }
+
+    /// Drain all pending `TurnEvent`s from the shared mutex queue.
+    ///
+    /// Return: a `Vec` of all events that were in the queue (may be empty).
+    pub fn drain_events(
+        events: &std::sync::Mutex<VecDeque<TurnEvent>>,
+    ) -> Vec<TurnEvent> {
+        events.lock().map(|mut q| q.drain(..).collect()).unwrap_or_default()
+    }
+}
+
+impl Default for EventLoop {
+    fn default() -> Self {
+        Self::new()
+    }
+}