triliumnext-mcp 0.3.10 → 0.3.12

package/README.md

@@ -1,188 +1,150 @@
-# TriliumNext Notes' MCP Server
-
-⚠️ **DISCLAIMER: This is a prototype for https://github.com/TriliumNext/Notes/issues/705. Suggested only for developer use. Please backup your Trilium notes before using this tool.** ⚠️
-
-A model context protocol server for TriliumNext Notes. This server provides tools to interact with your Trilium Notes instance through MCP.
-
-## Quick Start
-
-Make sure to set up your environment variables first:
-- `TRILIUM_API_URL` (default: http://localhost:8080/etapi)
-- `TRILIUM_API_TOKEN` (required, get this from your Trilium Notes settings)
-- `PERMISSIONS` (optional, default='READ;WRITE', where READ let this MCP has permissions to perform `search_notes` and `get_note` operation and WRITE let this MCP has permissions to perform `create_note`, `update_note` and `delete_note` operations) 
-- `VERBOSE` (optional, default='false', where if true it will print out some logging response and pass the logs into LLM (such as API call) which is useful for developers to debug this MCP)
-
-## Installation
-
-### 1. Using with Claude Desktop 
-
-Add the server config to your Claude Desktop configuration file:
-
-Add the following configuration to the `mcpServers` object in your Claude configuration file:
-
-
-#### For Local Installation (on Windows)
-
-```json
-"triliumnext-mcp": {
-  "command": "cmd",
-  "args": [
-        "/k",
-        "npx",
-        "-y",
-        "triliumnext-mcp"
-      ],
-   "env": {
-    "TRILIUM_API_URL": "http://localhost:8080/etapi",
-    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
-    "PERMISSIONS": "READ;WRITE"
-  }
-}
-```
-
-#### For Local installation (on Linux)
-
-```json
-"triliumnext-mcp": {
-  "command": "npx",
-  "args": [
-        "-y",
-        "triliumnext-mcp"
-      ],
-   "env": {
-    "TRILIUM_API_URL": "http://localhost:8080/etapi",
-    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
-    "PERMISSIONS": "READ;WRITE"
-  }
-}
-```
-
-#### For Development (on Windows / Linux)
-
-```bash
-cd /path/to/triliumnext-mcp
-npm run build
-```
-
-```json
-"triliumnext-mcp": {
-  "command": "node",
-  "args": [
-        "/path/to/triliumnext-mcp/build/index.js"
-  ],
-  "env": {
-    "TRILIUM_API_URL": "http://localhost:8080/etapi",
-    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
-    "PERMISSIONS": "READ;WRITE",
-    "VERBOSE": "true"
-  }
-}
-```
-
-
-Location of the configuration file:
-- Windows: `%APPDATA%/Claude/claude_desktop_config.json`
-- MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
-
-
-**Feedback**: Please report issues and test results at [GitHub Issues](https://github.com/TriliumNext/Notes/issues)
-
-
-## Available Tools
-
-The server provides the following tools for note management:
-
-### Search Tools
-
-- `search_notes` - Unified search with comprehensive filtering capabilities
-  - **Unified Architecture**: Uses `searchCriteria` parameter for complete boolean logic expressiveness
-  - **Cross-type OR logic**: Combine labels, relations, note properties, and hierarchy navigation with OR/AND logic
-  - **Parameters**: `text` (keyword search), `searchCriteria` (unified array structure), `limit`
-  - **Smart optimization**: Automatically uses fastSearch when only text parameter is provided
-  - **Complete filtering**: Supports labels (#book), relations (~author.title), note properties (title, content, dateCreated), hierarchy navigation (parents.*, children.*, ancestors.*)
-  - **Navigation support**: Use hierarchy properties like `parents.noteId` for direct children, `ancestors.noteId` for all descendants
-
-- `resolve_note_id` - Find note ID by name/title for LLM-friendly workflows
-  - **Simple title-based search**: Uses fuzzy search to find notes by title/name
-  - **Smart prioritization**: Exact matches → folder-type notes → most recent
-  - **User choice workflow**: When multiple matches found, presents options for user selection
-  - **Configurable results**: `maxResults` parameter (default: 3, range: 1-10)
-  - **JSON response format**: Returns structured data with selectedNote, totalMatches, and nextSteps guidance
-  - **Essential workflow**: resolve name → get ID → use with other tools
-
-### Note Discovery Tools
-
-- `search_notes` - Advanced search with unified filtering capabilities including hierarchy navigation
-  - **Complex queries**: Use for sophisticated filtering with multiple criteria
-  - **Boolean logic**: Cross-type OR/AND operations between all search criteria types
-  - **Unified structure**: Single `searchCriteria` parameter handles labels, relations, properties, and hierarchy
-  - **Navigation support**: Use hierarchy properties like `parents.noteId` for direct children, `ancestors.noteId` for all descendants
-  - **Performance optimized**: Automatic fastSearch when appropriate
-
-### Note Management Tools
-
-- `get_note` - Retrieve a note content by ID
-- `create_note` - Create a new note (supports various types: text, code, file, image, etc.)
-- `update_note` - Replace entire note content (⚠️ creates backup by default)  
-- `append_note` - Add content while preserving existing content (📝 optimized for logs/journals)
-- `delete_note` - Permanently delete a note (⚠️ cannot be undone)
-
-> 📖 **Detailed Usage**: See [Content Modification Guide](docs/content-modification-guide.md) for revision control strategy and best practices.
-
-## Example Queries
-
-### Search & Discovery
-- "Find my most recent 10 notes about 'n8n' since the beginning of 2020" → Uses `search_notes` with unified searchCriteria
-- "Show me notes I've edited in the last 7 days" → Uses `search_notes` with date properties
-- "Find notes with 'machine learning' in the title created this year" → Uses `search_notes` with cross-type criteria
-- "Search for 'kubernetes' in notes created between January and June" → Uses `search_notes` with boolean logic
-
-### Navigation & Browsing
-- "List all notes including subfolders" → Uses `search_notes` with `ancestors.noteId` hierarchy property
-- "Show me everything I have" → Uses `search_notes` with `ancestors.noteId` for complete inventory
-- "List all notes" → Uses `search_notes` with `parents.noteId` hierarchy property
-- "List all notes under 'n8n Template' folder" → Uses `search_notes` with `parents.noteId` hierarchy property
-- "List all notes under 'n8n Template' folder, including subfolders" → Uses `search_notes` with `ancestors.noteId` hierarchy property
-- "Find notes by author Tolkien OR created this week" → Uses `search_notes` with unified `searchCriteria` for cross-type OR logic
-
-### Content Management
-- "Add today's update to my work log" (uses `append_note`)
-- "Replace this draft with the final version" (uses `update_note`)
-- "Create a new note called 'Weekly Review' in my journal folder"
-
-> 📖 **More Examples**: See [User Query Examples](docs/user-query-examples.md) for comprehensive usage scenarios.
-
-## Documentation
-
-- [Content Modification Guide](docs/content-modification-guide.md) - Safe content editing with revision control
-- [User Query Examples](docs/user-query-examples.md) - Natural language query examples
-- [Search Query Examples](docs/search-examples/) - Advanced search syntax and filters
-
-## Development
-
-If you want to contribute or modify the server:
-
-```bash
-# Clone the repository
-git clone https://github.com/tan-yong-sheng/triliumnext-mcp.git
-
-# Install dependencies
-npm install
-
-# Build the server
-npm run build
-
-# For development with auto-rebuild
-npm run watch
-```
-
-## Contributing
-
-Contributions are welcome! If you are looking to improve the server, especially the search functionality, please familiarize yourself with the following resources:
-
-- **Trilium Search DSL**: The [official documentation](https://triliumnext.github.io/Docs/Wiki/search.html) provides the foundation for all search queries.
-- **Internal Search Implementation**: Our [Search Query Examples](docs/search-examples/) document details how `search_notes` parameters are translated into Trilium search strings. This is crucial for understanding and extending the current implementation.
-
-Please feel free to open an issue or submit a pull request.
-
-
+# TriliumNext Notes' MCP Server
+
+⚠️ **DISCLAIMER: This is a prototype for https://github.com/TriliumNext/Notes/issues/705. Suggested only for developer use. Please backup your Trilium notes before using this tool.** ⚠️
+
+A model context protocol server for TriliumNext Notes. This server provides tools to interact with your Trilium Notes instance through MCP.
+
+## Quick Start
+
+Make sure to set up your environment variables first:
+- `TRILIUM_API_URL` (default: http://localhost:8080/etapi)
+- `TRILIUM_API_TOKEN` (required, get this from your Trilium Notes settings)
+- `PERMISSIONS` (optional, default='READ;WRITE', where READ grants access to `search_notes`, `get_note`, `resolve_note_id`, and `read_attributes`, and WRITE grants access to `create_note`, `update_note`, `delete_note`, and `manage_attributes`)
+- `VERBOSE` (optional, default='false', which if true will print verbose debugging logs)
+
+## Installation
+
+### 1. Using with Claude Desktop
+
+Add the server config to your Claude Desktop configuration file:
+
+#### For Local Installation (on Windows)
+
+```json
+"triliumnext-mcp": {
+  "command": "cmd",
+  "args": [
+        "/k",
+        "npx",
+        "-y",
+        "triliumnext-mcp"
+      ],
+   "env": {
+    "TRILIUM_API_URL": "http://localhost:8080/etapi",
+    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
+    "PERMISSIONS": "READ;WRITE"
+  }
+}
+```
+
+#### For Local installation (on Linux)
+
+```json
+"triliumnext-mcp": {
+  "command": "npx",
+  "args": [
+        "-y",
+        "triliumnext-mcp"
+      ],
+   "env": {
+    "TRILIUM_API_URL": "http://localhost:8080/etapi",
+    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
+    "PERMISSIONS": "READ;WRITE"
+  }
+}
+```
+
+#### For Development (on Windows / Linux)
+
+```bash
+cd /path/to/triliumnext-mcp
+npm run build
+```
+
+```json
+"triliumnext-mcp": {
+  "command": "node",
+  "args": [
+        "/path/to/triliumnext-mcp/build/index.js"
+  ],
+  "env": {
+    "TRILIUM_API_URL": "http://localhost:8080/etapi",
+    "TRILIUM_API_TOKEN": "<YOUR_TRILIUM_API_TOKEN>",
+    "PERMISSIONS": "READ;WRITE",
+    "VERBOSE": "true"
+  }
+}
+```
+
+Location of the configuration file:
+- Windows: `%APPDATA%/Claude/claude_desktop_config.json`
+- MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+**Feedback**: Please report issues and test results at [GitHub Issues](https://github.com/TriliumNext/Notes/issues)
+
+## Available Tools
+
+The server provides the following tools for note management:
+
+### Search & Discovery Tools
+
+- `search_notes` - Unified search with comprehensive filtering capabilities including keyword search, date ranges, field-specific searches, attribute searches, note properties, template-based searches, note type filtering, MIME type filtering, and hierarchy navigation.
+- `resolve_note_id` - Find a note's ID by its title. Essential for getting a note's ID to use with other tools.
+
+### Note Management Tools
+
+- `get_note` - Retrieve a note and its content by ID. Can also be used with regex to extract specific patterns from the content.
+- `create_note` - Create a new note. Supports 9 note types and allows creating attributes (labels and relations) in the same step.
+- `update_note` - Updates a note's title or content. Requires a `mode` (`'overwrite'` or `'append'`) to specify the update type and an `expectedHash` to prevent conflicts.
+- `delete_note` - Permanently delete a note (⚠️ cannot be undone).
+
+### Attribute Management Tools
+
+- `read_attributes` - Read all attributes (labels and relations) for a given note.
+- `manage_attributes` - Create, update, or delete attributes on a note. Supports batch creation.
+
+> 📖 **Detailed Usage**: See [Note Management Guide](docs/manage-notes-examples/index.md) for revision control strategy and best practices.
+
+## Example Queries
+
+### Search & Discovery
+- "Find my most recent 10 notes about 'n8n' since the beginning of 2024"
+- "Show me notes I've edited in the last 7 days"
+- "List all notes under 'n8n Template' folder, including subfolders"
+
+### Content Management
+- "Add today's update to my work log" (uses `update_note` with `mode: 'append'`)
+- "Replace this draft with the final version" (uses `update_note` with `mode: 'overwrite'`)
+- "Create a new note called 'Weekly Review' in my journal folder"
+
+> 📖 **More Examples**: See [User Query Examples](docs/user-query-examples.md) for comprehensive usage scenarios.
+
+## Documentation
+
+- [Note Management Guide](docs/manage-notes-examples/index.md) - Safe content editing with revision control
+- [User Query Examples](docs/user-query-examples.md) - Natural language query examples
+- [Search Query Examples](docs/search-examples/) - Advanced search syntax and filters
+
+## Development
+
+If you want to contribute or modify the server:
+
+```bash
+# Clone the repository
+git clone https://github.com/tan-yong-sheng/triliumnext-mcp.git
+
+# Install dependencies
+npm install
+
+# Build the server
+npm run build
+
+# For development with auto-rebuild
+npm run watch
+```
+
+## Contributing
+
+Contributions are welcome! If you are looking to improve the server, please familiarize yourself with the official [Trilium Search DSL documentation](https://triliumnext.github.io/Docs/Wiki/search.html) and our internal [Search Query Examples](docs/search-examples/) to understand how search queries are constructed.
+
+Please feel free to open an issue or submit a pull request.

package/build/index.js

@@ -5,10 +5,11 @@ import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } f
 import axios from "axios";
 // Import modular components
 import { generateTools } from "./modules/toolDefinitions.js";
-import { handleCreateNoteRequest, handleUpdateNoteRequest, handleDeleteNoteRequest, handleGetNoteRequest } from "./modules/noteHandler.js";
+import { handleCreateNoteRequest, handleUpdateNoteRequest, handleDeleteNoteRequest, handleGetNoteRequest, handleSearchReplaceNoteRequest } from "./modules/noteHandler.js";
 import { handleSearchNotesRequest } from "./modules/searchHandler.js";
 import { handleResolveNoteRequest } from "./modules/resolveHandler.js";
 import { handleManageAttributes, handleReadAttributes } from "./modules/attributeHandler.js";
+import { handleListAttributesRequest } from "./modules/attributeListHandler.js";
 const TRILIUM_API_URL = process.env.TRILIUM_API_URL;
 const TRILIUM_API_TOKEN = process.env.TRILIUM_API_TOKEN;
 const PERMISSIONS = process.env.PERMISSIONS || "READ;WRITE";
@@ -23,7 +24,7 @@ class TriliumServer {
         this.allowedPermissions = PERMISSIONS.split(';');
         this.server = new Server({
             name: "triliumnext-mcp",
-            version: "0.1.0",
+            version: "0.3.10",
         }, {
             capabilities: {
                 tools: {},
@@ -66,6 +67,8 @@ class TriliumServer {
                         return await handleDeleteNoteRequest(request.params.arguments, this.axiosInstance, this);
                     case "get_note":
                         return await handleGetNoteRequest(request.params.arguments, this.axiosInstance, this);
+                    case "search_and_replace_note":
+                        return await handleSearchReplaceNoteRequest(request.params.arguments, this.axiosInstance, this);
                     // Search and listing operations
                     case "search_notes":
                         return await handleSearchNotesRequest(request.params.arguments, this.axiosInstance, this);
@@ -75,6 +78,8 @@ class TriliumServer {
                         return await handleReadAttributes(request.params.arguments, this.axiosInstance, this);
                     case "manage_attributes":
                         return await handleManageAttributes(request.params.arguments, this.axiosInstance, this);
+                    case "list_attributes":
+                        return await handleListAttributesRequest(request.params.arguments, this.axiosInstance, this);
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }

package/build/modules/attributeHandler.js

@@ -221,6 +221,38 @@ function format_attribute_response(result, noteId, operation) {
                 text: `📋 Error details:\n${result.errors.map((err, i) => `${i + 1}. ${err}`).join('\n')}`
             });
         }
+        // Add specific guidance for common errors
+        if (result.errors && result.errors.some(err => err.includes("already exists"))) {
+            content.push({
+                type: "text",
+                text: `💡 **Attribute Already Exists**
+
+The attribute you're trying to create already exists on this note. Here are your options:
+
+1. **Update the existing attribute** (recommended):
+   - Use operation: "update" instead of "create"
+   - Only the value and position can be updated for labels
+   - Only the position can be updated for relations
+
+2. **Delete and recreate** (for inheritable changes):
+   - First delete with operation: "delete"
+   - Then recreate with operation: "create"
+   - Use this when you need to change the 'isInheritable' property
+
+3. **View current attributes**:
+   - Use read_attributes to see all existing attributes
+   - Check current values, positions, and inheritable settings
+
+📋 **Example update operation**:
+\`\`\`
+{
+  "noteId": "${noteId}",
+  "operation": "update",
+  "attributes": [{"type": "label", "name": "your_attribute", "value": "new_value"}]
+}
+\`\`\``
+            });
+        }
     }
     // Add attribute data for successful operations
     if (result.success && result.attributes && result.attributes.length > 0) {
@@ -246,6 +278,28 @@ function format_attribute_response(result, noteId, operation) {
             });
         }
     }
+    // Add guidance for batch operations with conflicts
+    if (result.success && operation === "batch_create" && result.errors && result.errors.length > 0) {
+        const hasConflicts = result.errors.some(err => err.includes("Skipping duplicate") || err.includes("already exist"));
+        if (hasConflicts) {
+            content.push({
+                type: "text",
+                text: `⚠️ **Batch Operation Summary**
+
+Some attributes were skipped due to conflicts (already existing). This is normal behavior for batch operations:
+
+✅ **Successfully created**: ${result.attributes?.length || 0} attributes
+❌ **Skipped duplicates**: ${result.errors?.filter(err => err.includes("Skipping duplicate") || err.includes("already exist")).length || 0} attributes
+
+💡 **To manage skipped attributes**:
+- Use \`read_attributes\` to view current attributes
+- Use \`update\` operation to modify existing attributes
+- Use \`delete\` operation to remove unwanted attributes first
+
+This approach prevents accidental overwrites while allowing partial success for batch operations.`
+            });
+        }
+    }
     return { content };
 }
 /**
@@ -316,5 +370,11 @@ export function get_attributes_help() {
 - Template relations require the target note to exist in your Trilium instance
 - Position values control display order (lower numbers appear first)
 - Use read_attributes to view existing attributes before making changes
+
+🛡️ **Validation & Conflict Handling**:
+- Create operations now validate against existing attributes to prevent duplicates
+- If an attribute already exists, you'll get detailed error messages with guidance
+- Batch operations skip duplicates and continue with valid attributes
+- Use "update" to modify existing attributes, "create" for new ones only
 `;
 }

package/build/modules/attributeListHandler.js

@@ -0,0 +1,34 @@
+/**
+ * Attribute List Handler Module
+ * Centralized request handling for attribute listing operations
+ */
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { handleListAttributes } from "./attributeListManager.js";
+/**
+ * Handle list_attributes tool requests
+ */
+export async function handleListAttributesRequest(args, axiosInstance, permissionChecker) {
+    if (!permissionChecker.hasPermission("READ")) {
+        throw new McpError(ErrorCode.InvalidRequest, "Permission denied: Not authorized to list attributes.");
+    }
+    try {
+        const listOperation = {
+            noteId: args.noteId,
+            hierarchyLevel: args.hierarchyLevel || 'immediate',
+            limit: args.limit || 50
+        };
+        const result = await handleListAttributes(listOperation, axiosInstance);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : String(error));
+    }
+}

package/build/modules/attributeListManager.js

@@ -0,0 +1,147 @@
+/**
+ * Attribute List Management Module
+ * Handles attribute listing operations using search_notes internally
+ */
+import { handleSearchNotes } from './searchManager.js';
+import { logVerboseInput, logVerboseOutput } from '../utils/verboseUtils.js';
+/**
+ * Handle list attributes operation using search_notes internally
+ */
+export async function handleListAttributes(args, axiosInstance) {
+    logVerboseInput('handleListAttributes', args);
+    // Build search criteria based on hierarchy navigation
+    const searchCriteria = buildHierarchySearchCriteria(args);
+    // Use search_notes internally to find notes
+    const searchOperation = {
+        searchCriteria: searchCriteria,
+        limit: args.limit || 100
+    };
+    const searchResults = await handleSearchNotes(searchOperation, axiosInstance);
+    // Extract and organize attributes from search results
+    const attributes = extractAttributesFromResults(searchResults.results, args);
+    // Generate summary
+    const summary = generateAttributeSummary(attributes, args);
+    const result = {
+        attributes: attributes,
+        summary: summary
+    };
+    logVerboseOutput('handleListAttributes', result);
+    return result;
+}
+/**
+ * Build search criteria for hierarchy navigation
+ */
+function buildHierarchySearchCriteria(args) {
+    const criteria = [];
+    const hierarchyLevel = args.hierarchyLevel || 'immediate';
+    if (hierarchyLevel === 'immediate') {
+        // For immediate level, search for direct parents and children
+        criteria.push({
+            property: 'parents.noteId',
+            type: 'noteProperty',
+            op: '=',
+            value: args.noteId
+        });
+        criteria.push({
+            property: 'children.noteId',
+            type: 'noteProperty',
+            op: '=',
+            value: args.noteId,
+            logic: 'OR'
+        });
+    }
+    else {
+        // For all levels, search for ancestors and descendants
+        criteria.push({
+            property: 'ancestors.noteId',
+            type: 'noteProperty',
+            op: '=',
+            value: args.noteId
+        });
+        criteria.push({
+            property: 'descendants.noteId',
+            type: 'noteProperty',
+            op: '=',
+            value: args.noteId,
+            logic: 'OR'
+        });
+    }
+    // Exclude the anchor note itself
+    criteria.push({
+        property: 'noteId',
+        type: 'noteProperty',
+        op: '!=',
+        value: args.noteId,
+        logic: 'AND'
+    });
+    return criteria;
+}
+/**
+ * Extract and organize attributes from search results
+ */
+function extractAttributesFromResults(searchResults, args) {
+    const attributes = [];
+    for (const note of searchResults) {
+        if (note.attributes && Array.isArray(note.attributes)) {
+            for (const attribute of note.attributes) {
+                const attributeInfo = {
+                    noteId: note.noteId,
+                    noteTitle: note.title,
+                    noteType: note.type,
+                    attributeId: attribute.attributeId,
+                    attributeType: attribute.type,
+                    attributeName: attribute.name,
+                    attributeValue: attribute.value || '',
+                    position: attribute.position || 10,
+                    isInheritable: attribute.isInheritable || false,
+                    hierarchyPath: buildHierarchyPath(note, args)
+                };
+                attributes.push(attributeInfo);
+            }
+        }
+    }
+    return attributes;
+}
+/**
+ * Build hierarchy path for attribute context
+ */
+function buildHierarchyPath(note, args) {
+    const hierarchyLevel = args.hierarchyLevel || 'immediate';
+    const noteTitle = note.title || 'Unknown';
+    if (hierarchyLevel === 'immediate') {
+        return `Related to ${args.noteId}: ${noteTitle}`;
+    }
+    else {
+        return `Hierarchy-connected to ${args.noteId}: ${noteTitle}`;
+    }
+}
+/**
+ * Generate summary of attributes found
+ */
+function generateAttributeSummary(attributes, args) {
+    const totalAttributes = attributes.length;
+    if (totalAttributes === 0) {
+        return `No attributes found`;
+    }
+    // Group by attribute type
+    const labelCount = attributes.filter(attr => attr.attributeType === 'label').length;
+    const relationCount = attributes.filter(attr => attr.attributeType === 'relation').length;
+    // Group by note
+    const uniqueNotes = new Set(attributes.map(attr => attr.noteId)).size;
+    let summary = `Found ${totalAttributes} attributes across ${uniqueNotes} notes`;
+    if (labelCount > 0 || relationCount > 0) {
+        summary += ` (${labelCount} labels, ${relationCount} relations)`;
+    }
+    // Add hierarchy context
+    const hierarchyLevel = args.hierarchyLevel || 'immediate';
+    if (hierarchyLevel === 'immediate') {
+        summary += ` in immediate hierarchy (parents and children)`;
+    }
+    else {
+        summary += ` in full hierarchy (ancestors and descendants)`;
+    }
+    // Add unique attribute names count
+    const uniqueAttributeNames = new Set(attributes.map(attr => attr.attributeName)).size;
+    summary += ` with ${uniqueAttributeNames} unique attribute types`;
+    return summary;
+}