@tuturuuu/ai 0.0.10

package/src/tools/executors/theme.ts

@@ -0,0 +1,23 @@
+import type { MiraToolContext } from '../mira-tools';
+
+export async function executeSetTheme(
+  args: Record<string, unknown>,
+  _ctx: MiraToolContext
+) {
+  const theme = args.theme as string;
+  const valid = ['light', 'dark', 'system'];
+  if (!valid.includes(theme)) {
+    return {
+      error: `Invalid theme "${theme}". Must be one of: ${valid.join(', ')}`,
+    };
+  }
+
+  // Return a client-side action marker — the chat UI will detect this
+  // and apply the theme change via next-themes.
+  return {
+    success: true,
+    action: 'set_theme',
+    theme,
+    message: `Theme changed to ${theme}`,
+  };
+}

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

@@ -0,0 +1,110 @@
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { buildToolFailure } from './timer-helpers';
+
+const encodeCategoryCursorName = (value: string) => encodeURIComponent(value);
+
+const decodeCategoryCursorName = (value: string) => {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+};
+
+export type TimeTrackingCategoryRow = {
+  id: string;
+  ws_id: string;
+  name: string;
+  description: string | null;
+  color: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export async function executeListTimeTrackingCategories(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const limitRaw = Number(args.limit);
+  const limit =
+    Number.isFinite(limitRaw) && limitRaw > 0
+      ? Math.min(Math.floor(limitRaw), 50)
+      : 20;
+  const cursor = args.cursor;
+
+  let query = ctx.supabase
+    .from('time_tracking_categories')
+    .select('id, ws_id, name, description, color, created_at, updated_at')
+    .eq('ws_id', workspaceId)
+    .order('name', { ascending: true })
+    .order('id', { ascending: true })
+    .limit(limit + 1);
+
+  if (cursor !== undefined) {
+    if (typeof cursor !== 'string') {
+      return buildToolFailure(
+        'TT_CATEGORIES_INVALID_CURSOR',
+        'Invalid cursor format',
+        false
+      );
+    }
+
+    const separatorIndex = cursor.lastIndexOf('|');
+    if (separatorIndex <= 0 || separatorIndex === cursor.length - 1) {
+      return buildToolFailure(
+        'TT_CATEGORIES_INVALID_CURSOR',
+        'Invalid cursor format',
+        false
+      );
+    }
+
+    const rawName = cursor.slice(0, separatorIndex);
+    const lastId = cursor.slice(separatorIndex + 1);
+    const lastName = decodeCategoryCursorName(rawName);
+    if (!lastName || !lastId) {
+      return buildToolFailure(
+        'TT_CATEGORIES_INVALID_CURSOR',
+        'Invalid cursor format',
+        false
+      );
+    }
+
+    const esc = (value: string) =>
+      value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
+    query = query.or(
+      `name.gt."${esc(lastName)}",and(name.eq."${esc(lastName)}",id.gt."${esc(lastId)}")`
+    );
+  }
+
+  const { data, error } = await query;
+  if (error) {
+    return buildToolFailure('TT_CATEGORIES_FETCH_FAILED', error.message, true);
+  }
+
+  const rows = (data ?? []) as TimeTrackingCategoryRow[];
+  const hasMore = rows.length > limit;
+  const categories = hasMore ? rows.slice(0, limit) : rows;
+  const last = categories[categories.length - 1];
+
+  return {
+    success: true,
+    categories,
+    count: categories.length,
+    hasMore,
+    nextCursor: last
+      ? `${encodeCategoryCursorName(last.name)}|${last.id}`
+      : null,
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+      filtersApplied: {
+        cursorProvided: cursor !== undefined,
+        limit,
+      },
+    },
+  };
+}

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

@@ -0,0 +1,240 @@
+import type { TablesUpdate } from '@tuturuuu/types';
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { buildToolFailure, coerceOptionalString } from './timer-helpers';
+import {
+  type CreateTimeTrackingCategoryArgs,
+  createTimeTrackingCategoryArgsSchema,
+  type DeleteTimeTrackingCategoryArgs,
+  deleteTimeTrackingCategoryArgsSchema,
+  getZodErrorMessage,
+  type UpdateTimeTrackingCategoryArgs,
+  updateTimeTrackingCategoryArgsSchema,
+} from './timer-mutation-schemas';
+import type { TimeTrackingCategory } from './timer-mutation-types';
+
+export async function executeCreateTimeTrackingCategory(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: CreateTimeTrackingCategoryArgs;
+  try {
+    parsedArgs = createTimeTrackingCategoryArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_CATEGORY_CREATE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const name = parsedArgs.name.trim();
+  if (!name) {
+    return buildToolFailure(
+      'TT_CATEGORY_CREATE_NAME_REQUIRED',
+      'name is required',
+      false
+    );
+  }
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_categories')
+    .insert({
+      ws_id: workspaceId,
+      name,
+      description: coerceOptionalString(parsedArgs.description),
+      color: coerceOptionalString(parsedArgs.color) ?? 'BLUE',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+    .select('id, ws_id, name, description, color, created_at, updated_at')
+    .single();
+
+  if (error) {
+    return buildToolFailure('TT_CATEGORY_CREATE_FAILED', error.message, true);
+  }
+
+  return {
+    success: true,
+    message: 'Time tracking category created',
+    category: data as TimeTrackingCategory,
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}
+
+export async function executeUpdateTimeTrackingCategory(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: UpdateTimeTrackingCategoryArgs;
+  try {
+    parsedArgs = updateTimeTrackingCategoryArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_CATEGORY_UPDATE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const categoryId =
+    coerceOptionalString(parsedArgs.categoryId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!categoryId) {
+    return buildToolFailure(
+      'TT_CATEGORY_UPDATE_MISSING_ID',
+      'categoryId is required',
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+
+  const { data: existingCategory, error: existingCategoryError } =
+    await ctx.supabase
+      .from('time_tracking_categories')
+      .select('id')
+      .eq('id', categoryId)
+      .eq('ws_id', workspaceId)
+      .maybeSingle();
+
+  if (existingCategoryError) {
+    return buildToolFailure(
+      'TT_CATEGORY_UPDATE_LOOKUP_FAILED',
+      existingCategoryError.message,
+      true
+    );
+  }
+
+  if (!existingCategory) {
+    return buildToolFailure(
+      'TT_CATEGORY_UPDATE_NOT_FOUND',
+      'Category not found',
+      false
+    );
+  }
+
+  const updates: TablesUpdate<'time_tracking_categories'> = {
+    updated_at: new Date().toISOString(),
+  };
+
+  if (parsedArgs.name !== undefined) {
+    const trimmedName = parsedArgs.name?.trim();
+    if (!trimmedName) {
+      return buildToolFailure(
+        'TT_CATEGORY_UPDATE_INVALID_NAME',
+        'name cannot be empty',
+        false
+      );
+    }
+    updates.name = trimmedName;
+  }
+
+  if (parsedArgs.description !== undefined) {
+    updates.description = coerceOptionalString(parsedArgs.description);
+  }
+
+  if (parsedArgs.color !== undefined) {
+    updates.color = coerceOptionalString(parsedArgs.color);
+  }
+
+  if (Object.keys(updates).length === 1) {
+    return {
+      success: true,
+      message: 'No fields to update',
+      meta: {
+        workspaceId,
+        workspaceContextId:
+          ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+        isPersonalContext: ctx.workspaceContext?.personal ?? false,
+      },
+    };
+  }
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_categories')
+    .update(updates)
+    .eq('id', categoryId)
+    .eq('ws_id', workspaceId)
+    .select('id, ws_id, name, description, color, created_at, updated_at')
+    .single();
+
+  if (error) {
+    return buildToolFailure('TT_CATEGORY_UPDATE_FAILED', error.message, true);
+  }
+
+  return {
+    success: true,
+    message: 'Time tracking category updated',
+    category: data as TimeTrackingCategory,
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}
+
+export async function executeDeleteTimeTrackingCategory(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: DeleteTimeTrackingCategoryArgs;
+  try {
+    parsedArgs = deleteTimeTrackingCategoryArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_CATEGORY_DELETE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const categoryId =
+    coerceOptionalString(parsedArgs.categoryId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!categoryId) {
+    return buildToolFailure(
+      'TT_CATEGORY_DELETE_MISSING_ID',
+      'categoryId is required',
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_categories')
+    .delete()
+    .eq('id', categoryId)
+    .eq('ws_id', workspaceId)
+    .select('id')
+    .maybeSingle();
+
+  if (error) {
+    return buildToolFailure('TT_CATEGORY_DELETE_FAILED', error.message, true);
+  }
+
+  if (!data) {
+    return buildToolFailure(
+      'TT_CATEGORY_DELETE_NOT_FOUND',
+      'Category not found',
+      false
+    );
+  }
+
+  return {
+    success: true,
+    message: 'Time tracking category deleted',
+    deletedCategoryId: categoryId,
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}

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

@@ -0,0 +1,323 @@
+import type { TablesUpdate } from '@tuturuuu/types';
+import type { MiraToolContext } from '../../mira-tools';
+import { getWorkspaceContextWorkspaceId } from '../../workspace-context';
+import { buildToolFailure, coerceOptionalString } from './timer-helpers';
+import {
+  type CreateTimeTrackerGoalArgs,
+  createTimeTrackerGoalArgsSchema,
+  type DeleteTimeTrackerGoalArgs,
+  deleteTimeTrackerGoalArgsSchema,
+  getZodErrorMessage,
+  type UpdateTimeTrackerGoalArgs,
+  updateTimeTrackerGoalArgsSchema,
+} from './timer-mutation-schemas';
+import {
+  normalizeGoalCategory,
+  normalizeGoalCategoryIdInput,
+  type TimerGoal,
+} from './timer-mutation-types';
+
+export async function executeCreateTimeTrackerGoal(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: CreateTimeTrackerGoalArgs;
+  try {
+    parsedArgs = createTimeTrackerGoalArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_GOAL_CREATE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const normalizedCategory = normalizeGoalCategoryIdInput(
+    parsedArgs.categoryId
+  );
+  if (!normalizedCategory.ok) {
+    return buildToolFailure(
+      'TT_GOAL_CREATE_INVALID_CATEGORY',
+      normalizedCategory.error,
+      false
+    );
+  }
+
+  if (normalizedCategory.categoryId) {
+    const { data: categoryRow, error: categoryError } = await ctx.supabase
+      .from('time_tracking_categories')
+      .select('id')
+      .eq('id', normalizedCategory.categoryId)
+      .eq('ws_id', workspaceId)
+      .maybeSingle();
+
+    if (categoryError) {
+      return buildToolFailure(
+        'TT_GOAL_CREATE_CATEGORY_LOOKUP_FAILED',
+        categoryError.message,
+        true
+      );
+    }
+
+    if (!categoryRow) {
+      return buildToolFailure(
+        'TT_GOAL_CREATE_CATEGORY_NOT_FOUND',
+        'Category not found',
+        false
+      );
+    }
+  }
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_goals')
+    .insert({
+      ws_id: workspaceId,
+      user_id: ctx.userId,
+      category_id: normalizedCategory.categoryId,
+      daily_goal_minutes: parsedArgs.dailyGoalMinutes,
+      weekly_goal_minutes: parsedArgs.weeklyGoalMinutes ?? null,
+      is_active: parsedArgs.isActive ?? true,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    })
+    .select(
+      `
+      *,
+      category:time_tracking_categories(id, name, color)
+    `
+    )
+    .single();
+
+  if (error) {
+    return buildToolFailure('TT_GOAL_CREATE_FAILED', error.message, true);
+  }
+
+  const goal = data as TimerGoal;
+  return {
+    success: true,
+    message: 'Time tracker goal created',
+    goal: {
+      ...goal,
+      category: normalizeGoalCategory(goal.category),
+    },
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}
+
+export async function executeUpdateTimeTrackerGoal(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: UpdateTimeTrackerGoalArgs;
+  try {
+    parsedArgs = updateTimeTrackerGoalArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_GOAL_UPDATE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const goalId =
+    coerceOptionalString(parsedArgs.goalId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!goalId) {
+    return buildToolFailure(
+      'TT_GOAL_UPDATE_MISSING_ID',
+      'goalId is required',
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+
+  const { data: existingGoal, error: existingGoalError } = await ctx.supabase
+    .from('time_tracking_goals')
+    .select('id')
+    .eq('id', goalId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .maybeSingle();
+
+  if (existingGoalError) {
+    return buildToolFailure(
+      'TT_GOAL_UPDATE_LOOKUP_FAILED',
+      existingGoalError.message,
+      true
+    );
+  }
+
+  if (!existingGoal) {
+    return buildToolFailure(
+      'TT_GOAL_UPDATE_NOT_FOUND',
+      'Goal not found',
+      false
+    );
+  }
+
+  const updates: TablesUpdate<'time_tracking_goals'> = {
+    updated_at: new Date().toISOString(),
+  };
+
+  if (parsedArgs.categoryId !== undefined) {
+    const normalizedCategory = normalizeGoalCategoryIdInput(
+      parsedArgs.categoryId
+    );
+    if (!normalizedCategory.ok) {
+      return buildToolFailure(
+        'TT_GOAL_UPDATE_INVALID_CATEGORY',
+        normalizedCategory.error,
+        false
+      );
+    }
+
+    if (normalizedCategory.categoryId) {
+      const { data: categoryRow, error: categoryError } = await ctx.supabase
+        .from('time_tracking_categories')
+        .select('id')
+        .eq('id', normalizedCategory.categoryId)
+        .eq('ws_id', workspaceId)
+        .maybeSingle();
+
+      if (categoryError) {
+        return buildToolFailure(
+          'TT_GOAL_UPDATE_CATEGORY_LOOKUP_FAILED',
+          categoryError.message,
+          true
+        );
+      }
+
+      if (!categoryRow) {
+        return buildToolFailure(
+          'TT_GOAL_UPDATE_CATEGORY_NOT_FOUND',
+          'Category not found',
+          false
+        );
+      }
+    }
+
+    updates.category_id = normalizedCategory.categoryId;
+  }
+
+  if (parsedArgs.dailyGoalMinutes !== undefined) {
+    updates.daily_goal_minutes = parsedArgs.dailyGoalMinutes;
+  }
+  if (parsedArgs.weeklyGoalMinutes !== undefined) {
+    updates.weekly_goal_minutes = parsedArgs.weeklyGoalMinutes ?? null;
+  }
+  if (parsedArgs.isActive !== undefined) {
+    updates.is_active = parsedArgs.isActive;
+  }
+
+  if (Object.keys(updates).length === 1) {
+    return {
+      success: true,
+      message: 'No fields to update',
+      meta: {
+        workspaceId,
+        workspaceContextId:
+          ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+        isPersonalContext: ctx.workspaceContext?.personal ?? false,
+      },
+    };
+  }
+
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_goals')
+    .update(updates)
+    .eq('id', goalId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .select(
+      `
+      *,
+      category:time_tracking_categories(id, name, color)
+    `
+    )
+    .single();
+
+  if (error) {
+    return buildToolFailure('TT_GOAL_UPDATE_FAILED', error.message, true);
+  }
+
+  const goal = data as TimerGoal;
+  return {
+    success: true,
+    message: 'Time tracker goal updated',
+    goal: {
+      ...goal,
+      category: normalizeGoalCategory(goal.category),
+    },
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}
+
+export async function executeDeleteTimeTrackerGoal(
+  args: Record<string, unknown>,
+  ctx: MiraToolContext
+) {
+  let parsedArgs: DeleteTimeTrackerGoalArgs;
+  try {
+    parsedArgs = deleteTimeTrackerGoalArgsSchema.parse(args);
+  } catch (error) {
+    return buildToolFailure(
+      'TT_GOAL_DELETE_INVALID_ARGS',
+      getZodErrorMessage(error),
+      false
+    );
+  }
+
+  const goalId =
+    coerceOptionalString(parsedArgs.goalId) ??
+    coerceOptionalString(parsedArgs.id);
+  if (!goalId) {
+    return buildToolFailure(
+      'TT_GOAL_DELETE_MISSING_ID',
+      'goalId is required',
+      false
+    );
+  }
+
+  const workspaceId = getWorkspaceContextWorkspaceId(ctx);
+  const { data, error } = await ctx.supabase
+    .from('time_tracking_goals')
+    .delete()
+    .eq('id', goalId)
+    .eq('ws_id', workspaceId)
+    .eq('user_id', ctx.userId)
+    .select('id')
+    .maybeSingle();
+
+  if (error) {
+    return buildToolFailure('TT_GOAL_DELETE_FAILED', error.message, true);
+  }
+
+  if (!data) {
+    return buildToolFailure(
+      'TT_GOAL_DELETE_NOT_FOUND',
+      'Goal not found',
+      false
+    );
+  }
+
+  return {
+    success: true,
+    message: 'Time tracker goal deleted',
+    deletedGoalId: goalId,
+    meta: {
+      workspaceId,
+      workspaceContextId: ctx.workspaceContext?.workspaceContextId ?? ctx.wsId,
+      isPersonalContext: ctx.workspaceContext?.personal ?? false,
+    },
+  };
+}