obsidian-mcp-server 1.5.7 → 2.0.1

package/src/obsidian/errors.ts

@@ -1,105 +0,0 @@
-/**
- * Error handling for Obsidian client
- */
-import { AxiosError } from "axios";
-import type { ApiError } from '../utils/errors.js';
-import { ObsidianError, getErrorCodeFromStatus } from '../utils/errors.js';
-
-/**
- * Helper function to create a descriptive error message for SSL certificate issues
- */
-export function createSSLErrorMessage(error: Error, config: { verifySSL: boolean }): string {
-  return (
-    `SSL certificate verification failed. You have two options:\n\n` +
-    `Option 1 - Enable HTTP (not recommended for production):\n` +
-    `1. Go to Obsidian Settings > Local REST API\n` +
-    `2. Enable "Enable Non-encrypted (HTTP) Server"\n` +
-    `3. Update your client config to use "http" protocol\n\n` +
-    `Option 2 - Configure HTTPS (recommended):\n` +
-    `1. Go to Obsidian Settings > Local REST API\n` +
-    `2. Under 'How to Access', copy the certificate\n` +
-    `3. Add the certificate to your system's trusted certificates:\n` +
-    `   - On macOS: Add to Keychain Access\n` +
-    `   - On Windows: Add to Certificate Manager\n` +
-    `   - On Linux: Add to ca-certificates\n` +
-    `   For development only: Set verifySSL: false in client config\n\n` +
-    `Original error: ${error.message}`
-  );
-}
-
-/**
- * Helper function to create a descriptive error message for connection refused issues
- */
-export function createConnectionRefusedMessage(host: string, port: number): string {
-  return (
-    `Connection refused. To fix this:\n` +
-    `1. Ensure Obsidian is running\n` +
-    `2. Verify the 'Local REST API' plugin is enabled in Obsidian Settings\n` +
-    `3. Check that you're using the correct host (${host}) and port (${port})\n` +
-    `4. Make sure HTTPS is enabled in the plugin settings`
-  );
-}
-
-/**
- * Helper function to create a descriptive error message for authentication failures
- */
-export function createAuthFailedMessage(): string {
-  return (
-    `Authentication failed. To fix this:\n` +
-    `1. Go to Obsidian Settings > Local REST API\n` +
-    `2. Copy your API key from the settings\n` +
-    `3. Update your configuration with the new API key\n` +
-    `Note: The API key changes when you regenerate certificates`
-  );
-}
-
-/**
- * Helper function to create a descriptive error message for missing API key
- */
-export function createMissingAPIKeyMessage(): string {
-  return (
-    `Missing API key. To fix this:\n` +
-    `1. Install the 'Local REST API' plugin in Obsidian\n` +
-    `2. Enable the plugin in Obsidian Settings\n` +
-    `3. Copy your API key from Obsidian Settings > Local REST API\n` +
-    `4. Provide the API key in your configuration`
-  );
-}
-
-/**
- * Helper function to handle Axios errors consistently
- */
-export function handleAxiosError(error: AxiosError<ApiError>, host: string, port: number): ObsidianError {
-  const response = error.response;
-  const errorData = response?.data;
-    
-  // Handle common connection errors with helpful messages
-  if (error.code === 'DEPTH_ZERO_SELF_SIGNED_CERT' || error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
-    return new ObsidianError(
-      createSSLErrorMessage(error, { verifySSL: true }),
-      50001, // SSL error code
-      { code: error.code }
-    );
-  }
-
-  if (error.code === 'ECONNREFUSED') {
-    return new ObsidianError(
-      createConnectionRefusedMessage(host, port),
-      50002, // Connection refused
-      { code: error.code }
-    );
-  }
-
-  if (response?.status === 401) {
-    return new ObsidianError(
-      createAuthFailedMessage(),
-      40100, // Unauthorized
-      { code: error.code }
-    );
-  }
-
-  // For other errors, use API error code if available
-  const errorCode = errorData?.errorCode ?? getErrorCodeFromStatus(response?.status ?? 500);
-  const message = errorData?.message ?? error.message ?? "Unknown error";
-  return new ObsidianError(message, errorCode, errorData);
-}

package/src/obsidian/index.ts

@@ -1,7 +0,0 @@
-/**
- * Exports for the Obsidian module
- */
-export * from './client.js';
-export * from './errors.js';
-export * from './types.js';
-

package/src/obsidian/types.ts

@@ -1,124 +0,0 @@
-/**
- * Type definitions for Obsidian client
- */
-
-/**
- * Configuration for the Obsidian client
- */
-export interface ObsidianConfig {
-  apiKey: string;
-  verifySSL?: boolean;
-  timeout?: number;
-  maxContentLength?: number;
-  maxBodyLength?: number;
-}
-
-/**
- * Server configuration for Obsidian
- */
-export interface ObsidianServerConfig {
-  protocol: "http" | "https";
-  host: string;
-  port: number;
-}
-
-/**
- * Default configuration for Obsidian server
- */
-export const DEFAULT_OBSIDIAN_CONFIG: ObsidianServerConfig = {
-  protocol: "https", // HTTPS required by default in Obsidian REST API plugin
-  host: "127.0.0.1",
-  port: 27124
-} as const;
-
-/**
- * JSON representation of an Obsidian note
- */
-export interface NoteJson {
-  content: string;
-  frontmatter: Record<string, unknown>;
-  path: string;
-  stat: {
-    ctime: number;
-    mtime: number;
-    size: number;
-  };
-  tags: string[];
-}
-
-/**
- * Obsidian file/folder information
- */
-export interface ObsidianFile {
-  path: string;
-  type: "file" | "folder";
-  children?: ObsidianFile[];
-}
-
-/**
- * Obsidian command
- */
-export interface ObsidianCommand {
-  id: string;
-  name: string;
-}
-
-/**
- * Obsidian server status
- */
-export interface ObsidianStatus {
-  authenticated: boolean;
-  ok: string;
-  service: string;
-  versions: {
-    obsidian: string;
-    self: string;
-  };
-}
-
-/**
- * Period type for periodic notes
- */
-export interface PeriodType {
-  type: "daily" | "weekly" | "monthly" | "quarterly" | "yearly";
-}
-
-/**
- * Search match with context
- */
-export interface SearchMatch {
-  context: string;
-  match: {
-    start: number;
-    end: number;
-  };
-}
-
-/**
- * Standard search result
- */
-export interface SearchResult {
-  filename: string;
-  result: unknown;
-}
-
-/**
- * Simple search result with context
- */
-export interface SimpleSearchResult {
-  filename: string;
-  score: number;
-  matches: SearchMatch[];
-}
-
-/**
- * Union type for search responses
- */
-export type SearchResponse = SearchResult | SimpleSearchResult;
-
-/**
- * JSON Logic query for complex searches
- */
-export interface JsonLogicQuery {
-  [operator: string]: unknown;
-}

package/src/resources/index.ts

@@ -1,17 +0,0 @@
-/**
- * Resources module exports
- */
-export * from './tags.js';
-export * from './types.js';
-
-import { ObsidianClient } from '../obsidian/client.js';
-import { TagResource } from './tags.js';
-
-/**
- * Create and return the tag resource
- * @param client The ObsidianClient instance
- * @returns The tag resource
- */
-export function createTagResource(client: ObsidianClient): TagResource {
-  return new TagResource(client);
-}

package/src/resources/tags.ts

@@ -1,283 +0,0 @@
-/**
- * Tag resource implementation
- */
-import { Resource, TextContent } from "@modelcontextprotocol/sdk/types.js";
-import pLimit from 'p-limit'; // Import p-limit
-import { sep } from "path";
-import { ObsidianClient } from "../obsidian/client.js";
-import { JsonLogicQuery } from "../obsidian/types.js";
-import { PropertyManager } from "../tools/properties/manager.js";
-import { createLogger, ErrorCategoryType } from "../utils/logging.js";
-import { TagResponse } from "./types.js";
-
-// Create a logger for tag resources
-const logger = createLogger('TagResource');
-
-/**
- * Helper function to safely convert any error to an object
- */
-function errorToObject(error: unknown): Record<string, unknown> {
-  if (error instanceof Error) {
-    return {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-      errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
-    };
-  } else if (typeof error === 'object' && error !== null) {
-    return error as Record<string, unknown>;
-  } else {
-    return { 
-      error: String(error),
-      errorCategory: ErrorCategoryType.CATEGORY_UNKNOWN
-    };
-  }
-}
-
-/**
- * Resource for providing tags used in the Obsidian vault
- */
-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
-
-  constructor(private client: ObsidianClient) {
-    this.propertyManager = new PropertyManager(client);
-    this.initializeCache();
-  }
-
-  /**
-   * Get resource description for the MCP server
-   */
-  getResourceDescription(): Resource {
-    return {
-      uri: "obsidian://tags",
-      name: "Obsidian Tags",
-      description: "List of all tags used across the Obsidian vault with their usage counts",
-      mimeType: "application/json"
-    };
-  }
-
-  /**
-   * Initialize the tag cache
-   */
-  private async initializeCache() {
-    logger.startTimer('init_tag_cache');
-    
-    try {
-      logger.info('Initializing tag cache');
-      
-      // Get all markdown files using platform-agnostic path pattern
-      const query: JsonLogicQuery = {
-        "glob": [`**${sep}*.md`.replace(/\\/g, '/'), { "var": "path" }]
-      };
-      
-      const results = await this.client.searchJson(query);
-      this.tagCache.clear();
-
-      // 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 parseResult = this.propertyManager.parseProperties(content);
-            // Handle potential parsing errors before accessing properties
-            if (parseResult.error) {
-              logger.warn(`Skipping tags for ${filename} due to parsing error: ${parseResult.error.message}`);
-              return { filename, tags: [] }; // Return empty tags on error
-            }
-            return { filename, tags: parseResult.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);
-            });
-          }
-        } 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();
-      
-      const elapsedMs = logger.endTimer('init_tag_cache');
-      logger.logOperationResult(true, 'initialize_tag_cache', elapsedMs, {
-        tagCount: this.tagCache.size,
-        fileCount: results.length
-      });
-      
-      logger.info(`Tag cache initialized with ${this.tagCache.size} unique tags`);
-    } catch (error) {
-      const elapsedMs = logger.endTimer('init_tag_cache');
-      logger.logOperationResult(false, 'initialize_tag_cache', elapsedMs);
-      logger.error("Failed to initialize tag cache:", errorToObject(error));
-      throw error;
-    }
-  }
-
-  /**
-   * Add a tag to the cache
-   */
-  private addTag(tag: string, filepath: string) {
-    if (!this.tagCache.has(tag)) {
-      this.tagCache.set(tag, new Set());
-    }
-    this.tagCache.get(tag)!.add(filepath);
-  }
-
-  /**
-   * Update the cache if needed, preventing race conditions.
-   */
-  private async updateCacheIfNeeded() {
-    const now = Date.now();
-    // 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.');
-    }
-  }
-
-  /**
-   * Get the content for the resource, optionally filtering by path.
-   * Note: The path filtering logic assumes the tool handler passes the path correctly.
-   */
-  // TODO: Verify how the path argument is passed from the tool handler
-  async getContent(filterPath?: string): Promise<TextContent[]> { 
-    logger.startTimer('get_tags_content');
-    
-    try {
-      if (!this.isInitialized) {
-        logger.info('Tag cache not initialized, initializing now');
-        await this.initializeCache();
-      } else {
-        await this.updateCacheIfNeeded();
-      }
-
-      let filteredTagEntries: { name: string; files: Set<string> }[] = [];
-
-      // Filter tags based on the provided path
-      if (filterPath) {
-        // Normalize path to ensure it ends with a separator for accurate startsWith check
-        const normalizedFilterPath = filterPath.endsWith(sep) ? filterPath : filterPath + sep;
-        logger.debug(`Filtering tags for path: ${normalizedFilterPath}`);
-        
-        filteredTagEntries = Array.from(this.tagCache.entries())
-          .map(([name, files]) => {
-            // Filter files within each tag entry
-            const relevantFiles = Array.from(files).filter(file => file.startsWith(normalizedFilterPath));
-            return { name, files: new Set(relevantFiles) };
-          })
-          .filter(tagEntry => tagEntry.files.size > 0); // Keep only tags that exist in the filtered path
-          
-        logger.debug(`Found ${filteredTagEntries.length} tags after filtering.`);
-      } else {
-        // If no path provided, use all tags from the cache
-        filteredTagEntries = Array.from(this.tagCache.entries()).map(([name, files]) => ({ name, files }));
-      }
-
-      const response: TagResponse = {
-        tags: filteredTagEntries
-          .map(({ name, files }) => ({ // Map from the potentially filtered structure
-            name,
-            count: files.size,
-            files: Array.from(files).sort()
-          }))
-          .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name)), // Sort filtered results
-        metadata: {
-          // Note: Metadata currently reflects the entire vault cache, even when filtered.
-          // Adjust calculation here if path-specific metadata is desired.
-          totalOccurrences: Array.from(this.tagCache.values()) 
-            .reduce((sum, files) => sum + files.size, 0),
-          uniqueTags: this.tagCache.size,
-          scannedFiles: new Set(
-            Array.from(this.tagCache.values())
-              .flatMap(files => Array.from(files))
-          ).size,
-          lastUpdate: this.lastUpdate
-        }
-      };
-
-      logger.debug(`Returning tag resource with ${response.tags.length} tags`);
-      
-      const elapsedMs = logger.endTimer('get_tags_content');
-      logger.logOperationResult(true, 'get_tags', elapsedMs, {
-        tagCount: response.tags.length,
-        totalOccurrences: response.metadata.totalOccurrences,
-        uniqueTags: response.metadata.uniqueTags,
-        scannedFiles: response.metadata.scannedFiles
-      });
-      
-      return [{
-        type: "text",
-        text: JSON.stringify(response, null, 2),
-        uri: this.getResourceDescription().uri
-      }];
-    } catch (error) {
-      const elapsedMs = logger.endTimer('get_tags_content');
-      logger.logOperationResult(false, 'get_tags', elapsedMs);
-      logger.error("Failed to get tags:", errorToObject(error));
-      throw error;
-    }
-  }
-}

package/src/resources/types.ts

@@ -1,30 +0,0 @@
-/**
- * Resource types for the MCP server
- */
-
-/**
- * Tag information structure
- */
-export interface TagInfo {
-  name: string;
-  count: number;
-  files: string[];
-}
-
-/**
- * Tag metadata structure
- */
-export interface TagMetadata {
-  totalOccurrences: number;
-  uniqueTags: number;
-  scannedFiles: number;
-  lastUpdate: number;  // Timestamp of last cache update
-}
-
-/**
- * Tag resource response structure
- */
-export interface TagResponse {
-  tags: TagInfo[];
-  metadata: TagMetadata;
-}

package/src/tools/base.ts

@@ -1,123 +0,0 @@
-/**
- * Base class for all tool handlers
- */
-import { TextContent, Tool } from "@modelcontextprotocol/sdk/types.js";
-import { McpErrorCode } from "../mcp/types.js";
-import { ObsidianClient } from "../obsidian/client.js";
-import { ObsidianError } from "../utils/errors.js";
-import { createLogger, ErrorCategoryType } from "../utils/logging.js";
-import { tokenCounter } from "../utils/tokenization.js";
-
-// Create a logger for tool operations
-const logger = createLogger('Tools');
-
-/**
- * Interface that all tool handlers must implement
- */
-export interface ToolHandler<T = any> {
-  name: string;
-  getToolDescription(): Tool;
-  runTool(args: T): Promise<Array<TextContent>>;
-}
-
-/**
- * Base class for all tool handlers with common functionality
- */
-export abstract class BaseToolHandler<T = Record<string, unknown>> implements ToolHandler<T> {
-  /**
-   * Create a new tool handler
-   * @param name The name of the tool
-   * @param client The ObsidianClient instance
-   */
-  constructor(
-    public readonly name: string,
-    protected client: ObsidianClient
-  ) {}
-
-  /**
-   * Get the tool description for MCP server
-   */
-  abstract getToolDescription(): Tool;
-
-  /**
-   * Run the tool with the provided arguments
-   */
-  abstract runTool(args: T): Promise<Array<TextContent>>;
-
-  /**
-   * Create a standardized response from any content type
-   * @param content The content to format for response
-   * @returns An array of TextContent objects
-   */
-  protected createResponse(content: unknown): TextContent[] {
-    let text: string;
-
-    // Handle different content types
-    if (typeof content === 'string') {
-      text = content;
-    } else if (content instanceof Buffer) {
-      text = content.toString('utf-8');
-    } else if (Array.isArray(content) && content.every(item => typeof item === 'string')) {
-      text = content.join('\n');
-    } else if (content instanceof Error) {
-      text = `Error: ${content.message}\n${content.stack || ''}`;
-    } else {
-      try {
-        text = JSON.stringify(content, null, 2);
-      } catch (error) {
-        text = String(content);
-      }
-    }
-
-    // Count tokens and truncate if necessary
-    const originalTokenCount = tokenCounter.countTokens(text);
-    const truncatedText = tokenCounter.truncateToTokenLimit(text);
-    const finalTokenCount = tokenCounter.countTokens(truncatedText);
-    
-    if (originalTokenCount > finalTokenCount) {
-      logger.debug(`[${this.name}] Response truncated`, {
-        toolName: this.name,
-        originalTokens: originalTokenCount,
-        truncatedTokens: finalTokenCount,
-        truncationPercent: Math.round((1 - finalTokenCount / originalTokenCount) * 100)
-      });
-    }
-    
-    return [{
-      type: "text",
-      text: truncatedText
-    }];
-  }
-
-  /**
-   * Standard error handling for tool execution
-   * @param error The error to handle
-   * @throws ObsidianError
-   */
-  protected handleError(error: unknown): never {
-    if (error instanceof ObsidianError) {
-      throw error;
-    }
-    
-    logger.error(`Tool '${this.name}' execution failed`, {
-      toolName: this.name,
-      errorMessage: error instanceof Error ? error.message : String(error),
-      errorStack: error instanceof Error ? error.stack : undefined,
-      errorCategory: ErrorCategoryType.CATEGORY_SYSTEM
-    });
-    
-    if (error instanceof Error) {
-      throw new ObsidianError(
-        `Tool '${this.name}' execution failed: ${error.message}`,
-        McpErrorCode.INTERNAL_SERVER_ERROR,
-        { originalError: error.stack }
-      );
-    }
-    
-    throw new ObsidianError(
-      `Tool '${this.name}' execution failed with unknown error`,
-      McpErrorCode.INTERNAL_SERVER_ERROR,
-      { error: String(error) }
-    );
-  }
-}