docmeta 0.1.0

package/dist/chunk-NTXC32C4.js

@@ -0,0 +1,1091 @@
+#!/usr/bin/env node
+
+// src/types.ts
+var DocmetaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DocmetaError";
+  }
+};
+
+// src/core/config.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var CONFIG_NAMES = ["docmeta.config.yaml", "docmeta.config.yml"];
+function asStringList(value, field, source) {
+  if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+    throw new DocmetaError(
+      `${source}: "${field}" must be a list of strings.`
+    );
+  }
+  return value;
+}
+function parseConfig(text, source) {
+  let raw;
+  try {
+    raw = parseYaml(text);
+  } catch (err) {
+    throw new DocmetaError(
+      `${source}: invalid YAML: ${err.message}`
+    );
+  }
+  if (raw == null) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new DocmetaError(`${source}: top level must be a mapping.`);
+  }
+  const obj = raw;
+  const config = {};
+  if (obj.paths !== void 0) config.paths = asStringList(obj.paths, "paths", source);
+  if (obj.exclude !== void 0)
+    config.exclude = asStringList(obj.exclude, "exclude", source);
+  if (obj.schemas !== void 0)
+    config.schemas = asStringList(obj.schemas, "schemas", source);
+  if (obj.overrides !== void 0) {
+    if (!Array.isArray(obj.overrides)) {
+      throw new DocmetaError(`${source}: "overrides" must be a list.`);
+    }
+    config.overrides = obj.overrides.map((entry, i) => {
+      if (typeof entry !== "object" || entry === null) {
+        throw new DocmetaError(`${source}: overrides[${i}] must be a mapping.`);
+      }
+      const e = entry;
+      if (typeof e.files !== "string") {
+        throw new DocmetaError(
+          `${source}: overrides[${i}].files must be a string glob.`
+        );
+      }
+      return {
+        files: e.files,
+        schemas: asStringList(e.schemas, `overrides[${i}].schemas`, source)
+      };
+    });
+  }
+  return config;
+}
+async function loadConfig(explicitPath, cwd = process.cwd()) {
+  if (explicitPath) {
+    let text;
+    try {
+      text = await readFile(explicitPath, "utf8");
+    } catch {
+      throw new DocmetaError(`Config file not found: "${explicitPath}".`);
+    }
+    return { config: parseConfig(text, explicitPath), path: explicitPath };
+  }
+  for (const name of CONFIG_NAMES) {
+    const p = resolve(cwd, name);
+    try {
+      const text = await readFile(p, "utf8");
+      return { config: parseConfig(text, name), path: p };
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/core/resolve-schema.ts
+import picomatch from "picomatch";
+var DEFAULT_SCHEMA = "google:okf:0.1";
+var FILE_SCHEMA_KEY = "$schema";
+var matcherCache = /* @__PURE__ */ new Map();
+function matches(glob, filePath) {
+  let m = matcherCache.get(glob);
+  if (!m) {
+    m = picomatch(glob, { dot: true });
+    matcherCache.set(glob, m);
+  }
+  return m(filePath.replace(/\\/g, "/"));
+}
+function coerceFileSchema(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+    return value;
+  }
+  throw new Error(
+    `Invalid "${FILE_SCHEMA_KEY}": must be a string or a list of strings.`
+  );
+}
+function dedupe(refs) {
+  return [...new Set(refs)];
+}
+function resolveSchemaSet(params) {
+  const { filePath, fileSchema, cliSchemas, config } = params;
+  if (cliSchemas && cliSchemas.length > 0) return dedupe(cliSchemas);
+  const fromFile = coerceFileSchema(fileSchema);
+  if (fromFile && fromFile.length > 0) return dedupe(fromFile);
+  if (config?.overrides) {
+    for (const ov of config.overrides) {
+      if (matches(ov.files, filePath) && ov.schemas.length > 0) {
+        return dedupe(ov.schemas);
+      }
+    }
+  }
+  if (config?.schemas && config.schemas.length > 0) return dedupe(config.schemas);
+  return [DEFAULT_SCHEMA];
+}
+
+// src/core/schema-registry.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/schemas/okf/0.1.json
+var __default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "google:okf:0.1",
+  title: "Open Knowledge Format (OKF) v0.1",
+  description: "Frontmatter schema for OKF v0.1 concept files. OKF requires only `type`; all other fields are recommended, and unknown keys are explicitly tolerated. See https://github.com/GoogleCloudPlatform/knowledge-catalog/blob/main/okf/SPEC.md",
+  type: "object",
+  required: ["type"],
+  additionalProperties: true,
+  properties: {
+    type: {
+      type: "string",
+      minLength: 1,
+      description: "A short string identifying the kind of concept. Used for routing, filtering, and presentation."
+    },
+    title: {
+      type: "string",
+      description: "Human-readable display name. If omitted, consumers MAY derive a title from the filename."
+    },
+    description: {
+      type: "string",
+      description: "Single-sentence summary used for indexing and previews."
+    },
+    resource: {
+      type: "string",
+      format: "uri",
+      description: "A URI uniquely identifying the underlying asset. Absent for abstract concepts."
+    },
+    tags: {
+      type: "array",
+      items: { type: "string" },
+      description: "Short strings for categorization."
+    },
+    timestamp: {
+      type: "string",
+      format: "date-time",
+      description: "ISO 8601 datetime of last meaningful change."
+    }
+  }
+};
+
+// src/core/schema-registry.ts
+var BUILTINS = /* @__PURE__ */ new Map([
+  ["google:okf:0.1", __default]
+]);
+function listBuiltins() {
+  return [...BUILTINS.entries()].map(([id, schema]) => ({
+    id,
+    title: typeof schema.title === "string" ? schema.title : id,
+    description: typeof schema.description === "string" ? schema.description : ""
+  }));
+}
+var BUILTIN_ID = /^[a-z0-9][a-z0-9._-]*(?::[a-z0-9][a-z0-9._-]*)+$/i;
+function classifyRef(ref) {
+  if (/^https?:\/\//i.test(ref)) return { kind: "url", ref };
+  if (!ref.includes("/") && !ref.includes("\\") && !ref.toLowerCase().endsWith(".json") && BUILTIN_ID.test(ref)) {
+    return { kind: "builtin", ref };
+  }
+  return { kind: "file", ref };
+}
+var urlCache = /* @__PURE__ */ new Map();
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function loadSchema(ref, options = {}) {
+  const { kind } = classifyRef(ref);
+  if (kind === "builtin") {
+    const schema = BUILTINS.get(ref);
+    if (!schema) {
+      const available = [...BUILTINS.keys()].join(", ");
+      throw new DocmetaError(
+        `Unknown built-in schema "${ref}". Available: ${available || "(none)"}.`
+      );
+    }
+    return schema;
+  }
+  if (kind === "url") {
+    const cached = urlCache.get(ref);
+    if (cached) return cached;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let res;
+    try {
+      res = await fetch(ref, { signal: AbortSignal.timeout(timeoutMs) });
+    } catch (err) {
+      const e = err;
+      if (e.name === "TimeoutError" || e.name === "AbortError") {
+        throw new DocmetaError(
+          `Failed to fetch schema "${ref}": timed out after ${timeoutMs}ms.`
+        );
+      }
+      throw new DocmetaError(`Failed to fetch schema "${ref}": ${e.message}`);
+    }
+    if (!res.ok) {
+      throw new DocmetaError(
+        `Failed to fetch schema "${ref}": HTTP ${res.status}.`
+      );
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch (err) {
+      throw new DocmetaError(
+        `Schema "${ref}" did not return valid JSON: ${err.message}`
+      );
+    }
+    urlCache.set(ref, json);
+    return json;
+  }
+  let raw;
+  try {
+    raw = await readFile2(ref, "utf8");
+  } catch {
+    throw new DocmetaError(`Schema file not found: "${ref}".`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new DocmetaError(
+      `Schema file "${ref}" is not valid JSON: ${err.message}`
+    );
+  }
+}
+
+// src/core/validator.ts
+import * as AjvDraft07Ns from "ajv";
+import * as Ajv2019Ns from "ajv/dist/2019.js";
+import * as Ajv2020Ns from "ajv/dist/2020.js";
+import * as AjvDraft04Ns from "ajv-draft-04";
+import * as addFormatsNs from "ajv-formats";
+import { createRequire } from "module";
+var draft06MetaSchema = createRequire(import.meta.url)(
+  "ajv/dist/refs/json-schema-draft-06.json"
+);
+var AjvDraft07 = AjvDraft07Ns.default;
+var Ajv2019 = Ajv2019Ns.default;
+var Ajv2020 = Ajv2020Ns.default;
+var AjvDraft04 = AjvDraft04Ns.default;
+var addFormats = addFormatsNs.default;
+function dialectOf(schema) {
+  const meta = typeof schema.$schema === "string" ? schema.$schema : "";
+  if (meta.includes("2019-09")) return "2019";
+  if (meta.includes("draft-07") || meta.includes("draft/7") || meta.includes("draft-06") || meta.includes("draft/6")) {
+    return "draft7";
+  }
+  if (meta.includes("draft-04") || meta.includes("draft/4")) return "draft4";
+  return "2020";
+}
+function buildAjv(dialect) {
+  const opts = { allErrors: true, strict: false };
+  const ajv = dialect === "2019" ? new Ajv2019(opts) : dialect === "draft7" ? new AjvDraft07(opts) : dialect === "draft4" ? new AjvDraft04(opts) : new Ajv2020(opts);
+  addFormats(ajv);
+  if (dialect === "draft7") ajv.addMetaSchema(draft06MetaSchema);
+  return ajv;
+}
+var Validator = class {
+  ajvByDialect = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  ajvFor(dialect) {
+    let ajv = this.ajvByDialect.get(dialect);
+    if (!ajv) {
+      ajv = buildAjv(dialect);
+      this.ajvByDialect.set(dialect, ajv);
+    }
+    return ajv;
+  }
+  async compile(ref) {
+    const cached = this.cache.get(ref);
+    if (cached) return cached;
+    const schema = await loadSchema(ref);
+    let fn;
+    try {
+      fn = this.ajvFor(dialectOf(schema)).compile(schema);
+    } catch (err) {
+      throw new DocmetaError(
+        `Schema "${ref}" failed to compile: ${err.message}`
+      );
+    }
+    this.cache.set(ref, fn);
+    return fn;
+  }
+  /**
+   * Validate `data` against every schema in `refs`. Returns all violations,
+   * each tagged with the schema that produced it and a source line via
+   * `lineFor`.
+   */
+  async validate(data, refs, lineFor) {
+    const { [FILE_SCHEMA_KEY]: _omit, ...subject } = data;
+    void _omit;
+    const errors = [];
+    for (const ref of refs) {
+      const fn = await this.compile(ref);
+      const ok = fn(subject);
+      if (ok) continue;
+      for (const e of fn.errors ?? []) {
+        errors.push(toFieldError(ref, e, lineFor));
+      }
+    }
+    return errors;
+  }
+};
+function toFieldError(schema, e, lineFor) {
+  const instancePath = e.instancePath;
+  let message = e.message ?? "is invalid";
+  if (e.keyword === "required" && e.params && "missingProperty" in e.params) {
+    message = `must have required property '${String(e.params.missingProperty)}'`;
+  } else if (e.keyword === "additionalProperties" && e.params && "additionalProperty" in e.params) {
+    message = `must NOT have additional property '${String(e.params.additionalProperty)}'`;
+  }
+  const line = lineFor(instancePath);
+  return { schema, instancePath, message, ...line != null ? { line } : {} };
+}
+
+// src/commands/validate.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve3, extname as extname2 } from "path";
+
+// src/extractors/markdown.ts
+import { parseDocument, LineCounter, isMap, isSeq, isScalar } from "yaml";
+var OPENING = /^---\r?\n/;
+function splitFrontmatter(content) {
+  const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  if (!OPENING.test(body)) return null;
+  const lines = body.split(/\r?\n/);
+  let close = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === "---" || lines[i] === "...") {
+      close = i;
+      break;
+    }
+  }
+  if (close === -1) return null;
+  return { raw: lines.slice(1, close).join("\n"), firstYamlLine: 2 };
+}
+function escapePointerSegment(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function buildLineMap(doc, lc, prefixLines) {
+  const map = /* @__PURE__ */ new Map();
+  map.set("", 1);
+  const lineAt = (offset) => offset == null ? void 0 : lc.linePos(offset).line + prefixLines;
+  const walk = (node, pointer) => {
+    if (isMap(node)) {
+      for (const pair of node.items) {
+        const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+        const ptr = `${pointer}/${escapePointerSegment(key)}`;
+        const line = lineAt(
+          pair.key?.range?.[0]
+        );
+        if (line != null) map.set(ptr, line);
+        if (pair.value) walk(pair.value, ptr);
+      }
+    } else if (isSeq(node)) {
+      node.items.forEach((item, i) => {
+        const ptr = `${pointer}/${i}`;
+        const line = lineAt(
+          item?.range?.[0]
+        );
+        if (line != null) map.set(ptr, line);
+        walk(item, ptr);
+      });
+    }
+  };
+  if (doc.contents) walk(doc.contents, "");
+  return map;
+}
+function lineForFactory(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+function extractFrontmatter(content, format) {
+  const block = splitFrontmatter(content);
+  if (!block) {
+    return { data: {}, present: false, format, lineFor: () => void 0 };
+  }
+  const lc = new LineCounter();
+  const doc = parseDocument(block.raw, { lineCounter: lc });
+  if (doc.errors.length > 0) {
+    const e = doc.errors[0];
+    throw new Error(`Invalid YAML frontmatter: ${e?.message ?? "parse error"}`);
+  }
+  const js = doc.toJS({ maxAliasCount: 100 });
+  const data = js && typeof js === "object" && !Array.isArray(js) ? js : {};
+  const map = buildLineMap(doc, lc, block.firstYamlLine - 1);
+  return { data, present: true, format, lineFor: lineForFactory(map) };
+}
+var markdownExtractor = {
+  name: "markdown",
+  extensions: [".md", ".markdown"],
+  implemented: true,
+  extract: (content) => extractFrontmatter(content, "markdown")
+};
+
+// src/extractors/mdx.ts
+var mdxExtractor = {
+  name: "mdx",
+  extensions: [".mdx"],
+  implemented: true,
+  extract: (content) => extractFrontmatter(content, "mdx")
+};
+
+// src/extractors/asciidoc.ts
+import { parse as parseYamlScalar } from "yaml";
+var OPENING2 = /^---\r?\n/;
+var TITLE = /^=\s+(.+?)\s*$/;
+var UNSET = /^:(?:!([^:\s]+)|([^:\s]+)!):\s*$/;
+var SET = /^:([^:\s!][^:\s]*):(?:\s+(.*\S))?\s*$/;
+function escapePointerSegment2(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function typeValue(raw) {
+  try {
+    return parseYamlScalar(raw);
+  } catch {
+    return raw;
+  }
+}
+function lineForFactory2(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment2(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+function extractHeader(content) {
+  const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  const lines = body.split(/\r?\n/);
+  const data = {};
+  const map = /* @__PURE__ */ new Map();
+  map.set("", 1);
+  const setKey = (key, value, line) => {
+    data[key] = value;
+    map.set(`/${escapePointerSegment2(key)}`, line);
+  };
+  for (const [i, line] of lines.entries()) {
+    if (line.trim() === "") break;
+    if (i === 0) {
+      const title = TITLE.exec(line);
+      if (title?.[1] != null) {
+        setKey("title", title[1], i + 1);
+        continue;
+      }
+    }
+    const unset = UNSET.exec(line);
+    if (unset) {
+      const name = unset[1] ?? unset[2];
+      if (name != null) setKey(name, false, i + 1);
+      continue;
+    }
+    const set = SET.exec(line);
+    if (set?.[1] != null) {
+      const value = set[2] === void 0 ? true : typeValue(set[2]);
+      setKey(set[1], value, i + 1);
+      continue;
+    }
+  }
+  const present = Object.keys(data).length > 0;
+  return {
+    data,
+    present,
+    format: "asciidoc",
+    lineFor: lineForFactory2(map)
+  };
+}
+var asciidocExtractor = {
+  name: "asciidoc",
+  extensions: [".adoc", ".asciidoc"],
+  implemented: true,
+  extract(content) {
+    const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+    if (OPENING2.test(body)) {
+      const fm = extractFrontmatter(content, "asciidoc");
+      if (fm.present) return fm;
+    }
+    return extractHeader(content);
+  }
+};
+
+// src/extractors/rst.ts
+import { parse as parseYamlScalar2 } from "yaml";
+var OPENING3 = /^---\r?\n/;
+var FIELD = /^:([^:]+):(?:\s+(.*\S))?\s*$/;
+var ADORN = /^([=\-~:.'"*+#_^<>])\1+$/;
+function escapePointerSegment3(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function typeValue2(raw) {
+  try {
+    return parseYamlScalar2(raw);
+  } catch {
+    return raw;
+  }
+}
+function lineForFactory3(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment3(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+function adornment(line) {
+  const m = ADORN.exec(line);
+  return m && m[1] != null ? { char: m[1], length: line.length } : null;
+}
+function parseTitle(lines) {
+  let i = 0;
+  while (i < lines.length && (lines[i] ?? "").trim() === "") i++;
+  if (i >= lines.length) return { next: i };
+  const first = lines[i] ?? "";
+  if (FIELD.test(first)) return { next: i };
+  const over = adornment(first);
+  if (over) {
+    const text = lines[i + 1] ?? "";
+    const under2 = adornment(lines[i + 2] ?? "");
+    if (text.trim() !== "" && !FIELD.test(text) && under2 != null && under2.char === over.char && under2.length === over.length && over.length >= text.trim().length) {
+      return { title: text.trim(), line: i + 2, next: i + 3 };
+    }
+    return { next: i };
+  }
+  const under = adornment(lines[i + 1] ?? "");
+  if (under != null && under.length >= first.trim().length) {
+    return { title: first.trim(), line: i + 1, next: i + 2 };
+  }
+  return { next: i };
+}
+function extractDocinfo(content) {
+  const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  const lines = body.split(/\r?\n/);
+  const data = {};
+  const map = /* @__PURE__ */ new Map();
+  let blockStart = -1;
+  const titleInfo = parseTitle(lines);
+  if (titleInfo.title != null && titleInfo.line != null) {
+    data.title = titleInfo.title;
+    map.set("/title", titleInfo.line);
+    blockStart = titleInfo.line;
+  }
+  let i = titleInfo.next;
+  while (i < lines.length && (lines[i] ?? "").trim() === "") i++;
+  for (; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") break;
+    const field = FIELD.exec(line);
+    if (!field || field[1] == null) break;
+    const name = field[1].trim();
+    const value = field[2] === void 0 ? true : typeValue2(field[2]);
+    if (blockStart === -1) blockStart = i + 1;
+    data[name] = value;
+    map.set(`/${escapePointerSegment3(name)}`, i + 1);
+  }
+  const present = blockStart !== -1;
+  if (present) map.set("", blockStart);
+  return {
+    data,
+    present,
+    format: "rst",
+    lineFor: lineForFactory3(map)
+  };
+}
+var rstExtractor = {
+  name: "rst",
+  extensions: [".rst"],
+  implemented: true,
+  extract(content) {
+    const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+    if (OPENING3.test(body)) {
+      const fm = extractFrontmatter(content, "rst");
+      if (fm.present) return fm;
+    }
+    return extractDocinfo(content);
+  }
+};
+
+// src/extractors/xml.ts
+import { DOMParser } from "@xmldom/xmldom";
+import { parse as parseYamlScalar3 } from "yaml";
+function escapePointerSegment4(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function typeValue3(raw) {
+  if (raw === "") return "";
+  try {
+    return parseYamlScalar3(raw);
+  } catch {
+    return raw;
+  }
+}
+function lineForFactory4(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment4(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+var xmlExtractor = {
+  name: "xml",
+  extensions: [".xml"],
+  implemented: true,
+  extract(content) {
+    const body = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+    const errors = [];
+    const doc = new DOMParser({
+      onError: (level, msg) => {
+        if (level === "error" || level === "fatalError") errors.push(msg);
+      }
+    }).parseFromString(body, "text/xml");
+    if (errors.length > 0) {
+      throw new Error(`Invalid XML: ${errors[0] ?? "parse error"}`);
+    }
+    const root = doc.documentElement;
+    if (!root) {
+      return { data: {}, present: false, format: "xml", lineFor: () => void 0 };
+    }
+    const data = {};
+    const map = /* @__PURE__ */ new Map();
+    const rootLine = root.lineNumber ?? 1;
+    map.set("", rootLine);
+    const attrs = root.attributes;
+    for (let i = 0; i < attrs.length; i++) {
+      const attr = attrs.item(i);
+      if (!attr) continue;
+      const name = attr.name;
+      if (name === "xmlns" || name.startsWith("xmlns:")) continue;
+      data[name] = typeValue3(attr.value);
+      map.set(`/${escapePointerSegment4(name)}`, attr.lineNumber ?? rootLine);
+    }
+    const present = Object.keys(data).length > 0;
+    return { data, present, format: "xml", lineFor: lineForFactory4(map) };
+  }
+};
+
+// src/extractors/html.ts
+import { parse, defaultTreeAdapter } from "parse5";
+import { parse as parseYamlScalar4 } from "yaml";
+function escapePointerSegment5(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function typeValue4(raw) {
+  if (raw === "") return "";
+  try {
+    return parseYamlScalar4(raw);
+  } catch {
+    return raw;
+  }
+}
+function lineForFactory5(map) {
+  return (pointer) => {
+    const start = pointer !== "" && !pointer.startsWith("/") ? `/${escapePointerSegment5(pointer)}` : pointer;
+    if (map.has(start)) return map.get(start);
+    let p = start;
+    while (p.length > 0) {
+      const idx = p.lastIndexOf("/");
+      if (idx < 0) break;
+      p = p.slice(0, idx);
+      if (map.has(p)) return map.get(p);
+    }
+    return map.get("");
+  };
+}
+function attrValue(el, name) {
+  return el.attrs.find((a) => a.name === name)?.value;
+}
+var htmlExtractor = {
+  name: "html",
+  extensions: [".html", ".htm"],
+  implemented: true,
+  extract(content) {
+    const doc = parse(content, { sourceCodeLocationInfo: true });
+    const data = {};
+    const map = /* @__PURE__ */ new Map();
+    map.set("", 1);
+    const setKey = (key, value, line) => {
+      data[key] = value;
+      if (line != null) map.set(`/${escapePointerSegment5(key)}`, line);
+    };
+    const visit = (node) => {
+      if (defaultTreeAdapter.isElementNode(node)) {
+        const line = node.sourceCodeLocation?.startLine;
+        if (node.tagName === "title") {
+          if (data.title === void 0) {
+            const first = node.childNodes[0];
+            const text = first && defaultTreeAdapter.isTextNode(first) ? first.value : "";
+            setKey("title", text, line);
+          }
+        } else if (node.tagName === "meta") {
+          const key = attrValue(node, "name") ?? attrValue(node, "property");
+          const value = attrValue(node, "content");
+          if (key != null && value != null) {
+            setKey(key, typeValue4(value), line);
+          }
+        }
+      }
+      if (defaultTreeAdapter.isElementNode(node)) {
+        for (const child of node.childNodes) visit(child);
+      }
+    };
+    for (const child of doc.childNodes) visit(child);
+    const present = Object.keys(data).length > 0;
+    return { data, present, format: "html", lineFor: lineForFactory5(map) };
+  }
+};
+
+// src/extractors/index.ts
+var EXTRACTORS = [
+  markdownExtractor,
+  mdxExtractor,
+  asciidocExtractor,
+  rstExtractor,
+  xmlExtractor,
+  htmlExtractor
+];
+var byExtension = /* @__PURE__ */ new Map();
+var byName = /* @__PURE__ */ new Map();
+for (const ex of EXTRACTORS) {
+  byName.set(ex.name, ex);
+  for (const ext of ex.extensions) byExtension.set(ext.toLowerCase(), ex);
+}
+function extractorForExtension(ext) {
+  const ex = byExtension.get(ext.toLowerCase());
+  return ex?.implemented ? ex : void 0;
+}
+function extractorByName(name) {
+  return byName.get(name.toLowerCase());
+}
+function supportedExtensions() {
+  return EXTRACTORS.filter((e) => e.implemented).flatMap((e) => e.extensions);
+}
+function listFormats() {
+  return EXTRACTORS.map((e) => ({
+    name: e.name,
+    extensions: e.extensions,
+    implemented: e.implemented
+  }));
+}
+
+// src/core/load-files.ts
+import { stat } from "fs/promises";
+import { extname, relative, resolve as resolve2 } from "path";
+import fg from "fast-glob";
+var DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
+var STDIN_TOKEN = "-";
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+async function statOrNull(p) {
+  try {
+    return await stat(p);
+  } catch {
+    return null;
+  }
+}
+async function resolveTargets(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const exts = (opts.exts ?? supportedExtensions()).map(
+    (e) => e.toLowerCase().startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
+  );
+  const ignore = [...DEFAULT_IGNORE, ...opts.exclude ?? []];
+  const out = /* @__PURE__ */ new Set();
+  const keepByExt = (file) => exts.includes(extname(file).toLowerCase());
+  for (const input of opts.inputs) {
+    if (input === STDIN_TOKEN) continue;
+    const abs = resolve2(cwd, input);
+    const st = await statOrNull(abs);
+    if (st?.isFile()) {
+      out.add(toPosix(relative(cwd, abs)));
+      continue;
+    }
+    if (st?.isDirectory()) {
+      const found2 = await fg(`${toPosix(input)}/**/*`, {
+        cwd,
+        ignore,
+        onlyFiles: true,
+        dot: false
+      });
+      for (const f of found2) if (keepByExt(f)) out.add(f);
+      continue;
+    }
+    const found = await fg(toPosix(input), {
+      cwd,
+      ignore,
+      onlyFiles: true,
+      dot: false
+    });
+    for (const f of found) if (keepByExt(f)) out.add(f);
+  }
+  return [...out].sort();
+}
+
+// src/commands/validate.ts
+function parseErrorResult(file, format, message) {
+  const err = { schema: "(parse)", instancePath: "", message };
+  return { file, format, ok: false, schemas: [], errors: [err] };
+}
+async function runValidate(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const loaded = await loadConfig(opts.configPath, cwd);
+  const config = loaded?.config ?? null;
+  const inputs = opts.inputs.length > 0 ? opts.inputs : config?.paths ?? [];
+  const usingStdin = inputs.includes(STDIN_TOKEN);
+  if (inputs.length === 0) {
+    throw new DocmetaError(
+      "No files to validate. Pass paths/globs, or add `paths:` to docmeta.config.yaml."
+    );
+  }
+  const forcedExtractor = opts.as ? extractorByName(opts.as) : void 0;
+  if (opts.as && !forcedExtractor) {
+    throw new DocmetaError(
+      `Unknown format "${opts.as}". Supported extensions: ${supportedExtensions().join(", ")}.`
+    );
+  }
+  const exts = opts.exts ?? (forcedExtractor ? forcedExtractor.extensions : void 0);
+  const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
+  const files = await resolveTargets({
+    inputs: fileInputs,
+    exts,
+    exclude: [...config?.exclude ?? [], ...opts.exclude ?? []],
+    cwd
+  });
+  const validator = new Validator();
+  const results = [];
+  const processOne = async (label, content, extension) => {
+    const extractor = forcedExtractor ?? extractorForExtension(extension);
+    if (!extractor) {
+      throw new DocmetaError(
+        `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
+      );
+    }
+    let extracted;
+    try {
+      extracted = extractor.extract(content, label);
+    } catch (err) {
+      if (err instanceof DocmetaError) throw err;
+      results.push(parseErrorResult(label, extractor.name, err.message));
+      return;
+    }
+    let schemaSet;
+    try {
+      schemaSet = resolveSchemaSet({
+        filePath: label,
+        fileSchema: extracted.data[FILE_SCHEMA_KEY],
+        cliSchemas: opts.cliSchemas,
+        config
+      });
+    } catch (err) {
+      results.push(parseErrorResult(label, extractor.name, err.message));
+      return;
+    }
+    const errors = await validator.validate(
+      extracted.data,
+      schemaSet,
+      extracted.lineFor
+    );
+    results.push({
+      file: label,
+      format: extractor.name,
+      ok: errors.length === 0,
+      schemas: schemaSet,
+      errors
+    });
+  };
+  if (usingStdin) {
+    const content = opts.stdinContent ?? "";
+    if (!forcedExtractor) {
+      throw new DocmetaError(
+        "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+      );
+    }
+    await processOne("<stdin>", content, forcedExtractor.extensions[0] ?? "");
+  }
+  for (const file of files) {
+    const content = await readFile3(resolve3(cwd, file), "utf8");
+    await processOne(file, content, extname2(file));
+  }
+  const failed = results.filter((r) => !r.ok).length;
+  const summary = {
+    files: results.length,
+    passed: results.length - failed,
+    failed,
+    errors: results.reduce((n, r) => n + r.errors.length, 0)
+  };
+  return { results, summary };
+}
+
+// src/commands/get.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve4, extname as extname3 } from "path";
+async function runGet(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.fields.length === 0) {
+    throw new DocmetaError("Specify at least one field to get.");
+  }
+  const loaded = await loadConfig(opts.configPath, cwd);
+  const config = loaded?.config ?? null;
+  const inputs = opts.inputs.length > 0 ? opts.inputs : config?.paths ?? [];
+  const usingStdin = inputs.includes(STDIN_TOKEN);
+  if (inputs.length === 0) {
+    throw new DocmetaError(
+      "No files to read. Pass paths/globs, or add `paths:` to docmeta.config.yaml."
+    );
+  }
+  const forced = opts.as ? extractorByName(opts.as) : void 0;
+  if (opts.as && !forced) {
+    throw new DocmetaError(
+      `Unknown format "${opts.as}". Supported extensions: ${supportedExtensions().join(", ")}.`
+    );
+  }
+  const exts = opts.exts ?? (forced ? forced.extensions : void 0);
+  const fileInputs = inputs.filter((i) => i !== STDIN_TOKEN);
+  const files = await resolveTargets({
+    inputs: fileInputs,
+    exts,
+    exclude: [...config?.exclude ?? [], ...opts.exclude ?? []],
+    cwd
+  });
+  const out = [];
+  const readOne = (label, content, extension) => {
+    const extractor = forced ?? extractorForExtension(extension);
+    if (!extractor) {
+      throw new DocmetaError(
+        `Unsupported file type "${extension}" for "${label}". Supported: ${supportedExtensions().join(", ")}. Use --as to override.`
+      );
+    }
+    const extracted = extractor.extract(content, label);
+    const values = {};
+    for (const f of opts.fields) values[f] = extracted.data[f];
+    out.push({ file: label, present: extracted.present, values });
+  };
+  if (usingStdin) {
+    if (!forced) {
+      throw new DocmetaError(
+        "Reading from stdin (`-`) requires --as <format> to choose an extractor."
+      );
+    }
+    readOne("<stdin>", opts.stdinContent ?? "", forced.extensions[0] ?? "");
+  }
+  for (const file of files) {
+    const content = await readFile4(resolve4(cwd, file), "utf8");
+    readOne(file, content, extname3(file));
+  }
+  return out;
+}
+
+// src/commands/schemas.ts
+function getSchemasInfo() {
+  return { builtins: listBuiltins(), formats: listFormats() };
+}
+
+// src/reporters/color.ts
+import pc from "picocolors";
+function palette(enabled) {
+  return pc.createColors(enabled);
+}
+function shouldColor(opts) {
+  const env = opts.env ?? process.env;
+  if (opts.noColor) return false;
+  if (env.NO_COLOR != null && env.NO_COLOR !== "") return false;
+  return Boolean(opts.isTTY);
+}
+
+// src/reporters/index.ts
+function fieldLabel(instancePath) {
+  return instancePath === "" ? "(root)" : instancePath;
+}
+function renderPretty(results, summary, opts = {}) {
+  const c = palette(opts.color ?? false);
+  const lines = [];
+  for (const r of results) {
+    if (r.ok) {
+      if (!opts.quiet) lines.push(`${c.green("\u2713")} ${r.file}`);
+      continue;
+    }
+    lines.push(`${c.red("\u2717")} ${r.file}`);
+    for (const e of r.errors) {
+      const loc = e.line != null ? c.dim(`  (line ${e.line})`) : "";
+      lines.push(
+        `    ${c.cyan(fieldLabel(e.instancePath))}  ${e.message}${loc}  ${c.dim(
+          `[${e.schema}]`
+        )}`
+      );
+    }
+  }
+  const summaryText = `${summary.files} file${summary.files === 1 ? "" : "s"} checked, ${summary.passed} passed, ${summary.failed} failed, ${summary.errors} error${summary.errors === 1 ? "" : "s"}`;
+  if (lines.length > 0) lines.push("");
+  lines.push(summary.failed > 0 ? c.red(summaryText) : c.green(summaryText));
+  return lines.join("\n");
+}
+function renderJson(results, summary) {
+  return JSON.stringify({ summary, results }, null, 2);
+}
+function renderGithub(results) {
+  const lines = [];
+  for (const r of results) {
+    for (const e of r.errors) {
+      const params = [`file=${r.file}`];
+      if (e.line != null) params.push(`line=${e.line}`);
+      if (e.col != null) params.push(`col=${e.col}`);
+      const msg = `[${e.schema}] ${fieldLabel(e.instancePath)} ${e.message}`;
+      lines.push(`::error ${params.join(",")}::${msg}`);
+    }
+  }
+  return lines.join("\n");
+}
+function render(format, results, summary, opts = {}) {
+  switch (format) {
+    case "json":
+      return renderJson(results, summary);
+    case "github":
+      return renderGithub(results);
+    case "pretty":
+    default:
+      return renderPretty(results, summary, opts);
+  }
+}
+
+export {
+  DocmetaError,
+  parseConfig,
+  loadConfig,
+  DEFAULT_SCHEMA,
+  resolveSchemaSet,
+  listBuiltins,
+  classifyRef,
+  loadSchema,
+  Validator,
+  runValidate,
+  runGet,
+  getSchemasInfo,
+  palette,
+  shouldColor,
+  render
+};
+//# sourceMappingURL=chunk-NTXC32C4.js.map