@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/patchProcessor.js

@@ -0,0 +1,389 @@
+/**
+ * Component: PatchUtils Processor
+ * Block-UUID: 96ec8bca-9fc3-441b-b81f-6fefc840c626
+ * Parent-UUID: 9e5b8ae2-e978-4a20-b1dd-c044d9a5277f
+ * Version: 1.3.0
+ * Description: Handles applying, creating, and converting patches. Applies traditional unified diffs, cleaning line number prefixes from diff content before using jsdiff.
+ * Language: JavaScript
+ * Created-at: 2025-07-20T17:24:16.836Z
+ * 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 Flash (v1.2.0), Gemini 2.5 Flash Thinking (v1.3.0)
+ */
+
+
+const parser = require('./patchParser');
+const verifier = require('./patchVerifier');
+const jsdiff = require('diff');
+const { removeLineNumbers } = require('../CodeBlockUtils/lineNumberFormatter');
+
+/**
+ * Cleans line number prefixes ('NNN: ') from relevant lines in unified diff content.
+ * @param {string} diffContent - The raw unified diff content string.
+ * @returns {string} The cleaned diff content string, ready for jsdiff.
+ * @private
+ */
+function _cleanDiffContentLineNumbers(diffContent) {
+    if (!diffContent) {
+        return "";
+    }
+
+    const lines = diffContent.split('\n');
+    const cleanedLines = lines.map(line => {
+        // Only clean lines starting with '+', '-', or ' ' (context)
+        // Leave @@ headers and other markers alone.
+        if (
+            !line.startsWith('+++') &&
+            !line.startsWith('---') &&
+            (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))
+        ) {
+            const prefix = line[0]; // +, -, or space
+            // Preserve the prefix character in its own column
+            // The content starts after the prefix character
+            const contentWithoutPrefix = line.substring(1);
+
+            // Check if the content has a line number pattern (e.g., "12: ")
+            const lineNumberMatch = contentWithoutPrefix.match(/^\s*\d+:\s/);
+            if (lineNumberMatch) {
+                return prefix + contentWithoutPrefix.substring(lineNumberMatch[0].length);
+            }
+
+            return prefix + contentWithoutPrefix;
+        }
+        return line; // Return unchanged if not a diff content line
+    });
+    return cleanedLines.join('\n');
+}
+
+/**
+ * Apply patch against source code. Expects traditional unified diff format.
+ * Cleans line number prefixes from patch content before applying with jsdiff.
+ * @param {string} sourceText - Original source code (MUST NOT contain line numbers).
+ * @param {string} patchText - Full patch block content (metadata + unified diff with line numbers on diff lines).
+ * @returns {{
+ *   valid: boolean,
+ *   patchedText: string | null,
+ *   errors: string[]
+ * }} - Patch result with valid flag, patchedText (only if valid, without line numbers), and errors if any.
+ */
+function applyPatch(sourceText, patchText) {
+    if (sourceText === null || sourceText === undefined) { // Allow empty string source
+        return {
+            valid: false,
+            patchedText: null,
+            errors: ["Source code is null or undefined."]
+        };
+    }
+
+    if (!patchText) {
+        return {
+            valid: false,
+            patchedText: null,
+            errors: ["Patch text is empty or null."]
+        };
+    }
+
+    let patchApplied = null;
+
+    try {
+        // 1. Determine format (should be traditional)
+        const format = parser.determinePatchFormat(patchText);
+        if (format !== 'traditional') {
+            // Also handle 'context' explicitly as an error now
+            const errorMsg = format === 'context'
+                ? "Unsupported patch format: 'context'. Only 'traditional' unified diff is supported."
+                : `Unknown or invalid patch format detected: ${format}. Expected 'traditional' unified diff.`;
+            return { valid: false, patchedText: null, errors: [errorMsg] };
+        }
+
+        // 1.1. Play it safe and clean sourceText by removing potential line numbers
+        sourceText = removeLineNumbers(sourceText);
+
+        // 2. Extract metadata (optional for applying, but good practice)
+        const metadata = parser.extractPatchMetadata(patchText);
+        // Could add metadata validation here if needed, but applyPatch focuses on application
+
+        // 3. Extract the raw diff content
+        let rawDiffContent = parser.extractPatchContent(patchText, 'traditional');
+
+        if (!rawDiffContent && patchText.includes('@@')) {
+            // Check if content is missing but markers were present
+            console.warn("applyPatch: Patch text contains '@@' but no content was extracted between markers.");
+            // Proceed, jsdiff might handle empty diffs, or fail gracefully.
+        } else if (!rawDiffContent) {
+            return { valid: false, patchedText: null, errors: ["Could not extract diff content from patch text."] };
+        }
+
+        // 4. Apply the patch
+        const patchedResult = jsdiff.applyPatch(sourceText, rawDiffContent, { fuzzFactor: 0 });
+
+        if (patchedResult === false) {
+            // jsdiff.applyPatch returns false on failure
+            return {
+                valid: false,
+                patchedText: null,
+                errors: ["Patch could not be applied. Hunk mismatch or invalid patch format likely."]
+            };
+        }
+
+        // Success! patchedResult is the patched string
+        return {
+            valid: true,
+            patchedText: patchedResult,
+            errors: []
+        };
+    } catch (error) {
+        // Check if it's a jsdiff specific error if possible, otherwise generic
+        const errorMessage = error instanceof Error ? error.message : "Unexpected error during patch application.";
+        return {
+            valid: false,
+            patchedText: null,
+            errors: [errorMessage]
+        };
+    }
+}
+
+/**
+ * Creates a patch between two code versions
+ * @param {string} sourceText - Original source code (WITH line numbers NNN:)
+ * @param {string} targetCode - Modified source code (WITH line numbers NNN:)
+ * @param {Object} metadata - Patch metadata
+ * @param {string} filename - Optional filename for the diff header (defaults to 'Original')
+ * @returns {string} Patch in unified diff format with metadata and line numbers in diff lines
+ * @throws {Error} If patch creation fails.
+ */
+function createPatch(sourceText, targetCode, metadata = {}, filename = 'Original') {
+    if (sourceText === null || sourceText === undefined) {
+        throw new Error("createPatch: Source code is null or undefined");
+    }
+    if (targetCode === null || targetCode === undefined) {
+        throw new Error("createPatch: Target code is null or undefined");
+    }
+
+    try {
+        // --- CRITICAL: jsdiff needs CLEAN text ---
+        const cleanSource = removeLineNumbers(sourceText);
+        const cleanTarget = removeLineNumbers(targetCode);
+
+        // --- Generate standard diff ---
+        // Provide filenames for standard diff headers (--- filename \n +++ filename)
+        const diffResult = jsdiff.createPatch(filename, cleanSource, cleanTarget, '', '', { context: 3 });
+
+        // --- Post-process the diff to add line numbers back ---
+        const diffLines = diffResult.split('\n');
+        const outputLines = [];
+        let sourceLineCounter = 0; // 0-based index for original source lines array
+        const originalSourceLines = sourceText.split('\n'); // Keep original with numbers
+
+        // Skip the header lines generated by jsdiff (---, +++, @@) initially
+        let diffLineIndex = 0;
+        while (diffLineIndex < diffLines.length && !diffLines[diffLineIndex].startsWith('@@ ')) {
+            // Keep the standard --- and +++ headers, but potentially adjust filename if needed
+            if (diffLines[diffLineIndex].startsWith('--- ') || diffLines[diffLineIndex].startsWith('+++ ')) {
+                // Use conceptual filenames as per system prompt format
+                if (diffLines[diffLineIndex].startsWith('--- ')) outputLines.push('--- Original');
+                if (diffLines[diffLineIndex].startsWith('+++ ')) outputLines.push('+++ Modified');
+            } else {
+                // Keep other potential header lines if any (e.g., index) - unlikely with createPatch defaults
+                outputLines.push(diffLines[diffLineIndex]);
+            }
+            diffLineIndex++;
+        }
+
+        // Process hunks
+        while (diffLineIndex < diffLines.length) {
+            const line = diffLines[diffLineIndex];
+
+            if (line.startsWith('@@ ')) {
+                // Hunk header - Keep it as is, jsdiff generated it based on clean source,
+                // but the LLM expects it to reference the *numbered* source.
+                // This assumes the LLM correctly interprets these numbers against its numbered view.
+                outputLines.push(line);
+                // Extract starting line number from hunk to sync our sourceLineCounter
+                const match = line.match(/@@ -(\d+)/);
+                if (match && match[1]) {
+                    // jsdiff line numbers are 1-based, adjust to 0-based index
+                    sourceLineCounter = parseInt(match[1], 10) - 1;
+                } else {
+                    // This shouldn't happen with valid diffs, but handle defensively
+                    console.warn("Could not parse starting line number from hunk header:", line);
+                    // Attempt to continue, but line numbers might be wrong
+                }
+                diffLineIndex++;
+            } else if (line.startsWith(' ')) { // Context line
+                // Find the corresponding original line with number prefix
+                const originalLine = originalSourceLines[sourceLineCounter] ?? line.substring(1); // Fallback if out of sync
+                outputLines.push(` ${originalLine}`); // Add space prefix back
+                sourceLineCounter++;
+                diffLineIndex++;
+            } else if (line.startsWith('-')) { // Deletion line
+                const originalLine = originalSourceLines[sourceLineCounter] ?? line.substring(1);
+                outputLines.push(`-${originalLine}`); // Add dash prefix back
+                sourceLineCounter++; // Consume a line from the source
+                diffLineIndex++;
+            } else if (line.startsWith('+')) { // Addition line
+                // Additions don't have a direct corresponding *original* line number prefix.
+                // We need to add the prefix based on the *target* line number.
+                // This is tricky. For simplicity matching the LLM example, let's find the *next*
+                // non-deleted line's number in the original source OR increment if at end.
+                // A truly robust solution might need the target lines array.
+                // Let's use the *current* source line number for the prefix, as seen in the example patch.
+                const currentLineNumStr = String(sourceLineCounter + 1).padStart(3, ' '); // Rough padding
+                outputLines.push(`+${currentLineNumStr}: ${line.substring(1)}`); // Add plus prefix and generated number
+                // Do NOT increment sourceLineCounter for additions
+                diffLineIndex++;
+            } else if (line.trim() === '' || line === '\') {
+                // Keep blank lines and the "No newline" marker
+                outputLines.push(line);
+                diffLineIndex++;
+            } else {
+                // Unexpected line format in diff
+                console.warn("Unexpected line format in diff output:", line);
+                outputLines.push(line); // Keep it anyway?
+                diffLineIndex++;
+            }
+        }
+
+        const processedDiff = outputLines.join('\n');
+
+        // Format metadata
+        const formattedMetadata = _formatPatchMetadata(metadata); // Use internal helper
+
+        // Combine metadata, markers, and processed patch
+        return `${formattedMetadata}\n\n# --- PATCH START MARKER ---\n${processedDiff}\n# --- PATCH END MARKER ---`;
+
+    } catch (error) {
+        console.error("Error creating patch:", error);
+        throw new Error(`Failed to create patch: ${error.message}`);
+    }
+}
+
+/**
+ * Creates a patch between two full code block strings (including their metadata headers).
+ * The generated patch will contain the custom metadata header and adjusted hunk line numbers
+ * that account for the original code block's header.
+ *
+ * @param {object} CodeBlockUtils - Instance of CodeBlockUtils to work around circular dependencies
+ * @param {string} sourceCodeBlockText - The complete string of the original code block (including its metadata header).
+ * @param {string} targetCodeBlockText - The complete string of the modified code block (including its metadata header).
+ * @param {object} patchMetadata - An object containing the necessary metadata for the patch header (e.g., Source-Block-UUID, Target-Block-UUID, etc.).
+ * @returns {object} Patch in unified diff format, patch with custom metadata and adjusted line numbers.
+ * @throws {Error} If inputs are invalid or patch creation fails.
+ */
+function createPatchFromCodeBlocks(CodeBlockUtils, sourceCodeBlockText, targetCodeBlockText, patchMetadata = {}) {
+    if (typeof sourceCodeBlockText !== 'string' || typeof targetCodeBlockText !== 'string') {
+        throw new Error("createPatchFromCodeBlocks: Source and target code block texts must be strings.");
+    }
+
+    const [ sourceHeaderText ] = sourceCodeBlockText.split('\n\n\n');
+    const [ targetHeaderText ] = targetCodeBlockText.split('\n\n\n');
+
+    const sourceContentTemp = sourceCodeBlockText.split('\n\n\n'); sourceContentTemp.shift();
+    const sourceContent = sourceContentTemp.join('\n\n');
+
+    const targetContentTemp = targetCodeBlockText.split('\n\n\n'); targetContentTemp.shift();
+    const targetContent = targetContentTemp.join('\n\n');
+
+    // Get the number of lines in the header + two blank lines
+    const sourceHeaderLineCount = sourceHeaderText.split('\n').length;
+    const targetHeaderLineCount = targetHeaderText.split('\n').length;
+
+    // To keep things simple we are going to require the source and target header line count to be the same.
+    // By doing so, we can can just add the line count to the hunks
+    if (sourceHeaderLineCount !== targetHeaderLineCount) {
+        throw new Error('Source and target header line count must be the same');
+    }
+
+    const cleanSourceContent = sourceContent.trimEnd();
+    const cleanTargetContent = targetContent.trimEnd();
+
+    // 2. Generate raw diff on content only
+    const unadjustedDiffPatch = jsdiff.createTwoFilesPatch('Original', 'Modified', cleanSourceContent, cleanTargetContent, '', '', { context: 3, stripTrailingCr: true });
+
+    // 3. Post-process Diff to Adjust Line Numbers and Add NNN: Prefixes
+    const diffLines = unadjustedDiffPatch.split('\n');
+    const outputLines = [];
+    const outputDiffLines = [];
+
+    for (let i = 0; i < diffLines.length; i++) {
+        const line = diffLines[i];
+
+        if (!line.startsWith('@@ '))
+            continue;
+
+        // Hunk header: @@ -oldStart,oldCount +newStart,newCount @@
+        const match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (match) {
+            let oldStart = parseInt(match[1], 10);
+            let oldCount = match[2] ? parseInt(match[2], 10) : 1;
+            let newStart = parseInt(match[3], 10);
+            let newCount = match[4] ? parseInt(match[4], 10) : 1;
+
+            // Adjust line numbers to account for the header and 2 blank lines
+            oldStart += sourceHeaderLineCount + 2;
+            newStart += targetHeaderLineCount + 2;
+
+            const adjustedHeader = 
+                `@@ `+
+                `-${oldStart}${oldCount !== 1 ? ',' + oldCount : ''} `+
+                `+${newStart}${newCount !== 1 ? ',' + newCount : ''} `+
+                `@@`;
+
+            diffLines[i] = adjustedHeader; 
+        }
+    }
+
+    const adjustedDiffPatch = diffLines.join('\n');
+
+    // 4. Assemble Final Patch
+    const formattedMetadata = _formatPatchMetadata(patchMetadata);
+    const formatted = `${formattedMetadata}\n\n\n`+
+                      `# --- PATCH START MARKER ---\n`+
+                      `${adjustedDiffPatch}\n`+
+                      `# --- PATCH END MARKER ---`;
+    return {
+        formatted,
+        formattedMetadata,
+        unadjustedDiffPatch,
+        adjustedDiffPatch 
+    };
+}
+
+/**
+ * Formats patch metadata as string
+ * @param {Object} metadata - Patch metadata
+ * @returns {string} Formatted metadata string
+ * @private
+ */
+function _formatPatchMetadata(metadata) {
+    // --- Function body from original PatchUtils._formatPatchMetadata ---
+    // --- (Copied Verbatim) ---
+    const lines = ['# Patch Metadata'];
+    const metadataOrder = [
+        'Source-Block-UUID', 'Target-Block-UUID', 'Source-Version', 'Target-Version',
+        'Description', 'Authors'
+    ];
+
+    // Add ordered metadata
+    metadataOrder.forEach(key => {
+        if (metadata[key]) {
+            lines.push(`# ${key}: ${metadata[key]}`);
+        }
+    });
+
+    // Add any other metadata not in the preferred order
+    for (const [key, value] of Object.entries(metadata)) {
+        if (!metadataOrder.includes(key)) {
+            lines.push(`# ${key}: ${value}`);
+        }
+    }
+
+    return lines.join('\n');
+    // --- End of Function Body ---
+}
+
+module.exports = {
+    applyPatch,
+    createPatch,
+    createPatchFromCodeBlocks,
+};
+
+

package/src/PatchUtils/patchVerifier/constants.js

@@ -0,0 +1,23 @@
+/**
+ * Component: PatchUtils Constants
+ * Block-UUID: 32adc00e-7509-4219-8e40-6c1319371db9
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Contains shared constants and regular expressions used by the patch verification utilities.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:45:32.087Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
+ */
+
+
+// Regex to parse context/deletion/addition lines with line numbers
+// Captures: 1: diff prefix (' ', '-', or '+'), 2: line number, 3: content after 'NNN: '
+const CONTENT_LINE_REGEX = /^([ +-])\s*[-+]*(\d+):\s?(.*)$/;
+// Regex to parse hunk headers
+// Captures: 1: old_start, 2: old_count (optional), 3: new_start, 4: new_count (optional)
+const HUNK_HEADER_REGEX = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+module.exports = {
+    CONTENT_LINE_REGEX,
+    HUNK_HEADER_REGEX,
+};

package/src/PatchUtils/patchVerifier/detectAndFixOverlappingHunks.js

@@ -0,0 +1,281 @@
+/**
+ * Component: PatchUtils Detect and Fix Overlapping Hunks
+ * Block-UUID: 0e1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
+ * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
+ * Version: 1.0.0
+ * Description: Detects and optionally fixes overlapping hunks in a patch file by merging them.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:48:50.244Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
+ */
+
+
+const { CONTENT_LINE_REGEX, HUNK_HEADER_REGEX } = require('./constants');
+
+
+/**
+ * Represents an error found during patch verification.
+ * @typedef {object} VerificationError
+ * @property {number} [originalLineNumber] - The line number reported in the patch file (for line errors).
+ * @property {number} [hunkIndex] - The index (0-based) of the hunk where the error occurred (for header errors).
+ * @property {string} lineContent - The full content of the problematic line or header in the patch.
+ * @property {string} message - Description of the error.
+ * @property {number} [searchStart] - The starting line number (1-based) of the search window in the source.
+ * @property {number} [searchEnd] - The ending line number (1-based) of the search window in the source.
+ * @property {string} [errorType] - Type of error (e.g., 'redundant-change', 'line-mismatch', 'header-mismatch').
+ * @property {string[]} [suggestedFix] - Suggested lines to replace the problematic section.
+ */
+
+
+/**
+ * Detects and fixes overlapping hunks in a patch file. Overlapping hunks occur when
+ * multiple hunks try to modify the same section of code, which can cause patch application
+ * failures. This function identifies such overlaps and merges the affected hunks.
+ *
+ * @param {string} patchText - The full text of the patch (including metadata and markers).
+ * @param {boolean} [autoFix=false] - Whether to automatically fix detected overlapping hunks.
+ * @returns {{
+ *   correctedPatchText: string,
+ *   correctionsMade: boolean,
+ *   errors: VerificationError[]
+ * }} - An object containing the potentially corrected patch text, a flag indicating if corrections were made, and an array of errors encountered.
+ * @throws {Error} If patchText is not a string.
+ */
+function detectAndFixOverlappingHunks(patchText, autoFix = false) {
+    if (typeof patchText !== 'string') {
+        throw new Error("Invalid input: patchText must be a string.");
+    }
+
+    const lines = patchText.split('\n');
+    const errors = [];
+    let correctionsMade = false;
+
+    // Extract all hunks from the patch
+    const hunks = [];
+    let currentHunk = null;
+    let inMetadata = true;
+    let metadataLines = [];
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Collect metadata until we hit the patch start marker
+        if (inMetadata) {
+            metadataLines.push(line);
+            if (line === '# --- PATCH START MARKER ---') {
+                inMetadata = false;
+            }
+            continue;
+        }
+
+        // End of patch
+        if (line === '# --- PATCH END MARKER ---') {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+                currentHunk = null;
+            }
+            break;
+        }
+
+        // Start of a new hunk
+        if (line.startsWith('@@ ')) {
+            if (currentHunk) {
+                hunks.push(currentHunk);
+            }
+
+            const headerMatch = line.match(HUNK_HEADER_REGEX);
+            if (!headerMatch) {
+                errors.push({
+                    lineContent: line,
+                    message: "Failed to parse hunk header.",
+                    errorType: 'header-parse-error'
+                });
+                continue;
+            }
+
+            currentHunk = {
+                header: line,
+                headerMatch,
+                oldStart: parseInt(headerMatch[1], 10),
+                oldCount: headerMatch[2] ? parseInt(headerMatch[2], 10) : 1,
+                newStart: parseInt(headerMatch[3], 10),
+                newCount: headerMatch[4] ? parseInt(headerMatch[4], 10) : 1,
+                lines: [line],
+                contentLines: []
+            };
+        } else if (currentHunk) {
+            // Add line to current hunk
+            currentHunk.lines.push(line);
+            currentHunk.contentLines.push(line);
+        }
+    }
+
+    // Add the last hunk if there is one
+    if (currentHunk) {
+        hunks.push(currentHunk);
+    }
+
+    // Check for overlapping hunks
+    const overlappingPairs = [];
+    for (let i = 0; i < hunks.length; i++) {
+        for (let j = i + 1; j < hunks.length; j++) {
+            const hunk1 = hunks[i];
+            const hunk2 = hunks[j];
+
+            // Check if hunks overlap in the original file
+            const hunk1OldEnd = hunk1.oldStart + hunk1.oldCount - 1;
+            const hunk2OldEnd = hunk2.oldStart + hunk2.oldCount - 1;
+
+            // Check if hunks overlap in the new file
+            const hunk1NewEnd = hunk1.newStart + hunk1.newCount - 1;
+            const hunk2NewEnd = hunk2.newStart + hunk2.newCount - 1;
+
+
+            if ((hunk1.oldStart <= hunk2OldEnd && hunk2.oldStart <= hunk1OldEnd) ||
+                (hunk1.newStart <= hunk2NewEnd && hunk2.newStart <= hunk1NewEnd)) {
+
+                overlappingPairs.push({ hunk1Index: i, hunk2Index: j });
+
+                errors.push({
+                    lineContent: hunk1.header,
+                    message: `Overlapping hunks detected: Hunk starting at old line ${hunk1.oldStart} overlaps with hunk starting at old line ${hunk2.oldStart}.`,
+                    errorType: 'overlapping-hunks',
+                    hunkIndex: i
+                });
+            }
+        }
+    }
+
+    // If no overlaps or autoFix is disabled, return original
+    if (overlappingPairs.length === 0 || !autoFix) {
+        return {
+            correctedPatchText: patchText,
+            correctionsMade: false,
+            errors
+        };
+    }
+
+    // Fix overlapping hunks by merging them
+    const mergedHunks = [...hunks];
+    const removedIndices = new Set();
+
+    for (const { hunk1Index, hunk2Index } of overlappingPairs) {
+        // Skip if either hunk has already been merged
+        if (removedIndices.has(hunk1Index) || removedIndices.has(hunk2Index)) {
+            continue;
+        }
+
+        const hunk1 = mergedHunks[hunk1Index];
+        const hunk2 = mergedHunks[hunk2Index];
+
+        // Determine the range of the merged hunk
+        const oldStart = Math.min(hunk1.oldStart, hunk2.oldStart);
+        const oldEnd = Math.max(hunk1.oldStart + hunk1.oldCount - 1, hunk2.oldStart + hunk2.oldCount - 1);
+        const oldCount = oldEnd - oldStart + 1;
+
+        const newStart = Math.min(hunk1.newStart, hunk2.newStart);
+        const newEnd = Math.max(hunk1.newStart + hunk1.newCount - 1, hunk2.newStart + hunk2.newCount - 1);
+        const newCount = newEnd - newStart + 1;
+
+        // Create a new merged hunk header
+        const oldPart = oldCount === 1 ? `${oldStart}` : `${oldStart},${oldCount}`;
+        const newPart = newCount === 1 ? `${newStart}` : `${newStart},${newCount}`;
+        const mergedHeader = `@@ -${oldPart} +${newPart} @@`;
+
+        // Merge the content lines (this is a simplified approach)
+        // A more sophisticated implementation would need to handle line conflicts
+        const mergedContentLines = [];
+        const processedLines = new Set();
+
+        // Process hunk1 content
+        for (const line of hunk1.contentLines) {
+            const match = line.match(CONTENT_LINE_REGEX);
+            if (match) {
+                const lineNum = parseInt(match[2], 10);
+                const key = `${match[1]}-${lineNum}-${match[3]}`;
+                if (!processedLines.has(key)) {
+                    mergedContentLines.push(line);
+                    processedLines.add(key);
+                }
+            } else {
+                // Handle lines that don't match the content regex (e.g., comments within hunk)
+                 if (!processedLines.has(line)) {
+                     mergedContentLines.push(line);
+                     processedLines.add(line);
+                 }
+            }
+        }
+
+        // Process hunk2 content
+        for (const line of hunk2.contentLines) {
+            const match = line.match(CONTENT_LINE_REGEX);
+            if (match) {
+                const lineNum = parseInt(match[2], 10);
+                const key = `${match[1]}-${lineNum}-${match[3]}`;
+                if (!processedLines.has(key)) {
+                    mergedContentLines.push(line);
+                    processedLines.add(key);
+                }
+            } else {
+                 // Handle lines that don't match the content regex (e.g., comments within hunk)
+                 if (!processedLines.has(line)) {
+                     mergedContentLines.push(line);
+                     processedLines.add(line);
+                 }
+            }
+        }
+
+        // Sort merged content lines by line number for better readability (optional but good practice)
+        mergedContentLines.sort((a, b) => {
+            const matchA = a.match(CONTENT_LINE_REGEX);
+            const matchB = b.match(CONTENT_LINE_REGEX);
+
+            if (!matchA || !matchB) {
+                // If either doesn't match, keep original order relative to each other
+                return 0;
+            }
+
+            const lineNumA = parseInt(matchA[2], 10);
+            const lineNumB = parseInt(matchB[2], 10);
+
+            return lineNumA - lineNumB;
+        });
+
+
+        // Create the merged hunk
+        const mergedHunk = {
+            header: mergedHeader,
+            oldStart,
+            oldCount,
+            newStart,
+            newCount,
+            lines: [mergedHeader, ...mergedContentLines],
+            contentLines: mergedContentLines
+        };
+
+        // Replace hunk1 with the merged hunk and mark hunk2 for removal
+        mergedHunks[hunk1Index] = mergedHunk;
+        removedIndices.add(hunk2Index);
+
+        correctionsMade = true;
+    }
+
+    // Rebuild the patch text with merged hunks
+    const outputLines = [...metadataLines];
+    for (let i = 0; i < mergedHunks.length; i++) {
+        if (!removedIndices.has(i)) {
+            outputLines.push(...mergedHunks[i].lines);
+        }
+    }
+    outputLines.push('# --- PATCH END MARKER ---');
+
+    return {
+        correctedPatchText: outputLines.join('\n'),
+        correctionsMade,
+        errors
+    };
+}
+
+module.exports = {
+    detectAndFixOverlappingHunks,
+};