obelisk-mcp 0.1.0 → 0.1.2

package/README.md

@@ -4,8 +4,8 @@ Inline comments and GitHub-style suggested edits for [Obsidian](https://obsidian
 
 Select a passage, leave a comment on it, and optionally propose a replacement
 that can be applied with one click. Comments are stored in the note's own
-frontmatter, so they travel with the file through sync, git, export and rename.
-There is no sidecar database to fall out of step with the vault.
+frontmatter, so they travel with the file through sync, git, export and
+rename.
 
 > An *obelus* (†) was the mark ancient editors drew in the margin of a
 > manuscript to say: this passage is disputed.
@@ -13,8 +13,9 @@ There is no sidecar database to fall out of step with the vault.
 ## Status
 
 Pre-release. Anchoring, decoration, the sidebar, suggested edits and the agent
-integration are implemented. Not yet released or submitted to the community
-plugin list, and not yet exercised against a large vault.
+integration are implemented. The CLI and the MCP server are on npm as
+`obelisk-mcp`; the plugin has not been submitted to the community plugin list,
+and none of it has been exercised against a large vault.
 
 ## Features
 
@@ -29,7 +30,7 @@ plugin list, and not yet exercised against a large vault.
   underlying text has changed since. It also resolves the comment, and *Reopen*
   is there if the comment asked something the edit did not answer.
 - **Sidebar.** All of a note's comments in document order, or newest first from
-  the sort toggle; click one to scroll the editor to it. Chips filter to open
+  the sort toggle. Click one to scroll the editor to it. Chips filter to open
   comments, to comments carrying a suggestion, or to one agent's review pass.
   Resolved comments stay in the list, greyed rather than hidden, since they are
   still highlighted in the note.
@@ -51,7 +52,7 @@ plugin list, and not yet exercised against a large vault.
   the way down.
 - **Editable.** Rewrite a comment or a reply in the same composer that wrote
   it, suggestion button and all, from the card's *Edit* button or by
-  right-clicking the passage. Edited bodies are marked as such; the anchor is
+  right-clicking the passage. Edited bodies are marked as such. The anchor is
   left alone, so changing what you said never changes what you said it about.
 - **Deletable.** A whole comment from the card's *Delete*, or a single reply
   from the trash icon in its header, so striking one remark out of a thread
@@ -101,57 +102,35 @@ person wrote it, so nothing already in a vault needs migrating.
 ## Agents
 
 The same comments, from outside Obsidian. A model reviews a note and its
-remarks appear in the sidebar of the note you already have open; or you leave
+remarks appear in the sidebar of the note you already have open. Or you leave
 comments asking for things and a model reads them, makes the edits, and
 resolves them.
 
 ```bash
-npm run build
-npm link                              # puts `obelisk` and `obelisk-mcp` on PATH
+npm install -g obelisk-mcp            # puts `obelisk` and `obelisk-mcp` on PATH
 
 obelisk list note.md
 obelisk comment note.md --quote "The horse, which had been standing there, bolted." \
   --body "Two clauses fighting over one sentence." --run r7k2mq
 ```
 
-For an agent that speaks MCP, register the server with it. Nothing is published
-to npm yet, so point at the built file:
+For an agent that speaks MCP, register the server with it:
 
 ```bash
-npm run build                          # from the root of this repo
-claude mcp add obelisk --scope user -- \
-  node "$PWD/dist/mcp.mjs" --vault /path/to/your/vault
+claude mcp add obelisk --scope user -- npx -y obelisk-mcp
 ```
 
-`$PWD` fills in this repo's path, so the vault is the only one you have to
-supply, and it has to be a real one. A path that does not exist makes `node`
-exit before it says anything, which reaches the agent as `CONNECTION_CLOSED`
-and names nothing; if you see that, the path in `claude mcp get obelisk` is the
-first thing to check.
-
-Two things bite here, both of them silent:
-
-- **Scope.** `claude mcp add` defaults to `local`, which files the server under
-  the directory you happened to run it in. Run it from this repo and you get a
-  server that exists only while you are in this repo, the one place you have no
-  notes to comment on. `--scope user` registers it everywhere; `--scope
-  project` writes a `.mcp.json` in the vault instead, if the vault is a repo
-  and everyone working in it should get the server.
-- **`npx obelisk-mcp` only works inside this repo.** The package is not on npm
-  yet, and inside the repo npx resolves the bin out of the local
-  `package.json`. Anywhere else it goes to the registry and 404s. Use the
-  absolute path above, or `npm link` first and register `obelisk-mcp`.
-
-Both paths have to be absolute. The server is spawned without a shell, so a `~`
-in a config file stays a literal tilde, and the process inherits the agent's
-working directory rather than the vault's.
+One registration covers every vault: the tools work on whichever vault the
+agent is running in, and an absolute path reaches a note in one it is not. The
+server is listed in the official MCP registry as `io.github.zachhannum/obelisk`
+for a client that installs from there.
 
 **There is nothing to start.** It speaks MCP over stdio: the agent spawns a
 process when a session opens and kills it when the session ends, so
 `obelisk-mcp` is never run by hand and there is no port and no daemon. One
 process per session is also what makes a session's comments share one run chip
-in the sidebar. Rebuild while a session is open and it keeps the old process;
-reconnect it from `/mcp`, or start a new session.
+in the sidebar. A session keeps the process it spawned, so a new version of the
+package arrives at the next one. To take it sooner, reconnect from `/mcp`.
 
 To check the registration, `claude mcp list`, or `/mcp` inside a session. To
 check the server itself with no agent in the way:
@@ -161,7 +140,7 @@ printf '%s\n' \
   '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}}' \
   '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
   '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
-  | node dist/mcp.mjs --vault /abs/path/to/vault
+  | npx -y obelisk-mcp
 ```
 
 That should print the handshake and then the four tools. A server that fails
@@ -178,11 +157,11 @@ plausible wrong number attaches a comment to the wrong paragraph without ever
 looking like an error, so `--near-line` only picks between identical quotes and
 takes a number copied out of `obelisk list`. `--quote` has to appear in the
 note character for character, and if it does not, or appears twice, nothing is
-written and the tool says so. `obelisk list` prints the body line-numbered so
+written and the reason is printed. `obelisk list` prints the body numbered so
 the exact text is there to copy.
 
 Writes are frontmatter-only and leave the body byte-identical, so they are safe
-while the note is open in Obsidian; a write also re-reads the file first and
+while the note is open in Obsidian. A write also re-reads the file first and
 refuses if it changed underneath.
 
 ## Development

package/dist/cli.mjs

@@ -7351,9 +7351,39 @@ var require_dist = __commonJS({
 
 // src/cli/main.ts
 import { readFile, writeFile } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve as resolvePath } from "node:path";
+import { basename } from "node:path";
 import { parseArgs } from "node:util";
 
+// src/bin/vault.ts
+import { existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve as resolvePath } from "node:path";
+function findVault(from = process.cwd()) {
+  let dir = resolvePath(from);
+  for (; ; ) {
+    if (isDirectory(join(dir, ".obsidian"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function notePath(arg) {
+  const named = arg.endsWith(".md") ? arg : `${arg}.md`;
+  if (isAbsolute(named)) return resolvePath(named);
+  const fromCwd = resolvePath(named);
+  if (existsSync(fromCwd)) return fromCwd;
+  const vault = findVault();
+  if (!vault) return fromCwd;
+  const fromVault = resolvePath(join(vault, named));
+  return existsSync(fromVault) ? fromVault : fromCwd;
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 // src/core/note.ts
 var import_yaml = __toESM(require_dist());
 
@@ -8048,8 +8078,12 @@ Attribution
   every comment in one review; --human writes an ordinary human comment
   instead.
 
+Note paths
+  <note> is resolved from the working directory, then from the root of the
+  vault it is in, so a bare note name works from anywhere under the vault.
+  The .md is optional.
+
 Options
-  --vault DIR     Resolve <note> inside this vault (or $OBELISK_VAULT).
   --body -        Read the comment body from stdin, fences and all.
   --author NAME   Written into \`author\`. Defaults to the model, or "agent".
   --model NAME    Recorded on the comment as the model that wrote it.
@@ -8068,7 +8102,6 @@ var OPTIONS = {
   run: { type: "string" },
   model: { type: "string" },
   author: { type: "string" },
-  vault: { type: "string" },
   open: { type: "boolean", default: false },
   json: { type: "boolean", default: false },
   "no-body": { type: "boolean", default: false },
@@ -8127,7 +8160,7 @@ ${USAGE}`);
   }
 }
 async function listCommand(flags, args) {
-  const path = notePath(flags, args[0]);
+  const path = notePath2(args[0]);
   const listing = list(await read(path), basename(path));
   const shown = flags.open ? listing.comments.filter((c) => !c.resolved) : listing.comments;
   if (flags.json) {
@@ -8148,7 +8181,7 @@ async function listCommand(flags, args) {
   return 0;
 }
 async function commentCommand(flags, args) {
-  const path = notePath(flags, args[0]);
+  const path = notePath2(args[0]);
   const quote = flags.quote;
   if (!quote) throw new UsageError("comment needs --quote.");
   const body = await bodyArg(flags);
@@ -8169,7 +8202,7 @@ async function commentCommand(flags, args) {
   return 0;
 }
 async function replyCommand(flags, args) {
-  const path = notePath(flags, args[0]);
+  const path = notePath2(args[0]);
   const id = args[1];
   if (!id) throw new UsageError("reply needs the id of the comment to reply to.");
   const body = await bodyArg(flags);
@@ -8183,7 +8216,7 @@ async function replyCommand(flags, args) {
   return 0;
 }
 async function resolveCommand(flags, args) {
-  const path = notePath(flags, args[0]);
+  const path = notePath2(args[0]);
   const id = args[1];
   if (!id) throw new UsageError("resolve needs the id of a comment.");
   const result = await edit(
@@ -8294,11 +8327,9 @@ function oneLine(text, max = 120) {
   const flat = text.replace(/\s+/g, " ").trim();
   return flat.length > max ? flat.slice(0, max - 1) + "\u2026" : flat;
 }
-function notePath(flags, arg) {
+function notePath2(arg) {
   if (!arg) throw new UsageError("Which note? Pass a path.");
-  const vault = flags.vault ?? process.env.OBELISK_VAULT;
-  const path = isAbsolute(arg) || !vault ? resolvePath(arg) : resolvePath(join(vault, arg));
-  return path.endsWith(".md") ? path : `${path}.md`;
+  return notePath(arg);
 }
 async function bodyArg(flags) {
   if (flags.body === void 0) {

package/dist/mcp.mjs

@@ -295,24 +295,24 @@ var require_scope = __commonJS({
           return;
         return vs.get(keyOrRef);
       }
-      scopeRefs(scopeName, values2 = this._values) {
-        return this._reduceValues(values2, (name) => {
+      scopeRefs(scopeName, values = this._values) {
+        return this._reduceValues(values, (name) => {
           if (name.scopePath === void 0)
             throw new Error(`CodeGen: name "${name}" has no value`);
           return (0, code_1._)`${scopeName}${name.scopePath}`;
         });
       }
-      scopeCode(values2 = this._values, usedValues, getCode) {
-        return this._reduceValues(values2, (name) => {
+      scopeCode(values = this._values, usedValues, getCode) {
+        return this._reduceValues(values, (name) => {
           if (name.value === void 0)
             throw new Error(`CodeGen: name "${name}" has no value`);
           return name.value.code;
         }, usedValues, getCode);
       }
-      _reduceValues(values2, valueCode, usedValues = {}, getCode) {
+      _reduceValues(values, valueCode, usedValues = {}, getCode) {
         let code = code_1.nil;
-        for (const prefix in values2) {
-          const vs = values2[prefix];
+        for (const prefix in values) {
+          const vs = values[prefix];
           if (!vs)
             continue;
           const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
@@ -14509,8 +14509,7 @@ var require_dist2 = __commonJS({
 
 // src/mcp/main.ts
 import { readFile, writeFile } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve as resolvePath } from "node:path";
-import { parseArgs } from "node:util";
+import { basename } from "node:path";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -17823,9 +17822,9 @@ ZodLiteral.create = (value, params) => {
     ...processCreateParams(params)
   });
 };
-function createZodEnum(values2, params) {
+function createZodEnum(values, params) {
   return new ZodEnum({
-    values: values2,
+    values,
     typeName: ZodFirstPartyTypeKind.ZodEnum,
     ...processCreateParams(params)
   });
@@ -17881,14 +17880,14 @@ var ZodEnum = class _ZodEnum extends ZodType {
     }
     return enumValues;
   }
-  extract(values2, newDef = this._def) {
-    return _ZodEnum.create(values2, {
+  extract(values, newDef = this._def) {
+    return _ZodEnum.create(values, {
       ...this._def,
       ...newDef
     });
   }
-  exclude(values2, newDef = this._def) {
-    return _ZodEnum.create(this.options.filter((opt) => !values2.includes(opt)), {
+  exclude(values, newDef = this._def) {
+    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
       ...this._def,
       ...newDef
     });
@@ -17926,9 +17925,9 @@ var ZodNativeEnum = class extends ZodType {
     return this._def.values;
   }
 };
-ZodNativeEnum.create = (values2, params) => {
+ZodNativeEnum.create = (values, params) => {
   return new ZodNativeEnum({
-    values: values2,
+    values,
     typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
     ...processCreateParams(params)
   });
@@ -18810,8 +18809,8 @@ function assert(_) {
 }
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values2 = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
-  return values2;
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values;
 }
 function joinValues(array2, separator = "|") {
   return array2.map((val) => stringifyPrimitive(val)).join(separator);
@@ -21967,10 +21966,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
     const opts = def.options;
     const map2 = /* @__PURE__ */ new Map();
     for (const o of opts) {
-      const values2 = o._zod.propValues?.[def.discriminator];
-      if (!values2 || values2.size === 0)
+      const values = o._zod.propValues?.[def.discriminator];
+      if (!values || values.size === 0)
         throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
-      for (const v of values2) {
+      for (const v of values) {
         if (map2.has(v)) {
           throw new Error(`Duplicate discriminator value "${String(v)}"`);
         }
@@ -22253,11 +22252,11 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       return payload;
     }
     const proms = [];
-    const values2 = def.keyType._zod.values;
-    if (values2 && !def.partial) {
+    const values = def.keyType._zod.values;
+    if (values && !def.partial) {
       payload.value = memo2 ? memo2.alloc(inst, payload, {}, ctx) : {};
       const recordKeys = /* @__PURE__ */ new Set();
-      for (const key of values2) {
+      for (const key of values) {
         if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
           recordKeys.add(typeof key === "number" ? key.toString() : key);
           if (key === "__proto__")
@@ -22343,7 +22342,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         if (keyResult.issues.length) {
           if (def.mode === "loose") {
             payload.value[key] = input2[key];
-          } else if (values2) {
+          } else if (values) {
             unrecognized = unrecognized ?? [];
             unrecognized.push(key);
           } else {
@@ -22492,10 +22491,10 @@ function handleSetResult(result, final) {
 }
 var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   $ZodType.init(inst, def);
-  const values2 = getEnumValues(def.entries);
-  const valuesSet = new Set(values2);
+  const values = getEnumValues(def.entries);
+  const valuesSet = new Set(values);
   inst._zod.values = valuesSet;
-  const patternValues = values2.filter((k) => propertyKeyTypes.has(typeof k));
+  const patternValues = values.filter((k) => propertyKeyTypes.has(typeof k));
   inst._zod.pattern = new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join("|")})$` : "^[^\\s\\S]$");
   inst._zod.parse = (payload, _ctx) => {
     const input2 = payload.value;
@@ -22504,7 +22503,7 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
     }
     payload.issues.push({
       code: "invalid_value",
-      values: values2,
+      values,
       input: input2,
       inst
     });
@@ -22513,12 +22512,12 @@ var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 });
 var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
   $ZodType.init(inst, def);
-  const values2 = new Set(def.values);
-  inst._zod.values = values2;
+  const values = new Set(def.values);
+  inst._zod.values = values;
   inst._zod.pattern = new RegExp(def.values.length ? `^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$` : "^[^\\s\\S]$");
   inst._zod.parse = (payload, _ctx) => {
     const input2 = payload.value;
-    if (values2.has(input2)) {
+    if (values.has(input2)) {
       return payload;
     }
     payload.issues.push({
@@ -22577,8 +22576,8 @@ var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
   defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
   inst._zod.optout = "optional";
   defineLazyInternal(inst, "values", (zod) => {
-    const values2 = zod.def.innerType._zod.values;
-    return values2 ? /* @__PURE__ */ new Set([...values2, void 0]) : void 0;
+    const values = zod.def.innerType._zod.values;
+    return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;
   });
   defineLazyInternal(inst, "pattern", (zod) => {
     const pattern = zod.def.innerType._zod.pattern;
@@ -31662,15 +31661,15 @@ function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
 }
 function generateLiteralCheck(doc, ctx, schema, accessor) {
   const def = schema._zod.def;
-  const values2 = def.values;
-  if (values2.length !== 1) {
-    const literalSet = addConstant(ctx, new Set(values2));
+  const values = def.values;
+  if (values.length !== 1) {
+    const literalSet = addConstant(ctx, new Set(values));
     doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
     return accessor;
   }
-  const value = values2[0];
+  const value = values[0];
   if (typeof value === "number" && Number.isNaN(value)) {
-    const literalSet = addConstant(ctx, new Set(values2));
+    const literalSet = addConstant(ctx, new Set(values));
     doc.write(`if (!${literalSet}.has(${accessor})) return INVALID;`);
     return accessor;
   }
@@ -31690,11 +31689,11 @@ function generateLiteralCheck(doc, ctx, schema, accessor) {
   return accessor;
 }
 function generateEnumCheck(doc, ctx, schema, accessor) {
-  const values2 = schema._zod.values;
-  if (!values2) {
+  const values = schema._zod.values;
+  if (!values) {
     throw new ZodCompileUnsupportedError("enum schema without enumerated values");
   }
-  const enumSet = addConstant(ctx, values2);
+  const enumSet = addConstant(ctx, values);
   doc.write(`if (!${enumSet}.has(${accessor})) return INVALID;`);
   return accessor;
 }
@@ -31843,8 +31842,8 @@ function generateUnionCheck(doc, ctx, schema, accessor) {
   }
   const allLiterals = options.every((opt) => opt._zod.def.type === "literal" && !opt._zod.def.checks?.length);
   if (allLiterals) {
-    const values2 = new Set(options.flatMap((opt) => opt._zod.def.values));
-    const valuesConst = addConstant(ctx, values2);
+    const values = new Set(options.flatMap((opt) => opt._zod.def.values));
+    const valuesConst = addConstant(ctx, values);
     doc.write(`if (!${valuesConst}.has(${accessor})) return INVALID;`);
     return accessor;
   }
@@ -31881,17 +31880,17 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
   let firstBranch = true;
   const claimed = /* @__PURE__ */ new Set();
   for (const option of def.options) {
-    const values2 = option._zod.propValues?.[def.discriminator];
-    if (!values2 || values2.size === 0) {
+    const values = option._zod.propValues?.[def.discriminator];
+    if (!values || values.size === 0) {
       throw new ZodCompileUnsupportedError("discriminated union option without static discriminator values");
     }
-    for (const value of values2) {
+    for (const value of values) {
       if (claimed.has(value)) {
         throw new ZodCompileUnsupportedError(`duplicate discriminator value ${String(value)}`);
       }
       claimed.add(value);
     }
-    const conditions = Array.from(values2, (value) => literalEquality(ctx, discVar, value));
+    const conditions = Array.from(values, (value) => literalEquality(ctx, discVar, value));
     const prefix = firstBranch ? "if" : "else if";
     doc.write(`${prefix} (${conditions.join(" || ")}) {`);
     doc.indented((d) => {
@@ -32970,8 +32969,8 @@ function _set(Class2, valueType, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _enum(Class2, values2, params) {
-  const entries = Array.isArray(values2) ? Object.fromEntries(values2.map((v) => [v, v])) : values2;
+function _enum(Class2, values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   return new Class2({
     type: "enum",
     entries,
@@ -33887,16 +33886,16 @@ var dateProcessor = (schema, ctx, json2, params) => {
 };
 var enumProcessor = (schema, _ctx, json2, _params) => {
   const def = schema._zod.def;
-  const values2 = getEnumValues(def.entries);
-  if (values2.length === 0) {
+  const values = getEnumValues(def.entries);
+  if (values.length === 0) {
     json2.not = {};
     return;
   }
-  if (values2.every((v) => typeof v === "number"))
+  if (values.every((v) => typeof v === "number"))
     json2.type = "number";
-  if (values2.every((v) => typeof v === "string"))
+  if (values.every((v) => typeof v === "string"))
     json2.type = "string";
-  json2.enum = values2;
+  json2.enum = values;
 };
 var literalProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
@@ -34171,8 +34170,8 @@ function stringifyKeyNames(bySchema, json2, visited) {
   }
   const types = Array.isArray(json2.type) ? json2.type : [json2.type];
   const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
-  const values2 = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
-  if (!numericType && !values2?.some((v) => typeof v === "number"))
+  const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
+  if (!numericType && !values?.some((v) => typeof v === "number"))
     return json2;
   const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json2;
   if (rest.enum)
@@ -34182,7 +34181,7 @@ function stringifyKeyNames(bySchema, json2, visited) {
   if (!numericType)
     return rest;
   rest.type = "string";
-  if (!values2)
+  if (!values)
     rest.pattern = (types.includes("number") ? number : integer).source;
   return rest;
 }
@@ -34737,11 +34736,11 @@ function isZ4Schema(s) {
   return !!schema._zod;
 }
 function objectFromShape(shape) {
-  const values2 = Object.values(shape);
-  if (values2.length === 0)
+  const values = Object.values(shape);
+  if (values.length === 0)
     return object({});
-  const allV4 = values2.every(isZ4Schema);
-  const allV3 = values2.every((s) => !isZ4Schema(s));
+  const allV4 = values.every(isZ4Schema);
+  const allV3 = values.every((s) => !isZ4Schema(s));
   if (allV4)
     return object(shape);
   if (allV3)
@@ -34795,8 +34794,8 @@ function normalizeObjectSchema(schema) {
     const asV3 = schema;
     const asV4 = schema;
     if (!asV3._def && !asV4._zod) {
-      const values2 = Object.values(schema);
-      if (values2.length > 0 && values2.every((v) => typeof v === "object" && v !== null && (v._def !== void 0 || v._zod !== void 0 || typeof v.parse === "function"))) {
+      const values = Object.values(schema);
+      if (values.length > 0 && values.every((v) => typeof v === "object" && v !== null && (v._def !== void 0 || v._zod !== void 0 || typeof v.parse === "function"))) {
         return objectFromShape(schema);
       }
     }
@@ -36429,9 +36428,9 @@ var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   inst.enum = def.entries;
   inst.options = Object.values(def.entries);
   const keys = new Set(Object.keys(def.entries));
-  inst.extract = (values2, params) => {
+  inst.extract = (values, params) => {
     const newEntries = {};
-    for (const value of values2) {
+    for (const value of values) {
       if (keys.has(value)) {
         newEntries[value] = def.entries[value];
       } else
@@ -36444,9 +36443,9 @@ var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
       entries: newEntries
     });
   };
-  inst.exclude = (values2, params) => {
+  inst.exclude = (values, params) => {
     const newEntries = { ...def.entries };
-    for (const value of values2) {
+    for (const value of values) {
       if (keys.has(value)) {
         delete newEntries[value];
       } else
@@ -36460,8 +36459,8 @@ var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
     });
   };
 });
-function _enum2(values2, params) {
-  const entries = Array.isArray(values2) ? Object.fromEntries(values2.map((v) => [v, v])) : values2;
+function _enum2(values, params) {
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   return new ZodEnum2({
     type: "enum",
     entries,
@@ -39735,7 +39734,7 @@ function parseMapDef(def, refs) {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "0"]
   }) || parseAnyDef(refs);
-  const values2 = parseDef(def.valueType._def, {
+  const values = parseDef(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "1"]
   }) || parseAnyDef(refs);
@@ -39744,7 +39743,7 @@ function parseMapDef(def, refs) {
     maxItems: 125,
     items: {
       type: "array",
-      items: [keys, values2],
+      items: [keys, values],
       minItems: 2,
       maxItems: 2
     }
@@ -39758,7 +39757,7 @@ function parseNativeEnumDef(def) {
     return typeof object3[object3[key]] !== "number";
   });
   const actualValues = actualKeys.map((key) => object3[key]);
-  const parsedTypes = Array.from(new Set(actualValues.map((values2) => typeof values2)));
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
   return {
     type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
     enum: actualValues
@@ -42977,7 +42976,37 @@ var StdioServerTransport = class {
 };
 
 // package.json
-var version2 = "0.1.0";
+var version2 = "0.1.2";
+
+// src/bin/vault.ts
+import { existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve as resolvePath } from "node:path";
+function findVault(from = process.cwd()) {
+  let dir = resolvePath(from);
+  for (; ; ) {
+    if (isDirectory(join(dir, ".obsidian"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function notePath(arg) {
+  const named = arg.endsWith(".md") ? arg : `${arg}.md`;
+  if (isAbsolute(named)) return resolvePath(named);
+  const fromCwd = resolvePath(named);
+  if (existsSync(fromCwd)) return fromCwd;
+  const vault = findVault();
+  if (!vault) return fromCwd;
+  const fromVault = resolvePath(join(vault, named));
+  return existsSync(fromVault) ? fromVault : fromCwd;
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
 
 // src/core/id.ts
 var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -43641,15 +43670,11 @@ function bodyLineAt(frame, offset) {
 }
 
 // src/mcp/main.ts
-var { values } = parseArgs({
-  args: process.argv.slice(2),
-  options: { vault: { type: "string" } },
-  allowPositionals: false
-});
-var VAULT = values.vault ?? process.env.OBELISK_VAULT ?? process.cwd();
 var RUN = newCommentId();
 var server = new McpServer({ name: "obelisk", version: version2 });
-var noteArg = external_exports.string().describe("Path to the note, relative to the vault root. `.md` optional.");
+var noteArg = external_exports.string().describe(
+  "Path to the note, relative to the vault root or to the working directory. Absolute paths reach a note in another vault. `.md` optional."
+);
 server.registerTool(
   "obelisk_list",
   {
@@ -43742,7 +43767,7 @@ server.registerTool(
   "obelisk_resolve",
   {
     title: "Resolve or reopen a comment",
-    description: "Mark a comment settled \u2014 the reader's sidebar greys it out and drops it from the open count.\n\nThis is what closes the loop on a comment a person left for you: read it, make the edit in the note yourself, then resolve it. Resolving a comment you did not write is allowed, but it says the thing it asked for has been done, so only say that when it has.",
+    description: "Mark a comment settled \u2014 the reader's sidebar greys it out and drops it from the open count.\n\nThis is what closes the loop on a comment a person left for you: read it, make the edit in the note yourself, then resolve it. Resolving a comment you did not write is allowed, but it records that what the comment asked for has been done, so resolve only once it has.",
     inputSchema: {
       note: noteArg,
       id: external_exports.string().describe("The comment's id, from obelisk_list."),
@@ -43771,10 +43796,6 @@ async function write(note, operation) {
   await writeFile(path, result.value.text, "utf8");
   return result;
 }
-function notePath(note) {
-  const path = isAbsolute(note) ? resolvePath(note) : resolvePath(join(VAULT, note));
-  return path.endsWith(".md") ? path : `${path}.md`;
-}
 function summarize(comment2, listing) {
   return {
     id: comment2.id,

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "obelisk-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The Obelisk CLI and MCP server: comment on a passage of an Obsidian note, and propose suggested edits, from outside the app.",
+  "mcpName": "io.github.zachhannum/obelisk",
   "bin": {
     "obelisk": "dist/cli.mjs",
     "obelisk-mcp": "dist/mcp.mjs"