snow-ai 0.4.15 → 0.4.17

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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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/batch-operations.utils.d.ts

@@ -1,39 +0,0 @@
-/**
- * Batch operation utilities for filesystem operations
- */
-import type { BatchOperationResult, BatchResultItem, EditBySearchConfig, EditByLineConfig } from '../../types/filesystem.types.js';
-/**
- * Parse file path parameter into array format
- * Supports: string, string[], or array of config objects
- */
-export declare function parseFilePathParameter<T extends {
-    path: string;
-}>(filePath: string | string[] | T[]): Array<string | T>;
-/**
- * Extract file path from file item (string or object)
- */
-export declare function extractFilePath<T extends {
-    path: string;
-}>(fileItem: string | T): string;
-/**
- * Parse edit by search parameters
- */
-export declare function parseEditBySearchParams(fileItem: string | EditBySearchConfig, globalSearchContent?: string, globalReplaceContent?: string, globalOccurrence?: number): {
-    path: string;
-    searchContent: string;
-    replaceContent: string;
-    occurrence: number;
-};
-/**
- * Parse edit by line parameters
- */
-export declare function parseEditByLineParams(fileItem: string | EditByLineConfig, globalStartLine?: number, globalEndLine?: number, globalNewContent?: string): {
-    path: string;
-    startLine: number;
-    endLine: number;
-    newContent: string;
-};
-/**
- * Execute batch operation with error handling
- */
-export declare function executeBatchOperation<TConfig, TSingleResult, TBatchItem extends BatchResultItem>(fileItems: Array<string | TConfig>, parseParams: (fileItem: string | TConfig) => any, executeSingle: (...params: any[]) => Promise<TSingleResult>, mapResult: (path: string, result: TSingleResult) => Omit<TBatchItem, 'success' | 'error'>): Promise<BatchOperationResult<TBatchItem>>;

package/dist/mcp/utils/filesystem/batch-operations.utils.js

@@ -1,182 +0,0 @@
-/**
- * Batch operation utilities for filesystem operations
- */
-/**
- * Parse file path parameter into array format
- * Supports: string, string[], or array of config objects
- */
-export function parseFilePathParameter(filePath) {
-    if (Array.isArray(filePath)) {
-        return filePath;
-    }
-    return [filePath];
-}
-/**
- * Extract file path from file item (string or object)
- */
-export function extractFilePath(fileItem) {
-    return typeof fileItem === 'string' ? fileItem : fileItem.path;
-}
-/**
- * Parse edit by search parameters
- */
-export function parseEditBySearchParams(fileItem, globalSearchContent, globalReplaceContent, globalOccurrence) {
-    if (typeof fileItem === 'string') {
-        if (!globalSearchContent || !globalReplaceContent) {
-            throw new Error('searchContent and replaceContent are required for string array format');
-        }
-        return {
-            path: fileItem,
-            searchContent: globalSearchContent,
-            replaceContent: globalReplaceContent,
-            occurrence: globalOccurrence ?? 1,
-        };
-    }
-    return {
-        path: fileItem.path,
-        searchContent: fileItem.searchContent,
-        replaceContent: fileItem.replaceContent,
-        occurrence: fileItem.occurrence ?? globalOccurrence ?? 1,
-    };
-}
-/**
- * Parse edit by line parameters
- */
-export function parseEditByLineParams(fileItem, globalStartLine, globalEndLine, globalNewContent) {
-    if (typeof fileItem === 'string') {
-        if (globalStartLine === undefined ||
-            globalEndLine === undefined ||
-            globalNewContent === undefined) {
-            throw new Error('startLine, endLine, and newContent are required for string array format');
-        }
-        return {
-            path: fileItem,
-            startLine: globalStartLine,
-            endLine: globalEndLine,
-            newContent: globalNewContent,
-        };
-    }
-    return {
-        path: fileItem.path,
-        startLine: fileItem.startLine,
-        endLine: fileItem.endLine,
-        newContent: fileItem.newContent,
-    };
-}
-/**
- * Execute batch operation with error handling
- */
-export async function executeBatchOperation(fileItems, parseParams, executeSingle, mapResult) {
-    const results = [];
-    for (const fileItem of fileItems) {
-        try {
-            const params = parseParams(fileItem);
-            const result = await executeSingle(...Object.values(params));
-            results.push({
-                success: true,
-                ...mapResult(params.path, result),
-            });
-        }
-        catch (error) {
-            const filePath = typeof fileItem === 'string'
-                ? fileItem
-                : fileItem.path;
-            results.push({
-                path: filePath,
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            });
-        }
-    }
-    const successCount = results.filter(r => r.success).length;
-    const failureCount = results.filter(r => !r.success).length;
-    // Build detailed message with all file diffs
-    let detailedMessage = `📊 Batch Edit Summary: ${successCount} succeeded, ${failureCount} failed\n\n`;
-    results.forEach((result, index) => {
-        const num = index + 1;
-        const separator = '─'.repeat(80);
-        if (result.success) {
-            detailedMessage += `${separator}\n`;
-            detailedMessage += `✅ File ${num}/${results.length}: ${result.path}\n`;
-            detailedMessage += `${separator}\n\n`;
-            // Add individual file full result (including oldContent and newContent for diff)
-            const fileResult = result;
-            // Extract key metadata from message if available
-            if (fileResult.message) {
-                const lines = fileResult.message.split('\n');
-                const metadataLines = lines.filter((l) => l.trim().startsWith('Matched:') ||
-                    l.trim().startsWith('Replaced:') ||
-                    l.trim().startsWith('Result:') ||
-                    l.trim().startsWith('📍'));
-                if (metadataLines.length > 0) {
-                    metadataLines.forEach((line) => {
-                        detailedMessage += `${line}\n`;
-                    });
-                    detailedMessage += '\n';
-                }
-            }
-            // Add diff display - keep oldContent and newContent in results for UI rendering
-            // Don't format as text here, let the UI handle it with DiffViewer
-            if (fileResult.oldContent && fileResult.newContent) {
-                // Just add a placeholder message, actual diff will be rendered by UI
-                detailedMessage += `📊 Changes (lines ${fileResult.contextStartLine ?? '?'}-${fileResult.contextEndLine ?? '?'})\n\n`;
-            }
-            // Add structure analysis warnings if any
-            if (fileResult.structureAnalysis) {
-                const warnings = [];
-                const sa = fileResult.structureAnalysis;
-                if (!sa.bracketBalance?.curly?.balanced) {
-                    const diff = (sa.bracketBalance.curly.open || 0) -
-                        (sa.bracketBalance.curly.close || 0);
-                    warnings.push(`Curly brackets: ${diff > 0 ? `${diff} unclosed {` : `${Math.abs(diff)} extra }`}`);
-                }
-                if (!sa.bracketBalance?.round?.balanced) {
-                    const diff = (sa.bracketBalance.round.open || 0) -
-                        (sa.bracketBalance.round.close || 0);
-                    warnings.push(`Round brackets: ${diff > 0 ? `${diff} unclosed (` : `${Math.abs(diff)} extra )`}`);
-                }
-                if (!sa.bracketBalance?.square?.balanced) {
-                    const diff = (sa.bracketBalance.square.open || 0) -
-                        (sa.bracketBalance.square.close || 0);
-                    warnings.push(`Square brackets: ${diff > 0 ? `${diff} unclosed [` : `${Math.abs(diff)} extra ]`}`);
-                }
-                if (warnings.length > 0) {
-                    detailedMessage += `⚠️  Structure Warnings:\n`;
-                    warnings.forEach((w) => {
-                        detailedMessage += `   • ${w}\n`;
-                    });
-                    detailedMessage += '\n';
-                }
-            }
-            // Add diagnostics if any
-            if (fileResult.diagnostics && fileResult.diagnostics.length > 0) {
-                const errorCount = fileResult.diagnostics.filter((d) => d.severity === 'error').length;
-                const warningCount = fileResult.diagnostics.filter((d) => d.severity === 'warning').length;
-                if (errorCount > 0 || warningCount > 0) {
-                    detailedMessage += `🔧 Diagnostics: ${errorCount} error(s), ${warningCount} warning(s)\n`;
-                    fileResult.diagnostics.slice(0, 3).forEach((d) => {
-                        const icon = d.severity === 'error' ? '❌' : '⚠️';
-                        detailedMessage += `   ${icon} Line ${d.line}: ${d.message}\n`;
-                    });
-                    if (fileResult.diagnostics.length > 3) {
-                        detailedMessage += `   ... and ${fileResult.diagnostics.length - 3} more\n`;
-                    }
-                    detailedMessage += '\n';
-                }
-            }
-        }
-        else {
-            detailedMessage += `${separator}\n`;
-            detailedMessage += `❌ File ${num}/${results.length}: ${result.path}\n`;
-            detailedMessage += `${separator}\n`;
-            detailedMessage += `Error: ${result.error}\n\n`;
-        }
-    });
-    return {
-        message: detailedMessage.trim(),
-        results,
-        totalFiles: fileItems.length,
-        successCount,
-        failureCount,
-    };
-}

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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,165 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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;