openalmanac 0.3.6 → 0.4.1

package/dist/tool-registry.d.ts

@@ -0,0 +1,11 @@
+export declare const MCP_TOOL_NAMES: readonly ["search_pages", "search_topics", "list_pages", "download", "new", "publish", "read_page", "delete_pages", "list_topics", "update_topic", "create_topics", "list_wikis", "create_wiki", "get_wiki_settings", "update_wiki_settings", "join_wiki", "get_wiki_membership", "login", "logout", "whoami", "search_web", "read_webpage", "search_images", "view_images"];
+export type McpToolName = (typeof MCP_TOOL_NAMES)[number];
+export declare const INTERACTIVE_TOOL_NAMES: readonly string[];
+export interface McpToolGroup {
+    name: string;
+    description: string;
+    tools: readonly McpToolName[];
+}
+export declare const MCP_TOOL_GROUPS: readonly McpToolGroup[];
+export declare function toClaudePermissionName(name: McpToolName): string;
+export declare const MCP_TOOL_PERMISSION_NAMES: readonly string[];

package/dist/tool-registry.js

@@ -0,0 +1,148 @@
+// Single source of truth for the MCP tools the OpenAlmanac server exposes.
+//
+// This file is the contract that ties three otherwise-independent surfaces
+// together:
+//
+//   1. tools/*.ts                   — the actual `server.addTool({ name: ... })`
+//                                     registrations.
+//   2. setup.ts TOOL_GROUPS         — the permission grouping shown in the
+//                                     `npx openalmanac setup` TUI, written into
+//                                     `~/.claude/settings.json` so a user's
+//                                     agent can call these tools without a
+//                                     per-call approval prompt.
+//   3. gui/config.js                — the Electron app's allow-list passed to
+//                                     the Claude Code SDK.
+//
+// Drift between these three surfaces was a real bug: the rename refactor
+// added `read_page`, `list_wikis`, `create_wiki`, the topic tools, etc., but
+// only (1) was updated. (2) was still grouping the pre-refactor tool set, so
+// users who ran `setup` had to manually approve every wiki/topic call.
+//
+// The drift test in `test/tool-registry.test.ts` walks every register*Tools
+// function with a fake server, collects the names actually registered, and
+// asserts:
+//
+//   - every registered name is in MCP_TOOL_NAMES
+//   - every name in MCP_TOOL_NAMES is actually registered
+//   - every non-INTERACTIVE name appears in exactly one MCP_TOOL_GROUPS entry
+//
+// Adding a new MCP tool means: register it in tools/*.ts, add its name here,
+// and place it in a group below. Skipping any of those three breaks CI.
+export const MCP_TOOL_NAMES = [
+    // Pages
+    "search_pages",
+    "search_topics",
+    "list_pages",
+    "download",
+    "new",
+    "publish",
+    "read_page",
+    "delete_pages",
+    // Topics
+    "list_topics",
+    "update_topic",
+    "create_topics",
+    // Wikis
+    "list_wikis",
+    "create_wiki",
+    "get_wiki_settings",
+    "update_wiki_settings",
+    "join_wiki",
+    "get_wiki_membership",
+    // Account
+    "login",
+    "logout",
+    "whoami",
+    // Research
+    "search_web",
+    "read_webpage",
+    "search_images",
+    "view_images",
+];
+// Tools intentionally excluded from the setup-time permission grant because
+// they require interactive UI / per-call approval. The drift test allows these
+// to be absent from MCP_TOOL_GROUPS — but they must still appear in
+// MCP_TOOL_NAMES if they are actually registered.
+//
+// `register_sources` was a GUI citation-bubble handshake; it is currently
+// commented out in tools/research.ts (REV-62) and therefore not in
+// MCP_TOOL_NAMES. When it comes back, add it both there and here.
+export const INTERACTIVE_TOOL_NAMES = [
+    "register_sources",
+];
+// Permission groupings shown in the setup TUI. Each group is a checkbox the
+// user toggles; checked groups are written into `~/.claude/settings.json`
+// `permissions.allow` so the agent can call them without per-call approval.
+//
+// Group boundaries are user-facing — they should match the user's mental
+// model ("Search & Read", "Write & Publish") rather than the file the tool
+// happens to live in. Every non-INTERACTIVE name in MCP_TOOL_NAMES must
+// appear in exactly one group; the drift test enforces this.
+export const MCP_TOOL_GROUPS = [
+    {
+        name: "Search & Read",
+        description: "search, read, download, and browse pages, topics, and wikis",
+        tools: [
+            "search_pages",
+            "search_topics",
+            "list_pages",
+            "list_topics",
+            "list_wikis",
+            "download",
+            "read_page",
+        ],
+    },
+    {
+        name: "Research",
+        description: "web search, read pages, find and view images",
+        tools: [
+            "search_web",
+            "read_webpage",
+            "search_images",
+            "view_images",
+        ],
+    },
+    {
+        name: "Write & Publish",
+        description: "create, edit, and publish pages and topics",
+        tools: [
+            "new",
+            "publish",
+            "delete_pages",
+            "create_topics",
+            "update_topic",
+        ],
+    },
+    {
+        name: "Wikis",
+        description: "create wikis, configure settings, manage membership",
+        tools: [
+            "create_wiki",
+            "get_wiki_settings",
+            "update_wiki_settings",
+            "join_wiki",
+            "get_wiki_membership",
+        ],
+    },
+    {
+        name: "Account",
+        description: "login, logout, identity",
+        tools: [
+            "login",
+            "logout",
+            "whoami",
+        ],
+    },
+];
+// Convert a bare MCP tool name into the prefixed form Claude Code uses in
+// `~/.claude/settings.json` permissions and the Electron SDK's allow-list.
+//
+// Example: `read_page` → `mcp__almanac__read_page`.
+export function toClaudePermissionName(name) {
+    return `mcp__almanac__${name}`;
+}
+// Full set of allow-list entries for every registered MCP tool, in the
+// `mcp__almanac__*` form Claude Code expects. Consumers (gui/config.js once
+// it's bumped to a registry-aware mcp version) should derive their tool
+// allow-list from this.
+export const MCP_TOOL_PERMISSION_NAMES = MCP_TOOL_NAMES.map(toClaudePermissionName);

package/dist/tools/auth.js

@@ -4,7 +4,7 @@ export function registerAuthTools(server) {
     server.addTool({
         name: "login",
         description: "Log in via browser to connect your account and get a personal API key. This is the required " +
-            "first step before creating or updating articles. Only needs to be called once.\n\n" +
+            "first step before creating or updating pages. Only needs to be called once.\n\n" +
             "If you already have a valid API key, this returns immediately without opening a browser.",
         async execute() {
             const result = await performLogin();

package/dist/tools/{pages.js → pages/index.js}

@@ -1,167 +1,15 @@
 import { z } from "zod";
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from "node:fs";
 import { stringify as yamlStringify } from "yaml";
-import { request, ARTICLES_DIR } from "../auth.js";
-import { openBrowser } from "../browser.js";
-import { coerceJson } from "../utils.js";
-const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-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
-
-## Quoting
-
-For any string value with punctuation, quotes, or special characters (common in \`sources[].title\`), use YAML block-literal syntax:
-
-\`\`\`yaml
-sources:
-  - key: farza-yc
-    title: |-
-      "I'm joining Y Combinator, again" — Farza Majeed
-    url: https://...
-\`\`\`
-
-This sidesteps every YAML escaping rule. If you skip this, inner double quotes or em-dashes will break the parser.
-
-## Images
-
-Use search_images to find relevant images. Syntax: \`![Caption](url "position")\`
-Positions: "right" (default), "left", "center". Every image needs a descriptive caption.
-`.trim();
-function formatPublishResults(results, targetSlugs, wiki_slug, dry_run) {
-    const allAutoStubs = new Set();
-    const lines = [];
-    let okCount = 0;
-    let errorCount = 0;
-    for (let i = 0; i < results.length; i++) {
-        const r = results[i];
-        const slug = targetSlugs[i] ?? r.slug;
-        if (dry_run && r.plan) {
-            const plan = r.plan;
-            const hasError = plan.validation.status === "failed" ||
-                !plan.authorization.can_write ||
-                plan.action === "error";
-            if (hasError) {
-                errorCount++;
-                const reasons = [];
-                for (const e of plan.validation.errors) {
-                    reasons.push(`${e.field}: ${e.message}`);
-                }
-                if (!plan.authorization.can_write && plan.authorization.reason) {
-                    reasons.push(`auth: ${plan.authorization.reason}`);
-                }
-                lines.push(`- ${slug}: **error** — ${reasons.join("; ")}`);
-            }
-            else {
-                okCount++;
-                let line = `- ${plan.slug}: **${plan.action}**`;
-                if (plan.renamed_from)
-                    line += ` (rename: ${plan.renamed_from} → ${plan.slug})`;
-                const details = [];
-                if (plan.source_keys.referenced.length > 0) {
-                    details.push(`${plan.source_keys.referenced.length} source(s)`);
-                }
-                if (plan.wikilinks.will_auto_stub.length > 0) {
-                    details.push(`${plan.wikilinks.will_auto_stub.length} new stub(s)`);
-                    plan.wikilinks.will_auto_stub.forEach(s => allAutoStubs.add(s));
-                }
-                if (plan.source_keys.orphaned.length > 0) {
-                    details.push(`missing source key(s): ${plan.source_keys.orphaned.join(", ")}`);
-                }
-                if (plan.source_keys.unreferenced.length > 0) {
-                    details.push(`unreferenced source(s): ${plan.source_keys.unreferenced.join(", ")}`);
-                }
-                if (details.length > 0)
-                    line += ` (${details.join(", ")})`;
-                lines.push(line);
-            }
-        }
-        else {
-            // Real publish result
-            if (r.status === "error") {
-                errorCount++;
-                lines.push(`- ${r.slug}: **error** — ${r.error}`);
-            }
-            else {
-                okCount++;
-                // Clean up local files — pre-rename slug names the file
-                const fileSlug = r.renamed_from ?? slug;
-                const { filePath, refPath } = resolvePagePaths(fileSlug, wiki_slug);
-                try {
-                    unlinkSync(filePath);
-                }
-                catch { /* ok */ }
-                try {
-                    unlinkSync(refPath);
-                }
-                catch { /* ok */ }
-                let line = `- ${r.slug}: **${r.status}**`;
-                if (r.renamed_from)
-                    line += ` (renamed from ${r.renamed_from})`;
-                if (r.stubs_created?.length) {
-                    r.stubs_created.forEach(s => allAutoStubs.add(s));
-                }
-                lines.push(line);
-            }
-        }
-    }
-    const verb = dry_run ? "Dry-run" : "Published";
-    const summary = `${verb}: ${okCount}/${targetSlugs.length} OK${errorCount > 0 ? `, ${errorCount} error(s)` : ""}.`;
-    const parts = [summary, "", ...lines];
-    if (allAutoStubs.size > 0) {
-        const stubVerb = dry_run ? "Stubs that will be auto-created" : "Stubs auto-created";
-        parts.push("", `${stubVerb}: ${[...allAutoStubs].join(", ")}`);
-    }
-    return parts.join("\n");
-}
+import { request } from "../../auth.js";
+import { openBrowser } from "../../browser.js";
+import { coerceJson } from "../../utils.js";
+import { formatPublishResults } from "./publish-format.js";
+import { resolvePageDir, resolvePagePaths, SLUG_RE } from "./workspace.js";
+import { WRITING_GUIDE } from "./writing-guide.js";
 export function registerPageTools(server) {
     server.addTool({
-        name: "search_articles",
+        name: "search_pages",
         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({
@@ -213,7 +61,7 @@ export function registerPageTools(server) {
         },
     });
     server.addTool({
-        name: "list_articles",
+        name: "list_pages",
         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.",
@@ -237,7 +85,7 @@ export function registerPageTools(server) {
     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. " +
+            "Files go to ~/.openalmanac/pages/{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"),
@@ -308,7 +156,7 @@ export function registerPageTools(server) {
                         .replace(/^-+|-+$/g, "")
                         .replace(/-{2,}/g, "-") || "untitled";
                 }
-                const filePath = join(dir, `${fileSlug}.md`);
+                const { filePath } = resolvePagePaths(fileSlug, wiki_slug);
                 if (existsSync(filePath)) {
                     skipped.push(`${fileSlug}.md already exists`);
                     continue;
@@ -326,9 +174,28 @@ export function registerPageTools(server) {
                 writeFileSync(filePath, `---\n${frontmatter}---\n\n`, "utf-8");
                 created.push(filePath);
             }
+            // Scaffold-time nudge: check if any created pages have matching slugs
+            // in the global wiki (Almanac). Fires before writing so the agent can
+            // decide to cross-link instead of writing a duplicate treatment.
+            const nudges = [];
+            if (created.length > 0 && wiki_slug !== "global") {
+                const createdSlugs = created.map(p => p.split("/").pop().replace(".md", ""));
+                for (const slug of createdSlugs) {
+                    try {
+                        const res = await request("GET", `/api/w/global/pages/${slug}`);
+                        if (res.ok) {
+                            const page = await res.json();
+                            nudges.push(`Note: Almanac already has a page "${page.title ?? slug}" (slug: ${slug}). ` +
+                                `Write your own treatment for this wiki, or cross-link with [[global:${slug}]] instead.`);
+                        }
+                    }
+                    catch { /* page doesn't exist in global wiki — no nudge */ }
+                }
+            }
             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")}` : "",
+                nudges.length > 0 ? nudges.join("\n") : "",
                 WRITING_GUIDE,
             ];
             return parts.filter(Boolean).join("\n\n");
@@ -400,48 +267,18 @@ export function registerPageTools(server) {
             return summary;
         },
     });
-    // propose_article — GUI-only handshake. Commented out 2026-04-23 per REV-62.
-    // Revive when the GUI plan-card proposal flow is in active use.
-    /*
-    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: "read_article",
+        name: "read_page",
         description: "Read a single page by slug. Returns the full page JSON including content, topics, sources, and infobox. " +
             "No side effects — use this to read a page without downloading it to disk or joining the wiki. " +
             "For editing, use `download` instead (it writes local files and handles ref tokens). " +
-            "For discovery, use `search_articles` instead. No authentication needed.",
+            "For discovery, use `search_pages` instead. No authentication needed.",
         parameters: z.object({
             wiki_slug: z.string().describe("Wiki slug"),
-            article_slug: z.string().describe("Page slug"),
+            page_slug: z.string().describe("Page slug"),
         }),
-        async execute({ wiki_slug, article_slug }) {
-            const resp = await request("GET", `/api/w/${wiki_slug}/pages/${article_slug}`);
+        async execute({ wiki_slug, page_slug }) {
+            const resp = await request("GET", `/api/w/${wiki_slug}/pages/${page_slug}`);
             return JSON.stringify(await resp.json(), null, 2);
         },
     });
@@ -451,11 +288,11 @@ export function registerPageTools(server) {
             "Accepts multiple slugs and deletes them in sequence. Requires moderator or creator access.",
         parameters: z.object({
             wiki_slug: z.string().describe("Wiki slug"),
-            article_slugs: coerceJson(z.array(z.string()).min(1).max(50)).describe("Page slugs to delete (1-50)"),
+            page_slugs: coerceJson(z.array(z.string()).min(1).max(50)).describe("Page slugs to delete (1-50)"),
         }),
-        async execute({ wiki_slug, article_slugs }) {
+        async execute({ wiki_slug, page_slugs }) {
             const results = [];
-            for (const slug of article_slugs) {
+            for (const slug of page_slugs) {
                 try {
                     // DELETE returns 204 No Content on success
                     await request("DELETE", `/api/w/${wiki_slug}/pages/${slug}`, { auth: true });
@@ -470,7 +307,7 @@ export function registerPageTools(server) {
             const lines = results.map(r => r.status === "deleted"
                 ? `- ${r.slug}: deleted`
                 : `- ${r.slug}: error — ${r.message}`);
-            return `Deleted ${deleted}/${article_slugs.length} pages.\n\n${lines.join("\n")}`;
+            return `Deleted ${deleted}/${page_slugs.length} pages.\n\n${lines.join("\n")}`;
         },
     });
 }

package/dist/tools/pages/publish-format.d.ts

@@ -0,0 +1,48 @@
+export type PublishPlanValidation = {
+    status: string;
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+};
+export type PublishPlanAuthorization = {
+    can_write: boolean;
+    reason?: string;
+};
+export type PublishPlanWikilinks = {
+    found: string[];
+    in_batch?: string[];
+    stubs: string[];
+    will_auto_stub: string[];
+};
+export type PublishPlanSourceKeys = {
+    referenced: string[];
+    unreferenced: string[];
+    orphaned: string[];
+};
+export type PublishPlanInfobox = {
+    status: string;
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+};
+export type PublishPlan = {
+    action: string;
+    slug: string;
+    renamed_from?: string;
+    validation: PublishPlanValidation;
+    authorization: PublishPlanAuthorization;
+    wikilinks: PublishPlanWikilinks;
+    source_keys: PublishPlanSourceKeys;
+    infobox: PublishPlanInfobox;
+};
+export type PublishResult = {
+    slug: string;
+    status: string;
+    renamed_from?: string;
+    stubs_created?: string[];
+    error?: string;
+    plan?: PublishPlan;
+};
+export declare function formatPublishResults(results: PublishResult[], targetSlugs: string[], wiki_slug: string, dry_run: boolean): string;

package/dist/tools/pages/publish-format.js

@@ -0,0 +1,92 @@
+import { unlinkSync } from "node:fs";
+import { resolvePagePaths } from "./workspace.js";
+export function formatPublishResults(results, targetSlugs, wiki_slug, dry_run) {
+    const allAutoStubs = new Set();
+    const lines = [];
+    let okCount = 0;
+    let errorCount = 0;
+    for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const slug = targetSlugs[i] ?? r.slug;
+        if (dry_run && r.plan) {
+            const plan = r.plan;
+            const hasError = plan.validation.status === "failed" ||
+                !plan.authorization.can_write ||
+                plan.action === "error";
+            if (hasError) {
+                errorCount++;
+                const reasons = [];
+                for (const e of plan.validation.errors) {
+                    reasons.push(`${e.field}: ${e.message}`);
+                }
+                if (!plan.authorization.can_write && plan.authorization.reason) {
+                    reasons.push(`auth: ${plan.authorization.reason}`);
+                }
+                lines.push(`- ${slug}: **error** — ${reasons.join("; ")}`);
+            }
+            else {
+                okCount++;
+                let line = `- ${plan.slug}: **${plan.action}**`;
+                if (plan.renamed_from)
+                    line += ` (rename: ${plan.renamed_from} → ${plan.slug})`;
+                const details = [];
+                if (plan.source_keys.referenced.length > 0) {
+                    details.push(`${plan.source_keys.referenced.length} source(s)`);
+                }
+                if (plan.wikilinks.will_auto_stub.length > 0) {
+                    details.push(`${plan.wikilinks.will_auto_stub.length} new stub(s)`);
+                    plan.wikilinks.will_auto_stub.forEach(s => allAutoStubs.add(s));
+                }
+                const inBatchLinks = plan.wikilinks.in_batch ?? [];
+                if (inBatchLinks.length > 0) {
+                    details.push(`${inBatchLinks.length} in-batch link(s)`);
+                }
+                if (plan.source_keys.orphaned.length > 0) {
+                    details.push(`missing source key(s): ${plan.source_keys.orphaned.join(", ")}`);
+                }
+                if (plan.source_keys.unreferenced.length > 0) {
+                    details.push(`unreferenced source(s): ${plan.source_keys.unreferenced.join(", ")}`);
+                }
+                if (details.length > 0)
+                    line += ` (${details.join(", ")})`;
+                lines.push(line);
+            }
+        }
+        else {
+            // Real publish result
+            if (r.status === "error") {
+                errorCount++;
+                lines.push(`- ${r.slug}: **error** — ${r.error}`);
+            }
+            else {
+                okCount++;
+                // Clean up local files — pre-rename slug names the file
+                const fileSlug = r.renamed_from ?? slug;
+                const { filePath, refPath } = resolvePagePaths(fileSlug, wiki_slug);
+                try {
+                    unlinkSync(filePath);
+                }
+                catch { /* ok */ }
+                try {
+                    unlinkSync(refPath);
+                }
+                catch { /* ok */ }
+                let line = `- ${r.slug}: **${r.status}**`;
+                if (r.renamed_from)
+                    line += ` (renamed from ${r.renamed_from})`;
+                if (r.stubs_created?.length) {
+                    r.stubs_created.forEach(s => allAutoStubs.add(s));
+                }
+                lines.push(line);
+            }
+        }
+    }
+    const verb = dry_run ? "Dry-run" : "Published";
+    const summary = `${verb}: ${okCount}/${targetSlugs.length} OK${errorCount > 0 ? `, ${errorCount} error(s)` : ""}.`;
+    const parts = [summary, "", ...lines];
+    if (allAutoStubs.size > 0) {
+        const stubVerb = dry_run ? "Stubs that will be auto-created" : "Stubs auto-created";
+        parts.push("", `${stubVerb}: ${[...allAutoStubs].join(", ")}`);
+    }
+    return parts.join("\n");
+}

package/dist/tools/pages/workspace.d.ts

@@ -0,0 +1,7 @@
+export declare const SLUG_RE: RegExp;
+export declare function resolvePageDir(wikiSlug: string): string;
+export declare function resolvePagePaths(slug: string, wikiSlug: string): {
+    dir: string;
+    filePath: string;
+    refPath: string;
+};

package/dist/tools/pages/workspace.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+import { PAGES_DIR } from "../../auth.js";
+export const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export function resolvePageDir(wikiSlug) {
+    return join(PAGES_DIR, wikiSlug);
+}
+export function resolvePagePaths(slug, wikiSlug) {
+    const dir = resolvePageDir(wikiSlug);
+    return {
+        dir,
+        filePath: join(dir, `${slug}.md`),
+        refPath: join(dir, `.${slug}.ref`),
+    };
+}

package/dist/tools/pages/writing-guide.d.ts

@@ -0,0 +1 @@
+export declare const WRITING_GUIDE: string;