@nextsparkjs/theme-default 0.1.0-beta.1

package/lib/langchain/handlers/page-handler.ts

@@ -0,0 +1,232 @@
+/**
+ * Page Handler Node
+ *
+ * Executes page operations directly without additional LLM calls.
+ * Uses the PagesService to perform read operations.
+ */
+
+import { PagesService } from '@/themes/default/entities/pages/pages.service'
+import { config as pluginConfig } from '@/plugins/langchain/plugin.config'
+import { createAgentLogger } from '@/plugins/langchain/lib/logger'
+import type { OrchestratorState, PageHandlerResult, PageData, IntentType } from '@/plugins/langchain/lib/graph/types'
+
+/**
+ * Transform Page entity to PageData for handler result
+ */
+function toPageData(page: any): PageData {
+    return {
+        id: page.id,
+        title: page.title,
+        slug: page.slug,
+        status: page.status,
+        locale: page.locale,
+    }
+}
+
+/**
+ * Execute page operation based on intent
+ */
+async function executePageOperation(
+    action: string,
+    parameters: Record<string, unknown>,
+    context: { userId: string; teamId: string }
+): Promise<PageHandlerResult> {
+    const { userId } = context
+
+    try {
+        switch (action) {
+            case 'list': {
+                const locale = (parameters.locale as string) || 'en'
+                const { pages, total } = await PagesService.listPublished({
+                    locale,
+                    limit: 50,
+                    orderBy: 'createdAt',
+                    orderDir: 'desc',
+                })
+
+                return {
+                    success: true,
+                    operation: 'list',
+                    data: pages.map(toPageData),
+                    count: total,
+                    message: `Found ${total} published page(s)`,
+                }
+            }
+
+            case 'get': {
+                const id = parameters.id as string
+                const slug = parameters.slug as string
+
+                if (slug) {
+                    const locale = (parameters.locale as string) || 'en'
+                    const page = await PagesService.getPublishedBySlug(slug, locale)
+                    if (!page) {
+                        return {
+                            success: false,
+                            operation: 'get',
+                            data: null,
+                            message: `Page with slug "${slug}" not found`,
+                            error: 'Page not found',
+                        }
+                    }
+                    return {
+                        success: true,
+                        operation: 'get',
+                        data: toPageData(page),
+                        message: `Found page: ${page.title}`,
+                    }
+                }
+
+                if (id) {
+                    const page = await PagesService.getById(id, userId)
+                    if (!page) {
+                        return {
+                            success: false,
+                            operation: 'get',
+                            data: null,
+                            message: 'Page not found',
+                            error: 'Page not found',
+                        }
+                    }
+                    return {
+                        success: true,
+                        operation: 'get',
+                        data: toPageData(page),
+                        message: `Found page: ${page.title}`,
+                    }
+                }
+
+                return {
+                    success: false,
+                    operation: 'get',
+                    data: null,
+                    message: 'Page ID or slug is required',
+                    error: 'Missing page identifier',
+                }
+            }
+
+            case 'search': {
+                // Pages don't have a search method, so list and filter
+                const query = (parameters.query as string)?.toLowerCase()
+                const locale = (parameters.locale as string) || 'en'
+
+                const { pages } = await PagesService.listPublished({
+                    locale,
+                    limit: 100,
+                })
+
+                let filteredPages = pages
+                if (query) {
+                    filteredPages = pages.filter(
+                        (p) =>
+                            p.title.toLowerCase().includes(query) ||
+                            p.slug.toLowerCase().includes(query)
+                    )
+                }
+
+                return {
+                    success: true,
+                    operation: 'search',
+                    data: filteredPages.map(toPageData),
+                    count: filteredPages.length,
+                    message: `Found ${filteredPages.length} page(s) matching "${query}"`,
+                }
+            }
+
+            case 'create':
+            case 'update':
+            case 'delete':
+                // These operations are not supported through the AI agent
+                return {
+                    success: false,
+                    operation: action as any,
+                    data: null,
+                    message: `Page ${action} is not supported through the AI assistant. Please use the page builder.`,
+                    error: 'Operation not supported',
+                }
+
+            default:
+                return {
+                    success: false,
+                    operation: 'unknown',
+                    data: null,
+                    message: `Unknown action: ${action}`,
+                    error: `Unsupported action: ${action}`,
+                }
+        }
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+        return {
+            success: false,
+            operation: action as any,
+            data: null,
+            message: `Failed to execute ${action}: ${errorMessage}`,
+            error: errorMessage,
+        }
+    }
+}
+
+/**
+ * Page handler node
+ *
+ * Executes page operations without additional LLM calls.
+ * Returns JSON result for combiner to format.
+ */
+export async function pageHandlerNode(
+    state: OrchestratorState
+): Promise<Partial<OrchestratorState>> {
+    const { context, loggerTimestamp } = state
+    const logger = createAgentLogger({
+        agentName: 'graph-orchestrator',
+        userName: (context.userName as string) || 'system',
+        timestamp: loggerTimestamp,
+    })
+
+    // Find page intent
+    const pageIntent = state.intents.find((i) => i.type === 'page')
+
+    if (!pageIntent) {
+        // No page intent, skip
+        return {
+            completedHandlers: [...state.completedHandlers, 'page' as IntentType],
+        }
+    }
+
+    await logger.info('PAGE_HANDLER_INPUT', {
+        action: pageIntent.action,
+        parameters: pageIntent.parameters,
+    })
+
+    if (pluginConfig.debug) {
+        console.log('[PageHandler] Executing:', pageIntent.action, pageIntent.parameters)
+    }
+
+    const result = await executePageOperation(
+        pageIntent.action,
+        pageIntent.parameters,
+        {
+            userId: state.context.userId,
+            teamId: state.context.teamId as string,
+        }
+    )
+
+    await logger.info('PAGE_HANDLER_OUTPUT', {
+        success: result.success,
+        operation: result.operation,
+        message: result.message,
+        count: result.count,
+        data: result.data,
+    })
+
+    if (pluginConfig.debug) {
+        console.log('[PageHandler] Result:', result.success, result.message)
+    }
+
+    return {
+        handlerResults: {
+            ...state.handlerResults,
+            page: result,
+        },
+        completedHandlers: [...state.completedHandlers, 'page' as IntentType],
+    }
+}

package/lib/langchain/handlers/task-handler.ts

@@ -0,0 +1,323 @@
+/**
+ * Task Handler Node
+ *
+ * Executes task operations directly without additional LLM calls.
+ * Uses the TasksService to perform CRUD operations.
+ */
+
+import { TasksService } from '@/themes/default/entities/tasks/tasks.service'
+import { tracer } from '@/plugins/langchain/lib/tracer'
+import { config as pluginConfig } from '@/plugins/langchain/plugin.config'
+import { createAgentLogger } from '@/plugins/langchain/lib/logger'
+import type { OrchestratorState, TaskHandlerResult, TaskData, IntentType } from '@/plugins/langchain/lib/graph/types'
+
+/**
+ * Map priority strings to valid values
+ */
+function normalizePriority(priority?: unknown): 'low' | 'medium' | 'high' | 'urgent' | undefined {
+    if (!priority) return undefined
+    const p = String(priority).toLowerCase()
+    if (['low', 'medium', 'high', 'urgent'].includes(p)) {
+        return p as 'low' | 'medium' | 'high' | 'urgent'
+    }
+    return undefined
+}
+
+/**
+ * Map status strings to valid values
+ */
+function normalizeStatus(status?: unknown): 'todo' | 'in-progress' | 'review' | 'done' | 'blocked' | undefined {
+    if (!status) return undefined
+    const s = String(status).toLowerCase().replace(/[_-]/g, '-')
+    if (s === 'pending' || s === 'todo') return 'todo'
+    if (s === 'in-progress' || s === 'inprogress') return 'in-progress'
+    if (s === 'review') return 'review'
+    if (s === 'done' || s === 'completed' || s === 'complete') return 'done'
+    if (s === 'blocked') return 'blocked'
+    return undefined
+}
+
+/**
+ * Transform Task entity to TaskData for handler result
+ */
+function toTaskData(task: any): TaskData {
+    return {
+        id: task.id,
+        title: task.title,
+        status: task.status,
+        priority: task.priority,
+        dueDate: task.dueDate,
+        description: task.description,
+    }
+}
+
+/**
+ * Execute task operation based on intent
+ */
+async function executeTaskOperation(
+    action: string,
+    parameters: Record<string, unknown>,
+    context: { userId: string; teamId: string }
+): Promise<TaskHandlerResult> {
+    const { userId, teamId } = context
+
+    try {
+        switch (action) {
+            case 'list': {
+                const priority = normalizePriority(parameters.priority)
+                const status = normalizeStatus(parameters.status)
+
+                const { tasks, total } = await TasksService.list(userId, {
+                    priority,
+                    status,
+                    teamId,
+                    limit: 50,
+                    orderBy: 'createdAt',
+                    orderDir: 'desc',
+                })
+
+                return {
+                    success: true,
+                    operation: 'list',
+                    data: tasks.map(toTaskData),
+                    count: total,
+                    message: `Found ${total} task(s)`,
+                }
+            }
+
+            case 'get': {
+                const id = parameters.id as string
+                if (!id) {
+                    return {
+                        success: false,
+                        operation: 'get',
+                        data: null,
+                        message: 'Task ID is required',
+                        error: 'Missing task ID',
+                    }
+                }
+
+                const task = await TasksService.getById(id, userId)
+                if (!task) {
+                    return {
+                        success: false,
+                        operation: 'get',
+                        data: null,
+                        message: 'Task not found',
+                        error: 'Task not found',
+                    }
+                }
+
+                return {
+                    success: true,
+                    operation: 'get',
+                    data: toTaskData(task),
+                    message: `Found task: ${task.title}`,
+                }
+            }
+
+            case 'create': {
+                const title = parameters.title as string
+                if (!title) {
+                    return {
+                        success: false,
+                        operation: 'create',
+                        data: null,
+                        message: 'Task title is required',
+                        error: 'Missing title',
+                    }
+                }
+
+                const task = await TasksService.create(userId, {
+                    title,
+                    description: parameters.description as string | undefined,
+                    priority: normalizePriority(parameters.priority) || 'medium',
+                    status: normalizeStatus(parameters.status) || 'todo',
+                    dueDate: parameters.dueDate as string | undefined,
+                    teamId,
+                })
+
+                return {
+                    success: true,
+                    operation: 'create',
+                    data: toTaskData(task),
+                    message: `Created task: ${task.title}`,
+                }
+            }
+
+            case 'update': {
+                const id = parameters.id as string
+                if (!id) {
+                    return {
+                        success: false,
+                        operation: 'update',
+                        data: null,
+                        message: 'Task ID is required',
+                        error: 'Missing task ID',
+                    }
+                }
+
+                const updateData: Record<string, unknown> = {}
+                if (parameters.title) updateData.title = parameters.title
+                if (parameters.description !== undefined) updateData.description = parameters.description
+                if (parameters.priority) updateData.priority = normalizePriority(parameters.priority)
+                if (parameters.status) updateData.status = normalizeStatus(parameters.status)
+                if (parameters.dueDate) updateData.dueDate = parameters.dueDate
+
+                const task = await TasksService.update(userId, id, updateData)
+
+                return {
+                    success: true,
+                    operation: 'update',
+                    data: toTaskData(task),
+                    message: `Updated task: ${task.title}`,
+                }
+            }
+
+            case 'search': {
+                // For tasks, search is similar to list with filters
+                const query = parameters.query as string
+                const priority = normalizePriority(parameters.priority)
+                const status = normalizeStatus(parameters.status)
+
+                const { tasks, total } = await TasksService.list(userId, {
+                    priority,
+                    status,
+                    teamId,
+                    limit: 20,
+                })
+
+                // Filter by query if provided (title contains)
+                let filteredTasks = tasks
+                if (query) {
+                    const lowerQuery = query.toLowerCase()
+                    filteredTasks = tasks.filter(
+                        (t) =>
+                            t.title.toLowerCase().includes(lowerQuery) ||
+                            t.description?.toLowerCase().includes(lowerQuery)
+                    )
+                }
+
+                return {
+                    success: true,
+                    operation: 'search',
+                    data: filteredTasks.map(toTaskData),
+                    count: filteredTasks.length,
+                    message: `Found ${filteredTasks.length} matching task(s)`,
+                }
+            }
+
+            default:
+                return {
+                    success: false,
+                    operation: 'unknown',
+                    data: null,
+                    message: `Unknown action: ${action}`,
+                    error: `Unsupported action: ${action}`,
+                }
+        }
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+        return {
+            success: false,
+            operation: action as any,
+            data: null,
+            message: `Failed to execute ${action}: ${errorMessage}`,
+            error: errorMessage,
+        }
+    }
+}
+
+/**
+ * Task handler node
+ *
+ * Executes task operations without additional LLM calls.
+ * Returns JSON result for combiner to format.
+ */
+export async function taskHandlerNode(
+    state: OrchestratorState
+): Promise<Partial<OrchestratorState>> {
+    const { context, traceId, loggerTimestamp } = state
+    const logger = createAgentLogger({
+        agentName: 'graph-orchestrator',
+        userName: (context.userName as string) || 'system',
+        timestamp: loggerTimestamp,
+    })
+
+    // Find task intent
+    const taskIntent = state.intents.find((i) => i.type === 'task')
+
+    if (!taskIntent) {
+        // No task intent, skip
+        return {
+            completedHandlers: [...state.completedHandlers, 'task' as IntentType],
+        }
+    }
+
+    // Start span for task handler
+    const spanContext = traceId
+        ? await tracer.startSpan(
+              { userId: context.userId, teamId: context.teamId },
+              traceId,
+              {
+                  name: 'task-handler',
+                  type: 'tool',
+                  toolName: `task_${taskIntent.action}`,
+                  input: taskIntent.parameters,
+              }
+          )
+        : null
+
+    await logger.info('TASK_HANDLER_INPUT', {
+        action: taskIntent.action,
+        parameters: taskIntent.parameters,
+    })
+
+    if (pluginConfig.debug) {
+        console.log('[TaskHandler] Executing:', taskIntent.action, taskIntent.parameters)
+    }
+
+    const result = await executeTaskOperation(
+        taskIntent.action,
+        taskIntent.parameters,
+        {
+            userId: state.context.userId,
+            teamId: state.context.teamId as string,
+        }
+    )
+
+    await logger.info('TASK_HANDLER_OUTPUT', {
+        success: result.success,
+        operation: result.operation,
+        message: result.message,
+        count: result.count,
+        data: result.data,
+    })
+
+    if (pluginConfig.debug) {
+        console.log('[TaskHandler] Result:', result.success, result.message)
+    }
+
+    // End span
+    if (spanContext && traceId) {
+        await tracer.endSpan(
+            { userId: context.userId, teamId: context.teamId },
+            traceId,
+            spanContext.spanId,
+            {
+                output: { success: result.success, message: result.message, count: result.count },
+                toolInput: taskIntent.parameters,
+                toolOutput: result,
+                error: result.error ? new Error(result.error) : undefined,
+            }
+        )
+    }
+
+    return {
+        handlerResults: {
+            ...state.handlerResults,
+            task: result,
+        },
+        completedHandlers: [...state.completedHandlers, 'task' as IntentType],
+    }
+}