Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

13.6 KB
Raw Blame
use chrono::{DateTime, Utc};
use uuid::Uuid;

use crate::calendar_event::CalendarEventSearchScope;
use crate::call_record::CallRecordSearchResponseItemWithMetadata;
use crate::channel::{ChannelMessageSearchResponseItem, ChannelNameSearchResponseItem};
use crate::chat::ChatSearchResponseItemWithMetadata;
use crate::document::DocumentSearchResponseItemWithMetadata;
use crate::email::EmailSearchResponseItemWithMetadata;
use crate::project::ProjectSearchResponseItemWithMetadata;
use crate::{
    MatchType, SearchOn, call_record::SimpleCallRecordSearchResponseBaseItem,
    channel::SimpleChannelSearchReponseBaseItem, chat::SimpleChatSearchResponseBaseItem,
    document::SimpleDocumentSearchResponseBaseItem, email::SimpleEmailSearchResponseBaseItem,
    project::SimpleProjectSearchResponseBaseItem,
};
use item_filters::{
    CalendarEventFilters, CallFilters, ChannelFilters, ChatFilters, DocumentFilters, EmailFilters,
    EntityFilters, ProjectFilters, ast::document::resolve_file_types,
};
use model_file_type::{FileAssociation, FileType};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;

#[derive(Debug, Serialize, Deserialize, Clone, ToSchema, JsonSchema, Eq, PartialEq, Hash)]
#[serde(rename_all = "lowercase")]
pub enum UnifiedSearchIndex {
    #[serde(rename = "agent_sessions")]
    AgentSessions,
    Documents,
    Chats,
    Emails,
    Channels,
    Projects,
    #[serde(rename = "call_records")]
    CallRecords,
    #[serde(rename = "calendar_events")]
    CalendarEvents,
}

const NIL_UUID: &str = "00000000-0000-0000-0000-000000000000";

/// Build an [EntityFilters] from a list of [UnifiedSearchIndex] to include.
/// Entity types not in the list are excluded via NIL UUID.
/// If the list is empty, all entity types are included.
pub fn entity_filters_from_include(
    include: Vec<UnifiedSearchIndex>,
    base: EntityFilters,
) -> EntityFilters {
    let mut filters = base;
    if include.is_empty() {
        filters.agent_session_filters.include = true;
        return filters;
    }

    let exclude = vec![NIL_UUID.to_string()];
    if include.contains(&UnifiedSearchIndex::AgentSessions) {
        filters.agent_session_filters.include = true;
    } else {
        filters.agent_session_filters.ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::Documents) {
        filters.document_filters.document_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::Chats) {
        filters.chat_filters.chat_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::Emails) {
        filters.email_filters.email_thread_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::Channels) {
        filters.channel_filters.channel_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::Projects) {
        filters.project_filters.project_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::CallRecords) {
        filters.call_filters.channel_ids = exclude.clone();
    }
    if !include.contains(&UnifiedSearchIndex::CalendarEvents) {
        filters.calendar_event_filters.calendar_event_ids = exclude;
    }
    filters
}

// TODO: query, match_type are common to all requests. consolidate.
#[derive(Debug, Serialize, Deserialize, ToSchema, Clone, JsonSchema)]
pub struct UnifiedSearchRequest {
    /// The search query string. Must be at least 3 characters.
    pub query: String,

    /// How to match the search terms. 'exact' for precise case-sensitive phrase matches, 'partial' for prefix/partial matches. REQUIRED field.
    pub match_type: MatchType,

    /// Entity filters in the same shape as soup. Entity types with a NIL UUID in their primary ID field are excluded from search.
    #[serde(default)]
    pub filters: EntityFilters,

    /// Fields to search on (Name, Content, NameContent). Defaults to Content
    #[serde(default)]
    pub search_on: SearchOn,

    /// Opt in to searching the caller's team CRM companies (name/domain).
    /// Off by default: CRM results are only included when this is true and
    /// the caller has a qualifying team membership. CRM has no content
    /// index, so it is searched only under Name / NameContent.
    #[serde(default)]
    pub include_crm: bool,

    /// Which calendar events to search. Defaults to `own`: events on the
    /// caller's own and delegated calendars. `shared_with_you` searches only
    /// events shared with a channel the caller belongs to that are on none of
    /// their calendars.
    #[serde(default)]
    pub calendar_event_scope: CalendarEventSearchScope,

    #[schemars(skip)]
    pub collapse: Option<bool>,
}

/// Whether a [FileAssociation] is indexed by the search processing service.
pub fn is_searchable_association(assoc: &FileAssociation) -> bool {
    matches!(
        assoc,
        FileAssociation::Pdf(_)
            | FileAssociation::Write(_)
            | FileAssociation::Code(_)
            | FileAssociation::Canvas(_)
            | FileAssociation::Md(_)
    )
}

/// Whether documents of a file type have their content indexed by the search
/// processing service: the searchable associations, and the design files the
/// native engines read - Figma designs, Photoshop documents, and Illustrator
/// documents - while other vector files are not.
pub fn is_searchable_file_type(file_type: &FileType) -> bool {
    matches!(
        file_type,
        FileType::Fig | FileType::Psd | FileType::Psb | FileType::Ai
    ) || is_searchable_association(&file_type.macro_app_path())
}

/// Converted entity filters for the search service.
/// Determines which entity types to include based on NIL UUID exclusion
/// and expands file association prefixes (e.g. `assoc:code`) to concrete extensions.
#[derive(Debug, Clone)]
pub struct SearchEntityFilters {
    /// Whether to include folded agent sessions.
    pub should_include_agent_sessions: bool,
    /// Agent-session filters.
    pub agent_session_filters: item_filters::AgentSessionFilters,
    /// Whether to include documents in search results
    pub should_include_documents: bool,
    /// Whether to include chats in search results
    pub should_include_chats: bool,
    /// Whether to include emails in search results
    pub should_include_emails: bool,
    /// Whether to include channels in search results
    pub should_include_channels: bool,
    /// Whether to include projects in search results
    pub should_include_projects: bool,
    /// Whether to include call records in search results
    pub should_include_call_records: bool,
    /// Whether to include calendar events in search results
    pub should_include_calendar_events: bool,
    /// Document filters with file associations expanded
    pub document_filters: DocumentFilters,
    /// Chat filters
    pub chat_filters: ChatFilters,
    /// Email filters
    pub email_filters: EmailFilters,
    /// Channel filters
    pub channel_filters: ChannelFilters,
    /// Project filters
    pub project_filters: ProjectFilters,
    /// Call filters
    pub call_filters: CallFilters,
    /// Calendar event filters
    pub calendar_event_filters: CalendarEventFilters,
}

fn contains_nil_uuid(ids: &[String]) -> bool {
    ids.iter().any(|id| id == NIL_UUID)
}

fn strip_nil_uuids(ids: &mut Vec<String>) {
    ids.retain(|id| id != NIL_UUID);
}

/// Resolve file type strings to concrete extensions for search, dropping
/// non-searchable types. Handles both plain extensions (`"md"`) and `assoc:*`
/// prefixes (`"assoc:code"`).
fn expand_file_types_for_search(file_types: Vec<String>) -> Vec<String> {
    file_types
        .iter()
        .flat_map(|ft| resolve_file_types(ft))
        .filter(is_searchable_file_type)
        .map(|ty| ty.as_str().to_string())
        .collect()
}

impl From<EntityFilters> for SearchEntityFilters {
    fn from(filters: EntityFilters) -> Self {
        let mut agent_session_filters = filters.agent_session_filters;
        let should_include_agent_sessions = (agent_session_filters.include
            || !agent_session_filters.ids.is_empty()
            || !agent_session_filters.owners.is_empty())
            && !contains_nil_uuid(&agent_session_filters.ids);
        strip_nil_uuids(&mut agent_session_filters.ids);
        let mut document_filters = filters.document_filters;
        let mut chat_filters = filters.chat_filters;
        let mut email_filters = filters.email_filters;
        let mut channel_filters = filters.channel_filters;
        let mut project_filters = filters.project_filters;
        let mut call_filters = filters.call_filters;
        let mut calendar_event_filters = filters.calendar_event_filters;

        let should_include_documents = !contains_nil_uuid(&document_filters.document_ids);
        let should_include_chats = !contains_nil_uuid(&chat_filters.chat_ids);
        let should_include_emails = !contains_nil_uuid(&email_filters.email_thread_ids);
        let should_include_channels = !contains_nil_uuid(&channel_filters.channel_ids);
        let should_include_projects = !contains_nil_uuid(&project_filters.project_ids);
        let should_include_call_records = !contains_nil_uuid(&call_filters.channel_ids);
        let should_include_calendar_events =
            !contains_nil_uuid(&calendar_event_filters.calendar_event_ids);

        strip_nil_uuids(&mut document_filters.document_ids);
        strip_nil_uuids(&mut chat_filters.chat_ids);
        strip_nil_uuids(&mut email_filters.email_thread_ids);
        strip_nil_uuids(&mut email_filters.recipients);
        strip_nil_uuids(&mut channel_filters.channel_ids);
        strip_nil_uuids(&mut project_filters.project_ids);
        strip_nil_uuids(&mut call_filters.channel_ids);
        strip_nil_uuids(&mut calendar_event_filters.calendar_event_ids);

        document_filters.file_types = expand_file_types_for_search(document_filters.file_types);

        Self {
            should_include_agent_sessions,
            agent_session_filters,
            should_include_documents,
            should_include_chats,
            should_include_emails,
            should_include_channels,
            should_include_projects,
            should_include_call_records,
            should_include_calendar_events,
            document_filters,
            chat_filters,
            email_filters,
            channel_filters,
            project_filters,
            call_filters,
            calendar_event_filters,
        }
    }
}

#[derive(Debug, Serialize, Deserialize, ToSchema, JsonSchema)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum UnifiedSearchResponseItem {
    Document(DocumentSearchResponseItemWithMetadata),
    Chat(ChatSearchResponseItemWithMetadata),
    Email(EmailSearchResponseItemWithMetadata),
    ChannelMessage(ChannelMessageSearchResponseItem),
    Channel(ChannelNameSearchResponseItem),
    Project(ProjectSearchResponseItemWithMetadata),
    Call(CallRecordSearchResponseItemWithMetadata),
    Company(crate::crm_company::CrmCompanySearchResponseItem),
    CalendarEvent(crate::calendar_event::CalendarEventSearchResponseItemWithMetadata),
    AgentSession(crate::agent_session::AgentSessionSearchResponseItem),
}

impl UnifiedSearchResponseItem {
    pub fn entity_id(&self) -> Uuid {
        match self {
            Self::AgentSession(item) => item.id,
            Self::Document(item) => item.extra.id,
            Self::Chat(item) => item.extra.id,
            Self::Email(item) => item.extra.id,
            Self::ChannelMessage(item) => item.channel_id,
            Self::Channel(item) => item.channel_id,
            Self::Project(item) => item.extra.id,
            Self::Call(item) => item.extra.id,
            Self::Company(item) => item.id,
            Self::CalendarEvent(item) => item.extra.id,
        }
    }
    /// Get the updated_at timestamp for each item
    pub fn updated_at(&self) -> Option<DateTime<Utc>> {
        match self {
            Self::AgentSession(item) => Some(item.updated_at),
            Self::Document(item) => item.metadata.as_ref().map(|m| m.updated_at),
            Self::Chat(item) => item.metadata.as_ref().map(|m| m.updated_at),
            Self::Email(item) => Some(item.updated_at),
            Self::ChannelMessage(item) => Some(item.updated_at),
            Self::Channel(item) => item.metadata.as_ref().map(|metadata| metadata.updated_at),
            Self::Project(item) => item.metadata.as_ref().map(|m| m.updated_at),
            Self::Call(item) => item.metadata.as_ref().map(|m| m.updated_at),
            Self::Company(item) => Some(item.updated_at),
            Self::CalendarEvent(item) => item.metadata.as_ref().map(|m| m.updated_at),
        }
    }
}

#[derive(Debug, Serialize, Deserialize, ToSchema, Default)]
pub struct UnifiedSearchResponse {
    /// The search results
    pub results: Vec<UnifiedSearchResponseItem>,
    /// The next cursor to use for paginating results
    pub next_cursor: Option<String>,
}

#[derive(Debug, Serialize, Deserialize, ToSchema, JsonSchema)]
#[serde(rename_all = "camelCase", tag = "type")]
pub enum SimpleUnifiedSearchResponseBaseItem<T> {
    Document(SimpleDocumentSearchResponseBaseItem<T>),
    Chat(SimpleChatSearchResponseBaseItem<T>),
    Email(SimpleEmailSearchResponseBaseItem<T>),
    Channel(SimpleChannelSearchReponseBaseItem<T>),
    Project(SimpleProjectSearchResponseBaseItem<T>),
    Call(SimpleCallRecordSearchResponseBaseItem<T>),
    CalendarEvent(crate::calendar_event::SimpleCalendarEventSearchResponseBaseItem<T>),
}

pub type SimpleUnifiedSearchResponseItem =
    SimpleUnifiedSearchResponseBaseItem<crate::HumanReadableTimestamp>;

#[derive(Debug, Serialize, Deserialize, ToSchema, Default)]
pub struct SimpleUnifiedSearchBaseResponse<T> {
    pub results: Vec<SimpleUnifiedSearchResponseBaseItem<T>>,
}

pub type SimpleUnifiedSearchResponse =
    SimpleUnifiedSearchBaseResponse<crate::HumanReadableTimestamp>;

#[cfg(test)]
mod test;