@gitsense/gsc-utils 0.1.0

package/src/MessageUtils.js

@@ -0,0 +1,460 @@
+/**
+ * Component: MessageUtils
+ * Block-UUID: 01147ddf-320f-498a-a744-198d42a9d2ee
+ * Parent-UUID: fb0b40b3-ce0b-47e2-bb3e-b39092e9b829
+ * Version: 1.2.0
+ * Description: Utility functions for processing message files, including context message detection.
+ * Language: JavaScript
+ * Created-at: 2025-07-11T19:56:54.949Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0)
+ */
+
+
+const fs = require('fs');
+const path = require('path');
+const ANALYZE_MESSAGE_REGEXP = /^# Analyze - `([^`]+)`\n/;
+
+/**
+ * Extracts the role from the metadata section of a message file
+ * @param {string} metadata - The metadata section of the message file
+ * @returns {string} The extracted role
+ */
+function extractRole(metadata) {
+    const lines = metadata.split('\n');
+    for (const line of lines) {
+        if (line.trim().startsWith('; role:')) {
+            return line.trim().substring('; role:'.length).trim();
+        }
+    }
+    return 'user'; // Default to user if role is not found
+}
+
+/**
+ * Unescapes code blocks by removing forward slashes before backticks
+ * @param {string} content - The message content
+ * @returns {string} The content with unescaped code blocks
+ */
+function unescapeCodeBlocks(content) {
+    return content.replace(/\\(`+)/g, '$1');
+}
+
+/**
+ * Gets template messages from a specific message type directory
+ * @param {string} dirname- The directory containting the template messages directory
+ * @param {string} messageType - The type of messages to retrieve (e.g., 'notes', 'draft')
+ * @returns {Array} An array of message objects with role and content properties
+ */
+function getChatTemplateMessages(dirname, messageType) {
+    const messagesDir = path.join(dirname, messageType);
+    const messages = [];
+
+    try {
+        // Read all files in the directory
+        const files = fs.readdirSync(messagesDir);
+
+        // Sort files numerically (1.md, 2.md, etc.)
+        const sortedFiles = files.sort((a, b) => {
+            const numA = parseInt(a.split('.')[0]);
+            const numB = parseInt(b.split('.')[0]);
+            return numA - numB;
+        });
+
+        // Process each file
+        for (const file of sortedFiles) {
+            if (path.extname(file) === '.md') {
+                const filePath = path.join(messagesDir, file);
+                const fileContent = fs.readFileSync(filePath, 'utf8');
+
+                // Split by triple newline to separate metadata from content
+                const parts = fileContent.split('\n\n\n');
+
+                if (parts.length >= 2) {
+                    const metadata = parts[0];
+                    // Join all remaining parts in case there are other triple newlines in the content
+                    const content = parts.slice(1).join('\n\n\n').trim();
+
+                    const role = extractRole(metadata);
+                    const processedContent = unescapeCodeBlocks(content);
+
+                    messages.push({
+                        role,
+                        content: processedContent
+                    });
+                } else {
+                    // Handle case where there's no triple newline
+                    const role = extractRole(fileContent);
+                    messages.push({
+                        role,
+                        content: ''
+                    });
+                }
+            }
+        }
+
+        return messages;
+    } catch (error) {
+        console.error(`Error reading messages from ${messageType}:`, error);
+        return [];
+    }
+}
+
+/**
+ * Gets messages before a specific ID
+ * @param {string} model - The model to filter messages by
+ * @param {Object} message - The message object to start from
+ * @param {string} stopId - Optional ID to stop at
+ * @param {Array} messages - Optional array to accumulate messages
+ * @returns {Array} Array of messages
+ */
+function getMessagesBeforeId(model, message, stopId, messages = [], debug = false) {
+    if (!model)
+        throw new Error('MessageUtils: No model defined');
+
+    if (!message)
+        throw new Error('MessageUtils: No message defined');
+
+    const { role, id, kids, model: m } = message;
+
+    if (id === stopId) {
+        return messages;
+    }
+
+    if (!m || m === model) {
+        messages.push(message);
+    }
+
+    if (!kids || !kids.length) {
+        return messages;
+    }
+
+    return getMessagesBeforeId(model, kids[0], stopId, messages);
+}
+
+/**
+ * Gets a specific message by its ID from a chat tree.
+ * @param {Object} chatOrMessage - The root chat object or a message node to start searching from.
+ * @param {number|string} id - The ID of the message to find.
+ * @returns {Object|null} The found message object or null if not found.
+ */
+function getMessageById(chatOrMessage, id) {
+    // Use a stack for iterative depth-first search to avoid deep recursion issues
+    const stack = [];
+
+    // Determine starting point: root chat object or a specific message node
+    if (chatOrMessage && chatOrMessage.messages && Array.isArray(chatOrMessage.messages)) {
+        // If it's the root chat object, start with its top-level messages
+        stack.push(...chatOrMessage.messages);
+    } else if (chatOrMessage && chatOrMessage.id) {
+        // If it's a message node itself
+        stack.push(chatOrMessage);
+    } else {
+        // Invalid input
+        console.error("getMessageById: Invalid input provided.", chatOrMessage);
+        return null;
+    }
+
+    while (stack.length > 0) {
+        const currentMessage = stack.pop();
+
+        if (!currentMessage) continue; // Skip if undefined/null somehow got pushed
+
+        // Check if the current message is the one we're looking for
+        // Ensure type consistency for comparison if needed (e.g., both numbers or both strings)
+        if (currentMessage.id == id) { // Use == for potential type coercion if IDs might be numbers or strings
+            return currentMessage;
+        }
+
+        // Add children to the stack to search deeper
+        if (currentMessage.kids && Array.isArray(currentMessage.kids)) {
+            // Push children in reverse order to maintain depth-first order
+            for (let i = currentMessage.kids.length - 1; i >= 0; i--) {
+                stack.push(currentMessage.kids[i]);
+            }
+        }
+    }
+
+    // Message not found
+    return null;
+}
+
+/**
+ * Gets the last message in a specific conversation thread (follows the first child path).
+ * @param {Object} message - The message to start from.
+ * @returns {Object} The last message in the thread.
+ */
+function getLastMessage(message) {
+    let current = message;
+    while (current && current.kids && current.kids.length > 0) {
+        // Assuming the main thread follows the first child
+        current = current.kids[0];
+    }
+    return current;
+}
+
+/**
+ * Recursively finds all messages in a chat tree that match a given filter function.
+ * Uses an iterative approach with a stack to prevent deep recursion errors.
+ *
+ * @param {Object} rootNode - The starting node (can be the root chat object with a `messages` array, or any message node).
+ * @param {function(Object): boolean} filterFn - A function that takes a message object and returns true if it matches the criteria.
+ * @returns {Array<Object>} An array of message objects that matched the filter.
+ */
+function findMessages(rootNode, filterFn) {
+    const matchingMessages = [];
+    const stack = [];
+
+    // Initialize stack based on rootNode type
+    if (rootNode && rootNode.messages && Array.isArray(rootNode.messages)) {
+        // If it's the root chat object, start with its top-level messages (in reverse for stack processing)
+        for (let i = rootNode.messages.length - 1; i >= 0; i--) {
+            stack.push(rootNode.messages[i]);
+        }
+    } else if (rootNode && rootNode.id) {
+        // If it's a message node itself
+        stack.push(rootNode);
+    } else {
+        console.warn("findMessages: Invalid rootNode provided.", rootNode);
+        return []; // Return empty array for invalid input
+    }
+
+    while (stack.length > 0) {
+        const currentMessage = stack.pop();
+
+        if (!currentMessage) continue; // Skip if undefined/null
+
+        // Apply the filter function to the current message
+        try {
+            if (filterFn(currentMessage)) {
+                matchingMessages.push(currentMessage);
+            }
+        } catch (error) {
+             console.error("Error executing filter function on message:", currentMessage.id, error);
+             // Decide whether to skip this message or re-throw, depending on desired robustness
+        }
+
+
+        // Add children to the stack to search deeper (push in reverse order to maintain logical traversal order)
+        if (currentMessage.kids && Array.isArray(currentMessage.kids)) {
+            for (let i = currentMessage.kids.length - 1; i >= 0; i--) {
+                stack.push(currentMessage.kids[i]);
+            }
+        }
+    }
+
+    return matchingMessages;
+}
+
+/**
+ * Deletes messages by their IDs from a nested chat structure.
+ * Modifies the structure in place or returns a new root depending on input.
+ *
+ * @param {Object} rootNode - The root node of the chat structure. This can be the main chat object
+ *                            (containing a `messages` array) or a specific message node.
+ * @param {Array<number|string>} idsToDeleteArray - An array of message IDs to delete.
+ * @returns {Object} The modified rootNode. If the provided rootNode itself was deleted
+ *                   (and it was a message node), this function's behavior might need adjustment
+ *                   based on caller expectations (e.g., return null or throw error).
+ *                   Currently assumes the rootNode itself is not in idsToDeleteArray if it's a message node.
+ * @throws {Error} If idsToDeleteArray is not an array.
+ */
+function deleteMessagesByIds(rootNode, idsToDeleteArray) {
+    if (!Array.isArray(idsToDeleteArray)) {
+        throw new Error("idsToDeleteArray must be an array.");
+    }
+    if (!rootNode) {
+        console.warn("deleteMessagesByIds: rootNode is null or undefined.");
+        return rootNode; // Return unchanged if root is invalid
+    }
+
+    const idsToDeleteSet = new Set(idsToDeleteArray);
+
+    // Handle based on whether rootNode is the main chat object or a message node
+    if (rootNode.messages && Array.isArray(rootNode.messages)) {
+        // rootNode is the main chat object containing the top-level messages array
+        rootNode.messages = _processNodeListForDeletion(rootNode.messages, null, idsToDeleteSet);
+    } else if (rootNode.id) {
+        // rootNode is a message node itself.
+        // Check if the root message node itself needs deletion (this case is complex)
+        if (idsToDeleteSet.has(rootNode.id)) {
+            // This scenario is ambiguous. Deleting the root node passed in means
+            // the reference becomes invalid. The caller needs to handle this.
+            // For now, we'll log a warning and potentially return null or an empty structure.
+            // A safer approach is for the caller to ensure the root isn't deleted,
+            // or to always pass the main chat object.
+            console.warn(`deleteMessagesByIds: The provided rootNode (ID: ${rootNode.id}) itself is marked for deletion. Returning null.`);
+            // To properly handle this, we'd need to return the *children* of the deleted root,
+            // but the function signature returns the 'modified rootNode'.
+            // Returning null might be the clearest signal.
+             const children = rootNode.kids || [];
+             const parentIdForOrphanedChildren = 0; // Assuming root's parent is 0
+             const processedChildren = _processNodeListForDeletion(children, null, idsToDeleteSet);
+             for (const child of processedChildren) {
+                 child.parent_id = parentIdForOrphanedChildren;
+             }
+             // This isn't ideal as it returns an array, not the expected rootNode object.
+             // Returning null might be the clearest signal.
+             return null; // Indicate the root was deleted.
+        }
+        // Process the children of the root message node
+        rootNode.kids = _processNodeListForDeletion(rootNode.kids || [], rootNode, idsToDeleteSet);
+    } else {
+        console.warn("deleteMessagesByIds: Invalid rootNode structure.", rootNode);
+    }
+
+    return rootNode;
+}
+
+/**
+ * Recursively processes a list of message nodes, deleting specified messages
+ * and re-parenting their children.
+ *
+ * @param {Array<Object>} nodeList - The list of message nodes to process.
+ * @param {Object|null} parentNode - The parent node of the current list (null for root messages).
+ * @param {Set<number|string>} idsToDeleteSet - A Set containing the IDs of messages to delete.
+ * @returns {Array<Object>} A new list of nodes with specified messages removed and children re-parented.
+ * @private
+ */
+function _processNodeListForDeletion(nodeList, parentNode, idsToDeleteSet) {
+    if (!nodeList || nodeList.length === 0) {
+        return [];
+    }
+
+    const newNodelist = [];
+    // Determine the correct parent ID for children of deleted nodes
+    // Assuming 0 or null is used for top-level messages if parentNode is the root chat object
+    const parentIdForOrphanedChildren = parentNode ? parentNode.id : 0;
+
+    for (const node of nodeList) {
+        if (idsToDeleteSet.has(node.id)) {
+            // Node needs to be deleted
+            const children = node.kids || [];
+            // Recursively process the children of the deleted node *before* adding them
+            // Pass the *original parent* of the deleted node to maintain the level
+            const processedChildren = _processNodeListForDeletion(children, parentNode, idsToDeleteSet);
+
+            // Re-parent the processed children
+            for (const child of processedChildren) {
+                child.parent_id = parentIdForOrphanedChildren;
+                // Optional: Adjust child.level if necessary, though level might become less meaningful
+                // child.level = parentNode ? parentNode.level + 1 : 0;
+            }
+            // Add the re-parented children directly to the new list, effectively skipping the deleted node
+            newNodelist.push(...processedChildren);
+
+        } else {
+            // Node is kept
+            // Recursively process the children of the *kept* node
+            node.kids = _processNodeListForDeletion(node.kids || [], node, idsToDeleteSet);
+            // Add the processed node (with potentially modified kids) to the new list
+            newNodelist.push(node);
+        }
+    }
+
+    return newNodelist;
+}
+
+/**
+ * Determines the type of message content based on specific prefixes.
+ * @param {string} messageContent - The content of the message.
+ * @returns {'overview-context'|'file-content-context'|'analyze-message'|'regular'} The type of the message content.
+ */
+function getMessageContentType(messageContent) {
+    if (typeof messageContent !== 'string') {
+        return 'regular'; // Handle non-string input gracefully
+    }
+    const trimmedContent = messageContent.trimStart(); // Check from the beginning, ignoring leading whitespace
+    if (trimmedContent.startsWith('## FILE CONTENT')) {
+        return 'file-content-context';
+    } else if (trimmedContent.startsWith('## OVERVIEW')) {
+        return 'overview-context';
+    } else if (trimmedContent.startsWith('## Context Items Overview\n\nThis section provides')) {
+        return 'context-items-overview';
+    } else if (trimmedContent.match(ANALYZE_MESSAGE_REGEXP)) {
+        return 'analyze-message';
+    } else {
+        return 'regular';
+    }
+}
+
+/**
+ * Checks if a message is a context message (overview or file content).
+ * @param {string} messageContent - The content of the message.
+ * @returns {boolean} True if the message is a context message, false otherwise.
+ */
+function isContextMessage(messageContent) {
+    const type = getMessageContentType(messageContent);
+    return type === 'overview-context' || type === 'file-content-context';
+}
+
+function isContextItemsOverviewMessage(messageContent) {
+    const type = getMessageContentType(messageContent);
+    return type === 'context-items-overview';
+}
+
+function isAnalyzeMessage(messageContent) {
+    const type = getMessageContentType(messageContent);
+    return type === 'analyze-message';
+}
+
+/**
+ * Checks if a message is the final "New Analyzer Instructions" message.
+ * @param {string} messageContent - The content of the message.
+ * @param {boolean} strict - Enable or disable strict parsing
+ * @returns {boolean} True if the message is the new analyzer instructions message, false otherwise.
+ */
+function isNewAnalyzerInstructionsMessage(messageContent, strict = true) {
+    if (typeof messageContent !== 'string')
+        return false;
+
+    const trimmedMessage = messageContent.trimStart()
+    const header = '# New Analyzer Instructions';
+
+    if (strict) {
+        // In strict mode, we need the first list to contain the header
+        return trimmedMessage.startsWith(header);
+    } else {
+        // LLMs are instructed to always start with the header but they don't always
+        // comply so we will need to find the header and check the next line to make
+        // sure it has a unique identiifer
+        const lines = trimmedMessage.split('\n');
+        const newAnalyzerHeaderIndex = lines.indexOf(header);
+
+        if (newAnalyzerHeaderIndex === -1)
+            return false;
+
+        const analyzerId = lines[newAnalyzerHeaderIndex+1];
+
+        if (analyzerId.split('::').length === 3) {
+            return true;
+        }
+
+        return false;
+    }
+}
+
+function parseAnalyzeMessage(messageContent) {
+    const match = messageContent.match(ANALYZE_MESSAGE_REGEXP);
+
+    if (!match || match.length !== 2)
+        return {};
+
+    const uniqueAnalyzerId = match[1];
+    const [ analyzer, content, instructions ] = uniqueAnalyzerId.split('::');
+
+    return { id: uniqueAnalyzerId, analyzer, content, instructions };
+}
+
+module.exports = {
+    deleteMessagesByIds,
+    getChatTemplateMessages,
+    getMessagesBeforeId,
+    getMessageById,
+    getLastMessage,
+    getMessageContentType,
+    isNewAnalyzerInstructionsMessage,
+    findMessages,
+    isAnalyzeMessage,
+    isContextMessage,
+    isContextItemsOverviewMessage,
+    parseAnalyzeMessage
+};

package/src/PatchUtils/constants.js

@@ -0,0 +1,72 @@
+/**
+ * Component: PatchUtils Constants
+ * Block-UUID: c6747054-2c8b-461f-910d-0fd725d9a350
+ * Parent-UUID: 32adc00e-7509-4219-8e40-6c1319371db9
+ * Version: 2.0.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)
+ */
+
+
+// Regex to parse context/deletion/addition lines with line numbers
+// Captures: 1: diff prefix (' ', '-', or '+'), 2: line number, 3: content after 'NNN: '
+const CONTENT_LINE_REGEX = /^([ +-])\s*[-+]*(\d+):\s?(.*)$/;
+
+// Regex to parse hunk headers
+// Captures: 1: old_start, 2: old_count (optional), 3: new_start, 4: new_count (optional)
+const HUNK_HEADER_REGEX = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+// Regex to detect line number prefixes (e.g., "  12: ")
+const LINE_NUMBER_PREFIX_REGEX = /^\s*\d+:\s/;
+
+// Minimum confidence threshold for fuzzy matching
+const FUZZY_MATCH_THRESHOLD = 0.7;
+
+// Maximum number of alternative matches to consider
+const MAX_ALTERNATIVE_MATCHES = 3;
+
+// Sliding window size for fuzzy matching
+const DEFAULT_SLIDING_WINDOW_SIZE = 3;
+
+// Maximum context lines to use for fuzzy matching
+// If context is longer than this, we'll use a sliding window approach
+const MAX_CONTEXT_LINES_FOR_DIRECT_MATCH = 10;
+
+// Patch markers
+const PATCH_START_MARKER = '# --- PATCH START MARKER ---';
+const PATCH_END_MARKER = '# --- PATCH END MARKER ---';
+
+// Patch metadata header
+const PATCH_METADATA_HEADER = '# Patch Metadata';
+
+// Required metadata fields
+const REQUIRED_METADATA_FIELDS = [
+    'Source-Block-UUID',
+    'Target-Block-UUID',
+    'Source-Version',
+    'Target-Version',
+    'Description',
+    'Authors'
+];
+
+// Diff file headers
+const ORIGINAL_FILE_HEADER = '--- Original';
+const MODIFIED_FILE_HEADER = '+++ Modified';
+
+module.exports = {
+    CONTENT_LINE_REGEX,
+    HUNK_HEADER_REGEX,
+    LINE_NUMBER_PREFIX_REGEX,
+    FUZZY_MATCH_THRESHOLD,
+    MAX_ALTERNATIVE_MATCHES,
+    DEFAULT_SLIDING_WINDOW_SIZE,
+    MAX_CONTEXT_LINES_FOR_DIRECT_MATCH,
+    PATCH_START_MARKER,
+    PATCH_END_MARKER,
+    PATCH_METADATA_HEADER,
+    REQUIRED_METADATA_FIELDS,
+    ORIGINAL_FILE_HEADER,
+    MODIFIED_FILE_HEADER
+};