@gitsense/gsc-utils 0.2.25 → 0.2.28

package/src/GitSenseChatUtils.js

@@ -1,12 +1,12 @@
 /*
  * Component: GitSenseChatUtils
- * Block-UUID: 1793b3a8-4881-4306-bfdf-673eef503679
- * Parent-UUID: eaeabebb-04b6-4881-9b29-88798c7f21b6
- * Version: 2.4.0
- * Description: Interface class for GitSense Chat utilities providing a unified API for code block parsing (markdown), extraction, and patch operations. Integrates functionalities from CodeBlockUtils and PatchUtils modules, and now includes ConfigUtils, EnvUtils, and ObjectUtils.
+ * Block-UUID: c1b6c4d3-7959-4eb6-8022-6cd7aa59240d
+ * Parent-UUID: 1793b3a8-4881-4306-bfdf-673eef503679
+ * Version: 2.7.0
+ * Description: Interface class for GitSense Chat utilities providing a unified API for code block parsing (markdown), extraction, and patch operations. Integrates functionalities from CodeBlockUtils and PatchUtils modules, and now includes ConfigUtils, EnvUtils, ObjectUtils, MetaRawResultUtils, and CompactChatUtils.
  * Language: JavaScript
  * Created-at: 2025-10-17T17:13:04.663Z
- * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v2.0.0), Gemini 2.5 Pro (v2.1.0), Gemini 2.5 Pro (v2.1.1), Gemini 2.5 Flash (v2.1.2), Gemini 2.5 Flash (v2.1.3), Gemini 2.5 Flash (v2.1.4), Qwen 3 Coder 480B - Cerebras (v2.1.5), Qwen 3 Coder 480B - Cerebras (v2.2.0), Qwen 3 Coder 480B - Cerebras (v2.2.1), Claude Haiku 4.5 (v2.3.0), Qwen 3 Coder 480B - Cerebras (v2.4.0)
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v2.0.0), Gemini 2.5 Pro (v2.1.0), Gemini 2.5 Pro (v2.1.1), Gemini 2.5 Flash (v2.1.2), Gemini 2.5 Flash (v2.1.3), Gemini 2.5 Flash (v2.1.4), Qwen 3 Coder 480B - Cerebras (v2.1.5), Qwen 3 Coder 480B - Cerebras (v2.2.0), Qwen 3 Coder 480B - Cerebras (v2.2.1), Claude Haiku 4.5 (v2.3.0), Qwen 3 Coder 480B - Cerebras (v2.4.0), Qwen 3 Coder 480B - Cerebras (v2.5.0), GLM-4.6 (v2.6.0), GLM-4.6 (v2.7.0)
  */
 
 
@@ -28,7 +28,10 @@ const EnvUtils = require('./EnvUtils');
 const DomUtils = require('./DomUtils');
 const ObjectUtils = require('./ObjectUtils');
 const SVGUtils = require('./SVGUtils');
+const StringUtils = require('./SharedUtils/stringUtils');
 const LanguageNameUtils = require('./LanguageNameUtils');
+const MetaRawResultUtils = require('./MetaRawResultUtils');
+const CompactChatUtils = require('./CompactChatUtils');
 
 const {
     normalizeLanguageName,
@@ -114,6 +117,7 @@ const {
     removeCodeBlockMarkers,
     updateCodeBlockByIndex,
     deleteCodeBlockByIndex,
+    getLineage,
 } = CodeBlockUtils;
 
 const {
@@ -159,6 +163,7 @@ const {
     parseContextSection,
     extractContextSections,
     extractContextItemsOverviewTableRows,
+    getContextFiles,
     formatContextContent,
 } = ContextUtils;
 
@@ -166,6 +171,28 @@ const {
     trimObjectStrings
 } = ObjectUtils;
 
+const {
+    splitWithLimit,
+    capitalize,
+    titleCase,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    constantCase,
+    pascalCase,
+    trimWhitespace,
+    truncate,
+} = StringUtils;
+
+const {
+    extractMetaRawResultMappings,
+    isMetaRawResultMessage,
+    parseMetaRawResultContent,
+    parseTableRow,
+    parseSize,
+    parseTokens
+} = MetaRawResultUtils;
+
 
 /**
  * GitSenseChatUtils class provides a unified interface to code block and patch utilities.
@@ -406,7 +433,12 @@ module.exports = {
     EnvUtils,
     DomUtils,
     ObjectUtils,
+    StringUtils,
     SVGUtils,
+    MetaRawResultUtils,
+    CompactChatUtils,
+    ReferenceMessageUtils: CompactChatUtils.ReferenceMessageUtils,
+    CompactedMessageUtils: CompactChatUtils.CompactedMessageUtils,
 
     // --- Individual Function Exports (sourced correctly) ---
 
@@ -499,6 +531,18 @@ module.exports = {
     // Object Utils
     trimObjectStrings,
 
+    // String Utils
+    splitWithLimit,
+    capitalize,
+    titleCase,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    constantCase,
+    pascalCase,
+    trimWhitespace,
+    truncate,
+
     // Markdown Utils
     createMarkdownRenderer,
     removeSignature,
@@ -518,8 +562,17 @@ module.exports = {
     getApiKey,
 
     // Context Utils
+    getContextFiles,
     parseContextSection,
     extractContextSections,
     extractContextItemsOverviewTableRows,
     formatContextContent,
+
+    // MetaRawResult Utils
+    extractMetaRawResultMappings,
+    isMetaRawResultMessage,
+    parseMetaRawResultContent,
+    parseTableRow,
+    parseSize,
+    parseTokens,
 };

package/src/LLMUtils.js

@@ -1,6 +1,6 @@
 /**
  * Component: LLMUtils
- * Block-UUID: a3106054-42f1-474f-96f3-182d66eb19a0
+ * Block-UUID: b8536c11-ed0b-4538-b3ff-35da94e67012
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions related to Large Language Model interactions, such as token estimation.

package/src/MarkdownUtils.js

@@ -56,7 +56,10 @@ function createMarkdownRenderer(hljs, hstyle = {}, nhstyle = {}) {
                     // Create the inner code element with the highlighted content
                     // and the language label prepended.
                     const codeElement = h.createCode({
-                        html: `<span class='gs-chat-lang'>${lang}</span>\n\n${highlightedCode}`
+                        html: `<span class='gs-chat-lang'>${lang}</span>\n\n${highlightedCode}`,
+                        style: {
+                            fontSize: '13px'
+                        }
                     });
 
                     // Wrap the code element in a pre tag with styling

package/src/MessageUtils.js

@@ -363,7 +363,7 @@ function getMessageContentType(messageContent) {
         return 'regular'; // Handle non-string input gracefully
     }
     const trimmedContent = messageContent.trimStart(); // Check from the beginning, ignoring leading whitespace
-    if (trimmedContent.startsWith('## FILE CONTENT')) {
+    if (trimmedContent.startsWith('## FILE CONTENT') || trimmedContent.startsWith('## REFERENCE FILE CONTENT')) {
         return 'file-content-context';
     } else if (trimmedContent.startsWith('## OVERVIEW')) {
         return 'overview-context';

package/src/MetaRawResultUtils.js

@@ -0,0 +1,244 @@
+/**
+ * Component: MetaRawResultUtils
+ * Block-UUID: 8a4d235b-a9d3-44b8-9c08-47b3678ba1c0
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Utility for parsing and extracting mappings from meta-raw-result messages
+ * Language: JavaScript
+ * Created-at: 2025-11-15T19:15:00.000Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+
+const ChatUtils = require('./ChatUtils');
+
+/**
+ * Extracts and parses all meta-raw-result messages from a chat
+ * @param {Object} chat - The chat object containing messages
+ * @param {string} model - The model name (optional, for message filtering)
+ * @returns {Map<number, Object>} Map of chatId to file metadata
+ */
+function extractMetaRawResultMappings(chat, model = null) {
+    const mappings = new Map();
+    
+    try {
+        // Get all messages from the chat
+        const allMessages = ChatUtils.getChatMessages(chat, model);
+        
+        // Filter for meta-raw-result messages
+        const metaRawMessages = allMessages.filter(msg => isMetaRawResultMessage(msg));
+
+        // Parse each meta-raw-result message
+        for (const message of metaRawMessages) {
+            const messageMappings = parseMetaRawResultContent(message.message);
+            
+            // Merge mappings into the main map
+            for (const [chatId, fileInfo] of messageMappings) {
+                mappings.set(chatId, fileInfo);
+            }
+        }
+        
+        return mappings;
+    } catch (error) {
+        console.error('Error extracting meta-raw-result mappings:', error);
+        return mappings;
+    }
+}
+
+/**
+ * Validates if a message is a meta-raw-result message
+ * @param {Object} message - The message object to validate
+ * @returns {boolean} True if message is meta-raw-result type
+ */
+function isMetaRawResultMessage(message) {
+    if (!message || !message.message) {
+        return false;
+    }
+    
+    // Check if message type is meta-raw-result
+    if (message.type === 'meta-raw-result') {
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Parses a single meta-raw-result message content
+ * @param {string} messageContent - The message content to parse
+ * @returns {Map<number, Object>} Map of chatId to file metadata
+ */
+function parseMetaRawResultContent(messageContent) {
+    const mappings = new Map();
+    
+    try {
+        // Split content into lines
+        const lines = messageContent.split('\n');
+        
+        // Find the data section
+        let dataSectionStart = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trimStart().startsWith('## Data ')) {
+                dataSectionStart = i;
+                break;
+            }
+        }
+
+        if (dataSectionStart === -1) {
+            return mappings; // No data section found
+        }
+        
+        // Find the table header (line with |)
+        let headerLine = -1;
+        for (let i = dataSectionStart; i < lines.length; i++) {
+            if (lines[i].includes('|') && lines[i].includes('Chat ID')) {
+                headerLine = i;
+                break;
+            }
+        }
+        
+        if (headerLine === -1) {
+            return mappings; // No table header found
+        }
+        
+        // Find the separator line (|---|---|...)
+        let separatorLine = -1;
+        for (let i = headerLine + 1; i < lines.length; i++) {
+            if (lines[i].match(/^\|[\s\-\|]*\|$/)) {
+                separatorLine = i;
+                break;
+            }
+        }
+        
+        if (separatorLine === -1) {
+            return mappings; // No separator found
+        }
+       
+        // Parse data rows (everything after the separator)
+        for (let i = separatorLine + 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+
+            // Skip empty lines or separator lines
+            if (!line || line.match(/^\|[\s\-\|]*\|$/) || !line.includes('|')) {
+                continue;
+            }
+            
+            // Parse the table row
+            const fileInfo = parseTableRow(line);
+            if (fileInfo && fileInfo.id) {
+                mappings.set(fileInfo.id, fileInfo);
+            }
+        }
+        
+        return mappings;
+    } catch (error) {
+        console.error('Error parsing meta-raw-result content:', error);
+        return mappings;
+    }
+}
+
+/**
+ * Parses a single table row from meta-raw-result content
+ * @param {string} rowLine - The table row line to parse
+ * @returns {Object|null} Parsed file information object or null if parsing failed
+ */
+function parseTableRow(rowLine) {
+    try {
+        // Split the row by | and clean up
+        const cells = rowLine.split('|').map(cell => cell.trim()).filter(cell => cell);
+        
+        if (cells.length < 6) {
+            return null; // Not enough columns
+        }
+        
+        // Extract basic information from the table cells
+        const repo = cells[0];
+        const branch = cells[1];
+        const filePath = cells[2];
+        const language = cells[3];
+        const chatId = parseInt(cells[4], 10);
+        
+        // Parse file path to extract name and path
+        const pathParts = filePath.split('/');
+        const name = pathParts[pathParts.length - 1];
+        const path = filePath;
+        
+        // Create full path
+        const fullPath = `${repo}/${path}`;
+        
+        return {
+            id: chatId,
+            name: name,
+            path: path,
+            repo: repo,
+            branch: branch,
+            language: language,
+            fullPath: fullPath
+        };
+    } catch (error) {
+        console.error('Error parsing table row:', error);
+        return null;
+    }
+}
+
+/**
+ * Parses size string to bytes
+ * @param {string} sizeStr - Size string (e.g., "1.2 KB", "500 B")
+ * @returns {number} Size in bytes
+ */
+function parseSize(sizeStr) {
+    if (!sizeStr || sizeStr === 'N/A') {
+        return 0;
+    }
+    
+    const match = sizeStr.match(/^([\d.]+)\s*(B|KB|MB|GB)?$/i);
+    if (!match) {
+        return 0;
+    }
+    
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'B').toUpperCase();
+    
+    switch (unit) {
+        case 'B': return Math.round(value);
+        case 'KB': return Math.round(value * 1024);
+        case 'MB': return Math.round(value * 1024 * 1024);
+        case 'GB': return Math.round(value * 1024 * 1024 * 1024);
+        default: return 0;
+    }
+}
+
+/**
+ * Parses tokens string to number
+ * @param {string} tokensStr - Tokens string (e.g., "1.2k", "500")
+ * @returns {number} Token count
+ */
+function parseTokens(tokensStr) {
+    if (!tokensStr || tokensStr === 'N/A') {
+        return 0;
+    }
+    
+    const match = tokensStr.match(/^([\d.]+)(k|m|b)?$/i);
+    if (!match) {
+        return 0;
+    }
+    
+    const value = parseFloat(match[1]);
+    const suffix = (match[2] || '').toLowerCase();
+    
+    switch (suffix) {
+        case 'k': return Math.round(value * 1000);
+        case 'm': return Math.round(value * 1000000);
+        case 'b': return Math.round(value * 1000000000);
+        default: return Math.round(value);
+    }
+}
+
+module.exports = {
+    extractMetaRawResultMappings,
+    isMetaRawResultMessage,
+    parseMetaRawResultContent,
+    parseTableRow,
+    parseSize,
+    parseTokens
+};

package/src/PatchUtils/constants.js

@@ -2,11 +2,11 @@
  * Component: PatchUtils Constants
  * Block-UUID: c6747054-2c8b-461f-910d-0fd725d9a350
  * Parent-UUID: 32adc00e-7509-4219-8e40-6c1319371db9
- * Version: 2.0.0
+ * Version: 2.1.0
  * Description: Contains shared constants and regular expressions used by the enhanced patch utilities.
  * Language: JavaScript
  * Created-at: 2025-05-14T16:55:00.000Z
- * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Claude 3.7 Sonnet (v2.0.0)
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Claude 3.7 Sonnet (v2.0.0), Qwen 3 Coder 480B - Cerebras (v2.1.0)
  */
 
 
@@ -34,10 +34,14 @@ const DEFAULT_SLIDING_WINDOW_SIZE = 3;
 // If context is longer than this, we'll use a sliding window approach
 const MAX_CONTEXT_LINES_FOR_DIRECT_MATCH = 10;
 
-// Patch markers
+// Traditional patch markers
 const PATCH_START_MARKER = '# --- PATCH START MARKER ---';
 const PATCH_END_MARKER = '# --- PATCH END MARKER ---';
 
+// Abbreviated patch markers
+const ABBREVIATED_PATCH_START_MARKER = '# --- ABBREVIATED PATCH START MARKER ---';
+const ABBREVIATED_PATCH_END_MARKER = '# --- ABBREVIATED PATCH END MARKER ---';
+
 // Patch metadata header
 const PATCH_METADATA_HEADER = '# Patch Metadata';
 
@@ -65,6 +69,8 @@ module.exports = {
     MAX_CONTEXT_LINES_FOR_DIRECT_MATCH,
     PATCH_START_MARKER,
     PATCH_END_MARKER,
+    ABBREVIATED_PATCH_START_MARKER,
+    ABBREVIATED_PATCH_END_MARKER,
     PATCH_METADATA_HEADER,
     REQUIRED_METADATA_FIELDS,
     ORIGINAL_FILE_HEADER,

package/src/PatchUtils/patchParser.js

@@ -2,21 +2,24 @@
  * Component: PatchUtils Parser
  * Block-UUID: ce634df9-ff99-482a-a261-56ab34a2546e
  * Parent-UUID: fcc85ec1-0146-40bf-a937-6f7928258cbf
- * Version: 1.1.0
- * Description: Handles parsing, validation, extraction, and detection of traditional unified diff patches. Extracts metadata and raw diff content.
+ * Version: 1.2.0
+ * Description: Handles parsing, validation, extraction, and detection of traditional unified diff patches and abbreviated patches. Extracts metadata and raw diff content.
  * Language: JavaScript
  * Created-at: 2025-04-18T02:59:04.322Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0)
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0)
  */
 
 
 const { isValidVersion } = require('../SharedUtils/versionUtils'); // Assuming SharedUtils is one level up
+const { PATCH_START_MARKER, PATCH_END_MARKER, PATCH_METADATA_HEADER, 
+        ORIGINAL_FILE_HEADER, MODIFIED_FILE_HEADER, ABBREVIATED_PATCH_START_MARKER, 
+        ABBREVIATED_PATCH_END_MARKER } = require('./constants');
 
 /**
  * Determines the type of patch format used based on markers.
- * Primarily looks for traditional unified diff markers after metadata.
+ * Looks for traditional unified diff markers or abbreviated patch markers.
  * @param {string} patchText - The patch text
- * @returns {string} 'traditional', or 'unknown'
+ * @returns {string} 'traditional', 'abbreviated', or 'unknown'
  */
 function determinePatchFormat(patchText) {
     if (!patchText || typeof patchText !== 'string') {
@@ -24,29 +27,33 @@ function determinePatchFormat(patchText) {
     }
 
     // Check for required metadata header first
-    if (!patchText.includes('# Patch Metadata')) {
+    if (!patchText.includes(PATCH_METADATA_HEADER)) {
         return 'unknown'; // Must have metadata header
     }
 
     // Check for traditional unified diff markers *after* potential metadata and start marker
     // Look for ---, +++, @@ after the start marker
-    const startMarkerIndex = patchText.indexOf('# --- PATCH START MARKER ---');
-    if (startMarkerIndex === -1) {
-        return 'unknown'; // Must have start marker
-    }
+    const traditionalStartMarkerIndex = patchText.indexOf(PATCH_START_MARKER);
+    if (traditionalStartMarkerIndex !== -1) {
+        const contentAfterMarker = patchText.substring(traditionalStartMarkerIndex);
 
-    const contentAfterMarker = patchText.substring(startMarkerIndex);
+        // Use regex for more reliable detection within the content part
+        const traditionalMarkers = /^\s*--- Original\s*\n\s*\+\+\+ Modified\s*\n\s*@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
 
-    // Use regex for more reliable detection within the content part
-    const traditionalMarkers = /^\s*--- Original\s*\n\s*\+\+\+ Modified\s*\n\s*@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
+        if (traditionalMarkers.test(contentAfterMarker)) {
+            return 'traditional';
+        }
+    }
 
-    if (traditionalMarkers.test(contentAfterMarker)) {
-        return 'traditional';
+    // Check for abbreviated patch markers
+    const abbreviatedStartMarkerIndex = patchText.indexOf(ABBREVIATED_PATCH_START_MARKER);
+    if (abbreviatedStartMarkerIndex !== -1) {
+        return 'abbreviated';
     }
 
     // Removed check for obsolete '@=' context marker
 
-    return 'unknown'; // Format doesn't match expected traditional structure after markers
+    return 'unknown'; // Format doesn't match expected structures after markers
 }
 
 /**
@@ -68,7 +75,8 @@ function extractPatchMetadata(patchText) {
         const trimmedLine = line.trim();
 
         // Stop processing metadata if we hit content markers or the start marker
-        if (trimmedLine === '# --- PATCH START MARKER ---' ||
+        if (trimmedLine === PATCH_START_MARKER ||
+            trimmedLine === ABBREVIATED_PATCH_START_MARKER ||
             line.startsWith('--- ') || // Standard diff header start
             line.startsWith('+++ ') || // Standard diff header start
             line.startsWith('@@ '))   // Standard diff hunk header start
@@ -91,7 +99,7 @@ function extractPatchMetadata(patchText) {
                 }
             }
             // Allow lines that are just comments (e.g., # Description continued)
-        } else if (trimmedLine !== '' && !trimmedLine.startsWith('# Patch Metadata')) {
+        } else if (trimmedLine !== '' && !trimmedLine.startsWith(PATCH_METADATA_HEADER)) {
             // If we encounter non-empty, non-comment lines before the start marker,
             // it's likely malformed, stop metadata parsing.
             inMetadata = false;
@@ -135,11 +143,11 @@ function validatePatchMetadata(metadata) {
     }
 
     // Validate UUIDs are not the template string
-    if (metadata['Source-Block-UUID'] === '12d8a596-0620-4725-ba49-ae6fccdfa2ad') {
-        errors.push('Source-Block-UUID contains placeholder value "f016e2e4-f97f-4ffe-9f46-ea48f59a3eea".');
+    if (metadata['Source-Block-UUID'] === '{{GS-UUID}}') {
+        errors.push('Source-Block-UUID contains placeholder value "{{GS-UUID}}".');
     }
-     if (metadata['Target-Block-UUID'] === '5bfb717c-aaec-462e-a50e-d096aba0d63f') {
-        errors.push('Target-Block-UUID contains placeholder value "12e76392-f0ac-4c9d-a5be-c98401487352".');
+     if (metadata['Target-Block-UUID'] === '{{GS-UUID}}') {
+        errors.push('Target-Block-UUID contains placeholder value "{{GS-UUID}}".');
     }
 
     return errors;
@@ -152,23 +160,34 @@ function validatePatchMetadata(metadata) {
  * @param {string} format - Expected format (should be 'traditional').
  * @returns {string} Raw unified diff content, or empty string if not found/invalid.
  */
-function extractPatchContent(patchText, format) {
-    if (!patchText || format !== 'traditional') {
+function extractPatchContent(patchText, format = 'traditional') {
+    if (!patchText) {
         return "";
     }
 
     const lines = patchText.split('\n');
-
     let contentLines = [];
     let inContentBlock = false;
+    let startMarker, endMarker;
+
+    // Determine which markers to look for based on format
+    if (format === 'traditional') {
+        startMarker = PATCH_START_MARKER;
+        endMarker = PATCH_END_MARKER;
+    } else if (format === 'abbreviated') {
+        startMarker = ABBREVIATED_PATCH_START_MARKER;
+        endMarker = ABBREVIATED_PATCH_END_MARKER;
+    } else {
+        return ""; // Unsupported format
+    }
 
     for (const line of lines) {
-        if (line.trim() === '# --- PATCH START MARKER ---') {
+        if (line.trim() === startMarker) {
             inContentBlock = true;
             continue; // Skip the marker line itself
         }
 
-        if (line.trim() === '# --- PATCH END MARKER ---') {
+        if (line.trim() === endMarker) {
             inContentBlock = false;
             break; // Stop processing once end marker is found
         }
@@ -207,23 +226,25 @@ function detectPatch(messageText) {
     }
 
     // Find the first code block that contains patch metadata
-    // Regex looks for ``` optionally followed by 'diff' language hint
-    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+    // Regex looks for ``` optionally followed by language hint
+    const codeBlockRegex = /```([a-zA-Z0-9#+_-]*)?\s*\n([\s\S]*?)```/g;
     let match;
     while ((match = codeBlockRegex.exec(messageText)) !== null) {
-        const blockContent = match[1];
+        const language = match[1] || '';
+        const blockContent = match[2];
         if (isPatchBlock(blockContent)) { // Use isPatchBlock for check
              const metadata = extractPatchMetadata(blockContent); // Use extractPatchMetadata
              // Basic validation: Check for essential UUIDs
              if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
-                 metadata['Source-Block-UUID'] !== '26f930c9-2bc8-4906-bdf5-469700b2f857' && // Check placeholders
-                 metadata['Target-Block-UUID'] !== '48a957eb-dd72-44bb-84a2-0df3c7cb16ed')
+                 metadata['Source-Block-UUID'] !== '{{GS-UUID}}' && // Check placeholders
+                 metadata['Target-Block-UUID'] !== '{{GS-UUID}}')
              {
                  return {
                      patchText: blockContent, // Return the content inside the fence
                      metadata,
                      sourceBlockUUID: metadata['Source-Block-UUID'],
                      targetBlockUUID: metadata['Target-Block-UUID'],
+                     language: language,
                      startIndex: match.index, // Store block position if needed
                      endIndex: match.index + match[0].length
                  };
@@ -245,25 +266,28 @@ function findAllPatches(messageText) {
     }
 
     const patches = [];
-    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+    // Find code blocks with any language identifier
+    const codeBlockRegex = /```([a-zA-Z0-9#+_-]*)?\s*\n([\s\S]*?)```/g;
 
     let match;
     while ((match = codeBlockRegex.exec(messageText)) !== null) {
-        const blockContent = match[1];
+        const language = match[1] || '';
+        const blockContent = match[2];
 
         if (isPatchBlock(blockContent)) {
             const metadata = extractPatchMetadata(blockContent);
 
             // Basic validation: Check for essential UUIDs and non-placeholder values
             if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
-                metadata['Source-Block-UUID'] !== 'e898f14f-14f6-4710-b35b-1cf3478fb5da' &&
-                metadata['Target-Block-UUID'] !== '0093be2a-fd84-4925-a0c1-13f8a8260cbf')
+                metadata['Source-Block-UUID'] !== '{{GS-UUID}}' &&
+                metadata['Target-Block-UUID'] !== '{{GS-UUID}}')
             {
                 patches.push({
                     patchText: blockContent,
                     metadata,
                     sourceBlockUUID: metadata['Source-Block-UUID'],
                     targetBlockUUID: metadata['Target-Block-UUID'],
+                    language: language,
                     startIndex: match.index,
                     endIndex: match.index + match[0].length
                 });

package/src/PatchUtils/patchVerifier/detectAndFixOverlappingHunks.js

@@ -1,6 +1,6 @@
 /**
  * Component: PatchUtils Detect and Fix Overlapping Hunks
- * Block-UUID: 0e1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
+ * Block-UUID: 7324dab8-24ae-4a42-9dc3-766e69104ef6
  * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
  * Version: 1.0.0
  * Description: Detects and optionally fixes overlapping hunks in a patch file by merging them.

package/src/PatchUtils/patchVerifier/detectAndFixRedundantChanges.js

@@ -1,6 +1,6 @@
 /**
  * Component: PatchUtils Detect and Fix Redundant Changes
- * Block-UUID: ffd6e8fc-399d-4254-827c-ef17e2f7d0d5
+ * Block-UUID: bb354364-b497-412c-9570-b39355da8153
  * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
  * Version: 1.0.0
  * Description: Detects and optionally fixes redundant changes in a patch where content is deleted and re-added identically.

package/src/PatchUtils/patchVerifier/verifyAndCorrectHunkHeaders.js

@@ -1,6 +1,6 @@
 /**
  * Component: PatchUtils Verify and Correct Hunk Headers
- * Block-UUID: 61c74798-bddb-47e1-be48-4a102659933c
+ * Block-UUID: 013f7f2d-0077-4cec-bd22-3bf2fc81f222
  * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
  * Version: 1.0.0
  * Description: Verifies and corrects the hunk headers within a patch based on the line number prefixes in the content lines.