@gitsense/gsc-utils 0.1.0

package/src/PatchUtils/patchVerifier/verifyAndCorrectHunkHeaders.js

@@ -0,0 +1,202 @@
+/**
+ * Component: PatchUtils Verify and Correct Hunk Headers
+ * Block-UUID: 61c74798-bddb-47e1-be48-4a102659933c
+ * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
+ * Version: 1.0.0
+ * Description: Verifies and corrects the hunk headers within a patch based on the line number prefixes in the content lines.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T03:47:25.525Z
+ * 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.
+ */
+
+
+/**
+ * Verifies and corrects the hunk headers (`@@ -old,count +new,count @@`) within a patch
+ * based on the line number prefixes (`NNN:`) found in the hunk's content lines.
+ * Assumes the NNN: prefixes on content lines are already correct (e.g., after running verifyAndCorrectLineNumbers).
+ *
+ * @param {string} patchText - The full text of the patch (ideally, already processed by verifyAndCorrectLineNumbers).
+ * @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 verifyAndCorrectHunkHeaders(patchText) {
+    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; // Track which hunk we are in
+    let currentHunkLines = [];
+    let processingHunk = false;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (line.startsWith('@@ ')) {
+            // End of previous hunk (if any), process it
+            if (processingHunk) {
+                const result = processHunk(outputLines[outputLines.length - 1], currentHunkLines, currentHunkIndex);
+                outputLines[outputLines.length - 1] = result.correctedHeader; // Replace header in output
+                outputLines.push(...currentHunkLines); // Add content lines
+                errors.push(...result.hunkErrors);
+                if (result.corrected) correctionsMade = true;
+            }
+
+            // Start of new hunk
+            processingHunk = true;
+            currentHunkIndex++;
+            currentHunkLines = [];
+            outputLines.push(line); // Add header temporarily, will be replaced after processing
+
+        } else if (processingHunk) {
+            // Line is part of the current hunk's content
+            // Stop collecting if we hit the end marker
+            if (line === '# --- PATCH END MARKER ---') {
+                processingHunk = false; // Stop processing before the marker
+                // Process the last hunk before adding the marker
+                const result = processHunk(outputLines[outputLines.length - 1], currentHunkLines, currentHunkIndex);
+                outputLines[outputLines.length - 1] = result.correctedHeader;
+                outputLines.push(...currentHunkLines);
+                errors.push(...result.hunkErrors);
+                if (result.corrected) correctionsMade = true;
+                outputLines.push(line); // Now add the end marker
+            } else {
+                currentHunkLines.push(line);
+            }
+        } else {
+            // Line is outside a hunk (metadata, markers, etc.)
+            outputLines.push(line);
+        }
+    }
+
+    // Process the very last hunk if the patch didn't end with a marker
+    if (processingHunk) {
+        const result = processHunk(outputLines[outputLines.length - 1], currentHunkLines, currentHunkIndex);
+        outputLines[outputLines.length - 1] = result.correctedHeader;
+        outputLines.push(...currentHunkLines);
+        errors.push(...result.hunkErrors);
+        if (result.corrected) correctionsMade = true;
+    }
+
+    return {
+        correctedPatchText: outputLines.join('\n'),
+        correctionsMade: correctionsMade,
+        errors: errors
+    };
+}
+
+/**
+ * Helper function to process a single hunk's header and content.
+ * @param {string} headerLine - The original hunk header line (@@ ... @@).
+ * @param {string[]} contentLines - Array of lines within the hunk (' ', '+', '-').
+ * @param {number} hunkIndex - The 0-based index of this hunk in the patch.
+ * @returns {{correctedHeader: string, corrected: boolean, hunkErrors: VerificationError[]}}
+ * @private
+ */
+function processHunk(headerLine, contentLines, hunkIndex) {
+    const hunkErrors = [];
+    let corrected = false;
+
+    // Parse the original header
+    const headerMatch = headerLine.match(HUNK_HEADER_REGEX);
+    if (!headerMatch) {
+        hunkErrors.push({ hunkIndex, lineContent: headerLine, message: "Failed to parse original hunk header." });
+        return { correctedHeader: headerLine, corrected, hunkErrors }; // Return original if unparseable
+    }
+
+    // If there are no content lines, keep the original header
+    if (contentLines.length === 0) {
+        return { correctedHeader: headerLine, corrected: false, hunkErrors };
+    }
+
+    // Track line numbers and counts
+    let firstOldLineNumber = null;
+    let lastOldLineNumber = null;
+    let firstNewLineNumber = null;
+    let lastNewLineNumber = null;
+    let additionCount = 0;
+    let deletionCount = 0;
+
+    // First pass: find the line number ranges
+    for (const line of contentLines) {
+        const match = line.match(CONTENT_LINE_REGEX);
+
+        if (!match) {
+            continue;
+        }
+
+        const lineNum = parseInt(match[2], 10);
+        const prefix = match[1]; // ' ', '-', or '+'
+
+        if (prefix === ' ' || prefix === '-') {
+            // Update old file line numbers
+            if (firstOldLineNumber === null) firstOldLineNumber = lineNum;
+            lastOldLineNumber = lineNum;
+        }
+
+        if (prefix === ' ' || prefix === '+') {
+            // Update new file line numbers
+            if (firstNewLineNumber === null) firstNewLineNumber = lineNum;
+            lastNewLineNumber = lineNum;
+        }
+
+        if (prefix === '+') additionCount++;
+        if (prefix === '-') deletionCount++;
+    }
+
+
+    // If we couldn't determine line numbers from content, use the original header values
+    if (firstOldLineNumber === null) {
+        firstOldLineNumber = parseInt(headerMatch[1], 10);
+        firstNewLineNumber = parseInt(headerMatch[3], 10);
+    }
+
+    // Calculate the spans including all lines in the range
+    const oldSpan = lastOldLineNumber - firstOldLineNumber + 1;
+    const newSpan = lastNewLineNumber - firstNewLineNumber + 1;
+
+    // Adjust new span for additions and deletions
+    const finalOldSpan = oldSpan;
+    const finalNewSpan = oldSpan - deletionCount + additionCount;
+
+    // Format the new header
+    // Note: We always include the count even if it's 1, for consistency
+    const oldPart = `${firstOldLineNumber},${finalOldSpan}`;
+    const newPart = `${firstNewLineNumber},${finalNewSpan}`;
+    const correctedHeader = `@@ -${oldPart} +${newPart} @@`;
+
+    // Check if the header actually changed
+    if (correctedHeader !== headerLine) {
+        corrected = true;
+    }
+
+    return { correctedHeader, corrected, hunkErrors };
+}
+
+module.exports = {
+    verifyAndCorrectHunkHeaders,
+};

package/src/PatchUtils/patchVerifier/verifyAndCorrectLineNumbers.js

@@ -0,0 +1,254 @@
+/**
+ * Component: PatchUtils Verify and Correct Line Numbers
+ * Block-UUID: 8a9c6d2f-e3b7-4f15-9d0a-b2c1e5f7a8d9
+ * Parent-UUID: 647c1aef-0552-4072-810c-59bf72e3fdad
+ * Version: 1.2.0
+ * Description: Verifies and corrects the NNN: line number prefixes on context and deletion lines within a patch.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T06:27:12.345Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Claude 3.7 Sonnet (v1.1.0, v1.2.0)
+ */
+
+
+const { removeLineNumbers } = require('../../CodeBlockUtils/lineNumberFormatter'); // Assuming this utility exists
+const { CONTENT_LINE_REGEX } = require('./constants');
+const { formatAndAddLineNumbers } = require('./formatAndAddLineNumbers'); // Import the helper
+
+
+/**
+ * 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.
+ */
+
+
+/**
+ * Verifies and corrects the `NNN:` line number prefixes on context (' ') and deletion ('-') lines
+ * within a patch by comparing their content against the original source code within a sliding window.
+ *
+ * @param {string} patchText - The full text of the patch (including metadata, markers, and NNN: prefixes).
+ * @param {string} sourceText - The original source code text (MUST be clean, without NNN: prefixes).
+ * @param {number} [windowSize=251] - The total size of the search window (e.g., 5 means +/- 2 lines around the reported number). Must be an odd positive integer.
+ * @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 inputs are invalid (e.g., non-string text, invalid window size).
+ */
+function verifyAndCorrectLineNumbers(patchText, sourceText, windowSize = 251) {
+    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.");
+    }
+    if (!Number.isInteger(windowSize) || windowSize <= 0 || windowSize % 2 === 0) {
+        throw new Error("Invalid input: windowSize must be a positive odd integer (e.g., 3, 5, 7).");
+    }
+
+    // Ensure line numbers are present and correctly formatted before verification
+    const formatResult = formatAndAddLineNumbers(patchText, sourceText);
+    const patchLines = formatResult.formattedPatchText.split('\n');
+    // Ensure source is clean (defensive check, though caller should provide clean source)
+    const sourceLines = removeLineNumbers(sourceText).split('\n');
+    const outputLines = [];
+    const errors = [];
+    let correctionsMade = formatResult.correctionsMade; // Inherit corrections made by formatter
+    const windowRadius = Math.floor(windowSize / 2);
+    const padding = String(sourceText.split('\n').length).length;
+    
+    // Track current position in source and target files
+    let currentSourceLineNumber = 0;
+    let currentTargetLineNumber = 0;
+    
+    // Track hunk boundaries
+    let inHunk = false;
+    let hunkSourceStart = 0;
+    let hunkTargetStart = 0;
+    
+    // Process each line in the patch
+    for (let i = 0; i < patchLines.length; i++) {
+        const currentPatchLine = patchLines[i];
+        
+        // Check for hunk headers to reset line tracking
+        if (currentPatchLine.startsWith('@@')) {
+            inHunk = true;
+            outputLines.push(currentPatchLine);
+            
+            // Extract hunk header information to reset line counters
+            const hunkMatch = currentPatchLine.match(/@@ -(\d+),\d+ \+(\d+),\d+ @@/);
+            if (hunkMatch) {
+                hunkSourceStart = parseInt(hunkMatch[1], 10);
+                hunkTargetStart = parseInt(hunkMatch[2], 10);
+                currentSourceLineNumber = hunkSourceStart;
+                currentTargetLineNumber = hunkTargetStart;
+            }
+            continue;
+        }
+        
+        // Skip non-hunk lines (metadata, markers, etc.)
+        if (
+            !inHunk || 
+            currentPatchLine.startsWith('#') || currentPatchLine.startsWith('---') || currentPatchLine.startsWith('+++')
+        ) {
+            outputLines.push(currentPatchLine);
+            continue;
+        }
+        
+        const match = currentPatchLine.match(CONTENT_LINE_REGEX);
+        
+        // Process context lines (space-prefixed)
+        if (currentPatchLine.startsWith(' ')) {
+            if (match) {
+                const reportedLineNum = parseInt(match[2], 10);
+                const patchLineContent = match[3];
+                
+                // Verify content against source
+                let foundMatch = false;
+                let bestMatchIndex = -1;
+                
+                // Define search window
+                const searchStartIndex = Math.max(0, currentSourceLineNumber - 1 - windowRadius);
+                const searchEndIndex = Math.min(sourceLines.length - 1, currentSourceLineNumber - 1 + windowRadius);
+                
+                for (let j = searchStartIndex; j <= searchEndIndex; j++) {
+                    if (sourceLines[j].trim() === patchLineContent.trim()) {
+                        bestMatchIndex = j;
+                        foundMatch = true;
+                        break;
+                    }
+                }
+                
+                if (foundMatch) {
+                    // Use the actual line number from the source
+                    const actualLineNum = bestMatchIndex + 1;
+                    const correctedLine = ` ${String(actualLineNum).padStart(padding, ' ')}: ${patchLineContent}`;
+                    outputLines.push(correctedLine);
+                    
+                    // Update tracking variables
+                    if (actualLineNum !== reportedLineNum) {
+                        correctionsMade = true;
+                    }
+                    
+                    currentSourceLineNumber = actualLineNum + 1;
+                    currentTargetLineNumber = actualLineNum + 1;
+                } else {
+                    // Fallback: use current tracking position
+                    const correctedLine = ` ${String(currentSourceLineNumber).padStart(padding, ' ')}: ${patchLineContent}`;
+                    outputLines.push(correctedLine);
+                    
+                    if (currentSourceLineNumber !== reportedLineNum) {
+                        correctionsMade = true;
+                    }
+                    
+                    errors.push({
+                        originalLineNumber: i + 1,
+                        lineContent: currentPatchLine,
+                        message: `Content not found in source window [${searchStartIndex + 1}-${searchEndIndex + 1}]. Using current position ${currentSourceLineNumber}.`,
+                        searchStart: searchStartIndex + 1,
+                        searchEnd: searchEndIndex + 1
+                    });
+                    
+                    currentSourceLineNumber++;
+                    currentTargetLineNumber++;
+                }
+            } else {
+                // No line number match, keep original
+                outputLines.push(currentPatchLine);
+            }
+        }
+        // Process deletion lines (minus-prefixed)
+        else if (currentPatchLine.startsWith('-')) {
+            if (match) {
+                const reportedLineNum = parseInt(match[2], 10);
+                const patchLineContent = match[3];
+                
+                // Verify content against source
+                let foundMatch = false;
+                let bestMatchIndex = -1;
+                
+                // Define search window
+                const searchStartIndex = Math.max(0, currentSourceLineNumber - 1 - windowRadius);
+                const searchEndIndex = Math.min(sourceLines.length - 1, currentSourceLineNumber - 1 + windowRadius);
+                
+                for (let j = searchStartIndex; j <= searchEndIndex; j++) {
+                    if (sourceLines[j].trim() === patchLineContent.trim()) {
+                        bestMatchIndex = j;
+                        foundMatch = true;
+                        break;
+                    }
+                }
+                
+                if (foundMatch) {
+                    // Use the actual line number from the source
+                    const actualLineNum = bestMatchIndex + 1;
+                    const correctedLine = `- ${String(actualLineNum).padStart(padding, ' ')}: ${patchLineContent}`;
+                    outputLines.push(correctedLine);
+                    
+                    // Update tracking variables
+                    if (actualLineNum !== reportedLineNum) {
+                        correctionsMade = true;
+                    }
+                    
+                    currentSourceLineNumber = actualLineNum + 1;
+                } else {
+                    // Fallback: use current tracking position
+                    const correctedLine = `- ${String(currentSourceLineNumber).padStart(padding, ' ')}: ${patchLineContent}`;
+                    outputLines.push(correctedLine);
+                    
+                    if (currentSourceLineNumber !== reportedLineNum) {
+                        correctionsMade = true;
+                    }
+                    
+                    errors.push({
+                        originalLineNumber: i + 1,
+                        lineContent: currentPatchLine,
+                        message: `Content not found in source window [${searchStartIndex + 1}-${searchEndIndex + 1}]. Using current position ${currentSourceLineNumber}.`,
+                        searchStart: searchStartIndex + 1,
+                        searchEnd: searchEndIndex + 1
+                    });
+                    
+                    currentSourceLineNumber++;
+                }
+            } else {
+                // No line number match, keep original
+                outputLines.push(currentPatchLine);
+            }
+        }
+        // Process addition lines (plus-prefixed)
+        else if (currentPatchLine.startsWith('+')) {
+            if (match) {
+                const patchLineContent = match[3];
+                // For addition lines, use the current target line number
+                const correctedLine = `+ ${String(currentTargetLineNumber).padStart(padding, ' ')}: ${patchLineContent}`;
+                outputLines.push(correctedLine);
+                currentTargetLineNumber++;
+            } else {
+                // No line number match, keep original
+                outputLines.push(currentPatchLine);
+            }
+        }
+        // Any other lines (should be rare in a valid patch)
+        else {
+            outputLines.push(currentPatchLine);
+        }
+    }
+
+    return {
+        correctedPatchText: outputLines.join('\n'),
+        correctionsMade: correctionsMade,
+        errors: errors
+    };
+}
+
+module.exports = {
+    verifyAndCorrectLineNumbers,
+};

package/src/SharedUtils/timestampUtils.js

@@ -0,0 +1,41 @@
+i/**
+ * Component: SharedUtils Timestamp Utilities
+ * Block-UUID: 495fbd8d-a818-4db0-89c4-5311bdfb8537
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for formatting timestamps. Originally part of PatchUtils.
+ * Language: JavaScript
+ * Created-at: 2025-04-18T02:59:04.322Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+/**
+ * Formats a timestamp in a human-readable format
+ * @param {string|Date} timestamp - ISO timestamp or Date object
+ * @returns {string} Formatted date string
+ */
+function formatTimestamp(timestamp) {
+    if (!timestamp) {
+        return 'Unknown date';
+    }
+
+    const date = timestamp instanceof Date ? timestamp : new Date(timestamp);
+
+    if (isNaN(date.getTime())) {
+        return 'Invalid date';
+    }
+
+    return date.toLocaleString(undefined, {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit'
+    });
+}
+
+module.exports = {
+    formatTimestamp
+};

package/src/SharedUtils/versionUtils.js

@@ -0,0 +1,58 @@
+/**
+ * Component: SharedUtils Version Utilities
+ * Block-UUID: c18e08cb-1fc1-4d10-963a-eab9e70f6e6e
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for validating and manipulating semantic version strings. Originally part of PatchUtils.
+ * Language: JavaScript
+ * Created-at: 2025-04-18T02:59:04.322Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+
+/**
+ * Validates version string format (X.Y.Z)
+ * @param {string} version - Version string
+ * @returns {boolean} Whether version is valid
+ */
+function isValidVersion(version) {
+    // Note: This was originally _isValidVersion in PatchUtils
+    return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+/**
+ * Increments a semantic version string
+ * @param {string} version - Version in format X.Y.Z
+ * @param {string} type - Type of increment: 'major', 'minor', or 'patch'
+ * @returns {string} Incremented version
+ */
+function incrementVersion(version, type = 'patch') {
+    if (!version || !/^\d+\.\d+\.\d+$/.test(version)) {
+        throw new Error(`Invalid version format: ${version}`);
+    }
+
+    const parts = version.split('.').map(Number);
+
+    switch (type.toLowerCase()) {
+        case 'major':
+            parts[0] += 1;
+            parts[1] = 0;
+            parts[2] = 0;
+            break;
+        case 'minor':
+            parts[1] += 1;
+            parts[2] = 0;
+            break;
+        case 'patch':
+        default:
+            parts[2] += 1;
+            break;
+    }
+
+    return parts.join('.');
+}
+
+module.exports = {
+    isValidVersion,
+    incrementVersion
+};