@gitsense/gsc-utils 0.2.24 → 0.2.27

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/ObjectUtils.js

@@ -0,0 +1,54 @@
+/*
+ * Component: ObjectUtils
+ * Block-UUID: 6f3c6c7a-1c5a-40c4-be26-332703b68d31
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Utility functions for processing and manipulating JavaScript objects, including string property trimming for LLM token optimization
+ * Language: JavaScript
+ * Created-at: 2025-10-17T17:02:12.153Z
+ * Authors: Qwen 3 Coder 480B - Cerebras (v1.0.0)
+ */
+
+
+/**
+ * Recursively trims string properties in an object to a maximum length
+ * @param {Object|Array} obj - The object or array to process
+ * @param {number} maxLength - Maximum length for strings (default: 100)
+ * @param {string} suffix - Suffix to append to trimmed strings (default: '...')
+ * @returns {Object|Array} - New object with trimmed strings
+ */
+function trimObjectStrings(obj, maxLength = 100, suffix = '...') {
+    // Handle null or undefined
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+
+    // Handle strings
+    if (typeof obj === 'string') {
+        if (obj.length <= maxLength) {
+            return obj;
+        }
+        return obj.substring(0, maxLength - suffix.length) + suffix;
+    }
+
+    // Handle arrays
+    if (Array.isArray(obj)) {
+        return obj.map(item => trimObjectStrings(item, maxLength, suffix));
+    }
+
+    // Handle objects
+    if (typeof obj === 'object') {
+        const trimmedObj = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                trimmedObj[key] = trimObjectStrings(obj[key], maxLength, suffix);
+            }
+        }
+        return trimmedObj;
+    }
+
+    // Return other types unchanged
+    return obj;
+}
+
+module.exports = { trimObjectStrings };

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,22 +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
         }
@@ -180,8 +200,6 @@ function extractPatchContent(patchText, format) {
     return contentLines.join('\n');
 }
 
-// Removed extractContextPatches function (obsolete context format)
-
 /**
  * Determines if a code block's content represents a patch block
  * by checking for the mandatory metadata header.
@@ -208,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
                  };
@@ -246,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/patchProcessor.js

@@ -113,7 +113,7 @@ function applyPatch(sourceText, patchText) {
         }
 
         // 4. Apply the patch
-        const patchedResult = jsdiff.applyPatch(sourceText, rawDiffContent, { fuzzFactor: 0 });
+        const patchedResult = jsdiff.applyPatch(sourceText, rawDiffContent, { fuzzFactor: 20 });
 
         if (patchedResult === false) {
             // jsdiff.applyPatch returns false on failure
@@ -276,11 +276,13 @@ function createPatchFromCodeBlocks(CodeBlockUtils, sourceCodeBlockText, targetCo
     const [ sourceHeaderText ] = sourceCodeBlockText.split('\n\n\n');
     const [ targetHeaderText ] = targetCodeBlockText.split('\n\n\n');
 
-    const sourceContentTemp = sourceCodeBlockText.split('\n\n\n'); sourceContentTemp.shift();
-    const sourceContent = sourceContentTemp.join('\n\n');
+    const sourceContentTemp = sourceCodeBlockText.split('\n\n\n'); 
+    sourceContentTemp.shift();
+    const sourceContent = sourceContentTemp.join('\n\n\n');
 
-    const targetContentTemp = targetCodeBlockText.split('\n\n\n'); targetContentTemp.shift();
-    const targetContent = targetContentTemp.join('\n\n');
+    const targetContentTemp = targetCodeBlockText.split('\n\n\n'); 
+    targetContentTemp.shift();
+    const targetContent = targetContentTemp.join('\n\n\n');
 
     // Get the number of lines in the header + two blank lines
     // Note, before the code block header format was solidified, we use to include 'Updated-at' but no more so
@@ -346,6 +348,7 @@ function createPatchFromCodeBlocks(CodeBlockUtils, sourceCodeBlockText, targetCo
                       `# --- PATCH START MARKER ---\n`+
                       `${adjustedDiffPatch}\n`+
                       `# --- PATCH END MARKER ---`;
+
     return {
         formatted,
         formattedMetadata,

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.