@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/hunkValidator.js

@@ -0,0 +1,305 @@
+/**
+ * Component: PatchUtils Hunk Validator
+ * Block-UUID: 7f9e4d2c-1b6a-4f85-9c3d-8e2a5b7f9d0e
+ * Parent-UUID: 6d830314-b75d-48df-b23a-8467672c9503
+ * Version: 1.3.0
+ * Description: Validates individual hunks with detailed diagnostics and fuzzy matching capabilities.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T18:07:21.058Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Claude 3.5 Sonnet (v1.1.0, v1.2.0), Claude 3.5 Sonnet (v1.3.0), Gemini 2.5 Flash (v1.3.0)
+ */
+
+
+const jsdiff = require('diff');
+const { findBestContextMatch, findBestMatchWithSlidingWindow } = require('./fuzzyMatcher');
+const { removeLineNumbers } = require('../CodeBlockUtils/lineNumberFormatter');
+
+/**
+ * Parses a hunk into its components
+ * @param {string} hunkText - The full text of a single hunk
+ * @returns {object} Parsed hunk with header, context lines, added lines, and removed lines
+ */
+function parseHunk(hunkText) {
+    const lines = hunkText.split('\n');
+    const header = lines[0];
+    const contentLines = lines.slice(1);
+
+    // Arrays to store the different line types
+    const contextLines = [];
+    const contextLinesForMatching = [];
+    const addedLines = [];
+    const removedLines = [];
+
+    // Track current position in the hunk for building matching context
+    let currentPosition = 0;
+
+    for (const line of contentLines) {
+        // Clean line numbers from the content
+        const cleanLine = removeLineNumbers(line.substring(1));
+
+        if (line.startsWith(' ')) {
+            // Regular context line - add to both context arrays
+            contextLines.push(cleanLine);
+            contextLinesForMatching.push(cleanLine);
+            currentPosition++;
+        } else if (line.startsWith('+')) {
+            // Added line - only track in addedLines
+            addedLines.push(cleanLine);
+            currentPosition++;
+        } else if (line.startsWith('-')) {
+            // Removed line - add to removedLines and matching context
+            removedLines.push(cleanLine);
+            contextLinesForMatching.push(cleanLine);
+            currentPosition++;
+        }
+    }
+
+    return {
+        header,
+        // Original context lines (space-prefixed only)
+        contextLines,
+        // Context lines for matching against source (includes removed lines)
+        contextLinesForMatching,
+        // Lines being added and removed
+        addedLines,
+        removedLines,
+        // Original content with prefixes intact
+        originalLines: contentLines
+    };
+}
+
+/**
+ * Parses a hunk header into its components
+ * @param {string} header - The hunk header (e.g., "@@ -1,3 +1,4 @@")
+ * @returns {object} Parsed header with oldStart, oldCount, newStart, newCount
+ */
+function parseHunkHeader(header) {
+    const match = header.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+
+    if (!match) {
+        return {
+            valid: false,
+            error: "Invalid hunk header format"
+        };
+    }
+
+    const oldStart = parseInt(match[1], 10);
+    const oldCount = match[2] ? parseInt(match[2], 10) : 1;
+    const newStart = parseInt(match[3], 10);
+    const newCount = match[4] ? parseInt(match[4], 10) : 1;
+
+    return {
+        valid: true,
+        oldStart,
+        oldCount,
+        newStart,
+        newCount
+    };
+}
+
+/**
+ * Attempts to apply a hunk directly at the specified position
+ * @param {string} sourceCode - Original source code
+ * @param {number} startLine - Starting line number (1-based)
+ * @param {string[]} contextLines - Context lines from the hunk
+ * @param {string[]} contextLinesForMatching - Context lines including removed lines for matching
+ * @param {string[]} addedLines - Lines to add
+ * @param {string[]} removedLines - Lines to remove
+ * @returns {object} Result of the direct application attempt
+ */
+function tryApplyHunkDirect(sourceCode, startLine, contextLines, contextLinesForMatching, addedLines, removedLines) {
+    const sourceLines = sourceCode.split('\n');
+    const startIndex = startLine - 1;
+
+    // If the starting position seems wrong, try to find the correct position
+    if (startIndex < 0 || startIndex >= sourceLines.length) {
+        const matchResult = findBestContextMatch(contextLinesForMatching, sourceCode);
+
+        if (matchResult.found) {
+            // Recursively try applying at the found position
+            return tryApplyHunkDirect(
+                sourceCode,
+                matchResult.position + 1,
+                contextLines,
+                contextLinesForMatching,
+                addedLines,
+                removedLines
+            );
+        }
+
+        return {
+            valid: false,
+            reason: "Could not find matching context in source code"
+        };
+    }
+
+    // Verify the complete context (including removed lines) matches at the current position
+    let contextMatches = true;
+    let sourceIndex = startIndex;
+
+    // Verify the complete context matches
+    for (const expectedLine of contextLinesForMatching) {
+        if (sourceIndex >= sourceLines.length) {
+            contextMatches = false;
+            break;
+        }
+
+        const sourceLine = sourceLines[sourceIndex].trim();
+        const expectedTrimmed = expectedLine.trim();
+
+        if (sourceLine !== expectedTrimmed) {
+            contextMatches = false;
+            break;
+        }
+
+        sourceIndex++;
+    }
+
+    if (!contextMatches) {
+        return {
+            valid: false,
+            reason: "Context lines (including removed lines) don't match at specified position"
+        };
+    }
+
+    // Apply the changes
+    const resultLines = [...sourceLines];
+
+    // Remove the old lines
+    resultLines.splice(startIndex, contextLinesForMatching.length);
+
+    // Add context and new lines
+    const newContent = [];
+    for (let i = 0; i < contextLines.length; i++) {
+        newContent.push(contextLines[i]);
+        if (i < addedLines.length) {
+            newContent.push(addedLines[i]);
+        }
+    }
+
+    // Add any remaining new lines
+    for (let i = contextLines.length; i < addedLines.length; i++) {
+        newContent.push(addedLines[i]);
+    }
+
+    // Insert the new content
+    resultLines.splice(startIndex, 0, ...newContent);
+
+    return {
+        valid: true,
+        result: resultLines.join('\n')
+    };
+}
+
+/**
+ * Validates a single hunk against source code with detailed diagnostics
+ * @param {string} sourceCode - Original source code
+ * @param {string} hunkText - The full text of a single hunk
+ * @returns {object} Detailed validation results
+ */
+function validateHunk(sourceCode, hunkText) {
+    // Parse the hunk
+    const hunk = parseHunk(hunkText);
+    const headerInfo = parseHunkHeader(hunk.header);
+
+    if (!headerInfo.valid) {
+        return {
+            valid: false,
+            hunk,
+            diagnostics: {
+                headerValid: false,
+                headerError: headerInfo.error,
+                suggestedFix: null
+            }
+        };
+    }
+
+    // Try direct application first
+    const directResult = tryApplyHunkDirect(
+        sourceCode,
+        headerInfo.oldStart,
+        hunk.contextLines,
+        hunk.contextLinesForMatching,
+        hunk.addedLines,
+        hunk.removedLines
+    );
+
+    if (directResult.valid) {
+        return {
+            valid: true,
+            appliedText: directResult.result,
+            hunk,
+            headerInfo,
+            diagnostics: {
+                method: "direct",
+                confidence: 1.0,
+                message: "Hunk applied successfully at specified position"
+            }
+        };
+    }
+
+    // If direct application failed, try finding the correct position
+    const matchResult = findBestContextMatch(hunk.contextLinesForMatching, sourceCode); // Use the new array for matching
+
+    if (matchResult.found) {
+        const adjustedResult = tryApplyHunkDirect(
+            sourceCode,
+            matchResult.position + 1,
+            hunk.contextLines,
+            hunk.contextLinesForMatching, // Use the new array for matching
+            hunk.addedLines,
+            hunk.removedLines
+        );
+
+        if (adjustedResult.valid) {
+            return {
+                valid: true,
+                appliedText: adjustedResult.result,
+                hunk,
+                headerInfo,
+                diagnostics: {
+                    method: "adjusted",
+                    confidence: matchResult.confidence,
+                    message: `Hunk applied successfully at adjusted position (line ${matchResult.position + 1})`
+                }
+            };
+        }
+    }
+
+    // If we get here, both direct and adjusted attempts failed
+    return {
+        valid: false,
+        hunk,
+        headerInfo,
+        diagnostics: {
+            method: "direct_failed",
+            error: directResult.reason,
+            message: `Failed to apply hunk: ${directResult.reason}`,
+            needsFuzzyMatching: true
+        }
+    };
+}
+
+/**
+ * Validates all hunks in a patch
+ * @param {string} sourceCode - Original source code
+ * @param {string[]} hunks - Array of hunk texts
+ * @returns {object[]} Array of validation results for each hunk
+ */
+function validateHunks(sourceCode, hunks) {
+    return hunks.map((hunkText, index) => {
+        const result = validateHunk(sourceCode, hunkText);
+        return {
+            ...result,
+            hunkIndex: index
+        };
+    });
+}
+
+module.exports = {
+    parseHunk,
+    parseHunkHeader,
+    validateHunk,
+    validateHunks,
+    tryApplyHunkDirect
+};

package/src/PatchUtils/index.js

@@ -0,0 +1,135 @@
+/**
+ * Component: PatchUtils Index
+ * Block-UUID: a7827938-bbfd-4c4b-83a7-fcf39ede8c6e
+ * Parent-UUID: f4a8495e-5612-40b5-8ec3-12c8e06886d5
+ * Version: 2.0.0
+ * Description: Aggregates and exports public functions from the enhanced PatchUtils modules.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T16:55:00.000Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Claude 3.7 Sonnet (v2.0.0)
+ */
+
+
+// Import original modules (for backward compatibility)
+const parser = require('./patchParser');
+const processor = require('./patchProcessor');
+const headerFormatter = require('./patchHeaderFormatter');
+const verifier = require('./patchVerifier');
+
+// Import new enhanced modules
+const hunkValidator = require('./hunkValidator');
+const fuzzyMatcher = require('./fuzzyMatcher');
+const hunkCorrector = require('./hunkCorrector');
+const diagnosticReporter = require('./diagnosticReporter');
+const patchExtractor = require('./patchExtractor');
+const enhancedProcessor = require('./enhancedPatchProcessor');
+
+/**
+ * @typedef {object} PatchValidationResult
+ * @property {boolean} valid - Whether the patch is valid
+ * @property {boolean} fixable - Whether invalid hunks can be fixed
+ * @property {object[]} hunkResults - Detailed results for each hunk
+ * @property {string} humanReadableDiagnostics - Human-readable diagnostic report
+ * @property {object} llmFeedback - Structured feedback for LLMs
+ */
+
+/**
+ * @typedef {object} PatchApplicationResult
+ * @property {boolean} success - Whether the patch was applied successfully
+ * @property {string} patchedText - The resulting text after applying the patch
+ * @property {boolean} patchWasCorrected - Whether the patch needed correction
+ * @property {string} correctedPatch - The corrected patch if applicable
+ * @property {object[]} hunkResults - Detailed results for each hunk
+ * @property {string} humanReadableDiagnostics - Human-readable diagnostic report
+ * @property {object} llmFeedback - Structured feedback for LLMs
+ */
+
+/**
+ * @typedef {object} HunkValidationResult
+ * @property {boolean} valid - Whether the hunk is valid
+ * @property {object} hunk - Parsed hunk information
+ * @property {object} headerInfo - Parsed header information
+ * @property {object} diagnostics - Detailed diagnostic information
+ */
+
+// Export all modules
+module.exports = {
+    // Original exports (for backward compatibility)
+    validateAndParseContextPatch: parser.validateAndParseContextPatch,
+    determinePatchFormat: parser.determinePatchFormat,
+    extractPatchMetadata: parser.extractPatchMetadata,
+    validatePatchMetadata: parser.validatePatchMetadata,
+    extractPatchContent: parser.extractPatchContent,
+    extractContextPatches: parser.extractContextPatches,
+    isPatchBlock: parser.isPatchBlock,
+    detectPatch: parser.detectPatch,
+    findAllPatches: parser.findAllPatches,
+    applyPatch: processor.applyPatch,
+    createPatch: processor.createPatch,
+    convertContextPatchToDiff: processor.convertContextPatchToDiff,
+    convertDiffToContextPatch: processor.convertDiffToContextPatch,
+    /**
+     * Creates a patch between two full code block strings (including their metadata headers).
+     * @param {string} sourceCodeBlockText - The complete string of the original code block.
+     * @param {string} targetCodeBlockText - The complete string of the modified code block.
+     * @param {object} patchMetadata - Metadata for the patch header.
+     * @returns {string} Patch in unified diff format.
+     */
+    createPatchFromCodeBlocks: processor.createPatchFromCodeBlocks,
+    formatCodeBlockHeader: headerFormatter.formatCodeBlockHeader,
+    verifyAndCorrectLineNumbers: verifier.verifyAndCorrectLineNumbers,
+
+    // New enhanced exports
+    // Hunk validation
+    parseHunk: hunkValidator.parseHunk,
+    parseHunkHeader: hunkValidator.parseHunkHeader,
+    validateHunk: hunkValidator.validateHunk,
+    validateHunks: hunkValidator.validateHunks,
+
+    // Fuzzy matching
+    findBestContextMatch: fuzzyMatcher.findBestContextMatch,
+    findExactLineMatches: fuzzyMatcher.findExactLineMatches,
+    findBestMatchWithSlidingWindow: fuzzyMatcher.findBestMatchWithSlidingWindow,
+
+    // Hunk correction
+    recalculateHunkHeader: hunkCorrector.recalculateHunkHeader,
+    reconstructHunk: hunkCorrector.reconstructHunk,
+    generateCorrectedHunk: hunkCorrector.generateCorrectedHunk,
+    generateHunkCorrection: hunkCorrector.generateHunkCorrection,
+
+    // Diagnostic reporting
+    generateHumanReadableDiagnostics: diagnosticReporter.generateHumanReadableDiagnostics,
+    generateLLMFeedback: diagnosticReporter.generateLLMFeedback,
+    formatDiagnosticSummary: diagnosticReporter.formatDiagnosticSummary,
+
+    // Patch extraction
+    extractHunks: patchExtractor.extractHunks,
+    cleanHunkLineNumbers: patchExtractor.cleanHunkLineNumbers,
+    extractAndCleanHunks: patchExtractor.extractAndCleanHunks,
+    reconstructPatch: patchExtractor.reconstructPatch,
+
+    // Enhanced patch processing
+    /**
+     * Applies a patch with detailed diagnostics
+     * @param {string} sourceText - Original source code
+     * @param {string} patchText - Patch text
+     * @returns {PatchApplicationResult} Comprehensive result with diagnostics
+     */
+    applyPatchWithDiagnostics: enhancedProcessor.applyPatchWithDiagnostics,
+
+    /**
+     * Validates a patch without applying it
+     * @param {string} sourceText - Original source code
+     * @param {string} patchText - Patch text
+     * @returns {PatchValidationResult} Validation result with diagnostics
+     */
+    validatePatch: enhancedProcessor.validatePatch,
+
+    /**
+     * Applies a single hunk to source code
+     * @param {string} sourceText - Original source code
+     * @param {string} hunkText - Text of a single hunk
+     * @returns {object} Result of applying the hunk
+     */
+    applyHunk: enhancedProcessor.applyHunk
+};

package/src/PatchUtils/patchExtractor.js

@@ -0,0 +1,175 @@
+/**
+ * Component: PatchUtils Patch Extractor
+ * Block-UUID: ad8cda91-244b-4f47-9847-d6c0d93424fc
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Extracts individual hunks from a patch and cleans line numbers from content.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T16:50:00.000Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0)
+ */
+
+
+const { removeLineNumbers } = require('../CodeBlockUtils/lineNumberFormatter');
+
+/**
+ * Extracts individual hunks from a patch
+ * @param {string} patchText - Full patch text including metadata and markers
+ * @returns {object} Object containing metadata and array of hunk texts
+ */
+function extractHunks(patchText) {
+    if (!patchText) {
+        return { metadata: {}, hunks: [] };
+    }
+
+    const lines = patchText.split('\n');
+    const metadata = {};
+    const hunks = [];
+
+    let inMetadata = true;
+    let inHunk = false;
+    let currentHunk = [];
+    let inPatchContent = false;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Check for patch start marker
+        if (line === '# --- PATCH START MARKER ---') {
+            inMetadata = false;
+            inPatchContent = true;
+            continue;
+        }
+
+        // Check for patch end marker
+        if (line === '# --- PATCH END MARKER ---') {
+            // Save the last hunk if we were in one
+            if (inHunk && currentHunk.length > 0) {
+                hunks.push(currentHunk.join('\n'));
+                currentHunk = [];
+            }
+            inPatchContent = false;
+            break;
+        }
+
+        // Process metadata
+        if (inMetadata) {
+            if (line.startsWith('# ') && line !== '# Patch Metadata') {
+                const colonIndex = line.indexOf(':');
+                if (colonIndex > 0) {
+                    const key = line.substring(2, colonIndex).trim();
+                    const value = line.substring(colonIndex + 1).trim();
+                    metadata[key] = value;
+                }
+            }
+            continue;
+        }
+
+        // Process patch content
+        if (inPatchContent) {
+            // Check for hunk header
+            if (line.startsWith('@@ ')) {
+                // If we were already in a hunk, save it before starting a new one
+                if (inHunk && currentHunk.length > 0) {
+                    hunks.push(currentHunk.join('\n'));
+                    currentHunk = [];
+                }
+
+                inHunk = true;
+                currentHunk.push(line);
+            } else if (inHunk) {
+                // Add line to current hunk
+                currentHunk.push(line);
+            }
+            // Skip lines between hunks (like file headers)
+        }
+    }
+
+    // Add the last hunk if there is one
+    if (inHunk && currentHunk.length > 0) {
+        hunks.push(currentHunk.join('\n'));
+    }
+
+    return { metadata, hunks };
+}
+
+/**
+ * Cleans line numbers from hunk content
+ * @param {string} hunkText - Text of a single hunk
+ * @returns {string} Hunk with line numbers removed from content lines
+ */
+function cleanHunkLineNumbers(hunkText) {
+    if (!hunkText) {
+        return '';
+    }
+
+    const lines = hunkText.split('\n');
+    const cleanedLines = [];
+
+    // First line is always the hunk header
+    if (lines.length > 0) {
+        cleanedLines.push(lines[0]);
+    }
+
+    // Process content lines
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (line.startsWith(' ') || line.startsWith('+') || line.startsWith('-')) {
+            const prefix = line[0];
+            const content = removeLineNumbers(line.substring(1));
+            cleanedLines.push(`${prefix}${content}`);
+        } else {
+            // Non-content line, keep as is
+            cleanedLines.push(line);
+        }
+    }
+
+    return cleanedLines.join('\n');
+}
+
+/**
+ * Extracts and cleans all hunks from a patch
+ * @param {string} patchText - Full patch text
+ * @returns {object} Object with metadata and cleaned hunks
+ */
+function extractAndCleanHunks(patchText) {
+    const { metadata, hunks } = extractHunks(patchText);
+    const cleanedHunks = hunks.map(cleanHunkLineNumbers);
+
+    return { metadata, hunks: cleanedHunks };
+}
+
+/**
+ * Reconstructs a patch with cleaned hunks
+ * @param {object} metadata - Patch metadata
+ * @param {string[]} hunks - Array of hunk texts
+ * @returns {string} Reconstructed patch
+ */
+function reconstructPatch(metadata, hunks) {
+    // Format metadata
+    let result = '# Patch Metadata\n';
+
+    for (const [key, value] of Object.entries(metadata)) {
+        result += `# ${key}: ${value}\n`;
+    }
+
+    // Add patch markers and hunks
+    result += '\n# --- PATCH START MARKER ---\n';
+    result += '--- Original\n';
+    result += '+++ Modified\n';
+
+    // Add hunks with a blank line between them
+    result += hunks.join('\n\n');
+
+    result += '\n# --- PATCH END MARKER ---';
+
+    return result;
+}
+
+module.exports = {
+    extractHunks,
+    cleanHunkLineNumbers,
+    extractAndCleanHunks,
+    reconstructPatch
+};