task-o-matic 0.0.2 → 0.0.4

package/dist/services/tasks.js

@@ -1,9 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.taskService = exports.TaskService = void 0;
 const ai_service_factory_1 = require("../utils/ai-service-factory");
 const stack_formatter_1 = require("../utils/stack-formatter");
 const ai_config_builder_1 = require("../utils/ai-config-builder");
+const hooks_1 = require("../lib/hooks");
 /**
  * TaskService - Centralized business logic for all task operations
  * This service is framework-agnostic and can be used by CLI, TUI, or Web
@@ -17,16 +51,16 @@ class TaskService {
         let content = input.content;
         let aiMetadata;
         if (input.aiEnhance) {
-            input.callbacks?.onProgress?.({
-                type: 'progress',
-                message: 'Building context for task...',
+            hooks_1.hooks.emit("task:progress", {
+                message: "Building context for task...",
+                type: "progress",
             });
             const context = await (0, ai_service_factory_1.getContextBuilder)().buildContextForNewTask(input.title, input.content);
             const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
             const enhancementAIConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
-            input.callbacks?.onProgress?.({
-                type: 'progress',
-                message: 'Enhancing task with AI documentation...',
+            hooks_1.hooks.emit("task:progress", {
+                message: "Enhancing task with AI documentation...",
+                type: "progress",
             });
             const taskDescription = input.content ?? "";
             content = await (0, ai_service_factory_1.getAIOperations)().enhanceTaskWithDocumentation(`task-${Date.now()}`, input.title, taskDescription, stackInfo, input.streamingOptions, undefined, enhancementAIConfig, context.existingResearch);
@@ -41,9 +75,9 @@ class TaskService {
                 generatedAt: Date.now(),
             };
         }
-        input.callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Saving task...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Saving task...",
+            type: "progress",
         });
         const task = await (0, ai_service_factory_1.getStorage)().createTask({
             title: input.title,
@@ -52,10 +86,12 @@ class TaskService {
             parentId: input.parentId,
             estimatedEffort: input.effort,
         }, aiMetadata);
-        input.callbacks?.onProgress?.({
-            type: 'completed',
-            message: 'Task created successfully',
+        hooks_1.hooks.emit("task:progress", {
+            type: "completed",
+            message: "Task created successfully",
         });
+        // Emit task:created event
+        await hooks_1.hooks.emit("task:created", { task });
         return { success: true, task, aiMetadata };
     }
     async listTasks(filters) {
@@ -111,6 +147,19 @@ class TaskService {
         if (!updatedTask) {
             throw new Error(`Failed to update task ${id}`);
         }
+        // Emit task:updated event
+        await hooks_1.hooks.emit("task:updated", {
+            task: updatedTask,
+            changes: finalUpdates,
+        });
+        // Emit task:status-changed event if status changed
+        if (updates.status && updates.status !== existingTask.status) {
+            await hooks_1.hooks.emit("task:status-changed", {
+                task: updatedTask,
+                oldStatus: existingTask.status,
+                newStatus: updates.status,
+            });
+        }
         return updatedTask;
     }
     async setTaskStatus(id, status) {
@@ -140,7 +189,10 @@ class TaskService {
         else if (cascade) {
             // Recursively delete subtasks
             for (const subtask of subtasks) {
-                const result = await this.deleteTask(subtask.id, { cascade: true, force: true });
+                const result = await this.deleteTask(subtask.id, {
+                    cascade: true,
+                    force: true,
+                });
                 deleted.push(...result.deleted);
                 orphanedSubtasks.push(...result.orphanedSubtasks);
             }
@@ -149,6 +201,8 @@ class TaskService {
         const success = await storage.deleteTask(id);
         if (success) {
             deleted.push(taskToDelete);
+            // Emit task:deleted event
+            await hooks_1.hooks.emit("task:deleted", { taskId: id });
         }
         return { success: true, deleted, orphanedSubtasks };
     }
@@ -253,31 +307,31 @@ class TaskService {
     // ============================================================================
     // AI OPERATIONS
     // ============================================================================
-    async enhanceTask(taskId, aiOptions, streamingOptions, callbacks) {
+    async enhanceTask(taskId, aiOptions, streamingOptions) {
         const startTime = Date.now();
-        callbacks?.onProgress?.({
-            type: 'started',
-            message: 'Starting task enhancement...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Starting task enhancement...",
+            type: "started",
         });
         const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
         if (!task) {
             throw new Error(`Task with ID ${taskId} not found`);
         }
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Building context...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Building context...",
+            type: "progress",
         });
         const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
         const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
         const enhancementAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Calling AI for enhancement...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Calling AI for enhancement...",
+            type: "progress",
         });
         const enhancedContent = await (0, ai_service_factory_1.getAIOperations)().enhanceTaskWithDocumentation(task.id, task.title, task.description ?? "", stackInfo, streamingOptions, undefined, enhancementAIConfig, context.existingResearch);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Saving enhanced content...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Saving enhanced content...",
+            type: "progress",
         });
         const originalLength = task.description?.length || 0;
         if (enhancedContent.length > 200) {
@@ -303,9 +357,9 @@ class TaskService {
         };
         await (0, ai_service_factory_1.getStorage)().saveTaskAIMetadata(aiMetadata);
         const duration = Date.now() - startTime;
-        callbacks?.onProgress?.({
-            type: 'completed',
-            message: 'Task enhancement completed',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Task enhancement completed",
+            type: "completed",
         });
         return {
             success: true,
@@ -323,11 +377,11 @@ class TaskService {
             },
         };
     }
-    async splitTask(taskId, aiOptions, promptOverride, messageOverride, streamingOptions, callbacks) {
+    async splitTask(taskId, aiOptions, promptOverride, messageOverride, streamingOptions, enableFilesystemTools) {
         const startTime = Date.now();
-        callbacks?.onProgress?.({
-            type: 'started',
-            message: 'Starting task breakdown...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Starting task breakdown...",
+            type: "started",
         });
         const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
         if (!task) {
@@ -338,9 +392,9 @@ class TaskService {
         if (existingSubtasks.length > 0) {
             throw new Error(`Task ${task.title} already has ${existingSubtasks.length} subtasks. Use existing subtasks or delete them first.`);
         }
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Building context...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Building context...",
+            type: "progress",
         });
         // Build comprehensive context
         const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
@@ -348,25 +402,23 @@ class TaskService {
         // Get full task content
         const fullContent = context.task.fullContent || task.description || "";
         const breakdownAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Calling AI to break down task...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Calling AI to break down task...",
+            type: "progress",
         });
         // Use AI service to break down the task with enhanced context
-        const subtaskData = await (0, ai_service_factory_1.getAIOperations)().breakdownTask(task, breakdownAIConfig, promptOverride, messageOverride, streamingOptions, undefined, fullContent, stackInfo, existingSubtasks);
-        callbacks?.onProgress?.({
-            type: 'progress',
+        const subtaskData = await (0, ai_service_factory_1.getAIOperations)().breakdownTask(task, breakdownAIConfig, promptOverride, messageOverride, streamingOptions, undefined, fullContent, stackInfo, existingSubtasks, enableFilesystemTools);
+        hooks_1.hooks.emit("task:progress", {
             message: `Creating ${subtaskData.length} subtasks...`,
+            type: "progress",
         });
         // Create subtasks
         const createdSubtasks = [];
         for (let i = 0; i < subtaskData.length; i++) {
             const subtask = subtaskData[i];
-            callbacks?.onProgress?.({
-                type: 'progress',
+            hooks_1.hooks.emit("task:progress", {
                 message: `Creating subtask ${i + 1}/${subtaskData.length}: ${subtask.title}`,
-                current: i + 1,
-                total: subtaskData.length,
+                type: "progress",
             });
             const result = await this.createTask({
                 title: subtask.title,
@@ -390,9 +442,9 @@ class TaskService {
         };
         await (0, ai_service_factory_1.getStorage)().saveTaskAIMetadata(aiMetadata);
         const duration = Date.now() - startTime;
-        callbacks?.onProgress?.({
-            type: 'completed',
+        hooks_1.hooks.emit("task:progress", {
             message: `Task split into ${createdSubtasks.length} subtasks`,
+            type: "completed",
         });
         return {
             success: true,
@@ -409,11 +461,11 @@ class TaskService {
             },
         };
     }
-    async documentTask(taskId, force = false, aiOptions, streamingOptions, callbacks) {
+    async documentTask(taskId, force = false, aiOptions, streamingOptions) {
         const startTime = Date.now();
-        callbacks?.onProgress?.({
-            type: 'started',
-            message: 'Analyzing documentation needs...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Analyzing documentation needs...",
+            type: "started",
         });
         const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
         if (!task) {
@@ -421,9 +473,9 @@ class TaskService {
         }
         if (task.documentation && !force) {
             if ((0, ai_service_factory_1.getContextBuilder)().isDocumentationFresh(task.documentation)) {
-                callbacks?.onProgress?.({
-                    type: 'info',
-                    message: 'Documentation is fresh, skipping analysis',
+                hooks_1.hooks.emit("task:progress", {
+                    message: "Documentation is fresh, skipping analysis",
+                    type: "info",
                 });
                 return {
                     success: true,
@@ -435,9 +487,9 @@ class TaskService {
                 };
             }
         }
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Building context...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Building context...",
+            type: "progress",
         });
         const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
         const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
@@ -450,17 +502,17 @@ class TaskService {
         // Get existing documentations from all tasks
         const tasks = await (0, ai_service_factory_1.getStorage)().getTasks();
         const documentations = tasks.map((task) => task.documentation);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Calling AI to analyze documentation needs...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Calling AI to analyze documentation needs...",
+            type: "progress",
         });
         // First analyze what documentation is needed
         const analysis = await (0, ai_service_factory_1.getAIOperations)().analyzeDocumentationNeeds(task.id, task.title, fullContent, stackInfo, streamingOptions, undefined, analysisAIConfig, documentations);
         let documentation;
         if (analysis.libraries.length > 0) {
-            callbacks?.onProgress?.({
-                type: 'progress',
+            hooks_1.hooks.emit("task:progress", {
                 message: `Fetching documentation for ${analysis.libraries.length} libraries...`,
+                type: "progress",
             });
             // Build research object from actual libraries
             const research = {};
@@ -476,9 +528,9 @@ class TaskService {
                     doc: docFile,
                 });
             }
-            callbacks?.onProgress?.({
-                type: 'progress',
-                message: 'Generating documentation recap...',
+            hooks_1.hooks.emit("task:progress", {
+                message: "Generating documentation recap...",
+                type: "progress",
             });
             const recap = await (0, ai_service_factory_1.getAIOperations)().generateDocumentationRecap(analysis.libraries, analysis.toolResults?.map((tr) => ({
                 library: tr.toolName,
@@ -491,16 +543,16 @@ class TaskService {
                 files: analysis.files || [],
                 research,
             };
-            callbacks?.onProgress?.({
-                type: 'progress',
-                message: 'Saving documentation...',
+            hooks_1.hooks.emit("task:progress", {
+                message: "Saving documentation...",
+                type: "progress",
             });
             await (0, ai_service_factory_1.getStorage)().updateTask(taskId, { documentation });
         }
         const duration = Date.now() - startTime;
-        callbacks?.onProgress?.({
-            type: 'completed',
-            message: 'Documentation analysis completed',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Documentation analysis completed",
+            type: "completed",
         });
         return {
             success: true,
@@ -512,11 +564,11 @@ class TaskService {
             },
         };
     }
-    async planTask(taskId, aiOptions, streamingOptions, callbacks) {
+    async planTask(taskId, aiOptions, streamingOptions) {
         const startTime = Date.now();
-        callbacks?.onProgress?.({
-            type: 'started',
-            message: 'Creating implementation plan...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Creating implementation plan...",
+            type: "started",
         });
         const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
         if (!task) {
@@ -524,9 +576,9 @@ class TaskService {
         }
         const aiService = (0, ai_service_factory_1.getAIOperations)();
         const planAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Building task context...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Building task context...",
+            type: "progress",
         });
         // Build task context and details
         let taskContext = `Task ID: ${task.id}\nTitle: ${task.title}\n`;
@@ -548,21 +600,21 @@ class TaskService {
                 taskDetails += `   ${subtask.description || "No description"}\n\n`;
             });
         }
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Calling AI to create plan...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Calling AI to create plan...",
+            type: "progress",
         });
         const plan = await aiService.planTask(taskContext, taskDetails, planAIConfig, undefined, undefined, streamingOptions);
-        callbacks?.onProgress?.({
-            type: 'progress',
-            message: 'Saving plan...',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Saving plan...",
+            type: "progress",
         });
         // Save the plan to storage
         await (0, ai_service_factory_1.getStorage)().savePlan(taskId, plan);
         const duration = Date.now() - startTime;
-        callbacks?.onProgress?.({
-            type: 'completed',
-            message: 'Implementation plan created',
+        hooks_1.hooks.emit("task:progress", {
+            message: "Implementation plan created",
+            type: "completed",
         });
         const aiConfig = (0, ai_service_factory_1.getModelProvider)().getAIConfig();
         return {
@@ -579,6 +631,68 @@ class TaskService {
         };
     }
     // ============================================================================
+    // DOCUMENTATION OPERATIONS
+    // ============================================================================
+    async getTaskDocumentation(taskId) {
+        return (0, ai_service_factory_1.getStorage)().getTaskDocumentation(taskId);
+    }
+    async addTaskDocumentationFromFile(taskId, filePath) {
+        const task = await this.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        try {
+            const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require("fs")));
+            const { resolve } = await Promise.resolve().then(() => __importStar(require("path")));
+            const resolvedPath = resolve(filePath);
+            if (!existsSync(resolvedPath)) {
+                throw new Error(`Documentation file not found: ${filePath}`);
+            }
+            const content = readFileSync(resolvedPath, "utf-8");
+            const savedPath = await (0, ai_service_factory_1.getStorage)().saveTaskDocumentation(taskId, content);
+            return {
+                filePath: savedPath,
+                task,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to add documentation from file: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async setTaskPlan(taskId, planText, planFilePath) {
+        const task = await this.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        let plan;
+        if (planFilePath) {
+            try {
+                const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require("fs")));
+                const { resolve } = await Promise.resolve().then(() => __importStar(require("path")));
+                const resolvedPath = resolve(planFilePath);
+                if (!existsSync(resolvedPath)) {
+                    throw new Error(`Plan file not found: ${planFilePath}`);
+                }
+                plan = readFileSync(resolvedPath, "utf-8");
+            }
+            catch (error) {
+                throw new Error(`Failed to read plan file: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        else if (planText) {
+            plan = planText;
+        }
+        else {
+            throw new Error("Either planText or planFilePath must be provided");
+        }
+        await (0, ai_service_factory_1.getStorage)().savePlan(taskId, plan);
+        const planFile = `plans/${taskId}.md`;
+        return {
+            planFile,
+            task,
+        };
+    }
+    // ============================================================================
     // PLAN OPERATIONS
     // ============================================================================
     async getTaskPlan(taskId) {

package/dist/services/workflow-ai-assistant.d.ts

@@ -0,0 +1,74 @@
+import { StreamingOptions } from "../types";
+import { AIOptions } from "../utils/ai-config-builder";
+/**
+ * WorkflowAIAssistant - AI-powered decision making for workflow steps
+ * Helps users make configuration choices using natural language
+ */
+export declare class WorkflowAIAssistant {
+    /**
+     * Assist with initialization and bootstrap configuration
+     */
+    assistInitConfig(input: {
+        userDescription: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<{
+        projectName: string;
+        aiProvider: string;
+        aiModel: string;
+        frontend?: string;
+        backend?: string;
+        database?: string;
+        auth?: boolean;
+        reasoning: string;
+    }>;
+    /**
+     * Generate a PRD from user's product description
+     */
+    assistPRDCreation(input: {
+        userDescription: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+    /**
+     * Suggest improvements to an existing PRD
+     */
+    assistPRDRefinement(input: {
+        currentPRD: string;
+        userFeedback: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+    /**
+     * Help prioritize and organize tasks
+     */
+    assistTaskPrioritization(input: {
+        tasks: Array<{
+            id: string;
+            title: string;
+            description?: string;
+        }>;
+        userGuidance: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<{
+        prioritizedTasks: Array<{
+            id: string;
+            priority: number;
+            reasoning: string;
+        }>;
+        recommendations: string;
+    }>;
+    /**
+     * Generate custom instructions for task splitting
+     */
+    assistTaskSplitting(input: {
+        taskTitle: string;
+        taskContent?: string;
+        userGuidance: string;
+        aiOptions?: AIOptions;
+        streamingOptions?: StreamingOptions;
+    }): Promise<string>;
+}
+export declare const workflowAIAssistant: WorkflowAIAssistant;
+//# sourceMappingURL=workflow-ai-assistant.d.ts.map

package/dist/services/workflow-ai-assistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-ai-assistant.d.ts","sourceRoot":"","sources":["../../src/services/workflow-ai-assistant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,EAAiB,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAGtE;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACG,gBAAgB,CAAC,KAAK,EAAE;QAC5B,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IA+DF;;OAEG;IACG,iBAAiB,CAAC,KAAK,EAAE;QAC7B,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;IAmDnB;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;IA+BnB;;OAEG;IACG,wBAAwB,CAAC,KAAK,EAAE;QACpC,KAAK,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAClE,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC;QACV,gBAAgB,EAAE,KAAK,CAAC;YACtB,EAAE,EAAE,MAAM,CAAC;YACX,QAAQ,EAAE,MAAM,CAAC;YACjB,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC,CAAC;QACH,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;IA+DF;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE;QAC/B,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;KACrC,GAAG,OAAO,CAAC,MAAM,CAAC;CA6BpB;AAGD,eAAO,MAAM,mBAAmB,qBAA4B,CAAC"}