openalmanac 0.2.54 → 0.2.56

package/dist/server.js

@@ -3,10 +3,10 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { FastMCP } from "fastmcp";
 import { registerAuthTools } from "./tools/auth.js";
-import { registerArticleTools } from "./tools/articles.js";
+import { registerPageTools } from "./tools/pages.js";
 import { registerResearchTools } from "./tools/research.js";
-import { registerCommunityTools } from "./tools/communities.js";
-import { registerPeopleTools } from "./tools/people.js";
+import { registerWikiTools } from "./tools/wikis.js";
+import { registerTopicTools } from "./tools/topics.js";
 import { getApiKey } from "./auth.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
@@ -31,7 +31,7 @@ export function createServer() {
         name: "OpenAlmanac",
         version: pkg.version,
         instructions: [
-            "OpenAlmanac is an open knowledge base — a Wikipedia anyone can read from and write to through an API. Articles are markdown files with YAML frontmatter and [@key] citation markers mapped to named sources.",
+            "OpenAlmanac is an open knowledge base — a Wikipedia anyone can read from and write to through an API. Pages are markdown files with YAML frontmatter, [@key] citation markers, and [[wikilinks]]. Content is organized into wikis, each with topics, pages, and navigation.",
             "",
             "## How this should feel",
             "",
@@ -47,7 +47,7 @@ export function createServer() {
             "",
             "Your answers should feel like living knowledge — with linked entities and images, not plain text walls.",
             "",
-            "**Entity links:** Before writing your response, call `search_articles` with the key entity names you plan to mention (e.g. `queries: [\"Theravada Buddhism\", \"Thailand\", \"Angkor Wat\"]`). This returns which articles/stubs exist and their slugs. Then use `[[slug|Display Text]]` wikilink syntax in your response. Published articles preserve wikilinks in storage; dead links auto-create stub articles on publish (community wikis) so round-trip editing stays faithful.",
+            "**Entity links:** Before writing your response, call `search_articles` with the key entity names you plan to mention (e.g. `queries: [\"Theravada Buddhism\", \"Thailand\", \"Angkor Wat\"]`). This returns which pages/stubs exist and their slugs. Then use `[[slug|Display Text]]` wikilink syntax in your response. Dead links auto-create stub pages on publish so round-trip editing stays faithful.",
             "",
             "**Images:** Use `search_images` to find 1-2 relevant images for your response. Include them using the figure syntax: `![Descriptive caption](image_url \"position\")` where position is `right`, `left`, or `center`. Always write a descriptive caption. Use `view_images` to verify candidates before including them.",
             "",
@@ -78,7 +78,7 @@ export function createServer() {
             "",
             'Example: User says "I\'m interested in UX." Don\'t say "Would you like to focus on history, applications, or companies?" Instead, research and say: "So UX was coined by Don Norman at Apple in 1993, but the practice goes back to Henry Dreyfuss in the 1950s designing telephone handsets by measuring thousands of human bodies. There\'s also the dark patterns side — Ryanair\'s checkout flow got studied in academic papers as a case study in hostile design. And there\'s the curb cut effect — features designed for disabled users that end up benefiting everyone. What pulls you?"',
             "",
-            "**User has no topic** → Talk to them. What are they into — a movie they just watched, a hobby, something from work, a place they visited, a news story that caught their eye? Once you have a thread, research it and come back with real information. You can also use `list_articles` with `sort: \"most_referenced\"` and `stubs_only: true` on a community wiki to find high-demand stubs.",
+            "**User has no topic** → Talk to them. What are they into — a movie they just watched, a hobby, something from work, a place they visited, a news story that caught their eye? Once you have a thread, research it and come back with real information. You can also use `list_articles` with `wiki_slug` and `stubs_only: true` to find stubs that need writing.",
             "",
             "**User wants to edit an existing article** → Download it and read it. Look for what's *interesting but underdeveloped* — a one-sentence mention of a controversy probably has a whole story behind it. Share what you find and propose going deeper.",
             "",
@@ -103,7 +103,7 @@ export function createServer() {
             "",
             "3. **Read the writing guidelines** — Fetch https://www.openalmanac.org/writing-guidelines.md and https://www.openalmanac.org/ai-patterns-to-avoid.md before writing a single word.",
             "",
-            "4. **Scaffold** — Use `new` with one or more `{ title, slug?, topics? }` entries. Provide `slug` when you know the canonical ID; otherwise it is auto-derived from the title. For community wikis pass `community_slug`. List ALL sources you've gathered in the frontmatter before writing any body text. Don't discard sources — if you read it during research and it's relevant, include it.",
+            "4. **Scaffold** — Use `new` with one or more `{ title, slug?, topics? }` entries and a `wiki_slug`. Provide `slug` when you know the canonical ID; otherwise it is auto-derived from the title. List ALL sources you've gathered in the frontmatter before writing any body text. Don't discard sources — if you read it during research and it's relevant, include it.",
             "",
             "5. **Write a pure text draft** — This whole process (writing, review, fact-check, images, linking) takes a few minutes. Let the user know in a fun way that they can step away — and that once it's ready, you're happy to discuss any edits or polishing.",
             "",
@@ -111,14 +111,14 @@ export function createServer() {
             "",
             "6. **Dispatch four subagents in parallel** — After the draft is complete, dispatch these simultaneously. Each agent has its own guidelines file — tell it to fetch and read that file as its first step. The guidelines file tells the agent what to do, what additional guidelines to fetch, and what format to return results in.",
             "",
-            "   - **Review agent** → tell it to read https://www.openalmanac.org/review-guidelines.md and review the draft at `~/.openalmanac/articles/{slug}.md`",
-            "   - **Fact-check agent** → tell it to read https://www.openalmanac.org/fact-checking-guidelines.md and fact-check the draft at `~/.openalmanac/articles/{slug}.md`",
-            "   - **Image agent** → tell it to read https://www.openalmanac.org/image-guidelines.md and find images for the draft at `~/.openalmanac/articles/{slug}.md`",
-            "   - **Linking agent** → tell it to read https://www.openalmanac.org/linking-guidelines.md and add wikilinks for the draft at `~/.openalmanac/articles/{slug}.md` (dead links become stubs on publish — no manual `create_stubs` step)",
+            "   - **Review agent** → tell it to read https://www.openalmanac.org/review-guidelines.md and review the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
+            "   - **Fact-check agent** → tell it to read https://www.openalmanac.org/fact-checking-guidelines.md and fact-check the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
+            "   - **Image agent** → tell it to read https://www.openalmanac.org/image-guidelines.md and find images for the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md`",
+            "   - **Linking agent** → tell it to read https://www.openalmanac.org/linking-guidelines.md and add wikilinks for the draft at `~/.openalmanac/articles/{wiki_slug}/{slug}.md` (dead links become stubs on publish)",
             "",
             "7. **Integrate** — Present the review and fact-check feedback to the user. Then fix everything in one pass: review issues, fact-check corrections, add images, add wikilinks.",
             "",
-            "8. **Publish** — Validate and publish (`publish` with `slugs` or `community_slug` to batch). Put per-article change notes in frontmatter as `edit_summary` (maps to the API). Share the exact URL from the publish response when single-article. For community wikis, use `list_articles` to verify coverage.",
+            "8. **Publish** — Validate and publish (`publish` with `slugs` and `wiki_slug`). Put per-page change notes in frontmatter as `edit_summary`. Share the exact URL from the publish response when single-page. Use `list_articles` to verify coverage.",
             "",
             "Why this order: the draft must be finished before subagents run. The linking agent needs to see what entities are actually in the text. The image agent needs to match images to specific content. The review agent needs the complete article. Everything reads the draft.",
             "",
@@ -126,17 +126,17 @@ export function createServer() {
             "",
             "Reading and searching articles is open. Writing requires an API key (from login). Login creates a personal API key linked to your user account, so contributions are attributed to you.",
             "",
-            "Core flow: login (once) → search_articles (check if exists) → search_web + read_webpage (research) → `new` (batch scaffold, auto slugs) or `download` (batch) → edit files under ~/.openalmanac/articles/ → `publish` (slugs or community_slug for folder batch).",
+            "Core flow: login (once) → search_articles (check if exists) → search_web + read_webpage (research) → `new` (scaffold with wiki_slug) or `download` (batch with wiki_slug) → edit files under ~/.openalmanac/articles/{wiki_slug}/ → `publish` (slugs + wiki_slug).",
             "",
-            "After publishing, share the celebration URL when applicable. Community-owned articles are created under a community path — use `list_articles` to browse a community wiki.",
+            "After publishing, share the celebration URL when applicable. Use `list_articles` with `wiki_slug` to browse a wiki's pages.",
             "",
             "When working with tool results, write down any important information you might need later, as the original tool result may be cleared.",
         ].join("\n"),
     });
     registerAuthTools(server);
-    registerArticleTools(server);
+    registerPageTools(server);
     registerResearchTools(server);
-    registerCommunityTools(server);
-    registerPeopleTools(server);
+    registerWikiTools(server);
+    registerTopicTools(server);
     return server;
 }

package/dist/setup.js

@@ -617,9 +617,6 @@ function printRedditResult(agent, loginResult, mcpChanged, toolCount) {
     w(row(`  ${WHITE_BOLD}Next steps${RST}`));
     w(empty);
     w(row(`  ${BLUE}1.${RST}  Type ${WHITE_BOLD}claude${RST} to start Claude Code`));
-    w(row(`  ${BLUE}2.${RST}  Run ${BLUE}/reddit-wiki r/<subreddit>${RST}`));
-    w(empty);
-    w(row(`  ${DIM}Ask "how does reddit wiki work?" to learn more${RST}`));
     w(empty);
     w(`  ${BLUE_DIM}\u2570${"─".repeat(innerW)}\u256f${RST}`);
     w("");

package/dist/tools/pages.d.ts

@@ -0,0 +1,2 @@
+import { FastMCP } from "fastmcp";
+export declare function registerPageTools(server: FastMCP): void;

package/dist/tools/pages.js

@@ -0,0 +1,351 @@
+import { z } from "zod";
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { stringify as yamlStringify } from "yaml";
+import { request, ARTICLES_DIR } from "../auth.js";
+import { validateArticle } from "../validate.js";
+import { openBrowser } from "../browser.js";
+const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function slugify(title) {
+    return title
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}
+function coerceJson(schema) {
+    return z.preprocess((val) => {
+        if (typeof val === "string") {
+            try {
+                return JSON.parse(val);
+            }
+            catch {
+                return val;
+            }
+        }
+        return val;
+    }, schema);
+}
+function resolvePageDir(wikiSlug) {
+    return join(ARTICLES_DIR, wikiSlug);
+}
+function resolvePagePaths(slug, wikiSlug) {
+    const dir = resolvePageDir(wikiSlug);
+    return {
+        dir,
+        filePath: join(dir, `${slug}.md`),
+        refPath: join(dir, `.${slug}.ref`),
+    };
+}
+const WRITING_GUIDE = `
+## Page structure
+
+\`\`\`yaml
+---
+title: Page Title
+wiki: wiki-slug
+topics: [topic-one, topic-two]
+sources:
+  - key: example-source
+    url: https://example.com
+    title: Source Title
+    accessed_date: "2025-01-15"
+infobox:
+  header:
+    image_url: https://...
+    subtitle: Short tagline
+    details:
+      - key: Born
+        value: January 1, 1990
+---
+
+Page body with [@key] citation markers and [[wikilinks]]...
+\`\`\`
+
+## Wikilinks
+
+- Write natural text in double brackets: [[spool pins]], [[pin tumbler locks]]
+- Display text: [[spool-pins|spool pins]]
+- Cross-wiki: [[global:reddit|Reddit]], [[lockpicking:spool-pins|spool pins]]
+
+## Citations
+
+- Mark claims with [@key] after punctuation
+- Keys must be kebab-case with at least one hyphen
+- Every source must be referenced; every reference must have a source
+
+## Images
+
+Use search_images to find relevant images. Syntax: \`![Caption](url "position")\`
+Positions: "right" (default), "left", "center". Every image needs a descriptive caption.
+`.trim();
+export function registerPageTools(server) {
+    server.addTool({
+        name: "search_articles",
+        description: "Search OpenAlmanac pages and stubs across all wikis. Use to check existence, find slugs for wikilinks, " +
+            "or discover content. Optional wiki filter to scope results. No authentication needed.",
+        parameters: z.object({
+            queries: coerceJson(z.array(z.string()).min(1).max(20)).describe("Search queries (1-20)"),
+            wiki: z.string().optional().describe("Filter to a specific wiki slug"),
+            limit: z.number().default(20).describe("Max results per query (1-50, default 20)"),
+            include_stubs: z.boolean().default(true).describe("Include stubs in results"),
+        }),
+        async execute({ queries, wiki, limit, include_stubs }) {
+            const results = {};
+            for (const q of queries) {
+                const params = {
+                    query: q, limit, type: "pages",
+                };
+                if (wiki)
+                    params.wiki = wiki;
+                if (include_stubs)
+                    params.include_stubs = true;
+                const resp = await request("GET", "/api/search", { params });
+                results[q] = await resp.json();
+            }
+            return JSON.stringify(results, null, 2);
+        },
+    });
+    server.addTool({
+        name: "search_topics",
+        description: "Search OpenAlmanac topics across all wikis. Use to discover topic slugs and topic pages. " +
+            "Optional wiki filter to scope results. No authentication needed.",
+        parameters: z.object({
+            queries: coerceJson(z.array(z.string()).min(1).max(20)).describe("Search queries (1-20)"),
+            wiki: z.string().optional().describe("Filter to a specific wiki slug"),
+            limit: z.number().default(20).describe("Max results per query (1-50, default 20)"),
+        }),
+        async execute({ queries, wiki, limit }) {
+            const results = {};
+            for (const q of queries) {
+                const params = {
+                    query: q, limit, type: "topics",
+                };
+                if (wiki)
+                    params.wiki = wiki;
+                const resp = await request("GET", "/api/search", { params });
+                results[q] = await resp.json();
+            }
+            return JSON.stringify(results, null, 2);
+        },
+    });
+    server.addTool({
+        name: "list_articles",
+        description: "Browse pages in a wiki. Structured listing, not fuzzy search. " +
+            "Use to see what exists, find stubs, or discover pages by topic. " +
+            "Each returned page includes topic objects with both slug and title.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            topic: z.string().optional().describe("Filter by topic slug"),
+            sort: z.enum(["updated", "title"]).default("updated").describe("Sort order"),
+            stubs_only: z.boolean().default(false).describe("Only return stubs"),
+            limit: z.number().min(1).max(200).default(50).describe("Max results"),
+        }),
+        async execute({ wiki_slug, topic, sort, stubs_only, limit }) {
+            const params = { sort, limit };
+            if (topic)
+                params.topic = topic;
+            if (stubs_only)
+                params.stub = true;
+            const resp = await request("GET", `/api/w/${wiki_slug}/pages`, { params });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "download",
+        description: "Download pages to your local workspace for editing. " +
+            "Files go to ~/.openalmanac/articles/{wiki_slug}/{slug}.md with a .ref sidecar. " +
+            "After editing, use publish to push changes. The .ref file is system-managed — don't edit it.",
+        parameters: z.object({
+            slugs: coerceJson(z.array(z.string()).min(1).max(50)).describe("Page slugs to download"),
+            wiki_slug: z.string().describe("Wiki slug"),
+        }),
+        async execute({ slugs, wiki_slug }) {
+            const resp = await request("POST", `/api/w/${wiki_slug}/download`, {
+                auth: true,
+                json: { slugs },
+            });
+            const items = (await resp.json());
+            const dir = resolvePageDir(wiki_slug);
+            mkdirSync(dir, { recursive: true });
+            const lines = [];
+            for (const item of items) {
+                const slug = item.filename.replace(/\.md$/, "");
+                const { filePath, refPath } = resolvePagePaths(slug, wiki_slug);
+                writeFileSync(filePath, item.content, "utf-8");
+                writeFileSync(refPath, item.ref, "utf-8");
+                lines.push(`Downloaded "${slug}" to ${filePath}`);
+            }
+            return [lines.join("\n"), "", WRITING_GUIDE].join("\n");
+        },
+    });
+    server.addTool({
+        name: "new",
+        description: "Scaffold new pages locally. Creates .md files with YAML frontmatter and empty bodies. " +
+            "No .ref file is created (new pages). After writing content, use publish to go live.",
+        parameters: z.object({
+            pages: coerceJson(z.array(z.object({
+                title: z.string().describe("Page title"),
+                slug: z.string().optional().describe("Optional explicit slug"),
+                topics: z.array(z.string()).optional().describe("Topic slugs"),
+            })).min(1).max(50)).describe("Pages to scaffold"),
+            wiki_slug: z.string().describe("Wiki slug"),
+        }),
+        async execute({ pages, wiki_slug }) {
+            const dir = resolvePageDir(wiki_slug);
+            mkdirSync(dir, { recursive: true });
+            const created = [];
+            const skipped = [];
+            for (const item of pages) {
+                const slug = item.slug || slugify(item.title);
+                if (!slug || !SLUG_RE.test(slug)) {
+                    skipped.push(`"${item.title}" → invalid slug "${slug}"`);
+                    continue;
+                }
+                const filePath = join(dir, `${slug}.md`);
+                if (existsSync(filePath)) {
+                    skipped.push(`${slug}.md already exists`);
+                    continue;
+                }
+                const meta = { title: item.title, wiki: wiki_slug };
+                if (item.topics?.length)
+                    meta.topics = item.topics;
+                meta.sources = [];
+                const frontmatter = yamlStringify(meta);
+                writeFileSync(filePath, `---\n${frontmatter}---\n\n`, "utf-8");
+                created.push(filePath);
+            }
+            const parts = [
+                created.length > 0 ? `Created ${created.length} file(s):\n${created.map(p => `  - ${p}`).join("\n")}` : "No new files created.",
+                skipped.length > 0 ? `Skipped:\n${skipped.map(s => `  - ${s}`).join("\n")}` : "",
+                WRITING_GUIDE,
+            ];
+            return parts.filter(Boolean).join("\n\n");
+        },
+    });
+    server.addTool({
+        name: "publish",
+        description: "Publish pages from your local workspace. Reads .md files and their .ref sidecars, " +
+            "sends to the API. Pages with .ref are updates; pages without are new. " +
+            "Dead wikilinks auto-create stubs. Put edit_summary in frontmatter for change descriptions. Requires login.",
+        parameters: z.object({
+            slugs: coerceJson(z.array(z.string()).min(1).max(50)).optional()
+                .describe("Specific page slugs to publish"),
+            wiki_slug: z.string().describe("Wiki slug"),
+        }),
+        async execute({ slugs, wiki_slug }) {
+            const dir = resolvePageDir(wiki_slug);
+            // Determine which files to publish
+            let targetSlugs;
+            if (slugs?.length) {
+                targetSlugs = slugs;
+            }
+            else {
+                if (!existsSync(dir))
+                    throw new Error(`Wiki folder not found: ${dir}`);
+                targetSlugs = readdirSync(dir)
+                    .filter(f => f.endsWith(".md") && !f.startsWith("."))
+                    .map(f => f.replace(/\.md$/, ""));
+                if (targetSlugs.length === 0)
+                    throw new Error(`No .md files in ${dir}`);
+            }
+            // Build publish payload
+            const pages = [];
+            for (const slug of targetSlugs) {
+                const { filePath, refPath } = resolvePagePaths(slug, wiki_slug);
+                if (!existsSync(filePath)) {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                const content = readFileSync(filePath, "utf-8");
+                const errors = validateArticle(content);
+                if (errors.length > 0) {
+                    throw new Error(`Validation failed for ${slug}:\n${errors.map(e => `  ${e.field}: ${e.message}`).join("\n")}`);
+                }
+                const ref = existsSync(refPath) ? readFileSync(refPath, "utf-8").trim() : null;
+                pages.push({ content, ref });
+            }
+            const resp = await request("POST", `/api/w/${wiki_slug}/publish`, {
+                auth: true,
+                json: { pages },
+            });
+            const results = (await resp.json());
+            // Clean up local files for successful publishes
+            const lines = [];
+            let okCount = 0;
+            for (const r of results) {
+                if (r.status === "error") {
+                    lines.push(`FAILED ${r.slug}: ${r.error}`);
+                    continue;
+                }
+                okCount++;
+                // Delete local .md and .ref
+                const published_slug = r.renamed_from ? targetSlugs[results.indexOf(r)] : r.slug;
+                const { filePath, refPath } = resolvePagePaths(published_slug, wiki_slug);
+                try {
+                    unlinkSync(filePath);
+                }
+                catch { /* ok */ }
+                try {
+                    unlinkSync(refPath);
+                }
+                catch { /* ok */ }
+                let detail = `OK ${r.slug}: ${r.status}`;
+                if (r.renamed_from)
+                    detail += ` (renamed from ${r.renamed_from})`;
+                if (r.stubs_created?.length)
+                    detail += `\n  Stubs created: ${r.stubs_created.join(", ")}`;
+                lines.push(detail);
+                // Open browser for single publish
+                if (targetSlugs.length === 1 && process.env.OPENALMANAC_GUI !== "1") {
+                    const url = wiki_slug === "global"
+                        ? `https://www.openalmanac.org/page/${r.slug}?celebrate=true`
+                        : `https://www.openalmanac.org/w/${wiki_slug}/${r.slug}?celebrate=true`;
+                    openBrowser(url);
+                }
+            }
+            return `Published ${okCount}/${targetSlugs.length}.\n\n${lines.join("\n\n")}`;
+        },
+    });
+    server.addTool({
+        name: "propose_article",
+        description: "Propose an article before writing it. Structures your proposal with a user-facing summary and a detailed brief. " +
+            "Do not start writing without proposing first.",
+        parameters: z.object({
+            summary: z.string().describe("User-facing summary (3-5 bullet points)"),
+            details: z.string().describe("Full handoff brief with all sources, key facts, angle"),
+            title: z.string().describe("Proposed title"),
+            slug: z.string().describe("Proposed slug (kebab-case)"),
+            wiki_slug: z.string().default("global").describe("Wiki slug"),
+            _userChoice: z.enum(["background", "here", "expired", "already_in_progress"]).optional(),
+        }),
+        async execute({ summary, details, title, slug, wiki_slug, _userChoice }) {
+            if (_userChoice === "background") {
+                return `Article "${title}" is now being written in a background process.`;
+            }
+            if (_userChoice === "expired") {
+                return `Proposal expired. Continue the conversation naturally.`;
+            }
+            if (_userChoice === "already_in_progress") {
+                return `Article "${title}" is already being generated.`;
+            }
+            return `Article Proposal: ${title}\n\n${summary}\n\nProceed with writing this article following the writing flow in your instructions.`;
+        },
+    });
+    server.addTool({
+        name: "resolve",
+        description: "Check if pages exist before writing wikilinks. Returns status (found/stub/not_found) for each target. " +
+            "Use this to verify links before publishing.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            targets: coerceJson(z.array(z.string()).min(1).max(50)).describe("Link targets to resolve"),
+        }),
+        async execute({ wiki_slug, targets }) {
+            const resp = await request("POST", `/api/w/${wiki_slug}/resolve`, {
+                json: { targets },
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+}

package/dist/tools/topics.d.ts

@@ -0,0 +1,2 @@
+import { FastMCP } from "fastmcp";
+export declare function registerTopicTools(server: FastMCP): void;

package/dist/tools/topics.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { request } from "../auth.js";
+function coerceJson(schema) {
+    return z.preprocess((val) => {
+        if (typeof val === "string") {
+            try {
+                return JSON.parse(val);
+            }
+            catch {
+                return val;
+            }
+        }
+        return val;
+    }, schema);
+}
+export function registerTopicTools(server) {
+    server.addTool({
+        name: "list_topics",
+        description: "List topics in a wiki. Returns flat list or graph (nodes + edges). No authentication needed.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            format: z.enum(["flat", "graph"]).default("flat").describe("Response format"),
+        }),
+        async execute({ wiki_slug, format }) {
+            const resp = await request("GET", `/api/w/${wiki_slug}/topics`, {
+                params: { format },
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "create_topic",
+        description: "Create a topic in a wiki. Topics are lightweight categories — pages can belong to multiple topics. Requires wiki membership.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            title: z.string().describe("Topic title"),
+            description: z.string().default("").describe("Topic description"),
+            parent_slugs: coerceJson(z.array(z.string())).default([]).describe("Parent topic slugs"),
+        }),
+        async execute({ wiki_slug, title, description, parent_slugs }) {
+            const resp = await request("POST", `/api/w/${wiki_slug}/topics`, {
+                auth: true,
+                json: { title, description, parent_slugs },
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "create_topics_batch",
+        description: "Batch create topics in a wiki. Useful for bootstrapping a topic hierarchy. Requires wiki membership.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            topics: coerceJson(z.array(z.object({
+                title: z.string(),
+                description: z.string().default(""),
+                parent_slugs: z.array(z.string()).default([]),
+            })).min(1).max(100)).describe("Topics to create"),
+        }),
+        async execute({ wiki_slug, topics }) {
+            const resp = await request("POST", `/api/w/${wiki_slug}/topics/batch`, {
+                auth: true,
+                json: { topics },
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+}

package/dist/tools/wikis.d.ts

@@ -0,0 +1,2 @@
+import { FastMCP } from "fastmcp";
+export declare function registerWikiTools(server: FastMCP): void;

package/dist/tools/wikis.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { request } from "../auth.js";
+function coerceJson(schema) {
+    return z.preprocess((val) => {
+        if (typeof val === "string") {
+            try {
+                return JSON.parse(val);
+            }
+            catch {
+                return val;
+            }
+        }
+        return val;
+    }, schema);
+}
+export function registerWikiTools(server) {
+    server.addTool({
+        name: "create_wiki",
+        description: "Create a new wiki. Returns the wiki slug and URL. Requires login.",
+        parameters: z.object({
+            title: z.string().describe("Wiki title"),
+            description: z.string().default("").describe("Wiki description"),
+        }),
+        async execute({ title, description }) {
+            const resp = await request("POST", "/api/wikis", {
+                auth: true,
+                json: { title, description },
+            });
+            const wiki = (await resp.json());
+            return `Created wiki "${wiki.title}" at /w/${wiki.slug}`;
+        },
+    });
+    server.addTool({
+        name: "get_wiki_settings",
+        description: "Read a wiki's details and settings (nav, cover, theme). No authentication needed.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+        }),
+        async execute({ wiki_slug }) {
+            const resp = await request("GET", `/api/w/${wiki_slug}`);
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "update_wiki_settings",
+        description: "Update a wiki's settings (nav, cover_image_url, theme). Requires moderator access.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            settings: coerceJson(z.object({
+                nav: z.array(z.object({
+                    label: z.string(),
+                    page: z.string().optional(),
+                    topic: z.string().optional(),
+                    link: z.string().optional(),
+                    children: z.array(z.any()).optional(),
+                })).optional(),
+                cover_image_url: z.string().optional(),
+                theme: z.record(z.unknown()).optional(),
+            })).describe("Settings to update"),
+        }),
+        async execute({ wiki_slug, settings }) {
+            const resp = await request("PATCH", `/api/w/${wiki_slug}/settings`, {
+                auth: true,
+                json: settings,
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+    server.addTool({
+        name: "update_nav",
+        description: "Update just the navigation tree for a wiki. Shorthand for updating settings.nav. Requires moderator access.",
+        parameters: z.object({
+            wiki_slug: z.string().describe("Wiki slug"),
+            nav: coerceJson(z.array(z.object({
+                label: z.string(),
+                page: z.string().optional(),
+                topic: z.string().optional(),
+                link: z.string().optional(),
+                children: z.array(z.any()).optional(),
+            }))).describe("Nav items"),
+        }),
+        async execute({ wiki_slug, nav }) {
+            // Get current settings, merge nav
+            const getResp = await request("GET", `/api/w/${wiki_slug}`);
+            const wiki = (await getResp.json());
+            const settings = { ...wiki.settings, nav };
+            const resp = await request("PATCH", `/api/w/${wiki_slug}/settings`, {
+                auth: true,
+                json: settings,
+            });
+            return JSON.stringify(await resp.json(), null, 2);
+        },
+    });
+}

package/dist/validate.js

@@ -26,19 +26,12 @@ export function validateArticle(raw) {
     else if (title.length > 500) {
         errors.push({ field: "title", message: "Title must be 500 characters or fewer" });
     }
-    // article_id / slug
-    const articleId = frontmatter.article_id;
-    if (articleId && typeof articleId === "string" && !SLUG_RE.test(articleId)) {
+    // wiki (informational, not identity)
+    const wiki = frontmatter.wiki;
+    if (wiki != null && (typeof wiki !== "string" || !SLUG_RE.test(wiki))) {
         errors.push({
-            field: "article_id",
-            message: "Must be kebab-case (e.g. 'machine-learning'). Pattern: ^[a-z0-9]+(-[a-z0-9]+)*$",
-        });
-    }
-    const communitySlug = frontmatter.community_slug;
-    if (communitySlug != null && (typeof communitySlug !== "string" || !SLUG_RE.test(communitySlug))) {
-        errors.push({
-            field: "community_slug",
-            message: "Must be kebab-case (e.g. 'lockpicking'). Pattern: ^[a-z0-9]+(-[a-z0-9]+)*$",
+            field: "wiki",
+            message: "Must be kebab-case (e.g. 'lockpicking')",
         });
     }
     const topics = frontmatter.topics;