@rimori/client 1.0.4 → 1.1.0

package/src/controller/SharedContentController.ts

@@ -1,71 +1,232 @@
-import { v4 as uuidv4 } from 'uuid';
-import { ObjectRequest } from "./ObjectController";
+import { SupabaseClient } from '@supabase/supabase-js';
 import { RimoriClient } from "../plugin/RimoriClient";
+import { ObjectRequest } from "./ObjectController";
+
+export interface BasicAssignment<T> {
+  id: string;
+  createdAt: Date;
+  topic: string;
+  createdBy: string;
+  verified: boolean;
+  keywords: any;
+  data: T;
+}
 
-export interface BasicAssignment {
-    id: string;
-    createdAt: Date;
-    topic: string;
-    createdBy: string;
-    verified: boolean;
-    keywords: any;
+export interface SharedContentObjectRequest extends ObjectRequest {
+  fixedProperties?: Record<string, string | number | boolean>
 }
 
+export type SharedContentFilter = Record<string, string | number | boolean>
+
 export class SharedContentController {
-    private rimoriClient: RimoriClient;
+  private supabase: SupabaseClient;
+  private rimoriClient: RimoriClient;
+
+  constructor(supabase: SupabaseClient, rimoriClient: RimoriClient) {
+    this.supabase = supabase;
+    this.rimoriClient = rimoriClient;
+  }
+
+  /**
+   * Fetch new shared content for a given content type.
+   * @param contentType - The type of content to fetch.
+   * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
+   * @param filter - An optional filter to apply to the query.
+   * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+   * @returns The new shared content.
+   */
+  public async getNewSharedContent<T>(
+    contentType: string,
+    generatorInstructions: SharedContentObjectRequest,
+    //this filter is there if the content should be filtered additionally by a column and value
+    filter?: SharedContentFilter,
+    privateTopic?: boolean,
+  ): Promise<BasicAssignment<T>> {
+    const query = this.supabase.from("shared_content")
+      .select("*, scc:shared_content_completed(id)")
+      .eq('content_type', contentType)
+      .is('scc.id', null)
+      .limit(10);
+
+    if (filter) {
+      query.contains('data', filter);
+    }
+
+    const { data: newAssignments, error } = await query;
+
+    if (error) {
+      console.error('error fetching new assignments:', error);
+      throw new Error('error fetching new assignments');
+    }
+
+    console.log('newAssignments:', newAssignments);
+
+    if (newAssignments.length > 0) {
+      const index = Math.floor(Math.random() * newAssignments.length);
+      return newAssignments[index];
+    }
+
+    // generate new assignments
+    const fullInstructions = await this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+
+    console.log('fullInstructions:', fullInstructions);
+
+    const instructions = await this.rimoriClient.llm.getObject(fullInstructions);
+
+    console.log('instructions:', instructions);
+
+    const { data: newAssignment, error: insertError } = await this.supabase.from("shared_content").insert({
+      private: privateTopic,
+      content_type: contentType,
+      topic: instructions.topic,
+      keywords: instructions.keywords.map(({ text }: { text: string }) => text),
+      data: { ...instructions, topic: undefined, keywords: undefined, ...generatorInstructions.fixedProperties },
+    }).select();
+
+    if (insertError) {
+      console.error('error inserting new assignment:', insertError);
+      throw new Error('error inserting new assignment');
+    }
+
+    return newAssignment[0];
+  }
 
-    constructor(rimoriClient: RimoriClient) {
-        this.rimoriClient = rimoriClient;
+  private async getGeneratorInstructions(contentType: string, generatorInstructions: ObjectRequest, filter?: SharedContentFilter): Promise<ObjectRequest> {
+    const completedTopics = await this.getCompletedTopics(contentType, filter);
+
+    generatorInstructions.instructions += `
+    The following topics are already taken: ${completedTopics.join(', ')}`;
+
+    generatorInstructions.tool.topic = {
+      type: "string",
+      description: "What the topic is about. Short. ",
+    }
+    generatorInstructions.tool.keywords = {
+      type: [{ text: { type: "string" } }],
+      description: "Keywords around the topic of the assignment.",
+    }
+    return generatorInstructions;
+  }
+
+  private async getCompletedTopics(contentType: string, filter?: SharedContentFilter): Promise<string[]> {
+    const query = this.supabase.from("shared_content")
+      .select("topic, keywords, scc:shared_content_completed(id)")
+      .eq('content_type', contentType)
+      .not('scc.id', 'is', null)
+
+    if (filter) {
+      query.contains('data', filter);
     }
 
-    public async fetchNewSharedContent<T, R = T & BasicAssignment>(
-        type: string,
-        generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest,
-        filter?: { column: string, value: string | number | boolean },
-    ): Promise<R[]> {
-        const queryParameter = { filter_column: filter?.column || null, filter_value: filter?.value || null, unread: true }
-        const { data: newAssignments } = await this.rimoriClient.db.rpc(type + "_entries", queryParameter)
-        console.log('newAssignments:', newAssignments);
-
-        if ((newAssignments as any[]).length > 0) {
-            return newAssignments as R[];
-        }
-        // generate new assignments
-        const { data: oldAssignments } = await this.rimoriClient.db.rpc(type + "_entries", { ...queryParameter, unread: false })
-        console.log('oldAssignments:', oldAssignments);
-        const reservedTopics = this.getReservedTopics(oldAssignments as BasicAssignment[]);
-
-        const request = await generatorInstructions(reservedTopics);
-        if (!request.tool.keywords || !request.tool.topic) {
-            throw new Error("topic or keywords not found in the request schema");
-        }
-        const instructions = await this.rimoriClient.llm.getObject(request);
-        console.log('instructions:', instructions);
-
-        const preparedData = {
-            id: uuidv4(),
-            ...instructions,
-            keywords: this.purifyStringArray(instructions.keywords),
-        };
-        return await this.rimoriClient.db.from(type).insert(preparedData).then(() => [preparedData] as R[]);
+    const { data: oldAssignments, error } = await query;
+
+    if (error) {
+      console.error('error fetching old assignments:', error);
+      return [];
     }
+    return oldAssignments.map(({ topic, keywords }) => `${topic}(${keywords.join(',')})`);
+  }
 
-    private getReservedTopics(oldAssignments: BasicAssignment[]) {
-        return oldAssignments.map(({ topic, keywords }) => {
-            const keywordTexts = this.purifyStringArray(keywords).join(',');
-            return `${topic}(${keywordTexts})`;
-        });
+  public async getSharedContent<T>(contentType: string, id: string): Promise<BasicAssignment<T>> {
+    const { data, error } = await this.supabase.from("shared_content").select().eq('content_type', contentType).eq('id', id).single();
+    if (error) {
+      console.error('error fetching shared content:', error);
+      throw new Error('error fetching shared content');
     }
+    return data;
+  }
+
+  public async completeSharedContent(contentType: string, assignmentId: string) {
+    await this.supabase.from("shared_content_completed").insert({ content_type: contentType, id: assignmentId });
+  }
+
+  /**
+   * Fetch shared content from the database based on optional filters.
+   * @param contentType - The type of content to fetch.
+   * @param filter - Optional filter to apply to the query.
+   * @param limit - Optional limit for the number of results.
+   * @returns Array of shared content matching the criteria.
+   */
+  public async getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<BasicAssignment<T>[]> {
+    const query = this.supabase.from("shared_content").select("*").eq('content_type', contentType).limit(limit ?? 30);
 
-    private purifyStringArray(array: { text: string }[]): string[] {
-        return array.map(({ text }) => text);
+    if (filter) {
+      query.contains('data', filter);
     }
 
-    public async getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T> {
-        return await this.rimoriClient.db.from(type).select().eq('id', id).single() as unknown as T;
+    const { data, error } = await query;
+
+    if (error) {
+      console.error('error fetching shared content:', error);
+      throw new Error('error fetching shared content');
     }
 
-    public async completeSharedContent(type: string, assignmentId: string) {
-        await this.rimoriClient.db.from(type + "_result").insert({ assignment_id: assignmentId });
+    return data;
+  }
+
+  /**
+   * Insert new shared content into the database.
+   * @param param
+   * @param param.contentType - The type of content to insert.
+   * @param param.topic - The topic of the content.
+   * @param param.keywords - Keywords associated with the content.
+   * @param param.data - The content data to store.
+   * @param param.privateTopic - Optional flag to indicate if the topic should be private.
+   * @returns The inserted shared content.
+   * @throws {Error} if insertion fails.
+   */
+  public async createSharedContent<T>({ contentType, topic, keywords, data, privateTopic }: SharedContent<T>): Promise<BasicAssignment<T>> {
+    const { data: newContent, error } = await this.supabase.from("shared_content").insert({
+      private: privateTopic,
+      content_type: contentType,
+      topic,
+      keywords,
+      data,
+    }).select();
+
+    if (error) {
+      console.error('error inserting shared content:', error);
+      throw new Error('error inserting shared content');
     }
+
+    return newContent[0];
+  }
+
+  /**
+   * Update existing shared content in the database.
+   * @param id - The ID of the content to update.
+   * @param updates - The updates to apply to the shared content.
+   * @returns The updated shared content.
+   * @throws {Error} if update fails.
+   */
+  public async updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<BasicAssignment<T>> {
+    const updateData: any = {};
+
+    if (updates.contentType) updateData.content_type = updates.contentType;
+    if (updates.topic) updateData.topic = updates.topic;
+    if (updates.keywords) updateData.keywords = updates.keywords;
+    if (updates.data) updateData.data = updates.data;
+    if (updates.privateTopic !== undefined) updateData.private = updates.privateTopic;
+
+    const { data: updatedContent, error } = await this.supabase.from("shared_content").update(updateData).eq('id', id).select();
+
+    if (error) {
+      console.error('error updating shared content:', error);
+      throw new Error('error updating shared content');
+    }
+
+    if (!updatedContent || updatedContent.length === 0) {
+      throw new Error('shared content not found');
+    }
+
+    return updatedContent[0];
+  }
+}
+
+export interface SharedContent<T> {
+  contentType: string;
+  topic: string;
+  keywords: string[];
+  data: T;
+  privateTopic?: boolean;
 }

package/src/controller/SidePluginController.ts

@@ -1,17 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-
-export interface Plugin {
-    id: string;
-    title: string;
-    icon_url: string;
-    website: string;
-    context_menu_actions: string;
-    plugin_pages: string;
-    sidebar_pages: string;
-    settings_page: string;
-    version: string;
-    external_hosted_url: string;
-}
+import { Plugin } from '../plugin/fromRimori/PluginTypes';
 
 export async function getPlugins(supabase: SupabaseClient): Promise<Plugin[]> {
     let { data, error } = await supabase.from('plugins').select('*');

package/src/core/components/ContextMenu.tsx

@@ -0,0 +1,123 @@
+import React, { useState, useEffect, useRef } from "react";
+import { EventBus } from "../../plugin/fromRimori/EventBus";
+import { RimoriClient } from "../../plugin/RimoriClient";
+import { MenuEntry } from "../../plugin/fromRimori/PluginTypes";
+
+export interface Position {
+  x: number,
+  y: number,
+  text?: string
+}
+
+const ContextMenu = ({ client }: { client: RimoriClient }) => {
+  const [isOpen, setIsOpen] = useState<boolean>(false);
+  const [actions, setActions] = useState<MenuEntry[]>([]);
+  const [position, setPosition] = useState<Position>({ x: 0, y: 0 });
+  const [openOnTextSelect, setOpenOnTextSelect] = useState(false);
+  const menuRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    client.plugin.getInstalled().then(plugins => {
+      setActions(plugins.flatMap(p => p.context_menu_actions).filter(Boolean));
+    });
+
+    client.plugin.getUserInfo().then((userInfo) => {
+      setOpenOnTextSelect(userInfo.context_menu_on_select);
+    })
+
+    EventBus.on<{ actions: MenuEntry[] }>("global.contextMenu.createActions", ({ data }) => {
+      setActions([...data.actions, ...actions]);
+    });
+  }, []);
+
+  useEffect(() => {
+    // Track mouse position globally
+    const handleMouseMove = (e: MouseEvent) => {
+      const selectedText = window.getSelection()?.toString().trim();
+      if (isOpen && selectedText === position.text) return;
+      setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+    };
+
+    const handleMouseUp = (e: MouseEvent) => {
+      const selectedText = window.getSelection()?.toString().trim();
+      // Check if click is inside the context menu
+      if (menuRef.current && menuRef.current.contains(e.target as Node)) {
+        // Don't close the menu if clicking inside
+        return;
+      }
+
+      // Prevent context menu on textarea or text input selection
+      const target = e.target as HTMLElement;
+      const isTextInput = target && (
+        (target.tagName === 'TEXTAREA') ||
+        (target.tagName === 'INPUT' && (target as HTMLInputElement).type === 'text')
+      );
+      if (isTextInput) {
+        setIsOpen(false);
+        return;
+      }
+
+      if (e.button === 0 && isOpen) {
+        setIsOpen(false);
+        window.getSelection()?.removeAllRanges();
+      } else if (selectedText && (openOnTextSelect || e.button === 2)) {
+        if (e.button === 2) {
+          e.preventDefault();
+        }
+        setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+        setIsOpen(true);
+      } else {
+        setIsOpen(false);
+      }
+    };
+
+    // Add selectionchange listener to close menu if selection is cleared
+    const handleSelectionChange = () => {
+      const selectedText = window.getSelection()?.toString().trim();
+      if (!selectedText && isOpen) {
+        setIsOpen(false);
+      }
+    };
+
+    document.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener("mousemove", handleMouseMove);
+    document.addEventListener("contextmenu", handleMouseUp);
+    document.addEventListener("selectionchange", handleSelectionChange);
+
+    return () => {
+      document.removeEventListener("mouseup", handleMouseUp);
+      window.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("contextmenu", handleMouseUp);
+      document.removeEventListener("selectionchange", handleSelectionChange);
+    };
+  }, [openOnTextSelect, isOpen, position.text]);
+
+  if (!isOpen) {
+    return null;
+  }
+
+  return (
+    <div
+      ref={menuRef}
+      className="fixed bg-gray-400 dark:bg-gray-700 shadow-lg border border-gray-400 rounded-md overflow-hidden dark:text-white z-50"
+      style={{ top: position.y, left: position.x }}>
+      {actions.map((action, index) => (
+        <MenuEntryItem key={index} icon={action.icon} text={action.text} onClick={() => {
+          setIsOpen(false);
+          window.getSelection()?.removeAllRanges();
+          client.event.emitSidebarAction(action.pluginId, action.actionKey, position.text);
+        }} />
+      ))}
+    </div>
+  );
+};
+
+function MenuEntryItem(props: { icon: React.ReactNode, text: string, onClick: () => void }) {
+  return <button onClick={props.onClick} className="px-4 py-2 text-left hover:bg-gray-500 dark:hover:bg-gray-600 w-full flex flex-row">
+    <span className="flex-grow">{props.icon}</span>
+    <span className="flex-grow">{props.text}</span>
+    {/* <span className="text-sm">Ctrl+Shift+xxxx</span> */}
+  </button>
+}
+
+export default ContextMenu;

package/src/core.ts

@@ -7,4 +7,6 @@ export * from "./plugin/PluginController";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./worker/WorkerSetup";
-export * from "./plugin/fromRimori/EventBus";
+export * from "./plugin/fromRimori/EventBus";
+export * from "./plugin/AccomplishmentHandler";
+export * from "./utils/Language";

package/src/hooks/UseChatHook.ts

@@ -1,25 +1,25 @@
 import React from "react";
+import { Message, Tool, ToolInvocation } from "../controller/AIController";
 import { usePlugin } from "../providers/PluginProvider";
-import { ToolInvocation, Tool, Message } from "../controller/AIController";
 
 export function useChat(tools?: Tool[]) {
-    const [messages, setMessages] = React.useState<Message[]>([]);
-    const [isLoading, setIsLoading] = React.useState(false);
-    const { llm } = usePlugin();
+  const [messages, setMessages] = React.useState<Message[]>([]);
+  const [isLoading, setIsLoading] = React.useState(false);
+  const { llm } = usePlugin();
 
-    const append = (appendMessages: Message[]) => {
-        llm.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
-            const lastMessage = messages[messages.length - 1];
-            setIsLoading(!finished);
+  const append = (appendMessages: Message[]) => {
+    llm.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
+      const lastMessage = messages[messages.length - 1];
+      setIsLoading(!finished);
 
-            if (lastMessage?.id === id) {
-                lastMessage.content = message;
-                setMessages([...messages, lastMessage]);
-            } else {
-                setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolInvocations }]);
-            }
-        }, tools);
-    };
+      if (lastMessage?.id === id) {
+        lastMessage.content = message;
+        setMessages([...messages, lastMessage]);
+      } else {
+        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolInvocations }]);
+      }
+    }, tools);
+  };
 
-    return { messages, append, isLoading, setMessages, lastMessage: messages[messages.length - 1] as Message | undefined };
+  return { messages, append, isLoading, setMessages, lastMessage: messages[messages.length - 1] as Message | undefined };
 }

package/src/plugin/AccomplishmentHandler.ts

@@ -0,0 +1,165 @@
+import { EventBus, EventBusMessage } from "./fromRimori/EventBus";
+
+export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
+
+export const skillCategories = ["reading", "listening", "speaking", "writing", "learning", "community"] as const;
+
+interface BaseAccomplishmentPayload {
+  type: "micro" | "macro";
+  skillCategory: (typeof skillCategories)[number];
+  /*
+  what is the accomplishment? e.g. chapter, flashcard, story, etc.
+  only one keyword per skill category, written in lowercase without spaces, numbers, or special characters
+  */
+  accomplishmentKeyword: string;
+  // the human readable description of the accomplishment. Important for other plugin developers to understand the accomplishment.
+  description: string;
+  meta?: {
+    //the key of the meta data in snake_case
+    key: string;
+    //the value of the meta data
+    value: string | number | boolean;
+    //the human readable description of the meta data. Important for other plugin developers to understand the meta data.
+    description: string;
+  }[];
+}
+
+export interface MicroAccomplishmentPayload extends BaseAccomplishmentPayload {
+  type: "micro";
+}
+
+export interface MacroAccomplishmentPayload extends BaseAccomplishmentPayload {
+  type: "macro";
+  errorRatio: number;
+  durationMinutes: number;
+}
+
+export type AccomplishmentPayload = MicroAccomplishmentPayload | MacroAccomplishmentPayload;
+
+export class AccomplishmentHandler {
+  private pluginId: string;
+
+  public constructor(pluginId: string) {
+    this.pluginId = pluginId;
+  }
+
+  emitAccomplishment(payload: Omit<AccomplishmentPayload, "type">) {
+    const accomplishmentPayload = { ...payload, type: "durationMinutes" in payload ? "macro" : "micro" } as AccomplishmentPayload;
+
+    this.validateAccomplishment(accomplishmentPayload);
+
+    const sanitizedPayload = this.sanitizeAccomplishment(accomplishmentPayload);
+
+    const topic = "global.accomplishment.trigger" + (accomplishmentPayload.type === "macro" ? "Macro" : "Micro");
+
+    EventBus.emit(this.pluginId, topic, sanitizedPayload);
+  }
+
+  private validateAccomplishment(payload: AccomplishmentPayload) {
+    if (!skillCategories.includes(payload.skillCategory)) {
+      throw new Error(`Invalid skill category: ${payload.skillCategory}`);
+    }
+
+    //regex validate accomplishmentKeyword
+    if (!/^[a-z_-]+$/.test(payload.accomplishmentKeyword)) {
+      throw new Error(`The accomplishment keyword: ${payload.accomplishmentKeyword} is invalid. Only lowercase letters, minuses and underscores are allowed`);
+    }
+
+    //description is required
+    if (payload.description.length < 10) {
+      throw new Error("Description is too short");
+    }
+
+    //check that the type is valid
+    if (!["micro", "macro"].includes(payload.type)) {
+      throw new Error("Invalid accomplishment type " + payload.type);
+    }
+
+    //durationMinutes is required
+    if (payload.type === "macro" && payload.durationMinutes < 4) {
+      throw new Error("The duration must be at least 4 minutes");
+    }
+
+    //errorRatio is required
+    if (payload.type === "macro" && (payload.errorRatio < 0 || payload.errorRatio > 1)) {
+      throw new Error("The error ratio must be between 0 and 1");
+    }
+
+    //regex check meta data key
+    if (payload.meta) {
+      payload.meta.forEach(meta => {
+        if (!/^[a-z_]+$/.test(meta.key)) {
+          throw new Error("Invalid meta data key " + meta.key + ", only lowercase letters and underscores are allowed");
+        }
+      });
+    }
+  }
+
+  private sanitizeAccomplishment(payload: AccomplishmentPayload) {
+    payload.description = payload.description.replace(/[^\x20-\x7E]/g, "");
+
+    payload.meta?.forEach((meta) => {
+      meta.description = meta.description.replace(/[^\x20-\x7E]/g, "");
+    });
+
+    return payload;
+  }
+
+  private getDecoupledTopic(topic: string) {
+    const [plugin, skillCategory, accomplishmentKeyword] = topic.split(".");
+
+    return { plugin: plugin || "*", skillCategory: skillCategory || "*", accomplishmentKeyword: accomplishmentKeyword || "*" };
+  }
+
+  /**
+   * Subscribe to accomplishment events
+   * @param accomplishmentTopic - The topic of the accomplishment event. The pattern can be any pattern of plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword
+   * @param callback - The callback function to be called when the accomplishment event is triggered
+   */
+  subscribe(accomplishmentTopics = "*" as string | string[], callback: (payload: EventBusMessage<AccomplishmentPayload>) => void) {
+    if (typeof accomplishmentTopics === "string") {
+      accomplishmentTopics = [accomplishmentTopics];
+    }
+
+    accomplishmentTopics.forEach((accomplishmentTopic) => {
+      const topicLength = accomplishmentTopic.split(".").length
+      if (topicLength === 1) {
+        accomplishmentTopic += ".*.*"
+      } else if (topicLength === 2) {
+        accomplishmentTopic += ".*"
+      } else if (topicLength !== 3) {
+        throw new Error("Invalid accomplishment topic pattern. The pattern must be plugin.skillCategory.accomplishmentKeyword or an * as wildcard for any plugin, skill category or accomplishment keyword");
+      }
+
+      EventBus.on<AccomplishmentPayload>(["global.accomplishment.triggerMicro", "global.accomplishment.triggerMacro"], (event) => {
+        const { plugin, skillCategory, accomplishmentKeyword } = this.getDecoupledTopic(accomplishmentTopic);
+
+        if (plugin !== "*" && event.sender !== plugin) return;
+        if (skillCategory !== "*" && event.data.skillCategory !== skillCategory) return;
+        if (accomplishmentKeyword !== "*" && event.data.accomplishmentKeyword !== accomplishmentKeyword) return;
+
+        callback(event);
+      }, [this.pluginId]);
+    });
+  }
+}
+
+// const accomplishmentHandler = AccomplishmentHandler.getInstance("my-plugin");
+
+// accomplishmentHandler.subscribe("*", (payload) => {
+//   console.log(payload);
+// });
+
+// accomplishmentHandler.emitAccomplishment({
+//   skillCategory: "reading",
+//   accomplishmentKeyword: "chapter",
+//   description: "Read chapter 1 of the book",
+//   durationMinutes: 10,
+//   meta: [
+//     {
+//       key: "book",
+//       value: "The Great Gatsby",
+//       description: "The book I read",
+//     },
+//   ],
+// });