mmm-mcp-server 0.1.1 → 0.1.3

package/README.en.md

@@ -0,0 +1,228 @@
+# mmm-mcp-server
+
+[日本語](README.md) | English
+
+A tool that lets you read and write your own maps in Matryoshka Mind Map (a mind map / TODO app) directly from conversations with AI agents. Because it is built on the Model Context Protocol (MCP) open standard, it works with any MCP-compatible AI agent, not just Claude Desktop and Claude Code (**tested on Claude Desktop and Claude Code**; for other clients, see their documentation on how to register an MCP server).
+
+- Say "Show me my current maps" and it lists your maps.
+- Turn ideas from your conversation directly into a hierarchical mind map.
+- Just say "I finished task X" to check it off your TODO list.
+- Import long notes or Markdown straight into a map.
+
+This tool runs entirely on your computer, with no always-on server. It starts only when needed and accesses your own maps with your own login credentials (the developer cannot see your data).
+
+> **For users who installed via `git clone` before September 30, 2026**: Due to a data format migration in the app, older versions will fail when writing to maps. Please replace the registration in Step 5 below with `npx -y mmm-mcp-server` (you do not need to log in again). If you want to keep using your cloned copy, run `git pull && npm install && npm run build` in the `mmm_mcp` folder and restart your AI agent.
+
+> This guide walks you through every step, starting with how to open the terminal (the window where you type commands), so that you can follow along even if you are not used to working with a computer.
+>
+> **Supported OS**: It should work on both macOS and Windows. It runs purely on Node.js and does not depend on OS-specific features. However, **it has only been tested on real machines running macOS.** If you notice anything while trying it on Windows, please let us know via an Issue in this repository. Steps that differ by OS (opening the terminal and installing Node.js) are described separately for macOS and Windows. All other commands are the same on both.
+
+## 1. Prerequisites
+
+- A Matryoshka Mind Map account (**anonymous-only accounts cannot be used.** Make sure you can log in with Google, Apple, or an email address. You can also link one later with the "Link email address" feature in the app).
+- An MCP-compatible AI agent (tested with Claude Desktop / Claude Code; other MCP-compatible clients should generally work too).
+- Node.js (the runtime that runs the tool; you will install it in Step 3).
+
+## 2. Open the Terminal
+
+### On macOS
+
+1. Press `Command` + `Space` on your keyboard (opens Spotlight search).
+2. Type "Terminal".
+3. Click "Terminal" in the results, or press Enter.
+
+### On Windows
+
+1. Press the `Windows` key on your keyboard (opens Start menu search).
+2. Type "PowerShell".
+3. Click "Windows PowerShell" in the results, or press Enter.
+
+Once a dark (or light) window opens, you are ready. For the rest of the steps, paste the commands into this window one line at a time and press Enter (the commands themselves are the same on macOS and Windows).
+
+## 3. Install Node.js
+
+Check whether Node.js is already installed with this command:
+
+```bash
+node --version
+```
+
+If a version number of `v18` or higher is displayed (e.g., `v20.11.0`), it is already installed. If you see an error like "command not found", download the installer from:
+
+https://nodejs.org/
+
+The site shows two large buttons. Click the one labeled **"LTS"** to download (the `.pkg` installer for macOS or the `.msi` installer for Windows is chosen automatically for your OS). Double-click the downloaded file and follow the on-screen instructions (on macOS: "Continue" → "Agree" → "Install"; on Windows: "Next" → "I accept..." → "Install").
+
+When the installation is finished, go back to the terminal and check again:
+
+```bash
+node --version
+```
+
+## 4. Log In
+
+Choose one of the following three options based on how you usually log in to the Matryoshka Mind Map app. **None of these methods require any setup on your part beforehand.** The first run downloads the tool, so it may take a moment.
+
+### If you log in with Google
+
+```bash
+npx -y -p mmm-mcp-server mmm-login login --method google
+```
+
+Your browser opens automatically; log in with the Google account you usually use.
+
+### If you log in with Apple
+
+```bash
+npx -y -p mmm-mcp-server mmm-login login --method apple
+```
+
+Your browser opens automatically; log in with your Apple ID.
+
+### If you log in with an email address and password
+
+```bash
+npx -y -p mmm-mcp-server mmm-login login --method email
+```
+
+You will be asked for your email address and password (the password is not shown on screen).
+
+> **If you get a "wrong password" error**, it does not necessarily mean you mistyped your password. If your account signs in to the app with Google or Apple and has no email/password credentials at all, you get the same error. If that may be the case, try the "Google" or "Apple" steps above.
+
+Once you have logged in, you do not need to log in again each time (your credentials are stored only on your computer, in a form that only you can read).
+
+```bash
+npx -y -p mmm-mcp-server mmm-login status
+```
+
+shows your login status. To log out:
+
+```bash
+npx -y -p mmm-mcp-server mmm-login logout
+```
+
+## 5. Register It with Your AI Agent
+
+Below are the instructions for Claude Desktop and Claude Code, which have been tested. If you use another MCP-compatible client (e.g., Codex), in most cases you only need to register the server launch command (`npx -y mmm-mcp-server`) in that client's MCP server settings. See your client's documentation for the exact steps.
+
+### Claude Code
+
+```bash
+claude mcp add mmm -- npx -y mmm-mcp-server
+```
+
+### Claude Desktop
+
+Open the Claude Desktop configuration file (`claude_desktop_config.json`) and add the following under `mcpServers`:
+
+```json
+{
+  "mcpServers": {
+    "mmm": {
+      "command": "npx",
+      "args": ["-y", "mmm-mcp-server"]
+    }
+  }
+}
+```
+
+Save the file and restart Claude Desktop.
+
+## 6. Try It Out
+
+Try talking to your AI agent like this:
+
+- "Show me my Matryoshka maps."
+- "Add a task called [task] to the [map name] map."
+- "I finished the [task] task in the [map name] map."
+- "I'll paste my notes in Markdown; import them into the [map name] map."
+
+**Only the first time the contents of a map (the element text) are read**, the tool asks for your permission before returning the actual contents. This is out of consideration for personal information that the contents may contain.
+
+Instead of the contents, the tool returns only an instruction: "confirm directly with the user, then call again with `confirmed: true`." This is best-effort: the server has no way to verify whether the agent actually asked you, so whether the confirmation happens properly depends on the AI agent you use. Once confirmed, the same map is not confirmed again while that server is running (roughly one conversation).
+
+(Previously, MCP's standard confirmation dialog, "elicitation", was also used to enforce this. However, some clients advertised support without actually showing a dialog, so contents became unreadable without the user ever seeing a confirmation screen. It was removed on 2026-09-03 in favor of the approach above.)
+
+## Keeping Your Maps Tidy
+
+Letting an AI agent write your maps is convenient, but left alone the maps tend to become hard to read. Paste the following into the instruction file your AI agent loads every time (for Claude Code, `~/.claude/CLAUDE.md`) to keep the writing style consistent:
+
+```markdown
+## How to write in mmm
+
+- Keep each element short enough to read in one line. Do not pack in explanations.
+  If you want to keep reasons or notes, put them one level down as child elements.
+- Put a URL in its own element. Do not mix it with text like "Docs here: https://...".
+  Create an element named "Docs" and put only the URL as its child.
+- Order reminder items chronologically. Name them by when to do them, such as
+  "Right after release", "In 2 weeks", or "When X happens".
+```
+
+The reasons:
+
+- **One line per element**: Matryoshka shows elements nested inside each other, so long elements hurt readability and lose the benefit of drilling down through the hierarchy.
+- **Do not mix URLs with text**: A URL in the same element as other text is not treated as a link in the app, so tapping it does nothing.
+- **Chronological order**: Compared with ordering by task name, checking items off in order makes it easier to notice anything you missed.
+
+## Troubleshooting
+
+| Symptom | Cause / Solution |
+|---|---|
+| `node --version` says "command not found" | Node.js from Step 3 is not installed yet. After installing, close the terminal and open it again. |
+| "Wrong password" when logging in | See the note in Step 4. Try logging in with Google or Apple instead. |
+| The agent does not operate on your maps when asked | Check that the registration in Step 5 is correct. Claude Desktop needs a restart after registration. |
+| The agent will not show map contents / stops at the confirmation | Check that you answered "yes" when asked for permission to read. |
+| The AI cannot load a large map | With several hundred elements or more, the `list_elements` response gets large and may not fit in one go. Some AI agents handle this by saving it to a file and reading only the parts they need. If it happens often, split the map (swiping left on a top-level element turns it and everything under it into a separate map). |
+
+## Advanced Example: Recording Tasks per Folder Automatically
+
+What follows is **just one example of how it can be used**. It is not a standard workflow recommended for everyone, but shows what becomes possible with this kind of setup. Feel free to ignore it if it does not suit you.
+
+**Goal**: Pair each folder (project) you work on in Claude Code with a map of the same name, and have the AI agent record and update tasks that come up during work in that map in real time, without asking.
+
+> Setting (2) below uses Claude Code's "global CLAUDE.md", an instruction file that is always loaded. If your AI agent has a similar feature for instructions loaded every time, the same idea should apply.
+
+### Setup
+
+**(1) Re-register the mmm server so it is available in every folder**
+
+When registering with Claude Code in Step 5, the `mmm` tool is only available in the current folder by default. To use it no matter which folder you start `claude` in, register it with `--scope user`:
+
+```bash
+claude mcp add mmm --scope user -- npx -y mmm-mcp-server
+```
+
+**(2) Write the workflow rules in your global CLAUDE.md (`~/.claude/CLAUDE.md`)**
+
+For example, add something like this:
+
+```markdown
+## Task management with mmm
+
+Record tasks that come up in the working folder in mmm (the Matryoshka Mind Map
+integration) and manage them in real time.
+
+- Use the working folder name as the map title.
+- Check with list_maps whether a map with the same name exists. If not, create it
+  right away with create_map(title=folder name, isTodo=true) without confirming
+  the title (confirmation is not required for this workflow only).
+- Calling list_elements to see existing tasks asks for confirmation only the first
+  time the map is read in that process. After that, add and update tasks in real
+  time with auto_structure_thought / update_task_status.
+```
+
+### Why this works
+
+- `create_map` takes the title directly as an argument; "confirm in the conversation before calling" is only a recommended behavior for AI agents written in the tool description. A more specific instruction in CLAUDE.md takes priority, so maps can be created automatically without confirmation.
+- Only `list_elements`, which reads map contents, has confirmation enforced on the server side out of consideration for confidential information (see "Try It Out" above). This does not change with the per-folder workflow: confirmation happens once, the first time a map is read in that process.
+
+### Caveats
+
+- Maps are created automatically for every folder, so work-log style maps will mix in with your carefully curated mind maps. Some people may find this cluttered. Adjust it to suit you, for example by using a separate account or limiting it to certain folders.
+- Skipping confirmation for `create_map` applies only when you spell out this workflow in your own CLAUDE.md. Without any setup, the agent confirms in the conversation before creating a map, as usual.
+
+## About This Tool
+
+- Your login credentials (refresh token) are stored only on your computer (macOS: `~/.config/mmm-mcp/credentials.json`, Windows: `C:\Users\<username>\.config\mmm-mcp\credentials.json`) and are never sent anywhere else.
+- Your map contents are read from and written to your Firebase account directly, without going through any third-party server, including the developer's (only when logging in with Apple, the last step of login goes through a signing-only relay server, but your map contents never pass through it).
+- There is no always-running process; it runs only while you are in a conversation with your AI agent.

package/README.md

@@ -1,5 +1,7 @@
 # mmm-mcp-server
 
+日本語 | [English](README.en.md)
+
 Matryoshka Mind Map（マトリョシカ、マインドマップ／TODOアプリ）の自分のマップを、
 AIエージェントとの会話から直接読み書きできるようにするツールです。MCP
 （Model Context Protocol）という共通規格に対応したツールなので、Claude

package/dist/src/domain/appendForest.js

@@ -1,5 +1,4 @@
 import { newDocId } from "./idGen.js";
-import { lastChildOf } from "./body.js";
 /** ネストしたツリー入力を、ID採番済み・prev/next/parent/child関係を組んだ配列に変換する。 */
 export function buildForestFromTree(roots) {
     const all = [];
@@ -31,52 +30,3 @@ export function buildForestFromTree(roots) {
     build(roots, null);
     return all;
 }
-/**
- * 組み立てたforest(森)を、既存の要素の[targetParentId]配下の末尾に連結する
- * ためのFirestore書き込み一覧を作る。auto_structure_thought /
- * import_markdown_context の両方から共通で使う。
- *
- * `isTodo`がfalseのマップでは、doneは常にfalseとして書き込む
- * (MatryoshkaModel.importMarkdownと同じ挙動)。
- */
-export function buildAppendWrites(bodiesPath, existingBodies, forest, targetParentId, isTodo) {
-    const roots = forest.filter((n) => n.parentId === null);
-    const last = lastChildOf(existingBodies, targetParentId);
-    if (roots.length > 0) {
-        roots[0].prevId = last;
-    }
-    const writes = forest.map((node) => ({
-        path: `${bodiesPath}/${node.id}`,
-        fields: {
-            detail: node.detail,
-            parent: node.parentId ?? targetParentId,
-            prev: node.prevId,
-            next: node.nextId,
-            child: node.childId,
-            done: isTodo ? node.done : false,
-        },
-    }));
-    if (roots.length > 0) {
-        if (last !== null) {
-            // 末尾要素のnextを書き換える。読み取り後に他の操作(並行するappendや
-            // アプリ操作)がこの要素を書き換えていた場合、requireUpdateTimeにより
-            // FAILED_PRECONDITIONで失敗する(呼び出し側はrunOptimisticで読み取り
-            // からやり直す)。
-            const lastBody = existingBodies.find((b) => b.id === last);
-            writes.push({
-                path: `${bodiesPath}/${last}`,
-                fields: { next: roots[0].id },
-                requireUpdateTime: lastBody?.updateTime,
-            });
-        }
-        else if (targetParentId !== null) {
-            const parentBody = existingBodies.find((b) => b.id === targetParentId);
-            writes.push({
-                path: `${bodiesPath}/${targetParentId}`,
-                fields: { child: roots[0].id },
-                requireUpdateTime: parentBody?.updateTime,
-            });
-        }
-    }
-    return { writes, createdIds: forest.map((n) => n.id) };
-}

package/dist/src/domain/levels.js

@@ -7,15 +7,7 @@
 // levelIdはマップ最上位が'root'、それ以外はその要素自身のid。配列の並び順が
 // そのまま兄弟順。子を持つ要素だけドキュメントが存在する(無ければ葉)。
 //
-// MCPは「新形式のみ対応」(移行ロジックはDart側だけに持たせる)。levels/root
-// が無いマップに対する操作は、アプリで一度開いてもらうよう案内して止める。
-export class LevelsNotInitializedError extends Error {
-    constructor(title) {
-        super(`「${title}」はまだ新形式(levels)のデータがありません。` +
-            "お手数ですが、アプリでこのマップを一度開いてから、もう一度お試しください。");
-        this.name = "LevelsNotInitializedError";
-    }
-}
+// 書き込みは levelsOps.ts が行う。ここはデータ形状の解釈と読み取りだけを持つ。
 function toEntry(raw) {
     if (typeof raw !== "object" || raw === null)
         return null;
@@ -49,33 +41,9 @@ export async function readAllLevelDocs(client, levelsPath) {
     }
     return result;
 }
-/** levels/rootが無ければ、アプリで開いてもらうよう案内して止める。 */
-export function assertLevelsInitialized(levelsById, mapTitle) {
-    if (!levelsById.has("root")) {
-        throw new LevelsNotInitializedError(mapTitle);
-    }
-}
-/**
- * [levelId]のlevelsドキュメントが存在するかだけを軽く確認する。
- * 「levels/rootが無ければ止める」ような存在チェックのためだけに
- * readAllLevelDocs(コレクション全体のページング読み取り)を使うのは、
- * 子を多く持つ大きなマップほど無駄が大きい。1件のgetDocumentで足りる
- * 場面(list_elementsのようにツリー全体が実際に必要な場合を除く)は
- * こちらを使うこと。
- */
-export async function levelsDocExists(client, levelsPath, levelId) {
-    return (await client.getDocument(`${levelsPath}/${levelId}`)) !== null;
-}
-/** [levelsDocExists]の結果を見て、levels/rootが無ければ止める。 */
-export function assertLevelsRootExists(rootExists, mapTitle) {
-    if (!rootExists) {
-        throw new LevelsNotInitializedError(mapTitle);
-    }
-}
 /**
- * 'root'から再帰的にlevelsを展開してツリーを組み立てる(bodies版buildTreeの
- * levels版)。levelsは配列そのものが順序を表すため、連結リストの再構築や
- * 分断の復元は不要。循環参照だけは防御的に検出して打ち切る。
+ * 'root'から再帰的にlevelsを展開してツリーを組み立てる。levelsは配列そのものが
+ * 順序を表すため、並び順の再構築は不要。循環参照だけは防御的に検出して打ち切る。
  */
 export function buildTreeFromLevels(levelsById) {
     function walk(levelId, parentId, ancestry) {
@@ -95,148 +63,3 @@ export function buildTreeFromLevels(levelsById) {
     }
     return walk("root", null, new Set());
 }
-/**
- * forest(bodies用のbuildAppendWritesと同じ入力)から、levels側の書き込み
- * 一覧を組み立てる。forest内で子を持つノードごとに levels/{id} を新規作成し、
- * forestの最上位(ルート)群は挿入先(targetParentId ?? 'root')の既存配列へ
- * 追記する。[targetHasExistingChildren]は、bodies側でlastChildOfが返した
- * 値がnullでなかったか(＝挿入先が既に子を持っていたか)をそのまま渡すこと。
- */
-export function buildAppendLevelWrites(levelsPath, forest, targetParentId, targetHasExistingChildren, isTodo) {
-    const writes = [];
-    const byParent = new Map();
-    for (const node of forest) {
-        const list = byParent.get(node.parentId) ?? [];
-        list.push(node);
-        byParent.set(node.parentId, list);
-    }
-    const entryOf = (node) => ({
-        id: node.id,
-        detail: node.detail,
-        done: isTodo ? node.done : false,
-    });
-    // forest内で子を持つノードは全て新規作成なので、既存のlevels/{id}と
-    // 衝突することはない(既存ドキュメントは無いはず)。
-    for (const [parentId, children] of byParent) {
-        if (parentId === null)
-            continue; // ルート群は下で挿入先へ追記する
-        writes.push({
-            path: `${levelsPath}/${parentId}`,
-            fields: { children: children.map(entryOf) },
-        });
-    }
-    const roots = byParent.get(null) ?? [];
-    if (roots.length > 0) {
-        const targetLevelId = targetParentId ?? "root";
-        if (targetHasExistingChildren) {
-            writes.push({
-                path: `${levelsPath}/${targetLevelId}`,
-                arrayUnion: { field: "children", values: roots.map(entryOf) },
-            });
-        }
-        else {
-            writes.push({
-                path: `${levelsPath}/${targetLevelId}`,
-                fields: { children: roots.map(entryOf) },
-            });
-        }
-    }
-    return writes;
-}
-/**
- * [levelId]のlevelsドキュメントのchildren配列から、idが[removeIds]に含まれる
- * エントリを取り除くFirestoreWriteを1件返す。ドキュメントが無ければ何もしない
- * (levelsはbest-effortの書き込みで、bodiesと食い違っていても実害は無いため)。
- * requireUpdateTimeで楽観的ロックする(呼び出し側はrunOptimisticで使うこと)。
- */
-export async function buildRemoveChildrenWrite(client, levelsPath, levelId, removeIds) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    if (!doc)
-        return null;
-    const children = childrenOf(doc.data).filter((c) => !removeIds.includes(c.id));
-    return { path: `${levelsPath}/${levelId}`, fields: { children }, requireUpdateTime: doc.updateTime };
-}
-/**
- * [levelId]のlevelsドキュメントのchildren配列の[afterId]の直後(nullなら先頭)に
- * [entry]を挿入するFirestoreWriteを1件返す。ドキュメントが無ければ新規作成する
- * (この場合はrequireUpdateTimeを付けない = 何も無い前提で作成する)。[afterId]が
- * 見つからない場合は末尾に足す(Dart版LevelsRepository.insertChildと同じ方針)。
- */
-/**
- * [levelId]のchildrenの中で[entry]を一度取り除いてから、[afterId]の直後
- * (nullなら先頭)へ入れ直す書き込みを作る。同じ親の中での並べ替え専用。
- *
- * **remove用とinsert用の書き込みを別々に作って両方commitしてはいけない。**
- * どちらも「元のchildren」を読んでから組み立てるため、同じドキュメントへの
- * 書き込みが2つできて後勝ちになり、要素が重複する。
- */
-export async function buildReorderChildWrite(client, levelsPath, levelId, entry, afterId) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    const children = (doc ? childrenOf(doc.data) : []).filter((c) => c.id !== entry.id);
-    const insertIndex = afterId === null
-        ? 0
-        : (() => {
-            const found = children.findIndex((c) => c.id === afterId);
-            return found === -1 ? children.length : found + 1;
-        })();
-    children.splice(Math.min(Math.max(insertIndex, 0), children.length), 0, entry);
-    return {
-        path: `${levelsPath}/${levelId}`,
-        fields: { children },
-        requireUpdateTime: doc?.updateTime,
-    };
-}
-export async function buildInsertChildWrite(client, levelsPath, levelId, entry, afterId) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    const children = doc ? childrenOf(doc.data) : [];
-    const insertIndex = afterId === null
-        ? 0
-        : (() => {
-            const found = children.findIndex((c) => c.id === afterId);
-            return found === -1 ? children.length : found + 1;
-        })();
-    children.splice(Math.min(Math.max(insertIndex, 0), children.length), 0, entry);
-    return {
-        path: `${levelsPath}/${levelId}`,
-        fields: { children },
-        requireUpdateTime: doc?.updateTime,
-    };
-}
-/**
- * update_task_status用。[updates]を親ごとにグループ化し、levelsドキュメントを
- * 親ごとに1回だけ読んで該当エントリを書き換えた配列を書き戻すFirestoreWrite[]
- * を組み立てる(Dart版LevelsRepository.updateChildと同じ「読んで置換」方式)。
- * 該当ドキュメントや該当エントリが見つからない場合は、その分だけ静かに
- * スキップする(levelsはbest-effortの書き込みで、失敗しても実害は無いため)。
- */
-export async function buildUpdateEntryWrites(client, levelsPath, updates) {
-    const byLevelId = new Map();
-    for (const update of updates) {
-        const levelId = update.parentId ?? "root";
-        const list = byLevelId.get(levelId) ?? [];
-        list.push({ elementId: update.elementId, patch: update.patch });
-        byLevelId.set(levelId, list);
-    }
-    const writes = [];
-    for (const [levelId, group] of byLevelId) {
-        const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-        if (!doc)
-            continue;
-        const children = childrenOf(doc.data);
-        for (const { elementId, patch } of group) {
-            const index = children.findIndex((c) => c.id === elementId);
-            if (index === -1)
-                continue;
-            children[index] = { ...children[index], ...patch };
-        }
-        // requireUpdateTime: 読み取り後に他の操作がこのlevelsドキュメントを
-        // 書き換えていた場合、この書き込みはFAILED_PRECONDITIONで失敗する
-        // (呼び出し側はrunOptimisticで読み取りからやり直すこと)。
-        writes.push({
-            path: `${levelsPath}/${levelId}`,
-            fields: { children },
-            requireUpdateTime: doc.updateTime,
-        });
-    }
-    return writes;
-}

package/dist/src/domain/levelsOps.js

@@ -1,5 +1,4 @@
-// levels移行・切替後(config/app.migrationEnabled が true)の書き込み。
-// bodiesを一切読まず書かず、levelsコレクションだけで要素を探して書き換える。
+// levelsコレクションの読み取り結果から、要素を探して書き換える書き込みを組み立てる。
 //
 // どの操作も「levels全件の読み取り結果(LevelsSnapshot)」を受け取る純粋関数で、
 // 触った子一覧を作業用に複製して編集し、最後に元の状態との差分から
@@ -12,6 +11,15 @@ import { childrenOf } from "./levels.js";
 export function levelsSnapshotFromDocs(docs) {
     return new Map(docs.map((d) => [d.id, { children: childrenOf(d.data), updateTime: d.updateTime }]));
 }
+/**
+ * levels全件を読む。levels/rootが無いマップは空のマップとして扱う
+ * (rootへの最初の書き込みは、存在しないことを前提条件にした新規作成になる)。
+ * アプリで開いてもrootは作られないので、無いときに止めると中身の無い古い
+ * マップへ永久に書き込めなくなる。
+ */
+export async function readLevelsSnapshot(client, levelsPath) {
+    return levelsSnapshotFromDocs(await client.listDocuments(levelsPath));
+}
 /**
  * rootから辿れる要素だけを対象に、要素id -> 場所 の索引を作る。
  * どこからも辿れない子一覧ドキュメント(過去の不整合の残骸)の中身は数えない。

package/dist/src/domain/mapResolver.js

@@ -30,10 +30,7 @@ export async function resolveMap(client, session, mapId) {
     }
     throw new MapNotFoundError(mapId);
 }
-export function bodiesPathOf(map) {
-    return `users/${map.ownerUid}/headers/${map.headerId}/bodies`;
-}
-/** levels移行: bodiesPathOfと対になる、階層ごとの子一覧を配列で持つ新形式コレクション。 */
+/** マップの中身(階層ごとの子一覧を配列で持つコレクション)のパス。 */
 export function levelsPathOf(map) {
     return `users/${map.ownerUid}/headers/${map.headerId}/levels`;
 }

package/dist/src/domain/markdownParser.js

@@ -93,30 +93,29 @@ export function parseMarkdownForImport(markdownText, { headingsAsNodes }) {
     return { nodes, headingTitle, hasCheckbox };
 }
 function buildRelations(nodes) {
-    if (nodes.length === 0)
-        return;
-    const uniqueIndents = [...new Set(nodes.map((n) => n.rawIndent))].sort((a, b) => a - b);
-    const indentToDepth = new Map();
-    uniqueIndents.forEach((indent, i) => indentToDepth.set(indent, i));
-    const lastNodeAtDepth = new Map();
-    const byId = new Map(nodes.map((n) => [n.id, n]));
+    // 親は「自分より字下げが浅い直近の要素」とする。字下げの幅(2・4・タブ)は
+    // 浅い深いの比較にしか使わないので、刻み幅が混ざっても同じ結果になる。
+    // 段を飛ばした字下げ(`#`の直下の`-`、字下げのばらつき)でも必ず
+    // どこかへ繋がり、親も前の兄弟も無い要素ができない。
+    // 祖先の並び。末尾が直前の要素で、字下げは末尾ほど深い。
+    const ancestors = [];
+    // 親のID(最上位はnull)ごとの、いちばん後ろの子。
+    const lastChildOf = new Map();
     for (const node of nodes) {
-        const depth = indentToDepth.get(node.rawIndent) ?? 0;
-        if (depth > 0) {
-            node.parentId = lastNodeAtDepth.get(depth - 1) ?? null;
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1].rawIndent >= node.rawIndent) {
+            ancestors.pop();
         }
-        const prevId = lastNodeAtDepth.get(depth);
-        if (prevId !== undefined) {
-            node.prevId = prevId;
-            byId.get(prevId).nextId = node.id;
+        const parent = ancestors.length > 0 ? ancestors[ancestors.length - 1] : null;
+        node.parentId = parent?.id ?? null;
+        const prev = lastChildOf.get(node.parentId);
+        if (prev !== undefined) {
+            node.prevId = prev.id;
+            prev.nextId = node.id;
         }
-        else if (node.parentId !== null) {
-            byId.get(node.parentId).childId = node.id;
-        }
-        lastNodeAtDepth.set(depth, node.id);
-        for (const key of [...lastNodeAtDepth.keys()]) {
-            if (key > depth)
-                lastNodeAtDepth.delete(key);
+        else if (parent !== null) {
+            parent.childId = node.id;
         }
+        lastChildOf.set(node.parentId, node);
+        ancestors.push(node);
     }
 }

package/dist/src/firestore/restClient.js

@@ -29,45 +29,6 @@ async function parseJsonResponse(res) {
 }
 /** Firestoreの1コミット(:commit)に含められる書き込み件数の上限(500)より余裕を持たせた値。 */
 const COMMIT_CHUNK_SIZE = 400;
-/**
- * 同じドキュメントを指す書き込みを1件にまとめる。
- *
- * **1回のcommitに同じpathの書き込みを2つ以上積んではいけない。** Firestoreは
- * エラーにせず順に適用するため、後の書き込みが前の書き込みを打ち消す。
- * 実データで2度踏んだ(move_elementで要素が重複、delete_elementsで存在しない
- * IDを指すポインタが残る)。writesを返す直前に必ずこれを通すこと。
- *
- * deleteが1つでもあればdeleteが勝つ(消すドキュメントへの部分更新は無意味)。
- * fields同士はマージし、requireUpdateTimeは最初に読み取った値を残す。
- */
-export function mergeWritesByPath(writes) {
-    const byPath = new Map();
-    const order = [];
-    for (const write of writes) {
-        const prev = byPath.get(write.path);
-        if (!prev) {
-            byPath.set(write.path, { ...write });
-            order.push(write.path);
-            continue;
-        }
-        if (write.delete || prev.delete) {
-            byPath.set(write.path, { path: write.path, delete: true });
-            continue;
-        }
-        if (write.arrayUnion || prev.arrayUnion) {
-            // 配列追記と通常の更新は混ぜられない。後から積んだ方を採る。
-            byPath.set(write.path, { ...write });
-            continue;
-        }
-        byPath.set(write.path, {
-            path: write.path,
-            fields: { ...(prev.fields ?? {}), ...(write.fields ?? {}) },
-            requireUpdateTime: prev.requireUpdateTime ?? write.requireUpdateTime,
-            requireMissing: prev.requireMissing ?? write.requireMissing,
-        });
-    }
-    return order.map((path) => byPath.get(path));
-}
 export class FirestoreRestClient {
     session;
     constructor(session) {

package/dist/src/server.js

@@ -12,7 +12,7 @@ import { registerDeleteElements } from "./tools/deleteElements.js";
 import { registerMoveElement } from "./tools/moveElement.js";
 const server = new McpServer({
     name: "matryoshka-mindmap",
-    version: "0.1.1",
+    version: "0.1.3",
 }, {
     instructions: "このサーバーはリアルタイム同期を行わない。各ツールは呼び出された瞬間の" +
         "Firestoreの状態を返すだけで、アプリ側でユーザーが直接行った変更は" +