apexbot 1.0.1 → 1.0.4

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;