@gitsense/gsc-utils 0.1.0

package/src/CodeBlockUtils/lineNumberFormatter.js

@@ -0,0 +1,117 @@
+/**
+ * Component: CodeBlockUtils Line Number Formatter
+ * Block-UUID: 94373ca5-bd2f-487d-81d6-6b654867e972
+ * Parent-UUID: e7ff9961-a0cd-4f4b-b80a-65338a2207b0
+ * Version: 1.0.0
+ * Description: Provides a function to format code content with padded line numbers to aid in patch generation.
+ * Language: JavaScript
+ * Created-at: 2025-04-18T01:13:55.824Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0)
+ */
+
+
+/**
+ * Formats code content by adding padded line numbers to each line.
+ * The line numbers are formatted with right-aligned padding and a colon separator.
+ * 
+ * @param {string} codeContent - The raw code content to format with line numbers
+ * @param {number} [startLine=1] - The line number to start counting from (default: 1)
+ * @param {number} [paddingWidth=0] - Fixed padding width. If 0, automatically calculated based on total lines
+ * @returns {string} The formatted code with line numbers
+ */
+function formatWithLineNumbers(codeContent, startLine = 1, paddingWidth = 0) {
+    if (typeof codeContent !== 'string') {
+        throw new Error("codeContent must be a string");
+    }
+    
+    // Handle empty content
+    if (codeContent.trim() === '') {
+        return '';
+    }
+    
+    // Split the content into lines
+    const lines = codeContent.split('\n');
+    
+    // Calculate the width needed for the line numbers if not specified
+    const totalLines = lines.length;
+    const calculatedWidth = paddingWidth || Math.max(String(startLine + totalLines - 1).length, 3);
+    
+    // Format each line with a padded line number
+    return lines.map((line, index) => {
+        const lineNumber = startLine + index;
+        const paddedNumber = String(lineNumber).padStart(calculatedWidth, ' ');
+        return `${paddedNumber}: ${line}`;
+    }).join('\n');
+}
+
+/**
+ * Formats a code block object by adding line numbers to its code content.
+ * Only applies to blocks of type 'code', not 'patch'.
+ * 
+ * @param {Object} block - The processed code block object from processBlockContent
+ * @param {number} [startLine=1] - The line number to start counting from
+ * @param {number} [paddingWidth=0] - Fixed padding width. If 0, automatically calculated
+ * @returns {Object} A new block object with formatted content
+ */
+function formatBlockWithLineNumbers(block, startLine = 1, paddingWidth = 0) {
+    // Create a shallow copy of the block to avoid modifying the original
+    const formattedBlock = { ...block };
+    
+    // Only format code blocks, not patch blocks
+    if (block.type === 'code' && typeof block.content === 'string') {
+        formattedBlock.content = formatWithLineNumbers(block.content, startLine, paddingWidth);
+        formattedBlock.hasLineNumbers = true;
+    }
+    
+    return formattedBlock;
+}
+
+/**
+ * Formats all code blocks in a processed blocks array with line numbers.
+ * 
+ * @param {Array} blocks - Array of processed block objects
+ * @param {number} [startLine=1] - The line number to start counting from for each block
+ * @param {number} [paddingWidth=0] - Fixed padding width. If 0, automatically calculated per block
+ * @returns {Array} A new array of blocks with formatted content
+ */
+function formatBlocksWithLineNumbers(blocks, startLine = 1, paddingWidth = 0) {
+    if (!Array.isArray(blocks)) {
+        throw new Error("blocks must be an array");
+    }
+    
+    return blocks.map(block => formatBlockWithLineNumbers(block, startLine, paddingWidth));
+}
+
+/**
+ * Removes line numbers from formatted code content.
+ * 
+ * @param {string} formattedContent - The code content with line numbers
+ * @returns {string} The original code content without line numbers
+ */
+function removeLineNumbers(formattedContent) {
+    if (typeof formattedContent !== 'string') {
+        throw new Error("formattedContent must be a string");
+    }
+    
+    // Handle empty content
+    if (formattedContent.trim() === '') {
+        return '';
+    }
+    
+    // Regular expression to match the line number pattern
+    const lineNumberPattern = /^\s*\d+:\s/;
+    
+    // Split the content into lines and remove the line number prefix from each
+    return formattedContent.split('\n')
+        .map(line => line.replace(lineNumberPattern, ''))
+        .join('\n');
+}
+
+// Export the functions
+module.exports = {
+    formatWithLineNumbers,
+    formatBlockWithLineNumbers,
+    formatBlocksWithLineNumbers,
+    removeLineNumbers
+};
+

package/src/CodeBlockUtils/markerRemover.js

@@ -0,0 +1,89 @@
+/**
+ * Component: CodeBlockUtils Marker Remover
+ * Block-UUID: 40490e16-a9a3-4e93-b36b-5e9469cd2faf
+ * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
+ * Version: 1.0.0
+ * Description: Removes custom '--- CODE BLOCK START ---' and '--- CODE BLOCK COMPLETE ---' markers surrounding markdown code blocks, only when both markers are present for a block.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T16:01:34.371Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+/**
+ * Removes code block start and complete markers from markdown text,
+ * but only when both markers are present for a given code block.
+ *
+ * @param {string} markdownText - The markdown text containing code blocks with markers
+ * @returns {string} - The markdown text with complete code block markers removed
+ */
+function removeCodeBlockMarkers(markdownText) {
+  // Pattern to match a code block with both start and complete markers
+  // Ensures robust matching with potential variations in whitespace/newlines
+  const pattern = /---\s*CODE BLOCK START\s*---\s*```([\s\S]*?)```\s*---\s*CODE BLOCK COMPLETE\s*---/gs;
+
+  // Replace all instances where both markers are present
+  const result = markdownText.replace(pattern, (match, codeBlockContent) => {
+    // Return the standard markdown block without the custom markers
+    // Ensure consistent newline handling around the captured content
+    return '```' + codeBlockContent.trim() + '\n```';
+  });
+
+  return result;
+}
+
+// Example usage (kept commented out)
+/*
+function testRemoveCodeBlockMarkers() {
+  const exampleText = `
+# Example Markdown
+
+Here's a code block:
+
+--- CODE BLOCK START ---
+
+\`\`\`javascript
+function hello() {
+  console.log("Hello, World!");
+}
+\`\`\`
+
+--- CODE BLOCK COMPLETE ---
+
+And here's another one:
+
+--- CODE BLOCK START ---
+\`\`\`python
+def hello():
+    print("Hello, World!")
+\`\`\`
+--- CODE BLOCK COMPLETE ---
+
+Here's an incomplete one that won't be modified:
+
+--- CODE BLOCK START ---
+
+\`\`\`bash
+echo "Hello, World!"
+\`\`\`
+
+And some more text.
+
+A block without markers:
+\`\`\`text
+Plain text block.
+\`\`\`
+`;
+
+  const cleanedText = removeCodeBlockMarkers(exampleText);
+  console.log("Original Text:\n", exampleText);
+  console.log("\nCleaned Text:\n", cleanedText);
+}
+
+// Uncomment to run the example
+// testRemoveCodeBlockMarkers();
+*/
+
+// Export the function for Node.js environments
+// (Removed the check `if (typeof module !== 'undefined' && module.exports)` as it's standard in Node)
+module.exports = { removeCodeBlockMarkers };

package/src/CodeBlockUtils/patchIntegration.js

@@ -0,0 +1,38 @@
+/**
+ * Component: CodeBlockUtils Patch Integration
+ * Block-UUID: 9f7395ef-e213-4841-a95d-f263e422288a
+ * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
+ * Version: 1.0.0
+ * Description: Provides functions to detect the presence of patch blocks within text content using the core block processing logic.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T15:58:19.198Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+// Dependency on the core block processor
+const { processCodeBlocks } = require('./blockProcessor');
+
+/**
+ * Checks if the provided text content contains at least one patch block.
+ * @param {string} content - The text content to check.
+ * @param {Object} options - Options passed to processCodeBlocks (e.g., silent).
+ * @returns {boolean} - True if a patch block is found, false otherwise.
+ */
+function containsPatch(content, options = { silent: true }) {
+    // Use the core processor to get all blocks
+    const { blocks } = processCodeBlocks(content, options);
+
+    // Check if any processed block is of type 'patch'
+    for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i].type === 'patch') {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    containsPatch
+};

package/src/CodeBlockUtils/relationshipUtils.js

@@ -0,0 +1,159 @@
+/**
+ * Component: CodeBlockUtils Relationship Utilities
+ * Block-UUID: cde52e7f-97c6-4680-8a81-75459f10dae9
+ * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
+ * Version: 1.0.0
+ * Description: Provides functions to detect relationships between code blocks (parent-child, patches) and extract structural information like file paths or incomplete blocks from text.
+ * Language: JavaScript
+ * Created-at: 2025-04-15T15:58:56.290Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+// Dependency on the core block processor
+const { processCodeBlocks } = require('./blockProcessor');
+
+/**
+ * Detects special code block relationships in a message, such as patches or parent-child links.
+ * Assumes a 'codeBlockService' object with a 'getBlockInfo(uuid)' method is available in the calling context
+ * to verify the existence of parent UUIDs. This dependency might need to be injected or handled differently
+ * depending on the application architecture.
+ *
+ * @param {string} content - The message content.
+ * @param {Object} codeBlockService - An object/service instance with a method `getBlockInfo(uuid)`
+ *                                    that returns information about a block UUID (or null/undefined if not found).
+ * @param {Object} options - Options passed to processCodeBlocks (e.g., silent).
+ * @returns {Object} Object containing detection results:
+ *                   { blocks: Array, warnings: Array, containsPatch: boolean, hasParentChildRelationship: boolean, needsControls: boolean }
+ */
+function detectCodeBlockRelationships(content, codeBlockService, options = { silent: true }) {
+    if (!content || typeof content !== 'string') {
+        return {
+            blocks: [],
+            warnings: [{ type: 'invalid_input', message: 'Input content must be a non-empty string.' }],
+            containsPatch: false,
+            hasParentChildRelationship: false,
+            needsControls: false
+        };
+    }
+     // Ensure codeBlockService and its method exist
+     if (!codeBlockService || typeof codeBlockService.getBlockInfo !== 'function') {
+         console.warn("Warning: detectCodeBlockRelationships requires a valid codeBlockService with a getBlockInfo method.");
+         // Proceed without parent check if service is missing, but relationship detection will be incomplete.
+         codeBlockService = { getBlockInfo: () => null }; // Dummy service
+     }
+
+
+    // Extract all code blocks using the core processor
+    const { blocks, warnings } = processCodeBlocks(content, options);
+
+    let hasPatch = false;
+    let hasParentChildRelationship = false;
+
+    if (blocks && blocks.length > 0) {
+        for (const block of blocks) {
+            // Check for patch type
+            if (block.type === 'patch') {
+                hasPatch = true;
+                // Continue checking other blocks for parent-child relationships
+            }
+            // Check for parent-child relationship in code blocks
+            else if (block.type === 'code') {
+                const blockUUID = block.header?.['Block-UUID'];
+                const parentUUID = block.header?.['Parent-UUID'];
+
+                // Check if Parent-UUID is valid and not 'N/A'
+                if (blockUUID && parentUUID && parentUUID !== 'N/A' && parentUUID !== 'INVALID UUID') {
+                    // Check if parent exists using the provided service
+                    try {
+                        const parentInfo = codeBlockService.getBlockInfo(parentUUID);
+                        if (parentInfo) {
+                            hasParentChildRelationship = true;
+                            // If we find one relationship, we know controls might be needed,
+                            // but continue checking other blocks in case they also contain patches.
+                        }
+                    } catch (serviceError) {
+                         console.error(`Error calling codeBlockService.getBlockInfo for UUID ${parentUUID}:`, serviceError);
+                         // Add a warning? For now, just log it.
+                         warnings.push({
+                             position: block.position,
+                             type: 'service_error',
+                             message: `Error checking parent UUID ${parentUUID}: ${serviceError.message}`
+                         });
+                    }
+                }
+            }
+             // If both are found, no need to check further blocks
+             if (hasPatch && hasParentChildRelationship) {
+                 break;
+             }
+        }
+    }
+
+    // Determine if we need special controls (e.g., apply patch buttons, view parent buttons)
+    const needsControls = hasPatch || hasParentChildRelationship;
+
+    return {
+        blocks, // Return the processed blocks as well
+        warnings,
+        containsPatch: hasPatch,
+        hasParentChildRelationship,
+        needsControls
+    };
+}
+
+/**
+ * Detects if a message contains an incomplete code block using the core processor.
+ * @param {string} content - The message content.
+ * @param {Object} options - Options passed to processCodeBlocks (e.g., silent).
+ * @returns {Object} Object containing detection results:
+ *                   { hasIncompleteBlocks: boolean, incompleteBlock: Object|null }
+ *                   'incompleteBlock' is the *last* incomplete block found.
+ */
+function detectIncompleteCodeBlock(content, options = { silent: true }) {
+    if (!content || typeof content !== 'string') {
+        return {
+            hasIncompleteBlocks: false,
+            incompleteBlock: null
+        };
+    }
+
+    // Use the core processor which already identifies incomplete blocks
+    const { hasIncompleteBlocks, lastIncompleteBlock } = processCodeBlocks(content, options);
+
+    return {
+        hasIncompleteBlocks,
+        incompleteBlock: lastIncompleteBlock // Return the detailed last incomplete block object
+    };
+}
+
+/**
+ * Extracts file paths from specially formatted lines in a message.
+ * Assumes paths are marked like: #### File: `path/to/file.ext`
+ * @param {string} messageText - The message text.
+ * @returns {Array<string>} Array of extracted file paths.
+ */
+function extractFilePaths(messageText) {
+    if (!messageText || typeof messageText !== 'string') {
+        return [];
+    }
+
+    // Regex to find the specific file path format
+    const filePathRegex = /^####\s+File:\s+`([^`]+)`/gm; // Use ^ and gm for line-based matching
+    const filePaths = [];
+    let match;
+
+    while ((match = filePathRegex.exec(messageText)) !== null) {
+        // match[1] contains the captured path inside the backticks
+        filePaths.push(match[1]);
+    }
+
+    return filePaths;
+}
+
+
+module.exports = {
+    detectCodeBlockRelationships,
+    detectIncompleteCodeBlock,
+    extractFilePaths
+};