obsidian-mcp-server 2.0.7 → 3.0.0

package/dist/mcp-server/tools/definitions/index.d.ts

@@ -0,0 +1,531 @@
+/**
+ * @fileoverview Tool registration barrel. `obsidian_execute_command` is exported
+ * separately so callers can decide whether to register it based on the
+ * `OBSIDIAN_ENABLE_COMMANDS` flag — keeping this module free of eager config reads.
+ * @module mcp-server/tools/definitions/index
+ */
+import { obsidianExecuteCommand } from './obsidian-execute-command.tool.js';
+/** Tools registered unconditionally on every server. */
+export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    deleted: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "cancelled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidRequest;
+    readonly when: "User declined the deletion via interactive elicitation.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    format: import("zod").ZodEnum<{
+        content: "content";
+        section: "section";
+        full: "full";
+        "document-map": "document-map";
+    }>;
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    section: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"content">;
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"full">;
+        path: import("zod").ZodString;
+        content: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+        stat: import("zod").ZodObject<{
+            ctime: import("zod").ZodNumber;
+            mtime: import("zod").ZodNumber;
+            size: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"document-map">;
+        path: import("zod").ZodString;
+        headings: import("zod").ZodArray<import("zod").ZodString>;
+        blocks: import("zod").ZodArray<import("zod").ZodString>;
+        frontmatterFields: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        format: import("zod").ZodLiteral<"section">;
+        path: import("zod").ZodString;
+        section: import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                heading: "heading";
+                block: "block";
+                frontmatter: "frontmatter";
+            }>;
+            target: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>;
+        valueText: import("zod").ZodOptional<import("zod").ZodString>;
+        valueJson: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>], "format">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "section_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`format` is \"section\" but no `section` locator was provided.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    commands: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    path: import("zod").ZodOptional<import("zod").ZodString>;
+    extension: import("zod").ZodOptional<import("zod").ZodString>;
+    nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
+    depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    entries: import("zod").ZodArray<import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        type: import("zod").ZodEnum<{
+            file: "file";
+            directory: "directory";
+        }>;
+        truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+    totals: import("zod").ZodObject<{
+        entries: import("zod").ZodNumber;
+        files: import("zod").ZodNumber;
+        directories: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    appliedFilters: import("zod").ZodObject<{
+        extension: import("zod").ZodOptional<import("zod").ZodString>;
+        nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
+        depth: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+        reason: import("zod").ZodLiteral<"entry_cap">;
+        cap: import("zod").ZodNumber;
+        hint: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "regex_invalid";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The supplied `nameRegex` is not a valid ECMAScript regex.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The supplied `path` does not exist in the vault. Sub-directories that disappear mid-walk are silently skipped — only the root path surfaces this error.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    tags: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        count: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    operation: import("zod").ZodEnum<{
+        set: "set";
+        delete: "delete";
+        get: "get";
+    }>;
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    key: import("zod").ZodString;
+    value: import("zod").ZodOptional<import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"get">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        exists: import("zod").ZodBoolean;
+        value: import("zod").ZodUnknown;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"set">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"delete">;
+        path: import("zod").ZodString;
+        key: import("zod").ZodString;
+        frontmatter: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>], "operation">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "value_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`operation` is \"set\" but no `value` was supplied.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    operation: import("zod").ZodEnum<{
+        list: "list";
+        add: "add";
+        remove: "remove";
+    }>;
+    tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    location: import("zod").ZodDefault<import("zod").ZodEnum<{
+        frontmatter: "frontmatter";
+        inline: "inline";
+        both: "both";
+    }>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"list">;
+        path: import("zod").ZodString;
+        tags: import("zod").ZodObject<{
+            frontmatter: import("zod").ZodArray<import("zod").ZodString>;
+            inline: import("zod").ZodArray<import("zod").ZodString>;
+            all: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"add">;
+        path: import("zod").ZodString;
+        applied: import("zod").ZodArray<import("zod").ZodString>;
+        skipped: import("zod").ZodArray<import("zod").ZodString>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        operation: import("zod").ZodLiteral<"remove">;
+        path: import("zod").ZodString;
+        applied: import("zod").ZodArray<import("zod").ZodString>;
+        skipped: import("zod").ZodArray<import("zod").ZodString>;
+        tags: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "operation">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "tags_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`operation` is \"add\" or \"remove\" but `tags` was empty or omitted.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    failIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    newLeaf: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    opened: import("zod").ZodBoolean;
+    createdIfMissing: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "`failIfMissing: true` (default) and the path does not exist in the vault. Pass `failIfMissing: false` to allow Obsidian to create the file on open.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    section: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    operation: import("zod").ZodEnum<{
+        append: "append";
+        prepend: "prepend";
+        replace: "replace";
+    }>;
+    content: import("zod").ZodString;
+    contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    patchOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        createTargetIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        applyIfContentPreexists: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        trimTargetWhitespace: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    section: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>;
+    operation: import("zod").ZodEnum<{
+        append: "append";
+        prepend: "prepend";
+        replace: "replace";
+    }>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The named heading/block/frontmatter field does not exist in the note. Use `obsidian_get_note` with `format: \"document-map\"` to discover available targets.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    replacements: import("zod").ZodArray<import("zod").ZodObject<{
+        search: import("zod").ZodString;
+        replace: import("zod").ZodString;
+        useRegex: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        caseSensitive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        wholeWord: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        flexibleWhitespace: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        replaceAll: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    totalReplacements: import("zod").ZodNumber;
+    perReplacement: import("zod").ZodArray<import("zod").ZodObject<{
+        search: import("zod").ZodString;
+        count: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "regex_invalid";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "A `useRegex: true` replacement supplied a `search` pattern that is not a valid ECMAScript regex.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "The vault path does not resolve to an existing note.";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    mode: import("zod").ZodEnum<{
+        text: "text";
+        dataview: "dataview";
+        jsonlogic: "jsonlogic";
+    }>;
+    query: import("zod").ZodOptional<import("zod").ZodString>;
+    logic: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    contextLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+    pathPrefix: import("zod").ZodOptional<import("zod").ZodString>;
+    maxMatchesPerHit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"text">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            score: import("zod").ZodOptional<import("zod").ZodNumber>;
+            matches: import("zod").ZodArray<import("zod").ZodObject<{
+                context: import("zod").ZodString;
+                match: import("zod").ZodObject<{
+                    start: import("zod").ZodNumber;
+                    end: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>>;
+            totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
+            truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"dataview">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            result: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        mode: import("zod").ZodLiteral<"jsonlogic">;
+        hits: import("zod").ZodArray<import("zod").ZodObject<{
+            filename: import("zod").ZodString;
+            result: import("zod").ZodUnknown;
+        }, import("zod/v4/core").$strip>>;
+        excluded: import("zod").ZodOptional<import("zod").ZodObject<{
+            count: import("zod").ZodNumber;
+            hint: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>], "mode">;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "path_prefix_invalid_mode";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`pathPrefix` was provided in a non-text mode (only `text` supports prefix filtering).";
+}, {
+    readonly reason: "query_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`query` is missing for `text` or `dataview` mode (required for both).";
+}, {
+    readonly reason: "logic_required";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`logic` is missing for `jsonlogic` mode.";
+}]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"path">;
+        path: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"active">;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"periodic">;
+        period: import("zod").ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>], "type">;
+    content: import("zod").ZodString;
+    section: import("zod").ZodOptional<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    contentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    path: import("zod").ZodString;
+    sectionTargeted: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>, undefined>)[];
+export { obsidianExecuteCommand };
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp-server/tools/definitions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAa5E,wDAAwD;AACxD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAc/B,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/mcp-server/tools/definitions/index.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Tool registration barrel. `obsidian_execute_command` is exported
+ * separately so callers can decide whether to register it based on the
+ * `OBSIDIAN_ENABLE_COMMANDS` flag — keeping this module free of eager config reads.
+ * @module mcp-server/tools/definitions/index
+ */
+import { obsidianAppendToNote } from './obsidian-append-to-note.tool.js';
+import { obsidianDeleteNote } from './obsidian-delete-note.tool.js';
+import { obsidianExecuteCommand } from './obsidian-execute-command.tool.js';
+import { obsidianGetNote } from './obsidian-get-note.tool.js';
+import { obsidianListCommands } from './obsidian-list-commands.tool.js';
+import { obsidianListNotes } from './obsidian-list-notes.tool.js';
+import { obsidianListTags } from './obsidian-list-tags.tool.js';
+import { obsidianManageFrontmatter } from './obsidian-manage-frontmatter.tool.js';
+import { obsidianManageTags } from './obsidian-manage-tags.tool.js';
+import { obsidianOpenInUi } from './obsidian-open-in-ui.tool.js';
+import { obsidianPatchNote } from './obsidian-patch-note.tool.js';
+import { obsidianReplaceInNote } from './obsidian-replace-in-note.tool.js';
+import { obsidianSearchNotes } from './obsidian-search-notes.tool.js';
+import { obsidianWriteNote } from './obsidian-write-note.tool.js';
+/** Tools registered unconditionally on every server. */
+export const baseToolDefinitions = [
+    obsidianGetNote,
+    obsidianListNotes,
+    obsidianListTags,
+    obsidianListCommands,
+    obsidianSearchNotes,
+    obsidianWriteNote,
+    obsidianAppendToNote,
+    obsidianPatchNote,
+    obsidianReplaceInNote,
+    obsidianManageFrontmatter,
+    obsidianManageTags,
+    obsidianDeleteNote,
+    obsidianOpenInUi,
+];
+export { obsidianExecuteCommand };
+//# sourceMappingURL=index.js.map

package/dist/mcp-server/tools/definitions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE,wDAAwD;AACxD,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,eAAe;IACf,iBAAiB;IACjB,gBAAgB;IAChB,oBAAoB;IACpB,mBAAmB;IACnB,iBAAiB;IACjB,oBAAoB;IACpB,iBAAiB;IACjB,qBAAqB;IACrB,yBAAyB;IACzB,kBAAkB;IAClB,kBAAkB;IAClB,gBAAgB;CACjB,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview obsidian_append_to_note — append content to the end of a note,
+ * or to the end of a heading/block/frontmatter section via PATCH-with-append.
+ * @module mcp-server/tools/definitions/obsidian-append-to-note.tool
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+export declare const obsidianAppendToNote: import("@cyanheads/mcp-ts-core").ToolDefinition<z.ZodObject<{
+    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"path">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"active">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"periodic">;
+        period: z.ZodEnum<{
+            daily: "daily";
+            weekly: "weekly";
+            monthly: "monthly";
+            quarterly: "quarterly";
+            yearly: "yearly";
+        }>;
+        date: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">;
+    content: z.ZodString;
+    section: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            heading: "heading";
+            block: "block";
+            frontmatter: "frontmatter";
+        }>;
+        target: z.ZodString;
+    }, z.core.$strip>>;
+    contentType: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        json: "json";
+    }>>;
+    createTargetIfMissing: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    sectionTargeted: z.ZodBoolean;
+}, z.core.$strip>, undefined>;
+//# sourceMappingURL=obsidian-append-to-note.tool.d.ts.map

package/dist/mcp-server/tools/definitions/obsidian-append-to-note.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obsidian-append-to-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-append-to-note.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAIjD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAyD/B,CAAC"}