obsidian-mcp-server 3.6.0 → 3.7.0

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.js

@@ -1,146 +1,267 @@
 /**
- * @fileoverview obsidian_delete_note — permanently delete a note. Suspends via
+ * @fileoverview obsidian_delete_note — permanently delete a note. Built by a
+ * factory because the confirmation is an operator choice
+ * (`OBSIDIAN_DELETE_ELICITATION`, read in the entry point): off, the handler
+ * checks write scope, reads the note, and deletes. On, it suspends via
  * `ctx.requestInput` to confirm with the user before the DELETE, and is
- * re-entered with the answer on `ctx.inputs`.
+ * re-entered with the answer on `ctx.inputs`; the answer counts only on a
+ * round that redeems the consent record this handler stored when it asked.
  * @module mcp-server/tools/definitions/obsidian-delete-note.tool
  */
+import { createHash, randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
 import { inputRequired, tool, z } from '@cyanheads/mcp-ts-core';
-import { JsonRpcErrorCode } from '@cyanheads/mcp-ts-core/errors';
+import { JsonRpcErrorCode, McpError, notFound } from '@cyanheads/mcp-ts-core/errors';
 import { getObsidianService } from '../../../services/obsidian/obsidian-service.js';
 import { TargetSchema } from './_shared/schemas.js';
+import { findSimilarPaths } from './_shared/suggest-paths.js';
+const OPERATION = 'obsidian_delete_note';
+const CONSENT_TTL_SECONDS = 600;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 /** Answered by the client in the confirmation round; re-validated on re-entry. */
 const DeleteConfirmation = z.object({
     confirm: z.boolean().describe('Set to true to delete the note. Any other value cancels.'),
 });
-export const obsidianDeleteNote = tool('obsidian_delete_note', {
-    description: 'Permanently delete a note from the vault. Asks the user to confirm before deleting — the call is answered with a confirmation request and retried with the answer. Recovery requires the local trash in Obsidian — there is no API-level undo.',
-    annotations: { destructiveHint: true },
-    input: z.object({
-        target: TargetSchema.describe('Which note to delete.'),
-    }),
-    output: z.object({
-        path: z.string().describe('Resolved vault-relative path of the deleted note.'),
-        deleted: z.boolean().describe('True when the file was removed.'),
-        previousSizeInBytes: z
-            .number()
-            .describe('Byte size of the note immediately before deletion. Confirms the size of what was removed.'),
-        currentSizeInBytes: z
-            .number()
-            .describe('Always 0 after a successful delete — the file no longer exists.'),
-    }),
-    auth: ['tool:obsidian_delete_note:write'],
-    errors: [
-        {
-            reason: 'path_forbidden',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.Forbidden,
-            when: 'The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.',
-            recovery: 'Use a path inside the configured write scope. The error data echoes the active scope.',
-        },
-        {
-            reason: 'cancelled',
-            code: JsonRpcErrorCode.InvalidRequest,
-            when: 'User declined, cancelled, or answered false to the confirmation request.',
-            severity: 'notice',
-            recovery: 'Re-run the tool when the user is ready to confirm deletion.',
-        },
-        {
-            reason: 'note_missing',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.NotFound,
-            when: 'The vault path does not resolve to an existing note.',
-            recovery: 'Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note.',
-        },
-        {
-            reason: 'no_active_file',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.NotFound,
-            when: 'Target was `active` but no file is currently open in Obsidian.',
-            recovery: 'Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.',
-        },
-        {
-            reason: 'periodic_unsupported',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.NotFound,
-            when: 'Target was `periodic` and this vault runs Local REST API v5.0.2 or later without the companion periodic-notes extension, so the `/periodic/` routes are not served at all.',
-            recovery: 'Install the periodic-notes extension from https://github.com/coddingtonbear/obsidian-local-rest-api-periodic-notes, or address the note by an explicit vault path.',
-        },
-        {
-            reason: 'periodic_not_found',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.NotFound,
-            when: 'Target was `periodic`, the `/periodic/` routes are served on this vault, and no note exists for the requested period.',
-            recovery: 'Pass an explicit path target — periodic notes must already exist.',
-        },
-        {
-            reason: 'periodic_disabled',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.ValidationError,
-            when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.",
-            recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.",
-        },
-        {
-            reason: 'path_is_directory',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.ValidationError,
-            when: 'The supplied path names a folder rather than a note file. Deleting a folder is not offered — the upstream removes it and everything inside it in one unrecoverable step.',
-            recovery: 'Call obsidian_list_notes with this path to list the folder, then delete files one at a time by their full paths.',
-        },
-        {
-            reason: 'path_traversal',
-            thrownBy: 'service',
-            code: JsonRpcErrorCode.ValidationError,
-            when: 'The path contains a `.` or `..` segment, which is rejected to prevent vault escape.',
-            recovery: 'Supply a vault-relative path with no `.` or `..` segments, e.g. "Projects/Note.md". Use obsidian_list_notes to browse the vault.',
-        },
-    ],
-    async handler(input, ctx) {
-        const svc = getObsidianService();
-        const path = await svc.resolvePath(ctx, input.target);
-        const pathTarget = { type: 'path', path };
-        /**
-         * Probe size before asking for confirmation so the user sees how much
-         * they're about to destroy. Throws `note_missing` if the file is already
-         * gone — preempts a confusing post-confirmation DELETE 404. The probe runs
-         * again on re-entry, so the size is re-verified against the answer round.
-         */
-        const previousSizeInBytes = await svc.getSize(ctx, pathTarget);
-        /**
-         * A declined or cancelled prompt is a dead end, not a round to retry —
-         * re-asking would burn the round budget until the client gives up.
-         */
-        const view = ctx.inputs.view('confirm');
-        if (view.kind === 'elicit' && view.action !== 'accept') {
-            throw ctx.fail('cancelled', `User sent '${view.action}' for the deletion confirmation.`, {
-                path,
-                ...ctx.recoveryFor('cancelled'),
-            });
-        }
-        const answer = ctx.inputs.accepted('confirm', DeleteConfirmation);
-        if (!answer) {
-            return ctx.requestInput({
-                inputRequests: {
-                    confirm: inputRequired.elicit({
-                        message: `Permanently delete '${path}' (${previousSizeInBytes} bytes)? This cannot be undone via the API; recovery would require Obsidian's local trash.`,
-                        requestedSchema: DeleteConfirmation,
-                    }),
-                },
-            });
-        }
-        if (!answer.confirm) {
-            throw ctx.fail('cancelled', 'Deletion cancelled by user.', {
-                path,
-                ...ctx.recoveryFor('cancelled'),
-            });
-        }
-        await svc.deleteNote(ctx, pathTarget);
-        return { path, deleted: true, previousSizeInBytes, currentSizeInBytes: 0 };
-    },
-    format: (result) => [
-        {
-            type: 'text',
-            text: `**Deleted ${result.path}** (size: ${result.previousSizeInBytes} → ${result.currentSizeInBytes} bytes)`,
-        },
-    ],
+/**
+ * What a confirmation prompt confirmed, stored in `ctx.state` under
+ * `consent/<id>` when the handler asks; only the id travels as `requestState`.
+ */
+const ConsentRecord = z.object({
+    operation: z.string().describe('Tool the record was minted for.'),
+    clientId: z.string().describe('Authenticated client that was asked; empty without auth.'),
+    subject: z.string().describe('Authenticated subject that was asked; empty without auth.'),
+    target: z.string().describe('Resolved vault path the user confirmed.'),
+    contentHash: z.string().describe('SHA-256 of the note content the user confirmed.'),
 });
+/**
+ * Read the note at exactly `path`, letter case included, before anything can
+ * be deleted. The plugin's raw-markdown read and its v4.x DELETE
+ * (`adapter.exists` + `adapter.remove`) case-fold on a case-insensitive
+ * filesystem (macOS, Windows), so a wrong-case path would read — and then
+ * permanently remove — the differently-cased note. The `note+json` read
+ * resolves through Obsidian's case-sensitive vault index on v4.x and v5.x, so
+ * a wrong-case path 404s here. A miss names the case-insensitive and
+ * extension-stripped near matches in its folder; a delete never substitutes
+ * one. A folder path still fails `path_is_directory`: the folder listing has
+ * no `Content-Disposition` on this route either.
+ *
+ * The bytes come from a second, raw-markdown read of the path that read
+ * confirmed. `note+json` serves `cachedRead`, which lags a change made outside
+ * Obsidian (sync, git, another editor) until its file watcher fires, so a
+ * hash of it could match a consent record for text the file no longer holds.
+ */
+async function readExactNote(ctx, svc, path) {
+    const target = { type: 'path', path };
+    try {
+        await svc.getNoteJson(ctx, target);
+    }
+    catch (err) {
+        if (!(err instanceof McpError) || err.code !== JsonRpcErrorCode.NotFound)
+            throw err;
+        const suggestions = await findSimilarPaths(ctx, svc, path);
+        if (suggestions.length === 0)
+            throw err;
+        const list = suggestions.map((s) => `"${s}"`).join(', ');
+        throw notFound(`${err.message.replace(/[.!?]?\s*$/, '')}. Did you mean: ${list}?`, { ...(err.data ?? {}), suggestions }, { cause: err });
+    }
+    return await svc.getNoteContent(ctx, target);
+}
+/**
+ * `elicitation` mirrors `OBSIDIAN_DELETE_ELICITATION`. Off, the operator's
+ * `OBSIDIAN_WRITE_PATHS` / `OBSIDIAN_READ_ONLY` are what bound a delete — the
+ * same bound `obsidian_write_note` with `overwrite: true` already has.
+ */
+export function buildDeleteNoteTool({ elicitation }) {
+    return tool('obsidian_delete_note', {
+        description: elicitation
+            ? 'Permanently delete a note from the vault. Asks the user to confirm before deleting — the call is answered with a confirmation request and retried with the answer. Recovery requires the local trash in Obsidian — there is no API-level undo.'
+            : 'Permanently delete a note from the vault. Deletes on the first call without asking the user to confirm. Recovery requires the local trash in Obsidian — there is no API-level undo.',
+        annotations: { destructiveHint: true },
+        input: z.object({
+            target: TargetSchema.describe('Which note to delete.'),
+        }),
+        output: z.object({
+            path: z.string().describe('Resolved vault-relative path of the deleted note.'),
+            deleted: z.boolean().describe('True when the file was removed.'),
+            previousSizeInBytes: z
+                .number()
+                .describe('Byte size of the note immediately before deletion. Confirms the size of what was removed.'),
+            currentSizeInBytes: z
+                .number()
+                .describe('Always 0 after a successful delete — the file no longer exists.'),
+        }),
+        auth: ['tool:obsidian_delete_note:write'],
+        errors: [
+            {
+                reason: 'path_forbidden',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.Forbidden,
+                when: 'The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.',
+                recovery: 'Use a path inside the configured write scope. The error data echoes the active scope.',
+            },
+            /** Declared only where it can fire: the off build never asks, so never throws it. */
+            ...(elicitation
+                ? [
+                    {
+                        reason: 'cancelled',
+                        code: JsonRpcErrorCode.InvalidRequest,
+                        when: 'User declined, cancelled, or answered false to the confirmation request.',
+                        severity: 'notice',
+                        recovery: 'Re-run the tool when the user is ready to confirm deletion.',
+                    },
+                ]
+                : []),
+            {
+                reason: 'note_missing',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.NotFound,
+                when: 'No note has exactly this vault path, letter case included. Near matches in the same folder, such as a different-case spelling, are listed in `suggestions` and never deleted in its place.',
+                recovery: 'Verify the path with obsidian_list_notes or use obsidian_search_notes to locate the note. Deletes match the path exactly, letter case included; pass a path from `suggestions` as given.',
+            },
+            {
+                reason: 'no_active_file',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.NotFound,
+                when: 'Target was `active` but no file is currently open in Obsidian.',
+                recovery: 'Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.',
+            },
+            {
+                reason: 'periodic_unsupported',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.NotFound,
+                when: 'Target was `periodic` and this vault runs Local REST API v5.0.2 or later without the companion periodic-notes extension, so the `/periodic/` routes are not served at all.',
+                recovery: 'Install the periodic-notes extension from https://github.com/coddingtonbear/obsidian-local-rest-api-periodic-notes, or address the note by an explicit vault path.',
+            },
+            {
+                reason: 'periodic_not_found',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.NotFound,
+                when: 'Target was `periodic`, the `/periodic/` routes are served on this vault, and no note exists for the requested period.',
+                recovery: 'Pass an explicit path target — periodic notes must already exist.',
+            },
+            {
+                reason: 'periodic_disabled',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.ValidationError,
+                when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.",
+                recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.",
+            },
+            {
+                reason: 'path_is_directory',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.ValidationError,
+                when: 'The supplied path names a folder rather than a note file. Deleting a folder is not offered — the upstream removes it and everything inside it in one unrecoverable step.',
+                recovery: 'Call obsidian_list_notes with this path to list the folder, then delete files one at a time by their full paths.',
+            },
+            {
+                reason: 'path_traversal',
+                thrownBy: 'service',
+                code: JsonRpcErrorCode.ValidationError,
+                when: 'The path contains a `.` or `..` segment, which is rejected to prevent vault escape.',
+                recovery: 'Supply a vault-relative path with no `.` or `..` segments, e.g. "Projects/Note.md". Use obsidian_list_notes to browse the vault.',
+            },
+        ],
+        async handler(input, ctx) {
+            /**
+             * Redeem first: whatever this round carries, the record it names is spent
+             * before anything acts on the answer. An accepted answer on `ctx.inputs` is
+             * not proof the user was asked — a client that declared elicitation can
+             * pre-answer a call nothing prompted for — so only the record this handler
+             * stored when it asked makes the answer count.
+             *
+             * Single-use holds against a sequential replay, not concurrent retries:
+             * `ctx.state` has no atomic read-and-delete, so retries carrying one id at
+             * the same moment can each read the record before a delete lands, and the
+             * Local REST API DELETE takes no idempotency key to dedupe them upstream.
+             * The losing DELETE finds the file gone and fails `note_missing`, so the
+             * race removes nothing beyond the confirmed note unless that path is
+             * recreated in between. Tracked as cyanheads/mcp-ts-core#593 (an atomic
+             * `ctx.state.take`).
+             *
+             * With the confirmation off, nothing on `ctx.inputs` is read and nothing
+             * is written to `ctx.state`.
+             */
+            const id = elicitation ? ctx.inputs.state() : undefined;
+            const record = id && UUID.test(id) ? await ctx.state.get(`consent/${id}`, ConsentRecord) : null;
+            if (record)
+                await ctx.state.delete(`consent/${id}`);
+            /**
+             * Write scope is checked on the resolved path before the note is read, so
+             * a note the caller can read but not delete fails `path_forbidden` without
+             * a prompt or a stored record.
+             */
+            const svc = getObsidianService();
+            const path = await svc.resolvePath(ctx, input.target);
+            svc.policy.assertWritable(path);
+            const pathTarget = { type: 'path', path };
+            /**
+             * The read runs in both modes: it throws `path_is_directory` for a folder,
+             * which the DELETE would remove with everything inside it, and
+             * `note_missing` when no note has exactly this path — already gone, or a
+             * case variant of one (see `readExactNote`). With the confirmation on, it
+             * also serves the prompt and the record: the bytes the user is told
+             * they're destroying, and the hash a later round must still match.
+             */
+            const content = await readExactNote(ctx, svc, path);
+            const previousSizeInBytes = Buffer.byteLength(content);
+            if (elicitation) {
+                const expected = {
+                    operation: OPERATION,
+                    clientId: ctx.auth?.clientId ?? '',
+                    subject: ctx.auth?.sub ?? '',
+                    target: path,
+                    contentHash: createHash('sha256').update(content).digest('hex'),
+                };
+                const matches = record !== null && isDeepStrictEqual(record, expected);
+                /**
+                 * A declined or cancelled prompt the user was actually shown is a dead
+                 * end, not a round to retry — re-asking would burn the round budget
+                 * until the client gives up.
+                 */
+                const view = ctx.inputs.view('confirm');
+                if (matches && view.kind === 'elicit' && view.action !== 'accept') {
+                    throw ctx.fail('cancelled', `User sent '${view.action}' for the deletion confirmation.`, {
+                        path,
+                    });
+                }
+                const answer = matches ? ctx.inputs.accepted('confirm', DeleteConfirmation) : undefined;
+                if (!answer) {
+                    const fresh = randomUUID();
+                    await ctx.state.set(`consent/${fresh}`, expected, { ttl: CONSENT_TTL_SECONDS });
+                    return ctx.requestInput({
+                        inputRequests: {
+                            confirm: inputRequired.elicit({
+                                message: `Permanently delete '${path}' (${previousSizeInBytes} bytes)? This cannot be undone via the API; recovery would require Obsidian's local trash.`,
+                                requestedSchema: DeleteConfirmation,
+                            }),
+                        },
+                        requestState: fresh,
+                    });
+                }
+                if (!answer.confirm) {
+                    throw ctx.fail('cancelled', 'Deletion cancelled by user.', { path });
+                }
+            }
+            await svc.deleteNote(ctx, pathTarget);
+            return { path, deleted: true, previousSizeInBytes, currentSizeInBytes: 0 };
+        },
+        format: (result) => [
+            {
+                type: 'text',
+                text: `**Deleted ${result.path}** (size: ${result.previousSizeInBytes} → ${result.currentSizeInBytes} bytes)`,
+            },
+        ],
+    });
+}
+/**
+ * Static specimen for the MCP definition linter (which duck-types tool
+ * exports out of each `.tool.ts` file) and for tests that import the tool
+ * directly. Built with the confirmation off — the default, and what an
+ * unconfigured install registers. The entry point (`src/index.ts`) builds the
+ * live tool via `buildDeleteNoteTool` from `OBSIDIAN_DELETE_ELICITATION`; this
+ * export is not the registered tool. The confirming variant is exercised by
+ * tests rather than the linter (two exports under the same tool name would
+ * collide on `name-unique`).
+ */
+export const obsidianDeleteNote = buildDeleteNoteTool({ elicitation: false });
 //# sourceMappingURL=obsidian-delete-note.tool.js.map

package/dist/mcp-server/tools/definitions/obsidian-delete-note.tool.js.map

@@ -1 +1 @@
-{"version":3,"file":"obsidian-delete-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,kFAAkF;AAClF,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,0DAA0D,CAAC;CAC1F,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC,sBAAsB,EAAE;IAC7D,WAAW,EACT,gPAAgP;IAClP,WAAW,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE;IACtC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;QACd,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,uBAAuB,CAAC;KACvD,CAAC;IACF,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,mDAAmD,CAAC;QAC9E,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,iCAAiC,CAAC;QAChE,mBAAmB,EAAE,CAAC;aACnB,MAAM,EAAE;aACR,QAAQ,CACP,2FAA2F,CAC5F;QACH,kBAAkB,EAAE,CAAC;aAClB,MAAM,EAAE;aACR,QAAQ,CAAC,iEAAiE,CAAC;KAC/E,CAAC;IACF,IAAI,EAAE,CAAC,iCAAiC,CAAC;IACzC,MAAM,EAAE;QACN;YACE,MAAM,EAAE,gBAAgB;YACxB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,SAAS;YAChC,IAAI,EAAE,gGAAgG;YACtG,QAAQ,EACN,uFAAuF;SAC1F;QACD;YACE,MAAM,EAAE,WAAW;YACnB,IAAI,EAAE,gBAAgB,CAAC,cAAc;YACrC,IAAI,EAAE,0EAA0E;YAChF,QAAQ,EAAE,QAAQ;YAClB,QAAQ,EAAE,6DAA6D;SACxE;QACD;YACE,MAAM,EAAE,cAAc;YACtB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,QAAQ;YAC/B,IAAI,EAAE,sDAAsD;YAC5D,QAAQ,EACN,2FAA2F;SAC9F;QACD;YACE,MAAM,EAAE,gBAAgB;YACxB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,QAAQ;YAC/B,IAAI,EAAE,gEAAgE;YACtE,QAAQ,EACN,oFAAoF;SACvF;QACD;YACE,MAAM,EAAE,sBAAsB;YAC9B,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,QAAQ;YAC/B,IAAI,EAAE,4KAA4K;YAClL,QAAQ,EACN,oKAAoK;SACvK;QACD;YACE,MAAM,EAAE,oBAAoB;YAC5B,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,QAAQ;YAC/B,IAAI,EAAE,uHAAuH;YAC7H,QAAQ,EAAE,mEAAmE;SAC9E;QACD;YACE,MAAM,EAAE,mBAAmB;YAC3B,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,IAAI,EAAE,6GAA6G;YACnH,QAAQ,EACN,0GAA0G;SAC7G;QACD;YACE,MAAM,EAAE,mBAAmB;YAC3B,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,IAAI,EAAE,0KAA0K;YAChL,QAAQ,EACN,kHAAkH;SACrH;QACD;YACE,MAAM,EAAE,gBAAgB;YACxB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,gBAAgB,CAAC,eAAe;YACtC,IAAI,EAAE,qFAAqF;YAC3F,QAAQ,EACN,kIAAkI;SACrI;KACF;IAED,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG;QACtB,MAAM,GAAG,GAAG,kBAAkB,EAAE,CAAC;QAEjC,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACtD,MAAM,UAAU,GAAG,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,CAAC;QAEnD;;;;;WAKG;QACH,MAAM,mBAAmB,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QAE/D;;;WAGG;QACH,MAAM,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxC,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YACvD,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,IAAI,CAAC,MAAM,kCAAkC,EAAE;gBACvF,IAAI;gBACJ,GAAG,GAAG,CAAC,WAAW,CAAC,WAAW,CAAC;aAChC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;QAClE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,GAAG,CAAC,YAAY,CAAC;gBACtB,aAAa,EAAE;oBACb,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC;wBAC5B,OAAO,EAAE,uBAAuB,IAAI,MAAM,mBAAmB,4FAA4F;wBACzJ,eAAe,EAAE,kBAAkB;qBACpC,CAAC;iBACH;aACF,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,6BAA6B,EAAE;gBACzD,IAAI;gBACJ,GAAG,GAAG,CAAC,WAAW,CAAC,WAAW,CAAC;aAChC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACtC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,CAAC,EAAE,CAAC;IAC7E,CAAC;IAED,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC;QAClB;YACE,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,aAAa,MAAM,CAAC,IAAI,aAAa,MAAM,CAAC,mBAAmB,MAAM,MAAM,CAAC,kBAAkB,SAAS;SAC9G;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"obsidian-delete-note.tool.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-delete-note.tool.ts"],"names":[],"mappings":"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"}

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

@@ -147,6 +147,7 @@ export declare const obsidianGetNote: import("@cyanheads/mcp-ts-core").ToolDefin
     readonly when: "The path contains a `.` or `..` segment, which is rejected to prevent vault escape.";
     readonly recovery: "Supply a vault-relative path with no `.` or `..` segments, e.g. \"Projects/Note.md\". Use obsidian_list_notes to browse the vault.";
 }], {
+    readonly requestedPath: z.ZodOptional<z.ZodString>;
     readonly notice: z.ZodOptional<z.ZodString>;
 }>;
 //# sourceMappingURL=obsidian-get-note.tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"obsidian-get-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-get-note.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAY,MAAM,+BAA+B,CAAC;AAgB3E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsX1B,CAAC"}
+{"version":3,"file":"obsidian-get-note.tool.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/obsidian-get-note.tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAQ,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAY,MAAM,+BAA+B,CAAC;AAgB3E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiY1B,CAAC"}

package/dist/mcp-server/tools/definitions/obsidian-get-note.tool.js

@@ -8,14 +8,14 @@ import { JsonRpcErrorCode, McpError } from '@cyanheads/mcp-ts-core/errors';
 import { getObsidianService } from '../../../services/obsidian/obsidian-service.js';
 import { computeFenceMask, extractSection, } from '../../../services/obsidian/section-extractor.js';
 import { SectionSchema, TargetSchema } from './_shared/schemas.js';
-import { withCaseFallback } from './_shared/suggest-paths.js';
+import { discloseCaseSubstitution, withCaseFallback } from './_shared/suggest-paths.js';
 const StatSchema = z.object({
     ctime: z.number().describe('Created time, ms since epoch.'),
     mtime: z.number().describe('Modified time, ms since epoch.'),
     size: z.number().describe('File size in bytes.'),
 });
 export const obsidianGetNote = tool('obsidian_get_note', {
-    description: 'Read a note from the vault — by path, the active file, or a periodic note. Choose a `format` projection: raw body, full object, structural document map, or a single section.',
+    description: 'Read a note from the vault — by path, the active file, or a periodic note. Choose a `format` projection: raw body, full object, structural document map, or a single section. A `path` with no exact match but a single case-insensitive match in its folder reads that file instead and reports the path as sent in `requestedPath`; write and delete tools match paths exactly.',
     annotations: { readOnlyHint: true, idempotentHint: true },
     input: z.object({
         format: z
@@ -53,7 +53,7 @@ export const obsidianGetNote = tool('obsidian_get_note', {
                     .object({
                     target: z
                         .string()
-                        .describe('Link target as written — vault path, basename, or alias. No existence check.'),
+                        .describe('Link target — a vault path or basename. A wikilink gives it as Obsidian reads it, without its `#heading` or `|alias` (`\\|alias` in a table); a markdown link gives its URL as written. No existence check.'),
                     type: z.enum(['wikilink', 'markdown']).describe('Source syntax.'),
                 })
                     .describe('A single outgoing link reference.'))
@@ -97,10 +97,14 @@ export const obsidianGetNote = tool('obsidian_get_note', {
             .describe('Mode-discriminated projection of the requested note.'),
     }),
     enrichment: {
+        requestedPath: z
+            .string()
+            .optional()
+            .describe('The `target.path` as sent. Present only when it had no exact match and its single case-insensitive match in the same folder, `result.path`, was read instead — write and delete tools need `result.path`.'),
         notice: z
             .string()
             .optional()
-            .describe('Guidance when a heading locator matched several headings — names the path that was read and points at `candidates` for the rest.'),
+            .describe('Guidance when the read substituted a case-insensitive path match (names both paths), when a heading locator matched several headings (names the path that was read and points at `candidates` for the rest), or both.'),
     },
     auth: ['tool:obsidian_get_note:read'],
     errors: [
@@ -185,16 +189,23 @@ export const obsidianGetNote = tool('obsidian_get_note', {
         const { target } = input;
         if (input.format === 'content') {
             if (target.type === 'path') {
-                const { result: content, resolvedPath } = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteContent(ctx, t));
+                const fallback = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteContent(ctx, t));
+                discloseCaseSubstitution(ctx, fallback, 'read');
                 return {
-                    result: { format: 'content', path: resolvedPath ?? target.path, content },
+                    result: {
+                        format: 'content',
+                        path: fallback.resolvedPath ?? target.path,
+                        content: fallback.result,
+                    },
                 };
             }
             const note = await svc.getNoteJson(ctx, target);
             return { result: { format: 'content', path: note.path, content: note.content } };
         }
         if (input.format === 'full') {
-            const { result: note } = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteJson(ctx, t));
+            const fallback = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteJson(ctx, t));
+            discloseCaseSubstitution(ctx, fallback, 'read');
+            const note = fallback.result;
             return {
                 result: {
                     format: 'full',
@@ -209,11 +220,13 @@ export const obsidianGetNote = tool('obsidian_get_note', {
         }
         if (input.format === 'document-map') {
             if (target.type === 'path') {
-                const { result: map, resolvedPath } = await withCaseFallback(ctx, svc, target, (t) => svc.getDocumentMap(ctx, t));
+                const fallback = await withCaseFallback(ctx, svc, target, (t) => svc.getDocumentMap(ctx, t));
+                discloseCaseSubstitution(ctx, fallback, 'read');
+                const map = fallback.result;
                 return {
                     result: {
                         format: 'document-map',
-                        path: resolvedPath ?? target.path,
+                        path: fallback.resolvedPath ?? target.path,
                         headings: map.headings,
                         blocks: map.blocks,
                         frontmatterFields: map.frontmatterFields,
@@ -237,10 +250,11 @@ export const obsidianGetNote = tool('obsidian_get_note', {
         if (!input.section) {
             throw ctx.fail('section_required', '`section` is required when `format` is "section".', {
                 format: input.format,
-                ...ctx.recoveryFor('section_required'),
             });
         }
-        const { result: note } = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteJson(ctx, t));
+        const fallback = await withCaseFallback(ctx, svc, target, (t) => svc.getNoteJson(ctx, t));
+        const caseNotice = discloseCaseSubstitution(ctx, fallback, 'read');
+        const note = fallback.result;
         // `extractSection` throws `NotFound` for missing heading/block/frontmatter
         // targets — those route through the contract; anything else bubbles up to
         // the framework's default classifier.
@@ -251,12 +265,13 @@ export const obsidianGetNote = tool('obsidian_get_note', {
         catch (err) {
             if (!(err instanceof McpError) || err.code !== JsonRpcErrorCode.NotFound)
                 throw err;
-            throw ctx.fail('section_missing', err.message, { path: note.path, section: input.section, ...ctx.recoveryFor('section_missing') }, { cause: err });
+            throw ctx.fail('section_missing', err.message, { path: note.path, section: input.section }, { cause: err });
         }
         const { candidates, sectionTarget, value } = extracted;
         if (candidates) {
             const repeatedPath = candidates.every((c) => c === sectionTarget);
-            ctx.enrich.notice(`Heading \`${input.section.target}\` is ambiguous — ${candidates.length} headings share that name; read \`${sectionTarget}\`. See \`candidates\` for the rest.${repeatedPath ? ' Every one has the same full path, so the write tools reject it with `ambiguous_section`.' : ''}`);
+            const headingNotice = `Heading \`${input.section.target}\` is ambiguous — ${candidates.length} headings share that name; read \`${sectionTarget}\`. See \`candidates\` for the rest.${repeatedPath ? ' Every one has the same full path, so the write tools reject it with `ambiguous_section`.' : ''}`;
+            ctx.enrich.notice(caseNotice ? `${caseNotice} ${headingNotice}` : headingNotice);
         }
         return {
             result: {
@@ -344,6 +359,37 @@ function stringifyValue(v) {
         return v;
     return JSON.stringify(v, null, 2);
 }
+/**
+ * Wikilink: `[[body]]` or `![[body]]`, matched as Obsidian's metadata cache
+ * reads it — from `[[` to the first `]]` on the same line. Single `[` and `]`
+ * belong to the body (`[[Note|see [1]]]` links `Note`), but a second `[[`
+ * starts the link over, so every match attempt stops at the next `[[`, `]]`,
+ * or newline and the scan stays linear in note length. {@link wikilinkTarget}
+ * takes the target out of the body.
+ */
+const WIKILINK = /!?\[\[((?:(?!\[\[|\]\])[^\n])*)\]\]/g;
+/**
+ * The target of a wikilink body: the text before the first `|` (alias) or `#`
+ * (section). A backslash right before the alias pipe escapes it — Obsidian
+ * reads `[[Note\|A]]` as `Note` (the only way to alias inside a table cell) —
+ * while any other backslash stays: `[[Note\#H]]` and `[[Note\\|A]]` give `Note\`.
+ */
+function wikilinkTarget(body) {
+    const end = body.search(/[|#]/);
+    if (end < 0)
+        return body.trim();
+    const target = body.slice(0, end);
+    return (body[end] === '|' && target.endsWith('\\') ? target.slice(0, -1) : target).trim();
+}
+/**
+ * Markdown link: `[text](url)` or `[text](url "title")`. The URL is either
+ * `<bracketed text with spaces>` — the markdown spec's escape hatch for paths
+ * containing spaces — or a non-whitespace run whose parentheses come in
+ * balanced pairs (`Note(1).md`). The text may not contain `[` or `]`, and a
+ * bare URL ends at an unpaired `(`, so an unclosed `[` or `[a](` stops at the
+ * next bracket or parenthesis instead of scanning to the end of the note.
+ */
+const MARKDOWN_LINK = /\[[^[\]]*\]\((<[^<>\n]+>|(?:[^()\s]|\([^()\s]*\))+)(?:\s+"[^"]*")?\)/g;
 /**
  * Extract outgoing link references from note content. Captures Obsidian
  * wikilinks (`[[target]]`, `![[target]]`, with optional `|alias` or
@@ -357,17 +403,12 @@ function stringifyValue(v) {
 function parseOutgoingLinks(content) {
     const cleaned = stripMarkdownCode(content);
     const links = [];
-    for (const m of cleaned.matchAll(/!?\[\[([^\]|#]+)(?:[#|][^\]]*)?\]\]/g)) {
-        const target = m[1]?.trim();
+    for (const m of cleaned.matchAll(WIKILINK)) {
+        const target = wikilinkTarget(m[1] ?? '');
         if (target)
             links.push({ target, type: 'wikilink' });
     }
-    /**
-     * URL group accepts either `<bracketed text with spaces>` or a non-whitespace
-     * run. The bracketed form is the markdown spec's escape hatch for paths
-     * containing spaces.
-     */
-    for (const m of cleaned.matchAll(/\[[^\]]*\]\((<[^<>\n]+>|[^)\s]+)(?:\s+"[^"]*")?\)/g)) {
+    for (const m of cleaned.matchAll(MARKDOWN_LINK)) {
         let target = m[1]?.trim();
         if (!target)
             continue;