chapterhouse 0.3.17 → 0.3.19

package/dist/api/server-runtime.js

@@ -46,20 +46,4 @@ export function shouldServeSpaPath(pathname) {
 export function getDisplayHost(host) {
     return host === "0.0.0.0" || host === "::" || host === "127.0.0.1" || host === "::1" ? "localhost" : host;
 }
-export function buildHistoryEntries(pageIds, options) {
-    const resolveWikiPath = options?.resolveWikiPath ?? ((pageId) => pageId);
-    const stat = options?.stat;
-    return pageIds
-        .map((pageId) => {
-        try {
-            const fullPath = resolveWikiPath(pageId);
-            const mtime = stat ? stat(fullPath).mtimeMs : 0;
-            return { path: pageId, mtime };
-        }
-        catch {
-            return { path: pageId, mtime: 0 };
-        }
-    })
-        .sort((a, b) => b.mtime - a.mtime);
-}
 //# sourceMappingURL=server-runtime.js.map

package/dist/api/server.js

@@ -1,7 +1,7 @@
 import cors from "cors";
 import express from "express";
 import helmet from "helmet";
-import { existsSync, statSync } from "fs";
+import { existsSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
@@ -19,13 +19,13 @@ import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
 import { withWikiWrite } from "../wiki/lock.js";
 import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
-import { API_TOKEN_PATH, resolveWikiRelativePath } from "../paths.js";
+import { API_TOKEN_PATH } from "../paths.js";
 import { getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
 import { getTaskLogEvents, subscribeTaskLog } from "../copilot/task-event-log.js";
 import { subscribeSession, getSessionEventsFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
 import { getStatus, onStatusChange } from "../status.js";
 import { formatSseData, formatSseEvent } from "./sse.js";
-import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, buildHistoryEntries, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
+import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("server");
@@ -203,6 +203,20 @@ function assertValidPagePath(path) {
 function getWikiPageScope(path) {
     return teamWikiSync.isTeamPath(path) ? "team" : "personal";
 }
+function getEmptyWikiWelcomeContent(today = new Date()) {
+    return `---
+title: Wiki
+summary: Empty wiki — get started.
+updated: ${today.toISOString().slice(0, 10)}
+---
+
+# Wiki
+
+Your wiki is empty. Pages are organized by category — projects, people, tools, topics, areas, orgs, facts, preferences, routines.
+
+Create your first page via the wiki UI or by editing files under \`pages/\`.
+`;
+}
 // Active SSE connections
 const sseClients = new Map();
 const pendingSseMessages = [];
@@ -746,6 +760,10 @@ app.get("/api/wiki/page", async (req, res) => {
         : undefined;
     const content = await readWikiPage(path, { authorizationHeader });
     if (content === undefined) {
+        if (path === "pages/index.md") {
+            res.json({ path, content: getEmptyWikiWelcomeContent() });
+            return;
+        }
         throw new NotFoundError("Page not found");
     }
     res.json({ path, content });
@@ -766,17 +784,6 @@ app.delete("/api/wiki/page", async (req, res) => {
     res.json({ ok: removed, path });
 });
 // ---------------------------------------------------------------------------
-// History — past conversation summaries auto-written to pages/conversations/
-// ---------------------------------------------------------------------------
-app.get("/api/history", (_req, res) => {
-    ensureWikiStructure();
-    const entries = buildHistoryEntries(listPages().filter((p) => p.startsWith("pages/conversations/")), {
-        resolveWikiPath: resolveWikiRelativePath,
-        stat: statSync,
-    });
-    res.json(entries);
-});
-// ---------------------------------------------------------------------------
 // Skills
 // ---------------------------------------------------------------------------
 app.get("/api/skills", (_req, res) => {

package/dist/api/server.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
@@ -66,31 +66,6 @@ test("formats named SSE status events", async () => {
     assert.equal(typeof sse.formatSseEvent, "function", "formatSseEvent should be exported");
     assert.equal(sse.formatSseEvent("status", { status: "dreaming", message: "Consolidating memories..." }), 'event: status\ndata: {"status":"dreaming","message":"Consolidating memories..."}\n\n');
 });
-test("buildHistoryEntries resolves wiki files through the shared path resolver", async () => {
-    const runtime = await import("./server-runtime.js");
-    assert.equal(typeof runtime.buildHistoryEntries, "function", "buildHistoryEntries should be exported");
-    const seen = [];
-    const entries = runtime.buildHistoryEntries([
-        "pages/conversations/older.md",
-        "pages/conversations/newer.md",
-    ], {
-        resolveWikiPath: (pageId) => {
-            seen.push(pageId);
-            return `/wiki/${pageId}`;
-        },
-        stat: (fullPath) => ({
-            mtimeMs: fullPath.endsWith("newer.md") ? 200 : 100,
-        }),
-    });
-    assert.deepEqual(seen, [
-        "pages/conversations/older.md",
-        "pages/conversations/newer.md",
-    ]);
-    assert.deepEqual(entries, [
-        { path: "pages/conversations/newer.md", mtime: 200 },
-        { path: "pages/conversations/older.md", mtime: 100 },
-    ]);
-});
 const repoRoot = process.cwd();
 const serverTestRoot = join(repoRoot, ".test-work", `server-routes-${process.pid}`);
 async function getFreePort() {
@@ -293,6 +268,62 @@ test("server wiki routes support authenticated CRUD", async () => {
         assert.deepEqual(await missingResponse.json(), { error: "Page not found" });
     });
 });
+test("server wiki route synthesizes a welcome page when pages/index.md is missing", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        rmSync(join(serverTestRoot, ".chapterhouse", "wiki", "pages", "index.md"), { force: true });
+        const response = await fetch(`${baseUrl}/api/wiki/page?path=pages/index.md`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), {
+            path: "pages/index.md",
+            content: `---
+title: Wiki
+summary: Empty wiki — get started.
+updated: ${new Date().toISOString().slice(0, 10)}
+---
+
+# Wiki
+
+Your wiki is empty. Pages are organized by category — projects, people, tools, topics, areas, orgs, facts, preferences, routines.
+
+Create your first page via the wiki UI or by editing files under \`pages/\`.
+`,
+        });
+    });
+});
+test("server wiki route returns stored content for pages/index.md when it exists", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const indexPath = join(serverTestRoot, ".chapterhouse", "wiki", "pages", "index.md");
+        const content = `---
+title: Wiki
+summary: Existing home page.
+updated: 2026-05-12
+---
+
+# Custom Wiki Home
+`;
+        mkdirSync(join(serverTestRoot, ".chapterhouse", "wiki", "pages"), { recursive: true });
+        writeFileSync(indexPath, content, "utf-8");
+        const response = await fetch(`${baseUrl}/api/wiki/page?path=pages/index.md`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), {
+            path: "pages/index.md",
+            content,
+        });
+    });
+});
+test("server wiki route still returns 404 for other missing wiki pages", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/page?path=pages/projects/nonexistent/index.md`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 404);
+        assert.deepEqual(await response.json(), { error: "Page not found" });
+    });
+});
 test("server message route validates the SSE connection id", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const response = await fetch(`${baseUrl}/api/message`, {

package/dist/copilot/skills.test.js

@@ -7,4 +7,8 @@ test("listSkills includes bundled wiki-conventions skill metadata", () => {
     assert.equal(skill.name, "wiki-conventions");
     assert.match(skill.description, /creating, editing, linting, restructuring, or reviewing Chapterhouse wiki content/i);
 });
+test("listSkills does not include a bundled squad skill", () => {
+    const skill = listSkills().find((entry) => entry.slug === "squad" && entry.source === "bundled");
+    assert.equal(skill, undefined);
+});
 //# sourceMappingURL=skills.test.js.map

package/dist/copilot/tools.js

@@ -11,7 +11,9 @@ import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
 import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
 import { validateWikiFrontmatter } from "../wiki/frontmatter.js";
+import { fixWiki } from "../wiki/fix.js";
 import { lintWiki, renderWikiLintReport } from "../wiki/lint.js";
+import { rebuildIndexFromPages } from "../wiki/index-manager.js";
 import { appendLog } from "../wiki/log-manager.js";
 import { loadTaxonomy } from "../wiki/taxonomy.js";
 import { getCategoryDir, topicPagePath, slugify, entityCategories, FLAT_CATEGORIES } from "../wiki/topic-structure.js";
@@ -1088,6 +1090,36 @@ export function createTools(deps) {
                 });
             },
         }),
+        defineTool("wiki_fix", {
+            description: "Auto-repair common wiki inconsistencies. Defaults to dry-run preview mode and returns a per-file report " +
+                "plus unified diff. Supports frontmatter backfill, taxonomy tag normalization, and autostub marking.",
+            parameters: z.object({
+                dry_run: z.boolean().optional().describe("Preview only when true (default). Set false to apply fixes."),
+                fixes: z.array(z.enum(["frontmatter-backfill", "tag-normalize", "autostub-mark"])).optional()
+                    .describe("Optional subset of fixes to apply. Defaults to all fixes."),
+                path_glob: z.string().optional().describe("Optional glob to limit which wiki page paths are considered."),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                const dryRun = args.dry_run ?? true;
+                const runFixer = () => {
+                    const report = fixWiki({
+                        dryRun,
+                        fixes: args.fixes,
+                        pathGlob: args.path_glob,
+                        logAction: dryRun ? undefined : (type, path) => appendLog(type, path),
+                    });
+                    if (!dryRun && report.changedFiles > 0) {
+                        rebuildIndexFromPages();
+                    }
+                    return report;
+                };
+                if (dryRun) {
+                    return runFixer();
+                }
+                return withWikiWrite(runFixer);
+            },
+        }),
         defineTool("restart_chapterhouse", {
             description: "Restart the Chapterhouse daemon process. Use when the user asks Chapterhouse to restart himself, " +
                 "or when a restart is needed to pick up configuration changes. " +

package/dist/copilot/tools.wiki.test.js

@@ -140,4 +140,50 @@ Runtime notes with enough content to avoid incidental lint noise in the audit-lo
     assert.match(log, /rebuild-index \| wiki_rebuild_index: rebuilt \d+ entries from pages on disk \| tools-test-agent/);
     assert.match(log, /delete \| forget: deleted page pages\/shared\/chapterhouse\.md \| tools-test-agent/);
 });
+test("wiki_fix defaults to dry-run previews and logs applied fixes in write mode", async () => {
+    const toolsModule = await loadToolsModule();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const wikiFix = tools.find((entry) => entry.name === "wiki_fix");
+    assert.ok(wikiFix);
+    const wikiFs = await readWikiArtifacts();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Process
+- runbook
+`);
+    wikiFs.writePage("pages/projects/chapterhouse/index.md", `---
+title: Chapterhouse
+summary: Runtime notes
+updated: 2026-05-12
+tags: [Run Book]
+---
+
+# Chapterhouse
+
+Runtime notes with enough content to avoid incidental stub handling.
+
+## Details
+
+One
+Two
+Three
+Four
+Five
+Six
+Seven
+Eight
+`);
+    const before = wikiFs.readPage("pages/projects/chapterhouse/index.md");
+    const preview = await wikiFix.handler({});
+    assert.equal(typeof preview, "object");
+    assert.equal(preview.dryRun, true);
+    assert.equal(preview.changedFiles, 1);
+    assert.match(preview.diff, /--- a\/pages\/projects\/chapterhouse\/index\.md/);
+    assert.equal(wikiFs.readPage("pages/projects/chapterhouse/index.md"), before);
+    const applied = await wikiFix.handler({ dry_run: false });
+    assert.equal(applied.dryRun, false);
+    assert.match(wikiFs.readPage("pages/projects/chapterhouse/index.md") ?? "", /tags: \[runbook\]/);
+    assert.match(wikiFs.readLogFile(), /fix-tags \| pages\/projects\/chapterhouse\/index\.md \| tools-test-agent/);
+});
 //# sourceMappingURL=tools.wiki.test.js.map

package/dist/wiki/fix.js

@@ -0,0 +1,335 @@
+import { statSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import { resolveWikiRelativePath } from "../paths.js";
+import { parseWikiFrontmatter } from "./frontmatter.js";
+import { ensureWikiStructure, listPages, readPage, writePage } from "./fs.js";
+import { loadTaxonomy } from "./taxonomy.js";
+const DEFAULT_FIXES = [
+    "frontmatter-backfill",
+    "tag-normalize",
+    "autostub-mark",
+];
+const KNOWN_FIELD_ORDER = [
+    "title",
+    "summary",
+    "updated",
+    "tags",
+    "autostub",
+    "confidence",
+    "contested",
+    "contradictions",
+    "related",
+];
+export function fixWiki(options = {}) {
+    ensureWikiStructure();
+    const dryRun = options.dryRun ?? true;
+    const enabledFixes = new Set(options.fixes?.length ? options.fixes : DEFAULT_FIXES);
+    const pathFilter = options.pathGlob ? compileGlob(options.pathGlob) : undefined;
+    const allowedTags = enabledFixes.has("tag-normalize") ? loadTaxonomy() : [];
+    const canonicalTags = new Map(allowedTags.map((tag) => [normalizeTagKey(tag), tag]));
+    const reports = [];
+    const diffs = [];
+    let changedFiles = 0;
+    const pages = listPages()
+        .filter(isFixablePage)
+        .filter((path) => !pathFilter || pathFilter.test(path))
+        .sort();
+    for (const path of pages) {
+        const content = readPage(path);
+        if (!content)
+            continue;
+        const parsedResult = parseWikiFrontmatter(content);
+        if (parsedResult.parsed.metadata.autofix === false) {
+            continue;
+        }
+        const nextFrontmatter = cloneFrontmatter(parsedResult.parsed);
+        const body = parsedResult.body;
+        const changes = [];
+        let unknownTagsForFile = [];
+        if (enabledFixes.has("frontmatter-backfill")) {
+            let addedTitle = false;
+            let addedSummary = false;
+            let addedUpdated = false;
+            let addedAutostub = false;
+            if (!nextFrontmatter.title?.trim()) {
+                nextFrontmatter.title = inferTitle(path, body);
+                addedTitle = true;
+            }
+            if (!nextFrontmatter.summary?.trim()) {
+                const summary = inferSummary(body);
+                nextFrontmatter.summary = summary.text;
+                addedSummary = true;
+                if (summary.shouldMarkAutostub && nextFrontmatter.autostub !== true && nextFrontmatter.autostub === undefined) {
+                    nextFrontmatter.autostub = true;
+                    addedAutostub = true;
+                }
+            }
+            if (!nextFrontmatter.updated?.trim()) {
+                nextFrontmatter.updated = formatDate(statSync(resolveWikiRelativePath(path)).mtime);
+                addedUpdated = true;
+            }
+            const details = [
+                ...(addedTitle ? ["title"] : []),
+                ...(addedSummary ? ["summary"] : []),
+                ...(addedUpdated ? ["updated"] : []),
+                ...(addedAutostub ? ["autostub"] : []),
+            ];
+            if (details.length > 0) {
+                changes.push({ rule: "frontmatter-backfill", details });
+            }
+        }
+        if (enabledFixes.has("tag-normalize") && nextFrontmatter.tags?.length) {
+            const normalizedTags = [];
+            const details = [];
+            const unknownTags = [];
+            for (const tag of nextFrontmatter.tags) {
+                const normalized = canonicalTags.get(normalizeTagKey(tag));
+                if (normalized) {
+                    normalizedTags.push(normalized);
+                    if (normalized !== tag) {
+                        details.push(`${tag} -> ${normalized}`);
+                    }
+                }
+                else {
+                    normalizedTags.push(tag);
+                    unknownTags.push(tag);
+                }
+            }
+            if (details.length > 0) {
+                nextFrontmatter.tags = normalizedTags;
+                changes.push({ rule: "tag-normalize", details });
+            }
+            unknownTagsForFile = uniqueStrings(unknownTags);
+        }
+        if (enabledFixes.has("autostub-mark") && nextFrontmatter.autostub !== true && isStubBody(body)) {
+            nextFrontmatter.autostub = true;
+            changes.push({ rule: "autostub-mark", details: ["autostub"] });
+        }
+        if (changes.length === 0 && unknownTagsForFile.length === 0) {
+            continue;
+        }
+        const fileReport = {
+            path,
+            changes,
+        };
+        if (unknownTagsForFile.length > 0) {
+            fileReport.unknownTags = unknownTagsForFile;
+        }
+        reports.push(fileReport);
+        if (changes.length === 0) {
+            continue;
+        }
+        changedFiles += 1;
+        const nextContent = renderPage(nextFrontmatter, body);
+        if (dryRun) {
+            diffs.push(renderUnifiedDiff(path, content, nextContent));
+            continue;
+        }
+        writePage(path, nextContent);
+        for (const change of changes) {
+            const logType = logTypeForRule(change.rule);
+            if (logType) {
+                options.logAction?.(logType, path);
+            }
+        }
+    }
+    return {
+        dryRun,
+        scannedFiles: pages.length,
+        changedFiles,
+        files: reports,
+        diff: dryRun ? diffs.join("\n") : "",
+    };
+}
+function cloneFrontmatter(frontmatter) {
+    return {
+        ...frontmatter,
+        tags: frontmatter.tags ? [...frontmatter.tags] : undefined,
+        contradictions: frontmatter.contradictions ? [...frontmatter.contradictions] : undefined,
+        related: frontmatter.related ? [...frontmatter.related] : undefined,
+        metadata: { ...frontmatter.metadata },
+    };
+}
+function inferTitle(path, body) {
+    const heading = firstHeading(body);
+    if (heading) {
+        return stripMarkdown(heading);
+    }
+    return titleFromPath(path);
+}
+function inferSummary(body) {
+    const lines = body.split("\n");
+    const headingIndex = lines.findIndex((line) => /^#\s+/.test(line.trim()));
+    const startIndex = headingIndex >= 0 ? headingIndex + 1 : 0;
+    const paragraph = [];
+    for (let index = startIndex; index < lines.length; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (!line) {
+            if (paragraph.length > 0)
+                break;
+            continue;
+        }
+        if (line.startsWith("#")) {
+            if (paragraph.length > 0)
+                break;
+            continue;
+        }
+        paragraph.push(line);
+    }
+    const summary = stripMarkdown(paragraph.join(" ")).trim();
+    if (!summary) {
+        return {
+            text: "(no summary yet)",
+            shouldMarkAutostub: true,
+        };
+    }
+    return {
+        text: truncate(summary, 200),
+        shouldMarkAutostub: false,
+    };
+}
+function firstHeading(body) {
+    for (const rawLine of body.split("\n")) {
+        const match = rawLine.trim().match(/^#\s+(.+)$/);
+        if (match) {
+            return match[1].trim();
+        }
+    }
+    return undefined;
+}
+function titleFromPath(path) {
+    const file = basename(path, ".md");
+    const stem = file === "index" ? basename(dirname(path)) : file;
+    return stem
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function stripMarkdown(value) {
+    return value
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1")
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/[`*_~>#]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return value.slice(0, maxLength).trimEnd();
+}
+function formatDate(date) {
+    return date.toISOString().slice(0, 10);
+}
+function normalizeTagKey(tag) {
+    return tag.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function isStubBody(body) {
+    const meaningfulLines = body
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return meaningfulLines.length < 10;
+}
+function renderPage(frontmatter, body) {
+    const lines = ["---"];
+    for (const field of KNOWN_FIELD_ORDER) {
+        const value = frontmatter[field];
+        if (value === undefined)
+            continue;
+        lines.push(formatFrontmatterLine(field, value));
+    }
+    for (const [key, value] of Object.entries(frontmatter.metadata)) {
+        lines.push(formatFrontmatterLine(key, value));
+    }
+    lines.push("---");
+    const normalizedBody = body.replace(/^\n+/, "");
+    if (!normalizedBody) {
+        return `${lines.join("\n")}\n`;
+    }
+    return `${lines.join("\n")}\n\n${normalizedBody.endsWith("\n") ? normalizedBody : `${normalizedBody}\n`}`;
+}
+function formatFrontmatterLine(key, value) {
+    if (Array.isArray(value)) {
+        return `${key}: [${value.map(formatInlineValue).join(", ")}]`;
+    }
+    if (typeof value === "boolean") {
+        return `${key}: ${value ? "true" : "false"}`;
+    }
+    return `${key}: ${formatScalar(value)}`;
+}
+function formatInlineValue(value) {
+    return /^[A-Za-z0-9_./()-]+$/.test(value) ? value : formatScalar(value);
+}
+function formatScalar(value) {
+    if (value === "" || /[:#[\]{}'",]|^\s|\s$/.test(value)) {
+        return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function renderUnifiedDiff(path, before, after) {
+    const beforeLines = splitLines(before);
+    const afterLines = splitLines(after);
+    const beforeCount = beforeLines.length;
+    const afterCount = afterLines.length;
+    const diffLines = [
+        `--- a/${path}`,
+        `+++ b/${path}`,
+        `@@ -1,${beforeCount} +1,${afterCount} @@`,
+        ...beforeLines.map((line) => `-${line}`),
+        ...afterLines.map((line) => `+${line}`),
+    ];
+    return diffLines.join("\n");
+}
+function splitLines(content) {
+    return content.endsWith("\n")
+        ? content.slice(0, -1).split("\n")
+        : content.split("\n");
+}
+function compileGlob(pattern) {
+    let regex = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        const next = pattern[index + 1];
+        if (char === "*" && next === "*") {
+            regex += ".*";
+            index += 1;
+            continue;
+        }
+        if (char === "*") {
+            regex += "[^/]*";
+            continue;
+        }
+        if (char === "?") {
+            regex += "[^/]";
+            continue;
+        }
+        regex += escapeRegex(char);
+    }
+    regex += "$";
+    return new RegExp(regex);
+}
+function escapeRegex(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function logTypeForRule(rule) {
+    switch (rule) {
+        case "frontmatter-backfill":
+            return "fix-frontmatter";
+        case "tag-normalize":
+            return "fix-tags";
+        case "autostub-mark":
+            return "fix-autostub";
+        default:
+            return undefined;
+    }
+}
+function isFixablePage(path) {
+    return !path.startsWith("pages/_meta/") && path !== "pages/index.md";
+}
+//# sourceMappingURL=fix.js.map