@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/diagnosticReporter.js

@@ -0,0 +1,213 @@
+/**
+ * Component: PatchUtils Diagnostic Reporter
+ * Block-UUID: 3a7b9c5d-1e3f-4a2b-8c7d-6e5f4a3b2c1d
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Formats diagnostic information about patch hunks for humans and LLMs.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T16:50:00.000Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0)
+ */
+
+
+/**
+ * Generates a human-readable description of a hunk validation result
+ * @param {object} hunkResult - The validation result for a single hunk
+ * @returns {string} Human-readable description
+ */
+function describeHunkResult(hunkResult) {
+    if (!hunkResult) {
+        return "No hunk result provided";
+    }
+
+    if (hunkResult.valid) {
+        return `Hunk #${hunkResult.hunkIndex + 1} VALID: Applied successfully at specified position.`;
+    }
+
+    let description = `Hunk #${hunkResult.hunkIndex + 1} FAILED: `;
+
+    if (hunkResult.diagnostics) {
+        if (!hunkResult.diagnostics.headerValid) {
+            description += `Invalid hunk header format. ${hunkResult.diagnostics.headerError}`;
+        } else if (hunkResult.diagnostics.method === "direct_failed") {
+            description += hunkResult.diagnostics.message || "Failed to apply at specified position.";
+        } else {
+            description += "Unknown validation error.";
+        }
+    } else {
+        description += "No diagnostic information available.";
+    }
+
+    // Add correction information if available
+    if (hunkResult.correction && hunkResult.correction.success) {
+        description += `\n  - ${hunkResult.correction.explanation}`;
+    } else if (hunkResult.correction) {
+        description += `\n  - Could not generate correction: ${hunkResult.correction.reason}`;
+    }
+
+    return description;
+}
+
+/**
+ * Generates human-readable diagnostics for all hunks
+ * @param {object[]} hunkResults - Array of validation results for all hunks
+ * @returns {string} Human-readable diagnostic report
+ */
+function generateHumanReadableDiagnostics(hunkResults) {
+    if (!Array.isArray(hunkResults) || hunkResults.length === 0) {
+        return "No hunk results to report.";
+    }
+
+    const validHunks = hunkResults.filter(result => result.valid);
+    const invalidHunks = hunkResults.filter(result => !result.valid);
+
+    let report = `Patch Validation Report\n`;
+    report += `======================\n\n`;
+    report += `Summary: ${validHunks.length} of ${hunkResults.length} hunks valid.\n\n`;
+
+    if (invalidHunks.length > 0) {
+        report += `Invalid Hunks:\n`;
+        report += invalidHunks.map(result => describeHunkResult(result)).join('\n\n');
+        report += `\n\n`;
+    }
+
+    if (validHunks.length > 0) {
+        report += `Valid Hunks: ${validHunks.map(result => `#${result.hunkIndex + 1}`).join(', ')}`;
+    }
+
+    return report;
+}
+
+/**
+ * Formats a hunk result for LLM consumption
+ * @param {object} hunkResult - The validation result for a single hunk
+ * @returns {object} Structured hunk result for LLM
+ */
+function formatHunkResultForLLM(hunkResult) {
+    if (!hunkResult) {
+        return { error: "No hunk result provided" };
+    }
+
+    const result = {
+        hunkIndex: hunkResult.hunkIndex,
+        status: hunkResult.valid ? "valid" : "invalid",
+        header: hunkResult.hunk?.header || null
+    };
+
+    if (hunkResult.valid) {
+        result.message = "Hunk applied successfully at specified position";
+    } else {
+        result.issueType = hunkResult.diagnostics?.method === "direct_failed" 
+            ? "context_mismatch" 
+            : "header_invalid";
+
+        result.message = hunkResult.diagnostics?.message || "Unknown validation error";
+
+        if (hunkResult.correction && hunkResult.correction.success) {
+            result.correction = {
+                correctedHeader: hunkResult.correction.correctedHeader,
+                confidence: hunkResult.correction.confidence,
+                explanation: hunkResult.correction.explanation
+            };
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Generates structured feedback for LLMs about patch validation
+ * @param {object[]} hunkResults - Array of validation results for all hunks
+ * @returns {object} Structured feedback for LLM consumption
+ */
+function generateLLMFeedback(hunkResults) {
+    if (!Array.isArray(hunkResults) || hunkResults.length === 0) {
+        return { error: "No hunk results to report" };
+    }
+
+    const validCount = hunkResults.filter(result => result.valid).length;
+
+    return {
+        summary: {
+            totalHunks: hunkResults.length,
+            validHunks: validCount,
+            invalidHunks: hunkResults.length - validCount,
+            overallStatus: validCount === hunkResults.length ? "valid" : "invalid"
+        },
+        hunks: hunkResults.map(formatHunkResultForLLM)
+    };
+}
+
+/**
+ * Formats a diagnostic summary for the entire patch
+ * @param {object} patchResult - The overall patch validation result
+ * @returns {object} Formatted diagnostic summary
+ */
+function formatDiagnosticSummary(patchResult) {
+    if (!patchResult) {
+        return { error: "No patch result provided" };
+    }
+
+    const summary = {
+        success: patchResult.success,
+        hunkCount: patchResult.hunkResults?.length || 0,
+        validHunks: patchResult.hunkResults?.filter(h => h.valid)?.length || 0,
+        hasCorrections: patchResult.hunkResults?.some(h => h.correction?.success) || false
+    };
+
+    summary.allHunksValid = summary.validHunks === summary.hunkCount;
+    summary.allHunksFixable = summary.allHunksValid || 
+        (patchResult.hunkResults?.filter(h => !h.valid)
+            .every(h => h.correction?.success) || false);
+
+    if (!summary.allHunksValid) {
+        summary.invalidHunkIndices = patchResult.hunkResults
+            ?.filter(h => !h.valid)
+            .map(h => h.hunkIndex);
+    }
+
+    return summary;
+}
+
+/**
+ * Generates a concise error message for a failed patch
+ * @param {object} patchResult - The overall patch validation result
+ * @returns {string} Concise error message
+ */
+function generateErrorMessage(patchResult) {
+    if (!patchResult) {
+        return "Patch validation failed: No result available";
+    }
+
+    if (patchResult.success) {
+        return "Patch applied successfully";
+    }
+
+    const summary = formatDiagnosticSummary(patchResult);
+
+    if (summary.allHunksFixable) {
+        return "Patch contains fixable errors in hunk headers";
+    }
+
+    const invalidHunks = patchResult.hunkResults?.filter(h => !h.valid) || [];
+
+    if (invalidHunks.length === 0) {
+        return "Patch validation failed: Unknown error";
+    }
+
+    if (invalidHunks.length === 1) {
+        const hunk = invalidHunks[0];
+        return `Patch validation failed: Hunk #${hunk.hunkIndex + 1} - ${hunk.diagnostics?.message || "Unknown error"}`;
+    }
+
+    return `Patch validation failed: ${invalidHunks.length} invalid hunks (indices: ${summary.invalidHunkIndices?.join(', ')})`;
+}
+
+module.exports = {
+    describeHunkResult,
+    generateHumanReadableDiagnostics,
+    formatHunkResultForLLM,
+    generateLLMFeedback,
+    formatDiagnosticSummary,
+    generateErrorMessage
+};

package/src/PatchUtils/enhancedPatchProcessor.js

@@ -0,0 +1,390 @@
+/**
+ * Component: PatchUtils Enhanced Processor
+ * Block-UUID: 3e9a9106-7f16-4b49-9b38-86d95b413c2a
+ * Parent-UUID: 5bfb717c-aaec-462e-a50e-d096aba0d63f
+ * Version: 1.2.0
+ * Description: Enhanced patch processor with hunk-level validation, diagnostics, and fuzzy matching.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T18:26:31.210Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Flash (v1.1.0), Claude 3.7 Sonnet (v1.2.0)
+ */
+
+
+const jsdiff = require('diff');
+const { removeLineNumbers } = require('../CodeBlockUtils/lineNumberFormatter');
+const { extractAndCleanHunks, reconstructPatch } = require('./patchExtractor');
+const { validateHunk, validateHunks } = require('./hunkValidator');
+const { findBestContextMatch, findBestMatchWithSlidingWindow } = require('./fuzzyMatcher');
+const { generateCorrectedHunk, generateHunkCorrection } = require('./hunkCorrector');
+const { generateHumanReadableDiagnostics, generateLLMFeedback } = require('./diagnosticReporter');
+const { detectAndFixRedundantChanges } = require('./patchVerifier/detectAndFixRedundantChanges');
+
+/**
+ * @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
+ */
+
+/**
+ * Applies a patch with detailed per-hunk diagnostics
+ * @param {string} sourceText - Original source code
+ * @param {string} patchText - Patch text from LLM
+ * @returns {object} Comprehensive results including diagnostics
+ */
+function applyPatchWithDiagnostics(sourceText, patchText) {
+    if (!sourceText || !patchText) {
+        return {
+            success: false,
+            error: "Missing source or patch text",
+            patchedText: null,
+            hunkResults: []
+        };
+    }
+
+    // Clean source text (remove any line numbers)
+    const cleanSourceText = removeLineNumbers(sourceText);
+
+    // First, clean up redundant changes
+    const redundantFixResult = detectAndFixRedundantChanges(patchText, true);
+    const cleanedPatchText = redundantFixResult.correctionsMade
+        ? redundantFixResult.correctedPatchText
+        : patchText;
+
+    // Extract hunks from the patch
+    const { metadata, hunks } = extractAndCleanHunks(cleanedPatchText);
+
+    if (hunks.length === 0) {
+        return {
+            success: false,
+            error: "No hunks found in patch",
+            patchedText: null,
+            hunkResults: []
+        };
+    }
+
+    // Validate each hunk
+    const hunkResults = validateHunks(cleanSourceText, hunks);
+
+    // For invalid hunks, try fuzzy matching
+    for (let i = 0; i < hunkResults.length; i++) {
+        const result = hunkResults[i];
+
+        if (!result.valid && result.diagnostics?.needsFuzzyMatching) {
+            // Try fuzzy matching using the correct context for matching
+            const matchResult = findBestMatchWithSlidingWindow(
+                result.hunk.contextLinesForMatching, // Use the new array
+                cleanSourceText
+            );
+
+            // Generate correction if match found
+            if (matchResult.found) {
+                const correction = generateHunkCorrection(result, matchResult);
+                hunkResults[i].correction = correction;
+                hunkResults[i].matchResult = matchResult;
+            } else {
+                hunkResults[i].correction = {
+                    success: false,
+                    reason: matchResult.reason || "No suitable match found"
+                };
+                hunkResults[i].matchResult = matchResult;
+            }
+        }
+    }
+
+    // Check if all hunks are valid or fixable
+    const allValid = hunkResults.every(result => result.valid);
+    const allFixable = hunkResults
+        .filter(result => !result.valid)
+        .every(result => result.correction && result.correction.success);
+
+    // If all hunks are valid, apply the patch directly
+    if (allValid) {
+        try {
+            const patchedText = jsdiff.applyPatch(cleanSourceText, patchText);
+
+            if (patchedText === false) {
+                return {
+                    success: false,
+                    error: "Failed to apply patch despite all hunks validating individually",
+                    patchedText: null,
+                    hunkResults,
+                    humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                    llmFeedback: generateLLMFeedback(hunkResults)
+                };
+            }
+
+            return {
+                success: true,
+                patchedText,
+                hunkResults,
+                humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                llmFeedback: generateLLMFeedback(hunkResults)
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: `Error applying patch: ${error.message}`,
+                patchedText: null,
+                hunkResults,
+                humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                llmFeedback: generateLLMFeedback(hunkResults)
+            };
+        }
+    }
+
+    // If all invalid hunks are fixable, create a corrected patch and apply it
+    if (allFixable) {
+        try {
+            // Create corrected hunks
+            const correctedHunks = hunkResults.map(result => {
+                if (result.valid) {
+                    return hunks[result.hunkIndex];
+                } else {
+                    return result.correction.correctedHunkText;
+                }
+            });
+
+            // Reconstruct the patch
+            const correctedPatch = reconstructPatch(metadata, correctedHunks);
+
+            // Apply the corrected patch
+            const patchedText = jsdiff.applyPatch(cleanSourceText, correctedPatch.replace(/# --- PATCH (START|END) MARKER ---/g, ''));
+
+            if (patchedText === false) {
+                return {
+                    success: false,
+                    error: "Failed to apply corrected patch",
+                    patchedText: null,
+                    correctedPatch,
+                    hunkResults,
+                    humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                    llmFeedback: generateLLMFeedback(hunkResults)
+                };
+            }
+
+            return {
+                success: true,
+                patchedText,
+                correctedPatch,
+                hunkResults,
+                patchWasCorrected: true,
+                humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                llmFeedback: generateLLMFeedback(hunkResults)
+            };
+        } catch (error) {
+            return {
+                success: false,
+                error: `Error applying corrected patch: ${error.message}`,
+                patchedText: null,
+                hunkResults,
+                humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+                llmFeedback: generateLLMFeedback(hunkResults)
+            };
+        }
+    }
+
+    // If we get here, some hunks are invalid and not fixable
+    return {
+        success: false,
+        error: "Some hunks are invalid and could not be fixed",
+        patchedText: null,
+        hunkResults,
+        humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+        llmFeedback: generateLLMFeedback(hunkResults)
+    };
+}
+
+/**
+ * Validates a patch without applying it
+ * @param {string} sourceText - Original source code
+ * @param {string} patchText - Patch text from LLM
+ * @returns {object} Validation results with diagnostics
+ */
+function validatePatch(sourceText, patchText) {
+    if (!sourceText || !patchText) {
+        return {
+            valid: false,
+            error: "Missing source or patch text",
+            hunkResults: []
+        };
+    }
+
+    // Clean source text
+    const cleanSourceText = removeLineNumbers(sourceText);
+
+    // Clean up redundant changes
+    const redundantFixResult = detectAndFixRedundantChanges(patchText, true);
+    const cleanedPatchText = redundantFixResult.correctionsMade
+        ? redundantFixResult.correctedPatchText
+        : patchText;
+
+    // Extract hunks
+    const { metadata, hunks } = extractAndCleanHunks(cleanedPatchText);
+
+    if (hunks.length === 0) {
+        return {
+            valid: false,
+            error: "No hunks found in patch",
+            hunkResults: []
+        };
+    }
+
+    // Validate each hunk
+    const hunkResults = validateHunks(cleanSourceText, hunks);
+
+    // For invalid hunks, try fuzzy matching
+    for (let i = 0; i < hunkResults.length; i++) {
+        const result = hunkResults[i];
+
+        if (!result.valid && result.diagnostics?.needsFuzzyMatching) {
+            const matchResult = findBestMatchWithSlidingWindow(
+                result.hunk.contextLinesForMatching, // Use the new array
+                cleanSourceText
+            );
+
+            if (matchResult.found) {
+                const correction = generateHunkCorrection(result, matchResult);
+                hunkResults[i].correction = correction;
+                hunkResults[i].matchResult = matchResult;
+            } else {
+                hunkResults[i].correction = {
+                    success: false,
+                    reason: matchResult.reason || "No suitable match found"
+                };
+                hunkResults[i].matchResult = matchResult;
+            }
+        }
+    }
+
+    // Check if all hunks are valid or fixable
+    const allValid = hunkResults.every(result => result.valid);
+    const allFixable = hunkResults
+        .filter(result => !result.valid)
+        .every(result => result.correction && result.correction.success);
+
+    return {
+        valid: allValid,
+        fixable: !allValid && allFixable,
+        hunkResults,
+        humanReadableDiagnostics: generateHumanReadableDiagnostics(hunkResults),
+        llmFeedback: generateLLMFeedback(hunkResults)
+    };
+}
+
+/**
+ * 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
+ */
+function applyHunk(sourceText, hunkText) {
+    if (!sourceText || !hunkText) {
+        return {
+            success: false,
+            error: "Missing source or hunk text",
+            patchedText: null
+        };
+    }
+
+    // Clean source text
+    const cleanSourceText = removeLineNumbers(sourceText);
+
+    // Clean hunk line numbers
+    const cleanHunk = cleanHunkLineNumbers(hunkText);
+
+    // Validate the hunk
+    const validation = validateHunk(cleanSourceText, cleanHunk);
+
+    if (validation.valid) {
+        return {
+            success: true,
+            patchedText: validation.appliedText,
+            validation
+        };
+    }
+
+    // Try fuzzy matching
+    const matchResult = findBestMatchWithSlidingWindow(
+        validation.hunk.contextLinesForMatching, // Use the new array
+        cleanSourceText
+    );
+
+    if (matchResult.found) {
+        const correction = generateHunkCorrection(validation, matchResult);
+
+        if (correction.success) {
+            try {
+                // Create a minimal patch with just this hunk
+                const minimalPatch = `--- Original\n+++ Modified\n${correction.correctedHunkText}`;
+
+                // Apply the corrected hunk
+                const patchedText = jsdiff.applyPatch(cleanSourceText, minimalPatch);
+
+                if (patchedText === false) {
+                    return {
+                        success: false,
+                        error: "Failed to apply corrected hunk",
+                        patchedText: null,
+                        validation,
+                        correction,
+                        matchResult
+                    };
+                }
+
+                return {
+                    success: true,
+                    patchedText,
+                    validation,
+                    correction,
+                    matchResult,
+                    hunkWasCorrected: true
+                };
+            } catch (error) {
+                return {
+                    success: false,
+                    error: `Error applying corrected hunk: ${error.message}`,
+                    patchedText: null,
+                    validation,
+                    correction,
+                    matchResult
+                };
+            }
+        }
+    }
+
+    return {
+        success: false,
+        error: "Hunk is invalid and could not be fixed",
+        patchedText: null,
+        validation,
+        matchResult: matchResult || null
+    };
+}
+
+module.exports = {
+    applyPatchWithDiagnostics,
+    validatePatch,
+    applyHunk
+};