@gitsense/gsc-utils 0.2.25 → 0.2.27

package/src/SharedUtils/stringUtils.js

@@ -0,0 +1,303 @@
+/*
+ * Component: StringUtils
+ * Block-UUID: 7069f2b4-f0b3-4dcd-9eae-5cecaddcdd66
+ * Version: 1.0.0
+ * Description: A collection of utility functions for common string manipulation and processing tasks within GitSense Chat.
+ * Language: JavaScript
+ * Created-at: 2025-10-30T22:06:47.000Z
+ * Authors: Qwen 3 Coder 480B - Cerebras (v1.0.0)
+ */
+
+
+/**
+ * Splits a string into an array of substrings based on a delimiter, up to a specified limit.
+ * This mimics behavior similar to Python's `str.split(sep, maxsplit)` or Java's `String.split(regex, limit)`.
+ * 
+ * @param {string} text - The string to split.
+ * @param {string|RegExp} delimiter - The delimiter to split the string by.
+ * @param {number} [limit=Infinity] - The maximum number of parts to return. The final part will contain the remainder of the string.
+ * @returns {string[]} An array of substrings.
+ */
+function splitWithLimit(text, delimiter, limit = Infinity) {
+    if (limit === 0) {
+        return [];
+    }
+    if (limit === 1) {
+        return [text];
+    }
+
+    const parts = [];
+    let remainingText = text;
+    let count = 0;
+
+    // Handle RegExp delimiter
+    if (delimiter instanceof RegExp) {
+        // For RegExp, we need to manually find matches and slice the string
+        // This is a simplified approach and might not cover all edge cases of global regex matching
+        // especially with capture groups or zero-width matches.
+        const flags = delimiter.flags.includes('g') ? delimiter.flags : delimiter.flags + 'g';
+        const globalDelimiter = new RegExp(delimiter.source, flags);
+        let match;
+        let lastIndex = 0;
+        let matchCount = 0;
+
+        // We need (limit - 1) matches to create `limit` parts
+        while ((match = globalDelimiter.exec(remainingText)) !== null && matchCount < limit - 1) {
+            // Add the part before the match
+            parts.push(remainingText.substring(lastIndex, match.index));
+            // Add the matched delimiter part itself if it's non-empty (important for zero-width matches)
+            // This part is tricky; typically, the delimiter itself is not part of the returned array.
+            // The logic below follows the standard split behavior where the delimiter is not included.
+            lastIndex = match.index + match[0].length;
+            matchCount++;
+            // Avoid infinite loop for zero-length matches
+            if (match.index === globalDelimiter.lastIndex) {
+                globalDelimiter.lastIndex++;
+            }
+        }
+        // Add the final part
+        parts.push(remainingText.substring(lastIndex));
+    } else {
+        // Handle string delimiter
+        const delimLength = delimiter.length;
+        if (delimLength === 0) {
+             // If delimiter is an empty string, split by characters
+             // This is consistent with JS String.split('')
+            return text.split('').slice(0, limit);
+        }
+        let index;
+        while (count < limit - 1 && (index = remainingText.indexOf(delimiter)) !== -1) {
+            parts.push(remainingText.substring(0, index));
+            remainingText = remainingText.substring(index + delimLength);
+            count++;
+        }
+        // Add the final part (the rest of the string)
+        parts.push(remainingText);
+    }
+
+    return parts;
+}
+
+/**
+ * Capitalizes the first character of a string.
+ * 
+ * @param {string} text - The string to capitalize.
+ * @returns {string} The string with its first character capitalized.
+ */
+function capitalize(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+/**
+ * Converts a string to title case (capitalizing the first letter of each word).
+ * Words are sequences of characters separated by space, tab, or newline.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in title case.
+ */
+function titleCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    // Split by one or more whitespace characters
+    return text.split(/\s+/).map(word => capitalize(word)).join(' ');
+}
+
+/**
+ * Converts a string to camelCase.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in camelCase.
+ */
+function camelCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map((word, index) => {
+            if (index === 0) {
+                // First word is lowercase
+                return word.toLowerCase();
+            }
+            // Subsequent words have their first letter capitalized
+            return capitalize(word.toLowerCase());
+        })
+        .join('');
+}
+
+/**
+ * Converts a string to PascalCase.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in PascalCase.
+ */
+function pascalCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => capitalize(word.toLowerCase()))
+        .join('');
+}
+
+/**
+ * Converts a string to kebab-case.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in kebab-case.
+ */
+function kebabCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toLowerCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('-');
+}
+
+/**
+ * Converts a string to snake_case.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in snake_case.
+ */
+function snakeCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toLowerCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('_');
+}
+
+/**
+ * Converts a string to CONSTANT_CASE.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in CONSTANT_CASE.
+ */
+function constantCase(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toUpperCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('_');
+}
+
+/**
+ * Trims leading and trailing whitespace and normalizes internal whitespace
+ * (replacing sequences of whitespace characters with a single space).
+ * 
+ * @param {string} text - The string to trim and normalize.
+ * @returns {string} The trimmed and normalized string.
+ */
+function trimWhitespace(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.trim().replace(/\s+/g, ' ');
+}
+
+/**
+ * Truncates a string to a specified maximum length and appends a suffix if truncated.
+ * 
+ * @param {string} text - The string to truncate.
+ * @param {number} maxLength - The maximum length of the string.
+ * @param {string} [suffix='...'] - The suffix to append if the string is truncated.
+ * @returns {string} The truncated string with suffix, or the original string if not truncated.
+ */
+function truncate(text, maxLength, suffix = '...') {
+    if (!text || typeof text !== 'string' || maxLength <= 0) {
+        return '';
+    }
+    if (text.length <= maxLength) {
+        return text;
+    }
+    // Ensure we don't cut the suffix itself if maxLength is very small
+    const suffixLength = suffix.length;
+    if (maxLength <= suffixLength) {
+         // If max length is less than or equal to suffix, return a truncated suffix
+         // This is a bit of an edge case, but handles it gracefully.
+        return suffix.substring(0, maxLength);
+    }
+    return text.substring(0, maxLength - suffixLength) + suffix;
+}
+
+/**
+ * Escapes HTML characters in a string to prevent them from being interpreted as HTML.
+ * 
+ * @param {string} text - The string to escape.
+ * @returns {string} The escaped string.
+ */
+function escapeHtml(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    const htmlEscapes = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+    };
+    return text.replace(/[&<>"']/g, match => htmlEscapes[match]);
+}
+
+/**
+ * Removes HTML tags from a string.
+ * 
+ * @param {string} text - The string to strip tags from.
+ * @returns {string} The string without HTML tags.
+ */
+function stripHtml(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.replace(/<[^>]*>/g, '');
+}
+
+/**
+ * Performs a basic check to see if a string looks like a valid email address.
+ * This is a simple validation and should not be used for robust security checks.
+ * 
+ * @param {string} email - The email string to validate.
+ * @returns {boolean} True if the string looks like a valid email, false otherwise.
+ */
+function isValidEmail(email) {
+    if (!email || typeof email !== 'string') {
+        return false;
+    }
+    // A basic regex for email validation. Note: Fully validating email addresses
+    // is extremely complex. This covers common cases.
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+
+
+module.exports = {
+    splitWithLimit,
+    capitalize,
+    titleCase,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    constantCase,
+    pascalCase,
+    trimWhitespace,
+    truncate,
+    escapeHtml,
+    stripHtml,
+    isValidEmail,
+};

package/src/CodeBlockUtils/blockProcessor.js.rej

@@ -1,8 +0,0 @@
-@@ -262,6 +283,7 @@
- function processCodeBlocks(text, options = { silent: false, validatePatches: false }) {
-     if (typeof text !== "string") { // Allow empty strings
-         console.warn("Warning: Input must be a string.");
-+        return { blocks: [], warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }], hasIncompleteBlocks: false, lastIncompleteBlock: null };
-     }
-      if (text.trim() === "") {
-         return { blocks: [], warnings: [], hasIncompleteBlocks: false, lastIncompleteBlock: null };