@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/patchHeaderFormatter.js

@@ -0,0 +1,143 @@
+/**
+ * Component: PatchUtils Header Formatter
+ * Block-UUID: 87821582-84d4-46c1-ba5f-ea2591fba1bb
+ * Parent-UUID: 1a8f5d2e-c7b9-4e0a-8d1f-9c3b0a4e2f1a
+ * Version: 1.0.0
+ * Description: Formats the metadata header for a new code block created after applying a patch.
+ * Language: JavaScript
+ * Created-at: 2025-04-18T02:59:04.322Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+/**
+ * Formats the metadata header for a new code block based on source info and patch metadata.
+ * Follows the rules specified in the System Prompt for metadata inheritance and updates.
+ *
+ * @param {object} sourceBlockInfo - The block info object for the source code block (from CodeBlockService).
+ *                                   Expected to have a `header` property with source metadata.
+ * @param {object} patchBlock - The parsed patch block object (e.g., from patchParser.findAllPatches).
+ *                              Expected to have a `metadata` property with patch metadata.
+ * @returns {string} The formatted code block header string with appropriate comment syntax.
+ * @throws {Error} If required source or patch metadata is missing.
+ */
+function formatCodeBlockHeader(sourceBlockInfo, patchBlock) {
+    // --- Function body from original PatchUtils.formatCodeBlockHeader ---
+    // --- (Copied Verbatim) ---
+    if (!sourceBlockInfo || !sourceBlockInfo.header) {
+        throw new Error("formatCodeBlockHeader: Missing sourceBlockInfo or sourceBlockInfo.header.");
+    }
+    if (!patchBlock || !patchBlock.metadata) {
+        throw new Error("formatCodeBlockHeader: Missing patchBlock or patchBlock.metadata.");
+    }
+
+    const sourceHeader = sourceBlockInfo.header;
+    const patchMetadata = patchBlock.metadata;
+
+    // --- Validate required fields ---
+    const requiredSource = ['Component', 'Language', 'Description', 'Block-UUID', 'Version', 'Authors'];
+    const requiredPatch = ['Source-Block-UUID', 'Target-Block-UUID', 'Source-Version', 'Target-Version', 'Authors'];
+
+    requiredSource.forEach(key => {
+        if (!sourceHeader[key]) throw new Error(`formatCodeBlockHeader: Missing required source metadata key: ${key}`);
+    });
+    requiredPatch.forEach(key => {
+        if (!patchMetadata[key]) throw new Error(`formatCodeBlockHeader: Missing required patch metadata key: ${key}`);
+    });
+
+    // --- Construct New Metadata Object ---
+    const newMetadata = {
+        'Component': sourceHeader['Component'], // Preserve from source
+        'Block-UUID': patchMetadata['Target-Block-UUID'], // Use Target UUID from patch
+        'Parent-UUID': patchMetadata['Source-Block-UUID'], // Use Source UUID from patch as Parent
+        'Version': patchMetadata['Target-Version'], // Use Target Version from patch
+        'Description': sourceHeader['Description'], // Preserve Description from source
+        'Language': sourceHeader['Language'], // Preserve Language from source
+        'Created-at': new Date().toISOString(), // New timestamp
+        'Authors': patchMetadata['Authors'] // Use Authors list from patch
+    };
+
+    const language = newMetadata['Language'].toLowerCase();
+    let headerLines = [];
+    let commentStart = '';
+    let commentEnd = '';
+    let linePrefix = '';
+
+    // --- Determine Comment Style ---
+    // Based on Code Block Header Format Rules in System Prompt
+    switch (language) {
+        case 'python':
+        case 'py':
+            commentStart = '"""';
+            commentEnd = '"""';
+            break;
+        case 'javascript':
+        case 'js':
+        case 'typescript':
+        case 'ts':
+        case 'java':
+        case 'c':
+        case 'cpp':
+        case 'csharp':
+        case 'cs':
+        case 'go':
+        case 'php':
+        case 'swift':
+        case 'kotlin':
+        case 'rust':
+        case 'css':
+        case 'scss':
+        case 'less':
+            commentStart = '/**';
+            linePrefix = ' * ';
+            commentEnd = ' */';
+            break;
+        case 'ruby':
+        case 'rb':
+            commentStart = '=begin';
+            commentEnd = '=end';
+            break;
+        case 'html':
+        case 'xml':
+        case 'svg':
+            commentStart = '<!--';
+            linePrefix = ' '; // Optional: Add space for readability inside comment
+            commentEnd = '-->';
+            break;
+        case 'bash':
+        case 'sh':
+        case 'shell':
+        case 'yaml':
+        case 'yml':
+        case 'perl':
+        case 'powershell':
+        case 'ps1':
+        // Add other languages using # for single-line comments
+        default: // Default to # for unknown or simple languages
+            linePrefix = '# ';
+            break;
+    }
+
+    // --- Format Metadata Lines ---
+    const metadataOrder = [
+        'Component', 'Block-UUID', 'Parent-UUID', 'Version',
+        'Description', 'Language', 'Created-at', 'Authors'
+    ];
+
+    if (commentStart) headerLines.push(commentStart);
+
+    metadataOrder.forEach(key => {
+        if (newMetadata[key]) {
+            headerLines.push(`${linePrefix}${key}: ${newMetadata[key]}`);
+        }
+    });
+
+    if (commentEnd) headerLines.push(commentEnd);
+
+    return headerLines.join('\n');
+    // --- End of Function Body ---
+}
+
+module.exports = {
+    formatCodeBlockHeader
+};

package/src/PatchUtils/patchParser.js

@@ -0,0 +1,289 @@
+/**
+ * Component: PatchUtils Parser
+ * Block-UUID: ce634df9-ff99-482a-a261-56ab34a2546e
+ * Parent-UUID: fcc85ec1-0146-40bf-a937-6f7928258cbf
+ * Version: 1.1.0
+ * Description: Handles parsing, validation, extraction, and detection of traditional unified diff patches. Extracts metadata and raw diff content.
+ * Language: JavaScript
+ * Created-at: 2025-04-18T02:59:04.322Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0)
+ */
+
+
+const { isValidVersion } = require('../SharedUtils/versionUtils'); // Assuming SharedUtils is one level up
+
+/**
+ * Determines the type of patch format used based on markers.
+ * Primarily looks for traditional unified diff markers after metadata.
+ * @param {string} patchText - The patch text
+ * @returns {string} 'traditional', or 'unknown'
+ */
+function determinePatchFormat(patchText) {
+    if (!patchText || typeof patchText !== 'string') {
+        return 'unknown';
+    }
+
+    // Check for required metadata header first
+    if (!patchText.includes('# Patch Metadata')) {
+        return 'unknown'; // Must have metadata header
+    }
+
+    // Check for traditional unified diff markers *after* potential metadata and start marker
+    // Look for ---, +++, @@ after the start marker
+    const startMarkerIndex = patchText.indexOf('# --- PATCH START MARKER ---');
+    if (startMarkerIndex === -1) {
+        return 'unknown'; // Must have start marker
+    }
+
+    const contentAfterMarker = patchText.substring(startMarkerIndex);
+
+    // Use regex for more reliable detection within the content part
+    const traditionalMarkers = /^\s*--- Original\s*\n\s*\+\+\+ Modified\s*\n\s*@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
+
+    if (traditionalMarkers.test(contentAfterMarker)) {
+        return 'traditional';
+    }
+
+    // Removed check for obsolete '@=' context marker
+
+    return 'unknown'; // Format doesn't match expected traditional structure after markers
+}
+
+/**
+ * Extracts metadata from a patch block.
+ * Stops at the first sign of patch content (---, +++, @@, start marker).
+ * @param {string} patchText - The patch text including metadata.
+ * @returns {Object} Extracted metadata object.
+ */
+function extractPatchMetadata(patchText) {
+    if (!patchText) {
+        return {};
+    }
+
+    const metadata = {};
+    const lines = patchText.split('\n');
+    let inMetadata = true;
+
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+
+        // Stop processing metadata if we hit content markers or the start marker
+        if (trimmedLine === '# --- PATCH START MARKER ---' ||
+            line.startsWith('--- ') || // Standard diff header start
+            line.startsWith('+++ ') || // Standard diff header start
+            line.startsWith('@@ '))   // Standard diff hunk header start
+        {
+            inMetadata = false;
+            break; // Stop reading metadata
+        }
+
+        // Parse metadata lines (format: # Key: Value)
+        if (trimmedLine.startsWith('# ')) {
+            const metaLine = line.substring(line.indexOf('# ') + 2); // Get content after '# '
+            const colonIndex = metaLine.indexOf(':');
+
+            if (colonIndex > 0) {
+                const key = metaLine.substring(0, colonIndex).trim();
+                const value = metaLine.substring(colonIndex + 1).trim();
+                // Only add if key is not empty
+                if (key) {
+                    metadata[key] = value;
+                }
+            }
+            // Allow lines that are just comments (e.g., # Description continued)
+        } else if (trimmedLine !== '' && !trimmedLine.startsWith('# Patch Metadata')) {
+            // If we encounter non-empty, non-comment lines before the start marker,
+            // it's likely malformed, stop metadata parsing.
+            inMetadata = false;
+            break;
+        }
+    }
+
+    return metadata;
+}
+
+/**
+ * Validates patch metadata for required fields and version format.
+ * @param {Object} metadata - Patch metadata object extracted by extractPatchMetadata.
+ * @returns {Array<string>} Array of error messages, empty if valid.
+ */
+function validatePatchMetadata(metadata) {
+    const errors = [];
+    const requiredFields = [
+        'Source-Block-UUID',
+        'Target-Block-UUID',
+        'Source-Version',
+        'Target-Version',
+        'Description',
+        'Authors'
+    ];
+
+    for (const field of requiredFields) {
+        // Check for presence and non-empty string value
+        if (!metadata[field] || typeof metadata[field] !== 'string' || metadata[field].trim() === '') {
+            errors.push(`Missing or empty required metadata field: ${field}`);
+        }
+    }
+
+    // Validate version format if present
+    if (metadata['Source-Version'] && !isValidVersion(metadata['Source-Version'])) { // Use imported validator
+        errors.push(`Invalid Source-Version format: "${metadata['Source-Version']}". Expected X.Y.Z`);
+    }
+
+    if (metadata['Target-Version'] && !isValidVersion(metadata['Target-Version'])) { // Use imported validator
+        errors.push(`Invalid Target-Version format: "${metadata['Target-Version']}". Expected X.Y.Z`);
+    }
+
+    // Validate UUIDs are not the template string
+    if (metadata['Source-Block-UUID'] === '12d8a596-0620-4725-ba49-ae6fccdfa2ad') {
+        errors.push('Source-Block-UUID contains placeholder value "f016e2e4-f97f-4ffe-9f46-ea48f59a3eea".');
+    }
+     if (metadata['Target-Block-UUID'] === '5bfb717c-aaec-462e-a50e-d096aba0d63f') {
+        errors.push('Target-Block-UUID contains placeholder value "12e76392-f0ac-4c9d-a5be-c98401487352".');
+    }
+
+    return errors;
+}
+
+/**
+ * Extracts the raw unified diff content between the start and end markers.
+ * Includes lines with 'NNN: ' prefixes. Excludes the markers themselves.
+ * @param {string} patchText - Full patch text with metadata and markers.
+ * @param {string} format - Expected format (should be 'traditional').
+ * @returns {string} Raw unified diff content, or empty string if not found/invalid.
+ */
+function extractPatchContent(patchText, format) {
+    if (!patchText || format !== 'traditional') {
+        return "";
+    }
+
+    const lines = patchText.split('\n');
+    let contentLines = [];
+    let inContentBlock = false;
+
+    for (const line of lines) {
+        if (line.trim() === '# --- PATCH START MARKER ---') {
+            inContentBlock = true;
+            continue; // Skip the marker line itself
+        }
+
+        if (line.trim() === '# --- PATCH END MARKER ---') {
+            inContentBlock = false;
+            break; // Stop processing once end marker is found
+        }
+
+        if (inContentBlock) {
+            contentLines.push(line);
+        }
+    }
+
+    return contentLines.join('\n');
+}
+
+// Removed extractContextPatches function (obsolete context format)
+
+/**
+ * Determines if a code block's content represents a patch block
+ * by checking for the mandatory metadata header.
+ * @param {string} codeBlockContent - The content of the code block (between fences).
+ * @returns {boolean} True if the code block is a patch.
+ */
+function isPatchBlock(codeBlockContent) {
+    if (!codeBlockContent || typeof codeBlockContent !== 'string') {
+        return false;
+    }
+    // Check for the mandatory metadata header using a regex for robustness
+    // Allows for potential whitespace variations
+    return /^\s*#\s*Patch Metadata\s*\n/.test(codeBlockContent);
+}
+
+/**
+ * Detects the first valid patch block within a larger message text.
+ * @param {string} messageText - The message text to analyze.
+ * @returns {Object|null} Patch information object { patchText, metadata, sourceBlockUUID, targetBlockUUID, startIndex, endIndex } or null if no valid patch found.
+ */
+function detectPatch(messageText) {
+    if (!messageText || typeof messageText !== 'string') {
+        return null;
+    }
+
+    // Find the first code block that contains patch metadata
+    // Regex looks for ``` optionally followed by 'diff' language hint
+    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockRegex.exec(messageText)) !== null) {
+        const blockContent = match[1];
+        if (isPatchBlock(blockContent)) { // Use isPatchBlock for check
+             const metadata = extractPatchMetadata(blockContent); // Use extractPatchMetadata
+             // Basic validation: Check for essential UUIDs
+             if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
+                 metadata['Source-Block-UUID'] !== '26f930c9-2bc8-4906-bdf5-469700b2f857' && // Check placeholders
+                 metadata['Target-Block-UUID'] !== '48a957eb-dd72-44bb-84a2-0df3c7cb16ed')
+             {
+                 return {
+                     patchText: blockContent, // Return the content inside the fence
+                     metadata,
+                     sourceBlockUUID: metadata['Source-Block-UUID'],
+                     targetBlockUUID: metadata['Target-Block-UUID'],
+                     startIndex: match.index, // Store block position if needed
+                     endIndex: match.index + match[0].length
+                 };
+             }
+        }
+    }
+
+    return null; // No valid patch block found
+}
+
+/**
+ * Finds all valid patch blocks within a message text.
+ * @param {string} messageText - The message text to analyze.
+ * @returns {Array<Object>} Array of patch information objects.
+ */
+function findAllPatches(messageText) {
+    if (!messageText || typeof messageText !== 'string') {
+        return [];
+    }
+
+    const patches = [];
+    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+
+    let match;
+    while ((match = codeBlockRegex.exec(messageText)) !== null) {
+        const blockContent = match[1];
+
+        if (isPatchBlock(blockContent)) {
+            const metadata = extractPatchMetadata(blockContent);
+
+            // Basic validation: Check for essential UUIDs and non-placeholder values
+            if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
+                metadata['Source-Block-UUID'] !== 'e898f14f-14f6-4710-b35b-1cf3478fb5da' &&
+                metadata['Target-Block-UUID'] !== '0093be2a-fd84-4925-a0c1-13f8a8260cbf')
+            {
+                patches.push({
+                    patchText: blockContent,
+                    metadata,
+                    sourceBlockUUID: metadata['Source-Block-UUID'],
+                    targetBlockUUID: metadata['Target-Block-UUID'],
+                    startIndex: match.index,
+                    endIndex: match.index + match[0].length
+                });
+            }
+        }
+    }
+
+    return patches;
+}
+
+
+module.exports = {
+    // Removed validateAndParseContextPatch
+    determinePatchFormat,
+    extractPatchMetadata,
+    validatePatchMetadata,
+    extractPatchContent,
+    // Removed extractContextPatches
+    isPatchBlock,
+    detectPatch,
+    findAllPatches,
+};