@tuturuuu/ai 0.0.10

package/src/tools/context-builder.ts

@@ -0,0 +1,372 @@
+import type { SupabaseClient } from '@tuturuuu/supabase';
+import type { PermissionId } from '@tuturuuu/types';
+import type { MiraSoulConfig } from '../chat/mira-system-instruction';
+import { buildAiMemoryContext, resolveAiMemoryScope } from '../memory';
+
+/**
+ * Token budget for context injection (~4K tokens ≈ 16K chars).
+ * Each section is capped individually so one large section can't starve others.
+ */
+const MAX_CONTEXT_CHARS = 16_000;
+const SECTION_CHAR_LIMITS = {
+  soul: 2000,
+  tasks: 4000,
+  calendar: 3000,
+  finance: 2000,
+  memories: 3000,
+  meta: 500,
+} as const;
+
+type ContextOptions = {
+  userId: string;
+  wsId: string;
+  supabase: SupabaseClient;
+  timezone?: string;
+  withoutPermission?: (permission: PermissionId) => boolean;
+};
+
+export type MiraContextResult = {
+  /** Combined context string for injection into the prompt. */
+  contextString: string;
+  /** Raw soul data for use in buildMiraSystemInstruction. */
+  soul: MiraSoulConfig | null;
+  /** True when no soul config row exists (brand-new user). */
+  isFirstInteraction: boolean;
+};
+
+/**
+ * Builds a dynamic context string injected into Mira's system prompt.
+ * All data sources are fetched in parallel for performance.
+ *
+ * Returns the context string alongside the raw soul config so the
+ * caller can pass it to `buildMiraSystemInstruction()`.
+ */
+export async function buildMiraContext(
+  opts: ContextOptions
+): Promise<MiraContextResult> {
+  const { userId, wsId, supabase, timezone = 'UTC', withoutPermission } = opts;
+  const canReadCalendar = !withoutPermission?.('manage_calendar');
+  const canReadFinance = !withoutPermission?.('manage_finance');
+
+  let now = new Date();
+  try {
+    // If a valid timezone is provided, try to shift our "now" perspective
+    // to match the local calendar day for better "today" logic
+    const tzDateStr = new Intl.DateTimeFormat('en-US', {
+      timeZone: timezone,
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+    }).format(now);
+
+    // Parse the output back (MM/DD/YYYY, HH:mm:ss) to create a local-time equivalent Date
+    const [datePart, timePart] = tzDateStr.split(', ');
+    const [month, day, year] = datePart!.split('/');
+    const [hour, min, sec] = timePart!.split(':');
+    if (year && month && day && hour && min && sec) {
+      now = new Date(
+        parseInt(year, 10),
+        parseInt(month, 10) - 1,
+        parseInt(day, 10),
+        parseInt(hour, 10),
+        parseInt(min, 10),
+        parseInt(sec, 10)
+      );
+    }
+  } catch (err) {
+    console.warn(
+      'Failed to parse timezone for context builder, falling back to UTC',
+      err
+    );
+  }
+
+  const todayStart = new Date(now);
+  todayStart.setHours(0, 0, 0, 0);
+  const todayEnd = new Date(now);
+  todayEnd.setHours(23, 59, 59, 999);
+  const weekAhead = new Date(now);
+  weekAhead.setDate(weekAhead.getDate() + 7);
+
+  // Fetch all context sources in parallel
+  const [
+    soulResult,
+    tasksResult,
+    calendarResult,
+    walletsResult,
+    memoriesResult,
+  ] = await Promise.all([
+    // Soul config
+    supabase
+      .from('mira_soul')
+      .select('name, tone, personality, boundaries, vibe, chat_tone')
+      .eq('user_id', userId)
+      .maybeSingle(),
+
+    // Tasks: overdue + due today (via RPC)
+    supabase.rpc('get_user_accessible_tasks', {
+      p_user_id: userId,
+      p_ws_id: wsId,
+      p_include_deleted: false,
+      p_list_statuses: ['not_started', 'active'],
+    }),
+
+    // Calendar: next 7 days
+    canReadCalendar
+      ? supabase
+          .from('workspace_calendar_events')
+          .select('title, start_at, end_at, location')
+          .eq('ws_id', wsId)
+          .gte('start_at', now.toISOString())
+          .lte('start_at', weekAhead.toISOString())
+          .order('start_at', { ascending: true })
+          .limit(15)
+      : Promise.resolve({ data: null, error: null }),
+
+    // Wallets with balances
+    canReadFinance
+      ? supabase
+          .schema('private')
+          .from('workspace_wallets')
+          .select('name, currency, balance')
+          .eq('ws_id', wsId)
+          .limit(10)
+      : Promise.resolve({ data: null, error: null }),
+
+    // Mira AI memories, scoped to the current user + workspace.
+    buildAiMemoryContext({
+      limit: 15,
+      scope: resolveAiMemoryScope({
+        customId: `mira-context-${wsId}`,
+        product: 'mira',
+        source: 'mira_context',
+        surface: 'mira_context',
+        userId,
+        wsId,
+      }),
+    }).then((context) => ({ data: context, error: null })),
+  ]);
+
+  const sections: string[] = [];
+
+  // ── Soul / Personality ──
+  const soul = soulResult.data;
+  if (soul) {
+    const soulLines = [`Your name is ${soul.name || 'Mira'}.`];
+    if (soul.tone) soulLines.push(`Tone: ${soul.tone}.`);
+    if (soul.personality) soulLines.push(`Personality: ${soul.personality}`);
+    if (soul.boundaries) soulLines.push(`Boundaries: ${soul.boundaries}`);
+    if (soul.vibe) soulLines.push(`Vibe: ${soul.vibe}`);
+    if (soul.chat_tone) soulLines.push(`Chat tone: ${soul.chat_tone}.`);
+
+    sections.push(
+      truncateSection(
+        `## Your Identity\n${soulLines.join('\n')}`,
+        SECTION_CHAR_LIMITS.soul
+      )
+    );
+  }
+
+  // ── Meta ──
+  const formatterOptions: Intl.DateTimeFormatOptions = {
+    weekday: 'long',
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    timeZone: timezone,
+    timeZoneName: 'short',
+  };
+
+  let timeStr = now.toISOString();
+  let dateStr = now.toLocaleDateString('en-US');
+
+  try {
+    // Re-use real current time for the literal string output so it shows actual timezone
+    const realNow = new Date();
+    timeStr = realNow.toLocaleString('en-US', formatterOptions);
+    dateStr = realNow.toLocaleDateString('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      timeZone: timezone,
+    });
+  } catch (_) {
+    // Ignore formatting errors
+  }
+
+  const metaLines = [
+    `Current time: ${timeStr} (${timezone})`,
+    `Today: ${dateStr}`,
+  ];
+  sections.push(
+    truncateSection(
+      `## Context\n${metaLines.join('\n')}`,
+      SECTION_CHAR_LIMITS.meta
+    )
+  );
+
+  // ── Tasks ──
+  type RpcTask = {
+    task_id: string;
+    task_name: string;
+    task_priority: string | null;
+    task_end_date: string | null;
+    task_completed_at: string | null;
+    task_closed_at: string | null;
+  };
+
+  const allTasks = (tasksResult.data || []) as RpcTask[];
+  const activeTasks = allTasks.filter(
+    (t) => !t.task_completed_at && !t.task_closed_at
+  );
+
+  const overdueTasks = activeTasks
+    .filter((t) => t.task_end_date && t.task_end_date < now.toISOString())
+    .slice(0, 10);
+
+  const todayTasks = activeTasks
+    .filter(
+      (t) =>
+        t.task_end_date &&
+        t.task_end_date >= todayStart.toISOString() &&
+        t.task_end_date <= todayEnd.toISOString()
+    )
+    .slice(0, 10);
+
+  const upcomingTasks = activeTasks
+    .filter(
+      (t) =>
+        t.task_end_date &&
+        t.task_end_date > todayEnd.toISOString() &&
+        t.task_end_date <= weekAhead.toISOString()
+    )
+    .slice(0, 5);
+
+  if (overdueTasks.length || todayTasks.length || upcomingTasks.length) {
+    const taskLines: string[] = [`Total active tasks: ${activeTasks.length}`];
+
+    if (overdueTasks.length) {
+      taskLines.push(`\nOverdue (${overdueTasks.length}):`);
+      for (const t of overdueTasks) {
+        taskLines.push(
+          `- ${t.task_name}${t.task_priority ? ` [${t.task_priority}]` : ''} (due ${t.task_end_date})`
+        );
+      }
+    }
+
+    if (todayTasks.length) {
+      taskLines.push(`\nDue today (${todayTasks.length}):`);
+      for (const t of todayTasks) {
+        taskLines.push(
+          `- ${t.task_name}${t.task_priority ? ` [${t.task_priority}]` : ''}`
+        );
+      }
+    }
+
+    if (upcomingTasks.length) {
+      taskLines.push(`\nUpcoming this week (${upcomingTasks.length}):`);
+      for (const t of upcomingTasks) {
+        taskLines.push(`- ${t.task_name} (due ${t.task_end_date})`);
+      }
+    }
+
+    sections.push(
+      truncateSection(
+        `## Tasks\n${taskLines.join('\n')}`,
+        SECTION_CHAR_LIMITS.tasks
+      )
+    );
+  }
+
+  // ── Calendar ──
+  const events = calendarResult.data;
+  if (events?.length) {
+    const eventLines: string[] = [];
+    for (const e of events) {
+      const start = new Date(e.start_at);
+      const end = new Date(e.end_at);
+
+      let dateStr: string, timeStr: string;
+      try {
+        dateStr = start.toLocaleDateString('en-US', {
+          weekday: 'short',
+          month: 'short',
+          day: 'numeric',
+          timeZone: timezone,
+        });
+        timeStr = `${start.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', timeZone: timezone })}–${end.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', timeZone: timezone })}`;
+      } catch (_) {
+        dateStr = start.toLocaleDateString('en-US', {
+          weekday: 'short',
+          month: 'short',
+          day: 'numeric',
+        });
+        timeStr = `${start.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })}–${end.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })}`;
+      }
+      const loc = e.location ? ` @ ${e.location}` : '';
+      eventLines.push(`- ${dateStr} ${timeStr}: ${e.title}${loc}`);
+    }
+
+    sections.push(
+      truncateSection(
+        `## Calendar (next 7 days)\n${eventLines.join('\n')}`,
+        SECTION_CHAR_LIMITS.calendar
+      )
+    );
+  }
+
+  // ── Finance ──
+  const wallets = walletsResult.data;
+  if (wallets?.length) {
+    const walletLines = wallets.map(
+      (w: { name: string | null; balance: number | null; currency: string }) =>
+        `- ${w.name || 'Wallet'}: ${w.balance ?? 0} ${w.currency}`
+    );
+
+    sections.push(
+      truncateSection(
+        `## Wallets\n${walletLines.join('\n')}`,
+        SECTION_CHAR_LIMITS.finance
+      )
+    );
+  }
+
+  // ── Memories ──
+  const memories = memoriesResult.data?.trim();
+  if (memories) {
+    sections.push(truncateSection(memories, SECTION_CHAR_LIMITS.memories));
+  }
+
+  // Combine all sections, respecting total budget
+  let combined = sections.join('\n\n');
+  if (combined.length > MAX_CONTEXT_CHARS) {
+    combined = `${combined.slice(0, MAX_CONTEXT_CHARS)}\n[context truncated]`;
+  }
+
+  return {
+    contextString: combined,
+    soul: soul
+      ? {
+          name: soul.name ?? undefined,
+          tone: soul.tone,
+          personality: soul.personality,
+          boundaries: soul.boundaries,
+          vibe: soul.vibe,
+          chat_tone: soul.chat_tone,
+        }
+      : null,
+    isFirstInteraction: !soul,
+  };
+}
+
+/** Truncate a section to a char limit, adding an ellipsis marker */
+function truncateSection(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars - 20)}\n[...truncated]`;
+}

package/src/tools/core.ts

@@ -0,0 +1 @@
+export { tool } from 'ai';

package/src/tools/definitions/calendar.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { tool } from '../core';
+
+export const calendarToolDefinitions = {
+  get_upcoming_events: tool({
+    description:
+      'Get upcoming calendar events for the next N days. Events are automatically decrypted if E2EE is enabled.',
+    inputSchema: z.object({
+      days: z
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .optional()
+        .describe('Number of days to look ahead (default: 7)'),
+    }),
+  }),
+
+  create_event: tool({
+    description:
+      'Create a new calendar event. Events are automatically encrypted if E2EE is enabled.',
+    inputSchema: z
+      .object({
+        title: z.string().describe('Event title'),
+        startAt: z
+          .string()
+          .datetime({ offset: true })
+          .describe('Start time ISO 8601'),
+        endAt: z
+          .string()
+          .datetime({ offset: true })
+          .describe('End time ISO 8601'),
+        description: z
+          .string()
+          .nullish()
+          .describe('Event description, or null/omit'),
+        location: z.string().nullish().describe('Event location, or null/omit'),
+      })
+      .superRefine((value, ctx) => {
+        const startAt = new Date(value.startAt);
+        const endAt = new Date(value.endAt);
+
+        if (startAt >= endAt) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['endAt'],
+            message: 'endAt must be later than startAt',
+          });
+        }
+      }),
+  }),
+
+  update_event: tool({
+    description:
+      'Update an existing calendar event. Updated fields are encrypted automatically if E2EE is enabled.',
+    inputSchema: z
+      .object({
+        eventId: z.guid().describe('Event UUID'),
+        title: z.string().optional().describe('Updated event title'),
+        startAt: z.iso
+          .datetime({ offset: true })
+          .optional()
+          .describe('Updated start time ISO 8601'),
+        endAt: z.iso
+          .datetime({ offset: true })
+          .optional()
+          .describe('Updated end time ISO 8601'),
+        description: z
+          .string()
+          .nullish()
+          .describe('Updated event description, or null/omit'),
+        location: z
+          .string()
+          .nullish()
+          .describe('Updated event location, or null/omit'),
+      })
+      .refine(
+        (value) =>
+          value.title !== undefined ||
+          value.startAt !== undefined ||
+          value.endAt !== undefined ||
+          value.description !== undefined ||
+          value.location !== undefined,
+        { message: 'At least one field to update is required' }
+      ),
+  }),
+
+  delete_event: tool({
+    description: 'Delete a calendar event by ID.',
+    inputSchema: z.object({
+      eventId: z.guid().describe('Event UUID'),
+    }),
+  }),
+
+  check_e2ee_status: tool({
+    description:
+      'Check whether end-to-end encryption is enabled for calendar events in this workspace.',
+    inputSchema: z.object({}),
+  }),
+
+  enable_e2ee: tool({
+    description:
+      'Enable end-to-end encryption for calendar events. Once enabled, new events will be encrypted automatically.',
+    inputSchema: z.object({}),
+  }),
+} as const;

package/src/tools/definitions/finance.ts

@@ -0,0 +1,197 @@
+import { z } from 'zod';
+import { tool } from '../core';
+
+export const financeToolDefinitions = {
+  log_transaction: tool({
+    description:
+      'Log a financial transaction. Positive amount = income, negative = expense.',
+    inputSchema: z.object({
+      amount: z.number().describe('Amount (positive=income, negative=expense)'),
+      description: z.string().nullish().describe('What was this for?'),
+      walletId: z
+        .guid()
+        .nullish()
+        .describe('Wallet UUID. If null, uses the first wallet.'),
+    }),
+  }),
+
+  get_spending_summary: tool({
+    description: 'Get income/expense summary for the past N days.',
+    inputSchema: z.object({
+      days: z
+        .number()
+        .int()
+        .min(1)
+        .max(365)
+        .optional()
+        .describe('Number of past days to summarize (default: 30)'),
+    }),
+  }),
+
+  list_wallets: tool({
+    description: 'List all wallets in the workspace.',
+    inputSchema: z.object({}),
+  }),
+
+  create_wallet: tool({
+    description: 'Create a new wallet.',
+    inputSchema: z.object({
+      name: z.string().describe('Wallet name'),
+      currency: z.string().optional().describe('Currency code (e.g. USD, VND)'),
+      balance: z.number().optional().describe('Initial balance'),
+      type: z.string().optional().describe('Wallet type'),
+    }),
+  }),
+
+  update_wallet: tool({
+    description: 'Update wallet details.',
+    inputSchema: z.object({
+      walletId: z.guid().describe('Wallet UUID'),
+      name: z.string().optional().describe('New name'),
+      currency: z.string().optional().describe('New currency'),
+      balance: z.number().optional().describe('New balance'),
+      type: z.string().optional().describe('New wallet type'),
+    }),
+  }),
+
+  delete_wallet: tool({
+    description: 'Delete a wallet.',
+    inputSchema: z.object({
+      walletId: z.guid().describe('Wallet UUID'),
+    }),
+  }),
+
+  list_transactions: tool({
+    description: 'List transactions with optional filters.',
+    inputSchema: z.object({
+      walletId: z.guid().optional().describe('Filter by wallet UUID'),
+      categoryId: z.guid().optional().describe('Filter by category UUID'),
+      days: z
+        .number()
+        .int()
+        .min(1)
+        .max(365)
+        .optional()
+        .describe('Only last N days'),
+      limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe('Max results (default 50)'),
+    }),
+  }),
+
+  get_transaction: tool({
+    description: 'Get a single transaction by ID.',
+    inputSchema: z.object({
+      transactionId: z.guid().describe('Transaction UUID'),
+    }),
+  }),
+
+  update_transaction: tool({
+    description: 'Update a transaction.',
+    inputSchema: z.object({
+      transactionId: z.guid().describe('Transaction UUID'),
+      amount: z.number().optional().describe('New amount'),
+      description: z.string().optional().describe('New description'),
+      categoryId: z.guid().optional().describe('New category UUID'),
+      walletId: z.guid().optional().describe('New wallet UUID'),
+    }),
+  }),
+
+  delete_transaction: tool({
+    description: 'Delete a transaction.',
+    inputSchema: z.object({
+      transactionId: z.guid().describe('Transaction UUID'),
+    }),
+  }),
+
+  list_transaction_categories: tool({
+    description: 'List all transaction categories.',
+    inputSchema: z.object({}),
+  }),
+
+  create_transaction_category: tool({
+    description: 'Create a transaction category.',
+    inputSchema: z.object({
+      name: z.string().describe('Category name'),
+      isExpense: z
+        .boolean()
+        .optional()
+        .describe('Is this an expense category? Default true.'),
+    }),
+  }),
+
+  update_transaction_category: tool({
+    description: 'Update a transaction category.',
+    inputSchema: z.object({
+      categoryId: z.guid().describe('Category UUID'),
+      name: z.string().optional().describe('New name'),
+      isExpense: z.boolean().optional().describe('Is expense?'),
+    }),
+  }),
+
+  delete_transaction_category: tool({
+    description: 'Delete a transaction category.',
+    inputSchema: z.object({
+      categoryId: z.guid().describe('Category UUID'),
+    }),
+  }),
+
+  list_transaction_tags: tool({
+    description: 'List all transaction tags.',
+    inputSchema: z.object({}),
+  }),
+
+  create_transaction_tag: tool({
+    description: 'Create a transaction tag.',
+    inputSchema: z.object({
+      name: z.string().describe('Tag name'),
+      color: z
+        .string()
+        .regex(/^[#][0-9a-fA-F]{3,8}$/)
+        .optional()
+        .describe('Color hex'),
+      description: z.string().optional().describe('Tag description'),
+    }),
+  }),
+
+  update_transaction_tag: tool({
+    description: 'Update a transaction tag.',
+    inputSchema: z.object({
+      tagId: z.guid().describe('Tag UUID'),
+      name: z.string().optional().describe('New name'),
+      color: z
+        .string()
+        .regex(/^[#][0-9a-fA-F]{3,8}$/)
+        .optional()
+        .describe('New color'),
+      description: z.string().optional().describe('New description'),
+    }),
+  }),
+
+  delete_transaction_tag: tool({
+    description: 'Delete a transaction tag.',
+    inputSchema: z.object({
+      tagId: z.guid().describe('Tag UUID'),
+    }),
+  }),
+
+  set_default_currency: tool({
+    description:
+      'Set the default currency for the workspace. Use standard currency codes.',
+    inputSchema: z.object({
+      currency: z
+        .string()
+        .regex(/^[A-Z]{3}$/, {
+          message:
+            'Currency must be a valid ISO-4217 code (3 uppercase letters)',
+        })
+        .describe(
+          'Currency code in ISO-4217 format (exactly 3 uppercase letters, e.g. USD, VND, EUR, JPY, GBP, KRW, THB, SGD)'
+        ),
+    }),
+  }),
+} as const;