@creativeaitools/agent-wiki 2.0.0

package/dist/src/config.js

@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+export const CONFIG_PATH = "_system/config.json";
+export const CONFIG_EXAMPLE_PATH = "_system/config.example.json";
+export const DEFAULT_WORKSPACE_WIKI_DIR = "wiki";
+export const VALID_WIKI_TYPES = new Set(["vault", "workspace"]);
+const DEFAULT_SCAN = {
+    includeExtensions: [".md", ".markdown", ".txt", ".pdf", ".docx", ".csv", ".json", ".yaml", ".yml"],
+    excludeDirs: [
+        ".git",
+        ".hg",
+        ".svn",
+        ".obsidian",
+        ".venv",
+        "venv",
+        "env",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".ruff_cache",
+        "node_modules",
+        "dist",
+        "build",
+        ".next",
+        ".turbo",
+        ".cache",
+        "_system",
+        "reports",
+        "target",
+        "vendor"
+    ],
+    excludeFileGlobs: ["*.lock", "package-lock.json", "pnpm-lock.yaml", "yarn.lock", "uv.lock", "poetry.lock"]
+};
+export function loadConfig(root = ".") {
+    const rootPath = resolve(root);
+    const data = readJsonObject(joinPath(rootPath, CONFIG_PATH)) ?? readJsonObject(joinPath(rootPath, CONFIG_EXAMPLE_PATH)) ?? {};
+    const rawType = String(data.wikiType ?? data.wiki_type ?? "vault");
+    const wikiType = VALID_WIKI_TYPES.has(rawType) ? rawType : "vault";
+    const workspace = isObject(data.workspace) ? data.workspace : {};
+    const workspaceRootRaw = workspace.root ?? data.workspaceRoot;
+    let workspaceRoot = null;
+    if (typeof workspaceRootRaw === "string" && workspaceRootRaw.length > 0) {
+        workspaceRoot = resolve(rootPath, workspaceRootRaw);
+    }
+    const wikiDir = cleanWikiDir(String(workspace.wikiDir ?? data.wikiDir ?? DEFAULT_WORKSPACE_WIKI_DIR));
+    const scan = isObject(workspace.scan) ? workspace.scan : {};
+    return {
+        wikiType,
+        root: rootPath,
+        workspaceRoot,
+        wikiDir,
+        workspaceScan: {
+            includeExtensions: tupleFromConfig(scan, "includeExtensions", DEFAULT_SCAN.includeExtensions).map((ext) => ext.startsWith(".") ? ext : `.${ext}`),
+            excludeDirs: tupleFromConfig(scan, "excludeDirs", DEFAULT_SCAN.excludeDirs),
+            excludeFileGlobs: tupleFromConfig(scan, "excludeFileGlobs", DEFAULT_SCAN.excludeFileGlobs)
+        }
+    };
+}
+export function cleanWikiDir(value) {
+    return value.trim().replace(/^\/+|\/+$/g, "") || DEFAULT_WORKSPACE_WIKI_DIR;
+}
+export function readJsonObject(path) {
+    try {
+        const data = JSON.parse(readFileSync(path, "utf8"));
+        return isObject(data) ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tupleFromConfig(data, key, defaults) {
+    const value = data[key];
+    if (!Array.isArray(value)) {
+        return defaults;
+    }
+    const items = value.filter((item) => typeof item === "string" && item.length > 0);
+    return items.length > 0 ? items : defaults;
+}
+function joinPath(root, relative) {
+    return resolve(root, relative);
+}

package/dist/src/lifecycle.js

@@ -0,0 +1,171 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONFIG_PATH, DEFAULT_WORKSPACE_WIKI_DIR, VALID_WIKI_TYPES, cleanWikiDir, readJsonObject } from "./config.js";
+export const CONTENT_FOLDERS = ["sources", "sources/parts", "entities", "concepts", "claims", "syntheses", "questions", "_attachments", "_archive"];
+export const VAULT_RUNTIME_FOLDERS = ["_inbox", "_inbox/trash", "raw"];
+export const GENERATED_FOLDERS = ["reports", "_system/cache", "_system/indexes", "_system/logs", "_system/state"];
+export const SYSTEM_FOLDERS = ["skills"];
+export const REQUIRED_TEMPLATE_FILES = [
+    "AGENTS.md",
+    "WIKI.md",
+    "README.md",
+    "package.json",
+    "skills/compile-wiki/SKILL.md",
+    "skills/extract-knowledge-primitives/SKILL.md"
+];
+export const TEMPLATE_ROOT_FILES = ["AGENTS.md", "WIKI.md", "README.md", "ONBOARD.md", "INBOX.md", "AGENT-WIKI-SPEC-v2.md", "package.json"];
+export const TEMPLATE_DIRECTORIES = ["skills"];
+export const TEMPLATE_OPTIONAL_FILES = ["_system/config.example.json"];
+export function resolveInitPaths(options) {
+    if (!VALID_WIKI_TYPES.has(options.wikiType)) {
+        throw new Error(`wiki_type must be one of: ${Array.from(VALID_WIKI_TYPES).sort().join(", ")}`);
+    }
+    const wikiDir = cleanWikiDir(options.wikiDir ?? DEFAULT_WORKSPACE_WIKI_DIR);
+    if (options.wikiType === "workspace") {
+        const workspace = resolve(options.workspaceRoot ?? options.root ?? ".");
+        return { workspaceRoot: workspace, wikiRoot: resolve(workspace, wikiDir) };
+    }
+    return { workspaceRoot: null, wikiRoot: resolve(options.root ?? ".") };
+}
+export function initWiki(options) {
+    const { workspaceRoot, wikiRoot } = resolveInitPaths(options);
+    const created = createRequiredFolders(wikiRoot);
+    let configWritten = false;
+    if (options.writeConfig) {
+        writeLocalConfig(wikiRoot, options.wikiType, workspaceRoot, options.wikiDir ?? DEFAULT_WORKSPACE_WIKI_DIR);
+        configWritten = true;
+    }
+    const templateCopied = options.withTemplate
+        ? copyTemplateFiles(options.templateRoot ?? defaultTemplateRoot(), wikiRoot)
+        : [];
+    return { wikiType: options.wikiType, workspaceRoot, wikiRoot, created, configWritten, templateCopied };
+}
+export function createRequiredFolders(wikiRoot) {
+    const folders = [...CONTENT_FOLDERS, ...VAULT_RUNTIME_FOLDERS, ...GENERATED_FOLDERS, ...SYSTEM_FOLDERS];
+    const created = [];
+    for (const folder of folders) {
+        const path = join(wikiRoot, folder);
+        if (!existsSync(path)) {
+            mkdirSync(path, { recursive: true });
+            created.push(path);
+        }
+    }
+    return created;
+}
+export function writeLocalConfig(wikiRoot, wikiType, workspaceRoot, wikiDir) {
+    const configPath = join(wikiRoot, CONFIG_PATH);
+    mkdirSync(dirname(configPath), { recursive: true });
+    const existing = readJsonObject(configPath) ?? {};
+    existing.schemaVersion = 1;
+    existing.wikiType = wikiType;
+    const workspace = typeof existing.workspace === "object" && existing.workspace !== null && !Array.isArray(existing.workspace)
+        ? existing.workspace
+        : {};
+    workspace.root = workspaceRoot;
+    workspace.wikiDir = cleanWikiDir(wikiDir);
+    existing.workspace = workspace;
+    writeFileSync(configPath, `${JSON.stringify(existing, null, 2)}\n`, "utf8");
+}
+export function defaultTemplateRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+}
+export function copyTemplateFiles(sourceRoot, wikiRoot) {
+    const copied = [];
+    for (const name of [...TEMPLATE_ROOT_FILES, ...TEMPLATE_OPTIONAL_FILES]) {
+        const source = join(sourceRoot, name);
+        if (existsSync(source) && statSync(source).isFile() && copyFileIfMissing(source, join(wikiRoot, name))) {
+            copied.push(join(wikiRoot, name));
+        }
+    }
+    for (const name of TEMPLATE_DIRECTORIES) {
+        const source = join(sourceRoot, name);
+        if (existsSync(source) && statSync(source).isDirectory()) {
+            copied.push(...copyTreeIfMissing(source, join(wikiRoot, name)));
+        }
+    }
+    return copied;
+}
+export function doctorWiki(wikiRoot, wikiType) {
+    const root = resolve(wikiRoot);
+    if (!existsSync(root)) {
+        return [{ level: "error", code: "wiki_root_missing", message: "Wiki root does not exist.", path: root }];
+    }
+    if (!statSync(root).isDirectory()) {
+        return [{ level: "error", code: "wiki_root_not_directory", message: "Wiki root is not a directory.", path: root }];
+    }
+    const config = readJsonObject(join(root, CONFIG_PATH));
+    const detectedType = wikiType ?? detectWikiType(config);
+    const issues = [];
+    if (!VALID_WIKI_TYPES.has(detectedType)) {
+        issues.push({ level: "error", code: "invalid_wiki_type", message: `Invalid wiki type: ${detectedType}` });
+    }
+    for (const folder of requiredFoldersForDoctor(detectedType)) {
+        const path = join(root, folder);
+        if (!existsSync(path) || !statSync(path).isDirectory()) {
+            issues.push({ level: "error", code: "missing_folder", message: `Required folder is missing: ${folder}`, path });
+        }
+    }
+    for (const fileName of REQUIRED_TEMPLATE_FILES) {
+        const path = join(root, fileName);
+        if (!existsSync(path) || !statSync(path).isFile()) {
+            issues.push({ level: "warning", code: "missing_template_file", message: `Template file is missing: ${fileName}`, path });
+        }
+    }
+    if (config === null) {
+        issues.push({
+            level: "info",
+            code: "local_config_missing",
+            message: "_system/config.json is not present; defaults or _system/config.example.json will be used.",
+            path: join(root, CONFIG_PATH)
+        });
+    }
+    else if (!VALID_WIKI_TYPES.has(String(config.wikiType))) {
+        issues.push({ level: "error", code: "config_invalid_wiki_type", message: "_system/config.json has missing or invalid wikiType.", path: join(root, CONFIG_PATH) });
+    }
+    return issues;
+}
+export function requiredFoldersForDoctor(wikiType) {
+    return [...CONTENT_FOLDERS, ...VAULT_RUNTIME_FOLDERS, ...GENERATED_FOLDERS, ...SYSTEM_FOLDERS];
+}
+export function detectWikiType(config) {
+    return config && VALID_WIKI_TYPES.has(String(config.wikiType)) ? String(config.wikiType) : "vault";
+}
+export function issuesToJson(issues) {
+    return JSON.stringify(issues, null, 2);
+}
+export function issuesToText(issues) {
+    if (issues.length === 0) {
+        return "Doctor passed: no issues found.";
+    }
+    return issues.map(formatIssue).join("\n");
+}
+function formatIssue(issue) {
+    const suffix = issue.path ? ` (${issue.path})` : "";
+    return `${issue.level.toUpperCase().padEnd(7)} ${issue.code}: ${issue.message}${suffix}`;
+}
+function copyTreeIfMissing(source, destination) {
+    const copied = [];
+    for (const entry of readdirSync(source, { withFileTypes: true })) {
+        const sourcePath = join(source, entry.name);
+        const destinationPath = join(destination, entry.name);
+        if (entry.isDirectory()) {
+            copied.push(...copyTreeIfMissing(sourcePath, destinationPath));
+        }
+        else if (!shouldSkipTemplateFile(relative(source, sourcePath)) && copyFileIfMissing(sourcePath, destinationPath)) {
+            copied.push(destinationPath);
+        }
+    }
+    return copied;
+}
+function shouldSkipTemplateFile(path) {
+    return path.split(/[\\/]/).includes("__pycache__") || path.endsWith(".pyc");
+}
+function copyFileIfMissing(source, destination) {
+    if (existsSync(destination)) {
+        return false;
+    }
+    mkdirSync(dirname(destination), { recursive: true });
+    copyFileSync(source, destination);
+    return true;
+}

package/dist/src/migrate.js

@@ -0,0 +1,26 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToWikilink, refToWikilink, walkMarkdownPages } from "./wiki-utils.js";
+const ID_FIELDS = ["sourcePages", "derivedClaims", "relatedPages", "relatedClaims", "extractedEntities", "extractedConcepts", "extractedClaims", "extractedQuestions"];
+export function migrateRefs(args) {
+    const root = String(args.root || process.cwd());
+    const write = Boolean(args.write);
+    let changed = 0;
+    for (const page of walkMarkdownPages(root)) {
+        const path = join(root, page.path);
+        let text = readFileSync(path, "utf8");
+        const original = text;
+        for (const field of ID_FIELDS) {
+            text = text.replace(new RegExp(`(^${field}:\\n(?:\\s+-\\s+)([^\\n]+)(?:\\n\\s+-\\s+[^\\n]+)*)`, "gm"), (block) => block.replace(/^(\s+-\s+)(.+)$/gm, (_m, prefix, value) => `${prefix}${refToWikilink(value.trim())}`));
+        }
+        text = text.replace(/^(originPath:\s*)(.+)$/gm, (_m, prefix, value) => `${prefix}${pathToWikilink(String(value).trim())}`);
+        if (text !== original) {
+            changed += 1;
+            if (write)
+                writeFileSync(path, text, "utf8");
+            console.log(`${write ? "updated" : "would update"} ${page.path}`);
+        }
+    }
+    console.log(`${write ? "Updated" : "Would update"} ${changed} files.`);
+    return 0;
+}

package/dist/src/onboard.js

@@ -0,0 +1,159 @@
+import { existsSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { loadConfig, readJsonObject } from "./config.js";
+import { doctorWiki, writeLocalConfig } from "./lifecycle.js";
+import { writeJson } from "./wiki-utils.js";
+const CONVERTER_COMMANDS = ["markitdown", "pymupdf4llm", "marker_single"];
+export function onboard(args) {
+    const root = resolve(String(args["wiki-root"] || args.root || process.cwd()));
+    if (args["write-config"])
+        return writeConfig(root, args);
+    if (!args.check)
+        throw new Error("onboard requires --check or --write-config");
+    const report = buildOnboardingReport(root);
+    if (args.questions) {
+        console.log(renderQuestions(report));
+    }
+    else {
+        console.log(JSON.stringify(report, null, args.compact ? undefined : 2));
+    }
+    return report.summary.ready ? 0 : 1;
+}
+function writeConfig(root, args) {
+    const wikiType = String(args.type || loadConfig(root).wikiType);
+    if (wikiType !== "vault" && wikiType !== "workspace")
+        throw new Error("--type must be vault or workspace");
+    const wikiDir = String(args["wiki-dir"] || "wiki");
+    const workspaceRoot = wikiType === "workspace" ? String(args["workspace-root"] || "") || null : null;
+    writeLocalConfig(root, wikiType, workspaceRoot, wikiDir);
+    const conversionPolicy = String(args.conversion || "disabled");
+    const conversionEnabled = conversionPolicy !== "disabled";
+    writeJson(join(root, "_system/config.json"), {
+        schemaVersion: 1,
+        wikiType,
+        workspace: { root: workspaceRoot, wikiDir },
+        pythonCommand: args["python-command"] || null,
+        conversion: { enabled: conversionEnabled, policy: conversionPolicy }
+    });
+    console.log("Wrote _system/config.json");
+    return 0;
+}
+export function buildOnboardingReport(root) {
+    const config = loadConfig(root);
+    const doctorIssues = doctorWiki(root, config.wikiType);
+    const configPath = join(root, "_system/config.json");
+    const importLinkPath = join(root, "skills/import-link/config.json");
+    const importLinkConfig = readJsonObject(importLinkPath);
+    const requiredDocs = ["AGENTS.md", "WIKI.md", "ONBOARD.md", "AGENT-WIKI-SPEC-v2.md"];
+    const requiredSkills = [
+        "skills/process-inbox/SKILL.md",
+        "skills/extract-knowledge-primitives/SKILL.md",
+        "skills/compile-wiki/SKILL.md",
+        "skills/write-synthesis/SKILL.md",
+        "skills/update-overview/SKILL.md"
+    ];
+    const missingDocs = missingFiles(root, requiredDocs);
+    const missingSkills = missingFiles(root, requiredSkills);
+    const configExists = existsSync(configPath);
+    const importLinkConfigured = Boolean(importLinkConfig?.configured);
+    const errors = doctorIssues.filter((issue) => issue.level === "error");
+    return {
+        schemaVersion: 1,
+        command: "agent-wiki onboard --check",
+        root,
+        platform: {
+            os: process.platform,
+            arch: process.arch,
+            node: process.version
+        },
+        wiki: {
+            type: config.wikiType,
+            configExists,
+            configPath,
+            obsidianVault: existsDir(join(root, ".obsidian")),
+            missingDocs,
+            missingSkills
+        },
+        doctor: {
+            passed: errors.length === 0,
+            issues: doctorIssues
+        },
+        tools: {
+            agentWiki: { available: true, command: "agent-wiki" },
+            python: [probeCommand("python3", ["--version"]), probeCommand("python", ["--version"])],
+            converters: CONVERTER_COMMANDS.map((command) => probeCommand(command, ["--version"]))
+        },
+        importLink: {
+            configPath: importLinkPath,
+            configExists: existsSync(importLinkPath),
+            configured: importLinkConfigured
+        },
+        nextSteps: nextSteps({ configExists, importLinkConfigured, missingDocs, missingSkills, doctorIssues }),
+        summary: {
+            ready: errors.length === 0 && missingDocs.length === 0 && missingSkills.length === 0,
+            needsConfig: !configExists,
+            needsImportLinkConfig: !importLinkConfigured,
+            errorCount: errors.length,
+            warningCount: doctorIssues.filter((issue) => issue.level === "warning").length
+        }
+    };
+}
+function renderQuestions(report) {
+    const lines = [
+        "Agent Wiki onboarding questions",
+        "",
+        `1. Wiki type: ${report.wiki.type}`,
+        "   A. Keep detected wiki type",
+        "   B. Re-run init with --type vault",
+        "   C. Re-run init with --type workspace",
+        "",
+        `2. Local config: ${report.wiki.configExists ? "present" : "missing"}`,
+        "   A. Leave local config as-is",
+        "   B. Write local config with agent-wiki onboard --write-config",
+        "",
+        `3. Import-link config: ${report.importLink.configured ? "configured" : "not configured"}`,
+        "   A. Leave import-link disabled for now",
+        "   B. Configure skills/import-link/config.json before importing links",
+        "",
+        "4. Optional conversion policy",
+        "   A. Keep conversion disabled",
+        "   B. Enable already-installed local converters only"
+    ];
+    if (!report.doctor.passed) {
+        lines.push("", "Doctor errors must be fixed before editing wiki content.");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function nextSteps(input) {
+    const steps = [];
+    if (input.doctorIssues.some((issue) => issue.level === "error"))
+        steps.push("Fix doctor errors, then rerun agent-wiki onboard --check.");
+    if (input.missingDocs.length || input.missingSkills.length)
+        steps.push("Run agent-wiki init or migrate to restore missing docs/skills.");
+    if (!input.configExists)
+        steps.push("Persist local setup with agent-wiki onboard --write-config after choosing wiki type and policy.");
+    if (!input.importLinkConfigured)
+        steps.push("Configure skills/import-link/config.json before importing external links.");
+    steps.push("Run agent-wiki compile and agent-wiki index --check before handing the wiki to another agent.");
+    return steps;
+}
+function missingFiles(root, paths) {
+    return paths.filter((path) => !existsSync(join(root, path)) || !statSync(join(root, path)).isFile());
+}
+function existsDir(path) {
+    return existsSync(path) && statSync(path).isDirectory();
+}
+function probeCommand(command, args) {
+    const result = spawnSync(command, args, {
+        encoding: "utf8",
+        shell: process.platform === "win32",
+        timeout: 3000
+    });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim().split(/\r?\n/)[0] ?? "";
+    return {
+        command,
+        available: result.status === 0 || Boolean(output),
+        version: output || null
+    };
+}

package/dist/src/page.js

@@ -0,0 +1,188 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { idToFilename, pathToWikilink, readText, refToWikilink, renderMarkdown, today, walkMarkdownPages, writeOperationalLog, writeText } from "./wiki-utils.js";
+const PAGE_FOLDERS = {
+    source: "sources",
+    entity: "entities",
+    concept: "concepts",
+    claim: "claims",
+    question: "questions",
+    synthesis: "syntheses"
+};
+const SOURCE_TYPES = new Set(["webpage", "article", "document", "pdf", "transcript", "email", "meeting-notes", "dataset", "screenshot", "bridge", "import", "other"]);
+const ENTITY_TYPES = new Set(["person", "organization", "project", "product", "system", "place", "event", "artifact", "document", "other"]);
+const CONCEPT_TYPES = new Set(["definition", "principle", "framework", "method", "policy", "standard", "pattern", "workflow", "runbook", "checklist", "playbook", "theory", "taxonomy", "other"]);
+const SYNTHESIS_TYPES = new Set(["summary", "overview", "analysis", "timeline", "brief", "comparison"]);
+const CLAIM_TYPES = new Set(["descriptive", "historical", "causal", "interpretive", "normative", "forecast"]);
+export function createPage(args) {
+    const wikiRoot = process.cwd();
+    try {
+        const pageType = required(args, "type");
+        const subtype = required(args, "subtype");
+        const slug = required(args, "slug");
+        const title = required(args, "title");
+        if (!(pageType in PAGE_FOLDERS))
+            throw new Error("--type must be source, entity, concept, claim, question, or synthesis");
+        if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug))
+            throw new Error("--slug must use kebab-case lowercase letters, numbers, and hyphens");
+        validateSubtype(pageType, subtype);
+        const body = readBody(args, wikiRoot);
+        if (pageType !== "source" && wordCount(body) < 5)
+            throw new Error("authored knowledge pages require substantive body prose");
+        const createdAt = stringOpt(args.date, today());
+        const sourceRole = stringOpt(args["source-role"], "whole");
+        const sourceDate = stringOpt(args["source-date"], stringOpt(args["retrieved-at"], createdAt));
+        const pageId = buildPageId(pageType, subtype, slug, pageType === "source" ? sourceDate : createdAt, sourceRole, numberOpt(args["part-index"]));
+        const folder = pageType === "source" && sourceRole === "part" ? "sources/parts" : PAGE_FOLDERS[pageType];
+        const relPath = join(folder, idToFilename(pageId)).split("\\").join("/");
+        const absPath = join(wikiRoot, relPath);
+        const duplicate = walkMarkdownPages(wikiRoot).find((page) => page.id === pageId);
+        if (duplicate)
+            throw new Error(`page ID already exists in ${duplicate.path}`);
+        if (existsSync(absPath))
+            throw new Error(`target file already exists: ${relPath}`);
+        const frontmatter = buildFrontmatter(args, pageType, subtype, title, pageId, createdAt, sourceRole);
+        const result = {
+            schemaVersion: 1,
+            mode: args["dry-run"] ? "dry-run" : "write",
+            mutating: !args["dry-run"],
+            id: pageId,
+            path: relPath,
+            pageType,
+            status: frontmatter.status,
+            written: false
+        };
+        if (args["dry-run"]) {
+            result.frontmatter = frontmatter;
+        }
+        else {
+            writeText(absPath, renderMarkdown(frontmatter, body));
+            result.written = true;
+            if (!args["no-log"])
+                writeOperationalLog(wikiRoot, `create-page: created ${pageType} page ${pageId} at ${relPath}`);
+        }
+        console.log(JSON.stringify(result, null, args.compact ? undefined : 2));
+        return 0;
+    }
+    catch (error) {
+        console.log(JSON.stringify({ schemaVersion: 1, mode: args["dry-run"] ? "dry-run" : "write", mutating: false, written: false, error: error instanceof Error ? error.message : String(error) }, null, args.compact ? undefined : 2));
+        return 1;
+    }
+}
+function buildFrontmatter(args, pageType, subtype, title, id, createdAt, sourceRole) {
+    const fm = { id, pageType, title, status: defaultStatus(args, pageType, sourceRole) };
+    const subtypeField = { source: "sourceType", entity: "entityType", concept: "conceptType", claim: "claimType", synthesis: "synthesisType" };
+    if (subtypeField[pageType])
+        fm[subtypeField[pageType]] = subtype;
+    if (pageType === "source") {
+        if (!args["source-url"] && !args["origin-path"])
+            throw new Error("source pages require --source-url or --origin-path");
+        fm.sourceRole = sourceRole;
+        fm.sourceParts = list(args["source-part"]);
+        if (sourceRole === "part") {
+            fm.parentSourceId = required(args, "parent-source-id");
+            fm.partIndex = numberRequired(args, "part-index");
+            fm.partCount = numberRequired(args, "part-count");
+            fm.locator = required(args, "locator");
+        }
+        else if (sourceRole === "parent") {
+            if (list(args["source-part"]).length === 0)
+                throw new Error("parent source pages require at least one --source-part path");
+            fm.partCount = numberOpt(args["part-count"]);
+        }
+        if (args["source-url"])
+            fm.originUrl = args["source-url"];
+        if (args["origin-path"])
+            fm.originPath = pathToWikilink(String(args["origin-path"]));
+        fm.retrievedAt = stringOpt(args["retrieved-at"], createdAt);
+        for (const [flag, key] of [["published-at", "publishedAt"], ["converted-at", "convertedAt"], ["conversion-tool", "conversionTool"], ["conversion-tool-version", "conversionToolVersion"], ["conversion-backend", "conversionBackend"]]) {
+            if (args[flag])
+                fm[key] = args[flag];
+        }
+        if (list(args["conversion-warning"]).length)
+            fm.conversionWarnings = list(args["conversion-warning"]);
+        fm.attachments = list(args.attachment);
+    }
+    else if (pageType === "entity") {
+        fm.canonicalName = stringOpt(args["canonical-name"], title);
+    }
+    else if (pageType === "claim") {
+        fm.confidence = Number(stringOpt(args.confidence, "0.6"));
+        fm.text = stringOpt(args["claim-text"], title);
+        fm.subjectPageId = stringOpt(args["subject-page-id"], "");
+        fm.sourceIds = list(args["source-id"]);
+        fm.evidence = list(args.evidence).map(parseEvidence);
+    }
+    else if (pageType === "question") {
+        fm.priority = stringOpt(args.priority, "medium");
+        fm.relatedClaims = list(args["related-claim"]).map(refToWikilink);
+        fm.relatedPages = list(args["related-page"]).map(refToWikilink);
+        fm.openedAt = stringOpt(args["opened-at"], createdAt);
+    }
+    else if (pageType === "synthesis") {
+        if (!args.scope)
+            throw new Error("synthesis pages require --scope");
+        fm.scope = args.scope;
+        fm.sourcePages = list(args["source-page"]).map(refToWikilink);
+        fm.derivedClaims = list(args["derived-claim"]).map(refToWikilink);
+    }
+    if (!["claim", "question", "synthesis"].includes(pageType) && list(args["source-page"]).length)
+        fm.sourcePages = list(args["source-page"]).map(refToWikilink);
+    if (pageType !== "question" && list(args["related-page"]).length)
+        fm.relatedPages = list(args["related-page"]).map(refToWikilink);
+    fm.createdAt = createdAt;
+    fm.updatedAt = stringOpt(args["updated-at"], createdAt);
+    fm.aliases = list(args.alias);
+    fm.tags = list(args.tag);
+    return fm;
+}
+function buildPageId(pageType, subtype, slug, createdAt, sourceRole, partIndex) {
+    if (pageType === "source")
+        return `source.${createdAt}.${subtype}.${slug}${sourceRole === "part" ? `.part${String(partIndex).padStart(3, "0")}` : ""}`;
+    if (pageType === "question")
+        return `question.${subtype}.${slug}`;
+    return `${pageType}.${subtype}.${slug}`;
+}
+function defaultStatus(args, pageType, sourceRole) {
+    if (typeof args.status === "string")
+        return args.status;
+    if (pageType === "source")
+        return sourceRole === "parent" ? "partitioned" : "unprocessed";
+    if (pageType === "claim")
+        return "unverified";
+    if (pageType === "question")
+        return "open";
+    return "active";
+}
+function validateSubtype(pageType, subtype) {
+    const sets = { source: SOURCE_TYPES, entity: ENTITY_TYPES, concept: CONCEPT_TYPES, claim: CLAIM_TYPES, synthesis: SYNTHESIS_TYPES };
+    if (sets[pageType] && !sets[pageType].has(subtype))
+        throw new Error(`--subtype ${subtype} is not valid for page type ${pageType}`);
+}
+function parseEvidence(value) {
+    const raw = value.trim().startsWith("{") ? JSON.parse(value) : Object.fromEntries(value.split(";").filter(Boolean).map((part) => part.split("=", 2).map((x) => x.trim())));
+    for (const key of ["id", "sourceId", "path", "kind", "relation", "weight", "updatedAt"])
+        if (!raw[key])
+            throw new Error("--evidence is missing required fields");
+    raw.weight = Number(raw.weight);
+    return raw;
+}
+function readBody(args, wikiRoot) {
+    const bodyFile = stringOpt(args["body-file"]);
+    const body = bodyFile ? readText(resolve(wikiRoot, bodyFile)) : stringOpt(args.body, "");
+    if (!body.trim())
+        throw new Error("body prose/content is required");
+    return body;
+}
+function required(args, key) {
+    const value = stringOpt(args[key]);
+    if (!value)
+        throw new Error(`missing required --${key}`);
+    return value;
+}
+function stringOpt(value, fallback) { return typeof value === "string" ? value : fallback ?? ""; }
+function list(value) { return Array.isArray(value) ? value.map(String) : typeof value === "string" ? [value] : []; }
+function numberOpt(value) { return typeof value === "string" ? Number(value) : undefined; }
+function numberRequired(args, key) { const value = numberOpt(args[key]); if (!Number.isFinite(value))
+    throw new Error(`missing required --${key}`); return value; }
+function wordCount(value) { return (value.match(/\b\w+\b/g) ?? []).length; }