expose more comprehensive set of search params to the assistant

catalog/app/components/Assistant/Model/Conversation.ts

@@ -287,6 +287,7 @@ Your primary purpose is assisting users of Quilt Data products.
 Persona: conservative and creative scientist.
 `
 
+// TODO: mention the client company?
 const TASK_CONTEXT = `
 <task-context>
 You act as a chatbot deployed on the Quilt Catalog web app.

catalog/app/components/Assistant/Model/GlobalTools/search.ts

@@ -4,19 +4,64 @@ import * as S from '@effect/schema/Schema'
 
 import * as SearchModel from 'containers/Search/model'
 import * as Model from 'model'
+import * as Log from 'utils/Logging'
 
 import * as Content from '../Content'
 import * as Tool from '../Tool'
 
-// TODO: more comprehensive params
-const SearchParamsSchema = S.Struct({
-  resultType: S.Enums(SearchModel.ResultType).annotations({
-    title: 'result type',
-    description: 'whether to search for objects or packages',
+const MODULE = 'GlobalTools/search'
+
+const PackageFilterSchema = S.Struct({
+  modified: S.optional(SearchModel.PredicatesJSON.Datetime),
+  size: S.optional(SearchModel.PredicatesJSON.Number),
+  name: S.optional(SearchModel.PredicatesJSON.KeywordWildcard),
+  hash: S.optional(SearchModel.PredicatesJSON.KeywordWildcard),
+  entries: S.optional(SearchModel.PredicatesJSON.Number),
+  comment: S.optional(SearchModel.PredicatesJSON.Text),
+  workflow: S.optional(SearchModel.PredicatesJSON.KeywordEnum),
+})
+
+const PackageSearchParamsSchema = S.Struct({
+  resultType: S.Literal(SearchModel.ResultType.QuiltPackage).annotations({
+    title: 'result type: Quilt Package',
+  }),
+  filter: S.optional(PackageFilterSchema).annotations({
+    title: 'result filters',
+  }),
+  userMetaFilters: S.optional(SearchModel.UserMetaFiltersSchema).annotations({
+    title: 'user metadata filters',
+    description: 'a map of user metadata field paths to predicate values',
+  }),
+}).annotations({
+  title: 'package-specific search parameters',
+})
+
+const ObjectFilterSchema = S.Struct({
+  modified: S.optional(SearchModel.PredicatesJSON.Datetime),
+  size: S.optional(SearchModel.PredicatesJSON.Number),
+  ext: S.optional(SearchModel.PredicatesJSON.KeywordEnum).annotations({
+    title: 'file extensions (with a leading dot)',
+  }),
+  key: S.optional(SearchModel.PredicatesJSON.KeywordWildcard),
+  content: S.optional(SearchModel.PredicatesJSON.Text),
+  deleted: S.optional(SearchModel.PredicatesJSON.Boolean),
+})
+
+const ObjectSearchParamsSchema = S.Struct({
+  resultType: S.Literal(SearchModel.ResultType.S3Object).annotations({
+    title: 'result type: S3 Object',
+  }),
+  filter: S.optional(ObjectFilterSchema).annotations({
+    title: 'result filters',
   }),
+}).annotations({
+  title: 'object-specific search parameters',
+})
+
+const SearchParamsSchema = S.Struct({
   searchString: S.optional(S.String).annotations({
     title: 'search string',
-    description: 'string to search for',
+    description: 'string to search for, ElasticSearch syntax supported',
   }),
   buckets: S.Array(S.String).annotations({
     title: 'search buckets',
@@ -26,31 +71,63 @@ const SearchParamsSchema = S.Struct({
     title: 'search order',
     description: 'order of search results',
   }),
+  params: S.Union(PackageSearchParamsSchema, ObjectSearchParamsSchema).annotations({
+    title: 'result type-specific parameters',
+  }),
 }).annotations({
   title: 'search parameters',
   description: 'Start a search session',
 })
 
+type SearchParams = S.Schema.Type<typeof SearchParamsSchema>
+
+function searchUrlStateFromSearchParams({
+  params,
+  searchString,
+  ...rest
+}: SearchParams): SearchModel.SearchUrlState {
+  const base = { searchString: searchString ?? null, ...rest }
+  switch (params.resultType) {
+    case SearchModel.ResultType.S3Object:
+      return {
+        ...base,
+        resultType: params.resultType,
+        filter: SearchModel.ObjectsSearchFilterIO.fromJSON(params.filter),
+      }
+    case SearchModel.ResultType.QuiltPackage:
+      return {
+        ...base,
+        resultType: params.resultType,
+        filter: SearchModel.PackagesSearchFilterIO.fromJSON({}),
+        userMetaFilters: SearchModel.UserMetaFilters.fromJSON(params.userMetaFilters),
+      }
+    default:
+      return Eff.absurd<never>(params)
+  }
+}
+
 export function useStartSearch() {
   const makeUrl = SearchModel.useMakeUrl()
   const history = useHistory()
   return Tool.useMakeTool(
     SearchParamsSchema,
     (params) =>
-      Eff.Effect.gen(function* () {
-        yield* Eff.Console.debug('tool: start search', params)
-
-        const defaultParams = SearchModel.parseSearchParams(`t=${params.resultType}`)
-        const url = makeUrl({ ...defaultParams, ...params } as SearchModel.SearchUrlState)
-        yield* Eff.Effect.sync(() => history.push(url))
-        return Eff.Option.some(
-          Tool.succeed(
-            Content.ToolResultContentBlock.Text({
-              text: 'Navigating to the search page and starting the search session. Use catalog_search_getResults tool to get the search results.',
-            }),
-          ),
-        )
-      }),
+      Log.scoped({
+        name: `${MODULE}.startSearch`,
+        enter: [Log.br, 'params:', params],
+      })(
+        Eff.Effect.gen(function* () {
+          const url = makeUrl(searchUrlStateFromSearchParams(params))
+          yield* Eff.Effect.sync(() => history.push(url))
+          return Eff.Option.some(
+            Tool.succeed(
+              Content.ToolResultContentBlock.Text({
+                text: 'Navigating to the search page and starting the search session. Use catalog_search_getResults tool to get the search results.',
+              }),
+            ),
+          )
+        }),
+      ),
     [makeUrl, history],
   )
 }

catalog/app/containers/Search/model.ts

@@ -4,6 +4,7 @@ import * as R from 'ramda'
 import * as React from 'react'
 import * as RR from 'react-router-dom'
 import { useDebounce } from 'use-debounce'
+import * as S from '@effect/schema/Schema'
 import * as Sentry from '@sentry/react'
 
 import * as Model from 'model'
@@ -99,6 +100,7 @@ interface PredicateIO<Tag extends string, State, GQLType> {
   readonly _tag: Tag
   initialState: Tagged<Tag, State>
   fromString: (input: string) => Tagged<Tag, State>
+  fromJSON: (input: unknown) => Tagged<Tag, State>
   toString: (state: Tagged<Tag, State>) => string | null
   toGQL: (state: Tagged<Tag, State>) => GQLType | null
 }
@@ -118,13 +120,15 @@ function Predicate<Tag extends string, State, GQLType>(input: {
   tag: Tag
   init: State
   fromString: (input: string) => State
+  fromJSON: (input: unknown) => State
   toString: (state: Tagged<Tag, State>) => string | null
   toGQL: (state: Tagged<Tag, State>) => GQLType | null
 }): PredicateIO<Tag, State, GQLType> {
   return {
     _tag: input.tag,
     initialState: addTag(input.tag, input.init),
     fromString: (s: string) => addTag(input.tag, input.fromString(s)),
+    fromJSON: (s: unknown) => addTag(input.tag, input.fromJSON(s)),
     toString: input.toString,
     toGQL: input.toGQL,
   }
@@ -144,6 +148,10 @@ export const Predicates = {
         lte: parseDate(json.lte),
       }
     },
+    fromJSON: (input: unknown) => ({
+      gte: parseDate((input as any)?.gte),
+      lte: parseDate((input as any)?.lte),
+    }),
     toString: ({ _tag, ...state }) => JSON.stringify(state),
     toGQL: ({ _tag, ...state }) =>
       state.gte == null && state.lte === null
@@ -164,6 +172,10 @@ export const Predicates = {
         lte: (json.lte as number) ?? null,
       }
     },
+    fromJSON: (input: unknown) => ({
+      gte: ((input as any)?.gte as number) ?? null,
+      lte: ((input as any)?.lte as number) ?? null,
+    }),
     toString: ({ _tag, ...state }) => JSON.stringify(state),
     toGQL: ({ _tag, ...state }) =>
       state.gte == null && state.lte === null
@@ -175,6 +187,7 @@ export const Predicates = {
     tag: 'Text',
     init: { queryString: '' },
     fromString: (input: string) => ({ queryString: input }),
+    fromJSON: (input: unknown) => ({ queryString: input as string }),
     toString: ({ _tag, ...state }) => state.queryString.trim(),
     toGQL: ({ _tag, ...state }) => {
       const queryString = state.queryString.trim()
@@ -186,6 +199,7 @@ export const Predicates = {
     tag: 'KeywordEnum',
     init: { terms: [] as string[] },
     fromString: (input: string) => ({ terms: JSON.parse(`[${input}]`) as string[] }),
+    fromJSON: (input: unknown) => ({ terms: input as string[] }),
     toString: ({ terms }) => JSON.stringify(terms).slice(1, -1),
     toGQL: ({ terms }) =>
       terms.length
@@ -199,6 +213,7 @@ export const Predicates = {
       wildcard: '' as string,
     },
     fromString: (wildcard: string) => ({ wildcard }),
+    fromJSON: (input: unknown) => ({ wildcard: input as string }),
     toString: ({ wildcard }) => wildcard,
     toGQL: ({ wildcard }) =>
       wildcard
@@ -213,6 +228,10 @@ export const Predicates = {
       const values = input.split(',')
       return { true: values.includes('true'), false: values.includes('false') }
     },
+    fromJSON: (input: unknown) => ({
+      true: (input as any)?.includes?.('true'),
+      false: (input as any)?.includes?.('false'),
+    }),
     toString: (state) => {
       const values = []
       if (state.true) values.push('true')
@@ -259,6 +278,7 @@ type CombinedGQLType<PM extends PredicateMap> = {
 
 interface FilterIO<PM extends PredicateMap> {
   fromURLSearchParams: (params: URLSearchParams) => OrderedCombinedState<PM>
+  fromJSON: (params: Record<string, unknown> | undefined) => OrderedCombinedState<PM>
   toURLSearchParams: (state: OrderedCombinedState<PM>) => [string, string][]
   toGQL: (state: OrderedCombinedState<PM>) => CombinedGQLType<PM> | null
   children: PM
@@ -303,6 +323,19 @@ function Filter<PM extends PredicateMap>(children: PM): FilterIO<PM> {
     return state
   }
 
+  function fromJSON(
+    params: Record<string, unknown> | undefined,
+  ): OrderedCombinedState<PM> {
+    const state = initState()
+    Object.entries(params ?? {}).forEach(([k, v]) => {
+      const predicate = children[k]
+      if (!predicate) return
+      state.order.push(k as keyof PM)
+      state.predicates[k as keyof PM] = predicate.fromJSON(v)
+    })
+    return state
+  }
+
   function toURLSearchParams(state: OrderedCombinedState<PM>): [string, string][] {
     const params: [string, string][] = []
     state.order.forEach((k) => {
@@ -373,6 +406,7 @@ function Filter<PM extends PredicateMap>(children: PM): FilterIO<PM> {
 
   return {
     fromURLSearchParams,
+    fromJSON,
     toURLSearchParams,
     toGQL,
     children,
@@ -406,9 +440,62 @@ export const PackagesSearchFilterIO = Filter({
   workflow: Predicates.KeywordEnum,
 })
 
+// XXX: identifiers for predicate types?
+export const PredicatesJSON = {
+  Datetime: S.Struct({
+    gte: S.optional(S.NullOr(S.DateFromString)),
+    lte: S.optional(S.NullOr(S.DateFromString)),
+  }),
+  Number: S.Struct({
+    gte: S.optional(S.NullOr(S.Number)),
+    lte: S.optional(S.NullOr(S.Number)),
+  }),
+  Text: S.String,
+  KeywordEnum: S.Array(S.String),
+  KeywordWildcard: S.String,
+  Boolean: S.Array(S.Literal('true', 'false')),
+}
+
+// XXX: somehow map instead of enumerating manually?
+export const PredicateWithState = S.Union(
+  S.Struct({
+    path: S.String,
+    type: S.Literal('Datetime'),
+    value: PredicatesJSON.Datetime,
+  }),
+  S.Struct({
+    path: S.String,
+    type: S.Literal('Number'),
+    value: PredicatesJSON.Number,
+  }),
+  S.Struct({
+    path: S.String,
+    type: S.Literal('Text'),
+    value: PredicatesJSON.Text,
+  }),
+  S.Struct({
+    path: S.String,
+    type: S.Literal('KeywordEnum'),
+    value: PredicatesJSON.KeywordEnum,
+  }),
+  S.Struct({
+    path: S.String,
+    type: S.Literal('KeywordWildcard'),
+    value: PredicatesJSON.KeywordWildcard,
+  }),
+  S.Struct({
+    path: S.String,
+    type: S.Literal('Boolean'),
+    value: PredicatesJSON.Boolean,
+  }),
+)
+
+// XXX: make it a record?
+export const UserMetaFiltersSchema = S.Array(PredicateWithState)
+
 type UserMetaFilterMap = Map<string, PredicateState<KnownPredicate>>
 
-class UserMetaFilters {
+export class UserMetaFilters {
   filters: UserMetaFilterMap
 
   static typeMap: Record<string, KnownPredicate> = {
@@ -455,6 +542,18 @@ class UserMetaFilters {
     return new this(filters)
   }
 
+  static fromJSON(
+    params: S.Schema.Type<typeof UserMetaFiltersSchema> | undefined,
+  ): UserMetaFilters {
+    const filters: UserMetaFilterMap = new Map()
+    ;(params ?? []).forEach(({ path, type, value }) => {
+      const predicate = UserMetaFilters.typeMap[type]
+      if (!predicate) return
+      filters.set(path, predicate.fromJSON(value))
+    })
+    return new this(filters)
+  }
+
   constructor(filters?: UserMetaFilterMap) {
     this.filters = filters || new Map()
   }