mmm-mcp-server 0.1.2 → 0.2.0

package/dist/src/domain/levelsOps.js

@@ -1,5 +1,4 @@
-// levels移行・切替後(config/app.migrationEnabled が true)の書き込み。
-// bodiesを一切読まず書かず、levelsコレクションだけで要素を探して書き換える。
+// levelsコレクションの読み取り結果から、要素を探して書き換える書き込みを組み立てる。
 //
 // どの操作も「levels全件の読み取り結果(LevelsSnapshot)」を受け取る純粋関数で、
 // 触った子一覧を作業用に複製して編集し、最後に元の状態との差分から
@@ -8,9 +7,30 @@
 //
 // 子を持たなくなった要素の子一覧ドキュメントは消す(アプリのprojectLevelsと
 // 同じ扱い)。rootだけは空配列で残す。
-import { childrenOf } from "./levels.js";
+//
+// 期日・着手日(schedule)は children と同じドキュメントにあり、同じ1件の書き込みで
+// 丸ごと書き直す。子を別の親へ移すときは日付も移し、消すときは外す。書くときは
+// children に無いidを取り除く(古い版が取り残した分の掃除。docs/schedule.md §4)。
+//
+// マップ間リンク(links)も同じドキュメントにあり、日付と同じ扱いにする
+// (docs/map-links.md §8)。ただしリンクを足す・外すツールは無い。移すときに運び、消すときに外す。
+// header の linkCounts(リンク先ごとの件数の要約)は別ドキュメントなので、
+// [withLinkSummary]で、変わるときだけ同じコミットへ足す。
+import { buildTreeFromLevels, childrenOf, linksOf, scheduleOf, } from "./levels.js";
 export function levelsSnapshotFromDocs(docs) {
-    return new Map(docs.map((d) => [d.id, { children: childrenOf(d.data), updateTime: d.updateTime }]));
+    return new Map(docs.map((d) => [
+        d.id,
+        { children: childrenOf(d.data), schedule: scheduleOf(d.data), links: linksOf(d.data), updateTime: d.updateTime },
+    ]));
+}
+/**
+ * levels全件を読む。levels/rootが無いマップは空のマップとして扱う
+ * (rootへの最初の書き込みは、存在しないことを前提条件にした新規作成になる)。
+ * アプリで開いてもrootは作られないので、無いときに止めると中身の無い古い
+ * マップへ永久に書き込めなくなる。
+ */
+export async function readLevelsSnapshot(client, levelsPath) {
+    return levelsSnapshotFromDocs(await client.listDocuments(levelsPath));
 }
 /**
  * rootから辿れる要素だけを対象に、要素id -> 場所 の索引を作る。
@@ -64,11 +84,27 @@ export function subtreeIdsInLevels(snapshot, rootId) {
     walk(rootId);
     return result;
 }
+/** list_elements 用。rootから辿れる要素の木に、各要素の期日・着手日を添える。 */
+export function elementTreeOf(snapshot) {
+    const tree = buildTreeFromLevels(new Map([...snapshot].map(([id, level]) => [id, level.children])));
+    const attach = (nodes) => {
+        for (const node of nodes) {
+            const schedule = snapshot.get(node.parentId ?? "root")?.schedule.get(node.id);
+            if (schedule)
+                node.schedule = schedule;
+            attach(node.children);
+        }
+    };
+    attach(tree);
+    return tree;
+}
 /** 編集中の子一覧。触ったものだけを複製して持ち、最後に差分を書き込みにする。 */
 class LevelsDraft {
     levelsPath;
     snapshot;
     edited = new Map();
+    editedSchedule = new Map();
+    editedLinks = new Map();
     removed = new Set();
     constructor(levelsPath, snapshot) {
         this.levelsPath = levelsPath;
@@ -79,15 +115,58 @@ class LevelsDraft {
         if (!list) {
             list = (this.snapshot.get(levelId)?.children ?? []).map((c) => ({ ...c }));
             this.edited.set(levelId, list);
+            this.editedSchedule.set(levelId, new Map(this.snapshot.get(levelId)?.schedule));
+            this.editedLinks.set(levelId, new Map(this.snapshot.get(levelId)?.links));
             this.removed.delete(levelId);
         }
         return list;
     }
+    /** [levelId]の子の日付。触ると、その子一覧も書き込みの対象になる。 */
+    schedule(levelId) {
+        this.children(levelId);
+        return this.editedSchedule.get(levelId);
+    }
+    /** [levelId]の子のマップ間リンク。触ると、その子一覧も書き込みの対象になる。 */
+    links(levelId) {
+        this.children(levelId);
+        return this.editedLinks.get(levelId);
+    }
     /** 子一覧ドキュメントごと消す(配下ごと削除される要素の分)。 */
     remove(levelId) {
         this.edited.delete(levelId);
+        this.editedSchedule.delete(levelId);
+        this.editedLinks.delete(levelId);
         this.removed.add(levelId);
     }
+    /**
+     * 書き込む schedule。children に無いidは除く。元も今も日付が無ければ
+     * undefined を返し、schedule のフィールドに触れない(日付を使わないマップの
+     * 書き込みを今までと同じに保つ)。
+     */
+    scheduleToWrite(levelId, children) {
+        const ids = new Set(children.map((c) => c.id));
+        const result = {};
+        for (const [id, entry] of this.editedSchedule.get(levelId) ?? []) {
+            if (ids.has(id))
+                result[id] = entry;
+        }
+        const hadSchedule = (this.snapshot.get(levelId)?.schedule.size ?? 0) > 0;
+        return hadSchedule || Object.keys(result).length > 0 ? result : undefined;
+    }
+    /**
+     * 書き込む links。children に無いidは除く。元も今もリンクが無ければ undefined を返し、
+     * links のフィールドに触れない(リンクを使わないマップの書き込みを今までと同じに保つ)。
+     */
+    linksToWrite(levelId, children) {
+        const ids = new Set(children.map((c) => c.id));
+        const result = {};
+        for (const [id, targets] of this.editedLinks.get(levelId) ?? []) {
+            if (ids.has(id))
+                result[id] = targets;
+        }
+        const hadLinks = (this.snapshot.get(levelId)?.links.size ?? 0) > 0;
+        return hadLinks || Object.keys(result).length > 0 ? result : undefined;
+    }
     toWrites() {
         const writes = [];
         const pathOf = (levelId) => `${this.levelsPath}/${levelId}`;
@@ -105,9 +184,16 @@ class LevelsDraft {
                 }
                 continue;
             }
+            const schedule = this.scheduleToWrite(levelId, children);
+            const links = this.linksToWrite(levelId, children);
+            const fields = {
+                children,
+                ...(schedule ? { schedule } : {}),
+                ...(links ? { links } : {}),
+            };
             writes.push(original
-                ? { path: pathOf(levelId), fields: { children }, requireUpdateTime: original.updateTime }
-                : { path: pathOf(levelId), fields: { children }, requireMissing: true });
+                ? { path: pathOf(levelId), fields, requireUpdateTime: original.updateTime }
+                : { path: pathOf(levelId), fields, requireMissing: true });
         }
         return writes;
     }
@@ -127,6 +213,33 @@ export function buildLevelsPatchWrites(levelsPath, snapshot, updates) {
     }
     return { writes: draft.toWrites(), found };
 }
+/** set_schedule 用。見つからなかったidはfoundに入らない。同じ要素への指定は後が勝つ。 */
+export function buildLevelsScheduleWrites(levelsPath, snapshot, updates) {
+    const index = indexOf(snapshot);
+    const draft = new LevelsDraft(levelsPath, snapshot);
+    const found = new Set();
+    for (const { elementId, due, start } of updates) {
+        const loc = index.get(elementId);
+        if (!loc)
+            continue;
+        const schedule = draft.schedule(loc.levelId);
+        const next = { ...schedule.get(elementId) };
+        if (due === null)
+            delete next.due;
+        else if (due !== undefined)
+            next.due = due;
+        if (start === null)
+            delete next.start;
+        else if (start !== undefined)
+            next.start = start;
+        if (next.due || next.start)
+            schedule.set(elementId, next);
+        else
+            schedule.delete(elementId);
+        found.add(elementId);
+    }
+    return { writes: draft.toWrites(), found };
+}
 /**
  * auto_structure_thought / import_markdown_context 用。[forest]の最上位を
  * [targetParentId](nullなら最上位)の子の末尾へ足し、forest内で子を持つ
@@ -140,7 +253,10 @@ export function buildLevelsAppendWrites(levelsPath, snapshot, forest, targetPare
         done: isTodo ? node.done : false,
     });
     for (const node of forest) {
-        draft.children(node.parentId ?? targetParentId ?? "root").push(entryOf(node));
+        const levelId = node.parentId ?? targetParentId ?? "root";
+        draft.children(levelId).push(entryOf(node));
+        if (node.schedule)
+            draft.schedule(levelId).set(node.id, node.schedule);
     }
     return draft.toWrites();
 }
@@ -164,7 +280,20 @@ export function buildLevelsMoveWrites(levelsPath, snapshot, elementId, newParent
     const draft = new LevelsDraft(levelsPath, snapshot);
     const from = draft.children(loc.levelId);
     const [entry] = from.splice(from.findIndex((c) => c.id === elementId), 1);
-    const to = draft.children(newParentId ?? "root");
+    // 日付も一緒に移す(同じ親の中の並べ替えなら、外して同じ所へ戻すだけ)
+    const fromSchedule = draft.schedule(loc.levelId);
+    const dates = fromSchedule.get(elementId);
+    fromSchedule.delete(elementId);
+    // リンクも一緒に移す
+    const fromLinks = draft.links(loc.levelId);
+    const linkTargets = fromLinks.get(elementId);
+    fromLinks.delete(elementId);
+    const toLevelId = newParentId ?? "root";
+    const to = draft.children(toLevelId);
+    if (dates)
+        draft.schedule(toLevelId).set(elementId, dates);
+    if (linkTargets)
+        draft.links(toLevelId).set(elementId, linkTargets);
     const insertAt = afterId === null
         ? 0
         : (() => {
@@ -192,8 +321,66 @@ export function buildLevelsDeleteWrites(levelsPath, snapshot, elementIds) {
             continue;
         const list = draft.children(loc.levelId);
         list.splice(list.findIndex((c) => c.id === id), 1);
+        draft.schedule(loc.levelId).delete(id);
+        draft.links(loc.levelId).delete(id);
     }
     for (const id of deletedIds)
         draft.remove(id);
     return { writes: draft.toWrites(), deletedIds };
 }
+/**
+ * header の linkCounts に書く要約: リンク先のキー(`uid:headerId`)-> そのマップへリンクして
+ * いる要素の数。いま子一覧にある要素のリンクだけを数え、1つの要素が同じマップへ
+ * 複数張っていても1つと数える(アプリの linkCountsOf と同じ)。
+ */
+export function linkCountsOfSnapshot(snapshot) {
+    const counts = {};
+    for (const level of snapshot.values()) {
+        const ids = new Set(level.children.map((c) => c.id));
+        for (const [id, targets] of level.links) {
+            if (!ids.has(id))
+                continue;
+            for (const key of new Set(targets.map((t) => `${t.uid}:${t.headerId}`))) {
+                counts[key] = (counts[key] ?? 0) + 1;
+            }
+        }
+    }
+    return counts;
+}
+/** [writes]を[snapshot]へ適用した後の状態(書き込みを組み立て直さず、要約の比較に使う)。 */
+function applyWritesToSnapshot(levelsPath, snapshot, writes) {
+    const after = new Map(snapshot);
+    const prefix = `${levelsPath}/`;
+    for (const write of writes) {
+        if (!write.path.startsWith(prefix))
+            continue;
+        const levelId = write.path.slice(prefix.length);
+        if (write.delete) {
+            after.delete(levelId);
+            continue;
+        }
+        if (!write.fields)
+            continue;
+        const before = after.get(levelId);
+        after.set(levelId, {
+            children: write.fields.children !== undefined ? childrenOf(write.fields) : (before?.children ?? []),
+            schedule: before?.schedule ?? new Map(),
+            // links を書いていなければ、書き込み前のまま残る
+            links: write.fields.links !== undefined ? linksOf(write.fields) : (before?.links ?? new Map()),
+            updateTime: before?.updateTime,
+        });
+    }
+    return after;
+}
+/**
+ * [writes]でリンクの要約(linkCounts)が変わるときだけ、header への書き込みを足して返す
+ * (変わらなければ[writes]のまま)。levels と同じコミットで書く。header は別ドキュメントなので、
+ * levels の「同じドキュメントへ2件書かない」には触れない。
+ */
+export function withLinkSummary(headerPath, levelsPath, snapshot, writes) {
+    const before = linkCountsOfSnapshot(snapshot);
+    const after = linkCountsOfSnapshot(applyWritesToSnapshot(levelsPath, snapshot, writes));
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)]);
+    const changed = [...keys].some((k) => before[k] !== after[k]);
+    return changed ? [...writes, { path: headerPath, fields: { linkCounts: after } }] : writes;
+}

package/dist/src/domain/mapResolver.js

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

package/dist/src/domain/markdownParser.js

@@ -1,7 +1,24 @@
 import { newDocId } from "./idGen.js";
+import { parseScheduleDate } from "./scheduleText.js";
 const LIST_PATTERN = /^(\s*)(?:[-*+]|\d+\.)\s+(.+)$/;
 const CHECKBOX_PATTERN = /^\[([ xX])\]\s*(.*)$/;
 const HEADING_PATTERN = /^(#{1,6})\s+(.*)$/;
+// Obsidian Tasks の書き方(docs/schedule.md §7)。時刻付きは日付のあとに続ける。
+const SCHEDULE_PATTERN = /\s*(📅|🛫)\s*(\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2})?)/gu;
+/** 要素の1行目から 📅・🛫 の日付を取り出す。読めない日付は本文に残す。 */
+function extractSchedule(detail) {
+    const schedule = {};
+    const rest = detail.replace(SCHEDULE_PATTERN, (whole, mark, text) => {
+        try {
+            schedule[mark === "📅" ? "due" : "start"] = parseScheduleDate(text);
+            return "";
+        }
+        catch {
+            return whole;
+        }
+    });
+    return schedule.due || schedule.start ? { detail: rest.trim(), schedule } : { detail };
+}
 /**
  * Markdownテキストを解析して取り込める形の[MarkdownNode]の並びにする。
  *
@@ -48,15 +65,17 @@ export function parseMarkdownForImport(markdownText, { headingsAsNodes }) {
                 done = checkboxMatch[1].toLowerCase() === "x";
                 detail = checkboxMatch[2] ?? "";
             }
+            const extracted = extractSchedule(detail);
             currentNode = {
                 id: newDocId(),
-                detail,
+                detail: extracted.detail,
                 rawIndent: indent,
                 done,
                 parentId: null,
                 prevId: null,
                 nextId: null,
                 childId: null,
+                ...(extracted.schedule ? { schedule: extracted.schedule } : {}),
             };
             nodes.push(currentNode);
             continue;
@@ -93,30 +112,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;
-        }
-        const prevId = lastNodeAtDepth.get(depth);
-        if (prevId !== undefined) {
-            node.prevId = prevId;
-            byId.get(prevId).nextId = node.id;
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1].rawIndent >= node.rawIndent) {
+            ancestors.pop();
         }
-        else if (node.parentId !== null) {
-            byId.get(node.parentId).childId = 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;
         }
-        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/domain/scheduleText.js

@@ -0,0 +1,29 @@
+const PATTERN = /^(\d{4})-(\d{2})-(\d{2})(?: (\d{2}):(\d{2}))?$/;
+const pad = (n) => String(n).padStart(2, "0");
+export function formatScheduleDate(date) {
+    const d = date.at;
+    if (date.allDay) {
+        return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+    }
+    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ` +
+        `${pad(d.getHours())}:${pad(d.getMinutes())}`);
+}
+export function parseScheduleDate(text) {
+    const m = PATTERN.exec(text.trim());
+    const invalid = () => new Error(`日付「${text}」を読めません。終日なら "YYYY-MM-DD"、時刻付きなら "YYYY-MM-DD HH:mm" で指定してください。`);
+    if (!m)
+        throw invalid();
+    const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    const hasTime = m[4] !== undefined;
+    const [h, mi] = hasTime ? [Number(m[4]), Number(m[5])] : [0, 0];
+    if (h > 23 || mi > 59)
+        throw invalid();
+    const at = hasTime ? new Date(y, mo - 1, d, h, mi) : new Date(Date.UTC(y, mo - 1, d));
+    // 2/30 のような存在しない日付は、Date が翌月へ繰り越すので突き合わせて弾く
+    const [cy, cm, cd] = hasTime
+        ? [at.getFullYear(), at.getMonth() + 1, at.getDate()]
+        : [at.getUTCFullYear(), at.getUTCMonth() + 1, at.getUTCDate()];
+    if (cy !== y || cm !== mo || cd !== d)
+        throw invalid();
+    return { at, allDay: !hasTime };
+}

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/firestore/valueCodec.js

@@ -15,6 +15,9 @@ export function encodeValue(value) {
     if (typeof value === "string") {
         return { stringValue: value };
     }
+    if (value instanceof Date) {
+        return { timestampValue: value.toISOString() };
+    }
     if (Array.isArray(value)) {
         return { arrayValue: { values: value.map(encodeValue) } };
     }
@@ -36,6 +39,9 @@ export function decodeValue(value) {
         return value.doubleValue;
     if ("stringValue" in value)
         return value.stringValue;
+    // RFC 3339。ナノ秒まで来ることがあるが、Dateはミリ秒までしか持たない
+    if ("timestampValue" in value)
+        return new Date(value.timestampValue);
     if ("arrayValue" in value) {
         return (value.arrayValue.values ?? []).map(decodeValue);
     }

package/dist/src/server.js

@@ -10,9 +10,10 @@ import { registerImportMarkdownContext } from "./tools/importMarkdownContext.js"
 import { registerEditElement } from "./tools/editElement.js";
 import { registerDeleteElements } from "./tools/deleteElements.js";
 import { registerMoveElement } from "./tools/moveElement.js";
+import { registerSetSchedule } from "./tools/setSchedule.js";
 const server = new McpServer({
     name: "matryoshka-mindmap",
-    version: "0.1.2",
+    version: "0.2.0",
 }, {
     instructions: "このサーバーはリアルタイム同期を行わない。各ツールは呼び出された瞬間の" +
         "Firestoreの状態を返すだけで、アプリ側でユーザーが直接行った変更は" +
@@ -29,5 +30,6 @@ registerImportMarkdownContext(server);
 registerEditElement(server);
 registerDeleteElements(server);
 registerMoveElement(server);
+registerSetSchedule(server);
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/src/tools/autoStructureThought.js

@@ -1,17 +1,18 @@
 import { z } from "zod";
-import { mergeWritesByPath } from "../firestore/restClient.js";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsAppendWrites, locateInLevels } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails } from "../domain/body.js";
-import { buildForestFromTree, buildAppendWrites } from "../domain/appendForest.js";
-import { assertLevelsRootExists, buildAppendLevelWrites, levelsDocExists } from "../domain/levels.js";
+import { assertDetailLengths } from "../domain/detailLimit.js";
+import { ancestorDetailsInLevels, buildLevelsAppendWrites, locateInLevels, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
+import { buildForestFromTree } from "../domain/appendForest.js";
 const treeNodeSchema = z.lazy(() => z.object({
-    detail: z.string().min(1).describe("要素の本文"),
+    detail: z.string().min(1).describe("要素の本文(1要素5000文字まで)"),
     done: z.boolean().optional().describe("TODOマップのときのチェック状態(省略時false)"),
     children: z.array(treeNodeSchema).optional().describe("この要素の内側に入れ子にする子要素"),
 }));
+/** [nodes]とその配下すべての本文。 */
+function allDetails(nodes) {
+    return nodes.flatMap((node) => [node.detail, ...allDetails(node.children ?? [])]);
+}
 export function registerAutoStructureThought(server) {
     server.tool("auto_structure_thought", "会話中にClaudeが考えた階層構造を、既存のマップに追加する。深さは3階層固定ではなく任意。" +
         "構造化のロジック(何をどう分解するか)はClaude側の判断で行い、このツールはFirestoreへの" +
@@ -25,61 +26,27 @@ export function registerAutoStructureThought(server) {
             .describe("この要素の内側(子)として追加する。マップの最上位に追加する場合はnullまたは省略"),
         nodes: z.array(treeNodeSchema).min(1).describe("追加する階層構造(ルートの配列)"),
     }, async ({ mapId, parentElementId, nodes }) => {
+        assertDetailLengths(allDetails(nodes));
         const { client, session } = getContext();
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
         const targetParentId = parentElementId ?? null;
         const forest = buildForestFromTree(nodes);
-        if (await isLevelsOnly(client)) {
-            let levelsPathResult = "";
-            await client.runOptimistic(async () => {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                if (targetParentId !== null && !locateInLevels(snapshot, targetParentId)) {
-                    throw new Error(`parentElementId(${targetParentId})がこのマップに見つかりません。list_elementsで確認してください。`);
-                }
-                levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, targetParentId));
-                return buildLevelsAppendWrites(levelsPath, snapshot, forest, targetParentId, map.header.isTodo);
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ path: levelsPathResult, addedElementCount: forest.length }, null, 2),
-                    },
-                ],
-            };
-        }
-        // 読み取り(bodies一覧・levels存在確認)から書き込みまでを楽観的
-        // ロックでまとめる。読み取り後に対象ドキュメントが他から変更される
-        // とコミットがFAILED_PRECONDITIONになり、読み取りからやり直す。
-        let createdIds = [];
-        let existingBodiesForPath = [];
+        let levelsPathResult = "";
         await client.runOptimistic(async () => {
-            assertLevelsRootExists(await levelsDocExists(client, levelsPath, "root"), map.header.title);
-            const existingDocs = await client.listDocuments(bodiesPath);
-            const existingBodies = existingDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
-            existingBodiesForPath = existingBodies;
-            if (targetParentId !== null && !existingBodies.some((b) => b.id === targetParentId)) {
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            if (targetParentId !== null && !locateInLevels(snapshot, targetParentId)) {
                 throw new Error(`parentElementId(${targetParentId})がこのマップに見つかりません。list_elementsで確認してください。`);
             }
-            const { writes, createdIds: ids } = buildAppendWrites(bodiesPath, existingBodies, forest, targetParentId, map.header.isTodo);
-            createdIds = ids;
-            // 挿入先のlevelsドキュメントが実際に存在するかを直接確認する
-            // (bodies側の状態から推測すると、levelsとbodiesが食い違っている
-            // 場合にarrayUnion書き込みが「ドキュメントが無い」で失敗しうるため)。
-            const targetLevelId = targetParentId ?? "root";
-            const targetHasLevelsDoc = targetLevelId === "root" || (await levelsDocExists(client, levelsPath, targetLevelId));
-            const levelWrites = buildAppendLevelWrites(levelsPath, forest, targetParentId, targetHasLevelsDoc, map.header.isTodo);
-            return mergeWritesByPath([...writes, ...levelWrites]);
+            levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, targetParentId));
+            return buildLevelsAppendWrites(levelsPath, snapshot, forest, targetParentId, map.header.isTodo);
         });
-        const path = formatPath(map.header.title, ancestorDetails(existingBodiesForPath, targetParentId));
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({ path, addedElementCount: createdIds.length }, null, 2),
+                    text: JSON.stringify({ path: levelsPathResult, addedElementCount: forest.length }, null, 2),
                 },
             ],
         };

package/dist/src/tools/createMap.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
 import { newDocId } from "../domain/idGen.js";
+import { buildCreateMapWrites } from "../domain/headerOrder.js";
 export function registerCreateMap(server) {
     server.tool("create_map", "新しいマインドマップ(マップ)を1つ作成する。" +
         "list_mapsで確認して該当するマップが無いときだけ呼ぶこと。" +
@@ -10,23 +11,12 @@ export function registerCreateMap(server) {
         isTodo: z.boolean().describe("TODOマップ(要素にチェックボックスを付ける)にするかどうか"),
     }, async ({ title, isTodo }) => {
         const { client, session } = getContext();
-        const existing = await client.listDocuments(`users/${session.uid}/headers`);
-        const maxOrder = existing.reduce((max, doc) => Math.max(max, Number(doc.data.order ?? 0)), 0);
-        // levels移行: 自前でIDを採番し、header本体と空のlevels/rootを1回の
-        // commitWritesにまとめて作る。levels/rootを最初から持たせておくことで、
-        // 直後に書き込み系ツールを呼んでも「アプリで一度開いてください」で
-        // 弾かれない(移行ではなく単なる初期化なので問題ない)。
-        // migratedはアプリの新規作成(header_add_model.dart)と揃える。無いと、
-        // 切替前のアプリが開いたときに未移行とみなしてbodiesから作り直してしまう。
+        const headersPath = `users/${session.uid}/headers`;
+        // 振り直しは読んだ時点の updateTime を前提条件にするので、読んでから書くまでに
+        // ほかの端末で見出しが変わると失敗する。そのときは読み取りからやり直す。
+        // id はやり直しても同じものを使う(失敗した commit は何も書いていない)。
         const headerId = newDocId();
-        const headerPath = `users/${session.uid}/headers/${headerId}`;
-        await client.commitWrites([
-            {
-                path: headerPath,
-                fields: { title, order: maxOrder + 1, isTodo, editors: [], viewers: [] },
-            },
-            { path: `${headerPath}/levels/root`, fields: { children: [], migrated: true } },
-        ]);
+        await client.runOptimistic(async () => buildCreateMapWrites(headersPath, await client.listDocuments(headersPath), headerId, title, isTodo));
         return {
             content: [
                 {