npcrs 0.1.11

Rust core for the NPC system — agent kernel, jinx executor, LLM client
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

use crate::drivers::DriverManager;
use crate::error::Result;
use crate::ipc::IpcBus;
use crate::kernel::Kernel;
use crate::memory::CommandHistory;
use crate::npc_compiler;
use crate::process::Capabilities;
use crate::scheduler::Scheduler;
use crate::vfs::Vfs;
use std::collections::HashMap;
use std::sync::atomic::AtomicU32;

pub fn boot_kernel(team_dir: &str, db_path: &str) -> Result<Kernel> {
    tracing::info!("kernel: booting from {}", team_dir);

    let team = npc_compiler::load_team_from_directory(team_dir)?;
    let jinxes = team.jinxes.clone();

    tracing::info!(
        "kernel: loaded {} NPCs, {} jinxes",
        team.npcs.len(),
        jinxes.len()
    );

    let drivers = DriverManager::from_env();

    let db_path_expanded = shellexpand::tilde(db_path).to_string();
    let history = CommandHistory::open(&db_path_expanded)?;

    let vfs = Vfs::new(team_dir);

    let mut kernel = Kernel {
        processes: HashMap::new(),
        next_pid: AtomicU32::new(0),
        team,
        jinxes,
        drivers,
        vfs,
        ipc: IpcBus::new(),
        scheduler: Scheduler::new(),
        history,
        python_daemon: None,
        boot_time: chrono::Utc::now(),
    };

    let team_box = Box::new(kernel.team.clone());

    let mut init_npc = kernel.team.lead_npc().cloned().unwrap_or_else(|| {
        crate::npc_compiler::NPC::new("init", "You are the init process. Coordinate the system.")
    });
    init_npc.team = Some(team_box.clone());

    kernel.spawn_init(init_npc);
    tracing::info!("kernel: init process spawned (pid 0)");

    let other_npcs: Vec<_> = kernel
        .team
        .npcs
        .values()
        .filter(|n| Some(&n.name) != kernel.team.forenpc.as_ref())
        .cloned()
        .collect();

    for mut npc in other_npcs {
        npc.team = Some(team_box.clone());
        let name = npc.name.clone();
        let pid = kernel.spawn(npc, 0, Capabilities::root());
        tracing::info!("kernel: spawned daemon {} (pid {})", name, pid);
    }

    tracing::info!("kernel: boot complete");
    Ok(kernel)
}