mdkg 0.0.1 → 0.0.2

package/dist/graph/frontmatter.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FRONTMATTER_KEY_ORDER = void 0;
+exports.parseFrontmatter = parseFrontmatter;
+exports.formatFrontmatter = formatFrontmatter;
+const KEY_RE = /^[a-z][a-z0-9_]*$/;
+exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
+    "id",
+    "type",
+    "title",
+    "status",
+    "priority",
+    "epic",
+    "parent",
+    "prev",
+    "next",
+    "supersedes",
+    "tags",
+    "owners",
+    "links",
+    "artifacts",
+    "relates",
+    "blocked_by",
+    "blocks",
+    "refs",
+    "aliases",
+    "cases",
+    "scope",
+    "created",
+    "updated",
+];
+function formatError(filePath, lineNumber, message) {
+    return new Error(`${filePath}:${lineNumber}: ${message}`);
+}
+function parseList(valueRaw, filePath, lineNumber) {
+    if (!valueRaw.startsWith("[") || !valueRaw.endsWith("]")) {
+        throw formatError(filePath, lineNumber, "list must be enclosed in [ ]");
+    }
+    const inner = valueRaw.slice(1, -1).trim();
+    if (inner.length === 0) {
+        return [];
+    }
+    const parts = inner.split(",");
+    const items = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const item = parts[i].trim();
+        if (item.length === 0) {
+            throw formatError(filePath, lineNumber, "list items must be non-empty");
+        }
+        items.push(item);
+    }
+    return items;
+}
+function parseValue(valueRaw, filePath, lineNumber) {
+    if (valueRaw.length === 0) {
+        throw formatError(filePath, lineNumber, "value must not be empty");
+    }
+    if (valueRaw.startsWith("[")) {
+        return parseList(valueRaw, filePath, lineNumber);
+    }
+    if (valueRaw === "true") {
+        return true;
+    }
+    if (valueRaw === "false") {
+        return false;
+    }
+    return valueRaw;
+}
+function parseFrontmatter(content, filePath) {
+    const lines = content.split(/\r?\n/);
+    if (lines.length === 0 || lines[0].trim() !== "---") {
+        throw formatError(filePath, 1, "frontmatter must start with ---");
+    }
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i].trim() === "---") {
+            endIndex = i;
+            break;
+        }
+    }
+    if (endIndex === -1) {
+        throw formatError(filePath, 1, "frontmatter closing --- not found");
+    }
+    const frontmatter = {};
+    for (let i = 1; i < endIndex; i += 1) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        if (line.trim().length === 0) {
+            throw formatError(filePath, lineNumber, "frontmatter lines must not be blank");
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1) {
+            throw formatError(filePath, lineNumber, "frontmatter lines must be key: value");
+        }
+        const key = line.slice(0, colonIndex).trim();
+        const rawValue = line.slice(colonIndex + 1).trim();
+        if (!KEY_RE.test(key)) {
+            throw formatError(filePath, lineNumber, `invalid key: ${key}`);
+        }
+        if (Object.prototype.hasOwnProperty.call(frontmatter, key)) {
+            throw formatError(filePath, lineNumber, `duplicate key: ${key}`);
+        }
+        frontmatter[key] = parseValue(rawValue, filePath, lineNumber);
+    }
+    const body = lines.slice(endIndex + 1).join("\n");
+    return { frontmatter, body };
+}
+function formatValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "[]";
+        }
+        return `[${value.join(", ")}]`;
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    return value;
+}
+function formatFrontmatter(frontmatter, keyOrder = exports.DEFAULT_FRONTMATTER_KEY_ORDER) {
+    const keys = Object.keys(frontmatter);
+    const keySet = new Set(keys);
+    const ordered = [];
+    for (const key of keyOrder) {
+        if (keySet.has(key)) {
+            ordered.push(key);
+        }
+    }
+    const remaining = keys.filter((key) => !keyOrder.includes(key)).sort();
+    ordered.push(...remaining);
+    return ordered.map((key) => `${key}: ${formatValue(frontmatter[key])}`);
+}

package/dist/graph/index_cache.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeIndex = writeIndex;
+exports.loadIndex = loadIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sort_1 = require("../util/sort");
+const indexer_1 = require("./indexer");
+const staleness_1 = require("./staleness");
+function readIndex(indexPath) {
+    try {
+        const raw = fs_1.default.readFileSync(indexPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "unknown error";
+        throw new Error(`failed to read index: ${message}`);
+    }
+}
+function writeIndex(indexPath, index) {
+    const sortedIndex = { ...index, nodes: (0, sort_1.sortIndexNodes)(index.nodes) };
+    fs_1.default.mkdirSync(path_1.default.dirname(indexPath), { recursive: true });
+    fs_1.default.writeFileSync(indexPath, JSON.stringify(sortedIndex, null, 2));
+}
+function loadIndex(options) {
+    const useCache = options.useCache ?? true;
+    const allowReindex = options.allowReindex ?? options.config.index.auto_reindex;
+    const tolerant = options.tolerant ?? options.config.index.tolerant;
+    const indexPath = path_1.default.resolve(options.root, options.config.index.global_index_path);
+    if (!useCache) {
+        const index = (0, indexer_1.buildIndex)(options.root, options.config, { tolerant });
+        return { index, rebuilt: true, stale: false };
+    }
+    const stale = (0, staleness_1.isIndexStale)(options.root, options.config);
+    if (fs_1.default.existsSync(indexPath) && !stale) {
+        return { index: readIndex(indexPath), rebuilt: false, stale: false };
+    }
+    if (allowReindex) {
+        const index = (0, indexer_1.buildIndex)(options.root, options.config, { tolerant });
+        writeIndex(indexPath, index);
+        return { index, rebuilt: true, stale };
+    }
+    if (fs_1.default.existsSync(indexPath)) {
+        return { index: readIndex(indexPath), rebuilt: false, stale: true };
+    }
+    throw new Error("index missing and auto-reindex is disabled");
+}

package/dist/graph/indexer.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIndex = buildIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const node_1 = require("./node");
+const workspace_files_1 = require("./workspace_files");
+const validate_graph_1 = require("./validate_graph");
+const template_schema_1 = require("./template_schema");
+function normalizeEdgeTarget(value, ws) {
+    if (value.includes(":")) {
+        return value;
+    }
+    return `${ws}:${value}`;
+}
+function normalizeEdges(edges, ws) {
+    return {
+        epic: edges.epic ? normalizeEdgeTarget(edges.epic, ws) : undefined,
+        parent: edges.parent ? normalizeEdgeTarget(edges.parent, ws) : undefined,
+        prev: edges.prev ? normalizeEdgeTarget(edges.prev, ws) : undefined,
+        next: edges.next ? normalizeEdgeTarget(edges.next, ws) : undefined,
+        relates: edges.relates.map((value) => normalizeEdgeTarget(value, ws)),
+        blocked_by: edges.blocked_by.map((value) => normalizeEdgeTarget(value, ws)),
+        blocks: edges.blocks.map((value) => normalizeEdgeTarget(value, ws)),
+    };
+}
+function addReverseEdge(reverse, edgeKey, target, source) {
+    if (!reverse[edgeKey]) {
+        reverse[edgeKey] = {};
+    }
+    if (!reverse[edgeKey][target]) {
+        reverse[edgeKey][target] = [];
+    }
+    reverse[edgeKey][target].push(source);
+}
+function buildIndex(root, config, options = {}) {
+    const tolerant = options.tolerant ?? config.index.tolerant;
+    const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(root, config, node_1.ALLOWED_TYPES);
+    const nodes = {};
+    const idsByWorkspace = {};
+    const docFilesByAlias = (0, workspace_files_1.listWorkspaceDocFilesByAlias)(root, config);
+    const workspaceAliases = Object.keys(docFilesByAlias).sort();
+    for (const alias of workspaceAliases) {
+        idsByWorkspace[alias] = new Set();
+        const files = docFilesByAlias[alias];
+        for (const filePath of files) {
+            if (path_1.default.basename(filePath) === "core.md" && path_1.default.basename(path_1.default.dirname(filePath)) === "core") {
+                continue;
+            }
+            try {
+                const content = fs_1.default.readFileSync(filePath, "utf8");
+                const node = (0, node_1.parseNode)(content, filePath, {
+                    workStatusEnum: config.work.status_enum,
+                    priorityMin: config.work.priority_min,
+                    priorityMax: config.work.priority_max,
+                    templateSchemas,
+                });
+                if (idsByWorkspace[alias].has(node.id)) {
+                    throw new Error(`duplicate id ${node.id} in workspace ${alias}`);
+                }
+                idsByWorkspace[alias].add(node.id);
+                const qid = `${alias}:${node.id}`;
+                const relPath = path_1.default.relative(root, filePath);
+                const normalizedEdges = normalizeEdges(node.edges, alias);
+                nodes[qid] = {
+                    id: node.id,
+                    qid,
+                    ws: alias,
+                    type: node.type,
+                    title: node.title,
+                    status: node.status,
+                    priority: node.priority,
+                    created: node.created,
+                    updated: node.updated,
+                    tags: node.tags,
+                    owners: node.owners,
+                    links: node.links,
+                    artifacts: node.artifacts,
+                    refs: node.refs,
+                    aliases: node.aliases,
+                    path: relPath,
+                    edges: normalizedEdges,
+                };
+            }
+            catch (err) {
+                if (!tolerant) {
+                    throw err;
+                }
+            }
+        }
+    }
+    const reverse_edges = {};
+    for (const [qid, node] of Object.entries(nodes)) {
+        const edges = node.edges;
+        if (edges.epic) {
+            addReverseEdge(reverse_edges, "epic", edges.epic, qid);
+        }
+        if (edges.parent) {
+            addReverseEdge(reverse_edges, "parent", edges.parent, qid);
+        }
+        if (edges.prev) {
+            addReverseEdge(reverse_edges, "prev", edges.prev, qid);
+        }
+        if (edges.next) {
+            addReverseEdge(reverse_edges, "next", edges.next, qid);
+        }
+        for (const target of edges.relates) {
+            addReverseEdge(reverse_edges, "relates", target, qid);
+        }
+        for (const target of edges.blocked_by) {
+            addReverseEdge(reverse_edges, "blocked_by", target, qid);
+        }
+        for (const target of edges.blocks) {
+            addReverseEdge(reverse_edges, "blocks", target, qid);
+        }
+    }
+    for (const edgeKey of Object.keys(reverse_edges)) {
+        for (const target of Object.keys(reverse_edges[edgeKey])) {
+            reverse_edges[edgeKey][target].sort();
+        }
+    }
+    const workspaces = {};
+    for (const alias of Object.keys(config.workspaces).sort()) {
+        const entry = config.workspaces[alias];
+        workspaces[alias] = { path: entry.path, enabled: entry.enabled };
+    }
+    const index = {
+        meta: {
+            tool: config.tool,
+            schema_version: config.schema_version,
+            generated_at: new Date().toISOString(),
+            root,
+            workspaces: workspaceAliases,
+        },
+        workspaces,
+        nodes,
+        reverse_edges,
+    };
+    (0, validate_graph_1.validateGraph)(index, { allowMissing: tolerant });
+    return index;
+}

package/dist/graph/node.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_TYPES = exports.DEC_TYPES = exports.WORK_TYPES = void 0;
+exports.parseNode = parseNode;
+const frontmatter_1 = require("./frontmatter");
+const edges_1 = require("./edges");
+const ID_RE = /^[a-z]+-[0-9]+$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const DEC_ID_RE = /^dec-[0-9]+$/;
+exports.WORK_TYPES = new Set(["epic", "feat", "task", "bug", "checkpoint", "test"]);
+exports.DEC_TYPES = new Set(["dec"]);
+exports.ALLOWED_TYPES = new Set([
+    "rule",
+    "prd",
+    "edd",
+    "dec",
+    "prop",
+    "epic",
+    "feat",
+    "task",
+    "bug",
+    "checkpoint",
+    "test",
+]);
+const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
+function formatError(filePath, message) {
+    return new Error(`${filePath}: ${message}`);
+}
+function expectString(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (typeof value !== "string") {
+        throw formatError(filePath, `${key} must be a string`);
+    }
+    if (value.trim().length === 0) {
+        throw formatError(filePath, `${key} must not be empty`);
+    }
+    return value;
+}
+function optionalString(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw formatError(filePath, `${key} must be a string`);
+    }
+    if (value.trim().length === 0) {
+        throw formatError(filePath, `${key} must not be empty`);
+    }
+    return value;
+}
+function optionalList(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw formatError(filePath, `${key} must be a list`);
+    }
+    return value;
+}
+function requireLowercase(value, key, filePath) {
+    if (value !== value.toLowerCase()) {
+        throw formatError(filePath, `${key} must be lowercase`);
+    }
+    return value;
+}
+function requireLowercaseList(values, key, filePath) {
+    return values.map((value, index) => {
+        if (value !== value.toLowerCase()) {
+            throw formatError(filePath, `${key}[${index}] must be lowercase`);
+        }
+        return value;
+    });
+}
+function isValidId(value) {
+    return ID_RE.test(value) || value === "rule-guide";
+}
+function requireIdFormat(value, key, filePath) {
+    if (!isValidId(value)) {
+        throw formatError(filePath, `${key} must match <prefix>-<number>`);
+    }
+    return value;
+}
+function requireDate(value, key, filePath) {
+    if (!DATE_RE.test(value)) {
+        throw formatError(filePath, `${key} must be YYYY-MM-DD`);
+    }
+    return value;
+}
+function parsePriority(value, filePath, min, max) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed)) {
+        throw formatError(filePath, "priority must be an integer");
+    }
+    if (parsed < min || parsed > max) {
+        throw formatError(filePath, `priority must be between ${min} and ${max}`);
+    }
+    return parsed;
+}
+function normalizeIdList(values, key, filePath) {
+    return values.map((value) => {
+        if (value !== value.toLowerCase()) {
+            throw formatError(filePath, `${key} entries must be lowercase`);
+        }
+        if (!isValidId(value)) {
+            throw formatError(filePath, `${key} entries must match <prefix>-<number>`);
+        }
+        return value;
+    });
+}
+function requireTemplateSchema(type, templateSchemas, filePath) {
+    const schema = templateSchemas[type];
+    if (!schema) {
+        throw formatError(filePath, `template schema missing for type ${type}`);
+    }
+    return schema;
+}
+function validateTemplateKeys(frontmatter, schema, filePath) {
+    for (const key of Object.keys(frontmatter)) {
+        if (!schema.allowedKeys.has(key)) {
+            throw formatError(filePath, `unknown key: ${key}`);
+        }
+    }
+    for (const [key, value] of Object.entries(frontmatter)) {
+        const expected = schema.keyKinds[key];
+        if (!expected) {
+            continue;
+        }
+        const isList = Array.isArray(value);
+        const isBoolean = typeof value === "boolean";
+        if (expected === "list" && !isList) {
+            throw formatError(filePath, `${key} must be a list`);
+        }
+        if (expected === "boolean" && !isBoolean) {
+            throw formatError(filePath, `${key} must be a boolean`);
+        }
+        if (expected === "scalar" && (isList || isBoolean)) {
+            throw formatError(filePath, `${key} must be a string`);
+        }
+    }
+}
+function parseNode(content, filePath, options) {
+    const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+    const type = requireLowercase(expectString(frontmatter, "type", filePath), "type", filePath);
+    if (!exports.ALLOWED_TYPES.has(type)) {
+        throw formatError(filePath, `type must be one of ${Array.from(exports.ALLOWED_TYPES).join(", ")}`);
+    }
+    const schema = requireTemplateSchema(type, options.templateSchemas, filePath);
+    validateTemplateKeys(frontmatter, schema, filePath);
+    const id = requireIdFormat(requireLowercase(expectString(frontmatter, "id", filePath), "id", filePath), "id", filePath);
+    const title = expectString(frontmatter, "title", filePath);
+    const created = requireDate(expectString(frontmatter, "created", filePath), "created", filePath);
+    const updated = requireDate(expectString(frontmatter, "updated", filePath), "updated", filePath);
+    const statusValue = optionalString(frontmatter, "status", filePath);
+    let status = undefined;
+    const workStatus = new Set(options.workStatusEnum.map((value) => value.toLowerCase()));
+    if (exports.WORK_TYPES.has(type)) {
+        if (!statusValue) {
+            throw formatError(filePath, "status is required for work items");
+        }
+        const normalized = requireLowercase(statusValue, "status", filePath);
+        if (!workStatus.has(normalized)) {
+            throw formatError(filePath, `status must be one of ${Array.from(workStatus).join(", ")}`);
+        }
+        status = normalized;
+    }
+    else if (exports.DEC_TYPES.has(type)) {
+        if (!statusValue) {
+            throw formatError(filePath, "status is required for decision records");
+        }
+        const normalized = requireLowercase(statusValue, "status", filePath);
+        if (!DEC_STATUS.has(normalized)) {
+            throw formatError(filePath, `status must be one of ${Array.from(DEC_STATUS).join(", ")}`);
+        }
+        status = normalized;
+    }
+    else if (statusValue) {
+        throw formatError(filePath, "status is not allowed for this type");
+    }
+    const priorityValue = optionalString(frontmatter, "priority", filePath);
+    let priority = undefined;
+    if (priorityValue !== undefined) {
+        if (!exports.WORK_TYPES.has(type)) {
+            throw formatError(filePath, "priority is only allowed for work items");
+        }
+        priority = parsePriority(priorityValue, filePath, options.priorityMin, options.priorityMax);
+    }
+    const tags = requireLowercaseList(optionalList(frontmatter, "tags", filePath), "tags", filePath);
+    const owners = requireLowercaseList(optionalList(frontmatter, "owners", filePath), "owners", filePath);
+    const links = optionalList(frontmatter, "links", filePath);
+    const artifacts = optionalList(frontmatter, "artifacts", filePath);
+    const refs = normalizeIdList(optionalList(frontmatter, "refs", filePath), "refs", filePath);
+    const aliases = requireLowercaseList(optionalList(frontmatter, "aliases", filePath), "aliases", filePath);
+    normalizeIdList(optionalList(frontmatter, "scope", filePath), "scope", filePath);
+    const supersedesValue = optionalString(frontmatter, "supersedes", filePath);
+    if (supersedesValue !== undefined) {
+        if (!exports.DEC_TYPES.has(type)) {
+            throw formatError(filePath, "supersedes is only allowed for decision records");
+        }
+        const normalized = requireLowercase(supersedesValue, "supersedes", filePath);
+        if (!DEC_ID_RE.test(normalized)) {
+            throw formatError(filePath, "supersedes must be a dec-# id");
+        }
+    }
+    const edges = (0, edges_1.extractEdges)(frontmatter, filePath);
+    return {
+        id,
+        type,
+        title,
+        created,
+        updated,
+        status,
+        priority,
+        tags,
+        owners,
+        links,
+        artifacts,
+        refs,
+        aliases,
+        edges,
+        body,
+        frontmatter,
+    };
+}

package/dist/graph/staleness.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIndexStale = isIndexStale;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../core/paths");
+const workspace_files_1 = require("./workspace_files");
+function mtimeMs(filePath) {
+    return fs_1.default.statSync(filePath).mtimeMs;
+}
+function isIndexStale(root, config) {
+    const indexPath = path_1.default.resolve(root, config.index.global_index_path);
+    if (!fs_1.default.existsSync(indexPath)) {
+        return true;
+    }
+    const indexMtime = mtimeMs(indexPath);
+    const cfgPath = (0, paths_1.configPath)(root);
+    if (fs_1.default.existsSync(cfgPath) && mtimeMs(cfgPath) > indexMtime) {
+        return true;
+    }
+    const docs = (0, workspace_files_1.listWorkspaceDocFiles)(root, config);
+    for (const filePath of docs) {
+        if (mtimeMs(filePath) > indexMtime) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/graph/template_schema.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplateSchemas = loadTemplateSchemas;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const frontmatter_1 = require("./frontmatter");
+function listMarkdownFiles(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listMarkdownFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function getValueKind(value) {
+    if (Array.isArray(value)) {
+        return "list";
+    }
+    if (typeof value === "boolean") {
+        return "boolean";
+    }
+    return "scalar";
+}
+function addKeyToSchema(schema, key, kind, filePath) {
+    const existing = schema.keyKinds[key];
+    if (existing && existing !== kind) {
+        throw new Error(`template schema mismatch for ${schema.type}.${key}: ${existing} vs ${kind} (${filePath})`);
+    }
+    schema.keyKinds[key] = kind;
+    schema.allowedKeys.add(key);
+    if (kind === "list") {
+        schema.listKeys.add(key);
+    }
+}
+function loadTemplateSchemas(root, config, requiredTypes) {
+    const templateRoot = path_1.default.resolve(root, config.templates.root_path, config.templates.default_set);
+    const files = listMarkdownFiles(templateRoot);
+    if (files.length === 0) {
+        throw new Error(`no templates found at ${templateRoot}`);
+    }
+    const schemas = {};
+    for (const filePath of files) {
+        const content = fs_1.default.readFileSync(filePath, "utf8");
+        const { frontmatter } = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+        const typeValue = frontmatter.type;
+        if (typeof typeValue !== "string") {
+            throw new Error(`template missing type in ${filePath}`);
+        }
+        const normalizedType = typeValue.toLowerCase();
+        if (normalizedType !== typeValue) {
+            throw new Error(`template type must be lowercase in ${filePath}`);
+        }
+        const schema = schemas[normalizedType] ??
+            {
+                type: normalizedType,
+                allowedKeys: new Set(),
+                keyKinds: {},
+                listKeys: new Set(),
+            };
+        schemas[normalizedType] = schema;
+        for (const [key, value] of Object.entries(frontmatter)) {
+            const kind = getValueKind(value);
+            addKeyToSchema(schema, key, kind, filePath);
+        }
+    }
+    if (requiredTypes) {
+        const required = Array.from(requiredTypes, (value) => value.toLowerCase());
+        const missing = required.filter((value) => !schemas[value]);
+        if (missing.length > 0) {
+            throw new Error(`template schema missing for type(s): ${missing.join(", ")}`);
+        }
+    }
+    return schemas;
+}