@fayz-ai/plugin-tasks 0.1.1

package/src/data/mock.ts

@@ -0,0 +1,143 @@
+import type { TasksDataProvider } from './types'
+import type {
+  Task, TaskLabel, CreateTaskInput, UpdateTaskInput,
+  TaskQuery, TasksSummary, TaskStatus,
+} from '../types'
+
+function uid(): string { return crypto.randomUUID?.() ?? String(Date.now()) }
+function now(): string { return new Date().toISOString() }
+function today(): string { return new Date().toISOString().slice(0, 10) }
+
+const SEED_LABELS: TaskLabel[] = [
+  { id: 'lbl-bug', name: 'Bug', color: '#ef4444', isActive: true, tenantId: 'mock', createdAt: now() },
+  { id: 'lbl-feature', name: 'Feature', color: '#3b82f6', isActive: true, tenantId: 'mock', createdAt: now() },
+  { id: 'lbl-urgent', name: 'Urgent', color: '#f59e0b', isActive: true, tenantId: 'mock', createdAt: now() },
+  { id: 'lbl-personal', name: 'Personal', color: '#8b5cf6', isActive: true, tenantId: 'mock', createdAt: now() },
+]
+
+function makeSeedTasks(): Task[] {
+  const base = {
+    tenantId: 'mock',
+    description: null,
+    assignedToId: null,
+    assignedToName: null,
+    parentId: null,
+    labels: [],
+    createdById: null,
+    createdByName: null,
+    createdAt: now(),
+    updatedAt: now(),
+  }
+  return [
+    { ...base, id: uid(), title: 'Setup payment gateway', status: 'todo' as const, priority: 'high' as const, dueDate: today(), position: 0 },
+    { ...base, id: uid(), title: 'Update menu photos', status: 'todo' as const, priority: 'medium' as const, dueDate: null, position: 1 },
+    { ...base, id: uid(), title: 'Review monthly report', status: 'in_progress' as const, priority: 'medium' as const, dueDate: null, position: 0 },
+    { ...base, id: uid(), title: 'Fix login bug', status: 'in_progress' as const, priority: 'urgent' as const, dueDate: today(), position: 1, labels: ['lbl-bug'] },
+    { ...base, id: uid(), title: 'Onboard new employee', status: 'done' as const, priority: 'low' as const, dueDate: null, position: 0 },
+  ]
+}
+
+function matchesQuery(task: Task, query: TaskQuery): boolean {
+  if (query.status) {
+    const statuses = Array.isArray(query.status) ? query.status : [query.status]
+    if (!statuses.includes(task.status)) return false
+  }
+  if (query.priority) {
+    const priorities = Array.isArray(query.priority) ? query.priority : [query.priority]
+    if (!priorities.includes(task.priority)) return false
+  }
+  if (query.assignedToId && task.assignedToId !== query.assignedToId) return false
+  if (query.parentId !== undefined) {
+    if (query.parentId === null && task.parentId !== null) return false
+    if (query.parentId !== null && task.parentId !== query.parentId) return false
+  }
+  if (query.search) {
+    const s = query.search.toLowerCase()
+    if (!task.title.toLowerCase().includes(s)) return false
+  }
+  if (query.overdue && task.dueDate) {
+    if (task.dueDate >= today()) return false
+  }
+  return true
+}
+
+export function createMockTasksProvider(): TasksDataProvider {
+  let tasks = makeSeedTasks()
+  const labels = [...SEED_LABELS]
+
+  return {
+    async getTasks(query) {
+      return tasks.filter((t) => matchesQuery(t, query)).sort((a, b) => a.position - b.position)
+    },
+
+    async getTaskById(id) {
+      return tasks.find((t) => t.id === id) ?? null
+    },
+
+    async getSubtasks(parentId) {
+      return tasks.filter((t) => t.parentId === parentId).sort((a, b) => a.position - b.position)
+    },
+
+    async createTask(input: CreateTaskInput) {
+      const statusTasks = tasks.filter((t) => t.status === (input.status ?? 'todo') && t.parentId === (input.parentId ?? null))
+      const maxPos = statusTasks.reduce((max, t) => Math.max(max, t.position), -1)
+      const task: Task = {
+        id: uid(),
+        title: input.title,
+        description: input.description ?? null,
+        status: input.status ?? 'todo',
+        priority: input.priority ?? 'medium',
+        dueDate: input.dueDate ?? null,
+        assignedToId: input.assignedToId ?? null,
+        assignedToName: null,
+        parentId: input.parentId ?? null,
+        labels: input.labels ?? [],
+        position: maxPos + 1,
+        createdById: null,
+        createdByName: null,
+        tenantId: 'mock',
+        createdAt: now(),
+        updatedAt: now(),
+      }
+      tasks.push(task)
+      return task
+    },
+
+    async updateTask(id, input: UpdateTaskInput) {
+      const idx = tasks.findIndex((t) => t.id === id)
+      if (idx === -1) throw new Error('Task not found')
+      tasks[idx] = { ...tasks[idx], ...input, updatedAt: now() } as Task
+      return tasks[idx]
+    },
+
+    async deleteTask(id) {
+      tasks = tasks.filter((t) => t.id !== id && t.parentId !== id)
+    },
+
+    async reorderTask(id, newPosition, status) {
+      const task = tasks.find((t) => t.id === id)
+      if (!task) return
+      task.status = status
+      task.position = newPosition
+      task.updatedAt = now()
+    },
+
+    async getLabels() {
+      return labels.filter((l) => l.isActive)
+    },
+
+    async getSummary() {
+      const topLevel = tasks.filter((t) => t.parentId === null)
+      const d = today()
+      return {
+        total: topLevel.length,
+        todo: topLevel.filter((t) => t.status === 'todo').length,
+        inProgress: topLevel.filter((t) => t.status === 'in_progress').length,
+        done: topLevel.filter((t) => t.status === 'done').length,
+        overdue: topLevel.filter((t) => t.dueDate != null && t.dueDate < d && t.status !== 'done' && t.status !== 'cancelled').length,
+        dueToday: topLevel.filter((t) => t.dueDate === d && t.status !== 'done' && t.status !== 'cancelled').length,
+        highPriority: topLevel.filter((t) => (t.priority === 'high' || t.priority === 'urgent') && t.status !== 'done' && t.status !== 'cancelled').length,
+      }
+    },
+  }
+}

package/src/data/supabase.ts

@@ -0,0 +1,193 @@
+import type { TasksDataProvider } from './types'
+import type { Task, TaskLabel, TasksSummary, TaskStatus } from '../types'
+import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
+import { getTasksTenantId } from '../lib/tenant'
+
+function getTenantId(): string | undefined {
+  // Local override wins; else use the app's active tenant so writes pass RLS.
+  return getTasksTenantId() ?? getActiveTenantId()
+}
+
+function getClient() {
+  const supabase = getSupabaseClientOptional() as any
+  if (!supabase) throw new Error('Supabase not initialized')
+  return supabase
+}
+
+function snakeToCamel(obj: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    result[key.replace(/_([a-z])/g, (_, c) => c.toUpperCase())] = value
+  }
+  return result
+}
+
+function toTask(row: Record<string, unknown>): Task {
+  const t = snakeToCamel(row) as unknown as Task
+  // Ensure labels is always an array
+  if (!Array.isArray(t.labels)) t.labels = []
+  return t
+}
+
+export function createSupabaseTasksProvider(): TasksDataProvider {
+  return {
+    async getTasks(query) {
+      const tenantId = getTenantId()
+      if (!tenantId) return []
+      let q = getClient()
+        .from('tsk_tasks')
+        .select('*')
+        .eq('tenant_id', tenantId)
+
+      if (query.parentId === null) {
+        q = q.is('parent_id', null)
+      } else if (query.parentId) {
+        q = q.eq('parent_id', query.parentId)
+      }
+
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status]
+        q = q.in('status', statuses)
+      }
+      if (query.priority) {
+        const priorities = Array.isArray(query.priority) ? query.priority : [query.priority]
+        q = q.in('priority', priorities)
+      }
+      if (query.assignedToId) {
+        q = q.eq('assigned_to_id', query.assignedToId)
+      }
+      if (query.search) {
+        q = q.ilike('title', `%${query.search}%`)
+      }
+      if (query.overdue) {
+        q = q.lt('due_date', new Date().toISOString().slice(0, 10))
+          .not('status', 'in', '("done","cancelled")')
+      }
+
+      q = q.order('position', { ascending: true }).order('created_at', { ascending: false })
+
+      const { data } = await q
+      return (data ?? []).map(toTask)
+    },
+
+    async getTaskById(id) {
+      const { data } = await getClient()
+        .from('tsk_tasks')
+        .select('*')
+        .eq('id', id)
+        .maybeSingle()
+      return data ? toTask(data) : null
+    },
+
+    async getSubtasks(parentId) {
+      const { data } = await getClient()
+        .from('tsk_tasks')
+        .select('*')
+        .eq('parent_id', parentId)
+        .order('position', { ascending: true })
+      return (data ?? []).map(toTask)
+    },
+
+    async createTask(input) {
+      const tenantId = getTenantId()
+      if (!tenantId) throw new Error('No active tenant')
+
+      // Get max position for the status group
+      const { data: maxData } = await getClient()
+        .from('tsk_tasks')
+        .select('position')
+        .eq('tenant_id', tenantId)
+        .eq('status', input.status ?? 'todo')
+        .is('parent_id', input.parentId ?? null)
+        .order('position', { ascending: false })
+        .limit(1)
+      const maxPos = maxData?.[0]?.position ?? -1
+
+      const { data, error } = await getClient()
+        .from('tsk_tasks')
+        .insert({
+          tenant_id: tenantId,
+          title: input.title,
+          description: input.description ?? null,
+          status: input.status ?? 'todo',
+          priority: input.priority ?? 'medium',
+          due_date: input.dueDate ?? null,
+          assigned_to_id: input.assignedToId ?? null,
+          parent_id: input.parentId ?? null,
+          labels: input.labels ?? [],
+          position: maxPos + 1,
+        })
+        .select('*')
+        .single()
+      if (error) throw error
+      return toTask(data)
+    },
+
+    async updateTask(id, input) {
+      const payload: Record<string, unknown> = { updated_at: new Date().toISOString() }
+      if (input.title !== undefined) payload.title = input.title
+      if (input.description !== undefined) payload.description = input.description
+      if (input.status !== undefined) payload.status = input.status
+      if (input.priority !== undefined) payload.priority = input.priority
+      if (input.dueDate !== undefined) payload.due_date = input.dueDate
+      if (input.assignedToId !== undefined) payload.assigned_to_id = input.assignedToId
+      if (input.labels !== undefined) payload.labels = input.labels
+      if (input.position !== undefined) payload.position = input.position
+
+      const { data, error } = await getClient()
+        .from('tsk_tasks')
+        .update(payload)
+        .eq('id', id)
+        .select('*')
+        .single()
+      if (error) throw error
+      return toTask(data)
+    },
+
+    async deleteTask(id) {
+      await getClient().from('tsk_tasks').delete().eq('id', id)
+    },
+
+    async reorderTask(id, newPosition, status) {
+      await getClient()
+        .from('tsk_tasks')
+        .update({ position: newPosition, status, updated_at: new Date().toISOString() })
+        .eq('id', id)
+    },
+
+    async getLabels() {
+      const tenantId = getTenantId()
+      if (!tenantId) return []
+      const { data } = await getClient()
+        .from('tsk_labels')
+        .select('*')
+        .eq('tenant_id', tenantId)
+        .eq('is_active', true)
+        .order('name')
+      return (data ?? []).map((r: any) => snakeToCamel(r) as unknown as TaskLabel)
+    },
+
+    async getSummary() {
+      const tenantId = getTenantId()
+      if (!tenantId) return { total: 0, todo: 0, inProgress: 0, done: 0, overdue: 0, dueToday: 0, highPriority: 0 }
+
+      const { data } = await getClient()
+        .from('tsk_tasks')
+        .select('status, priority, due_date')
+        .eq('tenant_id', tenantId)
+        .is('parent_id', null)
+
+      const tasks = data ?? []
+      const today = new Date().toISOString().slice(0, 10)
+      return {
+        total: tasks.length,
+        todo: tasks.filter((t: any) => t.status === 'todo').length,
+        inProgress: tasks.filter((t: any) => t.status === 'in_progress').length,
+        done: tasks.filter((t: any) => t.status === 'done').length,
+        overdue: tasks.filter((t: any) => t.due_date && t.due_date < today && t.status !== 'done' && t.status !== 'cancelled').length,
+        dueToday: tasks.filter((t: any) => t.due_date === today && t.status !== 'done' && t.status !== 'cancelled').length,
+        highPriority: tasks.filter((t: any) => (t.priority === 'high' || t.priority === 'urgent') && t.status !== 'done' && t.status !== 'cancelled').length,
+      }
+    },
+  }
+}

package/src/data/types.ts

@@ -0,0 +1,16 @@
+import type {
+  Task, TaskLabel, CreateTaskInput, UpdateTaskInput,
+  TaskQuery, TasksSummary, TaskStatus,
+} from '../types'
+
+export interface TasksDataProvider {
+  getTasks(query: TaskQuery): Promise<Task[]>
+  getTaskById(id: string): Promise<Task | null>
+  getSubtasks(parentId: string): Promise<Task[]>
+  createTask(input: CreateTaskInput): Promise<Task>
+  updateTask(id: string, input: UpdateTaskInput): Promise<Task>
+  deleteTask(id: string): Promise<void>
+  reorderTask(id: string, newPosition: number, status: TaskStatus): Promise<void>
+  getLabels(): Promise<TaskLabel[]>
+  getSummary(): Promise<TasksSummary>
+}

package/src/index.ts

@@ -0,0 +1,217 @@
+import React from 'react'
+import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
+import { TasksContextProvider, type ResolvedTasksConfig, type TasksPluginLabels } from './TasksContext'
+import type { TasksDataProvider } from './data/types'
+import type { TaskPriority } from './types'
+import { createMockTasksProvider } from './data/mock'
+import { createSafeDataProvider, registerTranslations } from '@fayz-ai/core'
+import { createSupabaseTasksProvider } from './data/supabase'
+import { createTasksStore } from './store'
+import { tasksLocales } from './locales'
+import { tasksRegistries } from './registries'
+import { TasksGeneralSettings } from './components/TasksGeneralSettings'
+import { TasksTopbarButton } from './components/TasksTopbarButton'
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface TasksPluginOptions {
+  /** Label overrides */
+  labels?: Partial<TasksPluginLabels>
+  /** Plugin scope */
+  scope?: PluginScope
+  /** Vertical ID */
+  verticalId?: VerticalId
+  /** Data provider override (defaults to safe auto-selection) */
+  dataProvider?: TasksDataProvider
+  /** Default priority for new tasks (default: 'medium') */
+  defaultPriority?: TaskPriority
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+const DEFAULT_LABELS: TasksPluginLabels = {
+  drawerTitle: 'Tasks',
+  settingsTitle: 'Tasks',
+  quickAddPlaceholder: 'Add a task...',
+}
+
+// ---------------------------------------------------------------------------
+// Config resolver
+// ---------------------------------------------------------------------------
+
+function resolveConfig(options?: TasksPluginOptions): ResolvedTasksConfig {
+  return {
+    labels: { ...DEFAULT_LABELS, ...options?.labels },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Migration SQL
+// ---------------------------------------------------------------------------
+
+const MIGRATION_001 = `-- Tasks Plugin: Base Tables
+CREATE TABLE IF NOT EXISTS public.tsk_labels (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES saas_core.tenants(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  color text NOT NULL DEFAULT '#6366f1',
+  is_active boolean NOT NULL DEFAULT true,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.tsk_labels ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_tsk_labels_tenant ON public.tsk_labels(tenant_id);
+
+CREATE TABLE IF NOT EXISTS public.tsk_tasks (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL REFERENCES saas_core.tenants(id) ON DELETE CASCADE,
+  title text NOT NULL,
+  description text,
+  status text NOT NULL DEFAULT 'todo' CHECK (status IN ('todo','in_progress','done','cancelled')),
+  priority text NOT NULL DEFAULT 'medium' CHECK (priority IN ('low','medium','high','urgent')),
+  due_date date,
+  assigned_to_id uuid,
+  assigned_to_name text,
+  parent_id uuid REFERENCES public.tsk_tasks(id) ON DELETE CASCADE,
+  labels jsonb NOT NULL DEFAULT '[]'::jsonb,
+  position integer NOT NULL DEFAULT 0,
+  created_by_id uuid,
+  created_by_name text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+ALTER TABLE public.tsk_tasks ENABLE ROW LEVEL SECURITY;
+CREATE INDEX IF NOT EXISTS idx_tsk_tasks_tenant ON public.tsk_tasks(tenant_id);
+CREATE INDEX IF NOT EXISTS idx_tsk_tasks_status ON public.tsk_tasks(tenant_id, status);
+CREATE INDEX IF NOT EXISTS idx_tsk_tasks_parent ON public.tsk_tasks(parent_id);
+CREATE INDEX IF NOT EXISTS idx_tsk_tasks_assigned ON public.tsk_tasks(assigned_to_id);
+CREATE INDEX IF NOT EXISTS idx_tsk_tasks_due ON public.tsk_tasks(tenant_id, due_date) WHERE due_date IS NOT NULL;
+
+-- RLS policies for tsk_tasks
+CREATE POLICY tsk_tasks_select ON public.tsk_tasks FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_tasks_insert ON public.tsk_tasks FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_tasks_update ON public.tsk_tasks FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_tasks_delete ON public.tsk_tasks FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.tsk_tasks TO authenticated;
+
+-- RLS policies for tsk_labels
+CREATE POLICY tsk_labels_select ON public.tsk_labels FOR SELECT TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_labels_insert ON public.tsk_labels FOR INSERT TO authenticated WITH CHECK (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_labels_update ON public.tsk_labels FOR UPDATE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+CREATE POLICY tsk_labels_delete ON public.tsk_labels FOR DELETE TO authenticated USING (tenant_id IN (SELECT public.user_tenant_ids()));
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.tsk_labels TO authenticated;`
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createTasksPlugin(options?: TasksPluginOptions): PluginManifest {
+  const config = resolveConfig(options)
+  // Register locales globally so the plugin's translations resolve even when the
+  // host shell does not mount @fayz-ai/core's I18nProvider (incremental de-bridge).
+  registerTranslations(tasksLocales)
+  const provider = options?.dataProvider ?? createSafeDataProvider(
+    () => createSupabaseTasksProvider(),
+    () => createMockTasksProvider(),
+  )
+  const store = createTasksStore(provider)
+
+  return {
+    id: 'tasks',
+    name: config.labels.drawerTitle,
+    icon: 'CheckSquare',
+    version: '1.0.0',
+    scope: options?.scope ?? 'universal',
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: [],
+
+    navigation: [],
+
+    routes: [],
+
+    widgets: [
+      {
+        id: 'tasks-topbar-button',
+        zone: 'shell.topbar.end',
+        component: TasksTopbarButton as unknown as React.ComponentType<unknown>,
+        order: 10,
+        props: {
+          tasksConfig: config,
+          tasksProvider: provider,
+          tasksStore: store,
+        },
+      },
+    ],
+
+    aiTools: [
+      {
+        id: 'tasks.summary',
+        name: 'getTasksSummary',
+        description: 'Returns a summary of pending tasks: total, overdue, due today, by status and priority.',
+        icon: 'CheckSquare',
+        mode: 'read' as const,
+        category: 'Tasks',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            status: {
+              type: 'string' as const,
+              description: 'Filter by task status',
+              enum: ['todo', 'in_progress', 'done', 'cancelled', 'all'],
+            },
+          },
+        },
+        suggestions: [
+          { label: 'What tasks are overdue?' },
+          { label: 'How many tasks are pending?' },
+          { label: "What's due today?" },
+        ],
+      },
+    ],
+
+    registries: tasksRegistries,
+
+    settings: [
+      {
+        id: 'tasks',
+        label: config.labels.settingsTitle,
+        icon: 'CheckSquare',
+        component: (() => {
+          const Tab: React.FC = () =>
+            React.createElement(TasksContextProvider, { config, provider, store },
+              React.createElement(TasksGeneralSettings),
+            )
+          Tab.displayName = 'TasksSettingsTab'
+          return Tab as unknown as React.ComponentType<unknown>
+        })(),
+        order: 14,
+      },
+    ],
+
+    migrations: [
+      {
+        id: 'tasks-001-base-tables',
+        version: '1.0.0',
+        sql: MIGRATION_001,
+        description: 'Create tsk_tasks and tsk_labels tables',
+      },
+    ],
+
+    locales: tasksLocales,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Re-exports
+// ---------------------------------------------------------------------------
+
+export type { TasksDataProvider } from './data/types'
+export type { ResolvedTasksConfig, TasksPluginLabels } from './TasksContext'
+export type {
+  Task, TaskLabel, TaskStatus, TaskPriority, TasksSummary,
+  CreateTaskInput, UpdateTaskInput, TaskQuery,
+} from './types'

package/src/lib/tenant.ts

@@ -0,0 +1,13 @@
+// Current tenant id holder. The app/runtime sets this (runtime DI), decoupling
+// the plugin from any specific org store — previously this read saas-core's
+// organization.store. Defaults to undefined, in which case Supabase RLS scopes
+// queries by the authenticated session.
+let currentTenantId: string | undefined
+
+export function setTasksTenantId(id: string | undefined): void {
+  currentTenantId = id
+}
+
+export function getTasksTenantId(): string | undefined {
+  return currentTenantId
+}

package/src/locales/en.ts

@@ -0,0 +1,40 @@
+export const en: Record<string, string> = {
+  'tasks.title': 'Tasks',
+  'tasks.drawer.title': 'Tasks',
+  'tasks.drawer.subtitle': 'Manage your team tasks',
+  'tasks.quickAdd.placeholder': 'Add a task...',
+  'tasks.filter.all': 'All',
+  'tasks.filter.todo': 'To Do',
+  'tasks.filter.inProgress': 'In Progress',
+  'tasks.filter.done': 'Done',
+  'tasks.status.todo': 'To Do',
+  'tasks.status.in_progress': 'In Progress',
+  'tasks.status.done': 'Done',
+  'tasks.status.cancelled': 'Cancelled',
+  'tasks.priority.low': 'Low',
+  'tasks.priority.medium': 'Medium',
+  'tasks.priority.high': 'High',
+  'tasks.priority.urgent': 'Urgent',
+  'tasks.detail.description': 'Description',
+  'tasks.detail.descriptionPlaceholder': 'Add a description...',
+  'tasks.detail.status': 'Status',
+  'tasks.detail.priority': 'Priority',
+  'tasks.detail.dueDate': 'Due Date',
+  'tasks.detail.assignee': 'Assigned To',
+  'tasks.detail.labels': 'Labels',
+  'tasks.detail.subtasks': 'Subtasks',
+  'tasks.detail.delete': 'Delete Task',
+  'tasks.detail.deleteConfirm': 'Are you sure you want to delete this task?',
+  'tasks.detail.created': 'Created',
+  'tasks.detail.updated': 'Updated',
+  'tasks.detail.addSubtask': 'Add subtask...',
+  'tasks.detail.back': 'Back to list',
+  'tasks.summary.overdue': 'overdue',
+  'tasks.summary.dueToday': 'due today',
+  'tasks.empty': 'No tasks yet',
+  'tasks.empty.description': 'Add your first task using the input above',
+  'tasks.settings.title': 'Tasks',
+  'tasks.settings.general': 'General',
+  'tasks.settings.defaultPriority': 'Default Priority',
+  'tasks.settings.autoAssign': 'Auto-assign tasks to creator',
+}

package/src/locales/index.ts

@@ -0,0 +1,7 @@
+import { en } from './en'
+import { ptBR } from './pt-BR'
+
+export const tasksLocales: Record<string, Record<string, string>> = {
+  en,
+  'pt-BR': ptBR,
+}

package/src/locales/pt-BR.ts

@@ -0,0 +1,40 @@
+export const ptBR: Record<string, string> = {
+  'tasks.title': 'Tarefas',
+  'tasks.drawer.title': 'Tarefas',
+  'tasks.drawer.subtitle': 'Gerencie as tarefas da equipe',
+  'tasks.quickAdd.placeholder': 'Adicionar tarefa...',
+  'tasks.filter.all': 'Todas',
+  'tasks.filter.todo': 'A Fazer',
+  'tasks.filter.inProgress': 'Em Andamento',
+  'tasks.filter.done': 'Concluídas',
+  'tasks.status.todo': 'A Fazer',
+  'tasks.status.in_progress': 'Em Andamento',
+  'tasks.status.done': 'Concluída',
+  'tasks.status.cancelled': 'Cancelada',
+  'tasks.priority.low': 'Baixa',
+  'tasks.priority.medium': 'Média',
+  'tasks.priority.high': 'Alta',
+  'tasks.priority.urgent': 'Urgente',
+  'tasks.detail.description': 'Descrição',
+  'tasks.detail.descriptionPlaceholder': 'Adicionar descrição...',
+  'tasks.detail.status': 'Status',
+  'tasks.detail.priority': 'Prioridade',
+  'tasks.detail.dueDate': 'Data de Vencimento',
+  'tasks.detail.assignee': 'Responsável',
+  'tasks.detail.labels': 'Etiquetas',
+  'tasks.detail.subtasks': 'Subtarefas',
+  'tasks.detail.delete': 'Excluir Tarefa',
+  'tasks.detail.deleteConfirm': 'Tem certeza que deseja excluir esta tarefa?',
+  'tasks.detail.created': 'Criada em',
+  'tasks.detail.updated': 'Atualizada em',
+  'tasks.detail.addSubtask': 'Adicionar subtarefa...',
+  'tasks.detail.back': 'Voltar à lista',
+  'tasks.summary.overdue': 'atrasadas',
+  'tasks.summary.dueToday': 'vencem hoje',
+  'tasks.empty': 'Nenhuma tarefa ainda',
+  'tasks.empty.description': 'Adicione sua primeira tarefa usando o campo acima',
+  'tasks.settings.title': 'Tarefas',
+  'tasks.settings.general': 'Geral',
+  'tasks.settings.defaultPriority': 'Prioridade Padrão',
+  'tasks.settings.autoAssign': 'Atribuir tarefas automaticamente ao criador',
+}