@rimori/client 2.4.0 → 2.5.0-next.1

package/src/controller/AIController.ts

@@ -1,295 +0,0 @@
-import { Tool } from '../fromRimori/PluginTypes';
-
-export interface ToolInvocation {
-  toolCallId: string;
-  toolName: string;
-  args: Record<string, string>;
-}
-
-export interface Message {
-  id?: string;
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-  toolCalls?: ToolInvocation[];
-}
-
-export async function generateText(backendUrl: string, messages: Message[], tools: Tool[], token: string) {
-  const response = await fetch(`${backendUrl}/ai/llm`, {
-    method: 'POST',
-    body: JSON.stringify({ messages, tools }),
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-  });
-
-  return await response.json();
-}
-
-export type OnLLMResponse = (
-  id: string,
-  response: string,
-  finished: boolean,
-  toolInvocations?: ToolInvocation[],
-) => void;
-
-export async function streamChatGPT(
-  backendUrl: string,
-  messages: Message[],
-  tools: Tool[],
-  onResponse: OnLLMResponse,
-  token: string,
-) {
-  const messageId = Math.random().toString(36).substring(3);
-  const currentMessages: Message[] = [...messages];
-
-  console.log('Starting streamChatGPT with:', {
-    messageId,
-    messageCount: messages.length,
-    toolCount: tools.length,
-    backendUrl,
-  });
-
-  while (true) {
-    const messagesForApi = currentMessages.map(({ id, ...rest }) => rest);
-
-    try {
-      const response = await fetch(`${backendUrl}/ai/llm`, {
-        method: 'POST',
-        body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-
-      if (!response.body) {
-        console.error('No response body.');
-        return;
-      }
-
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder('utf-8');
-
-      let content = '';
-      let done = false;
-      const toolInvocations: { toolCallId: string; toolName: string; args: any }[] = [];
-      let currentTextId = '';
-      let isToolCallMode = false;
-      let buffer = ''; // Buffer for incomplete chunks
-
-      while (!done) {
-        const { value, done: readerDone } = await reader.read();
-
-        if (value) {
-          const chunk = decoder.decode(value, { stream: true });
-          buffer += chunk;
-
-          // Split by lines, but handle incomplete lines
-          const lines = buffer.split('\n');
-
-          // Keep the last line in buffer if it's incomplete
-          if (lines.length > 1) {
-            buffer = lines.pop() || '';
-          }
-
-          for (const line of lines) {
-            if (line.trim() === '') continue;
-
-            // Handle the new streaming format
-            if (line.startsWith('data: ')) {
-              const dataStr = line.substring(6); // Remove 'data: ' prefix
-
-              // Handle [DONE] marker
-              if (dataStr === '[DONE]') {
-                done = true;
-                break;
-              }
-
-              try {
-                const data = JSON.parse(dataStr);
-
-                // Log the first message to understand the format
-                if (!content && !isToolCallMode) {
-                  // console.log('First stream message received:', data);
-                }
-
-                switch (data.type) {
-                  case 'start':
-                    // Stream started, no action needed
-                    // console.log('Stream started');
-                    break;
-
-                  case 'start-step':
-                    // Step started, no action needed
-                    // console.log('Step started');
-                    break;
-
-                  case 'reasoning-start':
-                    // Reasoning started, no action needed
-                    console.log('Reasoning started:', data.id);
-                    break;
-
-                  case 'reasoning-end':
-                    // Reasoning ended, no action needed
-                    console.log('Reasoning ended:', data.id);
-                    break;
-
-                  case 'text-start':
-                    // Text generation started, store the ID
-                    currentTextId = data.id;
-                    console.log('Text generation started:', data.id);
-                    break;
-
-                  case 'text-delta':
-                    // Text delta received, append to content
-                    if (data.delta) {
-                      content += data.delta;
-                      onResponse(messageId, content, false);
-                    }
-                    break;
-
-                  case 'text-end':
-                    // Text generation ended
-                    console.log('Text generation ended:', data.id);
-                    break;
-
-                  case 'finish-step':
-                    // Step finished, no action needed
-                    // console.log('Step finished');
-                    break;
-
-                  case 'finish':
-                    // Stream finished
-                    // console.log('Stream finished');
-                    done = true;
-                    break;
-
-                  // Additional message types that might be present in the AI library
-                  case 'tool-call':
-                  case 'tool-input-available': //for now input calls should be handled the same way as tool calls
-                    // Tool call initiated
-                    console.log('Tool call initiated:', data);
-                    isToolCallMode = true;
-                    if (data.toolCallId && data.toolName && (data.args || data.input)) {
-                      toolInvocations.push({
-                        toolCallId: data.toolCallId,
-                        toolName: data.toolName,
-                        args: data.args || data.input,
-                      });
-                    }
-                    break;
-
-                  case 'tool-input-delta': //for now input calls should be handled the same way as tool calls
-                  case 'tool-call-delta':
-                    // Tool call delta (for streaming tool calls)
-                    console.log('Tool call delta:', data);
-                    break;
-
-                  case 'tool-call-end':
-                    // Tool call completed
-                    console.log('Tool call completed:', data);
-                    break;
-
-                  case 'tool-result':
-                    // Tool execution result
-                    console.log('Tool result:', data);
-                    break;
-
-                  case 'error':
-                    // Error occurred
-                    console.error('Stream error:', data);
-                    break;
-
-                  case 'usage':
-                    // Usage information
-                    console.log('Usage info:', data);
-                    break;
-
-                  case 'model':
-                    // Model information
-                    console.log('Model info:', data);
-                    break;
-
-                  case 'stop':
-                    // Stop signal
-                    console.log('Stop signal received');
-                    done = true;
-                    break;
-
-                  default:
-                    // Unknown type, log for debugging
-                    console.log('Unknown stream type:', data.type, data);
-                    break;
-                }
-              } catch (error) {
-                console.error('Error parsing stream data:', error, dataStr);
-              }
-            }
-          }
-        }
-
-        if (readerDone) {
-          done = true;
-        }
-      }
-
-      // Check if we have content or if this was a tool call response
-      if (content || toolInvocations.length > 0) {
-        currentMessages.push({
-          id: messageId,
-          role: 'assistant',
-          content: content,
-          toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
-        });
-      }
-
-      // Handle tool call scenario if tools were provided
-      if (tools.length > 0 && toolInvocations.length > 0) {
-        console.log('Tool calls detected, executing tools...');
-
-        const toolResults: Message[] = [];
-        for (const toolInvocation of toolInvocations) {
-          const tool = tools.find((t) => t.name === toolInvocation.toolName);
-          if (tool && tool.execute) {
-            try {
-              const result = await tool.execute(toolInvocation.args);
-              toolResults.push({
-                id: Math.random().toString(36).substring(3),
-                role: 'user',
-                content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
-              });
-            } catch (error) {
-              console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
-              toolResults.push({
-                id: Math.random().toString(36).substring(3),
-                role: 'user',
-                content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
-              });
-            }
-          }
-        }
-
-        if (toolResults.length > 0) {
-          currentMessages.push(...toolResults);
-          // Continue the loop to handle the next response
-          continue;
-        }
-      }
-
-      // Since the new format doesn't seem to support tool calls in the same way,
-      // we'll assume the stream is complete when we reach the end
-      // If tools are provided and no content was generated, this might indicate a tool call
-      if (tools.length > 0 && !content && !isToolCallMode) {
-        // This might be a tool call scenario, but we need more information
-        // For now, we'll just finish the stream
-        console.log('No content generated, but tools provided - might be tool call scenario');
-      }
-
-      onResponse(messageId, content, true, toolInvocations);
-      return;
-    } catch (error) {
-      console.error('Error in streamChatGPT:', error);
-      onResponse(messageId, `Error: ${error instanceof Error ? error.message : String(error)}`, true, []);
-      return;
-    }
-  }
-}

package/src/controller/AccomplishmentController.ts

@@ -1,188 +0,0 @@
-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 AccomplishmentController {
-  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;
-
-    if (!this.validateAccomplishment(accomplishmentPayload)) {
-      return;
-    }
-
-    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): boolean {
-    if (!skillCategories.includes(payload.skillCategory)) {
-      throw new Error(`Invalid skill category: ${payload.skillCategory}`);
-    }
-
-    //regex validate accomplishmentKeyword
-    if (!/^[0-9a-z_.-]+$/.test(payload.accomplishmentKeyword)) {
-      throw new Error(
-        `The accomplishment keyword: ${payload.accomplishmentKeyword} is invalid. Only lowercase letters, minuses, underscores and periods 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);
-    }
-
-    // disabled detection temporarelly to determine how long exercises normally are
-    //durationMinutes is required
-    // if (payload.type === 'macro' && payload.durationMinutes < 4) {
-    //   console.warn('The duration must be at least 4 minutes');
-    //   return false;
-    // }
-
-    //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');
-        }
-      });
-    }
-    return true;
-  }
-
-  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",
-//     },
-//   ],
-// });

package/src/controller/AudioController.ts

@@ -1,64 +0,0 @@
-import { EventBus } from '../fromRimori/EventBus';
-
-/**
- * AudioController is a class that provides methods to record audio. It is a wrapper around the Capacitor Voice Recorder plugin. For more information, see https://github.com/tchvu3/capacitor-voice-recorder.
- *
- * @example
- * const audioController = new AudioController();
- * await audioController.startRecording();
- */
-export class AudioController {
-  private pluginId: string;
-
-  constructor(pluginId: string) {
-    this.pluginId = pluginId;
-  }
-
-  /**
-   * Start the recording.
-   *
-   * @example
-   * const audioController = new AudioController();
-   * await audioController.startRecording();
-   * @returns void
-   */
-  public async startRecording(): Promise<void> {
-    EventBus.emit(this.pluginId, 'global.microphone.triggerStartRecording');
-  }
-
-  /**
-   * Stop the recording and return the audio data.
-   * @returns The audio data.
-   *
-   * @example
-   * const audioRef = new Audio(`data:${mimeType};base64,${base64Sound}`)
-   * audioRef.oncanplaythrough = () => audioRef.play()
-   * audioRef.load()
-   */
-  public async stopRecording(): Promise<{ recording: Blob; msDuration: number; mimeType: string }> {
-    const result = await EventBus.request<{ recording: Blob; msDuration: number; mimeType: string }>(
-      this.pluginId,
-      'global.microphone.triggerStopRecording',
-    );
-
-    return result.data;
-  }
-
-  public async pauseRecording(): Promise<boolean> {
-    const result = await EventBus.request<boolean>(this.pluginId, 'global.microphone.triggerPauseRecording');
-    return result.data;
-  }
-
-  public async resumeRecording(): Promise<boolean> {
-    const result = await EventBus.request<boolean>(this.pluginId, 'global.microphone.triggerResumeRecording');
-    return result.data;
-  }
-
-  public async getCurrentStatus(): Promise<'RECORDING' | 'PAUSED' | 'NONE'> {
-    const result = await EventBus.request<'RECORDING' | 'PAUSED' | 'NONE'>(
-      this.pluginId,
-      'global.microphone.triggerGetCurrentStatus',
-    );
-    return result.data;
-  }
-}

package/src/controller/ExerciseController.ts

@@ -1,117 +0,0 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from '../plugin/RimoriClient';
-
-export type TriggerAction = { action_key: string } & Record<string, string | number | boolean>;
-
-export interface CreateExerciseParams {
-  plugin_id: string;
-  start_date: string;
-  end_date: string;
-  trigger_action: TriggerAction;
-  name: string;
-  description: string;
-  estimated_duration: number;
-  achievement_topic: string; // Required: Topic in format "skillCategory.accomplishmentKeyword" for matching accomplishments
-}
-
-export interface Exercise {
-  id: string;
-  plugin_id: string;
-  start_date: string;
-  end_date: string;
-  trigger_action: TriggerAction;
-  // topic that identifies the accomplishment that the exercise is related to
-  achievement_topic: string;
-  name: string;
-  description: string;
-  estimated_duration: number;
-  created_at?: string;
-  updated_at?: string;
-}
-
-export class ExerciseController {
-  private supabase: SupabaseClient;
-  private rimoriClient: RimoriClient;
-
-  constructor(supabase: SupabaseClient, rimoriClient: RimoriClient) {
-    this.supabase = supabase;
-    this.rimoriClient = rimoriClient;
-  }
-
-  /**
-   * Fetches weekly exercises from the weekly_exercises view.
-   * Shows exercises for the current week that haven't expired.
-   * @returns Array of exercise objects.
-   */
-  public async viewWeeklyExercises(): Promise<Exercise[]> {
-    const { data, error } = await this.supabase.from('weekly_exercises').select('*');
-
-    if (error) {
-      throw new Error(`Failed to fetch weekly exercises: ${error.message}`);
-    }
-
-    return data || [];
-  }
-
-  /**
-   * Creates multiple exercises via the backend API.
-   * All requests are made in parallel but only one event is emitted.
-   * @param token The token to use for authentication.
-   * @param backendUrl The URL of the backend API.
-   * @param exercises Exercise creation parameters.
-   * @returns Created exercise objects.
-   */
-  public async addExercise(token: string, backendUrl: string, exercises: CreateExerciseParams[]): Promise<Exercise[]> {
-    const responses = await Promise.all(
-      exercises.map(async (exercise) => {
-        const response = await fetch(`${backendUrl}/exercises`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${token}`,
-          },
-          body: JSON.stringify(exercise),
-        });
-
-        if (!response.ok) {
-          const errorText = await response.text();
-          throw new Error(`Failed to create exercise: ${errorText}`);
-        }
-
-        return await response.json();
-      }),
-    );
-
-    this.rimoriClient.event.emit('global.exercises.triggerChange');
-
-    return responses;
-  }
-
-  /**
-   * Deletes an exercise via the backend API.
-   * @param token The token to use for authentication.
-   * @param backendUrl The URL of the backend API.
-   * @param exerciseId The exercise ID to delete.
-   * @returns Success status.
-   */
-  public async deleteExercise(
-    token: string,
-    backendUrl: string,
-    id: string,
-  ): Promise<{ success: boolean; message: string }> {
-    const response = await fetch(`${backendUrl}/exercises/${id}`, {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Failed to delete exercise: ${errorText}`);
-    }
-    this.rimoriClient.event.emit('global.exercises.triggerChange');
-
-    return await response.json();
-  }
-}