@futdevpro/nts-dynamo 1.15.104 → 1.15.107

package/src/_modules/ai/_modules/document-ai/_collections/dai-chunking.util.ts

@@ -1,639 +1,639 @@
-import { DyFM_Log, DyFM_Error, DyFM_AnyError, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-import { DyNTS_DAI_DocChunk } from '../_models/data-models/dai-doc-chunk.data-model';
-import { DyNTS_DAI_DocPage } from '../_models/data-models/dai-doc-page.data-model';
-
-
-interface DyNTS_DAI_DocChunking_Header {
-  level: number;
-  header: string;
-  index: number;
-}
-
-interface DyNTS_DAI_DocChunking_BreakPoint {
-  index: number;
-  level: number;
-}
-
-/**
- * ClickUp dokumentum chunking szolgáltatás
- * @author AI
- * @description ClickUp dokumentumok intelligens chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
- */
-export class DyNTS_DAI_DocChunking_Util {
-    
-  protected static readonly defaultErrorUserMsg: string = 
-    `We encountered an unhandled Control Service Error, ` +
-    `\nplease contact the responsible development team.`; 
-
-  /**
-   * Unified break points configuration
-   */
-  private static readonly breakPoints: { pattern: string, level: number, includeLength: number }[] = [
-    { pattern: '\n# ', level: 1, includeLength: 0 }, // Header 1 - cut before marker
-    { pattern: '\n## ', level: 2, includeLength: 0 }, // Header 2 - cut before marker
-    { pattern: '\n### ', level: 3, includeLength: 0 }, // Header 3 - cut before marker
-    { pattern: '\n#### ', level: 4, includeLength: 0 }, // Header 4 - cut before marker
-    { pattern: '\n\n', level: 0, includeLength: 2 }, // Double line break - include
-    { pattern: '\n', level: 0, includeLength: 1 }, // Single line break - include
-    { pattern: '. ', level: 0, includeLength: 2 }, // Sentence end - include
-    { pattern: ' ', level: 0, includeLength: 1 }, // Word break - include
-  ];
-
-  protected static readonly debugLog: boolean = false;
-
-  /**
-   * Markdown tartalom chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
-   * @param page - ClickUp dokumentum oldal
-   * @param issuer - Kérés kezdeményezője
-   * @returns Promise<CU_DocChunk[]> - Létrehozott chunk-ok listája
-   */
-  static async chunkMdContent<
-    T_Chunk extends DyNTS_DAI_DocChunk,
-    T_Page extends DyNTS_DAI_DocPage<T_Chunk>,
-    >(
-      page: T_Page,
-      getPageLink: (page: T_Page, issuer: string) => string,
-      issuer: string,
-      debugLog?: boolean
-  ): Promise<T_Chunk[]> {
-    try {
-      if (debugLog) {
-        DyFM_Log.info(`Chunking page "${page.name}"...`);
-      }
-
-      if (page.content.includes('#####')) {
-        DyFM_Log.warn('lvl5+ headers are not supported yet for page: ' + page.name);
-      }
-
-      if (!page.documentId) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page documentId is not set'), issuer),
-          errorCode: 'CCAP-CUC-CC2',
-        });
-      }
-
-      if (!page._id) {
-        throw new DyFM_Error({
-          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page _id is not set'), issuer),
-          errorCode: 'CCAP-CUC-CC3',
-        });
-      }
-
-      /* DyFM_Log.log(`Chunking page: ${page.name}\n\n`, JSON.stringify(page.content, null, 2)); */
-
-      let leftovers: string = page.content;
-      const maxChunkSize: number = DyNTS_global_settings.docChunking.maxChunkSize;
-      const maxChunkCount: number = DyNTS_global_settings.docChunking.maxChunkCount;
-      const chunks: T_Chunk[] = [];
-      let chunkIndex: number = 0;
-      let currentPosition: number = 0; // Track current position in original content
-
-      // Parse all headers to build hierarchy
-      const headerHierarchy: DyNTS_DAI_DocChunking_Header[] = this.parseHeaderHierarchy(leftovers);
-      
-      // Debug: Log parsed headers
-      /* console.log('\n=== Parsed Header Hierarchy ===');
-      headerHierarchy.forEach((header, index) => {
-        console.log(`${index}: Level ${header.level} at position ${header.index}: "${header.header}"`);
-      });
-      console.log('=== End Header Hierarchy ===\n'); */
-      
-      // Track the last headers of each level as we progress
-      const lastHeaders: Map<number, string> = new Map();
-
-      while (leftovers.length > 0 && chunkIndex < maxChunkCount) {
-        // Ha a teljes tartalom belefér egy chunk-ba, adjuk vissza az egészet
-        if (leftovers.length <= maxChunkSize) {
-          const chunkContent = leftovers.trim();
-
-          if (chunkContent.length > 0) {
-            //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
-            //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
-            const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders); // headerHierarchy.map(header => header.header);
-            //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-            
-            const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-              externalDocumentId: page.externalDocumentId,
-              documentId: page.documentId,
-              externalPageId: page.externalPageId,
-              pageId: page._id,
-
-              filePathParents: page.parentedPath,
-              chunkHeadParents: headParents,
-
-              allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-              /* path: [ ...page.parentedPath, ...headParents ].join('/'), */
-              path: page.allFlaggedParentsMerged,
-
-              documentName: page.externalDocumentId,
-              pageName: page.name,
-              pageLink: getPageLink(page, issuer),
-              chunkIndex: chunkIndex,
-              
-              chunkContent: chunkContent,
-              /* chunkOriginalContent: chunkContent,
-
-              chunkContent: chunkWithHierarchy, */
-            }) as T_Chunk;
-
-            if (this.debugLog || debugLog) {
-              DyFM_Log.H_info(
-                'Full content (before assembleChunkWithHeaders)',
-                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-                { chunk: chunk.chunkContent }
-              );
-            }
-
-            /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-            if (this.debugLog || debugLog) {
-              DyFM_Log.H_info(
-                'Full content (after assembleChunkWithHeaders)',
-                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-                { 
-                  chunk: chunk.chunkContent,
-                }
-              );
-            }
-
-            /* await DyFM_Async.wait(100_000); */
-            chunks.push(chunk);
-          }
-          break;
-        }
-
-        // Keressük meg a legjobb break point-ot a maxChunkSize-n belül
-        const breakPoint: DyNTS_DAI_DocChunking_BreakPoint | null = this.findBestBreakPoint(leftovers, maxChunkSize);
-        
-        if (breakPoint && breakPoint.index > 0) {
-          // Ha találtunk break point-ot, vágjunk a marker előtt
-          const chunkContent: string = leftovers.substring(0, breakPoint.index).trim();
-          
-          // Debug: Log current state
-          /* console.log(`\n--- Creating chunk ${chunkIndex} ---`);
-          console.log(`Current position: ${currentPosition}`);
-          console.log(`Last headers:`, Object.fromEntries(lastHeaders));
-          console.log(`Chunk content preview:`, chunkContent.substring(0, 100) + '...'); */
-          
-          // Check if chunk has headers
-          //const hasHeaders: boolean = headerHierarchy.some(header => 
-          //  header.index >= currentPosition && header.index < currentPosition + breakPoint.index
-          //);
-          /* console.log(`Chunk has headers: ${hasHeaders}`); */
-          
-          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
-          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
-          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders); // headerHierarchy.map(header => header.header);
-          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-          
-          /* console.log(`Chunk path:`, chunkPath);
-          console.log(`Chunk with hierarchy preview:`, chunkWithHierarchy.substring(0, 100) + '...'); */
-          
-          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-            externalDocumentId: page.externalDocumentId,
-            externalPageId: page.externalPageId,
-            documentId: page.documentId,
-            pageId: page._id,
-
-            filePathParents: page.parentedPath,
-            chunkHeadParents: headParents,
-
-            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-            path: [ ...page.parentedPath, ...headParents ].join('/'),
-
-            documentName: page.externalDocumentId,
-            pageName: page.name,
-            pageLink: getPageLink(page, issuer),
-            chunkIndex: chunkIndex,
-
-            chunkContent: chunkContent,
-            /* chunkOriginalContent: chunkContent,
-
-            chunkContent: chunkWithHierarchy, */
-          }) as T_Chunk;
-
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Break point (before assembleChunkWithHeaders)',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { chunk: chunk.chunkContent }
-            );
-          }
-          
-          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Break point (after assembleChunkWithHeaders)',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { 
-                chunk: chunk.chunkContent,
-              }
-            );
-          }
-
-          chunks.push(chunk);
-          chunkIndex++;
-          currentPosition += breakPoint.index;
-          leftovers = leftovers.substring(breakPoint.index);
-          
-          // Update last headers after creating the chunk
-          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
-          
-          /* console.log(`Updated last headers:`, Object.fromEntries(lastHeaders));
-          console.log(`--- End chunk ${chunkIndex - 1} ---\n`); */
-        } else {
-          // Ha nem találtunk break point-ot, használjuk a maxChunkSize-t
-          const chunkContent: string = leftovers.substring(0, maxChunkSize).trim();
-          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
-          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
-          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders); // headerHierarchy.map(header => header.header);
-          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
-          
-          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
-            externalDocumentId: page.externalDocumentId,
-            externalPageId: page.externalPageId,
-            documentId: page.documentId,
-            pageId: page._id,
-
-            filePathParents: page.parentedPath,
-            chunkHeadParents: headParents,
-
-            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
-            path: [ ...page.parentedPath, ...headParents ].join('/'),
-
-            documentName: page.externalDocumentId,
-            pageName: page.name,
-            pageLink: getPageLink(page, issuer),
-            chunkIndex: chunkIndex,
-
-            chunkContent: chunkContent,
-            /* chunkOriginalContent: chunkContent,
-
-            chunkContent: chunkWithHierarchy, */
-          }) as T_Chunk;
-
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              'Max chunk size',
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { chunk: chunk.chunkContent }
-            );
-          }
-
-          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
-          if (this.debugLog || debugLog) {
-            DyFM_Log.H_info(
-              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
-              { 
-                chunk: chunk.chunkContent,
-              }
-            );
-          }
-
-          chunks.push(chunk);
-          chunkIndex++;
-          currentPosition += maxChunkSize;
-          leftovers = leftovers.substring(maxChunkSize);
-          
-          // Update last headers after creating the chunk
-          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
-        }
-
-        // Safety check to prevent infinite loops
-        if (leftovers.length > 0 && leftovers.length >= page.content.length) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'chunkMdContent',
-              new Error('Infinite loop detected in chunking'),
-              issuer
-            ),
-            errorCode: 'CCAP-CUC-CC1',
-          });
-        }
-      }
-
-      // Log warning if we hit the chunk count limit
-      if (chunkIndex >= maxChunkCount && leftovers.length > 0) {
-        DyFM_Log.warn(
-          `⚠️  Reached maximum chunk count (${maxChunkCount}). Remaining content: ${leftovers.length} characters`,
-          {
-            pageName: page.name,
-            pageSize: page.content.length,
-          }
-        );
-      }
-
-      /* DyFM_Log.info(`✅ Created ${chunks.length} chunks`); */
-      return chunks;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('chunkMdContent', error, issuer),
-        errorCode: 'CCAP-CUC-CP0',
-      });
-    }
-  }
-
-  /* private static assembleChunkWithHeaders(chunk: DyNTS_DAI_DocChunk, issuer: string): string {
-    try {
-      const fileHeaders = chunk.filePathParents.map(
-        (header, index) => `${'>'.repeat(index + 1)} **${header}**`
-      ).join('\n');
-      const headers = chunk.chunkHeadParents.filter(
-        path => !chunk.chunkOriginalContent.includes(path)
-      ).join('\n');
-      return `${fileHeaders}\n\n${headers}\n\n${chunk.chunkOriginalContent}`;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('assembleChunkWithHeaders', error, issuer),
-        errorCode: 'CCAP-CUC-ACH0',
-      });
-    }
-  } */
-
-  static reassembleChunksToContent(
-    chunks: DyNTS_DAI_DocChunk[],
-    issuer: string
-  ): string {
-    try {
-      let pageContent: string = '';
-
-      for (const chunk of chunks) {
-        if (!chunk) {
-          throw new DyFM_Error({
-            ...this.getDefaultErrorSettings(
-              'reassembleChunksToContent', 
-              new Error('Chunk is null, you`ve passing null chunks to the function'), 
-              issuer
-            ),
-            errorCode: 'CCAP-CUC-RCTC0',
-
-            additionalContent: {
-              chunks: chunks,
-            },
-          });
-        }
-
-        pageContent += chunk.chunkContent;
-      }
-
-      return pageContent;
-    } catch (error) {
-      throw new DyFM_Error({
-        ...this.getDefaultErrorSettings('reassembleChunks', error, issuer),
-        errorCode: 'CCAP-CUC-RC0',
-      });
-    }
-  }
-
-  /**
-   * Find the best break point within the chunk size
-   * @param text - The text to search in
-   * @param maxIndex - Maximum index to search up to
-   * @returns The best break point or null if not found
-   */
-  private static findBestBreakPoint(text: string, maxIndex: number): DyNTS_DAI_DocChunking_BreakPoint | null {
-    for (const breakPoint of this.breakPoints) {
-      const index: number = this.findLastOccurrence(text, breakPoint.pattern, maxIndex);
-
-      if (index > 0) {
-        return {
-          index: index + breakPoint.includeLength,
-          level: breakPoint.level
-        };
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Parse header hierarchy from the content
-   * @param content - The content to parse
-   * @returns Array of header positions and levels
-   */
-  private static parseHeaderHierarchy(content: string): DyNTS_DAI_DocChunking_Header[] {
-    const headers: DyNTS_DAI_DocChunking_Header[] = [];
-    const lines: string[] = content.split('\n');
-    let currentIndex: number = 0;
-
-    for (const line of lines) {
-      const trimmedLine: string = line.trim();
-      
-      // Check if line starts with # and determine the level
-      if (trimmedLine.startsWith('#')) {
-        const match: RegExpMatchArray | null = trimmedLine.match(/^(#+)\s+(.+)$/);
-
-        if (match) {
-          const level: number = match[1].length; // Count the number of # symbols
-          const headerText: string = trimmedLine;
-          
-          if (level >= 1 && level <= 4) { // Only support levels 1-4
-            headers.push({
-              index: currentIndex,
-              level: level,
-              header: headerText
-            });
-          }
-        }
-      }
-      
-      currentIndex += line.length + 1; // +1 for the newline
-    }
-
-    return headers;
-  }
-
-  /**
-   * Update the last headers map based on current position
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param currentPosition - Current position in content
-   * @param lastHeaders - Map to store last headers of each level
-   */
-  private static updateLastHeaders(
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    currentPosition: number,
-    lastHeaders: Map<number, string>
-  ): void {
-    // Find all headers that come before current position (not including current position)
-    for (const header of headerHierarchy) {
-      if (header.index < currentPosition) {
-        // Set this header as the last header for its level
-        lastHeaders.set(header.level, header.header);
-        
-        // Clear all lower level headers (higher level numbers) when any header comes
-        // For example, if we see a level 2 header, clear levels 3, 4
-        // If we see a level 1 header, clear levels 2, 3, 4
-        for (let level: number = header.level + 1; level <= 4; level++) {
-          lastHeaders.delete(level);
-        }
-      }
-    }
-  }
-
-  /**
-   * Visszaadja a chunk-hoz tartozó releváns szülő fejléceket a hierarchia alapján.
-   * @param headerHierarchy - A feldolgozott fejléc-hierarchia
-   * @param startIndex - A chunk kezdőindexe az eredeti tartalomban
-   * @param endIndex - A chunk végindexe az eredeti tartalomban
-   * @param lastHeaders - Az utolsó ismert fejlécek szintenként
-   * @returns A releváns szülő fejlécek tömbje
-   */
-  private static getRelevantHeaders(
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string[] {
-    // Keressük meg az első fejlécet a chunkban
-    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
-      header.index >= startIndex && header.index < endIndex
-    );
-
-    if (!firstHeaderInChunk) {
-      // Nincs fejléc a chunkban, a legmagasabb szintű utolsó fejlécet használjuk
-      let highestLevel: number = 0;
-      let highestHeader: string = '';
-
-      for (const [level, header] of lastHeaders.entries()) {
-        if (level > highestLevel) {
-          highestLevel = level;
-          highestHeader = header;
-        }
-      }
-      return highestHeader ? [highestHeader] : [];
-    }
-
-    // Szülő fejlécek összegyűjtése az első fejléc szintje alapján
-    const relevantHeaders: string[] = [];
-    for (let level: number = 1; level < firstHeaderInChunk.level; level++) {
-      const parentHeader: string | undefined = lastHeaders.get(level);
-
-      if (parentHeader) {
-        relevantHeaders.push(parentHeader);
-      }
-    }
-    return relevantHeaders;
-  }
-
-  /**
-   * Build hierarchical chunk path based on header structure
-   * @param pageName - The page name
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param startIndex - Start index of the chunk in original content
-   * @param endIndex - End index of the chunk in original content
-   * @param lastHeaders - Map of last headers for each level
-   * @returns Hierarchical path array
-   */
-  private static buildChunkPath(
-    pageName: string,
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string[] {
-    // Find the first header within this chunk
-    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
-      header.index >= startIndex && header.index < endIndex
-    );
-
-    if (!firstHeaderInChunk) {
-      // No header in chunk, use the highest level from lastHeaders as parent
-      const pathParts: string[] = [pageName];
-      
-      // Find the highest level header from lastHeaders
-      let highestLevel: number = 0;
-      let highestHeader: string = '';
-
-      for (const [level, header] of lastHeaders.entries()) {
-        if (level > highestLevel) {
-          highestLevel = level;
-          highestHeader = header;
-        }
-      }
-      
-      if (highestHeader) {
-        pathParts.push(highestHeader);
-      }
-      
-      return pathParts;
-    }
-
-    // Build the path hierarchy
-    const pathParts: string[] = [pageName];
-    
-    // Add parent headers from lastHeaders (these are the actual parent headers)
-    for (let level = 1; level < firstHeaderInChunk.level; level++) {
-      const parentHeader: string | undefined = lastHeaders.get(level);
-
-      if (parentHeader) {
-        pathParts.push(parentHeader); // Include the full header with markdown symbols
-      }
-    }
-
-    // Add the first header in chunk
-    pathParts.push(firstHeaderInChunk.header); // Include the full header with markdown symbols
-
-    return pathParts;
-  }
-
-  /**
-   * Add header hierarchy to the beginning of a chunk
-   * @param chunkContent - The chunk content
-   * @param headerHierarchy - The parsed header hierarchy
-   * @param startIndex - Start index of the chunk in original content
-   * @param endIndex - End index of the chunk in original content
-   * @param lastHeaders - Map of last headers for each level
-   * @returns Content with header hierarchy added
-   */
-  private static addHeaderHierarchy(
-    chunkContent: string, 
-    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
-    startIndex: number,
-    endIndex: number,
-    lastHeaders: Map<number, string>
-  ): string {
-    const relevantHeaders: string[] = this.getRelevantHeaders(headerHierarchy, startIndex, endIndex, lastHeaders);
-
-    if (relevantHeaders.length > 0) {
-      return relevantHeaders.join('\n') + '\n\n' + chunkContent;
-    }
-
-    return chunkContent;
-  }
-
-  /**
-   * Helper method to find the last occurrence of a pattern within a specified range
-   * @param text - The text to search in
-   * @param pattern - The pattern to search for
-   * @param maxIndex - Maximum index to search up to
-   * @returns The index of the last occurrence, or -1 if not found
-   */
-  private static findLastOccurrence(text: string, pattern: string, maxIndex: number): number {
-    const searchText: string = text.substring(0, maxIndex);
-    const lastIndex: number = searchText.lastIndexOf(pattern);
-
-    return lastIndex;
-  }
-  
-  protected static getDefaultErrorSettings(
-    fnName: string, 
-    error: DyFM_AnyError,
-    issuer: string,
-    /** @deprecated we wont support the separate user message in the future, use the message instead */
-    useMessageAsUserMessage: boolean = true,
-    /* errorCode: string, */
-  ): DyFM_Error_Settings {
-    return {
-      status: (error as DyFM_Error)?.___status ?? 500,
-      message: (error as Error)?.message ??
-        (error as DyFM_Error)?._message ??
-        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
-      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
-      userMessage: (error as DyFM_Error)?.__userMessage ??  
-        (useMessageAsUserMessage ? (error as Error)?.message : this.defaultErrorUserMsg),
-      /* errorCode: errorCode, */
-      issuer: issuer,
-      issuerService: this.constructor?.name,
-      error: error,
-    };
-  }
-} 
+import { DyFM_Log, DyFM_Error, DyFM_AnyError, DyFM_Error_Settings } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
+import { DyNTS_DAI_DocChunk } from '../_models/data-models/dai-doc-chunk.data-model';
+import { DyNTS_DAI_DocPage } from '../_models/data-models/dai-doc-page.data-model';
+
+
+interface DyNTS_DAI_DocChunking_Header {
+  level: number;
+  header: string;
+  index: number;
+}
+
+interface DyNTS_DAI_DocChunking_BreakPoint {
+  index: number;
+  level: number;
+}
+
+/**
+ * ClickUp dokumentum chunking szolgáltatás
+ * @author AI
+ * @description ClickUp dokumentumok intelligens chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
+ */
+export class DyNTS_DAI_DocChunking_Util {
+    
+  protected static readonly defaultErrorUserMsg: string = 
+    `We encountered an unhandled Control Service Error, ` +
+    `\nplease contact the responsible development team.`; 
+
+  /**
+   * Unified break points configuration
+   */
+  private static readonly breakPoints: { pattern: string, level: number, includeLength: number }[] = [
+    { pattern: '\n# ', level: 1, includeLength: 0 }, // Header 1 - cut before marker
+    { pattern: '\n## ', level: 2, includeLength: 0 }, // Header 2 - cut before marker
+    { pattern: '\n### ', level: 3, includeLength: 0 }, // Header 3 - cut before marker
+    { pattern: '\n#### ', level: 4, includeLength: 0 }, // Header 4 - cut before marker
+    { pattern: '\n\n', level: 0, includeLength: 2 }, // Double line break - include
+    { pattern: '\n', level: 0, includeLength: 1 }, // Single line break - include
+    { pattern: '. ', level: 0, includeLength: 2 }, // Sentence end - include
+    { pattern: ' ', level: 0, includeLength: 1 }, // Word break - include
+  ];
+
+  protected static readonly debugLog: boolean = false;
+
+  /**
+   * Markdown tartalom chunking-ja a leghosszabb lehetséges chunk-ok létrehozásához
+   * @param page - ClickUp dokumentum oldal
+   * @param issuer - Kérés kezdeményezője
+   * @returns Promise<CU_DocChunk[]> - Létrehozott chunk-ok listája
+   */
+  static async chunkMdContent<
+    T_Chunk extends DyNTS_DAI_DocChunk,
+    T_Page extends DyNTS_DAI_DocPage<T_Chunk>,
+    >(
+      page: T_Page,
+      getPageLink: (page: T_Page, issuer: string) => string,
+      issuer: string,
+      debugLog?: boolean
+  ): Promise<T_Chunk[]> {
+    try {
+      if (debugLog) {
+        DyFM_Log.info(`Chunking page "${page.name}"...`);
+      }
+
+      if (page.content.includes('#####')) {
+        DyFM_Log.warn('lvl5+ headers are not supported yet for page: ' + page.name);
+      }
+
+      if (!page.documentId) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page documentId is not set'), issuer),
+          errorCode: 'CCAP-CUC-CC2',
+        });
+      }
+
+      if (!page._id) {
+        throw new DyFM_Error({
+          ...this.getDefaultErrorSettings('chunkMdContent', new Error('Page _id is not set'), issuer),
+          errorCode: 'CCAP-CUC-CC3',
+        });
+      }
+
+      /* DyFM_Log.log(`Chunking page: ${page.name}\n\n`, JSON.stringify(page.content, null, 2)); */
+
+      let leftovers: string = page.content;
+      const maxChunkSize: number = DyNTS_global_settings.docChunking.maxChunkSize;
+      const maxChunkCount: number = DyNTS_global_settings.docChunking.maxChunkCount;
+      const chunks: T_Chunk[] = [];
+      let chunkIndex: number = 0;
+      let currentPosition: number = 0; // Track current position in original content
+
+      // Parse all headers to build hierarchy
+      const headerHierarchy: DyNTS_DAI_DocChunking_Header[] = this.parseHeaderHierarchy(leftovers);
+      
+      // Debug: Log parsed headers
+      /* console.log('\n=== Parsed Header Hierarchy ===');
+      headerHierarchy.forEach((header, index) => {
+        console.log(`${index}: Level ${header.level} at position ${header.index}: "${header.header}"`);
+      });
+      console.log('=== End Header Hierarchy ===\n'); */
+      
+      // Track the last headers of each level as we progress
+      const lastHeaders: Map<number, string> = new Map();
+
+      while (leftovers.length > 0 && chunkIndex < maxChunkCount) {
+        // Ha a teljes tartalom belefér egy chunk-ba, adjuk vissza az egészet
+        if (leftovers.length <= maxChunkSize) {
+          const chunkContent = leftovers.trim();
+
+          if (chunkContent.length > 0) {
+            //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
+            //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders);
+            const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + leftovers.length, lastHeaders); // headerHierarchy.map(header => header.header);
+            //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
+            
+            const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
+              externalDocumentId: page.externalDocumentId,
+              documentId: page.documentId,
+              externalPageId: page.externalPageId,
+              pageId: page._id,
+
+              filePathParents: page.parentedPath,
+              chunkHeadParents: headParents,
+
+              allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
+              /* path: [ ...page.parentedPath, ...headParents ].join('/'), */
+              path: page.allFlaggedParentsMerged,
+
+              documentName: page.externalDocumentId,
+              pageName: page.name,
+              pageLink: getPageLink(page, issuer),
+              chunkIndex: chunkIndex,
+              
+              chunkContent: chunkContent,
+              /* chunkOriginalContent: chunkContent,
+
+              chunkContent: chunkWithHierarchy, */
+            }) as T_Chunk;
+
+            if (this.debugLog || debugLog) {
+              DyFM_Log.H_info(
+                'Full content (before assembleChunkWithHeaders)',
+                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+                { chunk: chunk.chunkContent }
+              );
+            }
+
+            /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
+            if (this.debugLog || debugLog) {
+              DyFM_Log.H_info(
+                'Full content (after assembleChunkWithHeaders)',
+                `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+                { 
+                  chunk: chunk.chunkContent,
+                }
+              );
+            }
+
+            /* await DyFM_Async.wait(100_000); */
+            chunks.push(chunk);
+          }
+          break;
+        }
+
+        // Keressük meg a legjobb break point-ot a maxChunkSize-n belül
+        const breakPoint: DyNTS_DAI_DocChunking_BreakPoint | null = this.findBestBreakPoint(leftovers, maxChunkSize);
+        
+        if (breakPoint && breakPoint.index > 0) {
+          // Ha találtunk break point-ot, vágjunk a marker előtt
+          const chunkContent: string = leftovers.substring(0, breakPoint.index).trim();
+          
+          // Debug: Log current state
+          /* console.log(`\n--- Creating chunk ${chunkIndex} ---`);
+          console.log(`Current position: ${currentPosition}`);
+          console.log(`Last headers:`, Object.fromEntries(lastHeaders));
+          console.log(`Chunk content preview:`, chunkContent.substring(0, 100) + '...'); */
+          
+          // Check if chunk has headers
+          //const hasHeaders: boolean = headerHierarchy.some(header => 
+          //  header.index >= currentPosition && header.index < currentPosition + breakPoint.index
+          //);
+          /* console.log(`Chunk has headers: ${hasHeaders}`); */
+          
+          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
+          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders);
+          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + breakPoint.index, lastHeaders); // headerHierarchy.map(header => header.header);
+          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
+          
+          /* console.log(`Chunk path:`, chunkPath);
+          console.log(`Chunk with hierarchy preview:`, chunkWithHierarchy.substring(0, 100) + '...'); */
+          
+          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
+            externalDocumentId: page.externalDocumentId,
+            externalPageId: page.externalPageId,
+            documentId: page.documentId,
+            pageId: page._id,
+
+            filePathParents: page.parentedPath,
+            chunkHeadParents: headParents,
+
+            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
+            path: [ ...page.parentedPath, ...headParents ].join('/'),
+
+            documentName: page.externalDocumentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
+            chunkIndex: chunkIndex,
+
+            chunkContent: chunkContent,
+            /* chunkOriginalContent: chunkContent,
+
+            chunkContent: chunkWithHierarchy, */
+          }) as T_Chunk;
+
+          if (this.debugLog || debugLog) {
+            DyFM_Log.H_info(
+              'Break point (before assembleChunkWithHeaders)',
+              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+              { chunk: chunk.chunkContent }
+            );
+          }
+          
+          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
+          if (this.debugLog || debugLog) {
+            DyFM_Log.H_info(
+              'Break point (after assembleChunkWithHeaders)',
+              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+              { 
+                chunk: chunk.chunkContent,
+              }
+            );
+          }
+
+          chunks.push(chunk);
+          chunkIndex++;
+          currentPosition += breakPoint.index;
+          leftovers = leftovers.substring(breakPoint.index);
+          
+          // Update last headers after creating the chunk
+          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
+          
+          /* console.log(`Updated last headers:`, Object.fromEntries(lastHeaders));
+          console.log(`--- End chunk ${chunkIndex - 1} ---\n`); */
+        } else {
+          // Ha nem találtunk break point-ot, használjuk a maxChunkSize-t
+          const chunkContent: string = leftovers.substring(0, maxChunkSize).trim();
+          //const chunkWithHierarchy: string = this.addHeaderHierarchy(chunkContent, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
+          //const chunkPath: string[] = this.buildChunkPath(page.name, headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders);
+          const headParents: string[] = this.getRelevantHeaders(headerHierarchy, currentPosition, currentPosition + maxChunkSize, lastHeaders); // headerHierarchy.map(header => header.header);
+          //const allFlaggedParents: string[] = [ ...page.allFlaggedParents, ...headParents ];
+          
+          const chunk: T_Chunk = new DyNTS_DAI_DocChunk({
+            externalDocumentId: page.externalDocumentId,
+            externalPageId: page.externalPageId,
+            documentId: page.documentId,
+            pageId: page._id,
+
+            filePathParents: page.parentedPath,
+            chunkHeadParents: headParents,
+
+            allFlaggedParents: [ ...page.allFlaggedParents, ...headParents ],
+            path: [ ...page.parentedPath, ...headParents ].join('/'),
+
+            documentName: page.externalDocumentId,
+            pageName: page.name,
+            pageLink: getPageLink(page, issuer),
+            chunkIndex: chunkIndex,
+
+            chunkContent: chunkContent,
+            /* chunkOriginalContent: chunkContent,
+
+            chunkContent: chunkWithHierarchy, */
+          }) as T_Chunk;
+
+          if (this.debugLog || debugLog) {
+            DyFM_Log.H_info(
+              'Max chunk size',
+              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+              { chunk: chunk.chunkContent }
+            );
+          }
+
+          /* chunk.chunkContent = this.assembleChunkWithHeaders(chunk, issuer); */
+          if (this.debugLog || debugLog) {
+            DyFM_Log.H_info(
+              `Chunk ${chunkIndex}: ${chunk.path.replaceAll('/', '/\n').split('/')}`, 
+              { 
+                chunk: chunk.chunkContent,
+              }
+            );
+          }
+
+          chunks.push(chunk);
+          chunkIndex++;
+          currentPosition += maxChunkSize;
+          leftovers = leftovers.substring(maxChunkSize);
+          
+          // Update last headers after creating the chunk
+          this.updateLastHeaders(headerHierarchy, currentPosition, lastHeaders);
+        }
+
+        // Safety check to prevent infinite loops
+        if (leftovers.length > 0 && leftovers.length >= page.content.length) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings(
+              'chunkMdContent',
+              new Error('Infinite loop detected in chunking'),
+              issuer
+            ),
+            errorCode: 'CCAP-CUC-CC1',
+          });
+        }
+      }
+
+      // Log warning if we hit the chunk count limit
+      if (chunkIndex >= maxChunkCount && leftovers.length > 0) {
+        DyFM_Log.warn(
+          `⚠️  Reached maximum chunk count (${maxChunkCount}). Remaining content: ${leftovers.length} characters`,
+          {
+            pageName: page.name,
+            pageSize: page.content.length,
+          }
+        );
+      }
+
+      /* DyFM_Log.info(`✅ Created ${chunks.length} chunks`); */
+      return chunks;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('chunkMdContent', error, issuer),
+        errorCode: 'CCAP-CUC-CP0',
+      });
+    }
+  }
+
+  /* private static assembleChunkWithHeaders(chunk: DyNTS_DAI_DocChunk, issuer: string): string {
+    try {
+      const fileHeaders = chunk.filePathParents.map(
+        (header, index) => `${'>'.repeat(index + 1)} **${header}**`
+      ).join('\n');
+      const headers = chunk.chunkHeadParents.filter(
+        path => !chunk.chunkOriginalContent.includes(path)
+      ).join('\n');
+      return `${fileHeaders}\n\n${headers}\n\n${chunk.chunkOriginalContent}`;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('assembleChunkWithHeaders', error, issuer),
+        errorCode: 'CCAP-CUC-ACH0',
+      });
+    }
+  } */
+
+  static reassembleChunksToContent(
+    chunks: DyNTS_DAI_DocChunk[],
+    issuer: string
+  ): string {
+    try {
+      let pageContent: string = '';
+
+      for (const chunk of chunks) {
+        if (!chunk) {
+          throw new DyFM_Error({
+            ...this.getDefaultErrorSettings(
+              'reassembleChunksToContent', 
+              new Error('Chunk is null, you`ve passing null chunks to the function'), 
+              issuer
+            ),
+            errorCode: 'CCAP-CUC-RCTC0',
+
+            additionalContent: {
+              chunks: chunks,
+            },
+          });
+        }
+
+        pageContent += chunk.chunkContent;
+      }
+
+      return pageContent;
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this.getDefaultErrorSettings('reassembleChunks', error, issuer),
+        errorCode: 'CCAP-CUC-RC0',
+      });
+    }
+  }
+
+  /**
+   * Find the best break point within the chunk size
+   * @param text - The text to search in
+   * @param maxIndex - Maximum index to search up to
+   * @returns The best break point or null if not found
+   */
+  private static findBestBreakPoint(text: string, maxIndex: number): DyNTS_DAI_DocChunking_BreakPoint | null {
+    for (const breakPoint of this.breakPoints) {
+      const index: number = this.findLastOccurrence(text, breakPoint.pattern, maxIndex);
+
+      if (index > 0) {
+        return {
+          index: index + breakPoint.includeLength,
+          level: breakPoint.level
+        };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parse header hierarchy from the content
+   * @param content - The content to parse
+   * @returns Array of header positions and levels
+   */
+  private static parseHeaderHierarchy(content: string): DyNTS_DAI_DocChunking_Header[] {
+    const headers: DyNTS_DAI_DocChunking_Header[] = [];
+    const lines: string[] = content.split('\n');
+    let currentIndex: number = 0;
+
+    for (const line of lines) {
+      const trimmedLine: string = line.trim();
+      
+      // Check if line starts with # and determine the level
+      if (trimmedLine.startsWith('#')) {
+        const match: RegExpMatchArray | null = trimmedLine.match(/^(#+)\s+(.+)$/);
+
+        if (match) {
+          const level: number = match[1].length; // Count the number of # symbols
+          const headerText: string = trimmedLine;
+          
+          if (level >= 1 && level <= 4) { // Only support levels 1-4
+            headers.push({
+              index: currentIndex,
+              level: level,
+              header: headerText
+            });
+          }
+        }
+      }
+      
+      currentIndex += line.length + 1; // +1 for the newline
+    }
+
+    return headers;
+  }
+
+  /**
+   * Update the last headers map based on current position
+   * @param headerHierarchy - The parsed header hierarchy
+   * @param currentPosition - Current position in content
+   * @param lastHeaders - Map to store last headers of each level
+   */
+  private static updateLastHeaders(
+    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
+    currentPosition: number,
+    lastHeaders: Map<number, string>
+  ): void {
+    // Find all headers that come before current position (not including current position)
+    for (const header of headerHierarchy) {
+      if (header.index < currentPosition) {
+        // Set this header as the last header for its level
+        lastHeaders.set(header.level, header.header);
+        
+        // Clear all lower level headers (higher level numbers) when any header comes
+        // For example, if we see a level 2 header, clear levels 3, 4
+        // If we see a level 1 header, clear levels 2, 3, 4
+        for (let level: number = header.level + 1; level <= 4; level++) {
+          lastHeaders.delete(level);
+        }
+      }
+    }
+  }
+
+  /**
+   * Visszaadja a chunk-hoz tartozó releváns szülő fejléceket a hierarchia alapján.
+   * @param headerHierarchy - A feldolgozott fejléc-hierarchia
+   * @param startIndex - A chunk kezdőindexe az eredeti tartalomban
+   * @param endIndex - A chunk végindexe az eredeti tartalomban
+   * @param lastHeaders - Az utolsó ismert fejlécek szintenként
+   * @returns A releváns szülő fejlécek tömbje
+   */
+  private static getRelevantHeaders(
+    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
+    startIndex: number,
+    endIndex: number,
+    lastHeaders: Map<number, string>
+  ): string[] {
+    // Keressük meg az első fejlécet a chunkban
+    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
+      header.index >= startIndex && header.index < endIndex
+    );
+
+    if (!firstHeaderInChunk) {
+      // Nincs fejléc a chunkban, a legmagasabb szintű utolsó fejlécet használjuk
+      let highestLevel: number = 0;
+      let highestHeader: string = '';
+
+      for (const [level, header] of lastHeaders.entries()) {
+        if (level > highestLevel) {
+          highestLevel = level;
+          highestHeader = header;
+        }
+      }
+      return highestHeader ? [highestHeader] : [];
+    }
+
+    // Szülő fejlécek összegyűjtése az első fejléc szintje alapján
+    const relevantHeaders: string[] = [];
+    for (let level: number = 1; level < firstHeaderInChunk.level; level++) {
+      const parentHeader: string | undefined = lastHeaders.get(level);
+
+      if (parentHeader) {
+        relevantHeaders.push(parentHeader);
+      }
+    }
+    return relevantHeaders;
+  }
+
+  /**
+   * Build hierarchical chunk path based on header structure
+   * @param pageName - The page name
+   * @param headerHierarchy - The parsed header hierarchy
+   * @param startIndex - Start index of the chunk in original content
+   * @param endIndex - End index of the chunk in original content
+   * @param lastHeaders - Map of last headers for each level
+   * @returns Hierarchical path array
+   */
+  private static buildChunkPath(
+    pageName: string,
+    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
+    startIndex: number,
+    endIndex: number,
+    lastHeaders: Map<number, string>
+  ): string[] {
+    // Find the first header within this chunk
+    const firstHeaderInChunk: DyNTS_DAI_DocChunking_Header | undefined = headerHierarchy.find(header => 
+      header.index >= startIndex && header.index < endIndex
+    );
+
+    if (!firstHeaderInChunk) {
+      // No header in chunk, use the highest level from lastHeaders as parent
+      const pathParts: string[] = [pageName];
+      
+      // Find the highest level header from lastHeaders
+      let highestLevel: number = 0;
+      let highestHeader: string = '';
+
+      for (const [level, header] of lastHeaders.entries()) {
+        if (level > highestLevel) {
+          highestLevel = level;
+          highestHeader = header;
+        }
+      }
+      
+      if (highestHeader) {
+        pathParts.push(highestHeader);
+      }
+      
+      return pathParts;
+    }
+
+    // Build the path hierarchy
+    const pathParts: string[] = [pageName];
+    
+    // Add parent headers from lastHeaders (these are the actual parent headers)
+    for (let level = 1; level < firstHeaderInChunk.level; level++) {
+      const parentHeader: string | undefined = lastHeaders.get(level);
+
+      if (parentHeader) {
+        pathParts.push(parentHeader); // Include the full header with markdown symbols
+      }
+    }
+
+    // Add the first header in chunk
+    pathParts.push(firstHeaderInChunk.header); // Include the full header with markdown symbols
+
+    return pathParts;
+  }
+
+  /**
+   * Add header hierarchy to the beginning of a chunk
+   * @param chunkContent - The chunk content
+   * @param headerHierarchy - The parsed header hierarchy
+   * @param startIndex - Start index of the chunk in original content
+   * @param endIndex - End index of the chunk in original content
+   * @param lastHeaders - Map of last headers for each level
+   * @returns Content with header hierarchy added
+   */
+  private static addHeaderHierarchy(
+    chunkContent: string, 
+    headerHierarchy: DyNTS_DAI_DocChunking_Header[],
+    startIndex: number,
+    endIndex: number,
+    lastHeaders: Map<number, string>
+  ): string {
+    const relevantHeaders: string[] = this.getRelevantHeaders(headerHierarchy, startIndex, endIndex, lastHeaders);
+
+    if (relevantHeaders.length > 0) {
+      return relevantHeaders.join('\n') + '\n\n' + chunkContent;
+    }
+
+    return chunkContent;
+  }
+
+  /**
+   * Helper method to find the last occurrence of a pattern within a specified range
+   * @param text - The text to search in
+   * @param pattern - The pattern to search for
+   * @param maxIndex - Maximum index to search up to
+   * @returns The index of the last occurrence, or -1 if not found
+   */
+  private static findLastOccurrence(text: string, pattern: string, maxIndex: number): number {
+    const searchText: string = text.substring(0, maxIndex);
+    const lastIndex: number = searchText.lastIndexOf(pattern);
+
+    return lastIndex;
+  }
+  
+  protected static getDefaultErrorSettings(
+    fnName: string, 
+    error: DyFM_AnyError,
+    issuer: string,
+    /** @deprecated we wont support the separate user message in the future, use the message instead */
+    useMessageAsUserMessage: boolean = true,
+    /* errorCode: string, */
+  ): DyFM_Error_Settings {
+    return {
+      status: (error as DyFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ??
+        (error as DyFM_Error)?._message ??
+        `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ??  
+        (useMessageAsUserMessage ? (error as Error)?.message : this.defaultErrorUserMsg),
+      /* errorCode: errorCode, */
+      issuer: issuer,
+      issuerService: this.constructor?.name,
+      error: error,
+    };
+  }
+}