wootype 0.1.0

Type System as a Service - Rust-powered Go type checker for AI Agents
Documentation 
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! gRPC API server
//! 
//! Serves TypeService over gRPC with high performance.

use super::service::TypeService;
use crate::core::SharedUniverse;
use crate::agent::AgentCoordinator;

use std::net::SocketAddr;
use std::sync::Arc;
use tokio::sync::mpsc;
use tonic::{transport::Server, Request, Response, Status};
use tracing::{info, error};

/// API server configuration
#[derive(Debug, Clone)]
pub struct ApiConfig {
    pub bind_address: SocketAddr,
    pub max_concurrent_streams: usize,
    pub enable_reflection: bool,
}

impl Default for ApiConfig {
    fn default() -> Self {
        Self {
            bind_address: "[::1]:50051".parse().unwrap(),
            max_concurrent_streams: 100,
            enable_reflection: true,
        }
    }
}

/// API server
pub struct ApiServer {
    config: ApiConfig,
    service: TypeService,
}

impl ApiServer {
    pub fn new(config: ApiConfig, universe: SharedUniverse) -> Self {
        let coordinator = Arc::new(AgentCoordinator::new(universe.clone()));
        let service = TypeService::new(universe, coordinator);
        
        Self {
            config,
            service,
        }
    }
    
    /// Start the API server
    pub async fn start(&self) -> Result<(), ApiError> {
        info!("Starting API server on {}", self.config.bind_address);
        
        // Would create actual gRPC service here
        // For now, just a placeholder
        info!("gRPC server placeholder - would start on {}", self.config.bind_address);
        
        Ok(())
    }
    
    /// Get server health
    pub async fn health_check(&self) -> HealthStatus {
        HealthStatus {
            healthy: true,
            active_sessions: 0, // Would get from coordinator
            uptime_seconds: 0,
        }
    }
}

/// Health status
#[derive(Debug, Clone)]
pub struct HealthStatus {
    pub healthy: bool,
    pub active_sessions: usize,
    pub uptime_seconds: u64,
}

/// API error
#[derive(Debug)]
pub enum ApiError {
    Transport(tonic::transport::Error),
    Bind(std::io::Error),
}

impl std::fmt::Display for ApiError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Transport(e) => write!(f, "Transport error: {}", e),
            Self::Bind(e) => write!(f, "Bind error: {}", e),
        }
    }
}

impl std::error::Error for ApiError {}

/// HTTP/REST fallback server
pub struct RestServer {
    bind_address: SocketAddr,
    service: TypeService,
}

impl RestServer {
    pub fn new(bind_address: SocketAddr, service: TypeService) -> Self {
        Self {
            bind_address,
            service,
        }
    }
    
    /// Start REST server
    pub async fn start(&self) -> Result<(), ApiError> {
        // Would implement REST endpoints using axum or similar
        info!("REST server would start on {}", self.bind_address);
        Ok(())
    }
}

/// WebSocket server for real-time streaming
pub struct WebSocketServer {
    bind_address: SocketAddr,
    service: TypeService,
}

impl WebSocketServer {
    pub fn new(bind_address: SocketAddr, service: TypeService) -> Self {
        Self {
            bind_address,
            service,
        }
    }
    
    /// Start WebSocket server for streaming validation
    pub async fn start(&self) -> Result<(), ApiError> {
        info!("WebSocket server would start on {}", self.bind_address);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::TypeUniverse;

    #[test]
    fn test_server_creation() {
        let universe = Arc::new(TypeUniverse::new());
        let config = ApiConfig::default();
        let server = ApiServer::new(config, universe);
        
        // Just verify it compiles
    }
}