mmm-mcp-server 0.1.1 → 0.1.3

package/dist/src/domain/body.js

@@ -1,127 +0,0 @@
-export function bodyFromFirestore(id, data, updateTime) {
-    return {
-        id,
-        detail: String(data.detail ?? ""),
-        prev: data.prev ?? null,
-        next: data.next ?? null,
-        parent: data.parent ?? null,
-        child: data.child ?? null,
-        done: Boolean(data.done ?? false),
-        updateTime,
-    };
-}
-/**
- * 壊れている(prev/nextが循環・欠落している)データでも、要素を1件も
- * 落とさずに返す。壊れ方の修復はアプリ本体(MatryoshkaModel.repair)の
- * 役目であり、ここでは読み取り専用なので直さず、可能な範囲で順序を
- * 復元しつつ全件を出す。
- */
-export function buildTree(bodies) {
-    const globalVisited = new Set();
-    function orderedChildrenOf(parentId) {
-        const siblings = bodies.filter((b) => b.parent === parentId);
-        if (siblings.length === 0)
-            return [];
-        const bySelfId = new Map(siblings.map((b) => [b.id, b]));
-        const head = siblings.find((b) => b.prev === null || !bySelfId.has(b.prev));
-        const ordered = [];
-        const seen = new Set();
-        let current = head?.id ?? null;
-        while (current !== null && !seen.has(current)) {
-            const node = bySelfId.get(current);
-            if (!node)
-                break;
-            seen.add(current);
-            ordered.push(node);
-            current = node.next;
-        }
-        // next/prevの循環や分断で辿れなかった残りも、無くさず末尾に足す。
-        for (const s of siblings) {
-            if (!seen.has(s.id))
-                ordered.push(s);
-        }
-        return ordered;
-    }
-    function walk(parentId) {
-        const result = [];
-        for (const node of orderedChildrenOf(parentId)) {
-            if (globalVisited.has(node.id))
-                continue; // 循環参照からの二重取り込みを防ぐ
-            globalVisited.add(node.id);
-            result.push({
-                id: node.id,
-                detail: node.detail,
-                done: node.done,
-                parentId: node.parent,
-                children: walk(node.id),
-            });
-        }
-        return result;
-    }
-    const tree = walk(null);
-    // parentが存在しない要素を指している等で上のwalkから漏れた要素も、
-    // 最上位に足しておく(取りこぼしが無いことを優先する)。
-    for (const b of bodies) {
-        if (!globalVisited.has(b.id)) {
-            globalVisited.add(b.id);
-            tree.push({ id: b.id, detail: b.detail, done: b.done, parentId: b.parent, children: [] });
-        }
-    }
-    return tree;
-}
-/** ルートから[elementId]までの祖先(自分自身を含む)のdetailを、根から順に並べる。 */
-export function ancestorDetails(bodies, elementId) {
-    if (elementId === null)
-        return [];
-    const byId = new Map(bodies.map((b) => [b.id, b]));
-    const chain = [];
-    let current = elementId;
-    const seen = new Set();
-    while (current !== null && byId.has(current) && !seen.has(current)) {
-        seen.add(current);
-        const node = byId.get(current);
-        chain.push(node.detail);
-        current = node.parent;
-    }
-    return chain.reverse();
-}
-/** [parentId]の子の連結リストの末尾のIDを求める。子が無ければnull。 */
-export function lastChildOf(bodies, parentId) {
-    const siblings = bodies.filter((b) => b.parent === parentId);
-    if (siblings.length === 0)
-        return null;
-    const byId = new Map(siblings.map((b) => [b.id, b]));
-    let current = siblings.find((b) => b.prev === null || !byId.has(b.prev)) ?? siblings[0];
-    const seen = new Set([current.id]);
-    while (current.next !== null && byId.has(current.next) && !seen.has(current.next)) {
-        current = byId.get(current.next);
-        seen.add(current.id);
-    }
-    return current.id;
-}
-/**
- * [rootId]自身とその配下(子孫)全ての id を集める。move/deleteのように
- * 「要素ごと配下を丸ごと動かす・消す」操作の対象範囲を求めるために使う。
- * 循環参照があっても無限ループしない。
- */
-export function collectSubtreeIds(bodies, rootId) {
-    const byParent = new Map();
-    for (const b of bodies) {
-        const list = byParent.get(b.parent) ?? [];
-        list.push(b);
-        byParent.set(b.parent, list);
-    }
-    const result = [];
-    const seen = new Set();
-    function walk(id) {
-        if (seen.has(id))
-            return;
-        seen.add(id);
-        result.push(id);
-        for (const child of byParent.get(id) ?? []) {
-            walk(child.id);
-        }
-    }
-    walk(rootId);
-    return result;
-}

package/dist/src/domain/deleteElements.js

@@ -1,85 +0,0 @@
-import { collectSubtreeIds } from "./body.js";
-import { buildRemoveChildrenWrite } from "./levels.js";
-import { mergeWritesByPath } from "../firestore/restClient.js";
-/**
- * [elementIds](配下ごと)を削除するための書き込みを組み立てる。tools/deleteElements.tsから
- * 切り出した純粋寄りの関数(client.getDocumentだけ呼ぶ)。
- *
- * 1周目で消える要素を全て確定させてから2周目で繋ぎ直すのは、隣り合う要素を
- * 同時に消すとき、1件ずつその場で繋ぎ直すと消える予定の相手を指すポインタを
- * 書いてしまい、存在しないIDを指したまま残る不具合(実データで発生)を防ぐため。
- */
-export async function buildDeleteElementWrites(client, bodiesPath, levelsPath, currentBodies, elementIds) {
-    const currentById = new Map(currentBodies.map((b) => [b.id, b]));
-    const writes = [];
-    const levelRemovals = new Map();
-    const allIds = new Set();
-    // 1周目: 消える要素を全て確定させる。繋ぎ直しは2周目で行う。
-    for (const elementId of elementIds) {
-        const body = currentById.get(elementId);
-        if (!body)
-            continue; // 既に削除済み(リトライ時など)
-        const subtree = collectSubtreeIds(currentBodies, elementId);
-        for (const id of subtree)
-            allIds.add(id);
-    }
-    /** [startId]から[key]方向へ、消えない要素に当たるまで辿る。 */
-    const survivingNeighbor = (startId, key) => {
-        let cursor = startId;
-        const seen = new Set();
-        while (cursor !== null && allIds.has(cursor) && !seen.has(cursor)) {
-            seen.add(cursor);
-            cursor = currentById.get(cursor)?.[key] ?? null;
-        }
-        return cursor;
-    };
-    // 2周目: 生き残る要素どうしを繋ぎ直す。
-    for (const elementId of elementIds) {
-        const body = currentById.get(elementId);
-        if (!body)
-            continue;
-        const newPrev = survivingNeighbor(body.prev, "prev");
-        const newNext = survivingNeighbor(body.next, "next");
-        if (newPrev !== null) {
-            writes.push({
-                path: `${bodiesPath}/${newPrev}`,
-                fields: { next: newNext },
-                requireUpdateTime: currentById.get(newPrev)?.updateTime,
-            });
-        }
-        else if (body.parent !== null && !allIds.has(body.parent)) {
-            writes.push({
-                path: `${bodiesPath}/${body.parent}`,
-                fields: { child: newNext },
-                requireUpdateTime: currentById.get(body.parent)?.updateTime,
-            });
-        }
-        if (newNext !== null) {
-            writes.push({
-                path: `${bodiesPath}/${newNext}`,
-                fields: { prev: newPrev },
-                requireUpdateTime: currentById.get(newNext)?.updateTime,
-            });
-        }
-        const levelId = body.parent ?? "root";
-        const list = levelRemovals.get(levelId) ?? [];
-        list.push(elementId);
-        levelRemovals.set(levelId, list);
-    }
-    for (const id of allIds) {
-        writes.push({ path: `${bodiesPath}/${id}`, delete: true });
-        // 配下の要素が子を持っていた場合、そのlevelsドキュメント自体も消す。
-        // 存在しないドキュメントへのdeleteはFirestoreでは無害。
-        writes.push({ path: `${levelsPath}/${id}`, delete: true });
-    }
-    for (const [levelId, removeIds] of levelRemovals) {
-        // 親自身も消えるなら、levels/{親} は上のdeleteで消える。
-        // ここで書き戻すと、消したドキュメントが中身入りで復活する。
-        if (allIds.has(levelId))
-            continue;
-        const write = await buildRemoveChildrenWrite(client, levelsPath, levelId, removeIds);
-        if (write)
-            writes.push(write);
-    }
-    return { writes: mergeWritesByPath(writes), deletedIds: allIds };
-}

package/dist/src/domain/levelsMode.js

@@ -1,24 +0,0 @@
-// 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/moveElement.js

@@ -1,93 +0,0 @@
-import { buildInsertChildWrite, buildReorderChildWrite, buildRemoveChildrenWrite } from "./levels.js";
-import { mergeWritesByPath } from "../firestore/restClient.js";
-/**
- * 要素1件(配下ごと)を新しい場所へ移動するための書き込みを組み立てる。
- * tools/moveElement.tsから切り出した純粋寄りの関数(client.getDocumentだけ呼ぶ)。
- * 呼び出し側で自己参照・循環などのバリデーションを済ませ、[elementId]が
- * [existingBodies]に存在することを保証しておくこと。
- */
-export async function buildMoveElementWrites(client, bodiesPath, levelsPath, existingBodies, elementId, newParentElementId, afterElementId) {
-    const byId = new Map(existingBodies.map((b) => [b.id, b]));
-    const body = byId.get(elementId);
-    if (!body) {
-        throw new Error(`elementId(${elementId})がこのマップに見つかりません。`);
-    }
-    const writes = [];
-    // 1) 元の場所の連結リストを繋ぎ直す
-    if (body.prev !== null) {
-        writes.push({
-            path: `${bodiesPath}/${body.prev}`,
-            fields: { next: body.next },
-            requireUpdateTime: byId.get(body.prev)?.updateTime,
-        });
-    }
-    else if (body.parent !== null) {
-        writes.push({
-            path: `${bodiesPath}/${body.parent}`,
-            fields: { child: body.next },
-            requireUpdateTime: byId.get(body.parent)?.updateTime,
-        });
-    }
-    if (body.next !== null) {
-        writes.push({
-            path: `${bodiesPath}/${body.next}`,
-            fields: { prev: body.prev },
-            requireUpdateTime: byId.get(body.next)?.updateTime,
-        });
-    }
-    // 2) 新しい場所へ挿入する位置を求める(afterElementIdが実際にnewParentElementId
-    //    の子でなければ、見つからない扱い=末尾として無視する)。
-    const newSiblingsExcludingSelf = existingBodies.filter((b) => b.parent === newParentElementId && b.id !== elementId);
-    const afterBody = afterElementId !== null
-        ? newSiblingsExcludingSelf.find((b) => b.id === afterElementId) ?? null
-        : null;
-    const newPrevId = afterElementId === null ? null : afterBody?.id ?? null;
-    const newNextId = newPrevId === null
-        ? newSiblingsExcludingSelf.find((b) => b.prev === null)?.id ?? null
-        : newSiblingsExcludingSelf.find((b) => b.prev === newPrevId)?.id ?? null;
-    writes.push({
-        path: `${bodiesPath}/${elementId}`,
-        fields: { parent: newParentElementId, prev: newPrevId, next: newNextId },
-        requireUpdateTime: body.updateTime,
-    });
-    if (newPrevId !== null) {
-        writes.push({
-            path: `${bodiesPath}/${newPrevId}`,
-            fields: { next: elementId },
-            requireUpdateTime: byId.get(newPrevId)?.updateTime,
-        });
-    }
-    else if (newParentElementId !== null) {
-        writes.push({
-            path: `${bodiesPath}/${newParentElementId}`,
-            fields: { child: elementId },
-            requireUpdateTime: byId.get(newParentElementId)?.updateTime,
-        });
-    }
-    if (newNextId !== null) {
-        writes.push({
-            path: `${bodiesPath}/${newNextId}`,
-            fields: { prev: elementId },
-            requireUpdateTime: byId.get(newNextId)?.updateTime,
-        });
-    }
-    // 3) levels側: 元の親から取り除き、新しい親へ挿入する
-    const oldLevelId = body.parent ?? "root";
-    const newLevelId = newParentElementId ?? "root";
-    const entry = { id: elementId, detail: body.detail, done: body.done };
-    if (oldLevelId === newLevelId) {
-        // **同じ親の中での並べ替えは1つの書き込みにまとめること。**
-        // remove用とinsert用を別々に作ると、どちらも「元のchildren」を
-        // 読んでから組み立てるため、同じドキュメントへの書き込みが2つでき、
-        // 後勝ちのinsert側だけが残る。insert側は対象がまだ入ったままの配列に
-        // もう1つ足したものなので、要素が重複する(実データで踏んだ)。
-        writes.push(await buildReorderChildWrite(client, levelsPath, oldLevelId, entry, newPrevId));
-    }
-    else {
-        const removeWrite = await buildRemoveChildrenWrite(client, levelsPath, oldLevelId, [elementId]);
-        if (removeWrite)
-            writes.push(removeWrite);
-        writes.push(await buildInsertChildWrite(client, levelsPath, newLevelId, entry, newPrevId));
-    }
-    return mergeWritesByPath(writes);
-}