monothink 0.4.7

/*
* This file is part of monothink.
*
* monothink is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* monothink is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with Wavething.
* If not, see <https://www.gnu.org/licenses/>.

*/

use rig::tool::{Tool, ToolContext};
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::{path::PathBuf, sync::Arc};
use tokio::sync::Mutex;

use crate::llm::package_resolver::PackageResolver;

#[derive(Deserialize, Serialize)]
pub struct ListDirArgs {
    path: PathBuf,
    // recursive: Option<bool>,
    #[serde(default)]
    start: Option<usize>,
    #[serde(default)]
    root: Option<String>,
}

pub struct ListDir {
    package_resolver: Arc<Mutex<PackageResolver>>,
    max_results: Option<usize>,
    has_pacmans: bool, // stored here both for performance reasions and to avoid a blocking lock
}

// @todo check access rights (i.e. calculated path must be below base_dir)
impl ListDir {
    pub async fn new(resolver: Arc<Mutex<PackageResolver>>, max_results: Option<usize>) -> Self {
        let has_pacmans = !resolver.lock().await.list_pacmans().is_empty();
        Self {
            package_resolver: resolver,
            max_results,
            has_pacmans,
        }
    }
}
impl Tool for ListDir {
    const NAME: &'static str = "list_dir";

    type Error = super::ToolError;
    type Args = ListDirArgs;
    type Output = super::DirectoryListing;

    async fn call(
        &self,
        _context: &mut ToolContext,
        args: Self::Args,
    ) -> Result<Self::Output, Self::Error> {
        let package_resolver = self.package_resolver.lock().await;
        let base_dir = package_resolver.base_directory(args.root.as_deref())?;
        let path = super::allowed_canonical_path(&args.path, std::path::Path::new(&base_dir))?;
        let mut result = super::list_dir(&path, false)?;
        // @todo clip long lists but preserve total entries (add actual entries as info)
        // @todo this is brickle, because it also includes permission denied errors, we should log the error and go on
        result.total_entries = result.entries.len();
        if let Some(max_results) = self.max_results
            && result.entries.len() > max_results
        {
            result.entries.truncate(max_results);
            result.truncated = true;
        }

        Ok(result)
    }

    fn description(&self) -> String {
        if !self.has_pacmans {
            format!(
                "List the files and directories in the given directory (relative to given root), \
        returning {} entries. Use an empty string \"\" for the root. \
        Results include both files and subdirectories with their types.",
                match self.max_results {
                    Some(val) => format!("at most {}", val),
                    None => "all".to_string(),
                }
            )
        } else {
            format!(
                "List the files and directories in the given directory (relative to workspace root), \
        returning {} entries. Use an empty string \"\" for the workspace root. \
        Results include both files and subdirectories with their types.",
                match self.max_results {
                    Some(val) => format!("at most {}", val),
                    None => "all".to_string(),
                }
            )
        }
    }

    fn parameters(&self) -> serde_json::Value {
        let path_description = format!(
            "Path to the directory relative to {} root directory. \
                     Use an empty string for the root directory.",
            if self.has_pacmans {
                "the given"
            } else {
                "workspace"
            }
        );

        let mut params = json!({
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": path_description
                },
                // "start": {
                //     "type": "integer",
                //     "description": "Optional, zero-based index of the first result to return. \
                //     Use this to paginate through results if a previous call was truncated."
                // },
            },
            "required": ["path"]
        });

        if self.has_pacmans {
            // Add the "root" parameter to properties
            if let Some(props) = params["properties"].as_object_mut() {
                props.insert(
                    "root".to_string(),
                    json!({
                        "type": "string",
                        "description": "Optional package/dependency identifier to use as the root \
                         directory instead of the workspace root. \
                         If not provided, the workspace root is used."
                    }),
                );
            }
        }

        params
    }

    fn map_error(&self, error: Self::Error) -> rig::tool::ToolExecutionError {
        rig::tool::ToolExecutionError::from_error(error)
    }
}