@gitsense/gsc-utils 0.2.16 → 0.2.18

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$2() {
+function generateUUID$3() {
     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$2() {
  * @param {string} uuid - The UUID string to validate
  * @returns {Object} Object containing validation results and replacement UUID if needed
  */
-function validateUUID$3(uuid) {
+function validateUUID$4(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$2()
+            "Correct Block-UUID": generateUUID$3()
         };
     }
 
@@ -704,8 +704,8 @@ function validateUUID$3(uuid) {
 }
 
 var uuidUtils = {
-    generateUUID: generateUUID$2,
-    validateUUID: validateUUID$3
+    generateUUID: generateUUID$3,
+    validateUUID: validateUUID$4
 };
 
 /**
@@ -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$9(formattedContent) {
+function removeLineNumbers$a(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$9
+    removeLineNumbers: removeLineNumbers$a
 };
 
 /**
@@ -837,8 +837,8 @@ var lineNumberFormatter = {
 
 // Dependencies from other modules within CodeBlockUtils
 const { COMMENT_STYLES: COMMENT_STYLES$2 } = constants$2;
-const { removeLineNumbers: removeLineNumbers$8 } = lineNumberFormatter; // Assuming this utility exists
-const { validateUUID: validateUUID$2 } = uuidUtils; // Assuming uuidUtils.js is in the same directory
+const { removeLineNumbers: removeLineNumbers$9 } = lineNumberFormatter; // Assuming this utility exists
+const { validateUUID: validateUUID$3 } = 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$2(header, language) {
+function parseHeader$3(header, language) {
     const headerObject = {};
 
     // Get comment style for the language
@@ -972,7 +972,7 @@ function parseHeader$2(header, language) {
             // Special handling for Block-UUID and Parent-UUID
             if (key === "Block-UUID" || key === "Parent-UUID") {
                 if (value !== 'N/A') {
-                    const uuidValidation = validateUUID$2(value); // Use imported function
+                    const uuidValidation = validateUUID$3(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$2,
+    parseHeader: parseHeader$3,
     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$2(text) {
+function findAllCodeFences$4(text) {
     const openingPositions = [];
     const closingPositions = [];
 
@@ -1139,7 +1139,7 @@ function findAllCodeFences$2(text) {
  * @param {Array} closingPositions - Array of closing fence objects { position, length }
  * @returns {Object} Object containing: { completeBlocks: Array, incompleteBlocks: Array, warnings: Array }
  */
-function matchFencesAndExtractBlocks$2(text, openingPositions, closingPositions) {
+function matchFencesAndExtractBlocks$4(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$1(messageText, blockUUID) {
+function findCodeBlockByUUID$2(messageText, blockUUID) {
     if (!messageText || !blockUUID) {
         return null;
     }
@@ -1308,10 +1308,10 @@ function findCodeBlockByUUID$1(messageText, blockUUID) {
 }
 
 var blockExtractor = {
-    findAllCodeFences: findAllCodeFences$2,
-    matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$2,
+    findAllCodeFences: findAllCodeFences$4,
+    matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$4,
     extractCodeBlocksWithUUIDs: extractCodeBlocksWithUUIDs$1,
-    findCodeBlockByUUID: findCodeBlockByUUID$1
+    findCodeBlockByUUID: findCodeBlockByUUID$2
 };
 
 /**
@@ -1458,7 +1458,7 @@ function validateAnalysisMetadata(metadata) {
 }
 
 
-var AnalysisBlockUtils$2 = { 
+var AnalysisBlockUtils$3 = { 
     isAnalysisBlock,
     getAnalysisBlockType,
     parseOverviewMetadata: parseOverviewMetadata$1,
@@ -1807,7 +1807,7 @@ var constants$1 = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
  */
 
-const { removeLineNumbers: removeLineNumbers$7 } = lineNumberFormatter; // Assuming this utility exists
+const { removeLineNumbers: removeLineNumbers$8 } = 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$6 } = lineNumberFormatter; // Assuming this utility exists
+const { removeLineNumbers: removeLineNumbers$7 } = 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$6(sourceText).split('\n');
+    const sourceLines = removeLineNumbers$7(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$5 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$6 } = 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$5(sourceText);
+        sourceText = removeLineNumbers$6(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$5(sourceText);
-        const cleanTarget = removeLineNumbers$5(targetCode);
+        const cleanSource = removeLineNumbers$6(sourceText);
+        const cleanTarget = removeLineNumbers$6(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$4 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$5 } = 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$4(line.substring(1));
+        const cleanLine = removeLineNumbers$5(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$3 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$4 } = 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$3(line.substring(1));
+            const content = removeLineNumbers$4(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$2 } = lineNumberFormatter;
+const { removeLineNumbers: removeLineNumbers$3 } = 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$2(sourceText);
+    const cleanSourceText = removeLineNumbers$3(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$2(sourceText);
+    const cleanSourceText = removeLineNumbers$3(sourceText);
 
     // Clean up redundant changes
     const redundantFixResult = detectAndFixRedundantChanges(patchText, true);
@@ -8465,7 +8465,7 @@ function applyHunk(sourceText, hunkText) {
     }
 
     // Clean source text
-    const cleanSourceText = removeLineNumbers$2(sourceText);
+    const cleanSourceText = removeLineNumbers$3(sourceText);
 
     // Clean hunk line numbers
     const cleanHunk = cleanHunkLineNumbers(hunkText);
@@ -8599,7 +8599,7 @@ const enhancedProcessor = enhancedPatchProcessor;
  */
 
 // Export all modules
-var PatchUtils$1 = {
+var PatchUtils$2 = {
     // Original exports (for backward compatibility)
     validateAndParseContextPatch: parser.validateAndParseContextPatch,
     determinePatchFormat: parser.determinePatchFormat,
@@ -8680,381 +8680,6 @@ var PatchUtils$1 = {
     applyHunk: enhancedProcessor.applyHunk
 };
 
-/**
- * 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)
- */
-
-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.");
-	    }
-
-	    // 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
-	    );
-
-	    // 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;
-}
-
 /**
  * Component: GitSense Tool Block Utilities
  * Block-UUID: 8e1f7b4e-7e30-48b4-a7fc-643bf647661f
@@ -9066,170 +8691,164 @@ function requireUpdateCodeBlock () {
  * 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;
-	    }
+/**
+ * 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;
+    }
 
-	    if (content.match(/^\s*# GitSense Chat Tool\n\s*{/)) 
-	        return true;
+    if (content.match(/^\s*# GitSense Chat Tool\n\s*{/)) 
+        return true;
 
-	    return false;
-	}
+    return false;
+}
 
-	/**
-	 * 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
-	    }
+/**
+ * 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
+    }
 
-	    const lines = content.split('\n');
-	    const jsonLines = [];
-	    let markerFound = false;
+    const lines = content.split('\n');
+    const jsonLines = [];
+    let markerFound = false;
 
-	    for (const line of lines) {
-	        const trimmedLine = line.trim();
+    for (const line of lines) {
+        const trimmedLine = line.trim();
 
-	        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 (!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)
+        }
 
-	        // After the marker, skip empty lines and comment lines
-	        if (trimmedLine.length === 0 || /^\s*#/.test(line)) {
-	            continue;
-	        }
+        // After the marker, skip empty lines and comment lines
+        if (trimmedLine.length === 0 || /^\s*#/.test(line)) {
+            continue;
+        }
 
-	        // Keep lines that are part of the JSON
-	        jsonLines.push(line);
-	    }
+        // Keep lines that are part of the JSON
+        jsonLines.push(line);
+    }
 
-	    const jsonString = jsonLines.join('\n');
+    const jsonString = jsonLines.join('\n');
 
-	    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.");
-	    }
+    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.");
+    }
 
-	    try {
-	        const parsed = JSON.parse(jsonString);
+    try {
+        const parsed = JSON.parse(jsonString);
 
-	        // 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.");
-	        }
+        // 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.");
+        }
 
-	        if (typeof parsed.config === 'undefined') {
-	            throw new Error("Parsed JSON object is missing the required 'config' property.");
-	        }
+        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}`);
-	    }
-	}
+        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)}`;
-	}
+/**
+ * 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.");
-	    }
+/**
+ * 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, processCodeBlocks, updateCodeBlockByIndex) {
+    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 });
+    // We can't require them as this will create a circular dependency
+    if (!processCodeBlocks || !updateCodeBlockByIndex) {
+        throw new Error("Missing required dependencies processCodeBlocks and/or updateCodeBlockByIndex.");
+    }
 
-	    let targetBlockIndex = -1;
+    // 1. Process the markdown content to find all code blocks
+    const { blocks, warnings } = processCodeBlocks(markdownContent, { silent: true });
 
-	    // 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
-	        }
-	    }
+    let targetBlockIndex = -1;
 
-	    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
-	    }
+    // 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
+        }
+    }
 
-	    // 3. Format the new tool data into the content that goes *inside* the fences
-	    const newContentBetweenFences = formatToolBlock(newToolData);
+    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
+    }
 
-	    // 4. Use CodeBlockUtils.updateCodeBlockByIndex to perform the replacement
-	    // The language for GitSense Tool Blocks is always 'txt'
-	    const updatedMarkdown = updateCodeBlockByIndex(
-	        markdownContent,
-	        targetBlockIndex,
-	        newContentBetweenFences,
-	        'txt'
-	    );
+    // 3. Format the new tool data into the content that goes *inside* the fences
+    const newContentBetweenFences = formatToolBlock(newToolData);
 
-	    return updatedMarkdown;
-	}
+    // 4. Use CodeBlockUtils.updateCodeBlockByIndex to perform the replacement
+    // The language for GitSense Tool Blocks is always 'txt'
+    const updatedMarkdown = updateCodeBlockByIndex(
+        markdownContent,
+        targetBlockIndex,
+        newContentBetweenFences,
+        'txt'
+    );
 
-	GSToolBlockUtils$2 = {
-	    isToolBlock,
-	    parseToolBlock,
-	    formatToolBlock,
-	    replaceToolBlock,
-	};
-	return GSToolBlockUtils$2;
+    return updatedMarkdown;
 }
 
+var GSToolBlockUtils$3 = {
+    isToolBlock: isToolBlock$1,
+    parseToolBlock: parseToolBlock$1,
+    formatToolBlock,
+    replaceToolBlock,
+};
+
 /*
  * Component: CodeBlockUtils Continuation Utilities
  * Block-UUID: 6fdf5c7d-4def-42a1-bc88-0312f6002cfc
@@ -9249,7 +8868,7 @@ function requireGSToolBlockUtils () {
  * @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$2(content, partNumber, language, header = {}) {
+function extractContinuationInfo$3(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']
@@ -9417,7 +9036,7 @@ Contribute code starting from the line immediately following the repeated code b
 
 
 var continuationUtils = {
-    extractContinuationInfo: extractContinuationInfo$2,
+    extractContinuationInfo: extractContinuationInfo$3,
     generateContinuationPrompt: generateContinuationPrompt$2
 };
 
@@ -9440,7 +9059,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$1(jsonString) {
+function detectJsonComments$2(jsonString) {
     const comments = [];
     let inString = false;
     let inBlockComment = false;
@@ -9519,7 +9138,7 @@ function detectJsonComments$1(jsonString) {
 }
 
 var JsonUtils$2 = {
-    detectJsonComments: detectJsonComments$1
+    detectJsonComments: detectJsonComments$2
 };
 
 /**
@@ -9533,558 +9152,550 @@ 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)
  */
 
-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
-	                });
-	            }
-	        }
+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);
 
-	        if (ignoreDueToComments) ; else {
-	            return {
-	                type: 'gs-tool',
-	                language: language,
-	                content: content,
-	                position: position,
-	                incomplete: incomplete,
-	                toolData: toolData,
-	                toolParseError: toolParseError,
-	                warnings: warnings,
-	            };
-	        }
-	    }
+            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
+                });
+            }
+        }
 
-	    // 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,
-	                });
-	            }
-	        }
+        if (ignoreDueToComments) ; else {
+            return {
+                type: 'gs-tool',
+                language: language,
+                content: content,
+                position: position,
+                incomplete: incomplete,
+                toolData: toolData,
+                toolParseError: toolParseError,
+                warnings: warnings,
+            };
+        }
+    }
 
-	        return {
-	            type: analysisType,
-	            language: language,
-	            content: content,
-	            position: position,
-	            incomplete: incomplete,
-	            analysisMetadata: analysisMetadata,
-	            analysisValidation: validationResult,
-	            warnings: warnings,
-	        };
-	    }
+    // 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);
 
-	    // 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
-	        };
-	    }
+        // 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);
 
-	    // 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.
-	        }
+            if (!validationResult.isValid) {
+                warnings.push({
+                    position: position,
+                    type: 'analysis_metadata_error',
+                    message: `Invalid analysis metadata: ${validationResult.errors.join(', ')}`,
+                    content: content,
+                });
+            }
+        }
 
-	        // 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,
-	                });
-	            }
-	        }
+        return {
+            type: analysisType,
+            language: language,
+            content: content,
+            position: position,
+            incomplete: incomplete,
+            analysisMetadata: analysisMetadata,
+            analysisValidation: validationResult,
+            warnings: warnings,
+        };
+    }
 
-	        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
-	    }
+    // 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
+        };
+    }
 
-	    // --- 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.
-	        }
-	    }
+    // 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
 
-	    // 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)
-	            }
-	        }
-	    }
+        let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
 
-	    // 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
-	        });
-	    }
+        // 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.
+        }
 
-	    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
-	    };
-	}
+        // 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: '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
+    }
 
-	/**
-	 * 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 as a regular code block ---
+    // Attempt 1: Look for triple newline separator (our standard)
+    const tripleNewlineSeparator = '\n\n\n';
+    const tripleNewlineIndex = content.indexOf(tripleNewlineSeparator);
 
-	    // 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"
-	            });
-	        }
-	    }
+    if (tripleNewlineIndex !== -1) {
+        const potentialHeaderText = content.substring(0, tripleNewlineIndex); // No trim here
 
-	    // Return processed blocks and collected warnings
-	    // Note: The caller (processCodeBlocks) will handle adding these warnings to its own return object.
-	    return { processedBlocks, allWarnings };
-	}
+        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.
+        }
+    }
 
+    // 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);
 
-	/**
-	 * 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 }
-	        ;
-	    }
+        if (doubleNewlineIndex !== -1) {
+            const potentialHeaderText = content.substring(0, doubleNewlineIndex); // No trim here
 
-	    if (text.trim() === "") {
-	        return { blocks: [], warnings: [], 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)
+            }
+        }
+    }
 
-	    // 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}`);
-	            }
-	        });
-	    }
+    // 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
+        });
+    }
 
-	    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
-	    };
-	}
+    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
+    };
+}
 
-	/**
-	 * 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
 
-	/**
-	 * 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
-	        };
-	    }
+    // 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"
+            });
+        }
+    }
 
-	    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);
-	            }
-	        }
-	    }
+    // 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/, '');
 
-	    return {
-	        text: fixedText,
-	        modified: modified
-	    };
-	}
+            const language = block.opening.language;
 
+            // Process block content - it's expected to be incomplete
+            const processedBlock = processBlockContent(content, language, block.opening.position, true, options);
 
-	blockProcessor = {
-	    processCodeBlocks,
-	    extractCodeBlocks,
-	    fixTextCodeBlocks,
-	};
-	return blockProcessor;
+            // 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;
+            });
+
+            // 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);
+
+                    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);
+            }
+        }
+    }
+
+    return {
+        text: fixedText,
+        modified: modified
+    };
+}
+
+
+var blockProcessor = {
+    processCodeBlocks: processCodeBlocks$5,
+    extractCodeBlocks: extractCodeBlocks$2,
+    fixTextCodeBlocks: fixTextCodeBlocks$2,
+};
+
 /**
  * Component: CodeBlockUtils Patch Integration
  * Block-UUID: 9f7395ef-e213-4841-a95d-f263e422288a
@@ -10097,7 +9708,7 @@ function requireBlockProcessor () {
  */
 
 // Dependency on the core block processor
-const { processCodeBlocks: processCodeBlocks$3 } = requireBlockProcessor();
+const { processCodeBlocks: processCodeBlocks$4 } = blockProcessor;
 
 /**
  * Checks if the provided text content contains at least one patch block.
@@ -10107,7 +9718,7 @@ const { processCodeBlocks: processCodeBlocks$3 } = requireBlockProcessor();
  */
 function containsPatch$2(content, options = { silent: true }) {
     // Use the core processor to get all blocks
-    const { blocks } = processCodeBlocks$3(content, options);
+    const { blocks } = processCodeBlocks$4(content, options);
 
     // Check if any processed block is of type 'patch'
     for (let i = 0; i < blocks.length; i++) {
@@ -10135,7 +9746,7 @@ var patchIntegration = {
  */
 
 // Dependency on the core block processor
-const { processCodeBlocks: processCodeBlocks$2 } = requireBlockProcessor();
+const { processCodeBlocks: processCodeBlocks$3 } = blockProcessor;
 
 /**
  * Detects special code block relationships in a message, such as patches or parent-child links.
@@ -10169,7 +9780,7 @@ function detectCodeBlockRelationships$2(content, codeBlockService, options = { s
 
 
     // Extract all code blocks using the core processor
-    const { blocks, warnings } = processCodeBlocks$2(content, options);
+    const { blocks, warnings } = processCodeBlocks$3(content, options);
 
     let hasPatch = false;
     let hasParentChildRelationship = false;
@@ -10243,7 +9854,7 @@ function detectIncompleteCodeBlock$2(content, options = { silent: true }) {
     }
 
     // Use the core processor which already identifies incomplete blocks
-    const { hasIncompleteBlocks, lastIncompleteBlock } = processCodeBlocks$2(content, options);
+    const { hasIncompleteBlocks, lastIncompleteBlock } = processCodeBlocks$3(content, options);
 
     return {
         hasIncompleteBlocks,
@@ -10546,6 +10157,281 @@ 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
@@ -10562,17 +10448,17 @@ 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 } = requireBlockProcessor();
+const { processCodeBlocks: processCodeBlocks$1, extractCodeBlocks: extractCodeBlocks$1, fixTextCodeBlocks: fixTextCodeBlocks$1 } = blockProcessor;
 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 } = requireUpdateCodeBlock();
+const { updateCodeBlockByIndex: updateCodeBlockByIndex$1, updateCodeBlockByUUID, updateCodeBlock, updateCodeBlockInMessage, deleteCodeBlockByIndex: deleteCodeBlockByIndex$1 } = updateCodeBlock_1;
 const { formatWithLineNumbers: formatWithLineNumbers$1, formatBlockWithLineNumbers: formatBlockWithLineNumbers$1, formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1, removeLineNumbers: removeLineNumbers$1 } = lineNumberFormatter;
 
 // Export all imported items
-var CodeBlockUtils$4 = {
+var CodeBlockUtils$5 = {
     // Constants
     COMMENT_STYLES: COMMENT_STYLES$1,
 
@@ -10639,7 +10525,7 @@ var CodeBlockUtils$4 = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash (v1.1.0)
  */
 
-const CodeBlockUtils$3 = CodeBlockUtils$4;
+const CodeBlockUtils$4 = CodeBlockUtils$5;
 const MessageUtils$2 = MessageUtils$3;
 
 /**
@@ -10778,7 +10664,7 @@ function parseContextSection$1(sectionText) {
         }
     });
 
-    const { blocks, warnings } = CodeBlockUtils$3.extractCodeBlocks(sectionText, { silent: true });
+    const { blocks, warnings } = CodeBlockUtils$4.extractCodeBlocks(sectionText, { silent: true });
     const codeBlocks = blocks.filter(block => block.type === 'code');
 
     if (codeBlocks.length === 0) {
@@ -11044,8 +10930,8 @@ var constants = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const CodeBlockUtils$2 = CodeBlockUtils$4;
-const GSToolBlockUtils$1 = requireGSToolBlockUtils();
+const CodeBlockUtils$3 = CodeBlockUtils$5;
+const GSToolBlockUtils$1 = GSToolBlockUtils$3;
 const JsonUtils$1 = JsonUtils$2;
 const { ANALYZE_HEADER_PREFIX } = constants;
 
@@ -11061,7 +10947,7 @@ const { ANALYZE_HEADER_PREFIX } = constants;
  */
 function processLLMAnalysisResponse$2(messageContent, stoppedStreaming) {
     const silent = { silent: true };
-    const { blocks, warnings } = CodeBlockUtils$2.extractCodeBlocks(messageContent, silent);
+    const { blocks, warnings } = CodeBlockUtils$3.extractCodeBlocks(messageContent, silent);
 
     const analysisBlocks = [];
     const analysisMetadataBlocks = [];
@@ -11174,7 +11060,7 @@ var responseProcessor = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const AnalysisBlockUtils$1 = AnalysisBlockUtils$2;
+const AnalysisBlockUtils$1 = AnalysisBlockUtils$3;
 
 /**
  * Validates the extracted analysis blocks and their metadata.
@@ -11318,6 +11204,7 @@ var instructionLoader = {
 const fs$6 = require$$0.promises;
 const path$4 = require$$1;
 const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$2 } = instructionLoader;
+const CodeBlockUtils$2 = CodeBlockUtils$5;
 
 /**
  * Reads and parses the config.json file in a directory.
@@ -11415,10 +11302,21 @@ async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
                                     const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
                                     const analyzerFullLabel = `${analyzerLabel} (${contentLabel} - ${instructionsLabel})`;
 
-                                    let descriptionContent = null;
+                                    let description = null;
                                     if (includeDescription) {
                                         try {
-                                            descriptionContent = await getAnalyzerInstructionsContent$2(analyzeMessagesBasePath, analyzerId);
+                                            const content = await getAnalyzerInstructionsContent$2(analyzeMessagesBasePath, analyzerId);
+                                            const { blocks, warnings } = CodeBlockUtils$2.extractCodeBlocks(content, { silent: true });
+                                            const jsonBlock = blocks.find(block => block.language === 'json');
+
+                                            if (jsonBlock && jsonBlock.content) {
+                                                try {
+                                                    const json = JSON.parse(jsonBlock.content);
+                                                    description = json.description;
+                                                } catch(error) {
+                                                    console.warn(`${analyzerId} contains an invalid JSON`);
+                                                }
+                                            }
                                         } catch (descError) {
                                             console.warn(`Warning: Could not load description for ${analyzerId}: ${descError.message}`);
                                             descriptionContent = null;
@@ -11430,7 +11328,7 @@ async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
                                         label: analyzerFullLabel,
                                         name: analyzerName,
                                         protected: analyzerConfig?.protected || false,
-                                        ...(descriptionContent && { description: descriptionContent })
+                                        description
                                      });
                                 } catch (error) {
                                     // If 1.md doesn't exist, this is not a complete analyzer configuration, skip.
@@ -11603,7 +11501,7 @@ var saver = {
 
 const fs$4 = require$$0.promises;
 const path$2 = require$$1;
-const CodeBlockUtils$1 = CodeBlockUtils$4;
+const CodeBlockUtils$1 = CodeBlockUtils$5;
 
 /**
  * Deduces the JSON schema type and format/items from a string value pattern.
@@ -12232,13 +12130,13 @@ var EnvUtils$1 = {
  */
 
 const ChatUtils = ChatUtils$1;
-const CodeBlockUtils = CodeBlockUtils$4;
+const CodeBlockUtils = CodeBlockUtils$5;
 const ContextUtils = ContextUtils$2;
 const MessageUtils = MessageUtils$3;
-const AnalysisBlockUtils = AnalysisBlockUtils$2;
+const AnalysisBlockUtils = AnalysisBlockUtils$3;
 const AnalyzerUtils = AnalyzerUtils$1;
-const PatchUtils = PatchUtils$1;
-const GSToolBlockUtils = requireGSToolBlockUtils();
+const PatchUtils = PatchUtils$2;
+const GSToolBlockUtils = GSToolBlockUtils$3;
 const LLMUtils = LLMUtils$1;
 const JsonUtils = JsonUtils$2;
 const ConfigUtils = ConfigUtils$1;