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, configure_vfs: impl FnOnce(&mut VfsRouter), ) -> Result<Self>

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

This is the constructor for embedding kaish in other systems that provide their own storage backend (e.g., CRDT-backed storage in kaijutsu).

A VirtualOverlayBackend routes paths automatically:

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

The optional configure_vfs closure lets you add additional virtual mounts (e.g., /v/docs for CRDT blocks) after the built-in mounts are set up.

Note: The config’s vfs_mode is ignored — all non-/v/* path routing is handled by your custom backend. The config is only used for name, cwd, skip_validation, and interactive.

Example

// Simple: default /v/* mounts only
let kernel = Kernel::with_backend(backend, config, |_| {})?;

// With custom mounts
let kernel = Kernel::with_backend(backend, config, |vfs| {
    vfs.mount_arc("/v/docs", docs_fs);
    vfs.mount_arc("/v/g", git_fs);
})?;

pub fn name(&self) -> &str

Get the kernel name.

pub fn init_terminal(&mut self)

Initialize terminal state for interactive job control.

Call this after kernel creation when running as an interactive REPL and stdin is a TTY. Sets up process groups and signal handling.

pub fn cancel(&self)

Cancel the current execution.

This cancels the current cancellation token, causing any execution loop to exit at the next checkpoint with exit code 130 (SIGINT). A fresh token is installed for the next execute() call.

pub fn is_cancelled(&self) -> bool

Check if the current execution has been cancelled.

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 set_positional( &self, script_name: impl Into<String>, args: Vec<String>, )

Set positional parameters ($0 script name and $1-$9 args).

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 async fn has_function(&self, name: &str) -> bool

Check if a user-defined function exists.

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.

Trait Implementations

impl CommandDispatcher for Kernel

fn dispatch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, cmd: &'life1 Command, ctx: &'life2 mut ExecContext, ) -> Pin<Box<dyn Future<Output = Result<ExecResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Dispatch a command through the Kernel’s full resolution chain.

This is the single path for all command execution when called from the pipeline runner. It provides the full dispatch chain: user tools → builtins → .kai scripts → external commands → backend tools.