tana-mcp-codemode 0.2.2 → 0.3.0

package/dist/entry-node.js

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/compat/index.ts
+var ops = null;
+function initCompat(compatOps) {
+  if (ops) {
+    console.warn("initCompat called multiple times \u2014 overwriting previous compat ops");
+  }
+  ops = compatOps;
+}
+function getOps() {
+  if (!ops) {
+    throw new Error(
+      "compat not initialized \u2014 call initCompat() before using createDatabase or transpileTS"
+    );
+  }
+  return ops;
+}
+function createDatabase(path) {
+  return getOps().createDatabase(path);
+}
+function transpileTS(code) {
+  return getOps().transpileTS(code);
+}
+
+// src/compat/node.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function getBetterSqlite3() {
+  try {
+    return require2("better-sqlite3");
+  } catch {
+    throw new Error(
+      "better-sqlite3 is required for Node.js. Install it: npm install better-sqlite3"
+    );
+  }
+}
+function getEsbuild() {
+  try {
+    return require2("esbuild");
+  } catch {
+    throw new Error(
+      "esbuild is required for Node.js. Install it: npm install esbuild"
+    );
+  }
+}
+function wrapStatement(stmt) {
+  return {
+    run(...params) {
+      const result = stmt.run(...params);
+      return { changes: result.changes };
+    },
+    all(...params) {
+      return stmt.all(...params);
+    }
+  };
+}
+function wrapDatabase(db2) {
+  return {
+    exec(sql) {
+      db2.exec(sql);
+    },
+    prepare(sql) {
+      return wrapStatement(db2.prepare(sql));
+    },
+    close() {
+      db2.close();
+    }
+  };
+}
+var nodeCompat = {
+  createDatabase(path) {
+    const BetterSqlite3 = getBetterSqlite3();
+    return wrapDatabase(new BetterSqlite3(path));
+  },
+  transpileTS(code) {
+    const esbuild = getEsbuild();
+    return esbuild.transformSync(code, { loader: "ts" }).code;
+  }
+};
+
+// src/main.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/api/client.ts
+var TanaAPIError = class extends Error {
+  constructor(message, statusCode, response, suggestion) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.suggestion = suggestion;
+    this.name = "TanaAPIError";
+  }
+};
+var RETRY_CONFIG = {
+  maxRetries: 2,
+  baseDelayMs: 500,
+  retryableCodes: /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504])
+};
+function isRetryableError(error) {
+  if (error instanceof TanaAPIError && error.statusCode) {
+    return RETRY_CONFIG.retryableCodes.has(error.statusCode);
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    return msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("timeout") || msg.includes("network");
+  }
+  return false;
+}
+function getFriendlyError(error) {
+  if (error instanceof TanaAPIError) {
+    switch (error.statusCode) {
+      case 401:
+        return {
+          message: "Authentication failed",
+          suggestion: "Check TANA_API_TOKEN - it may have expired. Generate a new token in Tana: Settings > API > Generate Token"
+        };
+      case 403:
+        return {
+          message: "Access forbidden",
+          suggestion: "Your API token may lack permissions for this operation. Try generating a new token."
+        };
+      case 404:
+        return {
+          message: "Resource not found",
+          suggestion: "The node or workspace may have been deleted, or the ID is incorrect."
+        };
+      case 429:
+        return {
+          message: "Rate limited",
+          suggestion: "Too many requests. Wait a moment and try again."
+        };
+      case 500:
+      case 502:
+      case 503:
+        return {
+          message: "Tana server error",
+          suggestion: "Tana is experiencing issues. Try again in a few seconds."
+        };
+    }
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("econnrefused")) {
+      return {
+        message: "Cannot connect to Tana",
+        suggestion: "Make sure Tana Desktop is running with Local API enabled. Check the port in Tana settings."
+      };
+    }
+    if (msg.includes("timeout") || msg.includes("etimedout")) {
+      return {
+        message: "Request timed out",
+        suggestion: "Tana took too long to respond. Try again or increase TANA_TIMEOUT."
+      };
+    }
+  }
+  return {
+    message: error instanceof Error ? error.message : "Unknown error",
+    suggestion: "Check if Tana Desktop is running and your API token is valid."
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TanaClient = class {
+  baseUrl;
+  token;
+  timeout;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.token = config.token;
+    this.timeout = config.timeout;
+  }
+  async request(method, path, body) {
+    let lastError;
+    for (let attempt = 1; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        };
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          let errorBody;
+          try {
+            errorBody = await response.json();
+          } catch {
+            errorBody = await response.text();
+          }
+          const error = new TanaAPIError(
+            `Tana API error: ${response.status} ${response.statusText}`,
+            response.status,
+            errorBody
+          );
+          if (isRetryableError(error) && attempt < RETRY_CONFIG.maxRetries) {
+            lastError = error;
+            const delayMs = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1);
+            console.error(`Retry ${attempt}/${RETRY_CONFIG.maxRetries} after ${delayMs}ms...`);
+            await delay(delayMs);
+            continue;
+          }
+          throw error;
+        }
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          return await response.json();
+        }
+        return await response.text();
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof TanaAPIError && !isRetryableError(error)) {
+          const friendly3 = getFriendlyError(error);
+          throw new TanaAPIError(friendly3.message, error.statusCode, error.response, friendly3.suggestion);
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          const friendly3 = getFriendlyError(new Error("timeout"));
+          throw new TanaAPIError(friendly3.message, void 0, void 0, friendly3.suggestion);
+        }
+        if (isRetryableError(error) && attempt < RETRY_CONFIG.maxRetries) {
+          lastError = error;
+          const delayMs = RETRY_CONFIG.baseDelayMs * Math.pow(2, attempt - 1);
+          console.error(`Retry ${attempt}/${RETRY_CONFIG.maxRetries} after ${delayMs}ms...`);
+          await delay(delayMs);
+          continue;
+        }
+        const friendly2 = getFriendlyError(error);
+        throw new TanaAPIError(friendly2.message, void 0, void 0, friendly2.suggestion);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    const friendly = getFriendlyError(lastError);
+    throw new TanaAPIError(
+      `Failed after ${RETRY_CONFIG.maxRetries} attempts: ${friendly.message}`,
+      void 0,
+      void 0,
+      friendly.suggestion
+    );
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path, body) {
+    return this.request("DELETE", path, body);
+  }
+};
+function createClient() {
+  const baseUrl = process.env.TANA_API_URL || "http://127.0.0.1:8262";
+  const token = process.env.TANA_API_TOKEN;
+  const timeout = parseInt(process.env.TANA_TIMEOUT || "3000", 10);
+  if (!token) {
+    throw new Error(
+      "TANA_API_TOKEN environment variable is required. Get your token from Tana Desktop: Settings > API > Generate Token"
+    );
+  }
+  return new TanaClient({ baseUrl, token, timeout });
+}
+
+// src/api/format.ts
+function hasKey(obj, key) {
+  return typeof obj === "object" && obj !== null && key in obj;
+}
+function formatTags(tags) {
+  if (!tags || tags.length === 0) return "";
+  return " " + tags.map((t) => `#${t.name}`).join(" ");
+}
+function formatSearchResults(data) {
+  const lines = data.map((r) => {
+    const tags = formatTags(r.tags);
+    const breadcrumb = r.breadcrumb?.length ? ` \u2014 ${r.breadcrumb.join(" > ")}` : "";
+    return `  [${r.id}] ${r.name}${tags}${breadcrumb}`;
+  });
+  return `${data.length} results:
+${lines.join("\n")}`;
+}
+function formatChildren(data) {
+  const showing = data.children.length;
+  const header = `${data.total} children (showing ${showing}${data.hasMore ? ", has more" : ""}):`;
+  const lines = data.children.map((c) => {
+    const tags = formatTags(c.tags);
+    const kids = c.childCount > 0 ? ` (${c.childCount} children)` : "";
+    return `  [${c.id}] ${c.name}${tags}${kids}`;
+  });
+  return `${header}
+${lines.join("\n")}`;
+}
+function formatChildNodes(data) {
+  const lines = data.map((c) => {
+    const tags = formatTags(c.tags);
+    const kids = c.childCount > 0 ? ` (${c.childCount} children)` : "";
+    return `  [${c.id}] ${c.name}${tags}${kids}`;
+  });
+  return `${data.length} nodes:
+${lines.join("\n")}`;
+}
+function formatTags_(data) {
+  const lines = data.map((t) => `  [${t.id}] ${t.name}`);
+  return `${data.length} tags:
+${lines.join("\n")}`;
+}
+function formatWorkspaces(data) {
+  const lines = data.map((w) => `  [${w.id}] ${w.name} (home: ${w.homeNodeId})`);
+  return `${data.length} workspaces:
+${lines.join("\n")}`;
+}
+function formatImportResult(data) {
+  if (data.success) {
+    const ids = data.nodeIds?.length ? ` (${data.nodeIds.join(", ")})` : "";
+    return `Import success: ${data.nodeIds?.length ?? 0} nodes${ids}`;
+  }
+  return `Import failed: ${data.error ?? "unknown error"}`;
+}
+function format(data) {
+  if (typeof data === "string") return data;
+  if (data === null || data === void 0) return String(data);
+  if (hasKey(data, "success") && (hasKey(data, "nodeIds") || hasKey(data, "error"))) {
+    return formatImportResult(data);
+  }
+  if (hasKey(data, "children") && hasKey(data, "total") && hasKey(data, "hasMore")) {
+    return formatChildren(data);
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "0 results";
+    const first = data[0];
+    if (hasKey(first, "breadcrumb")) {
+      return formatSearchResults(data);
+    }
+    if (hasKey(first, "childCount")) {
+      return formatChildNodes(data);
+    }
+    if (hasKey(first, "homeNodeId")) {
+      return formatWorkspaces(data);
+    }
+    if (hasKey(first, "id") && hasKey(first, "name") && !hasKey(first, "breadcrumb") && !hasKey(first, "childCount") && !hasKey(first, "homeNodeId")) {
+      return formatTags_(data);
+    }
+  }
+  try {
+    return JSON.stringify(data, null, 2);
+  } catch {
+    return String(data);
+  }
+}
+
+// src/api/tana.ts
+function addQueryParams(params, obj, prefix) {
+  for (const [key, value] of Object.entries(obj)) {
+    const paramKey = prefix ? `${prefix}[${key}]` : key;
+    if (value === null || value === void 0) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      addQueryParams(params, value, paramKey);
+    } else if (Array.isArray(value)) {
+      value.forEach((item, i) => {
+        if (typeof item === "object") {
+          addQueryParams(params, item, `${paramKey}[${i}]`);
+        } else {
+          params.push(`${encodeURIComponent(`${paramKey}[${i}]`)}=${encodeURIComponent(String(item))}`);
+        }
+      });
+    } else {
+      params.push(`${encodeURIComponent(paramKey)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+}
+function parseOptionsFromMarkdown(md) {
+  const results = [];
+  const lines = md.split("\n");
+  let inOptions = false;
+  for (const line of lines) {
+    if (line.includes("**Options**:")) {
+      inOptions = true;
+      continue;
+    }
+    if (inOptions) {
+      const match = line.match(/^\s+- (.+?)\s*<!--\s*node-id:\s*(\S+)\s*-->/);
+      if (match) {
+        results.push({ id: match[2], name: match[1] });
+      } else if (line.trim() && !line.startsWith("  ")) {
+        break;
+      }
+    }
+  }
+  return results;
+}
+function parseRefsFromMarkdown(md) {
+  const results = [];
+  const re = /\[([^\]]+)\]\(tana:([^)]+)\)/g;
+  let match;
+  while ((match = re.exec(md)) !== null) {
+    results.push({ id: match[2], name: match[1] });
+  }
+  return results;
+}
+function parseFieldValues(md, fieldName) {
+  const results = [];
+  const lines = md.split("\n");
+  let inField = false;
+  let fieldIndent = -1;
+  for (const line of lines) {
+    if (!inField && line.includes(`**${fieldName}**`)) {
+      inField = true;
+      fieldIndent = line.search(/\S/);
+      const inlineMatch = line.match(
+        new RegExp(`\\*\\*${fieldName}\\*\\*:\\s*(.+?)\\s*<!--\\s*node-id:\\s*(\\S+)\\s*-->`)
+      );
+      if (inlineMatch) {
+        results.push({ id: inlineMatch[2], name: inlineMatch[1].trim() });
+      }
+      const linkMatch = line.match(
+        new RegExp(`\\*\\*${fieldName}\\*\\*:\\s*\\[([^\\]]+)\\]\\(tana:([^)]+)\\)`)
+      );
+      if (linkMatch) {
+        results.push({ id: linkMatch[2], name: linkMatch[1] });
+      }
+      continue;
+    }
+    if (inField) {
+      const currentIndent = line.search(/\S/);
+      if (line.trim() && currentIndent <= fieldIndent) break;
+      const childMatch = line.match(/^\s+- (.+?)\s*<!--\s*node-id:\s*(\S+)\s*-->/);
+      if (childMatch) {
+        results.push({ id: childMatch[2], name: childMatch[1].trim() });
+        continue;
+      }
+      const childLinkMatch = line.match(/^\s+- \[([^\]]+)\]\(tana:([^)]+)\)/);
+      if (childLinkMatch) {
+        results.push({ id: childLinkMatch[2], name: childLinkMatch[1] });
+      }
+    }
+  }
+  return results;
+}
+function createTanaAPI(client, workspace, defaultSearchWorkspaceIds) {
+  return {
+    workspace: workspace ?? null,
+    async health() {
+      return client.get("/health");
+    },
+    workspaces: {
+      async list() {
+        return client.get("/workspaces");
+      }
+    },
+    nodes: {
+      async search(query, options) {
+        const params = [];
+        addQueryParams(params, query, "query");
+        if (options?.limit) params.push(`limit=${options.limit}`);
+        const effectiveWorkspaceIds = options?.workspaceIds ?? (defaultSearchWorkspaceIds?.length ? defaultSearchWorkspaceIds : void 0);
+        if (effectiveWorkspaceIds) {
+          effectiveWorkspaceIds.forEach((id, i) => {
+            params.push(`workspaceIds[${i}]=${encodeURIComponent(id)}`);
+          });
+        }
+        return client.get(`/nodes/search?${params.join("&")}`);
+      },
+      async read(nodeId, maxDepth = 1) {
+        const result = await client.get(
+          `/nodes/${nodeId}?maxDepth=${maxDepth}`
+        );
+        return result.markdown;
+      },
+      async getChildren(nodeId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit) params.set("limit", String(options.limit));
+        if (options?.offset) params.set("offset", String(options.offset));
+        const query = params.toString();
+        return client.get(
+          `/nodes/${nodeId}/children${query ? `?${query}` : ""}`
+        );
+      },
+      async edit(options) {
+        const result = await client.post(
+          `/nodes/${options.nodeId}/update`,
+          {
+            name: options.name,
+            description: options.description
+          }
+        );
+        return { success: !!result.nodeId };
+      },
+      async move(options) {
+        const result = await client.post(
+          `/nodes/${options.nodeId}/move`,
+          {
+            targetNodeId: options.targetNodeId,
+            keepSourceReference: options.keepSourceReference,
+            position: options.position,
+            referenceNodeId: options.referenceNodeId,
+            sourceParentId: options.sourceParentId
+          }
+        );
+        return { success: !!result.nodeId };
+      },
+      async open(nodeId, openType = "current") {
+        const result = await client.post(
+          `/nodes/${nodeId}/open`,
+          { openType }
+        );
+        return { success: !!result.nodeId };
+      },
+      async trash(nodeId) {
+        const result = await client.post(
+          `/nodes/${nodeId}/trash`,
+          {}
+        );
+        return { success: !!result.nodeId };
+      },
+      async check(nodeId) {
+        const result = await client.post(
+          `/nodes/${nodeId}/done`,
+          { done: true }
+        );
+        return { success: result.done === true };
+      },
+      async uncheck(nodeId) {
+        const result = await client.post(
+          `/nodes/${nodeId}/done`,
+          { done: false }
+        );
+        return { success: result.done === false };
+      }
+    },
+    tags: {
+      async listAll(workspaceId) {
+        const schemaNodeId = `${workspaceId}_SCHEMA`;
+        const tags = [];
+        let offset = 0;
+        while (true) {
+          const page = await client.get(
+            `/nodes/${schemaNodeId}/children?limit=200&offset=${offset}`
+          );
+          for (const child of page.children) {
+            if (child.docType === "tagDef") {
+              tags.push({ id: child.id, name: child.name });
+            }
+          }
+          if (!page.hasMore) break;
+          offset += 200;
+        }
+        return tags;
+      },
+      async getSchema(tagId, includeEditInstructions = false, includeInheritedFields = true) {
+        const result = await client.get(
+          `/tags/${tagId}/schema?includeEditInstructions=${includeEditInstructions}&includeInheritedFields=${includeInheritedFields}`
+        );
+        return truncateOptionLists(result.markdown);
+      },
+      async modify(nodeId, action, tagIds) {
+        const result = await client.post(
+          `/nodes/${nodeId}/tags`,
+          { action, tagIds }
+        );
+        return { success: !!result.nodeId };
+      },
+      async create(options) {
+        return client.post(
+          `/workspaces/${options.workspaceId}/tags`,
+          {
+            name: options.name,
+            description: options.description,
+            extendsTagIds: options.extendsTagIds,
+            showCheckbox: options.showCheckbox
+          }
+        );
+      },
+      async addField(options) {
+        return client.post(
+          `/tags/${options.tagId}/fields`,
+          {
+            name: options.name,
+            dataType: options.dataType,
+            description: options.description,
+            sourceTagId: options.sourceTagId,
+            options: options.options,
+            defaultValue: options.defaultValue,
+            isMultiValue: options.isMultiValue
+          }
+        );
+      },
+      async setCheckbox(options) {
+        const result = await client.post(
+          `/tags/${options.tagId}/checkbox`,
+          {
+            showCheckbox: options.showCheckbox,
+            doneStateMapping: options.doneStateMapping
+          }
+        );
+        return { success: !!result.tagId };
+      }
+    },
+    fields: {
+      // Workaround: append mode is broken in Tana API (clears field instead of appending).
+      // For arrays, we set first value via API, then import remaining into the field tuple.
+      // See claudedocs/api-bugs.md
+      async setOption(nodeId, attributeId, optionId, _mode) {
+        const ids = Array.isArray(optionId) ? optionId : [optionId];
+        if (ids.length === 0) return { success: true };
+        await client.post(
+          `/nodes/${nodeId}/fields/${attributeId}/option`,
+          { optionId: ids[0], mode: "replace" }
+        );
+        if (ids.length === 1) return { success: true };
+        const { children } = await client.get(
+          `/nodes/${nodeId}/children?limit=100`
+        );
+        let tupleId = null;
+        for (const child of children) {
+          if (child.docType === "tuple") {
+            const sub = await client.get(
+              `/nodes/${child.id}/children?limit=20`
+            );
+            if (sub.children.some((s) => s.id === attributeId)) {
+              tupleId = child.id;
+              break;
+            }
+          }
+        }
+        if (!tupleId) return { success: false };
+        const refs = ids.slice(1).map((id) => `- [[^${id}]]`).join("\n");
+        await client.post(`/nodes/${tupleId}/import`, { content: refs });
+        return { success: true };
+      },
+      async setContent(nodeId, attributeId, content, mode) {
+        const result = await client.post(
+          `/nodes/${nodeId}/fields/${attributeId}/content`,
+          { content, mode }
+        );
+        return { success: !!result.nodeId };
+      },
+      async getFieldOptions(fieldId, options) {
+        const result = await client.get(
+          `/nodes/${fieldId}?maxDepth=2`
+        );
+        const md = result.markdown;
+        if (md.includes("**Options**:")) {
+          return parseOptionsFromMarkdown(md);
+        }
+        if (md.includes("Options from supertag")) {
+          const sourceTagMatch = md.match(/\(tana:([^)]+)\)/);
+          if (sourceTagMatch) {
+            const params2 = [];
+            addQueryParams(params2, { hasType: sourceTagMatch[1] }, "query");
+            if (options?.workspaceId) {
+              params2.push(`workspaceIds[0]=${encodeURIComponent(options.workspaceId)}`);
+            }
+            if (options?.limit) params2.push(`limit=${options.limit}`);
+            const results = await client.get(`/nodes/search?${params2.join("&")}`);
+            return results.map((r) => ({ id: r.id, name: r.name }));
+          }
+        }
+        const searchNodeMatch = md.match(/\*\*Options List\*\*:.*?\(tana:([^)]+)\)/);
+        if (searchNodeMatch) {
+          const searchResult = await client.get(
+            `/nodes/${searchNodeMatch[1]}?maxDepth=1`
+          );
+          return parseRefsFromMarkdown(searchResult.markdown);
+        }
+        const fieldNameMatch = md.match(/^- (.+?) #field-definition/m);
+        if (!fieldNameMatch) return [];
+        const fieldName = fieldNameMatch[1];
+        const limit = options?.limit ?? 10;
+        const params = [];
+        const query = options?.tagId ? { and: [{ hasType: options.tagId }, { field: { fieldId, state: "set" } }] } : { field: { fieldId, state: "set" } };
+        addQueryParams(params, query, "query");
+        if (options?.workspaceId) {
+          params.push(`workspaceIds[0]=${encodeURIComponent(options.workspaceId)}`);
+        }
+        params.push(`limit=${limit}`);
+        const searchResults = await client.get(`/nodes/search?${params.join("&")}`);
+        const seen = /* @__PURE__ */ new Map();
+        for (const node of searchResults) {
+          const nodeMd = await client.get(
+            `/nodes/${node.id}?maxDepth=1`
+          );
+          for (const { id, name } of parseFieldValues(nodeMd.markdown, fieldName)) {
+            if (!seen.has(id)) seen.set(id, name);
+          }
+        }
+        return Array.from(seen, ([id, name]) => ({ id, name }));
+      }
+    },
+    calendar: {
+      async getOrCreate(workspaceId, granularity, date) {
+        const params = new URLSearchParams();
+        params.set("granularity", granularity);
+        if (date) params.set("date", date);
+        return client.get(
+          `/workspaces/${workspaceId}/calendar/node?${params.toString()}`
+        );
+      }
+    },
+    async import(parentNodeId, content) {
+      const raw = await client.post(`/nodes/${parentNodeId}/import`, { content });
+      return {
+        success: true,
+        nodeIds: raw.createdNodes.map((n) => n.id)
+      };
+    },
+    format(data) {
+      return format(data);
+    }
+  };
+}
+var MAX_OPTIONS_SHOWN = 5;
+var OPTION_LINE_RE = /^  - .+ \(id:/;
+function truncateOptionLists(markdown) {
+  const lines = markdown.split("\n");
+  const result = [];
+  let optionCount = 0;
+  let inOptions = false;
+  for (const line of lines) {
+    if (OPTION_LINE_RE.test(line)) {
+      if (!inOptions) {
+        inOptions = true;
+        optionCount = 0;
+      }
+      optionCount++;
+      if (optionCount <= MAX_OPTIONS_SHOWN) {
+        result.push(line);
+      }
+    } else {
+      if (inOptions && optionCount > MAX_OPTIONS_SHOWN) {
+        result.push(`  - ... (${optionCount - MAX_OPTIONS_SHOWN} more, ${optionCount} total)`);
+      }
+      inOptions = false;
+      optionCount = 0;
+      result.push(line);
+    }
+  }
+  if (inOptions && optionCount > MAX_OPTIONS_SHOWN) {
+    result.push(`  - ... (${optionCount - MAX_OPTIONS_SHOWN} more, ${optionCount} total)`);
+  }
+  return result.join("\n");
+}
+
+// src/storage/history.ts
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { mkdirSync, existsSync } from "fs";
+var db = null;
+function getDbPath() {
+  if (process.env.TANA_HISTORY_PATH) {
+    const customPath = process.env.TANA_HISTORY_PATH;
+    const dir = dirname(customPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    return customPath;
+  }
+  const platform = process.platform;
+  let baseDir;
+  if (platform === "darwin") {
+    baseDir = join(homedir(), "Library", "Application Support", "tana-mcp");
+  } else if (platform === "win32") {
+    baseDir = join(process.env.APPDATA || homedir(), "tana-mcp");
+  } else {
+    baseDir = join(homedir(), ".local", "share", "tana-mcp");
+  }
+  if (!existsSync(baseDir)) {
+    mkdirSync(baseDir, { recursive: true });
+  }
+  return join(baseDir, "history.db");
+}
+function migrateDb(database) {
+  const columns = database.prepare("PRAGMA table_info(script_runs)").all();
+  const columnNames = new Set(columns.map((c) => c.name));
+  const newColumns = [
+    { name: "input", type: "TEXT" },
+    { name: "api_calls", type: "TEXT" },
+    { name: "node_ids_affected", type: "TEXT" },
+    { name: "workspace_id", type: "TEXT" }
+  ];
+  for (const col of newColumns) {
+    if (!columnNames.has(col.name)) {
+      database.exec(`ALTER TABLE script_runs ADD COLUMN ${col.name} ${col.type}`);
+    }
+  }
+}
+function initDb() {
+  if (db) return db;
+  const dbPath = getDbPath();
+  db = createDatabase(dbPath);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS script_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      script TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      output TEXT NOT NULL,
+      error TEXT,
+      duration_ms INTEGER NOT NULL,
+      session_id TEXT,
+      input TEXT,
+      api_calls TEXT,
+      node_ids_affected TEXT,
+      workspace_id TEXT
+    )
+  `);
+  migrateDb(db);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_script_runs_timestamp
+    ON script_runs(timestamp DESC)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_script_runs_session
+    ON script_runs(session_id)
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_script_runs_workspace
+    ON script_runs(workspace_id)
+  `);
+  return db;
+}
+function saveScriptRun(options) {
+  try {
+    const database = initDb();
+    const stmt = database.prepare(`
+      INSERT INTO script_runs (
+        timestamp, script, success, output, error, duration_ms, session_id,
+        input, api_calls, node_ids_affected, workspace_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      Date.now(),
+      options.script,
+      options.success ? 1 : 0,
+      options.output,
+      options.error,
+      options.durationMs,
+      options.sessionId,
+      options.input ?? null,
+      options.apiCalls ? JSON.stringify(options.apiCalls) : null,
+      options.nodeIdsAffected ? JSON.stringify(options.nodeIdsAffected) : null,
+      options.workspaceId ?? null
+    );
+  } catch (e) {
+    console.error("Failed to save script run to history:", e);
+  }
+}
+function cleanupOldRuns(daysOld = 30) {
+  const database = initDb();
+  const cutoff = Date.now() - daysOld * 24 * 60 * 60 * 1e3;
+  const stmt = database.prepare(`
+    DELETE FROM script_runs WHERE timestamp < ?
+  `);
+  const result = stmt.run(cutoff);
+  return result.changes;
+}
+
+// src/sandbox/workflow.ts
+var workflowTableInitialized = false;
+function ensureWorkflowTable(db2) {
+  if (workflowTableInitialized) return;
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      timestamp INTEGER NOT NULL,
+      event_type TEXT NOT NULL,
+      message TEXT NOT NULL,
+      metadata TEXT
+    )
+  `);
+  db2.exec(`
+    CREATE INDEX IF NOT EXISTS idx_workflow_session
+    ON workflow_events(session_id, timestamp)
+  `);
+  workflowTableInitialized = true;
+}
+function saveWorkflowEvent(sessionId, eventType, message, metadata) {
+  try {
+    const db2 = initDb();
+    ensureWorkflowTable(db2);
+    const stmt = db2.prepare(`
+      INSERT INTO workflow_events (session_id, timestamp, event_type, message, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      sessionId,
+      Date.now(),
+      eventType,
+      message,
+      metadata ? JSON.stringify(metadata) : null
+    );
+  } catch (e) {
+    console.error("Failed to save workflow event:", e);
+  }
+}
+function createWorkflowHelper(sessionId) {
+  return {
+    start(message) {
+      saveWorkflowEvent(sessionId, "start", message);
+    },
+    step(message) {
+      saveWorkflowEvent(sessionId, "step", message);
+    },
+    progress(current, total, message) {
+      const progressMsg = message ? `${message} (${current}/${total})` : `${current}/${total}`;
+      saveWorkflowEvent(sessionId, "progress", progressMsg, { current, total });
+    },
+    complete(message) {
+      saveWorkflowEvent(sessionId, "complete", message ?? "Completed");
+    },
+    abort(reason) {
+      saveWorkflowEvent(sessionId, "abort", reason);
+    }
+  };
+}
+
+// src/sandbox/executor.ts
+var EXECUTION_TIMEOUT = 1e4;
+function createTrackedTanaAPI(tana, tracker) {
+  const track = (method, fn) => {
+    tracker.calls.push(method);
+    return fn();
+  };
+  const trackNodeId = (id) => tracker.nodeIds.add(id);
+  return {
+    workspace: tana.workspace,
+    health: () => track("health", () => tana.health()),
+    workspaces: {
+      list: () => track("workspaces.list", () => tana.workspaces.list())
+    },
+    nodes: {
+      search: (query, options) => {
+        if (options?.workspaceIds?.[0]) {
+          tracker.workspaceId = options.workspaceIds[0];
+        }
+        return track("nodes.search", () => tana.nodes.search(query, options));
+      },
+      read: (nodeId, maxDepth) => {
+        trackNodeId(nodeId);
+        return track("nodes.read", () => tana.nodes.read(nodeId, maxDepth));
+      },
+      getChildren: (nodeId, options) => {
+        trackNodeId(nodeId);
+        return track("nodes.getChildren", () => tana.nodes.getChildren(nodeId, options));
+      },
+      edit: (options) => {
+        trackNodeId(options.nodeId);
+        return track("nodes.edit", () => tana.nodes.edit(options));
+      },
+      move: (options) => {
+        trackNodeId(options.nodeId);
+        return track("nodes.move", () => tana.nodes.move(options));
+      },
+      open: (nodeId, openType) => {
+        trackNodeId(nodeId);
+        return track("nodes.open", () => tana.nodes.open(nodeId, openType));
+      },
+      trash: (nodeId) => {
+        trackNodeId(nodeId);
+        return track("nodes.trash", () => tana.nodes.trash(nodeId));
+      },
+      check: (nodeId) => {
+        trackNodeId(nodeId);
+        return track("nodes.check", () => tana.nodes.check(nodeId));
+      },
+      uncheck: (nodeId) => {
+        trackNodeId(nodeId);
+        return track("nodes.uncheck", () => tana.nodes.uncheck(nodeId));
+      }
+    },
+    tags: {
+      listAll: (workspaceId) => {
+        tracker.workspaceId = workspaceId;
+        return track("tags.listAll", () => tana.tags.listAll(workspaceId));
+      },
+      getSchema: (tagId, includeEditInstructions) => track("tags.getSchema", () => tana.tags.getSchema(tagId, includeEditInstructions)),
+      modify: (nodeId, action, tagIds) => {
+        trackNodeId(nodeId);
+        return track("tags.modify", () => tana.tags.modify(nodeId, action, tagIds));
+      },
+      create: (options) => {
+        tracker.workspaceId = options.workspaceId;
+        return track("tags.create", () => tana.tags.create(options));
+      },
+      addField: (options) => track("tags.addField", () => tana.tags.addField(options)),
+      setCheckbox: (options) => track("tags.setCheckbox", () => tana.tags.setCheckbox(options))
+    },
+    fields: {
+      setOption: (nodeId, attributeId, optionId) => {
+        trackNodeId(nodeId);
+        return track("fields.setOption", () => tana.fields.setOption(nodeId, attributeId, optionId));
+      },
+      setContent: (nodeId, attributeId, content) => {
+        trackNodeId(nodeId);
+        return track("fields.setContent", () => tana.fields.setContent(nodeId, attributeId, content));
+      },
+      getFieldOptions: (...args) => track("fields.getFieldOptions", () => tana.fields.getFieldOptions(...args))
+    },
+    calendar: {
+      getOrCreate: (workspaceId, granularity, date) => {
+        tracker.workspaceId = workspaceId;
+        return track(
+          "calendar.getOrCreate",
+          () => tana.calendar.getOrCreate(workspaceId, granularity, date)
+        );
+      }
+    },
+    import: (parentNodeId, content) => {
+      trackNodeId(parentNodeId);
+      return track("import", () => tana.import(parentNodeId, content));
+    },
+    format: (data) => tana.format(data)
+  };
+}
+async function executeSandbox(code, tana, sessionId) {
+  const startTime = performance.now();
+  const logs = [];
+  const tracker = {
+    calls: [],
+    nodeIds: /* @__PURE__ */ new Set(),
+    workspaceId: tana.workspace?.id ?? null
+  };
+  const sandboxConsole = {
+    log: (...args) => {
+      logs.push(args.map(formatArg).join(" "));
+    },
+    error: (...args) => {
+      logs.push(`[ERROR] ${args.map(formatArg).join(" ")}`);
+    },
+    warn: (...args) => {
+      logs.push(`[WARN] ${args.map(formatArg).join(" ")}`);
+    },
+    info: (...args) => {
+      logs.push(args.map(formatArg).join(" "));
+    }
+  };
+  const effectiveSessionId = sessionId ?? crypto.randomUUID();
+  const workflow = createWorkflowHelper(effectiveSessionId);
+  const trackedTana = createTrackedTanaAPI(tana, tracker);
+  try {
+    const AsyncFunction = Object.getPrototypeOf(
+      async function() {
+      }
+    ).constructor;
+    const shadowedGlobals = [
+      "process",
+      "require",
+      "Bun",
+      "Deno",
+      "globalThis",
+      "global",
+      "eval",
+      "Function",
+      "__dirname",
+      "__filename",
+      "module",
+      "exports"
+    ];
+    const jsCode = transpileTS(code);
+    const fn = new AsyncFunction(
+      "tana",
+      "console",
+      "workflow",
+      ...shadowedGlobals,
+      jsCode
+    );
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Execution timed out after ${EXECUTION_TIMEOUT}ms`));
+      }, EXECUTION_TIMEOUT);
+    });
+    const undefinedArgs = shadowedGlobals.map(() => void 0);
+    await Promise.race([
+      fn(trackedTana, sandboxConsole, workflow, ...undefinedArgs),
+      timeoutPromise
+    ]);
+    const durationMs = Math.round(performance.now() - startTime);
+    const output = logs.join("\n");
+    saveScriptRun({
+      script: code,
+      success: true,
+      output,
+      error: null,
+      durationMs,
+      sessionId: effectiveSessionId,
+      apiCalls: tracker.calls.length > 0 ? tracker.calls : null,
+      nodeIdsAffected: tracker.nodeIds.size > 0 ? Array.from(tracker.nodeIds) : null,
+      workspaceId: tracker.workspaceId
+    });
+    return {
+      success: true,
+      output,
+      durationMs
+    };
+  } catch (error) {
+    const durationMs = Math.round(performance.now() - startTime);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const output = logs.join("\n");
+    saveScriptRun({
+      script: code,
+      success: false,
+      output,
+      error: errorMessage,
+      durationMs,
+      sessionId: effectiveSessionId,
+      apiCalls: tracker.calls.length > 0 ? tracker.calls : null,
+      nodeIdsAffected: tracker.nodeIds.size > 0 ? Array.from(tracker.nodeIds) : null,
+      workspaceId: tracker.workspaceId
+    });
+    return {
+      success: false,
+      output,
+      error: errorMessage,
+      durationMs
+    };
+  }
+}
+function formatArg(arg) {
+  if (arg === null) return "null";
+  if (arg === void 0) return "undefined";
+  if (typeof arg === "string") return arg;
+  if (typeof arg === "number" || typeof arg === "boolean") return String(arg);
+  try {
+    return JSON.stringify(arg, null, 2);
+  } catch {
+    return String(arg);
+  }
+}
+
+// src/prompts.ts
+var TOOL_DESCRIPTION = `Execute TypeScript code to interact with Tana.
+
+## APIs
+
+tana.workspace \u2192 Workspace | null (pre-resolved default workspace)
+tana.workspaces.list() \u2192 Workspace[] { id, name, homeNodeId }
+
+### Nodes
+tana.nodes.search(query, options?) \u2192 SearchResult[]
+tana.nodes.read(nodeId, maxDepth?) \u2192 string (markdown)
+tana.nodes.getChildren(nodeId, { limit?, offset? }) \u2192 { children, total, hasMore }
+tana.nodes.edit({ nodeId, name?, description? }) \u2192 { success }
+tana.nodes.move({ nodeId, targetNodeId, keepSourceReference?, position?, referenceNodeId?, sourceParentId? }) \u2192 { success }
+tana.nodes.open(nodeId, openType?) \u2192 { success }  // openType: "current" | "panel" | "tab" (default: "current")
+tana.nodes.trash(nodeId) \u2192 { success }
+tana.nodes.check(nodeId) / uncheck(nodeId) \u2192 { success }
+
+### Tags
+tana.tags.listAll(workspaceId) \u2192 Tag[] (workspace supertags only \u2014 for schema analysis)
+tana.tags.getSchema(tagId) \u2192 string
+tana.tags.modify(nodeId, "add"|"remove", tagIds[])
+tana.tags.create({ workspaceId, name, description?, extendsTagIds?, showCheckbox? })
+tana.tags.addField({ tagId, name, dataType: "plain"|"number"|"date"|"url"|"email"|"checkbox"|"user"|"instance"|"options", ... })
+tana.tags.setCheckbox({ tagId, showCheckbox, doneStateMapping? })
+
+### Fields
+tana.fields.setOption(nodeId, attributeId, optionId)  // optionId: string | string[] (array for multi-value)
+tana.fields.setContent(nodeId, attributeId, content, mode?)  // content: string | null (null clears field), mode: "replace" | "append"
+tana.fields.getFieldOptions(fieldId, options?) \u2192 { id, name }[]  // discover available options for a field
+
+### Calendar
+tana.calendar.getOrCreate(workspaceId, "day"|"week"|"month"|"year", date?)
+
+### Import
+tana.import(parentNodeId, tanaPasteContent) \u2192 { success, nodeIds? }
+
+### Formatting
+tana.format(data) \u2192 string (compact display of any API response)
+
+Entry points: \`\${workspaceId}_CAPTURE_INBOX\` (inbox), \`\${workspaceId}_STASH\` (library)
+
+## Edit (search-and-replace)
+
+tana.nodes.edit({ nodeId, name: { old_string, new_string }, description: { old_string, new_string } })
+Empty old_string matches absent field.
+
+## Search Query Operators
+
+{ textContains: string } | { textMatches: "/regex/i" }
+{ hasType: tagId } | { field: { fieldId, stringValue?, numberValue?, nodeId?, state? } }
+{ compare: { fieldId, operator: "gt"|"lt"|"eq", value, type } }
+{ linksTo: nodeIds[] }
+{ is: "done"|"todo"|"template"|"field"|"published"|"entity"|"calendarNode"|"onDayNode"|"chat"|"search"|"command"|"inLibrary" }
+{ has: "tag"|"field"|"media"|"audio"|"video"|"image" }
+{ created: { last: N } } | { edited: { last?, by?, since? } } | { done: { last: N } }
+{ onDate: "YYYY-MM-DD" | { date, fieldId?, overlaps? } }
+{ overdue: true } | { inLibrary: true }
+{ and: [...] } | { or: [...] } | { not: {...} }
+
+## Default Workspace
+
+tana.workspace is pre-resolved if MAIN_TANA_WORKSPACE is set. Prefer over workspaces.list(): \`const ws = tana.workspace ?? (await tana.workspaces.list())[0];\`
+
+## Output
+
+console.log() output becomes LLM context. Keep it compact:
+- Use tana.format(data) for any API response, or .map() for task-specific fields
+- search returns metadata only (name, id, tags); use .read() for content and field values
+- Never JSON.stringify API responses
+
+## API Notes
+
+- search: no offset/pagination \u2014 use narrower queries, not repeated calls
+- getChildren: only endpoint with pagination (limit + offset)
+- Timeout is 10s. On timeout, try a different approach, not the same call.
+- childOf/ownedBy/inWorkspace operators broken. Scope by workspace: search(query, { workspaceIds: ["id"] })
+- Tag names are not unique. Find a tag by name: search({ and: [{ hasType: "SYS_T01" }, { textContains: "name" }] })
+- search results: { id, name, breadcrumb[], tags[{id,name}], tagIds[], workspaceId, docType, description, created, inTrash }
+- getSchema output: line 1 is \`# Tag definition: name (id:xxx)\`. Line 2 is \`Extends #parent (id:xxx)\` when tag has inheritance, or \`Extends #parent (base type) (id:xxx)\` for Tana built-in types. Parse "Extends" to find relationships.
+
+## Examples
+
+Search: await tana.nodes.search({ and: [{ hasType: "tagId" }, { is: "todo" }] })
+
+Import:
+\`\`\`
+await tana.import(parentNodeId, \`
+- Node #[[^tagId]]
+  - [[^fieldId]]:: value
+- [ ] Todo item
+\`)
+\`\`\`
+
+`;
+
+// src/main.ts
+async function resolveWorkspace(client) {
+  const envValue = process.env.MAIN_TANA_WORKSPACE?.trim();
+  if (!envValue) return null;
+  let workspaces;
+  try {
+    workspaces = await client.get("/workspaces");
+  } catch (err) {
+    console.error(
+      `[workspace] Failed to fetch workspaces: ${err instanceof Error ? err.message : err}`
+    );
+    return null;
+  }
+  const byId = workspaces.find((w) => w.id === envValue);
+  if (byId) {
+    console.error(`[workspace] Resolved "${envValue}" \u2192 ${byId.name} (${byId.id})`);
+    return byId;
+  }
+  const lowerEnv = envValue.toLowerCase();
+  const byName = workspaces.find((w) => w.name.toLowerCase() === lowerEnv);
+  if (byName) {
+    console.error(`[workspace] Resolved "${envValue}" \u2192 ${byName.name} (${byName.id})`);
+    return byName;
+  }
+  const available = workspaces.map((w) => `${w.name} (${w.id})`).join(", ");
+  console.error(
+    `[workspace] No match for "${envValue}". Available: ${available || "none"}`
+  );
+  return null;
+}
+async function resolveSearchWorkspaces(client) {
+  const envValue = process.env.TANA_SEARCH_WORKSPACES?.trim();
+  if (!envValue) return [];
+  const values = envValue.split(",").map((v) => v.trim()).filter(Boolean);
+  if (values.length === 0) return [];
+  let workspaces;
+  try {
+    workspaces = await client.get("/workspaces");
+  } catch (err) {
+    console.error(
+      `[search-workspaces] Failed to fetch workspaces: ${err instanceof Error ? err.message : err}`
+    );
+    return [];
+  }
+  const resolvedIds = [];
+  for (const value of values) {
+    const byId = workspaces.find((w) => w.id === value);
+    if (byId) {
+      resolvedIds.push(byId.id);
+      console.error(`[search-workspaces] Resolved "${value}" \u2192 ${byId.name} (${byId.id})`);
+      continue;
+    }
+    const lowerValue = value.toLowerCase();
+    const byName = workspaces.find((w) => w.name.toLowerCase() === lowerValue);
+    if (byName) {
+      resolvedIds.push(byName.id);
+      console.error(`[search-workspaces] Resolved "${value}" \u2192 ${byName.name} (${byName.id})`);
+      continue;
+    }
+    const available = workspaces.map((w) => `${w.name} (${w.id})`).join(", ");
+    console.error(
+      `[search-workspaces] No match for "${value}". Available: ${available || "none"}`
+    );
+  }
+  return resolvedIds;
+}
+async function main() {
+  initDb();
+  const cleaned = cleanupOldRuns(30);
+  if (cleaned > 0) {
+    console.error(`Cleaned up ${cleaned} old script runs`);
+  }
+  const client = createClient();
+  const workspace = await resolveWorkspace(client);
+  const searchWorkspaceIds = await resolveSearchWorkspaces(client);
+  const tana = createTanaAPI(client, workspace, searchWorkspaceIds);
+  const server = new McpServer({
+    name: "tana-mcp-codemode",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "execute",
+    {
+      description: TOOL_DESCRIPTION,
+      inputSchema: {
+        code: z.string().describe("TypeScript code to execute"),
+        sessionId: z.string().optional().describe("Optional session ID for grouping script runs")
+      }
+    },
+    async ({ code, sessionId }) => {
+      const result = await executeSandbox(code, tana, sessionId);
+      let responseText = "";
+      if (result.output) {
+        responseText += result.output;
+      }
+      if (result.error) {
+        responseText += responseText ? "\n\n" : "";
+        responseText += `Error: ${result.error}`;
+      }
+      responseText += `
+
+[Executed in ${result.durationMs}ms]`;
+      return {
+        content: [
+          {
+            type: "text",
+            text: responseText
+          }
+        ],
+        isError: !result.success
+      };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Tana MCP server started");
+}
+
+// src/entry-node.ts
+initCompat(nodeCompat);
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});