a3s 0.10.1

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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

use std::sync::Arc;

use a3s_boot::{
    ControllerDefinition, Module, ModuleRef, ProviderDefinition, ProviderToken,
    Result as BootResult,
};

use super::agents_controller::KernelAgentsController;
use super::chat_controller::KernelChatController;
use super::compaction_controller::KernelCompactionController;
use super::controls_controller::KernelControlsController;
use super::fork_controller::KernelForkController;
use super::output_controller::KernelOutputController;
use super::service::{KernelService, ManagedSessionReadPort};
use super::sessions_controller::KernelSessionsController;
use super::shell_controller::KernelShellController;
use super::sleep_controller::KernelSleepController;
use super::turn_queue_controller::KernelTurnQueueController;
use crate::api::code_web::state::CodeWebState;

pub(in crate::api::code_web) struct KernelModule;

impl Module for KernelModule {
    fn name(&self) -> &'static str {
        "a3s-code-web-kernel"
    }

    fn providers(&self) -> BootResult<Vec<ProviderDefinition>> {
        Ok(vec![
            ProviderDefinition::factory_arc::<KernelService, _>(|module_ref| {
                let state = module_ref.get::<CodeWebState>()?;
                Ok(Arc::new(KernelService::new(state)))
            }),
            ProviderDefinition::factory_arc::<ManagedSessionReadPort, _>(|module_ref| {
                let service = module_ref.get::<KernelService>()?;
                Ok(Arc::new(ManagedSessionReadPort::new(service)))
            }),
        ])
    }

    fn controllers(&self, module_ref: &ModuleRef) -> BootResult<Vec<ControllerDefinition>> {
        let service = module_ref.get::<KernelService>()?;
        Ok(vec![
            Arc::new(KernelAgentsController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelSessionsController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelControlsController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelCompactionController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelSleepController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelTurnQueueController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelForkController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelOutputController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelShellController::new(Arc::clone(&service))).controller()?,
            Arc::new(KernelChatController::new(service)).controller()?,
        ])
    }

    fn exports(&self) -> BootResult<Vec<ProviderToken>> {
        Ok(vec![ProviderToken::of::<ManagedSessionReadPort>()])
    }
}