@plusplusoneplusplus/coc 1.0.0

package/dist/server/wiki/wiki-routes.js

@@ -0,0 +1,763 @@
+"use strict";
+/**
+ * Wiki Routes
+ *
+ * Registers all wiki API endpoints under /api/wikis/* using the CoC Route[] pattern.
+ * Each route uses a RegExp pattern with wikiId in match[1].
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWikiRoutes = registerWikiRoutes;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const router_1 = require("../shared/router");
+const wiki_manager_1 = require("./wiki-manager");
+const ask_handler_1 = require("./ask-handler");
+const explore_handler_1 = require("./explore-handler");
+const admin_handlers_1 = require("./admin-handlers");
+const generate_handler_1 = require("./generate-handler");
+// ============================================================================
+// Route Registration
+// ============================================================================
+/**
+ * Register all wiki routes on the given route table.
+ * Returns the WikiManager instance for external access.
+ */
+function registerWikiRoutes(routes, options) {
+    const { sendJson, send404, send500, readJsonBody } = options.helpers ?? {
+        sendJson: router_1.sendJson,
+        send404: router_1.send404,
+        send500: router_1.send500,
+        readJsonBody: router_1.readJsonBody,
+    };
+    const wikiManager = new wiki_manager_1.WikiManager({
+        aiSendMessage: options.aiSendMessage,
+        onWikiRebuilding: options.onWikiRebuilding,
+        onWikiReloaded: options.onWikiReloaded,
+        onWikiError: options.onWikiError,
+    });
+    const store = options.store;
+    // Register initial wikis from explicit options
+    if (options.wikis) {
+        for (const [wikiId, config] of Object.entries(options.wikis)) {
+            try {
+                wikiManager.register({
+                    wikiId,
+                    wikiDir: config.wikiDir,
+                    repoPath: config.repoPath,
+                    aiEnabled: options.aiEnabled ?? false,
+                });
+            }
+            catch {
+                // Skip invalid wikis at startup — they can be re-registered later
+            }
+        }
+    }
+    // Restore persisted wikis from the store (async, best-effort)
+    if (store) {
+        store.getWikis().then((persistedWikis) => {
+            for (const wiki of persistedWikis) {
+                if (wikiManager.get(wiki.id))
+                    continue; // already registered from options
+                try {
+                    const graphPath = path.join(wiki.wikiDir, 'component-graph.json');
+                    if (fs.existsSync(graphPath)) {
+                        wikiManager.register({
+                            wikiId: wiki.id,
+                            wikiDir: wiki.wikiDir,
+                            repoPath: wiki.repoPath,
+                            aiEnabled: wiki.aiEnabled ?? options.aiEnabled ?? false,
+                            title: wiki.name,
+                        });
+                    }
+                }
+                catch {
+                    // Skip invalid persisted wikis
+                }
+            }
+        }).catch(() => {
+            // Ignore store read errors at startup
+        });
+    }
+    const askOptions = {
+        wikiManager,
+        aiSendMessage: options.aiSendMessage,
+        aiModel: options.aiModel,
+        aiWorkingDirectory: options.aiWorkingDirectory,
+    };
+    const exploreOptions = {
+        wikiManager,
+        aiSendMessage: options.aiSendMessage,
+        aiModel: options.aiModel,
+        aiWorkingDirectory: options.aiWorkingDirectory,
+    };
+    async function resolveAdminRuntime(wikiId) {
+        const loaded = wikiManager.get(wikiId);
+        if (loaded) {
+            return loaded;
+        }
+        if (!store) {
+            return null;
+        }
+        let persisted;
+        try {
+            persisted = (await store.getWikis()).find((w) => w.id === wikiId);
+        }
+        catch {
+            return null;
+        }
+        if (!persisted) {
+            return null;
+        }
+        const registration = {
+            wikiId: persisted.id,
+            wikiDir: persisted.wikiDir,
+            repoPath: persisted.repoPath,
+            aiEnabled: persisted.aiEnabled ?? options.aiEnabled ?? false,
+            title: persisted.name,
+        };
+        const pendingRuntime = {
+            registration,
+            wikiData: {
+                graph: {
+                    project: {
+                        name: persisted.name || persisted.id,
+                        description: 'Pending wiki generation',
+                    },
+                    components: [],
+                    categories: [],
+                },
+                reload: () => {
+                    // Once generation writes component-graph.json, promote to full runtime.
+                    const graphPath = path.join(registration.wikiDir, 'component-graph.json');
+                    if (!fs.existsSync(graphPath))
+                        return;
+                    try {
+                        wikiManager.register(registration);
+                    }
+                    catch {
+                        // Keep pending runtime if registration still fails.
+                    }
+                },
+                getThemeList: () => [],
+                getThemeArticle: () => null,
+                getThemeArticles: () => [],
+                getComponentSummaries: () => [],
+                getComponentDetail: () => null,
+                getSpecialPage: () => null,
+            },
+            contextBuilder: null,
+            sessionManager: null,
+            fileWatcher: null,
+        };
+        return pendingRuntime;
+    }
+    async function withAdminManager(wikiId) {
+        const runtime = await resolveAdminRuntime(wikiId);
+        if (!runtime) {
+            return null;
+        }
+        return {
+            get: (id) => (id === wikiId ? runtime : wikiManager.get(id)),
+        };
+    }
+    // ========================================================================
+    // Wiki CRUD endpoints (manage the registry — not per-wiki scoped)
+    // ========================================================================
+    // GET /api/wikis — List all registered wikis (merges manager + store)
+    routes.push({
+        method: 'GET',
+        pattern: '/api/wikis',
+        handler: async (_req, res) => {
+            // Start with wikis loaded in the manager
+            const seen = new Set();
+            const wikis = [];
+            // Build a color lookup from persisted wikis
+            let persistedMap = new Map();
+            if (store) {
+                try {
+                    const persisted = await store.getWikis();
+                    for (const wiki of persisted) {
+                        persistedMap.set(wiki.id, wiki);
+                    }
+                }
+                catch {
+                    // Ignore store read errors
+                }
+            }
+            for (const id of wikiManager.getRegisteredIds()) {
+                const runtime = wikiManager.get(id);
+                seen.add(id);
+                const componentCount = runtime.wikiData?.graph?.components?.length ?? 0;
+                const persisted = persistedMap.get(id);
+                wikis.push({
+                    id,
+                    name: persisted?.name ?? runtime.registration.title ?? id,
+                    wikiDir: runtime.registration.wikiDir,
+                    repoPath: runtime.registration.repoPath,
+                    aiEnabled: runtime.registration.aiEnabled,
+                    title: runtime.registration.title,
+                    color: persisted?.color,
+                    loaded: true,
+                    componentCount,
+                });
+            }
+            // Add persisted wikis that aren't loaded (e.g., pending generation)
+            for (const [id, wiki] of persistedMap) {
+                if (seen.has(id))
+                    continue;
+                wikis.push({
+                    id: wiki.id,
+                    name: wiki.name,
+                    wikiDir: wiki.wikiDir,
+                    repoPath: wiki.repoPath,
+                    aiEnabled: wiki.aiEnabled,
+                    color: wiki.color,
+                    loaded: false,
+                });
+            }
+            sendJson(res, wikis);
+        },
+    });
+    // POST /api/wikis — Register a new wiki
+    routes.push({
+        method: 'POST',
+        pattern: '/api/wikis',
+        handler: async (req, res) => {
+            try {
+                const body = await readJsonBody(req);
+                if (!body.id) {
+                    sendJson(res, { error: 'Missing required field: id' }, 400);
+                    return;
+                }
+                // Derive wikiDir from repoPath if not explicitly provided
+                let wikiDir = body.wikiDir;
+                if (!wikiDir && body.repoPath) {
+                    const baseDir = options.dataDir ?? path.join(os.homedir(), '.coc');
+                    wikiDir = path.join(baseDir, 'wikis', body.id);
+                }
+                if (!wikiDir) {
+                    sendJson(res, { error: 'Missing required field: wikiDir or repoPath' }, 400);
+                    return;
+                }
+                // When wikiDir is explicitly provided, it must exist and be a directory (reject invalid paths)
+                if (body.wikiDir) {
+                    const resolvedDir = path.resolve(wikiDir);
+                    if (!fs.existsSync(resolvedDir)) {
+                        sendJson(res, { error: 'wikiDir must be an existing directory' }, 400);
+                        return;
+                    }
+                    if (!fs.statSync(resolvedDir).isDirectory()) {
+                        sendJson(res, { error: 'wikiDir must be a directory' }, 400);
+                        return;
+                    }
+                }
+                else {
+                    // Derived from repoPath — ensure the wiki output directory exists
+                    fs.mkdirSync(wikiDir, { recursive: true });
+                }
+                // Check if wiki data already exists (component-graph.json)
+                const graphPath = path.join(wikiDir, 'component-graph.json');
+                const hasExistingData = fs.existsSync(graphPath);
+                if (hasExistingData) {
+                    // Register immediately — wiki data is available
+                    wikiManager.register({
+                        wikiId: body.id,
+                        wikiDir,
+                        repoPath: body.repoPath,
+                        aiEnabled: body.aiEnabled ?? options.aiEnabled ?? false,
+                        title: body.title ?? body.name,
+                    });
+                }
+                // Persist wiki registration to the store
+                if (store) {
+                    const wikiInfo = {
+                        id: body.id,
+                        name: body.name ?? body.id,
+                        wikiDir,
+                        repoPath: body.repoPath,
+                        color: body.color,
+                        aiEnabled: body.aiEnabled ?? options.aiEnabled ?? false,
+                        registeredAt: new Date().toISOString(),
+                    };
+                    await store.registerWiki(wikiInfo);
+                }
+                sendJson(res, {
+                    success: true,
+                    id: body.id,
+                    wikiDir,
+                    repoPath: body.repoPath,
+                    hasExistingData,
+                    generateWithAI: body.generateWithAI ?? false,
+                    name: body.name,
+                    color: body.color,
+                }, 201);
+            }
+            catch (err) {
+                sendJson(res, { error: err instanceof Error ? err.message : String(err) }, 400);
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId — Get wiki metadata
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const runtime = await resolveAdminRuntime(wikiId);
+            if (!runtime || !runtime.registration) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            sendJson(res, {
+                id: wikiId,
+                wikiDir: runtime.registration.wikiDir,
+                repoPath: runtime.registration.repoPath,
+                aiEnabled: runtime.registration.aiEnabled,
+                title: runtime.registration.title,
+                componentCount: runtime.wikiData?.graph?.components?.length ?? 0,
+                loaded: !!wikiManager.get(wikiId),
+            });
+        },
+    });
+    // DELETE /api/wikis/:wikiId — Remove a wiki
+    routes.push({
+        method: 'DELETE',
+        pattern: /^\/api\/wikis\/([^/]+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const removedFromManager = wikiManager.unregister(wikiId);
+            let removedFromStore = false;
+            if (store) {
+                try {
+                    removedFromStore = await store.removeWiki(wikiId);
+                }
+                catch { /* ignore */ }
+            }
+            if (!removedFromManager && !removedFromStore) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            sendJson(res, { success: true, id: wikiId });
+        },
+    });
+    // PATCH /api/wikis/:wikiId — Update wiki metadata
+    routes.push({
+        method: 'PATCH',
+        pattern: /^\/api\/wikis\/([^/]+)$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            try {
+                const body = await readJsonBody(req);
+                const runtime = wikiManager.get(wikiId);
+                let foundInStore = false;
+                // Persist updates to the store
+                if (store) {
+                    const storeUpdates = {};
+                    if (body.name !== undefined)
+                        storeUpdates.name = body.name;
+                    if (body.title !== undefined)
+                        storeUpdates.name = body.title;
+                    if (body.color !== undefined)
+                        storeUpdates.color = body.color;
+                    if (body.aiEnabled !== undefined)
+                        storeUpdates.aiEnabled = body.aiEnabled;
+                    if (Object.keys(storeUpdates).length > 0) {
+                        const updated = await store.updateWiki(wikiId, storeUpdates);
+                        foundInStore = updated !== undefined;
+                    }
+                    else {
+                        const wikis = await store.getWikis();
+                        foundInStore = wikis.some(w => w.id === wikiId);
+                    }
+                }
+                if (!runtime && !foundInStore) {
+                    send404(res, `Wiki not found: ${wikiId}`);
+                    return;
+                }
+                // Update manager registration if wiki is loaded
+                if (runtime) {
+                    const reg = { ...runtime.registration };
+                    if (body.title !== undefined)
+                        reg.title = body.title;
+                    if (body.name !== undefined)
+                        reg.title = body.name;
+                    if (body.aiEnabled !== undefined)
+                        reg.aiEnabled = body.aiEnabled;
+                    wikiManager.register(reg);
+                }
+                sendJson(res, { success: true, id: wikiId });
+            }
+            catch (err) {
+                sendJson(res, { error: err instanceof Error ? err.message : String(err) }, 400);
+            }
+        },
+    });
+    // ========================================================================
+    // Data endpoints (per-wiki)
+    // ========================================================================
+    // GET /api/wikis/:wikiId/graph
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/graph$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                sendJson(res, wiki.wikiData.graph);
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/themes
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/themes$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                sendJson(res, wiki.wikiData.getThemeList());
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/themes/:themeId/:slug
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/themes\/([^/]+)\/([^/]+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const themeId = decodeURIComponent(match[2]);
+            const slug = decodeURIComponent(match[3]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                const detail = wiki.wikiData.getThemeArticle(themeId, slug);
+                if (!detail) {
+                    send404(res, `Theme article not found: ${themeId}/${slug}`);
+                    return;
+                }
+                sendJson(res, { themeId, slug, content: detail.content, meta: detail.meta });
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/themes/:themeId
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/themes\/([^/]+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const themeId = decodeURIComponent(match[2]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                const themes = wiki.wikiData.getThemeList();
+                const meta = themes.find((t) => t.id === themeId);
+                if (!meta) {
+                    send404(res, `Theme not found: ${themeId}`);
+                    return;
+                }
+                const articles = wiki.wikiData.getThemeArticles(themeId);
+                sendJson(res, { ...meta, articles: articles.map((a) => ({ slug: a.slug, title: a.title, content: a.content })) });
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/components
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/components$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                sendJson(res, wiki.wikiData.getComponentSummaries());
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/components/:id
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/components\/(.+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const componentId = decodeURIComponent(match[2]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                const detail = wiki.wikiData.getComponentDetail(componentId);
+                if (!detail) {
+                    send404(res, `Component not found: ${componentId}`);
+                    return;
+                }
+                sendJson(res, detail);
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // GET /api/wikis/:wikiId/pages/:key
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/pages\/(.+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const key = decodeURIComponent(match[2]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            try {
+                const page = wiki.wikiData.getSpecialPage(key);
+                if (!page) {
+                    send404(res, `Page not found: ${key}`);
+                    return;
+                }
+                sendJson(res, page);
+            }
+            catch (err) {
+                send500(res, err instanceof Error ? err.message : String(err));
+            }
+        },
+    });
+    // ========================================================================
+    // AI endpoints (ask, explore)
+    // ========================================================================
+    // POST /api/wikis/:wikiId/ask
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/ask$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            await (0, ask_handler_1.handleWikiAskRequest)(req, res, wikiId, askOptions);
+        },
+    });
+    // DELETE /api/wikis/:wikiId/ask/session/:sessionId
+    routes.push({
+        method: 'DELETE',
+        pattern: /^\/api\/wikis\/([^/]+)\/ask\/session\/(.+)$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const sessionId = decodeURIComponent(match[2]);
+            const wiki = wikiManager.get(wikiId);
+            if (!wiki) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            if (!wiki.sessionManager) {
+                sendJson(res, { error: 'Session management is not enabled for this wiki' }, 400);
+                return;
+            }
+            const destroyed = wiki.sessionManager.destroy(sessionId);
+            sendJson(res, { destroyed, sessionId });
+        },
+    });
+    // POST /api/wikis/:wikiId/explore/:componentId
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/explore\/(.+)$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const componentId = decodeURIComponent(match[2]);
+            await (0, explore_handler_1.handleWikiExploreRequest)(req, res, wikiId, componentId, exploreOptions);
+        },
+    });
+    // ========================================================================
+    // Admin endpoints (seeds, config, generate)
+    // ========================================================================
+    // GET /api/wikis/:wikiId/admin/seeds
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/seeds$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, admin_handlers_1.handleGetSeeds)(res, wikiId, manager);
+        },
+    });
+    // PUT /api/wikis/:wikiId/admin/seeds
+    routes.push({
+        method: 'PUT',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/seeds$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, admin_handlers_1.handlePutSeeds)(req, res, wikiId, manager);
+        },
+    });
+    // POST /api/wikis/:wikiId/admin/seeds/generate
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/seeds\/generate$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, admin_handlers_1.handleGenerateSeeds)(req, res, wikiId, manager);
+        },
+    });
+    // GET /api/wikis/:wikiId/admin/config
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/config$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            (0, admin_handlers_1.handleGetConfig)(res, wikiId, manager);
+        },
+    });
+    // PUT /api/wikis/:wikiId/admin/config
+    routes.push({
+        method: 'PUT',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/config$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, admin_handlers_1.handlePutConfig)(req, res, wikiId, manager);
+        },
+    });
+    // POST /api/wikis/:wikiId/admin/generate
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/generate$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, generate_handler_1.handleStartGenerate)(req, res, wikiId, manager);
+        },
+    });
+    // POST /api/wikis/:wikiId/admin/generate/cancel
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/generate\/cancel$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            (0, generate_handler_1.handleCancelGenerate)(res, wikiId);
+        },
+    });
+    // GET /api/wikis/:wikiId/admin/generate/status
+    routes.push({
+        method: 'GET',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/generate\/status$/,
+        handler: async (_req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            (0, generate_handler_1.handleGetGenerateStatus)(res, wikiId, manager);
+        },
+    });
+    // POST /api/wikis/:wikiId/admin/generate/component/:componentId
+    routes.push({
+        method: 'POST',
+        pattern: /^\/api\/wikis\/([^/]+)\/admin\/generate\/component\/(.+)$/,
+        handler: async (req, res, match) => {
+            const wikiId = decodeURIComponent(match[1]);
+            const componentId = decodeURIComponent(match[2]);
+            const manager = await withAdminManager(wikiId);
+            if (!manager) {
+                send404(res, `Wiki not found: ${wikiId}`);
+                return;
+            }
+            await (0, generate_handler_1.handleComponentRegenerate)(req, res, wikiId, componentId, manager);
+        },
+    });
+    return wikiManager;
+}
+//# sourceMappingURL=wiki-routes.js.map