apexbot 1.0.2 → 1.0.4

package/dist/tools/math.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * Math Tool
+ *
+ * Perform calculations, unit conversions, and math operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTool = exports.mathTool = void 0;
+exports.registerMathTools = registerMathTools;
+const index_1 = require("./index");
+const mathTool = {
+    definition: {
+        name: 'math',
+        description: 'Evaluate mathematical expressions and perform calculations.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'expression',
+                type: 'string',
+                description: 'Mathematical expression to evaluate (e.g., "2 + 2", "sqrt(16)", "sin(45)")',
+                required: true,
+            },
+        ],
+        returns: 'Calculation result',
+        examples: [
+            'math({ expression: "2 + 2 * 3" })',
+            'math({ expression: "sqrt(144) + pow(2, 10)" })',
+            'math({ expression: "(100 * 1.15) - 50" })',
+        ],
+    },
+    async execute(params, context) {
+        const { expression } = params;
+        if (!expression) {
+            return { success: false, error: 'Expression is required' };
+        }
+        try {
+            // Safe math evaluation with supported functions
+            const mathFunctions = {
+                abs: Math.abs,
+                ceil: Math.ceil,
+                floor: Math.floor,
+                round: Math.round,
+                sqrt: Math.sqrt,
+                cbrt: Math.cbrt,
+                pow: Math.pow,
+                exp: Math.exp,
+                log: Math.log,
+                log10: Math.log10,
+                log2: Math.log2,
+                sin: Math.sin,
+                cos: Math.cos,
+                tan: Math.tan,
+                asin: Math.asin,
+                acos: Math.acos,
+                atan: Math.atan,
+                sinh: Math.sinh,
+                cosh: Math.cosh,
+                tanh: Math.tanh,
+                min: Math.min,
+                max: Math.max,
+                random: Math.random,
+                sign: Math.sign,
+                trunc: Math.trunc,
+            };
+            const constants = {
+                PI: Math.PI,
+                E: Math.E,
+                LN2: Math.LN2,
+                LN10: Math.LN10,
+                SQRT2: Math.SQRT2,
+            };
+            // Sanitize and prepare expression
+            let sanitized = expression
+                .replace(/\s+/g, ' ')
+                .trim();
+            // Replace constants
+            for (const [name, value] of Object.entries(constants)) {
+                sanitized = sanitized.replace(new RegExp(`\\b${name}\\b`, 'gi'), String(value));
+            }
+            // Check for dangerous patterns
+            if (/[;{}[\]]|function|eval|require|import|process|global/.test(sanitized)) {
+                return { success: false, error: 'Invalid expression: contains forbidden patterns' };
+            }
+            // Build safe evaluation context
+            const funcNames = Object.keys(mathFunctions).join(',');
+            const funcValues = Object.values(mathFunctions);
+            // Create function with math functions in scope
+            const evalFunc = new Function(...Object.keys(mathFunctions), `"use strict"; return (${sanitized});`);
+            const result = evalFunc(...funcValues);
+            if (typeof result !== 'number' || !isFinite(result)) {
+                return {
+                    success: true,
+                    data: {
+                        expression,
+                        result: String(result),
+                        type: typeof result,
+                    },
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    expression,
+                    result,
+                    formatted: result.toLocaleString(),
+                    scientific: result.toExponential(),
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: `Evaluation error: ${error.message}` };
+        }
+    },
+};
+exports.mathTool = mathTool;
+// Unit Conversion Tool
+const convertTool = {
+    definition: {
+        name: 'convert',
+        description: 'Convert between units (length, weight, temperature, etc.)',
+        category: 'core',
+        parameters: [
+            {
+                name: 'value',
+                type: 'number',
+                description: 'Value to convert',
+                required: true,
+            },
+            {
+                name: 'from',
+                type: 'string',
+                description: 'Source unit',
+                required: true,
+            },
+            {
+                name: 'to',
+                type: 'string',
+                description: 'Target unit',
+                required: true,
+            },
+        ],
+        returns: 'Converted value',
+        examples: [
+            'convert({ value: 100, from: "km", to: "miles" })',
+            'convert({ value: 32, from: "fahrenheit", to: "celsius" })',
+            'convert({ value: 1, from: "gb", to: "mb" })',
+        ],
+    },
+    async execute(params, context) {
+        const { value, from, to } = params;
+        if (value === undefined || !from || !to) {
+            return { success: false, error: 'Value, from, and to are required' };
+        }
+        const conversions = {
+            // Length (base: meters)
+            m: { m: 1, km: 0.001, cm: 100, mm: 1000, mi: 0.000621371, miles: 0.000621371, ft: 3.28084, feet: 3.28084, in: 39.3701, inch: 39.3701, yd: 1.09361, yard: 1.09361 },
+            km: { m: 1000, km: 1, cm: 100000, mm: 1000000, mi: 0.621371, miles: 0.621371, ft: 3280.84, feet: 3280.84 },
+            miles: { km: 1.60934, m: 1609.34, mi: 1, miles: 1, ft: 5280, feet: 5280 },
+            mi: { km: 1.60934, m: 1609.34, mi: 1, miles: 1, ft: 5280, feet: 5280 },
+            cm: { m: 0.01, km: 0.00001, cm: 1, mm: 10, in: 0.393701, inch: 0.393701 },
+            ft: { m: 0.3048, cm: 30.48, in: 12, inch: 12, ft: 1, feet: 1 },
+            feet: { m: 0.3048, cm: 30.48, in: 12, inch: 12, ft: 1, feet: 1 },
+            in: { cm: 2.54, m: 0.0254, ft: 0.0833333, feet: 0.0833333, in: 1, inch: 1 },
+            inch: { cm: 2.54, m: 0.0254, ft: 0.0833333, feet: 0.0833333, in: 1, inch: 1 },
+            // Weight (base: kg)
+            kg: { kg: 1, g: 1000, lb: 2.20462, lbs: 2.20462, oz: 35.274 },
+            g: { kg: 0.001, g: 1, mg: 1000, lb: 0.00220462, oz: 0.035274 },
+            lb: { kg: 0.453592, g: 453.592, lb: 1, lbs: 1, oz: 16 },
+            lbs: { kg: 0.453592, g: 453.592, lb: 1, lbs: 1, oz: 16 },
+            oz: { g: 28.3495, kg: 0.0283495, lb: 0.0625, lbs: 0.0625, oz: 1 },
+            // Data (base: bytes)
+            b: { b: 1, kb: 0.001, mb: 0.000001, gb: 0.000000001, tb: 0.000000000001 },
+            kb: { b: 1000, kb: 1, mb: 0.001, gb: 0.000001, tb: 0.000000001 },
+            mb: { b: 1000000, kb: 1000, mb: 1, gb: 0.001, tb: 0.000001 },
+            gb: { b: 1000000000, kb: 1000000, mb: 1000, gb: 1, tb: 0.001 },
+            tb: { b: 1000000000000, kb: 1000000000, mb: 1000000, gb: 1000, tb: 1 },
+            // Time
+            sec: { sec: 1, min: 1 / 60, hr: 1 / 3600, day: 1 / 86400 },
+            min: { sec: 60, min: 1, hr: 1 / 60, day: 1 / 1440 },
+            hr: { sec: 3600, min: 60, hr: 1, day: 1 / 24 },
+            day: { sec: 86400, min: 1440, hr: 24, day: 1, week: 1 / 7 },
+            week: { day: 7, hr: 168, min: 10080, sec: 604800 },
+        };
+        const fromLower = from.toLowerCase();
+        const toLower = to.toLowerCase();
+        // Special case: temperature
+        if (['c', 'celsius', 'f', 'fahrenheit', 'k', 'kelvin'].includes(fromLower)) {
+            let celsius;
+            // Convert to Celsius first
+            if (fromLower === 'c' || fromLower === 'celsius') {
+                celsius = value;
+            }
+            else if (fromLower === 'f' || fromLower === 'fahrenheit') {
+                celsius = (value - 32) * 5 / 9;
+            }
+            else {
+                celsius = value - 273.15;
+            }
+            // Convert from Celsius to target
+            let result;
+            if (toLower === 'c' || toLower === 'celsius') {
+                result = celsius;
+            }
+            else if (toLower === 'f' || toLower === 'fahrenheit') {
+                result = celsius * 9 / 5 + 32;
+            }
+            else if (toLower === 'k' || toLower === 'kelvin') {
+                result = celsius + 273.15;
+            }
+            else {
+                return { success: false, error: `Unknown temperature unit: ${to}` };
+            }
+            return {
+                success: true,
+                data: {
+                    value,
+                    from,
+                    to,
+                    result: Math.round(result * 100) / 100,
+                },
+            };
+        }
+        // Look up conversion
+        const fromConversions = conversions[fromLower];
+        if (!fromConversions) {
+            return { success: false, error: `Unknown unit: ${from}` };
+        }
+        const factor = fromConversions[toLower];
+        if (factor === undefined) {
+            return { success: false, error: `Cannot convert from ${from} to ${to}` };
+        }
+        const result = value * factor;
+        return {
+            success: true,
+            data: {
+                value,
+                from,
+                to,
+                result: Math.round(result * 1000000) / 1000000,
+            },
+        };
+    },
+};
+exports.convertTool = convertTool;
+function registerMathTools() {
+    index_1.toolRegistry.register(mathTool);
+    index_1.toolRegistry.register(convertTool);
+}

package/dist/tools/shell.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Shell Tool
+ *
+ * Execute shell commands safely with timeout and output capture.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const shellTool = {
+    definition: {
+        name: 'shell',
+        description: 'Execute a shell command and return the output. Use for running scripts, system commands, or CLI tools.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'command',
+                type: 'string',
+                description: 'The shell command to execute',
+                required: true,
+            },
+            {
+                name: 'cwd',
+                type: 'string',
+                description: 'Working directory for the command',
+                required: false,
+            },
+            {
+                name: 'timeout',
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 30000)',
+                required: false,
+                default: 30000,
+            },
+        ],
+        returns: 'Command output (stdout and stderr)',
+        examples: [
+            'shell({ command: "ls -la" })',
+            'shell({ command: "npm install", cwd: "/path/to/project" })',
+        ],
+    },
+    async execute(params, context) {
+        const { command, cwd, timeout = 30000 } = params;
+        if (!command) {
+            return { success: false, error: 'Command is required' };
+        }
+        // Security check - block dangerous commands
+        const dangerous = ['rm -rf /', 'format c:', ':(){:|:&};:', 'dd if=', 'mkfs'];
+        for (const pattern of dangerous) {
+            if (command.toLowerCase().includes(pattern.toLowerCase())) {
+                return { success: false, error: 'Blocked: potentially dangerous command' };
+            }
+        }
+        return new Promise((resolve) => {
+            const isWindows = process.platform === 'win32';
+            const shell = isWindows ? 'powershell.exe' : '/bin/bash';
+            const shellArgs = isWindows ? ['-Command', command] : ['-c', command];
+            const proc = (0, child_process_1.spawn)(shell, shellArgs, {
+                cwd: cwd || context.workspaceDir || process.cwd(),
+                windowsHide: true,
+                timeout,
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            const timeoutId = setTimeout(() => {
+                proc.kill('SIGTERM');
+                resolve({
+                    success: false,
+                    error: 'Command timed out',
+                    data: { stdout, stderr },
+                });
+            }, timeout);
+            proc.on('close', (code) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    success: code === 0,
+                    data: {
+                        exitCode: code,
+                        stdout: stdout.trim(),
+                        stderr: stderr.trim(),
+                        output: (stdout + stderr).trim(),
+                    },
+                    error: code !== 0 ? `Exit code: ${code}` : undefined,
+                });
+            });
+            proc.on('error', (error) => {
+                clearTimeout(timeoutId);
+                resolve({
+                    success: false,
+                    error: error.message,
+                });
+            });
+        });
+    },
+    validate(params) {
+        return typeof params.command === 'string' && params.command.length > 0;
+    },
+};
+exports.default = shellTool;

package/dist/tools/web.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Web / Browser Tool
+ *
+ * Fetch web pages, search the web, and extract content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSearchTool = exports.fetchUrlTool = void 0;
+exports.registerWebTools = registerWebTools;
+const index_1 = require("./index");
+// Fetch URL Tool
+const fetchUrlTool = {
+    definition: {
+        name: 'fetch_url',
+        description: 'Fetch content from a URL. Can extract text, HTML, or JSON.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'url',
+                type: 'string',
+                description: 'URL to fetch',
+                required: true,
+            },
+            {
+                name: 'format',
+                type: 'string',
+                description: 'Response format: text, html, json',
+                required: false,
+                default: 'text',
+                enum: ['text', 'html', 'json'],
+            },
+            {
+                name: 'timeout',
+                type: 'number',
+                description: 'Timeout in milliseconds',
+                required: false,
+                default: 10000,
+            },
+        ],
+        returns: 'Fetched content',
+        examples: [
+            'fetch_url({ url: "https://example.com" })',
+            'fetch_url({ url: "https://api.example.com/data", format: "json" })',
+        ],
+    },
+    async execute(params, context) {
+        const { url, format = 'text', timeout = 10000 } = params;
+        if (!url) {
+            return { success: false, error: 'URL is required' };
+        }
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(url, {
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': 'ApexBot/1.0',
+                },
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            let content;
+            const contentType = response.headers.get('content-type') || '';
+            if (format === 'json' || contentType.includes('application/json')) {
+                content = await response.json();
+            }
+            else if (format === 'html' || contentType.includes('text/html')) {
+                content = await response.text();
+                // Simple HTML to text conversion (strip tags)
+                if (format === 'text') {
+                    content = content
+                        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                        .replace(/<[^>]+>/g, ' ')
+                        .replace(/\s+/g, ' ')
+                        .trim();
+                }
+            }
+            else {
+                content = await response.text();
+            }
+            return {
+                success: true,
+                data: {
+                    url,
+                    status: response.status,
+                    contentType,
+                    content,
+                },
+            };
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                return { success: false, error: 'Request timed out' };
+            }
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.fetchUrlTool = fetchUrlTool;
+// Web Search Tool (using DuckDuckGo instant answers)
+const webSearchTool = {
+    definition: {
+        name: 'web_search',
+        description: 'Search the web using DuckDuckGo and return results.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query',
+                required: true,
+            },
+            {
+                name: 'max_results',
+                type: 'number',
+                description: 'Maximum number of results',
+                required: false,
+                default: 5,
+            },
+        ],
+        returns: 'Search results with titles and snippets',
+        examples: [
+            'web_search({ query: "weather in Tokyo" })',
+            'web_search({ query: "nodejs tutorial", max_results: 10 })',
+        ],
+    },
+    async execute(params, context) {
+        const { query, max_results = 5 } = params;
+        if (!query) {
+            return { success: false, error: 'Query is required' };
+        }
+        try {
+            // Use DuckDuckGo instant answer API
+            const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1`;
+            const response = await fetch(url, {
+                headers: { 'User-Agent': 'ApexBot/1.0' },
+            });
+            if (!response.ok) {
+                return { success: false, error: `Search failed: ${response.statusText}` };
+            }
+            const data = await response.json();
+            const results = [];
+            // Abstract (main answer)
+            if (data.Abstract) {
+                results.push({
+                    title: data.Heading || 'Result',
+                    snippet: data.Abstract,
+                    url: data.AbstractURL || '',
+                    source: data.AbstractSource || '',
+                });
+            }
+            // Related topics
+            if (data.RelatedTopics) {
+                for (const topic of data.RelatedTopics.slice(0, max_results - results.length)) {
+                    if (topic.Text) {
+                        results.push({
+                            title: topic.Text.split(' - ')[0] || 'Related',
+                            snippet: topic.Text,
+                            url: topic.FirstURL || '',
+                        });
+                    }
+                }
+            }
+            // Instant answer
+            if (data.Answer && results.length === 0) {
+                results.push({
+                    title: 'Answer',
+                    snippet: data.Answer,
+                    url: '',
+                });
+            }
+            return {
+                success: true,
+                data: {
+                    query,
+                    results: results.slice(0, max_results),
+                    total: results.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.webSearchTool = webSearchTool;
+// Register web tools
+function registerWebTools() {
+    index_1.toolRegistry.register(fetchUrlTool);
+    index_1.toolRegistry.register(webSearchTool);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apexbot",
-  "version": "1.0.2",
-  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Like Clawdbot but open-source!",
+  "version": "1.0.4",
+  "description": "ApexBot - Your free, private AI assistant. 100% free with Ollama (local AI). Multi-channel: Telegram, Discord, WebChat. Tools & Skills system like Clawdbot!",
   "main": "dist/index.js",
   "bin": {
     "apexbot": "./dist/cli/index.js"