snow-ai 0.4.15 → 0.4.17

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

@@ -1,85 +0,0 @@
-/**
- * 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 => setTimeout(resolve, 0));
-        }
-        // 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/office-parser.utils.d.ts

@@ -1,43 +0,0 @@
-/**
- * Office file parsing utilities
- * Handles parsing of PDF, Word, Excel, and PowerPoint files
- */
-import type { DocumentContent } from '../../types/filesystem.types.js';
-/**
- * Parse Word document (.docx, .doc)
- * @param fullPath - Full path to the Word document
- * @returns DocumentContent object with extracted text
- */
-export declare function parseWordDocument(fullPath: string): Promise<DocumentContent | null>;
-/**
- * Parse PDF document
- * @param fullPath - Full path to the PDF file
- * @returns DocumentContent object with extracted text
- */
-export declare function parsePDFDocument(fullPath: string): Promise<DocumentContent | null>;
-/**
- * Parse Excel spreadsheet (.xlsx, .xls)
- * @param fullPath - Full path to the Excel file
- * @returns DocumentContent object with extracted text
- */
-export declare function parseExcelDocument(fullPath: string): Promise<DocumentContent | null>;
-/**
- * Parse PowerPoint presentation (.pptx, .ppt)
- * Note: PowerPoint parsing is complex and requires unzipping the .pptx file
- * This is a placeholder implementation
- * @param fullPath - Full path to the PowerPoint file
- * @returns DocumentContent object with extracted text
- */
-export declare function parsePowerPointDocument(fullPath: string): Promise<DocumentContent | null>;
-/**
- * Get Office file type based on extension
- * @param filePath - Path to the file
- * @returns File type or undefined
- */
-export declare function getOfficeFileType(filePath: string): 'pdf' | 'word' | 'excel' | 'powerpoint' | undefined;
-/**
- * Main entry point: Read and parse Office document
- * @param fullPath - Full path to the Office document
- * @returns DocumentContent object with extracted text
- */
-export declare function readOfficeDocument(fullPath: string): Promise<DocumentContent | null>;

package/dist/mcp/utils/filesystem/office-parser.utils.js

@@ -1,163 +0,0 @@
-/**
- * Office file parsing utilities
- * Handles parsing of PDF, Word, Excel, and PowerPoint files
- */
-import { promises as fs } from 'fs';
-import mammoth from 'mammoth';
-import * as XLSX from 'xlsx';
-import { OFFICE_FILE_TYPES } from '../../types/filesystem.types.js';
-import * as path from 'path';
-/**
- * Parse Word document (.docx, .doc)
- * @param fullPath - Full path to the Word document
- * @returns DocumentContent object with extracted text
- */
-export async function parseWordDocument(fullPath) {
-    try {
-        const buffer = await fs.readFile(fullPath);
-        const result = await mammoth.extractRawText({ buffer });
-        return {
-            type: 'document',
-            text: result.value,
-            fileType: 'word',
-            metadata: {
-                messages: result.messages.length > 0 ? result.messages : undefined,
-            },
-        };
-    }
-    catch (error) {
-        console.error(`Failed to parse Word document ${fullPath}:`, error);
-        return null;
-    }
-}
-/**
- * Parse PDF document
- * @param fullPath - Full path to the PDF file
- * @returns DocumentContent object with extracted text
- */
-export async function parsePDFDocument(fullPath) {
-    try {
-        // Lazy import pdf-parse to avoid loading pdfjs-dist at startup
-        // pdfjs-dist requires browser APIs (DOMMatrix) which causes errors in Node.js
-        const { PDFParse } = await import('pdf-parse');
-        const buffer = await fs.readFile(fullPath);
-        const uint8Array = new Uint8Array(buffer);
-        // Create parser instance and parse
-        const parser = new PDFParse({ data: uint8Array });
-        const data = await parser.getText();
-        return {
-            type: 'document',
-            text: data.text,
-            fileType: 'pdf',
-            metadata: {
-                pages: data.total,
-            },
-        };
-    }
-    catch (error) {
-        console.error(`Failed to parse PDF document ${fullPath}:`, error);
-        return null;
-    }
-}
-/**
- * Parse Excel spreadsheet (.xlsx, .xls)
- * @param fullPath - Full path to the Excel file
- * @returns DocumentContent object with extracted text
- */
-export async function parseExcelDocument(fullPath) {
-    try {
-        const buffer = await fs.readFile(fullPath);
-        const workbook = XLSX.read(buffer, { type: 'buffer' });
-        const sheets = [];
-        let allText = '';
-        workbook.SheetNames.forEach(sheetName => {
-            sheets.push(sheetName);
-            const worksheet = workbook.Sheets[sheetName];
-            if (worksheet) {
-                const sheetText = XLSX.utils.sheet_to_txt(worksheet);
-                allText += `\n\n=== Sheet: ${sheetName} ===\n${sheetText}`;
-            }
-        });
-        return {
-            type: 'document',
-            text: allText.trim(),
-            fileType: 'excel',
-            metadata: {
-                sheets,
-                sheetCount: sheets.length,
-            },
-        };
-    }
-    catch (error) {
-        console.error(`Failed to parse Excel document ${fullPath}:`, error);
-        return null;
-    }
-}
-/**
- * Parse PowerPoint presentation (.pptx, .ppt)
- * Note: PowerPoint parsing is complex and requires unzipping the .pptx file
- * This is a placeholder implementation
- * @param fullPath - Full path to the PowerPoint file
- * @returns DocumentContent object with extracted text
- */
-export async function parsePowerPointDocument(fullPath) {
-    try {
-        // PowerPoint parsing requires extracting and parsing XML from the .pptx archive
-        // A full implementation would use JSZip to extract slide XML files
-        // and parse them to extract text content
-        // For now, return a placeholder message
-        return {
-            type: 'document',
-            text: '[PowerPoint parsing not fully implemented yet. Please use a specialized tool to extract text from .pptx files.]',
-            fileType: 'powerpoint',
-            metadata: {
-                note: 'PowerPoint text extraction requires additional implementation',
-                suggestion: 'Consider using external tools or libraries like python-pptx for full PowerPoint text extraction',
-            },
-        };
-    }
-    catch (error) {
-        console.error(`Failed to parse PowerPoint document ${fullPath}:`, error);
-        return null;
-    }
-}
-/**
- * Get Office file type based on extension
- * @param filePath - Path to the file
- * @returns File type or undefined
- */
-export function getOfficeFileType(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return OFFICE_FILE_TYPES[ext];
-}
-/**
- * Main entry point: Read and parse Office document
- * @param fullPath - Full path to the Office document
- * @returns DocumentContent object with extracted text
- */
-export async function readOfficeDocument(fullPath) {
-    const fileType = getOfficeFileType(fullPath);
-    if (!fileType) {
-        return null;
-    }
-    let docContent = null;
-    switch (fileType) {
-        case 'word': {
-            docContent = await parseWordDocument(fullPath);
-            break;
-        }
-        case 'pdf': {
-            docContent = await parsePDFDocument(fullPath);
-            break;
-        }
-        case 'excel': {
-            docContent = await parseExcelDocument(fullPath);
-            break;
-        }
-        case 'powerpoint': {
-            docContent = await parsePowerPointDocument(fullPath);
-            break;
-        }
-    }
-    return docContent;
-}

package/dist/mcp/utils/filesystem/path-fixer.utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Attempt to fix common path issues when file is not found
- * @param originalPath - The original path that failed
- * @param basePath - Base path for resolving relative paths
- * @returns Fixed path or null if cannot be fixed
- */
-export declare function tryFixPath(originalPath: string, basePath: string): Promise<string | null>;

package/dist/mcp/utils/filesystem/path-fixer.utils.js

@@ -1,60 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { resolve } from 'node:path';
-/**
- * Attempt to fix common path issues when file is not found
- * @param originalPath - The original path that failed
- * @param basePath - Base path for resolving relative paths
- * @returns Fixed path or null if cannot be fixed
- */
-export async function tryFixPath(originalPath, basePath) {
-    try {
-        // Common pattern: "source/mcp/utils/filesystem.ts" should be "source/mcp/filesystem.ts"
-        // Remove unnecessary intermediate directories
-        const segments = originalPath.split('/');
-        // Try removing 'utils' directory if present
-        if (segments.includes('utils')) {
-            const withoutUtils = segments.filter(s => s !== 'utils').join('/');
-            const fixedPath = resolve(basePath, withoutUtils);
-            try {
-                await fs.access(fixedPath);
-                return withoutUtils;
-            }
-            catch {
-                // Continue to next attempt
-            }
-        }
-        // Try parent directories
-        for (let i = 0; i < segments.length - 1; i++) {
-            const reducedPath = [
-                ...segments.slice(0, i),
-                segments[segments.length - 1],
-            ].join('/');
-            const fixedPath = resolve(basePath, reducedPath);
-            try {
-                await fs.access(fixedPath);
-                return reducedPath;
-            }
-            catch {
-                // Continue to next attempt
-            }
-        }
-        // Try searching for the file by name in common directories
-        const fileName = segments[segments.length - 1];
-        const commonDirs = ['source', 'src', 'lib', 'dist'];
-        for (const dir of commonDirs) {
-            const searchPath = `${dir}/${fileName}`;
-            const fixedPath = resolve(basePath, searchPath);
-            try {
-                await fs.access(fixedPath);
-                return searchPath;
-            }
-            catch {
-                // Continue to next attempt
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}

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

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

package/dist/mcp/utils/filesystem/similarity.utils.js

@@ -1,75 +0,0 @@
-/**
- * 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 function calculateSimilarity(str1, str2, threshold = 0) {
-    // Normalize whitespace for comparison: collapse all whitespace to single spaces
-    const normalize = (s) => s.replace(/\s+/g, ' ').trim();
-    const norm1 = normalize(str1);
-    const norm2 = normalize(str2);
-    const len1 = norm1.length;
-    const len2 = norm2.length;
-    if (len1 === 0)
-        return len2 === 0 ? 1 : 0;
-    if (len2 === 0)
-        return 0;
-    // Quick length check - if lengths differ too much, similarity can't be above threshold
-    const maxLen = Math.max(len1, len2);
-    const minLen = Math.min(len1, len2);
-    const lengthRatio = minLen / maxLen;
-    if (threshold > 0 && lengthRatio < threshold) {
-        return lengthRatio; // Can't possibly meet threshold
-    }
-    // Use Levenshtein distance for better similarity calculation
-    const distance = levenshteinDistance(norm1, norm2, Math.ceil(maxLen * (1 - threshold)));
-    return 1 - distance / maxLen;
-}
-/**
- * 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 function levenshteinDistance(str1, str2, maxDistance = Infinity) {
-    const len1 = str1.length;
-    const len2 = str2.length;
-    // Quick exit for identical strings
-    if (str1 === str2)
-        return 0;
-    // Quick exit if length difference already exceeds maxDistance
-    if (Math.abs(len1 - len2) > maxDistance) {
-        return maxDistance + 1;
-    }
-    // Use single-row algorithm to save memory (only need previous row)
-    let prevRow = Array.from({ length: len2 + 1 }, (_, i) => i);
-    for (let i = 1; i <= len1; i++) {
-        const currRow = [i];
-        let minInRow = i; // Track minimum value in current row
-        for (let j = 1; j <= len2; j++) {
-            const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-            const val = Math.min(prevRow[j] + 1, // deletion
-            currRow[j - 1] + 1, // insertion
-            prevRow[j - 1] + cost);
-            currRow[j] = val;
-            minInRow = Math.min(minInRow, val);
-        }
-        // Early termination: if minimum in this row exceeds maxDistance, we can stop
-        if (minInRow > maxDistance) {
-            return maxDistance + 1;
-        }
-        prevRow = currRow;
-    }
-    return prevRow[len2];
-}
-/**
- * Normalize whitespace for display purposes
- * Makes preview more readable by collapsing whitespace
- */
-export function normalizeForDisplay(line) {
-    return line.replace(/\t/g, ' ').replace(/  +/g, ' ');
-}

package/dist/mcp/utils/todo/date.utils.d.ts

@@ -1,9 +0,0 @@
-/**
- * Date utilities for TODO service
- */
-/**
- * Format date for folder name (YYYY-MM-DD)
- * @param date - Date to format
- * @returns Formatted date string
- */
-export declare function formatDateForFolder(date: Date): string;

package/dist/mcp/utils/todo/date.utils.js

@@ -1,14 +0,0 @@
-/**
- * Date utilities for TODO service
- */
-/**
- * Format date for folder name (YYYY-MM-DD)
- * @param date - Date to format
- * @returns Formatted date string
- */
-export function formatDateForFolder(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    return `${year}-${month}-${day}`;
-}

package/dist/mcp/utils/websearch/browser.utils.d.ts

@@ -1,8 +0,0 @@
-/**
- * Browser detection utilities for web search
- */
-/**
- * Detect system Chrome/Edge browser executable path
- * @returns Browser executable path or null if not found
- */
-export declare function findBrowserExecutable(): string | null;

package/dist/mcp/utils/websearch/browser.utils.js

@@ -1,58 +0,0 @@
-/**
- * Browser detection utilities for web search
- */
-import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { platform } from 'node:os';
-/**
- * Detect system Chrome/Edge browser executable path
- * @returns Browser executable path or null if not found
- */
-export function findBrowserExecutable() {
-    const os = platform();
-    const paths = [];
-    if (os === 'win32') {
-        // Windows: Prioritize Edge (built-in), then Chrome
-        const edgePaths = [
-            'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
-            'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
-        ];
-        const chromePaths = [
-            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
-            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
-            process.env['LOCALAPPDATA'] + '\\Google\\Chrome\\Application\\chrome.exe',
-        ];
-        paths.push(...edgePaths, ...chromePaths);
-    }
-    else if (os === 'darwin') {
-        // macOS
-        paths.push('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium', '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge');
-    }
-    else {
-        // Linux
-        const binPaths = [
-            'google-chrome',
-            'chromium',
-            'chromium-browser',
-            'microsoft-edge',
-        ];
-        for (const bin of binPaths) {
-            try {
-                const path = execSync(`which ${bin}`, { encoding: 'utf8' }).trim();
-                if (path) {
-                    return path;
-                }
-            }
-            catch {
-                // Continue to next binary
-            }
-        }
-    }
-    // Check if any path exists
-    for (const path of paths) {
-        if (path && existsSync(path)) {
-            return path;
-        }
-    }
-    return null;
-}

package/dist/mcp/utils/websearch/text.utils.d.ts

@@ -1,16 +0,0 @@
-/**
- * Text processing utilities for web search
- */
-import type { SearchResponse } from '../../types/websearch.types.js';
-/**
- * Clean text by removing extra whitespace and HTML entities
- * @param text - Raw text to clean
- * @returns Cleaned text
- */
-export declare function cleanText(text: string): string;
-/**
- * Format search results as readable text for AI consumption
- * @param searchResponse - Search response object
- * @returns Formatted text representation
- */
-export declare function formatSearchResults(searchResponse: SearchResponse): string;

package/dist/mcp/utils/websearch/text.utils.js

@@ -1,39 +0,0 @@
-/**
- * Text processing utilities for web search
- */
-/**
- * Clean text by removing extra whitespace and HTML entities
- * @param text - Raw text to clean
- * @returns Cleaned text
- */
-export function cleanText(text) {
-    return text
-        .replace(/\s+/g, ' ') // Replace multiple spaces with single space
-        .replace(/"/g, '"')
-        .replace(/&/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/<b>/g, '')
-        .replace(/<\/b>/g, '')
-        .trim();
-}
-/**
- * Format search results as readable text for AI consumption
- * @param searchResponse - Search response object
- * @returns Formatted text representation
- */
-export function formatSearchResults(searchResponse) {
-    const { query, results, totalResults } = searchResponse;
-    let output = `Search Results for: "${query}"\n`;
-    output += `Found ${totalResults} results\n\n`;
-    output += '='.repeat(80) + '\n\n';
-    results.forEach((result, index) => {
-        output += `${index + 1}. ${result.title}\n`;
-        output += `   URL: ${result.url}\n`;
-        if (result.snippet) {
-            output += `   ${result.snippet}\n`;
-        }
-        output += '\n';
-    });
-    return output;
-}