@gitsense/gsc-utils 0.1.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@gitsense/gsc-utils",
+  "version": "0.1.0",
+  "description": "Utilities for GitSense Chat (GSC)",
+  "main": "dist/gsc-utils.cjs.js",
+  "module": "dist/gsc-utils.esm.js",
+  "browser": "dist/gsc-utils.cjs.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "chat",
+    "code-blocks",
+    "patches",
+    "markdown",
+    "parsing"
+  ],
+  "author": "GitSense Team",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "jest": "^29.7.0",
+    "rollup": "^4.9.6"
+  }
+}

package/src/AnalysisBlockUtils.js

@@ -0,0 +1,151 @@
+/**
+ * Component: AnalysisBlockUtils
+ * Block-UUID: df4a5c56-bcee-4e83-989f-056b0d20005b
+ * Parent-UUID: 2a1b8c5d-e0f3-4a1c-8d7e-5e6f0a9b1c2e
+ * Version: 1.2.0
+ * Description: Provides utilities for identifying, parsing, and validating structured analysis blocks, including specific types like Overview (Short/Long/Tiny). These blocks typically follow a specific Markdown format generated by LLMs.
+ * Language: JavaScript
+ * Created-at: 2025-04-20T04:26:47.000Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0)
+ */
+
+
+/**
+ * Checks for the `# Gitsense Chat Analysis` line
+ * @param {string} content - The raw content string to check.
+ * @returns {boolean} True if the content starts with the overview headers, false otherwise.
+ */
+function isAnalysisBlock(content) {
+    if (typeof content !== 'string') {
+        return false;
+    }
+
+    const trimmedContent = content.trimStart();
+    return trimmedContent.startsWith('# GitSense Chat Analysis\n');
+}
+
+/**
+ * Determines the type of overview block based on its starting header.
+ * @param {string} content - The raw content string.
+ * @returns analysis block type or null if not recognized.
+ */
+function getAnalysisBlockType(content) {
+    if (typeof content !== 'string') {
+        return null;
+    }
+    const lines = content.split('\n');
+
+    // The first header 2 line contains the analyze type
+    const typeLine = lines.find(line => line.startsWith('## ')) || '';
+
+    if (typeLine)
+        return typeLine.trim().split('## ').pop().toLowerCase();
+
+    return null;
+}
+
+/**
+ * Parses the metadata from a structured analysis block content.
+ * Assumes metadata is presented as a Markdown list: '*   **Field:** Value'.
+ * Handles single-line values primarily. Multi-line values might require adjustments.
+ * @param {string} content - The raw content of the analysis block.
+ * @returns {Object | null} An object containing the extracted metadata fields (e.g., { 'Chat ID': '...', 'Repository': '...' }) or null if parsing fails or no fields are found.
+ */
+function parseOverviewMetadata(content) {
+    if (!isAnalysisBlock(content)) {
+        return null; // Not an overview block
+    }
+
+    const metadata = {};
+    const lines = content.split('\n');
+
+    // Regex to capture "Field Name" and "Value" from lines like '*   **Field Name: ** Value'
+    const fieldRegex = /^\*\s+\*\*([\w\s.-]+):\*\*\s+(.*)$/;
+    let foundList = false;
+    let currentKey = null; // For potential multi-line handling in the future
+
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+
+        // Skip empty lines before the list starts
+        if (!trimmedLine && !foundList) {
+            continue;
+        }
+        // If we found the list and encounter an empty line, assume the list ended.
+        if (!trimmedLine && foundList) {
+             break;
+        }
+
+        const match = trimmedLine.match(fieldRegex);
+
+        if (match) {
+            foundList = true;
+            const key = match[1].trim(); // e.g., "Chat ID", "Summarized At"
+            const value = match[2].trim();
+            metadata[key] = key.includes('ID') ? parseInt(value) : value;
+            currentKey = key; // Track the last successfully parsed key
+        } else if (foundList) {
+            // FIXME: This is currently not supported. Should we remove it?
+            //
+            // Handle potential multi-line values (simple append approach)
+            // Only append if the line doesn't look like another list item or header
+            if (currentKey && !trimmedLine.startsWith('*') && !trimmedLine.startsWith('#')) {
+                 // Check if the field is one known to potentially be multi-line
+                 const multiLineFields = ['Summary', 'Key Functionality', 'Keywords'];
+                 if (multiLineFields.includes(currentKey)) {
+                    metadata[currentKey] += '\n' + trimmedLine; // Append the raw trimmed line
+                 } else {
+                     // If not a known multi-line field, assume the list ended here.
+                     break;
+                 }
+            } else {
+                 // If it looks like another list item or something else, stop parsing this block's list.
+                 break;
+            }
+        }
+        // Ignore lines before the list starts that don't match the pattern
+    }
+
+    // Basic check if any metadata was actually parsed
+    if (Object.keys(metadata).length === 0) {
+        // console.warn("AnalysisBlockUtils: Could not parse any metadata fields from the block.");
+        return null;
+    }
+
+    return metadata;
+}
+
+/**
+ * Validates the parsed analysis metadata object.
+ * Checks for the presence and basic type of required fields.
+ * @param {Object | null} metadata - The metadata object returned by parseOverviewMetadata.
+ * @returns {{isValid: boolean, errors: Array<string>}} Validation result.
+ */
+function validateAnalysisMetadata(metadata) {
+    const errors = [];
+    const requiredFields = [ 'Chat ID' ];
+
+    if (!metadata || typeof metadata !== 'object') {
+        return { isValid: false, errors: ['Metadata object is null or invalid.'] };
+    }
+
+    // Check for presence and non-empty string values
+    for (const field of requiredFields) {
+        if (!metadata[field]) {
+            errors.push(`Missing or empty required field: "${field}".`);
+        }
+    }
+
+    return {
+        isValid: errors.length === 0,
+        errors: errors
+    };
+}
+
+
+module.exports = { 
+    isAnalysisBlock,
+    getAnalysisBlockType,
+    parseOverviewMetadata,
+    validateAnalysisMetadata
+};

package/src/ChatUtils.js

@@ -0,0 +1,126 @@
+/**
+ * Component: ChatUtils
+ * Block-UUID: fdbd7f40-a1ee-4c07-bbfe-bbac53efd2c8
+ * Parent-UUID: c981830e-3472-4d2b-b6d4-37b8e661ef4c
+ * Version: 1.3.0
+ * Description: Provides utility functions for analyzing and classifying chat sessions based on message content and structure.
+ * Language: JavaScript
+ * Created-at: 2025-07-11T19:54:25.519Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0), Gemini 2.5 Flash Thinking (v1.2.1), Gemini 2.5 Flash Thinking (v1.3.0)
+ */
+
+
+const { getMessagesBeforeId } = require('./MessageUtils');
+
+/**
+ * Internal helper function to determine if a chat session matches a specific pattern.
+ * Checks message count, structure, and specific starting strings for the first two assistant messages.
+ * @param {object} chat - The chat object, expected to have `chat.messages[0]` containing the message array.
+ * @param {string} model - The model.
+ * @param {string} firstAssistantMsgStart - The string the first assistant message must start with.
+ * @returns {boolean} True if the chat matches the pattern, false otherwise.
+ * @private
+ */
+function checkChatTypePattern(chat, model, firstAssistantMsgStart) {
+    if (!chat || !Array.isArray(chat.messages) || !chat.messages.length) {
+        console.error("ChatUtils: Invalid chat or message structure provided.");
+        return false;
+    }
+
+    const messages = getChatMessages(chat, model);
+
+    /*
+     * Common checks for chat type classification:
+     * 1) Must be 4 or more messages.
+     * 2) First assistant message must start with a specific string (passed as parameter).
+     * 3) Second assistant message must be instructions or context.
+     *    - Instructions start with '# User Instructions\n'
+     *    - Context starts with '## FILE CONTENT - ' or '## OVERVIEW - '
+     */
+
+    // Filter assistant messages
+    const assistantMessages = messages.filter(m => m.role === 'assistant');
+
+    // First assistant message check
+    if (!assistantMessages[0].message || !assistantMessages[0].message.startsWith(firstAssistantMsgStart)) {
+        return false;
+    }
+
+    return true;
+}
+
+
+/**
+ * Determines if the current chat session appears to be a "New Analyzer" session.
+ * @param {object} chat - The chat object.
+ * @returns {boolean} True if the chat is of type 'new-analyzer'
+ */
+function isNewAnalyzerChat(chat, model) {
+    return chat.type === 'new-analyzer';
+}
+
+/**
+ * Determines if the current chat session appears to be an "Analyze" session.
+ * @param {object} chat - The chat object.
+ * @param {string} model - Optional model.
+ * @returns {boolean} True if the chat matches the Overview Builder pattern, false otherwise.
+ */
+function isAnalyzeChat(chat, model) {
+    return chat.type === 'analyze';
+}
+
+/**
+ * Determines if the current chat session appears to be an "Ask" session.
+ * @param {object} chat - The chat object.
+ * @param {string} model - Optional model.
+ * @returns {boolean} True if the chat matches the Ask pattern, false otherwise.
+ */
+function isAskChat(chat, model) {
+    return checkChatTypePattern(chat, model || chat.main_model, '# Ask\n');
+}
+
+/**
+ * Determines if the current chat session appears to be a "Plan Chat" session.
+ * @param {object} chat - The chat object.
+ * @param {string} model - Optional model.
+ * @returns {boolean} True if the chat matches the Plan Chat pattern, false otherwise.
+ */
+function isPlanChat(chat, model) {
+    // Note: Original code checked for '# Plan'. If '# Context Builder Assistant' was intended, update the string below.
+    return checkChatTypePattern(chat, model || chat.main_model, '# Plan\n');
+}
+
+/**
+ * Determines if the current chat session appears to be a "Code Chat" session.
+ * @param {object} chat - The chat object.
+ * @param {string} model - Optional model.
+ * @returns {boolean} True if the chat matches the Code Chat pattern, false otherwise.
+ */
+function isCodeChat(chat, model) {
+    // Note: Original code checked for '# Coding Assistant'. If '# Code - Coding Assistant' was intended, update the string below.
+    return checkChatTypePattern(chat, model || chat.main_model, '# Code\n');
+}
+
+/**
+ * Retrieves all messages from a chat session.
+ * @param {object} chat - The chat object, expected to have `chat.messages[0]` containing the message array.
+ * @param {string} model - Optional model.
+ * @returns {Array<object>} An array of message objects, or an empty array if chat or messages are invalid.
+ */
+function getChatMessages(chat, model) {
+    if (!chat || !Array.isArray(chat.messages) || !chat.messages.length) {
+        console.error("ChatUtils: Invalid chat or message structure provided for getChatMessages.");
+        return [];
+    }
+    // Setting before id to null will retrieve all messages
+    return getMessagesBeforeId(model || chat.main_model, chat.messages[0], null);
+}
+
+module.exports = {
+    isAskChat,
+    isNewAnalyzerChat,
+    isAnalyzeChat,
+    isPlanChat,
+    isCodeChat,
+    getChatMessages
+};

package/src/CodeBlockUtils/blockExtractor.js

@@ -0,0 +1,277 @@
+/**
+ * Component: CodeBlockUtils Block Extractor
+ * Block-UUID: efacd230-2ced-4910-a417-efc536ca4c68
+ * Parent-UUID: 4b1a9f2c-8d3e-4c5a-9b1f-0e2d7a3c8b4d
+ * Version: 1.2.0
+ * Description: Provides functions to find and match markdown code fences (```) to identify block boundaries, and extract blocks with UUIDs.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T15:55:49.293Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0)
+ */
+
+
+/**
+ * Finds all opening and closing code fence positions using a line-by-line approach
+ * @param {string} text - The input text
+ * @returns {Object} Object containing arrays of opening and closing fence positions: { openingPositions: Array, closingPositions: Array }
+ */
+function findAllCodeFences(text) {
+    const openingPositions = [];
+    const closingPositions = [];
+
+    // Split text into lines for processing
+    const lines = text.split('\n');
+    let inCodeBlock = false;
+    let currentOpeningFence = null;
+    let linePosition = 0;
+
+    // Process each line
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+
+        // Check for opening fence (only if not already in a code block)
+        if (!inCodeBlock) {
+            // Match opening fence with or without language specifier
+            const openingMatch = trimmedLine.match(/^```([a-zA-Z-]*)$/);
+            if (openingMatch) {
+                inCodeBlock = true;
+                const fencePosition = linePosition + line.indexOf('```');
+                currentOpeningFence = {
+                    position: fencePosition,
+                    language: openingMatch[1].trim().toLowerCase() || "unknown",
+                    length: openingMatch[0].length
+                };
+                openingPositions.push(currentOpeningFence);
+            }
+        }
+        // Check for closing fence (only if in a code block)
+        else if (inCodeBlock) {
+            // Match closing fence (exactly ```)
+            if (trimmedLine === '```') {
+                inCodeBlock = false;
+                const fencePosition = linePosition + line.indexOf('```');
+                closingPositions.push({
+                    position: fencePosition,
+                    length: 3
+                });
+                currentOpeningFence = null;
+            }
+        }
+
+        // Update line position for next iteration
+        linePosition += line.length + 1; // +1 for the newline character
+    }
+
+    // If we reach the end and still have an open code block, it's incomplete
+    // We don't add a closing position for it
+
+    return {
+        openingPositions,
+        closingPositions
+    };
+}
+
+
+/**
+ * Matches opening and closing fences to identify complete and incomplete blocks
+ * @param {string} text - The input text
+ * @param {Array} openingPositions - Array of opening fence objects { position, language, length }
+ * @param {Array} closingPositions - Array of closing fence objects { position, length }
+ * @returns {Object} Object containing: { completeBlocks: Array, incompleteBlocks: Array, warnings: Array }
+ */
+function matchFencesAndExtractBlocks(text, openingPositions, closingPositions) {
+    const completeBlocks = [];
+    const incompleteBlocks = [];
+    const warnings = [];
+
+    // Create a copy of closing positions that we can modify
+    const availableClosingPositions = [...closingPositions];
+
+    // Sort opening and closing positions by their position in the text
+    const sortedOpenings = [...openingPositions].sort((a, b) => a.position - b.position);
+    availableClosingPositions.sort((a, b) => a.position - b.position);
+
+    // Process all opening fences in order
+    let openingIndex = 0;
+    let closingIndex = 0; // Tracks the next available closing fence to consider
+
+    while (openingIndex < sortedOpenings.length) {
+        const currentOpening = sortedOpenings[openingIndex];
+
+        // Find the next closing fence that comes *after* this opening fence ends
+        let matchingClosingIndex = -1;
+        for (let i = closingIndex; i < availableClosingPositions.length; i++) {
+            if (availableClosingPositions[i].position > currentOpening.position + currentOpening.length -1) { // Ensure closing is strictly after opening
+                matchingClosingIndex = i;
+                break;
+            }
+        }
+
+        if (matchingClosingIndex !== -1) {
+            // Found a potential matching closing fence
+            const matchingClosing = availableClosingPositions[matchingClosingIndex];
+
+            // Check if there's another opening fence before this closing fence
+            let nestedOpeningFound = false;
+            if (openingIndex + 1 < sortedOpenings.length) {
+                if (sortedOpenings[openingIndex + 1].position < matchingClosing.position) {
+                    // This indicates a likely nested structure or potentially malformed input.
+                    // For simplicity in this extractor, we'll treat the current opening as incomplete
+                    // if a new opening starts before its potential closer.
+                    // A more sophisticated parser might handle nesting.
+                    // nestedOpeningFound = true; // Uncomment if handling nesting differently
+                }
+            }
+
+            // If not nested (or handling nesting differently), proceed
+            if (!nestedOpeningFound) {
+                 // Check if there's any content between the fences (excluding only whitespace)
+                const blockContent = text.substring(
+                    currentOpening.position + currentOpening.length,
+                    matchingClosing.position
+                );
+
+                // Only consider it a valid block if there's non-whitespace content or it's explicitly empty
+                 if (blockContent.trim().length > 0 || blockContent.length === 0) { // Allow empty blocks like ```\n```
+                    completeBlocks.push({
+                        opening: currentOpening,
+                        closing: matchingClosing,
+                        incomplete: false
+                    });
+
+                    // Consume this closing fence and advance the closing index
+                    closingIndex = matchingClosingIndex + 1;
+                } else {
+                    // Block contains only whitespace - treat as potentially malformed or skip
+                     warnings.push({
+                        position: currentOpening.position,
+                        type: 'whitespace_only_block',
+                        message: `Code block starting at position ${currentOpening.position} contains only whitespace.`
+                    });
+                     // Don't consume the closing fence yet, let the next opening try to pair with it
+                }
+            } else {
+                 // Handle nested/malformed case - treat current opening as incomplete for now
+                 incompleteBlocks.push({
+                    opening: currentOpening,
+                    incomplete: true
+                });
+                 warnings.push({
+                    position: currentOpening.position,
+                    type: 'potentially_nested_or_malformed',
+                    message: `Potentially nested or malformed block structure starting at position ${currentOpening.position}. Treating as incomplete.`
+                });
+            }
+
+        } else {
+            // No matching closing fence found for this opening fence - this is an incomplete block
+            // Check if there's actual content after the opening fence
+            const remainingContent = text.substring(currentOpening.position + currentOpening.length);
+            if (remainingContent.trim().length > 0) {
+                 incompleteBlocks.push({
+                    opening: currentOpening,
+                    incomplete: true
+                });
+                 warnings.push({
+                    position: currentOpening.position,
+                    type: 'incomplete_block',
+                    message: `Incomplete code block found starting at position ${currentOpening.position}. Missing closing fence.`
+                });
+            } else {
+                 // Opening fence at the very end of the file with nothing after it. Ignore.
+                 warnings.push({
+                    position: currentOpening.position,
+                    type: 'trailing_opening_fence',
+                    message: `Opening code fence found at the end of the text with no content after it at position ${currentOpening.position}.`
+                });
+            }
+        }
+
+        // Move to the next opening fence
+        openingIndex++;
+    }
+
+     // Check for any remaining closing fences that weren't matched (might indicate ``` outside blocks)
+     if (closingIndex < availableClosingPositions.length) {
+         for (let i = closingIndex; i < availableClosingPositions.length; i++) {
+             warnings.push({
+                 position: availableClosingPositions[i].position,
+                 type: 'unmatched_closing_fence',
+                 message: `Found an unmatched closing code fence at position ${availableClosingPositions[i].position}.`
+             });
+         }
+     }
+
+
+    return { completeBlocks, incompleteBlocks, warnings };
+}
+
+/**
+ * Extracts all code blocks with their Block-UUIDs from a message
+ * @param {string} messageText - The message text
+ * @returns {Array} Array of objects with code, language, blockUUID, startIndex, endIndex
+ */
+function extractCodeBlocksWithUUIDs(messageText) {
+    if (!messageText || typeof messageText !== 'string') {
+        return [];
+    }
+
+    const codeBlocks = [];
+    // Improved regex to handle various code block formats
+    const codeBlockRegex = /```(\w+)?\s*\n([\s\S]*?)```/g;
+
+    let match;
+    while ((match = codeBlockRegex.exec(messageText)) !== null) {
+        const language = match[1] ? match[1].trim() : 'text';
+        const code = match[2]; // Keep original spacing/newlines within block
+
+        // Extract Block-UUID from code if present - more flexible pattern
+        let blockUUID = null;
+        // Match UUID in potential header section (look near the top)
+        const lines = code.split('\n');
+        const maxHeaderLines = 20; // Limit search to avoid scanning huge blocks
+        for (let i = 0; i < Math.min(lines.length, maxHeaderLines); i++) {
+            const uuidMatch = code.match(/Block-UUID:\s*([a-f0-9-]+)/i);
+             if (uuidMatch && uuidMatch[1]) {
+                 blockUUID = uuidMatch[1];
+                 break; // Found it
+             }
+        }
+
+
+        codeBlocks.push({
+            language,
+            code, // Raw code content
+            blockUUID,
+            startIndex: match.index,
+            endIndex: match.index + match[0].length
+        });
+    }
+
+    return codeBlocks;
+}
+
+/**
+ * Finds a code block by UUID in message text
+ * (Moved from original PatchUtils)
+ * @param {string} messageText - The message text
+ * @param {string} blockUUID - The Block-UUID to find
+ * @returns {Object|null} Code block object or null if not found
+ */
+function findCodeBlockByUUID(messageText, blockUUID) {
+    if (!messageText || !blockUUID) {
+        return null;
+    }
+    // Use the extractor function now part of this module
+    const codeBlocks = extractCodeBlocksWithUUIDs(messageText);
+    return codeBlocks.find(block => block.blockUUID === blockUUID) || null;
+}
+
+module.exports = {
+    findAllCodeFences,
+    matchFencesAndExtractBlocks,
+    extractCodeBlocksWithUUIDs,
+    findCodeBlockByUUID
+};
+