@gitsense/gsc-utils 0.1.0

package/src/CodeBlockUtils/continuationUtils.js

@@ -0,0 +1,191 @@
+/**
+ * Component: CodeBlockUtils Continuation Utilities
+ * Block-UUID: 6fdf5c7d-4def-42a1-bc88-0312f6002cfc
+ * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
+ * Version: 1.0.0
+ * Description: Provides functions to extract context from incomplete code blocks and generate prompts for continuation.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T15:59:41.768Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+/**
+ * Extracts continuation information from an incomplete block's content.
+ * @param {string} content - The raw content of the incomplete block (after the opening fence).
+ * @param {number} partNumber - The calculated part number for the continuation (e.g., 2 for the first continuation).
+ * @param {string} language - The language of the block.
+ * @param {Object} header - The parsed header object from the incomplete block (if available).
+ * @returns {Object} Continuation information { lastLines: Array<string>, blockUUID: string|null, partNumber: number, language: string, metadata: Object }
+ */
+function extractContinuationInfo(content, partNumber, language, header = {}) {
+    // Extract Block-UUID directly from the parsed header if available and valid
+    let blockUUID = (header && header['Block-UUID'] && header['Block-UUID'] !== 'INVALID UUID')
+        ? header['Block-UUID']
+        : null;
+
+    // Fallback: Try to find UUID in content if not in header (less reliable)
+    if (!blockUUID) {
+    const uuidMatch = content.match(/Block-UUID: ([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/);
+        if (uuidMatch && uuidMatch[1]) {
+            blockUUID = uuidMatch[1];
+        }
+    }
+
+    // Clean up potential warning messages appended by some systems
+    // Note: This might need adjustment based on the specific format of such warnings.
+    let cleanedContent = content.replace(/\n---\nWarning: Incomplete response\n\n?/, '');
+    cleanedContent = cleanedContent.replace(/Authored by LLM .+ at .+$/, ''); // Remove potential authorship line
+
+    const lines = cleanedContent.split('\n');
+
+    // Determine if the very last line might be incomplete.
+    // Heuristic: If the content doesn't end with a newline, the last line was likely cut off.
+    // This isn't foolproof.
+    const lastLinePotentiallyIncomplete = !cleanedContent.endsWith('\n') && lines.length > 0;
+
+    // If the last line is potentially incomplete, we keep it.
+    // If it seems complete (ends with \n), we can consider removing the *very last* line
+    // as it might be fully formed and the LLM should start *after* it.
+    // However, safest is often to include it and let the LLM figure out the exact continuation point.
+    // Let's keep the last line for now, whether complete or not.
+
+    // Find the last 5 non-empty lines and include empty lines between them
+    const lastLinesForContext = [];
+    const nonEmptyIndices = [];
+
+    // Get indices of all non-empty lines
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() !== '') {
+            nonEmptyIndices.push(i);
+        }
+    }
+
+    // Get the indices of the last 5 non-empty lines
+    const lastNonEmptyIndices = nonEmptyIndices.slice(-5);
+
+    if (lastNonEmptyIndices.length > 0) {
+        // Get all lines from the *start* of the first of these last 5 non-empty lines up to the end
+        const startIndex = lastNonEmptyIndices[0];
+        // Include all lines until the very end of the original lines array
+        lastLinesForContext.push(...lines.slice(startIndex));
+    } else if (lines.length > 0) {
+         // If there are fewer than 5 non-empty lines, take all available lines
+         lastLinesForContext.push(...lines);
+    }
+     // If the block was completely empty after the header, lastLinesForContext will be empty.
+
+
+    return {
+        lastLines: lastLinesForContext, // The actual lines to show in the prompt
+        blockUUID: blockUUID,
+        partNumber: partNumber,
+        language: language,
+        lastLineIncomplete: lastLinePotentiallyIncomplete, // Hint for prompt generation
+        metadata: header // Pass the parsed header info along
+    };
+}
+
+
+/**
+ * Generates a continuation prompt for an incomplete code block.
+ * @param {Object} continuationInfo - The object returned by extractContinuationInfo.
+ * @returns {string} Formatted continuation prompt.
+ */
+function generateContinuationPrompt(incompleteBlock, isLastPart = false) {
+    if (!incompleteBlock) {
+        console.warn("generateContinuationPrompt called with invalid incompleteBlock.");
+        return '';
+    }
+
+    const {
+        lastLines = [],
+        blockUUID = null,
+        partNumber = 2,
+        language = 'unknown',
+        lastLineIncomplete = false, // Use the flag from continuationInfo
+        metadata = {} // Use the metadata passed from continuationInfo
+    } = incompleteBlock.continuationInfo;
+
+    // Extract relevant metadata fields for the prompt example
+    const componentName = metadata['Component'] || 'UnknownComponent';
+    const parentUUID = metadata['Parent-UUID'] || 'N/A';
+    const currentVersion = metadata['Version'] || '1.0.0'; // Version from the *incomplete* block's header
+    const description = metadata['Description'] || 'No description provided.';
+    const authors = metadata['Authors'] || 'Unknown Authors';
+    // Created-at is less relevant for the *next* part's example header, use current time there.
+
+    // Calculate the expected next version (increment patch version)
+    let nextVersion = '1.0.1'; // Default if current version is invalid
+    const versionPattern = /^(\d+)\.(\d+)\.(\d+)$/;
+    const versionMatch = typeof currentVersion === 'string' ? currentVersion.match(versionPattern) : null;
+    if (versionMatch) {
+        nextVersion = `${versionMatch[1]}.${versionMatch[2]}.${parseInt(versionMatch[3]) + 1}`;
+    } else {
+        console.warn(`Invalid current version format "${currentVersion}" in continuation metadata. Defaulting next version to 1.0.1.`);
+    }
+
+    // Build UUID context string
+    const uuidSection = blockUUID
+        ? `This is PART ${partNumber} of a multi-part code block.\nPlease continue the code block with Block-UUID: ${blockUUID}`
+        : `This is PART ${partNumber} of a multi-part code block.\nPlease continue the code block.`;
+
+    // Add specific instruction if the last line was likely cut off
+    const lastLineInstruction = lastLineIncomplete
+        ? "The last line provided below might be incomplete. Start your response by completing that line if necessary, then continue the code."
+        : "The last line provided below appears complete. Start your response *after* this line.";
+
+    // Create metadata instructions
+    const metadataInstructions = `
+METADATA PRESERVATION INSTRUCTIONS:
+1. Keep the same Block-UUID: ${blockUUID}
+2. Add "Continuation-Part: ${partNumber}" to the metadata
+3. Preserve all other metadata fields (Description, Language, etc.)
+`;
+
+    // Construct the prompt
+    return `[CONTINUATION REQUEST - PART ${partNumber}]
+${uuidSection}
+
+The previous part ended with the following lines:
+\`\`\`${language}
+${lastLines.join('\n')}
+\`\`\`
+
+IMPORTANT INSTRUCTIONS:
+1.  ${lastLineInstruction}
+2.  Your response MUST start with the complete metadata header block, followed by the repeated code lines from above (adjusting the last line if it was incomplete), and then the new code.
+3.  Follow the METADATA REQUIREMENTS listed below precisely.
+4.  Maintain the original coding style, indentation, and structure.
+5.  Wrap your entire response in a single markdown code block (\`\`\`${language} ... \`\`\`).
+
+${metadataInstructions}
+
+Example of the START of your response:
+\`\`\`${language}
+/**
+ * Component: ${componentName}
+* Block-UUID: 01147ddf-320f-498a-a744-198d42a9d2ee
+* Parent-UUID: e4c0d839-ea17-467d-a0cc-d269d1dbc404
+ * Version: ${nextVersion}
+ * Description: ${description}
+ * Language: ${language}
+ * Created-at: ${new Date().toISOString()}
+ * Authors: ${authors}, Your Name (v${nextVersion})
+ * Continuation-Part: ${partNumber}
+ */
+
+
+${lastLines.join('\n')} // <-- Repeat the lines from above (adjust last if needed)
+// New code starts here...
+const nextVariable = true;
+\`\`\`
+Contribute code starting from the line immediately following the repeated code block.
+`;
+}
+
+
+module.exports = {
+    extractContinuationInfo,
+    generateContinuationPrompt
+};

package/src/CodeBlockUtils/headerParser.js

@@ -0,0 +1,175 @@
+/**
+ * Component: CodeBlockUtils Header Parser (Comment-Delimited)
+ * Block-UUID: ab5ec4f5-0e35-4052-b6ce-a7e9c3117bd0
+ * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
+ * Version: 1.0.0
+ * Description: Parses code blocks where metadata headers are enclosed in language-specific comment delimiters (e.g., /** ... * /, """ ... """), not markdown fences. Extracts metadata and content.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T16:00:32.420Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+// Note: This parser operates differently from the markdown fence-based parser.
+// It looks for specific comment block styles to delimit the header.
+
+function parseCodeBlocks(input) {
+    let state = "START";
+    let position = { line: 1, column: 1, offset: 0 };
+    let metadata = {};
+    let content = "";
+    let errors = [];
+    let buffer = ""; // Temporary buffer for metadata fields
+    let headerLanguage = null; // To track the type of comment delimiter found
+
+    // Helper function to update position
+    function updatePosition(char) {
+        if (char === "\n") {
+            position.line++;
+            position.column = 1;
+        } else {
+            position.column++;
+        }
+        position.offset++;
+    }
+
+    // Helper function to check for opening delimiters and determine language context
+    function checkOpeningDelimiter(input, index) {
+        if (input.slice(index, index + 3) === '"""') return { lang: "PYTHON", length: 3 };
+        if (input.slice(index, index + 3) === '/**') return { lang: "JAVASCRIPT", length: 3 }; // Common C-style block comment start
+        if (input.slice(index, index + 2) === '/*') return { lang: "C_STYLE_GENERIC", length: 2 }; // Generic C-style, might not be header
+        if (input.slice(index, index + 6) === '=begin') return { lang: "RUBY", length: 6}; // Ruby block comment
+        // Add other language-specific block comment openings if needed
+        return null;
+    }
+
+    // Helper function to check for closing delimiters based on the detected header language
+    function checkClosingDelimiter(input, index, detectedLanguage) {
+        if (detectedLanguage === "PYTHON" && input.slice(index, index + 3) === '"""') return 3;
+        if ((detectedLanguage === "JAVASCRIPT" || detectedLanguage === "C_STYLE_GENERIC") && input.slice(index, index + 2) === '*/') return 2;
+        if (detectedLanguage === "RUBY" && input.slice(index, index + 4) === '=end') return 4;
+        // Add other language-specific block comment closings
+        return 0;
+    }
+
+    // Helper function to parse metadata fields from the buffer
+    function parseMetadataLine(line) {
+        // Handle different comment line prefixes within the block
+        const cleanedLine = line.replace(/^[\s\*#;!]*/, '').trim(); // Remove leading comment chars/whitespace
+        if (!cleanedLine) return; // Skip empty or comment-only lines
+
+        const colonIndex = cleanedLine.indexOf(":");
+        if (colonIndex === -1) {
+            // Allow lines without colons if they are part of a multi-line value (heuristic)
+            // This is tricky; requires more robust parsing or stricter format.
+            // For now, we'll treat lines without colons as errors unless a specific key allows multi-line.
+             if (!Object.keys(metadata).some(k => ['Description', 'Authors'].includes(k))) { // Example: Allow multi-line for Description/Authors
+                 errors.push({ message: `Invalid metadata line (missing colon?): ${cleanedLine}`, position: { ...position } });
+             } else {
+                 // Append to the last key if it allows multi-line (simple approach)
+                 const lastKey = Object.keys(metadata).pop();
+                 if (lastKey && ['Description', 'Authors'].includes(lastKey)) {
+                     metadata[lastKey] += '\n' + cleanedLine;
+                 }
+             }
+            return;
+        }
+        const key = cleanedLine.slice(0, colonIndex).trim();
+        const value = cleanedLine.slice(colonIndex + 1).trim();
+        metadata[key] = value;
+    }
+
+    // Main parsing loop
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+
+        switch (state) {
+            case "START": {
+                const delimiterInfo = checkOpeningDelimiter(input, i);
+                if (delimiterInfo) {
+                    state = "HEADER";
+                    headerLanguage = delimiterInfo.lang;
+                    // Skip the delimiter characters
+                    for(let k=0; k<delimiterInfo.length; k++) updatePosition(input[i+k]);
+                    i += delimiterInfo.length - 1;
+                    buffer = ""; // Reset buffer for the new header
+                } else {
+                     updatePosition(char); // Consume char if not starting a header
+                }
+                break;
+            }
+
+            case "HEADER": {
+                 const closingLength = checkClosingDelimiter(input, i, headerLanguage);
+                 if (closingLength > 0) {
+                     // Found end of header block
+                     if (buffer.trim()) {
+                         parseMetadataLine(buffer); // Parse the last line in the buffer
+                     }
+                     state = "CONTENT";
+                     // Skip the closing delimiter characters
+                     for(let k=0; k<closingLength; k++) updatePosition(input[i+k]);
+                     i += closingLength - 1;
+                     buffer = ""; // Clear buffer
+                 } else if (char === "\n") {
+                     // End of a line within the header
+                     if (buffer.trim() || buffer === '') { // Process line even if empty within header
+                         parseMetadataLine(buffer);
+                         buffer = "";
+                     }
+                     updatePosition(char);
+                 } else {
+                     buffer += char;
+                     updatePosition(char);
+                 }
+                 break;
+            }
+
+            case "CONTENT": {
+                // Once in content, we assume the rest is content until EOF or potentially another START?
+                // This simple parser assumes only one header block at the beginning.
+                content += char;
+                updatePosition(char);
+                // To handle multiple blocks, state would need to transition back to START
+                // after consuming whitespace or based on other rules.
+                break;
+            }
+
+            // case "END": // Not really used in this simple model
+            //     break;
+
+            default: {
+                errors.push({ message: `Unexpected parser state: ${state}`, position: { ...position } });
+                // Attempt recovery? For now, just log and continue consuming as content.
+                state = "CONTENT";
+                content += char;
+                updatePosition(char);
+                break;
+            }
+        }
+    }
+
+     // If loop finishes while still in HEADER state, it's an unterminated header
+     if (state === "HEADER") {
+         errors.push({ message: "Unterminated metadata header block.", position: { ...position } });
+         // Process any remaining buffer content from the unterminated header
+         if (buffer.trim()) {
+             parseMetadataLine(buffer);
+         }
+     }
+
+    // Basic validation of essential metadata fields after parsing
+    // More robust validation (UUID format, Version format, Timestamp format) should be done separately
+    if (!metadata["Component"] || !metadata["Block-UUID"] || !metadata["Version"]) {
+        errors.push({ message: "Parsing finished, but missing required metadata fields (Component, Block-UUID, Version).", position: { ...position } });
+    }
+
+    return {
+        metadata,
+        content: content.trim(), // Trim final content
+        position, // Final position reached
+        errors,
+    };
+}
+
+module.exports = { parseCodeBlocks };

package/src/CodeBlockUtils/headerUtils.js

@@ -0,0 +1,236 @@
+/**
+ * Component: CodeBlockUtils Header Utilities
+ * Block-UUID: 2565f708-feec-4b59-88fd-984084410fd4
+ * Parent-UUID: 01147ddf-320f-498a-a744-198d42a9d2ee
+ * Version: 1.2.0
+ * Description: Provides utility functions for parsing metadata headers from code blocks, validating timestamps, and calculating header line counts.
+ * Language: JavaScript
+ * Created-at: 2025-07-21T00:23:28.169Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash Thinking (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0)
+ */
+
+
+// Dependencies from other modules within CodeBlockUtils
+const { COMMENT_STYLES } = require('./constants');
+const { removeLineNumbers } = require('./lineNumberFormatter'); // Assuming this utility exists
+const { validateUUID } = require('./uuidUtils'); // Assuming uuidUtils.js is in the same directory
+
+const MAX_HEADER_LINES = 12; // Maximum allowed non-empty lines for a header
+/**
+ * Validates if a string is a valid ISO 8601 timestamp
+ * @param {string} timestamp - The timestamp to validate
+ * @returns {boolean} - True if valid, false otherwise
+ */
+function isValidISOTimestamp(timestamp) {
+    const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
+    if (!isoPattern.test(timestamp)) {
+        return false;
+    }
+
+    const date = new Date(timestamp);
+    return date instanceof Date && !isNaN(date);
+}
+
+/**
+ * Parses the header string into a structured object.
+ * @param {string} header - The header string to parse.
+ * @param {string} language - The programming language of the code block.
+ * @returns {Object} - The parsed header object.
+ * @throws {Error} If header parsing fails (e.g., missing fields, invalid format).
+ */
+function parseHeader(header, language) {
+    const headerObject = {};
+
+    // Get comment style for the language
+    const commentStyle = COMMENT_STYLES[language] || { type: 'unknown' };
+
+    // Remove comment syntax based on language style
+    let cleanHeader = header;
+
+    switch (commentStyle.type) {
+        case 'c-style':
+            cleanHeader = header.replace(/^\/\*\*|\*\/$/g, '')
+                               .split('\n')
+                               .map(line => line.replace(/^\s*\*\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'hash':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*#\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'ruby-block':
+            cleanHeader = header.replace(/^=begin\s*\n/, '')
+                               .replace(/\n=end\s*$/, '');
+            break;
+
+        case 'semicolon':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*;\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'ada':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*--\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'lua':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*--\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'percent':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*%\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'haskell':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*--\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'sql':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*--\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'exclamation':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*!\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'apostrophe':
+            cleanHeader = header.split('\n')
+                               .map(line => line.replace(/^\s*'\s?/, ''))
+                               .join('\n');
+            break;
+
+        case 'unknown':
+            // Attempt basic detection if language wasn't found in COMMENT_STYLES
+            if (header.startsWith('/**')) {
+                cleanHeader = header.replace(/^\/\*\*|\*\/$/g, '')
+                                   .split('\n')
+                                   .map(line => line.replace(/^\s*\*\s?/, ''))
+                                   .join('\n');
+            } else if (header.startsWith('#')) {
+                cleanHeader = header.split('\n')
+                                   .map(line => line.replace(/^\s*#\s?/, ''))
+                                   .join('\n');
+            }
+            // Add more basic detections if needed
+            break;
+    }
+
+    // Parse the cleaned header
+    const lines = cleanHeader.split('\n').filter(line => line.trim() !== '');
+    if (lines.length > MAX_HEADER_LINES) {
+        throw new Error(`Header exceeds maximum allowed lines (${MAX_HEADER_LINES}). Found ${lines.length} non-empty lines.`);
+    }
+
+    const missingFields = [];
+
+    for (const line of lines) {
+        const match = line.match(/^\s*([^:]+):\s*(.*)$/);
+        if (match) {
+            const key = match[1].trim();
+            let value = match[2].trim();
+
+            // Special handling for Block-UUID and Parent-UUID
+            if (key === "Block-UUID" || key === "Parent-UUID") {
+                if (value !== 'N/A') {
+                    const uuidValidation = validateUUID(value); // Use imported function
+                    if (uuidValidation["Block-UUID"] === "INVALID UUID") {
+                        // Store invalid status and the suggested correction
+                        headerObject[key] = "INVALID UUID";
+                        headerObject[`Correct ${key}`] = uuidValidation["Correct Block-UUID"];
+                    } else {
+                        headerObject[key] = value;
+                    }
+                } else {
+                    headerObject[key] = value; // Keep 'N/A' as is
+                }
+            } else {
+                headerObject[key] = value;
+            }
+        } else {
+            // Do nothing since some lines will just have something like `/*` or `*/`  
+        }
+    }
+
+    // Check required fields
+    const requiredFields = [
+        'Component',
+        'Block-UUID',
+        'Version', // Keep Version as string here, handle parsing elsewhere if needed
+        'Language',
+        'Created-at',
+        'Authors'
+    ];
+
+    // Special handling for Parent-UUID - if missing, set it to 'N/A'
+    if (!('Parent-UUID' in headerObject)) {
+        headerObject['Parent-UUID'] = 'N/A';
+    }
+
+    for (const field of requiredFields) {
+        if (!(field in headerObject)) {
+            missingFields.push(field);
+        }
+    }
+
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
+    }
+
+    // Validate timestamp format
+    if (!isValidISOTimestamp(headerObject['Created-at'])) { // Use local function
+        throw new Error('Invalid ISO 8601 timestamp format in Created-at field');
+    }
+
+    // Validate Version format (simple check for X.Y.Z structure)
+    const versionPattern = /^\d+\.\d+\.\d+$/;
+    if (typeof headerObject['Version'] !== 'string' || !versionPattern.test(headerObject['Version'])) {
+         throw new Error(`Invalid Version format: "${headerObject['Version']}". Expected format X.Y.Z`);
+    }
+
+
+    return headerObject;
+}
+
+/**
+ * Calculates the total number of lines a code block's header occupies,
+ * including the comment block and the two blank lines that follow it.
+ * This is crucial for correctly adjusting line numbers in patches.
+ *
+ * @param {string} headerText - The raw string content of the header comment block
+ * @param {string} language - The programming language of the code block.
+ * @returns {number} The total number of lines the header occupies in the full code block.
+ */
+function getHeaderLineCount(headerText, language) {
+    if (typeof headerText !== 'string') {
+        return 2; // Default to 2 blank lines if no header text
+    }
+
+    // The headerText already includes the comment delimiters if they are multi-line.
+    // We just need to count the lines in the headerText and add the 2 blank lines.
+    const linesInHeaderCommentBlock = headerText.split('\n').length;
+
+    // Add 2 for the mandatory blank lines between the header comment block and the code implementation.
+    return linesInHeaderCommentBlock + 2;
+}
+
+
+module.exports = {
+    isValidISOTimestamp,
+    parseHeader,
+    getHeaderLineCount // Export the new function
+};

package/src/CodeBlockUtils/index.js

@@ -0,0 +1,83 @@
+/**
+ * Component: CodeBlockUtils Index
+ * Block-UUID: 7e9d3f8a-1b2c-4d5e-8f9a-0123456789ab
+ * Parent-UUID: a3b9c8d1-e0f2-4a1b-8c7d-5e6f0a9b1c2d
+ * Version: 1.4.0
+ * Description: Aggregates and exports all utilities related to code block processing from the CodeBlockUtils module. Serves as the main entry point for this module.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T16:02:20.217Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Claude 3.7 Sonnet (v1.2.0), Gemini 2.5 Pro (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
+ */
+
+
+// Import from individual utility files
+const { COMMENT_STYLES } = require('./constants');
+const { generateUUID, validateUUID } = require('./uuidUtils');
+const { isValidISOTimestamp, parseHeader, getHeaderLineCount } = require('./headerUtils');
+const { findAllCodeFences, matchFencesAndExtractBlocks, extractCodeBlocksWithUUIDs, findCodeBlockByUUID } = require('./blockExtractor');
+const { processCodeBlocks, extractCodeBlocks, fixTextCodeBlocks } = require('./blockProcessor');
+const { containsPatch } = require('./patchIntegration');
+const { detectCodeBlockRelationships, detectIncompleteCodeBlock, extractFilePaths } = require('./relationshipUtils');
+const { extractContinuationInfo, generateContinuationPrompt } = require('./continuationUtils');
+const { parseCodeBlocks: parseCommentDelimitedBlocks } = require('./headerParser');
+const { removeCodeBlockMarkers } = require('./markerRemover');
+const { updateCodeBlockByIndex, updateCodeBlockByUUID, updateCodeBlock, updateCodeBlockInMessage, deleteCodeBlockByIndex } = require('./updateCodeBlock');
+const { formatWithLineNumbers, formatBlockWithLineNumbers, formatBlocksWithLineNumbers, removeLineNumbers } = require('./lineNumberFormatter');
+
+// Export all imported items
+module.exports = {
+    // Constants
+    COMMENT_STYLES,
+
+    // UUID Utilities
+    generateUUID,
+    validateUUID,
+
+    // Header/Timestamp Utilities
+    isValidISOTimestamp,
+    parseHeader, // Parses headers from markdown blocks
+    getHeaderLineCount, // New: Calculates header line count
+
+    // Block Extraction (Markdown Fences)
+    findAllCodeFences,
+    matchFencesAndExtractBlocks,
+    extractCodeBlocksWithUUIDs,
+    findCodeBlockByUUID,
+
+    // Block Processing (Markdown Fences)
+    processCodeBlocks, // Core processor, returns detailed info
+    extractCodeBlocks, // Simpler API wrapper
+    fixTextCodeBlocks, // Fixes UUIDs in markdown blocks
+
+    // Patch Integration
+    containsPatch,
+
+    // Relationship/Context Utilities
+    detectCodeBlockRelationships,
+    detectIncompleteCodeBlock,
+    extractFilePaths,
+
+    // Continuation Utilities
+    extractContinuationInfo,
+    generateContinuationPrompt,
+
+    // Comment-Delimited Header Parsing
+    parseCommentDelimitedBlocks,
+
+    // Marker Removal
+    removeCodeBlockMarkers,
+
+    // Code Block Updating Utilities
+    updateCodeBlockByIndex,
+    updateCodeBlockByUUID,
+    updateCodeBlock,
+    updateCodeBlockInMessage,
+    deleteCodeBlockByIndex,
+
+    // Line Number Formatting Utilities
+    formatWithLineNumbers,
+    formatBlockWithLineNumbers,
+    formatBlocksWithLineNumbers,
+    removeLineNumbers,
+};
+