@mauricio.wolff/mcp-obsidian 0.4.1 → 0.5.1

package/dist/src/filesystem.js

@@ -0,0 +1,525 @@
+import { join, resolve, relative, dirname } from 'path';
+import { readdir, stat, readFile, writeFile, unlink, mkdir, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { FrontmatterHandler } from './frontmatter.js';
+import { PathFilter } from './pathfilter.js';
+export class FileSystemService {
+    vaultPath;
+    frontmatterHandler;
+    pathFilter;
+    constructor(vaultPath, pathFilter, frontmatterHandler) {
+        this.vaultPath = vaultPath;
+        this.vaultPath = resolve(vaultPath);
+        this.pathFilter = pathFilter || new PathFilter();
+        this.frontmatterHandler = frontmatterHandler || new FrontmatterHandler();
+    }
+    resolvePath(relativePath) {
+        // Handle undefined or null path
+        if (!relativePath) {
+            relativePath = '';
+        }
+        // Trim whitespace from path
+        relativePath = relativePath.trim();
+        // Normalize and resolve the path within the vault
+        const normalizedPath = relativePath.startsWith('/')
+            ? relativePath.slice(1)
+            : relativePath;
+        const fullPath = resolve(join(this.vaultPath, normalizedPath));
+        // Security check: ensure path is within vault
+        const relativeToVault = relative(this.vaultPath, fullPath);
+        if (relativeToVault.startsWith('..')) {
+            throw new Error(`Path traversal not allowed: ${relativePath}`);
+        }
+        return fullPath;
+    }
+    async readNote(path) {
+        const fullPath = this.resolvePath(path);
+        if (!this.pathFilter.isAllowed(path)) {
+            throw new Error(`Access denied: ${path}`);
+        }
+        // Check if the path is a directory first
+        const isDir = await this.isDirectory(path);
+        if (isDir) {
+            throw new Error(`Cannot read directory as file: ${path}. Use list_directory tool instead.`);
+        }
+        try {
+            try {
+                await access(fullPath, constants.F_OK);
+            }
+            catch {
+                throw new Error(`File not found: ${path}`);
+            }
+            const content = await readFile(fullPath, 'utf-8');
+            return this.frontmatterHandler.parse(content);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('File not found')) {
+                    throw error;
+                }
+                if (error.message.includes('permission') || error.message.includes('access')) {
+                    throw new Error(`Permission denied: ${path}`);
+                }
+                if (error.message.includes('Cannot read directory')) {
+                    throw error;
+                }
+            }
+            throw new Error(`Failed to read file: ${path} - ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async writeNote(params) {
+        const { path, content, frontmatter, mode = 'overwrite' } = params;
+        const fullPath = this.resolvePath(path);
+        if (!this.pathFilter.isAllowed(path)) {
+            throw new Error(`Access denied: ${path}`);
+        }
+        // Validate frontmatter if provided
+        if (frontmatter) {
+            const validation = this.frontmatterHandler.validate(frontmatter);
+            if (!validation.isValid) {
+                throw new Error(`Invalid frontmatter: ${validation.errors.join(', ')}`);
+            }
+        }
+        try {
+            let finalContent;
+            if (mode === 'overwrite') {
+                // Original behavior - replace entire content
+                finalContent = frontmatter
+                    ? this.frontmatterHandler.stringify(frontmatter, content)
+                    : content;
+            }
+            else {
+                // For append/prepend, we need to read existing content
+                let existingNote;
+                try {
+                    existingNote = await this.readNote(path);
+                }
+                catch (error) {
+                    // File doesn't exist, treat as overwrite
+                    finalContent = frontmatter
+                        ? this.frontmatterHandler.stringify(frontmatter, content)
+                        : content;
+                }
+                if (existingNote) {
+                    // Merge frontmatter if provided
+                    const mergedFrontmatter = frontmatter
+                        ? { ...existingNote.frontmatter, ...frontmatter }
+                        : existingNote.frontmatter;
+                    if (mode === 'append') {
+                        finalContent = this.frontmatterHandler.stringify(mergedFrontmatter, existingNote.content + content);
+                    }
+                    else if (mode === 'prepend') {
+                        finalContent = this.frontmatterHandler.stringify(mergedFrontmatter, content + existingNote.content);
+                    }
+                }
+            }
+            // Create directories if they don't exist
+            await mkdir(dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, finalContent, 'utf-8');
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('permission') || error.message.includes('access')) {
+                    throw new Error(`Permission denied: ${path}`);
+                }
+                if (error.message.includes('space') || error.message.includes('ENOSPC')) {
+                    throw new Error(`No space left on device: ${path}`);
+                }
+            }
+            throw new Error(`Failed to write file: ${path} - ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async listDirectory(path = '') {
+        const fullPath = this.resolvePath(path);
+        try {
+            const entries = await readdir(fullPath, { withFileTypes: true });
+            const files = [];
+            const directories = [];
+            for (const entry of entries) {
+                const entryPath = path ? `${path}/${entry.name}` : entry.name;
+                if (!this.pathFilter.isAllowed(entryPath)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    directories.push(entry.name);
+                }
+                else if (entry.isFile()) {
+                    files.push(entry.name);
+                }
+                // Skip other types (symlinks, etc.)
+            }
+            return {
+                files: files.sort(),
+                directories: directories.sort()
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('not found') || error.message.includes('ENOENT')) {
+                    throw new Error(`Directory not found: ${path}`);
+                }
+                if (error.message.includes('permission') || error.message.includes('access')) {
+                    throw new Error(`Permission denied: ${path}`);
+                }
+                if (error.message.includes('not a directory') || error.message.includes('ENOTDIR')) {
+                    throw new Error(`Not a directory: ${path}`);
+                }
+            }
+            throw new Error(`Failed to list directory: ${path} - ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async exists(path) {
+        const fullPath = this.resolvePath(path);
+        if (!this.pathFilter.isAllowed(path)) {
+            return false;
+        }
+        try {
+            await access(fullPath, constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async isDirectory(path) {
+        const fullPath = this.resolvePath(path);
+        if (!this.pathFilter.isAllowed(path)) {
+            return false;
+        }
+        try {
+            const stats = await stat(fullPath);
+            return stats.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    async deleteNote(params) {
+        const { path, confirmPath } = params;
+        // Confirmation check - paths must match exactly
+        if (path !== confirmPath) {
+            return {
+                success: false,
+                path: path,
+                message: "Deletion cancelled: confirmation path does not match. For safety, both 'path' and 'confirmPath' must be identical."
+            };
+        }
+        const fullPath = this.resolvePath(path);
+        if (!this.pathFilter.isAllowed(path)) {
+            return {
+                success: false,
+                path: path,
+                message: `Access denied: ${path}`
+            };
+        }
+        try {
+            // Check if it's a directory first (can't delete directories with this method)
+            const isDir = await this.isDirectory(path);
+            if (isDir) {
+                return {
+                    success: false,
+                    path: path,
+                    message: `Cannot delete: ${path} is not a file`
+                };
+            }
+            // Check if file exists
+            try {
+                await access(fullPath, constants.F_OK);
+            }
+            catch {
+                return {
+                    success: false,
+                    path: path,
+                    message: `File not found: ${path}`
+                };
+            }
+            // Perform the deletion using Node.js native API
+            await unlink(fullPath);
+            return {
+                success: true,
+                path: path,
+                message: `Successfully deleted note: ${path}. This action cannot be undone.`
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error) {
+                if (error.code === 'ENOENT') {
+                    return {
+                        success: false,
+                        path: path,
+                        message: `File not found: ${path}`
+                    };
+                }
+                if (error.code === 'EACCES') {
+                    return {
+                        success: false,
+                        path: path,
+                        message: `Permission denied: ${path}`
+                    };
+                }
+            }
+            return {
+                success: false,
+                path: path,
+                message: `Failed to delete file: ${path} - ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    async moveNote(params) {
+        const { oldPath, newPath, overwrite = false } = params;
+        if (!this.pathFilter.isAllowed(oldPath)) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Access denied: ${oldPath}`
+            };
+        }
+        if (!this.pathFilter.isAllowed(newPath)) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Access denied: ${newPath}`
+            };
+        }
+        const oldFullPath = this.resolvePath(oldPath);
+        const newFullPath = this.resolvePath(newPath);
+        try {
+            // Check if source file exists
+            try {
+                await access(oldFullPath, constants.F_OK);
+            }
+            catch {
+                return {
+                    success: false,
+                    oldPath,
+                    newPath,
+                    message: `Source file not found: ${oldPath}`
+                };
+            }
+            // Check if target already exists
+            let targetExists = false;
+            try {
+                await access(newFullPath, constants.F_OK);
+                targetExists = true;
+            }
+            catch {
+                // Target doesn't exist, which is fine
+            }
+            if (targetExists && !overwrite) {
+                return {
+                    success: false,
+                    oldPath,
+                    newPath,
+                    message: `Target file already exists: ${newPath}. Use overwrite=true to replace it.`
+                };
+            }
+            // Read source content
+            const content = await readFile(oldFullPath, 'utf-8');
+            // Write to new location (create directories if they don't exist)
+            await mkdir(dirname(newFullPath), { recursive: true });
+            await writeFile(newFullPath, content, 'utf-8');
+            // Verify the write was successful
+            try {
+                await access(newFullPath, constants.F_OK);
+            }
+            catch {
+                return {
+                    success: false,
+                    oldPath,
+                    newPath,
+                    message: `Failed to create target file: ${newPath}`
+                };
+            }
+            // Delete the source file
+            await unlink(oldFullPath);
+            return {
+                success: true,
+                oldPath,
+                newPath,
+                message: `Successfully moved note from ${oldPath} to ${newPath}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                oldPath,
+                newPath,
+                message: `Failed to move note: ${error instanceof Error ? error.message : 'Unknown error'}`
+            };
+        }
+    }
+    async readMultipleNotes(params) {
+        const { paths, includeContent = true, includeFrontmatter = true } = params;
+        if (paths.length > 10) {
+            throw new Error('Maximum 10 files per batch read request');
+        }
+        const results = await Promise.allSettled(paths.map(async (path) => {
+            if (!this.pathFilter.isAllowed(path)) {
+                throw new Error(`Access denied: ${path}`);
+            }
+            const note = await this.readNote(path);
+            const result = { path };
+            if (includeFrontmatter) {
+                result.frontmatter = note.frontmatter;
+            }
+            if (includeContent) {
+                result.content = note.content;
+            }
+            return result;
+        }));
+        const successful = [];
+        const failed = [];
+        results.forEach((result, index) => {
+            if (result.status === 'fulfilled') {
+                successful.push(result.value);
+            }
+            else {
+                failed.push({
+                    path: paths[index] || '',
+                    error: result.reason instanceof Error ? result.reason.message : 'Unknown error'
+                });
+            }
+        });
+        return { successful, failed };
+    }
+    async updateFrontmatter(params) {
+        const { path, frontmatter, merge = true } = params;
+        if (!this.pathFilter.isAllowed(path)) {
+            throw new Error(`Access denied: ${path}`);
+        }
+        // Read the existing note
+        const note = await this.readNote(path);
+        // Prepare new frontmatter
+        const newFrontmatter = merge
+            ? { ...note.frontmatter, ...frontmatter }
+            : frontmatter;
+        // Validate the new frontmatter
+        const validation = this.frontmatterHandler.validate(newFrontmatter);
+        if (!validation.isValid) {
+            throw new Error(`Invalid frontmatter: ${validation.errors.join(', ')}`);
+        }
+        // Update the note with new frontmatter, preserving content
+        await this.writeNote({
+            path,
+            content: note.content,
+            frontmatter: newFrontmatter
+        });
+    }
+    async getNotesInfo(paths) {
+        const results = await Promise.allSettled(paths.map(async (path) => {
+            if (!this.pathFilter.isAllowed(path)) {
+                throw new Error(`Access denied: ${path}`);
+            }
+            const fullPath = this.resolvePath(path);
+            try {
+                await access(fullPath, constants.F_OK);
+            }
+            catch {
+                throw new Error(`File not found: ${path}`);
+            }
+            const stats = await stat(fullPath);
+            const size = stats.size;
+            const lastModified = stats.mtime.getTime();
+            // Quick check for frontmatter without reading full content
+            const file = await readFile(fullPath, 'utf-8');
+            const firstChunk = file.slice(0, 100);
+            const hasFrontmatter = firstChunk.startsWith('---\n');
+            return {
+                path,
+                size,
+                modified: lastModified,
+                hasFrontmatter
+            };
+        }));
+        // Return only successful results, filter out failed ones
+        return results
+            .filter((result) => result.status === 'fulfilled')
+            .map(result => result.value);
+    }
+    async manageTags(params) {
+        const { path, operation, tags = [] } = params;
+        if (!this.pathFilter.isAllowed(path)) {
+            return {
+                path,
+                operation,
+                tags: [],
+                success: false,
+                message: `Access denied: ${path}`
+            };
+        }
+        try {
+            const note = await this.readNote(path);
+            let currentTags = [];
+            // Extract tags from frontmatter
+            if (note.frontmatter.tags) {
+                if (Array.isArray(note.frontmatter.tags)) {
+                    currentTags = note.frontmatter.tags;
+                }
+                else if (typeof note.frontmatter.tags === 'string') {
+                    currentTags = [note.frontmatter.tags];
+                }
+            }
+            // Also extract inline tags from content
+            const inlineTagMatches = note.content.match(/#[a-zA-Z0-9_-]+/g) || [];
+            const inlineTags = inlineTagMatches.map(tag => tag.slice(1)); // Remove #
+            currentTags = [...new Set([...currentTags, ...inlineTags])]; // Deduplicate
+            if (operation === 'list') {
+                return {
+                    path,
+                    operation,
+                    tags: currentTags,
+                    success: true
+                };
+            }
+            let newTags = [...currentTags];
+            if (operation === 'add') {
+                for (const tag of tags) {
+                    if (!newTags.includes(tag)) {
+                        newTags.push(tag);
+                    }
+                }
+            }
+            else if (operation === 'remove') {
+                newTags = newTags.filter(tag => !tags.includes(tag));
+            }
+            // Update frontmatter with new tags
+            const updatedFrontmatter = {
+                ...note.frontmatter
+            };
+            if (newTags.length > 0) {
+                updatedFrontmatter.tags = newTags;
+            }
+            else if ('tags' in updatedFrontmatter) {
+                delete updatedFrontmatter.tags;
+            }
+            // Write back the note with updated frontmatter
+            await this.writeNote({
+                path,
+                content: note.content,
+                frontmatter: updatedFrontmatter,
+                mode: 'overwrite'
+            });
+            return {
+                path,
+                operation,
+                tags: newTags,
+                success: true,
+                message: `Successfully ${operation === 'add' ? 'added' : 'removed'} tags`
+            };
+        }
+        catch (error) {
+            return {
+                path,
+                operation,
+                tags: [],
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    getVaultPath() {
+        return this.vaultPath;
+    }
+}

package/dist/src/frontmatter.js

@@ -0,0 +1,104 @@
+import matter from 'gray-matter';
+import * as yaml from 'js-yaml';
+export class FrontmatterHandler {
+    parse(content) {
+        try {
+            const parsed = matter(content);
+            return {
+                frontmatter: parsed.data,
+                content: parsed.content,
+                originalContent: content
+            };
+        }
+        catch (error) {
+            // If parsing fails, treat as content without frontmatter
+            return {
+                frontmatter: {},
+                content: content,
+                originalContent: content
+            };
+        }
+    }
+    stringify(frontmatterData, content) {
+        try {
+            // If no frontmatter, return content as-is
+            if (!frontmatterData || Object.keys(frontmatterData).length === 0) {
+                return content;
+            }
+            return matter.stringify(content, frontmatterData);
+        }
+        catch (error) {
+            throw new Error(`Failed to stringify frontmatter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    validate(frontmatterData) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: []
+        };
+        try {
+            // Test if the frontmatter can be serialized to valid YAML using js-yaml
+            yaml.dump(frontmatterData);
+        }
+        catch (error) {
+            result.isValid = false;
+            result.errors.push(`Invalid YAML structure: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Check for problematic values
+        this.checkForProblematicValues(frontmatterData, result, '');
+        return result;
+    }
+    checkForProblematicValues(obj, result, path) {
+        if (obj === null || obj === undefined) {
+            return;
+        }
+        if (typeof obj === 'function') {
+            result.errors.push(`Functions are not allowed in frontmatter at path: ${path}`);
+            result.isValid = false;
+            return;
+        }
+        if (typeof obj === 'symbol') {
+            result.errors.push(`Symbols are not allowed in frontmatter at path: ${path}`);
+            result.isValid = false;
+            return;
+        }
+        if (obj instanceof Date) {
+            // Dates are fine, but warn if they're invalid
+            if (isNaN(obj.getTime())) {
+                result.warnings.push(`Invalid date at path: ${path}`);
+            }
+            return;
+        }
+        if (Array.isArray(obj)) {
+            obj.forEach((item, index) => {
+                this.checkForProblematicValues(item, result, `${path}[${index}]`);
+            });
+            return;
+        }
+        if (typeof obj === 'object' && obj !== null) {
+            for (const [key, value] of Object.entries(obj)) {
+                const currentPath = path ? `${path}.${key}` : key;
+                // Check for problematic keys
+                if (typeof key !== 'string') {
+                    result.errors.push(`Non-string keys are not allowed: ${key}`);
+                    result.isValid = false;
+                }
+                this.checkForProblematicValues(value, result, currentPath);
+            }
+        }
+    }
+    extractFrontmatter(content) {
+        const parsed = this.parse(content);
+        return parsed.frontmatter;
+    }
+    updateFrontmatter(content, updates) {
+        const parsed = this.parse(content);
+        const updatedFrontmatter = { ...parsed.frontmatter, ...updates };
+        const validation = this.validate(updatedFrontmatter);
+        if (!validation.isValid) {
+            throw new Error(`Invalid frontmatter: ${validation.errors.join(', ')}`);
+        }
+        return this.stringify(updatedFrontmatter, parsed.content);
+    }
+}

package/dist/src/pathfilter.js

@@ -0,0 +1,57 @@
+export class PathFilter {
+    ignoredPatterns;
+    allowedExtensions;
+    constructor(config) {
+        this.ignoredPatterns = [
+            '.obsidian/**',
+            '.git/**',
+            'node_modules/**',
+            '.DS_Store',
+            'Thumbs.db',
+            ...config?.ignoredPatterns || []
+        ];
+        this.allowedExtensions = [
+            '.md',
+            '.markdown',
+            '.txt',
+            ...config?.allowedExtensions || []
+        ];
+    }
+    simpleGlobMatch(pattern, path) {
+        // Convert glob pattern to regex
+        // Handle ** (any number of directories)
+        let regexPattern = pattern
+            .replace(/\*\*/g, '.*') // ** matches any number of directories
+            .replace(/\*/g, '[^/]*') // * matches anything except /
+            .replace(/\?/g, '[^/]') // ? matches single character except /
+            .replace(/\./g, '\\.'); // Escape dots
+        // Ensure we match the full path
+        regexPattern = '^' + regexPattern + '$';
+        const regex = new RegExp(regexPattern);
+        return regex.test(path);
+    }
+    isAllowed(path) {
+        // Normalize path separators
+        const normalizedPath = path.replace(/\\/g, '/');
+        // Check if path matches any ignored pattern
+        for (const pattern of this.ignoredPatterns) {
+            if (this.simpleGlobMatch(pattern, normalizedPath)) {
+                return false;
+            }
+        }
+        // For files, check extension if allowedExtensions is configured
+        if (this.allowedExtensions.length > 0 && this.isFile(normalizedPath)) {
+            const hasAllowedExtension = this.allowedExtensions.some(ext => normalizedPath.toLowerCase().endsWith(ext.toLowerCase()));
+            if (!hasAllowedExtension) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isFile(path) {
+        return path.includes('.') && !path.endsWith('/');
+    }
+    filterPaths(paths) {
+        return paths.filter(path => this.isAllowed(path));
+    }
+}