obsidian-mcp-server 1.2.6 → 1.4.0

package/build/{properties.js → tools/properties/manager.js}

@@ -1,5 +1,15 @@
+/**
+ * Property manager for Obsidian notes
+ */
 import { parse, stringify } from 'yaml';
-import { ObsidianPropertiesSchema, PropertyUpdateSchema } from './propertyTypes.js';
+import { EOL } from 'os';
+import { createLogger } from '../../utils/logging.js';
+import { ObsidianPropertiesSchema, PropertyUpdateSchema } from './types.js';
+// Create a logger for property operations
+const logger = createLogger('PropertyManager');
+/**
+ * Manages YAML frontmatter properties in Obsidian notes
+ */
 export class PropertyManager {
     client;
     constructor(client) {
@@ -7,48 +17,59 @@ export class PropertyManager {
     }
     /**
      * Parse YAML frontmatter from note content
+     * @param content The note content
+     * @returns Extracted properties
      */
     parseProperties(content) {
         try {
-            // Extract frontmatter between --- markers
-            const match = content.match(/^---\n([\s\S]*?)\n---/);
+            // Extract frontmatter between --- markers (handles both \n and \r\n)
+            const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
             if (!match) {
+                logger.debug('No frontmatter found in content');
                 return {};
             }
             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) => tag.startsWith('#') ? tag.substring(1) : tag);
+            }
             // Validate against schema
             const result = ObsidianPropertiesSchema.safeParse(properties);
             if (!result.success) {
-                console.warn('Property validation warnings:', result.error);
-                // Return partial valid properties rather than throwing
+                logger.warn('Property validation warnings:', result.error);
+                // Return the properties with fixed tags
                 return properties;
             }
             return result.data;
         }
         catch (error) {
-            console.error('Error parsing properties:', error);
+            logger.error('Error parsing properties:', error);
             return {};
         }
     }
     /**
      * Generate YAML frontmatter from properties
+     * @param properties The properties to convert to YAML
+     * @returns YAML frontmatter string
      */
     generateProperties(properties) {
         try {
             // Remove undefined values
             const cleanProperties = Object.fromEntries(Object.entries(properties).filter(([_, v]) => v !== undefined));
-            // Generate YAML
+            // Generate YAML with platform-specific line endings
             const yaml = stringify(cleanProperties);
-            return `---\n${yaml}---\n`;
+            return `---${EOL}${yaml}---${EOL}`;
         }
         catch (error) {
-            console.error('Error generating properties:', error);
+            logger.error('Error generating properties:', error);
             throw error;
         }
     }
     /**
-     * Validate property values
+     * Validate property values against schema
+     * @param properties The properties to validate
+     * @returns Validation result
      */
     validateProperties(properties) {
         const result = PropertyUpdateSchema.safeParse(properties);
@@ -62,6 +83,10 @@ export class PropertyManager {
     }
     /**
      * Merge new properties with existing ones
+     * @param existing The existing properties
+     * @param updates The new properties to merge
+     * @param replace Whether to replace arrays instead of merging them
+     * @returns The merged properties
      */
     mergeProperties(existing, updates, replace = false) {
         const merged = { ...existing };
@@ -94,9 +119,12 @@ export class PropertyManager {
     }
     /**
      * Get properties from a note
+     * @param filepath Path to the note
+     * @returns The properties from the note
      */
     async getProperties(filepath) {
         try {
+            logger.debug(`Getting properties from file: ${filepath}`);
             const content = await this.client.getFileContents(filepath);
             const properties = this.parseProperties(content);
             return {
@@ -106,6 +134,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
+            logger.error(`Failed to get properties from ${filepath}:`, error);
             return {
                 success: false,
                 message: `Failed to get properties: ${error instanceof Error ? error.message : String(error)}`,
@@ -115,12 +144,17 @@ export class PropertyManager {
     }
     /**
      * Update properties of a note
+     * @param filepath Path to the note
+     * @param newProperties The new properties to apply
+     * @param replace Whether to replace arrays instead of merging them
+     * @returns The result of the update operation
      */
     async updateProperties(filepath, newProperties, replace = false) {
         try {
             // Validate new properties
             const validation = this.validateProperties(newProperties);
             if (!validation.valid) {
+                logger.warn(`Invalid properties for ${filepath}:`, validation.errors);
                 return {
                     success: false,
                     message: 'Invalid properties',
@@ -128,17 +162,19 @@ export class PropertyManager {
                 };
             }
             // Get existing content and properties
+            logger.debug(`Updating properties for file: ${filepath}`);
             const content = await this.client.getFileContents(filepath);
             const existingProperties = this.parseProperties(content);
             // Merge properties
             const mergedProperties = this.mergeProperties(existingProperties, newProperties, replace);
             // Generate new frontmatter
             const newFrontmatter = this.generateProperties(mergedProperties);
-            // Replace existing frontmatter or prepend to file
-            const newContent = content.replace(/^---[\s\S]*?---\n/, '') || '';
+            // Replace existing frontmatter or prepend to file (handles both \n and \r\n)
+            const newContent = content.replace(/^---[\s\S]*?---\r?\n/, '') || '';
             const updatedContent = newFrontmatter + newContent;
             // Update file
             await this.client.updateContent(filepath, updatedContent);
+            logger.debug(`Successfully updated properties for ${filepath}`);
             return {
                 success: true,
                 message: 'Properties updated successfully',
@@ -146,6 +182,7 @@ export class PropertyManager {
             };
         }
         catch (error) {
+            logger.error(`Failed to update properties for ${filepath}:`, error);
             return {
                 success: false,
                 message: `Failed to update properties: ${error instanceof Error ? error.message : String(error)}`,
@@ -154,4 +191,4 @@ export class PropertyManager {
         }
     }
 }
-//# sourceMappingURL=properties.js.map
+//# sourceMappingURL=manager.js.map

package/build/{propertyTools.js → tools/properties/tools.js}

@@ -1,13 +1,22 @@
-import { BaseToolHandler } from "./tools.js";
-import { PropertyManager } from "./properties.js";
-const TOOL_NAMES = {
+import { BaseToolHandler } from "../base.js";
+import { PropertyManager } from "./manager.js";
+import { createLogger } from "../../utils/logging.js";
+// Create a logger for property tools
+const logger = createLogger('PropertyTools');
+/**
+ * Tool names for property operations
+ */
+export const PROPERTY_TOOL_NAMES = {
     GET_PROPERTIES: "obsidian_get_properties",
     UPDATE_PROPERTIES: "obsidian_update_properties"
 };
+/**
+ * Tool handler for getting properties from a note
+ */
 export class GetPropertiesToolHandler extends BaseToolHandler {
     propertyManager;
     constructor(client) {
-        super(TOOL_NAMES.GET_PROPERTIES, client);
+        super(PROPERTY_TOOL_NAMES.GET_PROPERTIES, client);
         this.propertyManager = new PropertyManager(client);
     }
     getToolDescription() {
@@ -43,18 +52,23 @@ export class GetPropertiesToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
+            logger.debug(`Getting properties from: ${args.filepath}`);
             const result = await this.propertyManager.getProperties(args.filepath);
             return this.createResponse(result);
         }
         catch (error) {
+            logger.error(`Error getting properties from ${args.filepath}:`, error);
             return this.handleError(error);
         }
     }
 }
+/**
+ * Tool handler for updating properties in a note
+ */
 export class UpdatePropertiesToolHandler extends BaseToolHandler {
     propertyManager;
     constructor(client) {
-        super(TOOL_NAMES.UPDATE_PROPERTIES, client);
+        super(PROPERTY_TOOL_NAMES.UPDATE_PROPERTIES, client);
         this.propertyManager = new PropertyManager(client);
     }
     getToolDescription() {
@@ -164,12 +178,14 @@ export class UpdatePropertiesToolHandler extends BaseToolHandler {
     }
     async runTool(args) {
         try {
+            logger.debug(`Updating properties for: ${args.filepath}`);
             const result = await this.propertyManager.updateProperties(args.filepath, args.properties, args.replace);
             return this.createResponse(result);
         }
         catch (error) {
+            logger.error(`Error updating properties for ${args.filepath}:`, error);
             return this.handleError(error);
         }
     }
 }
-//# sourceMappingURL=propertyTools.js.map
+//# sourceMappingURL=tools.js.map

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
@@ -18,7 +28,7 @@ export const ObsidianPropertiesSchema = z.object({
     // Classification
     type: z.array(PropertyType).optional(),
     // Organization
-    tags: z.array(z.string().startsWith("#")).optional(),
+    tags: z.array(z.string()).optional(),
     // Technical Metadata
     status: z.array(StatusEnum).optional(),
     version: z.string().optional(),
@@ -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(),
@@ -40,7 +52,7 @@ export const PropertyUpdateSchema = z.object({
     // Classification
     type: z.array(PropertyType).optional(),
     // Organization
-    tags: z.array(z.string().startsWith("#")).optional(),
+    tags: z.array(z.string()).optional(),
     // Technical Metadata
     status: z.array(StatusEnum).optional(),
     version: 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