server: mcp + global: refactor

crates/brk_query/src/lib.rs

@@ -1,178 +0,0 @@
-#![doc = include_str!("../README.md")]
-#![doc = "\n## Example\n\n```rust"]
-#![doc = include_str!("../examples/main.rs")]
-#![doc = "```"]
-
-use brk_computer::Computer;
-use brk_core::Result;
-use brk_indexer::Indexer;
-use brk_vec::AnyCollectableVec;
-use tabled::settings::Style;
-
-mod format;
-mod index;
-mod output;
-mod params;
-mod table;
-mod vec_trees;
-
-pub use format::Format;
-pub use index::Index;
-pub use output::{Output, Value};
-pub use params::{Params, ParamsOpt};
-pub use table::Tabled;
-use vec_trees::VecTrees;
-
-pub struct Query<'a> {
-    pub vec_trees: VecTrees<'a>,
-    _indexer: &'a Indexer,
-    _computer: &'a Computer,
-}
-
-impl<'a> Query<'a> {
-    pub fn build(indexer: &'a Indexer, computer: &'a Computer) -> Self {
-        let mut vec_trees = VecTrees::default();
-
-        indexer
-            .vecs()
-            .vecs()
-            .into_iter()
-            .for_each(|vec| vec_trees.insert(vec));
-
-        computer
-            .vecs()
-            .into_iter()
-            .for_each(|vec| vec_trees.insert(vec));
-
-        Self {
-            vec_trees,
-            _indexer: indexer,
-            _computer: computer,
-        }
-    }
-
-    pub fn search(&self, index: Index, ids: &[&str]) -> Vec<(String, &&dyn AnyCollectableVec)> {
-        let tuples = ids
-            .iter()
-            .flat_map(|s| {
-                s.to_lowercase()
-                    .replace("_", "-")
-                    .split_whitespace()
-                    .flat_map(|s| {
-                        s.split(',')
-                            .flat_map(|s| s.split('+').map(|s| s.to_string()))
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .map(|mut id| {
-                let mut res = self.vec_trees.id_to_index_to_vec.get(&id);
-                if res.is_none() {
-                    if let Ok(index) = Index::try_from(id.as_str()) {
-                        id = index.possible_values().last().unwrap().to_string();
-                        res = self.vec_trees.id_to_index_to_vec.get(&id)
-                    }
-                }
-                (id, res)
-            })
-            .filter(|(_, opt)| opt.is_some())
-            .map(|(id, vec)| (id, vec.unwrap()))
-            .collect::<Vec<_>>();
-
-        tuples
-            .iter()
-            .flat_map(|(str, i_to_v)| i_to_v.get(&index).map(|vec| (str.to_owned(), vec)))
-            .collect::<Vec<_>>()
-    }
-
-    pub fn format(
-        &self,
-        vecs: Vec<(String, &&dyn AnyCollectableVec)>,
-        from: Option<i64>,
-        to: Option<i64>,
-        format: Option<Format>,
-    ) -> color_eyre::Result<Output> {
-        let mut values = vecs
-            .iter()
-            .map(|(_, vec)| -> Result<Vec<serde_json::Value>> {
-                vec.collect_range_serde_json(from, to)
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        if values.is_empty() {
-            return Ok(Output::default(format));
-        }
-
-        let ids_last_i = vecs.len() - 1;
-
-        Ok(match format {
-            Some(Format::CSV) | Some(Format::TSV) => {
-                let delimiter = if format == Some(Format::CSV) {
-                    ','
-                } else {
-                    '\t'
-                };
-
-                let mut text = vecs
-                    .iter()
-                    .map(|(id, _)| id.to_owned())
-                    .collect::<Vec<_>>()
-                    .join(&delimiter.to_string());
-
-                text.push('\n');
-
-                let values_len = values.first().unwrap().len();
-
-                (0..values_len).for_each(|i| {
-                    let mut line = "".to_string();
-                    values.iter().enumerate().for_each(|(id_i, v)| {
-                        line += &v.get(i).unwrap().to_string();
-                        if id_i == ids_last_i {
-                            line.push('\n');
-                        } else {
-                            line.push(delimiter);
-                        }
-                    });
-                    text += &line;
-                });
-
-                if format == Some(Format::CSV) {
-                    Output::CSV(text)
-                } else {
-                    Output::TSV(text)
-                }
-            }
-            Some(Format::MD) => {
-                let mut table =
-                    values.to_table(vecs.iter().map(|(s, _)| s.to_owned()).collect::<Vec<_>>());
-
-                table.with(Style::markdown());
-
-                Output::MD(table.to_string())
-            }
-            Some(Format::JSON) | None => {
-                if values.len() == 1 {
-                    let mut values = values.pop().unwrap();
-                    if values.len() == 1 {
-                        let value = values.pop().unwrap();
-                        Output::Json(Value::Single(value))
-                    } else {
-                        Output::Json(Value::List(values))
-                    }
-                } else {
-                    Output::Json(Value::Matrix(values))
-                }
-            }
-        })
-    }
-
-    pub fn search_and_format(
-        &self,
-        index: Index,
-        ids: &[&str],
-        from: Option<i64>,
-        to: Option<i64>,
-        format: Option<Format>,
-    ) -> color_eyre::Result<Output> {
-        self.format(self.search(index, ids), from, to, format)
-    }
-}