read_attributes

Instructions

Implementation Reference

• src/modules/attributeHandler.ts:129-168 (handler)

  MCP handler for read_attributes tool: validates noteId, checks READ permission, calls core read_attributes function, handles errors, and formats MCP response.

  export async function handleReadAttributes(
    args: ReadAttributesParams,
    axiosInstance: AxiosInstance,
    permissionChecker: PermissionChecker
  ): Promise<any> {
    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
      };
    }
  }

• src/modules/attributeManager.ts:373-411 (helper)

  Core implementation of read_attributes: fetches note from Trilium API, maps attributes to structured format (labels/relations), provides summary.

  export async function read_attributes(
    params: ReadAttributesParams,
    axiosInstance: AxiosInstance
  ): Promise<AttributeOperationResult> {
    try {
      const response = await axiosInstance.get(`/notes/${params.noteId}`);
  
      const attributes: Attribute[] = response.data.attributes.map((attr: any) => ({
        type: attr.type,
        name: attr.name,
        value: attr.value,
        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 ${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) {
      return {
        success: false,
        message: `Failed to retrieve attributes: ${error instanceof Error ? error.message : 'Unknown error'}`,
        errors: [error instanceof Error ? error.message : 'Unknown error']
      };
    }
  }

• src/modules/toolDefinitions.ts:328-341 (schema)

  Input schema definition for the read_attributes tool, requiring noteId.

  {
    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"
        }
      },
      required: ["noteId"]
    }
  }

• src/index.ts:115-116 (registration)

  Registration of read_attributes tool in main switch handler, routing to handleReadAttributes.

  case "read_attributes":
    return await handleReadAttributes(request.params.arguments as any, this.axiosInstance, this);

• src/modules/attributeManager.ts:18-20 (schema)

  TypeScript interface defining input parameters for read_attributes (noteId).

  export interface ReadAttributesParams {
    noteId: string;
  }