@gitsense/gsc-utils 0.2.14 → 0.2.16

package/dist/gsc-utils.esm.js

@@ -675,7 +675,7 @@ var constants$2 = {
  * Generates a valid RFC 4122 UUID v4
  * @returns {string} A valid UUID v4
  */
-function generateUUID$3() {
+function generateUUID$2() {
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
         const r = Math.random() * 16 | 0;
         const v = c === 'x' ? r : (r & 0x3 | 0x8);
@@ -688,13 +688,13 @@ function generateUUID$3() {
  * @param {string} uuid - The UUID string to validate
  * @returns {Object} Object containing validation results and replacement UUID if needed
  */
-function validateUUID$4(uuid) {
+function validateUUID$3(uuid) {
     const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
     if (!uuidPattern.test(uuid)) {
         return {
             "Block-UUID": "INVALID UUID",
-            "Correct Block-UUID": generateUUID$3()
+            "Correct Block-UUID": generateUUID$2()
         };
     }
 
@@ -704,8 +704,8 @@ function validateUUID$4(uuid) {
 }
 
 var uuidUtils = {
-    generateUUID: generateUUID$3,
-    validateUUID: validateUUID$4
+    generateUUID: generateUUID$2,
+    validateUUID: validateUUID$3
 };
 
 /**
@@ -797,7 +797,7 @@ function formatBlocksWithLineNumbers$2(blocks, startLine = 1, paddingWidth = 0)
  * @param {string} formattedContent - The code content with line numbers
  * @returns {string} The original code content without line numbers
  */
-function removeLineNumbers$a(formattedContent) {
+function removeLineNumbers$9(formattedContent) {
     if (typeof formattedContent !== 'string') {
         throw new Error("formattedContent must be a string");
     }
@@ -821,7 +821,7 @@ var lineNumberFormatter = {
     formatWithLineNumbers: formatWithLineNumbers$2,
     formatBlockWithLineNumbers: formatBlockWithLineNumbers$2,
     formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$2,
-    removeLineNumbers: removeLineNumbers$a
+    removeLineNumbers: removeLineNumbers$9
 };
 
 /**
@@ -837,8 +837,8 @@ var lineNumberFormatter = {
 
 // Dependencies from other modules within CodeBlockUtils
 const { COMMENT_STYLES: COMMENT_STYLES$2 } = constants$2;
-const { removeLineNumbers: removeLineNumbers$9 } = lineNumberFormatter; // Assuming this utility exists
-const { validateUUID: validateUUID$3 } = uuidUtils; // Assuming uuidUtils.js is in the same directory
+const { removeLineNumbers: removeLineNumbers$8 } = lineNumberFormatter; // Assuming this utility exists
+const { validateUUID: validateUUID$2 } = uuidUtils; // Assuming uuidUtils.js is in the same directory
 
 const MAX_HEADER_LINES = 12; // Maximum allowed non-empty lines for a header
 /**
@@ -863,7 +863,7 @@ function isValidISOTimestamp$2(timestamp) {
  * @returns {Object} - The parsed header object.
  * @throws {Error} If header parsing fails (e.g., missing fields, invalid format).
  */
-function parseHeader$3(header, language) {
+function parseHeader$2(header, language) {
     const headerObject = {};
 
     // Get comment style for the language
@@ -972,7 +972,7 @@ function parseHeader$3(header, language) {
             // Special handling for Block-UUID and Parent-UUID
             if (key === "Block-UUID" || key === "Parent-UUID") {
                 if (value !== 'N/A') {
-                    const uuidValidation = validateUUID$3(value); // Use imported function
+                    const uuidValidation = validateUUID$2(value); // Use imported function
                     if (uuidValidation["Block-UUID"] === "INVALID UUID") {
                         // Store invalid status and the suggested correction
                         headerObject[key] = "INVALID UUID";
@@ -1054,7 +1054,7 @@ function getHeaderLineCount$1(headerText, language) {
 
 var headerUtils = {
     isValidISOTimestamp: isValidISOTimestamp$2,
-    parseHeader: parseHeader$3,
+    parseHeader: parseHeader$2,
     getHeaderLineCount: getHeaderLineCount$1 // Export the new function
 };
 
@@ -1074,7 +1074,7 @@ var headerUtils = {
  * @param {string} text - The input text
  * @returns {Object} Object containing arrays of opening and closing fence positions: { openingPositions: Array, closingPositions: Array }
  */
-function findAllCodeFences$4(text) {
+function findAllCodeFences$2(text) {
     const openingPositions = [];
     const closingPositions = [];
 
@@ -1139,7 +1139,7 @@ function findAllCodeFences$4(text) {
  * @param {Array} closingPositions - Array of closing fence objects { position, length }
  * @returns {Object} Object containing: { completeBlocks: Array, incompleteBlocks: Array, warnings: Array }
  */
-function matchFencesAndExtractBlocks$4(text, openingPositions, closingPositions) {
+function matchFencesAndExtractBlocks$2(text, openingPositions, closingPositions) {
     const completeBlocks = [];
     const incompleteBlocks = [];
     const warnings = [];
@@ -1298,7 +1298,7 @@ function extractCodeBlocksWithUUIDs$1(messageText) {
  * @param {string} blockUUID - The Block-UUID to find
  * @returns {Object|null} Code block object or null if not found
  */
-function findCodeBlockByUUID$2(messageText, blockUUID) {
+function findCodeBlockByUUID$1(messageText, blockUUID) {
     if (!messageText || !blockUUID) {
         return null;
     }
@@ -1308,10 +1308,10 @@ function findCodeBlockByUUID$2(messageText, blockUUID) {
 }
 
 var blockExtractor = {
-    findAllCodeFences: findAllCodeFences$4,
-    matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$4,
+    findAllCodeFences: findAllCodeFences$2,
+    matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$2,
     extractCodeBlocksWithUUIDs: extractCodeBlocksWithUUIDs$1,
-    findCodeBlockByUUID: findCodeBlockByUUID$2
+    findCodeBlockByUUID: findCodeBlockByUUID$1
 };
 
 /**
@@ -1458,7 +1458,7 @@ function validateAnalysisMetadata(metadata) {
 }
 
 
-var AnalysisBlockUtils$3 = { 
+var AnalysisBlockUtils$2 = { 
     isAnalysisBlock,
     getAnalysisBlockType,
     parseOverviewMetadata: parseOverviewMetadata$1,
@@ -1807,7 +1807,7 @@ var constants$1 = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
  */
 
-const { removeLineNumbers: removeLineNumbers$8 } = lineNumberFormatter; // Assuming this utility exists
+const { removeLineNumbers: removeLineNumbers$7 } = lineNumberFormatter; // Assuming this utility exists
 const { CONTENT_LINE_REGEX: CONTENT_LINE_REGEX$4, HUNK_HEADER_REGEX: HUNK_HEADER_REGEX$3 } = constants$1;
 
 
@@ -1972,7 +1972,7 @@ var formatAndAddLineNumbers_1 = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Claude 3.7 Sonnet (v1.1.0, v1.2.0)
  */
 
-const { removeLineNumbers: removeLineNumbers$7 } = lineNumberFormatter; // Assuming this utility exists
+const { removeLineNumbers: removeLineNumbers$6 } = lineNumberFormatter; // Assuming this utility exists
 const { CONTENT_LINE_REGEX: CONTENT_LINE_REGEX$3 } = constants$1;
 const { formatAndAddLineNumbers: formatAndAddLineNumbers$1 } = formatAndAddLineNumbers_1; // Import the helper
 
@@ -2020,7 +2020,7 @@ function verifyAndCorrectLineNumbers$2(patchText, sourceText, windowSize = 251)
     const formatResult = formatAndAddLineNumbers$1(patchText, sourceText);
     const patchLines = formatResult.formattedPatchText.split('\n');
     // Ensure source is clean (defensive check, though caller should provide clean source)
-    const sourceLines = removeLineNumbers$7(sourceText).split('\n');
+    const sourceLines = removeLineNumbers$6(sourceText).split('\n');
     const outputLines = [];
     const errors = [];
     let correctionsMade = formatResult.correctionsMade; // Inherit corrections made by formatter
@@ -6578,7 +6578,7 @@ function escapeHTML(s) {
 
 const parser$1 = patchParser;
 const jsdiff$1 = lib;
-const { removeLineNumbers: removeLineNumbers$6 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$5 } = lineNumberFormatter;
 
 /**
  * Apply patch against source code. Expects traditional unified diff format.
@@ -6620,7 +6620,7 @@ function applyPatch(sourceText, patchText) {
         }
 
         // 1.1. Play it safe and clean sourceText by removing potential line numbers
-        sourceText = removeLineNumbers$6(sourceText);
+        sourceText = removeLineNumbers$5(sourceText);
 
         // 2. Extract metadata (optional for applying, but good practice)
         const metadata = parser$1.extractPatchMetadata(patchText);
@@ -6685,8 +6685,8 @@ function createPatch(sourceText, targetCode, metadata = {}, filename = 'Original
 
     try {
         // --- CRITICAL: jsdiff needs CLEAN text ---
-        const cleanSource = removeLineNumbers$6(sourceText);
-        const cleanTarget = removeLineNumbers$6(targetCode);
+        const cleanSource = removeLineNumbers$5(sourceText);
+        const cleanTarget = removeLineNumbers$5(targetCode);
 
         // --- Generate standard diff ---
         // Provide filenames for standard diff headers (--- filename \n +++ filename)
@@ -7320,7 +7320,7 @@ var fuzzyMatcher$1 = {
  * Authors: Claude 3.7 Sonnet (v1.0.0), Claude 3.5 Sonnet (v1.1.0, v1.2.0), Claude 3.5 Sonnet (v1.3.0), Gemini 2.5 Flash (v1.3.0)
  */
 const { findBestContextMatch: findBestContextMatch$1, findBestMatchWithSlidingWindow: findBestMatchWithSlidingWindow$1 } = fuzzyMatcher$1;
-const { removeLineNumbers: removeLineNumbers$5 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$4 } = lineNumberFormatter;
 
 /**
  * Parses a hunk into its components
@@ -7340,7 +7340,7 @@ function parseHunk(hunkText) {
 
     for (const line of contentLines) {
         // Clean line numbers from the content
-        const cleanLine = removeLineNumbers$5(line.substring(1));
+        const cleanLine = removeLineNumbers$4(line.substring(1));
 
         if (line.startsWith(' ')) {
             // Regular context line - add to both context arrays
@@ -7991,7 +7991,7 @@ var diagnosticReporter$1 = {
  * Authors: Claude 3.7 Sonnet (v1.0.0)
  */
 
-const { removeLineNumbers: removeLineNumbers$4 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$3 } = lineNumberFormatter;
 
 /**
  * Extracts individual hunks from a patch
@@ -8098,7 +8098,7 @@ function cleanHunkLineNumbers$1(hunkText) {
 
         if (line.startsWith(' ') || line.startsWith('+') || line.startsWith('-')) {
             const prefix = line[0];
-            const content = removeLineNumbers$4(line.substring(1));
+            const content = removeLineNumbers$3(line.substring(1));
             cleanedLines.push(`${prefix}${content}`);
         } else {
             // Non-content line, keep as is
@@ -8167,7 +8167,7 @@ var patchExtractor$1 = {
  */
 
 const jsdiff = lib;
-const { removeLineNumbers: removeLineNumbers$3 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$2 } = lineNumberFormatter;
 const { extractAndCleanHunks, reconstructPatch } = patchExtractor$1;
 const { validateHunk, validateHunks } = hunkValidator$1;
 const { findBestContextMatch, findBestMatchWithSlidingWindow } = fuzzyMatcher$1;
@@ -8220,7 +8220,7 @@ function applyPatchWithDiagnostics(sourceText, patchText) {
     }
 
     // Clean source text (remove any line numbers)
-    const cleanSourceText = removeLineNumbers$3(sourceText);
+    const cleanSourceText = removeLineNumbers$2(sourceText);
 
     // First, clean up redundant changes
     const redundantFixResult = detectAndFixRedundantChanges(patchText, true);
@@ -8388,7 +8388,7 @@ function validatePatch(sourceText, patchText) {
     }
 
     // Clean source text
-    const cleanSourceText = removeLineNumbers$3(sourceText);
+    const cleanSourceText = removeLineNumbers$2(sourceText);
 
     // Clean up redundant changes
     const redundantFixResult = detectAndFixRedundantChanges(patchText, true);
@@ -8465,7 +8465,7 @@ function applyHunk(sourceText, hunkText) {
     }
 
     // Clean source text
-    const cleanSourceText = removeLineNumbers$3(sourceText);
+    const cleanSourceText = removeLineNumbers$2(sourceText);
 
     // Clean hunk line numbers
     const cleanHunk = cleanHunkLineNumbers(hunkText);
@@ -8599,7 +8599,7 @@ const enhancedProcessor = enhancedPatchProcessor;
  */
 
 // Export all modules
-var PatchUtils$2 = {
+var PatchUtils$1 = {
     // Original exports (for backward compatibility)
     validateAndParseContextPatch: parser.validateAndParseContextPatch,
     determinePatchFormat: parser.determinePatchFormat,
@@ -8681,112 +8681,554 @@ var PatchUtils$2 = {
 };
 
 /**
- * Component: GitSense Tool Block Utilities
- * Block-UUID: 72db6a5f-3b09-49e8-8f39-d4e3d37b510a
- * Parent-UUID: N/A
- * Version: 1.0.0
- * Description: Provides utility functions for identifying and parsing GitSense Chat Tool Blocks.
+ * Component: CodeBlockUtils Update Code Block
+ * Block-UUID: 6a7b8c9d-0e1f-42a3-b4c5-d6e7f8a9b0c1
+ * Parent-UUID: 5f9c1e3a-7b2d-4e8f-a1d0-9c4b2e1f8a0b
+ * Version: 1.4.0
+ * Description: Provides functions to update the content of a specific code block within a string, identified by index, UUID, or direct reference.
  * Language: JavaScript
- * Created-at: 2025-04-27T01:29:53.576Z
- * Authors: Gemini 2.5 Pro (v1.0.0)
+ * Created-at: 2025-04-16T00:56:57.352Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Pro (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
  */
 
-/**
- * Checks if a given code block content represents a GitSense Chat Tool Block.
- * It verifies if the first non-empty line starts with "# GitSense Chat Tool".
- *
- * @param {string} content - The raw content of the code block (within the fences).
- * @returns {boolean} True if it's a GitSense Chat Tool Block, false otherwise.
- */
-function isToolBlock$1(content) {
-    if (!content || typeof content !== 'string') {
-        return false;
-    }
+var updateCodeBlock_1;
+var hasRequiredUpdateCodeBlock;
+
+function requireUpdateCodeBlock () {
+	if (hasRequiredUpdateCodeBlock) return updateCodeBlock_1;
+	hasRequiredUpdateCodeBlock = 1;
+	// Dependencies from other modules within CodeBlockUtils
+	const { findAllCodeFences, matchFencesAndExtractBlocks, findCodeBlockByUUID } = blockExtractor; // Added findCodeBlockByUUID
+	const { processCodeBlocks } = requireBlockProcessor(); // To get parsed block info
+
+	/**
+	 * Replaces the content of a code block specified by its index within a message string.
+	 *
+	 * @param {string} messageContent - The original message string containing code blocks.
+	 * @param {number} blockIndex - The 0-based index of the code block to replace.
+	 * @param {string} newCodeContent - The new raw content (code, potentially including header) to insert into the block.
+	 * @param {string} [language] - Optional: The language identifier for the updated code block fence. If omitted, the original language is preserved.
+	 * @returns {string} The message content with the specified code block updated.
+	 * @throws {Error} If the blockIndex is out of bounds or if block boundaries cannot be determined.
+	 */
+	function updateCodeBlockByIndex(messageContent, blockIndex, newCodeContent, language = undefined) {
+	    if (typeof messageContent !== 'string') {
+	        throw new Error("messageContent must be a string.");
+	    }
+	    if (typeof blockIndex !== 'number' || blockIndex < 0) {
+	        throw new Error("blockIndex must be a non-negative number.");
+	    }
+	    if (typeof newCodeContent !== 'string') {
+	        // Allow empty string replacement, but not other types
+	        throw new Error("newCodeContent must be a string.");
+	    }
 
-    if (content.match(/^\s*# GitSense Chat Tool\n\s*{/)) 
-        return true;
+	    // Step 1: Find all fence positions to get accurate start/end of the full block
+	    const { openingPositions, closingPositions } = findAllCodeFences(messageContent);
+	    const { completeBlocks, incompleteBlocks, warnings: extractorWarnings } = matchFencesAndExtractBlocks(
+	        messageContent, openingPositions, closingPositions
+	    );
 
-    return false;
+	    // Combine complete and incomplete for indexing, assuming we might want to update an incomplete one too
+	    // Note: Replacing content in an incomplete block might be unusual, but technically possible.
+	    const allBlocks = [...completeBlocks, ...incompleteBlocks];
+
+	    // Step 2: Validate index
+	    if (blockIndex >= allBlocks.length) {
+	        throw new Error(`blockIndex ${blockIndex} is out of bounds. Found ${allBlocks.length} blocks.`);
+	    }
+
+	    // Step 3: Get the target block's boundary information
+	    const targetBlockBoundaries = allBlocks[blockIndex];
+	    const openingFence = targetBlockBoundaries.opening;
+	    const closingFence = targetBlockBoundaries.closing; // Will be undefined for incomplete blocks
+
+	    if (!openingFence) {
+	        // Should not happen if index is valid, but good practice to check
+	        throw new Error(`Could not find opening fence for block at index ${blockIndex}.`);
+	    }
+
+	    // Determine the exact start and end of the full markdown block
+	    const blockStartPos = openingFence.position;
+	    // If the block is incomplete, the end is the end of the messageContent
+	    const blockEndPos = closingFence
+	        ? closingFence.position + closingFence.length
+	        : messageContent.length;
+
+	    // Step 4: Construct the replacement block string
+	    const targetLanguage = language !== undefined ? language : (openingFence.language || ''); // Use provided language or original/empty
+	    const newBlockString = `\`\`\`${targetLanguage}\n${newCodeContent}\n\`\`\``;
+
+	    // Step 5: Perform the replacement
+	    const updatedMessageContent =
+	        messageContent.substring(0, blockStartPos) +
+	        newBlockString +
+	        messageContent.substring(blockEndPos);
+
+	    return updatedMessageContent;
+	}
+
+	/**
+	 * Replaces the content of a code block specified by its Block-UUID within a message string.
+	 *
+	 * @param {string} messageContent - The original message string containing code blocks.
+	 * @param {string} blockUUID - The Block-UUID of the code block to replace.
+	 * @param {string} newCodeContent - The new raw content (code, potentially including header) to insert into the block.
+	 * @param {string} [language] - Optional: The language identifier for the updated code block fence. If omitted, the original language is preserved.
+	 * @returns {string} The message content with the specified code block updated.
+	 * @throws {Error} If no block with the specified UUID is found, or if multiple blocks have the same UUID.
+	 */
+	function updateCodeBlockByUUID(messageContent, blockUUID, newCodeContent, language = undefined) {
+	    if (typeof messageContent !== 'string') {
+	        throw new Error("messageContent must be a string.");
+	    }
+	    if (typeof blockUUID !== 'string' || !blockUUID) {
+	        throw new Error("blockUUID must be a non-empty string.");
+	    }
+	    if (typeof newCodeContent !== 'string') {
+	        throw new Error("newCodeContent must be a string.");
+	    }
+
+	    // Step 1: Process blocks to get headers and find the target index
+	    const { blocks: processedBlocks, warnings } = processCodeBlocks(messageContent, { silent: true });
+
+	    let targetIndex = -1;
+
+	    for (let i = 0; i < processedBlocks.length; i++) {
+	        const block = processedBlocks[i];
+	        let match = false;
+
+	        // Check standard code blocks by Block-UUID
+	        if ((block.type === 'code') && block.header && block.header['Block-UUID'] === blockUUID) {
+	            match = true;
+	        }
+	        // Check patch blocks by Target-Block-UUID
+	        else if (block.type === 'patch' && block.metadata && block.metadata['Target-Block-UUID'] === blockUUID) {
+	            match = true;
+	        }
+
+	        if (match) {
+	            // If we've already found one, log a warning but still update the first one found.
+	            if (targetIndex !== -1) {
+	                console.warn(`Multiple blocks found matching UUID: ${blockUUID} (could be Block-UUID or Target-Block-UUID). Updating the first occurrence.`);
+	            } else {
+	                targetIndex = i;
+	            }
+	        }
+	    }
+
+	    // Step 2: Handle findings
+	    if (targetIndex === -1) { // Use targetIndex to check if *any* valid match was set
+	        throw new Error(`No code or patch block found matching UUID: ${blockUUID} (checked Block-UUID and Target-Block-UUID).`);
+	    }
+	    // Warning for multiple matches is handled inside the loop now.
+
+	    // Step 3: Call the index-based function
+	    // We need the index relative to *all* blocks (complete and incomplete), not just processed ones.
+	    // Re-extract boundaries to get the correct index mapping.
+	    const { openingPositions, closingPositions } = findAllCodeFences(messageContent);
+	    const { completeBlocks, incompleteBlocks } = matchFencesAndExtractBlocks(
+	        messageContent, openingPositions, closingPositions
+	    );
+	    const allBlocks = [...completeBlocks, ...incompleteBlocks];
+
+	    // Find the index in the combined list that corresponds to the processed block's position
+	    const targetProcessedBlock = processedBlocks[targetIndex];
+	    const actualIndex = allBlocks.findIndex(b => b.opening.position === targetProcessedBlock.position);
+
+	    if (actualIndex === -1) {
+	        // This indicates a discrepancy between blockProcessor and blockExtractor results, which shouldn't happen.
+	        throw new Error(`Internal error: Could not map processed block at index ${targetIndex} (matching UUID: ${blockUUID}) back to extracted block boundaries.`);
+	    }
+
+	    // Pass the optional language parameter down
+	    return updateCodeBlockByIndex(messageContent, actualIndex, newCodeContent, language);
+	}
+
+	/**
+	 * Updates a code block in message text identified by UUID.
+	 * (Moved from original PatchUtils)
+	 * @param {string} messageText - The original message text
+	 * @param {string} blockUUID - The Block-UUID to update
+	 * @param {string} newCode - The new code content (raw content, including header if applicable)
+	 * @param {string} language - The code language for the fence
+	 * @returns {string} Updated message text
+	 * @throws {Error} If block not found or parameters missing.
+	 */
+	function updateCodeBlockInMessage(messageText, blockUUID, newCode, language) {
+	    if (!messageText || !blockUUID || newCode === null || newCode === undefined) { // Allow empty string for newCode
+	        throw new Error("Missing required parameters for updating code block (messageText, blockUUID, newCode)");
+	    }
+
+	    // Use findCodeBlockByUUID from blockExtractor
+	    const block = findCodeBlockByUUID(messageText, blockUUID);
+
+	    if (!block) {
+	        throw new Error(`Code block with UUID ${blockUUID} not found`);
+	    }
+
+	    // Construct the new full block string
+	    const newBlockString = '```' + (language || block.language) + '\n' + newCode + '\n```';
+
+	    // Replace the old block with the new one using precise indices
+	    return messageText.substring(0, block.startIndex) +
+	           newBlockString +
+	           messageText.substring(block.endIndex);
+	}
+
+
+	/**
+	 * Generic router function to update a code block by index or UUID.
+	 *
+	 * @param {string} messageContent - The original message string.
+	 * @param {number|string} identifier - The block index (number) or Block-UUID (string).
+	 * @param {string} newCodeContent - The new raw content for the block.
+	 * @param {string} [language] - Optional: The language identifier for the updated code block fence.
+	 * @returns {string} The updated message content.
+	 * @throws {Error} If the identifier type is invalid or if the underlying update function fails.
+	 */
+	function updateCodeBlock(messageContent, identifier, newCodeContent, language = undefined) {
+	    if (typeof identifier === 'number') {
+	        // Pass language to index-based function
+	        return updateCodeBlockByIndex(messageContent, identifier, newCodeContent, language);
+	    } else if (typeof identifier === 'string') {
+	        // Pass language to UUID-based function
+	        return updateCodeBlockByUUID(messageContent, identifier, newCodeContent, language);
+	    } else {
+	        throw new Error("Invalid identifier type. Must be a number (index) or a string (UUID).");
+	    }
+	}
+
+	/**
+	 * Deletes a code block specified by its index within a message string.
+	 *
+	 * @param {string} messageContent - The original message string containing code blocks.
+	 * @param {number} blockIndex - The 0-based index of the code block to delete.
+	 * @returns {string} The message content with the specified code block deleted.
+	 * @throws {Error} If the blockIndex is out of bounds or if block boundaries cannot be determined.
+	 */
+	function deleteCodeBlockByIndex(messageContent, blockIndex) {
+	    if (typeof messageContent !== 'string') {
+	        throw new Error("messageContent must be a string.");
+	    }
+	    if (typeof blockIndex !== 'number' || blockIndex < 0) {
+	        throw new Error("blockIndex must be a non-negative number.");
+	    }
+
+	    // Step 1: Find all fence positions to get accurate start/end of the full block
+	    const { openingPositions, closingPositions } = findAllCodeFences(messageContent);
+	    const { completeBlocks, incompleteBlocks } = matchFencesAndExtractBlocks(
+	        messageContent, openingPositions, closingPositions
+	    );
+
+	    // Combine complete and incomplete for indexing
+	    const allBlocks = [...completeBlocks, ...incompleteBlocks];
+
+	    // Step 2: Validate index
+	    if (blockIndex >= allBlocks.length) {
+	        throw new Error(`blockIndex ${blockIndex} is out of bounds. Found ${allBlocks.length} blocks.`);
+	    }
+
+	    // Step 3: Get the target block's boundary information
+	    const targetBlockBoundaries = allBlocks[blockIndex];
+	    const openingFence = targetBlockBoundaries.opening;
+	    const closingFence = targetBlockBoundaries.closing; // Will be undefined for incomplete blocks
+
+	    if (!openingFence) {
+	        // Should not happen if index is valid, but good practice to check
+	        throw new Error(`Could not find opening fence for block at index ${blockIndex}.`);
+	    }
+
+	    // Determine the exact start and end of the full markdown block
+	    const blockStartPos = openingFence.position;
+	    // If the block is incomplete, the end is the end of the messageContent
+	    const blockEndPos = closingFence
+	        ? closingFence.position + closingFence.length
+	        : messageContent.length;
+
+	    // Step 4: Perform the deletion
+	    const updatedMessageContent =
+	        messageContent.substring(0, blockStartPos) +
+	        messageContent.substring(blockEndPos);
+
+	    return updatedMessageContent;
+	}
+
+	/**
+	 * Deletes a code block specified by its Block-UUID within a message string.
+	 *
+	 * @param {string} messageContent - The original message string containing code blocks.
+	 * @param {string} blockUUID - The Block-UUID of the code block to delete.
+	 * @returns {string} The message content with the specified code block deleted.
+	 * @throws {Error} If no block with the specified UUID is found, or if multiple blocks have the same UUID.
+	 */
+	function deleteCodeBlockByUUID(messageContent, blockUUID) {
+	    if (typeof messageContent !== 'string') {
+	        throw new Error("messageContent must be a string.");
+	    }
+	    if (typeof blockUUID !== 'string' || !blockUUID) {
+	        throw new Error("blockUUID must be a non-empty string.");
+	    }
+
+	    // Step 1: Process blocks to get headers and find the target index
+	    const { blocks: processedBlocks, warnings } = processCodeBlocks(messageContent, { silent: true });
+
+	    let targetIndex = -1;
+
+	    for (let i = 0; i < processedBlocks.length; i++) {
+	        const block = processedBlocks[i];
+	        let match = false;
+
+	        // Check standard code blocks by Block-UUID
+	        if (block.type === 'code' && block.header && block.header['Block-UUID'] === blockUUID) {
+	            match = true;
+	        }
+	        // Check patch blocks by Target-Block-UUID
+	        else if (block.type === 'patch' && block.metadata && block.metadata['Target-Block-UUID'] === blockUUID) {
+	            match = true;
+	        }
+
+	        if (match) {
+	            // If we've already found one, log a warning but still target the first one found.
+	            if (targetIndex !== -1) {
+	                console.warn(`Multiple blocks found matching UUID: ${blockUUID} (could be Block-UUID or Target-Block-UUID). Deleting the first occurrence.`);
+	            } else {
+	                targetIndex = i;
+	            }
+	        }
+	    }
+
+	    // Step 2: Handle findings
+	    if (targetIndex === -1) { // Use targetIndex to check if *any* valid match was set
+	        throw new Error(`No code or patch block found matching UUID: ${blockUUID} (checked Block-UUID and Target-Block-UUID).`);
+	    }
+	    // Warning for multiple matches is handled inside the loop now.
+
+	    // Step 3: Call the index-based function
+	    // We need the index relative to *all* blocks (complete and incomplete), not just processed ones.
+	    // Re-extract boundaries to get the correct index mapping.
+	    const { openingPositions, closingPositions } = findAllCodeFences(messageContent);
+	    const { completeBlocks, incompleteBlocks } = matchFencesAndExtractBlocks(
+	        messageContent, openingPositions, closingPositions
+	    );
+	    const allBlocks = [...completeBlocks, ...incompleteBlocks];
+
+	    // Find the index in the combined list that corresponds to the processed block's position
+	    const targetProcessedBlock = processedBlocks[targetIndex];
+	    const actualIndex = allBlocks.findIndex(b => b.opening.position === targetProcessedBlock.position);
+
+	    if (actualIndex === -1) {
+	        // This indicates a discrepancy between blockProcessor and blockExtractor results, which shouldn't happen.
+	        throw new Error(`Internal error: Could not map processed block at index ${targetIndex} (matching UUID: ${blockUUID}) back to extracted block boundaries.`);
+	    }
+
+	    return deleteCodeBlockByIndex(messageContent, actualIndex);
+	}
+
+	/**
+	 * Generic router function to delete a code block by index or UUID.
+	 *
+	 * @param {string} messageContent - The original message string.
+	 * @param {number|string} identifier - The block index (number) or Block-UUID (string).
+	 * @returns {string} The updated message content.
+	 * @throws {Error} If the identifier type is invalid or if the underlying delete function fails.
+	 */
+	function deleteCodeBlock(messageContent, identifier) {
+	    if (typeof identifier === 'number') {
+	        return deleteCodeBlockByIndex(messageContent, identifier);
+	    } else if (typeof identifier === 'string') {
+	        return deleteCodeBlockByUUID(messageContent, identifier);
+	    } else {
+	        throw new Error("Invalid identifier type. Must be a number (index) or a string (UUID).");
+	    }
+	}
+
+	updateCodeBlock_1 = {
+	    updateCodeBlockByIndex,
+	    updateCodeBlockByUUID,
+	    updateCodeBlock,
+	    updateCodeBlockInMessage,
+	    deleteCodeBlockByIndex,
+	    deleteCodeBlockByUUID,
+	    deleteCodeBlock,
+	};
+	return updateCodeBlock_1;
 }
 
 /**
- * Parses the content of a GitSense Chat Tool Block to extract the JSON payload.
- * It strips the marker line and any subsequent lines starting with '#' (comments)
- * or empty lines before attempting to parse the remaining content as JSON.
- *
- * @param {string} content - The raw content of the code block, verified by isToolBlock.
- * @returns {{ tool: string, config: object, data: object } | null} The parsed JSON object { tool, config, data } or null if parsing fails or format is invalid.
- * @throws {Error} If JSON parsing fails.
- */
-function parseToolBlock$1(content) {
-    if (!isToolBlock$1(content)) {
-        return null; // Should already be verified, but double-check
-    }
+ * Component: GitSense Tool Block Utilities
+ * Block-UUID: 8e1f7b4e-7e30-48b4-a7fc-643bf647661f
+ * Parent-UUID: 72db6a5f-3b09-49e8-8f39-d4e3d37b510a
+ * Version: 1.1.0
+ * Description: Provides utility functions for identifying and parsing GitSense Chat Tool Blocks, and now for replacing them within markdown.
+ * Language: JavaScript
+ * Created-at: 2025-09-12T17:23:34.779Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ */
+
+var GSToolBlockUtils$2;
+var hasRequiredGSToolBlockUtils;
+
+function requireGSToolBlockUtils () {
+	if (hasRequiredGSToolBlockUtils) return GSToolBlockUtils$2;
+	hasRequiredGSToolBlockUtils = 1;
+	const { updateCodeBlockByIndex } = requireUpdateCodeBlock();
+	const { processCodeBlocks } = requireBlockProcessor();
+
+	/**
+	 * Checks if a given code block content represents a GitSense Chat Tool Block.
+	 * It verifies if the first non-empty line starts with "# GitSense Chat Tool".
+	 *
+	 * @param {string} content - The raw content of the code block (within the fences).
+	 * @returns {boolean} True if it's a GitSense Chat Tool Block, false otherwise.
+	 */
+	function isToolBlock(content) {
+	    if (!content || typeof content !== 'string') {
+	        return false;
+	    }
 
-    const lines = content.split('\n');
-    const jsonLines = [];
-    let markerFound = false;
+	    if (content.match(/^\s*# GitSense Chat Tool\n\s*{/)) 
+	        return true;
 
-    for (const line of lines) {
-        const trimmedLine = line.trim();
+	    return false;
+	}
 
-        if (!markerFound) {
-            if (trimmedLine.startsWith('# GitSense Chat Tool')) {
-                markerFound = true; // Skip the marker line itself
-            }
-            continue; // Skip lines before the marker (shouldn't be any non-empty ones based on isToolBlock)
-        }
+	/**
+	 * Parses the content of a GitSense Chat Tool Block to extract the JSON payload.
+	 * It strips the marker line and any subsequent lines starting with '#' (comments)
+	 * or empty lines before attempting to parse the remaining content as JSON.
+	 *
+	 * @param {string} content - The raw content of the code block, verified by isToolBlock.
+	 * @returns {{ tool: string, config: object, data: object } | null} The parsed JSON object { tool, config, data } or null if parsing fails or format is invalid.
+	 * @throws {Error} If JSON parsing fails.
+	 */
+	function parseToolBlock(content) {
+	    if (!isToolBlock(content)) {
+	        return null; // Should already be verified, but double-check
+	    }
 
-        // After the marker, skip empty lines and comment lines
-        if (trimmedLine.length === 0 || /^\s*#/.test(line)) {
-            continue;
-        }
+	    const lines = content.split('\n');
+	    const jsonLines = [];
+	    let markerFound = false;
 
-        // Keep lines that are part of the JSON
-        jsonLines.push(line);
-    }
+	    for (const line of lines) {
+	        const trimmedLine = line.trim();
 
-    const jsonString = jsonLines.join('\n');
+	        if (!markerFound) {
+	            if (trimmedLine.startsWith('# GitSense Chat Tool')) {
+	                markerFound = true; // Skip the marker line itself
+	            }
+	            continue; // Skip lines before the marker (shouldn't be any non-empty ones based on isToolBlock)
+	        }
 
-    if (!jsonString) {
-        // No JSON content found after stripping comments/marker
-        throw new Error("No JSON content found in the tool block after stripping marker and comments.");
-    }
+	        // After the marker, skip empty lines and comment lines
+	        if (trimmedLine.length === 0 || /^\s*#/.test(line)) {
+	            continue;
+	        }
 
-    try {
-        const parsed = JSON.parse(jsonString);
+	        // Keep lines that are part of the JSON
+	        jsonLines.push(line);
+	    }
 
-        // Basic validation of the parsed structure
-        // The properties tool and  config are required.  Tool cannot be null or undefined but
-        // config can't. The reason for requiring config to be declared is to reserve the 
-        // property name.
-        if (typeof parsed !== 'object' || parsed === null) {
-            throw new Error("Parsed content is not a valid JSON object.");
-        }
-        if (typeof parsed.tool !== 'string' || !parsed.tool) {
-            throw new Error("Parsed JSON object is missing the required 'tool' string property.");
-        }
+	    const jsonString = jsonLines.join('\n');
 
-        if (typeof parsed.config === 'undefined') {
-            throw new Error("Parsed JSON object is missing the required 'config' property.");
-        }
+	    if (!jsonString) {
+	        // No JSON content found after stripping comments/marker
+	        throw new Error("No JSON content found in the tool block after stripping marker and comments.");
+	    }
 
-        return parsed;
-    } catch (error) {
-        // Re-throw JSON parsing errors with more context
-        throw new Error(`Failed to parse tool block JSON: ${error.message}\nContent after stripping comments:\n${jsonString}`);
-    }
-}
+	    try {
+	        const parsed = JSON.parse(jsonString);
 
-function formatToolBlock(toolData) {
-    return `# GitSense Chat Tool\n\n${JSON.stringify(toolData, null, 2)}`;
-}
+	        // Basic validation of the parsed structure
+	        // The properties tool and  config are required.  Tool cannot be null or undefined but
+	        // config can't. The reason for requiring config to be declared is to reserve the 
+	        // property name.
+	        if (typeof parsed !== 'object' || parsed === null) {
+	            throw new Error("Parsed content is not a valid JSON object.");
+	        }
+	        if (typeof parsed.tool !== 'string' || !parsed.tool) {
+	            throw new Error("Parsed JSON object is missing the required 'tool' string property.");
+	        }
 
-var GSToolBlockUtils$3 = {
-    isToolBlock: isToolBlock$1,
-    parseToolBlock: parseToolBlock$1,
-    formatToolBlock
-};
+	        if (typeof parsed.config === 'undefined') {
+	            throw new Error("Parsed JSON object is missing the required 'config' property.");
+	        }
+
+	        return parsed;
+	    } catch (error) {
+	        // Re-throw JSON parsing errors with more context
+	        throw new Error(`Failed to parse tool block JSON: ${error.message}\nContent after stripping comments:\n${jsonString}`);
+	    }
+	}
+
+	/**
+	 * Formats tool data into a GitSense Chat Tool Block string.
+	 *
+	 * @param {object} toolData - The tool data object to format.
+	 * @returns {string} The formatted GitSense Chat Tool Block string.
+	 */
+	function formatToolBlock(toolData) {
+	    return `# GitSense Chat Tool\n\n${JSON.stringify(toolData, null, 2)}`;
+	}
+
+	/**
+	 * Replaces a specific GitSense Chat Tool Block within a markdown string with updated tool data.
+	 * This function leverages CodeBlockUtils for robust parsing and updating.
+	 *
+	 * @param {string} markdownContent - The original markdown string containing code blocks.
+	 * @param {string} toolName - The 'tool' property value of the target GitSense Chat Tool Block to replace.
+	 * @param {Object} newToolData - The new tool data object to insert into the block.
+	 * @returns {string} The markdown content with the specified tool block updated.
+	 * @throws {Error} If the target tool block is not found or if CodeBlockUtils encounters an error.
+	 */
+	function replaceToolBlock(markdownContent, toolName, newToolData) {
+	    if (typeof markdownContent !== 'string' || !toolName || !newToolData) {
+	        throw new Error("Missing required parameters for replaceToolBlock.");
+	    }
+
+	    // 1. Process the markdown content to find all code blocks
+	    const { blocks, warnings } = processCodeBlocks(markdownContent, { silent: true });
+
+	    let targetBlockIndex = -1;
+
+	    // 2. Iterate through the processed blocks to find the target GitSense Chat Tool Block
+	    for (let i = 0; i < blocks.length; i++) {
+	        const block = blocks[i];
+	        if (block.type === 'gs-tool' && block.toolData && block.toolData.tool === toolName) {
+	            targetBlockIndex = i;
+	            break; // Found the first matching tool block
+	        }
+	    }
+
+	    if (targetBlockIndex === -1) {
+	        console.warn(`replaceToolBlock: No GitSense Chat Tool Block with name "${toolName}" found to replace.`);
+	        return markdownContent; // Return original content if no replacement occurred
+	    }
+
+	    // 3. Format the new tool data into the content that goes *inside* the fences
+	    const newContentBetweenFences = formatToolBlock(newToolData);
+
+	    // 4. Use CodeBlockUtils.updateCodeBlockByIndex to perform the replacement
+	    // The language for GitSense Tool Blocks is always 'txt'
+	    const updatedMarkdown = updateCodeBlockByIndex(
+	        markdownContent,
+	        targetBlockIndex,
+	        newContentBetweenFences,
+	        'txt'
+	    );
+
+	    return updatedMarkdown;
+	}
+
+	GSToolBlockUtils$2 = {
+	    isToolBlock,
+	    parseToolBlock,
+	    formatToolBlock,
+	    replaceToolBlock,
+	};
+	return GSToolBlockUtils$2;
+}
 
 /*
  * Component: CodeBlockUtils Continuation Utilities
@@ -8807,7 +9249,7 @@ var GSToolBlockUtils$3 = {
  * @param {Object} header - The parsed header object from the incomplete block (if available).
  * @returns {Object} Continuation information { lastLines: Array<string>, blockUUID: string|null, partNumber: number, language: string, metadata: Object }
  */
-function extractContinuationInfo$3(content, partNumber, language, header = {}) {
+function extractContinuationInfo$2(content, partNumber, language, header = {}) {
     // Extract Block-UUID directly from the parsed header if available and valid
     let blockUUID = (header && header['Block-UUID'] && header['Block-UUID'] !== 'INVALID UUID')
         ? header['Block-UUID']
@@ -8975,7 +9417,7 @@ Contribute code starting from the line immediately following the repeated code b
 
 
 var continuationUtils = {
-    extractContinuationInfo: extractContinuationInfo$3,
+    extractContinuationInfo: extractContinuationInfo$2,
     generateContinuationPrompt: generateContinuationPrompt$2
 };
 
@@ -8998,7 +9440,7 @@ var continuationUtils = {
  * @param {string} jsonString The string potentially containing JSON and comments.
  * @returns {string[]} An array of detected comment strings (including their markers).
  */
-function detectJsonComments$2(jsonString) {
+function detectJsonComments$1(jsonString) {
     const comments = [];
     let inString = false;
     let inBlockComment = false;
@@ -9077,7 +9519,7 @@ function detectJsonComments$2(jsonString) {
 }
 
 var JsonUtils$2 = {
-    detectJsonComments: detectJsonComments$2
+    detectJsonComments: detectJsonComments$1
 };
 
 /**
@@ -9091,550 +9533,558 @@ var JsonUtils$2 = {
  * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Flash Thinking (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
  */
 
-const { findAllCodeFences: findAllCodeFences$3, matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$3 } = blockExtractor;
-const { parseHeader: parseHeader$2 } = headerUtils;
-const { validateUUID: validateUUID$2, generateUUID: generateUUID$2 } = uuidUtils;
-const AnalysisBlockUtils$2 = AnalysisBlockUtils$3;
-const PatchUtils$1 = PatchUtils$2;
-const GSToolBlockUtils$2 = GSToolBlockUtils$3;
-const { extractContinuationInfo: extractContinuationInfo$2 } = continuationUtils;
-const { removeLineNumbers: removeLineNumbers$2 } = lineNumberFormatter;
-const { detectJsonComments: detectJsonComments$1 } = JsonUtils$2;
-
-/**
- * Processes a single block's content (internal helper)
- * @param {string} content - The block content
- * @param {string} language - The language of the block
- * @param {number} position - The position in the original text
- * @param {boolean} incomplete - Whether the block is incomplete
- * @param {Object} options - Processing options (e.g., silent, validatePatches)
- * @returns {Object} Processed block object
- */
-function processBlockContent(content, language, position, incomplete, options = { silent: true, validatePatches: false }) {
-    const { silent, validatePatches } = options;
-    let warnings = []; // Collect warnings specific to this block
-    let header = {};
-    let headerText = ''; // Raw header text including comments
-    let headerParseError = null;
-    let headerDelimiterType = null; // 'triple' or 'double'
-    let codeText = content; // Default to all content being code
-
-    // Check if this is a GitSense Tool Block *first*
-    if (GSToolBlockUtils$2.isToolBlock(content)) {
-        let ignoreDueToComments = false;
-        let toolData = null;
-        let toolParseError = null;
-        try {
-            toolData = GSToolBlockUtils$2.parseToolBlock(content);
-        } catch (error) {
-            // When chatting about the tool block, the LLM may add
-            // add comments in it so let's test for this
-            const comments = detectJsonComments$1(content);
+var blockProcessor;
+var hasRequiredBlockProcessor;
+
+function requireBlockProcessor () {
+	if (hasRequiredBlockProcessor) return blockProcessor;
+	hasRequiredBlockProcessor = 1;
+	const { findAllCodeFences, matchFencesAndExtractBlocks } = blockExtractor;
+	const { parseHeader } = headerUtils;
+	const { validateUUID, generateUUID } = uuidUtils;
+	const AnalysisBlockUtils = AnalysisBlockUtils$2;
+	const PatchUtils = PatchUtils$1;
+	const GSToolBlockUtils = requireGSToolBlockUtils();
+	const { extractContinuationInfo } = continuationUtils;
+	const { removeLineNumbers } = lineNumberFormatter;
+	const { detectJsonComments } = JsonUtils$2;
+
+	/**
+	 * Processes a single block's content (internal helper)
+	 * @param {string} content - The block content
+	 * @param {string} language - The language of the block
+	 * @param {number} position - The position in the original text
+	 * @param {boolean} incomplete - Whether the block is incomplete
+	 * @param {Object} options - Processing options (e.g., silent, validatePatches)
+	 * @returns {Object} Processed block object
+	 */
+	function processBlockContent(content, language, position, incomplete, options = { silent: true, validatePatches: false }) {
+	    const { silent, validatePatches } = options;
+	    let warnings = []; // Collect warnings specific to this block
+	    let header = {};
+	    let headerText = ''; // Raw header text including comments
+	    let headerParseError = null;
+	    let headerDelimiterType = null; // 'triple' or 'double'
+	    let codeText = content; // Default to all content being code
+
+	    // Check if this is a GitSense Tool Block *first*
+	    if (GSToolBlockUtils.isToolBlock(content)) {
+	        let ignoreDueToComments = false;
+	        let toolData = null;
+	        let toolParseError = null;
+	        try {
+	            toolData = GSToolBlockUtils.parseToolBlock(content);
+	        } catch (error) {
+	            // When chatting about the tool block, the LLM may add
+	            // add comments in it so let's test for this
+	            const comments = detectJsonComments(content);
+
+	            if (comments.length) {
+	                ignoreDueToComments = true;
+	            } else {
+	                toolParseError = error.message;
+	                warnings.push({
+	                    position: position,
+	                    type: 'gs_tool_block_parse_error',
+	                    message: `Invalid GitSense tool block: ${error.message}`,
+	                    content: content
+	                });
+	            }
+	        }
 
-            if (comments.length) {
-                ignoreDueToComments = true;
-            } else {
-                toolParseError = error.message;
-                warnings.push({
-                    position: position,
-                    type: 'gs_tool_block_parse_error',
-                    message: `Invalid GitSense tool block: ${error.message}`,
-                    content: content
-                });
-            }
-        }
+	        if (ignoreDueToComments) ; else {
+	            return {
+	                type: 'gs-tool',
+	                language: language,
+	                content: content,
+	                position: position,
+	                incomplete: incomplete,
+	                toolData: toolData,
+	                toolParseError: toolParseError,
+	                warnings: warnings,
+	            };
+	        }
+	    }
 
-        if (ignoreDueToComments) ; else {
-            return {
-                type: 'gs-tool',
-                language: language,
-                content: content,
-                position: position,
-                incomplete: incomplete,
-                toolData: toolData,
-                toolParseError: toolParseError,
-                warnings: warnings,
-            };
-        }
-    }
+	    // Check if this is an analysis block *next*
+	    if (AnalysisBlockUtils.isAnalysisBlock(content)) {
+	        const analysisType = AnalysisBlockUtils.getAnalysisBlockType(content);
+	        const analysisMetadata = AnalysisBlockUtils.parseOverviewMetadata(content);
+
+	        // Validate the metadata if it was successfully parsed
+	        let validationResult = { isValid: false, errors: ['Failed to parse analysis metadata'] };
+	        if (analysisMetadata) {
+	            validationResult = AnalysisBlockUtils.validateAnalysisMetadata(analysisMetadata);
+
+	            if (!validationResult.isValid) {
+	                warnings.push({
+	                    position: position,
+	                    type: 'analysis_metadata_error',
+	                    message: `Invalid analysis metadata: ${validationResult.errors.join(', ')}`,
+	                    content: content,
+	                });
+	            }
+	        }
 
-    // Check if this is an analysis block *next*
-    if (AnalysisBlockUtils$2.isAnalysisBlock(content)) {
-        const analysisType = AnalysisBlockUtils$2.getAnalysisBlockType(content);
-        const analysisMetadata = AnalysisBlockUtils$2.parseOverviewMetadata(content);
+	        return {
+	            type: analysisType,
+	            language: language,
+	            content: content,
+	            position: position,
+	            incomplete: incomplete,
+	            analysisMetadata: analysisMetadata,
+	            analysisValidation: validationResult,
+	            warnings: warnings,
+	        };
+	    }
 
-        // Validate the metadata if it was successfully parsed
-        let validationResult = { isValid: false, errors: ['Failed to parse analysis metadata'] };
-        if (analysisMetadata) {
-            validationResult = AnalysisBlockUtils$2.validateAnalysisMetadata(analysisMetadata);
+	    // Check if this is a gitsense-search-flow block *next*
+	    if (language === 'gitsense-search-flow') {
+	        // Future parsing logic for gitsense-search-flow content would go here.
+	        // For now, we just identify the type and keep the raw content.
+	        return {
+	            type: 'gitsense-search-flow',
+	            language: language,
+	            content: content, // Keep raw content for now
+	            position: position,
+	            incomplete: incomplete,
+	            // Add parsedData: {} or similar if parsing is implemented later
+	            warnings: warnings, // Include any warnings collected so far
+	        };
+	    }
 
-            if (!validationResult.isValid) {
-                warnings.push({
-                    position: position,
-                    type: 'analysis_metadata_error',
-                    message: `Invalid analysis metadata: ${validationResult.errors.join(', ')}`,
-                    content: content,
-                });
-            }
-        }
+	    // Then check if this is a patch block
+	    if (PatchUtils.isPatchBlock(content)) {
+	        const patchFormat = PatchUtils.determinePatchFormat(content);
+	        const metadata = PatchUtils.extractPatchMetadata(content); // Extract metadata regardless of validation
+	        const patchContent = PatchUtils.extractPatchContent(content); // Extract raw patch content
+
+	        let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
+
+	        // Validate metadata (always useful)
+	        const errors = PatchUtils.validatePatchMetadata(metadata);
+	        if (errors.length) {
+	            warnings.push({
+	                position: position,
+	                type: 'patch_metadata_error',
+	                message: `Invalid patch metadata: ${errors.join(', ')}`,
+	                content: content,
+	            });
+	            // Decide if invalid metadata makes the whole block invalid or just adds a warning
+	            // For now, just warn, but return the extracted (potentially invalid) metadata.
+	        }
 
-        return {
-            type: analysisType,
-            language: language,
-            content: content,
-            position: position,
-            incomplete: incomplete,
-            analysisMetadata: analysisMetadata,
-            analysisValidation: validationResult,
-            warnings: warnings,
-        };
-    }
+	        // Optionally validate context patch structure if requested
+	        if (patchFormat === 'context' && validatePatches) {
+	            try {
+	                const patches = PatchUtils.extractContextPatches(content);
+	                if (!patches || patches.length === 0) {
+	                    patchValidationResult = { valid: false, errors: ['No valid context patch content found.'], patches: null };
+	                    warnings.push({
+	                        position: position,
+	                        type: 'patch_content_error',
+	                        message: 'No valid context patch content found.',
+	                        content: content,
+	                    });
+	                } else {
+	                    // Basic validation passed (structure was parsable)
+	                    patchValidationResult = { valid: true, errors: [], patches: patches };
+	                }
+	            } catch (error) {
+	                patchValidationResult = { valid: false, errors: [error.message], patches: null };
+	                warnings.push({
+	                    position: position,
+	                    type: 'patch_parse_error',
+	                    message: `Error parsing context patch: ${error.message}`,
+	                    content: content,
+	                });
+	            }
+	        }
 
-    // Check if this is a gitsense-search-flow block *next*
-    if (language === 'gitsense-search-flow') {
-        // Future parsing logic for gitsense-search-flow content would go here.
-        // For now, we just identify the type and keep the raw content.
-        return {
-            type: 'gitsense-search-flow',
-            language: language,
-            content: content, // Keep raw content for now
-            position: position,
-            incomplete: incomplete,
-            // Add parsedData: {} or similar if parsing is implemented later
-            warnings: warnings, // Include any warnings collected so far
-        };
-    }
+	        return {
+	            type: 'patch',
+	            language: language === 'diff' ? 'diff' : language, // Use 'diff' if specified, else keep original
+	            content: content, // Full original content within fences
+	            position: position,
+	            incomplete: incomplete,
+	            metadata: metadata,
+	            patch: patchContent, // Raw patch content after metadata
+	            patchFormat: patchFormat,
+	            patchValidation: validatePatches ? patchValidationResult : undefined, // Include validation only if requested
+	            warnings: warnings,
+	        };
+	    } else {
+	        // For non-patch blocks, remove display line numbers before processing content
+	        content = removeLineNumbers(content); // This is the "cleaned" content
+	    }
 
-    // Then check if this is a patch block
-    if (PatchUtils$1.isPatchBlock(content)) {
-        const patchFormat = PatchUtils$1.determinePatchFormat(content);
-        const metadata = PatchUtils$1.extractPatchMetadata(content); // Extract metadata regardless of validation
-        const patchContent = PatchUtils$1.extractPatchContent(content); // Extract raw patch content
+	    // --- Process as a regular code block ---
+	    // Attempt 1: Look for triple newline separator (our standard)
+	    const tripleNewlineSeparator = '\n\n\n';
+	    const tripleNewlineIndex = content.indexOf(tripleNewlineSeparator);
+
+	    if (tripleNewlineIndex !== -1) {
+	        const potentialHeaderText = content.substring(0, tripleNewlineIndex); // No trim here
+
+	        try {
+	            header = parseHeader(potentialHeaderText, language);
+	            headerText = potentialHeaderText;
+	            codeText = content.substring(tripleNewlineIndex + tripleNewlineSeparator.length);
+	            headerDelimiterType = 'triple';
+	        } catch (error) {
+	            // If parsing fails, it's not a valid header, log warning and try double newline
+	            headerParseError = error.message;
+	            warnings.push({
+	                position: position,
+	                type: 'header_parse_error',
+	                message: `Invalid header (triple newline attempt): ${error.message}. Attempting double newline.`,
+	                content: potentialHeaderText // Show the problematic header text
+	            });
+	            // Do not set header, headerText, codeText, or headerDelimiterType yet.
+	            // Fall through to the next attempt.
+	        }
+	    }
 
-        let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
+	    // Attempt 2: Look for double newline separator (fallback)
+	    // Only if a valid header wasn't found in the triple newline attempt
+	    if (!headerDelimiterType) {
+	        const doubleNewlineSeparator = '\n\n';
+	        const doubleNewlineIndex = content.indexOf(doubleNewlineSeparator);
+
+	        if (doubleNewlineIndex !== -1) {
+	            const potentialHeaderText = content.substring(0, doubleNewlineIndex); // No trim here
+
+	            try {
+	                header = parseHeader(potentialHeaderText, language);
+	                headerText = potentialHeaderText;
+	                codeText = content.substring(doubleNewlineIndex + doubleNewlineSeparator.length);
+	                headerDelimiterType = 'double';
+	            } catch (error) {
+	                // If parsing fails, it's not a valid header, log warning and default to no header
+	                headerParseError = error.message;
+	                warnings.push({
+	                    position: position,
+	                    type: 'header_parse_error',
+	                    message: `Invalid header (double newline attempt): ${error.message}. Treating block as code only.`,
+	                    content: potentialHeaderText // Show the problematic header text
+	                });
+	                // Fall through to default case (no header)
+	            }
+	        }
+	    }
 
-        // Validate metadata (always useful)
-        const errors = PatchUtils$1.validatePatchMetadata(metadata);
-        if (errors.length) {
-            warnings.push({
-                position: position,
-                type: 'patch_metadata_error',
-                message: `Invalid patch metadata: ${errors.join(', ')}`,
-                content: content,
-            });
-            // Decide if invalid metadata makes the whole block invalid or just adds a warning
-            // For now, just warn, but return the extracted (potentially invalid) metadata.
-        }
+	    // Default: If no valid header was found after both attempts
+	    if (!headerDelimiterType && !incomplete) { // Only warn about missing header if the block is complete
+	        warnings.push({
+	            position: position,
+	            type: 'missing_header',
+	            message: `No distinct header found or parsed as valid. Treating block as code only.`,
+	            content: content.substring(0, 100) + '...' // Show beginning of content
+	        });
+	    }
 
-        // Optionally validate context patch structure if requested
-        if (patchFormat === 'context' && validatePatches) {
-            try {
-                const patches = PatchUtils$1.extractContextPatches(content);
-                if (!patches || patches.length === 0) {
-                    patchValidationResult = { valid: false, errors: ['No valid context patch content found.'], patches: null };
-                    warnings.push({
-                        position: position,
-                        type: 'patch_content_error',
-                        message: 'No valid context patch content found.',
-                        content: content,
-                    });
-                } else {
-                    // Basic validation passed (structure was parsable)
-                    patchValidationResult = { valid: true, errors: [], patches: patches };
-                }
-            } catch (error) {
-                patchValidationResult = { valid: false, errors: [error.message], patches: null };
-                warnings.push({
-                    position: position,
-                    type: 'patch_parse_error',
-                    message: `Error parsing context patch: ${error.message}`,
-                    content: content,
-                });
-            }
-        }
+	    return {
+	        type: 'code',
+	        language: language,
+	        header: header,
+	        headerText: headerText.trim(), // Include the raw header text if successfully parsed
+	        content: codeText, // The code part after the header (or full content if no header)
+	        position: position, // Position of the opening fence
+	        headerDelimiterType: headerDelimiterType, // 'triple', 'double', or null
+	        incomplete: incomplete,
+	        warnings: warnings,
+	        headerParseError: headerParseError // Include error message if parsing failed
+	    };
+	}
 
-        return {
-            type: 'patch',
-            language: language === 'diff' ? 'diff' : language, // Use 'diff' if specified, else keep original
-            content: content, // Full original content within fences
-            position: position,
-            incomplete: incomplete,
-            metadata: metadata,
-            patch: patchContent, // Raw patch content after metadata
-            patchFormat: patchFormat,
-            patchValidation: validatePatches ? patchValidationResult : undefined, // Include validation only if requested
-            warnings: warnings,
-        };
-    } else {
-        // For non-patch blocks, remove display line numbers before processing content
-        content = removeLineNumbers$2(content); // This is the "cleaned" content
-    }
 
-    // --- Process as a regular code block ---
-    // Attempt 1: Look for triple newline separator (our standard)
-    const tripleNewlineSeparator = '\n\n\n';
-    const tripleNewlineIndex = content.indexOf(tripleNewlineSeparator);
+	/**
+	 * Processes the content of complete and incomplete blocks (internal helper)
+	 * @param {string} text - The input text
+	 * @param {Array} completeBlocks - Array of complete block objects from extractor
+	 * @param {Array} incompleteBlocks - Array of incomplete block objects from extractor
+	 * @param {Object} options - Processing options
+	 * @returns {Array} Array of processed block objects
+	 */
+	function processBlockContents(text, completeBlocks, incompleteBlocks, options) {
+	    const processedBlocks = [];
+	    const allWarnings = []; // Collect warnings from all blocks
+
+	    // Process complete blocks
+	    for (const block of completeBlocks) {
+	        try {
+	            const startPos = block.opening.position + block.opening.length;
+	            const endPos = block.closing.position;
+	            // Get content, including the newlines immediately after opening and before closing fence
+	            const contentWithNewlines = text.substring(startPos, endPos);
+	            const content = contentWithNewlines; //.replace(/^\s*\n|\n\s*$/g, '');
+
+	            const language = block.opening.language;
+
+	            // Process block content
+	            const processedBlock = processBlockContent(content, language, block.opening.position, false, options);
+	            processedBlocks.push(processedBlock);
+	            if (processedBlock.warnings) {
+	                allWarnings.push(...processedBlock.warnings);
+	            }
+	        } catch (error) {
+	            // Catch errors during the processing of a single block
+	            allWarnings.push({
+	                position: block.opening?.position || -1,
+	                type: 'block_processing_error',
+	                message: `Error processing complete block: ${error.message}`,
+	                content: text.substring(block.opening?.position, block.closing?.position + block.closing?.length) || "Error retrieving block content"
+	            });
+	        }
+	    }
 
-    if (tripleNewlineIndex !== -1) {
-        const potentialHeaderText = content.substring(0, tripleNewlineIndex); // No trim here
+	    // Process incomplete blocks
+	    for (const block of incompleteBlocks) {
+	        try {
+	            const startPos = block.opening.position + block.opening.length;
+	            // Get content from opening fence to end of text
+	            const contentWithNewline = text.substring(startPos);
+	            // Trim only leading whitespace line
+	            const content = contentWithNewline.replace(/^\s*\n/, '');
+
+	            const language = block.opening.language;
+
+	            // Process block content - it's expected to be incomplete
+	            const processedBlock = processBlockContent(content, language, block.opening.position, true, options);
+
+	            // Extract continuation info for incomplete blocks
+	            // Requires extractContinuationInfo from continuationUtils
+	            try {
+	                // Pass the *processed* header info to continuation utils
+	                let { 'Continuation-Part': partNumber } = processedBlock?.header || {};
+	                partNumber = partNumber ? parseInt(partNumber) + 1 : 2; // Default to part 2 if not specified
+	                processedBlock.continuationInfo = extractContinuationInfo(processedBlock.content, partNumber, language, processedBlock.header);
+	            } catch (continuationError) {
+	                allWarnings.push({
+	                    position: block.opening?.position || -1,
+	                    type: 'continuation_info_error',
+	                    message: `Error extracting continuation info: ${continuationError.message}`,
+	                    content: content
+	                });
+	            }
+
+
+	            processedBlocks.push(processedBlock);
+	            if (processedBlock.warnings) {
+	                allWarnings.push(...processedBlock.warnings);
+	            }
+	        } catch (error) {
+	            // Catch errors during the processing of a single incomplete block
+	            allWarnings.push({
+	                position: block.opening?.position || -1,
+	                type: 'incomplete_block_processing_error',
+	                message: `Error processing incomplete block: ${error.message}`,
+	                content: text.substring(block.opening?.position) || "Error retrieving block content"
+	            });
+	        }
+	    }
 
-        try {
-            header = parseHeader$2(potentialHeaderText, language);
-            headerText = potentialHeaderText;
-            codeText = content.substring(tripleNewlineIndex + tripleNewlineSeparator.length);
-            headerDelimiterType = 'triple';
-        } catch (error) {
-            // If parsing fails, it's not a valid header, log warning and try double newline
-            headerParseError = error.message;
-            warnings.push({
-                position: position,
-                type: 'header_parse_error',
-                message: `Invalid header (triple newline attempt): ${error.message}. Attempting double newline.`,
-                content: potentialHeaderText // Show the problematic header text
-            });
-            // Do not set header, headerText, codeText, or headerDelimiterType yet.
-            // Fall through to the next attempt.
-        }
-    }
+	    // Return processed blocks and collected warnings
+	    // Note: The caller (processCodeBlocks) will handle adding these warnings to its own return object.
+	    return { processedBlocks, allWarnings };
+	}
 
-    // Attempt 2: Look for double newline separator (fallback)
-    // Only if a valid header wasn't found in the triple newline attempt
-    if (!headerDelimiterType) {
-        const doubleNewlineSeparator = '\n\n';
-        const doubleNewlineIndex = content.indexOf(doubleNewlineSeparator);
 
-        if (doubleNewlineIndex !== -1) {
-            const potentialHeaderText = content.substring(0, doubleNewlineIndex); // No trim here
+	/**
+	 * Core function to process code blocks with shared logic
+	 * @param {string} text - The input text containing code blocks
+	 * @param {Object} options - Processing options (e.g., silent, validatePatches)
+	 * @returns {Object} { blocks: Array, warnings: Array, hasIncompleteBlocks: boolean, lastIncompleteBlock: Object|null }
+	 */
+	function processCodeBlocks(text, options = { silent: false, validatePatches: false }) {
+	    if (typeof text !== "string") { // Allow empty strings
+	        console.warn("Warning: Input must be a string.");
+	        return {
+	            blocks: [],
+	            warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }],
+	            hasIncompleteBlocks: false,
+	            lastIncompleteBlock: null }
+	        ;
+	    }
 
-            try {
-                header = parseHeader$2(potentialHeaderText, language);
-                headerText = potentialHeaderText;
-                codeText = content.substring(doubleNewlineIndex + doubleNewlineSeparator.length);
-                headerDelimiterType = 'double';
-            } catch (error) {
-                // If parsing fails, it's not a valid header, log warning and default to no header
-                headerParseError = error.message;
-                warnings.push({
-                    position: position,
-                    type: 'header_parse_error',
-                    message: `Invalid header (double newline attempt): ${error.message}. Treating block as code only.`,
-                    content: potentialHeaderText // Show the problematic header text
-                });
-                // Fall through to default case (no header)
-            }
-        }
-    }
+	    if (text.trim() === "") {
+	        return { blocks: [], warnings: [], hasIncompleteBlocks: false, lastIncompleteBlock: null };
+	    }
 
-    // Default: If no valid header was found after both attempts
-    if (!headerDelimiterType && !incomplete) { // Only warn about missing header if the block is complete
-        warnings.push({
-            position: position,
-            type: 'missing_header',
-            message: `No distinct header found or parsed as valid. Treating block as code only.`,
-            content: content.substring(0, 100) + '...' // Show beginning of content
-        });
-    }
+	    // Step 1: Find all fence positions
+	    const { openingPositions, closingPositions } = findAllCodeFences(text);
+
+	    // Step 2: Match fences to get potential block boundaries
+	    const { completeBlocks, incompleteBlocks, warnings: extractorWarnings } = matchFencesAndExtractBlocks(
+	        text, openingPositions, closingPositions
+	    );
+
+	    // Step 3: Process the content of these potential blocks
+	    const { processedBlocks, allWarnings: processorWarnings } = processBlockContents(
+	        text, completeBlocks, incompleteBlocks, options
+	    );
+
+	    // Combine warnings from extractor and processor
+	    const allWarnings = [...extractorWarnings, ...processorWarnings];
+
+	    // Log warnings if not silent
+	    if (!options.silent && allWarnings.length > 0) {
+	        console.warn('\nCode Block Processing Warnings:');
+	        allWarnings.forEach((warning, index) => {
+	            console.warn(`\nWarning ${index + 1}:`);
+	            console.warn(`Type: ${warning.type}`);
+	            console.warn(`Message: ${warning.message}`);
+	            console.warn(`Position: ${warning.position}`);
+	            if (warning.content) {
+	                // Limit logged content length
+	                const maxLogLength = 200;
+	                const loggedContent = warning.content.length > maxLogLength
+	                    ? warning.content.substring(0, maxLogLength) + '...'
+	                    : warning.content;
+	                console.warn(`Content Hint: ${loggedContent}`);
+	            }
+	        });
+	    }
 
-    return {
-        type: 'code',
-        language: language,
-        header: header,
-        headerText: headerText.trim(), // Include the raw header text if successfully parsed
-        content: codeText, // The code part after the header (or full content if no header)
-        position: position, // Position of the opening fence
-        headerDelimiterType: headerDelimiterType, // 'triple', 'double', or null
-        incomplete: incomplete,
-        warnings: warnings,
-        headerParseError: headerParseError // Include error message if parsing failed
-    };
-}
+	    const hasIncompleteBlocks = incompleteBlocks.length > 0;
+	    const lastIncompleteBlock = hasIncompleteBlocks
+	        ? processedBlocks.find(block => block.incomplete) // Find the corresponding processed block
+	        : null;
+
+	    return {
+	        blocks: processedBlocks,
+	        warnings: allWarnings,
+	        hasIncompleteBlocks: hasIncompleteBlocks,
+	        lastIncompleteBlock: lastIncompleteBlock
+	    };
+	}
 
+	/**
+	 * Public API function - maintains backward compatibility for simple extraction.
+	 * Use processCodeBlocks for more detailed results (warnings, incomplete status).
+	 * @param {string} text - The input text containing code blocks
+	 * @param {Object} options - Options for extraction (e.g., { silent: true })
+	 * @returns {Object} - Object containing extracted blocks and warnings { blocks: Array, warnings: Array }
+	 */
+	function extractCodeBlocks(text, options = { silent: false, validatePatches: false, debug: false }) {
+	    const { blocks, warnings } = processCodeBlocks(text, options);
+	    return { blocks, warnings };
+	}
 
-/**
- * Processes the content of complete and incomplete blocks (internal helper)
- * @param {string} text - The input text
- * @param {Array} completeBlocks - Array of complete block objects from extractor
- * @param {Array} incompleteBlocks - Array of incomplete block objects from extractor
- * @param {Object} options - Processing options
- * @returns {Array} Array of processed block objects
- */
-function processBlockContents(text, completeBlocks, incompleteBlocks, options) {
-    const processedBlocks = [];
-    const allWarnings = []; // Collect warnings from all blocks
 
-    // Process complete blocks
-    for (const block of completeBlocks) {
-        try {
-            const startPos = block.opening.position + block.opening.length;
-            const endPos = block.closing.position;
-            // Get content, including the newlines immediately after opening and before closing fence
-            const contentWithNewlines = text.substring(startPos, endPos);
-            const content = contentWithNewlines; //.replace(/^\s*\n|\n\s*$/g, '');
-
-            const language = block.opening.language;
-
-            // Process block content
-            const processedBlock = processBlockContent(content, language, block.opening.position, false, options);
-            processedBlocks.push(processedBlock);
-            if (processedBlock.warnings) {
-                allWarnings.push(...processedBlock.warnings);
-            }
-        } catch (error) {
-            // Catch errors during the processing of a single block
-            allWarnings.push({
-                position: block.opening?.position || -1,
-                type: 'block_processing_error',
-                message: `Error processing complete block: ${error.message}`,
-                content: text.substring(block.opening?.position, block.closing?.position + block.closing?.length) || "Error retrieving block content"
-            });
-        }
-    }
-
-    // Process incomplete blocks
-    for (const block of incompleteBlocks) {
-        try {
-            const startPos = block.opening.position + block.opening.length;
-            // Get content from opening fence to end of text
-            const contentWithNewline = text.substring(startPos);
-            // Trim only leading whitespace line
-            const content = contentWithNewline.replace(/^\s*\n/, '');
-
-            const language = block.opening.language;
-
-            // Process block content - it's expected to be incomplete
-            const processedBlock = processBlockContent(content, language, block.opening.position, true, options);
-
-            // Extract continuation info for incomplete blocks
-            // Requires extractContinuationInfo from continuationUtils
-            try {
-                // Pass the *processed* header info to continuation utils
-                let { 'Continuation-Part': partNumber } = processedBlock?.header || {};
-                partNumber = partNumber ? parseInt(partNumber) + 1 : 2; // Default to part 2 if not specified
-                processedBlock.continuationInfo = extractContinuationInfo$2(processedBlock.content, partNumber, language, processedBlock.header);
-            } catch (continuationError) {
-                allWarnings.push({
-                    position: block.opening?.position || -1,
-                    type: 'continuation_info_error',
-                    message: `Error extracting continuation info: ${continuationError.message}`,
-                    content: content
-                });
-            }
-
-
-            processedBlocks.push(processedBlock);
-            if (processedBlock.warnings) {
-                allWarnings.push(...processedBlock.warnings);
-            }
-        } catch (error) {
-            // Catch errors during the processing of a single incomplete block
-            allWarnings.push({
-                position: block.opening?.position || -1,
-                type: 'incomplete_block_processing_error',
-                message: `Error processing incomplete block: ${error.message}`,
-                content: text.substring(block.opening?.position) || "Error retrieving block content"
-            });
-        }
-    }
-
-    // Return processed blocks and collected warnings
-    // Note: The caller (processCodeBlocks) will handle adding these warnings to its own return object.
-    return { processedBlocks, allWarnings };
-}
-
-
-/**
- * Core function to process code blocks with shared logic
- * @param {string} text - The input text containing code blocks
- * @param {Object} options - Processing options (e.g., silent, validatePatches)
- * @returns {Object} { blocks: Array, warnings: Array, hasIncompleteBlocks: boolean, lastIncompleteBlock: Object|null }
- */
-function processCodeBlocks$5(text, options = { silent: false, validatePatches: false }) {
-    if (typeof text !== "string") { // Allow empty strings
-        console.warn("Warning: Input must be a string.");
-        return {
-            blocks: [],
-            warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }],
-            hasIncompleteBlocks: false,
-            lastIncompleteBlock: null }
-        ;
-    }
-
-    if (text.trim() === "") {
-        return { blocks: [], warnings: [], hasIncompleteBlocks: false, lastIncompleteBlock: null };
-    }
-
-    // Step 1: Find all fence positions
-    const { openingPositions, closingPositions } = findAllCodeFences$3(text);
-
-    // Step 2: Match fences to get potential block boundaries
-    const { completeBlocks, incompleteBlocks, warnings: extractorWarnings } = matchFencesAndExtractBlocks$3(
-        text, openingPositions, closingPositions
-    );
-
-    // Step 3: Process the content of these potential blocks
-    const { processedBlocks, allWarnings: processorWarnings } = processBlockContents(
-        text, completeBlocks, incompleteBlocks, options
-    );
-
-    // Combine warnings from extractor and processor
-    const allWarnings = [...extractorWarnings, ...processorWarnings];
-
-    // Log warnings if not silent
-    if (!options.silent && allWarnings.length > 0) {
-        console.warn('\nCode Block Processing Warnings:');
-        allWarnings.forEach((warning, index) => {
-            console.warn(`\nWarning ${index + 1}:`);
-            console.warn(`Type: ${warning.type}`);
-            console.warn(`Message: ${warning.message}`);
-            console.warn(`Position: ${warning.position}`);
-            if (warning.content) {
-                // Limit logged content length
-                const maxLogLength = 200;
-                const loggedContent = warning.content.length > maxLogLength
-                    ? warning.content.substring(0, maxLogLength) + '...'
-                    : warning.content;
-                console.warn(`Content Hint: ${loggedContent}`);
-            }
-        });
-    }
-
-    const hasIncompleteBlocks = incompleteBlocks.length > 0;
-    const lastIncompleteBlock = hasIncompleteBlocks
-        ? processedBlocks.find(block => block.incomplete) // Find the corresponding processed block
-        : null;
-
-    return {
-        blocks: processedBlocks,
-        warnings: allWarnings,
-        hasIncompleteBlocks: hasIncompleteBlocks,
-        lastIncompleteBlock: lastIncompleteBlock
-    };
-}
-
-/**
- * Public API function - maintains backward compatibility for simple extraction.
- * Use processCodeBlocks for more detailed results (warnings, incomplete status).
- * @param {string} text - The input text containing code blocks
- * @param {Object} options - Options for extraction (e.g., { silent: true })
- * @returns {Object} - Object containing extracted blocks and warnings { blocks: Array, warnings: Array }
- */
-function extractCodeBlocks$2(text, options = { silent: false, validatePatches: false, debug: false }) {
-    const { blocks, warnings } = processCodeBlocks$5(text, options);
-    return { blocks, warnings };
-}
-
-
-/**
- * Fixes invalid UUIDs in code blocks within text
- * @param {string} text - The input text containing code blocks
- * @returns {Object} - Object containing fixed text and whether changes were made { text: string, modified: boolean }
- */
-function fixTextCodeBlocks$2(text) {
-    if (typeof text !== "string" || text.trim() === "") {
-        return {
-            text: text,
-            modified: false
-        };
-    }
-
-    let modified = false;
-    let fixedText = text;
-
-    // Regex to match code blocks with their language
-    const codeBlockRegex = /```([a-zA-Z-]*)\n([\s\S]*?)\n```/g;
-
-    // Store all matches to process in reverse
-    const matches = Array.from(text.matchAll(codeBlockRegex));
-
-    // Process matches in reverse to maintain correct positions
-    for (let i = matches.length - 1; i >= 0; i--) {
-        const match = matches[i];
-        const fullMatch = match[0];
-        const language = match[1];
-        const blockContent = match[2];
-
-        // Check if this is a patch block or a gitsense-search-flow block (if they contain UUIDs)
-        if (PatchUtils$1.isPatchBlock(blockContent)) {
-            // Process patch block UUIDs
-            const lines = blockContent.split('\n');
-            let blockModified = false;
-
-            const newLines = lines.map(line => {
-                // Check for UUID fields in patch metadata
-                if ((line.includes('# Source-Block-UUID:') || line.includes('# Target-Block-UUID:')) &&
-                    !line.includes('{{GS-UUID}')) {
-
-                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
-
-                    // Validate UUID
-                    const validation = validateUUID$2(valuePart);
-                    if (validation["Block-UUID"] === "INVALID UUID") {
-                        blockModified = true;
-                        modified = true;
-                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
-                    }
-                }
-                return line;
-            });
+	/**
+	 * Fixes invalid UUIDs in code blocks within text
+	 * @param {string} text - The input text containing code blocks
+	 * @returns {Object} - Object containing fixed text and whether changes were made { text: string, modified: boolean }
+	 */
+	function fixTextCodeBlocks(text) {
+	    if (typeof text !== "string" || text.trim() === "") {
+	        return {
+	            text: text,
+	            modified: false
+	        };
+	    }
 
-            // If this block was modified, replace it in the text
-            if (blockModified) {
-                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
-                fixedText = fixedText.substring(0, match.index) +
-                    newBlock +
-                    fixedText.substring(match.index + fullMatch.length);
-            }
-        } else {
-            // Process regular code block or gitsense-search-flow block for UUIDs
-            // Split block content into lines to check for header/UUIDs
-            const lines = blockContent.split('\n');
-            let blockModified = false;
-
-            // Process each line
-            const newLines = lines.map(line => {
-                // Check for UUID fields
-                if (line.includes(' Block-UUID: ') || line.includes(' Parent-UUID: ')) {
-                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
-
-                    // Skip if N/A or contains unexpected characters
-                    if (valuePart === 'N/A' || valuePart.match(/\(/)) {
-                        return line;
-                    }
-                    // Validate UUID
-                    const validation = validateUUID$2(valuePart);
+	    let modified = false;
+	    let fixedText = text;
+
+	    // Regex to match code blocks with their language
+	    const codeBlockRegex = /```([a-zA-Z-]*)\n([\s\S]*?)\n```/g;
+
+	    // Store all matches to process in reverse
+	    const matches = Array.from(text.matchAll(codeBlockRegex));
+
+	    // Process matches in reverse to maintain correct positions
+	    for (let i = matches.length - 1; i >= 0; i--) {
+	        const match = matches[i];
+	        const fullMatch = match[0];
+	        const language = match[1];
+	        const blockContent = match[2];
+
+	        // Check if this is a patch block or a gitsense-search-flow block (if they contain UUIDs)
+	        if (PatchUtils.isPatchBlock(blockContent)) {
+	            // Process patch block UUIDs
+	            const lines = blockContent.split('\n');
+	            let blockModified = false;
+
+	            const newLines = lines.map(line => {
+	                // Check for UUID fields in patch metadata
+	                if ((line.includes('# Source-Block-UUID:') || line.includes('# Target-Block-UUID:')) &&
+	                    !line.includes('{{GS-UUID}')) {
+
+	                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
+
+	                    // Validate UUID
+	                    const validation = validateUUID(valuePart);
+	                    if (validation["Block-UUID"] === "INVALID UUID") {
+	                        blockModified = true;
+	                        modified = true;
+	                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
+	                    }
+	                }
+	                return line;
+	            });
+
+	            // If this block was modified, replace it in the text
+	            if (blockModified) {
+	                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
+	                fixedText = fixedText.substring(0, match.index) +
+	                    newBlock +
+	                    fixedText.substring(match.index + fullMatch.length);
+	            }
+	        } else {
+	            // Process regular code block or gitsense-search-flow block for UUIDs
+	            // Split block content into lines to check for header/UUIDs
+	            const lines = blockContent.split('\n');
+	            let blockModified = false;
+
+	            // Process each line
+	            const newLines = lines.map(line => {
+	                // Check for UUID fields
+	                if (line.includes(' Block-UUID: ') || line.includes(' Parent-UUID: ')) {
+	                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
+
+	                    // Skip if N/A or contains unexpected characters
+	                    if (valuePart === 'N/A' || valuePart.match(/\(/)) {
+	                        return line;
+	                    }
+	                    // Validate UUID
+	                    const validation = validateUUID(valuePart);
+
+	                    if (validation["Block-UUID"] === "INVALID UUID") {
+	                        blockModified = true;
+	                        modified = true;
+	                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
+	                    }
+	                }
+	                return line;
+	            });
+
+	            // If this block was modified, replace it in the text
+	            if (blockModified) {
+	                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
+	                fixedText = fixedText.substring(0, match.index) +
+	                    newBlock +
+	                    fixedText.substring(match.index + fullMatch.length);
+	            }
+	        }
+	    }
 
-                    if (validation["Block-UUID"] === "INVALID UUID") {
-                        blockModified = true;
-                        modified = true;
-                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
-                    }
-                }
-                return line;
-            });
+	    return {
+	        text: fixedText,
+	        modified: modified
+	    };
+	}
 
-            // If this block was modified, replace it in the text
-            if (blockModified) {
-                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
-                fixedText = fixedText.substring(0, match.index) +
-                    newBlock +
-                    fixedText.substring(match.index + fullMatch.length);
-            }
-        }
-    }
 
-    return {
-        text: fixedText,
-        modified: modified
-    };
+	blockProcessor = {
+	    processCodeBlocks,
+	    extractCodeBlocks,
+	    fixTextCodeBlocks,
+	};
+	return blockProcessor;
 }
 
-
-var blockProcessor = {
-    processCodeBlocks: processCodeBlocks$5,
-    extractCodeBlocks: extractCodeBlocks$2,
-    fixTextCodeBlocks: fixTextCodeBlocks$2,
-};
-
 /**
  * Component: CodeBlockUtils Patch Integration
  * Block-UUID: 9f7395ef-e213-4841-a95d-f263e422288a
@@ -9647,7 +10097,7 @@ var blockProcessor = {
  */
 
 // Dependency on the core block processor
-const { processCodeBlocks: processCodeBlocks$4 } = blockProcessor;
+const { processCodeBlocks: processCodeBlocks$3 } = requireBlockProcessor();
 
 /**
  * Checks if the provided text content contains at least one patch block.
@@ -9657,7 +10107,7 @@ const { processCodeBlocks: processCodeBlocks$4 } = blockProcessor;
  */
 function containsPatch$2(content, options = { silent: true }) {
     // Use the core processor to get all blocks
-    const { blocks } = processCodeBlocks$4(content, options);
+    const { blocks } = processCodeBlocks$3(content, options);
 
     // Check if any processed block is of type 'patch'
     for (let i = 0; i < blocks.length; i++) {
@@ -9685,7 +10135,7 @@ var patchIntegration = {
  */
 
 // Dependency on the core block processor
-const { processCodeBlocks: processCodeBlocks$3 } = blockProcessor;
+const { processCodeBlocks: processCodeBlocks$2 } = requireBlockProcessor();
 
 /**
  * Detects special code block relationships in a message, such as patches or parent-child links.
@@ -9719,7 +10169,7 @@ function detectCodeBlockRelationships$2(content, codeBlockService, options = { s
 
 
     // Extract all code blocks using the core processor
-    const { blocks, warnings } = processCodeBlocks$3(content, options);
+    const { blocks, warnings } = processCodeBlocks$2(content, options);
 
     let hasPatch = false;
     let hasParentChildRelationship = false;
@@ -9793,7 +10243,7 @@ function detectIncompleteCodeBlock$2(content, options = { silent: true }) {
     }
 
     // Use the core processor which already identifies incomplete blocks
-    const { hasIncompleteBlocks, lastIncompleteBlock } = processCodeBlocks$3(content, options);
+    const { hasIncompleteBlocks, lastIncompleteBlock } = processCodeBlocks$2(content, options);
 
     return {
         hasIncompleteBlocks,
@@ -10096,281 +10546,6 @@ Plain text block.
 // (Removed the check `if (typeof module !== 'undefined' && module.exports)` as it's standard in Node)
 var markerRemover = { removeCodeBlockMarkers: removeCodeBlockMarkers$2 };
 
-/**
- * Component: CodeBlockUtils Update Code Block
- * Block-UUID: 6a7b8c9d-0e1f-42a3-b4c5-d6e7f8a9b0c1
- * Parent-UUID: 5f9c1e3a-7b2d-4e8f-a1d0-9c4b2e1f8a0b
- * Version: 1.4.0
- * Description: Provides functions to update the content of a specific code block within a string, identified by index, UUID, or direct reference.
- * Language: JavaScript
- * Created-at: 2025-04-16T00:56:57.352Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Pro (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
- */
-
-// Dependencies from other modules within CodeBlockUtils
-const { findAllCodeFences: findAllCodeFences$2, matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$2, findCodeBlockByUUID: findCodeBlockByUUID$1 } = blockExtractor; // Added findCodeBlockByUUID
-const { processCodeBlocks: processCodeBlocks$2 } = blockProcessor; // To get parsed block info
-
-/**
- * Replaces the content of a code block specified by its index within a message string.
- *
- * @param {string} messageContent - The original message string containing code blocks.
- * @param {number} blockIndex - The 0-based index of the code block to replace.
- * @param {string} newCodeContent - The new raw content (code, potentially including header) to insert into the block.
- * @param {string} [language] - Optional: The language identifier for the updated code block fence. If omitted, the original language is preserved.
- * @returns {string} The message content with the specified code block updated.
- * @throws {Error} If the blockIndex is out of bounds or if block boundaries cannot be determined.
- */
-function updateCodeBlockByIndex$2(messageContent, blockIndex, newCodeContent, language = undefined) {
-    if (typeof messageContent !== 'string') {
-        throw new Error("messageContent must be a string.");
-    }
-    if (typeof blockIndex !== 'number' || blockIndex < 0) {
-        throw new Error("blockIndex must be a non-negative number.");
-    }
-    if (typeof newCodeContent !== 'string') {
-        // Allow empty string replacement, but not other types
-        throw new Error("newCodeContent must be a string.");
-    }
-
-    // Step 1: Find all fence positions to get accurate start/end of the full block
-    const { openingPositions, closingPositions } = findAllCodeFences$2(messageContent);
-    const { completeBlocks, incompleteBlocks, warnings: extractorWarnings } = matchFencesAndExtractBlocks$2(
-        messageContent, openingPositions, closingPositions
-    );
-
-    // Combine complete and incomplete for indexing, assuming we might want to update an incomplete one too
-    // Note: Replacing content in an incomplete block might be unusual, but technically possible.
-    const allBlocks = [...completeBlocks, ...incompleteBlocks];
-
-    // Step 2: Validate index
-    if (blockIndex >= allBlocks.length) {
-        throw new Error(`blockIndex ${blockIndex} is out of bounds. Found ${allBlocks.length} blocks.`);
-    }
-
-    // Step 3: Get the target block's boundary information
-    const targetBlockBoundaries = allBlocks[blockIndex];
-    const openingFence = targetBlockBoundaries.opening;
-    const closingFence = targetBlockBoundaries.closing; // Will be undefined for incomplete blocks
-
-    if (!openingFence) {
-        // Should not happen if index is valid, but good practice to check
-        throw new Error(`Could not find opening fence for block at index ${blockIndex}.`);
-    }
-
-    // Determine the exact start and end of the full markdown block
-    const blockStartPos = openingFence.position;
-    // If the block is incomplete, the end is the end of the messageContent
-    const blockEndPos = closingFence
-        ? closingFence.position + closingFence.length
-        : messageContent.length;
-
-    // Step 4: Construct the replacement block string
-    const targetLanguage = language !== undefined ? language : (openingFence.language || ''); // Use provided language or original/empty
-    const newBlockString = `\`\`\`${targetLanguage}\n${newCodeContent}\n\`\`\``;
-
-    // Step 5: Perform the replacement
-    const updatedMessageContent =
-        messageContent.substring(0, blockStartPos) +
-        newBlockString +
-        messageContent.substring(blockEndPos);
-
-    return updatedMessageContent;
-}
-
-/**
- * Replaces the content of a code block specified by its Block-UUID within a message string.
- *
- * @param {string} messageContent - The original message string containing code blocks.
- * @param {string} blockUUID - The Block-UUID of the code block to replace.
- * @param {string} newCodeContent - The new raw content (code, potentially including header) to insert into the block.
- * @param {string} [language] - Optional: The language identifier for the updated code block fence. If omitted, the original language is preserved.
- * @returns {string} The message content with the specified code block updated.
- * @throws {Error} If no block with the specified UUID is found, or if multiple blocks have the same UUID.
- */
-function updateCodeBlockByUUID$1(messageContent, blockUUID, newCodeContent, language = undefined) {
-    if (typeof messageContent !== 'string') {
-        throw new Error("messageContent must be a string.");
-    }
-    if (typeof blockUUID !== 'string' || !blockUUID) {
-        throw new Error("blockUUID must be a non-empty string.");
-    }
-    if (typeof newCodeContent !== 'string') {
-        throw new Error("newCodeContent must be a string.");
-    }
-
-    // Step 1: Process blocks to get headers and find the target index
-    const { blocks: processedBlocks, warnings } = processCodeBlocks$2(messageContent, { silent: true });
-
-    let targetIndex = -1;
-
-    for (let i = 0; i < processedBlocks.length; i++) {
-        const block = processedBlocks[i];
-        let match = false;
-
-        // Check standard code blocks by Block-UUID
-        if ((block.type === 'code') && block.header && block.header['Block-UUID'] === blockUUID) {
-            match = true;
-        }
-        // Check patch blocks by Target-Block-UUID
-        else if (block.type === 'patch' && block.metadata && block.metadata['Target-Block-UUID'] === blockUUID) {
-            match = true;
-        }
-
-        if (match) {
-            // If we've already found one, log a warning but still update the first one found.
-            if (targetIndex !== -1) {
-                console.warn(`Multiple blocks found matching UUID: ${blockUUID} (could be Block-UUID or Target-Block-UUID). Updating the first occurrence.`);
-            } else {
-                targetIndex = i;
-            }
-        }
-    }
-
-    // Step 2: Handle findings
-    if (targetIndex === -1) { // Use targetIndex to check if *any* valid match was set
-        throw new Error(`No code or patch block found matching UUID: ${blockUUID} (checked Block-UUID and Target-Block-UUID).`);
-    }
-    // Warning for multiple matches is handled inside the loop now.
-
-    // Step 3: Call the index-based function
-    // We need the index relative to *all* blocks (complete and incomplete), not just processed ones.
-    // Re-extract boundaries to get the correct index mapping.
-    const { openingPositions, closingPositions } = findAllCodeFences$2(messageContent);
-    const { completeBlocks, incompleteBlocks } = matchFencesAndExtractBlocks$2(
-        messageContent, openingPositions, closingPositions
-    );
-    const allBlocks = [...completeBlocks, ...incompleteBlocks];
-
-    // Find the index in the combined list that corresponds to the processed block's position
-    const targetProcessedBlock = processedBlocks[targetIndex];
-    const actualIndex = allBlocks.findIndex(b => b.opening.position === targetProcessedBlock.position);
-
-    if (actualIndex === -1) {
-        // This indicates a discrepancy between blockProcessor and blockExtractor results, which shouldn't happen.
-        throw new Error(`Internal error: Could not map processed block at index ${targetIndex} (matching UUID: ${blockUUID}) back to extracted block boundaries.`);
-    }
-
-    // Pass the optional language parameter down
-    return updateCodeBlockByIndex$2(messageContent, actualIndex, newCodeContent, language);
-}
-
-/**
- * Updates a code block in message text identified by UUID.
- * (Moved from original PatchUtils)
- * @param {string} messageText - The original message text
- * @param {string} blockUUID - The Block-UUID to update
- * @param {string} newCode - The new code content (raw content, including header if applicable)
- * @param {string} language - The code language for the fence
- * @returns {string} Updated message text
- * @throws {Error} If block not found or parameters missing.
- */
-function updateCodeBlockInMessage$1(messageText, blockUUID, newCode, language) {
-    if (!messageText || !blockUUID || newCode === null || newCode === undefined) { // Allow empty string for newCode
-        throw new Error("Missing required parameters for updating code block (messageText, blockUUID, newCode)");
-    }
-
-    // Use findCodeBlockByUUID from blockExtractor
-    const block = findCodeBlockByUUID$1(messageText, blockUUID);
-
-    if (!block) {
-        throw new Error(`Code block with UUID ${blockUUID} not found`);
-    }
-
-    // Construct the new full block string
-    const newBlockString = '```' + (language || block.language) + '\n' + newCode + '\n```';
-
-    // Replace the old block with the new one using precise indices
-    return messageText.substring(0, block.startIndex) +
-           newBlockString +
-           messageText.substring(block.endIndex);
-}
-
-
-/**
- * Generic router function to update a code block by index or UUID.
- *
- * @param {string} messageContent - The original message string.
- * @param {number|string} identifier - The block index (number) or Block-UUID (string).
- * @param {string} newCodeContent - The new raw content for the block.
- * @param {string} [language] - Optional: The language identifier for the updated code block fence.
- * @returns {string} The updated message content.
- * @throws {Error} If the identifier type is invalid or if the underlying update function fails.
- */
-function updateCodeBlock$1(messageContent, identifier, newCodeContent, language = undefined) {
-    if (typeof identifier === 'number') {
-        // Pass language to index-based function
-        return updateCodeBlockByIndex$2(messageContent, identifier, newCodeContent, language);
-    } else if (typeof identifier === 'string') {
-        // Pass language to UUID-based function
-        return updateCodeBlockByUUID$1(messageContent, identifier, newCodeContent, language);
-    } else {
-        throw new Error("Invalid identifier type. Must be a number (index) or a string (UUID).");
-    }
-}
-
-/**
- * Deletes a code block specified by its index within a message string.
- *
- * @param {string} messageContent - The original message string containing code blocks.
- * @param {number} blockIndex - The 0-based index of the code block to delete.
- * @returns {string} The message content with the specified code block deleted.
- * @throws {Error} If the blockIndex is out of bounds or if block boundaries cannot be determined.
- */
-function deleteCodeBlockByIndex$2(messageContent, blockIndex) {
-    if (typeof messageContent !== 'string') {
-        throw new Error("messageContent must be a string.");
-    }
-    if (typeof blockIndex !== 'number' || blockIndex < 0) {
-        throw new Error("blockIndex must be a non-negative number.");
-    }
-
-    // Step 1: Find all fence positions to get accurate start/end of the full block
-    const { openingPositions, closingPositions } = findAllCodeFences$2(messageContent);
-    const { completeBlocks, incompleteBlocks } = matchFencesAndExtractBlocks$2(
-        messageContent, openingPositions, closingPositions
-    );
-
-    // Combine complete and incomplete for indexing
-    const allBlocks = [...completeBlocks, ...incompleteBlocks];
-
-    // Step 2: Validate index
-    if (blockIndex >= allBlocks.length) {
-        throw new Error(`blockIndex ${blockIndex} is out of bounds. Found ${allBlocks.length} blocks.`);
-    }
-
-    // Step 3: Get the target block's boundary information
-    const targetBlockBoundaries = allBlocks[blockIndex];
-    const openingFence = targetBlockBoundaries.opening;
-    const closingFence = targetBlockBoundaries.closing; // Will be undefined for incomplete blocks
-
-    if (!openingFence) {
-        // Should not happen if index is valid, but good practice to check
-        throw new Error(`Could not find opening fence for block at index ${blockIndex}.`);
-    }
-
-    // Determine the exact start and end of the full markdown block
-    const blockStartPos = openingFence.position;
-    // If the block is incomplete, the end is the end of the messageContent
-    const blockEndPos = closingFence
-        ? closingFence.position + closingFence.length
-        : messageContent.length;
-
-    // Step 4: Perform the deletion
-    const updatedMessageContent =
-        messageContent.substring(0, blockStartPos) +
-        messageContent.substring(blockEndPos);
-
-    return updatedMessageContent;
-}
-
-var updateCodeBlock_1 = {
-    updateCodeBlockByIndex: updateCodeBlockByIndex$2,
-    updateCodeBlockByUUID: updateCodeBlockByUUID$1,
-    updateCodeBlock: updateCodeBlock$1,
-    updateCodeBlockInMessage: updateCodeBlockInMessage$1,
-    deleteCodeBlockByIndex: deleteCodeBlockByIndex$2};
-
 /**
  * Component: CodeBlockUtils Index
  * Block-UUID: 7e9d3f8a-1b2c-4d5e-8f9a-0123456789ab
@@ -10387,13 +10562,13 @@ const { COMMENT_STYLES: COMMENT_STYLES$1 } = constants$2;
 const { generateUUID: generateUUID$1, validateUUID: validateUUID$1 } = uuidUtils;
 const { isValidISOTimestamp: isValidISOTimestamp$1, parseHeader: parseHeader$1, getHeaderLineCount } = headerUtils;
 const { findAllCodeFences: findAllCodeFences$1, matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$1, extractCodeBlocksWithUUIDs, findCodeBlockByUUID } = blockExtractor;
-const { processCodeBlocks: processCodeBlocks$1, extractCodeBlocks: extractCodeBlocks$1, fixTextCodeBlocks: fixTextCodeBlocks$1 } = blockProcessor;
+const { processCodeBlocks: processCodeBlocks$1, extractCodeBlocks: extractCodeBlocks$1, fixTextCodeBlocks: fixTextCodeBlocks$1 } = requireBlockProcessor();
 const { containsPatch: containsPatch$1 } = patchIntegration;
 const { detectCodeBlockRelationships: detectCodeBlockRelationships$1, detectIncompleteCodeBlock: detectIncompleteCodeBlock$1, extractFilePaths: extractFilePaths$1 } = relationshipUtils;
 const { extractContinuationInfo: extractContinuationInfo$1, generateContinuationPrompt: generateContinuationPrompt$1 } = continuationUtils;
 const { parseCodeBlocks: parseCommentDelimitedBlocks$1 } = headerParser;
 const { removeCodeBlockMarkers: removeCodeBlockMarkers$1 } = markerRemover;
-const { updateCodeBlockByIndex: updateCodeBlockByIndex$1, updateCodeBlockByUUID, updateCodeBlock, updateCodeBlockInMessage, deleteCodeBlockByIndex: deleteCodeBlockByIndex$1 } = updateCodeBlock_1;
+const { updateCodeBlockByIndex: updateCodeBlockByIndex$1, updateCodeBlockByUUID, updateCodeBlock, updateCodeBlockInMessage, deleteCodeBlockByIndex: deleteCodeBlockByIndex$1 } = requireUpdateCodeBlock();
 const { formatWithLineNumbers: formatWithLineNumbers$1, formatBlockWithLineNumbers: formatBlockWithLineNumbers$1, formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1, removeLineNumbers: removeLineNumbers$1 } = lineNumberFormatter;
 
 // Export all imported items
@@ -10870,7 +11045,7 @@ var constants = {
  */
 
 const CodeBlockUtils$2 = CodeBlockUtils$4;
-const GSToolBlockUtils$1 = GSToolBlockUtils$3;
+const GSToolBlockUtils$1 = requireGSToolBlockUtils();
 const JsonUtils$1 = JsonUtils$2;
 const { ANALYZE_HEADER_PREFIX } = constants;
 
@@ -10999,7 +11174,7 @@ var responseProcessor = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const AnalysisBlockUtils$1 = AnalysisBlockUtils$3;
+const AnalysisBlockUtils$1 = AnalysisBlockUtils$2;
 
 /**
  * Validates the extracted analysis blocks and their metadata.
@@ -11070,11 +11245,11 @@ var dataValidator = {
 };
 
 /*
- * Component: AnalyzerUtils Discovery
- * Block-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
+ * Component: AnalyzerUtils Instruction Loader
+ * Block-UUID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5e
  * Parent-UUID: N/A
  * Version: 1.0.0
- * Description: Provides utility functions for discovering available analyzers.
+ * Description: Provides utility functions for loading raw analyzer instruction content.
  * Language: JavaScript
  * Created-at: 2025-08-28T23:48:00.000Z
  * Authors: Gemini 2.5 Flash (v1.0.0)
@@ -11083,6 +11258,67 @@ var dataValidator = {
 const fs$7 = require$$0.promises;
 const path$5 = require$$1;
 
+/**
+ * Retrieves the raw Markdown content of the analyzer's '1.md' instruction file.
+ *
+ * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
+ * @returns {Promise<string|null>} A promise that resolves with the full Markdown content of the '1.md' file, or null if not found/invalid.
+ */
+async function getAnalyzerInstructionsContent$3(analyzeMessagesBasePath, analyzerId) {
+    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
+        console.error('Error: analyzeMessagesBasePath is required.');
+        return null;
+    }
+    if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
+        console.error('Error: analyzerId is required.');
+        return null;
+    }
+
+    const parts = analyzerId.split('::');
+    if (parts.length !== 3) {
+        console.error(`Error: Invalid analyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${analyzerId}'.`);
+        return null;
+    }
+    const [analyzerName, contentType, instructionsType] = parts;
+
+    const instructionsFilePath = path$5.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+
+    try {
+        const fileContent = await fs$7.readFile(instructionsFilePath, 'utf8');
+        const parts = fileContent.split('\n\n\n');
+        parts.shift();
+        return parts.join('\n\n\n');
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
+            return null;
+        } else {
+            console.error(`Error reading analyzer instructions file ${instructionsFilePath}: ${error.message}`);
+            throw error;
+        }
+    }
+}
+
+var instructionLoader = {
+    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$3
+};
+
+/*
+ * Component: AnalyzerUtils Discovery
+ * Block-UUID: a87a86c4-69fc-4cbb-80a8-857f56122395
+ * Parent-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
+ * Version: 1.1.0
+ * Description: Provides utility functions for discovering available analyzers.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T23:48:00.000Z
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ */
+
+const fs$6 = require$$0.promises;
+const path$4 = require$$1;
+const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$2 } = instructionLoader;
+
 /**
  * Reads and parses the config.json file in a directory.
  * @param {string} dirPath - The path to the directory.
@@ -11090,9 +11326,9 @@ const path$5 = require$$1;
  *                                 or null if the file doesn't exist or is invalid.
  */
 async function readConfig$1(dirPath) {
-    const configPath = path$5.join(dirPath, 'config.json');
+    const configPath = path$4.join(dirPath, 'config.json');
     try {
-        const fileContent = await fs$7.readFile(configPath, 'utf8');
+        const fileContent = await fs$6.readFile(configPath, 'utf8');
         return JSON.parse(fileContent);
     } catch (error) {
         if (error.code !== 'ENOENT') {
@@ -11123,47 +11359,50 @@ function isValidDirName(name) {
  * An analyzer is considered valid if a '1.md' file exists in the instructions directory.
  *
  * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
- * @returns {Promise<Array<{id: string, label: string}>>} A promise that resolves to an array of analyzer objects.
+ * @param {object} [options={}] - Optional configuration.
+ * @param {boolean} [options.includeDescription=false] - Whether to include the description of the analyzer.
+ * @returns {Promise<Array<{id: string, label: string, name: string, protected: boolean, description?: string}>>} A promise that resolves to an array of analyzer objects.
  */
-async function getAnalyzers$2(analyzeMessagesBasePath) {
+async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
+    const { includeDescription = false } = options;
     const analyzers = [];
 
     try {
-        const analyzerEntries = await fs$7.readdir(analyzeMessagesBasePath, { withFileTypes: true });
+        const analyzerEntries = await fs$6.readdir(analyzeMessagesBasePath, { withFileTypes: true });
 
         for (const analyzerEntry of analyzerEntries) {
             if (analyzerEntry.isDirectory() && isValidDirName(analyzerEntry.name)) {
                 const analyzerName = analyzerEntry.name;
-                const analyzerPath = path$5.join(analyzeMessagesBasePath, analyzerName);
+                const analyzerPath = path$4.join(analyzeMessagesBasePath, analyzerName);
                 const analyzerConfig = await readConfig$1(analyzerPath);
                 const analyzerLabel = analyzerConfig?.label || analyzerName;
 
-                const contentEntries = await fs$7.readdir(analyzerPath, { withFileTypes: true });
+                const contentEntries = await fs$6.readdir(analyzerPath, { withFileTypes: true });
 
                 for (const contentEntry of contentEntries) {
                     if (contentEntry.isDirectory() && isValidDirName(contentEntry.name)) {
                         const contentType = contentEntry.name;
-                        const contentPath = path$5.join(analyzerPath, contentType);
+                        const contentPath = path$4.join(analyzerPath, contentType);
                         const contentConfig = await readConfig$1(contentPath);
                         const contentLabel = contentConfig?.label || contentType;
 
-                        const instructionsEntries = await fs$7.readdir(contentPath, { withFileTypes: true });
+                        const instructionsEntries = await fs$6.readdir(contentPath, { withFileTypes: true });
 
                         for (const instructionsEntry of instructionsEntries) {
                             if (instructionsEntry.isDirectory() && isValidDirName(instructionsEntry.name)) {
                                 const instructionsType = instructionsEntry.name;
-                                const instructionsPath = path$5.join(contentPath, instructionsType);
+                                const instructionsPath = path$4.join(contentPath, instructionsType);
                                 const instructionsConfig = await readConfig$1(instructionsPath);
                                 const instructionsLabel = instructionsConfig?.label || instructionsType;
 
                                 // Check for the existence of 1.md to confirm a valid analyzer configuration
-                                const instructionsFilePath = path$5.join(instructionsPath, '1.md');
+                                const instructionsFilePath = path$4.join(instructionsPath, '1.md');
                                 try {
-                                    await fs$7.access(instructionsFilePath); // Check if file exists and is accessible
+                                    await fs$6.access(instructionsFilePath); // Check if file exists and is accessible
 
                                     // If analyzerName starts with 'tutorial-', check its last modified time.
                                     if (analyzerName.startsWith('tutorial-')) {
-                                        const stats = await fs$7.stat(instructionsFilePath);
+                                        const stats = await fs$6.stat(instructionsFilePath);
                                         const lastModified = stats.mtime.getTime(); // Get timestamp in milliseconds
                                         const sixtyMinutesAgo = Date.now() - (60 * 60 * 1000); // Current time - 60 minutes in ms
 
@@ -11176,11 +11415,23 @@ async function getAnalyzers$2(analyzeMessagesBasePath) {
                                     const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
                                     const analyzerFullLabel = `${analyzerLabel} (${contentLabel} - ${instructionsLabel})`;
 
+                                    let descriptionContent = null;
+                                    if (includeDescription) {
+                                        try {
+                                            descriptionContent = await getAnalyzerInstructionsContent$2(analyzeMessagesBasePath, analyzerId);
+                                        } catch (descError) {
+                                            console.warn(`Warning: Could not load description for ${analyzerId}: ${descError.message}`);
+                                            descriptionContent = null;
+                                        }
+                                    }
+
                                     analyzers.push({
                                         id: analyzerId,
                                         label: analyzerFullLabel,
-                                        protected: analyzerConfig?.protected || false
-                                    });
+                                        name: analyzerName,
+                                        protected: analyzerConfig?.protected || false,
+                                        ...(descriptionContent && { description: descriptionContent })
+                                     });
                                 } catch (error) {
                                     // If 1.md doesn't exist, this is not a complete analyzer configuration, skip.
                                     if (error.code !== 'ENOENT') {
@@ -11217,8 +11468,8 @@ var discovery = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash Thinking (v1.1.0)
  */
 
-const fs$6 = require$$0.promises;
-const path$4 = require$$1;
+const fs$5 = require$$0.promises;
+const path$3 = require$$1;
 
 /**
  * Saves or updates an analyzer configuration.
@@ -11273,18 +11524,18 @@ async function saveConfiguration$1(analyzeMessagesBasePath, analyzerId, instruct
     }
 
     // 3. Construct directory paths
-    const analyzerDir = path$4.join(analyzeMessagesBasePath, analyzerName);
-    const contentDir = path$4.join(analyzerDir, contentType);
-    const instructionsDir = path$4.join(contentDir, instructionsType);
-    const instructionsFilePath = path$4.join(instructionsDir, '1.md');
+    const analyzerDir = path$3.join(analyzeMessagesBasePath, analyzerName);
+    const contentDir = path$3.join(analyzerDir, contentType);
+    const instructionsDir = path$3.join(contentDir, instructionsType);
+    const instructionsFilePath = path$3.join(instructionsDir, '1.md');
 
     try {
         // 4. Create directories recursively
-        await fs$6.mkdir(instructionsDir, { recursive: true });
+        await fs$5.mkdir(instructionsDir, { recursive: true });
 
         // 5. Save instructions content to 1.md
         const finalContent = `; role: assistant\n\n\n${instructionsContent}`; 
-        await fs$6.writeFile(instructionsFilePath, finalContent, 'utf8');
+        await fs$5.writeFile(instructionsFilePath, finalContent, 'utf8');
 
         // 6. Optionally create/Update config.json files
         if (ensureConfigs) {
@@ -11310,11 +11561,11 @@ async function saveConfiguration$1(analyzeMessagesBasePath, analyzerId, instruct
  * @param {string} label - The label to ensure is in the config.json.
  */
 async function ensureConfigJson(dirPath, label) {
-    const configPath = path$4.join(dirPath, 'config.json');
+    const configPath = path$3.join(dirPath, 'config.json');
     let config = {};
 
     try {
-        const fileContent = await fs$6.readFile(configPath, 'utf8');
+        const fileContent = await fs$5.readFile(configPath, 'utf8');
         config = JSON.parse(fileContent);
     } catch (error) {
         // If file doesn't exist or parsing fails, start with an empty config
@@ -11331,7 +11582,7 @@ async function ensureConfigJson(dirPath, label) {
     }
 
     // Write the updated config back to the file
-    await fs$6.writeFile(configPath, JSON.stringify(config, null, 4), 'utf8');
+    await fs$5.writeFile(configPath, JSON.stringify(config, null, 4), 'utf8');
 }
 
 
@@ -11350,8 +11601,8 @@ var saver = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const fs$5 = require$$0.promises;
-const path$3 = require$$1;
+const fs$4 = require$$0.promises;
+const path$2 = require$$1;
 const CodeBlockUtils$1 = CodeBlockUtils$4;
 
 /**
@@ -11437,10 +11688,10 @@ async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const instructionsFilePath = path$3.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+    const instructionsFilePath = path$2.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
 
     try {
-        const fileContent = await fs$5.readFile(instructionsFilePath, 'utf8');
+        const fileContent = await fs$4.readFile(instructionsFilePath, 'utf8');
         const { blocks } = CodeBlockUtils$1.extractCodeBlocks(fileContent, { silent: true });
         const jsonBlocks = blocks.filter(block => block.type === 'code' && block.language === 'json');
 
@@ -11511,8 +11762,8 @@ var schemaLoader = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const fs$4 = require$$0.promises;
-const path$2 = require$$1;
+const fs$3 = require$$0.promises;
+const path$1 = require$$1;
 const { readConfig } = discovery; // Import helper from discovery
 
 /**
@@ -11522,7 +11773,7 @@ const { readConfig } = discovery; // Import helper from discovery
  */
 async function isDirectoryEmpty(dirPath) {
     try {
-        const files = await fs$4.readdir(dirPath);
+        const files = await fs$3.readdir(dirPath);
         return files.length === 0 || (files.length === 1 && files[0] === 'config.json');
     } catch (error) {
         if (error.code === 'ENOENT') {
@@ -11553,10 +11804,10 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const analyzerDir = path$2.join(analyzeMessagesBasePath, analyzerName);
-    const contentDir = path$2.join(analyzerDir, contentType);
-    const instructionsDir = path$2.join(contentDir, instructionsType);
-    const instructionsFilePath = path$2.join(instructionsDir, '1.md');
+    const analyzerDir = path$1.join(analyzeMessagesBasePath, analyzerName);
+    const contentDir = path$1.join(analyzerDir, contentType);
+    const instructionsDir = path$1.join(contentDir, instructionsType);
+    const instructionsFilePath = path$1.join(instructionsDir, '1.md');
 
     try {
         // 1. Check for protection at all levels
@@ -11577,7 +11828,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
 
         // 2. Delete the 1.md file
         try {
-            await fs$4.unlink(instructionsFilePath);
+            await fs$3.unlink(instructionsFilePath);
         } catch (error) {
             if (error.code === 'ENOENT') {
                 return { success: false, message: `Analyzer instructions file not found: ${instructionsFilePath}. It may have already been deleted.` };
@@ -11591,7 +11842,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete instructions directory
         if (await isDirectoryEmpty(instructionsDir)) {
             try {
-                await fs$4.rmdir(instructionsDir);
+                await fs$3.rmdir(instructionsDir);
                 deletedDirs.push(instructionsDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty instructions directory ${instructionsDir}: ${error.message}`);
@@ -11601,7 +11852,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete content directory
         if (await isDirectoryEmpty(contentDir)) {
             try {
-                await fs$4.rmdir(contentDir);
+                await fs$3.rmdir(contentDir);
                 deletedDirs.push(contentDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty content directory ${contentDir}: ${error.message}`);
@@ -11611,7 +11862,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete analyzer directory
         if (await isDirectoryEmpty(analyzerDir)) {
             try {
-                await fs$4.rmdir(analyzerDir);
+                await fs$3.rmdir(analyzerDir);
                 deletedDirs.push(analyzerDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty analyzer directory ${analyzerDir}: ${error.message}`);
@@ -11629,67 +11880,9 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
 var management = {
     deleteAnalyzer: deleteAnalyzer$2};
 
-/*
- * Component: AnalyzerUtils Instruction Loader
- * Block-UUID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5e
- * Parent-UUID: N/A
- * Version: 1.0.0
- * Description: Provides utility functions for loading raw analyzer instruction content.
- * Language: JavaScript
- * Created-at: 2025-08-28T23:48:00.000Z
- * Authors: Gemini 2.5 Flash (v1.0.0)
- */
-
-const fs$3 = require$$0.promises;
-const path$1 = require$$1;
-
-/**
- * Retrieves the raw Markdown content of the analyzer's '1.md' instruction file.
- *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
- * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
- * @returns {Promise<string|null>} A promise that resolves with the full Markdown content of the '1.md' file, or null if not found/invalid.
- */
-async function getAnalyzerInstructionsContent$2(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required.');
-        return null;
-    }
-    if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
-        console.error('Error: analyzerId is required.');
-        return null;
-    }
-
-    const parts = analyzerId.split('::');
-    if (parts.length !== 3) {
-        console.error(`Error: Invalid analyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${analyzerId}'.`);
-        return null;
-    }
-    const [analyzerName, contentType, instructionsType] = parts;
-
-    const instructionsFilePath = path$1.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
-
-    try {
-        const fileContent = await fs$3.readFile(instructionsFilePath, 'utf8');
-        return fileContent;
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
-            return null;
-        } else {
-            console.error(`Error reading analyzer instructions file ${instructionsFilePath}: ${error.message}`);
-            throw error;
-        }
-    }
-}
-
-var instructionLoader = {
-    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$2
-};
-
 /*
  * Component: AnalyzerUtils Default Prompt Loader
- * Block-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
+ * Block-UUID: be863744-6461-4b94-97ce-b1d177e9e881
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions for loading shared, default prompt components (system and start messages).
@@ -12042,10 +12235,10 @@ const ChatUtils = ChatUtils$1;
 const CodeBlockUtils = CodeBlockUtils$4;
 const ContextUtils = ContextUtils$2;
 const MessageUtils = MessageUtils$3;
-const AnalysisBlockUtils = AnalysisBlockUtils$3;
+const AnalysisBlockUtils = AnalysisBlockUtils$2;
 const AnalyzerUtils = AnalyzerUtils$1;
-const PatchUtils = PatchUtils$2;
-const GSToolBlockUtils = GSToolBlockUtils$3;
+const PatchUtils = PatchUtils$1;
+const GSToolBlockUtils = requireGSToolBlockUtils();
 const LLMUtils = LLMUtils$1;
 const JsonUtils = JsonUtils$2;
 const ConfigUtils = ConfigUtils$1;