read_multiple_notes

Instructions

Implementation Reference

• src/tools/filesystem.ts:245-287 (handler)

  The handler function that executes the tool logic: reads multiple note files from the notes directory, validates paths are within bounds, handles individual file errors, and formats output with separators.

  export async function handleReadMultipleNotes(notesPath: string, args: ReadMultipleNotesArgs): Promise<ToolCallResult> {
    try {
      // Validate paths is provided and is an array
      if (!args.paths || !Array.isArray(args.paths)) {
        throw new Error("'paths' parameter is required and must be an array");
      }
      
      // Process each file path
      const results = await Promise.all(
        args.paths.map(async (notePath) => {
          try {
            const filePath = path.join(notesPath, notePath);
            
            // Ensure the path is within allowed directory
            if (!filePath.startsWith(notesPath)) {
              return `${notePath}: Error - Access denied - path outside notes directory`;
            }
            
            try {
              const content = await fs.readFile(filePath, 'utf-8');
              return `${notePath}:\n${content}\n`;
            } catch (error) {
              const errorMessage = error instanceof Error ? error.message : String(error);
              return `${notePath}: Error - ${errorMessage}`;
            }
          } catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            return `${notePath}: Error - ${errorMessage}`;
          }
        })
      );
      
      return {
        content: [{ type: "text", text: results.join("\n---\n") }]
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return {
        content: [{ type: "text", text: `Error reading notes: ${errorMessage}` }],
        isError: true
      };
    }
  }

• src/tools/filesystem.ts:84-100 (schema)

  Tool definition object containing the name, description, and input schema (JSON Schema) for the read_multiple_notes tool.

  {
    name: "read_multiple_notes",
    description: "Read the contents of multiple note files simultaneously. " +
      "Specify paths relative to your notes directory (e.g., ['Log/2023-01-01.md', 'Rollups/2023-01-01-rollup.md']). " +
      "Returns each file's content with its path as a reference.",
    inputSchema: {
      type: "object",
      properties: {
        paths: { 
          type: "array",
          items: { type: "string" },
          description: "Array of paths to note files, relative to your notes directory" 
        }
      },
      required: ["paths"]
    },
  },

• src/tools/filesystem.ts:31-33 (schema)

  TypeScript interface defining the input arguments for the handler.

  interface ReadMultipleNotesArgs {
    paths: string[];
  }

• src/tools/index.ts:354-355 (registration)

  Registration in the central tool dispatcher (handleToolCall switch statement) that routes calls to the specific handler.

  case "read_multiple_notes":
    return await handleReadMultipleNotes(notesPath, args);

• src/tools/index.ts:9-17 (registration)

  Import of the handler and tool definitions from filesystem module into the central tools index.

    ensureDirectory,
    initializeNotesDirectory,
    handleSearchFiles,
    handleReadNote,
    handleReadMultipleNotes,
    handleListDirectory,
    handleCreateDirectory,
    getFilesystemToolDefinitions
  } from './filesystem.js';