brave-real-browser-mcp-server 2.14.7 → 2.14.9

package/dist/handlers/data-processing-handlers.js

@@ -2,45 +2,6 @@
 // Text cleaning, validation, formatting utilities
 // @ts-nocheck
 import { withErrorHandling } from '../system-utils.js';
-import { parsePhoneNumber } from 'libphonenumber-js';
-import * as chrono from 'chrono-node';
-import Ajv from 'ajv/dist/2020.js';
-/**
- * Extra whitespace और special characters remove करता है
- */
-export async function handleSmartTextCleaner(args) {
-    return await withErrorHandling(async () => {
-        let text = args.text;
-        const removeExtraWhitespace = args.removeExtraWhitespace !== false;
-        const removeSpecialChars = args.removeSpecialChars || false;
-        const toLowerCase = args.toLowerCase || false;
-        const trim = args.trim !== false;
-        // Remove extra whitespace
-        if (removeExtraWhitespace) {
-            text = text.replace(/\s+/g, ' ');
-        }
-        // Remove special characters
-        if (removeSpecialChars) {
-            text = text.replace(/[^\w\s]/g, '');
-        }
-        // Convert to lowercase
-        if (toLowerCase) {
-            text = text.toLowerCase();
-        }
-        // Trim
-        if (trim) {
-            text = text.trim();
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Text cleaned\n\nOriginal length: ${args.text.length}\nCleaned length: ${text.length}\n\nCleaned text:\n${text}`,
-                },
-            ],
-        };
-    }, 'Failed to clean text');
-}
 /**
  * HTML tags intelligently remove करता है
  */
@@ -85,242 +46,6 @@ export async function handleHTMLToText(args) {
         };
     }, 'Failed to convert HTML to text');
 }
-/**
- * Currency symbols और formatting से actual numbers निकालता है
- */
-export async function handlePriceParser(args) {
-    return await withErrorHandling(async () => {
-        const text = args.text;
-        const currency = args.currency;
-        // Regular expressions for price patterns
-        const pricePatterns = [
-            /\$\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // $1,234.56
-            /(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)\s?USD/gi, // 1234.56 USD
-            /€\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // €1,234.56
-            /£\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // £1,234.56
-            /₹\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // ₹1,234.56
-            /(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // 1,234.56
-        ];
-        const prices = [];
-        pricePatterns.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(text)) !== null) {
-                const priceStr = match[1] || match[0];
-                const numericValue = parseFloat(priceStr.replace(/,/g, ''));
-                if (!isNaN(numericValue)) {
-                    // Detect currency symbol
-                    let detectedCurrency = currency || 'Unknown';
-                    if (match[0].includes('$'))
-                        detectedCurrency = 'USD';
-                    else if (match[0].includes('€'))
-                        detectedCurrency = 'EUR';
-                    else if (match[0].includes('£'))
-                        detectedCurrency = 'GBP';
-                    else if (match[0].includes('₹'))
-                        detectedCurrency = 'INR';
-                    prices.push({
-                        original: match[0],
-                        value: numericValue,
-                        currency: detectedCurrency,
-                        formatted: `${detectedCurrency} ${numericValue.toFixed(2)}`,
-                    });
-                }
-            }
-        });
-        // Remove duplicates
-        const uniquePrices = prices.filter((price, index, self) => index === self.findIndex((p) => p.value === price.value && p.currency === price.currency));
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Parsed ${uniquePrices.length} price(s)\n\n${JSON.stringify(uniquePrices, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to parse prices');
-}
-/**
- * Different date formats को standard format में convert करता है
- */
-export async function handleDateNormalizer(args) {
-    return await withErrorHandling(async () => {
-        const text = args.text;
-        const outputFormat = args.outputFormat || 'iso';
-        // Parse dates using chrono-node
-        const parsedDates = chrono.parse(text);
-        const dates = [];
-        parsedDates.forEach((parsed) => {
-            const date = parsed.start.date();
-            let formatted;
-            if (outputFormat === 'iso') {
-                formatted = date.toISOString();
-            }
-            else if (outputFormat === 'locale') {
-                formatted = date.toLocaleString();
-            }
-            else if (outputFormat === 'unix') {
-                formatted = Math.floor(date.getTime() / 1000);
-            }
-            else {
-                formatted = date.toISOString();
-            }
-            dates.push({
-                original: parsed.text,
-                parsed: formatted,
-                components: {
-                    year: date.getFullYear(),
-                    month: date.getMonth() + 1,
-                    day: date.getDate(),
-                    hour: date.getHours(),
-                    minute: date.getMinutes(),
-                },
-            });
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Normalized ${dates.length} date(s)\n\n${JSON.stringify(dates, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to normalize dates');
-}
-/**
- * Contact information automatically detect करता है
- */
-export async function handleContactExtractor(args) {
-    return await withErrorHandling(async () => {
-        const text = args.text;
-        const types = args.types || ['phone', 'email'];
-        const defaultCountry = args.defaultCountry || 'US';
-        const results = {
-            phones: [],
-            emails: [],
-        };
-        // Extract emails
-        if (types.includes('email')) {
-            const emailPattern = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
-            const emails = text.match(emailPattern) || [];
-            results.emails = [...new Set(emails)].map((email) => ({
-                value: email,
-                domain: email.split('@')[1],
-                username: email.split('@')[0],
-            }));
-        }
-        // Extract phone numbers
-        if (types.includes('phone')) {
-            // Common phone patterns
-            const phonePatterns = [
-                /\+?\d{1,3}[-.\s]?\(?\d{1,4}\)?[-.\s]?\d{1,4}[-.\s]?\d{1,9}/g,
-                /\(\d{3}\)\s?\d{3}-?\d{4}/g,
-                /\d{3}[-.\s]?\d{3}[-.\s]?\d{4}/g,
-            ];
-            const potentialPhones = [];
-            phonePatterns.forEach((pattern) => {
-                const matches = text.match(pattern) || [];
-                potentialPhones.push(...matches);
-            });
-            // Parse and validate phone numbers
-            potentialPhones.forEach((phone) => {
-                try {
-                    const parsed = parsePhoneNumber(phone, defaultCountry);
-                    if (parsed && parsed.isValid()) {
-                        results.phones.push({
-                            original: phone,
-                            international: parsed.formatInternational(),
-                            national: parsed.formatNational(),
-                            country: parsed.country,
-                            type: parsed.getType(),
-                        });
-                    }
-                }
-                catch (e) {
-                    // Invalid phone number, skip
-                    results.phones.push({
-                        original: phone,
-                        valid: false,
-                    });
-                }
-            });
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Extracted contact info\n\nEmails: ${results.emails.length}\nPhones: ${results.phones.length}\n\n${JSON.stringify(results, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to extract contact info');
-}
-/**
- * Extracted data की structure verify करता है
- */
-export async function handleSchemaValidator(args) {
-    return await withErrorHandling(async () => {
-        const data = args.data;
-        const schema = args.schema;
-        const ajv = new Ajv({ allErrors: true });
-        const validate = ajv.compile(schema);
-        const valid = validate(data);
-        if (valid) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: '✅ Data validation passed\n\nAll fields match the schema.',
-                    },
-                ],
-            };
-        }
-        else {
-            const errors = validate.errors?.map((err) => ({
-                field: err.instancePath,
-                message: err.message,
-                params: err.params,
-            }));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Data validation failed\n\n${JSON.stringify(errors, null, 2)}`,
-                    },
-                ],
-            };
-        }
-    }, 'Failed to validate schema');
-}
-/**
- * Missing data detect करता है
- */
-export async function handleRequiredFieldsChecker(args) {
-    return await withErrorHandling(async () => {
-        const data = args.data;
-        const requiredFields = args.requiredFields;
-        const missing = [];
-        const present = [];
-        requiredFields.forEach((field) => {
-            // Support nested fields with dot notation
-            const value = field.split('.').reduce((obj, key) => obj?.[key], data);
-            if (value === undefined || value === null || value === '') {
-                missing.push(field);
-            }
-            else {
-                present.push(field);
-            }
-        });
-        const isValid = missing.length === 0;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `${isValid ? '✅' : '❌'} Required fields check\n\nPresent: ${present.length}/${requiredFields.length}\nMissing: ${missing.join(', ') || 'None'}\n\n${isValid ? 'All required fields are present!' : 'Some required fields are missing.'}`,
-                },
-            ],
-        };
-    }, 'Failed to check required fields');
-}
 /**
  * Repeated data filter करता है
  */

package/dist/handlers/data-quality-handlers.js

@@ -74,94 +74,6 @@ export async function handleDataDeduplication(args) {
 /**
  * Missing Data Handler - Detect and handle missing data
  */
-export async function handleMissingDataHandler(args) {
-    const { data, requiredFields, strategy = 'report' } = args;
-    try {
-        if (!Array.isArray(data)) {
-            throw new Error('Data must be an array');
-        }
-        const results = [];
-        const missingReport = {};
-        let totalMissing = 0;
-        data.forEach((item, index) => {
-            const itemMissing = {};
-            let hasMissing = false;
-            if (requiredFields && Array.isArray(requiredFields)) {
-                requiredFields.forEach(field => {
-                    const value = item[field];
-                    if (value === undefined || value === null || value === '') {
-                        itemMissing[field] = true;
-                        hasMissing = true;
-                        totalMissing++;
-                        if (!missingReport[field]) {
-                            missingReport[field] = { count: 0, indices: [] };
-                        }
-                        missingReport[field].count++;
-                        missingReport[field].indices.push(index);
-                    }
-                });
-            }
-            // Handle missing data based on strategy
-            let processedItem = { ...item };
-            switch (strategy) {
-                case 'remove':
-                    if (!hasMissing)
-                        results.push(processedItem);
-                    break;
-                case 'fill':
-                    Object.keys(itemMissing).forEach(field => {
-                        if (typeof item[field] === 'number') {
-                            processedItem[field] = 0;
-                        }
-                        else if (typeof item[field] === 'string') {
-                            processedItem[field] = 'N/A';
-                        }
-                        else {
-                            processedItem[field] = null;
-                        }
-                    });
-                    results.push(processedItem);
-                    break;
-                case 'flag':
-                    processedItem._hasMissingData = hasMissing;
-                    processedItem._missingFields = Object.keys(itemMissing);
-                    results.push(processedItem);
-                    break;
-                case 'report':
-                default:
-                    results.push(processedItem);
-                    break;
-            }
-        });
-        const itemsWithMissing = Object.values(missingReport).length > 0 ?
-            [...new Set(Object.values(missingReport).flatMap((r) => r.indices))].length : 0;
-        const missingRate = ((totalMissing / (data.length * (requiredFields?.length || 1))) * 100).toFixed(2);
-        let summary = `Missing Data Analysis:\n\nStatistics:\n- Total Items: ${data.length}\n- Items with Missing Data: ${itemsWithMissing}\n- Total Missing Fields: ${totalMissing}\n- Missing Rate: ${missingRate}%\n- Strategy: ${strategy}`;
-        if (Object.keys(missingReport).length > 0) {
-            summary += `\n\nMissing Fields Report:\n${Object.entries(missingReport).map(([field, info]) => `- ${field}: ${info.count} occurrences (indices: ${info.indices.slice(0, 5).join(', ')}${info.indices.length > 5 ? '...' : ''})`).join('\n')}`;
-        }
-        summary += `\n\nProcessed Items: ${results.length}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Missing Data Handler Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
 /**
  * Data Type Validator - Validate data types against schema
  */
@@ -343,135 +255,3 @@ export async function handleOutlierDetection(args) {
 /**
  * Consistency Checker - Check data consistency across fields
  */
-export async function handleConsistencyChecker(args) {
-    const { data, rules } = args;
-    try {
-        if (!Array.isArray(data)) {
-            throw new Error('Data must be an array');
-        }
-        if (!rules || !Array.isArray(rules)) {
-            throw new Error('Rules must be provided as an array');
-        }
-        const violations = [];
-        const ruleResults = {};
-        rules.forEach(rule => {
-            ruleResults[rule.name] = { passed: 0, failed: 0, violations: [] };
-        });
-        data.forEach((item, index) => {
-            rules.forEach(rule => {
-                let passed = true;
-                let reason = '';
-                try {
-                    switch (rule.type) {
-                        case 'required':
-                            if (item[rule.field] === undefined || item[rule.field] === null || item[rule.field] === '') {
-                                passed = false;
-                                reason = `Field '${rule.field}' is required but missing`;
-                            }
-                            break;
-                        case 'range':
-                            const value = parseFloat(item[rule.field]);
-                            if (isNaN(value) || value < rule.min || value > rule.max) {
-                                passed = false;
-                                reason = `Field '${rule.field}' value ${value} is outside range [${rule.min}, ${rule.max}]`;
-                            }
-                            break;
-                        case 'pattern':
-                            const regex = new RegExp(rule.pattern);
-                            if (!regex.test(String(item[rule.field]))) {
-                                passed = false;
-                                reason = `Field '${rule.field}' does not match pattern ${rule.pattern}`;
-                            }
-                            break;
-                        case 'dependency':
-                            if (item[rule.field] && !item[rule.dependsOn]) {
-                                passed = false;
-                                reason = `Field '${rule.field}' requires '${rule.dependsOn}' to be present`;
-                            }
-                            break;
-                        case 'unique':
-                            // Check uniqueness within dataset
-                            const duplicates = data.filter(d => d[rule.field] === item[rule.field]);
-                            if (duplicates.length > 1) {
-                                passed = false;
-                                reason = `Field '${rule.field}' value '${item[rule.field]}' is not unique`;
-                            }
-                            break;
-                        case 'comparison':
-                            const val1 = parseFloat(item[rule.field1]);
-                            const val2 = parseFloat(item[rule.field2]);
-                            let comparisonPassed = false;
-                            switch (rule.operator) {
-                                case '>':
-                                    comparisonPassed = val1 > val2;
-                                    break;
-                                case '<':
-                                    comparisonPassed = val1 < val2;
-                                    break;
-                                case '>=':
-                                    comparisonPassed = val1 >= val2;
-                                    break;
-                                case '<=':
-                                    comparisonPassed = val1 <= val2;
-                                    break;
-                                case '==':
-                                    comparisonPassed = val1 === val2;
-                                    break;
-                                case '!=':
-                                    comparisonPassed = val1 !== val2;
-                                    break;
-                            }
-                            if (!comparisonPassed) {
-                                passed = false;
-                                reason = `Comparison failed: ${rule.field1} (${val1}) ${rule.operator} ${rule.field2} (${val2})`;
-                            }
-                            break;
-                    }
-                }
-                catch (err) {
-                    passed = false;
-                    reason = `Error checking rule: ${err.message}`;
-                }
-                if (passed) {
-                    ruleResults[rule.name].passed++;
-                }
-                else {
-                    ruleResults[rule.name].failed++;
-                    const violation = {
-                        index,
-                        item,
-                        rule: rule.name,
-                        reason
-                    };
-                    ruleResults[rule.name].violations.push(violation);
-                    violations.push(violation);
-                }
-            });
-        });
-        const consistencyRate = (((data.length - violations.length) / data.length) * 100).toFixed(2);
-        let summary = `Consistency Check Results:\n\nSummary:\n- Total Items: ${data.length}\n- Rules Checked: ${rules.length}\n- Total Violations: ${violations.length}\n- Consistency Rate: ${consistencyRate}%`;
-        summary += `\n\nRule Results:\n${Object.entries(ruleResults).map(([name, result]) => `- ${name}: ${result.passed} passed, ${result.failed} failed`).join('\n')}`;
-        if (violations.length > 0) {
-            summary += `\n\nViolations (Top 10):\n${violations.slice(0, 10).map((v, i) => `${i + 1}. Index ${v.index} - Rule: ${v.rule}\n   Reason: ${v.reason}`).join('\n')}`;
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Consistency Checker Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}