@gitsense/gsc-utils 0.2.25 → 0.2.28

package/src/CompactChatUtils/ReferenceMessageUtils.js

@@ -0,0 +1,143 @@
+/**
+ * Component: ReferenceMessageUtils
+ * Block-UUID: 2870551a-4311-4d64-9491-c9cc62f276e8
+ * Parent-UUID: N/A
+ * Description: Utility for parsing reference messages in the compact message workflow, extracting session data, metadata, and message sections.
+ * Language: JavaScript
+ * Created-at: 2025-12-07T00:08:42.573Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+
+class ReferenceMessageUtils {
+    /**
+     * Extracts all data from a reference message including session data, metadata, and message sections
+     * @param {string} referenceMessage - The reference message content to parse
+     * @returns {Object} Parsed data with messages to compact and keep, metadata, and session information
+     */
+    static extractReferenceMessageData(referenceMessage) {
+        if (!referenceMessage) {
+            return {
+                messagesToCompact: [],
+                messagesToKeep: [],
+                originalChatUuid: null,
+                validationHash: null,
+                sessionId: null,
+                range: null,
+                from: null,
+                to: null
+            };
+        }
+
+        // Extract Original Chat UUID
+        const originalChatUuidMatch = referenceMessage.match(/Original Chat UUID:\s*([a-f0-9-]+)/i);
+        const originalChatUuid = originalChatUuidMatch ? originalChatUuidMatch[1] : null;
+
+        // Extract Validation Hash
+        const validationHashMatch = referenceMessage.match(/Validation Hash:\s*([a-f0-9]+)/i);
+        const validationHash = validationHashMatch ? validationHashMatch[1] : null;
+
+        // Extract Session ID
+        const sessionIdMatch = referenceMessage.match(/Session ID:\s*(\d+)/i);
+        const sessionId = sessionIdMatch ? sessionIdMatch[1] : null;
+
+        // Extract Range
+        const rangeMatch = referenceMessage.match(/Range:\s*(\d+-\d+)/i);
+        const range = rangeMatch ? rangeMatch[1] : null;
+
+        // Extract From and To values
+        const fromMatch = referenceMessage.match(/From:\s*(\d+)/i);
+        const from = fromMatch ? parseInt(fromMatch[1], 10) : null;
+
+        const toMatch = referenceMessage.match(/To:\s*(\d+)/i);
+        const to = toMatch ? parseInt(toMatch[1], 10) : null;
+
+        // If range is not found but from and to are available, construct the range
+        if (!range && from !== null && to !== null) {
+            range = `${from}-${to}`;
+        }
+
+        // Extract Messages to Compact section
+        const compactSectionMatch = referenceMessage.match(/# Messages to Compact\n([\s\S]*?)(?=\n# |\n$|$)/);
+        const compactSection = compactSectionMatch ? compactSectionMatch[1] : '';
+
+        // Extract Messages to Keep section
+        const keepSectionMatch = referenceMessage.match(/# Messages to Keep \(Context\)\n([\s\S]*?)(?=\n# |\n$|$)/);
+        const keepSection = keepSectionMatch ? keepSectionMatch[1] : '';
+
+        // Parse messages from each section
+        const messagesToCompact = this.parseMessageSection(compactSection);
+        const messagesToKeep = this.parseMessageSection(keepSection);
+
+        return {
+            messagesToCompact,
+            messagesToKeep,
+            originalChatUuid,
+            validationHash,
+            sessionId,
+            range,
+            from,
+            to
+        };
+    }
+
+    /**
+     * Parses a message section to extract individual messages
+     * @param {string} section - The section content to parse
+     * @returns {Array} Array of parsed message objects
+     */
+    static parseMessageSection(section) {
+        if (!section) return [];
+
+        const messages = [];
+        const messageRegex = /<(\w+) message number (\d+)>\n([\s\S]*?)\n<\/\1 message number \2>/g;
+        let match;
+
+        while ((match = messageRegex.exec(section)) !== null) {
+            const [, role, positionStr, content] = match;
+            const position = parseInt(positionStr, 10);
+
+            messages.push({
+                role,
+                position,
+                content: content.trim()
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Extracts just the metadata from a reference message without the message sections
+     * @param {string} referenceMessage - The reference message content to parse
+     * @returns {Object} Metadata object with original chat UUID, validation hash, session ID, and range information
+     */
+    static extractReferenceMessageMetadata(referenceMessage) {
+        const data = this.extractReferenceMessageData(referenceMessage);
+
+        return {
+            originalChatUuid: data.originalChatUuid,
+            validationHash: data.validationHash,
+            sessionId: data.sessionId,
+            range: data.range,
+            from: data.from,
+            to: data.to
+        };
+    }
+
+    /**
+     * Checks if a message is a reference message
+     * @param {string} message - The message content to check
+     * @returns {boolean} True if the message is a reference message
+     */
+    static isReferenceMessage(message) {
+        if (!message) return false;
+
+        // Check for key indicators of a reference message
+        return message.includes('# Compact Messages Reference') &&
+            message.includes('Original Chat UUID:') &&
+            message.includes('Session ID:');
+    }
+}
+
+module.exports = { ReferenceMessageUtils };

package/src/CompactChatUtils/index.js

@@ -0,0 +1,40 @@
+/**
+ * Component: CompactChatUtils Index
+ * Block-UUID: cd0a6091-edb6-4e92-9439-63dd8f6a6796
+ * Parent-UUID: 5ffa0338-b4fb-4968-908c-f23a26d4923b
+ * Version: 2.0.0
+ * Description: Entry point for CompactChatUtils that exports both ReferenceMessageUtils and CompactedMessageUtils methods directly for easier access.
+ * Language: JavaScript
+ * Created-at: 2025-12-07T00:10:05.123Z
+ * Authors: GLM-4.6 (v1.0.0), GLM-4.6 (v2.0.0)
+ */
+
+
+const { ReferenceMessageUtils } = require('./ReferenceMessageUtils');
+const { CompactedMessageUtils } = require('./CompactedMessageUtils');
+
+/**
+ * CompactChatUtils provides utilities for working with compacted messages in GitSense Chat.
+ * It includes functionality for parsing reference messages and formatting/parsing compacted messages.
+ */
+module.exports = {
+    // Export the classes for those who want to access them directly
+    ReferenceMessageUtils,
+    CompactedMessageUtils,
+    
+    // Export all methods from ReferenceMessageUtils directly
+    extractReferenceMessageData: ReferenceMessageUtils.extractReferenceMessageData,
+    parseMessageSection: ReferenceMessageUtils.parseMessageSection,
+    extractReferenceMessageMetadata: ReferenceMessageUtils.extractReferenceMessageMetadata,
+    isReferenceMessage: ReferenceMessageUtils.isReferenceMessage,
+    
+    // Export all methods from CompactedMessageUtils directly
+    formatCompactedMessage: CompactedMessageUtils.formatCompactedMessage,
+    extractCompactedMessageMetadata: CompactedMessageUtils.extractCompactedMessageMetadata,
+    extractCompactedMessageContent: CompactedMessageUtils.extractCompactedMessageContent,
+    validateCompactedMessageFormat: CompactedMessageUtils.validateCompactedMessageFormat,
+    isCompactedMessage: CompactedMessageUtils.isCompactedMessage,
+    isValidUUID: CompactedMessageUtils.isValidUUID,
+    isValidMessageRange: CompactedMessageUtils.isValidMessageRange,
+    isValidISOTimestamp: CompactedMessageUtils.isValidISOTimestamp
+};

package/src/ContextUtils.js

@@ -1,12 +1,12 @@
 /*
  * Component: ContextUtils
- * Block-UUID: a0b71292-b1cc-401a-8ce2-544a047b0fef
- * Parent-UUID: c018b1f9-2291-4bc9-9c4b-ab53a5db745e
- * Version: 1.3.0
+ * Block-UUID: 534c348d-a11f-4de6-ad15-f33068d51fb8
+ * Parent-UUID: a0b71292-b1cc-401a-8ce2-544a047b0fef
+ * Version: 1.4.0
  * Description: Provides utility functions for parsing context message sections to extract file details and code blocks, and for formatting content for LLM context.
  * Language: JavaScript
  * Created-at: 2025-05-09T01:36:20.107Z
- * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), Qwen 3 Coder 480B - Cerebras (v1.3.0)
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), Qwen 3 Coder 480B - Cerebras (v1.3.0), Qwen 3 Coder 480B - Cerebras (v1.4.0)
  */
 
 
@@ -77,6 +77,41 @@ function _createContextSummary(items, contentType) {
     return summary + "\n";
 }
 
+/**
+ * Extracts all context files from a given chat object.
+ * Iterates through chat messages, identifies context loader outputs,
+ * and parses them into individual file objects.
+ *
+ * @param {object} chat - The GitSense chat object.
+ * @returns {Array<object>} An array of parsed context file objects.
+ *                           Returns an empty array if no context files are found or on error.
+ */
+function getContextFiles(chat) {
+    const ChatUtils = require('./ChatUtils');
+    const contextFiles = [];
+    const messages = ChatUtils.getChatMessages(chat);
+
+    if (!Array.isArray(messages)) {
+        console.warn("getContextFiles: Provided chat object does not contain a valid messages array.");
+        return contextFiles;
+    }
+
+    messages.forEach(message => {
+        // Check if the message content is a context message
+        if (MessageUtils.isContextMessage(message.message)) {
+            try {
+                // Extract all context sections from the message content
+                const extractedFiles = extractContextSections(message.message);
+                contextFiles.push(...extractedFiles);
+            } catch (error) {
+                console.warn(`getContextFiles: Failed to extract context sections from message ID ${message.id}:`, error);
+            }
+        }
+    });
+
+    return contextFiles;
+}
+
 /**
  * Escapes backticks in code blocks to prevent premature termination of LLM-generated code blocks.
  * @param {string} content - The content string to escape.
@@ -351,6 +386,7 @@ function formatContextContent(items, contentType, contentOption) {
 module.exports = {
     parseContextSection,
     extractContextSections,
+    getContextFiles,
     extractContextItemsOverviewTableRows,
     formatContextContent,
 };

package/src/DomUtils.js

@@ -1,12 +1,12 @@
 /**
  * Component: DomUtils Helper Functions
- * Block-UUID: e85d4e1d-f45e-450b-a0f2-941af362c2be
- * Parent-UUID: fe462d17-e1c8-45d6-9fb0-f53322c9cda9
- * Version: 1.1.0
+ * Block-UUID: 9a8e8e8e-8b15-4346-bbfa-740e6a5d2d79
+ * Parent-UUID: 8a528728-ce54-4445-946d-1743fb4b16be
+ * Version: 1.3.1
  * Description: Provides helper functions for creating and manipulating DOM elements.
  * Language: JavaScript
- * Created-at: 2025-09-11T19:03:50.026Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ * Created-at: 2025-12-14T04:18:40.180Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), GLM-4.6 (v1.2.1), GLM-4.6 (v1.3.0), GLM-4.6 (v1.3.1)
  */
 
 
@@ -19,6 +19,7 @@ function createElement(type, params) {
     let {
         id,
         ariaLabel,
+        xmlns,
         role,
         html,
         text,
@@ -41,11 +42,15 @@ function createElement(type, params) {
         "data-message-role": dmr,
         attrs = {},
         dataset,
+        rows
     } = params;
 
     // Set standard attributes
     if (id != null) elem.id = id;
     if (ariaLabel) elem.setAttribute("aria-label", ariaLabel);
+    if (xmlns) elem.setAttribute("xmlns", xmlns);
+    if (params.viewBox) elem.setAttribute("viewBox", params.viewBox);
+    if (params.fill) elem.setAttribute("fill", params.fill);
     if (role) elem.setAttribute("role", role);
     if (placeholder) elem.setAttribute("placeholder", placeholder);
     if (cls || className) elem.setAttribute("class", cls || className);
@@ -53,6 +58,9 @@ function createElement(type, params) {
     if (title != null) elem.setAttribute("title", title);
     if (inputType) elem.setAttribute("type", inputType);
     if (name != null) elem.setAttribute("name", name);
+    if (params.width) elem.setAttribute("width", params.width);
+    if (params.height) elem.setAttribute("height", params.height);
+    if (params.stroke) elem.setAttribute("stroke", params.stroke);
     if (value != null) elem.value = value;
     if (checked != null && checked) elem.checked = true; // Use property for checked
     if (selected != null && selected) elem.selected = true; // Use property for selected
@@ -60,13 +68,21 @@ function createElement(type, params) {
     if (dmi != null) elem.setAttribute("data-message-id", dmi);
     if (dmr != null) elem.setAttribute("data-message-role", dmr);
     if (_for != null ) elem.setAttribute("for", _for);
+    if (params.strokeWidth) elem.setAttribute("stroke-width", params.strokeWidth);
+    if (params.strokeLinecap) elem.setAttribute("stroke-linecap", params.strokeLinecap);
+    if (params.strokeLinejoin) elem.setAttribute("stroke-linejoin", params.strokeLinejoin);
     if (colSpan != null) elem.colSpan = colSpan;
+    if (rows) elem.setAttribute("rows", params.rows);
 
     // Set content
     if (html != null) {
         if (typeof html === "object" && html instanceof Node) { // Ensure html is a Node
             elem.appendChild(html);
         } else if (typeof html === "string") {
+            // For SVG elements, use innerHTML to support path elements
+            if (type === 'svg' && params.innerHTML) {
+                elem.innerHTML = params.innerHTML;
+            }
             elem.innerHTML = html;
         }
     } else if (text != null) {
@@ -92,12 +108,12 @@ function createElement(type, params) {
         });
     }
 
-    // NEW: Set additional attributes from attrs object
+    // Set additional attributes from attrs object
     if (attrs && typeof attrs === 'object') {
         for (const [key, value] of Object.entries(attrs)) {
             if (value !== undefined && value !== null) {
                 // Skip if already set by standard properties or handled directly
-                if (!['id', 'class', 'role', 'aria-label', 'title', 'style', 'checked', 'selected', 'disabled', 'value', 'name', 'type', 'for'].includes(key) && !key.startsWith('data-')) {
+                if (!['id', 'class', 'role', 'aria-label', 'title', 'style', 'selected', 'disabled', 'value', 'name', 'type', 'for'].includes(key) && !key.startsWith('data-')) {
                     elem.setAttribute(key, value);
                 }
             }
@@ -210,14 +226,17 @@ const h = {
     },
     createLink: (params) => {
         const link = createElement("a", params);
-        // href and target are handled by createElement
-        if (params?.href) link.href = params.href; // Ensure href is set if provided
+        if (params?.href) link.href = params.href;
+        if (params?.target) link.target = params.target;
         return link;
     },
     createNav: (params) => {
         return createElement("nav", params);
     },
-    createOL: (params) => { // Added
+    createOl: (params) => {
+        return createElement("ol", params);
+    },
+    createOL: (params) => {
         return createElement("ol", params);
     },
     createOption: (params) => { // Added
@@ -233,13 +252,49 @@ const h = {
     createPre: (params) => {
         return createElement("pre", params);
     },
-    createSelect: (params) => { // Added
-        // name, disabled etc handled by createElement
-        return createElement("select", params);
+    createSelect: (params) => { 
+        // Extract value before creating the select element
+        const { value, ...selectParams } = params || {};
+        
+        // Create select element without the value initially
+        const select = createElement("select", selectParams);
+        
+        // Handle options array if provided
+        if (params && params.options && Array.isArray(params.options)) {
+            params.options.forEach(option => {
+                if (option && typeof option === 'object') {
+                    // Check if this option should be selected based on the value
+                    const isSelected = (value !== undefined && value !== null) && 
+                                      (option.value === value || 
+                                       (value === '' && option.value === '') ||
+                                       (value === null && option.value === null));
+                    
+                    const optionElement = createElement("option", {
+                        value: option.value,
+                        text: option.text,
+                        selected: isSelected || option.selected
+                    });
+                    select.appendChild(optionElement);
+                }
+            });
+        }
+        
+        // Set the value after options are added to ensure proper selection
+        if (value !== undefined && value !== null) {
+            select.value = value;
+        }
+        
+        return select;
     },
     createSpan: (params) => {
         return createElement("span", params);
     },
+    createSvg: (params) => {
+        // Create SVG element with xmlns attribute
+        const svgParams = { ...params, xmlns: "http://www.w3.org/2000/svg" };
+        const svg = createElement("svg", svgParams);
+        return svg;
+    },
     createStrong: (params) => { // Added
         return createElement("strong", params);
     },
@@ -252,6 +307,10 @@ const h = {
     createText: (text) => {
         return document.createTextNode(text);
     },
+    createTextarea: (params) => {
+        const textArea = createElement("textarea", params);
+        return textArea;
+    },
     createTextArea: (params) => {
         const textArea = createElement("textarea", params);
         return textArea;
@@ -450,6 +509,35 @@ const h = {
             })
             .join('');
     },
+    
+    /**
+     * Injects CSS styles into the document head.
+     * @param {string} cssString - The CSS string to inject.
+     * @param {string} [id] - Optional ID for the style element to prevent duplicates.
+     * @returns {HTMLStyleElement} The created or existing style element.
+     */
+    injectStyles: (cssString, id) => {
+        // If an ID is provided, check if styles with this ID already exist
+        if (id) {
+            const existingStyle = document.getElementById(id);
+            if (existingStyle) {
+                // Styles already injected, return the existing element
+                return existingStyle;
+            }
+        }
+
+        // Create a new style element
+        const styleElement = document.createElement('style');
+        if (id) {
+            styleElement.id = id;
+        }
+        styleElement.textContent = cssString;
+
+        // Append to the document head
+        document.head.appendChild(styleElement);
+
+        return styleElement;
+    },
 
     /**
      * Calculates the distance between an element's edge and the viewport's corresponding edge
@@ -480,6 +568,6 @@ const h = {
             return rect.left;
         }
     }
-}
+};
 
 module.exports = { h };

package/src/FormatterUtils.js

@@ -1,6 +1,6 @@
 /**
  * Component: Formatter Utilities
- * Block-UUID: 9b1e07bf-e92c-43c1-9ac0-5dacdb7ae618
+ * Block-UUID: 8512c809-87b0-4f90-af9d-b3dca204c4de
  * Parent-UUID: 9c07d12f-5a05-4402-99d2-85d872d7b2f7
  * Version: 1.0.0
  * Description: Utility functions for formatting content in GitSense Chat

package/src/GSToolBlockUtils.js

@@ -10,6 +10,8 @@
  */
 
 
+const GS_TOOL_BLOCK_TYPE = 'gs-tool';
+
 /**
  * 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".
@@ -28,6 +30,65 @@ function isToolBlock(content) {
     return false;
 }
 
+
+// TODO: Add JSDocs
+function getToolBlocksByTool(content, tool, CodeBlockUtils) {
+    const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(content, { silent: true });
+
+    return blocks.filter((block, index) => {
+        if (block.type !== GS_TOOL_BLOCK_TYPE)
+            return;
+
+        try {
+            const data = parseToolBlock(block.content);
+
+            if (data.tool === tool) {
+                block.index = index;
+                return block;
+            }
+        } catch(error) {
+            // FIXME: We need a more elegant way to identify examples. 
+            if (!content.includes(/Internal INTEGER IDs/)) {
+                console.warn(`Invalid tool block JSON: ${error.message}`);
+            }
+        }
+    });
+}
+
+// TODO: Add JSDocs
+function getToolBlockElemsByTool(dom, tool) {
+    const elems = dom.querySelectorAll('pre');
+    const toolBockElems = [];
+
+    for ( let i = 0; i < elems.length; i++ ) {
+        const elem = elems[i];
+        let content = elem.textContent;
+
+        // We need to strip out the first two lines since this is not part of the actual code
+        // block. These two lines are designed to make it easy to identify the language 
+        content = content.split('\n').slice(2).join('\n');
+
+        if (!isToolBlock(content)) 
+            continue;
+
+        try {
+            const data = parseToolBlock(content, { silent: true });
+
+            if (data.tool === tool)
+                toolBockElems.push(elem);
+        } catch(error) {
+            // FIXME: We need a more elegant way to identify examples. 
+            if (!content.match(/Internal INTEGER IDs/)) {
+                console.warn("getToolBlockElemsByTool: ",error.message);
+            }
+            continue; 
+        }
+    }
+
+    return toolBockElems;
+}
+
+
 /**
  * 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)
@@ -136,7 +197,7 @@ function replaceToolBlock(markdownContent, toolName, newToolData, CodeBlockUtils
     // 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) {
+        if (block.type === GS_TOOL_BLOCK_TYPE && block.toolData && block.toolData.tool === toolName) {
             targetBlockIndex = i;
             break; // Found the first matching tool block
         }
@@ -270,10 +331,14 @@ function detectAndFormatUnfencedToolBlock(messageContent) {
     };
 }
 
+
+
 module.exports = {
     isToolBlock,
     parseToolBlock,
     formatToolBlock,
     replaceToolBlock,
+    getToolBlocksByTool,
+    getToolBlockElemsByTool,
     detectAndFormatUnfencedToolBlock,
 }