@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/patchVerifier/detectAndFixRedundantChanges.js

@@ -0,0 +1,404 @@
+/**
+ * Component: PatchUtils Detect and Fix Redundant Changes
+ * Block-UUID: ffd6e8fc-399d-4254-827c-ef17e2f7d0d5
+ * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
+ * Version: 1.0.0
+ * Description: Detects and optionally fixes redundant changes in a patch where content is deleted and re-added identically.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:48:02.248Z
+ * 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 optionally fixes redundant changes in a patch, where content is unnecessarily
+ * deleted and then re-added with identical content. This is a common issue in LLM-generated
+ * patches that can cause "malformed patch" errors when applying the patch.
+ *
+ * @param {string} patchText - The full text of the patch (including metadata and markers).
+ * @param {boolean} [autoFix=false] - Whether to automatically fix detected redundant changes.
+ * @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 detectAndFixRedundantChanges(patchText, autoFix = false) {
+    if (typeof patchText !== 'string') {
+        throw new Error("Invalid input: patchText must be a string.");
+    }
+
+    const lines = patchText.split('\n');
+    const outputLines = [];
+    const errors = [];
+    let correctionsMade = false;
+    let currentHunkIndex = -1;
+    let processingHunk = false;
+    let currentHunkStart = -1;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (line.startsWith('@@ ')) {
+            // Start of a new hunk
+            if (processingHunk) {
+                // Process the previous hunk before starting a new one
+                const result = processRedundantChanges(
+                    lines.slice(currentHunkStart, i),
+                    currentHunkIndex,
+                    autoFix
+                );
+
+                outputLines.push(...result.correctedLines);
+                errors.push(...result.errors);
+                if (result.corrected) correctionsMade = true;
+            }
+
+            processingHunk = true;
+            currentHunkIndex++;
+            currentHunkStart = i;
+            outputLines.push(line); // Add the hunk header
+        } else if (line === '# --- PATCH END MARKER ---') {
+            // End of patch content
+            if (processingHunk) {
+                // Process the last hunk
+                const result = processRedundantChanges(
+                    lines.slice(currentHunkStart, i),
+                    currentHunkIndex,
+                    autoFix
+                );
+
+                // Remove the hunk header we already added
+                outputLines.pop();
+                outputLines.push(...result.correctedLines);
+                errors.push(...result.errors);
+                if (result.corrected) correctionsMade = true;
+                processingHunk = false;
+            }
+            outputLines.push(line); // Add the end marker
+        } else if (!processingHunk) {
+            // Outside of a hunk (metadata, markers, etc.)
+            outputLines.push(line);
+        }
+        // We don't add hunk content lines here - they're handled in processRedundantChanges
+    }
+
+    // Process the last hunk if we're still in one and there was no end marker
+    if (processingHunk) {
+        const result = processRedundantChanges(
+            lines.slice(currentHunkStart),
+            currentHunkIndex,
+            autoFix
+        );
+
+        // Remove the hunk header we already added
+        outputLines.pop();
+        outputLines.push(...result.correctedLines);
+        errors.push(...result.errors);
+        if (result.corrected) correctionsMade = true;
+    }
+
+    return {
+        correctedPatchText: outputLines.join('\n'),
+        correctionsMade,
+        errors
+    };
+}
+
+/**
+ * Helper function to process a single hunk for redundant changes.
+ * @param {string[]} hunkLines - Array of lines in the hunk, including the header.
+ * @param {number} hunkIndex - The 0-based index of this hunk in the patch.
+ * @param {boolean} autoFix - Whether to automatically fix detected issues.
+ * @returns {{correctedLines: string[], corrected: boolean, errors: VerificationError[]}}
+ * @private
+ */
+function processRedundantChanges(hunkLines, hunkIndex, autoFix) {
+    if (hunkLines.length < 2) {
+        return { correctedLines: hunkLines, corrected: false, errors: [] };
+    }
+
+    const errors = [];
+    let corrected = false;
+
+    // First line should be the hunk header
+    const headerLine = hunkLines[0];
+    const headerMatch = headerLine.match(HUNK_HEADER_REGEX);
+    if (!headerMatch) {
+        return {
+            correctedLines: hunkLines,
+            corrected: false,
+            errors: [{
+                hunkIndex,
+                lineContent: headerLine,
+                message: "Failed to parse hunk header.",
+                errorType: 'header-parse-error'
+            }]
+        };
+    }
+
+    // Extract content lines (skip the header)
+    const contentLines = hunkLines.slice(1);
+
+    // Group consecutive deletion and addition lines
+    const groups = [];
+    let currentGroup = { deletions: [], additions: [], startIndex: -1 };
+
+    for (let i = 0; i < contentLines.length; i++) {
+        const line = contentLines[i];
+
+        if (line.startsWith('-')) {
+            if (currentGroup.additions.length > 0) {
+                // We've been collecting additions and now hit a deletion
+                // This is a new group
+                groups.push({ ...currentGroup });
+                currentGroup = { deletions: [line], additions: [], startIndex: i };
+            } else {
+                // Continue collecting deletions
+                if (currentGroup.startIndex === -1) currentGroup.startIndex = i;
+                currentGroup.deletions.push(line);
+            }
+        } else if (line.startsWith('+')) {
+            // Continue collecting additions
+            if (currentGroup.startIndex === -1) currentGroup.startIndex = i;
+            currentGroup.additions.push(line);
+        } else {
+            // Context line - end the current group if it has any content
+            if (currentGroup.deletions.length > 0 || currentGroup.additions.length > 0) {
+                groups.push({ ...currentGroup });
+                currentGroup = { deletions: [], additions: [], startIndex: -1 };
+            }
+        }
+    }
+
+    // Add the last group if it has content
+    if (currentGroup.deletions.length > 0 || currentGroup.additions.length > 0) {
+        groups.push(currentGroup);
+    }
+
+    // Check each group for redundant changes
+    const redundantGroups = [];
+
+    for (const group of groups) {
+        if (group.deletions.length > 0 && group.additions.length > 0) {
+            // Extract content without diff markers and line numbers
+            const deletionContents = group.deletions.map(line => {
+                const match = line.match(CONTENT_LINE_REGEX);
+                return match ? match[3].trim() : line.substring(1).trim();
+            });
+
+            const additionContents = group.additions.map(line => {
+                const match = line.match(CONTENT_LINE_REGEX);
+                return match ? match[3].trim() : line.substring(1).trim();
+            });
+
+            // Check if the contents are identical
+            if (deletionContents.length === additionContents.length) {
+                let identical = true;
+                for (let i = 0; i < deletionContents.length; i++) {
+                    if (deletionContents[i] !== additionContents[i]) {
+                        identical = false;
+                        break;
+                    }
+                }
+
+                if (identical) {
+                    redundantGroups.push({
+                        ...group,
+                        fixedLines: group.deletions.map((line, i) => {
+                            // Convert to context lines by replacing '-' with ' '
+                            const match = line.match(CONTENT_LINE_REGEX);
+                            if (match) {
+                                return ` ${match[2]}: ${match[3]}`;
+                            } else {
+                                // Fallback if regex fails, try to preserve original line number if possible
+                                const fallbackMatch = line.match(/^-\s*(\d+):\s?(.*)$/);
+                                if (fallbackMatch) {
+                                     return ` ${fallbackMatch[1]}: ${fallbackMatch[2]}`;
+                                }
+                                return ` ${line.substring(1)}`; // Just remove the '-'
+                            }
+                        })
+                    });
+                }
+            }
+        }
+    }
+
+    // If we found redundant groups, report them and optionally fix
+    if (redundantGroups.length > 0) {
+        for (const group of redundantGroups) {
+            // Calculate line numbers relative to the start of the hunk content lines (after the header)
+            const startLineInHunkContent = group.startIndex;
+            const endLineInHunkContent = startLineInHunkContent + group.deletions.length + group.additions.length - 1;
+
+            // Find the actual line number in the patch file for the start of the redundant block
+            // This requires iterating through the original hunkLines to find the line index
+            let actualStartLineInPatch = -1;
+            let currentContentLineIndex = 0;
+            for(let k = 1; k < hunkLines.length; k++) { // Start from 1 to skip header
+                if (currentContentLineIndex === startLineInHunkContent) {
+                    // The line index in the original patch file is the index in hunkLines + the start line of the hunk in the full patch
+                    // We don't have the start line of the hunk in the full patch here, so we'll report relative to the hunk start.
+                    // A better approach might be to pass the global line index to processHunk.
+                    // For now, report relative to the start of the hunk content.
+                    actualStartLineInPatch = k; // Index within hunkLines (0-based)
+                    break;
+                }
+                 // Only increment content line index for lines that are part of the content (not header)
+                if (!hunkLines[k].startsWith('@@ ')) {
+                     currentContentLineIndex++;
+                }
+            }
+
+
+            errors.push({
+                hunkIndex,
+                // Report the line in the original hunkLines array where the redundant block starts
+                lineContent: hunkLines[actualStartLineInPatch !== -1 ? actualStartLineInPatch : group.startIndex + 1], // Fallback to index relative to content start + 1 for header
+                message: `Redundant change detected: content is deleted and then re-added with identical content (starts at line ${startLineInHunkContent + 1} within hunk content).`,
+                errorType: 'redundant-change',
+                suggestedFix: autoFix ? group.fixedLines : undefined // Only suggest fix if autoFix is true
+            });
+        }
+
+        // If autoFix is enabled, replace the redundant changes with context lines
+        if (autoFix) {
+            let correctedContentLines = [...contentLines];
+
+            // Process groups in reverse order to avoid index shifting
+            redundantGroups.sort((a, b) => b.startIndex - a.startIndex);
+
+            for (const group of redundantGroups) {
+                const startIdx = group.startIndex;
+                const endIdx = startIdx + group.deletions.length + group.additions.length;
+
+                // Replace the redundant deletion+addition with context lines
+                correctedContentLines.splice(
+                    startIdx,
+                    endIdx - startIdx,
+                    ...group.fixedLines
+                );
+            }
+
+            // Count the different types of lines in the corrected content
+            let contextLineCount = 0;
+            let deletionLineCount = 0;
+            let additionLineCount = 0;
+
+            for (const line of correctedContentLines) {
+                if (line.startsWith(' ')) contextLineCount++;
+                else if (line.startsWith('-')) deletionLineCount++;
+                else if (line.startsWith('+')) additionLineCount++;
+            }
+
+            // Parse the original header
+            const oldStart = parseInt(headerMatch[1], 10);
+            const newStart = parseInt(headerMatch[3], 10);
+
+            // Calculate the new counts
+            const oldCount = contextLineCount + deletionLineCount;
+            const newCount = contextLineCount + additionLineCount;
+
+            // If both counts are 0, this means the entire hunk was redundant changes
+            // In this case, we should preserve at least one context line to maintain a valid hunk
+            if (oldCount === 0 && newCount === 0) {
+                // Find the first line number from the original content
+                let lineNumber = null;
+                for (const line of contentLines) {
+                    const match = line.match(CONTENT_LINE_REGEX);
+                    if (match) {
+                        lineNumber = match[2];
+                        break;
+                    }
+                }
+
+                // If we found a line number, add a context line
+                if (lineNumber) {
+                    // Find the corresponding line in the original content
+                     // Need to find the original line content to reconstruct the context line
+                    let originalLineContent = '';
+                     for (const line of contentLines) {
+                        const match = line.match(CONTENT_LINE_REGEX);
+                        if (match && match[2] === lineNumber) {
+                            originalLineContent = match[3];
+                            break;
+                        }
+                    }
+
+                    if (originalLineContent) {
+                         // Reconstruct the context line with the found line number and content
+                        const padding = String(lineNumber).length; // Use the line number's length for padding
+                        correctedContentLines = [` ${String(lineNumber).padStart(padding, ' ')}: ${originalLineContent}`];
+                        contextLineCount = 1;
+                    } else {
+                         // If we couldn't find the original content, just add a generic context line
+                         correctedContentLines = [` ${String(oldStart).padStart(String(oldStart).length, ' ')}: ...`]; // Use oldStart as a fallback line number
+                         contextLineCount = 1;
+                    }
+                } else {
+                     // If no line numbers were found at all, add a minimal valid hunk
+                     correctedContentLines = [` ${String(oldStart).padStart(String(oldStart).length, ' ')}: ...`];
+                     contextLineCount = 1;
+                }
+            }
+
+            // Recalculate in case we added a context line
+            const finalOldCount = contextLineCount + deletionLineCount;
+            const finalNewCount = contextLineCount + additionLineCount;
+
+            // Format the new header
+            const oldPart = finalOldCount === 1 ? `${oldStart}` : `${oldStart},${finalOldCount}`;
+            const newPart = finalNewCount === 1 ? `${newStart}` : `${newStart},${finalNewCount}`;
+            const newHeader = `@@ -${oldPart} +${newPart} @@`;
+
+            // If we have no content lines left, this hunk should be removed entirely
+            if (correctedContentLines.length === 0) {
+                return {
+                    correctedLines: [], // Return empty array to signal this hunk should be removed
+                    corrected: true,
+                    errors: [...errors, {
+                        hunkIndex,
+                        lineContent: headerLine,
+                        message: "Entire hunk consists of redundant changes and has been removed.",
+                        errorType: 'hunk-removed'
+                    }]
+                };
+            }
+
+            return {
+                correctedLines: [newHeader, ...correctedContentLines],
+                corrected: true,
+                errors
+            };
+        }
+    }
+
+    return {
+        correctedLines: hunkLines,
+        corrected: false,
+        errors
+    };
+}
+
+module.exports = {
+    detectAndFixRedundantChanges,
+};

package/src/PatchUtils/patchVerifier/formatAndAddLineNumbers.js

@@ -0,0 +1,165 @@
+/**
+ * Component: PatchUtils Format and Add Line Numbers
+ * Block-UUID: 37c3f528-dede-4d2f-9e4f-df87d1dce78f
+ * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
+ * Version: 1.0.0
+ * Description: Ensures patch content lines have NNN: line number prefixes with consistent padding, adding them if missing.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:46:14.708Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
+ */
+
+
+const { removeLineNumbers } = require('../../CodeBlockUtils/lineNumberFormatter'); // Assuming this utility exists
+const { CONTENT_LINE_REGEX, HUNK_HEADER_REGEX } = require('./constants');
+
+
+/**
+ * Ensures patch content lines have NNN: line number prefixes with consistent padding,
+ * adding them if missing. This function focuses solely on the line number prefix
+ * format and presence, not the correctness of the numbers themselves (which is
+ * handled by verifyAndCorrectLineNumbers).
+ *
+ * @param {string} patchText - The full text of the patch (including metadata, markers, etc.).
+ * @param {string} sourceText - The original source code text (MUST be clean, without NNN: prefixes).
+ * @returns {{
+ *   formattedPatchText: string,
+ *   correctionsMade: boolean
+ * }} - An object containing the potentially corrected patch text and a flag indicating if corrections were made.
+ * @throws {Error} If inputs are invalid (e.g., non-string text).
+ */
+function formatAndAddLineNumbers(patchText, sourceText) {
+    if (typeof patchText !== 'string') {
+        throw new Error("Invalid input: patchText must be a string.");
+    }
+    if (typeof sourceText !== 'string') {
+        throw new Error("Invalid input: sourceText must be a string.");
+    }
+
+    const patchLines = patchText.split('\n');
+    const sourceLineCount = sourceText.split('\n').length;
+    // Calculate padding width based on the number of lines in the source file
+    const padding = String(sourceLineCount).length;
+    // Ensure minimum padding is 1 even for empty source
+    const requiredPadding = Math.max(1, padding);
+
+    const outputLines = [];
+    let correctionsMade = false;
+    let currentHunkOldStart = null;
+    let currentHunkNewStart = null;
+    let oldLineCounter = 0; // Counter for lines in the original file perspective within the hunk
+    let inHunk = false;
+
+    for (let i = 0; i < patchLines.length; i++) {
+        const currentPatchLine = patchLines[i];
+
+        const headerMatch = currentPatchLine.match(HUNK_HEADER_REGEX);
+        if (headerMatch) {
+            // Start of a new hunk
+            inHunk = true;
+            currentHunkOldStart = parseInt(headerMatch[1], 10);
+            currentHunkNewStart = parseInt(headerMatch[3], 10);
+            // Reset counter for the new hunk
+            oldLineCounter = 0;
+            outputLines.push(currentPatchLine);
+            continue; // Move to the next line
+        }
+
+        // Check for patch markers to potentially reset hunk state
+        if (currentPatchLine === '# --- PATCH START MARKER ---' || currentPatchLine === '# --- PATCH END MARKER ---') {
+             // Assume markers are outside hunks and reset hunk processing
+             inHunk = false;
+             outputLines.push(currentPatchLine);
+             continue;
+        }
+
+        if (inHunk) {
+            const contentMatch = currentPatchLine.match(CONTENT_LINE_REGEX);
+            const prefix = currentPatchLine.charAt(0); // Get the diff prefix (+, -, or space)
+
+            if (prefix === '+' || prefix === '-' || prefix === ' ') {
+                // This is a content line within a hunk
+                // Get content after the potential prefix and line number
+                const content = contentMatch ? contentMatch[3] : currentPatchLine.substring(1);
+
+                let newLineCounter = oldLineCounter; // Track position in the new file
+
+                let lineNumberToUse;
+                if (contentMatch) {
+                    // Line already has a number prefix, use the parsed number
+                    lineNumberToUse = parseInt(contentMatch[2], 10);
+                } else {
+                    // Line is missing a number prefix, estimate based on hunk start and counter
+                    // The number prefix NNN: always refers to the original file's line number
+                    if (prefix === '+') {
+                        // For addition lines, use the new file's line number
+                        lineNumberToUse = currentHunkNewStart + newLineCounter;
+                    } else {
+                        // For context and deletion lines, use the original file's line number
+                        lineNumberToUse = currentHunkOldStart + oldLineCounter;
+                    }
+                }
+
+                const formattedLine = `${prefix} ${String(lineNumberToUse).padStart(requiredPadding, ' ')}: ${content}`;
+
+                if (formattedLine !== currentPatchLine) {
+                    correctionsMade = true;
+                }
+
+                outputLines.push(formattedLine);
+
+                // Increment the oldLineCounter for context and deletion lines
+                // Addition lines (+), while part of the hunk, don't exist in the original file
+                // sequence for the purpose of this counter.
+                if (prefix === ' ' || prefix === '-') {
+                    oldLineCounter++;
+                }
+                // For context and addition lines, increment the new file counter
+                if (prefix === ' ' || prefix === '+') {
+                    newLineCounter++;
+                }
+            } else {
+                // Line is within a hunk but not a standard content line (e.g., comments within hunk)
+                // Add as is, but check if it looks like a malformed content line without prefix
+                if (currentPatchLine.length > 0 && (currentPatchLine.startsWith('+') || currentPatchLine.startsWith('-') || currentPatchLine.startsWith(' '))) {
+                    // It starts with a diff prefix but didn't match the regex, likely missing NNN:
+                    // Treat it as missing the prefix and add one
+                    const content = currentPatchLine.substring(1);
+
+                    let estimatedLineNumber;
+                    if (prefix === '+') {
+                        estimatedLineNumber = currentHunkNewStart + oldLineCounter; // Use new file position for additions
+                    } else {
+                        estimatedLineNumber = currentHunkOldStart + oldLineCounter; // Use old file position for context/deletions
+                    }
+
+
+                    const formattedLine = `${prefix} ${String(estimatedLineNumber).padStart(requiredPadding, ' ')}: ${content}`;
+                    outputLines.push(formattedLine);
+                    correctionsMade = true;
+
+                    // Increment counter if it's a line type that affects the original file sequence
+                    if (prefix === ' ' || prefix === '-') {
+                        oldLineCounter++;
+                    }
+
+                } else {
+                    // Truly not a content line, add as is
+                    outputLines.push(currentPatchLine);
+                }
+            }
+        } else {
+            // Line is outside a hunk (metadata, etc.)
+            outputLines.push(currentPatchLine);
+        }
+    }
+
+    return {
+        formattedPatchText: outputLines.join('\n'),
+        correctionsMade: correctionsMade
+    };
+}
+
+module.exports = {
+    formatAndAddLineNumbers,
+};

package/src/PatchUtils/patchVerifier/index.js

@@ -0,0 +1,25 @@
+/**
+ * Component: PatchUtils Verifier Index
+ * Block-UUID: 0bca5027-9656-44f8-89e1-e32991b386bd
+ * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
+ * Version: 1.0.0
+ * Description: Provides a backwards-compatible entry point for the patch verification utilities.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:49:18.423Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
+ */
+
+
+const { formatAndAddLineNumbers } = require('./formatAndAddLineNumbers');
+const { verifyAndCorrectLineNumbers } = require('./verifyAndCorrectLineNumbers');
+const { verifyAndCorrectHunkHeaders } = require('./verifyAndCorrectHunkHeaders');
+const { detectAndFixRedundantChanges } = require('./detectAndFixRedundantChanges');
+const { detectAndFixOverlappingHunks } = require('./detectAndFixOverlappingHunks');
+
+module.exports = {
+    formatAndAddLineNumbers,
+    verifyAndCorrectLineNumbers,
+    verifyAndCorrectHunkHeaders,
+    detectAndFixRedundantChanges,
+    detectAndFixOverlappingHunks,
+};