@e0ipso/ai-task-manager 1.18.6 → 1.19.0

package/templates/ai-task-manager/config/scripts/get-approval-methods.cjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Enable debug logging via environment variable
+const DEBUG = process.env.DEBUG === 'true';
+
+/**
+ * Debug logging utility
+ * @param {string} message - Debug message
+ * @param {...any} args - Additional arguments to log
+ */
+function debugLog(message, ...args) {
+  if (DEBUG) {
+    console.error(`[DEBUG] ${message}`, ...args);
+  }
+}
+
+/**
+ * Error logging utility
+ * @param {string} message - Error message
+ * @param {...any} args - Additional arguments to log
+ */
+function errorLog(message, ...args) {
+  console.error(`[ERROR] ${message}`, ...args);
+}
+
+/**
+ * Find the task manager root directory by traversing up from current working directory
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const filesystemRoot = path.parse(currentPath).root;
+
+  debugLog(`Starting search for task manager root from: ${currentPath}`);
+
+  while (currentPath !== filesystemRoot) {
+    const taskManagerPlansPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    debugLog(`Checking for task manager at: ${taskManagerPlansPath}`);
+
+    try {
+      if (fs.existsSync(taskManagerPlansPath)) {
+        const stats = fs.lstatSync(taskManagerPlansPath);
+        if (stats.isDirectory()) {
+          const taskManagerRoot = path.join(currentPath, '.ai', 'task-manager');
+          debugLog(`Found valid task manager root at: ${taskManagerRoot}`);
+          return taskManagerRoot;
+        }
+      }
+    } catch (err) {
+      debugLog(`Filesystem error checking ${taskManagerPlansPath}: ${err.message}`);
+    }
+
+    const parentPath = path.dirname(currentPath);
+    if (parentPath === currentPath) {
+      break;
+    }
+
+    currentPath = parentPath;
+  }
+
+  debugLog(`Task manager root not found in any parent directory`);
+  return null;
+}
+
+/**
+ * Find plan file by ID in plans or archive directories
+ * @param {string} taskManagerRoot - Path to task manager root
+ * @param {string} planId - Plan ID to find
+ * @returns {string|null} Path to plan file or null if not found
+ */
+function findPlanFile(taskManagerRoot, planId) {
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+
+  debugLog(`Searching for plan ${planId} in ${plansDir} and ${archiveDir}`);
+
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      debugLog(`Directory does not exist: ${dir}`);
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.match(/^\d+--/)) {
+          // Check if directory matches plan ID
+          const dirMatch = entry.name.match(/^(\d+)--/);
+          if (dirMatch && dirMatch[1] === planId) {
+            const planDirPath = path.join(dir, entry.name);
+            debugLog(`Found plan directory: ${planDirPath}`);
+
+            // Look for plan file inside directory
+            try {
+              const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
+
+              for (const planEntry of planDirEntries) {
+                if (planEntry.isFile() && planEntry.name.match(/^plan-\d+--.*\.md$/)) {
+                  const planFilePath = path.join(planDirPath, planEntry.name);
+                  debugLog(`Found plan file: ${planFilePath}`);
+                  return planFilePath;
+                }
+              }
+            } catch (err) {
+              debugLog(`Failed to read plan directory ${planDirPath}: ${err.message}`);
+            }
+          }
+        } else if (entry.isFile() && entry.name.match(/^plan-\d+--.*\.md$/)) {
+          // Legacy: direct plan file in plans/archive directory
+          const filenameMatch = entry.name.match(/^plan-(\d+)--/);
+          if (filenameMatch && filenameMatch[1] === planId) {
+            const planFilePath = path.join(dir, entry.name);
+            debugLog(`Found legacy plan file: ${planFilePath}`);
+            return planFilePath;
+          }
+        }
+      }
+    } catch (err) {
+      errorLog(`Failed to read directory ${dir}: ${err.message}`);
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract a field value from YAML frontmatter
+ * @param {string} frontmatter - YAML frontmatter text
+ * @param {string} fieldName - Field name to extract
+ * @param {string} defaultValue - Default value if field not found
+ * @returns {string} Field value or default
+ */
+function extractField(frontmatter, fieldName, defaultValue = 'manual') {
+  debugLog(`Extracting field: ${fieldName}`);
+
+  // Pattern to match field with various formatting:
+  // - field: value
+  // - field: "value"
+  // - field: 'value'
+  // - "field": value
+  // - field : value (extra spaces)
+  const regex = new RegExp(`^\\s*["']?${fieldName}["']?\\s*:\\s*(.+)$`, 'm');
+  const match = frontmatter.match(regex);
+
+  if (!match) {
+    debugLog(`Field ${fieldName} not found, using default: ${defaultValue}`);
+    return defaultValue;
+  }
+
+  // Clean up value: remove quotes and trim
+  let value = match[1].trim();
+  value = value.replace(/^['"]|['"]$/g, '');
+
+  debugLog(`Extracted ${fieldName}: ${value}`);
+  return value || defaultValue;
+}
+
+/**
+ * Main function to get approval methods from plan file
+ */
+function main() {
+  // Get plan ID from command line
+  const planId = process.argv[2];
+  if (!planId) {
+    errorLog('Error: Plan ID is required');
+    console.error('Usage: node get-approval-methods.cjs <plan-id>');
+    process.exit(1);
+  }
+
+  debugLog(`Looking for plan ID: ${planId}`);
+
+  // Find task manager root
+  const taskManagerRoot = findTaskManagerRoot();
+  if (!taskManagerRoot) {
+    errorLog('No .ai/task-manager directory found in current directory or any parent directory.');
+    errorLog('Please ensure you are in a project with task manager initialized.');
+    errorLog(`Current working directory: ${process.cwd()}`);
+    process.exit(1);
+  }
+
+  // Find plan file
+  const planFile = findPlanFile(taskManagerRoot, planId);
+  if (!planFile) {
+    errorLog(`Plan file for ID ${planId} not found in plans or archive directories.`);
+    process.exit(1);
+  }
+
+  debugLog(`Reading plan file: ${planFile}`);
+
+  // Read plan file
+  let content;
+  try {
+    content = fs.readFileSync(planFile, 'utf8');
+  } catch (err) {
+    errorLog(`Failed to read plan file ${planFile}: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Extract YAML frontmatter
+  const frontmatterRegex = /^---\s*\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+
+  if (!match) {
+    errorLog('No YAML frontmatter found in plan file');
+    process.exit(1);
+  }
+
+  const frontmatter = match[1];
+  debugLog(`Found frontmatter:\n${frontmatter}`);
+
+  // Extract approval method fields
+  const approvalMethodPlan = extractField(frontmatter, 'approval_method_plan');
+  const approvalMethodTasks = extractField(frontmatter, 'approval_method_tasks');
+
+  // Output JSON
+  const result = {
+    approval_method_plan: approvalMethodPlan,
+    approval_method_tasks: approvalMethodTasks
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// Run main function
+main();

package/templates/ai-task-manager/config/scripts/validate-plan-blueprint.cjs

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Enable debug logging via environment variable
+const DEBUG = process.env.DEBUG === 'true';
+
+/**
+ * Debug logging utility
+ * @param {string} message - Debug message
+ * @param {...any} args - Additional arguments to log
+ */
+function debugLog(message, ...args) {
+  if (DEBUG) {
+    console.error(`[DEBUG] ${message}`, ...args);
+  }
+}
+
+/**
+ * Error logging utility
+ * @param {string} message - Error message
+ * @param {...any} args - Additional arguments to log
+ */
+function errorLog(message, ...args) {
+  console.error(`[ERROR] ${message}`, ...args);
+}
+
+/**
+ * Find the task manager root directory by traversing up from current working directory
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const filesystemRoot = path.parse(currentPath).root;
+
+  debugLog(`Starting search for task manager root from: ${currentPath}`);
+  debugLog(`Filesystem root: ${filesystemRoot}`);
+
+  while (currentPath !== filesystemRoot) {
+    const taskManagerPlansPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    debugLog(`Checking for task manager at: ${taskManagerPlansPath}`);
+
+    try {
+      if (fs.existsSync(taskManagerPlansPath)) {
+        const stats = fs.lstatSync(taskManagerPlansPath);
+        if (stats.isDirectory()) {
+          const taskManagerRoot = path.join(currentPath, '.ai', 'task-manager');
+          debugLog(`Found valid task manager root at: ${taskManagerRoot}`);
+          return taskManagerRoot;
+        } else {
+          debugLog(`Path exists but is not a directory: ${taskManagerPlansPath}`);
+        }
+      } else {
+        debugLog(`Task manager path does not exist: ${taskManagerPlansPath}`);
+      }
+    } catch (err) {
+      if (err.code === 'EPERM' || err.code === 'EACCES') {
+        const warningMsg = `Warning: Permission denied accessing ${taskManagerPlansPath}`;
+        console.warn(warningMsg);
+        debugLog(`Permission error: ${err.message}`);
+      } else {
+        debugLog(`Filesystem error checking ${taskManagerPlansPath}: ${err.message}`);
+      }
+    }
+
+    const parentPath = path.dirname(currentPath);
+
+    if (parentPath === currentPath) {
+      debugLog(`Reached filesystem root, stopping traversal`);
+      break;
+    }
+
+    currentPath = parentPath;
+    debugLog(`Moving up to parent directory: ${currentPath}`);
+  }
+
+  debugLog(`Task manager root not found in any parent directory`);
+  return null;
+}
+
+/**
+ * Find plan file and directory for a given plan ID
+ * @param {string|number} planId - Plan ID to search for
+ * @returns {Object|null} Object with planFile and planDir, or null if not found
+ */
+function findPlanById(planId) {
+  const taskManagerRoot = findTaskManagerRoot();
+
+  if (!taskManagerRoot) {
+    errorLog('No .ai/task-manager directory found in current directory or any parent directory.');
+    return null;
+  }
+
+  debugLog(`Task manager root found: ${taskManagerRoot}`);
+
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+
+  debugLog(`Searching for plan ID ${planId} in: ${plansDir}, ${archiveDir}`);
+
+  // Search both plans and archive directories
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      debugLog(`Directory does not exist: ${dir}`);
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      debugLog(`Found ${entries.length} entries in ${dir}`);
+
+      for (const entry of entries) {
+        // Match directory pattern: [plan-id]--*
+        if (entry.isDirectory() && entry.name.match(new RegExp(`^${planId}--`))) {
+          const planDirPath = path.join(dir, entry.name);
+          debugLog(`Found matching plan directory: ${planDirPath}`);
+
+          try {
+            const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
+
+            // Look for plan file: plan-[plan-id]--*.md
+            for (const planEntry of planDirEntries) {
+              if (planEntry.isFile() && planEntry.name.match(new RegExp(`^plan-${planId}--.*\\.md$`))) {
+                const planFilePath = path.join(planDirPath, planEntry.name);
+                debugLog(`Found plan file: ${planFilePath}`);
+
+                return {
+                  planFile: planFilePath,
+                  planDir: planDirPath
+                };
+              }
+            }
+
+            debugLog(`No plan file found in directory: ${planDirPath}`);
+          } catch (err) {
+            errorLog(`Failed to read plan directory ${planDirPath}: ${err.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      errorLog(`Failed to read directory ${dir}: ${err.message}`);
+    }
+  }
+
+  debugLog(`Plan ID ${planId} not found in any directory`);
+  return null;
+}
+
+/**
+ * Count task files in a plan's tasks directory
+ * @param {string} planDir - Plan directory path
+ * @returns {number} Number of task files found
+ */
+function countTasks(planDir) {
+  const tasksDir = path.join(planDir, 'tasks');
+
+  if (!fs.existsSync(tasksDir)) {
+    debugLog(`Tasks directory does not exist: ${tasksDir}`);
+    return 0;
+  }
+
+  try {
+    const stats = fs.lstatSync(tasksDir);
+    if (!stats.isDirectory()) {
+      debugLog(`Tasks path exists but is not a directory: ${tasksDir}`);
+      return 0;
+    }
+
+    const files = fs.readdirSync(tasksDir).filter(f => f.endsWith('.md'));
+    debugLog(`Found ${files.length} task files in ${tasksDir}`);
+    return files.length;
+  } catch (err) {
+    errorLog(`Failed to read tasks directory ${tasksDir}: ${err.message}`);
+    return 0;
+  }
+}
+
+/**
+ * Check if execution blueprint section exists in plan file
+ * @param {string} planFile - Path to plan file
+ * @returns {boolean} True if blueprint section exists, false otherwise
+ */
+function checkBlueprintExists(planFile) {
+  try {
+    const planContent = fs.readFileSync(planFile, 'utf8');
+    const blueprintExists = /^## Execution Blueprint/m.test(planContent);
+    debugLog(`Blueprint section ${blueprintExists ? 'found' : 'not found'} in ${planFile}`);
+    return blueprintExists;
+  } catch (err) {
+    errorLog(`Failed to read plan file ${planFile}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * List available plans for error messaging
+ * @returns {string[]} Array of plan directory names
+ */
+function listAvailablePlans() {
+  const taskManagerRoot = findTaskManagerRoot();
+
+  if (!taskManagerRoot) {
+    return [];
+  }
+
+  const plansDir = path.join(taskManagerRoot, 'plans');
+  const archiveDir = path.join(taskManagerRoot, 'archive');
+  const plans = [];
+
+  for (const dir of [plansDir, archiveDir]) {
+    if (!fs.existsSync(dir)) {
+      continue;
+    }
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.match(/^\d+--/)) {
+          plans.push(entry.name);
+        }
+      }
+    } catch (err) {
+      // Silently continue
+    }
+  }
+
+  return plans.sort((a, b) => {
+    const aId = parseInt(a.match(/^(\d+)--/)[1], 10);
+    const bId = parseInt(b.match(/^(\d+)--/)[1], 10);
+    return aId - bId;
+  });
+}
+
+/**
+ * Validate plan blueprint and output JSON
+ * @param {string|number} planId - Plan ID to validate
+ */
+function validatePlanBlueprint(planId) {
+  if (!planId) {
+    errorLog('Plan ID is required');
+    errorLog('');
+    errorLog('Usage: node validate-plan-blueprint.cjs <plan-id>');
+    errorLog('');
+    errorLog('Example:');
+    errorLog('  node validate-plan-blueprint.cjs 47');
+    process.exit(1);
+  }
+
+  debugLog(`Validating plan blueprint for ID: ${planId}`);
+
+  const planInfo = findPlanById(planId);
+
+  if (!planInfo) {
+    errorLog(`Plan ID ${planId} not found`);
+    errorLog('');
+
+    const availablePlans = listAvailablePlans();
+    if (availablePlans.length > 0) {
+      errorLog('Available plans:');
+      availablePlans.forEach(plan => {
+        errorLog(`  ${plan}`);
+      });
+    } else {
+      errorLog('No plans found in .ai/task-manager/{plans,archive}/');
+    }
+
+    errorLog('');
+    errorLog('Please verify:');
+    errorLog('  1. You are in the correct project directory');
+    errorLog('  2. The plan exists in .ai/task-manager/plans/ or .ai/task-manager/archive/');
+    errorLog('  3. The plan directory follows the naming pattern: [plan-id]--[name]');
+    errorLog('  4. The plan file follows the naming pattern: plan-[plan-id]--[name].md');
+    process.exit(1);
+  }
+
+  const { planFile, planDir } = planInfo;
+  const taskCount = countTasks(planDir);
+  const blueprintExists = checkBlueprintExists(planFile);
+
+  const result = {
+    planFile,
+    planDir,
+    taskCount,
+    blueprintExists
+  };
+
+  debugLog('Validation complete:', result);
+  console.log(JSON.stringify(result, null, 2));
+}
+
+// Main execution
+const planId = process.argv[2];
+validatePlanBlueprint(planId);

package/templates/assistant/commands/tasks/execute-blueprint.md

@@ -45,22 +45,15 @@ Before proceeding with execution, validate that tasks exist and the execution bl
 
 **Validation Steps:**
 
-1. **Locate the plan document**:
 ```bash
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-[0-9][0-9]*--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
-PLAN_DIR=$(dirname "$PLAN_FILE")
-```
-
-2. **Check for task files**:
-```bash
-setopt null_glob 2>/dev/null || true
-TASK_FILES=(${PLAN_DIR}/tasks/*.md)
-TASK_COUNT=${#TASK_FILES[@]}
-```
-
-3. **Check for execution blueprint section**:
-```bash
-BLUEPRINT_EXISTS=$(grep -q "^## Execution Blueprint" "$PLAN_FILE" && echo "yes" || echo "no")
+# Validate plan exists and check for tasks/blueprint
+VALIDATION=$(node .ai/task-manager/config/scripts/validate-plan-blueprint.cjs $1)
+
+# Parse validation results
+PLAN_FILE=$(echo "$VALIDATION" | grep -o '"planFile": "[^"]*"' | cut -d'"' -f4)
+PLAN_DIR=$(echo "$VALIDATION" | grep -o '"planDir": "[^"]*"' | cut -d'"' -f4)
+TASK_COUNT=$(echo "$VALIDATION" | grep -o '"taskCount": [0-9]*' | awk '{print $2}')
+BLUEPRINT_EXISTS=$(echo "$VALIDATION" | grep -o '"blueprintExists": [a-z]*' | awk '{print $2}')
 ```
 
 4. **Automatic task generation**:
@@ -154,12 +147,11 @@ Read and execute .ai/task-manager/config/hooks/POST_ERROR_DETECTION.md
 First, extract both approval method fields from the plan document:
 
 ```bash
-# Find plan file by ID
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-$1--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
+# Extract approval methods from plan metadata
+APPROVAL_METHODS=$(node .ai/task-manager/config/scripts/get-approval-methods.cjs $1)
 
-# Extract both approval method fields from YAML frontmatter
-APPROVAL_METHOD_PLAN=$(sed -n '/^---$/,/^---$/p' "$PLAN_FILE" | grep '^approval_method_plan:' | sed 's/approval_method_plan: *//;s/"//g' | tr -d " '")
-APPROVAL_METHOD_TASKS=$(sed -n '/^---$/,/^---$/p' "$PLAN_FILE" | grep '^approval_method_tasks:' | sed 's/approval_method_tasks: *//;s/"//g' | tr -d " '")
+APPROVAL_METHOD_PLAN=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_plan": "[^"]*"' | cut -d'"' -f4)
+APPROVAL_METHOD_TASKS=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_tasks": "[^"]*"' | cut -d'"' -f4)
 
 # Defaults to "manual" if fields don't exist
 APPROVAL_METHOD_PLAN=${APPROVAL_METHOD_PLAN:-manual}

package/templates/assistant/commands/tasks/generate-tasks.md

@@ -303,11 +303,10 @@ Read and run the .ai/task-manager/config/hooks/POST_TASK_GENERATION_ALL.md
 First, extract the approval_method from the plan document:
 
 ```bash
-# Find plan file by ID
-PLAN_FILE=$(find .ai/task-manager/{plans,archive} -name "plan-$1--*.md" -type f -exec grep -l "^id: \?$1$" {} \;)
+# Extract approval method from plan metadata
+APPROVAL_METHODS=$(node .ai/task-manager/config/scripts/get-approval-methods.cjs $1)
 
-# Extract approval_method_tasks from YAML frontmatter
-APPROVAL_METHOD_TASKS=$(sed -n '/^---$/,/^---$/p' "$PLAN_FILE" | grep '^approval_method_tasks:' | sed 's/approval_method_tasks: *//;s/"//g' | tr -d " '")
+APPROVAL_METHOD_TASKS=$(echo "$APPROVAL_METHODS" | grep -o '"approval_method_tasks": "[^"]*"' | cut -d'"' -f4)
 
 # Default to "manual" if field doesn't exist (backward compatibility)
 APPROVAL_METHOD_TASKS=${APPROVAL_METHOD_TASKS:-manual}

package/dist/logger.d.ts

@@ -1,70 +0,0 @@
-/**
- * Simple Logging Utility
- *
- * This file provides a simple logging interface for the CLI
- * Handles different log levels and formatted output with optional color support
- */
-/**
- * Get chalk instance, initializing if necessary
- */
-export declare function getChalk(): Promise<any | null>;
-/**
- * Debug mode flag - can be set externally
- */
-export declare let isDebugMode: boolean;
-/**
- * Enable or disable debug mode
- */
-export declare function setDebugMode(enabled: boolean): void;
-/**
- * Log an informational message
- */
-export declare function info(message: string): Promise<void>;
-/**
- * Log a success message
- */
-export declare function success(message: string): Promise<void>;
-/**
- * Log an error message
- */
-export declare function error(message: string): Promise<void>;
-/**
- * Log a warning message
- */
-export declare function warning(message: string): Promise<void>;
-/**
- * Log a debug message (only shown in debug mode)
- */
-export declare function debug(message: string): Promise<void>;
-/**
- * Synchronous versions for cases where async is not suitable
- * These will only use colors if chalk was previously initialized
- */
-export declare const sync: {
-    /**
-     * Log an informational message (sync)
-     */
-    info(message: string): void;
-    /**
-     * Log a success message (sync)
-     */
-    success(message: string): void;
-    /**
-     * Log an error message (sync)
-     */
-    error(message: string): void;
-    /**
-     * Log a warning message (sync)
-     */
-    warning(message: string): void;
-    /**
-     * Log a debug message (sync, only shown in debug mode)
-     */
-    debug(message: string): void;
-};
-/**
- * Initialize the logger - call this early in your application
- * This pre-loads chalk to avoid delays on first use
- */
-export declare function initLogger(): Promise<void>;
-//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH;;GAEG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAGpD;AAED;;GAEG;AACH,eAAO,IAAI,WAAW,SAAQ,CAAC;AAE/B;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEnD;AAED;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzD;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5D;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1D;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5D;AAED;;GAEG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1D;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI;IACf;;OAEG;kBACW,MAAM,GAAG,IAAI;IAK3B;;OAEG;qBACc,MAAM,GAAG,IAAI;IAK9B;;OAEG;mBACY,MAAM,GAAG,IAAI;IAK5B;;OAEG;qBACc,MAAM,GAAG,IAAI;IAK9B;;OAEG;mBACY,MAAM,GAAG,IAAI;CAM7B,CAAC;AAEF;;;GAGG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAEhD"}