neuro-vault-mcp 6.0.0 → 8.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 > 🧠💾 **Make your personal vault usable by agents.** Low-token retrieval, explicit provenance, and safe writes for your Obsidian notes — in Claude Code, Cursor, Windsurf, and any MCP client.
 
-https://github.com/user-attachments/assets/25c1bafb-7b90-43ac-aa50-50e85705fb5b
+[https://github.com/user-attachments/assets/25c1bafb-7b90-43ac-aa50-50e85705fb5b](https://github.com/user-attachments/assets/5ac86cd7-2d67-420d-b940-dba4ae1a2ccb)
 
 [![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)
@@ -140,7 +140,7 @@ Two vaults cannot share the same directory basename — the basename doubles as
 With multiple vaults registered:
 
 - **Every tool** accepts an optional `vault: "<name>"` parameter to target a specific vault.
-- **`search_notes`, `query_notes`, and `get_vault_overview`** fan out across all registered vaults when `vault` is omitted. The response shape switches to `results_by_vault: [...]` (one entry per vault) plus `skipped_vaults: [...]` for any vault the tool could not reach.
+- **`search_notes`, `query_notes`, `get_vault_overview`, `list_tags`, and `list_properties`** fan out across all registered vaults when `vault` is omitted. The response shape switches to `results_by_vault: [...]` (one entry per vault) plus `skipped_vaults: [...]` for any vault the tool could not reach and `failed_vaults: [...]` for per-vault runtime errors (`{ vault, error: { code, message, details? } }`). A single failed vault does not abort the whole call.
 - **All other tools** (writes, reads of specific paths, single-vault diagnostics) require an explicit `vault` in multi-vault mode. Omitting it returns `VAULT_REQUIRED`.
 - **Semantic fan-out** silently skips vaults whose Smart Connections `.smart-env/multi/` index is unavailable. Targeting such a vault explicitly with `vault: "<name>"` returns `SEMANTIC_INDEX_NOT_FOUND`.
 

package/dist/cli.js

@@ -59,10 +59,6 @@ async function parseConfig(argv) {
     type: "boolean",
     default: true,
     describe: "Enable semantic search module (Smart Connections embeddings)"
-  }).option("operations", {
-    type: "boolean",
-    default: true,
-    describe: "Enable vault operations module (Obsidian CLI required at call time)"
   }).option("obsidian-cli", {
     type: "string",
     describe: 'Path to the obsidian CLI binary (default: "obsidian" from PATH)'
@@ -71,9 +67,6 @@ async function parseConfig(argv) {
   if (rawVaults.length === 0) {
     throw new Error("--vault is required: provide at least one vault with --vault <path>");
   }
-  if (!args.semantic && !args.operations) {
-    throw new Error("At least one module must be enabled (--semantic or --operations)");
-  }
   const vaults = rawVaults.map(buildVaultConfig);
   const seen = /* @__PURE__ */ new Set();
   for (const v of vaults) {
@@ -92,10 +85,7 @@ async function parseConfig(argv) {
       modelKey: DEFAULT_MODEL_KEY,
       modelId: DEFAULT_MODEL_ID
     },
-    operations: {
-      enabled: args.operations,
-      binaryPath: args["obsidian-cli"]
-    }
+    obsidianCli: args["obsidian-cli"]
   };
 }
 
@@ -14238,6 +14228,16 @@ var ToolHandlerError = class extends Error {
     }
   }
 };
+var FATAL_TOOL_ERROR_CODES = /* @__PURE__ */ new Set([
+  "INVALID_ARGUMENT",
+  "INVALID_PARAMS",
+  "INVALID_FILTER",
+  "VAULT_REQUIRED",
+  "VAULT_NOT_FOUND"
+]);
+function isFatalToolError(error48) {
+  return error48 instanceof ToolHandlerError && FATAL_TOOL_ERROR_CODES.has(error48.code);
+}
 function isPlainRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
@@ -14315,19 +14315,21 @@ function registerTool(tool) {
 
 // src/lib/resolve-vault.ts
 function resolveVault(input, registry2, opts) {
-  let entry;
   if (input.vault !== void 0 && input.vault !== "") {
-    entry = registry2.require(input.vault);
-  } else if (!registry2.isMulti()) {
-    entry = registry2.list()[0];
-  } else {
-    throw new ToolHandlerError(
-      "VAULT_REQUIRED",
-      `Tool "${opts.tool}" requires a vault: parameter in multi-vault mode`,
-      { details: { tool: opts.tool, registered_vaults: registry2.names() } }
-    );
+    return registry2.require(input.vault);
   }
-  if (opts.requireSemantic && !entry.semanticAvailable) {
+  if (!registry2.isMulti()) {
+    return registry2.list()[0];
+  }
+  throw new ToolHandlerError(
+    "VAULT_REQUIRED",
+    `Tool "${opts.tool}" requires a vault: parameter in multi-vault mode`,
+    { details: { tool: opts.tool, registered_vaults: registry2.names() } }
+  );
+}
+function resolveSemanticVault(input, registry2, opts) {
+  const entry = resolveVault(input, registry2, opts);
+  if (!entry.semanticAvailable) {
     throw new ToolHandlerError(
       "SEMANTIC_INDEX_NOT_FOUND",
       `Semantic index for vault "${entry.name}" is unavailable: ${entry.semanticUnavailableReason ?? "unknown reason"}`,
@@ -14511,9 +14513,8 @@ function buildFindDuplicatesTool(deps) {
     ),
     inputSchema,
     handler: async (input) => {
-      const entry = resolveVault(input, registry2, {
-        tool: "find_duplicates",
-        requireSemantic: true
+      const entry = resolveSemanticVault(input, registry2, {
+        tool: "find_duplicates"
       });
       const corpus = entry.corpus;
       const threshold = readThreshold(input.threshold, DEFAULT_DUPLICATE_THRESHOLD, "threshold");
@@ -15612,9 +15613,8 @@ function buildGetSimilarNotesTool(deps) {
     ),
     inputSchema,
     handler: async (input) => {
-      const entry = resolveVault(input, registry2, {
-        tool: "get_similar_notes",
-        requireSemantic: true
+      const entry = resolveSemanticVault(input, registry2, {
+        tool: "get_similar_notes"
       });
       const corpus = entry.corpus;
       const notePath = normalizeNotePath(input.path);
@@ -15696,9 +15696,8 @@ function buildGetStatsTool(deps) {
     ),
     inputSchema,
     handler: async (input) => {
-      const entry = resolveVault(input, registry2, {
-        tool: "get_stats",
-        requireSemantic: true
+      const entry = resolveSemanticVault(input, registry2, {
+        tool: "get_stats"
       });
       const corpus = entry.corpus;
       try {
@@ -15726,20 +15725,73 @@ function buildGetStatsTool(deps) {
 }
 
 // src/lib/fan-out.ts
+function findFatalRejection(settled) {
+  for (const outcome of settled) {
+    if (outcome.status === "rejected" && isFatalToolError(outcome.reason)) {
+      return outcome.reason;
+    }
+  }
+  return void 0;
+}
+function mapRejectionToFailedVault(vault, reason) {
+  if (reason instanceof ToolHandlerError) {
+    return {
+      vault,
+      error: {
+        code: reason.code,
+        message: reason.message,
+        ...reason.details ? { details: reason.details } : {}
+      }
+    };
+  }
+  return {
+    vault,
+    error: {
+      code: "INTERNAL_ERROR",
+      message: reason instanceof Error ? reason.message : String(reason)
+    }
+  };
+}
 async function runFanOut(registry2, fn) {
   const entries = registry2.list();
-  const results = await Promise.all(
-    entries.map(async (entry) => ({ vault: entry.name, ...await fn(entry) }))
-  );
-  return { results_by_vault: results, skipped_vaults: [] };
+  const settled = await Promise.allSettled(entries.map((entry) => fn(entry)));
+  const fatalError = findFatalRejection(settled);
+  if (fatalError) {
+    throw fatalError;
+  }
+  const results = [];
+  const failed = [];
+  for (let i = 0; i < settled.length; i++) {
+    const outcome = settled[i];
+    const vault = entries[i].name;
+    if (outcome.status === "fulfilled") {
+      results.push({ vault, ...outcome.value });
+    } else {
+      failed.push(mapRejectionToFailedVault(vault, outcome.reason));
+    }
+  }
+  return { results_by_vault: results, skipped_vaults: [], failed_vaults: failed };
 }
 async function runSemanticFanOut(registry2, fn) {
   const eligible = registry2.semanticAvailableEntries();
   const skipped = registry2.list().filter((e) => !e.semanticAvailable).map((e) => ({ vault: e.name, reason: "SEMANTIC_INDEX_NOT_FOUND" }));
-  const results = await Promise.all(
-    eligible.map(async (entry) => ({ vault: entry.name, ...await fn(entry) }))
-  );
-  return { results_by_vault: results, skipped_vaults: skipped };
+  const settled = await Promise.allSettled(eligible.map((entry) => fn(entry)));
+  const fatalError = findFatalRejection(settled);
+  if (fatalError) {
+    throw fatalError;
+  }
+  const results = [];
+  const failed = [];
+  for (let i = 0; i < settled.length; i++) {
+    const outcome = settled[i];
+    const vault = eligible[i].name;
+    if (outcome.status === "fulfilled") {
+      results.push({ vault, ...outcome.value });
+    } else {
+      failed.push(mapRejectionToFailedVault(vault, outcome.reason));
+    }
+  }
+  return { results_by_vault: results, skipped_vaults: skipped, failed_vaults: failed };
 }
 
 // src/modules/semantic/retrieval-policy.ts
@@ -16179,12 +16231,15 @@ function buildSearchNotesTool(deps) {
       if (input.vault === void 0 && registry2.isMulti()) {
         return await runSemanticFanOut(
           registry2,
-          (entry2) => runSearchForEntry(entry2, input, entryDeps)
+          (entry2) => runSearchForEntry(
+            entry2,
+            input,
+            entryDeps
+          )
         );
       }
-      const entry = resolveVault(input, registry2, {
-        tool: "search_notes",
-        requireSemantic: true
+      const entry = resolveSemanticVault(input, registry2, {
+        tool: "search_notes"
       });
       return runSearchForEntry(entry, input, entryDeps);
     }
@@ -16368,9 +16423,6 @@ function buildCreateNoteTool(deps) {
     inputSchema,
     handler: async (input) => {
       const entry = resolveVault(input, registry2, { tool: "create_note" });
-      if (!entry.provider) {
-        throw invalidArgument("operations module is disabled", "vault");
-      }
       if (input.name === void 0 && input.path === void 0) {
         throw invalidArgument("Provide name or path", "name");
       }
@@ -16948,11 +17000,6 @@ function registerResource(resource) {
 // src/modules/operations/resources/vault-overview.ts
 function buildVaultOverviewResource(opts) {
   const { uri, entry } = opts;
-  if (!entry.provider) {
-    throw new Error(
-      `buildVaultOverviewResource: vault "${entry.name}" has no provider \u2014 operations module must be enabled`
-    );
-  }
   return {
     name: uri === "vault://overview" ? "vault-overview" : `vault-overview-${entry.name}`,
     uri,
@@ -17008,8 +17055,8 @@ var VaultRegistry = class _VaultRegistry {
       const reader = deps.readerFactory({ vaultRoot: v.path });
       const graph = deps.graphFactory({ reader });
       const listMatchingPaths = deps.listMatchingPathsFactory({ reader, graph });
-      const writer = config2.operationsEnabled ? deps.writerFactory({ vaultRoot: v.path }) : void 0;
-      const provider = config2.operationsEnabled ? deps.providerFactory({ vaultName: v.name, binaryPath: config2.binaryPath }) : void 0;
+      const writer = deps.writerFactory({ vaultRoot: v.path });
+      const provider = deps.providerFactory({ vaultName: v.name, binaryPath: config2.binaryPath });
       let corpus;
       let semanticAvailable = false;
       let semanticUnavailableReason;
@@ -17304,7 +17351,7 @@ var ObsidianCLIProvider = class {
     if (/vault (not found|does not exist)/i.test(stderr)) {
       return new ToolHandlerError(
         "VAULT_NOT_FOUND",
-        `Obsidian does not recognize a vault named '${this.vaultName}'. This usually means the vault was renamed in Obsidian's "Manage vaults" UI and the display name no longer matches the directory basename. Re-launch the server with --vault-name <exact-name-in-obsidian>.`,
+        `Obsidian does not recognize a vault named '${this.vaultName}'. The MCP-side alias is derived from the vault directory's basename and must match the display name Obsidian shows in "Manage vaults". Rename either the directory (and re-launch with the matching --vault path) or the vault in Obsidian so the two agree.`,
         { details: { stderr, vaultName: this.vaultName }, cause: error48 }
       );
     }
@@ -17489,7 +17536,7 @@ async function buildServerInstructions(registry2) {
 
 ## Multi-vault mode
 
-This server is registered with multiple vaults: ${names}. Every tool accepts an optional \`vault\` parameter. For broad recall, \`search_notes\`, \`query_notes\`, and \`get_vault_overview\` fan out across all vaults when \`vault\` is omitted; other tools (reads of specific paths, writes, single-vault diagnostics) require an explicit \`vault\` \u2014 omitting it returns \`VAULT_REQUIRED\`. Path-shaped parameters (\`path\`, \`paths\`, \`path_prefix\`) remain vault-relative; vault identity is always carried by \`vault\`.`;
+This server is registered with multiple vaults: ${names}. Every tool accepts an optional \`vault\` parameter. For broad recall, \`search_notes\`, \`query_notes\`, \`get_vault_overview\`, \`list_tags\`, and \`list_properties\` fan out across all vaults when \`vault\` is omitted; other tools (reads of specific paths, writes, single-vault diagnostics) require an explicit \`vault\` \u2014 omitting it returns \`VAULT_REQUIRED\`. Fan-out responses include \`results_by_vault\`, \`skipped_vaults\` (vaults pre-filtered out, e.g. missing semantic index), and \`failed_vaults\` (per-vault runtime errors with \`{ code, message, details? }\`) \u2014 a single failed vault does not abort the whole call. Path-shaped parameters (\`path\`, \`paths\`, \`path_prefix\`) remain vault-relative; vault identity is always carried by \`vault\`.`;
   }
   for (const entry of registry2.list()) {
     const extra = await readExternalAgentInstructions(entry.path);
@@ -17522,16 +17569,12 @@ function buildDefaultVaultEntryDeps(overrides = {}) {
   };
 }
 async function startNeuroVaultServer(config2, deps = {}) {
-  if (!config2.semantic.enabled && !config2.operations.enabled) {
-    throw new Error("No modules enabled \u2014 pass --semantic or --operations");
-  }
   const registry2 = await VaultRegistry.create(
     {
       vaults: config2.vaults,
-      operationsEnabled: config2.operations.enabled,
       semanticEnabled: config2.semantic.enabled,
       modelKey: config2.semantic.modelKey,
-      binaryPath: config2.operations.binaryPath
+      binaryPath: config2.obsidianCli
     },
     buildDefaultVaultEntryDeps(deps.vaultEntryDeps)
   );
@@ -17552,15 +17595,9 @@ async function startNeuroVaultServer(config2, deps = {}) {
     toolRegistrations.push(...semantic.tools);
     warmup = semantic.warmup;
   }
-  if (config2.operations.enabled) {
-    const operations = createOperationsModule(
-      registry2,
-      { binaryPath: config2.operations.binaryPath },
-      deps.operations
-    );
-    toolRegistrations.push(...operations.tools);
-    resourceRegistrations.push(...operations.resources);
-  }
+  const operations = createOperationsModule(registry2, {}, deps.operations);
+  toolRegistrations.push(...operations.tools);
+  resourceRegistrations.push(...operations.resources);
   for (const tool of toolRegistrations) {
     server.registerTool(tool.name, tool.spec, tool.handler);
   }