obsidian-mcp-server 1.5.0 → 1.5.2

package/src/resources/tags.ts

@@ -4,6 +4,7 @@
 import { Resource, TextContent } from "@modelcontextprotocol/sdk/types.js";
 import { ObsidianClient } from "../obsidian/client.js";
 import { JsonLogicQuery } from "../obsidian/types.js";
+import pLimit from 'p-limit'; // Import p-limit
 import { PropertyManager } from "../tools/properties/manager.js";
 import { join, sep } from "path";
 import { createLogger, ErrorCategoryType } from "../utils/logging.js";
@@ -40,6 +41,7 @@ export class TagResource {
   private tagCache: Map<string, Set<string>> = new Map();
   private propertyManager: PropertyManager;
   private isInitialized = false;
+  private isUpdating = false; // Flag to prevent concurrent updates
   private lastUpdate = 0;
   private updateInterval = 5000; // 5 seconds
 
@@ -77,24 +79,46 @@ export class TagResource {
       const results = await this.client.searchJson(query);
       this.tagCache.clear();
 
-      // Process each file
-      for (const result of results) {
-        if (!('filename' in result)) continue;
-        
-        try {
-          const content = await this.client.getFileContents(result.filename);
-          
-          // Only extract tags from frontmatter YAML
-          const properties = this.propertyManager.parseProperties(content);
-          if (properties.tags) {
-            properties.tags.forEach((tag: string) => {
-              this.addTag(tag, result.filename);
+      // Create a limiter with a concurrency of 3 (reduced from 10)
+      const limit = pLimit(3); 
+
+      // Create promises for processing each file with concurrency limiting
+      const processingPromises = results
+        .filter(result => 'filename' in result) // Ensure filename exists
+        .map((result) => limit(async () => { // Wrap the async function with the limiter
+          const filename = result.filename;
+          try {
+            // This call is now rate-limited
+            const content = await this.client.getFileContents(filename); 
+            // Only extract tags from frontmatter YAML
+            const properties = this.propertyManager.parseProperties(content);
+            return { filename, tags: properties.tags || [] };
+          } catch (error) {
+            logger.error(`Failed to process file ${filename}:`, errorToObject(error));
+            return { filename, error: true }; // Mark as failed
+          }
+        })); // Close the limiter wrapper
+
+      // Execute promises in parallel and wait for all to settle
+      const processedResults = await Promise.allSettled(processingPromises);
+
+      // Populate the cache from settled results
+      processedResults.forEach(settledResult => {
+        // Check if the promise was fulfilled and didn't encounter a processing error
+        if (settledResult.status === 'fulfilled' && !settledResult.value.error) {
+          const { filename, tags } = settledResult.value;
+          // Ensure tags is an array before iterating
+          if (tags && Array.isArray(tags)) {
+            tags.forEach((tag: string) => {
+              this.addTag(tag, filename);
             });
           }
-        } catch (error) {
-          logger.error(`Failed to process file ${result.filename}:`, errorToObject(error));
-        }
-      }
+        } else if (settledResult.status === 'rejected') {
+          // Log unexpected rejections from the async map function itself
+          logger.error(`Unexpected error during file processing setup:`, errorToObject(settledResult.reason));
+        } 
+        // Errors during getFileContents/parseProperties are already logged within the map function
+      });
 
       this.isInitialized = true;
       this.lastUpdate = Date.now();
@@ -125,13 +149,47 @@ export class TagResource {
   }
 
   /**
-   * Update the cache if needed
+   * Update the cache if needed, preventing race conditions.
    */
   private async updateCacheIfNeeded() {
     const now = Date.now();
-    if (now - this.lastUpdate > this.updateInterval) {
-      logger.debug('Tag cache needs update, refreshing...');
-      await this.initializeCache();
+    // Check if cache is fresh enough
+    if (now - this.lastUpdate <= this.updateInterval) {
+      return; // Cache is up-to-date
+    }
+
+    // Check if an update is already in progress
+    if (this.isUpdating) {
+      logger.debug('Cache update already in progress, skipping redundant update.');
+      // Optionally, wait for the ongoing update instead of returning immediately
+      // For now, we return to avoid complexity, potentially serving slightly stale data.
+      return; 
+    }
+
+    // Acquire the update lock
+    this.isUpdating = true;
+    logger.debug('Acquired cache update lock.');
+
+    try {
+      // Double-check the update condition after acquiring the lock
+      // to handle cases where another process finished updating
+      // while this one was waiting for the lock (though less likely with a simple flag).
+      const nowAfterLock = Date.now();
+      if (nowAfterLock - this.lastUpdate > this.updateInterval) {
+        logger.info('Tag cache needs update, refreshing...');
+        await this.initializeCache(); // This method updates this.lastUpdate internally
+      } else {
+        logger.debug('Cache was updated by another process while waiting for lock.');
+      }
+    } catch (error) {
+      // Log error during update, but don't necessarily block other operations
+      logger.error('Error during cache update:', errorToObject(error));
+      // Decide if the error should be re-thrown or handled gracefully
+      // For now, we log and continue, allowing the lock to be released.
+    } finally {
+      // Release the update lock
+      this.isUpdating = false;
+      logger.debug('Released cache update lock.');
     }
   }
 
@@ -191,4 +249,4 @@ export class TagResource {
       throw error;
     }
   }
-}
+}

package/src/tools/properties/manager.ts

@@ -37,24 +37,33 @@ export class PropertyManager {
       }
 
       const frontmatter = match[1];
-      const properties = parse(frontmatter);
-      
-      // Handle tags - don't add # prefix in frontmatter
-      if (properties.tags && Array.isArray(properties.tags)) {
-        properties.tags = properties.tags.map((tag: string) =>
-          tag.startsWith('#') ? tag.substring(1) : tag
-        );
+      // Parse YAML first
+      const rawProperties = parse(frontmatter);
+
+      // Validate the raw parsed object against the schema
+      const validationResult = ObsidianPropertiesSchema.safeParse(rawProperties);
+
+      if (!validationResult.success) {
+        // Log validation errors and return empty if invalid
+        logger.warn('Frontmatter validation failed:', { 
+          validationError: validationResult.error.flatten() 
+        });
+        return {}; // Return empty object for invalid frontmatter
       }
 
-      // Validate against schema
-      const result = ObsidianPropertiesSchema.safeParse(properties);
-      if (!result.success) {
-        logger.warn('Property validation warnings:', { validationError: result.error });
-        // Return the properties with fixed tags
-        return properties;
+      // Use the validated data from now on
+      const validatedProperties = validationResult.data;
+
+      // Handle tags transformation on validated data
+      if (validatedProperties.tags && Array.isArray(validatedProperties.tags)) {
+        // Create a new array to avoid modifying the validated data directly if needed elsewhere
+        validatedProperties.tags = validatedProperties.tags.map((tag: string) =>
+          tag.startsWith('#') ? tag.substring(1) : tag
+        );
       }
 
-      return result.data;
+      // Return the validated (and potentially transformed) properties
+      return validatedProperties;
     } catch (error) {
       logger.error('Error parsing properties:', error instanceof Error ? error : { error: String(error) });
       return {};
@@ -230,4 +239,4 @@ export class PropertyManager {
       };
     }
   }
-}
+}

package/src/utils/idGenerator.ts

@@ -0,0 +1,22 @@
+import { nanoid } from 'nanoid';
+
+/**
+ * Generates a unique, URL-friendly, 6-character alphanumeric ID.
+ * Uses nanoid's default alphabet (A-Za-z0-9_-).
+ *
+ * @returns A 6-character string ID.
+ */
+export function generateShortId(): string {
+  return nanoid(6);
+}
+
+/**
+ * Generates a unique ID with a specified prefix and length.
+ *
+ * @param prefix - The prefix for the ID (e.g., 'prj', 'tsk', 'knw').
+ * @param length - The desired length of the random part of the ID (default: 10).
+ * @returns A prefixed ID string (e.g., 'prj_aBcDeFgHiJ').
+ */
+export function generatePrefixedId(prefix: string, length: number = 10): string {
+  return `${prefix}_${nanoid(length)}`;
+}

package/src/utils/tokenization.ts

@@ -13,22 +13,29 @@ export const TRUNCATION_MESSAGE = "\n\n[Response truncated due to length]";
 export class TokenCounter {
   private tokenizer = encoding_for_model("gpt-4"); // This is strictly for token counting, not for LLM inference
   private isShuttingDown = false;
+  private cleanupListener: () => void;
 
   constructor() {
-    // Clean up tokenizer when process exits
-    const cleanup = () => {
+    // Define the cleanup logic
+    this.cleanupListener = () => {
       if (!this.isShuttingDown) {
         this.isShuttingDown = true;
         if (this.tokenizer) {
           this.tokenizer.free();
+          // No need to explicitly set this.tokenizer to null,
+          // but ensure it's not used after free()
         }
+        // Remove listeners after execution to prevent multiple calls
+        // and potential leaks if cleanup is called manually before exit
+        this.removeListeners();
       }
     };
 
-    process.on('exit', cleanup);
-    process.on('SIGINT', cleanup);
-    process.on('SIGTERM', cleanup);
-    process.on('uncaughtException', cleanup);
+    // Attach listeners
+    process.on('exit', this.cleanupListener);
+    process.on('SIGINT', this.cleanupListener);
+    process.on('SIGTERM', this.cleanupListener);
+    process.on('uncaughtException', this.cleanupListener);
   }
 
   /**
@@ -57,15 +64,22 @@ export class TokenCounter {
   }
 
   /**
-   * Clean up resources
+   * Clean up resources and remove listeners
    */
   cleanup(): void {
-    if (this.tokenizer && !this.isShuttingDown) {
-      this.isShuttingDown = true;
-      this.tokenizer.free();
-    }
+    this.cleanupListener(); // Call the main cleanup logic
+  }
+
+  /**
+   * Remove process event listeners
+   */
+  private removeListeners(): void {
+    process.off('exit', this.cleanupListener);
+    process.off('SIGINT', this.cleanupListener);
+    process.off('SIGTERM', this.cleanupListener);
+    process.off('uncaughtException', this.cleanupListener);
   }
 }
 
 // Export a singleton instance
-export const tokenCounter = new TokenCounter();
+export const tokenCounter = new TokenCounter();

package/src/utils/validation.ts

@@ -1,6 +1,8 @@
 /**
  * Validation utilities for the Obsidian MCP Server
  */
+import { McpErrorCode } from "../mcp/types.js";
+import { ObsidianError } from "./errors.js";
 
 /**
  * Validates a file path to prevent path traversal attacks and other security issues
@@ -11,12 +13,20 @@ export function validateFilePath(filepath: string): void {
   // Prevent path traversal attacks
   const normalizedPath = filepath.replace(/\\/g, '/');
   if (normalizedPath.includes('../') || normalizedPath.includes('..\\')) {
-    throw new Error('Invalid file path: Path traversal not allowed');
+    // Use ObsidianError for consistency
+    throw new ObsidianError(
+      'Invalid file path: Path traversal not allowed',
+      McpErrorCode.BAD_REQUEST
+    );
   }
   
-  // Additional path validations
+  // Additional path validations (check for absolute paths Unix or Windows style)
   if (normalizedPath.startsWith('/') || /^[a-zA-Z]:/.test(normalizedPath)) {
-    throw new Error('Invalid file path: Absolute paths not allowed');
+     // Use ObsidianError for consistency
+     throw new ObsidianError(
+       'Invalid file path: Absolute paths not allowed',
+       McpErrorCode.BAD_REQUEST
+     );
   }
 }
 
@@ -92,4 +102,4 @@ export function validateToolArguments(args: unknown, schema: any): { valid: bool
   }
 
   return { valid: errors.length === 0, errors };
-}
+}

package/examples/README.md

@@ -1,48 +0,0 @@
-# Obsidian MCP Server Tool Examples
-
-This directory contains example requests and responses for each tool provided by the obsidian-mcp-server. These examples demonstrate the capabilities and expected output format of each tool.
-
-## Tools
-
-### 1. [List Files in Vault](list-files-in-vault.md)
-Lists all files and directories in the root directory of your Obsidian vault. Returns a hierarchical structure of files and folders, including metadata like file type.
-
-### 2. [List Files in Directory](list-files-in-dir.md)
-Lists all files and directories that exist in a specific Obsidian directory. Returns a hierarchical structure showing files, folders, and their relationships.
-
-### 3. [Get File Contents](get-file-contents.md)
-Return the content of a single file in your vault. Supports markdown files, text files, and other readable formats.
-
-### 4. [Find in File](find-in-file.md)
-Full-text search across all files in the vault. Returns matching files with surrounding context for each match.
-
-### 5. [Append Content](append-content.md)
-Append content to a new or existing file in the vault. Useful for adding new sections, notes, or updates to existing documents.
-
-### 6. [Patch Content](patch-content.md)
-Update the entire content of an existing note or create a new one. Provides complete control over file contents.
-
-### 7. [Complex Search](complex-search.md)
-File path pattern matching using JsonLogic queries. Supports operations like glob pattern matching and variable access.
-
-### 8. [Get Properties](get-properties.md)
-Get properties (title, tags, status, etc.) from an Obsidian note's YAML frontmatter. Returns all available properties including custom fields.
-
-### 9. [Update Properties](update-properties.md)
-Update properties in an Obsidian note's YAML frontmatter. Intelligently merges arrays and handles custom fields.
-
-## Resources
-
-### Direct Resources
-- obsidian://tags - List of all tags used across the Obsidian vault with their usage counts
-
-## Production Readiness
-
-All tools have been tested and demonstrate:
-- Proper input validation and error handling
-- Comprehensive and well-structured responses
-- Consistent output formatting
-- Practical applicability to real-world Obsidian vault management
-- Deep integration with Obsidian's features and capabilities
-
-The examples serve as both documentation and test cases, showing the expected behavior and quality of responses for each tool.

package/examples/append-content.md

@@ -1,63 +0,0 @@
-# Append Content Tool Example
-
-## Request 1 (Append to Existing Note)
-```json
-{
-  "filepath": "Projects/Project Alpha/Notes/Meeting Notes.md",
-  "content": "\n\n## Team Meeting - 2024-01-25\n\n### Discussion Points\n- Reviewed project timeline\n- Discussed technical challenges\n- Assigned new tasks\n\n### Action Items\n- [ ] Update documentation\n- [ ] Schedule follow-up meeting\n- [ ] Share progress report"
-}
-```
-
-## Response 1
-```json
-{
-  "success": true,
-  "message": "Content appended successfully"
-}
-```
-
-## Request 2 (Create New Note)
-```json
-{
-  "filepath": "Daily Notes/2024-01-25.md",
-  "content": "---\ntitle: Daily Note - January 25, 2024\ntags: [daily-notes]\ndate: 2024-01-25\n---\n\n# Daily Notes\n\n## Tasks\n- [ ] Review project updates\n- [ ] Team meeting at 2 PM\n- [ ] Update documentation\n\n## Notes\n- Started work on new feature\n- Discussed timeline with team\n- Reviewed technical specifications"
-}
-```
-
-## Response 2
-```json
-{
-  "success": true,
-  "message": "File created and content appended successfully"
-}
-```
-
-## Example Use Cases
-
-1. **Meeting Notes**
-   - Add new meeting minutes to existing notes
-   - Create structured meeting summaries
-   - Track action items and decisions
-
-2. **Daily Notes**
-   - Create daily journal entries
-   - Add to existing daily logs
-   - Maintain consistent note structure
-
-3. **Project Documentation**
-   - Add new sections to documentation
-   - Update progress logs
-   - Append new requirements or specifications
-
-## Notes
-- Can append to existing files or create new ones
-- Preserves existing content in the file
-- Maintains proper markdown formatting
-- Supports YAML frontmatter
-- Handles various content types:
-  * Meeting notes
-  * Daily logs
-  * Task lists
-  * Documentation updates
-- File path is relative to vault root
-- Creates parent directories if needed

package/examples/complex-search.md

@@ -1,117 +0,0 @@
-# Complex Search Tool Example
-
-## Request 1 (Simple Glob Pattern)
-```json
-{
-  "query": {
-    "glob": ["*.md", {"var": "path"}]
-  }
-}
-```
-
-## Response 1
-```json
-{
-  "matches": [
-    "README.md",
-    "Projects/Project Alpha/Documentation/Requirements.md",
-    "Daily Notes/2024-01-25.md",
-    "Templates/Meeting Note.md"
-  ]
-}
-```
-
-## Request 2 (Complex Pattern)
-```json
-{
-  "query": {
-    "and": [
-      {
-        "glob": ["Projects/**/*.md", {"var": "path"}]
-      },
-      {
-        "in": [
-          "Documentation",
-          {"var": "path"}
-        ]
-      }
-    ]
-  }
-}
-```
-
-## Response 2
-```json
-{
-  "matches": [
-    "Projects/Project Alpha/Documentation/Requirements.md",
-    "Projects/Project Alpha/Documentation/Architecture.md",
-    "Projects/Project Beta/Documentation/API.md"
-  ]
-}
-```
-
-## Example Use Cases
-
-1. **File Organization**
-   - Find files by pattern matching
-   - Filter by path components
-   - Combine multiple search criteria
-
-2. **Content Management**
-   - Locate files in specific directories
-   - Filter by file extensions
-   - Find files matching complex patterns
-
-3. **Project Navigation**
-   - Search within project directories
-   - Find documentation files
-   - Filter by file location
-
-## Notes
-- Uses JsonLogic for query construction
-- Supports glob pattern matching
-- Can combine multiple conditions
-- Available operations:
-  * glob: Pattern matching for paths
-  * var: Variable access (path)
-  * and/or: Logical operations
-  * in: Membership testing
-- Path is relative to vault root
-- Returns matching file paths
-- Useful for complex file filtering
-
-## Common Patterns
-
-1. **Find All Markdown Files**
-```json
-{
-  "glob": ["**/*.md", {"var": "path"}]
-}
-```
-
-2. **Files in Specific Directory**
-```json
-{
-  "glob": ["Projects/Project Alpha/**/*", {"var": "path"}]
-}
-```
-
-3. **Multiple Extensions**
-```json
-{
-  "or": [
-    {"glob": ["**/*.md", {"var": "path"}]},
-    {"glob": ["**/*.txt", {"var": "path"}]}
-  ]
-}
-```
-
-4. **Exclude Pattern**
-```json
-{
-  "and": [
-    {"glob": ["**/*.md", {"var": "path"}]},
-    {"not": {"glob": ["**/Archive/**", {"var": "path"}]}}
-  ]
-}

package/examples/find-in-file.md

@@ -1,94 +0,0 @@
-# Find in File Tool Example
-
-## Request 1 (Many Results)
-```json
-{
-  "query": "tags:",
-  "contextLength": 20
-}
-```
-
-## Response 1
-```json
-{
-  "message": "Found 34 files with matches. Showing file names only:",
-  "results": [
-    {
-      "filename": "Projects/Project Alpha/Documentation/Requirements.md",
-      "matchCount": 1
-    },
-    {
-      "filename": "Projects/Project Beta/Specifications.md",
-      "matchCount": 2
-    },
-    {
-      "filename": "Daily Notes/2024-01-25.md",
-      "matchCount": 1
-    }
-  ]
-}
-```
-
-## Request 2 (Few Results)
-```json
-{
-  "query": "priority: high",
-  "contextLength": 50
-}
-```
-
-## Response 2
-```json
-{
-  "results": [
-    {
-      "filename": "Projects/Project Alpha/tasks.md",
-      "matches": [
-        {
-          "line": 15,
-          "content": "---\ntitle: Critical Tasks\ntags: [tasks, urgent]\npriority: high\n---\n\n# High Priority Tasks",
-          "matchStart": 45,
-          "matchEnd": 57
-        }
-      ]
-    },
-    {
-      "filename": "Areas/Work/Deadlines.md",
-      "matches": [
-        {
-          "line": 8,
-          "content": "## Q1 Deliverables\n- [ ] Feature launch (priority: high)\n- [ ] Security audit",
-          "matchStart": 35,
-          "matchEnd": 47
-        }
-      ]
-    }
-  ]
-}
-```
-
-## Example Use Cases
-
-1. **Content Search**
-   - Find notes with specific tags or properties
-   - Search for keywords across the vault
-   - Locate specific metadata patterns
-
-2. **Task Management**
-   - Find high-priority tasks
-   - Search for incomplete items
-   - Locate notes with specific status
-
-3. **Knowledge Discovery**
-   - Find related content across notes
-   - Search for specific topics or references
-   - Identify patterns in note metadata
-
-## Notes
-- Returns either file list or detailed matches based on result count
-- Provides line numbers for precise location
-- Shows surrounding context for each match
-- Context length is customizable
-- Supports searching in frontmatter and note content
-- Results include match position information
-- Can search across all vault files