apexbot 1.0.1 → 1.0.4

package/dist/tools/file.js

@@ -0,0 +1,352 @@
+"use strict";
+/**
+ * File System Tools
+ *
+ * Read, write, list, and manage files and directories.
+ */
+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 });
+exports.editFileTool = exports.deleteFileTool = exports.listDirTool = exports.writeFileTool = exports.readFileTool = void 0;
+exports.registerFileTools = registerFileTools;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+// Read File Tool
+const readFileTool = {
+    definition: {
+        name: 'read_file',
+        description: 'Read the contents of a file. Supports text files.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'path',
+                type: 'string',
+                description: 'Path to the file to read',
+                required: true,
+            },
+            {
+                name: 'encoding',
+                type: 'string',
+                description: 'File encoding (default: utf-8)',
+                required: false,
+                default: 'utf-8',
+            },
+        ],
+        returns: 'File contents as string',
+    },
+    async execute(params, context) {
+        const { path: filePath, encoding = 'utf-8' } = params;
+        if (!filePath) {
+            return { success: false, error: 'Path is required' };
+        }
+        try {
+            const fullPath = path.resolve(context.workspaceDir || process.cwd(), filePath);
+            const content = await fs.readFile(fullPath, encoding);
+            return {
+                success: true,
+                data: {
+                    path: fullPath,
+                    content,
+                    size: content.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.readFileTool = readFileTool;
+// Write File Tool
+const writeFileTool = {
+    definition: {
+        name: 'write_file',
+        description: 'Write content to a file. Creates the file if it does not exist.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'path',
+                type: 'string',
+                description: 'Path to the file to write',
+                required: true,
+            },
+            {
+                name: 'content',
+                type: 'string',
+                description: 'Content to write to the file',
+                required: true,
+            },
+            {
+                name: 'append',
+                type: 'boolean',
+                description: 'Append to file instead of overwriting',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Success confirmation',
+    },
+    async execute(params, context) {
+        const { path: filePath, content, append = false } = params;
+        if (!filePath) {
+            return { success: false, error: 'Path is required' };
+        }
+        try {
+            const fullPath = path.resolve(context.workspaceDir || process.cwd(), filePath);
+            // Ensure directory exists
+            const dir = path.dirname(fullPath);
+            await fs.mkdir(dir, { recursive: true });
+            if (append) {
+                await fs.appendFile(fullPath, content);
+            }
+            else {
+                await fs.writeFile(fullPath, content);
+            }
+            return {
+                success: true,
+                data: {
+                    path: fullPath,
+                    bytesWritten: content.length,
+                    append,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.writeFileTool = writeFileTool;
+// List Directory Tool
+const listDirTool = {
+    definition: {
+        name: 'list_dir',
+        description: 'List files and directories in a path.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'path',
+                type: 'string',
+                description: 'Directory path to list',
+                required: false,
+                default: '.',
+            },
+            {
+                name: 'recursive',
+                type: 'boolean',
+                description: 'List recursively',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Array of file/directory entries',
+    },
+    async execute(params, context) {
+        const { path: dirPath = '.', recursive = false } = params;
+        try {
+            const fullPath = path.resolve(context.workspaceDir || process.cwd(), dirPath);
+            async function listRecursive(dir) {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                const results = [];
+                for (const entry of entries) {
+                    const entryPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(fullPath, entryPath);
+                    const info = {
+                        name: entry.name,
+                        path: relativePath,
+                        isDirectory: entry.isDirectory(),
+                        isFile: entry.isFile(),
+                    };
+                    if (entry.isFile()) {
+                        const stat = await fs.stat(entryPath);
+                        info.size = stat.size;
+                        info.modified = stat.mtime;
+                    }
+                    results.push(info);
+                    if (recursive && entry.isDirectory()) {
+                        const subEntries = await listRecursive(entryPath);
+                        results.push(...subEntries);
+                    }
+                }
+                return results;
+            }
+            const entries = await listRecursive(fullPath);
+            return {
+                success: true,
+                data: {
+                    path: fullPath,
+                    entries,
+                    count: entries.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.listDirTool = listDirTool;
+// Delete File Tool
+const deleteFileTool = {
+    definition: {
+        name: 'delete_file',
+        description: 'Delete a file or directory.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'path',
+                type: 'string',
+                description: 'Path to delete',
+                required: true,
+            },
+            {
+                name: 'recursive',
+                type: 'boolean',
+                description: 'Delete directories recursively',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Success confirmation',
+    },
+    async execute(params, context) {
+        const { path: filePath, recursive = false } = params;
+        if (!filePath) {
+            return { success: false, error: 'Path is required' };
+        }
+        try {
+            const fullPath = path.resolve(context.workspaceDir || process.cwd(), filePath);
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                if (!recursive) {
+                    return { success: false, error: 'Use recursive: true to delete directories' };
+                }
+                await fs.rm(fullPath, { recursive: true, force: true });
+            }
+            else {
+                await fs.unlink(fullPath);
+            }
+            return {
+                success: true,
+                data: {
+                    path: fullPath,
+                    deleted: true,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.deleteFileTool = deleteFileTool;
+// Edit File Tool (search and replace)
+const editFileTool = {
+    definition: {
+        name: 'edit_file',
+        description: 'Edit a file by searching for text and replacing it.',
+        category: 'core',
+        parameters: [
+            {
+                name: 'path',
+                type: 'string',
+                description: 'Path to the file to edit',
+                required: true,
+            },
+            {
+                name: 'search',
+                type: 'string',
+                description: 'Text to search for',
+                required: true,
+            },
+            {
+                name: 'replace',
+                type: 'string',
+                description: 'Replacement text',
+                required: true,
+            },
+            {
+                name: 'all',
+                type: 'boolean',
+                description: 'Replace all occurrences (default: first only)',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Success confirmation with replacement count',
+    },
+    async execute(params, context) {
+        const { path: filePath, search, replace, all = false } = params;
+        if (!filePath || !search) {
+            return { success: false, error: 'Path and search text are required' };
+        }
+        try {
+            const fullPath = path.resolve(context.workspaceDir || process.cwd(), filePath);
+            let content = await fs.readFile(fullPath, 'utf-8');
+            let count = 0;
+            if (all) {
+                const regex = new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+                count = (content.match(regex) || []).length;
+                content = content.replace(regex, replace);
+            }
+            else {
+                if (content.includes(search)) {
+                    content = content.replace(search, replace);
+                    count = 1;
+                }
+            }
+            await fs.writeFile(fullPath, content);
+            return {
+                success: true,
+                data: {
+                    path: fullPath,
+                    replacements: count,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+exports.editFileTool = editFileTool;
+// Register all file tools
+function registerFileTools() {
+    index_1.toolRegistry.register(readFileTool);
+    index_1.toolRegistry.register(writeFileTool);
+    index_1.toolRegistry.register(listDirTool);
+    index_1.toolRegistry.register(deleteFileTool);
+    index_1.toolRegistry.register(editFileTool);
+}

package/dist/tools/index.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * ApexBot Tools System
+ *
+ * Tools are capabilities that the agent can use to interact with the world.
+ * This is the core architecture for all integrations (like Clawdbot's skills).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolRegistry = exports.ToolRegistry = void 0;
+const events_1 = require("events");
+class ToolRegistry extends events_1.EventEmitter {
+    tools = new Map();
+    categories = new Map();
+    register(tool) {
+        const name = tool.definition.name;
+        this.tools.set(name, tool);
+        // Track by category
+        const category = tool.definition.category;
+        if (!this.categories.has(category)) {
+            this.categories.set(category, new Set());
+        }
+        this.categories.get(category).add(name);
+        console.log(`[Tools] Registered: ${name} (${category})`);
+        this.emit('tool:registered', { name, category });
+    }
+    unregister(name) {
+        const tool = this.tools.get(name);
+        if (tool) {
+            this.tools.delete(name);
+            const category = tool.definition.category;
+            this.categories.get(category)?.delete(name);
+            console.log(`[Tools] Unregistered: ${name}`);
+            this.emit('tool:unregistered', { name });
+        }
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    list() {
+        return Array.from(this.tools.values()).map(t => t.definition);
+    }
+    listByCategory(category) {
+        const names = this.categories.get(category);
+        if (!names)
+            return [];
+        return Array.from(names)
+            .map(name => this.tools.get(name)?.definition)
+            .filter((d) => d !== undefined);
+    }
+    getCategories() {
+        return Array.from(this.categories.keys());
+    }
+    async execute(name, params, context) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return { success: false, error: `Tool not found: ${name}` };
+        }
+        // Validate parameters
+        if (tool.validate && !tool.validate(params)) {
+            return { success: false, error: `Invalid parameters for tool: ${name}` };
+        }
+        try {
+            console.log(`[Tools] Executing: ${name}`);
+            this.emit('tool:executing', { name, params });
+            const result = await tool.execute(params, context);
+            this.emit('tool:executed', { name, params, result });
+            console.log(`[Tools] Completed: ${name} (success: ${result.success})`);
+            return result;
+        }
+        catch (error) {
+            console.error(`[Tools] Error executing ${name}:`, error);
+            return { success: false, error: error.message || 'Unknown error' };
+        }
+    }
+    // Generate OpenAI/Anthropic function calling schema
+    toFunctionSchema() {
+        return Array.from(this.tools.values()).map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.definition.name,
+                description: tool.definition.description,
+                parameters: {
+                    type: 'object',
+                    properties: tool.definition.parameters.reduce((acc, param) => {
+                        acc[param.name] = {
+                            type: param.type,
+                            description: param.description,
+                            ...(param.enum ? { enum: param.enum } : {}),
+                            ...(param.default !== undefined ? { default: param.default } : {}),
+                        };
+                        return acc;
+                    }, {}),
+                    required: tool.definition.parameters
+                        .filter(p => p.required)
+                        .map(p => p.name),
+                },
+            },
+        }));
+    }
+    // Generate Ollama tools schema
+    toOllamaSchema() {
+        return this.toFunctionSchema();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+// Global registry instance
+exports.toolRegistry = new ToolRegistry();
+exports.default = exports.toolRegistry;

package/dist/tools/loader.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Tools & Skills Loader
+ *
+ * Registers all built-in tools and skills.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolRegistry = void 0;
+exports.registerBuiltInTools = registerBuiltInTools;
+exports.registerSkills = registerSkills;
+exports.initializeToolsSystem = initializeToolsSystem;
+const tools_1 = require("../tools");
+Object.defineProperty(exports, "toolRegistry", { enumerable: true, get: function () { return tools_1.toolRegistry; } });
+const shell_1 = __importDefault(require("../tools/shell"));
+const file_1 = require("../tools/file");
+const web_1 = require("../tools/web");
+const datetime_1 = require("../tools/datetime");
+const math_1 = require("../tools/math");
+const skills_1 = require("../skills");
+const obsidian_1 = __importDefault(require("../skills/obsidian"));
+const weather_1 = __importDefault(require("../skills/weather"));
+const reminder_1 = __importDefault(require("../skills/reminder"));
+const system_1 = __importDefault(require("../skills/system"));
+/**
+ * Register all built-in tools
+ */
+function registerBuiltInTools() {
+    console.log('[Loader] Registering built-in tools...');
+    // Core tools
+    tools_1.toolRegistry.register(shell_1.default);
+    (0, file_1.registerFileTools)();
+    (0, web_1.registerWebTools)();
+    (0, datetime_1.registerDateTimeTools)();
+    (0, math_1.registerMathTools)();
+    console.log(`[Loader] Registered ${tools_1.toolRegistry.list().length} tools`);
+}
+/**
+ * Register all built-in skills and load user configuration
+ */
+async function registerSkills(configDir) {
+    console.log('[Loader] Registering skills...');
+    const skillManager = (0, skills_1.initSkillManager)(configDir);
+    await skillManager.loadConfig();
+    // Register built-in skills
+    skillManager.register(obsidian_1.default);
+    skillManager.register(weather_1.default);
+    skillManager.register(reminder_1.default);
+    skillManager.register(system_1.default);
+    // Initialize enabled skills
+    await skillManager.initializeEnabled();
+    console.log(`[Loader] Registered ${skillManager.list().length} skills`);
+    return skillManager;
+}
+/**
+ * Initialize the entire tools system
+ */
+async function initializeToolsSystem(configDir) {
+    registerBuiltInTools();
+    const skillManager = await registerSkills(configDir);
+    console.log('[Loader] Tools system ready');
+    console.log('[Loader] Available tools:', tools_1.toolRegistry.list().map(t => t.name).join(', '));
+    return skillManager;
+}