minovative-mind-cli 1.0.0

package/dist/utils/excludedExtensions.js

@@ -0,0 +1,125 @@
+/**
+ * Comprehensive list of binary/generated file extensions that grep should skip.
+ * Covers images, video, audio, fonts, archives, documents, compiled artifacts,
+ * IDE files, and tool-specific generated files across all major languages.
+ * These are used to prevent commands like `grep` from searching through
+ * non-textual or compiled files, which can lead to incorrect results or errors.
+ */
+export const EXCLUDED_EXTENSIONS = [
+    // --- Images ---
+    "*.png",
+    "*.jpg",
+    "*.jpeg",
+    "*.gif",
+    "*.bmp",
+    "*.ico",
+    "*.webp",
+    "*.svg",
+    "*.tiff",
+    // --- Video ---
+    "*.mp4",
+    "*.webm",
+    "*.avi",
+    "*.mov",
+    "*.mkv",
+    "*.wmv",
+    "*.flv",
+    // --- Audio ---
+    "*.mp3",
+    "*.wav",
+    "*.ogg",
+    "*.aac",
+    // --- Fonts ---
+    "*.woff",
+    "*.woff2",
+    "*.ttf",
+    "*.otf",
+    "*.eot",
+    // --- Archives ---
+    "*.zip",
+    "*.rar",
+    "*.7z",
+    "*.tar",
+    "*.gz",
+    "*.tgz",
+    // --- Documents ---
+    "*.pdf",
+    "*.doc",
+    "*.docx",
+    "*.ppt",
+    "*.pptx",
+    "*.xls",
+    "*.xlsx",
+    // --- Compiled/Binary Artifacts (C/C++/.NET/Go) ---
+    "*.exe",
+    "*.dll",
+    "*.so",
+    "*.dylib",
+    "*.o",
+    "*.a",
+    "*.obj",
+    "*.lib",
+    "*.exp",
+    "*.ilk",
+    "*.pch",
+    "*.gch",
+    "*.d",
+    "*.pdb",
+    "*.aps",
+    "*.ncb",
+    "*.opensdf",
+    "*.sdf",
+    // --- Java/Kotlin ---
+    "*.class",
+    "*.jar",
+    "*.war",
+    "*.ear",
+    // --- Python ---
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    "*.spec",
+    // --- Go ---
+    "*.test",
+    // --- Ruby ---
+    "*.gem",
+    // --- iOS/macOS ---
+    "*.ipa",
+    "*.app",
+    "*.dSYM",
+    "*.xcuserdatad",
+    // --- .NET/Visual Studio ---
+    "*.user",
+    "*.filters",
+    "*.suo",
+    // --- IDE/Editor Files ---
+    "*.iml",
+    "*.ipr",
+    "*.iws",
+    "*.swp",
+    "*.swo",
+    "*.swn",
+    "*.elc",
+    "*.sublime-project",
+    "*.sublime-workspace",
+    // --- Terraform ---
+    "*.tfstate",
+    // --- TypeScript ---
+    "*.tsbuildinfo",
+    // --- Database ---
+    "*.vsix",
+    "*.db",
+    "*.sqlite",
+    "*.sqlite3",
+    // --- Source Maps / Logs / Locks ---
+    "*.log",
+    "*.lock",
+    "*.map",
+    // --- Misc Generated/Temp ---
+    "*.tmp",
+    "*.bak",
+    "*.orig",
+    "*.rej",
+    "*.patch",
+    "*.diff",
+];

package/dist/utils/fuzzyMatch.d.ts

@@ -0,0 +1,21 @@
+export interface MatchResult {
+    start: number;
+    end: number;
+    strategy: string;
+}
+/**
+ * Trims each line, collapses multiple spaces/tabs to single space,
+ * and normalizes line endings.
+ */
+export declare function normalizeWhitespace(text: string): string;
+/**
+ * Returns 0-1 similarity ratio.
+ * 1.0 is exact match, 0.0 is completely different.
+ */
+export declare function levenshteinSimilarity(a: string, b: string): number;
+/**
+ * Finds the best match for `searchContent` inside `fileContent`.
+ * Uses a pipeline of strategies: Exact -> Whitespace-normalized -> Levenshtein.
+ */
+export declare function findBestMatch(fileContent: string, searchContent: string): MatchResult | null;
+export declare function applyMatch(fileContent: string, match: MatchResult, replaceContent: string): string;

package/dist/utils/fuzzyMatch.js

@@ -0,0 +1,121 @@
+import { distance } from 'fastest-levenshtein';
+/**
+ * Trims each line, collapses multiple spaces/tabs to single space,
+ * and normalizes line endings.
+ */
+export function normalizeWhitespace(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/\s+/g, ' '))
+        .join('\n')
+        .trim();
+}
+/**
+ * Returns 0-1 similarity ratio.
+ * 1.0 is exact match, 0.0 is completely different.
+ */
+export function levenshteinSimilarity(a, b) {
+    const maxLength = Math.max(a.length, b.length);
+    if (maxLength === 0)
+        return 1.0;
+    const d = distance(a, b);
+    return 1 - d / maxLength;
+}
+/**
+ * Finds the best match for `searchContent` inside `fileContent`.
+ * Uses a pipeline of strategies: Exact -> Whitespace-normalized -> Levenshtein.
+ */
+export function findBestMatch(fileContent, searchContent) {
+    if (!fileContent || !searchContent)
+        return null;
+    // Strategy 1: Exact Match
+    const exactIndex = fileContent.indexOf(searchContent);
+    if (exactIndex !== -1) {
+        return {
+            start: exactIndex,
+            end: exactIndex + searchContent.length,
+            strategy: 'Exact Match',
+        };
+    }
+    // Strategy 2: Whitespace-normalized Match
+    const normFileLines = fileContent.split(/\r?\n/);
+    const normSearchContent = normalizeWhitespace(searchContent);
+    // Fast check: does the normalized file content contain the normalized search content at all?
+    // Since newlines are preserved by normalizeWhitespace (it only trims lines), we can do this:
+    const normFileContent = normalizeWhitespace(fileContent);
+    // To map back to original lines, we try matching line by line.
+    const searchLines = searchContent.split(/\r?\n/);
+    const numSearchLines = searchLines.length;
+    if (numSearchLines > 0 && numSearchLines <= normFileLines.length) {
+        for (let i = 0; i <= normFileLines.length - numSearchLines; i++) {
+            let isMatch = true;
+            let charMatchCount = 0;
+            for (let j = 0; j < numSearchLines; j++) {
+                const fileLineNorm = normalizeWhitespace(normFileLines[i + j]);
+                const searchLineNorm = normalizeWhitespace(searchLines[j]);
+                if (fileLineNorm !== searchLineNorm) {
+                    isMatch = false;
+                    break;
+                }
+            }
+            if (isMatch) {
+                // Map back to original byte offsets
+                const start = getByteOffsetOfLine(fileContent, i);
+                const endLineOffset = getByteOffsetOfLine(fileContent, i + numSearchLines - 1);
+                const originalEndLine = normFileLines[i + numSearchLines - 1];
+                const end = endLineOffset + originalEndLine.length;
+                return {
+                    start,
+                    end,
+                    strategy: 'Whitespace-Normalized Match',
+                };
+            }
+        }
+    }
+    // Strategy 3: Levenshtein Similarity
+    // We use a sliding window of size `numSearchLines`, `+ 1`, and `- 1` to handle line hallucinations.
+    const THRESHOLD = 0.8;
+    let bestSim = 0;
+    let bestMatch = null;
+    if (numSearchLines > 0) {
+        for (let i = 0; i < normFileLines.length; i++) {
+            for (const windowSize of [numSearchLines, numSearchLines + 1, numSearchLines - 1]) {
+                if (windowSize <= 0 || i + windowSize > normFileLines.length)
+                    continue;
+                const windowLines = normFileLines.slice(i, i + windowSize);
+                // Normalize both strings before comparing to ignore indentation/whitespace differences
+                const windowStr = normalizeWhitespace(windowLines.join('\n'));
+                const targetStr = normalizeWhitespace(searchLines.join('\n'));
+                const sim = levenshteinSimilarity(windowStr, targetStr);
+                if (sim >= THRESHOLD && sim > bestSim) {
+                    bestSim = sim;
+                    const start = getByteOffsetOfLine(fileContent, i);
+                    const endLineOffset = getByteOffsetOfLine(fileContent, i + windowSize - 1);
+                    const originalEndLine = normFileLines[i + windowSize - 1];
+                    const end = endLineOffset + originalEndLine.length;
+                    bestMatch = {
+                        start,
+                        end,
+                        strategy: `Levenshtein Match (${(sim * 100).toFixed(1)}%) [Window: ${windowSize}]`,
+                    };
+                }
+            }
+        }
+    }
+    return bestMatch;
+}
+export function applyMatch(fileContent, match, replaceContent) {
+    return fileContent.slice(0, match.start) + replaceContent + fileContent.slice(match.end);
+}
+function getByteOffsetOfLine(text, lineIndex) {
+    let offset = 0;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lineIndex; i++) {
+        offset += lines[i].length + 1; // +1 for the newline character
+        // Account for \r\n
+        if (text[offset - 1] === '\n' && text[offset - 2] === '\r') {
+            offset += 1;
+        }
+    }
+    return offset;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Toggles the internal debug mode on/off.
+ */
+export declare function toggleDebugMode(): boolean;
+/**
+ * Prints a debug log to the console if debug mode is enabled.
+ */
+export declare function debugLog(message: string): void;

package/dist/utils/logger.js

@@ -0,0 +1,17 @@
+import pc from 'picocolors';
+let isDebugEnabled = process.env.MINO_DEBUG === 'true';
+/**
+ * Toggles the internal debug mode on/off.
+ */
+export function toggleDebugMode() {
+    isDebugEnabled = !isDebugEnabled;
+    return isDebugEnabled;
+}
+/**
+ * Prints a debug log to the console if debug mode is enabled.
+ */
+export function debugLog(message) {
+    if (isDebugEnabled) {
+        console.log(pc.magenta(`[DEBUG] ${message}`));
+    }
+}

package/dist/utils/pathSecurity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolves a file path against the workspace root and ensures it does not
+ * break out of the workspace directory (path traversal defense).
+ *
+ * @param workspaceRoot The normalized absolute path to the workspace root
+ * @param filePath The user or AI provided file path (relative or absolute)
+ * @returns The validated absolute path
+ * @throws Error if the resolved path is outside the workspace
+ */
+export declare function resolveAndValidatePath(workspaceRoot: string, filePath: string): string;

package/dist/utils/pathSecurity.js

@@ -0,0 +1,26 @@
+import * as path from 'path';
+/**
+ * Resolves a file path against the workspace root and ensures it does not
+ * break out of the workspace directory (path traversal defense).
+ *
+ * @param workspaceRoot The normalized absolute path to the workspace root
+ * @param filePath The user or AI provided file path (relative or absolute)
+ * @returns The validated absolute path
+ * @throws Error if the resolved path is outside the workspace
+ */
+export function resolveAndValidatePath(workspaceRoot, filePath) {
+    // Prevent absolute paths from bypassing the workspace root entirely
+    if (path.isAbsolute(filePath)) {
+        throw new Error(`Path security violation: Absolute paths are not allowed ("${filePath}"). Please use relative paths.`);
+    }
+    // Resolve the path against the workspace root
+    const resolvedPath = path.resolve(workspaceRoot, filePath);
+    // Normalize both paths to ensure consistent matching (removes .., ., extra slashes)
+    const normalizedRoot = path.normalize(workspaceRoot);
+    const normalizedResolved = path.normalize(resolvedPath);
+    // Ensure the resolved path starts with the workspace root directory
+    if (!normalizedResolved.startsWith(normalizedRoot)) {
+        throw new Error(`Path security violation: Path "${filePath}" escapes the workspace root.`);
+    }
+    return normalizedResolved;
+}

package/dist/utils/symbolExtractor.d.ts

@@ -0,0 +1,6 @@
+export interface ExtractedSymbol {
+    symbol: string;
+    startLine: number;
+    endLine: number;
+}
+export declare function extractSymbols(content: string, filePath: string, targetElements: string[]): string;

package/dist/utils/symbolExtractor.js

@@ -0,0 +1,249 @@
+import * as path from 'node:path';
+function getIndentation(line) {
+    const match = line.match(/^([ \t]*)/);
+    return match ? match[1].length : 0;
+}
+function isCommentOrEmpty(line, ext) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return true;
+    if (ext === '.py')
+        return trimmed.startsWith('#');
+    return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
+}
+function buildDeclarationRegex(symbolName, ext) {
+    const s = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (ext === '.py') {
+        return new RegExp(`^\\s*(?:async\\s+)?(?:def|class)\\s+${s}\\b|^\\s*${s}\\s*[:=]`);
+    }
+    if (ext === '.go') {
+        return new RegExp(`^\\s*(?:func(?:\\s+\\([^)]+\\))?\\s+${s}\\b|type\\s+${s}\\b|var\\s+${s}\\b|const\\s+${s}\\b)`);
+    }
+    if (ext === '.rs') {
+        return new RegExp(`^\\s*(?:(?:pub\\s+)?(?:async\\s+)?fn\\s+${s}\\b|(?:pub\\s+)?struct\\s+${s}\\b|(?:pub\\s+)?enum\\s+${s}\\b|(?:pub\\s+)?trait\\s+${s}\\b|(?:pub\\s+)?impl(?:\\s+.*)?\\s+for\\s+${s}\\b)`);
+    }
+    // Default for JS, TS, Java, C++, etc.
+    return new RegExp(`^\\s*(?:(?:export\\s+|default\\s+|async\\s+|abstract\\s+|static\\s+|public\\s+|private\\s+|protected\\s+|readonly\\s+)*` +
+        `(?:class|function|const|let|var|type|interface|enum)\\s+(?:[\\w<>]+\\s+)?${s}\\b|` +
+        `^\\s*${s}\\s*[:=]|` +
+        `^\\s*(?:async\\s+)?${s}\\s*[<]?\\w*[>]?\\s*\\()`);
+}
+function findPrecedingContext(lines, declarationIndex, ext) {
+    let start = declarationIndex;
+    // Walk backwards to include decorators and JSDoc/docstrings
+    while (start > 0) {
+        const prevLine = lines[start - 1].trim();
+        if (!prevLine) {
+            start--;
+            continue;
+        }
+        const isDecorator = prevLine.startsWith('@');
+        const isPythonComment = ext === '.py' && prevLine.startsWith('#');
+        const isJsDocEnd = (ext === '.ts' || ext === '.js' || ext === '.tsx' || ext === '.jsx') && prevLine === '*/';
+        const isJsDocLine = (ext === '.ts' || ext === '.js' || ext === '.tsx' || ext === '.jsx') && prevLine.startsWith('*');
+        const isJsDocStart = (ext === '.ts' || ext === '.js' || ext === '.tsx' || ext === '.jsx') && prevLine.startsWith('/**');
+        const isLineComment = prevLine.startsWith('//');
+        if (isDecorator || isPythonComment || isLineComment || isJsDocEnd || isJsDocLine || isJsDocStart) {
+            start--;
+            if (isJsDocStart)
+                break; // Usually stop scanning up after /**
+        }
+        else {
+            break;
+        }
+    }
+    return start;
+}
+export function extractSymbols(content, filePath, targetElements) {
+    if (!targetElements || targetElements.length === 0)
+        return content;
+    const ext = path.extname(filePath).toLowerCase();
+    const lines = content.split('\n');
+    const linesToKeep = new Set();
+    // To avoid false positives inside large strings/comments, we do a basic stateful scan
+    let inMultiLineComment = false;
+    let inMultiLineString = null;
+    // Fast tracking of states per line so we don't start symbols inside comments
+    const validLines = new Array(lines.length).fill(true);
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        let j = 0;
+        let lineHasValidCode = false;
+        while (j < line.length) {
+            // String logic
+            if (!inMultiLineComment && inMultiLineString) {
+                if (line[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (line[j] === inMultiLineString) {
+                    inMultiLineString = null;
+                }
+                j++;
+                continue;
+            }
+            if (!inMultiLineComment && !inMultiLineString) {
+                // Comment start
+                if (line[j] === '/' && line[j + 1] === '/') {
+                    break;
+                } // Line comment ends processing for this line
+                if (ext === '.py' && line[j] === '#') {
+                    break;
+                }
+                if (line[j] === '/' && line[j + 1] === '*') {
+                    inMultiLineComment = true;
+                    j += 2;
+                    continue;
+                }
+                // String start
+                if (line[j] === '"' || line[j] === "'" || line[j] === '`') {
+                    inMultiLineString = line[j];
+                    j++;
+                    continue;
+                }
+                if (line[j].trim())
+                    lineHasValidCode = true;
+            }
+            // Comment end
+            if (inMultiLineComment && line[j] === '*' && line[j + 1] === '/') {
+                inMultiLineComment = false;
+                j += 2;
+                continue;
+            }
+            j++;
+        }
+        if (!lineHasValidCode && (inMultiLineComment || inMultiLineString)) {
+            validLines[i] = false;
+        }
+    }
+    // Iterate over requested symbols
+    for (const symbol of targetElements) {
+        const regex = buildDeclarationRegex(symbol, ext);
+        for (let i = 0; i < lines.length; i++) {
+            if (!validLines[i])
+                continue;
+            if (regex.test(lines[i])) {
+                const startIndex = findPrecedingContext(lines, i, ext);
+                let endIndex = i;
+                // Python indentation-based termination
+                if (ext === '.py') {
+                    const baseIndentation = getIndentation(lines[i]);
+                    // Move forward until we find a line with less or equal indentation that isn't empty/comment
+                    for (let j = i + 1; j < lines.length; j++) {
+                        if (isCommentOrEmpty(lines[j], ext)) {
+                            endIndex = j;
+                            continue;
+                        }
+                        if (getIndentation(lines[j]) <= baseIndentation) {
+                            break;
+                        }
+                        endIndex = j;
+                    }
+                }
+                // Bracket/brace-based termination
+                else {
+                    let braces = 0;
+                    let brackets = 0;
+                    let parens = 0;
+                    let foundOpen = false;
+                    let inStr = null;
+                    let inComment = false;
+                    for (let j = i; j < lines.length; j++) {
+                        endIndex = j;
+                        const line = lines[j];
+                        let charIdx = 0;
+                        while (charIdx < line.length) {
+                            const char = line[charIdx];
+                            if (inComment) {
+                                if (char === '*' && line[charIdx + 1] === '/') {
+                                    inComment = false;
+                                    charIdx += 2;
+                                    continue;
+                                }
+                                charIdx++;
+                                continue;
+                            }
+                            if (inStr) {
+                                if (char === '\\') {
+                                    charIdx += 2;
+                                    continue;
+                                }
+                                if (char === inStr)
+                                    inStr = null;
+                                charIdx++;
+                                continue;
+                            }
+                            if (char === '/' && line[charIdx + 1] === '/')
+                                break;
+                            if (char === '/' && line[charIdx + 1] === '*') {
+                                inComment = true;
+                                charIdx += 2;
+                                continue;
+                            }
+                            if (char === '"' || char === "'" || char === '`') {
+                                inStr = char;
+                                charIdx++;
+                                continue;
+                            }
+                            if (char === '{') {
+                                braces++;
+                                foundOpen = true;
+                            }
+                            else if (char === '}')
+                                braces--;
+                            else if (char === '[') {
+                                brackets++;
+                                foundOpen = true;
+                            }
+                            else if (char === ']')
+                                brackets--;
+                            else if (char === '(') {
+                                parens++;
+                                foundOpen = true;
+                            }
+                            else if (char === ')')
+                                parens--;
+                            charIdx++;
+                        }
+                        // If we found some opening block and it all balanced out to 0, we're done
+                        if (foundOpen && braces === 0 && brackets === 0 && parens === 0) {
+                            break;
+                        }
+                        // For one-liners without braces
+                        if (!foundOpen && j > i && braces === 0 && brackets === 0 && parens === 0) {
+                            // If we went to a new line and still no open braces, maybe it was a single line statement
+                            // Let's just break. But wait, if it's a multi-line chain, let's keep going if it ends with . or ,
+                            const prevLine = lines[j - 1].trim();
+                            if (!prevLine.endsWith(',') && !prevLine.endsWith('.')) {
+                                endIndex = j - 1;
+                                break;
+                            }
+                        }
+                    }
+                }
+                // Add lines to keep
+                for (let k = startIndex; k <= endIndex; k++) {
+                    linesToKeep.add(k);
+                }
+            }
+        }
+    }
+    // If we found nothing, fall back to returning the whole file (or maybe just an empty string?
+    // Returning the whole file might defeat the purpose, but returning an error is better handled by the caller.
+    // We'll return what we found. If it's empty, we return a message.)
+    if (linesToKeep.size === 0) {
+        return `// No specific symbols matching \${JSON.stringify(targetElements)} were found in this file.\n// Try using normal read_file without targetElements, or check spelling.`;
+    }
+    // Construct output with omitted blocks
+    const output = [];
+    let previousLineNum = -2;
+    const sortedLines = Array.from(linesToKeep).sort((a, b) => a - b);
+    for (const lineNum of sortedLines) {
+        if (lineNum > previousLineNum + 1 && previousLineNum !== -2) {
+            output.push('\n// ... [Code Omitted] ...\n');
+        }
+        output.push(lines[lineNum]);
+        previousLineNum = lineNum;
+    }
+    return output.join('\n');
+}

package/dist/utils/syntaxValidator.d.ts

@@ -0,0 +1,5 @@
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare function validateSyntax(content: string, filePath: string): ValidationResult;

package/dist/utils/syntaxValidator.js

@@ -0,0 +1,81 @@
+import * as path from 'node:path';
+export function validateSyntax(content, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const errors = [];
+    // Fast check for truncation markers from AI
+    if (/(\/\/|\/\*)\s*\.\.\./.test(content) || /<!--\s*\.\.\.\s*-->/.test(content)) {
+        errors.push('File contains a truncation marker (e.g., "// ..."). Please output the complete file content without truncating.');
+    }
+    // Language specific checks
+    if (ext === '.json') {
+        try {
+            JSON.parse(content);
+        }
+        catch (err) {
+            errors.push(`Invalid JSON syntax: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (['.ts', '.tsx', '.js', '.jsx', '.css', '.scss'].includes(ext)) {
+        const braceBalance = countBalance(content, '{', '}');
+        const bracketBalance = countBalance(content, '[', ']');
+        const parenBalance = countBalance(content, '(', ')');
+        if (braceBalance > 0)
+            errors.push(`Unmatched opening brace '{' (missing ${braceBalance} closing braces)`);
+        if (braceBalance < 0)
+            errors.push(`Unmatched closing brace '}' (missing ${-braceBalance} opening braces)`);
+        if (bracketBalance > 0)
+            errors.push(`Unmatched opening bracket '[' (missing ${bracketBalance} closing brackets)`);
+        if (bracketBalance < 0)
+            errors.push(`Unmatched closing bracket ']' (missing ${-bracketBalance} opening brackets)`);
+        if (parenBalance > 0)
+            errors.push(`Unmatched opening parenthesis '(' (missing ${parenBalance} closing parentheses)`);
+        if (parenBalance < 0)
+            errors.push(`Unmatched closing parenthesis ')' (missing ${-parenBalance} opening parentheses)`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+function countBalance(text, openChar, closeChar) {
+    let balance = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        // Skip string contents
+        if (inString) {
+            if (char === '\\') {
+                i++; // Skip escaped character
+                continue;
+            }
+            if (char === stringChar) {
+                inString = false;
+            }
+            continue;
+        }
+        // Entering a string
+        if (char === '"' || char === "'" || char === '`') {
+            inString = true;
+            stringChar = char;
+            continue;
+        }
+        // Basic comment skipping
+        if (char === '/' && text[i + 1] === '/') {
+            const nextLine = text.indexOf('\n', i);
+            i = nextLine !== -1 ? nextLine : text.length;
+            continue;
+        }
+        // Block comment skip
+        if (char === '/' && text[i + 1] === '*') {
+            const nextEnd = text.indexOf('*/', i + 2);
+            i = nextEnd !== -1 ? nextEnd + 1 : text.length;
+            continue;
+        }
+        if (char === openChar)
+            balance++;
+        else if (char === closeChar)
+            balance--;
+    }
+    return balance;
+}