neuro-vault-mcp 4.1.0 → 4.2.0

package/dist/cli.js

@@ -944,6 +944,33 @@ function extractTags(frontmatter) {
   return out;
 }
 
+// src/lib/obsidian/query/default-regex-options.ts
+var REGEX_KEY = "$regex";
+var OPTIONS_KEY = "$options";
+var DEFAULT_OPTIONS = "i";
+function applyDefaultRegexOptions(filter) {
+  return walk2(filter);
+}
+function walk2(value) {
+  if (Array.isArray(value)) {
+    return value.map(walk2);
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    out[key] = walk2(child);
+  }
+  if (REGEX_KEY in out && !(OPTIONS_KEY in out)) {
+    out[OPTIONS_KEY] = DEFAULT_OPTIONS;
+  }
+  return out;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/lib/obsidian/query/whitelist.ts
 var ALLOWED_OPERATORS = /* @__PURE__ */ new Set([
   "$eq",
@@ -956,32 +983,33 @@ var ALLOWED_OPERATORS = /* @__PURE__ */ new Set([
   "$lte",
   "$exists",
   "$regex",
+  "$options",
   "$and",
   "$or",
   "$nor",
   "$not"
 ]);
 function validateFilter(filter) {
-  if (!isPlainObject(filter)) {
+  if (!isPlainObject2(filter)) {
     throw invalidFilter("filter must be a JSON object");
   }
-  walk2(filter, []);
+  walk3(filter, []);
 }
-function walk2(value, pathSegments) {
+function walk3(value, pathSegments) {
   if (Array.isArray(value)) {
-    value.forEach((entry, idx) => walk2(entry, [...pathSegments, `[${idx}]`]));
+    value.forEach((entry, idx) => walk3(entry, [...pathSegments, `[${idx}]`]));
     return;
   }
-  if (!isPlainObject(value)) return;
+  if (!isPlainObject2(value)) return;
   for (const [key, child] of Object.entries(value)) {
     if (key.startsWith("$") && !ALLOWED_OPERATORS.has(key)) {
       const where = pathSegments.length === 0 ? key : `${pathSegments.join(".")}.${key}`;
       throw invalidFilter(`operator ${key} is not allowed (at ${where})`);
     }
-    walk2(child, [...pathSegments, key]);
+    walk3(child, [...pathSegments, key]);
   }
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function invalidFilter(message) {
@@ -997,6 +1025,7 @@ var READ_BATCH_SIZE2 = 32;
 async function runQueryNotes(input, reader, graph) {
   const validated = validateInput(input);
   validateFilter(validated.filter);
+  const effectiveFilter = applyDefaultRegexOptions(validated.filter);
   if (graph) {
     await graph.ensureFresh();
   }
@@ -1016,7 +1045,7 @@ async function runQueryNotes(input, reader, graph) {
   }
   let matcher;
   try {
-    matcher = sift(validated.filter);
+    matcher = sift(effectiveFilter);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new ToolHandlerError("INVALID_FILTER", `filter rejected by sift: ${message}`);
@@ -1811,7 +1840,7 @@ __export(util_exports, {
   getSizableOrigin: () => getSizableOrigin,
   hexToUint8Array: () => hexToUint8Array,
   isObject: () => isObject,
-  isPlainObject: () => isPlainObject2,
+  isPlainObject: () => isPlainObject3,
   issue: () => issue,
   joinValues: () => joinValues,
   jsonStringifyReplacer: () => jsonStringifyReplacer,
@@ -1995,7 +2024,7 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject2(o) {
+function isPlainObject3(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -2012,7 +2041,7 @@ function isPlainObject2(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject2(o))
+  if (isPlainObject3(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -2205,7 +2234,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -2228,7 +2257,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject2(shape)) {
+  if (!isPlainObject3(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -4503,7 +4532,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject2(a) && isPlainObject2(b)) {
+  if (isPlainObject3(a) && isPlainObject3(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -4657,7 +4686,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload, ctx) => {
     const input = payload.value;
-    if (!isPlainObject2(input)) {
+    if (!isPlainObject3(input)) {
       payload.issues.push({
         expected: "record",
         code: "invalid_type",
@@ -14969,7 +14998,7 @@ function unwrap(schema) {
   }
   return current;
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function describeJsonShape(parsed) {
@@ -15018,7 +15047,7 @@ function coerceFieldValue(schema, value, fieldName = "value") {
     return value;
   }
   if (inner instanceof external_exports.ZodObject || inner instanceof external_exports.ZodRecord) {
-    if (isPlainObject3(value)) return value;
+    if (isPlainObject4(value)) return value;
     if (typeof value === "string") {
       let parsed;
       try {
@@ -15029,7 +15058,7 @@ function coerceFieldValue(schema, value, fieldName = "value") {
           `expected object or JSON-string of one, failed to parse: ${JSON.stringify(value)}`
         );
       }
-      if (isPlainObject3(parsed)) return parsed;
+      if (isPlainObject4(parsed)) return parsed;
       throw new CoerceError(
         fieldName,
         `expected object, parsed JSON resolved to ${describeJsonShape(parsed)}`
@@ -16311,7 +16340,7 @@ function buildQueryNotesTool(deps) {
   return {
     name: "query_notes",
     title: "Query Notes",
-    description: 'Run a structured MongoDB-style query against the vault\'s frontmatter, tags, and wikilink graph. `filter` is a sift/MongoDB filter object evaluated against `NoteRecord` shape `{ path, frontmatter, tags, backlink_count }` \u2014 `tags` is an array of strings (no leading `#`) extracted from the `tags:` frontmatter field; `backlink_count` is the number of vault-wide wikilinks (and `![[embeds]]`) that point at the note. Reference frontmatter keys with the dotted prefix `frontmatter.<key>`. Supported operators: `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`, `$exists`, `$regex`, `$and`, `$or`, `$nor`, `$not`. Optional `path_prefix` restricts the scan to a vault subtree (vault-relative POSIX, no leading slash). Optional `sort` is `{ field, order }` \u2014 `field` must be `"path"`, `"backlink_count"`, or start with `"frontmatter."`. Optional `limit` defaults to 100, max 1000. Optional `include_content` (default false) \u2014 when true, each result also carries `content` (note body). Returns `{ results, count, truncated }`; each result item carries `backlink_count`. `truncated` is true when more notes matched than `limit` allowed. Reads directly from disk and does not require Obsidian to be running.',
+    description: 'Run a structured MongoDB-style query against the vault\'s frontmatter, tags, and wikilink graph. `filter` is a sift/MongoDB filter object evaluated against `NoteRecord` shape `{ path, frontmatter, tags, backlink_count }` \u2014 `tags` is an array of strings (no leading `#`) extracted from the `tags:` frontmatter field; `backlink_count` is the number of vault-wide wikilinks (and `![[embeds]]`) that point at the note. Reference frontmatter keys with the dotted prefix `frontmatter.<key>`. Supported operators: `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`, `$exists`, `$regex`, `$options`, `$and`, `$or`, `$nor`, `$not`. `$regex` is case-insensitive by default; pass `$options` (e.g. `\'\'` for case-sensitive, `\'m\'` for multiline-only) to override. Optional `path_prefix` restricts the scan to a vault subtree (vault-relative POSIX, no leading slash). Optional `sort` is `{ field, order }` \u2014 `field` must be `"path"`, `"backlink_count"`, or start with `"frontmatter."`. Optional `limit` defaults to 100, max 1000. Optional `include_content` (default false) \u2014 when true, each result also carries `content` (note body). Returns `{ results, count, truncated }`; each result item carries `backlink_count`. `truncated` is true when more notes matched than `limit` allowed. Reads directly from disk and does not require Obsidian to be running.',
     inputSchema: inputSchema11,
     handler: async (input) => {
       return runQueryNotes(input, reader, graph);
@@ -16531,7 +16560,7 @@ Use \`read_notes\`, \`create_note\`, \`edit_note\`, \`read_daily\`, \`append_dai
 
 ### Structured queries
 
-Use \`query_notes\` for multi-criteria questions that combine tags, frontmatter properties, and ranges \u2014 for example "active projects with #ai", "todo tasks created this week", "notes with deadline set", "all notes tagged X". The \`filter\` is a MongoDB-style object evaluated against \`{ path, frontmatter, tags, backlink_count }\` \u2014 reference frontmatter keys as \`frontmatter.<key>\`, tags via the top-level \`tags\` field (no leading \`#\`), and \`backlink_count\` as a top-level scalar. Supported operators: \`$eq\`, \`$ne\`, \`$in\`, \`$nin\`, \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`, \`$exists\`, \`$regex\`, \`$and\`, \`$or\`, \`$nor\`, \`$not\`. To list notes by a single tag use \`{ filter: { tags: 'X' } }\`. \`backlink_count\` is filterable (\`{ backlink_count: { $gte: 5 } }\`) and sortable (\`sort: { field: 'backlink_count', order: 'desc' }\`). The result \`{ results, count, truncated }\` includes \`frontmatter\` and \`backlink_count\` always; pass \`include_content: true\` only when bodies are needed up-front (it can grow the response a lot). Reads directly from disk; does not need Obsidian running. \`limit\` defaults to 100 and is capped at 1000.
+Use \`query_notes\` for multi-criteria questions that combine tags, frontmatter properties, and ranges \u2014 for example "active projects with #ai", "todo tasks created this week", "notes with deadline set", "all notes tagged X". The \`filter\` is a MongoDB-style object evaluated against \`{ path, frontmatter, tags, backlink_count }\` \u2014 reference frontmatter keys as \`frontmatter.<key>\`, tags via the top-level \`tags\` field (no leading \`#\`), and \`backlink_count\` as a top-level scalar. Supported operators: \`$eq\`, \`$ne\`, \`$in\`, \`$nin\`, \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`, \`$exists\`, \`$regex\`, \`$options\`, \`$and\`, \`$or\`, \`$nor\`, \`$not\`. \`$regex\` is case-insensitive by default; pass \`$options\` (e.g. \`''\` for case-sensitive, \`'m'\` for multiline-only) to override. To list notes by a single tag use \`{ filter: { tags: 'X' } }\`. \`backlink_count\` is filterable (\`{ backlink_count: { $gte: 5 } }\`) and sortable (\`sort: { field: 'backlink_count', order: 'desc' }\`). The result \`{ results, count, truncated }\` includes \`frontmatter\` and \`backlink_count\` always; pass \`include_content: true\` only when bodies are needed up-front (it can grow the response a lot). Reads directly from disk; does not need Obsidian running. \`limit\` defaults to 100 and is capped at 1000.
 
 ### Frontmatter properties