tea-coding-tools 0.1.0

Workspace-scoped native coding tool adapters for tea-rs
Documentation
#![allow(dead_code)]

use std::fs;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};

use futures_util::StreamExt;
use serde_json::Value;
use tea_coding_tools::{
    EditTool, ReadTool, WorkspaceFileResourceResolver, WorkspaceRoot, WriteTool,
};
use tea_control::CancellationScope;
use tea_protocol::{ProtocolMetadata, ToolCallId};
use tea_tools::{
    ToolExecutionEvent, ToolInvocation, ToolName, ToolRegistry, ToolResourceAccess,
    ToolStreamValidator,
};

static NEXT_TEMP_ID: AtomicU64 = AtomicU64::new(0);

#[derive(Debug)]
pub struct TestDirectory {
    path: PathBuf,
}

impl TestDirectory {
    pub fn new() -> Self {
        let id = NEXT_TEMP_ID.fetch_add(1, Ordering::Relaxed);
        let path =
            std::env::temp_dir().join(format!("tea-coding-file-tools-{}-{id}", std::process::id()));
        let _ = fs::remove_dir_all(&path);
        fs::create_dir(&path).unwrap();
        Self { path }
    }

    pub fn path(&self) -> &Path {
        &self.path
    }

    pub fn workspace(&self) -> WorkspaceRoot {
        WorkspaceRoot::new(&self.path).unwrap()
    }
}

impl Drop for TestDirectory {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.path);
    }
}

pub fn read_registry(workspace: WorkspaceRoot) -> ToolRegistry {
    let mut registry = ToolRegistry::new();
    registry
        .register(
            ReadTool::spec().unwrap(),
            Arc::new(WorkspaceFileResourceResolver::new(ToolResourceAccess::Read)),
            Arc::new(ReadTool::new(workspace)),
        )
        .unwrap();
    registry
}

pub fn write_registry(workspace: WorkspaceRoot) -> ToolRegistry {
    let mut registry = ToolRegistry::new();
    registry
        .register(
            WriteTool::spec().unwrap(),
            Arc::new(WorkspaceFileResourceResolver::new(
                ToolResourceAccess::Write,
            )),
            Arc::new(WriteTool::new(workspace)),
        )
        .unwrap();
    registry
}

pub fn edit_registry(workspace: WorkspaceRoot) -> ToolRegistry {
    let mut registry = ToolRegistry::new();
    registry
        .register(
            EditTool::spec().unwrap(),
            Arc::new(WorkspaceFileResourceResolver::read_write()),
            Arc::new(EditTool::new(workspace)),
        )
        .unwrap();
    registry
}

pub fn invocation(name: &str, arguments: Value) -> ToolInvocation {
    ToolInvocation::new(
        ToolCallId::from_str("0195a0b1-5e45-75be-8284-0aa7aa000011").unwrap(),
        ToolName::from_str(name).unwrap(),
        arguments,
        ProtocolMetadata::default(),
    )
    .unwrap()
}

pub async fn execute(
    registry: &ToolRegistry,
    name: &str,
    arguments: Value,
) -> Vec<ToolExecutionEvent> {
    let events = registry
        .execute(invocation(name, arguments), CancellationScope::new())
        .unwrap()
        .collect::<Vec<_>>()
        .await;
    let mut validator = ToolStreamValidator::new();
    for event in &events {
        validator.observe(event).unwrap();
    }
    assert_eq!(validator.finish().unwrap(), events.len());
    events
}

pub fn finished(events: &[ToolExecutionEvent]) -> &tea_tools::ToolResult {
    assert_eq!(events.len(), 1, "unexpected events: {events:?}");
    match &events[0] {
        ToolExecutionEvent::Finished(result) => result,
        event => panic!("expected successful result, got {event:?}"),
    }
}

pub fn failed(events: &[ToolExecutionEvent]) -> &tea_tools::ToolExecutionFailure {
    assert_eq!(events.len(), 1, "unexpected events: {events:?}");
    match &events[0] {
        ToolExecutionEvent::Failed(failure) => failure,
        event => panic!("expected failure, got {event:?}"),
    }
}