mcp-tabula-api 3.0.0 → 3.1.0

package/dist/index.js

@@ -30982,8 +30982,6 @@ var EMPTY_COMPLETION_RESULT = {
 import * as path from "path";
 import * as fs from "fs/promises";
 import { existsSync } from "fs";
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
 
 // src/utils/tabula-api.ts
 import { exec } from "child_process";
@@ -31009,21 +31007,15 @@ async function apiKey() {
   } catch {}
   throw new Error("Tabula API key not found. Set TABULA_API_KEY in this server's MCP " + "registration (copy it from Tabula → Settings → Headless API).");
 }
-var DEFAULT_ACTOR_ID = process.env.TABULA_ACTOR_ID || "claude";
-async function postNote(body) {
-  const payload = { actor_kind: "agent", actor_id: DEFAULT_ACTOR_ID, ...body };
+async function apiFetch(pathAndQuery, init) {
   let res;
   try {
-    res = await fetch(`${API_BASE}/api/notes`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": await apiKey()
-      },
-      body: JSON.stringify(payload)
+    res = await fetch(`${API_BASE}${pathAndQuery}`, {
+      ...init,
+      headers: { "x-api-key": await apiKey(), ...init?.headers || {} }
     });
   } catch (err) {
-    throw new Error(`Cannot reach Tabula Headless API at ${API_BASE} (${err?.cause?.code || err.message}). ` + "Vault writes require the Tabula app to be running — all mutations go " + "through its audited write path.");
+    throw new Error(`Cannot reach Tabula Headless API at ${API_BASE} (${err?.cause?.code || err.message}). ` + "The Tabula app must be running — this server talks to the vault only " + "through its headless API (reads and writes both).");
   }
   const text = await res.text();
   if (!res.ok) {
@@ -31031,10 +31023,38 @@ async function postNote(body) {
   }
   return text;
 }
+var DEFAULT_ACTOR_ID = process.env.TABULA_ACTOR_ID || "claude";
+async function postNote(body) {
+  const payload = { actor_kind: "agent", actor_id: DEFAULT_ACTOR_ID, ...body };
+  return apiFetch(`/api/notes`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
+async function getNote(relPath) {
+  const text = await apiFetch(`/api/notes?path=${encodeURIComponent(relPath)}`);
+  const json2 = JSON.parse(text);
+  return json2.content;
+}
+async function search(q, limit = 20) {
+  const text = await apiFetch(`/api/search?q=${encodeURIComponent(q)}&limit=${limit}`);
+  return JSON.parse(text);
+}
+var cachedVaultPath = null;
+async function vaultPath() {
+  if (cachedVaultPath)
+    return cachedVaultPath;
+  const text = await apiFetch(`/api/status`);
+  const json2 = JSON.parse(text);
+  if (!json2.vault_path) {
+    throw new Error("Tabula API /api/status returned no vault_path.");
+  }
+  cachedVaultPath = json2.vault_path;
+  return cachedVaultPath;
+}
 
 // src/mcp.ts
-var execAsync2 = promisify2(exec2);
-var VAULT_DST = "/home/takaki2/Documents/tabula_vault";
 function injectOrReplaceId(content, regenerateId) {
   const newId = crypto.randomUUID();
   const eol = content.includes(`\r
@@ -31059,10 +31079,11 @@ function injectOrReplaceId(content, regenerateId) {
     return fm + content;
   }
 }
+var TEXT_ONLY_NOTICE = "Error: Tabula's vault is text-only — only .md files can be imported through " + "the API. Media/binaries live outside the vault by design.";
 function createMcpServer() {
   const server = new McpServer({
     name: "tabula-mcp-api",
-    version: "1.7.0"
+    version: "3.1.0"
   }, {
     instructions: [
       "tabula_vault は「契約を持つ」vault です。ノートを書く/整理する前に、まず契約を読んでください（自動探索でなく明示ロード）:",
@@ -31078,12 +31099,7 @@ function createMcpServer() {
     rel_path: exports_external.string().describe("Relative path inside tabula_vault.")
   }, async ({ rel_path }) => {
     try {
-      const targetPath = path.join(VAULT_DST, rel_path);
-      if (!targetPath.startsWith(VAULT_DST))
-        return { content: [{ type: "text", text: `Error: Path traversal.` }] };
-      if (!existsSync(targetPath))
-        return { content: [{ type: "text", text: `Error: File not found.` }] };
-      const text = await fs.readFile(targetPath, "utf-8");
+      const text = await getNote(rel_path);
       return { content: [{ type: "text", text }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
@@ -31109,110 +31125,100 @@ function createMcpServer() {
     }
   });
   server.tool("tabula_copy", "Copy a markdown file into tabula_vault. It automatically generates a NEW UUID to prevent ID collision. Use this for importing or duplicating.", {
-    src_abs_path: exports_external.string().describe("Absolute path of the source file (can be inside or outside tabula_vault)."),
+    src_abs_path: exports_external.string().describe("Absolute path of the source .md file (can be inside or outside tabula_vault)."),
     dest_rel_path: exports_external.string().describe("Destination relative path inside tabula_vault.")
   }, async ({ src_abs_path, dest_rel_path }) => {
     try {
       if (!existsSync(src_abs_path))
         return { content: [{ type: "text", text: `Error: Source not found.` }] };
-      if (src_abs_path.endsWith(".md")) {
-        const content = await fs.readFile(src_abs_path, "utf-8");
-        const processed = injectOrReplaceId(content, true);
-        await postNote({ path: dest_rel_path, mode: "overwrite", content: processed });
-      } else {
-        const dstPath = path.join(VAULT_DST, dest_rel_path);
-        if (!dstPath.startsWith(VAULT_DST))
-          return { content: [{ type: "text", text: `Error: Invalid destination.` }] };
-        await fs.mkdir(path.dirname(dstPath), { recursive: true });
-        await fs.copyFile(src_abs_path, dstPath);
-      }
+      if (!src_abs_path.endsWith(".md"))
+        return { content: [{ type: "text", text: TEXT_ONLY_NOTICE }] };
+      const content = await fs.readFile(src_abs_path, "utf-8");
+      const processed = injectOrReplaceId(content, true);
+      await postNote({ path: dest_rel_path, mode: "overwrite", content: processed });
       return { content: [{ type: "text", text: `Success: Copied to '${dest_rel_path}' with regenerated UUID (via Tabula API).` }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
     }
   });
   server.tool("tabula_cut", "Move (cut) a file into tabula_vault. It preserves the existing UUID to keep links intact. Automatically injects one if missing.", {
-    src_abs_path: exports_external.string().describe("Absolute path of the source file (can be inside or outside tabula_vault)."),
+    src_abs_path: exports_external.string().describe("Absolute path of the source .md file (can be inside or outside tabula_vault)."),
     dest_rel_path: exports_external.string().describe("Destination relative path inside tabula_vault.")
   }, async ({ src_abs_path, dest_rel_path }) => {
     try {
-      if (!existsSync(src_abs_path))
-        return { content: [{ type: "text", text: `Error: Source not found.` }] };
-      const srcInVault = src_abs_path.startsWith(VAULT_DST + "/");
-      if (srcInVault) {
-        const srcRel = path.relative(VAULT_DST, src_abs_path);
+      const vault = await vaultPath();
+      const vaultRoot = vault.replace(/\/+$/, "");
+      if (src_abs_path === vaultRoot || src_abs_path.startsWith(vaultRoot + "/")) {
+        const srcRel = path.relative(vaultRoot, src_abs_path);
         await postNote({ path: srcRel, mode: "move", dest: dest_rel_path });
         return { content: [{ type: "text", text: `Success: Moved to '${dest_rel_path}' while preserving UUID (via Tabula API).` }] };
       }
-      if (src_abs_path.endsWith(".md")) {
-        const content = await fs.readFile(src_abs_path, "utf-8");
-        const processed = injectOrReplaceId(content, false);
-        await postNote({ path: dest_rel_path, mode: "overwrite", content: processed });
-        await fs.unlink(src_abs_path);
-      } else {
-        const dstPath = path.join(VAULT_DST, dest_rel_path);
-        if (!dstPath.startsWith(VAULT_DST))
-          return { content: [{ type: "text", text: `Error: Invalid destination.` }] };
-        await fs.mkdir(path.dirname(dstPath), { recursive: true });
-        await fs.copyFile(src_abs_path, dstPath);
-        await fs.unlink(src_abs_path);
-      }
+      if (!existsSync(src_abs_path))
+        return { content: [{ type: "text", text: `Error: Source not found.` }] };
+      if (!src_abs_path.endsWith(".md"))
+        return { content: [{ type: "text", text: TEXT_ONLY_NOTICE }] };
+      const content = await fs.readFile(src_abs_path, "utf-8");
+      const processed = injectOrReplaceId(content, false);
+      await postNote({ path: dest_rel_path, mode: "overwrite", content: processed });
+      await fs.unlink(src_abs_path);
       return { content: [{ type: "text", text: `Success: Moved to '${dest_rel_path}' while preserving UUID (via Tabula API).` }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
     }
   });
-  server.tool("tabula_eye", "List directory contents in tabula_vault. Returns files and folders.", {
+  server.tool("tabula_eye", "List directory contents in tabula_vault. Returns files and folders (immediate children of rel_path).", {
     rel_path: exports_external.string().describe("Directory relative path inside tabula_vault (use '' for root).")
   }, async ({ rel_path }) => {
     try {
-      const targetPath = path.join(VAULT_DST, rel_path || ".");
-      if (!targetPath.startsWith(VAULT_DST))
-        return { content: [{ type: "text", text: `Error: Path traversal.` }] };
-      if (!existsSync(targetPath))
-        return { content: [{ type: "text", text: `Error: Directory not found.` }] };
-      const items = await fs.readdir(targetPath, { withFileTypes: true });
-      const list = items.map((i) => `${i.isDirectory() ? "[DIR]" : "[FILE]"} ${i.name}`).join(`
+      const all = await search("", 1e5);
+      const prefix = rel_path ? rel_path.replace(/^\/+|\/+$/g, "") + "/" : "";
+      const children = new Map;
+      for (const r of all) {
+        if (prefix && !r.name.startsWith(prefix))
+          continue;
+        const rest = r.name.slice(prefix.length);
+        if (!rest)
+          continue;
+        const slash = rest.indexOf("/");
+        if (slash === -1)
+          children.set(rest, false);
+        else
+          children.set(rest.slice(0, slash), true);
+      }
+      if (children.size === 0)
+        return { content: [{ type: "text", text: "(empty directory)" }] };
+      const list = [...children.entries()].sort((a, b) => a[0].localeCompare(b[0])).map(([n, isDir]) => `${isDir ? "[DIR]" : "[FILE]"} ${n}`).join(`
 `);
-      return { content: [{ type: "text", text: list || "(empty directory)" }] };
+      return { content: [{ type: "text", text: list }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
     }
   });
-  server.tool("tabula_find", "Find files by filename in tabula_vault.", {
-    query: exports_external.string().describe("Filename or keyword to search for.")
+  server.tool("tabula_find", "Find notes by filename in tabula_vault (fuzzy match on the path).", {
+    query: exports_external.string().describe("Filename or keyword to fuzzy-match against note paths.")
   }, async ({ query }) => {
     try {
-      const { stdout } = await execAsync2(`find "${VAULT_DST}" -type f -iname "*${query}*" | head -n 20`);
-      if (!stdout.trim())
+      const results = await search(query, 20);
+      if (!results.length)
         return { content: [{ type: "text", text: `No files found matching '${query}'` }] };
-      const relativePaths = stdout.trim().split(`
-`).map((p) => path.relative(VAULT_DST, p)).join(`
-`);
-      return { content: [{ type: "text", text: relativePaths }] };
+      return { content: [{ type: "text", text: results.map((r) => r.name).join(`
+`) }] };
     } catch (err) {
-      return { content: [{ type: "text", text: `Search failed or no matches found.` }] };
+      return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
     }
   });
-  server.tool("tabula_grep", "Search file contents using regular expressions in tabula_vault.", {
-    query: exports_external.string().describe("Text or regex to search inside files.")
+  server.tool("tabula_grep", "Full-text search over note contents in tabula_vault. Returns matching notes with snippets.", {
+    query: exports_external.string().describe("Text to search inside note contents.")
   }, async ({ query }) => {
     try {
-      const { stdout } = await execAsync2(`grep -rnI "${query}" "${VAULT_DST}" | head -n 20`);
-      if (!stdout.trim())
+      const results = await search("@" + query, 20);
+      if (!results.length)
         return { content: [{ type: "text", text: `No matches found for '${query}'` }] };
-      const relativePaths = stdout.trim().split(`
-`).map((line) => {
-        const absPath = line.substring(0, line.indexOf(":"));
-        if (absPath.startsWith(VAULT_DST)) {
-          return path.relative(VAULT_DST, absPath) + line.substring(line.indexOf(":"));
-        }
-        return line;
-      }).join(`
+      const lines = results.map((r) => r.snippet ? `${r.name}: ${r.snippet}` : r.name).join(`
 `);
-      return { content: [{ type: "text", text: relativePaths }] };
+      return { content: [{ type: "text", text: lines }] };
     } catch (err) {
-      return { content: [{ type: "text", text: `Search failed or no matches found.` }] };
+      return { content: [{ type: "text", text: `Failed: ${err.message}` }] };
     }
   });
   return server;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcp-tabula-api",
-    "version": "3.0.0",
+    "version": "3.1.0",
     "description": "MCP bridge that lets a cloud AI (Claude, etc.) drive a local Tabula vault via its Headless API.",
     "license": "MIT",
     "type": "module",
@@ -31,4 +31,4 @@
         "hono": "^4.0.0",
         "zod": "^4.3.5"
     }
-}
+}