Struct Kernel 

pub struct Kernel { /* private fields */ }

The Kernel (核) — executes kaish code.

This is the primary interface for running kaish commands. It owns all the runtime state: variables, tools, VFS, jobs, and persistence.

Implementations

impl Kernel

pub fn new(config: KernelConfig) -> Result<Self>

Create a new kernel with the given configuration.

pub fn transient() -> Result<Self>

Create a transient kernel (no persistence).

pub fn with_backend( backend: Arc<dyn KernelBackend>, config: KernelConfig, ) -> Result<Self>

Create a kernel with a custom backend.

This constructor allows embedding kaish in other systems that provide their own storage backend (e.g., CRDT-backed storage in kaijutsu). The provided backend will be used for all file operations in builtins.

Note: A VfsRouter is still created internally for compatibility with the vfs() method, but it won’t be used for execution context operations.

pub fn with_backend_and_virtual_paths( backend: Arc<dyn KernelBackend>, config: KernelConfig, ) -> Result<Self>

Create a kernel with a custom backend and automatic /v/* path support.

This is the recommended constructor for embedders who want their custom backend to also support kaish’s virtual filesystems (like /v/jobs for job observability).

Paths are routed as follows:

• /v/* → Internal VFS (JobFs at /v/jobs, MemoryFs at /v/blobs, etc.)
• Everything else → Your custom backend

Example

let my_backend: Arc<dyn KernelBackend> = Arc::new(MyBackend::new());
let kernel = Kernel::with_backend_and_virtual_paths(my_backend, config)?;

// Now agents can use /v/jobs to monitor background commands
kernel.execute("cargo build &").await?;
kernel.execute("cat /v/jobs/1/stdout").await?;

pub fn name(&self) -> &str

Get the kernel name.

pub async fn execute(&self, input: &str) -> Result<ExecResult>

Execute kaish source code.

Returns the result of the last statement executed.

pub async fn execute_streaming( &self, input: &str, on_output: &mut dyn FnMut(&ExecResult), ) -> Result<ExecResult>

Execute kaish source code with a per-statement callback.

Each statement’s result is passed to on_output as it completes, allowing callers to flush output incrementally (e.g., print builtin output immediately rather than buffering until the script finishes).

External commands in interactive mode already stream to the terminal via Stdio::inherit(), so the callback mainly handles builtins.

pub async fn get_var(&self, name: &str) -> Option<Value>

Get a variable value.

pub async fn set_var(&self, name: &str, value: Value)

Set a variable value.

pub async fn list_vars(&self) -> Vec<(String, Value)>

List all variables.

pub async fn cwd(&self) -> PathBuf

Get current working directory.

pub async fn set_cwd(&self, path: PathBuf)

Set current working directory.

pub async fn last_result(&self) -> ExecResult

Get the last result ($?).

pub fn tool_schemas(&self) -> Vec<ToolSchema>

Get available tool schemas.

pub fn jobs(&self) -> Arc<JobManager>

Get job manager.

pub fn vfs(&self) -> Arc<VfsRouter>

Get VFS router.

pub async fn reset(&self) -> Result<()>

Reset kernel to initial state.

Clears in-memory variables and resets cwd to root. History is not cleared (it persists across resets).

pub async fn shutdown(self) -> Result<()>

Shutdown the kernel.