triliumnext-mcp 0.3.8-beta.4 → 0.3.8-beta.5

package/build/index.js

@@ -8,7 +8,7 @@ import { generateTools } from "./modules/toolDefinitions.js";
 import { handleCreateNoteRequest, handleUpdateNoteRequest, handleAppendNoteRequest, handleDeleteNoteRequest, handleGetNoteRequest } from "./modules/noteHandler.js";
 import { handleSearchNotesRequest } from "./modules/searchHandler.js";
 import { handleResolveNoteRequest } from "./modules/resolveHandler.js";
-import { handleManageAttributes } from "./modules/attributeHandler.js";
+import { handleManageAttributes, handleReadAttributes } from "./modules/attributeHandler.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";
@@ -73,6 +73,8 @@ class TriliumServer {
                         return await handleSearchNotesRequest(request.params.arguments, this.axiosInstance, this);
                     case "resolve_note_id":
                         return await handleResolveNoteRequest(request.params.arguments, this, this.axiosInstance);
+                    case "read_attributes":
+                        return await handleReadAttributes(request.params.arguments, this.axiosInstance, this);
                     case "manage_attributes":
                         return await handleManageAttributes(request.params.arguments, this.axiosInstance, this);
                     default:

package/build/modules/attributeHandler.js

@@ -3,7 +3,7 @@
  * Processes MCP requests for attribute management operations
  */
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { manage_attributes, get_note_attributes } from './attributeManager.js';
+import { manage_attributes, read_attributes } from './attributeManager.js';
 /**
  * Handle manage_attributes MCP request
  */
@@ -32,35 +32,23 @@ export async function handleManageAttributes(args, axiosInstance, permissionChec
                 isError: true
             };
         }
-        // Check permissions based on operation type
-        const readOperations = ["read"];
-        const writeOperations = ["create", "update", "delete", "batch_create"];
-        if (readOperations.includes(args.operation)) {
-            if (!permissionChecker.hasPermission("READ")) {
-                throw new McpError(ErrorCode.InvalidRequest, "Permission denied: Not authorized to read attributes.");
-            }
+        // Check WRITE permission for all manage_attributes operations
+        if (!permissionChecker.hasPermission("WRITE")) {
+            throw new McpError(ErrorCode.InvalidRequest, "Permission denied: Not authorized to manage attributes.");
         }
-        else if (writeOperations.includes(args.operation)) {
-            if (!permissionChecker.hasPermission("WRITE")) {
-                throw new McpError(ErrorCode.InvalidRequest, "Permission denied: Not authorized to manage attributes.");
-            }
-        }
-        else {
+        // Validate operation
+        const validOperations = ["create", "update", "delete", "batch_create"];
+        if (!validOperations.includes(args.operation)) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: `❌ Invalid operation: ${args.operation}. Valid operations are: ${[...readOperations, ...writeOperations].join(", ")}`
+                        text: `❌ Invalid operation: ${args.operation}. Valid operations are: ${validOperations.join(", ")}`
                     }
                 ],
                 isError: true
             };
         }
-        // Handle read operation
-        if (args.operation === "read") {
-            const result = await get_note_attributes(args.noteId, axiosInstance);
-            return format_attribute_response(result, args.noteId, "read");
-        }
         // Validate attributes for write operations
         if (!args.attributes || !Array.isArray(args.attributes) || args.attributes.length === 0) {
             return {
@@ -106,6 +94,109 @@ export async function handleManageAttributes(args, axiosInstance, permissionChec
         };
     }
 }
+/**
+ * Handle read_attributes MCP request
+ */
+export async function handleReadAttributes(args, axiosInstance, permissionChecker) {
+    try {
+        // Validate required parameters
+        if (!args.noteId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "❌ Missing required parameter: noteId"
+                    }
+                ],
+                isError: true
+            };
+        }
+        // Check READ permission
+        if (!permissionChecker.hasPermission("READ")) {
+            throw new McpError(ErrorCode.InvalidRequest, "Permission denied: Not authorized to read attributes.");
+        }
+        // Execute the read operation
+        const result = await read_attributes(args, axiosInstance);
+        return format_read_attribute_response(result, args.noteId);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `❌ Attribute read operation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+                }
+            ],
+            isError: true
+        };
+    }
+}
+/**
+ * Format read attribute operation result for MCP response
+ */
+function format_read_attribute_response(result, noteId) {
+    const content = [];
+    // Add status message
+    if (result.success) {
+        content.push({
+            type: "text",
+            text: `✅ ${result.message}`
+        });
+    }
+    else {
+        content.push({
+            type: "text",
+            text: `❌ ${result.message}`
+        });
+        // Add error details if available
+        if (result.errors && result.errors.length > 0) {
+            content.push({
+                type: "text",
+                text: `📋 Error details:\n${result.errors.map((err, i) => `${i + 1}. ${err}`).join('\n')}`
+            });
+        }
+    }
+    // Add attribute data for successful operations
+    if (result.success && result.attributes && result.attributes.length > 0) {
+        // Separate labels and relations for better organization
+        const labels = result.attributes.filter(attr => attr.type === 'label');
+        const relations = result.attributes.filter(attr => attr.type === 'relation');
+        content.push({
+            type: "text",
+            text: format_attributes_for_display(result.attributes)
+        });
+        // Add structured summary if available
+        if (result.summary) {
+            content.push({
+                type: "text",
+                text: `📊 Summary: ${result.summary.total} total attributes (${result.summary.labels} labels, ${result.summary.relations} relations)`
+            });
+        }
+        // Add detailed breakdown
+        if (labels.length > 0) {
+            content.push({
+                type: "text",
+                text: `🏷️  Labels (${labels.length}):\n${labels.map(attr => {
+                    const value = attr.value ? ` = "${attr.value}"` : "";
+                    return `  #${attr.name}${value}`;
+                }).join('\n')}`
+            });
+        }
+        if (relations.length > 0) {
+            content.push({
+                type: "text",
+                text: `🔗 Relations (${relations.length}):\n${relations.map(attr => `  ~${attr.name} = "${attr.value}"`).join('\n')}`
+            });
+        }
+    }
+    else if (result.success) {
+        content.push({
+            type: "text",
+            text: "📋 No attributes found for this note"
+        });
+    }
+    return { content };
+}
 /**
  * Format attribute operation result for MCP response
  */
@@ -178,23 +269,27 @@ function format_attributes_for_display(attributes) {
  */
 export function get_attributes_help() {
     return `
-🔧 Attribute Management Tool (manage_attributes)
+🔧 Attribute Management Tools
 
-This tool manages note attributes (labels and relations) in TriliumNext.
+📖 read_attributes: Read all attributes (labels and relations) for a note
+🔧 manage_attributes: Create, update, delete attributes (write operations)
 
 📝 Usage Examples:
 
-1. Create a single label:
+📖 Read Attributes:
+   - noteId: "abc123"
+
+🔧 Create a single label:
    - noteId: "abc123"
    - operation: "create"
    - attributes: [{type: "label", name: "important", position: 10}]
 
-2. Create a template relation:
+🔧 Create a template relation:
    - noteId: "abc123"
    - operation: "create"
    - attributes: [{type: "relation", name: "template", value: "Board", position: 10}]
 
-3. Create multiple attributes (batch):
+🔧 Create multiple attributes (batch):
    - noteId: "abc123"
    - operation: "batch_create"
    - attributes: [
@@ -203,16 +298,12 @@ This tool manages note attributes (labels and relations) in TriliumNext.
        {type: "relation", name: "template", value: "Grid View", position: 30}
      ]
 
-4. Read all attributes:
-   - noteId: "abc123"
-   - operation: "read"
-
-5. Update an attribute:
+🔧 Update an attribute:
    - noteId: "abc123"
    - operation: "update"
    - attributes: [{type: "label", name: "important", position: 15}]
 
-6. Delete an attribute:
+🔧 Delete an attribute:
    - noteId: "abc123"
    - operation: "delete"
    - attributes: [{type: "label", name: "important"}]
@@ -224,5 +315,6 @@ This tool manages note attributes (labels and relations) in TriliumNext.
 - Use "batch_create" for multiple attributes (faster than individual calls)
 - 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
 `;
 }

package/build/modules/attributeManager.js

@@ -5,7 +5,8 @@
 import axios from 'axios';
 import { logVerbose, logVerboseApi, logVerboseAxiosError } from "../utils/verboseUtils.js";
 /**
- * Main attribute management function that orchestrates different operations
+ * Manage note attributes with write operations (create, update, delete)
+ * This function provides write-only access to note attributes
  */
 export async function manage_attributes(params, axiosInstance) {
     try {
@@ -262,11 +263,12 @@ function validate_attribute(attribute) {
     };
 }
 /**
- * Get all attributes for a note
+ * Read all attributes for a note (labels and relations)
+ * This function provides read-only access to note attributes
  */
-export async function get_note_attributes(noteId, axiosInstance) {
+export async function read_attributes(params, axiosInstance) {
     try {
-        const response = await axiosInstance.get(`/notes/${noteId}`);
+        const response = await axiosInstance.get(`/notes/${params.noteId}`);
         const attributes = response.data.attributes.map((attr) => ({
             type: attr.type,
             name: attr.name,
@@ -274,10 +276,20 @@ export async function get_note_attributes(noteId, axiosInstance) {
             position: attr.position,
             isInheritable: attr.isInheritable
         }));
+        // Separate labels and relations for better organization
+        const labels = attributes.filter(attr => attr.type === 'label');
+        const relations = attributes.filter(attr => attr.type === 'relation');
         return {
             success: true,
-            message: `Retrieved ${attributes.length} attributes for note ${noteId}`,
-            attributes
+            message: `Retrieved ${attributes.length} attributes for note ${params.noteId} (${labels.length} labels, ${relations.length} relations)`,
+            attributes,
+            // Add structured summary for easier parsing
+            summary: {
+                total: attributes.length,
+                labels: labels.length,
+                relations: relations.length,
+                noteId: params.noteId
+            }
         };
     }
     catch (error) {

package/build/modules/toolDefinitions.js

@@ -321,22 +321,17 @@ function createSearchProperties() {
 export function createReadAttributeTools() {
     return [
         {
-            name: "manage_attributes",
-            description: "Read note attributes (labels and relations). View existing labels (#tags), template relations (~template), and note metadata. This tool allows you to inspect the current attributes assigned to any note.",
+            name: "read_attributes",
+            description: "Read all attributes (labels and relations) for a note. View existing labels (#tags), template relations (~template), and note metadata. This tool provides read-only access to inspect current attributes assigned to any note. Returns structured data with labels, relations, and summary information.",
             inputSchema: {
                 type: "object",
                 properties: {
                     noteId: {
                         type: "string",
                         description: "ID of the note to read attributes from"
-                    },
-                    operation: {
-                        type: "string",
-                        enum: ["read"],
-                        description: "Operation type: 'read' (list all attributes)"
                     }
                 },
-                required: ["noteId", "operation"]
+                required: ["noteId"]
             }
         }
     ];
@@ -348,7 +343,7 @@ export function createWriteAttributeTools() {
     return [
         {
             name: "manage_attributes",
-            description: "Manage note attributes (labels and relations) with write operations. ONLY use this tool when the user explicitly requests attribute management (e.g., 'add a tag', 'create a relation', 'manage attributes'). TRY NOT to use this tool proactively unless for automated metadata tagging as part of a clear workflow. Create labels (#tags), template relations (~template), update existing attributes, and organize notes with metadata. IMPORTANT: Relations require values pointing to existing notes (e.g., template relations use 'Board', 'Calendar'; author relations use target note titles or IDs). UPDATE LIMITATIONS: For labels, only value and position can be updated. For relations, only position can be updated. The isInheritable property cannot be changed via update - delete and recreate to modify inheritability. Supports single operations and efficient batch creation for better performance. Template relations like ~template.title = 'Board' enable specialized note layouts and functionality.",
+            description: "Manage note attributes with write operations (create, update, delete). Create labels (#tags), template relations (~template), update existing attributes, and organize notes with metadata. IMPORTANT: This tool only provides write access - use read_attributes to view existing attributes. Relations require values pointing to existing notes (e.g., template relations use 'Board', 'Calendar'; author relations use target note titles or IDs). UPDATE LIMITATIONS: For labels, only value and position can be updated. For relations, only position can be updated. The isInheritable property cannot be changed via update - delete and recreate to modify inheritability. Supports single operations and efficient batch creation for better performance.",
             inputSchema: {
                 type: "object",
                 properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triliumnext-mcp",
-  "version": "0.3.8-beta.4",
+  "version": "0.3.8-beta.5",
   "description": "A model context protocol server for TriliumNext Notes",
   "type": "module",
   "bin": {