ayda 1.1.1

Ask your Documents Anything. A tool for querying your documents with a large language model.
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! aza
//!
//!
//!
use std::path::PathBuf;

use ayda::anythingllm::ChatMode;
use clap::Parser;
use color_eyre::owo_colors::OwoColorize;
use eyre::Context;
use tokio::select;
use tracing::Level;
use tracing_subscriber::{EnvFilter, FmtSubscriber};

use ayda::app::{commands::admin, commands::workspace, commands::zotero, Commands::*};
use ayda::app::{Cli, SourceType, ZoteroCmd};

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let (non_blocking_stdio, _guard) = tracing_appender::non_blocking(std::io::stdout());

    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::ERROR)
        // .with_env_filter(EnvFilter::new("app::commands::zotero::enhance=error"))
        .with_writer(non_blocking_stdio)
        .compact()
        .finish();

    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");

    let config_path = ayda::Config::check_config()?;
    color_eyre::install()?;

    let cli = Cli::parse();

    select! {
        _ = command(config_path, cli) => {},
        _ = tokio::signal::ctrl_c() => {
            tracing::info!("detected interrupt, exiting");
        },
    }

    Ok(())
}

#[tracing::instrument(skip(config_path, cli))]
async fn command(config_path: PathBuf, cli: Cli) -> eyre::Result<()> {
    match cli.command {
        Create { workspace_name } => workspace::create::create(workspace_name)
            .await
            .wrap_err("unable to create workspace"),

        List {} => workspace::list().await.wrap_err("unable to list workspace"),

        Delete {
            workspace_name: Some(name),
            all: false,
        } => {
            // Delete a specific workspace
            match workspace::delete(name).await {
                Ok(_) => Ok(()),
                Err(e) => {
                    println!("{}", e.to_string().red());
                    Err(e)
                }
            }
        }

        Delete {
            workspace_name: None,
            all: true,
        } => {
            // Delete all workspaces
            match workspace::delete_all().await {
                Ok(_) => Ok(()),
                Err(e) => {
                    println!("{}", e.to_string().red());
                    Err(e)
                }
            }
        }

        Import {
            source,
            source_name,
        } => match source {
            SourceType::Zotero {} => workspace::import_zotero(source_name)
                .await
                .wrap_err("unable to import zotero collection"),
            SourceType::Folder {} => workspace::import_folder(PathBuf::from(source_name))
                .await
                .wrap_err("unable to import file"),
            SourceType::Item {} => workspace::import_item()
                .await
                .wrap_err("unable to import item"),
        },

        Chat { workspace_name } => workspace::chat(workspace_name, ChatMode::Chat)
            .await
            .wrap_err("unable to chat with workspace"),

        Query { workspace_name } => workspace::chat(workspace_name, ChatMode::Query)
            .await
            .wrap_err("unable to query workspace"),

        Zotero {
            command: ZoteroCmd::ListCollections,
        } => zotero::list_collections().await.wrap_err("unable to list Zotero collections"),

        Zotero {
            command: ZoteroCmd::Enhance { collection_name },
        } => zotero::enhance_collection(collection_name)
            .await
            .wrap_err("unable to enhance collection"),

        Config {} => admin::configure(&config_path)
            .wrap_err("unable to configure application"),

        _ => {
            println!(
                "Invalid combination of arguments. Please consult the documentation for available commands"
            );
            Ok(())
        }
    }
    .wrap_err("couldn't execute command")
}