Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

plugins/coding-tools/src/lib.rs

Raw
//! Built-in coding tools through `smith:plugin` (`SMH-SPEC-PLUG0001`).
#![expect(missing_docs, reason = "wit-bindgen generates the world surface")]
#![expect(clippy::pedantic, reason = "wit-bindgen generates the world surface")]

wit_bindgen::generate!({
    path: "../../wit/smith-plugin.wit",
    world: "plugin-world",
});

use exports::smith::plugin::plugin::{Guest, ToolDeclaration};
use exports::smith::plugin::provider::{
    CatalogSnapshot, DecodeStep, Guest as ProviderGuest, ProviderRequest, ProviderSettings,
    RequestTemplate, SettingsProvenance,
};
use exports::smith::plugin::registration::{Guest as RegistrationGuest, Registrations};
use serde::Deserialize;
use smith::plugin::tooling::{self, DirectoryQuery, FileEdit, FileRead, FileWrite};

struct CodingTools;

impl RegistrationGuest for CodingTools {
    fn declare() -> Registrations {
        Registrations {
            credential_sources: Vec::new(),
            providers: Vec::new(),
            models: Vec::new(),
        }
    }
}

#[derive(Deserialize)]
struct ToolMetadata {
    name: String,
    description: String,
    input_schema_json: String,
}

fn tool_metadata() -> Vec<ToolMetadata> {
    serde_json::from_str(include_str!("../metadata.json")).unwrap_or_else(|_| Vec::new())
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ReadInput {
    path: String,
    #[serde(default)]
    offset: u64,
    #[serde(default = "read_limit")]
    limit: u64,
    #[serde(default = "read_max_bytes")]
    max_bytes: u64,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ListInput {
    #[serde(default)]
    path: String,
}

const fn read_limit() -> u64 {
    u64::MAX
}

const fn read_max_bytes() -> u64 {
    64 * 1024
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct WriteInput {
    path: String,
    content: String,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct EditInput {
    path: String,
    old_string: String,
    new_string: String,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct QueryInput {
    #[serde(default)]
    path: String,
    #[serde(default)]
    pattern: String,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct GrepInput {
    path: String,
    query: String,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct BashInput {
    command: String,
    #[serde(default = "bash_timeout_ms")]
    timeout_ms: u64,
}

const fn bash_timeout_ms() -> u64 {
    30_000
}

impl ProviderGuest for CodingTools {
    fn declare_settings() -> ProviderSettings {
        ProviderSettings {
            include_usage: false,
            subscription: false,
            provenance: SettingsProvenance::BuiltIn,
        }
    }
    fn validate_settings(_settings: ProviderSettings) -> Result<ProviderSettings, String> {
        Err("coding tools do not provide protocol settings".to_string())
    }
    fn build_request(
        _model: String,
        _request: ProviderRequest,
        _settings: ProviderSettings,
        _catalog: CatalogSnapshot,
    ) -> Result<RequestTemplate, String> {
        Err("coding tools do not provide a model codec".to_string())
    }
    fn decode_response(
        _state: Vec<u8>,
        _chunk: Vec<u8>,
        _finished: bool,
    ) -> Result<DecodeStep, String> {
        Err("coding tools do not provide a model decoder".to_string())
    }
}

impl Guest for CodingTools {
    fn declare_tools() -> Vec<ToolDeclaration> {
        tool_metadata()
            .into_iter()
            .map(|tool| ToolDeclaration {
                name: tool.name,
                description: tool.description,
                input_schema_json: tool.input_schema_json,
            })
            .collect()
    }

    fn invoke(name: String, input_json: String) -> Result<String, String> {
        match name.as_str() {
            "read" => {
                let input: ReadInput = parse(&input_json)?;
                tooling::read(&FileRead {
                    path: input.path,
                    offset: input.offset,
                    limit: input.limit,
                    max_bytes: input.max_bytes,
                })
                .map(|content| content.text)
            }
            "write" => {
                let input: WriteInput = parse(&input_json)?;
                tooling::write(&FileWrite {
                    path: input.path,
                    content: input.content,
                })
                .map(|()| "written".to_string())
            }
            "edit" => {
                let input: EditInput = parse(&input_json)?;
                tooling::edit(&FileEdit {
                    path: input.path,
                    old_text: input.old_string,
                    new_text: input.new_string,
                })
                .map(|()| "edited".to_string())
            }
            "ls" => {
                let input: ListInput = parse(&input_json)?;
                tooling::list_directory(&DirectoryQuery {
                    path: input.path,
                    pattern: None,
                })
                .map(|items| items.join("\n"))
            }
            "find" => {
                let input: QueryInput = parse(&input_json)?;
                tooling::find(&DirectoryQuery {
                    path: input.path,
                    pattern: Some(input.pattern),
                })
                .map(|items| items.join("\n"))
            }
            "grep" => {
                let input: GrepInput = parse(&input_json)?;
                tooling::grep(&DirectoryQuery {
                    path: input.path,
                    pattern: Some(input.query),
                })
                .map(|items| items.join("\n"))
            }
            "bash" => {
                let input: BashInput = parse(&input_json)?;
                tooling::run_command(&tooling::CommandRequest {
                    text: input.command,
                    timeout_ms: input.timeout_ms,
                })
            }
            _ => Err(format!("unknown tool: {name}")),
        }
    }
}

fn parse<Input: serde::de::DeserializeOwned>(input: &str) -> Result<Input, String> {
    serde_json::from_str(input).map_err(|error| format!("invalid tool input: {error}"))
}

export!(CodingTools);