@gitsense/gsc-utils 0.1.0

package/src/CodeBlockUtils/blockProcessor.js

@@ -0,0 +1,559 @@
+/**
+ * Component: CodeBlockUtils Block Processor
+ * Block-UUID: 1d8a559b-4f7a-4b0b-9e0a-13786f94a74e
+ * Parent-UUID: 082abf8b-079f-4c95-8464-0e66c0de45eb
+ * Version: 1.4.0
+ * Description: Processes the content of identified code blocks, parsing headers or patch details, and provides utilities like fixing UUIDs within blocks.
+ * Language: JavaScript
+ * Created-at: 2025-07-21T00:33:22.312Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Flash Thinking (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
+ */
+
+
+const { findAllCodeFences, matchFencesAndExtractBlocks } = require('./blockExtractor');
+const { parseHeader } = require('./headerUtils');
+const { validateUUID, generateUUID } = require('./uuidUtils');
+const AnalysisBlockUtils = require('../AnalysisBlockUtils');
+const PatchUtils = require('../PatchUtils');
+const GSToolBlockUtils = require('../GSToolBlockUtils');
+const { extractContinuationInfo } = require('./continuationUtils');
+const { removeLineNumbers } = require('./lineNumberFormatter');
+const { detectJsonComments } = require('../JsonUtils');
+
+/**
+ * Processes a single block's content (internal helper)
+ * @param {string} content - The block content
+ * @param {string} language - The language of the block
+ * @param {number} position - The position in the original text
+ * @param {boolean} incomplete - Whether the block is incomplete
+ * @param {Object} options - Processing options (e.g., silent, validatePatches)
+ * @returns {Object} Processed block object
+ */
+function processBlockContent(content, language, position, incomplete, options = { silent: true, validatePatches: false }) {
+    const { silent, validatePatches } = options;
+    let warnings = []; // Collect warnings specific to this block
+    let header = {};
+    let headerText = ''; // Raw header text including comments
+    let headerParseError = null;
+    let headerDelimiterType = null; // 'triple' or 'double'
+    let codeText = content; // Default to all content being code
+
+    // Check if this is a GitSense Tool Block *first*
+    if (GSToolBlockUtils.isToolBlock(content)) {
+        let ignoreDueToComments = false;
+        let toolData = null;
+        let toolParseError = null;
+        try {
+            toolData = GSToolBlockUtils.parseToolBlock(content);
+        } catch (error) {
+            // When chatting about the tool block, the LLM may add
+            // add comments in it so let's test for this
+            const comments = detectJsonComments(content);
+
+            if (comments.length) {
+                ignoreDueToComments = true;
+            } else {
+                toolParseError = error.message;
+                warnings.push({
+                    position: position,
+                    type: 'gs_tool_block_parse_error',
+                    message: `Invalid GitSense tool block: ${error.message}`,
+                    content: content
+                });
+            }
+        }
+
+        if (ignoreDueToComments) {
+            // Uncomment to show warning
+            // console.warn('GitSense Chat Tool JSON contains one or more comments');
+        } else {
+            return {
+                type: 'gs-tool',
+                language: language,
+                content: content,
+                position: position,
+                incomplete: incomplete,
+                toolData: toolData,
+                toolParseError: toolParseError,
+                warnings: warnings,
+            };
+        }
+    }
+
+    // Check if this is an analysis block *next*
+    if (AnalysisBlockUtils.isAnalysisBlock(content)) {
+        const analysisType = AnalysisBlockUtils.getAnalysisBlockType(content);
+        const analysisMetadata = AnalysisBlockUtils.parseOverviewMetadata(content);
+
+        // Validate the metadata if it was successfully parsed
+        let validationResult = { isValid: false, errors: ['Failed to parse analysis metadata'] };
+        if (analysisMetadata) {
+            validationResult = AnalysisBlockUtils.validateAnalysisMetadata(analysisMetadata);
+
+            if (!validationResult.isValid) {
+                warnings.push({
+                    position: position,
+                    type: 'analysis_metadata_error',
+                    message: `Invalid analysis metadata: ${validationResult.errors.join(', ')}`,
+                    content: content,
+                });
+            }
+        }
+
+        return {
+            type: analysisType,
+            language: language,
+            content: content,
+            position: position,
+            incomplete: incomplete,
+            analysisMetadata: analysisMetadata,
+            analysisValidation: validationResult,
+            warnings: warnings,
+        };
+    }
+
+    // Check if this is a gitsense-search-flow block *next*
+    if (language === 'gitsense-search-flow') {
+        // Future parsing logic for gitsense-search-flow content would go here.
+        // For now, we just identify the type and keep the raw content.
+        return {
+            type: 'gitsense-search-flow',
+            language: language,
+            content: content, // Keep raw content for now
+            position: position,
+            incomplete: incomplete,
+            // Add parsedData: {} or similar if parsing is implemented later
+            warnings: warnings, // Include any warnings collected so far
+        };
+    }
+
+    // Then check if this is a patch block
+    if (PatchUtils.isPatchBlock(content)) {
+        const patchFormat = PatchUtils.determinePatchFormat(content);
+        const metadata = PatchUtils.extractPatchMetadata(content); // Extract metadata regardless of validation
+        const patchContent = PatchUtils.extractPatchContent(content); // Extract raw patch content
+
+        let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
+
+        // Validate metadata (always useful)
+        const errors = PatchUtils.validatePatchMetadata(metadata);
+        if (errors.length) {
+            warnings.push({
+                position: position,
+                type: 'patch_metadata_error',
+                message: `Invalid patch metadata: ${errors.join(', ')}`,
+                content: content,
+            });
+            // Decide if invalid metadata makes the whole block invalid or just adds a warning
+            // For now, just warn, but return the extracted (potentially invalid) metadata.
+        }
+
+        // Optionally validate context patch structure if requested
+        if (patchFormat === 'context' && validatePatches) {
+            try {
+                const patches = PatchUtils.extractContextPatches(content);
+                if (!patches || patches.length === 0) {
+                    patchValidationResult = { valid: false, errors: ['No valid context patch content found.'], patches: null };
+                    warnings.push({
+                        position: position,
+                        type: 'patch_content_error',
+                        message: 'No valid context patch content found.',
+                        content: content,
+                    });
+                } else {
+                    // Basic validation passed (structure was parsable)
+                    patchValidationResult = { valid: true, errors: [], patches: patches };
+                }
+            } catch (error) {
+                patchValidationResult = { valid: false, errors: [error.message], patches: null };
+                warnings.push({
+                    position: position,
+                    type: 'patch_parse_error',
+                    message: `Error parsing context patch: ${error.message}`,
+                    content: content,
+                });
+            }
+        }
+
+        return {
+            type: 'patch',
+            language: language === 'diff' ? 'diff' : language, // Use 'diff' if specified, else keep original
+            content: content, // Full original content within fences
+            position: position,
+            incomplete: incomplete,
+            metadata: metadata,
+            patch: patchContent, // Raw patch content after metadata
+            patchFormat: patchFormat,
+            patchValidation: validatePatches ? patchValidationResult : undefined, // Include validation only if requested
+            warnings: warnings,
+        };
+    } else {
+        // For non-patch blocks, remove display line numbers before processing content
+        content = removeLineNumbers(content); // This is the "cleaned" content
+    }
+
+    // --- Process as a regular code block ---
+    // Attempt 1: Look for triple newline separator (our standard)
+    const tripleNewlineSeparator = '\n\n\n';
+    const tripleNewlineIndex = content.indexOf(tripleNewlineSeparator);
+
+    if (tripleNewlineIndex !== -1) {
+        const potentialHeaderText = content.substring(0, tripleNewlineIndex); // No trim here
+
+        try {
+            header = parseHeader(potentialHeaderText, language);
+            headerText = potentialHeaderText;
+            codeText = content.substring(tripleNewlineIndex + tripleNewlineSeparator.length);
+            headerDelimiterType = 'triple';
+        } catch (error) {
+            // If parsing fails, it's not a valid header, log warning and try double newline
+            headerParseError = error.message;
+            warnings.push({
+                position: position,
+                type: 'header_parse_error',
+                message: `Invalid header (triple newline attempt): ${error.message}. Attempting double newline.`,
+                content: potentialHeaderText // Show the problematic header text
+            });
+            // Do not set header, headerText, codeText, or headerDelimiterType yet.
+            // Fall through to the next attempt.
+        }
+    }
+
+    // Attempt 2: Look for double newline separator (fallback)
+    // Only if a valid header wasn't found in the triple newline attempt
+    if (!headerDelimiterType) {
+        const doubleNewlineSeparator = '\n\n';
+        const doubleNewlineIndex = content.indexOf(doubleNewlineSeparator);
+
+        if (doubleNewlineIndex !== -1) {
+            const potentialHeaderText = content.substring(0, doubleNewlineIndex); // No trim here
+
+            try {
+                header = parseHeader(potentialHeaderText, language);
+                headerText = potentialHeaderText;
+                codeText = content.substring(doubleNewlineIndex + doubleNewlineSeparator.length);
+                headerDelimiterType = 'double';
+            } catch (error) {
+                // If parsing fails, it's not a valid header, log warning and default to no header
+                headerParseError = error.message;
+                warnings.push({
+                    position: position,
+                    type: 'header_parse_error',
+                    message: `Invalid header (double newline attempt): ${error.message}. Treating block as code only.`,
+                    content: potentialHeaderText // Show the problematic header text
+                });
+                // Fall through to default case (no header)
+            }
+        }
+    }
+
+    // Default: If no valid header was found after both attempts
+    if (!headerDelimiterType && !incomplete) { // Only warn about missing header if the block is complete
+        warnings.push({
+            position: position,
+            type: 'missing_header',
+            message: `No distinct header found or parsed as valid. Treating block as code only.`,
+            content: content.substring(0, 100) + '...' // Show beginning of content
+        });
+    }
+
+    return {
+        type: 'code',
+        language: language,
+        header: header,
+        headerText: headerText.trim(), // Include the raw header text if successfully parsed
+        content: codeText, // The code part after the header (or full content if no header)
+        position: position, // Position of the opening fence
+        headerDelimiterType: headerDelimiterType, // 'triple', 'double', or null
+        incomplete: incomplete,
+        warnings: warnings,
+        headerParseError: headerParseError // Include error message if parsing failed
+    };
+}
+
+
+/**
+ * Processes the content of complete and incomplete blocks (internal helper)
+ * @param {string} text - The input text
+ * @param {Array} completeBlocks - Array of complete block objects from extractor
+ * @param {Array} incompleteBlocks - Array of incomplete block objects from extractor
+ * @param {Object} options - Processing options
+ * @returns {Array} Array of processed block objects
+ */
+function processBlockContents(text, completeBlocks, incompleteBlocks, options) {
+    const processedBlocks = [];
+    const allWarnings = []; // Collect warnings from all blocks
+
+    // Process complete blocks
+    for (const block of completeBlocks) {
+        try {
+            const startPos = block.opening.position + block.opening.length;
+            const endPos = block.closing.position;
+            // Get content, including the newlines immediately after opening and before closing fence
+            const contentWithNewlines = text.substring(startPos, endPos);
+            const content = contentWithNewlines; //.replace(/^\s*\n|\n\s*$/g, '');
+
+            const language = block.opening.language;
+
+            // Process block content
+            const processedBlock = processBlockContent(content, language, block.opening.position, false, options);
+            processedBlocks.push(processedBlock);
+            if (processedBlock.warnings) {
+                allWarnings.push(...processedBlock.warnings);
+            }
+        } catch (error) {
+            // Catch errors during the processing of a single block
+            allWarnings.push({
+                position: block.opening?.position || -1,
+                type: 'block_processing_error',
+                message: `Error processing complete block: ${error.message}`,
+                content: text.substring(block.opening?.position, block.closing?.position + block.closing?.length) || "Error retrieving block content"
+            });
+        }
+    }
+
+    // Process incomplete blocks
+    for (const block of incompleteBlocks) {
+        try {
+            const startPos = block.opening.position + block.opening.length;
+            // Get content from opening fence to end of text
+            const contentWithNewline = text.substring(startPos);
+            // Trim only leading whitespace line
+            const content = contentWithNewline.replace(/^\s*\n/, '');
+
+            const language = block.opening.language;
+
+            // Process block content - it's expected to be incomplete
+            const processedBlock = processBlockContent(content, language, block.opening.position, true, options);
+
+            // Extract continuation info for incomplete blocks
+            // Requires extractContinuationInfo from continuationUtils
+            try {
+                // Pass the *processed* header info to continuation utils
+                let { 'Continuation-Part': partNumber } = processedBlock?.header || {};
+                partNumber = partNumber ? parseInt(partNumber) + 1 : 2; // Default to part 2 if not specified
+                processedBlock.continuationInfo = extractContinuationInfo(processedBlock.content, partNumber, language, processedBlock.header);
+            } catch (continuationError) {
+                allWarnings.push({
+                    position: block.opening?.position || -1,
+                    type: 'continuation_info_error',
+                    message: `Error extracting continuation info: ${continuationError.message}`,
+                    content: content
+                });
+            }
+
+
+            processedBlocks.push(processedBlock);
+            if (processedBlock.warnings) {
+                allWarnings.push(...processedBlock.warnings);
+            }
+        } catch (error) {
+            // Catch errors during the processing of a single incomplete block
+            allWarnings.push({
+                position: block.opening?.position || -1,
+                type: 'incomplete_block_processing_error',
+                message: `Error processing incomplete block: ${error.message}`,
+                content: text.substring(block.opening?.position) || "Error retrieving block content"
+            });
+        }
+    }
+
+    // Return processed blocks and collected warnings
+    // Note: The caller (processCodeBlocks) will handle adding these warnings to its own return object.
+    return { processedBlocks, allWarnings };
+}
+
+
+/**
+ * Core function to process code blocks with shared logic
+ * @param {string} text - The input text containing code blocks
+ * @param {Object} options - Processing options (e.g., silent, validatePatches)
+ * @returns {Object} { blocks: Array, warnings: Array, hasIncompleteBlocks: boolean, lastIncompleteBlock: Object|null }
+ */
+function processCodeBlocks(text, options = { silent: false, validatePatches: false }) {
+    if (typeof text !== "string") { // Allow empty strings
+        console.warn("Warning: Input must be a string.");
+        return {
+            blocks: [],
+            warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }],
+            hasIncompleteBlocks: false,
+            lastIncompleteBlock: null }
+        ;
+    }
+
+    if (text.trim() === "") {
+        return { blocks: [], warnings: [], hasIncompleteBlocks: false, lastIncompleteBlock: null };
+    }
+
+    // Step 1: Find all fence positions
+    const { openingPositions, closingPositions } = findAllCodeFences(text);
+
+    // Step 2: Match fences to get potential block boundaries
+    const { completeBlocks, incompleteBlocks, warnings: extractorWarnings } = matchFencesAndExtractBlocks(
+        text, openingPositions, closingPositions
+    );
+
+    // Step 3: Process the content of these potential blocks
+    const { processedBlocks, allWarnings: processorWarnings } = processBlockContents(
+        text, completeBlocks, incompleteBlocks, options
+    );
+
+    // Combine warnings from extractor and processor
+    const allWarnings = [...extractorWarnings, ...processorWarnings];
+
+    // Log warnings if not silent
+    if (!options.silent && allWarnings.length > 0) {
+        console.warn('\nCode Block Processing Warnings:');
+        allWarnings.forEach((warning, index) => {
+            console.warn(`\nWarning ${index + 1}:`);
+            console.warn(`Type: ${warning.type}`);
+            console.warn(`Message: ${warning.message}`);
+            console.warn(`Position: ${warning.position}`);
+            if (warning.content) {
+                // Limit logged content length
+                const maxLogLength = 200;
+                const loggedContent = warning.content.length > maxLogLength
+                    ? warning.content.substring(0, maxLogLength) + '...'
+                    : warning.content;
+                console.warn(`Content Hint: ${loggedContent}`);
+            }
+        });
+    }
+
+    const hasIncompleteBlocks = incompleteBlocks.length > 0;
+    const lastIncompleteBlock = hasIncompleteBlocks
+        ? processedBlocks.find(block => block.incomplete) // Find the corresponding processed block
+        : null;
+
+    return {
+        blocks: processedBlocks,
+        warnings: allWarnings,
+        hasIncompleteBlocks: hasIncompleteBlocks,
+        lastIncompleteBlock: lastIncompleteBlock
+    };
+}
+
+/**
+ * Public API function - maintains backward compatibility for simple extraction.
+ * Use processCodeBlocks for more detailed results (warnings, incomplete status).
+ * @param {string} text - The input text containing code blocks
+ * @param {Object} options - Options for extraction (e.g., { silent: true })
+ * @returns {Object} - Object containing extracted blocks and warnings { blocks: Array, warnings: Array }
+ */
+function extractCodeBlocks(text, options = { silent: false, validatePatches: false, debug: false }) {
+    const { blocks, warnings } = processCodeBlocks(text, options);
+    return { blocks, warnings };
+}
+
+
+/**
+ * Fixes invalid UUIDs in code blocks within text
+ * @param {string} text - The input text containing code blocks
+ * @returns {Object} - Object containing fixed text and whether changes were made { text: string, modified: boolean }
+ */
+function fixTextCodeBlocks(text) {
+    if (typeof text !== "string" || text.trim() === "") {
+        return {
+            text: text,
+            modified: false
+        };
+    }
+
+    let modified = false;
+    let fixedText = text;
+
+    // Regex to match code blocks with their language
+    const codeBlockRegex = /```([a-zA-Z-]*)\n([\s\S]*?)\n```/g;
+
+    // Store all matches to process in reverse
+    const matches = Array.from(text.matchAll(codeBlockRegex));
+
+    // Process matches in reverse to maintain correct positions
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const match = matches[i];
+        const fullMatch = match[0];
+        const language = match[1];
+        const blockContent = match[2];
+        let blockModified = false;
+
+        // Check if this is a patch block or a gitsense-search-flow block (if they contain UUIDs)
+        if (PatchUtils.isPatchBlock(blockContent)) {
+            // Process patch block UUIDs
+            const lines = blockContent.split('\n');
+            let blockModified = false;
+
+            const newLines = lines.map(line => {
+                // Check for UUID fields in patch metadata
+                if ((line.includes('# Source-Block-UUID:') || line.includes('# Target-Block-UUID:')) &&
+                    !line.includes('{{GS-UUID}')) {
+
+                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
+
+                    // Validate UUID
+                    const validation = validateUUID(valuePart);
+                    if (validation["Block-UUID"] === "INVALID UUID") {
+                        blockModified = true;
+                        modified = true;
+                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
+                    }
+                }
+                return line;
+            });
+
+            // If this block was modified, replace it in the text
+            if (blockModified) {
+                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
+                fixedText = fixedText.substring(0, match.index) +
+                    newBlock +
+                    fixedText.substring(match.index + fullMatch.length);
+            }
+        } else {
+            // Process regular code block or gitsense-search-flow block for UUIDs
+            // Split block content into lines to check for header/UUIDs
+            const lines = blockContent.split('\n');
+            let blockModified = false;
+
+            // Process each line
+            const newLines = lines.map(line => {
+                // Check for UUID fields
+                if (line.includes(' Block-UUID: ') || line.includes(' Parent-UUID: ')) {
+                    const [fieldPart, valuePart] = line.split(':').map(p => p.trim());
+
+                    // Skip if N/A or contains unexpected characters
+                    if (valuePart === 'N/A' || valuePart.match(/\(/)) {
+                        return line;
+                    }
+                    // Validate UUID
+                    const validation = validateUUID(valuePart);
+
+                    if (validation["Block-UUID"] === "INVALID UUID") {
+                        blockModified = true;
+                        modified = true;
+                        return `${fieldPart}: ${validation["Correct Block-UUID"]}`;
+                    }
+                }
+                return line;
+            });
+
+            // If this block was modified, replace it in the text
+            if (blockModified) {
+                const newBlock = `\`\`\`${language}\n${newLines.join('\n')}\n\`\`\``;
+                fixedText = fixedText.substring(0, match.index) +
+                    newBlock +
+                    fixedText.substring(match.index + fullMatch.length);
+            }
+        }
+    }
+
+    return {
+        text: fixedText,
+        modified: modified
+    };
+}
+
+
+module.exports = {
+    processCodeBlocks,
+    extractCodeBlocks,
+    fixTextCodeBlocks,
+};

package/src/CodeBlockUtils/blockProcessor.js.rej

@@ -0,0 +1,8 @@
+@@ -262,6 +283,7 @@
+ function processCodeBlocks(text, options = { silent: false, validatePatches: false }) {
+     if (typeof text !== "string") { // Allow empty strings
+         console.warn("Warning: Input must be a string.");
++        return { blocks: [], warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }], hasIncompleteBlocks: false, lastIncompleteBlock: null };
+     }
+      if (text.trim() === "") {
+         return { blocks: [], warnings: [], hasIncompleteBlocks: false, lastIncompleteBlock: null };

package/src/CodeBlockUtils/constants.js

@@ -0,0 +1,62 @@
+/**
+ * Component: CodeBlockUtils Constants
+ * Block-UUID: 01b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d
+ * Parent-UUID: 144d19a5-139a-4e80-8abe-84965583e35e
+ * Version: 1.0.1
+ * Description: Defines constants used across the CodeBlockUtils modules, such as comment styles for various languages.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T15:51:16.973Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash Thinking (v1.0.1)
+ */
+
+
+// Defines comment styles for various programming languages and block types.
+const COMMENT_STYLES = {
+    // C-style comments
+    'javascript': { type: 'c-style' },
+    'typescript': { type: 'c-style' },
+    'java': { type: 'c-style' },
+    'c': { type: 'c-style' },
+    'cpp': { type: 'c-style' },
+    'csharp': { type: 'c-style' },
+    'php': { type: 'c-style' },
+    'swift': { type: 'c-style' },
+    'kotlin': { type: 'c-style' },
+    'scala': { type: 'c-style' },
+    'rust': { type: 'c-style' },
+    'go': { type: 'c-style' },
+
+    // Custom GitSense block types
+    'gitsense-search-flow': { type: 'none' },
+
+    // Hash-style comments
+    'python': { type: 'hash' },
+    'ruby': { type: 'ruby-block' },
+    'perl': { type: 'hash' },
+    'bash': { type: 'hash' },
+    'shell': { type: 'hash' },
+    'yaml': { type: 'hash' },
+    'powershell': { type: 'hash' },
+    'r': { type: 'hash' },
+    'julia': { type: 'hash' },
+
+    // Other language styles
+    'lisp': { type: 'semicolon' },
+    'clojure': { type: 'semicolon' },
+    'scheme': { type: 'semicolon' },
+    'ada': { type: 'ada' },
+    'lua': { type: 'lua' },
+    'matlab': { type: 'percent' },
+    'octave': { type: 'percent' },
+    'haskell': { type: 'haskell' },
+    'sql': { type: 'sql' },
+    'fortran': { type: 'exclamation' },
+    'vb': { type: 'apostrophe' },
+    'vbscript': { type: 'apostrophe' }
+};
+
+module.exports = {
+    COMMENT_STYLES
+};
+
+