@biaoo/tiangong-wiki 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import packageJson from "../package.json" with { type: "json" };
+import { registerAssetCommand } from "./commands/asset.js";
 import { registerCheckConfigCommand } from "./commands/check-config.js";
 import { registerCreateCommand } from "./commands/create.js";
 import { registerDaemonCommand } from "./commands/daemon.js";
@@ -17,6 +18,7 @@ import { registerListCommand } from "./commands/list.js";
 import { registerPageInfoCommand } from "./commands/page-info.js";
 import { registerSearchCommand } from "./commands/search.js";
 import { registerSetupCommand } from "./commands/setup.js";
+import { registerSkillCommand } from "./commands/skill.js";
 import { registerStatCommand } from "./commands/stat.js";
 import { registerSyncCommand } from "./commands/sync.js";
 import { registerTemplateCommand } from "./commands/template.js";
@@ -27,12 +29,39 @@ import { loadRuntimeConfig } from "./core/runtime.js";
 import { embedPendingPages } from "./core/sync.js";
 import { processVaultQueueBatch } from "./core/vault-processing.js";
 import { handleCliError, writeJson } from "./utils/output.js";
+function extractEnvFileOption(argv) {
+    const nextArgv = argv.slice(0, 2);
+    let envFile = null;
+    for (let index = 2; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--env-file") {
+            const value = argv[index + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error("--env-file requires a value");
+            }
+            envFile = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--env-file=")) {
+            const value = arg.slice("--env-file=".length);
+            if (!value) {
+                throw new Error("--env-file requires a value");
+            }
+            envFile = value;
+            continue;
+        }
+        nextArgv.push(arg);
+    }
+    return { envFile, argv: nextArgv };
+}
 function buildProgram() {
     const program = new Command();
     program
         .name("tiangong-wiki")
         .description("Tiangong Wiki — local-first indexing and query CLI")
         .version(packageJson.version)
+        .option("--env-file <path>", "Load runtime environment from a specific .wiki.env file")
         .showHelpAfterError();
     let runtimeConfig;
     try {
@@ -42,10 +71,12 @@ function buildProgram() {
         runtimeConfig = undefined;
     }
     registerSetupCommand(program);
+    registerSkillCommand(program);
     registerInitCommand(program);
     registerDoctorCommand(program);
     registerSyncCommand(program);
     registerCheckConfigCommand(program);
+    registerAssetCommand(program);
     registerFindCommand(program, runtimeConfig);
     registerSearchCommand(program);
     registerFtsCommand(program);
@@ -77,9 +108,13 @@ function buildProgram() {
     return program;
 }
 try {
+    const { envFile, argv } = extractEnvFileOption(process.argv);
+    if (envFile) {
+        process.env.WIKI_ENV_FILE = envFile;
+    }
     applyCliEnvironment(process.env, process.cwd());
     const program = buildProgram();
-    await program.parseAsync(process.argv);
+    await program.parseAsync(argv);
 }
 catch (error) {
     handleCliError(error);

package/dist/operations/asset.js

@@ -0,0 +1,81 @@
+import { copyFileSync, renameSync, unlinkSync } from "node:fs";
+import path from "node:path";
+import { resolveRuntimePaths } from "../core/paths.js";
+import { AppError } from "../utils/errors.js";
+import { findCandidates, nextAvailableName, resolveAssetDir, toPosixSlashes, toSlug, validateSlug, validateSourceFile, } from "../utils/asset.js";
+import { ensureDirSync, pathExistsSync } from "../utils/fs.js";
+export function saveAsset(env, sourceFile, options = {}) {
+    const assetType = options.type ?? "image";
+    const { wikiRoot } = resolveRuntimePaths(env);
+    const absSource = path.resolve(sourceFile);
+    validateSourceFile(absSource);
+    const sourceExt = path.extname(absSource).replace(/^\./, "").toLowerCase();
+    if (!sourceExt) {
+        throw new AppError("Source file has no extension", "config");
+    }
+    const name = options.name ? (validateSlug(options.name), options.name) : toSlug(path.basename(absSource, path.extname(absSource)));
+    const assetDir = resolveAssetDir(wikiRoot, assetType);
+    ensureDirSync(assetDir);
+    const finalName = nextAvailableName(assetDir, name, sourceExt);
+    const finalPath = path.join(assetDir, finalName);
+    const tmpName = `.tmp-${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${sourceExt}`;
+    const tmpPath = path.join(assetDir, tmpName);
+    try {
+        copyFileSync(absSource, tmpPath);
+        renameSync(tmpPath, finalPath);
+    }
+    catch (err) {
+        try {
+            if (pathExistsSync(tmpPath)) {
+                unlinkSync(tmpPath);
+            }
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        throw new AppError(`Failed to save asset: ${err instanceof Error ? err.message : String(err)}`, "runtime");
+    }
+    return {
+        assetPath: toPosixSlashes(path.relative(wikiRoot, finalPath)),
+    };
+}
+export function refAsset(env, assetPathOrName, options) {
+    const assetType = options.type ?? "image";
+    const { wikiRoot, wikiPath } = resolveRuntimePaths(env);
+    // Normalize: if no directory separator, treat as filename and prepend type dir
+    const assetRelPath = assetPathOrName.includes("/") || assetPathOrName.includes("\\")
+        ? assetPathOrName
+        : toPosixSlashes(path.join(resolveAssetDir("", assetType), assetPathOrName));
+    const absAssetPath = path.join(wikiRoot, assetRelPath);
+    const absPageDir = path.dirname(path.join(wikiPath, options.page));
+    if (pathExistsSync(absAssetPath)) {
+        const rel = path.relative(absPageDir, absAssetPath);
+        return {
+            relativePath: toPosixSlashes(rel),
+            assetPath: toPosixSlashes(assetRelPath),
+        };
+    }
+    // Try candidate matching
+    const assetDir = resolveAssetDir(wikiRoot, assetType);
+    const fileName = path.basename(assetPathOrName);
+    const ext = path.extname(fileName).replace(/^\./, "");
+    const baseName = path.basename(fileName, path.extname(fileName));
+    if (ext && baseName) {
+        const candidates = findCandidates(assetDir, baseName, ext);
+        if (candidates.length > 0) {
+            return {
+                match: "candidates",
+                message: `${fileName} not found, but similar files exist`,
+                candidates: candidates.map((c) => {
+                    const cAssetPath = toPosixSlashes(path.relative(wikiRoot, path.join(assetDir, c)));
+                    const cRelPath = path.relative(absPageDir, path.join(assetDir, c));
+                    return {
+                        relativePath: toPosixSlashes(cRelPath),
+                        assetPath: cAssetPath,
+                    };
+                }),
+            };
+        }
+    }
+    throw new AppError(`Asset not found: ${assetPathOrName}`, "not_found");
+}

package/dist/operations/query.js

@@ -9,7 +9,7 @@ import { readAllPages } from "../core/sync.js";
 import { getVaultQueueSnapshot } from "../core/vault-processing.js";
 import { camelToSnake } from "../utils/case.js";
 import { AppError } from "../utils/errors.js";
-import { listFilesRecursiveSync } from "../utils/fs.js";
+import { listFilesRecursiveSync, pathExistsSync } from "../utils/fs.js";
 import { normalizeFtsQuery } from "../utils/segmenter.js";
 function parsePositiveLimit(value, label, fallback) {
     const normalized = value ?? fallback;
@@ -609,6 +609,30 @@ export function runLint(env = process.env, options = {}) {
             if (page.unregisteredFields.length > 0) {
                 addLintItem(result.info, page.page.id, "unregistered_fields", `Unregistered fields: ${page.unregisteredFields.join(", ")}`);
             }
+            // Check for broken image references in page body
+            const imageRefPattern = /!\[[^\]]*\]\(([^)]+)\)/g;
+            let imageMatch;
+            while ((imageMatch = imageRefPattern.exec(page.body)) !== null) {
+                let refPath = imageMatch[1].trim();
+                // Strip optional markdown title: ![alt](path "title")
+                const titleMatch = refPath.match(/^(\S+)\s+"[^"]*"$/);
+                if (titleMatch)
+                    refPath = titleMatch[1];
+                // Skip non-local references
+                if (!refPath || refPath.startsWith("http://") || refPath.startsWith("https://")
+                    || refPath.startsWith("data:") || refPath.startsWith("#"))
+                    continue;
+                // Decode URL-encoded paths (e.g., %20 → space)
+                try {
+                    refPath = decodeURIComponent(refPath);
+                }
+                catch { /* use as-is */ }
+                // Resolve relative to the page file's directory
+                const absRefPath = path.resolve(path.dirname(filePath), refPath);
+                if (!pathExistsSync(absRefPath)) {
+                    addLintItem(result.warnings, page.page.id, "broken_image_ref", `Image not found: ${refPath}`);
+                }
+            }
         }
         const draftCount = indexedPages.filter((page) => page.status === "draft").length;
         const pendingEmbeddings = indexedPages.filter((page) => page.embeddingStatus !== "done").length;

package/dist/operations/template-lint.js

@@ -0,0 +1,160 @@
+import matter from "gray-matter";
+import path from "node:path";
+import { getTemplate, resolveTemplateFilePath } from "../core/config.js";
+import { loadRuntimeConfig } from "../core/runtime.js";
+import { AppError } from "../utils/errors.js";
+import { pathExistsSync, readTextFileSync } from "../utils/fs.js";
+const REQUIRED_TEMPLATE_FIELDS = [
+    "pageType",
+    "title",
+    "status",
+    "visibility",
+    "sourceRefs",
+    "relatedPages",
+    "tags",
+    "createdAt",
+    "updatedAt",
+];
+const FIXED_TEMPLATE_FIELDS = new Set([
+    ...REQUIRED_TEMPLATE_FIELDS,
+    "nodeId",
+]);
+function ensureTemplateLintLevel(value) {
+    const normalized = (value ?? "info").toLowerCase();
+    if (normalized === "error" || normalized === "warning" || normalized === "info") {
+        return normalized;
+    }
+    throw new AppError(`Invalid lint level: ${value}`, "config");
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasField(data, field) {
+    return Object.prototype.hasOwnProperty.call(data, field);
+}
+function collectBodySections(markdown) {
+    return markdown
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^##\s+\S+/.test(line));
+}
+function addItem(collection, pageType, template, check, message) {
+    collection.push({ pageType, template, check, message });
+}
+export function runTemplateLint(env = process.env, options = {}) {
+    const level = ensureTemplateLintLevel(options.level);
+    const { paths, config } = loadRuntimeConfig(env);
+    if (options.pageType) {
+        getTemplate(config, options.pageType);
+    }
+    const pageTypes = (options.pageType ? [options.pageType] : Object.keys(config.templates)).sort((left, right) => left.localeCompare(right));
+    const result = {
+        errors: [],
+        warnings: [],
+        info: [],
+        summary: {
+            templates: pageTypes.length,
+            errors: 0,
+            warnings: 0,
+            info: 0,
+        },
+    };
+    for (const pageType of pageTypes) {
+        const templateConfig = config.templates[pageType];
+        const templatePath = resolveTemplateFilePath(config, paths.wikiRoot, pageType);
+        const templateLabel = templateConfig.file;
+        if (!pathExistsSync(templatePath)) {
+            addItem(result.errors, pageType, templateLabel, "template_file_missing", `Template file not found: ${path.relative(paths.wikiRoot, templatePath)}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = matter(readTextFileSync(templatePath));
+        }
+        catch (error) {
+            addItem(result.errors, pageType, templateLabel, "template_parse_error", error instanceof Error ? error.message : String(error));
+            continue;
+        }
+        if (!isPlainObject(parsed.data)) {
+            addItem(result.errors, pageType, templateLabel, "invalid_frontmatter", "Template frontmatter must be a YAML object.");
+            continue;
+        }
+        const data = parsed.data;
+        const registeredFields = new Set([
+            ...FIXED_TEMPLATE_FIELDS,
+            ...Object.keys(config.customColumns),
+            ...Object.keys(config.commonEdges),
+            ...Object.keys(templateConfig.columns),
+            ...Object.keys(templateConfig.edges),
+        ]);
+        const missingRequiredFields = REQUIRED_TEMPLATE_FIELDS.filter((field) => !hasField(data, field));
+        if (missingRequiredFields.length > 0) {
+            addItem(result.errors, pageType, templateLabel, "missing_required_fields", `Missing required template fields: ${missingRequiredFields.join(", ")}`);
+        }
+        if (data.pageType !== pageType) {
+            addItem(result.errors, pageType, templateLabel, "template_page_type_mismatch", `Frontmatter pageType must be "${pageType}", got "${String(data.pageType ?? "")}"`);
+        }
+        const unregisteredFields = Object.keys(data)
+            .filter((field) => !registeredFields.has(field))
+            .sort();
+        if (unregisteredFields.length > 0) {
+            addItem(result.errors, pageType, templateLabel, "unregistered_template_fields", `Fields present in template frontmatter but not declared in schema: ${unregisteredFields.join(", ")}`);
+        }
+        const unregisteredSummaryFields = templateConfig.summaryFields
+            .filter((field) => !registeredFields.has(field))
+            .sort();
+        if (unregisteredSummaryFields.length > 0) {
+            addItem(result.errors, pageType, templateLabel, "summary_fields_unregistered", `summaryFields reference undeclared fields: ${unregisteredSummaryFields.join(", ")}`);
+        }
+        const missingCommonEdgeFields = Object.keys(config.commonEdges)
+            .filter((field) => !hasField(data, field))
+            .sort();
+        if (missingCommonEdgeFields.length > 0) {
+            addItem(result.warnings, pageType, templateLabel, "common_edge_fields_missing", `Common edge fields missing from template frontmatter: ${missingCommonEdgeFields.join(", ")}`);
+        }
+        const missingDeclaredFields = [...Object.keys(templateConfig.columns), ...Object.keys(templateConfig.edges)]
+            .filter((field) => !hasField(data, field))
+            .sort();
+        if (missingDeclaredFields.length > 0) {
+            addItem(result.warnings, pageType, templateLabel, "declared_fields_missing", `Fields declared in config but absent from template frontmatter: ${missingDeclaredFields.join(", ")}`);
+        }
+        const arrayBackedFields = [...Object.keys(config.commonEdges), ...Object.keys(templateConfig.edges)].sort();
+        const nonArrayEdgeFields = arrayBackedFields.filter((field) => hasField(data, field) && !Array.isArray(data[field]));
+        if (nonArrayEdgeFields.length > 0) {
+            addItem(result.errors, pageType, templateLabel, "edge_fields_not_array", `Edge fields must be arrays in template frontmatter: ${nonArrayEdgeFields.join(", ")}`);
+        }
+        const sections = collectBodySections(parsed.content);
+        if (sections.length < 2) {
+            addItem(result.warnings, pageType, templateLabel, "body_sections_min", `Template body should contain at least 2 level-2 sections, found ${sections.length}`);
+        }
+    }
+    result.summary = {
+        templates: pageTypes.length,
+        errors: result.errors.length,
+        warnings: level === "warning" || level === "info" ? result.warnings.length : 0,
+        info: level === "info" ? result.info.length : 0,
+    };
+    return {
+        errors: result.errors,
+        warnings: level === "warning" || level === "info" ? result.warnings : [],
+        info: level === "info" ? result.info : [],
+        summary: result.summary,
+    };
+}
+export function renderTemplateLintResult(result) {
+    const lines = [`tiangong-wiki template lint: ${result.summary.templates} templates checked`, ""];
+    const sections = [
+        { label: "ERROR", items: result.errors },
+        { label: "WARN", items: result.warnings },
+        { label: "INFO", items: result.info },
+    ];
+    for (const section of sections) {
+        for (const item of section.items) {
+            lines.push(`  ${section.label.padEnd(5)} ${item.pageType} (${item.template})`);
+            lines.push(`         ${item.message}`);
+            lines.push("");
+        }
+    }
+    lines.push(`Summary: ${result.summary.errors} errors, ${result.summary.warnings} warnings, ${result.summary.info} info`);
+    return lines.join("\n");
+}

package/dist/utils/asset.js

@@ -0,0 +1,75 @@
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { AppError } from "./errors.js";
+import { pathExistsSync } from "./fs.js";
+export const ASSET_TYPE_DIRS = {
+    image: "assets/images",
+};
+const SLUG_PATTERN = /^[a-z0-9-]{1,80}$/;
+const MAX_FILE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
+export function resolveAssetDir(wikiRoot, assetType) {
+    const subdir = ASSET_TYPE_DIRS[assetType];
+    if (!subdir) {
+        throw new AppError(`Unsupported asset type: ${assetType}. Supported: ${Object.keys(ASSET_TYPE_DIRS).join(", ")}`, "config");
+    }
+    return path.join(wikiRoot, subdir);
+}
+export function validateSlug(name) {
+    if (!SLUG_PATTERN.test(name)) {
+        throw new AppError(`Invalid asset name: ${name} (must match [a-z0-9-], 1-80 chars)`, "config");
+    }
+}
+export function toSlug(rawName) {
+    const slug = rawName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+    if (!slug) {
+        throw new AppError("Cannot derive a valid slug from the source filename", "config");
+    }
+    return slug;
+}
+export function validateSourceFile(filePath) {
+    if (!pathExistsSync(filePath)) {
+        throw new AppError(`Source file not found: ${filePath}`, "not_found");
+    }
+    const stat = statSync(filePath);
+    if (!stat.isFile()) {
+        throw new AppError(`Source path is not a regular file: ${filePath}`, "config");
+    }
+    if (stat.size > MAX_FILE_SIZE_BYTES) {
+        const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
+        throw new AppError(`File too large: ${sizeMB}MB (max 20MB)`, "config");
+    }
+}
+export function nextAvailableName(dir, name, ext) {
+    const base = `${name}.${ext}`;
+    if (!pathExistsSync(path.join(dir, base))) {
+        return base;
+    }
+    for (let i = 1;; i++) {
+        const candidate = `${name}-${i}.${ext}`;
+        if (!pathExistsSync(path.join(dir, candidate))) {
+            return candidate;
+        }
+    }
+}
+export function findCandidates(dir, name, ext) {
+    if (!pathExistsSync(dir)) {
+        return [];
+    }
+    const pattern = new RegExp(`^${escapeRegExp(name)}(-\\d+)?\\.${escapeRegExp(ext)}$`);
+    try {
+        return readdirSync(dir).filter((entry) => pattern.test(entry)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function toPosixSlashes(p) {
+    return p.replace(/\\/g, "/");
+}

package/dist/utils/errors.js

@@ -10,11 +10,17 @@ export class AppError extends Error {
         this.details = details;
     }
 }
+function isPromptAbortError(error) {
+    return error.name === "ExitPromptError" || error.message.startsWith("User force closed the prompt");
+}
 export function asAppError(error) {
     if (error instanceof AppError) {
         return error;
     }
     if (error instanceof Error) {
+        if (isPromptAbortError(error)) {
+            return new AppError("Prompt cancelled by user.", "runtime");
+        }
         return new AppError(error.message, "runtime");
     }
     return new AppError(String(error), "runtime");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biaoo/tiangong-wiki",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Local-first wiki index and query engine for Markdown knowledge pages (Tiangong Wiki).",
   "type": "module",
   "publishConfig": {
@@ -43,6 +43,7 @@
     "@antv/g6": "^5.1.0",
     "@fontsource/jetbrains-mono": "^5.2.8",
     "@fontsource/space-grotesk": "^5.2.10",
+    "@inquirer/prompts": "^7.10.1",
     "@openai/codex-sdk": "^0.118.0",
     "adm-zip": "^0.5.17",
     "better-sqlite3": "^12.8.0",

package/references/cli-interface.md

@@ -13,6 +13,13 @@ npx @biaoo/tiangong-wiki <command> [options]
 npm run dev -- <command> [options]
 ```
 
+Global workspace resolution priority:
+
+1. `--env-file <path>`
+2. `WIKI_ENV_FILE`
+3. nearest `.wiki.env` found by walking upward from the current directory
+4. the global default workspace config written by `tiangong-wiki setup`
+
 ---
 
 ## Command Overview
@@ -20,6 +27,7 @@ npm run dev -- <command> [options]
 | Command | Description |
 | --- | --- |
 | `setup` | Interactive configuration wizard — writes `.wiki.env` and scaffolds workspace |
+| `skill` | Inspect and update workspace-local managed skills |
 | `doctor` | Diagnose configuration, paths, embedding, and daemon health |
 | `init` | Initialize workspace assets and run the first sync |
 | `sync` | Incrementally sync pages, embeddings, and vault metadata |
@@ -56,6 +64,7 @@ Interactive step-by-step wizard that:
 - Records `WIKI_PATH`, `VAULT_PATH`, `WIKI_DB_PATH`, `WIKI_CONFIG_PATH`, `WIKI_TEMPLATES_PATH`
 - Optionally configures `EMBEDDING_*` and Synology vault settings
 - Writes `.wiki.env` in the current working directory
+- Writes a global default workspace config pointing to that `.wiki.env`
 - Scaffolds `wiki/pages/`, `vault/`, `wiki.config.json`, and `templates/`
 
 After setup, run `tiangong-wiki doctor` then `tiangong-wiki init` to complete initialization.
@@ -63,11 +72,12 @@ After setup, run `tiangong-wiki doctor` then `tiangong-wiki init` to complete in
 ### doctor
 
 ```
-tiangong-wiki doctor [--probe] [--format text|json]
+tiangong-wiki doctor [--env-file <path>] [--probe] [--format text|json]
 ```
 
 | Option | Description |
 | --- | --- |
+| `--env-file` | Load a specific `.wiki.env` before running the command |
 | `--probe` | Additionally test remote services (embedding endpoint, Synology NAS) |
 | `--format` | Output format: `text` (default) or `json` |
 
@@ -196,16 +206,37 @@ Creates a page from the corresponding template in `wiki/templates/`, fills front
 
 Output: `{ created, filePath }`.
 
+### skill
+
+```
+tiangong-wiki skill add <source> --skill <name> [--force] [--format text|json]
+tiangong-wiki skill status [name] [--format text|json]
+tiangong-wiki skill update [name] [--all] [--force] [--format text|json]
+```
+
+- `add` — Install a skill from any repo URL or local path via the external `npx skills add <source> --skill <name> -a codex -y` flow, then start tracking it as a managed workspace-local skill
+- `status` — Inspect managed workspace-local skills such as `tiangong-wiki-skill`, parser skills declared in `WIKI_PARSER_SKILLS`, and repo/path-sourced skills previously added via `skill add`
+- `update` — Install missing managed skills, refresh skills that have newer source content, and refuse to overwrite local conflicts unless `--force` is passed
+
+The command distinguishes at least four states:
+
+- `up_to_date` — Installed content matches the current managed source
+- `update_available` — Upstream changed and local files still match the managed baseline
+- `conflict` — Local files differ from the managed baseline, so update will be skipped unless `--force` is used
+- `missing` — Skill is absent or unreadable and can be installed
+
 ### template
 
 ```
 tiangong-wiki template list [--format text|json]
 tiangong-wiki template show <pageType> [--format text|json]
+tiangong-wiki template lint [pageType] [--level error|warning|info] [--format text|json]
 tiangong-wiki template create --type <pageType> --title <title>
 ```
 
 - `list` — Show registered templates
 - `show` — Display template content for a specific type
+- `lint` — Validate template frontmatter, schema declarations, summaryFields, and minimum body structure
 - `create` — Generate a new template file in `wiki/templates/` and register it in `wiki.config.json`
 
 ### type