@rimori/client 1.0.4 → 1.1.0

package/dist/controller/SettingsController.js

@@ -12,50 +12,55 @@ export class SettingsController {
         this.supabase = supabase;
         this.pluginId = pluginId;
     }
-    getSettingsType(genericSettings) {
-        return genericSettings || "plugin";
-    }
-    fetchSettings(type) {
+    fetchSettings() {
         return __awaiter(this, void 0, void 0, function* () {
-            const pluginId = type === "plugin" ? this.pluginId : type;
-            const { data } = yield this.supabase.from("plugin_settings").select("*").eq("plugin_id", pluginId);
+            const { data } = yield this.supabase.from("plugin_settings").select("*").eq("plugin_id", this.pluginId);
             if (!data || data.length === 0) {
                 return null;
             }
             return data[0].settings;
         });
     }
-    saveSettings(settings, type) {
+    setSettings(settings) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (type !== "plugin") {
-                throw new Error(`Cannot modify ${type} settings`);
-            }
             yield this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
         });
     }
     getUserInfo() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.getSettings({
-                motherTongue: "sv",
-                languageLevel: "A1",
-                contextMenuOnSelect: true,
-            }, "user");
+            const { data } = yield 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,
+                };
+            }
+            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.
-     * @param genericSettings The type of settings to get.
      * @returns The settings for the plugin.
      */
-    getSettings(defaultSettings, genericSettings) {
+    getSettings(defaultSettings) {
         return __awaiter(this, void 0, void 0, function* () {
-            const type = this.getSettingsType(genericSettings);
-            const storedSettings = yield this.fetchSettings(type);
+            const storedSettings = yield this.fetchSettings();
             if (!storedSettings) {
-                if (type === "plugin") {
-                    yield this.saveSettings(defaultSettings, type);
-                }
+                yield this.setSettings(defaultSettings);
                 return defaultSettings;
             }
             // Handle settings migration
@@ -64,18 +69,10 @@ export class SettingsController {
             if (storedKeys.length !== defaultKeys.length) {
                 const validStoredSettings = Object.fromEntries(Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key)));
                 const mergedSettings = Object.assign(Object.assign({}, defaultSettings), validStoredSettings);
-                if (type === "plugin") {
-                    yield this.saveSettings(mergedSettings, type);
-                }
+                yield this.setSettings(mergedSettings);
                 return mergedSettings;
             }
             return storedSettings;
         });
     }
-    setSettings(settings, genericSettings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const type = this.getSettingsType(genericSettings);
-            yield this.saveSettings(settings, type);
-        });
-    }
 }

package/dist/controller/SharedContentController.d.ts

@@ -1,22 +1,69 @@
-import { ObjectRequest } from "./ObjectController";
+import { SupabaseClient } from '@supabase/supabase-js';
 import { RimoriClient } from "../plugin/RimoriClient";
-export interface BasicAssignment {
+import { ObjectRequest } from "./ObjectController";
+export interface BasicAssignment<T> {
     id: string;
     createdAt: Date;
     topic: string;
     createdBy: string;
     verified: boolean;
     keywords: any;
+    data: T;
+}
+export interface SharedContentObjectRequest extends ObjectRequest {
+    fixedProperties?: Record<string, string | number | boolean>;
 }
+export type SharedContentFilter = Record<string, string | number | boolean>;
 export declare class SharedContentController {
+    private supabase;
     private rimoriClient;
-    constructor(rimoriClient: RimoriClient);
-    fetchNewSharedContent<T, R = T & BasicAssignment>(type: string, generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest, filter?: {
-        column: string;
-        value: string | number | boolean;
-    }): Promise<R[]>;
-    private getReservedTopics;
-    private purifyStringArray;
-    getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T>;
-    completeSharedContent(type: string, assignmentId: string): Promise<void>;
+    constructor(supabase: SupabaseClient, 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.
+     */
+    getNewSharedContent<T>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, privateTopic?: boolean): Promise<BasicAssignment<T>>;
+    private getGeneratorInstructions;
+    private getCompletedTopics;
+    getSharedContent<T>(contentType: string, id: string): Promise<BasicAssignment<T>>;
+    completeSharedContent(contentType: string, assignmentId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<BasicAssignment<T>[]>;
+    /**
+     * 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.
+     */
+    createSharedContent<T>({ contentType, topic, keywords, data, privateTopic }: SharedContent<T>): Promise<BasicAssignment<T>>;
+    /**
+     * 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.
+     */
+    updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<BasicAssignment<T>>;
+}
+export interface SharedContent<T> {
+    contentType: string;
+    topic: string;
+    keywords: string[];
+    data: T;
+    privateTopic?: boolean;
 }

package/dist/controller/SharedContentController.js

@@ -7,50 +7,185 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { v4 as uuidv4 } from 'uuid';
 export class SharedContentController {
-    constructor(rimoriClient) {
+    constructor(supabase, rimoriClient) {
+        this.supabase = supabase;
         this.rimoriClient = rimoriClient;
     }
-    fetchNewSharedContent(type, generatorInstructions, filter) {
+    /**
+     * 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.
+     */
+    getNewSharedContent(contentType, generatorInstructions, 
+    //this filter is there if the content should be filtered additionally by a column and value
+    filter, privateTopic) {
         return __awaiter(this, void 0, void 0, function* () {
-            const queryParameter = { filter_column: (filter === null || filter === void 0 ? void 0 : filter.column) || null, filter_value: (filter === null || filter === void 0 ? void 0 : filter.value) || null, unread: true };
-            const { data: newAssignments } = yield this.rimoriClient.db.rpc(type + "_entries", queryParameter);
+            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 } = yield 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) {
-                return newAssignments;
+                const index = Math.floor(Math.random() * newAssignments.length);
+                return newAssignments[index];
             }
             // generate new assignments
-            const { data: oldAssignments } = yield this.rimoriClient.db.rpc(type + "_entries", Object.assign(Object.assign({}, queryParameter), { unread: false }));
-            console.log('oldAssignments:', oldAssignments);
-            const reservedTopics = this.getReservedTopics(oldAssignments);
-            const request = yield generatorInstructions(reservedTopics);
-            if (!request.tool.keywords || !request.tool.topic) {
-                throw new Error("topic or keywords not found in the request schema");
-            }
-            const instructions = yield this.rimoriClient.llm.getObject(request);
+            const fullInstructions = yield this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+            console.log('fullInstructions:', fullInstructions);
+            const instructions = yield this.rimoriClient.llm.getObject(fullInstructions);
             console.log('instructions:', instructions);
-            const preparedData = Object.assign(Object.assign({ id: uuidv4() }, instructions), { keywords: this.purifyStringArray(instructions.keywords) });
-            return yield this.rimoriClient.db.from(type).insert(preparedData).then(() => [preparedData]);
+            const { data: newAssignment, error: insertError } = yield this.supabase.from("shared_content").insert({
+                private: privateTopic,
+                content_type: contentType,
+                topic: instructions.topic,
+                keywords: instructions.keywords.map(({ text }) => text),
+                data: Object.assign(Object.assign(Object.assign({}, 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];
+        });
+    }
+    getGeneratorInstructions(contentType, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const completedTopics = yield 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;
+        });
+    }
+    getCompletedTopics(contentType, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            }
+            const { data: oldAssignments, error } = yield query;
+            if (error) {
+                console.error('error fetching old assignments:', error);
+                return [];
+            }
+            return oldAssignments.map(({ topic, keywords }) => `${topic}(${keywords.join(',')})`);
         });
     }
-    getReservedTopics(oldAssignments) {
-        return oldAssignments.map(({ topic, keywords }) => {
-            const keywordTexts = this.purifyStringArray(keywords).join(',');
-            return `${topic}(${keywordTexts})`;
+    getSharedContent(contentType, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield 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;
         });
     }
-    purifyStringArray(array) {
-        return array.map(({ text }) => text);
+    completeSharedContent(contentType, assignmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.supabase.from("shared_content_completed").insert({ content_type: contentType, id: assignmentId });
+        });
     }
-    getSharedContent(type, id) {
+    /**
+     * 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.
+     */
+    getSharedContentList(contentType, filter, limit) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.rimoriClient.db.from(type).select().eq('id', id).single();
+            const query = this.supabase.from("shared_content").select("*").eq('content_type', contentType).limit(limit !== null && limit !== void 0 ? limit : 30);
+            if (filter) {
+                query.contains('data', filter);
+            }
+            const { data, error } = yield query;
+            if (error) {
+                console.error('error fetching shared content:', error);
+                throw new Error('error fetching shared content');
+            }
+            return data;
         });
     }
-    completeSharedContent(type, assignmentId) {
+    /**
+     * 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.
+     */
+    createSharedContent(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contentType, topic, keywords, data, privateTopic }) {
+            const { data: newContent, error } = yield 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.
+     */
+    updateSharedContent(id, updates) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.rimoriClient.db.from(type + "_result").insert({ assignment_id: assignmentId });
+            const updateData = {};
+            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 } = yield 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];
         });
     }
 }

package/dist/controller/SidePluginController.d.ts

@@ -1,14 +1,3 @@
 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 declare function getPlugins(supabase: SupabaseClient): Promise<Plugin[]>;

package/dist/core/components/ContextMenu.d.ts

@@ -0,0 +1,10 @@
+import { RimoriClient } from "../../plugin/RimoriClient";
+export interface Position {
+    x: number;
+    y: number;
+    text?: string;
+}
+declare const ContextMenu: ({ client }: {
+    client: RimoriClient;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export default ContextMenu;

package/dist/core/components/ContextMenu.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useRef } from "react";
+import { EventBus } from "../../plugin/fromRimori/EventBus";
+const ContextMenu = ({ client }) => {
+    const [isOpen, setIsOpen] = useState(false);
+    const [actions, setActions] = useState([]);
+    const [position, setPosition] = useState({ x: 0, y: 0 });
+    const [openOnTextSelect, setOpenOnTextSelect] = useState(false);
+    const menuRef = useRef(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("global.contextMenu.createActions", ({ data }) => {
+            setActions([...data.actions, ...actions]);
+        });
+    }, []);
+    useEffect(() => {
+        // Track mouse position globally
+        const handleMouseMove = (e) => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            if (isOpen && selectedText === position.text)
+                return;
+            setPosition({ x: e.clientX, y: e.clientY, text: selectedText });
+        };
+        const handleMouseUp = (e) => {
+            var _a, _b;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.toString().trim();
+            // Check if click is inside the context menu
+            if (menuRef.current && menuRef.current.contains(e.target)) {
+                // Don't close the menu if clicking inside
+                return;
+            }
+            // Prevent context menu on textarea or text input selection
+            const target = e.target;
+            const isTextInput = target && ((target.tagName === 'TEXTAREA') ||
+                (target.tagName === 'INPUT' && target.type === 'text'));
+            if (isTextInput) {
+                setIsOpen(false);
+                return;
+            }
+            if (e.button === 0 && isOpen) {
+                setIsOpen(false);
+                (_b = window.getSelection()) === null || _b === void 0 ? void 0 : _b.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 = () => {
+            var _a;
+            const selectedText = (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.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 (_jsx("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 }, children: actions.map((action, index) => (_jsx(MenuEntryItem, { icon: action.icon, text: action.text, onClick: () => {
+                var _a;
+                setIsOpen(false);
+                (_a = window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
+                client.event.emitSidebarAction(action.pluginId, action.actionKey, position.text);
+            } }, index))) }));
+};
+function MenuEntryItem(props) {
+    return _jsxs("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", children: [_jsx("span", { className: "flex-grow", children: props.icon }), _jsx("span", { className: "flex-grow", children: props.text })] });
+}
+export default ContextMenu;

package/dist/core.d.ts

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

package/dist/core.js

@@ -8,3 +8,5 @@ export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
 export * from "./worker/WorkerSetup";
 export * from "./plugin/fromRimori/EventBus";
+export * from "./plugin/AccomplishmentHandler";
+export * from "./utils/Language";

package/dist/hooks/UseChatHook.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { Tool, Message } from "../controller/AIController";
+import { Message, Tool } from "../controller/AIController";
 export declare function useChat(tools?: Tool[]): {
     messages: Message[];
     append: (appendMessages: Message[]) => void;

package/dist/plugin/AccomplishmentHandler.d.ts

@@ -0,0 +1,38 @@
+import { EventBusMessage } from "./fromRimori/EventBus";
+export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;
+export declare const skillCategories: readonly ["reading", "listening", "speaking", "writing", "learning", "community"];
+interface BaseAccomplishmentPayload {
+    type: "micro" | "macro";
+    skillCategory: (typeof skillCategories)[number];
+    accomplishmentKeyword: string;
+    description: string;
+    meta?: {
+        key: string;
+        value: string | number | boolean;
+        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 declare class AccomplishmentHandler {
+    private pluginId;
+    constructor(pluginId: string);
+    emitAccomplishment(payload: Omit<AccomplishmentPayload, "type">): void;
+    private validateAccomplishment;
+    private sanitizeAccomplishment;
+    private getDecoupledTopic;
+    /**
+     * 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: string | string[] | undefined, callback: (payload: EventBusMessage<AccomplishmentPayload>) => void): void;
+}
+export {};