@rimori/client 1.0.5 → 1.1.1

package/src/controller/AIController.ts

@@ -69,7 +69,8 @@ export async function streamChatGPT(supabaseUrl: string, messages: Message[], to
           // console.log("AI response:", content);
 
           //content \n\n should be real line break when message is displayed
-          onResponse(messageId, content.replace(/\\n/g, '\n'), false);
+          //content \"\" should be real double quote when message is displayed
+          onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"|"\\+/g, '"'), false);
         } else if (command === 'd') {
           // console.log("AI usage:", JSON.parse(line.substring(2)));
           done = true;

package/src/controller/SettingsController.ts

@@ -1,102 +1,101 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { LanguageLevel } from "../utils/difficultyConverter";
+import { Language } from "../utils/Language";
 
 export interface UserInfo {
-    motherTongue: string;
-    xp: number;
-    listening_level: LanguageLevel;
-    reading_level: LanguageLevel;
-    speaking_level: LanguageLevel;
-    writing_level: LanguageLevel;
-    understanding_level: LanguageLevel;
-    grammar_level: LanguageLevel;
-    longterm_goal: string;
-    motivation_type: string;
-    study_buddy: string;
-    preferred_genre: string;
-    milestone: string;
-    settings: {
-        contextMenuOnSelect: boolean;
-    }
+  skill_level_reading: LanguageLevel;
+  skill_level_writing: LanguageLevel;
+  skill_level_grammar: LanguageLevel;
+  skill_level_speaking: LanguageLevel;
+  skill_level_listening: LanguageLevel;
+  skill_level_understanding: LanguageLevel;
+  goal_longterm: string;
+  goal_weekly: string;
+  study_buddy: string;
+  story_genre: string;
+  study_duration: number;
+  mother_tongue: Language;
+  motivation_type: string;
+  onboarding_completed: boolean;
+  context_menu_on_select: boolean;
 }
 
 export class SettingsController {
-    private pluginId: string;
-    private supabase: SupabaseClient;
-
-    constructor(supabase: SupabaseClient, pluginId: string) {
-        this.supabase = supabase;
-        this.pluginId = pluginId;
-    }
+  private pluginId: string;
+  private supabase: SupabaseClient;
 
-    private async fetchSettings(): Promise<any | null> {
-        const { data } = await this.supabase.from("plugin_settings").select("*").eq("plugin_id", this.pluginId)
+  constructor(supabase: SupabaseClient, pluginId: string) {
+    this.supabase = supabase;
+    this.pluginId = pluginId;
+  }
 
-        if (!data || data.length === 0) {
-            return null;
-        }
+  private async fetchSettings(): Promise<any | null> {
+    const { data } = await this.supabase.from("plugin_settings").select("*").eq("plugin_id", this.pluginId)
 
-        return data[0].settings;
+    if (!data || data.length === 0) {
+      return null;
     }
 
-    public async setSettings(settings: any): Promise<void> {
-        await this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
+    return data[0].settings;
+  }
+
+  public async setSettings(settings: any): Promise<void> {
+    await this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
+  }
+
+  public async getUserInfo(): Promise<UserInfo> {
+    const { data } = await this.supabase.from("profiles").select("*");
+
+    if (!data || data.length === 0) {
+      return {
+        mother_tongue: "en",
+        skill_level_listening: "Pre-A1",
+        skill_level_reading: "Pre-A1",
+        skill_level_speaking: "Pre-A1",
+        skill_level_writing: "Pre-A1",
+        skill_level_understanding: "Pre-A1",
+        skill_level_grammar: "Pre-A1",
+        goal_longterm: "",
+        goal_weekly: "",
+        study_buddy: "clarence",
+        story_genre: "adventure",
+        study_duration: 30,
+        motivation_type: "self-motivated",
+        onboarding_completed: false,
+        context_menu_on_select: false,
+      }
     }
 
-    public async getUserInfo(): Promise<UserInfo> {
-        const { data } = await this.supabase.from("profiles").select("*");
-
-        if (!data || data.length === 0) {
-            return {
-                motherTongue: "en",
-                xp: 0,
-                listening_level: "Pre-A1",
-                reading_level: "Pre-A1",
-                speaking_level: "Pre-A1",
-                writing_level: "Pre-A1",
-                understanding_level: "Pre-A1",
-                grammar_level: "Pre-A1",
-                longterm_goal: "",
-                motivation_type: "self-motivated",
-                study_buddy: "clarence",
-                preferred_genre: "adventure",
-                milestone: "",
-                settings: {
-                    contextMenuOnSelect: false,
-                }
-            }
-        }
-
-        return data[0];
+    return data[0].settings;
+  }
+
+  /**
+   * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+   * @param defaultSettings The default settings to use if no settings are found.
+   * @returns The settings for the plugin. 
+   */
+  public async getSettings<T extends object>(defaultSettings: T): Promise<T> {
+    const storedSettings = await this.fetchSettings() as T | null;
+
+    if (!storedSettings) {
+      await this.setSettings(defaultSettings);
+      return defaultSettings;
     }
 
-    /**
-     * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
-     * @param defaultSettings The default settings to use if no settings are found.
-     * @returns The settings for the plugin. 
-     */
-    public async getSettings<T extends object>(defaultSettings: T): Promise<T> {
-        const storedSettings = await this.fetchSettings() as T | null;
-
-        if (!storedSettings) {
-            await this.setSettings(defaultSettings);
-            return defaultSettings;
-        }
-
-        // Handle settings migration
-        const storedKeys = Object.keys(storedSettings);
-        const defaultKeys = Object.keys(defaultSettings);
-
-        if (storedKeys.length !== defaultKeys.length) {
-            const validStoredSettings = Object.fromEntries(
-                Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key))
-            );
-            const mergedSettings = { ...defaultSettings, ...validStoredSettings } as T;
-
-            await this.setSettings(mergedSettings);
-            return mergedSettings;
-        }
-
-        return storedSettings;
+    // Handle settings migration
+    const storedKeys = Object.keys(storedSettings);
+    const defaultKeys = Object.keys(defaultSettings);
+
+    if (storedKeys.length !== defaultKeys.length) {
+      const validStoredSettings = Object.fromEntries(
+        Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key))
+      );
+      const mergedSettings = { ...defaultSettings, ...validStoredSettings } as T;
+
+      await this.setSettings(mergedSettings);
+      return mergedSettings;
     }
+
+    return storedSettings;
+  }
 }

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('*');
@@ -24,8 +12,9 @@ export async function getPlugins(supabase: SupabaseClient): Promise<Plugin[]> {
     return (data || []).map((plugin: any) => ({
         id: plugin.id,
         title: plugin.title,
+        description: plugin.description,
         icon_url: plugin.icon_url,
-        website: plugin.website,
+        endpoint: plugin.endpoint,
         context_menu_actions: plugin.context_menu_actions,
         plugin_pages: plugin.plugin_pages,
         sidebar_pages: plugin.sidebar_pages,

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

@@ -1,10 +1,7 @@
 // Core functionality exports
-export * from "./controller/AIController";
-export * from "./controller/SharedContentController";
-export * from "./controller/SettingsController";
 export * from "./plugin/RimoriClient";
 export * from "./plugin/PluginController";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./worker/WorkerSetup";
-export * from "./plugin/fromRimori/EventBus";
+export * from "./utils/Language";