snow-ai 0.3.5 → 0.3.7

package/dist/mcp/utils/aceCodeSearch/search.utils.js

@@ -0,0 +1,136 @@
+/**
+ * Search utilities for ACE Code Search
+ */
+import { spawn } from 'child_process';
+import { EOL } from 'os';
+import * as path from 'path';
+/**
+ * Check if a command is available in the system PATH
+ * @param command - Command to check
+ * @returns Promise resolving to true if command is available
+ */
+export function isCommandAvailable(command) {
+    return new Promise(resolve => {
+        try {
+            let child;
+            if (process.platform === 'win32') {
+                // Windows: where is an executable, no shell needed
+                child = spawn('where', [command], {
+                    stdio: 'ignore',
+                    windowsHide: true,
+                });
+            }
+            else {
+                // Unix/Linux: Use 'which' command instead of 'command -v'
+                // 'which' is an external executable, not a shell builtin
+                child = spawn('which', [command], {
+                    stdio: 'ignore',
+                });
+            }
+            child.on('close', code => resolve(code === 0));
+            child.on('error', () => resolve(false));
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+/**
+ * Parse grep output (format: filePath:lineNumber:lineContent)
+ * @param output - Grep output string
+ * @param basePath - Base path for relative path calculation
+ * @returns Array of search results
+ */
+export function parseGrepOutput(output, basePath) {
+    const results = [];
+    if (!output)
+        return results;
+    const lines = output.split(EOL);
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        // Find first and second colon indices
+        const firstColonIndex = line.indexOf(':');
+        if (firstColonIndex === -1)
+            continue;
+        const secondColonIndex = line.indexOf(':', firstColonIndex + 1);
+        if (secondColonIndex === -1)
+            continue;
+        // Extract parts
+        const filePathRaw = line.substring(0, firstColonIndex);
+        const lineNumberStr = line.substring(firstColonIndex + 1, secondColonIndex);
+        const lineContent = line.substring(secondColonIndex + 1);
+        const lineNumber = parseInt(lineNumberStr, 10);
+        if (isNaN(lineNumber))
+            continue;
+        const absoluteFilePath = path.resolve(basePath, filePathRaw);
+        const relativeFilePath = path.relative(basePath, absoluteFilePath);
+        results.push({
+            filePath: relativeFilePath || path.basename(absoluteFilePath),
+            line: lineNumber,
+            column: 1, // grep doesn't provide column info, default to 1
+            content: lineContent.trim(),
+        });
+    }
+    return results;
+}
+/**
+ * Convert glob pattern to RegExp
+ * Supports: *, **, ?, [abc], {js,ts}
+ * @param glob - Glob pattern
+ * @returns Regular expression
+ */
+export function globToRegex(glob) {
+    // Escape special regex characters except glob wildcards
+    let pattern = glob
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
+        .replace(/\*\*/g, '<<<DOUBLESTAR>>>') // Temporarily replace **
+        .replace(/\*/g, '[^/]*') // * matches anything except /
+        .replace(/<<<DOUBLESTAR>>>/g, '.*') // ** matches everything
+        .replace(/\?/g, '[^/]'); // ? matches single char except /
+    // Handle {js,ts} alternatives
+    pattern = pattern.replace(/\\{([^}]+)\\}/g, (_, alternatives) => {
+        return '(' + alternatives.split(',').join('|') + ')';
+    });
+    // Handle [abc] character classes (already valid regex)
+    pattern = pattern.replace(/\\\[([^\]]+)\\\]/g, '[$1]');
+    return new RegExp(pattern, 'i');
+}
+/**
+ * Calculate fuzzy match score for symbol name
+ * @param symbolName - Symbol name to score
+ * @param query - Search query
+ * @returns Score (0-100, higher is better)
+ */
+export function calculateFuzzyScore(symbolName, query) {
+    const nameLower = symbolName.toLowerCase();
+    const queryLower = query.toLowerCase();
+    // Exact match
+    if (nameLower === queryLower)
+        return 100;
+    // Starts with
+    if (nameLower.startsWith(queryLower))
+        return 80;
+    // Contains
+    if (nameLower.includes(queryLower))
+        return 60;
+    // Camel case match (e.g., "gfc" matches "getFileContent")
+    const camelCaseMatch = symbolName
+        .split(/(?=[A-Z])/)
+        .map(s => s[0]?.toLowerCase() || '')
+        .join('');
+    if (camelCaseMatch.includes(queryLower))
+        return 40;
+    // Fuzzy match
+    let score = 0;
+    let queryIndex = 0;
+    for (let i = 0; i < nameLower.length && queryIndex < queryLower.length; i++) {
+        if (nameLower[i] === queryLower[queryIndex]) {
+            score += 20;
+            queryIndex++;
+        }
+    }
+    if (queryIndex === queryLower.length)
+        return score;
+    return 0;
+}

package/dist/mcp/utils/aceCodeSearch/symbol.utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Symbol parsing utilities for ACE Code Search
+ */
+import type { CodeSymbol } from '../../types/aceCodeSearch.types.js';
+/**
+ * Get context lines around a specific line
+ * @param lines - All lines in file
+ * @param lineIndex - Target line index (0-based)
+ * @param contextSize - Number of lines before and after
+ * @returns Context string
+ */
+export declare function getContext(lines: string[], lineIndex: number, contextSize: number): string;
+/**
+ * Parse file content to extract code symbols using regex patterns
+ * @param filePath - Path to file
+ * @param content - File content
+ * @param basePath - Base path for relative path calculation
+ * @returns Array of code symbols
+ */
+export declare function parseFileSymbols(filePath: string, content: string, basePath: string): Promise<CodeSymbol[]>;

package/dist/mcp/utils/aceCodeSearch/symbol.utils.js

@@ -0,0 +1,141 @@
+/**
+ * Symbol parsing utilities for ACE Code Search
+ */
+import * as path from 'path';
+import { LANGUAGE_CONFIG, detectLanguage } from './language.utils.js';
+/**
+ * Get context lines around a specific line
+ * @param lines - All lines in file
+ * @param lineIndex - Target line index (0-based)
+ * @param contextSize - Number of lines before and after
+ * @returns Context string
+ */
+export function getContext(lines, lineIndex, contextSize) {
+    const start = Math.max(0, lineIndex - contextSize);
+    const end = Math.min(lines.length, lineIndex + contextSize + 1);
+    return lines
+        .slice(start, end)
+        .filter(l => l !== undefined)
+        .join('\n')
+        .trim();
+}
+/**
+ * Parse file content to extract code symbols using regex patterns
+ * @param filePath - Path to file
+ * @param content - File content
+ * @param basePath - Base path for relative path calculation
+ * @returns Array of code symbols
+ */
+export async function parseFileSymbols(filePath, content, basePath) {
+    const symbols = [];
+    const language = detectLanguage(filePath);
+    if (!language || !LANGUAGE_CONFIG[language]) {
+        return symbols;
+    }
+    const config = LANGUAGE_CONFIG[language];
+    const lines = content.split('\n');
+    // Parse each line for symbols
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const lineNumber = i + 1;
+        // Extract functions
+        if (config.symbolPatterns.function) {
+            const match = line.match(config.symbolPatterns.function);
+            if (match) {
+                const name = match[1] || match[2] || match[3];
+                if (name) {
+                    // Get function signature (current line + next few lines)
+                    const contextLines = lines.slice(i, Math.min(i + 3, lines.length));
+                    const signature = contextLines.join('\n').trim();
+                    symbols.push({
+                        name,
+                        type: 'function',
+                        filePath: path.relative(basePath, filePath),
+                        line: lineNumber,
+                        column: line.indexOf(name) + 1,
+                        signature,
+                        language,
+                        context: getContext(lines, i, 2),
+                    });
+                }
+            }
+        }
+        // Extract classes
+        if (config.symbolPatterns.class) {
+            const match = line.match(config.symbolPatterns.class);
+            if (match) {
+                const name = match[1] || match[2] || match[3];
+                if (name) {
+                    symbols.push({
+                        name,
+                        type: 'class',
+                        filePath: path.relative(basePath, filePath),
+                        line: lineNumber,
+                        column: line.indexOf(name) + 1,
+                        signature: line.trim(),
+                        language,
+                        context: getContext(lines, i, 2),
+                    });
+                }
+            }
+        }
+        // Extract variables
+        if (config.symbolPatterns.variable) {
+            const match = line.match(config.symbolPatterns.variable);
+            if (match) {
+                const name = match[1];
+                if (name) {
+                    symbols.push({
+                        name,
+                        type: 'variable',
+                        filePath: path.relative(basePath, filePath),
+                        line: lineNumber,
+                        column: line.indexOf(name) + 1,
+                        signature: line.trim(),
+                        language,
+                        context: getContext(lines, i, 1),
+                    });
+                }
+            }
+        }
+        // Extract imports
+        if (config.symbolPatterns.import) {
+            const match = line.match(config.symbolPatterns.import);
+            if (match) {
+                const name = match[1] || match[2];
+                if (name) {
+                    symbols.push({
+                        name,
+                        type: 'import',
+                        filePath: path.relative(basePath, filePath),
+                        line: lineNumber,
+                        column: line.indexOf(name) + 1,
+                        signature: line.trim(),
+                        language,
+                    });
+                }
+            }
+        }
+        // Extract exports
+        if (config.symbolPatterns.export) {
+            const match = line.match(config.symbolPatterns.export);
+            if (match) {
+                const name = match[1];
+                if (name) {
+                    symbols.push({
+                        name,
+                        type: 'export',
+                        filePath: path.relative(basePath, filePath),
+                        line: lineNumber,
+                        column: line.indexOf(name) + 1,
+                        signature: line.trim(),
+                        language,
+                    });
+                }
+            }
+        }
+    }
+    return symbols;
+}

package/dist/mcp/utils/bash/security.utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Security utilities for terminal command execution
+ */
+/**
+ * Dangerous command patterns that should be blocked
+ */
+export declare const DANGEROUS_PATTERNS: RegExp[];
+/**
+ * Check if a command contains dangerous patterns
+ * @param command - Command to check
+ * @returns true if command is dangerous
+ */
+export declare function isDangerousCommand(command: string): boolean;
+/**
+ * Truncate output if it exceeds maximum length
+ * @param output - Output string to truncate
+ * @param maxLength - Maximum allowed length
+ * @returns Truncated output with indicator if truncated
+ */
+export declare function truncateOutput(output: string, maxLength: number): string;

package/dist/mcp/utils/bash/security.utils.js

@@ -0,0 +1,34 @@
+/**
+ * Security utilities for terminal command execution
+ */
+/**
+ * Dangerous command patterns that should be blocked
+ */
+export const DANGEROUS_PATTERNS = [
+    /rm\s+-rf\s+\/[^/\s]*/i, // rm -rf / or /path
+    />\s*\/dev\/sda/i, // writing to disk devices
+    /mkfs/i, // format filesystem
+    /dd\s+if=/i, // disk operations
+];
+/**
+ * Check if a command contains dangerous patterns
+ * @param command - Command to check
+ * @returns true if command is dangerous
+ */
+export function isDangerousCommand(command) {
+    return DANGEROUS_PATTERNS.some(pattern => pattern.test(command));
+}
+/**
+ * Truncate output if it exceeds maximum length
+ * @param output - Output string to truncate
+ * @param maxLength - Maximum allowed length
+ * @returns Truncated output with indicator if truncated
+ */
+export function truncateOutput(output, maxLength) {
+    if (!output)
+        return '';
+    if (output.length > maxLength) {
+        return output.slice(0, maxLength) + '\n... (output truncated)';
+    }
+    return output;
+}

package/dist/mcp/utils/filesystem/code-analysis.utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Code analysis utilities for structure validation
+ */
+import type { StructureAnalysis } from '../../types/filesystem.types.js';
+/**
+ * Analyze code structure for balance and completeness
+ * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
+ */
+export declare function analyzeCodeStructure(_content: string, filePath: string, editedLines: string[]): StructureAnalysis;
+/**
+ * Find smart context boundaries for editing
+ * Expands context to include complete code blocks when possible
+ */
+export declare function findSmartContextBoundaries(lines: string[], startLine: number, endLine: number, requestedContext: number): {
+    start: number;
+    end: number;
+    extended: boolean;
+};

package/dist/mcp/utils/filesystem/code-analysis.utils.js

@@ -0,0 +1,165 @@
+/**
+ * Code analysis utilities for structure validation
+ */
+/**
+ * Analyze code structure for balance and completeness
+ * Helps AI identify bracket mismatches, unclosed tags, and boundary issues
+ */
+export function analyzeCodeStructure(_content, filePath, editedLines) {
+    const analysis = {
+        bracketBalance: {
+            curly: { open: 0, close: 0, balanced: true },
+            round: { open: 0, close: 0, balanced: true },
+            square: { open: 0, close: 0, balanced: true },
+        },
+        indentationWarnings: [],
+    };
+    // Count brackets in the edited content
+    const editedContent = editedLines.join('\n');
+    // Remove string literals and comments to avoid false positives
+    const cleanContent = editedContent
+        .replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, '""') // Remove strings
+        .replace(/\/\/.*$/gm, '') // Remove single-line comments
+        .replace(/\/\*[\s\S]*?\*\//g, ''); // Remove multi-line comments
+    // Count brackets
+    analysis.bracketBalance.curly.open = (cleanContent.match(/\{/g) || []).length;
+    analysis.bracketBalance.curly.close = (cleanContent.match(/\}/g) || []).length;
+    analysis.bracketBalance.curly.balanced =
+        analysis.bracketBalance.curly.open === analysis.bracketBalance.curly.close;
+    analysis.bracketBalance.round.open = (cleanContent.match(/\(/g) || []).length;
+    analysis.bracketBalance.round.close = (cleanContent.match(/\)/g) || []).length;
+    analysis.bracketBalance.round.balanced =
+        analysis.bracketBalance.round.open === analysis.bracketBalance.round.close;
+    analysis.bracketBalance.square.open = (cleanContent.match(/\[/g) || []).length;
+    analysis.bracketBalance.square.close = (cleanContent.match(/\]/g) || []).length;
+    analysis.bracketBalance.square.balanced =
+        analysis.bracketBalance.square.open ===
+            analysis.bracketBalance.square.close;
+    // HTML/JSX tag analysis (for .html, .jsx, .tsx, .vue files)
+    const isMarkupFile = /\.(html|jsx|tsx|vue)$/i.test(filePath);
+    if (isMarkupFile) {
+        const tagPattern = /<\/?([a-zA-Z][a-zA-Z0-9-]*)[^>]*>/g;
+        const selfClosingPattern = /<[a-zA-Z][a-zA-Z0-9-]*[^>]*\/>/g;
+        // Remove self-closing tags
+        const contentWithoutSelfClosing = cleanContent.replace(selfClosingPattern, '');
+        const tags = [];
+        const unclosedTags = [];
+        const unopenedTags = [];
+        let match;
+        while ((match = tagPattern.exec(contentWithoutSelfClosing)) !== null) {
+            const isClosing = match[0]?.startsWith('</');
+            const tagName = match[1]?.toLowerCase();
+            if (!tagName)
+                continue;
+            if (isClosing) {
+                const lastOpenTag = tags.pop();
+                if (!lastOpenTag || lastOpenTag !== tagName) {
+                    unopenedTags.push(tagName);
+                    if (lastOpenTag)
+                        tags.push(lastOpenTag); // Put it back
+                }
+            }
+            else {
+                tags.push(tagName);
+            }
+        }
+        unclosedTags.push(...tags);
+        analysis.htmlTags = {
+            unclosedTags,
+            unopenedTags,
+            balanced: unclosedTags.length === 0 && unopenedTags.length === 0,
+        };
+    }
+    // Check indentation consistency
+    const lines = editedContent.split('\n');
+    const indents = lines
+        .filter(line => line.trim().length > 0)
+        .map(line => {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1] : '';
+    })
+        .filter((indent) => indent !== undefined);
+    // Detect mixed tabs/spaces
+    const hasTabs = indents.some(indent => indent.includes('\t'));
+    const hasSpaces = indents.some(indent => indent.includes(' '));
+    if (hasTabs && hasSpaces) {
+        analysis.indentationWarnings.push('Mixed tabs and spaces detected');
+    }
+    // Detect inconsistent indentation levels (spaces only)
+    if (!hasTabs && hasSpaces) {
+        const spaceCounts = indents
+            .filter(indent => indent.length > 0)
+            .map(indent => indent.length);
+        if (spaceCounts.length > 1) {
+            const gcd = spaceCounts.reduce((a, b) => {
+                while (b !== 0) {
+                    const temp = b;
+                    b = a % b;
+                    a = temp;
+                }
+                return a;
+            });
+            const hasInconsistent = spaceCounts.some(count => count % gcd !== 0 && gcd > 1);
+            if (hasInconsistent) {
+                analysis.indentationWarnings.push(`Inconsistent indentation (expected multiples of ${gcd} spaces)`);
+            }
+        }
+    }
+    // Note: Boundary checking removed - AI should be free to edit partial code blocks
+    // The bracket balance check above is sufficient for detecting real issues
+    return analysis;
+}
+/**
+ * Find smart context boundaries for editing
+ * Expands context to include complete code blocks when possible
+ */
+export function findSmartContextBoundaries(lines, startLine, endLine, requestedContext) {
+    const totalLines = lines.length;
+    let contextStart = Math.max(1, startLine - requestedContext);
+    let contextEnd = Math.min(totalLines, endLine + requestedContext);
+    let extended = false;
+    // Try to find the start of the enclosing block
+    let bracketDepth = 0;
+    for (let i = startLine - 1; i >= Math.max(0, startLine - 50); i--) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const trimmed = line.trim();
+        // Count brackets (simple approach)
+        const openBrackets = (line.match(/\{/g) || []).length;
+        const closeBrackets = (line.match(/\}/g) || []).length;
+        bracketDepth += closeBrackets - openBrackets;
+        // If we find a function/class/block definition with balanced brackets
+        if (bracketDepth === 0 &&
+            (trimmed.match(/^(function|class|const|let|var|if|for|while|async|export)\s/i) ||
+                trimmed.match(/=>\s*\{/) ||
+                trimmed.match(/^\w+\s*\(/))) {
+            if (i + 1 < contextStart) {
+                contextStart = i + 1;
+                extended = true;
+            }
+            break;
+        }
+    }
+    // Try to find the end of the enclosing block
+    bracketDepth = 0;
+    for (let i = endLine - 1; i < Math.min(totalLines, endLine + 50); i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const trimmed = line.trim();
+        // Count brackets
+        const openBrackets = (line.match(/\{/g) || []).length;
+        const closeBrackets = (line.match(/\}/g) || []).length;
+        bracketDepth += openBrackets - closeBrackets;
+        // If we find a closing bracket at depth 0
+        if (bracketDepth === 0 && trimmed.startsWith('}')) {
+            if (i + 1 > contextEnd) {
+                contextEnd = i + 1;
+                extended = true;
+            }
+            break;
+        }
+    }
+    return { start: contextStart, end: contextEnd, extended };
+}

package/dist/mcp/utils/filesystem/match-finder.utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Match finding utilities for fuzzy search
+ */
+import type { MatchCandidate } from '../../types/filesystem.types.js';
+/**
+ * Find the closest matching candidates in the file content
+ * Returns top N candidates sorted by similarity
+ * Optimized with safe pre-filtering and early exit
+ * ASYNC to prevent terminal freeze during search
+ */
+export declare function findClosestMatches(searchContent: string, fileLines: string[], topN?: number): Promise<MatchCandidate[]>;
+/**
+ * Generate a helpful diff message showing differences between search and actual content
+ * Note: This is ONLY for display purposes. Tabs/spaces are normalized for better readability.
+ */
+export declare function generateDiffMessage(searchContent: string, actualContent: string, maxLines?: number): string;

package/dist/mcp/utils/filesystem/match-finder.utils.js

@@ -0,0 +1,85 @@
+/**
+ * Match finding utilities for fuzzy search
+ */
+import { calculateSimilarity, normalizeForDisplay } from './similarity.utils.js';
+/**
+ * Find the closest matching candidates in the file content
+ * Returns top N candidates sorted by similarity
+ * Optimized with safe pre-filtering and early exit
+ * ASYNC to prevent terminal freeze during search
+ */
+export async function findClosestMatches(searchContent, fileLines, topN = 3) {
+    const searchLines = searchContent.split('\n');
+    const candidates = [];
+    // Fast pre-filter: use first line as anchor (only for multi-line searches)
+    const searchFirstLine = searchLines[0]?.replace(/\s+/g, ' ').trim() || '';
+    const threshold = 0.5;
+    const usePreFilter = searchLines.length >= 5; // Only for 5+ line searches
+    const preFilterThreshold = 0.2; // Very conservative - only skip completely unrelated lines
+    // Try to find candidates by sliding window with optimizations
+    const maxCandidates = topN * 3; // Collect more candidates, then pick best
+    const YIELD_INTERVAL = 100; // Yield control every 100 iterations
+    for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+        // Yield control periodically to prevent UI freeze
+        if (i % YIELD_INTERVAL === 0) {
+            await new Promise(resolve => setImmediate(resolve));
+        }
+        // Quick pre-filter: check first line similarity (only for multi-line)
+        if (usePreFilter) {
+            const firstLineCandidate = fileLines[i]?.replace(/\s+/g, ' ').trim() || '';
+            const firstLineSimilarity = calculateSimilarity(searchFirstLine, firstLineCandidate, preFilterThreshold);
+            // Skip only if first line is very different
+            if (firstLineSimilarity < preFilterThreshold) {
+                continue;
+            }
+        }
+        // Full candidate check
+        const candidateLines = fileLines.slice(i, i + searchLines.length);
+        const candidateContent = candidateLines.join('\n');
+        const similarity = calculateSimilarity(searchContent, candidateContent, threshold);
+        // Only consider candidates with >50% similarity
+        if (similarity > threshold) {
+            candidates.push({
+                startLine: i + 1,
+                endLine: i + searchLines.length,
+                similarity,
+                preview: candidateLines
+                    .map((line, idx) => `${i + idx + 1}→${normalizeForDisplay(line)}`)
+                    .join('\n'),
+            });
+            // Early exit if we found a nearly perfect match
+            if (similarity >= 0.95) {
+                break;
+            }
+            // Limit candidates to avoid excessive computation
+            if (candidates.length >= maxCandidates) {
+                break;
+            }
+        }
+    }
+    // Sort by similarity descending and return top N
+    return candidates.sort((a, b) => b.similarity - a.similarity).slice(0, topN);
+}
+/**
+ * Generate a helpful diff message showing differences between search and actual content
+ * Note: This is ONLY for display purposes. Tabs/spaces are normalized for better readability.
+ */
+export function generateDiffMessage(searchContent, actualContent, maxLines = 10) {
+    const searchLines = searchContent.split('\n');
+    const actualLines = actualContent.split('\n');
+    const diffLines = [];
+    const maxLen = Math.max(searchLines.length, actualLines.length);
+    for (let i = 0; i < Math.min(maxLen, maxLines); i++) {
+        const searchLine = searchLines[i] || '';
+        const actualLine = actualLines[i] || '';
+        if (searchLine !== actualLine) {
+            diffLines.push(`Line ${i + 1}:`);
+            diffLines.push(`  Search: ${JSON.stringify(normalizeForDisplay(searchLine))}`);
+            diffLines.push(`  Actual: ${JSON.stringify(normalizeForDisplay(actualLine))}`);
+        }
+    }
+    if (maxLen > maxLines) {
+        diffLines.push(`... (${maxLen - maxLines} more lines)`);
+    }
+    return diffLines.join('\n');
+}

package/dist/mcp/utils/filesystem/similarity.utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Similarity calculation utilities for fuzzy matching
+ */
+/**
+ * Calculate similarity between two strings using a smarter algorithm
+ * This normalizes whitespace first to avoid false negatives from spacing differences
+ * Returns a value between 0 (completely different) and 1 (identical)
+ */
+export declare function calculateSimilarity(str1: string, str2: string, threshold?: number): number;
+/**
+ * Calculate Levenshtein distance between two strings with early termination
+ * @param str1 First string
+ * @param str2 Second string
+ * @param maxDistance Maximum distance to compute (early exit if exceeded)
+ * @returns Levenshtein distance, or maxDistance+1 if exceeded
+ */
+export declare function levenshteinDistance(str1: string, str2: string, maxDistance?: number): number;
+/**
+ * Normalize whitespace for display purposes
+ * Makes preview more readable by collapsing whitespace
+ */
+export declare function normalizeForDisplay(line: string): string;