neuro-vault-mcp 3.3.1 → 3.5.0

package/README.md

@@ -1,12 +1,14 @@
 # Neuro Vault MCP
 
-**Semantic vault search and direct vault operations for your Obsidian vault — right inside your AI assistant.**
+> 🧠💾 **Plug your knowledge in like a USB drive.** Your Obsidian vault, available in every AI conversation — search it, query it, write to it. Same vault in Claude Code, Cursor, Windsurf — no copy-paste, no context-switching, no re-indexing.
 
 [![npm version](https://img.shields.io/npm/v/neuro-vault-mcp)](https://www.npmjs.com/package/neuro-vault-mcp)
 [![Node.js](https://img.shields.io/node/v/neuro-vault-mcp)](https://nodejs.org)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 
-> "What did I write about that idea last month?" — and now your assistant can actually answer.
+Your second brain stops being a folder you open between contexts and becomes a first-class participant in every project. Ask, recall, decide, write back — all without leaving the conversation.
+
+> _"What did I write about that idea last month?"_ — and now your assistant can actually answer.
 
 ---
 
@@ -22,30 +24,35 @@
 
 ---
 
-## 🏗 How it works
+## 🧰 Two superpowers, one server
 
-```mermaid
-flowchart LR
-    You([You]) --> AI[AI assistant]
-    AI <-->|MCP| NV[Neuro Vault]
-    NV <--> Vault[(Obsidian vault)]
-```
+Most "vault MCP" servers give you one or the other. Neuro Vault gives you both, and lets your assistant pick the right one per question:
 
-You ask, the assistant calls Neuro Vault, Neuro Vault reads your vault — semantic search uses embeddings already in `.smart-env/`, vault operations go through the `obsidian` CLI. No database, no background processes.
+|                  | 🔭 **Semantic recall**                                                    | 🛠 **Vault operations**                                                        |
+| ---------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| **What it does** | Finds notes by meaning, not keywords. Surfaces neighbours and duplicates. | Reads, writes, edits notes; manages frontmatter, tags, daily notes.            |
+| **Best for**     | _"What did I think about X?"_, fuzzy recall, exploratory research.        | Structured queries, capturing decisions, updating tasks, batch reads.          |
+| **Powered by**   | Smart Connections embeddings (already in your vault).                     | The official Obsidian CLI — Smart Connections, sync, plugins all stay in sync. |
 
-For module wiring and internal data flow, see [docs/architecture/module-structure.md](./docs/architecture/module-structure.md).
+The two work together: semantic search finds the right region of the vault, vault operations let the assistant actually _do something_ with what it found.
 
 ---
 
-## 🧭 Your vault, but queryable
+## ✨ What it looks like in practice
 
-A plain-text vault is great for humans and rough on agents. Without the right tools, an assistant ends up listing folders, opening dozens of notes, and grepping inside each one just to answer a simple question.
+**Before:** _"Could you check my notes about that LangGraph experiment?"_
+→ Assistant lists `Notes/`, opens 12 files, greps for "LangGraph", gives up halfway, you paste the relevant note manually.
 
-Neuro Vault gives your assistant a way to **ask the vault directly** — by tag, by frontmatter property, by folder, by similarity. Things like:
+**After:** _"Could you check my notes about that LangGraph experiment?"_
+→ One semantic search, top-3 ranked notes back, follow-up question already grounded in your own writing.
+
+A few more questions Neuro Vault makes one-shot:
 
 > _"What are my active projects tagged #ai with a deadline this quarter?"_
-> _"Show meeting notes from `Work/` from the last two weeks."_
+> _"Show meeting notes from `Work/` from the last two weeks, newest first."_
 > _"Find notes similar to this one I'm reading."_
+> _"Append today's decision to the daily note."_
+> _"What did past-me write about retrieval policy before I started building it?"_
 
 One question, one answer. Your assistant stops being a file browser and starts being an actual second brain.
 
@@ -53,6 +60,21 @@ One question, one answer. Your assistant stops being a file browser and starts b
 
 ---
 
+## 🏗 How it works
+
+```mermaid
+flowchart LR
+    You([You]) --> AI[AI assistant]
+    AI <-->|MCP| NV[Neuro Vault]
+    NV <--> Vault[(Obsidian vault)]
+```
+
+You ask, the assistant calls Neuro Vault, Neuro Vault reads your vault — semantic search uses embeddings already in `.smart-env/`, vault operations go through the `obsidian` CLI. No database, no background processes.
+
+For module wiring and internal data flow, see [docs/architecture/module-structure.md](./docs/architecture/module-structure.md).
+
+---
+
 ## ⚡ Quickstart
 
 ```bash

package/dist/cli.js

@@ -14263,6 +14263,16 @@ function date4(params) {
 config(en_default());
 
 // src/lib/input-coercion.ts
+var CoerceError = class extends Error {
+  fieldName;
+  bareMessage;
+  constructor(fieldName, bareMessage) {
+    super(`${fieldName}: ${bareMessage}`);
+    this.name = "CoerceError";
+    this.fieldName = fieldName;
+    this.bareMessage = bareMessage;
+  }
+};
 function unwrap(schema) {
   let current = schema;
   while (current instanceof external_exports.ZodOptional || current instanceof external_exports.ZodNullable || current instanceof external_exports.ZodDefault) {
@@ -14275,35 +14285,87 @@ function unwrap(schema) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function coerceFieldValue(schema, value) {
+function describeJsonShape(parsed) {
+  if (parsed === null) return "null";
+  if (Array.isArray(parsed)) return "array";
+  return typeof parsed;
+}
+function getUnionOptions(union2) {
+  const def = union2._def;
+  return def.options ?? [];
+}
+function isStringArraySchema(schema) {
+  const inner = unwrap(schema);
+  if (!(inner instanceof external_exports.ZodArray)) return false;
+  const def = inner._def;
+  const element = def.element ?? def.type;
+  if (!element) return false;
+  return unwrap(element) instanceof external_exports.ZodString;
+}
+function coerceFieldValue(schema, value, fieldName = "value") {
   if (value === null || value === void 0) return value;
   const inner = unwrap(schema);
   if (inner instanceof external_exports.ZodNumber) {
-    if (typeof value === "string" && value.trim() !== "") {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      if (value.trim() === "") return value;
       const n = Number(value);
       if (Number.isFinite(n)) return n;
+      throw new CoerceError(
+        fieldName,
+        `expected number or numeric string, got ${JSON.stringify(value)}`
+      );
     }
     return value;
   }
   if (inner instanceof external_exports.ZodBoolean) {
+    if (typeof value === "boolean") return value;
     if (value === "true") return true;
     if (value === "false") return false;
+    if (typeof value === "string") {
+      throw new CoerceError(
+        fieldName,
+        `expected boolean or "true"/"false", got ${JSON.stringify(value)}`
+      );
+    }
     return value;
   }
   if (inner instanceof external_exports.ZodObject || inner instanceof external_exports.ZodRecord) {
+    if (isPlainObject2(value)) return value;
     if (typeof value === "string") {
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new CoerceError(
+          fieldName,
+          `expected object or JSON-string of one, failed to parse: ${JSON.stringify(value)}`
+        );
+      }
+      if (isPlainObject2(parsed)) return parsed;
+      throw new CoerceError(
+        fieldName,
+        `expected object, parsed JSON resolved to ${describeJsonShape(parsed)}`
+      );
+    }
+    return value;
+  }
+  if (inner instanceof external_exports.ZodUnion && typeof value === "string") {
+    const options = getUnionOptions(inner);
+    if (options.some(isStringArraySchema)) {
       try {
         const parsed = JSON.parse(value);
-        if (isPlainObject2(parsed)) return parsed;
+        if (Array.isArray(parsed) && parsed.every((x) => typeof x === "string")) {
+          return parsed;
+        }
       } catch {
       }
-      return value;
     }
     return value;
   }
   return value;
 }
-function wrapField(field) {
+function wrapField(field, fieldName) {
   let inner = field;
   let isOptional = false;
   while (inner instanceof external_exports.ZodOptional || inner instanceof external_exports.ZodNullable || inner instanceof external_exports.ZodDefault) {
@@ -14312,7 +14374,17 @@ function wrapField(field) {
     if (!next) break;
     inner = next;
   }
-  const wrapped = external_exports.preprocess((v) => coerceFieldValue(inner, v), inner);
+  const wrapped = external_exports.preprocess((v, ctx) => {
+    try {
+      return coerceFieldValue(inner, v, fieldName);
+    } catch (err) {
+      if (err instanceof CoerceError) {
+        ctx.addIssue({ code: "custom", message: err.bareMessage });
+        return external_exports.NEVER;
+      }
+      throw err;
+    }
+  }, inner);
   return isOptional ? wrapped.optional() : wrapped;
 }
 function wrapSchemaWithCoercion(schema) {
@@ -14320,7 +14392,7 @@ function wrapSchemaWithCoercion(schema) {
   const shape = schema.shape;
   const newShape = {};
   for (const [key, field] of Object.entries(shape)) {
-    newShape[key] = wrapField(field);
+    newShape[key] = wrapField(field, key);
   }
   return external_exports.object(newShape);
 }