Method handle_add

crates/chat-cli/src/cli/chat/cli/knowledge.rs:256–312

(
        os: &Os,
        session: &mut ChatSession,
        name: &str,
        path: &str,
        include_patterns: &[String],
        exclude_patterns: &[String],
        index_type: &Option<Stri

    }

    async fn handle_add(
        os: &Os,
        session: &mut ChatSession,
        name: &str,
        path: &str,
        include_patterns: &[String],
        exclude_patterns: &[String],
        index_type: &Option<String>,
    ) -> OperationResult {
        match Self::validate_and_sanitize_path(os, path) {
            Ok(sanitized_path) => {
                let agent = Self::get_agent(session);

                let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
                    Ok(store) => store,
                    Err(e) => return OperationResult::Error(format!("Error accessing knowledge base: {}", e)),
                };
                let mut store = async_knowledge_store.lock().await;

                let include = if include_patterns.is_empty() {
                    Self::get_db_patterns(os, crate::database::settings::Setting::KnowledgeDefaultIncludePatterns)
                } else {
                    include_patterns.to_vec()
                };

                let exclude = if exclude_patterns.is_empty() {
                    Self::get_db_patterns(os, crate::database::settings::Setting::KnowledgeDefaultExcludePatterns)
                } else {
                    exclude_patterns.to_vec()
                };

                let embedding_type_resolved = index_type.clone().or_else(|| {
                    os.database
                        .settings
                        .get(crate::database::settings::Setting::KnowledgeIndexType)
                        .and_then(|v| v.as_str().map(|s| s.to_string()))
                });

                let options = crate::util::knowledge_store::AddOptions::new()
                    .with_include_patterns(include)
                    .with_exclude_patterns(exclude)
                    .with_embedding_type(embedding_type_resolved);

                match store.add(name, &sanitized_path.clone(), options).await {
                    Ok(message) => OperationResult::Info(message),
                    Err(e) => {
                        if e.contains("Invalid include pattern") || e.contains("Invalid exclude pattern") {
                            OperationResult::Error(e)
                        } else {
                            OperationResult::Error(format!("Failed to add: {}", e))
                        }
                    },
                }
            },
            Err(e) => OperationResult::Error(format!("Invalid path: {}", e)),
        }
    }