apexbot 1.0.2 → 1.0.4

package/dist/skills/index.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * ApexBot Skills System
+ *
+ * Skills are collections of tools for specific integrations (Obsidian, Spotify, etc.)
+ * Similar to Clawdbot's skills/integrations architecture.
+ */
+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.SkillManager = void 0;
+exports.getSkillManager = getSkillManager;
+exports.initSkillManager = initSkillManager;
+const events_1 = require("events");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const tools_1 = require("../tools");
+class SkillManager extends events_1.EventEmitter {
+    skills = new Map();
+    enabledSkills = new Set();
+    skillConfigs = new Map();
+    configDir;
+    constructor(configDir) {
+        super();
+        this.configDir = configDir;
+    }
+    async loadConfig() {
+        try {
+            const configPath = path.join(this.configDir, 'skills.json');
+            const data = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(data);
+            this.enabledSkills = new Set(config.enabled || []);
+            this.skillConfigs = new Map(Object.entries(config.configs || {}));
+            console.log('[Skills] Loaded config, enabled:', Array.from(this.enabledSkills));
+        }
+        catch (error) {
+            // Config doesn't exist yet, use defaults
+            console.log('[Skills] No config found, using defaults');
+        }
+    }
+    async saveConfig() {
+        const configPath = path.join(this.configDir, 'skills.json');
+        const config = {
+            enabled: Array.from(this.enabledSkills),
+            configs: Object.fromEntries(this.skillConfigs),
+        };
+        await fs.mkdir(this.configDir, { recursive: true });
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+        console.log('[Skills] Saved config');
+    }
+    register(skill) {
+        const name = skill.manifest.name;
+        this.skills.set(name, skill);
+        console.log(`[Skills] Registered: ${name} v${skill.manifest.version}`);
+        this.emit('skill:registered', { name, manifest: skill.manifest });
+    }
+    async enable(name, config) {
+        const skill = this.skills.get(name);
+        if (!skill) {
+            console.error(`[Skills] Skill not found: ${name}`);
+            return false;
+        }
+        try {
+            // Store config
+            if (config) {
+                this.skillConfigs.set(name, config);
+            }
+            // Initialize skill
+            const skillConfig = this.skillConfigs.get(name) || {};
+            if (skill.initialize) {
+                await skill.initialize(skillConfig);
+            }
+            // Register tools
+            for (const tool of skill.tools) {
+                tools_1.toolRegistry.register(tool);
+            }
+            this.enabledSkills.add(name);
+            await this.saveConfig();
+            console.log(`[Skills] Enabled: ${name}`);
+            this.emit('skill:enabled', { name });
+            return true;
+        }
+        catch (error) {
+            console.error(`[Skills] Failed to enable ${name}:`, error.message);
+            return false;
+        }
+    }
+    async disable(name) {
+        const skill = this.skills.get(name);
+        if (!skill) {
+            return false;
+        }
+        try {
+            // Shutdown skill
+            if (skill.shutdown) {
+                await skill.shutdown();
+            }
+            // Unregister tools
+            for (const tool of skill.tools) {
+                tools_1.toolRegistry.unregister(tool.definition.name);
+            }
+            this.enabledSkills.delete(name);
+            await this.saveConfig();
+            console.log(`[Skills] Disabled: ${name}`);
+            this.emit('skill:disabled', { name });
+            return true;
+        }
+        catch (error) {
+            console.error(`[Skills] Failed to disable ${name}:`, error.message);
+            return false;
+        }
+    }
+    isEnabled(name) {
+        return this.enabledSkills.has(name);
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    list() {
+        return Array.from(this.skills.values()).map(skill => ({
+            name: skill.manifest.name,
+            version: skill.manifest.version,
+            description: skill.manifest.description,
+            category: skill.manifest.category,
+            enabled: this.enabledSkills.has(skill.manifest.name),
+            tools: skill.tools.map(t => t.definition.name),
+        }));
+    }
+    listEnabled() {
+        return this.list().filter(s => s.enabled);
+    }
+    listByCategory(category) {
+        return this.list().filter(s => s.category === category);
+    }
+    getConfig(name) {
+        return this.skillConfigs.get(name);
+    }
+    async setConfig(name, config) {
+        this.skillConfigs.set(name, config);
+        await this.saveConfig();
+        // Re-initialize if enabled
+        if (this.enabledSkills.has(name)) {
+            const skill = this.skills.get(name);
+            if (skill?.initialize) {
+                await skill.initialize(config);
+            }
+        }
+    }
+    // Initialize all enabled skills on startup
+    async initializeEnabled() {
+        for (const name of this.enabledSkills) {
+            const skill = this.skills.get(name);
+            if (skill) {
+                try {
+                    const config = this.skillConfigs.get(name) || {};
+                    if (skill.initialize) {
+                        await skill.initialize(config);
+                    }
+                    for (const tool of skill.tools) {
+                        tools_1.toolRegistry.register(tool);
+                    }
+                    console.log(`[Skills] Initialized: ${name}`);
+                }
+                catch (error) {
+                    console.error(`[Skills] Failed to initialize ${name}:`, error.message);
+                }
+            }
+        }
+    }
+}
+exports.SkillManager = SkillManager;
+// Global skill manager instance (initialized in gateway)
+let skillManager = null;
+function getSkillManager() {
+    return skillManager;
+}
+function initSkillManager(configDir) {
+    skillManager = new SkillManager(configDir);
+    return skillManager;
+}
+exports.default = { SkillManager, getSkillManager, initSkillManager };

package/dist/skills/obsidian.js

@@ -0,0 +1,440 @@
+"use strict";
+/**
+ * Obsidian Skill
+ *
+ * Integration with Obsidian note-taking app.
+ * Supports reading, writing, searching notes, and managing daily notes.
+ */
+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 fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+let vaultPath = '';
+const searchNotesTool = {
+    definition: {
+        name: 'obsidian_search',
+        description: 'Search for notes in Obsidian vault by content or filename.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'query',
+                type: 'string',
+                description: 'Search query',
+                required: true,
+            },
+            {
+                name: 'type',
+                type: 'string',
+                description: 'Search type: content, filename, tag',
+                required: false,
+                default: 'content',
+                enum: ['content', 'filename', 'tag'],
+            },
+            {
+                name: 'limit',
+                type: 'number',
+                description: 'Maximum results',
+                required: false,
+                default: 10,
+            },
+        ],
+        returns: 'List of matching notes',
+    },
+    async execute(params, context) {
+        const { query, type = 'content', limit = 10 } = params;
+        if (!vaultPath) {
+            return { success: false, error: 'Obsidian vault not configured' };
+        }
+        try {
+            const results = [];
+            async function searchDir(dir) {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (results.length >= limit)
+                        return;
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(vaultPath, fullPath);
+                    // Skip hidden files/folders
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    if (entry.isDirectory()) {
+                        await searchDir(fullPath);
+                    }
+                    else if (entry.name.endsWith('.md')) {
+                        const noteName = entry.name.replace('.md', '');
+                        if (type === 'filename') {
+                            if (noteName.toLowerCase().includes(query.toLowerCase())) {
+                                results.push({
+                                    name: noteName,
+                                    path: relativePath,
+                                });
+                            }
+                        }
+                        else if (type === 'content' || type === 'tag') {
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            if (type === 'tag') {
+                                const tagPattern = new RegExp(`#${query}\\b`, 'i');
+                                if (tagPattern.test(content)) {
+                                    results.push({
+                                        name: noteName,
+                                        path: relativePath,
+                                        preview: content.slice(0, 200),
+                                    });
+                                }
+                            }
+                            else {
+                                if (content.toLowerCase().includes(query.toLowerCase())) {
+                                    const idx = content.toLowerCase().indexOf(query.toLowerCase());
+                                    const start = Math.max(0, idx - 50);
+                                    const end = Math.min(content.length, idx + query.length + 50);
+                                    results.push({
+                                        name: noteName,
+                                        path: relativePath,
+                                        preview: content.slice(start, end),
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            await searchDir(vaultPath);
+            return {
+                success: true,
+                data: {
+                    query,
+                    type,
+                    results,
+                    count: results.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const readNoteTool = {
+    definition: {
+        name: 'obsidian_read',
+        description: 'Read the content of an Obsidian note.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'name',
+                type: 'string',
+                description: 'Note name or path (without .md)',
+                required: true,
+            },
+        ],
+        returns: 'Note content',
+    },
+    async execute(params, context) {
+        const { name } = params;
+        if (!vaultPath) {
+            return { success: false, error: 'Obsidian vault not configured' };
+        }
+        try {
+            let notePath = name;
+            if (!notePath.endsWith('.md')) {
+                notePath += '.md';
+            }
+            const fullPath = path.join(vaultPath, notePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            // Parse frontmatter if present
+            let frontmatter = {};
+            let body = content;
+            if (content.startsWith('---')) {
+                const endIdx = content.indexOf('---', 3);
+                if (endIdx !== -1) {
+                    const yamlStr = content.slice(3, endIdx).trim();
+                    body = content.slice(endIdx + 3).trim();
+                    // Simple YAML parsing
+                    yamlStr.split('\n').forEach(line => {
+                        const [key, ...valueParts] = line.split(':');
+                        if (key && valueParts.length) {
+                            frontmatter[key.trim()] = valueParts.join(':').trim();
+                        }
+                    });
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    name,
+                    path: notePath,
+                    frontmatter,
+                    content: body,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const writeNoteTool = {
+    definition: {
+        name: 'obsidian_write',
+        description: 'Create or update an Obsidian note.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'name',
+                type: 'string',
+                description: 'Note name or path (without .md)',
+                required: true,
+            },
+            {
+                name: 'content',
+                type: 'string',
+                description: 'Note content (markdown)',
+                required: true,
+            },
+            {
+                name: 'append',
+                type: 'boolean',
+                description: 'Append to existing note',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'Success confirmation',
+    },
+    async execute(params, context) {
+        const { name, content, append = false } = params;
+        if (!vaultPath) {
+            return { success: false, error: 'Obsidian vault not configured' };
+        }
+        try {
+            let notePath = name;
+            if (!notePath.endsWith('.md')) {
+                notePath += '.md';
+            }
+            const fullPath = path.join(vaultPath, notePath);
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            if (append) {
+                const existing = await fs.readFile(fullPath, 'utf-8').catch(() => '');
+                await fs.writeFile(fullPath, existing + '\n' + content);
+            }
+            else {
+                await fs.writeFile(fullPath, content);
+            }
+            return {
+                success: true,
+                data: {
+                    name,
+                    path: notePath,
+                    action: append ? 'appended' : 'created',
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const dailyNoteTool = {
+    definition: {
+        name: 'obsidian_daily',
+        description: 'Get or create today\'s daily note.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'date',
+                type: 'string',
+                description: 'Date (YYYY-MM-DD), defaults to today',
+                required: false,
+            },
+            {
+                name: 'append',
+                type: 'string',
+                description: 'Content to append to daily note',
+                required: false,
+            },
+        ],
+        returns: 'Daily note content',
+    },
+    async execute(params, context) {
+        const { date, append } = params;
+        if (!vaultPath) {
+            return { success: false, error: 'Obsidian vault not configured' };
+        }
+        try {
+            const targetDate = date ? new Date(date) : new Date();
+            const dateStr = targetDate.toISOString().split('T')[0];
+            const notePath = `Daily Notes/${dateStr}.md`;
+            const fullPath = path.join(vaultPath, notePath);
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            let content;
+            try {
+                content = await fs.readFile(fullPath, 'utf-8');
+            }
+            catch {
+                // Create new daily note
+                content = `# ${targetDate.toLocaleDateString('en-US', {
+                    weekday: 'long',
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric'
+                })}\n\n`;
+                await fs.writeFile(fullPath, content);
+            }
+            if (append) {
+                content += '\n' + append;
+                await fs.writeFile(fullPath, content);
+            }
+            return {
+                success: true,
+                data: {
+                    date: dateStr,
+                    path: notePath,
+                    content,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const listNotesTool = {
+    definition: {
+        name: 'obsidian_list',
+        description: 'List notes in Obsidian vault.',
+        category: 'productivity',
+        parameters: [
+            {
+                name: 'folder',
+                type: 'string',
+                description: 'Folder to list (default: root)',
+                required: false,
+                default: '',
+            },
+            {
+                name: 'recursive',
+                type: 'boolean',
+                description: 'List recursively',
+                required: false,
+                default: false,
+            },
+        ],
+        returns: 'List of notes',
+    },
+    async execute(params, context) {
+        const { folder = '', recursive = false } = params;
+        if (!vaultPath) {
+            return { success: false, error: 'Obsidian vault not configured' };
+        }
+        try {
+            const targetPath = path.join(vaultPath, folder);
+            const notes = [];
+            async function listDir(dir) {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.'))
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(vaultPath, fullPath);
+                    if (entry.isDirectory()) {
+                        if (recursive) {
+                            await listDir(fullPath);
+                        }
+                        else {
+                            notes.push({
+                                name: entry.name,
+                                path: relativePath,
+                                isFolder: true,
+                            });
+                        }
+                    }
+                    else if (entry.name.endsWith('.md')) {
+                        const stat = await fs.stat(fullPath);
+                        notes.push({
+                            name: entry.name.replace('.md', ''),
+                            path: relativePath,
+                            isFolder: false,
+                            modified: stat.mtime,
+                            size: stat.size,
+                        });
+                    }
+                }
+            }
+            await listDir(targetPath);
+            return {
+                success: true,
+                data: {
+                    folder,
+                    notes,
+                    count: notes.length,
+                },
+            };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    },
+};
+const manifest = {
+    name: 'obsidian',
+    version: '1.0.0',
+    description: 'Integration with Obsidian note-taking app',
+    category: 'productivity',
+    icon: 'notes',
+    tools: ['obsidian_search', 'obsidian_read', 'obsidian_write', 'obsidian_daily', 'obsidian_list'],
+    config: [
+        {
+            name: 'vaultPath',
+            type: 'string',
+            description: 'Path to your Obsidian vault folder',
+            required: true,
+        },
+    ],
+};
+const obsidianSkill = {
+    manifest,
+    tools: [searchNotesTool, readNoteTool, writeNoteTool, dailyNoteTool, listNotesTool],
+    async initialize(config) {
+        vaultPath = config.vaultPath || '';
+        console.log(`[Obsidian] Initialized with vault: ${vaultPath}`);
+    },
+    async shutdown() {
+        vaultPath = '';
+        console.log('[Obsidian] Shutdown');
+    },
+};
+exports.default = obsidianSkill;