wsb 0.164.718

Workspace - A tool suite for file operations, version management, and development workflow automation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::prelude::*;
use tokio::sync::broadcast;

use crate::logging::{LogLine, LogRingBuffer};
use crate::persist::global::{DatabaseConfig, DatabaseService, WsbRepos};

#[derive(Clone)]
pub struct AppContext {
    pub db: Arc<WsbRepos>,
    pub db_service: Arc<DatabaseService>,
    pub workspace_root: PathBuf,
}

impl AppContext {
    pub fn bootstrap(workspace_root: &Path) -> Result<Self> {
        let db_path = workspace_root.join(".wsb").join("wsb.db");
        let config = DatabaseConfig::new(&db_path);
        let service = DatabaseService::new(&config)?;
        let service = Arc::new(service);
        let repos = Arc::new(WsbRepos::new(&service));
        Ok(Self {
            db: repos,
            db_service: service,
            workspace_root: workspace_root.to_path_buf(),
        })
    }
}

#[derive(Clone)]
pub struct AppState {
    pub ctx: AppContext,
    pub debug: bool,
    pub port: u16,
    pub log_tx: broadcast::Sender<LogLine>,
    pub log_ring: LogRingBuffer,
}

impl AppState {
    pub fn new(
        ctx: AppContext,
        debug: bool,
        port: u16,
        log_tx: broadcast::Sender<LogLine>,
        log_ring: LogRingBuffer,
    ) -> Self {
        Self {
            ctx,
            debug,
            port,
            log_tx,
            log_ring,
        }
    }
}

#[derive(Clone, Debug, serde::Serialize)]
pub struct SyncProgress {
    pub phase: SyncPhase,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub current_project: Option<String>,
    pub sessions_total: usize,
    pub sessions_done: usize,
    pub messages_indexed: usize,
}

#[derive(Clone, Debug, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SyncPhase {
    Idle,
    Discovering,
    Syncing,
    Done,
}