kaish-kernel 0.8.0

Core kernel for kaish: lexer, parser, interpreter, and runtime
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

//! kaish-version — Print kaish version.

use async_trait::async_trait;
use clap::{CommandFactory, Parser};

use crate::interpreter::{ExecResult, OutputData};
use crate::tools::{schema_from_clap, ExecContext, ToolCtx, GlobalFlags, Tool, ToolArgs, ToolSchema};

/// kaish-version: prints the kaish version string.
pub struct KaishVersion;

/// clap-derived argv layer for kaish-version. See docs/clap-migration.md.
#[derive(Parser, Debug)]
#[command(name = "kaish-version", about = "Print kaish version")]
struct KaishVersionArgs {
    #[command(flatten)]
    global: GlobalFlags,

    /// Sink — to_argv() always emits `--` before positionals.
    #[arg(hide = true)]
    rest: Vec<String>,
}

#[async_trait]
impl Tool for KaishVersion {
    fn name(&self) -> &str {
        "kaish-version"
    }

    fn schema(&self) -> ToolSchema {
        schema_from_clap(
            &KaishVersionArgs::command(),
            "kaish-version",
            "Print kaish version",
            [("Show version", "kaish-version")],
        )
    }

    async fn execute(&self, args: ToolArgs, ctx: &mut dyn ToolCtx) -> ExecResult {
        let Some(ctx) = ctx.as_any_mut().downcast_mut::<ExecContext>() else {
            return ExecResult::failure(1, "internal error: kernel builtin requires ExecContext");
        };
        let parsed = match KaishVersionArgs::try_parse_from(
            std::iter::once("kaish-version".to_string()).chain(args.to_argv()),
        ) {
            Ok(p) => p,
            Err(e) => return ExecResult::failure(2, format!("kaish-version: {e}")),
        };
        parsed.global.apply(ctx);

        let version = env!("CARGO_PKG_VERSION");
        ExecResult::with_output(OutputData::text(format!("kaish {version}\n")))
    }
}