mmm-mcp-server 0.1.0

package/dist/src/domain/levels.js

@@ -0,0 +1,242 @@
+// levels移行: users/{uid}/headers/{headerId}/levels/{levelId} の読み書き。
+// lib/matryoshka/levels_repository.dart(Dart側)と同じデータ形状を前提にする。
+//
+//   levels/{levelId}
+//     children: [ { id, detail, done }, ... ]
+//
+// levelIdはマップ最上位が'root'、それ以外はその要素自身のid。配列の並び順が
+// そのまま兄弟順。子を持つ要素だけドキュメントが存在する(無ければ葉)。
+//
+// MCPは「新形式のみ対応」(移行ロジックはDart側だけに持たせる)。levels/root
+// が無いマップに対する操作は、アプリで一度開いてもらうよう案内して止める。
+export class LevelsNotInitializedError extends Error {
+    constructor(title) {
+        super(`「${title}」はまだ新形式(levels)のデータがありません。` +
+            "お手数ですが、アプリでこのマップを一度開いてから、もう一度お試しください。");
+        this.name = "LevelsNotInitializedError";
+    }
+}
+function toEntry(raw) {
+    if (typeof raw !== "object" || raw === null)
+        return null;
+    const obj = raw;
+    if (typeof obj.id !== "string")
+        return null;
+    return {
+        id: obj.id,
+        detail: String(obj.detail ?? ""),
+        done: Boolean(obj.done ?? false),
+    };
+}
+export function childrenOf(data) {
+    const raw = data.children;
+    if (!Array.isArray(raw))
+        return [];
+    const result = [];
+    for (const entry of raw) {
+        const parsed = toEntry(entry);
+        if (parsed)
+            result.push(parsed);
+    }
+    return result;
+}
+/** levels配下の全ドキュメントを読み、levelId -> children[] のMapにする。 */
+export async function readAllLevelDocs(client, levelsPath) {
+    const docs = await client.listDocuments(levelsPath);
+    const result = new Map();
+    for (const doc of docs) {
+        result.set(doc.id, childrenOf(doc.data));
+    }
+    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は配列そのものが順序を表すため、連結リストの再構築や
+ * 分断の復元は不要。循環参照だけは防御的に検出して打ち切る。
+ */
+export function buildTreeFromLevels(levelsById) {
+    function walk(levelId, parentId, ancestry) {
+        const children = levelsById.get(levelId) ?? [];
+        const nextAncestry = new Set(ancestry);
+        nextAncestry.add(levelId);
+        return children.map((entry) => {
+            const hasOwnChildren = levelsById.has(entry.id) && !ancestry.has(entry.id);
+            return {
+                id: entry.id,
+                detail: entry.detail,
+                done: entry.done,
+                parentId,
+                children: hasOwnChildren ? walk(entry.id, entry.id, nextAncestry) : [],
+            };
+        });
+    }
+    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/levelsMode.js

@@ -0,0 +1,24 @@
+// levels移行の切替フラグ。アプリと同じく Firestore の config/app.migrationEnabled を
+// 見て、明示的にfalseの間だけ従来どおりbodiesとlevelsの両方へ書く。それ以外
+// (true・フィールドが無い・ドキュメントが無い)はbodiesを一切使わずlevelsだけで
+// 読み書きする(levelsOps.ts)。bodies削除後にフラグを消しても、公開済みの古い版が
+// bodiesへ書きに行かないよう、未設定はlevels側に倒す。
+//
+// フラグを見ずにlevelsだけへ書くと、切替前はアプリ(bodiesを読んで書く)の
+// 書き込みがMCPの変更を上書きしてしまう。逆にbodiesを使い続けると、切替後は
+// アプリで足した要素が見つからず、bodiesを読み取り専用にするルールの適用後は
+// コミットごと失敗する。呼び出しのたびに読み直すので、MCPサーバーを
+// 再起動しなくても切替に追従する。
+import { LevelsNotInitializedError } from "./levels.js";
+import { levelsSnapshotFromDocs } from "./levelsOps.js";
+export async function isLevelsOnly(client) {
+    const config = await client.getDocument("config/app");
+    return config?.data.migrationEnabled !== false;
+}
+/** levels全件を読む。levels/rootが無ければ、アプリで開いてもらうよう案内して止める。 */
+export async function readLevelsSnapshot(client, levelsPath, mapTitle) {
+    const snapshot = levelsSnapshotFromDocs(await client.listDocuments(levelsPath));
+    if (!snapshot.has("root"))
+        throw new LevelsNotInitializedError(mapTitle);
+    return snapshot;
+}

package/dist/src/domain/levelsOps.js

@@ -0,0 +1,199 @@
+// levels移行・切替後(config/app.migrationEnabled が true)の書き込み。
+// bodiesを一切読まず書かず、levelsコレクションだけで要素を探して書き換える。
+//
+// どの操作も「levels全件の読み取り結果(LevelsSnapshot)」を受け取る純粋関数で、
+// 触った子一覧を作業用に複製して編集し、最後に元の状態との差分から
+// 書き込みを組み立てる。1つのドキュメントへの書き込みは必ず1件になる
+// (同じpathへ2件積むと後勝ちになり、要素の重複や復活が起きる)。
+//
+// 子を持たなくなった要素の子一覧ドキュメントは消す(アプリのprojectLevelsと
+// 同じ扱い)。rootだけは空配列で残す。
+import { childrenOf } from "./levels.js";
+export function levelsSnapshotFromDocs(docs) {
+    return new Map(docs.map((d) => [d.id, { children: childrenOf(d.data), updateTime: d.updateTime }]));
+}
+/**
+ * rootから辿れる要素だけを対象に、要素id -> 場所 の索引を作る。
+ * どこからも辿れない子一覧ドキュメント(過去の不整合の残骸)の中身は数えない。
+ */
+function indexOf(snapshot) {
+    const index = new Map();
+    const walk = (levelId) => {
+        const children = snapshot.get(levelId)?.children ?? [];
+        children.forEach((entry, i) => {
+            if (index.has(entry.id))
+                return; // 循環・重複は最初の位置を採る
+            index.set(entry.id, { parentId: levelId === "root" ? null : levelId, levelId, index: i });
+            walk(entry.id);
+        });
+    };
+    walk("root");
+    return index;
+}
+export function locateInLevels(snapshot, elementId) {
+    return indexOf(snapshot).get(elementId) ?? null;
+}
+/** ルートから[elementId]までの祖先(自分自身を含む)のdetailを、根から順に並べる。 */
+export function ancestorDetailsInLevels(snapshot, elementId) {
+    const index = indexOf(snapshot);
+    const chain = [];
+    let current = elementId;
+    const seen = new Set();
+    while (current !== null && !seen.has(current)) {
+        seen.add(current);
+        const loc = index.get(current);
+        if (!loc)
+            break;
+        chain.push(snapshot.get(loc.levelId).children[loc.index].detail);
+        current = loc.parentId;
+    }
+    return chain.reverse();
+}
+/** [rootId]自身とその配下(子孫)全てのidを集める。 */
+export function subtreeIdsInLevels(snapshot, rootId) {
+    const result = [];
+    const seen = new Set();
+    const walk = (id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        result.push(id);
+        for (const child of snapshot.get(id)?.children ?? [])
+            walk(child.id);
+    };
+    walk(rootId);
+    return result;
+}
+/** 編集中の子一覧。触ったものだけを複製して持ち、最後に差分を書き込みにする。 */
+class LevelsDraft {
+    levelsPath;
+    snapshot;
+    edited = new Map();
+    removed = new Set();
+    constructor(levelsPath, snapshot) {
+        this.levelsPath = levelsPath;
+        this.snapshot = snapshot;
+    }
+    children(levelId) {
+        let list = this.edited.get(levelId);
+        if (!list) {
+            list = (this.snapshot.get(levelId)?.children ?? []).map((c) => ({ ...c }));
+            this.edited.set(levelId, list);
+            this.removed.delete(levelId);
+        }
+        return list;
+    }
+    /** 子一覧ドキュメントごと消す(配下ごと削除される要素の分)。 */
+    remove(levelId) {
+        this.edited.delete(levelId);
+        this.removed.add(levelId);
+    }
+    toWrites() {
+        const writes = [];
+        const pathOf = (levelId) => `${this.levelsPath}/${levelId}`;
+        for (const levelId of this.removed) {
+            const original = this.snapshot.get(levelId);
+            if (!original)
+                continue; // 元から無いものは消す必要が無い
+            writes.push({ path: pathOf(levelId), delete: true, requireUpdateTime: original.updateTime });
+        }
+        for (const [levelId, children] of this.edited) {
+            const original = this.snapshot.get(levelId);
+            if (children.length === 0 && levelId !== "root") {
+                if (original) {
+                    writes.push({ path: pathOf(levelId), delete: true, requireUpdateTime: original.updateTime });
+                }
+                continue;
+            }
+            writes.push(original
+                ? { path: pathOf(levelId), fields: { children }, requireUpdateTime: original.updateTime }
+                : { path: pathOf(levelId), fields: { children }, requireMissing: true });
+        }
+        return writes;
+    }
+}
+/** edit_element / update_task_status 用。見つからなかったidはfoundに入らない。 */
+export function buildLevelsPatchWrites(levelsPath, snapshot, updates) {
+    const index = indexOf(snapshot);
+    const draft = new LevelsDraft(levelsPath, snapshot);
+    const found = new Set();
+    for (const { elementId, patch } of updates) {
+        const loc = index.get(elementId);
+        if (!loc)
+            continue;
+        const list = draft.children(loc.levelId);
+        list[loc.index] = { ...list[loc.index], ...patch };
+        found.add(elementId);
+    }
+    return { writes: draft.toWrites(), found };
+}
+/**
+ * auto_structure_thought / import_markdown_context 用。[forest]の最上位を
+ * [targetParentId](nullなら最上位)の子の末尾へ足し、forest内で子を持つ
+ * 要素の子一覧を新規作成する。挿入先の存在確認は呼び出し側で済ませること。
+ */
+export function buildLevelsAppendWrites(levelsPath, snapshot, forest, targetParentId, isTodo) {
+    const draft = new LevelsDraft(levelsPath, snapshot);
+    const entryOf = (node) => ({
+        id: node.id,
+        detail: node.detail,
+        done: isTodo ? node.done : false,
+    });
+    for (const node of forest) {
+        draft.children(node.parentId ?? targetParentId ?? "root").push(entryOf(node));
+    }
+    return draft.toWrites();
+}
+/**
+ * move_element 用。[elementId](配下ごと)を[newParentId]の子の、[afterId]の
+ * 直後(nullなら先頭)へ移す。[afterId]が移動先の子でなければ末尾へ置く。
+ * 配下の子一覧ドキュメントはidが変わらないので触らない。
+ */
+export function buildLevelsMoveWrites(levelsPath, snapshot, elementId, newParentId, afterId) {
+    const index = indexOf(snapshot);
+    const loc = index.get(elementId);
+    if (!loc) {
+        throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
+    }
+    if (newParentId !== null && !index.has(newParentId)) {
+        throw new Error(`newParentElementId(${newParentId})がこのマップに見つかりません。`);
+    }
+    if (newParentId !== null && subtreeIdsInLevels(snapshot, elementId).includes(newParentId)) {
+        throw new Error("要素を自分自身の配下(子孫)の中へ移動することはできません。");
+    }
+    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 insertAt = afterId === null
+        ? 0
+        : (() => {
+            const found = to.findIndex((c) => c.id === afterId);
+            return found === -1 ? to.length : found + 1;
+        })();
+    to.splice(insertAt, 0, entry);
+    return draft.toWrites();
+}
+/** delete_elements 用。[elementIds]を配下ごと消す。既に無いidは無視する。 */
+export function buildLevelsDeleteWrites(levelsPath, snapshot, elementIds) {
+    const index = indexOf(snapshot);
+    const deletedIds = new Set();
+    for (const id of elementIds) {
+        if (!index.has(id))
+            continue;
+        for (const sub of subtreeIdsInLevels(snapshot, id))
+            deletedIds.add(sub);
+    }
+    const draft = new LevelsDraft(levelsPath, snapshot);
+    for (const id of deletedIds) {
+        const loc = index.get(id);
+        // 親も消えるなら、親の子一覧ドキュメントごと消えるので書き換えない。
+        if (loc.parentId !== null && deletedIds.has(loc.parentId))
+            continue;
+        const list = draft.children(loc.levelId);
+        list.splice(list.findIndex((c) => c.id === id), 1);
+    }
+    for (const id of deletedIds)
+        draft.remove(id);
+    return { writes: draft.toWrites(), deletedIds };
+}

package/dist/src/domain/mapResolver.js

@@ -0,0 +1,52 @@
+import { canEditHeader, headerFromFirestore } from "./header.js";
+export class MapNotFoundError extends Error {
+    constructor(mapId) {
+        super(`マップが見つかりません(id: ${mapId})。list_mapsで存在するIDを確認してください。`);
+        this.name = "MapNotFoundError";
+    }
+}
+/**
+ * mapId(headerId)から、自分の所有マップか共有されたマップかを判定し、
+ * 実際にドキュメントを持っているユーザーのuidを特定する。
+ * 自分の所有物を先に見に行き、無ければ自分のrefs(共有されて見えているマップ)
+ * から探す(header_list_model.dartの一覧結合と同じ考え方)。
+ */
+export async function resolveMap(client, session, mapId) {
+    const own = await client.getDocument(`users/${session.uid}/headers/${mapId}`);
+    if (own) {
+        return { headerId: mapId, ownerUid: session.uid, header: headerFromFirestore(mapId, session.uid, own.data) };
+    }
+    const refs = await client.listDocuments(`users/${session.uid}/refs`);
+    for (const ref of refs) {
+        if (ref.data.headerId !== mapId)
+            continue;
+        const ownerUid = ref.data.userId;
+        if (typeof ownerUid !== "string" || ownerUid === "")
+            continue; // 壊れたrefsは無視する
+        const doc = await client.getDocument(`users/${ownerUid}/headers/${mapId}`);
+        if (doc) {
+            return { headerId: mapId, ownerUid, header: headerFromFirestore(mapId, ownerUid, doc.data) };
+        }
+    }
+    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`;
+}
+/**
+ * 書き込み系ツールの入口で呼ぶ。閲覧のみで共有されているマップに対する
+ * 書き込みを、Firestoreルールに委ねる前にわかりやすいメッセージで止める。
+ */
+export function assertCanEditMap(map, session) {
+    if (!canEditHeader(map.header, session.uid, session.email)) {
+        throw new Error(`「${map.header.title}」は閲覧のみで共有されているため編集できません。`);
+    }
+}
+/** マップ名から要素までの祖先チェーンを「＞」区切りの1本の文字列にする。 */
+export function formatPath(mapTitle, ancestorDetails) {
+    return [mapTitle, ...ancestorDetails].join("＞");
+}

package/dist/src/domain/markdownParser.js

@@ -0,0 +1,122 @@
+import { newDocId } from "./idGen.js";
+const LIST_PATTERN = /^(\s*)(?:[-*+]|\d+\.)\s+(.+)$/;
+const CHECKBOX_PATTERN = /^\[([ xX])\]\s*(.*)$/;
+const HEADING_PATTERN = /^(#{1,6})\s+(.*)$/;
+/**
+ * Markdownテキストを解析して取り込める形の[MarkdownNode]の並びにする。
+ *
+ * `headingsAsNodes`は、見出しを1つの要素として取り込むか
+ * (import_markdown_contextツールでは常にtrue相当、Claudeが組み立てた
+ * 構造をそのまま反映するため)を切り替える。
+ *
+ * 署名行(`---`)より後は読み捨てる。エクスポートしたものを再度取り込んでも
+ * 署名が要素として入らないようにするため。
+ */
+export function parseMarkdownForImport(markdownText, { headingsAsNodes }) {
+    const rawLines = markdownText.split(/\n?\n/);
+    const lines = [];
+    for (const line of rawLines) {
+        if (line.trim() === "---")
+            break;
+        lines.push(line);
+    }
+    let headingTitle = null;
+    for (const line of lines) {
+        const trimLine = line.trim();
+        if (trimLine.startsWith("# ")) {
+            headingTitle = trimLine.substring(2).trim();
+            break;
+        }
+        else if (trimLine.startsWith("## ")) {
+            headingTitle = trimLine.substring(3).trim();
+            break;
+        }
+    }
+    const nodes = [];
+    let currentNode = null;
+    let hasCheckbox = false;
+    for (const line of lines) {
+        const match = LIST_PATTERN.exec(line);
+        if (match) {
+            const indentStr = match[1] ?? "";
+            let detail = match[2] ?? "";
+            const indent = indentStr.replace(/\t/g, "    ").length;
+            let done = false;
+            const checkboxMatch = CHECKBOX_PATTERN.exec(detail);
+            if (checkboxMatch) {
+                hasCheckbox = true;
+                done = checkboxMatch[1].toLowerCase() === "x";
+                detail = checkboxMatch[2] ?? "";
+            }
+            currentNode = {
+                id: newDocId(),
+                detail,
+                rawIndent: indent,
+                done,
+                parentId: null,
+                prevId: null,
+                nextId: null,
+                childId: null,
+            };
+            nodes.push(currentNode);
+            continue;
+        }
+        const trimmed = line.trim();
+        if (headingsAsNodes) {
+            const headingMatch = HEADING_PATTERN.exec(trimmed);
+            if (headingMatch) {
+                const level = headingMatch[1].length;
+                const text = headingMatch[2].trim();
+                if (text === "")
+                    continue;
+                currentNode = {
+                    id: newDocId(),
+                    detail: text,
+                    rawIndent: level - 7,
+                    done: false,
+                    parentId: null,
+                    prevId: null,
+                    nextId: null,
+                    childId: null,
+                };
+                nodes.push(currentNode);
+                continue;
+            }
+        }
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        if (currentNode) {
+            currentNode.detail += `\n${trimmed}`;
+        }
+    }
+    buildRelations(nodes);
+    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]));
+    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;
+        }
+        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);
+        }
+    }
+}