@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/fuzzyMatcher.js

@@ -0,0 +1,252 @@
+/**
+ * Component: PatchUtils Fuzzy Matcher
+ * Block-UUID: 12e76392-f0ac-4c9d-a5be-c98401487352
+ * Parent-UUID: 7679fc85-9213-4637-8d41-9bb5c551c62d
+ * Version: 1.1.0
+ * Description: Implements fuzzy matching algorithms to find the best location for patch hunks.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T18:09:37.976Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ */
+
+
+/**
+ * Calculates the longest common subsequence length between two strings
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} Length of the longest common subsequence
+ * @private
+ */
+function _lcsLength(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array(m + 1).fill().map(() => Array(n + 1).fill(0));
+
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+
+    return dp[m][n];
+}
+
+/**
+ * Calculates similarity score between two strings using LCS
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} Similarity score between 0 and 1
+ * @private
+ */
+function _calculateSimilarity(a, b) {
+    if (!a.length || !b.length) return 0;
+    const lcs = _lcsLength(a, b);
+    return lcs / Math.max(a.length, b.length);
+}
+
+/**
+ * Calculates similarity score between two blocks of text
+ * @param {string[]} blockA - First block of text (array of lines)
+ * @param {string[]} blockB - Second block of text (array of lines)
+ * @returns {number} Similarity score between 0 and 1
+ * @private
+ */
+function _calculateBlockSimilarity(blockA, blockB) {
+    if (blockA.length !== blockB.length) {
+        // If blocks have different number of lines, calculate average similarity
+        let totalSimilarity = 0;
+        const minLength = Math.min(blockA.length, blockB.length);
+
+        // Compare available lines
+        for (let i = 0; i < minLength; i++) {
+            totalSimilarity += _calculateSimilarity(blockA[i], blockB[i]);
+        }
+
+        // Penalize for length difference
+        const lengthPenalty = minLength / Math.max(blockA.length, blockB.length);
+        return (totalSimilarity / blockA.length) * lengthPenalty;
+    }
+
+    // If blocks have same number of lines, calculate average line similarity
+    let totalSimilarity = 0;
+    for (let i = 0; i < blockA.length; i++) {
+        totalSimilarity += _calculateSimilarity(blockA[i], blockB[i]);
+    }
+
+    return totalSimilarity / blockA.length;
+}
+
+/**
+ * Finds the best match for context lines within source code
+ * @param {string[]} contextLinesForMatching - Array of context lines (including removed lines)
+ * @param {string} sourceCode - Full source code to search within
+ * @param {object} options - Optional parameters
+ * @param {number} options.threshold - Minimum similarity threshold (default: 0.7)
+ * @param {number} options.maxMatches - Maximum number of matches to return (default: 3)
+ * @returns {object} Best match information with position and confidence
+ */
+function findBestContextMatch(contextLinesForMatching, sourceCode, options = {}) {
+    const { threshold = 0.7, maxMatches = 3 } = options;
+
+    // If no context lines, return no match
+    if (!contextLinesForMatching.length) {
+        return {
+            found: false,
+            reason: "No context lines provided for matching",
+            matches: []
+        };
+    }
+
+    const sourceLines = sourceCode.split('\n');
+    const matches = [];
+
+    // For each possible starting position in the source
+    for (let i = 0; i <= sourceLines.length - contextLinesForMatching.length; i++) {
+        const sourceBlock = sourceLines.slice(i, i + contextLinesForMatching.length);
+        const similarity = _calculateBlockSimilarity(
+            contextLinesForMatching.map(line => line.trim()),
+            sourceBlock.map(line => line.trim())
+        );
+
+        if (similarity >= threshold) {
+            matches.push({
+                position: i + 1, // Convert to 1-based line numbers
+                confidence: similarity,
+                sourceBlock
+            });
+        }
+    }
+
+    // Sort matches by confidence (descending)
+    matches.sort((a, b) => b.confidence - a.confidence);
+
+    // Limit number of matches
+    const topMatches = matches.slice(0, maxMatches);
+
+    if (topMatches.length === 0) {
+        return {
+            found: false,
+            reason: "No matches found above threshold",
+            threshold,
+            matches: []
+        };
+    }
+
+    return {
+        found: true,
+        bestMatch: topMatches[0],
+        matches: topMatches
+    };
+}
+
+/**
+ * Finds exact matches for a single context line
+ * @param {string} contextLine - A single context line to find
+ * @param {string} sourceCode - Full source code to search within
+ * @returns {number[]} Array of line numbers (1-based) where the context line appears
+ */
+function findExactLineMatches(contextLine, sourceCode) {
+    const sourceLines = sourceCode.split('\n');
+    const matches = [];
+
+    const trimmedContext = contextLine.trim();
+
+    for (let i = 0; i < sourceLines.length; i++) {
+        if (sourceLines[i].trim() === trimmedContext) {
+            matches.push(i + 1); // Convert to 1-based line numbers
+        }
+    }
+
+    return matches;
+}
+
+/**
+ * Finds the best match using a sliding window approach
+ * @param {string[]} contextLinesForMatching - Array of context lines (including removed lines)
+ * @param {string} sourceCode - Full source code
+ * @param {number} windowSize - Size of the sliding window
+ * @returns {object} Best match information
+ */
+function findBestMatchWithSlidingWindow(contextLinesForMatching, sourceCode, windowSize = 3) {
+    if (contextLinesForMatching.length < windowSize) {
+        // If we have fewer context lines than the window size, use regular matching
+        return findBestContextMatch(contextLinesForMatching, sourceCode);
+    }
+
+    const sourceLines = sourceCode.split('\n');
+    const numWindows = contextLinesForMatching.length - windowSize + 1;
+    const candidatePositions = [];
+
+    // For each window in the context lines
+    for (let windowStart = 0; windowStart < numWindows; windowStart++) {
+        const windowLines = contextLinesForMatching.slice(windowStart, windowStart + windowSize);
+
+        // Find matches for this window
+        const windowMatches = findBestContextMatch(windowLines, sourceCode, { threshold: 0.9 });
+
+        if (windowMatches.found) {
+            // For each match of this window
+            for (const match of windowMatches.matches) {
+                // Calculate the position where the full context would start
+                const fullContextStart = match.position - windowStart;
+
+                // Only consider valid positions
+                if (fullContextStart >= 1 && fullContextStart + contextLinesForMatching.length <= sourceLines.length + 1) {
+                    candidatePositions.push({
+                        position: fullContextStart,
+                        windowConfidence: match.confidence,
+                        windowStart
+                    });
+                }
+            }
+        }
+    }
+
+    // If no candidate positions found
+    if (candidatePositions.length === 0) {
+        return {
+            found: false,
+            reason: "No matching windows found",
+            matches: []
+        };
+    }
+
+    // Evaluate each candidate position with the full context
+    const evaluatedPositions = candidatePositions.map(candidate => {
+        const sourceBlock = sourceLines.slice(
+            candidate.position - 1,
+            candidate.position - 1 + contextLinesForMatching.length
+        );
+
+        const fullSimilarity = _calculateBlockSimilarity(
+            contextLinesForMatching.map(line => line.trim()),
+            sourceBlock.map(line => line.trim())
+        );
+
+        return {
+            position: candidate.position,
+            confidence: fullSimilarity,
+            sourceBlock,
+            windowConfidence: candidate.windowConfidence
+        };
+    });
+
+    // Sort by confidence
+    evaluatedPositions.sort((a, b) => b.confidence - a.confidence);
+
+    return {
+        found: evaluatedPositions.length > 0,
+        bestMatch: evaluatedPositions[0] || null,
+        matches: evaluatedPositions.slice(0, 3)
+    };
+}
+
+module.exports = {
+    findBestContextMatch,
+    findExactLineMatches,
+    findBestMatchWithSlidingWindow
+};

package/src/PatchUtils/hunkCorrector.js

@@ -0,0 +1,204 @@
+/**
+ * Component: PatchUtils Hunk Corrector
+ * Block-UUID: f0c9d9fe-facc-4d04-a246-d24aab8de3d8
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Generates corrected hunks based on validation results and fuzzy matching.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T16:45:00.000Z
+ * Authors: Claude 3.7 Sonnet (v1.0.0)
+ */
+
+
+/**
+ * Recalculates a hunk header based on the matched position and content
+ * @param {number} matchPosition - The 1-based line number where the hunk should start
+ * @param {string[]} contextLines - Context lines in the hunk
+ * @param {string[]} addedLines - Lines being added
+ * @param {string[]} removedLines - Lines being removed
+ * @returns {string} Corrected hunk header
+ */
+function recalculateHunkHeader(matchPosition, contextLines, addedLines, removedLines) {
+    // Calculate old count (context + removed)
+    const oldCount = contextLines.length + removedLines.length;
+
+    // Calculate new count (context + added)
+    const newCount = contextLines.length + addedLines.length;
+
+    // Format the header parts
+    const oldPart = oldCount === 1 ? `${matchPosition}` : `${matchPosition},${oldCount}`;
+    const newPart = newCount === 1 ? `${matchPosition}` : `${matchPosition},${newCount}`;
+
+    return `@@ -${oldPart} +${newPart} @@`;
+}
+
+/**
+ * Reconstructs a hunk with the corrected header
+ * @param {string} header - The corrected hunk header
+ * @param {string[]} contextLines - Context lines in the hunk
+ * @param {string[]} addedLines - Lines being added
+ * @param {string[]} removedLines - Lines being removed
+ * @returns {string} Reconstructed hunk
+ */
+function reconstructHunk(header, contextLines, addedLines, removedLines) {
+    const lines = [header];
+
+    // A simple approach would be to add all context, then removals, then additions
+    // But that's not how patches typically look. Instead, we need to interleave them.
+
+    // This is a simplified approach - a real implementation would need to preserve
+    // the original structure of context/added/removed lines
+
+    // Add context and removed lines first (interleaved)
+    let contextIndex = 0;
+    let removedIndex = 0;
+
+    while (contextIndex < contextLines.length || removedIndex < removedLines.length) {
+        // Add a context line
+        if (contextIndex < contextLines.length) {
+            lines.push(` ${contextLines[contextIndex]}`);
+            contextIndex++;
+        }
+
+        // Add a removed line
+        if (removedIndex < removedLines.length) {
+            lines.push(`-${removedLines[removedIndex]}`);
+            removedIndex++;
+        }
+    }
+
+    // Add all addition lines at the end
+    for (const line of addedLines) {
+        lines.push(`+${line}`);
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Generates a corrected hunk based on fuzzy matching results
+ * @param {object} originalHunk - The original parsed hunk
+ * @param {object} matchResult - Result from fuzzy matching
+ * @returns {object} Corrected hunk information
+ */
+function generateCorrectedHunk(originalHunk, matchResult) {
+    if (!matchResult.found || !matchResult.bestMatch) {
+        return {
+            success: false,
+            reason: matchResult.reason || "No suitable match found",
+            originalHunk
+        };
+    }
+
+    const { contextLines, addedLines, removedLines } = originalHunk;
+    const matchPosition = matchResult.bestMatch.position;
+
+    // Recalculate the header
+    const correctedHeader = recalculateHunkHeader(
+        matchPosition,
+        contextLines,
+        addedLines,
+        removedLines
+    );
+
+    // Reconstruct the hunk
+    const correctedHunkText = reconstructHunk(
+        correctedHeader,
+        contextLines,
+        addedLines,
+        removedLines
+    );
+
+    return {
+        success: true,
+        correctedHunkText,
+        correctedHeader,
+        matchPosition,
+        confidence: matchResult.bestMatch.confidence,
+        originalHunk
+    };
+}
+
+/**
+ * Preserves the original structure of a hunk while updating its header
+ * @param {string} originalHunkText - The original hunk text
+ * @param {string} correctedHeader - The corrected header
+ * @returns {string} Hunk with preserved structure but updated header
+ */
+function preserveHunkStructure(originalHunkText, correctedHeader) {
+    const lines = originalHunkText.split('\n');
+
+    // Replace just the header line
+    if (lines.length > 0 && lines[0].startsWith('@@ ')) {
+        lines[0] = correctedHeader;
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Generates a corrected version of a problematic hunk
+ * @param {object} hunkValidation - Validation result for the hunk
+ * @param {object} matchResult - Result from fuzzy matching
+ * @returns {object} Corrected hunk with explanation
+ */
+function generateHunkCorrection(hunkValidation, matchResult) {
+    if (!hunkValidation || !matchResult) {
+        return {
+            success: false,
+            reason: "Missing validation or match result"
+        };
+    }
+
+    if (hunkValidation.valid) {
+        return {
+            success: true,
+            message: "Hunk is already valid",
+            hunkText: hunkValidation.hunk.originalLines.join('\n'),
+            needsCorrection: false
+        };
+    }
+
+    if (!matchResult.found) {
+        return {
+            success: false,
+            reason: matchResult.reason || "No suitable match found",
+            diagnostics: {
+                originalHeader: hunkValidation.hunk.header,
+                contextLines: hunkValidation.hunk.contextLines,
+                matchAttempts: matchResult.matches || []
+            }
+        };
+    }
+
+    // Generate corrected hunk
+    const correctedHeader = recalculateHunkHeader(
+        matchResult.bestMatch.position,
+        hunkValidation.hunk.contextLines,
+        hunkValidation.hunk.addedLines,
+        hunkValidation.hunk.removedLines
+    );
+
+    // Preserve the original structure but update the header
+    const originalHunkText = [hunkValidation.hunk.header, ...hunkValidation.hunk.originalLines].join('\n');
+    const correctedHunkText = preserveHunkStructure(originalHunkText, correctedHeader);
+
+    return {
+        success: true,
+        correctedHunkText,
+        correctedHeader,
+        originalHeader: hunkValidation.hunk.header,
+        matchPosition: matchResult.bestMatch.position,
+        confidence: matchResult.bestMatch.confidence,
+        needsCorrection: true,
+        explanation: `Hunk header corrected from "${hunkValidation.hunk.header}" to "${correctedHeader}" based on fuzzy matching with ${(matchResult.bestMatch.confidence * 100).toFixed(1)}% confidence.`
+    };
+}
+
+module.exports = {
+    recalculateHunkHeader,
+    reconstructHunk,
+    generateCorrectedHunk,
+    preserveHunkStructure,
+    generateHunkCorrection
+};