@tuturuuu/ai 0.0.10

package/src/tools/executors/timer/timer-session-mutations.ts

@@ -0,0 +1,10 @@
+export {
+  executeCreateTimeTrackingEntry,
+  executeStartTimer,
+  executeStopTimer,
+} from './timer-session-lifecycle';
+export { executeMoveTimeTrackingSession } from './timer-session-queries';
+export {
+  executeDeleteTimeTrackingSession,
+  executeUpdateTimeTrackingSession,
+} from './timer-session-updates';

package/src/tools/executors/timer/timer-session-queries.ts

@@ -0,0 +1,153 @@
+import { verifyWorkspaceMembershipType } from '@tuturuuu/utils/workspace-helper';
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { coerceOptionalString } from './timer-helpers';
+import {
+  getZodErrorMessage,
+  type MoveTimeTrackingSessionArgs,
+  moveTimeTrackingSessionArgsSchema,
+} from './timer-mutation-schemas';
+import {
+  type MoveTimeTrackingSessionResult,
+  toTimerSession,
+} from './timer-mutation-types';
+
+export async function executeMoveTimeTrackingSession(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+): Promise<MoveTimeTrackingSessionResult> {
+  let parsedArgs: MoveTimeTrackingSessionArgs;
+  try {
+    parsedArgs = moveTimeTrackingSessionArgsSchema.parse(args);
+  } catch (error) {
+    return { error: getZodErrorMessage(error) };
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const sessionId =
+    coerceOptionalString(parsedArgs.sessionId) ??
+    coerceOptionalString(parsedArgs.id);
+  const targetWorkspaceId = coerceOptionalString(parsedArgs.targetWorkspaceId);
+
+  if (!sessionId) return { error: 'sessionId is required' };
+  if (!targetWorkspaceId) return { error: 'targetWorkspaceId is required' };
+
+  const [sourceCheck, targetCheck] = await Promise.all([
+    verifyWorkspaceMembershipType({
+      wsId: workspaceId,
+      userId: ctx.userId,
+      supabase: ctx.supabase,
+      requiredType: 'MEMBER',
+    }),
+    verifyWorkspaceMembershipType({
+      wsId: targetWorkspaceId,
+      userId: ctx.userId,
+      supabase: ctx.supabase,
+      requiredType: 'MEMBER',
+    }),
+  ]);
+
+  if (
+    sourceCheck.error === 'membership_lookup_failed' ||
+    targetCheck.error === 'membership_lookup_failed'
+  ) {
+    return { error: 'Could not verify workspace access' };
+  }
+
+  if (!sourceCheck.ok) {
+    return { error: 'Source workspace access denied' };
+  }
+
+  if (!targetCheck.ok) {
+    return { error: 'Target workspace access denied' };
+  }
+
+  const { data: session, error: sessionError } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .select(
+      `
+      *,
+      category:time_tracking_categories(id, name),
+      task:tasks(id, name)
+    `
+    )
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .maybeSingle();
+
+  if (sessionError) return { error: sessionError.message };
+  if (!session) return { error: 'Session not found' };
+  if (session.is_running) {
+    return {
+      error: 'Cannot move running sessions. Please stop the session first.',
+    };
+  }
+
+  let targetCategoryId: string | null = null;
+  if (session.category?.name) {
+    const { data: targetCategory, error: targetCategoryError } =
+      await ctx.supabase
+        .from('time_tracking_categories')
+        .select('id')
+        .eq('ws_id', targetWorkspaceId)
+        .eq('name', session.category.name)
+        .limit(1)
+        .maybeSingle();
+
+    if (targetCategoryError) {
+      return {
+        error: `Failed to resolve matching category in target workspace: ${targetCategoryError.message}`,
+      };
+    }
+
+    targetCategoryId = targetCategory?.id ?? null;
+  }
+
+  let targetTaskId: string | null = null;
+  if (session.task?.name) {
+    const { data: targetTask, error: targetTaskError } = await ctx.supabase
+      .from('tasks')
+      .select('id, list:task_lists!inner(board:workspace_boards!inner(ws_id))')
+      .eq('list.board.ws_id', targetWorkspaceId)
+      .eq('name', session.task.name)
+      .limit(1)
+      .maybeSingle();
+
+    if (targetTaskError) {
+      return {
+        error: `Failed to resolve matching task in target workspace: ${targetTaskError.message}`,
+      };
+    }
+
+    targetTaskId = targetTask?.id ?? null;
+  }
+
+  const { data: movedSession, error: moveError } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .update({
+      ws_id: targetWorkspaceId,
+      category_id: targetCategoryId,
+      task_id: targetTaskId,
+      updated_at: new Date().toISOString(),
+    })
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .select(
+      `
+      *,
+      category:time_tracking_categories(*),
+      task:tasks(*)
+    `
+    )
+    .single();
+
+  if (moveError) return { error: moveError.message };
+
+  return {
+    success: true,
+    message: 'Session moved successfully',
+    session: toTimerSession(movedSession as Record<string, unknown>),
+  };
+}

package/src/tools/executors/timer/timer-session-updates.ts

@@ -0,0 +1,200 @@
+import type { TablesUpdate } from '@tuturuuu/types';
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { hasTaskAccess, hasTimeTrackingCategoryAccess } from '../scope-helpers';
+import {
+  coerceOptionalString,
+  MIN_DURATION_SECONDS,
+  parseFlexibleDateTime,
+} from './timer-helpers';
+import {
+  type DeleteTimeTrackingSessionArgs,
+  deleteTimeTrackingSessionArgsSchema,
+  getZodErrorMessage,
+  type UpdateTimeTrackingSessionArgs,
+  updateTimeTrackingSessionArgsSchema,
+} from './timer-mutation-schemas';
+import {
+  type DeleteTimeTrackingSessionResult,
+  toTimerSession,
+  type UpdateTimeTrackingSessionResult,
+} from './timer-mutation-types';
+
+export async function executeUpdateTimeTrackingSession(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+): Promise<UpdateTimeTrackingSessionResult> {
+  let parsedArgs: UpdateTimeTrackingSessionArgs;
+  try {
+    parsedArgs = updateTimeTrackingSessionArgsSchema.parse(args);
+  } catch (error) {
+    return { error: getZodErrorMessage(error) };
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const sessionId =
+    coerceOptionalString(parsedArgs.sessionId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!sessionId) return { error: 'sessionId is required' };
+
+  const { data: existing, error: existingError } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .select('*')
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .maybeSingle();
+
+  if (existingError) return { error: existingError.message };
+  if (!existing) return { error: 'Session not found' };
+
+  const updates: TablesUpdate<'time_tracking_sessions'> = {};
+  if (parsedArgs.title !== undefined) {
+    if (typeof parsedArgs.title !== 'string') {
+      return { error: 'title must be a string' };
+    }
+
+    const normalizedTitle = parsedArgs.title.trim();
+    if (normalizedTitle.length === 0) {
+      return { error: 'title cannot be blank' };
+    }
+    updates.title = normalizedTitle;
+  }
+  if (parsedArgs.description !== undefined) {
+    updates.description = coerceOptionalString(parsedArgs.description);
+  }
+  if (parsedArgs.categoryId !== undefined) {
+    const categoryId = coerceOptionalString(parsedArgs.categoryId);
+
+    if (categoryId) {
+      try {
+        if (!(await hasTimeTrackingCategoryAccess(ctx, categoryId))) {
+          return { error: 'Category not found in current workspace' };
+        }
+      } catch (error) {
+        return {
+          error:
+            error instanceof Error ? error.message : 'Category lookup failed',
+        };
+      }
+    }
+
+    updates.category_id = categoryId;
+  }
+  if (parsedArgs.taskId !== undefined) {
+    const taskId = coerceOptionalString(parsedArgs.taskId);
+
+    if (taskId) {
+      try {
+        if (!(await hasTaskAccess(ctx, taskId))) {
+          return { error: 'Task not found in current workspace' };
+        }
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : 'Task lookup failed',
+        };
+      }
+    }
+
+    updates.task_id = taskId;
+  }
+
+  let nextStartTime = existing.start_time;
+  let nextEndTime = existing.end_time;
+
+  if (parsedArgs.startTime !== undefined) {
+    const parsed = parseFlexibleDateTime(parsedArgs.startTime, 'startTime', {
+      date: parsedArgs.date,
+      timezone: ctx.timezone,
+    });
+    if (!parsed.ok) return { error: parsed.error };
+    nextStartTime = parsed.value.toISOString();
+    updates.start_time = nextStartTime;
+  }
+
+  if (parsedArgs.endTime !== undefined) {
+    const parsed = parseFlexibleDateTime(parsedArgs.endTime, 'endTime', {
+      date: parsedArgs.date,
+      timezone: ctx.timezone,
+    });
+    if (!parsed.ok) return { error: parsed.error };
+    nextEndTime = parsed.value.toISOString();
+    updates.end_time = nextEndTime;
+  }
+
+  if (parsedArgs.startTime !== undefined || parsedArgs.endTime !== undefined) {
+    if (!nextEndTime) {
+      return { error: 'Cannot compute duration without endTime' };
+    }
+
+    const start = new Date(nextStartTime);
+    const end = new Date(nextEndTime);
+    if (end <= start) {
+      return { error: 'endTime must be after startTime' };
+    }
+
+    const durationSeconds = Math.floor(
+      (end.getTime() - start.getTime()) / 1000
+    );
+    if (durationSeconds < MIN_DURATION_SECONDS) {
+      return { error: 'Session must be at least 1 minute long' };
+    }
+    updates.duration_seconds = durationSeconds;
+  }
+
+  if (Object.keys(updates).length === 0) {
+    return { success: true, message: 'No fields to update' };
+  }
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .update(updates)
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .select(
+      `
+      *,
+      category:time_tracking_categories(*),
+      task:tasks(*)
+    `
+    )
+    .single();
+
+  if (error) return { error: error.message };
+  return {
+    success: true,
+    message: 'Session updated',
+    session: toTimerSession(data as Record<string, unknown>),
+  };
+}
+
+export async function executeDeleteTimeTrackingSession(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+): Promise<DeleteTimeTrackingSessionResult> {
+  let parsedArgs: DeleteTimeTrackingSessionArgs;
+  try {
+    parsedArgs = deleteTimeTrackingSessionArgsSchema.parse(args);
+  } catch (error) {
+    return { error: getZodErrorMessage(error) };
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const sessionId =
+    coerceOptionalString(parsedArgs.sessionId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!sessionId) return { error: 'sessionId is required' };
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .delete()
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .select('id');
+
+  if (error) return { error: error.message };
+  if (!data?.length) return { error: 'Session not found' };
+  return { success: true, message: 'Session deleted' };
+}

package/src/tools/executors/timer/timer-sessions-executor.ts

@@ -0,0 +1,91 @@
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { coerceOptionalString, normalizeCursor } from './timer-helpers';
+
+export async function executeListTimeTrackingSessions(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const includePending = Boolean(args.includePending);
+  const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 50);
+  const cursor = args.cursor;
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+
+  let query = ctx.supabase
+    .from('time_tracking_sessions')
+    .select(
+      `
+      id, title, description, start_time, end_time, duration_seconds,
+      is_running, category_id, task_id, pending_approval, ws_id,
+      category:time_tracking_categories(id, name, color),
+      task:tasks(id, name)
+    `
+    )
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .order('start_time', { ascending: false })
+    .order('id', { ascending: false })
+    .limit(limit + 1);
+
+  if (!includePending) {
+    query = query.eq('pending_approval', false);
+  }
+
+  if (cursor !== undefined) {
+    const normalized = normalizeCursor(cursor);
+    if (!normalized.ok) return { error: normalized.error };
+
+    const esc = (value: string) =>
+      value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
+    query = query.or(
+      `start_time.lt."${esc(normalized.lastStartTime)}",and(start_time.eq."${esc(normalized.lastStartTime)}",id.lt."${esc(normalized.lastId)}")`
+    );
+  }
+
+  const { data, error } = await query;
+  if (error) return { error: error.message };
+
+  const rows = data ?? [];
+  const hasMore = rows.length > limit;
+  const sessions = hasMore ? rows.slice(0, limit) : rows;
+  const last = sessions[sessions.length - 1];
+
+  return {
+    success: true,
+    count: sessions.length,
+    sessions,
+    hasMore,
+    nextCursor: last ? `${last.start_time}|${last.id}` : null,
+  };
+}
+
+export async function executeGetTimeTrackingSession(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const sessionIdNormalized = coerceOptionalString(args.sessionId);
+  const idNormalized = coerceOptionalString(args.id);
+  const sessionId = sessionIdNormalized ?? idNormalized;
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  if (!sessionId) return { error: 'sessionId is required' };
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_sessions')
+    .select(
+      `
+      *,
+      category:time_tracking_categories(*),
+      task:tasks(*)
+    `
+    )
+    .eq('id', sessionId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .maybeSingle();
+
+  if (error) return { error: error.message };
+  if (!data) return { error: 'Session not found' };
+
+  return { success: true, session: data };
+}

package/src/tools/executors/timer/timer-stats-executor.ts

@@ -0,0 +1,157 @@
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import {
+  buildToolFailure,
+  resolveTimezone,
+  toFiniteNumber,
+} from './timer-helpers';
+
+export type TimeTrackerStatsRow = {
+  today_time?: number | null;
+  week_time?: number | null;
+  month_time?: number | null;
+  streak?: number | null;
+  daily_activity?: Array<{
+    date?: string | null;
+    duration?: number | null;
+    sessions?: number | null;
+  }> | null;
+};
+
+export async function fetchTimeTrackerStats(
+  ctx: MiraToolContext,
+  options?: {
+    timezone?: string;
+    summaryOnly?: boolean;
+    daysBack?: number;
+  }
+) {
+  const summaryOnly = options?.summaryOnly ?? true;
+  const daysBack = Math.max(0, Math.min(options?.daysBack ?? 365, 365));
+  const appliedDaysBack = summaryOnly ? 0 : daysBack;
+  const timezoneResolution = resolveTimezone(options?.timezone, ctx.timezone);
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+
+  const { data, error } = await ctx.supabase.rpc('get_time_tracker_stats', {
+    p_user_id: ctx.userId,
+    p_ws_id: workspaceId,
+    p_is_personal: ctx.workspaceContext?.personal ?? false,
+    p_timezone: timezoneResolution.resolved,
+    p_days_back: appliedDaysBack,
+  });
+
+  if (error) {
+    return buildToolFailure('TT_STATS_RPC_FAILED', error.message, true);
+  }
+
+  const row = ((Array.isArray(data) ? data[0] : null) ??
+    {}) as TimeTrackerStatsRow;
+  const dailyActivity = Array.isArray(row.daily_activity)
+    ? row.daily_activity.map((entry) => ({
+        date: entry.date ?? '',
+        duration: toFiniteNumber(entry.duration),
+        sessions: toFiniteNumber(entry.sessions),
+      }))
+    : [];
+
+  const todayTime = toFiniteNumber(row.today_time);
+  const weekTime = toFiniteNumber(row.week_time);
+  const monthTime = toFiniteNumber(row.month_time);
+  const streak = toFiniteNumber(row.streak);
+  const totalDuration = dailyActivity.reduce(
+    (sum, entry) => sum + toFiniteNumber(entry.duration),
+    0
+  );
+  const totalSessions = dailyActivity.reduce(
+    (sum, entry) => sum + toFiniteNumber(entry.sessions),
+    0
+  );
+  const averageDailyDuration =
+    dailyActivity.length > 0 ? totalDuration / dailyActivity.length : 0;
+
+  return {
+    success: true,
+    workspaceId,
+    timezone: timezoneResolution.resolved,
+    timezoneResolution,
+    summaryOnly,
+    daysBack: appliedDaysBack,
+    todayTime,
+    weekTime,
+    monthTime,
+    streak,
+    dailyActivity,
+    insights: {
+      totalDuration,
+      totalSessions,
+      averageDailyDuration,
+      averageSessionDuration:
+        totalSessions > 0 ? Math.round(totalDuration / totalSessions) : 0,
+    },
+  };
+}
+
+export async function executeGetTimeTrackerStats(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const summaryOnly =
+    typeof args.summaryOnly === 'boolean' ? args.summaryOnly : true;
+  const daysBackRaw = Number(args.daysBack);
+  const daysBack =
+    Number.isFinite(daysBackRaw) && daysBackRaw > 0
+      ? Math.min(Math.floor(daysBackRaw), 3650)
+      : 365;
+  const timezoneArg =
+    typeof args.timezone === 'string' ? args.timezone : undefined;
+
+  const result = await fetchTimeTrackerStats(ctx, {
+    timezone: timezoneArg,
+    summaryOnly,
+    daysBack,
+  });
+
+  if (!result.success) return result;
+
+  return {
+    success: true,
+    todayTime: result.todayTime,
+    weekTime: result.weekTime,
+    monthTime: result.monthTime,
+    streak: result.streak,
+    dailyActivity: result.dailyActivity,
+    stats: {
+      todayTimeSeconds: result.todayTime,
+      weekTimeSeconds: result.weekTime,
+      monthTimeSeconds: result.monthTime,
+      streakDays: result.streak,
+      dailyActivity: result.dailyActivity.map((entry) => ({
+        date: entry.date,
+        durationSeconds: entry.duration,
+        sessionCount: entry.sessions,
+      })),
+    },
+    insights: result.insights,
+    meta: {
+      workspaceId: result.workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+      filtersApplied: {
+        summaryOnly: result.summaryOnly,
+        daysBack: result.daysBack,
+      },
+      timezone: {
+        requested: result.timezoneResolution.requested,
+        resolved: result.timezoneResolution.resolved,
+        validRequested: result.timezoneResolution.validRequested,
+        usedFallback: result.timezoneResolution.usedFallback,
+      },
+      units: {
+        durations: 'seconds',
+        streak: 'days',
+        goalTargets: 'minutes',
+        progress: 'percent',
+      },
+    },
+  };
+}

package/src/tools/executors/timer.ts

@@ -0,0 +1,22 @@
+export { executeListTimeTrackingCategories } from './timer/timer-categories-executor';
+export { executeGetTimeTrackerGoals } from './timer/timer-goals-executor';
+export { parseFlexibleDateTime } from './timer/timer-helpers';
+export {
+  executeCreateTimeTrackerGoal,
+  executeCreateTimeTrackingCategory,
+  executeCreateTimeTrackingEntry,
+  executeDeleteTimeTrackerGoal,
+  executeDeleteTimeTrackingCategory,
+  executeDeleteTimeTrackingSession,
+  executeMoveTimeTrackingSession,
+  executeStartTimer,
+  executeStopTimer,
+  executeUpdateTimeTrackerGoal,
+  executeUpdateTimeTrackingCategory,
+  executeUpdateTimeTrackingSession,
+} from './timer/timer-mutations';
+export {
+  executeGetTimeTrackingSession,
+  executeListTimeTrackingSessions,
+} from './timer/timer-sessions-executor';
+export { executeGetTimeTrackerStats } from './timer/timer-stats-executor';

package/src/tools/executors/user.ts

@@ -0,0 +1,60 @@
+import type { MiraToolContext } from '../mira-tools';
+
+export async function executeUpdateUserName(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const displayName = args.displayName as string | undefined;
+  const fullName = args.fullName as string | undefined;
+
+  if (!displayName && !fullName) {
+    return {
+      success: false,
+      error: 'No name fields provided to update',
+      message: 'You must provide at least one of displayName or fullName.',
+    };
+  }
+
+  const results: Record<string, any> = {};
+
+  if (displayName) {
+    const { error } = await ctx.supabase
+      .from('users')
+      .update({ display_name: displayName })
+      .eq('id', ctx.userId);
+
+    if (error) {
+      results.displayNameError = error.message;
+    } else {
+      results.displayNameUpdated = true;
+    }
+  }
+
+  if (fullName) {
+    const { error } = await ctx.supabase
+      .from('user_private_details')
+      .update({ full_name: fullName })
+      .eq('user_id', ctx.userId);
+
+    if (error) {
+      results.fullNameError = error.message;
+    } else {
+      results.fullNameUpdated = true;
+    }
+  }
+
+  if (results.displayNameError || results.fullNameError) {
+    return {
+      success: false,
+      error: 'Partial or complete failure',
+      message: 'Failed to update some or all name fields',
+      details: results,
+    };
+  }
+
+  return {
+    success: true,
+    message: 'User name updated successfully',
+    details: results,
+  };
+}