apexbot 1.0.2 → 1.0.4

package/dist/skills/system.js

@@ -0,0 +1,360 @@
+"use strict";
+/**
+ * System Info Skill
+ *
+ * Get system information, resource usage, and process management.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const systemInfoTool = {
+    definition: {
+        name: 'system_info',
+        description: 'Get system information: OS, CPU, memory, disk, network.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Info type: all, os, cpu, memory, disk, network',
+                required: false,
+                default: 'all',
+                enum: ['all', 'os', 'cpu', 'memory', 'disk', 'network'],
+            },
+        ],
+        returns: 'System information',
+    },
+    async execute(params, context) {
+        const { type = 'all' } = params;
+        try {
+            const result = {};
+            if (type === 'all' || type === 'os') {
+                result.os = {
+                    platform: os.platform(),
+                    type: os.type(),
+                    release: os.release(),
+                    arch: os.arch(),
+                    hostname: os.hostname(),
+                    uptime: Math.floor(os.uptime() / 3600) + ' hours',
+                };
+            }
+            if (type === 'all' || type === 'cpu') {
+                const cpus = os.cpus();
+                result.cpu = {
+                    model: cpus[0]?.model || 'Unknown',
+                    cores: cpus.length,
+                    speed: cpus[0]?.speed + ' MHz',
+                    loadAvg: os.loadavg().map(l => l.toFixed(2)),
+                };
+            }
+            if (type === 'all' || type === 'memory') {
+                const totalMem = os.totalmem();
+                const freeMem = os.freemem();
+                const usedMem = totalMem - freeMem;
+                result.memory = {
+                    total: (totalMem / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+                    used: (usedMem / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+                    free: (freeMem / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+                    usage: ((usedMem / totalMem) * 100).toFixed(1) + '%',
+                };
+            }
+            if (type === 'all' || type === 'disk') {
+                try {
+                    if (os.platform() === 'win32') {
+                        const { stdout } = await execAsync('wmic logicaldisk get size,freespace,caption');
+                        const lines = stdout.trim().split('\n').slice(1);
+                        result.disk = lines.map(line => {
+                            const parts = line.trim().split(/\s+/);
+                            if (parts.length >= 3) {
+                                const free = parseInt(parts[1]) || 0;
+                                const total = parseInt(parts[2]) || 1;
+                                return {
+                                    drive: parts[0],
+                                    total: (total / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+                                    free: (free / 1024 / 1024 / 1024).toFixed(2) + ' GB',
+                                    usage: (((total - free) / total) * 100).toFixed(1) + '%',
+                                };
+                            }
+                            return null;
+                        }).filter(Boolean);
+                    }
+                    else {
+                        const { stdout } = await execAsync('df -h /');
+                        const lines = stdout.trim().split('\n');
+                        if (lines.length > 1) {
+                            const parts = lines[1].split(/\s+/);
+                            result.disk = [{
+                                    mount: parts[5],
+                                    total: parts[1],
+                                    used: parts[2],
+                                    free: parts[3],
+                                    usage: parts[4],
+                                }];
+                        }
+                    }
+                }
+                catch {
+                    result.disk = { error: 'Could not get disk info' };
+                }
+            }
+            if (type === 'all' || type === 'network') {
+                const interfaces = os.networkInterfaces();
+                result.network = Object.entries(interfaces)
+                    .filter(([name]) => !name.includes('Loopback') && !name.startsWith('lo'))
+                    .map(([name, addrs]) => ({
+                    name,
+                    addresses: addrs?.filter(a => a.family === 'IPv4').map(a => a.address) || [],
+                }))
+                    .filter(n => n.addresses.length > 0);
+            }
+            return {
+                success: true,
+                data: result,
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const processListTool = {
+    definition: {
+        name: 'process_list',
+        description: 'List running processes.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'filter',
+                type: 'string',
+                description: 'Filter by process name',
+                required: false,
+            },
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Max results (default: 20)',
+                required: false,
+                default: 20,
+            },
+        ],
+        returns: 'List of processes',
+    },
+    async execute(params, context) {
+        const { filter, limit = 20 } = params;
+        try {
+            let processes = [];
+            if (os.platform() === 'win32') {
+                const { stdout } = await execAsync('tasklist /fo csv /nh');
+                const lines = stdout.trim().split('\n');
+                for (const line of lines) {
+                    const match = line.match(/"([^"]+)","(\d+)","([^"]+)","(\d+)","([^"]+)"/);
+                    if (match) {
+                        processes.push({
+                            name: match[1],
+                            pid: match[2],
+                            session: match[3],
+                            memory: match[5],
+                        });
+                    }
+                }
+            }
+            else {
+                const { stdout } = await execAsync('ps aux --no-headers');
+                const lines = stdout.trim().split('\n');
+                for (const line of lines) {
+                    const parts = line.trim().split(/\s+/);
+                    if (parts.length >= 11) {
+                        processes.push({
+                            user: parts[0],
+                            pid: parts[1],
+                            cpu: parts[2] + '%',
+                            memory: parts[3] + '%',
+                            name: parts.slice(10).join(' '),
+                        });
+                    }
+                }
+            }
+            // Filter
+            if (filter) {
+                processes = processes.filter(p => p.name.toLowerCase().includes(filter.toLowerCase()));
+            }
+            // Limit
+            processes = processes.slice(0, limit);
+            return {
+                success: true,
+                data: {
+                    processes,
+                    count: processes.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const killProcessTool = {
+    definition: {
+        name: 'process_kill',
+        description: 'Kill a process by PID or name.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'target',
+                type: 'string',
+                description: 'Process PID or name',
+                required: true,
+            },
+        ],
+        returns: 'Kill confirmation',
+    },
+    async execute(params, context) {
+        const { target } = params;
+        if (!target) {
+            return { success: false, error: 'Target is required' };
+        }
+        try {
+            const isPid = /^\d+$/.test(target);
+            if (os.platform() === 'win32') {
+                const cmd = isPid
+                    ? `taskkill /PID ${target} /F`
+                    : `taskkill /IM "${target}" /F`;
+                await execAsync(cmd);
+            }
+            else {
+                const cmd = isPid
+                    ? `kill -9 ${target}`
+                    : `pkill -9 "${target}"`;
+                await execAsync(cmd);
+            }
+            return {
+                success: true,
+                data: {
+                    target,
+                    killed: true,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const clipboardTool = {
+    definition: {
+        name: 'clipboard',
+        description: 'Read or write system clipboard.',
+        category: 'automation',
+        parameters: [
+            {
+                name: 'action',
+                type: 'string',
+                description: 'Action: read, write',
+                required: true,
+                enum: ['read', 'write'],
+            },
+            {
+                name: 'content',
+                type: 'string',
+                description: 'Content to write (for write action)',
+                required: false,
+            },
+        ],
+        returns: 'Clipboard content or confirmation',
+    },
+    async execute(params, context) {
+        const { action, content } = params;
+        try {
+            if (action === 'read') {
+                let text;
+                if (os.platform() === 'win32') {
+                    const { stdout } = await execAsync('powershell -command "Get-Clipboard"');
+                    text = stdout.trim();
+                }
+                else if (os.platform() === 'darwin') {
+                    const { stdout } = await execAsync('pbpaste');
+                    text = stdout;
+                }
+                else {
+                    const { stdout } = await execAsync('xclip -selection clipboard -o');
+                    text = stdout;
+                }
+                return {
+                    success: true,
+                    data: { content: text },
+                };
+            }
+            else if (action === 'write') {
+                if (!content) {
+                    return { success: false, error: 'Content is required for write action' };
+                }
+                if (os.platform() === 'win32') {
+                    await execAsync(`powershell -command "Set-Clipboard -Value '${content.replace(/'/g, "''")}'"`);
+                }
+                else if (os.platform() === 'darwin') {
+                    await execAsync(`echo "${content.replace(/"/g, '\\"')}" | pbcopy`);
+                }
+                else {
+                    await execAsync(`echo "${content.replace(/"/g, '\\"')}" | xclip -selection clipboard`);
+                }
+                return {
+                    success: true,
+                    data: { written: true, length: content.length },
+                };
+            }
+            return { success: false, error: 'Invalid action' };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const manifest = {
+    name: 'system',
+    version: '1.0.0',
+    description: 'System information and process management',
+    category: 'automation',
+    icon: 'computer',
+    tools: ['system_info', 'process_list', 'process_kill', 'clipboard'],
+    config: [],
+};
+const systemSkill = {
+    manifest,
+    tools: [systemInfoTool, processListTool, killProcessTool, clipboardTool],
+};
+exports.default = systemSkill;

package/dist/skills/weather.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Weather Skill
+ *
+ * Get current weather and forecasts using Open-Meteo API (free, no API key required).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const weatherTool = {
+    definition: {
+        name: 'weather',
+        description: 'Get current weather and forecast for a location.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'location',
+                type: 'string',
+                description: 'City name or coordinates (lat,lon)',
+                required: true,
+            },
+            {
+                name: 'days',
+                type: 'number',
+                description: 'Forecast days (1-7)',
+                required: false,
+                default: 1,
+            },
+        ],
+        returns: 'Weather data',
+        examples: [
+            'weather({ location: "London" })',
+            'weather({ location: "New York", days: 3 })',
+            'weather({ location: "48.8566,2.3522" })',
+        ],
+    },
+    async execute(params, context) {
+        const { location, days = 1 } = params;
+        if (!location) {
+            return { success: false, error: 'Location is required' };
+        }
+        try {
+            // Check if location is coordinates
+            let lat, lon, locationName;
+            if (location.includes(',')) {
+                const [latStr, lonStr] = location.split(',');
+                lat = parseFloat(latStr.trim());
+                lon = parseFloat(lonStr.trim());
+                locationName = `${lat}, ${lon}`;
+            }
+            else {
+                // Geocode the location
+                const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
+                const geoResponse = await fetch(geoUrl);
+                const geoData = await geoResponse.json();
+                if (!geoData.results || geoData.results.length === 0) {
+                    return { success: false, error: `Location not found: ${location}` };
+                }
+                const result = geoData.results[0];
+                lat = result.latitude;
+                lon = result.longitude;
+                locationName = `${result.name}, ${result.country}`;
+            }
+            // Get weather data
+            const weatherUrl = `https://api.open-meteo.com/v1/forecast?` +
+                `latitude=${lat}&longitude=${lon}` +
+                `&current=temperature_2m,relative_humidity_2m,apparent_temperature,weather_code,wind_speed_10m,wind_direction_10m` +
+                `&daily=weather_code,temperature_2m_max,temperature_2m_min,precipitation_sum,wind_speed_10m_max` +
+                `&forecast_days=${Math.min(days, 7)}` +
+                `&timezone=auto`;
+            const weatherResponse = await fetch(weatherUrl);
+            const weatherData = await weatherResponse.json();
+            // Weather code descriptions
+            const weatherCodes = {
+                0: 'Clear sky',
+                1: 'Mainly clear',
+                2: 'Partly cloudy',
+                3: 'Overcast',
+                45: 'Foggy',
+                48: 'Depositing rime fog',
+                51: 'Light drizzle',
+                53: 'Moderate drizzle',
+                55: 'Dense drizzle',
+                61: 'Slight rain',
+                63: 'Moderate rain',
+                65: 'Heavy rain',
+                71: 'Slight snow',
+                73: 'Moderate snow',
+                75: 'Heavy snow',
+                80: 'Slight rain showers',
+                81: 'Moderate rain showers',
+                82: 'Violent rain showers',
+                95: 'Thunderstorm',
+                96: 'Thunderstorm with slight hail',
+                99: 'Thunderstorm with heavy hail',
+            };
+            const current = {
+                temperature: weatherData.current.temperature_2m,
+                feelsLike: weatherData.current.apparent_temperature,
+                humidity: weatherData.current.relative_humidity_2m,
+                windSpeed: weatherData.current.wind_speed_10m,
+                windDirection: weatherData.current.wind_direction_10m,
+                condition: weatherCodes[weatherData.current.weather_code] || 'Unknown',
+            };
+            const forecast = weatherData.daily.time.map((date, i) => ({
+                date,
+                tempMax: weatherData.daily.temperature_2m_max[i],
+                tempMin: weatherData.daily.temperature_2m_min[i],
+                precipitation: weatherData.daily.precipitation_sum[i],
+                windSpeed: weatherData.daily.wind_speed_10m_max[i],
+                condition: weatherCodes[weatherData.daily.weather_code[i]] || 'Unknown',
+            }));
+            return {
+                success: true,
+                data: {
+                    location: locationName,
+                    coordinates: { lat, lon },
+                    current,
+                    forecast,
+                    units: {
+                        temperature: 'C',
+                        wind: 'km/h',
+                        precipitation: 'mm',
+                    },
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const manifest = {
+    name: 'weather',
+    version: '1.0.0',
+    description: 'Get current weather and forecasts',
+    category: 'productivity',
+    icon: 'cloud',
+    tools: ['weather'],
+    config: [],
+};
+const weatherSkill = {
+    manifest,
+    tools: [weatherTool],
+};
+exports.default = weatherSkill;

package/dist/tools/datetime.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * DateTime Tool
+ *
+ * Get current time, convert timezones, calculate dates.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDateTimeTools = registerDateTimeTools;
+const index_1 = require("./index");
+const dateTimeTool = {
+    definition: {
+        name: 'datetime',
+        description: 'Get current date/time, convert timezones, or calculate dates.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'action',
+                type: 'string',
+                description: 'Action: now, convert, add, diff',
+                required: false,
+                default: 'now',
+                enum: ['now', 'convert', 'add', 'diff'],
+            },
+            {
+                name: 'timezone',
+                type: 'string',
+                description: 'Timezone (e.g., America/New_York, Europe/London)',
+                required: false,
+            },
+            {
+                name: 'date',
+                type: 'string',
+                description: 'Input date (ISO format or natural)',
+                required: false,
+            },
+            {
+                name: 'amount',
+                type: 'number',
+                description: 'Amount to add (for add action)',
+                required: false,
+            },
+            {
+                name: 'unit',
+                type: 'string',
+                description: 'Unit for add action: days, hours, minutes, weeks, months',
+                required: false,
+                enum: ['days', 'hours', 'minutes', 'weeks', 'months', 'years'],
+            },
+            {
+                name: 'date2',
+                type: 'string',
+                description: 'Second date for diff action',
+                required: false,
+            },
+        ],
+        returns: 'Date/time information',
+        examples: [
+            'datetime({ action: "now" })',
+            'datetime({ action: "now", timezone: "Asia/Tokyo" })',
+            'datetime({ action: "add", date: "2024-01-01", amount: 7, unit: "days" })',
+        ],
+    },
+    async execute(params, context) {
+        const { action = 'now', timezone, date, amount, unit, date2 } = params;
+        try {
+            switch (action) {
+                case 'now': {
+                    const now = new Date();
+                    const options = {
+                        year: 'numeric',
+                        month: 'long',
+                        day: 'numeric',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        weekday: 'long',
+                        timeZoneName: 'short',
+                    };
+                    if (timezone) {
+                        options.timeZone = timezone;
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            iso: now.toISOString(),
+                            unix: Math.floor(now.getTime() / 1000),
+                            formatted: now.toLocaleString('en-US', options),
+                            timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+                            date: now.toLocaleDateString('en-US', timezone ? { timeZone: timezone } : {}),
+                            time: now.toLocaleTimeString('en-US', timezone ? { timeZone: timezone } : {}),
+                        },
+                    };
+                }
+                case 'convert': {
+                    if (!date || !timezone) {
+                        return { success: false, error: 'Date and timezone required for convert' };
+                    }
+                    const inputDate = new Date(date);
+                    const options = {
+                        year: 'numeric',
+                        month: 'long',
+                        day: 'numeric',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        timeZone: timezone,
+                        timeZoneName: 'short',
+                    };
+                    return {
+                        success: true,
+                        data: {
+                            original: date,
+                            converted: inputDate.toLocaleString('en-US', options),
+                            timezone,
+                        },
+                    };
+                }
+                case 'add': {
+                    if (!amount || !unit) {
+                        return { success: false, error: 'Amount and unit required for add' };
+                    }
+                    const inputDate = date ? new Date(date) : new Date();
+                    const result = new Date(inputDate);
+                    switch (unit) {
+                        case 'minutes':
+                            result.setMinutes(result.getMinutes() + amount);
+                            break;
+                        case 'hours':
+                            result.setHours(result.getHours() + amount);
+                            break;
+                        case 'days':
+                            result.setDate(result.getDate() + amount);
+                            break;
+                        case 'weeks':
+                            result.setDate(result.getDate() + amount * 7);
+                            break;
+                        case 'months':
+                            result.setMonth(result.getMonth() + amount);
+                            break;
+                        case 'years':
+                            result.setFullYear(result.getFullYear() + amount);
+                            break;
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            original: inputDate.toISOString(),
+                            result: result.toISOString(),
+                            added: `${amount} ${unit}`,
+                        },
+                    };
+                }
+                case 'diff': {
+                    if (!date || !date2) {
+                        return { success: false, error: 'Two dates required for diff' };
+                    }
+                    const d1 = new Date(date);
+                    const d2 = new Date(date2);
+                    const diffMs = Math.abs(d2.getTime() - d1.getTime());
+                    return {
+                        success: true,
+                        data: {
+                            date1: d1.toISOString(),
+                            date2: d2.toISOString(),
+                            difference: {
+                                milliseconds: diffMs,
+                                seconds: Math.floor(diffMs / 1000),
+                                minutes: Math.floor(diffMs / (1000 * 60)),
+                                hours: Math.floor(diffMs / (1000 * 60 * 60)),
+                                days: Math.floor(diffMs / (1000 * 60 * 60 * 24)),
+                                weeks: Math.floor(diffMs / (1000 * 60 * 60 * 24 * 7)),
+                            },
+                        },
+                    };
+                }
+                default:
+                    return { success: false, error: `Unknown action: ${action}` };
+            }
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+function registerDateTimeTools() {
+    index_1.toolRegistry.register(dateTimeTool);
+}
+exports.default = dateTimeTool;