obsidian-mcp-server 1.3.0 → 1.4.0

package/build/{propertyTypes.js → tools/properties/types.js}

@@ -1,14 +1,24 @@
+/**
+ * Property types and schemas for Obsidian notes
+ */
 import { z } from "zod";
-// Define validation schemas
-// Allow any string for type to be more flexible
+/**
+ * Define validation schemas
+ * Allow any string for type to be more flexible
+ */
 export const PropertyType = z.string();
+/**
+ * Valid status values for notes
+ */
 export const StatusEnum = z.enum([
     "draft",
     "in-progress",
     "review",
     "complete"
 ]);
-// Schema for reading properties (includes timestamps)
+/**
+ * Schema for reading properties (includes timestamps)
+ */
 export const ObsidianPropertiesSchema = z.object({
     // Basic Metadata
     // Note: Timestamps are managed automatically
@@ -32,7 +42,9 @@ export const ObsidianPropertiesSchema = z.object({
     // Custom Fields
     custom: z.record(z.unknown()).optional()
 });
-// Schema for validating property updates (excludes timestamps)
+/**
+ * Schema for validating property updates (excludes timestamps)
+ */
 export const PropertyUpdateSchema = z.object({
     // Basic Metadata
     title: z.string().optional(),
@@ -54,4 +66,4 @@ export const PropertyUpdateSchema = z.object({
     // Custom Fields
     custom: z.record(z.unknown()).optional()
 });
-//# sourceMappingURL=propertyTypes.js.map
+//# sourceMappingURL=types.js.map

package/build/tools/search/complex.js

@@ -0,0 +1,203 @@
+import { PropertyManager } from "../properties/manager.js";
+import { BaseToolHandler } from "../base.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for complex search operations
+const logger = createLogger('ComplexSearchTools');
+/**
+ * Tool name for complex search
+ */
+export const COMPLEX_SEARCH_TOOL_NAME = "obsidian_complex_search";
+/**
+ * Tool handler for complex JsonLogic searches
+ */
+export class ComplexSearchToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(COMPLEX_SEARCH_TOOL_NAME, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "File path pattern matching using JsonLogic queries. Supported operations:\n- glob: Pattern matching for paths (e.g., \"*.md\")\n- Variable access: {\"var\": \"path\"}\n\nNote: For full-text content search, date-based searches, or other advanced queries, use obsidian_find_in_file instead.",
+            examples: [
+                {
+                    description: "Find markdown files in Projects folder",
+                    args: {
+                        query: {
+                            "glob": ["Projects/*.md", { "var": "path" }]
+                        }
+                    }
+                },
+                {
+                    description: "Find files in a specific subfolder",
+                    args: {
+                        query: {
+                            "glob": ["**/Test/*.md", { "var": "path" }]
+                        }
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "object",
+                        description: "JsonLogic query object. Example: {\"glob\": [\"*.md\", {\"var\": \"path\"}]} matches all markdown files"
+                    }
+                },
+                required: ["query"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Executing complex search with query: ${JSON.stringify(args.query)}`);
+            // Perform search
+            const results = await this.client.searchJson(args.query);
+            // Format response based on result type
+            const formattedResults = results.map(result => {
+                if ('matches' in result) {
+                    // SimpleSearchResult
+                    return {
+                        filename: result.filename,
+                        matches: result.matches,
+                        score: result.score
+                    };
+                }
+                else {
+                    // SearchResult
+                    return {
+                        filename: result.filename,
+                        result: result.result
+                    };
+                }
+            });
+            logger.debug(`Complex search found ${results.length} results`);
+            return this.createResponse({
+                message: `Found ${results.length} result(s)`,
+                results: formattedResults
+            });
+        }
+        catch (error) {
+            logger.error(`Complex search error: ${error}`);
+            return this.handleError(error);
+        }
+    }
+}
+/**
+ * Tool handler for getting all tags used in the vault
+ */
+export class GetTagsToolHandler extends BaseToolHandler {
+    propertyManager;
+    constructor(client) {
+        super("obsidian_get_tags", client);
+        this.propertyManager = new PropertyManager(client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Get all tags used across the Obsidian vault with their usage counts. Optionally filter tags within a specific folder.",
+            examples: [
+                {
+                    description: "Get all tags in vault",
+                    args: {}
+                },
+                {
+                    description: "Get tags in Projects folder",
+                    args: {
+                        path: "Projects"
+                    }
+                },
+                {
+                    description: "Example response",
+                    args: {},
+                    response: {
+                        "tags": [
+                            {
+                                "name": "project",
+                                "count": 15,
+                                "files": [
+                                    "Projects/ProjectA.md",
+                                    "Projects/ProjectB.md"
+                                ]
+                            }
+                        ],
+                        "metadata": {
+                            "totalOccurrences": 45,
+                            "uniqueTags": 12,
+                            "scannedFiles": 30
+                        }
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Optional path to limit tag search to specific folder",
+                        format: "path"
+                    }
+                }
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Getting tags${args.path ? ` in path: ${args.path}` : ' in whole vault'}`);
+            const tagMap = new Map();
+            // Use searchJson to find files with .md extension
+            const query = args.path
+                ? { "glob": [`${args.path}/**/*.md`.replace(/\\/g, '/'), { "var": "path" }] }
+                : { "glob": ["**/*.md", { "var": "path" }] };
+            const results = await this.client.searchJson(query);
+            let scannedFiles = 0;
+            // Process each file to extract tags from frontmatter
+            for (const result of results) {
+                if (!('filename' in result))
+                    continue;
+                try {
+                    const content = await this.client.getFileContents(result.filename);
+                    scannedFiles++;
+                    // Use PropertyManager to properly parse frontmatter
+                    const properties = this.propertyManager.parseProperties(content);
+                    // Process tags if they exist
+                    if (properties.tags && Array.isArray(properties.tags)) {
+                        // Process each tag
+                        for (const tag of properties.tags) {
+                            const cleanTag = tag.replace(/^#/, ''); // Remove leading # if present
+                            if (!tagMap.has(cleanTag)) {
+                                tagMap.set(cleanTag, new Set());
+                            }
+                            tagMap.get(cleanTag).add(result.filename);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error(`Failed to process file ${result.filename}:`, error);
+                }
+            }
+            // Calculate total occurrences
+            const totalOccurrences = Array.from(tagMap.values())
+                .reduce((sum, files) => sum + files.size, 0);
+            return this.createResponse({
+                tags: Array.from(tagMap.entries())
+                    .map(([name, files]) => ({
+                    name,
+                    count: files.size,
+                    files: Array.from(files).sort()
+                }))
+                    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)),
+                metadata: {
+                    totalOccurrences,
+                    uniqueTags: tagMap.size,
+                    scannedFiles,
+                    lastUpdate: Date.now()
+                }
+            });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+//# sourceMappingURL=complex.js.map

package/build/tools/search/index.js

@@ -0,0 +1,20 @@
+/**
+ * Search tools exports
+ */
+export * from './simple.js';
+export * from './complex.js';
+import { FindInFileToolHandler } from './simple.js';
+import { ComplexSearchToolHandler, GetTagsToolHandler } from './complex.js';
+/**
+ * Create all search-related tool handlers
+ * @param client The ObsidianClient instance
+ * @returns Array of search tool handlers
+ */
+export function createSearchToolHandlers(client) {
+    return [
+        new FindInFileToolHandler(client),
+        new ComplexSearchToolHandler(client),
+        new GetTagsToolHandler(client)
+    ];
+}
+//# sourceMappingURL=index.js.map

package/build/tools/search/simple.js

@@ -0,0 +1,127 @@
+import { BaseToolHandler } from "../base.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for search operations
+const logger = createLogger('SimpleSearchTools');
+/**
+ * Tool name for simple search
+ */
+export const SIMPLE_SEARCH_TOOL_NAME = "obsidian_find_in_file";
+/**
+ * Tool handler for simple text search across files
+ */
+export class FindInFileToolHandler extends BaseToolHandler {
+    constructor(client) {
+        super(SIMPLE_SEARCH_TOOL_NAME, client);
+    }
+    getToolDescription() {
+        return {
+            name: this.name,
+            description: "Full-text search across all files in the vault. Returns matching files with surrounding context for each match. For results with more than 5 matching files, returns only file names and match counts to prevent overwhelming responses. Useful for finding specific content, references, or patterns across notes.",
+            examples: [
+                {
+                    description: "Search for a specific term",
+                    args: {
+                        query: "neural networks",
+                        contextLength: 20
+                    }
+                },
+                {
+                    description: "Search with default context",
+                    args: {
+                        query: "#todo"
+                    },
+                    response: {
+                        "message": "Found 1 file with matches:",
+                        "results": [
+                            {
+                                "filename": "Projects/AI.md",
+                                "matches": [
+                                    {
+                                        "context": "Research needed:\n#todo Implement transformer architecture\nDeadline: Next week",
+                                        "match": { "start": 15, "end": 45 }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    description: "Example response with many matches (file-only format)",
+                    args: {
+                        query: "API"
+                    },
+                    response: {
+                        "message": "Found 92 files with matches. Showing file names only:",
+                        "results": [
+                            {
+                                "filename": "Developer/Documentation/API.md",
+                                "matchCount": 43
+                            },
+                            {
+                                "filename": "Projects/API_Design.md",
+                                "matchCount": 34
+                            }
+                        ]
+                    }
+                }
+            ],
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Text pattern to search for. Can include tags, keywords, or phrases."
+                    },
+                    contextLength: {
+                        type: "integer",
+                        description: "Number of characters to include before and after each match for context (default: 10)",
+                        default: 10
+                    }
+                },
+                required: ["query"]
+            }
+        };
+    }
+    async runTool(args) {
+        try {
+            logger.debug(`Searching for "${args.query}" with context length: ${args.contextLength || 100}`);
+            const results = await this.client.search(args.query, args.contextLength ?? 100);
+            // If more than 5 results, only return filenames and match counts to prevent overwhelming responses
+            if (results.length > 5) {
+                const fileOnlyResults = results.map(result => ({
+                    filename: result.filename,
+                    matchCount: result.matches.length
+                }));
+                logger.debug(`Found ${results.length} files with matches, returning file-only format`);
+                return this.createResponse({
+                    message: `Found ${results.length} files with matches. Showing file names only:`,
+                    results: fileOnlyResults
+                });
+            }
+            // Otherwise return full context as before
+            const formattedResults = results.map(result => ({
+                filename: result.filename,
+                matches: result.matches.map(match => ({
+                    context: match.context,
+                    match: {
+                        text: match.context.substring(match.match.start, match.match.end),
+                        position: {
+                            start: match.match.start,
+                            end: match.match.end
+                        }
+                    }
+                })),
+                score: result.score
+            }));
+            logger.debug(`Found ${results.length} files with matches, returning with context`);
+            return this.createResponse({
+                message: `Found ${results.length} file(s) with matches:`,
+                results: formattedResults
+            });
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+}
+//# sourceMappingURL=simple.js.map

package/build/utils/errors.js

@@ -0,0 +1,59 @@
+/**
+ * Error handling utilities for the Obsidian MCP Server
+ */
+/**
+ * Error class for Obsidian MCP Server specific errors
+ */
+export class ObsidianError extends Error {
+    details;
+    errorCode;
+    constructor(message, errorCode = 50000, // Default server error code
+    details) {
+        super(message);
+        this.details = details;
+        this.name = "ObsidianError";
+        // Ensure 5-digit error code
+        if (errorCode < 10000 || errorCode > 99999) {
+            // Convert HTTP status codes to 5-digit codes
+            // 4xx -> 4xxxx
+            // 5xx -> 5xxxx
+            this.errorCode = errorCode < 1000 ? errorCode * 100 : 50000;
+        }
+        else {
+            this.errorCode = errorCode;
+        }
+    }
+    // Convert to API error format
+    toApiError() {
+        return {
+            errorCode: this.errorCode,
+            message: this.message
+        };
+    }
+}
+/**
+ * Maps HTTP status codes to internal error codes
+ */
+export function getErrorCodeFromStatus(status) {
+    switch (status) {
+        case 400: return 40000; // Bad request
+        case 401: return 40100; // Unauthorized
+        case 403: return 40300; // Forbidden
+        case 404: return 40400; // Not found
+        case 405: return 40500; // Method not allowed
+        case 409: return 40900; // Conflict
+        case 429: return 42900; // Too many requests
+        case 500: return 50000; // Internal server error
+        case 501: return 50100; // Not implemented
+        case 502: return 50200; // Bad gateway
+        case 503: return 50300; // Service unavailable
+        case 504: return 50400; // Gateway timeout
+        default:
+            if (status >= 400 && status < 500)
+                return 40000 + (status - 400) * 100;
+            if (status >= 500 && status < 600)
+                return 50000 + (status - 500) * 100;
+            return 50000;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/build/utils/index.js

@@ -0,0 +1,9 @@
+/**
+ * Exports all utility functions and classes
+ */
+export * from './errors.js';
+export * from './logging.js';
+export * from './rate-limiting.js';
+export * from './tokenization.js';
+export * from './validation.js';
+//# sourceMappingURL=index.js.map

package/build/utils/logging.js

@@ -0,0 +1,119 @@
+/**
+ * Logging utilities for the Obsidian MCP Server
+ */
+/**
+ * Log levels
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Default logger configuration
+ */
+const DEFAULT_CONFIG = {
+    level: process.env.NODE_ENV === 'production'
+        ? LogLevel.INFO
+        : LogLevel.DEBUG,
+    includeTimestamps: true,
+    includeLevel: true
+};
+/**
+ * Simple logger for MCP server operations
+ */
+export class Logger {
+    name;
+    config;
+    constructor(name, config = {}) {
+        this.name = name;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Internal method to format and output a log message
+     */
+    log(level, message, ...args) {
+        if (level > this.config.level)
+            return;
+        const parts = [];
+        // Add timestamp if configured
+        if (this.config.includeTimestamps) {
+            parts.push(`[${new Date().toISOString()}]`);
+        }
+        // Add level if configured
+        if (this.config.includeLevel) {
+            const levelStr = LogLevel[level] || 'UNKNOWN';
+            parts.push(`[${levelStr}]`);
+        }
+        // Add component name
+        parts.push(`[${this.name}]`);
+        // Add message
+        parts.push(message);
+        // Output to console
+        const output = parts.join(' ');
+        switch (level) {
+            case LogLevel.ERROR:
+                console.error(output, ...args);
+                break;
+            case LogLevel.WARN:
+                console.warn(output, ...args);
+                break;
+            case LogLevel.INFO:
+                console.info(output, ...args);
+                break;
+            case LogLevel.DEBUG:
+            case LogLevel.TRACE:
+            default:
+                console.debug(output, ...args);
+                break;
+        }
+    }
+    /**
+     * Log an error message
+     */
+    error(message, ...args) {
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+    /**
+     * Log a warning message
+     */
+    warn(message, ...args) {
+        this.log(LogLevel.WARN, message, ...args);
+    }
+    /**
+     * Log an info message
+     */
+    info(message, ...args) {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+    /**
+     * Log a debug message
+     */
+    debug(message, ...args) {
+        this.log(LogLevel.DEBUG, message, ...args);
+    }
+    /**
+     * Log a trace message
+     */
+    trace(message, ...args) {
+        this.log(LogLevel.TRACE, message, ...args);
+    }
+    /**
+     * Set the log level
+     */
+    setLevel(level) {
+        this.config.level = level;
+    }
+}
+/**
+ * Create and return a namespaced logger
+ */
+export function createLogger(name, config) {
+    return new Logger(name, config);
+}
+// Create a global root logger
+export const rootLogger = createLogger('mcp-server');
+//# sourceMappingURL=logging.js.map

package/build/utils/rate-limiting.js

@@ -0,0 +1,94 @@
+/**
+ * Rate limiting utilities for the Obsidian MCP Server
+ */
+import { ObsidianError } from './errors.js';
+/**
+ * Default rate limit configuration
+ */
+export const DEFAULT_RATE_LIMIT_CONFIG = {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    maxRequests: 200
+};
+/**
+ * RateLimit manages request rate limiting for API endpoints
+ */
+export class RateLimiter {
+    config;
+    requestCounts = new Map();
+    cleanupInterval;
+    constructor(config = DEFAULT_RATE_LIMIT_CONFIG) {
+        this.config = config;
+        // Clean up expired rate limit entries periodically
+        this.cleanupInterval = setInterval(() => this.cleanup(), 60000); // Clean up every minute
+    }
+    /**
+     * Check if a request is within rate limits
+     * @param key Identifier for the rate limit bucket (e.g., toolName)
+     * @returns Whether the request is allowed
+     */
+    checkRateLimit(key) {
+        const now = Date.now();
+        const requestInfo = this.requestCounts.get(key);
+        if (!requestInfo || now > requestInfo.resetTime) {
+            // Reset counter for new window
+            this.requestCounts.set(key, {
+                count: 1,
+                resetTime: now + this.config.windowMs
+            });
+            return true;
+        }
+        if (requestInfo.count >= this.config.maxRequests) {
+            return false;
+        }
+        requestInfo.count++;
+        return true;
+    }
+    /**
+     * Check rate limit and throw an error if exceeded
+     * @param key Identifier for the rate limit bucket
+     * @throws ObsidianError if rate limit is exceeded
+     */
+    enforceRateLimit(key) {
+        if (!this.checkRateLimit(key)) {
+            throw new ObsidianError(`Rate limit exceeded for ${key}. Please try again later.`, 42900 // 42900 = Rate limit exceeded
+            );
+        }
+    }
+    /**
+     * Get information about current rate limit status
+     * @param key Identifier for the rate limit bucket
+     * @returns Rate limit information or null if no requests have been made
+     */
+    getRateLimitInfo(key) {
+        const requestInfo = this.requestCounts.get(key);
+        if (!requestInfo) {
+            return null;
+        }
+        return {
+            remaining: Math.max(0, this.config.maxRequests - requestInfo.count),
+            resetTime: requestInfo.resetTime
+        };
+    }
+    /**
+     * Clean up expired rate limit entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, info] of this.requestCounts.entries()) {
+            if (now > info.resetTime) {
+                this.requestCounts.delete(key);
+            }
+        }
+    }
+    /**
+     * Clean up resources (e.g., when shutting down)
+     */
+    dispose() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+    }
+}
+// Export a singleton instance with default configuration
+export const rateLimiter = new RateLimiter();
+//# sourceMappingURL=rate-limiting.js.map