wiki-formant 0.69.0 → 0.70.0

package/README.md

@@ -91,6 +91,7 @@ const { items, total } = await searchWiki(reading, 'validators', { page: 1, size
 
 - Every row carries `path`, which every read tool takes back, and `chars` where the page's text was read. A pasted URL resolves, with `pathPrefix` stripped; a category's path reads its hub article; a miss names the nearest pages.
 - Every row carries the page `id` too, which a `pageList` block takes. `get_page` with `blocks: true` returns the stored blocks, the page `id`, its whole metadata and `version`: what an edit starts from. `forEdit` adds what the app's write tool takes beside them, and `authors` names each revision's author in `get_page_history`.
+- `text` should be the serializer the page's markdown twin uses, and `resolve` the resolver its page uses to fill what is read live (a page list's pages): `get_page`, `get_pages` and the default corpus read text through both, so a page reads the same over MCP as at its twin, which `twinParity` checks.
 - `privateHidden` closes the back office to every tool; without it a hidden page is unlisted but readable by path, as its URL is.
 - `metadata`, `label`, `corpus`, `noMatch` and `skills` are the app's: what a row adds, how a category is named, the sections its llms-full.txt is made of, what an empty search says, and the A2A skills.
 - Writes stay with each app, because who may write is the one thing no two of them agree on.

package/dist/wiki-tools.d.ts

@@ -11,6 +11,13 @@ export interface WikiToolsOptions<B extends DiffBlock> {
     url: (tagPath: string, slug: string) => string;
     /** A page's blocks as plain prose: what `get_page` returns and `chars` counts. */
     text: (blocks: B[]) => string;
+    /**
+     * A page's blocks with what is read live filled in, such as a page list's
+     * pages: the resolver the app's page and markdown twin use. `get_page`,
+     * `get_pages` and the default corpus read their text through it, so a list
+     * reads there as it does on the twin rather than as its stored placeholder.
+     */
+    resolve?: (blocks: B[]) => Promise<B[]>;
     /** The wiki as the descriptions name it: "the Radix Wiki", "this DAO's wiki". */
     noun: string;
     /** The corpus document's heading. */

package/dist/wiki-tools.js

@@ -90,21 +90,23 @@ export function wikiReadTools(o) {
             hint: 'Paths are exact. Use search_wiki for a keyword, or list_pages with the tagPath to enumerate the branch.',
         });
     };
-    const full = (page) => ({
+    /** Blocks as the page shows them. */
+    const shown = (blocks) => (o.resolve ? o.resolve(blocks) : Promise.resolve(blocks));
+    const head = (page) => ({
         ...summary({ ...page, snippet: describe(openingText(page.content)) }),
         version: page.version,
-        content: o.text(page.content),
     });
+    const full = async (page) => ({ ...head(page), content: o.text(await shown(page.content)) });
     const sections = async (tagPath) => {
         if (o.corpus)
             return o.corpus(tagPath);
         const pages = (await store.corpus())
             .filter(p => !(p.tagPath === '' && p.slug === '') && (!tagPath || p.tagPath === tagPath || p.tagPath.startsWith(`${tagPath}/`)))
             .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-        return pages.map(p => {
+        return Promise.all(pages.map(async (p) => {
             const path = pathOf(p.tagPath, p.slug);
-            return { path, tagPath: p.tagPath, section: `## ${p.title}\n\nPath: ${path}\nURL: ${o.url(p.tagPath, p.slug)}\nUpdated: ${isoDate(p.updatedAt)}\n\n${o.text(p.content)}` };
-        });
+            return { path, tagPath: p.tagPath, section: `## ${p.title}\n\nPath: ${path}\nURL: ${o.url(p.tagPath, p.slug)}\nUpdated: ${isoDate(p.updatedAt)}\n\n${o.text(await shown(p.content))}` };
+        }));
     };
     const tools = [
         {
@@ -165,8 +167,9 @@ export function wikiReadTools(o) {
                 const r = readArgs(args);
                 const page = await named(r);
                 if (!r.bool('blocks'))
-                    return withAdjustments(r, full(page));
-                return withAdjustments(r, { ...full(page), id: page.id, content: page.content, metadata: page.metadata, ...o.forEdit?.(page) });
+                    return withAdjustments(r, await full(page));
+                // Stored, not resolved: what an edit sends back is what was stored.
+                return withAdjustments(r, { ...head(page), id: page.id, content: page.content, metadata: page.metadata, ...o.forEdit?.(page) });
             },
         },
         {
@@ -207,7 +210,7 @@ export function wikiReadTools(o) {
                         missing.push(input);
                         continue;
                     }
-                    const row = full(page);
+                    const row = await full(page);
                     // At least one page always comes back, so one oversized page can still be read.
                     if (pages.length && used + row.content.length > maxChars) {
                         omitted.push({ path: row.path, chars: row.content.length });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-formant",
-  "version": "0.69.0",
+  "version": "0.70.0",
   "description": "The portable half of a wiki: derived taxonomy and facet controls, a version-negotiating MCP transport, markdown twins, block rendering, a rich-text editor engine, conditional-GET plumbing, and the headers and CSP every origin sends.",
   "type": "module",
   "license": "MIT",